Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : #ifndef _ASM_GENERIC_PGTABLE_H
3 : : #define _ASM_GENERIC_PGTABLE_H
4 : :
5 : : #include <linux/pfn.h>
6 : :
7 : : #ifndef __ASSEMBLY__
8 : : #ifdef CONFIG_MMU
9 : :
10 : : #include <linux/mm_types.h>
11 : : #include <linux/bug.h>
12 : : #include <linux/errno.h>
13 : :
14 : : #if 5 - defined(__PAGETABLE_P4D_FOLDED) - defined(__PAGETABLE_PUD_FOLDED) - \
15 : : defined(__PAGETABLE_PMD_FOLDED) != CONFIG_PGTABLE_LEVELS
16 : : #error CONFIG_PGTABLE_LEVELS is not consistent with __PAGETABLE_{P4D,PUD,PMD}_FOLDED
17 : : #endif
18 : :
19 : : /*
20 : : * On almost all architectures and configurations, 0 can be used as the
21 : : * upper ceiling to free_pgtables(): on many architectures it has the same
22 : : * effect as using TASK_SIZE. However, there is one configuration which
23 : : * must impose a more careful limit, to avoid freeing kernel pgtables.
24 : : */
25 : : #ifndef USER_PGTABLES_CEILING
26 : : #define USER_PGTABLES_CEILING 0UL
27 : : #endif
28 : :
29 : : #ifndef __HAVE_ARCH_PTEP_SET_ACCESS_FLAGS
30 : : extern int ptep_set_access_flags(struct vm_area_struct *vma,
31 : : unsigned long address, pte_t *ptep,
32 : : pte_t entry, int dirty);
33 : : #endif
34 : :
35 : : #ifndef __HAVE_ARCH_PMDP_SET_ACCESS_FLAGS
36 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
37 : : extern int pmdp_set_access_flags(struct vm_area_struct *vma,
38 : : unsigned long address, pmd_t *pmdp,
39 : : pmd_t entry, int dirty);
40 : : extern int pudp_set_access_flags(struct vm_area_struct *vma,
41 : : unsigned long address, pud_t *pudp,
42 : : pud_t entry, int dirty);
43 : : #else
44 : : static inline int pmdp_set_access_flags(struct vm_area_struct *vma,
45 : : unsigned long address, pmd_t *pmdp,
46 : : pmd_t entry, int dirty)
47 : : {
48 : : BUILD_BUG();
49 : : return 0;
50 : : }
51 : : static inline int pudp_set_access_flags(struct vm_area_struct *vma,
52 : : unsigned long address, pud_t *pudp,
53 : : pud_t entry, int dirty)
54 : : {
55 : : BUILD_BUG();
56 : : return 0;
57 : : }
58 : : #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
59 : : #endif
60 : :
61 : : #ifndef __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG
62 : : static inline int ptep_test_and_clear_young(struct vm_area_struct *vma,
63 : : unsigned long address,
64 : : pte_t *ptep)
65 : : {
66 : : pte_t pte = *ptep;
67 : : int r = 1;
68 : : if (!pte_young(pte))
69 : : r = 0;
70 : : else
71 : : set_pte_at(vma->vm_mm, address, ptep, pte_mkold(pte));
72 : : return r;
73 : : }
74 : : #endif
75 : :
76 : : #ifndef __HAVE_ARCH_PMDP_TEST_AND_CLEAR_YOUNG
77 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
78 : : static inline int pmdp_test_and_clear_young(struct vm_area_struct *vma,
79 : : unsigned long address,
80 : : pmd_t *pmdp)
81 : : {
82 : : pmd_t pmd = *pmdp;
83 : : int r = 1;
84 : : if (!pmd_young(pmd))
85 : : r = 0;
86 : : else
87 : : set_pmd_at(vma->vm_mm, address, pmdp, pmd_mkold(pmd));
88 : : return r;
89 : : }
90 : : #else
91 : : static inline int pmdp_test_and_clear_young(struct vm_area_struct *vma,
92 : : unsigned long address,
93 : : pmd_t *pmdp)
94 : : {
95 : : BUILD_BUG();
96 : : return 0;
97 : : }
98 : : #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
99 : : #endif
100 : :
101 : : #ifndef __HAVE_ARCH_PTEP_CLEAR_YOUNG_FLUSH
102 : : int ptep_clear_flush_young(struct vm_area_struct *vma,
103 : : unsigned long address, pte_t *ptep);
104 : : #endif
105 : :
106 : : #ifndef __HAVE_ARCH_PMDP_CLEAR_YOUNG_FLUSH
107 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
108 : : extern int pmdp_clear_flush_young(struct vm_area_struct *vma,
109 : : unsigned long address, pmd_t *pmdp);
110 : : #else
111 : : /*
112 : : * Despite relevant to THP only, this API is called from generic rmap code
113 : : * under PageTransHuge(), hence needs a dummy implementation for !THP
114 : : */
115 : : static inline int pmdp_clear_flush_young(struct vm_area_struct *vma,
116 : : unsigned long address, pmd_t *pmdp)
117 : : {
118 : : BUILD_BUG();
119 : : return 0;
120 : : }
121 : : #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
122 : : #endif
123 : :
124 : : #ifndef __HAVE_ARCH_PTEP_GET_AND_CLEAR
125 : : static inline pte_t ptep_get_and_clear(struct mm_struct *mm,
126 : : unsigned long address,
127 : : pte_t *ptep)
128 : : {
129 : : pte_t pte = *ptep;
130 : : pte_clear(mm, address, ptep);
131 : : return pte;
132 : : }
133 : : #endif
134 : :
135 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
136 : : #ifndef __HAVE_ARCH_PMDP_HUGE_GET_AND_CLEAR
137 : : static inline pmd_t pmdp_huge_get_and_clear(struct mm_struct *mm,
138 : : unsigned long address,
139 : : pmd_t *pmdp)
140 : : {
141 : : pmd_t pmd = *pmdp;
142 : : pmd_clear(pmdp);
143 : : return pmd;
144 : : }
145 : : #endif /* __HAVE_ARCH_PMDP_HUGE_GET_AND_CLEAR */
146 : : #ifndef __HAVE_ARCH_PUDP_HUGE_GET_AND_CLEAR
147 : : static inline pud_t pudp_huge_get_and_clear(struct mm_struct *mm,
148 : : unsigned long address,
149 : : pud_t *pudp)
150 : : {
151 : : pud_t pud = *pudp;
152 : :
153 : : pud_clear(pudp);
154 : : return pud;
155 : : }
156 : : #endif /* __HAVE_ARCH_PUDP_HUGE_GET_AND_CLEAR */
157 : : #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
158 : :
159 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
160 : : #ifndef __HAVE_ARCH_PMDP_HUGE_GET_AND_CLEAR_FULL
161 : : static inline pmd_t pmdp_huge_get_and_clear_full(struct mm_struct *mm,
162 : : unsigned long address, pmd_t *pmdp,
163 : : int full)
164 : : {
165 : : return pmdp_huge_get_and_clear(mm, address, pmdp);
166 : : }
167 : : #endif
168 : :
169 : : #ifndef __HAVE_ARCH_PUDP_HUGE_GET_AND_CLEAR_FULL
170 : : static inline pud_t pudp_huge_get_and_clear_full(struct mm_struct *mm,
171 : : unsigned long address, pud_t *pudp,
172 : : int full)
173 : : {
174 : : return pudp_huge_get_and_clear(mm, address, pudp);
175 : : }
176 : : #endif
177 : : #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
178 : :
179 : : #ifndef __HAVE_ARCH_PTEP_GET_AND_CLEAR_FULL
180 : : static inline pte_t ptep_get_and_clear_full(struct mm_struct *mm,
181 : : unsigned long address, pte_t *ptep,
182 : : int full)
183 : : {
184 : : pte_t pte;
185 : : pte = ptep_get_and_clear(mm, address, ptep);
186 : : return pte;
187 : : }
188 : : #endif
189 : :
190 : : /*
191 : : * Some architectures may be able to avoid expensive synchronization
192 : : * primitives when modifications are made to PTE's which are already
193 : : * not present, or in the process of an address space destruction.
194 : : */
195 : : #ifndef __HAVE_ARCH_PTE_CLEAR_NOT_PRESENT_FULL
196 : 0 : static inline void pte_clear_not_present_full(struct mm_struct *mm,
197 : : unsigned long address,
198 : : pte_t *ptep,
199 : : int full)
200 : : {
201 : 0 : pte_clear(mm, address, ptep);
202 : : }
203 : : #endif
204 : :
205 : : #ifndef __HAVE_ARCH_PTEP_CLEAR_FLUSH
206 : : extern pte_t ptep_clear_flush(struct vm_area_struct *vma,
207 : : unsigned long address,
208 : : pte_t *ptep);
209 : : #endif
210 : :
211 : : #ifndef __HAVE_ARCH_PMDP_HUGE_CLEAR_FLUSH
212 : : extern pmd_t pmdp_huge_clear_flush(struct vm_area_struct *vma,
213 : : unsigned long address,
214 : : pmd_t *pmdp);
215 : : extern pud_t pudp_huge_clear_flush(struct vm_area_struct *vma,
216 : : unsigned long address,
217 : : pud_t *pudp);
218 : : #endif
219 : :
220 : : #ifndef __HAVE_ARCH_PTEP_SET_WRPROTECT
221 : : struct mm_struct;
222 : : static inline void ptep_set_wrprotect(struct mm_struct *mm, unsigned long address, pte_t *ptep)
223 : : {
224 : : pte_t old_pte = *ptep;
225 : : set_pte_at(mm, address, ptep, pte_wrprotect(old_pte));
226 : : }
227 : : #endif
228 : :
229 : : #ifndef pte_savedwrite
230 : : #define pte_savedwrite pte_write
231 : : #endif
232 : :
233 : : #ifndef pte_mk_savedwrite
234 : : #define pte_mk_savedwrite pte_mkwrite
235 : : #endif
236 : :
237 : : #ifndef pte_clear_savedwrite
238 : : #define pte_clear_savedwrite pte_wrprotect
239 : : #endif
240 : :
241 : : #ifndef pmd_savedwrite
242 : : #define pmd_savedwrite pmd_write
243 : : #endif
244 : :
245 : : #ifndef pmd_mk_savedwrite
246 : : #define pmd_mk_savedwrite pmd_mkwrite
247 : : #endif
248 : :
249 : : #ifndef pmd_clear_savedwrite
250 : : #define pmd_clear_savedwrite pmd_wrprotect
251 : : #endif
252 : :
253 : : #ifndef __HAVE_ARCH_PMDP_SET_WRPROTECT
254 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
255 : : static inline void pmdp_set_wrprotect(struct mm_struct *mm,
256 : : unsigned long address, pmd_t *pmdp)
257 : : {
258 : : pmd_t old_pmd = *pmdp;
259 : : set_pmd_at(mm, address, pmdp, pmd_wrprotect(old_pmd));
260 : : }
261 : : #else
262 : : static inline void pmdp_set_wrprotect(struct mm_struct *mm,
263 : : unsigned long address, pmd_t *pmdp)
264 : : {
265 : : BUILD_BUG();
266 : : }
267 : : #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
268 : : #endif
269 : : #ifndef __HAVE_ARCH_PUDP_SET_WRPROTECT
270 : : #ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD
271 : : static inline void pudp_set_wrprotect(struct mm_struct *mm,
272 : : unsigned long address, pud_t *pudp)
273 : : {
274 : : pud_t old_pud = *pudp;
275 : :
276 : : set_pud_at(mm, address, pudp, pud_wrprotect(old_pud));
277 : : }
278 : : #else
279 : : static inline void pudp_set_wrprotect(struct mm_struct *mm,
280 : : unsigned long address, pud_t *pudp)
281 : : {
282 : : BUILD_BUG();
283 : : }
284 : : #endif /* CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD */
285 : : #endif
286 : :
287 : : #ifndef pmdp_collapse_flush
288 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
289 : : extern pmd_t pmdp_collapse_flush(struct vm_area_struct *vma,
290 : : unsigned long address, pmd_t *pmdp);
291 : : #else
292 : : static inline pmd_t pmdp_collapse_flush(struct vm_area_struct *vma,
293 : : unsigned long address,
294 : : pmd_t *pmdp)
295 : : {
296 : : BUILD_BUG();
297 : : return *pmdp;
298 : : }
299 : : #define pmdp_collapse_flush pmdp_collapse_flush
300 : : #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
301 : : #endif
302 : :
303 : : #ifndef __HAVE_ARCH_PGTABLE_DEPOSIT
304 : : extern void pgtable_trans_huge_deposit(struct mm_struct *mm, pmd_t *pmdp,
305 : : pgtable_t pgtable);
306 : : #endif
307 : :
308 : : #ifndef __HAVE_ARCH_PGTABLE_WITHDRAW
309 : : extern pgtable_t pgtable_trans_huge_withdraw(struct mm_struct *mm, pmd_t *pmdp);
310 : : #endif
311 : :
312 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
313 : : /*
314 : : * This is an implementation of pmdp_establish() that is only suitable for an
315 : : * architecture that doesn't have hardware dirty/accessed bits. In this case we
316 : : * can't race with CPU which sets these bits and non-atomic aproach is fine.
317 : : */
318 : : static inline pmd_t generic_pmdp_establish(struct vm_area_struct *vma,
319 : : unsigned long address, pmd_t *pmdp, pmd_t pmd)
320 : : {
321 : : pmd_t old_pmd = *pmdp;
322 : : set_pmd_at(vma->vm_mm, address, pmdp, pmd);
323 : : return old_pmd;
324 : : }
325 : : #endif
326 : :
327 : : #ifndef __HAVE_ARCH_PMDP_INVALIDATE
328 : : extern pmd_t pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,
329 : : pmd_t *pmdp);
330 : : #endif
331 : :
332 : : #ifndef __HAVE_ARCH_PTE_SAME
333 : : static inline int pte_same(pte_t pte_a, pte_t pte_b)
334 : : {
335 : : return pte_val(pte_a) == pte_val(pte_b);
336 : : }
337 : : #endif
338 : :
339 : : #ifndef __HAVE_ARCH_PTE_UNUSED
340 : : /*
341 : : * Some architectures provide facilities to virtualization guests
342 : : * so that they can flag allocated pages as unused. This allows the
343 : : * host to transparently reclaim unused pages. This function returns
344 : : * whether the pte's page is unused.
345 : : */
346 : 0 : static inline int pte_unused(pte_t pte)
347 : : {
348 [ # # ]: 0 : return 0;
349 : : }
350 : : #endif
351 : :
352 : : #ifndef pte_access_permitted
353 : : #define pte_access_permitted(pte, write) \
354 : : (pte_present(pte) && (!(write) || pte_write(pte)))
355 : : #endif
356 : :
357 : : #ifndef pmd_access_permitted
358 : : #define pmd_access_permitted(pmd, write) \
359 : : (pmd_present(pmd) && (!(write) || pmd_write(pmd)))
360 : : #endif
361 : :
362 : : #ifndef pud_access_permitted
363 : : #define pud_access_permitted(pud, write) \
364 : : (pud_present(pud) && (!(write) || pud_write(pud)))
365 : : #endif
366 : :
367 : : #ifndef p4d_access_permitted
368 : : #define p4d_access_permitted(p4d, write) \
369 : : (p4d_present(p4d) && (!(write) || p4d_write(p4d)))
370 : : #endif
371 : :
372 : : #ifndef pgd_access_permitted
373 : : #define pgd_access_permitted(pgd, write) \
374 : : (pgd_present(pgd) && (!(write) || pgd_write(pgd)))
375 : : #endif
376 : :
377 : : #ifndef __HAVE_ARCH_PMD_SAME
378 : 0 : static inline int pmd_same(pmd_t pmd_a, pmd_t pmd_b)
379 : : {
380 [ # # ]: 0 : return pmd_val(pmd_a) == pmd_val(pmd_b);
381 : : }
382 : :
383 : 0 : static inline int pud_same(pud_t pud_a, pud_t pud_b)
384 : : {
385 [ # # ]: 0 : return pud_val(pud_a) == pud_val(pud_b);
386 : : }
387 : : #endif
388 : :
389 : : #ifndef __HAVE_ARCH_P4D_SAME
390 : 0 : static inline int p4d_same(p4d_t p4d_a, p4d_t p4d_b)
391 : : {
392 [ # # ]: 0 : return p4d_val(p4d_a) == p4d_val(p4d_b);
393 : : }
394 : : #endif
395 : :
396 : : #ifndef __HAVE_ARCH_PGD_SAME
397 : : static inline int pgd_same(pgd_t pgd_a, pgd_t pgd_b)
398 : : {
399 : : return pgd_val(pgd_a) == pgd_val(pgd_b);
400 : : }
401 : : #endif
402 : :
403 : : /*
404 : : * Use set_p*_safe(), and elide TLB flushing, when confident that *no*
405 : : * TLB flush will be required as a result of the "set". For example, use
406 : : * in scenarios where it is known ahead of time that the routine is
407 : : * setting non-present entries, or re-setting an existing entry to the
408 : : * same value. Otherwise, use the typical "set" helpers and flush the
409 : : * TLB.
410 : : */
411 : : #define set_pte_safe(ptep, pte) \
412 : : ({ \
413 : : WARN_ON_ONCE(pte_present(*ptep) && !pte_same(*ptep, pte)); \
414 : : set_pte(ptep, pte); \
415 : : })
416 : :
417 : : #define set_pmd_safe(pmdp, pmd) \
418 : : ({ \
419 : : WARN_ON_ONCE(pmd_present(*pmdp) && !pmd_same(*pmdp, pmd)); \
420 : : set_pmd(pmdp, pmd); \
421 : : })
422 : :
423 : : #define set_pud_safe(pudp, pud) \
424 : : ({ \
425 : : WARN_ON_ONCE(pud_present(*pudp) && !pud_same(*pudp, pud)); \
426 : : set_pud(pudp, pud); \
427 : : })
428 : :
429 : : #define set_p4d_safe(p4dp, p4d) \
430 : : ({ \
431 : : WARN_ON_ONCE(p4d_present(*p4dp) && !p4d_same(*p4dp, p4d)); \
432 : : set_p4d(p4dp, p4d); \
433 : : })
434 : :
435 : : #define set_pgd_safe(pgdp, pgd) \
436 : : ({ \
437 : : WARN_ON_ONCE(pgd_present(*pgdp) && !pgd_same(*pgdp, pgd)); \
438 : : set_pgd(pgdp, pgd); \
439 : : })
440 : :
441 : : #ifndef __HAVE_ARCH_DO_SWAP_PAGE
442 : : /*
443 : : * Some architectures support metadata associated with a page. When a
444 : : * page is being swapped out, this metadata must be saved so it can be
445 : : * restored when the page is swapped back in. SPARC M7 and newer
446 : : * processors support an ADI (Application Data Integrity) tag for the
447 : : * page as metadata for the page. arch_do_swap_page() can restore this
448 : : * metadata when a page is swapped back in.
449 : : */
450 : 0 : static inline void arch_do_swap_page(struct mm_struct *mm,
451 : : struct vm_area_struct *vma,
452 : : unsigned long addr,
453 : : pte_t pte, pte_t oldpte)
454 : : {
455 : :
456 [ # # ]: 0 : }
457 : : #endif
458 : :
459 : : #ifndef __HAVE_ARCH_UNMAP_ONE
460 : : /*
461 : : * Some architectures support metadata associated with a page. When a
462 : : * page is being swapped out, this metadata must be saved so it can be
463 : : * restored when the page is swapped back in. SPARC M7 and newer
464 : : * processors support an ADI (Application Data Integrity) tag for the
465 : : * page as metadata for the page. arch_unmap_one() can save this
466 : : * metadata on a swap-out of a page.
467 : : */
468 : 0 : static inline int arch_unmap_one(struct mm_struct *mm,
469 : : struct vm_area_struct *vma,
470 : : unsigned long addr,
471 : : pte_t orig_pte)
472 : : {
473 [ # # ]: 0 : return 0;
474 : : }
475 : : #endif
476 : :
477 : : #ifndef __HAVE_ARCH_PGD_OFFSET_GATE
478 : : #define pgd_offset_gate(mm, addr) pgd_offset(mm, addr)
479 : : #endif
480 : :
481 : : #ifndef __HAVE_ARCH_MOVE_PTE
482 : : #define move_pte(pte, prot, old_addr, new_addr) (pte)
483 : : #endif
484 : :
485 : : #ifndef pte_accessible
486 : : # define pte_accessible(mm, pte) ((void)(pte), 1)
487 : : #endif
488 : :
489 : : #ifndef flush_tlb_fix_spurious_fault
490 : : #define flush_tlb_fix_spurious_fault(vma, address) flush_tlb_page(vma, address)
491 : : #endif
492 : :
493 : : #ifndef pgprot_noncached
494 : : #define pgprot_noncached(prot) (prot)
495 : : #endif
496 : :
497 : : #ifndef pgprot_writecombine
498 : : #define pgprot_writecombine pgprot_noncached
499 : : #endif
500 : :
501 : : #ifndef pgprot_writethrough
502 : : #define pgprot_writethrough pgprot_noncached
503 : : #endif
504 : :
505 : : #ifndef pgprot_device
506 : : #define pgprot_device pgprot_noncached
507 : : #endif
508 : :
509 : : #ifndef pgprot_modify
510 : : #define pgprot_modify pgprot_modify
511 : : static inline pgprot_t pgprot_modify(pgprot_t oldprot, pgprot_t newprot)
512 : : {
513 : : if (pgprot_val(oldprot) == pgprot_val(pgprot_noncached(oldprot)))
514 : : newprot = pgprot_noncached(newprot);
515 : : if (pgprot_val(oldprot) == pgprot_val(pgprot_writecombine(oldprot)))
516 : : newprot = pgprot_writecombine(newprot);
517 : : if (pgprot_val(oldprot) == pgprot_val(pgprot_device(oldprot)))
518 : : newprot = pgprot_device(newprot);
519 : : return newprot;
520 : : }
521 : : #endif
522 : :
523 : : /*
524 : : * When walking page tables, get the address of the next boundary,
525 : : * or the end address of the range if that comes earlier. Although no
526 : : * vma end wraps to 0, rounded up __boundary may wrap to 0 throughout.
527 : : */
528 : :
529 : : #define pgd_addr_end(addr, end) \
530 : : ({ unsigned long __boundary = ((addr) + PGDIR_SIZE) & PGDIR_MASK; \
531 : : (__boundary - 1 < (end) - 1)? __boundary: (end); \
532 : : })
533 : :
534 : : #ifndef p4d_addr_end
535 : : #define p4d_addr_end(addr, end) \
536 : : ({ unsigned long __boundary = ((addr) + P4D_SIZE) & P4D_MASK; \
537 : : (__boundary - 1 < (end) - 1)? __boundary: (end); \
538 : : })
539 : : #endif
540 : :
541 : : #ifndef pud_addr_end
542 : : #define pud_addr_end(addr, end) \
543 : : ({ unsigned long __boundary = ((addr) + PUD_SIZE) & PUD_MASK; \
544 : : (__boundary - 1 < (end) - 1)? __boundary: (end); \
545 : : })
546 : : #endif
547 : :
548 : : #ifndef pmd_addr_end
549 : : #define pmd_addr_end(addr, end) \
550 : : ({ unsigned long __boundary = ((addr) + PMD_SIZE) & PMD_MASK; \
551 : : (__boundary - 1 < (end) - 1)? __boundary: (end); \
552 : : })
553 : : #endif
554 : :
555 : : /*
556 : : * When walking page tables, we usually want to skip any p?d_none entries;
557 : : * and any p?d_bad entries - reporting the error before resetting to none.
558 : : * Do the tests inline, but report and clear the bad entry in mm/memory.c.
559 : : */
560 : : void pgd_clear_bad(pgd_t *);
561 : :
562 : : #ifndef __PAGETABLE_P4D_FOLDED
563 : : void p4d_clear_bad(p4d_t *);
564 : : #else
565 : : #define p4d_clear_bad(p4d) do { } while (0)
566 : : #endif
567 : :
568 : : #ifndef __PAGETABLE_PUD_FOLDED
569 : : void pud_clear_bad(pud_t *);
570 : : #else
571 : : #define pud_clear_bad(p4d) do { } while (0)
572 : : #endif
573 : :
574 : : void pmd_clear_bad(pmd_t *);
575 : :
576 : 3904725 : static inline int pgd_none_or_clear_bad(pgd_t *pgd)
577 : : {
578 [ + - ]: 3904725 : if (pgd_none(*pgd))
579 : : return 1;
580 [ - + ]: 3904725 : if (unlikely(pgd_bad(*pgd))) {
581 : 0 : pgd_clear_bad(pgd);
582 : 0 : return 1;
583 : : }
584 : : return 0;
585 : : }
586 : :
587 : 3904725 : static inline int p4d_none_or_clear_bad(p4d_t *p4d)
588 : : {
589 [ + - + + : 3904725 : if (p4d_none(*p4d))
+ - + + ]
590 : : return 1;
591 [ - + - + : 3867938 : if (unlikely(p4d_bad(*p4d))) {
- + - + ]
592 : 0 : p4d_clear_bad(p4d);
593 : 0 : return 1;
594 : : }
595 : : return 0;
596 : : }
597 : :
598 : 3868369 : static inline int pud_none_or_clear_bad(pud_t *pud)
599 : : {
600 [ + + ]: 3868369 : if (pud_none(*pud))
601 : : return 1;
602 [ + - - + ]: 7712534 : if (unlikely(pud_bad(*pud))) {
603 : 0 : pud_clear_bad(pud);
604 : 0 : return 1;
605 : : }
606 : : return 0;
607 : : }
608 : :
609 : 1230418 : static inline int pmd_none_or_clear_bad(pmd_t *pmd)
610 : : {
611 [ + + ]: 1230418 : if (pmd_none(*pmd))
612 : : return 1;
613 [ + - - + ]: 2431322 : if (unlikely(pmd_bad(*pmd))) {
614 : 0 : pmd_clear_bad(pmd);
615 : 0 : return 1;
616 : : }
617 : : return 0;
618 : : }
619 : :
620 : 304391 : static inline pte_t __ptep_modify_prot_start(struct vm_area_struct *vma,
621 : : unsigned long addr,
622 : : pte_t *ptep)
623 : : {
624 : : /*
625 : : * Get the current pte state, but zero it out to make it
626 : : * non-present, preventing the hardware from asynchronously
627 : : * updating it.
628 : : */
629 : 304391 : return ptep_get_and_clear(vma->vm_mm, addr, ptep);
630 : : }
631 : :
632 : 304391 : static inline void __ptep_modify_prot_commit(struct vm_area_struct *vma,
633 : : unsigned long addr,
634 : : pte_t *ptep, pte_t pte)
635 : : {
636 : : /*
637 : : * The pte is non-present, so there's no hardware state to
638 : : * preserve.
639 : : */
640 : 304391 : set_pte_at(vma->vm_mm, addr, ptep, pte);
641 : : }
642 : :
643 : : #ifndef __HAVE_ARCH_PTEP_MODIFY_PROT_TRANSACTION
644 : : /*
645 : : * Start a pte protection read-modify-write transaction, which
646 : : * protects against asynchronous hardware modifications to the pte.
647 : : * The intention is not to prevent the hardware from making pte
648 : : * updates, but to prevent any updates it may make from being lost.
649 : : *
650 : : * This does not protect against other software modifications of the
651 : : * pte; the appropriate pte lock must be held over the transation.
652 : : *
653 : : * Note that this interface is intended to be batchable, meaning that
654 : : * ptep_modify_prot_commit may not actually update the pte, but merely
655 : : * queue the update to be done at some later time. The update must be
656 : : * actually committed before the pte lock is released, however.
657 : : */
658 : 304391 : static inline pte_t ptep_modify_prot_start(struct vm_area_struct *vma,
659 : : unsigned long addr,
660 : : pte_t *ptep)
661 : : {
662 : 304391 : return __ptep_modify_prot_start(vma, addr, ptep);
663 : : }
664 : :
665 : : /*
666 : : * Commit an update to a pte, leaving any hardware-controlled bits in
667 : : * the PTE unmodified.
668 : : */
669 : 304391 : static inline void ptep_modify_prot_commit(struct vm_area_struct *vma,
670 : : unsigned long addr,
671 : : pte_t *ptep, pte_t old_pte, pte_t pte)
672 : : {
673 : 304391 : __ptep_modify_prot_commit(vma, addr, ptep, pte);
674 : : }
675 : : #endif /* __HAVE_ARCH_PTEP_MODIFY_PROT_TRANSACTION */
676 : : #endif /* CONFIG_MMU */
677 : :
678 : : /*
679 : : * No-op macros that just return the current protection value. Defined here
680 : : * because these macros can be used used even if CONFIG_MMU is not defined.
681 : : */
682 : : #ifndef pgprot_encrypted
683 : : #define pgprot_encrypted(prot) (prot)
684 : : #endif
685 : :
686 : : #ifndef pgprot_decrypted
687 : : #define pgprot_decrypted(prot) (prot)
688 : : #endif
689 : :
690 : : /*
691 : : * A facility to provide lazy MMU batching. This allows PTE updates and
692 : : * page invalidations to be delayed until a call to leave lazy MMU mode
693 : : * is issued. Some architectures may benefit from doing this, and it is
694 : : * beneficial for both shadow and direct mode hypervisors, which may batch
695 : : * the PTE updates which happen during this window. Note that using this
696 : : * interface requires that read hazards be removed from the code. A read
697 : : * hazard could result in the direct mode hypervisor case, since the actual
698 : : * write to the page tables may not yet have taken place, so reads though
699 : : * a raw PTE pointer after it has been modified are not guaranteed to be
700 : : * up to date. This mode can only be entered and left under the protection of
701 : : * the page table locks for all page tables which may be modified. In the UP
702 : : * case, this is required so that preemption is disabled, and in the SMP case,
703 : : * it must synchronize the delayed page table writes properly on other CPUs.
704 : : */
705 : : #ifndef __HAVE_ARCH_ENTER_LAZY_MMU_MODE
706 : : #define arch_enter_lazy_mmu_mode() do {} while (0)
707 : : #define arch_leave_lazy_mmu_mode() do {} while (0)
708 : : #define arch_flush_lazy_mmu_mode() do {} while (0)
709 : : #endif
710 : :
711 : : /*
712 : : * A facility to provide batching of the reload of page tables and
713 : : * other process state with the actual context switch code for
714 : : * paravirtualized guests. By convention, only one of the batched
715 : : * update (lazy) modes (CPU, MMU) should be active at any given time,
716 : : * entry should never be nested, and entry and exits should always be
717 : : * paired. This is for sanity of maintaining and reasoning about the
718 : : * kernel code. In this case, the exit (end of the context switch) is
719 : : * in architecture-specific code, and so doesn't need a generic
720 : : * definition.
721 : : */
722 : : #ifndef __HAVE_ARCH_START_CONTEXT_SWITCH
723 : : #define arch_start_context_switch(prev) do {} while (0)
724 : : #endif
725 : :
726 : : #ifdef CONFIG_HAVE_ARCH_SOFT_DIRTY
727 : : #ifndef CONFIG_ARCH_ENABLE_THP_MIGRATION
728 : : static inline pmd_t pmd_swp_mksoft_dirty(pmd_t pmd)
729 : : {
730 : : return pmd;
731 : : }
732 : :
733 : : static inline int pmd_swp_soft_dirty(pmd_t pmd)
734 : : {
735 : : return 0;
736 : : }
737 : :
738 : : static inline pmd_t pmd_swp_clear_soft_dirty(pmd_t pmd)
739 : : {
740 : : return pmd;
741 : : }
742 : : #endif
743 : : #else /* !CONFIG_HAVE_ARCH_SOFT_DIRTY */
744 : : static inline int pte_soft_dirty(pte_t pte)
745 : : {
746 : : return 0;
747 : : }
748 : :
749 : : static inline int pmd_soft_dirty(pmd_t pmd)
750 : : {
751 : : return 0;
752 : : }
753 : :
754 : : static inline pte_t pte_mksoft_dirty(pte_t pte)
755 : : {
756 : : return pte;
757 : : }
758 : :
759 : : static inline pmd_t pmd_mksoft_dirty(pmd_t pmd)
760 : : {
761 : : return pmd;
762 : : }
763 : :
764 : : static inline pte_t pte_clear_soft_dirty(pte_t pte)
765 : : {
766 : : return pte;
767 : : }
768 : :
769 : : static inline pmd_t pmd_clear_soft_dirty(pmd_t pmd)
770 : : {
771 : : return pmd;
772 : : }
773 : :
774 : : static inline pte_t pte_swp_mksoft_dirty(pte_t pte)
775 : : {
776 : : return pte;
777 : : }
778 : :
779 : : static inline int pte_swp_soft_dirty(pte_t pte)
780 : : {
781 : : return 0;
782 : : }
783 : :
784 : : static inline pte_t pte_swp_clear_soft_dirty(pte_t pte)
785 : : {
786 : : return pte;
787 : : }
788 : :
789 : : static inline pmd_t pmd_swp_mksoft_dirty(pmd_t pmd)
790 : : {
791 : : return pmd;
792 : : }
793 : :
794 : : static inline int pmd_swp_soft_dirty(pmd_t pmd)
795 : : {
796 : : return 0;
797 : : }
798 : :
799 : : static inline pmd_t pmd_swp_clear_soft_dirty(pmd_t pmd)
800 : : {
801 : : return pmd;
802 : : }
803 : : #endif
804 : :
805 : : #ifndef __HAVE_PFNMAP_TRACKING
806 : : /*
807 : : * Interfaces that can be used by architecture code to keep track of
808 : : * memory type of pfn mappings specified by the remap_pfn_range,
809 : : * vmf_insert_pfn.
810 : : */
811 : :
812 : : /*
813 : : * track_pfn_remap is called when a _new_ pfn mapping is being established
814 : : * by remap_pfn_range() for physical range indicated by pfn and size.
815 : : */
816 : : static inline int track_pfn_remap(struct vm_area_struct *vma, pgprot_t *prot,
817 : : unsigned long pfn, unsigned long addr,
818 : : unsigned long size)
819 : : {
820 : : return 0;
821 : : }
822 : :
823 : : /*
824 : : * track_pfn_insert is called when a _new_ single pfn is established
825 : : * by vmf_insert_pfn().
826 : : */
827 : : static inline void track_pfn_insert(struct vm_area_struct *vma, pgprot_t *prot,
828 : : pfn_t pfn)
829 : : {
830 : : }
831 : :
832 : : /*
833 : : * track_pfn_copy is called when vma that is covering the pfnmap gets
834 : : * copied through copy_page_range().
835 : : */
836 : : static inline int track_pfn_copy(struct vm_area_struct *vma)
837 : : {
838 : : return 0;
839 : : }
840 : :
841 : : /*
842 : : * untrack_pfn is called while unmapping a pfnmap for a region.
843 : : * untrack can be called for a specific region indicated by pfn and size or
844 : : * can be for the entire vma (in which case pfn, size are zero).
845 : : */
846 : : static inline void untrack_pfn(struct vm_area_struct *vma,
847 : : unsigned long pfn, unsigned long size)
848 : : {
849 : : }
850 : :
851 : : /*
852 : : * untrack_pfn_moved is called while mremapping a pfnmap for a new region.
853 : : */
854 : : static inline void untrack_pfn_moved(struct vm_area_struct *vma)
855 : : {
856 : : }
857 : : #else
858 : : extern int track_pfn_remap(struct vm_area_struct *vma, pgprot_t *prot,
859 : : unsigned long pfn, unsigned long addr,
860 : : unsigned long size);
861 : : extern void track_pfn_insert(struct vm_area_struct *vma, pgprot_t *prot,
862 : : pfn_t pfn);
863 : : extern int track_pfn_copy(struct vm_area_struct *vma);
864 : : extern void untrack_pfn(struct vm_area_struct *vma, unsigned long pfn,
865 : : unsigned long size);
866 : : extern void untrack_pfn_moved(struct vm_area_struct *vma);
867 : : #endif
868 : :
869 : : #ifdef __HAVE_COLOR_ZERO_PAGE
870 : : static inline int is_zero_pfn(unsigned long pfn)
871 : : {
872 : : extern unsigned long zero_pfn;
873 : : unsigned long offset_from_zero_pfn = pfn - zero_pfn;
874 : : return offset_from_zero_pfn <= (zero_page_mask >> PAGE_SHIFT);
875 : : }
876 : :
877 : : #define my_zero_pfn(addr) page_to_pfn(ZERO_PAGE(addr))
878 : :
879 : : #else
880 : 514777 : static inline int is_zero_pfn(unsigned long pfn)
881 : : {
882 : 514777 : extern unsigned long zero_pfn;
883 [ + + - - : 514777 : return pfn == zero_pfn;
- - - + ]
884 : : }
885 : :
886 : 25956 : static inline unsigned long my_zero_pfn(unsigned long addr)
887 : : {
888 : 25956 : extern unsigned long zero_pfn;
889 [ + - ]: 25956 : return zero_pfn;
890 : : }
891 : : #endif
892 : :
893 : : #ifdef CONFIG_MMU
894 : :
895 : : #ifndef CONFIG_TRANSPARENT_HUGEPAGE
896 : 23989031 : static inline int pmd_trans_huge(pmd_t pmd)
897 : : {
898 [ + + ]: 17542733 : return 0;
899 : : }
900 : : #ifndef pmd_write
901 : : static inline int pmd_write(pmd_t pmd)
902 : : {
903 : : BUG();
904 : : return 0;
905 : : }
906 : : #endif /* pmd_write */
907 : : #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
908 : :
909 : : #ifndef pud_write
910 : : static inline int pud_write(pud_t pud)
911 : : {
912 : : BUG();
913 : : return 0;
914 : : }
915 : : #endif /* pud_write */
916 : :
917 : : #if !defined(CONFIG_ARCH_HAS_PTE_DEVMAP) || !defined(CONFIG_TRANSPARENT_HUGEPAGE)
918 : 11230981 : static inline int pmd_devmap(pmd_t pmd)
919 : : {
920 [ - - ]: 6715216 : return 0;
921 : : }
922 : 6192811 : static inline int pud_devmap(pud_t pud)
923 : : {
924 [ - - + - ]: 6192811 : return 0;
925 : : }
926 : : static inline int pgd_devmap(pgd_t pgd)
927 : : {
928 : : return 0;
929 : : }
930 : : #endif
931 : :
932 : : #if !defined(CONFIG_TRANSPARENT_HUGEPAGE) || \
933 : : (defined(CONFIG_TRANSPARENT_HUGEPAGE) && \
934 : : !defined(CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD))
935 : 6121607 : static inline int pud_trans_huge(pud_t pud)
936 : : {
937 : 6693704 : return 0;
938 : : }
939 : : #endif
940 : :
941 : : /* See pmd_none_or_trans_huge_or_clear_bad for discussion. */
942 : : static inline int pud_none_or_trans_huge_or_dev_or_clear_bad(pud_t *pud)
943 : : {
944 : : pud_t pudval = READ_ONCE(*pud);
945 : :
946 : : if (pud_none(pudval) || pud_trans_huge(pudval) || pud_devmap(pudval))
947 : : return 1;
948 : : if (unlikely(pud_bad(pudval))) {
949 : : pud_clear_bad(pud);
950 : : return 1;
951 : : }
952 : : return 0;
953 : : }
954 : :
955 : : /* See pmd_trans_unstable for discussion. */
956 : 2952690 : static inline int pud_trans_unstable(pud_t *pud)
957 : : {
958 : : #if defined(CONFIG_TRANSPARENT_HUGEPAGE) && \
959 : : defined(CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD)
960 : : return pud_none_or_trans_huge_or_dev_or_clear_bad(pud);
961 : : #else
962 : 2952690 : return 0;
963 : : #endif
964 : : }
965 : :
966 : : #ifndef pmd_read_atomic
967 : 2944147 : static inline pmd_t pmd_read_atomic(pmd_t *pmdp)
968 : : {
969 : : /*
970 : : * Depend on compiler for an atomic pmd read. NOTE: this is
971 : : * only going to work, if the pmdval_t isn't larger than
972 : : * an unsigned long.
973 : : */
974 [ + + ]: 2944147 : return *pmdp;
975 : : }
976 : : #endif
977 : :
978 : : #ifndef arch_needs_pgtable_deposit
979 : : #define arch_needs_pgtable_deposit() (false)
980 : : #endif
981 : : /*
982 : : * This function is meant to be used by sites walking pagetables with
983 : : * the mmap_sem hold in read mode to protect against MADV_DONTNEED and
984 : : * transhuge page faults. MADV_DONTNEED can convert a transhuge pmd
985 : : * into a null pmd and the transhuge page fault can convert a null pmd
986 : : * into an hugepmd or into a regular pmd (if the hugepage allocation
987 : : * fails). While holding the mmap_sem in read mode the pmd becomes
988 : : * stable and stops changing under us only if it's not null and not a
989 : : * transhuge pmd. When those races occurs and this function makes a
990 : : * difference vs the standard pmd_none_or_clear_bad, the result is
991 : : * undefined so behaving like if the pmd was none is safe (because it
992 : : * can return none anyway). The compiler level barrier() is critically
993 : : * important to compute the two checks atomically on the same pmdval.
994 : : *
995 : : * For 32bit kernels with a 64bit large pmd_t this automatically takes
996 : : * care of reading the pmd atomically to avoid SMP race conditions
997 : : * against pmd_populate() when the mmap_sem is hold for reading by the
998 : : * caller (a special atomic read not done by "gcc" as in the generic
999 : : * version above, is also needed when THP is disabled because the page
1000 : : * fault can populate the pmd from under us).
1001 : : */
1002 : 2746434 : static inline int pmd_none_or_trans_huge_or_clear_bad(pmd_t *pmd)
1003 : : {
1004 : 2746434 : pmd_t pmdval = pmd_read_atomic(pmd);
1005 : : /*
1006 : : * The barrier will stabilize the pmdval in a register or on
1007 : : * the stack so that it will stop changing under the code.
1008 : : *
1009 : : * When CONFIG_TRANSPARENT_HUGEPAGE=y on x86 32bit PAE,
1010 : : * pmd_read_atomic is allowed to return a not atomic pmdval
1011 : : * (for example pointing to an hugepage that has never been
1012 : : * mapped in the pmd). The below checks will only care about
1013 : : * the low part of the pmd with 32bit PAE x86 anyway, with the
1014 : : * exception of pmd_none(). So the important thing is that if
1015 : : * the low part of the pmd is found null, the high part will
1016 : : * be also null or the pmd_none() check below would be
1017 : : * confused.
1018 : : */
1019 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
1020 : : barrier();
1021 : : #endif
1022 : : /*
1023 : : * !pmd_present() checks for pmd migration entries
1024 : : *
1025 : : * The complete check uses is_pmd_migration_entry() in linux/swapops.h
1026 : : * But using that requires moving current function and pmd_trans_unstable()
1027 : : * to linux/swapops.h to resovle dependency, which is too much code move.
1028 : : *
1029 : : * !pmd_present() is equivalent to is_pmd_migration_entry() currently,
1030 : : * because !pmd_present() pages can only be under migration not swapped
1031 : : * out.
1032 : : *
1033 : : * pmd_none() is preseved for future condition checks on pmd migration
1034 : : * entries and not confusing with this function name, although it is
1035 : : * redundant with !pmd_present().
1036 : : */
1037 [ + + ]: 2746434 : if (pmd_none(pmdval) || pmd_trans_huge(pmdval) ||
1038 : : (IS_ENABLED(CONFIG_ARCH_ENABLE_THP_MIGRATION) && !pmd_present(pmdval)))
1039 : : return 1;
1040 [ + - - + ]: 5393514 : if (unlikely(pmd_bad(pmdval))) {
1041 : 0 : pmd_clear_bad(pmd);
1042 : 0 : return 1;
1043 : : }
1044 : : return 0;
1045 : : }
1046 : :
1047 : : /*
1048 : : * This is a noop if Transparent Hugepage Support is not built into
1049 : : * the kernel. Otherwise it is equivalent to
1050 : : * pmd_none_or_trans_huge_or_clear_bad(), and shall only be called in
1051 : : * places that already verified the pmd is not none and they want to
1052 : : * walk ptes while holding the mmap sem in read mode (write mode don't
1053 : : * need this). If THP is not enabled, the pmd can't go away under the
1054 : : * code even if MADV_DONTNEED runs, but if THP is enabled we need to
1055 : : * run a pmd_trans_unstable before walking the ptes after
1056 : : * split_huge_pmd returns (because it may have run when the pmd become
1057 : : * null, but then a page fault can map in a THP and not a regular page).
1058 : : */
1059 : 5073068 : static inline int pmd_trans_unstable(pmd_t *pmd)
1060 : : {
1061 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
1062 : : return pmd_none_or_trans_huge_or_clear_bad(pmd);
1063 : : #else
1064 [ + - + - : 5073068 : return 0;
+ + ]
1065 : : #endif
1066 : : }
1067 : :
1068 : : #ifndef CONFIG_NUMA_BALANCING
1069 : : /*
1070 : : * Technically a PTE can be PROTNONE even when not doing NUMA balancing but
1071 : : * the only case the kernel cares is for NUMA balancing and is only ever set
1072 : : * when the VMA is accessible. For PROT_NONE VMAs, the PTEs are not marked
1073 : : * _PAGE_PROTNONE so by by default, implement the helper as "always no". It
1074 : : * is the responsibility of the caller to distinguish between PROT_NONE
1075 : : * protections and NUMA hinting fault protections.
1076 : : */
1077 : 836969 : static inline int pte_protnone(pte_t pte)
1078 : : {
1079 [ + - ]: 836969 : return 0;
1080 : : }
1081 : :
1082 : 0 : static inline int pmd_protnone(pmd_t pmd)
1083 : : {
1084 : 0 : return 0;
1085 : : }
1086 : : #endif /* CONFIG_NUMA_BALANCING */
1087 : :
1088 : : #endif /* CONFIG_MMU */
1089 : :
1090 : : #ifdef CONFIG_HAVE_ARCH_HUGE_VMAP
1091 : :
1092 : : #ifndef __PAGETABLE_P4D_FOLDED
1093 : : int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot);
1094 : : int p4d_clear_huge(p4d_t *p4d);
1095 : : #else
1096 : : static inline int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot)
1097 : : {
1098 : : return 0;
1099 : : }
1100 : : static inline int p4d_clear_huge(p4d_t *p4d)
1101 : : {
1102 : : return 0;
1103 : : }
1104 : : #endif /* !__PAGETABLE_P4D_FOLDED */
1105 : :
1106 : : int pud_set_huge(pud_t *pud, phys_addr_t addr, pgprot_t prot);
1107 : : int pmd_set_huge(pmd_t *pmd, phys_addr_t addr, pgprot_t prot);
1108 : : int pud_clear_huge(pud_t *pud);
1109 : : int pmd_clear_huge(pmd_t *pmd);
1110 : : int p4d_free_pud_page(p4d_t *p4d, unsigned long addr);
1111 : : int pud_free_pmd_page(pud_t *pud, unsigned long addr);
1112 : : int pmd_free_pte_page(pmd_t *pmd, unsigned long addr);
1113 : : #else /* !CONFIG_HAVE_ARCH_HUGE_VMAP */
1114 : : static inline int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot)
1115 : : {
1116 : : return 0;
1117 : : }
1118 : : static inline int pud_set_huge(pud_t *pud, phys_addr_t addr, pgprot_t prot)
1119 : : {
1120 : : return 0;
1121 : : }
1122 : : static inline int pmd_set_huge(pmd_t *pmd, phys_addr_t addr, pgprot_t prot)
1123 : : {
1124 : : return 0;
1125 : : }
1126 : : static inline int p4d_clear_huge(p4d_t *p4d)
1127 : : {
1128 : : return 0;
1129 : : }
1130 : : static inline int pud_clear_huge(pud_t *pud)
1131 : : {
1132 : : return 0;
1133 : : }
1134 : : static inline int pmd_clear_huge(pmd_t *pmd)
1135 : : {
1136 : : return 0;
1137 : : }
1138 : : static inline int p4d_free_pud_page(p4d_t *p4d, unsigned long addr)
1139 : : {
1140 : : return 0;
1141 : : }
1142 : : static inline int pud_free_pmd_page(pud_t *pud, unsigned long addr)
1143 : : {
1144 : : return 0;
1145 : : }
1146 : : static inline int pmd_free_pte_page(pmd_t *pmd, unsigned long addr)
1147 : : {
1148 : : return 0;
1149 : : }
1150 : : #endif /* CONFIG_HAVE_ARCH_HUGE_VMAP */
1151 : :
1152 : : #ifndef __HAVE_ARCH_FLUSH_PMD_TLB_RANGE
1153 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
1154 : : /*
1155 : : * ARCHes with special requirements for evicting THP backing TLB entries can
1156 : : * implement this. Otherwise also, it can help optimize normal TLB flush in
1157 : : * THP regime. stock flush_tlb_range() typically has optimization to nuke the
1158 : : * entire TLB TLB if flush span is greater than a threshold, which will
1159 : : * likely be true for a single huge page. Thus a single thp flush will
1160 : : * invalidate the entire TLB which is not desitable.
1161 : : * e.g. see arch/arc: flush_pmd_tlb_range
1162 : : */
1163 : : #define flush_pmd_tlb_range(vma, addr, end) flush_tlb_range(vma, addr, end)
1164 : : #define flush_pud_tlb_range(vma, addr, end) flush_tlb_range(vma, addr, end)
1165 : : #else
1166 : : #define flush_pmd_tlb_range(vma, addr, end) BUILD_BUG()
1167 : : #define flush_pud_tlb_range(vma, addr, end) BUILD_BUG()
1168 : : #endif
1169 : : #endif
1170 : :
1171 : : struct file;
1172 : : int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
1173 : : unsigned long size, pgprot_t *vma_prot);
1174 : :
1175 : : #ifndef CONFIG_X86_ESPFIX64
1176 : : static inline void init_espfix_bsp(void) { }
1177 : : #endif
1178 : :
1179 : : extern void __init pgtable_cache_init(void);
1180 : :
1181 : : #ifndef __HAVE_ARCH_PFN_MODIFY_ALLOWED
1182 : : static inline bool pfn_modify_allowed(unsigned long pfn, pgprot_t prot)
1183 : : {
1184 : : return true;
1185 : : }
1186 : :
1187 : : static inline bool arch_has_pfn_modify_check(void)
1188 : : {
1189 : : return false;
1190 : : }
1191 : : #endif /* !_HAVE_ARCH_PFN_MODIFY_ALLOWED */
1192 : :
1193 : : /*
1194 : : * Architecture PAGE_KERNEL_* fallbacks
1195 : : *
1196 : : * Some architectures don't define certain PAGE_KERNEL_* flags. This is either
1197 : : * because they really don't support them, or the port needs to be updated to
1198 : : * reflect the required functionality. Below are a set of relatively safe
1199 : : * fallbacks, as best effort, which we can count on in lieu of the architectures
1200 : : * not defining them on their own yet.
1201 : : */
1202 : :
1203 : : #ifndef PAGE_KERNEL_RO
1204 : : # define PAGE_KERNEL_RO PAGE_KERNEL
1205 : : #endif
1206 : :
1207 : : #ifndef PAGE_KERNEL_EXEC
1208 : : # define PAGE_KERNEL_EXEC PAGE_KERNEL
1209 : : #endif
1210 : :
1211 : : #endif /* !__ASSEMBLY__ */
1212 : :
1213 : : #ifndef io_remap_pfn_range
1214 : : #define io_remap_pfn_range remap_pfn_range
1215 : : #endif
1216 : :
1217 : : #ifndef has_transparent_hugepage
1218 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
1219 : : #define has_transparent_hugepage() 1
1220 : : #else
1221 : : #define has_transparent_hugepage() 0
1222 : : #endif
1223 : : #endif
1224 : :
1225 : : /*
1226 : : * On some architectures it depends on the mm if the p4d/pud or pmd
1227 : : * layer of the page table hierarchy is folded or not.
1228 : : */
1229 : : #ifndef mm_p4d_folded
1230 : : #define mm_p4d_folded(mm) __is_defined(__PAGETABLE_P4D_FOLDED)
1231 : : #endif
1232 : :
1233 : : #ifndef mm_pud_folded
1234 : : #define mm_pud_folded(mm) __is_defined(__PAGETABLE_PUD_FOLDED)
1235 : : #endif
1236 : :
1237 : : #ifndef mm_pmd_folded
1238 : : #define mm_pmd_folded(mm) __is_defined(__PAGETABLE_PMD_FOLDED)
1239 : : #endif
1240 : :
1241 : : /*
1242 : : * p?d_leaf() - true if this entry is a final mapping to a physical address.
1243 : : * This differs from p?d_huge() by the fact that they are always available (if
1244 : : * the architecture supports large pages at the appropriate level) even
1245 : : * if CONFIG_HUGETLB_PAGE is not defined.
1246 : : * Only meaningful when called on a valid entry.
1247 : : */
1248 : : #ifndef pgd_leaf
1249 : : #define pgd_leaf(x) 0
1250 : : #endif
1251 : : #ifndef p4d_leaf
1252 : : #define p4d_leaf(x) 0
1253 : : #endif
1254 : : #ifndef pud_leaf
1255 : : #define pud_leaf(x) 0
1256 : : #endif
1257 : : #ifndef pmd_leaf
1258 : : #define pmd_leaf(x) 0
1259 : : #endif
1260 : :
1261 : : #endif /* _ASM_GENERIC_PGTABLE_H */
|
