/* SPDX-License-Identifier: GPL-2.0 */#ifndef _ASM_GENERIC_PGTABLE_H#define _ASM_GENERIC_PGTABLE_H #include <linux/pfn.h> #ifndef __ASSEMBLY__#ifdef CONFIG_MMU #include <linux/mm_types.h>#include <linux/bug.h>#include <linux/errno.h> #if 5 - defined(__PAGETABLE_P4D_FOLDED) - defined(__PAGETABLE_PUD_FOLDED) - \	defined(__PAGETABLE_PMD_FOLDED) != CONFIG_PGTABLE_LEVELS#error CONFIG_PGTABLE_LEVELS is not consistent with __PAGETABLE_{P4D,PUD,PMD}_FOLDED#endif /* * On almost all architectures and configurations, 0 can be used as the * upper ceiling to free_pgtables(): on many architectures it has the same * effect as using TASK_SIZE.  However, there is one configuration which * must impose a more careful limit, to avoid freeing kernel pgtables. */#ifndef USER_PGTABLES_CEILING#define USER_PGTABLES_CEILING	0UL#endif #ifndef __HAVE_ARCH_PTEP_SET_ACCESS_FLAGSextern int ptep_set_access_flags(struct vm_area_struct *vma,				 unsigned long address, pte_t *ptep,				 pte_t entry, int dirty);#endif #ifndef __HAVE_ARCH_PMDP_SET_ACCESS_FLAGS#ifdef CONFIG_TRANSPARENT_HUGEPAGEextern int pmdp_set_access_flags(struct vm_area_struct *vma,				 unsigned long address, pmd_t *pmdp,				 pmd_t entry, int dirty);extern int pudp_set_access_flags(struct vm_area_struct *vma,				 unsigned long address, pud_t *pudp,				 pud_t entry, int dirty);#elsestatic inline int pmdp_set_access_flags(struct vm_area_struct *vma,					unsigned long address, pmd_t *pmdp,					pmd_t entry, int dirty){	BUILD_BUG();	return 0;}static inline int pudp_set_access_flags(struct vm_area_struct *vma,					unsigned long address, pud_t *pudp,					pud_t entry, int dirty){	BUILD_BUG();	return 0;}#endif /* CONFIG_TRANSPARENT_HUGEPAGE */#endif #ifndef __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNGstatic inline int ptep_test_and_clear_young(struct vm_area_struct *vma,					    unsigned long address,					    pte_t *ptep){	pte_t pte = *ptep;	int r = 1;	if (!pte_young(pte))		r = 0;	else		set_pte_at(vma->vm_mm, address, ptep, pte_mkold(pte));	return r;}#endif #ifndef __HAVE_ARCH_PMDP_TEST_AND_CLEAR_YOUNG#ifdef CONFIG_TRANSPARENT_HUGEPAGEstatic inline int pmdp_test_and_clear_young(struct vm_area_struct *vma,					    unsigned long address,					    pmd_t *pmdp){	pmd_t pmd = *pmdp;	int r = 1;	if (!pmd_young(pmd))		r = 0;	else		set_pmd_at(vma->vm_mm, address, pmdp, pmd_mkold(pmd));	return r;}#elsestatic inline int pmdp_test_and_clear_young(struct vm_area_struct *vma,					    unsigned long address,					    pmd_t *pmdp){	BUILD_BUG();	return 0;}#endif /* CONFIG_TRANSPARENT_HUGEPAGE */#endif #ifndef __HAVE_ARCH_PTEP_CLEAR_YOUNG_FLUSHint ptep_clear_flush_young(struct vm_area_struct *vma,			   unsigned long address, pte_t *ptep);#endif #ifndef __HAVE_ARCH_PMDP_CLEAR_YOUNG_FLUSH#ifdef CONFIG_TRANSPARENT_HUGEPAGEextern int pmdp_clear_flush_young(struct vm_area_struct *vma,				  unsigned long address, pmd_t *pmdp);#else/* * Despite relevant to THP only, this API is called from generic rmap code * under PageTransHuge(), hence needs a dummy implementation for !THP */static inline int pmdp_clear_flush_young(struct vm_area_struct *vma,					 unsigned long address, pmd_t *pmdp){	BUILD_BUG();	return 0;}#endif /* CONFIG_TRANSPARENT_HUGEPAGE */#endif #ifndef __HAVE_ARCH_PTEP_GET_AND_CLEARstatic inline pte_t ptep_get_and_clear(struct mm_struct *mm,				       unsigned long address,				       pte_t *ptep){	pte_t pte = *ptep;	pte_clear(mm, address, ptep);	return pte;}#endif #ifdef CONFIG_TRANSPARENT_HUGEPAGE#ifndef __HAVE_ARCH_PMDP_HUGE_GET_AND_CLEARstatic inline pmd_t pmdp_huge_get_and_clear(struct mm_struct *mm,					    unsigned long address,					    pmd_t *pmdp){	pmd_t pmd = *pmdp;	pmd_clear(pmdp);	return pmd;}#endif /* __HAVE_ARCH_PMDP_HUGE_GET_AND_CLEAR */#ifndef __HAVE_ARCH_PUDP_HUGE_GET_AND_CLEARstatic inline pud_t pudp_huge_get_and_clear(struct mm_struct *mm,					    unsigned long address,					    pud_t *pudp){	pud_t pud = *pudp; 	pud_clear(pudp);	return pud;}#endif /* __HAVE_ARCH_PUDP_HUGE_GET_AND_CLEAR */#endif /* CONFIG_TRANSPARENT_HUGEPAGE */ #ifdef CONFIG_TRANSPARENT_HUGEPAGE#ifndef __HAVE_ARCH_PMDP_HUGE_GET_AND_CLEAR_FULLstatic inline pmd_t pmdp_huge_get_and_clear_full(struct mm_struct *mm,					    unsigned long address, pmd_t *pmdp,					    int full){	return pmdp_huge_get_and_clear(mm, address, pmdp);}#endif #ifndef __HAVE_ARCH_PUDP_HUGE_GET_AND_CLEAR_FULLstatic inline pud_t pudp_huge_get_and_clear_full(struct mm_struct *mm,					    unsigned long address, pud_t *pudp,					    int full){	return pudp_huge_get_and_clear(mm, address, pudp);}#endif#endif /* CONFIG_TRANSPARENT_HUGEPAGE */ #ifndef __HAVE_ARCH_PTEP_GET_AND_CLEAR_FULLstatic inline pte_t ptep_get_and_clear_full(struct mm_struct *mm,					    unsigned long address, pte_t *ptep,					    int full){	pte_t pte;	pte = ptep_get_and_clear(mm, address, ptep);	return pte;}#endif /* * Some architectures may be able to avoid expensive synchronization * primitives when modifications are made to PTE's which are already * not present, or in the process of an address space destruction. */#ifndef __HAVE_ARCH_PTE_CLEAR_NOT_PRESENT_FULLstatic inline void pte_clear_not_present_full(struct mm_struct *mm,					      unsigned long address,					      pte_t *ptep,					      int full){	pte_clear(mm, address, ptep);}#endif #ifndef __HAVE_ARCH_PTEP_CLEAR_FLUSHextern pte_t ptep_clear_flush(struct vm_area_struct *vma,			      unsigned long address,			      pte_t *ptep);#endif #ifndef __HAVE_ARCH_PMDP_HUGE_CLEAR_FLUSHextern pmd_t pmdp_huge_clear_flush(struct vm_area_struct *vma,			      unsigned long address,			      pmd_t *pmdp);extern pud_t pudp_huge_clear_flush(struct vm_area_struct *vma,			      unsigned long address,			      pud_t *pudp);#endif #ifndef __HAVE_ARCH_PTEP_SET_WRPROTECTstruct mm_struct;static inline void ptep_set_wrprotect(struct mm_struct *mm, unsigned long address, pte_t *ptep){	pte_t old_pte = *ptep;	set_pte_at(mm, address, ptep, pte_wrprotect(old_pte));}#endif #ifndef pte_savedwrite#define pte_savedwrite pte_write#endif #ifndef pte_mk_savedwrite#define pte_mk_savedwrite pte_mkwrite#endif #ifndef pte_clear_savedwrite#define pte_clear_savedwrite pte_wrprotect#endif #ifndef pmd_savedwrite#define pmd_savedwrite pmd_write#endif #ifndef pmd_mk_savedwrite#define pmd_mk_savedwrite pmd_mkwrite#endif #ifndef pmd_clear_savedwrite#define pmd_clear_savedwrite pmd_wrprotect#endif #ifndef __HAVE_ARCH_PMDP_SET_WRPROTECT#ifdef CONFIG_TRANSPARENT_HUGEPAGEstatic inline void pmdp_set_wrprotect(struct mm_struct *mm,				      unsigned long address, pmd_t *pmdp){	pmd_t old_pmd = *pmdp;	set_pmd_at(mm, address, pmdp, pmd_wrprotect(old_pmd));}#elsestatic inline void pmdp_set_wrprotect(struct mm_struct *mm,				      unsigned long address, pmd_t *pmdp){	BUILD_BUG();}#endif /* CONFIG_TRANSPARENT_HUGEPAGE */#endif#ifndef __HAVE_ARCH_PUDP_SET_WRPROTECT#ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUDstatic inline void pudp_set_wrprotect(struct mm_struct *mm,				      unsigned long address, pud_t *pudp){	pud_t old_pud = *pudp; 	set_pud_at(mm, address, pudp, pud_wrprotect(old_pud));}#elsestatic inline void pudp_set_wrprotect(struct mm_struct *mm,				      unsigned long address, pud_t *pudp){	BUILD_BUG();}#endif /* CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD */#endif #ifndef pmdp_collapse_flush#ifdef CONFIG_TRANSPARENT_HUGEPAGEextern pmd_t pmdp_collapse_flush(struct vm_area_struct *vma,				 unsigned long address, pmd_t *pmdp);#elsestatic inline pmd_t pmdp_collapse_flush(struct vm_area_struct *vma,					unsigned long address,					pmd_t *pmdp){	BUILD_BUG();	return *pmdp;}#define pmdp_collapse_flush pmdp_collapse_flush#endif /* CONFIG_TRANSPARENT_HUGEPAGE */#endif #ifndef __HAVE_ARCH_PGTABLE_DEPOSITextern void pgtable_trans_huge_deposit(struct mm_struct *mm, pmd_t *pmdp,				       pgtable_t pgtable);#endif #ifndef __HAVE_ARCH_PGTABLE_WITHDRAWextern pgtable_t pgtable_trans_huge_withdraw(struct mm_struct *mm, pmd_t *pmdp);#endif #ifdef CONFIG_TRANSPARENT_HUGEPAGE/* * This is an implementation of pmdp_establish() that is only suitable for an * architecture that doesn't have hardware dirty/accessed bits. In this case we * can't race with CPU which sets these bits and non-atomic aproach is fine. */static inline pmd_t generic_pmdp_establish(struct vm_area_struct *vma,		unsigned long address, pmd_t *pmdp, pmd_t pmd){	pmd_t old_pmd = *pmdp;	set_pmd_at(vma->vm_mm, address, pmdp, pmd);	return old_pmd;}#endif #ifndef __HAVE_ARCH_PMDP_INVALIDATEextern pmd_t pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,			    pmd_t *pmdp);#endif #ifndef __HAVE_ARCH_PTE_SAMEstatic inline int pte_same(pte_t pte_a, pte_t pte_b){	return pte_val(pte_a) == pte_val(pte_b);}#endif #ifndef __HAVE_ARCH_PTE_UNUSED/* * Some architectures provide facilities to virtualization guests * so that they can flag allocated pages as unused. This allows the * host to transparently reclaim unused pages. This function returns * whether the pte's page is unused. */static inline int pte_unused(pte_t pte){	return 0;}#endif #ifndef pte_access_permitted#define pte_access_permitted(pte, write) \	(pte_present(pte) && (!(write) || pte_write(pte)))#endif #ifndef pmd_access_permitted#define pmd_access_permitted(pmd, write) \	(pmd_present(pmd) && (!(write) || pmd_write(pmd)))#endif #ifndef pud_access_permitted#define pud_access_permitted(pud, write) \	(pud_present(pud) && (!(write) || pud_write(pud)))#endif #ifndef p4d_access_permitted#define p4d_access_permitted(p4d, write) \	(p4d_present(p4d) && (!(write) || p4d_write(p4d)))#endif #ifndef pgd_access_permitted#define pgd_access_permitted(pgd, write) \	(pgd_present(pgd) && (!(write) || pgd_write(pgd)))#endif #ifndef __HAVE_ARCH_PMD_SAMEstatic inline int pmd_same(pmd_t pmd_a, pmd_t pmd_b){	return pmd_val(pmd_a) == pmd_val(pmd_b);} static inline int pud_same(pud_t pud_a, pud_t pud_b){	return pud_val(pud_a) == pud_val(pud_b);}#endif #ifndef __HAVE_ARCH_P4D_SAMEstatic inline int p4d_same(p4d_t p4d_a, p4d_t p4d_b){	return p4d_val(p4d_a) == p4d_val(p4d_b);}#endif #ifndef __HAVE_ARCH_PGD_SAMEstatic inline int pgd_same(pgd_t pgd_a, pgd_t pgd_b){	return pgd_val(pgd_a) == pgd_val(pgd_b);}#endif /* * Use set_p*_safe(), and elide TLB flushing, when confident that *no* * TLB flush will be required as a result of the "set". For example, use * in scenarios where it is known ahead of time that the routine is * setting non-present entries, or re-setting an existing entry to the * same value. Otherwise, use the typical "set" helpers and flush the * TLB. */#define set_pte_safe(ptep, pte) \({ \	WARN_ON_ONCE(pte_present(*ptep) && !pte_same(*ptep, pte)); \	set_pte(ptep, pte); \}) #define set_pmd_safe(pmdp, pmd) \({ \	WARN_ON_ONCE(pmd_present(*pmdp) && !pmd_same(*pmdp, pmd)); \	set_pmd(pmdp, pmd); \}) #define set_pud_safe(pudp, pud) \({ \	WARN_ON_ONCE(pud_present(*pudp) && !pud_same(*pudp, pud)); \	set_pud(pudp, pud); \}) #define set_p4d_safe(p4dp, p4d) \({ \	WARN_ON_ONCE(p4d_present(*p4dp) && !p4d_same(*p4dp, p4d)); \	set_p4d(p4dp, p4d); \}) #define set_pgd_safe(pgdp, pgd) \({ \	WARN_ON_ONCE(pgd_present(*pgdp) && !pgd_same(*pgdp, pgd)); \	set_pgd(pgdp, pgd); \}) #ifndef __HAVE_ARCH_DO_SWAP_PAGE/* * Some architectures support metadata associated with a page. When a * page is being swapped out, this metadata must be saved so it can be * restored when the page is swapped back in. SPARC M7 and newer * processors support an ADI (Application Data Integrity) tag for the * page as metadata for the page. arch_do_swap_page() can restore this * metadata when a page is swapped back in. */static inline void arch_do_swap_page(struct mm_struct *mm,				     struct vm_area_struct *vma,				     unsigned long addr,				     pte_t pte, pte_t oldpte){ }#endif #ifndef __HAVE_ARCH_UNMAP_ONE/* * Some architectures support metadata associated with a page. When a * page is being swapped out, this metadata must be saved so it can be * restored when the page is swapped back in. SPARC M7 and newer * processors support an ADI (Application Data Integrity) tag for the * page as metadata for the page. arch_unmap_one() can save this * metadata on a swap-out of a page. */static inline int arch_unmap_one(struct mm_struct *mm,				  struct vm_area_struct *vma,				  unsigned long addr,				  pte_t orig_pte){	return 0;}#endif #ifndef __HAVE_ARCH_PGD_OFFSET_GATE#define pgd_offset_gate(mm, addr)	pgd_offset(mm, addr)#endif #ifndef __HAVE_ARCH_MOVE_PTE#define move_pte(pte, prot, old_addr, new_addr)	(pte)#endif #ifndef pte_accessible# define pte_accessible(mm, pte)	((void)(pte), 1)#endif #ifndef flush_tlb_fix_spurious_fault#define flush_tlb_fix_spurious_fault(vma, address) flush_tlb_page(vma, address)#endif #ifndef pgprot_noncached#define pgprot_noncached(prot)	(prot)#endif #ifndef pgprot_writecombine#define pgprot_writecombine pgprot_noncached#endif 

Lines 1–500 of 1190. Load more