#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 #ifndef __HAVE_ARCH_PMDP_INVALIDATEextern void pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,			    pmd_t *pmdp);#endif #ifndef __HAVE_ARCH_PMDP_HUGE_SPLIT_PREPAREstatic inline void pmdp_huge_split_prepare(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_SAME#ifdef CONFIG_TRANSPARENT_HUGEPAGEstatic 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);}#else /* CONFIG_TRANSPARENT_HUGEPAGE */static inline int pmd_same(pmd_t pmd_a, pmd_t pmd_b){	BUILD_BUG();	return 0;} static inline int pud_same(pud_t pud_a, pud_t pud_b){	BUILD_BUG();	return 0;}#endif /* CONFIG_TRANSPARENT_HUGEPAGE */#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 #ifndef pgprot_writethrough#define pgprot_writethrough pgprot_noncached#endif #ifndef pgprot_device#define pgprot_device pgprot_noncached#endif #ifndef pgprot_modify#define pgprot_modify pgprot_modifystatic inline pgprot_t pgprot_modify(pgprot_t oldprot, pgprot_t newprot){	if (pgprot_val(oldprot) == pgprot_val(pgprot_noncached(oldprot)))		newprot = pgprot_noncached(newprot);	if (pgprot_val(oldprot) == pgprot_val(pgprot_writecombine(oldprot)))		newprot = pgprot_writecombine(newprot);	if (pgprot_val(oldprot) == pgprot_val(pgprot_device(oldprot)))		newprot = pgprot_device(newprot);	return newprot;}#endif /* * When walking page tables, get the address of the next boundary, * or the end address of the range if that comes earlier.  Although no * vma end wraps to 0, rounded up __boundary may wrap to 0 throughout. */ #define pgd_addr_end(addr, end)						\({	unsigned long __boundary = ((addr) + PGDIR_SIZE) & PGDIR_MASK;	\	(__boundary - 1 < (end) - 1)? __boundary: (end);		\}) #ifndef p4d_addr_end#define p4d_addr_end(addr, end)						\({	unsigned long __boundary = ((addr) + P4D_SIZE) & P4D_MASK;	\	(__boundary - 1 < (end) - 1)? __boundary: (end);		\})#endif #ifndef pud_addr_end#define pud_addr_end(addr, end)						\({	unsigned long __boundary = ((addr) + PUD_SIZE) & PUD_MASK;	\	(__boundary - 1 < (end) - 1)? __boundary: (end);		\})#endif #ifndef pmd_addr_end#define pmd_addr_end(addr, end)						\({	unsigned long __boundary = ((addr) + PMD_SIZE) & PMD_MASK;	\	(__boundary - 1 < (end) - 1)? __boundary: (end);		\})#endif /* * When walking page tables, we usually want to skip any p?d_none entries; * and any p?d_bad entries - reporting the error before resetting to none. * Do the tests inline, but report and clear the bad entry in mm/memory.c. */void pgd_clear_bad(pgd_t *);void p4d_clear_bad(p4d_t *);void pud_clear_bad(pud_t *);void pmd_clear_bad(pmd_t *); static inline int pgd_none_or_clear_bad(pgd_t *pgd){	if (pgd_none(*pgd))		return 1;	if (unlikely(pgd_bad(*pgd))) {		pgd_clear_bad(pgd);		return 1;	}	return 0;} static inline int p4d_none_or_clear_bad(p4d_t *p4d){	if (p4d_none(*p4d))		return 1;	if (unlikely(p4d_bad(*p4d))) {		p4d_clear_bad(p4d);		return 1;

Lines 1–500 of 973. Load more