Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef _X86_64_PGTABLE_H |
| 2 | #define _X86_64_PGTABLE_H |
| 3 | |
Randy Dunlap | 6df95fd | 2007-05-08 00:31:11 -0700 | [diff] [blame] | 4 | #include <linux/const.h> |
Vivek Goyal | 9d291e7 | 2007-05-02 19:27:06 +0200 | [diff] [blame] | 5 | #ifndef __ASSEMBLY__ |
| 6 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | /* |
| 8 | * This file contains the functions and defines necessary to modify and use |
| 9 | * the x86-64 page table tree. |
| 10 | */ |
| 11 | #include <asm/processor.h> |
Jiri Slaby | 1977f03 | 2007-10-18 23:40:25 -0700 | [diff] [blame] | 12 | #include <linux/bitops.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <linux/threads.h> |
| 14 | #include <asm/pda.h> |
| 15 | |
| 16 | extern pud_t level3_kernel_pgt[512]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | extern pud_t level3_ident_pgt[512]; |
| 18 | extern pmd_t level2_kernel_pgt[512]; |
| 19 | extern pgd_t init_level4_pgt[]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | |
Linus Torvalds | e3ebadd | 2007-05-07 08:44:24 -0700 | [diff] [blame] | 21 | #define swapper_pg_dir init_level4_pgt |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | extern void paging_init(void); |
| 24 | extern void clear_kernel_mapping(unsigned long addr, unsigned long size); |
| 25 | |
Vivek Goyal | 9d291e7 | 2007-05-02 19:27:06 +0200 | [diff] [blame] | 26 | #endif /* !__ASSEMBLY__ */ |
| 27 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | /* |
| 29 | * PGDIR_SHIFT determines what a top-level page table entry can map |
| 30 | */ |
| 31 | #define PGDIR_SHIFT 39 |
| 32 | #define PTRS_PER_PGD 512 |
| 33 | |
| 34 | /* |
| 35 | * 3rd level page |
| 36 | */ |
| 37 | #define PUD_SHIFT 30 |
| 38 | #define PTRS_PER_PUD 512 |
| 39 | |
| 40 | /* |
| 41 | * PMD_SHIFT determines the size of the area a middle-level |
| 42 | * page table can map |
| 43 | */ |
| 44 | #define PMD_SHIFT 21 |
| 45 | #define PTRS_PER_PMD 512 |
| 46 | |
| 47 | /* |
| 48 | * entries per page directory level |
| 49 | */ |
| 50 | #define PTRS_PER_PTE 512 |
| 51 | |
Vivek Goyal | 9d291e7 | 2007-05-02 19:27:06 +0200 | [diff] [blame] | 52 | #ifndef __ASSEMBLY__ |
| 53 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | #define pte_ERROR(e) \ |
| 55 | printk("%s:%d: bad pte %p(%016lx).\n", __FILE__, __LINE__, &(e), pte_val(e)) |
| 56 | #define pmd_ERROR(e) \ |
| 57 | printk("%s:%d: bad pmd %p(%016lx).\n", __FILE__, __LINE__, &(e), pmd_val(e)) |
| 58 | #define pud_ERROR(e) \ |
| 59 | printk("%s:%d: bad pud %p(%016lx).\n", __FILE__, __LINE__, &(e), pud_val(e)) |
| 60 | #define pgd_ERROR(e) \ |
| 61 | printk("%s:%d: bad pgd %p(%016lx).\n", __FILE__, __LINE__, &(e), pgd_val(e)) |
| 62 | |
| 63 | #define pgd_none(x) (!pgd_val(x)) |
| 64 | #define pud_none(x) (!pud_val(x)) |
| 65 | |
| 66 | static inline void set_pte(pte_t *dst, pte_t val) |
| 67 | { |
Jeremy Fitzhardinge | c8e5393 | 2008-01-30 13:32:57 +0100 | [diff] [blame] | 68 | *dst = val; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | } |
| 70 | #define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval) |
| 71 | |
| 72 | static inline void set_pmd(pmd_t *dst, pmd_t val) |
| 73 | { |
Ingo Molnar | 7a2389b | 2008-01-30 13:32:42 +0100 | [diff] [blame] | 74 | *dst = val; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 75 | } |
| 76 | |
| 77 | static inline void set_pud(pud_t *dst, pud_t val) |
| 78 | { |
Ingo Molnar | 7a2389b | 2008-01-30 13:32:42 +0100 | [diff] [blame] | 79 | *dst = val; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | } |
| 81 | |
Adrian Bunk | 9c0aa0f | 2005-09-12 18:49:24 +0200 | [diff] [blame] | 82 | static inline void pud_clear (pud_t *pud) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 83 | { |
| 84 | set_pud(pud, __pud(0)); |
| 85 | } |
| 86 | |
| 87 | static inline void set_pgd(pgd_t *dst, pgd_t val) |
| 88 | { |
Ingo Molnar | 7a2389b | 2008-01-30 13:32:42 +0100 | [diff] [blame] | 89 | *dst = val; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | } |
| 91 | |
Adrian Bunk | 9c0aa0f | 2005-09-12 18:49:24 +0200 | [diff] [blame] | 92 | static inline void pgd_clear (pgd_t * pgd) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | { |
| 94 | set_pgd(pgd, __pgd(0)); |
| 95 | } |
| 96 | |
Jeremy Fitzhardinge | 195466d | 2008-01-30 13:32:58 +0100 | [diff] [blame] | 97 | #define native_ptep_get_and_clear(xp) __pte(xchg(&(xp)->pte, 0)) |
Zachary Amsden | 61e0603 | 2005-09-03 15:55:06 -0700 | [diff] [blame] | 98 | |
Tim Schmielau | 8c65b4a | 2005-11-07 00:59:43 -0800 | [diff] [blame] | 99 | struct mm_struct; |
| 100 | |
Jeremy Fitzhardinge | 195466d | 2008-01-30 13:32:58 +0100 | [diff] [blame] | 101 | static inline pte_t native_ptep_get_and_clear_full(struct mm_struct *mm, unsigned long addr, pte_t *ptep, int full) |
Zachary Amsden | 61e0603 | 2005-09-03 15:55:06 -0700 | [diff] [blame] | 102 | { |
| 103 | pte_t pte; |
| 104 | if (full) { |
| 105 | pte = *ptep; |
| 106 | *ptep = __pte(0); |
| 107 | } else { |
Jeremy Fitzhardinge | 195466d | 2008-01-30 13:32:58 +0100 | [diff] [blame] | 108 | pte = native_ptep_get_and_clear(ptep); |
Zachary Amsden | 61e0603 | 2005-09-03 15:55:06 -0700 | [diff] [blame] | 109 | } |
| 110 | return pte; |
| 111 | } |
| 112 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | #define pte_same(a, b) ((a).pte == (b).pte) |
| 114 | |
Arjan van de Ven | c728252 | 2006-01-06 00:12:03 -0800 | [diff] [blame] | 115 | #define pte_pgprot(a) (__pgprot((a).pte & ~PHYSICAL_PAGE_MASK)) |
| 116 | |
Vivek Goyal | 9d291e7 | 2007-05-02 19:27:06 +0200 | [diff] [blame] | 117 | #endif /* !__ASSEMBLY__ */ |
| 118 | |
| 119 | #define PMD_SIZE (_AC(1,UL) << PMD_SHIFT) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | #define PMD_MASK (~(PMD_SIZE-1)) |
Vivek Goyal | 9d291e7 | 2007-05-02 19:27:06 +0200 | [diff] [blame] | 121 | #define PUD_SIZE (_AC(1,UL) << PUD_SHIFT) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 122 | #define PUD_MASK (~(PUD_SIZE-1)) |
Vivek Goyal | 9d291e7 | 2007-05-02 19:27:06 +0200 | [diff] [blame] | 123 | #define PGDIR_SIZE (_AC(1,UL) << PGDIR_SHIFT) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | #define PGDIR_MASK (~(PGDIR_SIZE-1)) |
| 125 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | |
Randy Dunlap | 63f6564 | 2007-05-08 00:31:14 -0700 | [diff] [blame] | 127 | #define MAXMEM _AC(0x3fffffffffff, UL) |
| 128 | #define VMALLOC_START _AC(0xffffc20000000000, UL) |
| 129 | #define VMALLOC_END _AC(0xffffe1ffffffffff, UL) |
Christoph Lameter | 0889eba | 2007-10-16 01:24:15 -0700 | [diff] [blame] | 130 | #define VMEMMAP_START _AC(0xffffe20000000000, UL) |
Randy Dunlap | 63f6564 | 2007-05-08 00:31:14 -0700 | [diff] [blame] | 131 | #define MODULES_VADDR _AC(0xffffffff88000000, UL) |
| 132 | #define MODULES_END _AC(0xfffffffffff00000, UL) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | #define MODULES_LEN (MODULES_END - MODULES_VADDR) |
| 134 | |
Vivek Goyal | 9d291e7 | 2007-05-02 19:27:06 +0200 | [diff] [blame] | 135 | #ifndef __ASSEMBLY__ |
| 136 | |
Jan Beulich | eab724e | 2006-12-07 02:14:09 +0100 | [diff] [blame] | 137 | static inline unsigned long pgd_bad(pgd_t pgd) |
| 138 | { |
| 139 | return pgd_val(pgd) & ~(PTE_MASK | _KERNPG_TABLE | _PAGE_USER); |
| 140 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 141 | |
| 142 | static inline unsigned long pud_bad(pud_t pud) |
| 143 | { |
Jan Beulich | eab724e | 2006-12-07 02:14:09 +0100 | [diff] [blame] | 144 | return pud_val(pud) & ~(PTE_MASK | _KERNPG_TABLE | _PAGE_USER); |
| 145 | } |
| 146 | |
| 147 | static inline unsigned long pmd_bad(pmd_t pmd) |
| 148 | { |
| 149 | return pmd_val(pmd) & ~(PTE_MASK | _KERNPG_TABLE | _PAGE_USER); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | } |
| 151 | |
| 152 | #define pte_none(x) (!pte_val(x)) |
| 153 | #define pte_present(x) (pte_val(x) & (_PAGE_PRESENT | _PAGE_PROTNONE)) |
Jeremy Fitzhardinge | 195466d | 2008-01-30 13:32:58 +0100 | [diff] [blame] | 154 | #define native_pte_clear(mm,addr,xp) do { set_pte_at(mm, addr, xp, __pte(0)); } while (0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | |
Joerg Roedel | 1c6f703 | 2008-01-30 13:31:02 +0100 | [diff] [blame] | 156 | #define pages_to_mb(x) ((x) >> (20-PAGE_SHIFT)) /* FIXME: is this right? */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | #define pte_page(x) pfn_to_page(pte_pfn(x)) |
Andi Kleen | 6b75aee | 2005-11-05 17:25:53 +0100 | [diff] [blame] | 158 | #define pte_pfn(x) ((pte_val(x) & __PHYSICAL_MASK) >> PAGE_SHIFT) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | /* |
| 161 | * Macro to mark a page protection value as "uncacheable". |
| 162 | */ |
| 163 | #define pgprot_noncached(prot) (__pgprot(pgprot_val(prot) | _PAGE_PCD | _PAGE_PWT)) |
| 164 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 165 | |
| 166 | /* |
| 167 | * Conversion functions: convert a page and protection to a page entry, |
| 168 | * and a page entry and page directory to the page they refer to. |
| 169 | */ |
| 170 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | /* |
| 172 | * Level 4 access. |
| 173 | */ |
Dave McCracken | 46a82b2 | 2006-09-25 23:31:48 -0700 | [diff] [blame] | 174 | #define pgd_page_vaddr(pgd) ((unsigned long) __va((unsigned long)pgd_val(pgd) & PTE_MASK)) |
| 175 | #define pgd_page(pgd) (pfn_to_page(pgd_val(pgd) >> PAGE_SHIFT)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 176 | #define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1)) |
| 177 | #define pgd_offset(mm, addr) ((mm)->pgd + pgd_index(addr)) |
| 178 | #define pgd_offset_k(address) (init_level4_pgt + pgd_index(address)) |
| 179 | #define pgd_present(pgd) (pgd_val(pgd) & _PAGE_PRESENT) |
| 180 | #define mk_kernel_pgd(address) ((pgd_t){ (address) | _KERNPG_TABLE }) |
| 181 | |
| 182 | /* PUD - Level3 access */ |
| 183 | /* to find an entry in a page-table-directory. */ |
Dave McCracken | 46a82b2 | 2006-09-25 23:31:48 -0700 | [diff] [blame] | 184 | #define pud_page_vaddr(pud) ((unsigned long) __va(pud_val(pud) & PHYSICAL_PAGE_MASK)) |
| 185 | #define pud_page(pud) (pfn_to_page(pud_val(pud) >> PAGE_SHIFT)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | #define pud_index(address) (((address) >> PUD_SHIFT) & (PTRS_PER_PUD-1)) |
Dave McCracken | 46a82b2 | 2006-09-25 23:31:48 -0700 | [diff] [blame] | 187 | #define pud_offset(pgd, address) ((pud_t *) pgd_page_vaddr(*(pgd)) + pud_index(address)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | #define pud_present(pud) (pud_val(pud) & _PAGE_PRESENT) |
| 189 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | /* PMD - Level 2 access */ |
Dave McCracken | 46a82b2 | 2006-09-25 23:31:48 -0700 | [diff] [blame] | 191 | #define pmd_page_vaddr(pmd) ((unsigned long) __va(pmd_val(pmd) & PTE_MASK)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | #define pmd_page(pmd) (pfn_to_page(pmd_val(pmd) >> PAGE_SHIFT)) |
| 193 | |
| 194 | #define pmd_index(address) (((address) >> PMD_SHIFT) & (PTRS_PER_PMD-1)) |
Dave McCracken | 46a82b2 | 2006-09-25 23:31:48 -0700 | [diff] [blame] | 195 | #define pmd_offset(dir, address) ((pmd_t *) pud_page_vaddr(*(dir)) + \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | pmd_index(address)) |
| 197 | #define pmd_none(x) (!pmd_val(x)) |
| 198 | #define pmd_present(x) (pmd_val(x) & _PAGE_PRESENT) |
| 199 | #define pmd_clear(xp) do { set_pmd(xp, __pmd(0)); } while (0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | #define pfn_pmd(nr,prot) (__pmd(((nr) << PAGE_SHIFT) | pgprot_val(prot))) |
Andi Kleen | 6b75aee | 2005-11-05 17:25:53 +0100 | [diff] [blame] | 201 | #define pmd_pfn(x) ((pmd_val(x) & __PHYSICAL_MASK) >> PAGE_SHIFT) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 202 | |
| 203 | #define pte_to_pgoff(pte) ((pte_val(pte) & PHYSICAL_PAGE_MASK) >> PAGE_SHIFT) |
Jeremy Fitzhardinge | c8e5393 | 2008-01-30 13:32:57 +0100 | [diff] [blame] | 204 | #define pgoff_to_pte(off) ((pte_t) { .pte = ((off) << PAGE_SHIFT) | _PAGE_FILE }) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | #define PTE_FILE_MAX_BITS __PHYSICAL_MASK_SHIFT |
| 206 | |
| 207 | /* PTE - Level 1 access. */ |
| 208 | |
| 209 | /* page, protection -> pte */ |
| 210 | #define mk_pte(page, pgprot) pfn_pte(page_to_pfn(page), (pgprot)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | #define pte_index(address) \ |
Kirill Korotaev | 1294b11 | 2005-09-30 10:32:19 +0400 | [diff] [blame] | 213 | (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)) |
Dave McCracken | 46a82b2 | 2006-09-25 23:31:48 -0700 | [diff] [blame] | 214 | #define pte_offset_kernel(dir, address) ((pte_t *) pmd_page_vaddr(*(dir)) + \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | pte_index(address)) |
| 216 | |
| 217 | /* x86-64 always has all page tables mapped. */ |
| 218 | #define pte_offset_map(dir,address) pte_offset_kernel(dir,address) |
| 219 | #define pte_offset_map_nested(dir,address) pte_offset_kernel(dir,address) |
| 220 | #define pte_unmap(pte) /* NOP */ |
| 221 | #define pte_unmap_nested(pte) /* NOP */ |
| 222 | |
| 223 | #define update_mmu_cache(vma,address,pte) do { } while (0) |
| 224 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | /* Encode and de-code a swap entry */ |
| 226 | #define __swp_type(x) (((x).val >> 1) & 0x3f) |
| 227 | #define __swp_offset(x) ((x).val >> 8) |
| 228 | #define __swp_entry(type, offset) ((swp_entry_t) { ((type) << 1) | ((offset) << 8) }) |
| 229 | #define __pte_to_swp_entry(pte) ((swp_entry_t) { pte_val(pte) }) |
Jeremy Fitzhardinge | c8e5393 | 2008-01-30 13:32:57 +0100 | [diff] [blame] | 230 | #define __swp_entry_to_pte(x) ((pte_t) { .pte = (x).val }) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 231 | |
Jan Beulich | 8c914cb | 2006-03-25 16:29:40 +0100 | [diff] [blame] | 232 | extern spinlock_t pgd_lock; |
Christoph Lameter | 2bff738 | 2007-05-02 19:27:10 +0200 | [diff] [blame] | 233 | extern struct list_head pgd_list; |
Jan Beulich | 8c914cb | 2006-03-25 16:29:40 +0100 | [diff] [blame] | 234 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 235 | extern int kern_addr_valid(unsigned long addr); |
| 236 | |
Andi Kleen | 19d36cc | 2007-07-22 11:12:31 +0200 | [diff] [blame] | 237 | pte_t *lookup_address(unsigned long addr); |
| 238 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 239 | #define io_remap_pfn_range(vma, vaddr, pfn, size, prot) \ |
| 240 | remap_pfn_range(vma, vaddr, pfn, size, prot) |
| 241 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | #define HAVE_ARCH_UNMAPPED_AREA |
Jiri Kosina | cc503c1 | 2008-01-30 13:31:07 +0100 | [diff] [blame] | 243 | #define HAVE_ARCH_UNMAPPED_AREA_TOPDOWN |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | |
| 245 | #define pgtable_cache_init() do { } while (0) |
Linus Torvalds | da8f153 | 2007-09-21 12:09:41 -0700 | [diff] [blame] | 246 | #define check_pgt_cache() do { } while (0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | |
| 248 | #define PAGE_AGP PAGE_KERNEL_NOCACHE |
| 249 | #define HAVE_PAGE_AGP 1 |
| 250 | |
| 251 | /* fs/proc/kcore.c */ |
| 252 | #define kc_vaddr_to_offset(v) ((v) & __VIRTUAL_MASK) |
| 253 | #define kc_offset_to_vaddr(o) \ |
| 254 | (((o) & (1UL << (__VIRTUAL_MASK_SHIFT-1))) ? ((o) | (~__VIRTUAL_MASK)) : (o)) |
| 255 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | #define __HAVE_ARCH_PTE_SAME |
Vivek Goyal | 9d291e7 | 2007-05-02 19:27:06 +0200 | [diff] [blame] | 257 | #endif /* !__ASSEMBLY__ */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 258 | |
| 259 | #endif /* _X86_64_PGTABLE_H */ |