arch/mips/include/asm/pgtable-64.h

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 1994, 95, 96, 97, 98, 99, 2000, 2003 Ralf Baechle
   7  * Copyright (C) 1999, 2000, 2001 Silicon Graphics, Inc.
   8  */
   9 #ifndef _ASM_PGTABLE_64_H
  10 #define _ASM_PGTABLE_64_H
  11
  12 #include <linux/compiler.h>
  13 #include <linux/linkage.h>
  14
  15 #include <asm/addrspace.h>
  16 #include <asm/page.h>
  17 #include <asm/cachectl.h>
  18 #include <asm/fixmap.h>
  19
  20 #define __ARCH_USE_5LEVEL_HACK
  21 #if CONFIG_PGTABLE_LEVELS == 2
  22 #include <asm-generic/pgtable-nopmd.h>
  23 #elif CONFIG_PGTABLE_LEVELS == 3
  24 #include <asm-generic/pgtable-nopud.h>
  25 #else
  26 #include <asm-generic/5level-fixup.h>
  27 #endif
  28
  29 /*
  30  * Each address space has 2 4K pages as its page directory, giving 1024
  31  * (== PTRS_PER_PGD) 8 byte pointers to pmd tables. Each pmd table is a
  32  * single 4K page, giving 512 (== PTRS_PER_PMD) 8 byte pointers to page
  33  * tables. Each page table is also a single 4K page, giving 512 (==
  34  * PTRS_PER_PTE) 8 byte ptes. Each pud entry is initialized to point to
  35  * invalid_pmd_table, each pmd entry is initialized to point to
  36  * invalid_pte_table, each pte is initialized to 0. When memory is low,
  37  * and a pmd table or a page table allocation fails, empty_bad_pmd_table
  38  * and empty_bad_page_table is returned back to higher layer code, so
  39  * that the failure is recognized later on. Linux does not seem to
  40  * handle these failures very well though. The empty_bad_page_table has
  41  * invalid pte entries in it, to force page faults.
  42  *
  43  * Kernel mappings: kernel mappings are held in the swapper_pg_table.
  44  * The layout is identical to userspace except it's indexed with the
  45  * fault address - VMALLOC_START.
  46  */
  47
  48
  49 /* PGDIR_SHIFT determines what a third-level page table entry can map */
  50 #ifdef __PAGETABLE_PMD_FOLDED
  51 #define PGDIR_SHIFT     (PAGE_SHIFT + PAGE_SHIFT + PTE_ORDER - 3)
  52 #else
  53
  54 /* PMD_SHIFT determines the size of the area a second-level page table can map */
  55 #define PMD_SHIFT       (PAGE_SHIFT + (PAGE_SHIFT + PTE_ORDER - 3))
  56 #define PMD_SIZE        (1UL << PMD_SHIFT)
  57 #define PMD_MASK        (~(PMD_SIZE-1))
  58
  59 # ifdef __PAGETABLE_PUD_FOLDED
  60 # define PGDIR_SHIFT    (PMD_SHIFT + (PAGE_SHIFT + PMD_ORDER - 3))
  61 # endif
  62 #endif
  63
  64 #ifndef __PAGETABLE_PUD_FOLDED
  65 #define PUD_SHIFT       (PMD_SHIFT + (PAGE_SHIFT + PMD_ORDER - 3))
  66 #define PUD_SIZE        (1UL << PUD_SHIFT)
  67 #define PUD_MASK        (~(PUD_SIZE-1))
  68 #define PGDIR_SHIFT     (PUD_SHIFT + (PAGE_SHIFT + PUD_ORDER - 3))
  69 #endif
  70
  71 #define PGDIR_SIZE      (1UL << PGDIR_SHIFT)
  72 #define PGDIR_MASK      (~(PGDIR_SIZE-1))
  73
  74 /*
  75  * For 4kB page size we use a 3 level page tree and an 8kB pud, which
  76  * permits us mapping 40 bits of virtual address space.
  77  *
  78  * We used to implement 41 bits by having an order 1 pmd level but that seemed
  79  * rather pointless.
  80  *
  81  * For 8kB page size we use a 3 level page tree which permits a total of
  82  * 8TB of address space.  Alternatively a 33-bit / 8GB organization using
  83  * two levels would be easy to implement.
  84  *
  85  * For 16kB page size we use a 2 level page tree which permits a total of
  86  * 36 bits of virtual address space.  We could add a third level but it seems
  87  * like at the moment there's no need for this.
  88  *
  89  * For 64kB page size we use a 2 level page table tree for a total of 42 bits
  90  * of virtual address space.
  91  */
  92 #ifdef CONFIG_PAGE_SIZE_4KB
  93 # ifdef CONFIG_MIPS_VA_BITS_48
  94 #  define PGD_ORDER             0
  95 #  define PUD_ORDER             0
  96 # else
  97 #  define PGD_ORDER             1
  98 #  define PUD_ORDER             aieeee_attempt_to_allocate_pud
  99 # endif
 100 #define PMD_ORDER               0
 101 #define PTE_ORDER               0
 102 #endif
 103 #ifdef CONFIG_PAGE_SIZE_8KB
 104 #define PGD_ORDER               0
 105 #define PUD_ORDER               aieeee_attempt_to_allocate_pud
 106 #define PMD_ORDER               0
 107 #define PTE_ORDER               0
 108 #endif
 109 #ifdef CONFIG_PAGE_SIZE_16KB
 110 #ifdef CONFIG_MIPS_VA_BITS_48
 111 #define PGD_ORDER               1
 112 #else
 113 #define PGD_ORDER               0
 114 #endif
 115 #define PUD_ORDER               aieeee_attempt_to_allocate_pud
 116 #define PMD_ORDER               0
 117 #define PTE_ORDER               0
 118 #endif
 119 #ifdef CONFIG_PAGE_SIZE_32KB
 120 #define PGD_ORDER               0
 121 #define PUD_ORDER               aieeee_attempt_to_allocate_pud
 122 #define PMD_ORDER               0
 123 #define PTE_ORDER               0
 124 #endif
 125 #ifdef CONFIG_PAGE_SIZE_64KB
 126 #define PGD_ORDER               0
 127 #define PUD_ORDER               aieeee_attempt_to_allocate_pud
 128 #ifdef CONFIG_MIPS_VA_BITS_48
 129 #define PMD_ORDER               0
 130 #else
 131 #define PMD_ORDER               aieeee_attempt_to_allocate_pmd
 132 #endif
 133 #define PTE_ORDER               0
 134 #endif
 135
 136 #define PTRS_PER_PGD    ((PAGE_SIZE << PGD_ORDER) / sizeof(pgd_t))
 137 #ifndef __PAGETABLE_PUD_FOLDED
 138 #define PTRS_PER_PUD    ((PAGE_SIZE << PUD_ORDER) / sizeof(pud_t))
 139 #endif
 140 #ifndef __PAGETABLE_PMD_FOLDED
 141 #define PTRS_PER_PMD    ((PAGE_SIZE << PMD_ORDER) / sizeof(pmd_t))
 142 #endif
 143 #define PTRS_PER_PTE    ((PAGE_SIZE << PTE_ORDER) / sizeof(pte_t))
 144
 145 #define USER_PTRS_PER_PGD       ((TASK_SIZE64 / PGDIR_SIZE)?(TASK_SIZE64 / PGDIR_SIZE):1)
 146 #define FIRST_USER_ADDRESS      0UL
 147
 148 /*
 149  * TLB refill handlers also map the vmalloc area into xuseg.  Avoid
 150  * the first couple of pages so NULL pointer dereferences will still
 151  * reliably trap.
 152  */
 153 #define VMALLOC_START           (MAP_BASE + (2 * PAGE_SIZE))
 154 #define VMALLOC_END     \
 155         (MAP_BASE + \
 156          min(PTRS_PER_PGD * PTRS_PER_PUD * PTRS_PER_PMD * PTRS_PER_PTE * PAGE_SIZE, \
 157              (1UL << cpu_vmbits)) - (1UL << 32))
 158
 159 #if defined(CONFIG_MODULES) && defined(KBUILD_64BIT_SYM32) && \
 160         VMALLOC_START != CKSSEG
 161 /* Load modules into 32bit-compatible segment. */
 162 #define MODULE_START    CKSSEG
 163 #define MODULE_END      (FIXADDR_START-2*PAGE_SIZE)
 164 #endif
 165
 166 #define pte_ERROR(e) \
 167         printk("%s:%d: bad pte %016lx.\n", __FILE__, __LINE__, pte_val(e))
 168 #ifndef __PAGETABLE_PMD_FOLDED
 169 #define pmd_ERROR(e) \
 170         printk("%s:%d: bad pmd %016lx.\n", __FILE__, __LINE__, pmd_val(e))
 171 #endif
 172 #ifndef __PAGETABLE_PUD_FOLDED
 173 #define pud_ERROR(e) \
 174         printk("%s:%d: bad pud %016lx.\n", __FILE__, __LINE__, pud_val(e))
 175 #endif
 176 #define pgd_ERROR(e) \
 177         printk("%s:%d: bad pgd %016lx.\n", __FILE__, __LINE__, pgd_val(e))
 178
 179 extern pte_t invalid_pte_table[PTRS_PER_PTE];
 180 extern pte_t empty_bad_page_table[PTRS_PER_PTE];
 181
 182 #ifndef __PAGETABLE_PUD_FOLDED
 183 /*
 184  * For 4-level pagetables we defines these ourselves, for 3-level the
 185  * definitions are below, for 2-level the
 186  * definitions are supplied by <asm-generic/pgtable-nopmd.h>.
 187  */
 188 typedef struct { unsigned long pud; } pud_t;
 189 #define pud_val(x)      ((x).pud)
 190 #define __pud(x)        ((pud_t) { (x) })
 191
 192 extern pud_t invalid_pud_table[PTRS_PER_PUD];
 193
 194 /*
 195  * Empty pgd entries point to the invalid_pud_table.
 196  */
 197 static inline int pgd_none(pgd_t pgd)
 198 {
 199         return pgd_val(pgd) == (unsigned long)invalid_pud_table;
 200 }
 201
 202 static inline int pgd_bad(pgd_t pgd)
 203 {
 204         if (unlikely(pgd_val(pgd) & ~PAGE_MASK))
 205                 return 1;
 206
 207         return 0;
 208 }
 209
 210 static inline int pgd_present(pgd_t pgd)
 211 {
 212         return pgd_val(pgd) != (unsigned long)invalid_pud_table;
 213 }
 214
 215 static inline void pgd_clear(pgd_t *pgdp)
 216 {
 217         pgd_val(*pgdp) = (unsigned long)invalid_pud_table;
 218 }
 219
 220 #define pud_index(address)      (((address) >> PUD_SHIFT) & (PTRS_PER_PUD - 1))
 221
 222 static inline unsigned long pgd_page_vaddr(pgd_t pgd)
 223 {
 224         return pgd_val(pgd);
 225 }
 226
 227 #define pgd_phys(pgd)           virt_to_phys((void *)pgd_val(pgd))
 228 #define pgd_page(pgd)           (pfn_to_page(pgd_phys(pgd) >> PAGE_SHIFT))
 229
 230 static inline pud_t *pud_offset(pgd_t *pgd, unsigned long address)
 231 {
 232         return (pud_t *)pgd_page_vaddr(*pgd) + pud_index(address);
 233 }
 234
 235 static inline void set_pgd(pgd_t *pgd, pgd_t pgdval)
 236 {
 237         *pgd = pgdval;
 238 }
 239
 240 #endif
 241
 242 #ifndef __PAGETABLE_PMD_FOLDED
 243 /*
 244  * For 3-level pagetables we defines these ourselves, for 2-level the
 245  * definitions are supplied by <asm-generic/pgtable-nopmd.h>.
 246  */
 247 typedef struct { unsigned long pmd; } pmd_t;
 248 #define pmd_val(x)      ((x).pmd)
 249 #define __pmd(x)        ((pmd_t) { (x) } )
 250
 251
 252 extern pmd_t invalid_pmd_table[PTRS_PER_PMD];
 253 #endif
 254
 255 /*
 256  * Empty pgd/pmd entries point to the invalid_pte_table.
 257  */
 258 static inline int pmd_none(pmd_t pmd)
 259 {
 260         return pmd_val(pmd) == (unsigned long) invalid_pte_table;
 261 }
 262
 263 static inline int pmd_bad(pmd_t pmd)
 264 {
 265 #ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
 266         /* pmd_huge(pmd) but inline */
 267         if (unlikely(pmd_val(pmd) & _PAGE_HUGE))
 268                 return 0;
 269 #endif
 270
 271         if (unlikely(pmd_val(pmd) & ~PAGE_MASK))
 272                 return 1;
 273
 274         return 0;
 275 }
 276
 277 static inline int pmd_present(pmd_t pmd)
 278 {
 279 #ifdef CONFIG_MIPS_HUGE_TLB_SUPPORT
 280         if (unlikely(pmd_val(pmd) & _PAGE_HUGE))
 281                 return pmd_val(pmd) & _PAGE_PRESENT;
 282 #endif
 283
 284         return pmd_val(pmd) != (unsigned long) invalid_pte_table;
 285 }
 286
 287 static inline void pmd_clear(pmd_t *pmdp)
 288 {
 289         pmd_val(*pmdp) = ((unsigned long) invalid_pte_table);
 290 }
 291 #ifndef __PAGETABLE_PMD_FOLDED
 292
 293 /*
 294  * Empty pud entries point to the invalid_pmd_table.
 295  */
 296 static inline int pud_none(pud_t pud)
 297 {
 298         return pud_val(pud) == (unsigned long) invalid_pmd_table;
 299 }
 300
 301 static inline int pud_bad(pud_t pud)
 302 {
 303         return pud_val(pud) & ~PAGE_MASK;
 304 }
 305
 306 static inline int pud_present(pud_t pud)
 307 {
 308         return pud_val(pud) != (unsigned long) invalid_pmd_table;
 309 }
 310
 311 static inline void pud_clear(pud_t *pudp)
 312 {
 313         pud_val(*pudp) = ((unsigned long) invalid_pmd_table);
 314 }
 315 #endif
 316
 317 #define pte_page(x)             pfn_to_page(pte_pfn(x))
 318
 319 #ifdef CONFIG_CPU_VR41XX
 320 #define pte_pfn(x)              ((unsigned long)((x).pte >> (PAGE_SHIFT + 2)))
 321 #define pfn_pte(pfn, prot)      __pte(((pfn) << (PAGE_SHIFT + 2)) | pgprot_val(prot))
 322 #else
 323 #define pte_pfn(x)              ((unsigned long)((x).pte >> _PFN_SHIFT))
 324 #define pfn_pte(pfn, prot)      __pte(((pfn) << _PFN_SHIFT) | pgprot_val(prot))
 325 #define pfn_pmd(pfn, prot)      __pmd(((pfn) << _PFN_SHIFT) | pgprot_val(prot))
 326 #endif
 327
 328 #define __pgd_offset(address)   pgd_index(address)
 329 #define __pud_offset(address)   (((address) >> PUD_SHIFT) & (PTRS_PER_PUD-1))
 330 #define __pmd_offset(address)   pmd_index(address)
 331
 332 /* to find an entry in a kernel page-table-directory */
 333 #define pgd_offset_k(address) pgd_offset(&init_mm, address)
 334
 335 #define pgd_index(address)      (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
 336 #define pmd_index(address)      (((address) >> PMD_SHIFT) & (PTRS_PER_PMD-1))
 337
 338 /* to find an entry in a page-table-directory */
 339 #define pgd_offset(mm, addr)    ((mm)->pgd + pgd_index(addr))
 340
 341 #ifndef __PAGETABLE_PMD_FOLDED
 342 static inline unsigned long pud_page_vaddr(pud_t pud)
 343 {
 344         return pud_val(pud);
 345 }
 346 #define pud_phys(pud)           virt_to_phys((void *)pud_val(pud))
 347 #define pud_page(pud)           (pfn_to_page(pud_phys(pud) >> PAGE_SHIFT))
 348
 349 /* Find an entry in the second-level page table.. */
 350 static inline pmd_t *pmd_offset(pud_t * pud, unsigned long address)
 351 {
 352         return (pmd_t *) pud_page_vaddr(*pud) + pmd_index(address);
 353 }
 354 #endif
 355
 356 /* Find an entry in the third-level page table.. */
 357 #define __pte_offset(address)                                           \
 358         (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
 359 #define pte_offset(dir, address)                                        \
 360         ((pte_t *) pmd_page_vaddr(*(dir)) + __pte_offset(address))
 361 #define pte_offset_kernel(dir, address)                                 \
 362         ((pte_t *) pmd_page_vaddr(*(dir)) + __pte_offset(address))
 363 #define pte_offset_map(dir, address)                                    \
 364         ((pte_t *)page_address(pmd_page(*(dir))) + __pte_offset(address))
 365 #define pte_unmap(pte) ((void)(pte))
 366
 367 /*
 368  * Initialize a new pgd / pmd table with invalid pointers.
 369  */
 370 extern void pgd_init(unsigned long page);
 371 extern void pud_init(unsigned long page, unsigned long pagetable);
 372 extern void pmd_init(unsigned long page, unsigned long pagetable);
 373
 374 /*
 375  * Non-present pages:  high 40 bits are offset, next 8 bits type,
 376  * low 16 bits zero.
 377  */
 378 static inline pte_t mk_swap_pte(unsigned long type, unsigned long offset)
 379 { pte_t pte; pte_val(pte) = (type << 16) | (offset << 24); return pte; }
 380
 381 #define __swp_type(x)           (((x).val >> 16) & 0xff)
 382 #define __swp_offset(x)         ((x).val >> 24)
 383 #define __swp_entry(type, offset) ((swp_entry_t) { pte_val(mk_swap_pte((type), (offset))) })
 384 #define __pte_to_swp_entry(pte) ((swp_entry_t) { pte_val(pte) })
 385 #define __swp_entry_to_pte(x)   ((pte_t) { (x).val })
 386
 387 #endif /* _ASM_PGTABLE_64_H */