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-x86_64 / pgtable.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  15.4 KB  |  460 lines

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