mk-rootfs.sh

hc

2023-12-11 072de836f53be56a70cecf70b43ae43b7ce17376

 kernel/arch/parisc/mm/hugetlbpage.c
..
..
@@ -15,7 +15,6 @@
15
15
 #include <linux/sysctl.h>
16
16
 
17
17
 #include <asm/mman.h>
18
-#include <asm/pgalloc.h>
19
18
 #include <asm/tlb.h>
20
19
 #include <asm/tlbflush.h>
21
20
 #include <asm/cacheflush.h>
..
..
@@ -45,10 +44,11 @@
45
44
 }
46
45
 
47
46
 
48
-pte_t *huge_pte_alloc(struct mm_struct *mm,
47
+pte_t *huge_pte_alloc(struct mm_struct *mm, struct vm_area_struct *vma,
49
48
 			unsigned long addr, unsigned long sz)
50
49
 {
51
50
 	pgd_t *pgd;
51
+	p4d_t *p4d;
52
52
 	pud_t *pud;
53
53
 	pmd_t *pmd;
54
54
 	pte_t *pte = NULL;
..
..
@@ -61,7 +61,8 @@
61
61
 	addr &= HPAGE_MASK;
62
62
 
63
63
 	pgd = pgd_offset(mm, addr);
64
-	pud = pud_alloc(mm, pgd, addr);
64
+	p4d = p4d_offset(pgd, addr);
65
+	pud = pud_alloc(mm, p4d, addr);
65
66
 	if (pud) {
66
67
 		pmd = pmd_alloc(mm, pud, addr);
67
68
 		if (pmd)
..
..
@@ -74,6 +75,7 @@
74
75
 		       unsigned long addr, unsigned long sz)
75
76
 {
76
77
 	pgd_t *pgd;
78
+	p4d_t *p4d;
77
79
 	pud_t *pud;
78
80
 	pmd_t *pmd;
79
81
 	pte_t *pte = NULL;
..
..
@@ -82,11 +84,14 @@
82
84
 
83
85
 	pgd = pgd_offset(mm, addr);
84
86
 	if (!pgd_none(*pgd)) {
85
-		pud = pud_offset(pgd, addr);
86
-		if (!pud_none(*pud)) {
87
-			pmd = pmd_offset(pud, addr);
88
-			if (!pmd_none(*pmd))
89
-				pte = pte_offset_map(pmd, addr);
87
+		p4d = p4d_offset(pgd, addr);
88
+		if (!p4d_none(*p4d)) {
89
+			pud = pud_offset(p4d, addr);
90
+			if (!pud_none(*pud)) {
91
+				pmd = pmd_offset(pud, addr);
92
+				if (!pmd_none(*pmd))
93
+					pte = pte_offset_map(pmd, addr);
94
+			}
90
95
 		}
91
96
 	}
92
97
 	return pte;
..
..
@@ -137,24 +142,17 @@
137
142
 void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
138
143
 		     pte_t *ptep, pte_t entry)
139
144
 {
140
-	unsigned long flags;
141
-
142
-	purge_tlb_start(flags);
143
145
 	__set_huge_pte_at(mm, addr, ptep, entry);
144
-	purge_tlb_end(flags);
145
146
 }
146
147
 
147
148
 
148
149
 pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
149
150
 			      pte_t *ptep)
150
151
 {
151
-	unsigned long flags;
152
152
 	pte_t entry;
153
153
 
154
-	purge_tlb_start(flags);
155
154
 	entry = *ptep;
156
155
 	__set_huge_pte_at(mm, addr, ptep, __pte(0));
157
-	purge_tlb_end(flags);
158
156
 
159
157
 	return entry;
160
158
 }
..
..
@@ -163,28 +161,23 @@
163
161
 void huge_ptep_set_wrprotect(struct mm_struct *mm,
164
162
 				unsigned long addr, pte_t *ptep)
165
163
 {
166
-	unsigned long flags;
167
164
 	pte_t old_pte;
168
165
 
169
-	purge_tlb_start(flags);
170
166
 	old_pte = *ptep;
171
167
 	__set_huge_pte_at(mm, addr, ptep, pte_wrprotect(old_pte));
172
-	purge_tlb_end(flags);
173
168
 }
174
169
 
175
170
 int huge_ptep_set_access_flags(struct vm_area_struct *vma,
176
171
 				unsigned long addr, pte_t *ptep,
177
172
 				pte_t pte, int dirty)
178
173
 {
179
-	unsigned long flags;
180
174
 	int changed;
175
+	struct mm_struct *mm = vma->vm_mm;
181
176
 
182
-	purge_tlb_start(flags);
183
177
 	changed = !pte_same(*ptep, pte);
184
178
 	if (changed) {
185
-		__set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
179
+		__set_huge_pte_at(mm, addr, ptep, pte);
186
180
 	}
187
-	purge_tlb_end(flags);
188
181
 	return changed;
189
182
 }
190
183