kernel_5.10 no rt

hc

2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f

 kernel/arch/m68k/include/asm/motorola_pgalloc.h
..
..
@@ -5,93 +5,77 @@
5
5
 #include <asm/tlb.h>
6
6
 #include <asm/tlbflush.h>
7
7
 
8
-extern pmd_t *get_pointer_table(void);
9
-extern int free_pointer_table(pmd_t *);
8
+extern void mmu_page_ctor(void *page);
9
+extern void mmu_page_dtor(void *page);
10
10
 
11
-static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
11
+enum m68k_table_types {
12
+	TABLE_PGD = 0,
13
+	TABLE_PMD = 0, /* same size as PGD */
14
+	TABLE_PTE = 1,
15
+};
16
+
17
+extern void init_pointer_table(void *table, int type);
18
+extern void *get_pointer_table(int type);
19
+extern int free_pointer_table(void *table, int type);
20
+
21
+/*
22
+ * Allocate and free page tables. The xxx_kernel() versions are
23
+ * used to allocate a kernel page table - this turns on ASN bits
24
+ * if any.
25
+ */
26
+
27
+static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
12
28
 {
13
-	pte_t *pte;
14
-
15
-	pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
16
-	if (pte) {
17
-		__flush_page_to_ram(pte);
18
-		flush_tlb_kernel_page(pte);
19
-		nocache_page(pte);
20
-	}
21
-
22
-	return pte;
29
+	return get_pointer_table(TABLE_PTE);
23
30
 }
24
31
 
25
32
 static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
26
33
 {
27
-	cache_page(pte);
28
-	free_page((unsigned long) pte);
34
+	free_pointer_table(pte, TABLE_PTE);
29
35
 }
30
36
 
31
-static inline pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)
37
+static inline pgtable_t pte_alloc_one(struct mm_struct *mm)
32
38
 {
33
-	struct page *page;
34
-	pte_t *pte;
35
-
36
-	page = alloc_pages(GFP_KERNEL|__GFP_ZERO, 0);
37
-	if(!page)
38
-		return NULL;
39
-	if (!pgtable_page_ctor(page)) {
40
-		__free_page(page);
41
-		return NULL;
42
-	}
43
-
44
-	pte = kmap(page);
45
-	__flush_page_to_ram(pte);
46
-	flush_tlb_kernel_page(pte);
47
-	nocache_page(pte);
48
-	kunmap(page);
49
-	return page;
39
+	return get_pointer_table(TABLE_PTE);
50
40
 }
51
41
 
52
-static inline void pte_free(struct mm_struct *mm, pgtable_t page)
42
+static inline void pte_free(struct mm_struct *mm, pgtable_t pgtable)
53
43
 {
54
-	pgtable_page_dtor(page);
55
-	cache_page(kmap(page));
56
-	kunmap(page);
57
-	__free_page(page);
44
+	free_pointer_table(pgtable, TABLE_PTE);
58
45
 }
59
46
 
60
-static inline void __pte_free_tlb(struct mmu_gather *tlb, pgtable_t page,
47
+static inline void __pte_free_tlb(struct mmu_gather *tlb, pgtable_t pgtable,
61
48
 				  unsigned long address)
62
49
 {
63
-	pgtable_page_dtor(page);
64
-	cache_page(kmap(page));
65
-	kunmap(page);
66
-	__free_page(page);
50
+	free_pointer_table(pgtable, TABLE_PTE);
67
51
 }
68
52
 
69
53
 
70
54
 static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
71
55
 {
72
-	return get_pointer_table();
56
+	return get_pointer_table(TABLE_PMD);
73
57
 }
74
58
 
75
59
 static inline int pmd_free(struct mm_struct *mm, pmd_t *pmd)
76
60
 {
77
-	return free_pointer_table(pmd);
61
+	return free_pointer_table(pmd, TABLE_PMD);
78
62
 }
79
63
 
80
64
 static inline int __pmd_free_tlb(struct mmu_gather *tlb, pmd_t *pmd,
81
65
 				 unsigned long address)
82
66
 {
83
-	return free_pointer_table(pmd);
67
+	return free_pointer_table(pmd, TABLE_PMD);
84
68
 }
85
69
 
86
70
 
87
71
 static inline void pgd_free(struct mm_struct *mm, pgd_t *pgd)
88
72
 {
89
-	pmd_free(mm, (pmd_t *)pgd);
73
+	free_pointer_table(pgd, TABLE_PGD);
90
74
 }
91
75
 
92
76
 static inline pgd_t *pgd_alloc(struct mm_struct *mm)
93
77
 {
94
-	return (pgd_t *)get_pointer_table();
78
+	return get_pointer_table(TABLE_PGD);
95
79
 }
96
80
 
97
81
 
..
..
@@ -102,13 +86,13 @@
102
86
 
103
87
 static inline void pmd_populate(struct mm_struct *mm, pmd_t *pmd, pgtable_t page)
104
88
 {
105
-	pmd_set(pmd, page_address(page));
89
+	pmd_set(pmd, page);
106
90
 }
107
-#define pmd_pgtable(pmd) pmd_page(pmd)
91
+#define pmd_pgtable(pmd) ((pgtable_t)pmd_page_vaddr(pmd))
108
92
 
109
-static inline void pgd_populate(struct mm_struct *mm, pgd_t *pgd, pmd_t *pmd)
93
+static inline void pud_populate(struct mm_struct *mm, pud_t *pud, pmd_t *pmd)
110
94
 {
111
-	pgd_set(pgd, pmd);
95
+	pud_set(pud, pmd);
112
96
 }
113
97
 
114
98
 #endif /* _MOTOROLA_PGALLOC_H */