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