include/asm-x86_64/pgtable.h

   1 #ifndef _X86_64_PGTABLE_H
   2 #define _X86_64_PGTABLE_H
   3
   4 /*
   5  * This file contains the functions and defines necessary to modify and use
   6  * the x86-64 page table tree.
   7  *
   8  * x86-64 has a 4 level table setup. Generic linux MM only supports
   9  * three levels. The fourth level is currently a single static page that
  10  * is shared by everybody and just contains a pointer to the current
  11  * three level page setup on the beginning and some kernel mappings at
  12  * the end. For more details see Documentation/x86_64/mm.txt
  13  */
  14 #include <asm/processor.h>
  15 #include <asm/fixmap.h>
  16 #include <asm/bitops.h>
  17 #include <linux/threads.h>
  18 #include <asm/pda.h>
  19
  20 extern pgd_t level3_kernel_pgt[512];
  21 extern pgd_t level3_physmem_pgt[512];
  22 extern pgd_t level3_ident_pgt[512];
  23 extern pmd_t level2_kernel_pgt[512];
  24 extern pml4_t init_level4_pgt[];
  25 extern pgd_t boot_vmalloc_pgt[];
  26 extern unsigned long __supported_pte_mask;
  27
  28 #define swapper_pg_dir NULL
  29
  30 extern void paging_init(void);
  31 extern void clear_kernel_mapping(unsigned long addr, unsigned long size);
  32
  33 extern unsigned long pgkern_mask;
  34
  35 /*
  36  * ZERO_PAGE is a global shared page that is always zero: used
  37  * for zero-mapped memory areas etc..
  38  */
  39 extern unsigned long empty_zero_page[PAGE_SIZE/sizeof(unsigned long)];
  40 #define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page))
  41
  42 #define PML4_SHIFT      39
  43 #define PTRS_PER_PML4   512
  44
  45 /*
  46  * PGDIR_SHIFT determines what a top-level page table entry can map
  47  */
  48 #define PGDIR_SHIFT     30
  49 #define PTRS_PER_PGD    512
  50
  51 /*
  52  * PMD_SHIFT determines the size of the area a middle-level
  53  * page table can map
  54  */
  55 #define PMD_SHIFT       21
  56 #define PTRS_PER_PMD    512
  57
  58 /*
  59  * entries per page directory level
  60  */
  61 #define PTRS_PER_PTE    512
  62
  63 #define pte_ERROR(e) \
  64         printk("%s:%d: bad pte %p(%016lx).\n", __FILE__, __LINE__, &(e), pte_val(e))
  65 #define pmd_ERROR(e) \
  66         printk("%s:%d: bad pmd %p(%016lx).\n", __FILE__, __LINE__, &(e), pmd_val(e))
  67 #define pgd_ERROR(e) \
  68         printk("%s:%d: bad pgd %p(%016lx).\n", __FILE__, __LINE__, &(e), pgd_val(e))
  69
  70
  71 #define pml4_none(x)    (!pml4_val(x))
  72 #define pgd_none(x)     (!pgd_val(x))
  73
  74 extern inline int pgd_present(pgd_t pgd)        { return !pgd_none(pgd); }
  75
  76 static inline void set_pte(pte_t *dst, pte_t val)
  77 {
  78         pte_val(*dst) = pte_val(val);
  79 }
  80
  81 static inline void set_pmd(pmd_t *dst, pmd_t val)
  82 {
  83         pmd_val(*dst) = pmd_val(val);
  84 }
  85
  86 static inline void set_pgd(pgd_t *dst, pgd_t val)
  87 {
  88         pgd_val(*dst) = pgd_val(val);
  89 }
  90
  91 extern inline void pgd_clear (pgd_t * pgd)
  92 {
  93         set_pgd(pgd, __pgd(0));
  94 }
  95
  96 static inline void set_pml4(pml4_t *dst, pml4_t val)
  97 {
  98         pml4_val(*dst) = pml4_val(val);
  99 }
 100
 101 #define pgd_page(pgd) \
 102 ((unsigned long) __va(pgd_val(pgd) & PHYSICAL_PAGE_MASK))
 103
 104 #define ptep_get_and_clear(xp)  __pte(xchg(&(xp)->pte, 0))
 105 #define pte_same(a, b)          ((a).pte == (b).pte)
 106
 107 #define PML4_SIZE       (1UL << PML4_SHIFT)
 108 #define PML4_MASK       (~(PML4_SIZE-1))
 109 #define PMD_SIZE        (1UL << PMD_SHIFT)
 110 #define PMD_MASK        (~(PMD_SIZE-1))
 111 #define PGDIR_SIZE      (1UL << PGDIR_SHIFT)
 112 #define PGDIR_MASK      (~(PGDIR_SIZE-1))
 113
 114 #define USER_PTRS_PER_PGD       (TASK_SIZE/PGDIR_SIZE)
 115 #define FIRST_USER_PGD_NR       0
 116
 117 #define USER_PGD_PTRS (PAGE_OFFSET >> PGDIR_SHIFT)
 118 #define KERNEL_PGD_PTRS (PTRS_PER_PGD-USER_PGD_PTRS)
 119
 120 #define TWOLEVEL_PGDIR_SHIFT    20
 121 #define BOOT_USER_L4_PTRS 1
 122 #define BOOT_KERNEL_L4_PTRS 511 /* But we will do it in 4rd level */
 123
 124
 125
 126 #ifndef __ASSEMBLY__
 127 #define VMALLOC_START    0xffffff0000000000UL
 128 #define VMALLOC_END      0xffffff7fffffffffUL
 129 #define MODULES_VADDR    0xffffffffa0000000UL
 130 #define MODULES_END      0xffffffffafffffffUL
 131 #define MODULES_LEN   (MODULES_END - MODULES_VADDR)
 132
 133 #define IOMAP_START      0xfffffe8000000000UL
 134
 135 #define _PAGE_BIT_PRESENT       0
 136 #define _PAGE_BIT_RW            1
 137 #define _PAGE_BIT_USER          2
 138 #define _PAGE_BIT_PWT           3
 139 #define _PAGE_BIT_PCD           4
 140 #define _PAGE_BIT_ACCESSED      5
 141 #define _PAGE_BIT_DIRTY         6
 142 #define _PAGE_BIT_PSE           7       /* 4 MB (or 2MB) page */
 143 #define _PAGE_BIT_GLOBAL        8       /* Global TLB entry PPro+ */
 144 #define _PAGE_BIT_NX           63       /* No execute: only valid after cpuid check */
 145
 146 #define _PAGE_PRESENT   0x001
 147 #define _PAGE_RW        0x002
 148 #define _PAGE_USER      0x004
 149 #define _PAGE_PWT       0x008
 150 #define _PAGE_PCD       0x010
 151 #define _PAGE_ACCESSED  0x020
 152 #define _PAGE_DIRTY     0x040
 153 #define _PAGE_PSE       0x080   /* 2MB page */
 154 #define _PAGE_FILE      0x040   /* set:pagecache, unset:swap */
 155 #define _PAGE_GLOBAL    0x100   /* Global TLB entry */
 156
 157 #define _PAGE_PROTNONE  0x080   /* If not present */
 158 #define _PAGE_NX        (1UL<<_PAGE_BIT_NX)
 159
 160 #define _PAGE_TABLE     (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
 161 #define _KERNPG_TABLE   (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
 162
 163 #define _PAGE_CHG_MASK  (PTE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
 164
 165 #define PAGE_NONE       __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED)
 166 #define PAGE_SHARED     __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_NX)
 167 #define PAGE_SHARED_EXEC __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
 168 #define PAGE_COPY_NOEXEC __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_NX)
 169 #define PAGE_COPY PAGE_COPY_NOEXEC
 170 #define PAGE_COPY_EXEC __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
 171 #define PAGE_READONLY   __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_NX)
 172 #define PAGE_READONLY_EXEC __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
 173 #define __PAGE_KERNEL \
 174         (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_NX)
 175 #define __PAGE_KERNEL_EXEC \
 176         (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
 177 #define __PAGE_KERNEL_NOCACHE \
 178         (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_PCD | _PAGE_ACCESSED | _PAGE_NX)
 179 #define __PAGE_KERNEL_RO \
 180         (_PAGE_PRESENT | _PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_NX)
 181 #define __PAGE_KERNEL_VSYSCALL \
 182         (_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
 183 #define __PAGE_KERNEL_VSYSCALL_NOCACHE \
 184         (_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_PCD)
 185 #define __PAGE_KERNEL_LARGE \
 186         (__PAGE_KERNEL | _PAGE_PSE)
 187
 188 #define MAKE_GLOBAL(x) __pgprot((x) | _PAGE_GLOBAL)
 189
 190 #define PAGE_KERNEL MAKE_GLOBAL(__PAGE_KERNEL)
 191 #define PAGE_KERNEL_EXEC MAKE_GLOBAL(__PAGE_KERNEL_EXEC)
 192 #define PAGE_KERNEL_RO MAKE_GLOBAL(__PAGE_KERNEL_RO)
 193 #define PAGE_KERNEL_NOCACHE MAKE_GLOBAL(__PAGE_KERNEL_NOCACHE)
 194 #define PAGE_KERNEL_VSYSCALL MAKE_GLOBAL(__PAGE_KERNEL_VSYSCALL)
 195 #define PAGE_KERNEL_LARGE MAKE_GLOBAL(__PAGE_KERNEL_LARGE)
 196 #define PAGE_KERNEL_VSYSCALL_NOCACHE MAKE_GLOBAL(__PAGE_KERNEL_VSYSCALL_NOCACHE)
 197
 198 /*         xwr */
 199 #define __P000  PAGE_NONE
 200 #define __P001  PAGE_READONLY
 201 #define __P010  PAGE_COPY
 202 #define __P011  PAGE_COPY
 203 #define __P100  PAGE_READONLY_EXEC
 204 #define __P101  PAGE_READONLY_EXEC
 205 #define __P110  PAGE_COPY_EXEC
 206 #define __P111  PAGE_COPY_EXEC
 207
 208 #define __S000  PAGE_NONE
 209 #define __S001  PAGE_READONLY
 210 #define __S010  PAGE_SHARED
 211 #define __S011  PAGE_SHARED
 212 #define __S100  PAGE_READONLY_EXEC
 213 #define __S101  PAGE_READONLY_EXEC
 214 #define __S110  PAGE_SHARED_EXEC
 215 #define __S111  PAGE_SHARED_EXEC
 216
 217 static inline unsigned long pgd_bad(pgd_t pgd)
 218 {
 219        unsigned long val = pgd_val(pgd);
 220        val &= ~PTE_MASK;
 221        val &= ~(_PAGE_USER | _PAGE_DIRTY);
 222        return val & ~(_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED);
 223 }
 224
 225 #define pte_none(x)     (!pte_val(x))
 226 #define pte_present(x)  (pte_val(x) & (_PAGE_PRESENT | _PAGE_PROTNONE))
 227 #define pte_clear(xp)   do { set_pte(xp, __pte(0)); } while (0)
 228
 229 #define pages_to_mb(x) ((x) >> (20-PAGE_SHIFT)) /* FIXME: is this
 230                                                    right? */
 231 #define pte_page(x)     pfn_to_page(pte_pfn(x))
 232 #define pte_pfn(x)  ((pte_val(x) >> PAGE_SHIFT) & __PHYSICAL_MASK)
 233
 234 static inline pte_t pfn_pte(unsigned long page_nr, pgprot_t pgprot)
 235 {
 236         pte_t pte;
 237         pte_val(pte) = (page_nr << PAGE_SHIFT);
 238         pte_val(pte) |= pgprot_val(pgprot);
 239         pte_val(pte) &= __supported_pte_mask;
 240         return pte;
 241 }
 242
 243 /*
 244  * The following only work if pte_present() is true.
 245  * Undefined behaviour if not..
 246  */
 247 static inline int pte_user(pte_t pte)           { return pte_val(pte) & _PAGE_USER; }
 248 extern inline int pte_read(pte_t pte)           { return pte_val(pte) & _PAGE_USER; }
 249 extern inline int pte_exec(pte_t pte)           { return pte_val(pte) & _PAGE_USER; }
 250 extern inline int pte_dirty(pte_t pte)          { return pte_val(pte) & _PAGE_DIRTY; }
 251 extern inline int pte_young(pte_t pte)          { return pte_val(pte) & _PAGE_ACCESSED; }
 252 extern inline int pte_write(pte_t pte)          { return pte_val(pte) & _PAGE_RW; }
 253 static inline int pte_file(pte_t pte)           { return pte_val(pte) & _PAGE_FILE; }
 254
 255 extern inline pte_t pte_rdprotect(pte_t pte)    { set_pte(&pte, __pte(pte_val(pte) & ~_PAGE_USER)); return pte; }
 256 extern inline pte_t pte_exprotect(pte_t pte)    { set_pte(&pte, __pte(pte_val(pte) & ~_PAGE_USER)); return pte; }
 257 extern inline pte_t pte_mkclean(pte_t pte)      { set_pte(&pte, __pte(pte_val(pte) & ~_PAGE_DIRTY)); return pte; }
 258 extern inline pte_t pte_mkold(pte_t pte)        { set_pte(&pte, __pte(pte_val(pte) & ~_PAGE_ACCESSED)); return pte; }
 259 extern inline pte_t pte_wrprotect(pte_t pte)    { set_pte(&pte, __pte(pte_val(pte) & ~_PAGE_RW)); return pte; }
 260 extern inline pte_t pte_mkread(pte_t pte)       { set_pte(&pte, __pte(pte_val(pte) | _PAGE_USER)); return pte; }
 261 extern inline pte_t pte_mkexec(pte_t pte)       { set_pte(&pte, __pte(pte_val(pte) | _PAGE_USER)); return pte; }
 262 extern inline pte_t pte_mkdirty(pte_t pte)      { set_pte(&pte, __pte(pte_val(pte) | _PAGE_DIRTY)); return pte; }
 263 extern inline pte_t pte_mkyoung(pte_t pte)      { set_pte(&pte, __pte(pte_val(pte) | _PAGE_ACCESSED)); return pte; }
 264 extern inline pte_t pte_mkwrite(pte_t pte)      { set_pte(&pte, __pte(pte_val(pte) | _PAGE_RW)); return pte; }
 265
 266 static inline int ptep_test_and_clear_dirty(pte_t *ptep)
 267 {
 268         if (!pte_dirty(*ptep))
 269                 return 0;
 270         return test_and_clear_bit(_PAGE_BIT_DIRTY, ptep);
 271 }
 272
 273 static inline int ptep_test_and_clear_young(pte_t *ptep)
 274 {
 275         if (!pte_young(*ptep))
 276                 return 0;
 277         return test_and_clear_bit(_PAGE_BIT_ACCESSED, ptep);
 278 }
 279
 280 static inline void ptep_set_wrprotect(pte_t *ptep)              { clear_bit(_PAGE_BIT_RW, ptep); }
 281 static inline void ptep_mkdirty(pte_t *ptep)                    { set_bit(_PAGE_BIT_DIRTY, ptep); }
 282
 283 /*
 284  * Macro to mark a page protection value as "uncacheable".
 285  */
 286 #define pgprot_noncached(prot)  (__pgprot(pgprot_val(prot) | _PAGE_PCD | _PAGE_PWT))
 287
 288 #define __LARGE_PTE (_PAGE_PSE|_PAGE_PRESENT)
 289 static inline int pmd_large(pmd_t pte) {
 290         return (pmd_val(pte) & __LARGE_PTE) == __LARGE_PTE;
 291 }
 292
 293
 294 /*
 295  * Conversion functions: convert a page and protection to a page entry,
 296  * and a page entry and page directory to the page they refer to.
 297  */
 298
 299 #define page_pte(page) page_pte_prot(page, __pgprot(0))
 300
 301 /*
 302  * Level 4 access.
 303  * Never use these in the common code.
 304  */
 305 #define pml4_page(pml4) ((unsigned long) __va(pml4_val(pml4) & PTE_MASK))
 306 #define pml4_index(address) ((address >> PML4_SHIFT) & (PTRS_PER_PML4-1))
 307 #define pml4_offset_k(address) (init_level4_pgt + pml4_index(address))
 308 #define pml4_present(pml4) (pml4_val(pml4) & _PAGE_PRESENT)
 309 #define mk_kernel_pml4(address) ((pml4_t){ (address) | _KERNPG_TABLE })
 310 #define level3_offset_k(dir, address) ((pgd_t *) pml4_page(*(dir)) + pgd_index(address))
 311
 312 /* PGD - Level3 access */
 313 /* to find an entry in a page-table-directory. */
 314 #define pgd_index(address) ((address >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
 315 static inline pgd_t *__pgd_offset_k(pgd_t *pgd, unsigned long address)
 316 {
 317         return pgd + pgd_index(address);
 318 }
 319
 320 /* Find correct pgd via the hidden fourth level page level: */
 321
 322 /* This accesses the reference page table of the boot cpu.
 323    Other CPUs get synced lazily via the page fault handler. */
 324 static inline pgd_t *pgd_offset_k(unsigned long address)
 325 {
 326         unsigned long addr;
 327
 328         addr = pml4_val(init_level4_pgt[pml4_index(address)]);
 329         addr &= PHYSICAL_PAGE_MASK;
 330         return __pgd_offset_k((pgd_t *)__va(addr), address);
 331 }
 332
 333 /* Access the pgd of the page table as seen by the current CPU. */
 334 static inline pgd_t *current_pgd_offset_k(unsigned long address)
 335 {
 336         unsigned long addr;
 337
 338         addr = read_pda(level4_pgt)[pml4_index(address)];
 339         addr &= PHYSICAL_PAGE_MASK;
 340         return __pgd_offset_k((pgd_t *)__va(addr), address);
 341 }
 342
 343 #define pgd_offset(mm, address) ((mm)->pgd+pgd_index(address))
 344
 345 /* PMD  - Level 2 access */
 346 #define pmd_page_kernel(pmd) ((unsigned long) __va(pmd_val(pmd) & PTE_MASK))
 347 #define pmd_page(pmd)           (pfn_to_page(pmd_val(pmd) >> PAGE_SHIFT))
 348
 349 #define pmd_index(address) (((address) >> PMD_SHIFT) & (PTRS_PER_PMD-1))
 350 #define pmd_offset(dir, address) ((pmd_t *) pgd_page(*(dir)) + \
 351                         pmd_index(address))
 352 #define pmd_none(x)     (!pmd_val(x))
 353 #define pmd_present(x)  (pmd_val(x) & _PAGE_PRESENT)
 354 #define pmd_clear(xp)   do { set_pmd(xp, __pmd(0)); } while (0)
 355 #define pmd_bad(x)      ((pmd_val(x) & (~PTE_MASK & ~_PAGE_USER)) != _KERNPG_TABLE )
 356 #define pfn_pmd(nr,prot) (__pmd(((nr) << PAGE_SHIFT) | pgprot_val(prot)))
 357 #define pmd_pfn(x)  ((pmd_val(x) >> PAGE_SHIFT) & __PHYSICAL_MASK)
 358
 359 #define pte_to_pgoff(pte) ((pte_val(pte) & PHYSICAL_PAGE_MASK) >> PAGE_SHIFT)
 360 #define pgoff_to_pte(off) ((pte_t) { ((off) << PAGE_SHIFT) | _PAGE_FILE })
 361 #define PTE_FILE_MAX_BITS __PHYSICAL_MASK_SHIFT
 362
 363 /* PTE - Level 1 access. */
 364
 365 /* page, protection -> pte */
 366 #define mk_pte(page, pgprot)    pfn_pte(page_to_pfn(page), (pgprot))
 367 #define mk_pte_huge(entry) (pte_val(entry) |= _PAGE_PRESENT | _PAGE_PSE)
 368
 369 /* physical address -> PTE */
 370 static inline pte_t mk_pte_phys(unsigned long physpage, pgprot_t pgprot)
 371 {
 372         pte_t pte;
 373         pte_val(pte) = physpage | pgprot_val(pgprot);
 374         return pte;
 375 }
 376
 377 /* Change flags of a PTE */
 378 extern inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 379 {
 380         pte_val(pte) &= _PAGE_CHG_MASK;
 381         pte_val(pte) |= pgprot_val(newprot);
 382         pte_val(pte) &= __supported_pte_mask;
 383        return pte;
 384 }
 385
 386 #define pte_index(address) \
 387                 ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
 388 #define pte_offset_kernel(dir, address) ((pte_t *) pmd_page_kernel(*(dir)) + \
 389                         pte_index(address))
 390
 391 /* x86-64 always has all page tables mapped. */
 392 #define pte_offset_map(dir,address) pte_offset_kernel(dir,address)
 393 #define pte_offset_map_nested(dir,address) pte_offset_kernel(dir,address)
 394 #define pte_unmap(pte) /* NOP */
 395 #define pte_unmap_nested(pte) /* NOP */
 396
 397 #define update_mmu_cache(vma,address,pte) do { } while (0)
 398
 399 /* We only update the dirty/accessed state if we set
 400  * the dirty bit by hand in the kernel, since the hardware
 401  * will do the accessed bit for us, and we don't want to
 402  * race with other CPU's that might be updating the dirty
 403  * bit at the same time. */
 404 #define  __HAVE_ARCH_PTEP_SET_ACCESS_FLAGS
 405 #define ptep_set_access_flags(__vma, __address, __ptep, __entry, __dirty) \
 406         do {                                                              \
 407                 if (__dirty) {                                            \
 408                         set_pte(__ptep, __entry);                         \
 409                         flush_tlb_page(__vma, __address);                 \
 410                 }                                                         \
 411         } while (0)
 412
 413 /* Encode and de-code a swap entry */
 414 #define __swp_type(x)                   (((x).val >> 1) & 0x3f)
 415 #define __swp_offset(x)                 ((x).val >> 8)
 416 #define __swp_entry(type, offset)       ((swp_entry_t) { ((type) << 1) | ((offset) << 8) })
 417 #define __pte_to_swp_entry(pte)         ((swp_entry_t) { pte_val(pte) })
 418 #define __swp_entry_to_pte(x)           ((pte_t) { (x).val })
 419
 420 #endif /* !__ASSEMBLY__ */
 421
 422 extern int kern_addr_valid(unsigned long addr);
 423
 424 #define io_remap_page_range remap_page_range
 425
 426 #define HAVE_ARCH_UNMAPPED_AREA
 427
 428 #define pgtable_cache_init()   do { } while (0)
 429 #define check_pgt_cache()      do { } while (0)
 430
 431 #define PAGE_AGP    PAGE_KERNEL_NOCACHE
 432 #define HAVE_PAGE_AGP 1
 433
 434 /* fs/proc/kcore.c */
 435 #define kc_vaddr_to_offset(v) ((v) & __VIRTUAL_MASK)
 436 #define kc_offset_to_vaddr(o) \
 437    (((o) & (1UL << (__VIRTUAL_MASK_SHIFT-1))) ? ((o) | (~__VIRTUAL_MASK)) : (o))
 438
 439 #define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG
 440 #define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_DIRTY
 441 #define __HAVE_ARCH_PTEP_GET_AND_CLEAR
 442 #define __HAVE_ARCH_PTEP_SET_WRPROTECT
 443 #define __HAVE_ARCH_PTEP_MKDIRTY
 444 #define __HAVE_ARCH_PTE_SAME
 445 #include <asm-generic/pgtable.h>
 446
 447 #endif /* _X86_64_PGTABLE_H */