include/asm-um/pgtable.h

   1 /*
   2  * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
   3  * Derived from include/asm-i386/pgtable.h
   4  * Licensed under the GPL
   5  */
   6
   7 #ifndef __UM_PGTABLE_H
   8 #define __UM_PGTABLE_H
   9
  10 #include "linux/sched.h"
  11 #include "asm/processor.h"
  12 #include "asm/page.h"
  13 #include "asm/fixmap.h"
  14
  15 extern pgd_t swapper_pg_dir[1024];
  16
  17 extern void *um_virt_to_phys(struct task_struct *task, unsigned long virt,
  18                              pte_t *pte_out);
  19
  20 /* zero page used for uninitialized stuff */
  21 extern unsigned long *empty_zero_page;
  22
  23 #define pgtable_cache_init() do ; while (0)
  24
  25 /* PMD_SHIFT determines the size of the area a second-level page table can map */
  26 #define PMD_SHIFT       22
  27 #define PMD_SIZE        (1UL << PMD_SHIFT)
  28 #define PMD_MASK        (~(PMD_SIZE-1))
  29
  30 /* PGDIR_SHIFT determines what a third-level page table entry can map */
  31 #define PGDIR_SHIFT     22
  32 #define PGDIR_SIZE      (1UL << PGDIR_SHIFT)
  33 #define PGDIR_MASK      (~(PGDIR_SIZE-1))
  34
  35 /*
  36  * entries per page directory level: the i386 is two-level, so
  37  * we don't really have any PMD directory physically.
  38  */
  39 #define PTRS_PER_PTE    1024
  40 #define PTRS_PER_PMD    1
  41 #define PTRS_PER_PGD    1024
  42 #define USER_PTRS_PER_PGD       (TASK_SIZE/PGDIR_SIZE)
  43 #define FIRST_USER_PGD_NR       0
  44
  45 #define pte_ERROR(e) \
  46         printk("%s:%d: bad pte %08lx.\n", __FILE__, __LINE__, pte_val(e))
  47 #define pmd_ERROR(e) \
  48         printk("%s:%d: bad pmd %08lx.\n", __FILE__, __LINE__, pmd_val(e))
  49 #define pgd_ERROR(e) \
  50         printk("%s:%d: bad pgd %08lx.\n", __FILE__, __LINE__, pgd_val(e))
  51
  52 /*
  53  * pgd entries used up by user/kernel:
  54  */
  55
  56 #define USER_PGD_PTRS (TASK_SIZE >> PGDIR_SHIFT)
  57 #define KERNEL_PGD_PTRS (PTRS_PER_PGD-USER_PGD_PTRS)
  58
  59 #ifndef __ASSEMBLY__
  60 /* Just any arbitrary offset to the start of the vmalloc VM area: the
  61  * current 8MB value just means that there will be a 8MB "hole" after the
  62  * physical memory until the kernel virtual memory starts.  That means that
  63  * any out-of-bounds memory accesses will hopefully be caught.
  64  * The vmalloc() routines leaves a hole of 4kB between each vmalloced
  65  * area for the same reason. ;)
  66  */
  67
  68 extern unsigned long high_physmem;
  69
  70 #define VMALLOC_OFFSET  (__va_space)
  71 #define VMALLOC_START   (((unsigned long) high_physmem + VMALLOC_OFFSET) & ~(VMALLOC_OFFSET-1))
  72
  73 #ifdef CONFIG_HIGHMEM
  74 # define VMALLOC_END    (PKMAP_BASE-2*PAGE_SIZE)
  75 #else
  76 # define VMALLOC_END    (FIXADDR_START-2*PAGE_SIZE)
  77 #endif
  78
  79 #define _PAGE_PRESENT   0x001
  80 #define _PAGE_NEWPAGE   0x002
  81 #define _PAGE_PROTNONE  0x004   /* If not present */
  82 #define _PAGE_RW        0x008
  83 #define _PAGE_USER      0x010
  84 #define _PAGE_ACCESSED  0x020
  85 #define _PAGE_DIRTY     0x040
  86 #define _PAGE_NEWPROT   0x080
  87
  88 #define REGION_MASK     0xf0000000
  89 #define REGION_SHIFT    28
  90
  91 #define _PAGE_TABLE     (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
  92 #define _KERNPG_TABLE   (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
  93 #define _PAGE_CHG_MASK  (PAGE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
  94
  95 #define PAGE_NONE       __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED)
  96 #define PAGE_SHARED     __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
  97 #define PAGE_COPY       __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
  98 #define PAGE_READONLY   __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
  99 #define PAGE_KERNEL     __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
 100 #define PAGE_KERNEL_RO  __pgprot(_PAGE_PRESENT | _PAGE_DIRTY | _PAGE_ACCESSED)
 101
 102 /*
 103  * The i386 can't do page protection for execute, and considers that the same are read.
 104  * Also, write permissions imply read permissions. This is the closest we can get..
 105  */
 106 #define __P000  PAGE_NONE
 107 #define __P001  PAGE_READONLY
 108 #define __P010  PAGE_COPY
 109 #define __P011  PAGE_COPY
 110 #define __P100  PAGE_READONLY
 111 #define __P101  PAGE_READONLY
 112 #define __P110  PAGE_COPY
 113 #define __P111  PAGE_COPY
 114
 115 #define __S000  PAGE_NONE
 116 #define __S001  PAGE_READONLY
 117 #define __S010  PAGE_SHARED
 118 #define __S011  PAGE_SHARED
 119 #define __S100  PAGE_READONLY
 120 #define __S101  PAGE_READONLY
 121 #define __S110  PAGE_SHARED
 122 #define __S111  PAGE_SHARED
 123
 124 /*
 125  * Define this if things work differently on an i386 and an i486:
 126  * it will (on an i486) warn about kernel memory accesses that are
 127  * done without a 'verify_area(VERIFY_WRITE,..)'
 128  */
 129 #undef TEST_VERIFY_AREA
 130
 131 /* page table for 0-4MB for everybody */
 132 extern unsigned long pg0[1024];
 133
 134 /*
 135  * BAD_PAGETABLE is used when we need a bogus page-table, while
 136  * BAD_PAGE is used for a bogus page.
 137  *
 138  * ZERO_PAGE is a global shared page that is always zero: used
 139  * for zero-mapped memory areas etc..
 140  */
 141 extern pte_t __bad_page(void);
 142 extern pte_t * __bad_pagetable(void);
 143
 144 #define BAD_PAGETABLE __bad_pagetable()
 145 #define BAD_PAGE __bad_page()
 146 #define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page))
 147
 148 /* number of bits that fit into a memory pointer */
 149 #define BITS_PER_PTR                    (8*sizeof(unsigned long))
 150
 151 /* to align the pointer to a pointer address */
 152 #define PTR_MASK                        (~(sizeof(void*)-1))
 153
 154 /* sizeof(void*)==1<<SIZEOF_PTR_LOG2 */
 155 /* 64-bit machines, beware!  SRB. */
 156 #define SIZEOF_PTR_LOG2                 2
 157
 158 /* to find an entry in a page-table */
 159 #define PAGE_PTR(address) \
 160 ((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
 161
 162 #define pte_none(x)     !(pte_val(x) & ~_PAGE_NEWPAGE)
 163 #define pte_present(x)  (pte_val(x) & (_PAGE_PRESENT | _PAGE_PROTNONE))
 164
 165 #define pte_clear(xp)   do { pte_val(*(xp)) = _PAGE_NEWPAGE; } while (0)
 166
 167 #define phys_region_index(x) (((x) & REGION_MASK) >> REGION_SHIFT)
 168 #define pte_region_index(x) phys_region_index(pte_val(x))
 169
 170 #define pmd_none(x)     (!(pmd_val(x) & ~_PAGE_NEWPAGE))
 171 #define pmd_bad(x)      ((pmd_val(x) & (~PAGE_MASK & ~_PAGE_USER)) != _KERNPG_TABLE)
 172 #define pmd_present(x)  (pmd_val(x) & _PAGE_PRESENT)
 173 #define pmd_clear(xp)   do { pmd_val(*(xp)) = _PAGE_NEWPAGE; } while (0)
 174
 175 #define pmd_newpage(x)  (pmd_val(x) & _PAGE_NEWPAGE)
 176 #define pmd_mkuptodate(x) (pmd_val(x) &= ~_PAGE_NEWPAGE)
 177
 178 /*
 179  * The "pgd_xxx()" functions here are trivial for a folded two-level
 180  * setup: the pgd is never bad, and a pmd always exists (as it's folded
 181  * into the pgd entry)
 182  */
 183 static inline int pgd_none(pgd_t pgd)           { return 0; }
 184 static inline int pgd_bad(pgd_t pgd)            { return 0; }
 185 static inline int pgd_present(pgd_t pgd)        { return 1; }
 186 static inline void pgd_clear(pgd_t * pgdp)      { }
 187
 188
 189 #define pages_to_mb(x) ((x) >> (20-PAGE_SHIFT))
 190
 191 extern struct page *pte_mem_map(pte_t pte);
 192 extern struct page *phys_mem_map(unsigned long phys);
 193 extern unsigned long phys_to_pfn(unsigned long p);
 194 extern unsigned long pfn_to_phys(unsigned long pfn);
 195
 196 #define pte_page(x) pfn_to_page(pte_pfn(x))
 197 #define pte_address(x) (__va(pte_val(x) & PAGE_MASK))
 198 #define mk_phys(a, r) ((a) + (r << REGION_SHIFT))
 199 #define phys_addr(p) ((p) & ~REGION_MASK)
 200 #define phys_page(p) (phys_mem_map(p) + ((phys_addr(p)) >> PAGE_SHIFT))
 201 #define pte_pfn(x) phys_to_pfn(pte_val(x))
 202 #define pfn_pte(pfn, prot) __pte(pfn_to_phys(pfn) | pgprot_val(prot))
 203 #define pfn_pmd(pfn, prot) __pmd(pfn_to_phys(pfn) | pgprot_val(prot))
 204
 205 static inline pte_t pte_mknewprot(pte_t pte)
 206 {
 207         pte_val(pte) |= _PAGE_NEWPROT;
 208         return(pte);
 209 }
 210
 211 static inline pte_t pte_mknewpage(pte_t pte)
 212 {
 213         pte_val(pte) |= _PAGE_NEWPAGE;
 214         return(pte);
 215 }
 216
 217 static inline void set_pte(pte_t *pteptr, pte_t pteval)
 218 {
 219         /* If it's a swap entry, it needs to be marked _PAGE_NEWPAGE so
 220          * fix_range knows to unmap it.  _PAGE_NEWPROT is specific to
 221          * mapped pages.
 222          */
 223         *pteptr = pte_mknewpage(pteval);
 224         if(pte_present(*pteptr)) *pteptr = pte_mknewprot(*pteptr);
 225 }
 226
 227 /*
 228  * (pmds are folded into pgds so this doesn't get actually called,
 229  * but the define is needed for a generic inline function.)
 230  */
 231 #define set_pmd(pmdptr, pmdval) (*(pmdptr) = pmdval)
 232 #define set_pgd(pgdptr, pgdval) (*(pgdptr) = pgdval)
 233
 234 /*
 235  * The following only work if pte_present() is true.
 236  * Undefined behaviour if not..
 237  */
 238 static inline int pte_read(pte_t pte)
 239 {
 240         return((pte_val(pte) & _PAGE_USER) &&
 241                !(pte_val(pte) & _PAGE_PROTNONE));
 242 }
 243
 244 static inline int pte_exec(pte_t pte){
 245         return((pte_val(pte) & _PAGE_USER) &&
 246                !(pte_val(pte) & _PAGE_PROTNONE));
 247 }
 248
 249 static inline int pte_write(pte_t pte)
 250 {
 251         return((pte_val(pte) & _PAGE_RW) &&
 252                !(pte_val(pte) & _PAGE_PROTNONE));
 253 }
 254
 255 static inline int pte_dirty(pte_t pte)  { return pte_val(pte) & _PAGE_DIRTY; }
 256 static inline int pte_young(pte_t pte)  { return pte_val(pte) & _PAGE_ACCESSED; }
 257 static inline int pte_newpage(pte_t pte) { return pte_val(pte) & _PAGE_NEWPAGE; }
 258 static inline int pte_newprot(pte_t pte)
 259 {
 260         return(pte_present(pte) && (pte_val(pte) & _PAGE_NEWPROT));
 261 }
 262
 263 static inline pte_t pte_rdprotect(pte_t pte)
 264 {
 265         pte_val(pte) &= ~_PAGE_USER;
 266         return(pte_mknewprot(pte));
 267 }
 268
 269 static inline pte_t pte_exprotect(pte_t pte)
 270 {
 271         pte_val(pte) &= ~_PAGE_USER;
 272         return(pte_mknewprot(pte));
 273 }
 274
 275 static inline pte_t pte_mkclean(pte_t pte)
 276 {
 277         pte_val(pte) &= ~_PAGE_DIRTY;
 278         return(pte);
 279 }
 280
 281 static inline pte_t pte_mkold(pte_t pte)
 282 {
 283         pte_val(pte) &= ~_PAGE_ACCESSED;
 284         return(pte);
 285 }
 286
 287 static inline pte_t pte_wrprotect(pte_t pte)
 288 {
 289         pte_val(pte) &= ~_PAGE_RW;
 290         return(pte_mknewprot(pte));
 291 }
 292
 293 static inline pte_t pte_mkread(pte_t pte)
 294 {
 295         pte_val(pte) |= _PAGE_USER;
 296         return(pte_mknewprot(pte));
 297 }
 298
 299 static inline pte_t pte_mkexec(pte_t pte)
 300 {
 301         pte_val(pte) |= _PAGE_USER;
 302         return(pte_mknewprot(pte));
 303 }
 304
 305 static inline pte_t pte_mkdirty(pte_t pte)
 306 {
 307         pte_val(pte) |= _PAGE_DIRTY;
 308         return(pte);
 309 }
 310
 311 static inline pte_t pte_mkyoung(pte_t pte)
 312 {
 313         pte_val(pte) |= _PAGE_ACCESSED;
 314         return(pte);
 315 }
 316
 317 static inline pte_t pte_mkwrite(pte_t pte)
 318 {
 319         pte_val(pte) |= _PAGE_RW;
 320         return(pte_mknewprot(pte));
 321 }
 322
 323 static inline pte_t pte_mkuptodate(pte_t pte)
 324 {
 325         pte_val(pte) &= ~_PAGE_NEWPAGE;
 326         if(pte_present(pte)) pte_val(pte) &= ~_PAGE_NEWPROT;
 327         return(pte);
 328 }
 329
 330 extern unsigned long page_to_phys(struct page *page);
 331
 332 /*
 333  * Conversion functions: convert a page and protection to a page entry,
 334  * and a page entry and page directory to the page they refer to.
 335  */
 336
 337 #define mk_pte(page, pgprot) \
 338 ({                                      \
 339         pte_t __pte;                    \
 340                                         \
 341         pte_val(__pte) = page_to_phys(page) + pgprot_val(pgprot);\
 342         if(pte_present(__pte)) pte_mknewprot(pte_mknewpage(__pte)); \
 343         __pte;                          \
 344 })
 345
 346 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 347 {
 348         pte_val(pte) = (pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot);
 349         if(pte_present(pte)) pte = pte_mknewpage(pte_mknewprot(pte));
 350         return pte;
 351 }
 352
 353 #define pmd_page_kernel(pmd) ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
 354 #define pmd_page(pmd) (phys_mem_map(pmd_val(pmd) & PAGE_MASK) + \
 355                        ((phys_addr(pmd_val(pmd)) >> PAGE_SHIFT)))
 356
 357 /* to find an entry in a page-table-directory. */
 358 #define pgd_index(address) ((address >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
 359
 360 /* to find an entry in a page-table-directory */
 361 #define pgd_offset(mm, address) \
 362 ((mm)->pgd + ((address) >> PGDIR_SHIFT))
 363
 364 /* to find an entry in a kernel page-table-directory */
 365 #define pgd_offset_k(address) pgd_offset(&init_mm, address)
 366
 367 #define pmd_index(address) \
 368                 (((address) >> PMD_SHIFT) & (PTRS_PER_PMD-1))
 369
 370 /* Find an entry in the second-level page table.. */
 371 static inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
 372 {
 373         return (pmd_t *) dir;
 374 }
 375
 376 /* Find an entry in the third-level page table.. */
 377 #define pte_index(address) (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
 378 #define pte_offset_kernel(dir, address) \
 379         ((pte_t *) pmd_page_kernel(*(dir)) +  pte_index(address))
 380 #define pte_offset_map(dir, address) \
 381         ((pte_t *)kmap_atomic(pmd_page(*(dir)),KM_PTE0) + pte_index(address))
 382 #define pte_offset_map_nested(dir, address) \
 383         ((pte_t *)kmap_atomic(pmd_page(*(dir)),KM_PTE1) + pte_index(address))
 384 #define pte_unmap(pte) kunmap_atomic((pte), KM_PTE0)
 385 #define pte_unmap_nested(pte) kunmap_atomic((pte), KM_PTE1)
 386
 387 #define update_mmu_cache(vma,address,pte) do ; while (0)
 388
 389 /* Encode and de-code a swap entry */
 390 #define __swp_type(x)                   (((x).val >> 3) & 0x7f)
 391 #define __swp_offset(x)                 ((x).val >> 10)
 392
 393 #define __swp_entry(type, offset) \
 394         ((swp_entry_t) { ((type) << 3) | ((offset) << 10) })
 395 #define __pte_to_swp_entry(pte) \
 396         ((swp_entry_t) { pte_val(pte_mkuptodate(pte)) })
 397 #define __swp_entry_to_pte(x)           ((pte_t) { (x).val })
 398
 399 #define kern_addr_valid(addr) (1)
 400
 401 #include <asm-generic/pgtable.h>
 402
 403 #endif
 404
 405 #endif
 406 /*
 407  * Overrides for Emacs so that we follow Linus's tabbing style.
 408  * Emacs will notice this stuff at the end of the file and automatically
 409  * adjust the settings for this buffer only.  This must remain at the end
 410  * of the file.
 411  * ---------------------------------------------------------------------------
 412  * Local variables:
 413  * c-file-style: "linux"
 414  * End:
 415  */