x86: move all asm/pgtable constants into one place

32 and 64-bit use the same flags for pagetable entries, so make them all common. [ mingo@elte.hu: fixes ] Signed-off-by: Jeremy Fitzhardinge <jeremy@xensource.com> Signed-off-by: Ingo Molnar <mingo@elte.hu> Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
author: Jeremy Fitzhardinge <jeremy@goop.org> 2008-01-30 07:32:55 -0500
committer: Ingo Molnar <mingo@elte.hu> 2008-01-30 07:32:55 -0500
commit: 6c3866558213ff706d8331053386915371ad63ec (patch)
tree: 7c7d4b56c0544abbc2256f078d71a78d3ebfb84d
parent: 82bc03fc158e28c90d7ed9919410776039cb4e14 (diff)
3 files changed, 119 insertions, 201 deletions
diff --git a/include/asm-x86/pgtable.h b/include/asm-x86/pgtable.h
index 1039140652af..5b858f0285a8 100644
--- a/include/asm-x86/pgtable.h
+++ b/include/asm-x86/pgtable.h
@@ -1,5 +1,124 @@
+#ifndef _ASM_X86_PGTABLE_H
+#define _ASM_X86_PGTABLE_H
+#define USER_PTRS_PER_PGD       ((TASK_SIZE-1)/PGDIR_SIZE+1)
+#define FIRST_USER_ADDRESS      0
+#define _PAGE_BIT_PRESENT       0
+#define _PAGE_BIT_RW            1
+#define _PAGE_BIT_USER          2
+#define _PAGE_BIT_PWT           3
+#define _PAGE_BIT_PCD           4
+#define _PAGE_BIT_ACCESSED      5
+#define _PAGE_BIT_DIRTY         6
+#define _PAGE_BIT_FILE          6
+#define _PAGE_BIT_PSE           7       /* 4 MB (or 2MB) page */
+#define _PAGE_BIT_GLOBAL        8       /* Global TLB entry PPro+ */
+#define _PAGE_BIT_UNUSED1       9       /* available for programmer */
+#define _PAGE_BIT_UNUSED2       10
+#define _PAGE_BIT_UNUSED3       11
+#define _PAGE_BIT_NX           63       /* No execute: only valid after cpuid check */
+#define _PAGE_PRESENT   (_AC(1, UL)<<_PAGE_BIT_PRESENT)
+#define _PAGE_RW        (_AC(1, UL)<<_PAGE_BIT_RW)
+#define _PAGE_USER      (_AC(1, UL)<<_PAGE_BIT_USER)
+#define _PAGE_PWT       (_AC(1, UL)<<_PAGE_BIT_PWT)
+#define _PAGE_PCD       (_AC(1, UL)<<_PAGE_BIT_PCD)
+#define _PAGE_ACCESSED  (_AC(1, UL)<<_PAGE_BIT_ACCESSED)
+#define _PAGE_DIRTY     (_AC(1, UL)<<_PAGE_BIT_DIRTY)
+#define _PAGE_PSE       (_AC(1, UL)<<_PAGE_BIT_PSE)     /* 2MB page */
+#define _PAGE_GLOBAL    (_AC(1, UL)<<_PAGE_BIT_GLOBAL)  /* Global TLB entry */
+#define _PAGE_UNUSED1   (_AC(1, UL)<<_PAGE_BIT_UNUSED1)
+#define _PAGE_UNUSED2   (_AC(1, UL)<<_PAGE_BIT_UNUSED2)
+#define _PAGE_UNUSED3   (_AC(1, UL)<<_PAGE_BIT_UNUSED3)
+#if defined(CONFIG_X86_64) || defined(CONFIG_X86_PAE)
+#define _PAGE_NX        (_AC(1, ULL) << _PAGE_BIT_NX)
+#else
+#define _PAGE_NX        0
+#endif
+/* If _PAGE_PRESENT is clear, we use these: */
+#define _PAGE_FILE      _PAGE_DIRTY     /* nonlinear file mapping, saved PTE; unset:swap */
+#define _PAGE_PROTNONE  _PAGE_PSE       /* if the user mapped it with PROT_NONE;
+                                           pte_present gives true */
+#define _PAGE_TABLE     (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
+#define _KERNPG_TABLE   (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
+#define _PAGE_CHG_MASK  (PTE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
+#define PAGE_NONE       __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED)
+#define PAGE_SHARED     __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_NX)
+#define PAGE_SHARED_EXEC        __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
+#define PAGE_COPY_NOEXEC        __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_NX)
+#define PAGE_COPY_EXEC          __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
+#define PAGE_COPY               PAGE_COPY_NOEXEC
+#define PAGE_READONLY           __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_NX)
+#define PAGE_READONLY_EXEC      __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
+#ifdef CONFIG_X86_32
+#define _PAGE_KERNEL_EXEC \
+        (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
+#define _PAGE_KERNEL (_PAGE_KERNEL_EXEC | _PAGE_NX)
+#ifndef __ASSEMBLY__
+extern unsigned long long __PAGE_KERNEL, __PAGE_KERNEL_EXEC;
+#endif  /* __ASSEMBLY__ */
+#else
+#define __PAGE_KERNEL_EXEC                                              \
+        (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
+#define __PAGE_KERNEL           (__PAGE_KERNEL_EXEC | _PAGE_NX)
+#endif
+#define __PAGE_KERNEL_RO                (__PAGE_KERNEL & ~_PAGE_RW)
+#define __PAGE_KERNEL_RX                (__PAGE_KERNEL_EXEC & ~_PAGE_RW)
+#define __PAGE_KERNEL_NOCACHE           (__PAGE_KERNEL | _PAGE_PCD | _PAGE_PWT)
+#define __PAGE_KERNEL_VSYSCALL          (__PAGE_KERNEL_RX | _PAGE_USER)
+#define __PAGE_KERNEL_VSYSCALL_NOCACHE  (__PAGE_KERNEL_VSYSCALL | _PAGE_PCD | _PAGE_PWT)
+#define __PAGE_KERNEL_LARGE             (__PAGE_KERNEL | _PAGE_PSE)
+#define __PAGE_KERNEL_LARGE_EXEC        (__PAGE_KERNEL_EXEC | _PAGE_PSE)
+#ifdef CONFIG_X86_32
+# define MAKE_GLOBAL(x)                 __pgprot((x))
+#else
+# define MAKE_GLOBAL(x)                 __pgprot((x) | _PAGE_GLOBAL)
+#endif
+#define PAGE_KERNEL                     MAKE_GLOBAL(__PAGE_KERNEL)
+#define PAGE_KERNEL_RO                  MAKE_GLOBAL(__PAGE_KERNEL_RO)
+#define PAGE_KERNEL_EXEC                MAKE_GLOBAL(__PAGE_KERNEL_EXEC)
+#define PAGE_KERNEL_RX                  MAKE_GLOBAL(__PAGE_KERNEL_RX)
+#define PAGE_KERNEL_NOCACHE             MAKE_GLOBAL(__PAGE_KERNEL_NOCACHE)
+#define PAGE_KERNEL_LARGE               MAKE_GLOBAL(__PAGE_KERNEL_LARGE)
+#define PAGE_KERNEL_LARGE_EXEC          MAKE_GLOBAL(__PAGE_KERNEL_LARGE_EXEC)
+#define PAGE_KERNEL_VSYSCALL            MAKE_GLOBAL(__PAGE_KERNEL_VSYSCALL)
+#define PAGE_KERNEL_VSYSCALL_NOCACHE    MAKE_GLOBAL(__PAGE_KERNEL_VSYSCALL_NOCACHE)
+/*         xwr */
+#define __P000  PAGE_NONE
+#define __P001  PAGE_READONLY
+#define __P010  PAGE_COPY
+#define __P011  PAGE_COPY
+#define __P100  PAGE_READONLY_EXEC
+#define __P101  PAGE_READONLY_EXEC
+#define __P110  PAGE_COPY_EXEC
+#define __P111  PAGE_COPY_EXEC
+#define __S000  PAGE_NONE
+#define __S001  PAGE_READONLY
+#define __S010  PAGE_SHARED
+#define __S011  PAGE_SHARED
+#define __S100  PAGE_READONLY_EXEC
+#define __S101  PAGE_READONLY_EXEC
+#define __S110  PAGE_SHARED_EXEC
+#define __S111  PAGE_SHARED_EXEC
 #ifdef CONFIG_X86_32
 # include "pgtable_32.h"
 #else
 # include "pgtable_64.h"
 #endif
+#endif  /* _ASM_X86_PGTABLE_H */
diff --git a/include/asm-x86/pgtable_32.h b/include/asm-x86/pgtable_32.h
index 16da5d5cce40..3b40cb6dea18 100644
--- a/include/asm-x86/pgtable_32.h
+++ b/include/asm-x86/pgtable_32.h
@@ -58,9 +58,6 @@ void paging_init(void);
 #define PGDIR_SIZE      (1UL << PGDIR_SHIFT)
 #define PGDIR_MASK      (~(PGDIR_SIZE-1))
-#define USER_PTRS_PER_PGD       (TASK_SIZE/PGDIR_SIZE)
-#define FIRST_USER_ADDRESS      0
 #define USER_PGD_PTRS (PAGE_OFFSET >> PGDIR_SHIFT)
 #define KERNEL_PGD_PTRS (PTRS_PER_PGD-USER_PGD_PTRS)
@@ -85,113 +82,6 @@ void paging_init(void);
 #endif
 /*
- * _PAGE_PSE set in the page directory entry just means that
- * the page directory entry points directly to a 4MB-aligned block of
- * memory. 
- */
-#define _PAGE_BIT_PRESENT       0
-#define _PAGE_BIT_RW            1
-#define _PAGE_BIT_USER          2
-#define _PAGE_BIT_PWT           3
-#define _PAGE_BIT_PCD           4
-#define _PAGE_BIT_ACCESSED      5
-#define _PAGE_BIT_DIRTY         6
-#define _PAGE_BIT_PSE           7       /* 4 MB (or 2MB) page, Pentium+, if present.. */
-#define _PAGE_BIT_GLOBAL        8       /* Global TLB entry PPro+ */
-#define _PAGE_BIT_UNUSED1       9       /* available for programmer */
-#define _PAGE_BIT_UNUSED2       10
-#define _PAGE_BIT_UNUSED3       11
-#define _PAGE_BIT_NX            63
-#define _PAGE_PRESENT   0x001
-#define _PAGE_RW        0x002
-#define _PAGE_USER      0x004
-#define _PAGE_PWT       0x008
-#define _PAGE_PCD       0x010
-#define _PAGE_ACCESSED  0x020
-#define _PAGE_DIRTY     0x040
-#define _PAGE_PSE       0x080   /* 4 MB (or 2MB) page, Pentium+, if present.. */
-#define _PAGE_GLOBAL    0x100   /* Global TLB entry PPro+ */
-#define _PAGE_UNUSED1   0x200   /* available for programmer */
-#define _PAGE_UNUSED2   0x400
-#define _PAGE_UNUSED3   0x800
-/* If _PAGE_PRESENT is clear, we use these: */
-#define _PAGE_FILE      0x040   /* nonlinear file mapping, saved PTE; unset:swap */
-#define _PAGE_PROTNONE  0x080   /* if the user mapped it with PROT_NONE;
-                                   pte_present gives true */
-#ifdef CONFIG_X86_PAE
-#define _PAGE_NX        (1ULL<<_PAGE_BIT_NX)
-#else
-#define _PAGE_NX        0
-#endif
-#define _PAGE_TABLE     (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
-#define _KERNPG_TABLE   (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
-#define _PAGE_CHG_MASK  (PTE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
-#define PAGE_NONE \
-        __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED)
-#define PAGE_SHARED \
-        __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
-#define PAGE_SHARED_EXEC \
-        __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
-#define PAGE_COPY_NOEXEC \
-        __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_NX)
-#define PAGE_COPY_EXEC \
-        __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
-#define PAGE_COPY \
-        PAGE_COPY_NOEXEC
-#define PAGE_READONLY \
-        __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_NX)
-#define PAGE_READONLY_EXEC \
-        __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
-#define _PAGE_KERNEL \
-        (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_NX)
-#define _PAGE_KERNEL_EXEC \
-        (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
-extern unsigned long long __PAGE_KERNEL, __PAGE_KERNEL_EXEC;
-#define __PAGE_KERNEL_RO                (__PAGE_KERNEL & ~_PAGE_RW)
-#define __PAGE_KERNEL_RX                (__PAGE_KERNEL_EXEC & ~_PAGE_RW)
-#define __PAGE_KERNEL_NOCACHE           (__PAGE_KERNEL | _PAGE_PCD | _PAGE_PWT)
-#define __PAGE_KERNEL_LARGE             (__PAGE_KERNEL | _PAGE_PSE)
-#define __PAGE_KERNEL_LARGE_EXEC        (__PAGE_KERNEL_EXEC | _PAGE_PSE)
-#define PAGE_KERNEL             __pgprot(__PAGE_KERNEL)
-#define PAGE_KERNEL_RO          __pgprot(__PAGE_KERNEL_RO)
-#define PAGE_KERNEL_EXEC        __pgprot(__PAGE_KERNEL_EXEC)
-#define PAGE_KERNEL_RX          __pgprot(__PAGE_KERNEL_RX)
-#define PAGE_KERNEL_NOCACHE     __pgprot(__PAGE_KERNEL_NOCACHE)
-#define PAGE_KERNEL_LARGE       __pgprot(__PAGE_KERNEL_LARGE)
-#define PAGE_KERNEL_LARGE_EXEC  __pgprot(__PAGE_KERNEL_LARGE_EXEC)
-/*
- * The i386 can't do page protection for execute, and considers that
- * the same are read. Also, write permissions imply read permissions.
- * This is the closest we can get..
- */
-#define __P000  PAGE_NONE
-#define __P001  PAGE_READONLY
-#define __P010  PAGE_COPY
-#define __P011  PAGE_COPY
-#define __P100  PAGE_READONLY_EXEC
-#define __P101  PAGE_READONLY_EXEC
-#define __P110  PAGE_COPY_EXEC
-#define __P111  PAGE_COPY_EXEC
-#define __S000  PAGE_NONE
-#define __S001  PAGE_READONLY
-#define __S010  PAGE_SHARED
-#define __S011  PAGE_SHARED
-#define __S100  PAGE_READONLY_EXEC
-#define __S101  PAGE_READONLY_EXEC
-#define __S110  PAGE_SHARED_EXEC
-#define __S111  PAGE_SHARED_EXEC
-/*
 * Define this if things work differently on an i386 and an i486:
 * it will (on an i486) warn about kernel memory accesses that are
 * done without a 'access_ok(VERIFY_WRITE,..)'
diff --git a/include/asm-x86/pgtable_64.h b/include/asm-x86/pgtable_64.h
index 9c9cddf5138b..93eb4df2ec11 100644
--- a/include/asm-x86/pgtable_64.h
+++ b/include/asm-x86/pgtable_64.h
@@ -131,8 +131,6 @@ static inline pte_t ptep_get_and_clear_full(struct mm_struct *mm, unsigned long
 #define PGDIR_SIZE      (_AC(1,UL) << PGDIR_SHIFT)
 #define PGDIR_MASK      (~(PGDIR_SIZE-1))
-#define USER_PTRS_PER_PGD       ((TASK_SIZE-1)/PGDIR_SIZE+1)
-#define FIRST_USER_ADDRESS      0
 #define MAXMEM           _AC(0x3fffffffffff, UL)
 #define VMALLOC_START    _AC(0xffffc20000000000, UL)
@@ -142,95 +140,6 @@ static inline pte_t ptep_get_and_clear_full(struct mm_struct *mm, unsigned long
 #define MODULES_END      _AC(0xfffffffffff00000, UL)
 #define MODULES_LEN   (MODULES_END - MODULES_VADDR)
-#define _PAGE_BIT_PRESENT       0
-#define _PAGE_BIT_RW            1
-#define _PAGE_BIT_USER          2
-#define _PAGE_BIT_PWT           3
-#define _PAGE_BIT_PCD           4
-#define _PAGE_BIT_ACCESSED      5
-#define _PAGE_BIT_DIRTY         6
-#define _PAGE_BIT_PSE           7       /* 4 MB (or 2MB) page */
-#define _PAGE_BIT_FILE          6
-#define _PAGE_BIT_GLOBAL        8       /* Global TLB entry PPro+ */
-#define _PAGE_BIT_NX           63       /* No execute: only valid after cpuid check */
-#define _PAGE_PRESENT   (_AC(1, UL)<<_PAGE_BIT_PRESENT)
-#define _PAGE_RW        (_AC(1, UL)<<_PAGE_BIT_RW)
-#define _PAGE_USER      (_AC(1, UL)<<_PAGE_BIT_USER)
-#define _PAGE_PWT       (_AC(1, UL)<<_PAGE_BIT_PWT)
-#define _PAGE_PCD       (_AC(1, UL)<<_PAGE_BIT_PCD)
-#define _PAGE_ACCESSED  (_AC(1, UL)<<_PAGE_BIT_ACCESSED)
-#define _PAGE_DIRTY     (_AC(1, UL)<<_PAGE_BIT_DIRTY)
-/* 2MB page */
-#define _PAGE_PSE       (_AC(1, UL)<<_PAGE_BIT_PSE)
-/* nonlinear file mapping, saved PTE; unset:swap */
-#define _PAGE_FILE      (_AC(1, UL)<<_PAGE_BIT_FILE)
-/* Global TLB entry */
-#define _PAGE_GLOBAL    (_AC(1, UL)<<_PAGE_BIT_GLOBAL)
-#define _PAGE_PROTNONE  0x080   /* If not present */
-#define _PAGE_NX        (_AC(1, UL)<<_PAGE_BIT_NX)
-#define _PAGE_TABLE     (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
-#define _KERNPG_TABLE   (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
-#define _PAGE_CHG_MASK  (PTE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
-#define PAGE_NONE       __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED)
-#define PAGE_SHARED     __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_NX)
-#define PAGE_SHARED_EXEC __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
-#define PAGE_COPY_NOEXEC __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_NX)
-#define PAGE_COPY PAGE_COPY_NOEXEC
-#define PAGE_COPY_EXEC __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
-#define PAGE_READONLY   __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_NX)
-#define PAGE_READONLY_EXEC __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
-#define __PAGE_KERNEL \
-        (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_NX)
-#define __PAGE_KERNEL_EXEC \
-        (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
-#define __PAGE_KERNEL_NOCACHE \
-        (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_PCD | _PAGE_PWT | _PAGE_ACCESSED | _PAGE_NX)
-#define __PAGE_KERNEL_RO \
-        (_PAGE_PRESENT | _PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_NX)
-#define __PAGE_KERNEL_VSYSCALL \
-        (_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
-#define __PAGE_KERNEL_VSYSCALL_NOCACHE \
-        (_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_PCD | _PAGE_PWT)
-#define __PAGE_KERNEL_LARGE \
-        (__PAGE_KERNEL | _PAGE_PSE)
-#define __PAGE_KERNEL_LARGE_EXEC \
-        (__PAGE_KERNEL_EXEC | _PAGE_PSE)
-#define MAKE_GLOBAL(x) __pgprot((x) | _PAGE_GLOBAL)
-#define PAGE_KERNEL MAKE_GLOBAL(__PAGE_KERNEL)
-#define PAGE_KERNEL_EXEC MAKE_GLOBAL(__PAGE_KERNEL_EXEC)
-#define PAGE_KERNEL_RO MAKE_GLOBAL(__PAGE_KERNEL_RO)
-#define PAGE_KERNEL_NOCACHE MAKE_GLOBAL(__PAGE_KERNEL_NOCACHE)
-#define PAGE_KERNEL_VSYSCALL32 __pgprot(__PAGE_KERNEL_VSYSCALL)
-#define PAGE_KERNEL_VSYSCALL MAKE_GLOBAL(__PAGE_KERNEL_VSYSCALL)
-#define PAGE_KERNEL_LARGE MAKE_GLOBAL(__PAGE_KERNEL_LARGE)
-#define PAGE_KERNEL_VSYSCALL_NOCACHE MAKE_GLOBAL(__PAGE_KERNEL_VSYSCALL_NOCACHE)
-/*         xwr */
-#define __P000  PAGE_NONE
-#define __P001  PAGE_READONLY
-#define __P010  PAGE_COPY
-#define __P011  PAGE_COPY
-#define __P100  PAGE_READONLY_EXEC
-#define __P101  PAGE_READONLY_EXEC
-#define __P110  PAGE_COPY_EXEC
-#define __P111  PAGE_COPY_EXEC
-#define __S000  PAGE_NONE
-#define __S001  PAGE_READONLY
-#define __S010  PAGE_SHARED
-#define __S011  PAGE_SHARED
-#define __S100  PAGE_READONLY_EXEC
-#define __S101  PAGE_READONLY_EXEC
-#define __S110  PAGE_SHARED_EXEC
-#define __S111  PAGE_SHARED_EXEC
 #ifndef __ASSEMBLY__
 static inline unsigned long pgd_bad(pgd_t pgd)
author	Jeremy Fitzhardinge <jeremy@goop.org>	2008-01-30 07:32:55 -0500
committer	Ingo Molnar <mingo@elte.hu>	2008-01-30 07:32:55 -0500
commit	6c3866558213ff706d8331053386915371ad63ec (patch)
tree	7c7d4b56c0544abbc2256f078d71a78d3ebfb84d
parent	82bc03fc158e28c90d7ed9919410776039cb4e14 (diff)

diff --git a/include/asm-x86/pgtable.h b/include/asm-x86/pgtable.h index 1039140652af..5b858f0285a8 100644 --- a/include/asm-x86/pgtable.h +++ b/include/asm-x86/pgtable.h
@@ -1,5 +1,124 @@
		1	#ifndef _ASM_X86_PGTABLE_H
		2	#define _ASM_X86_PGTABLE_H
		3
		4	#define USER_PTRS_PER_PGD ((TASK_SIZE-1)/PGDIR_SIZE+1)
		5	#define FIRST_USER_ADDRESS 0
		6
		7	#define _PAGE_BIT_PRESENT 0
		8	#define _PAGE_BIT_RW 1
		9	#define _PAGE_BIT_USER 2
		10	#define _PAGE_BIT_PWT 3
		11	#define _PAGE_BIT_PCD 4
		12	#define _PAGE_BIT_ACCESSED 5
		13	#define _PAGE_BIT_DIRTY 6
		14	#define _PAGE_BIT_FILE 6
		15	#define _PAGE_BIT_PSE 7 /* 4 MB (or 2MB) page */
		16	#define _PAGE_BIT_GLOBAL 8 /* Global TLB entry PPro+ */
		17	#define _PAGE_BIT_UNUSED1 9 /* available for programmer */
		18	#define _PAGE_BIT_UNUSED2 10
		19	#define _PAGE_BIT_UNUSED3 11
		20	#define _PAGE_BIT_NX 63 /* No execute: only valid after cpuid check */
		21
		22	#define _PAGE_PRESENT (_AC(1, UL)<<_PAGE_BIT_PRESENT)
		23	#define _PAGE_RW (_AC(1, UL)<<_PAGE_BIT_RW)
		24	#define _PAGE_USER (_AC(1, UL)<<_PAGE_BIT_USER)
		25	#define _PAGE_PWT (_AC(1, UL)<<_PAGE_BIT_PWT)
		26	#define _PAGE_PCD (_AC(1, UL)<<_PAGE_BIT_PCD)
		27	#define _PAGE_ACCESSED (_AC(1, UL)<<_PAGE_BIT_ACCESSED)
		28	#define _PAGE_DIRTY (_AC(1, UL)<<_PAGE_BIT_DIRTY)
		29	#define _PAGE_PSE (_AC(1, UL)<<_PAGE_BIT_PSE) /* 2MB page */
		30	#define _PAGE_GLOBAL (_AC(1, UL)<<_PAGE_BIT_GLOBAL) /* Global TLB entry */
		31	#define _PAGE_UNUSED1 (_AC(1, UL)<<_PAGE_BIT_UNUSED1)
		32	#define _PAGE_UNUSED2 (_AC(1, UL)<<_PAGE_BIT_UNUSED2)
		33	#define _PAGE_UNUSED3 (_AC(1, UL)<<_PAGE_BIT_UNUSED3)
		34
		35	#if defined(CONFIG_X86_64) \|\| defined(CONFIG_X86_PAE)
		36	#define _PAGE_NX (_AC(1, ULL) << _PAGE_BIT_NX)
		37	#else
		38	#define _PAGE_NX 0
		39	#endif
		40
		41	/* If _PAGE_PRESENT is clear, we use these: */
		42	#define _PAGE_FILE _PAGE_DIRTY /* nonlinear file mapping, saved PTE; unset:swap */
		43	#define _PAGE_PROTNONE _PAGE_PSE /* if the user mapped it with PROT_NONE;
		44	pte_present gives true */
		45
		46	#define _PAGE_TABLE (_PAGE_PRESENT \| _PAGE_RW \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_DIRTY)
		47	#define _KERNPG_TABLE (_PAGE_PRESENT \| _PAGE_RW \| _PAGE_ACCESSED \| _PAGE_DIRTY)
		48
		49	#define _PAGE_CHG_MASK (PTE_MASK \| _PAGE_ACCESSED \| _PAGE_DIRTY)
		50
		51	#define PAGE_NONE __pgprot(_PAGE_PROTNONE \| _PAGE_ACCESSED)
		52	#define PAGE_SHARED __pgprot(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_NX)
		53
		54	#define PAGE_SHARED_EXEC __pgprot(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_USER \| _PAGE_ACCESSED)
		55	#define PAGE_COPY_NOEXEC __pgprot(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_NX)
		56	#define PAGE_COPY_EXEC __pgprot(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED)
		57	#define PAGE_COPY PAGE_COPY_NOEXEC
		58	#define PAGE_READONLY __pgprot(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_NX)
		59	#define PAGE_READONLY_EXEC __pgprot(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED)
		60
		61	#ifdef CONFIG_X86_32
		62	#define _PAGE_KERNEL_EXEC \
		63	(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_DIRTY \| _PAGE_ACCESSED)
		64	#define _PAGE_KERNEL (_PAGE_KERNEL_EXEC \| _PAGE_NX)
		65
		66	#ifndef __ASSEMBLY__
		67	extern unsigned long long __PAGE_KERNEL, __PAGE_KERNEL_EXEC;
		68	#endif /* __ASSEMBLY__ */
		69	#else
		70	#define __PAGE_KERNEL_EXEC \
		71	(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_DIRTY \| _PAGE_ACCESSED)
		72	#define __PAGE_KERNEL (__PAGE_KERNEL_EXEC \| _PAGE_NX)
		73	#endif
		74
		75	#define __PAGE_KERNEL_RO (__PAGE_KERNEL & ~_PAGE_RW)
		76	#define __PAGE_KERNEL_RX (__PAGE_KERNEL_EXEC & ~_PAGE_RW)
		77	#define __PAGE_KERNEL_NOCACHE (__PAGE_KERNEL \| _PAGE_PCD \| _PAGE_PWT)
		78	#define __PAGE_KERNEL_VSYSCALL (__PAGE_KERNEL_RX \| _PAGE_USER)
		79	#define __PAGE_KERNEL_VSYSCALL_NOCACHE (__PAGE_KERNEL_VSYSCALL \| _PAGE_PCD \| _PAGE_PWT)
		80	#define __PAGE_KERNEL_LARGE (__PAGE_KERNEL \| _PAGE_PSE)
		81	#define __PAGE_KERNEL_LARGE_EXEC (__PAGE_KERNEL_EXEC \| _PAGE_PSE)
		82
		83	#ifdef CONFIG_X86_32
		84	# define MAKE_GLOBAL(x) __pgprot((x))
		85	#else
		86	# define MAKE_GLOBAL(x) __pgprot((x) \| _PAGE_GLOBAL)
		87	#endif
		88
		89	#define PAGE_KERNEL MAKE_GLOBAL(__PAGE_KERNEL)
		90	#define PAGE_KERNEL_RO MAKE_GLOBAL(__PAGE_KERNEL_RO)
		91	#define PAGE_KERNEL_EXEC MAKE_GLOBAL(__PAGE_KERNEL_EXEC)
		92	#define PAGE_KERNEL_RX MAKE_GLOBAL(__PAGE_KERNEL_RX)
		93	#define PAGE_KERNEL_NOCACHE MAKE_GLOBAL(__PAGE_KERNEL_NOCACHE)
		94	#define PAGE_KERNEL_LARGE MAKE_GLOBAL(__PAGE_KERNEL_LARGE)
		95	#define PAGE_KERNEL_LARGE_EXEC MAKE_GLOBAL(__PAGE_KERNEL_LARGE_EXEC)
		96	#define PAGE_KERNEL_VSYSCALL MAKE_GLOBAL(__PAGE_KERNEL_VSYSCALL)
		97	#define PAGE_KERNEL_VSYSCALL_NOCACHE MAKE_GLOBAL(__PAGE_KERNEL_VSYSCALL_NOCACHE)
		98
		99	/* xwr */
		100	#define __P000 PAGE_NONE
		101	#define __P001 PAGE_READONLY
		102	#define __P010 PAGE_COPY
		103	#define __P011 PAGE_COPY
		104	#define __P100 PAGE_READONLY_EXEC
		105	#define __P101 PAGE_READONLY_EXEC
		106	#define __P110 PAGE_COPY_EXEC
		107	#define __P111 PAGE_COPY_EXEC
		108
		109	#define __S000 PAGE_NONE
		110	#define __S001 PAGE_READONLY
		111	#define __S010 PAGE_SHARED
		112	#define __S011 PAGE_SHARED
		113	#define __S100 PAGE_READONLY_EXEC
		114	#define __S101 PAGE_READONLY_EXEC
		115	#define __S110 PAGE_SHARED_EXEC
		116	#define __S111 PAGE_SHARED_EXEC
		117
1	#ifdef CONFIG_X86_32	118	#ifdef CONFIG_X86_32
2	# include "pgtable_32.h"	119	# include "pgtable_32.h"
3	#else	120	#else
4	# include "pgtable_64.h"	121	# include "pgtable_64.h"
5	#endif	122	#endif
		123
		124	#endif /* _ASM_X86_PGTABLE_H */


diff --git a/include/asm-x86/pgtable_32.h b/include/asm-x86/pgtable_32.h index 16da5d5cce40..3b40cb6dea18 100644 --- a/include/asm-x86/pgtable_32.h +++ b/include/asm-x86/pgtable_32.h
@@ -58,9 +58,6 @@ void paging_init(void);
58	#define PGDIR_SIZE (1UL << PGDIR_SHIFT)	58	#define PGDIR_SIZE (1UL << PGDIR_SHIFT)
59	#define PGDIR_MASK (~(PGDIR_SIZE-1))	59	#define PGDIR_MASK (~(PGDIR_SIZE-1))
60		60
61	#define USER_PTRS_PER_PGD (TASK_SIZE/PGDIR_SIZE)
62	#define FIRST_USER_ADDRESS 0
63
64	#define USER_PGD_PTRS (PAGE_OFFSET >> PGDIR_SHIFT)	61	#define USER_PGD_PTRS (PAGE_OFFSET >> PGDIR_SHIFT)
65	#define KERNEL_PGD_PTRS (PTRS_PER_PGD-USER_PGD_PTRS)	62	#define KERNEL_PGD_PTRS (PTRS_PER_PGD-USER_PGD_PTRS)
66		63
@@ -85,113 +82,6 @@ void paging_init(void);
85	#endif	82	#endif
86		83
87	/*	84	/*
88	* _PAGE_PSE set in the page directory entry just means that
89	* the page directory entry points directly to a 4MB-aligned block of
90	* memory.
91	*/
92	#define _PAGE_BIT_PRESENT 0
93	#define _PAGE_BIT_RW 1
94	#define _PAGE_BIT_USER 2
95	#define _PAGE_BIT_PWT 3
96	#define _PAGE_BIT_PCD 4
97	#define _PAGE_BIT_ACCESSED 5
98	#define _PAGE_BIT_DIRTY 6
99	#define _PAGE_BIT_PSE 7 /* 4 MB (or 2MB) page, Pentium+, if present.. */
100	#define _PAGE_BIT_GLOBAL 8 /* Global TLB entry PPro+ */
101	#define _PAGE_BIT_UNUSED1 9 /* available for programmer */
102	#define _PAGE_BIT_UNUSED2 10
103	#define _PAGE_BIT_UNUSED3 11
104	#define _PAGE_BIT_NX 63
105
106	#define _PAGE_PRESENT 0x001
107	#define _PAGE_RW 0x002
108	#define _PAGE_USER 0x004
109	#define _PAGE_PWT 0x008
110	#define _PAGE_PCD 0x010
111	#define _PAGE_ACCESSED 0x020
112	#define _PAGE_DIRTY 0x040
113	#define _PAGE_PSE 0x080 /* 4 MB (or 2MB) page, Pentium+, if present.. */
114	#define _PAGE_GLOBAL 0x100 /* Global TLB entry PPro+ */
115	#define _PAGE_UNUSED1 0x200 /* available for programmer */
116	#define _PAGE_UNUSED2 0x400
117	#define _PAGE_UNUSED3 0x800
118
119	/* If _PAGE_PRESENT is clear, we use these: */
120	#define _PAGE_FILE 0x040 /* nonlinear file mapping, saved PTE; unset:swap */
121	#define _PAGE_PROTNONE 0x080 /* if the user mapped it with PROT_NONE;
122	pte_present gives true */
123	#ifdef CONFIG_X86_PAE
124	#define _PAGE_NX (1ULL<<_PAGE_BIT_NX)
125	#else
126	#define _PAGE_NX 0
127	#endif
128
129	#define _PAGE_TABLE (_PAGE_PRESENT \| _PAGE_RW \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_DIRTY)
130	#define _KERNPG_TABLE (_PAGE_PRESENT \| _PAGE_RW \| _PAGE_ACCESSED \| _PAGE_DIRTY)
131	#define _PAGE_CHG_MASK (PTE_MASK \| _PAGE_ACCESSED \| _PAGE_DIRTY)
132
133	#define PAGE_NONE \
134	__pgprot(_PAGE_PROTNONE \| _PAGE_ACCESSED)
135	#define PAGE_SHARED \
136	__pgprot(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_USER \| _PAGE_ACCESSED)
137
138	#define PAGE_SHARED_EXEC \
139	__pgprot(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_USER \| _PAGE_ACCESSED)
140	#define PAGE_COPY_NOEXEC \
141	__pgprot(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_NX)
142	#define PAGE_COPY_EXEC \
143	__pgprot(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED)
144	#define PAGE_COPY \
145	PAGE_COPY_NOEXEC
146	#define PAGE_READONLY \
147	__pgprot(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_NX)
148	#define PAGE_READONLY_EXEC \
149	__pgprot(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED)
150
151	#define _PAGE_KERNEL \
152	(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_DIRTY \| _PAGE_ACCESSED \| _PAGE_NX)
153	#define _PAGE_KERNEL_EXEC \
154	(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_DIRTY \| _PAGE_ACCESSED)
155
156	extern unsigned long long __PAGE_KERNEL, __PAGE_KERNEL_EXEC;
157	#define __PAGE_KERNEL_RO (__PAGE_KERNEL & ~_PAGE_RW)
158	#define __PAGE_KERNEL_RX (__PAGE_KERNEL_EXEC & ~_PAGE_RW)
159	#define __PAGE_KERNEL_NOCACHE (__PAGE_KERNEL \| _PAGE_PCD \| _PAGE_PWT)
160	#define __PAGE_KERNEL_LARGE (__PAGE_KERNEL \| _PAGE_PSE)
161	#define __PAGE_KERNEL_LARGE_EXEC (__PAGE_KERNEL_EXEC \| _PAGE_PSE)
162
163	#define PAGE_KERNEL __pgprot(__PAGE_KERNEL)
164	#define PAGE_KERNEL_RO __pgprot(__PAGE_KERNEL_RO)
165	#define PAGE_KERNEL_EXEC __pgprot(__PAGE_KERNEL_EXEC)
166	#define PAGE_KERNEL_RX __pgprot(__PAGE_KERNEL_RX)
167	#define PAGE_KERNEL_NOCACHE __pgprot(__PAGE_KERNEL_NOCACHE)
168	#define PAGE_KERNEL_LARGE __pgprot(__PAGE_KERNEL_LARGE)
169	#define PAGE_KERNEL_LARGE_EXEC __pgprot(__PAGE_KERNEL_LARGE_EXEC)
170
171	/*
172	* The i386 can't do page protection for execute, and considers that
173	* the same are read. Also, write permissions imply read permissions.
174	* This is the closest we can get..
175	*/
176	#define __P000 PAGE_NONE
177	#define __P001 PAGE_READONLY
178	#define __P010 PAGE_COPY
179	#define __P011 PAGE_COPY
180	#define __P100 PAGE_READONLY_EXEC
181	#define __P101 PAGE_READONLY_EXEC
182	#define __P110 PAGE_COPY_EXEC
183	#define __P111 PAGE_COPY_EXEC
184
185	#define __S000 PAGE_NONE
186	#define __S001 PAGE_READONLY
187	#define __S010 PAGE_SHARED
188	#define __S011 PAGE_SHARED
189	#define __S100 PAGE_READONLY_EXEC
190	#define __S101 PAGE_READONLY_EXEC
191	#define __S110 PAGE_SHARED_EXEC
192	#define __S111 PAGE_SHARED_EXEC
193
194	/*
195	* Define this if things work differently on an i386 and an i486:	85	* Define this if things work differently on an i386 and an i486:
196	* it will (on an i486) warn about kernel memory accesses that are	86	* it will (on an i486) warn about kernel memory accesses that are
197	* done without a 'access_ok(VERIFY_WRITE,..)'	87	* done without a 'access_ok(VERIFY_WRITE,..)'


diff --git a/include/asm-x86/pgtable_64.h b/include/asm-x86/pgtable_64.h index 9c9cddf5138b..93eb4df2ec11 100644 --- a/include/asm-x86/pgtable_64.h +++ b/include/asm-x86/pgtable_64.h
@@ -131,8 +131,6 @@ static inline pte_t ptep_get_and_clear_full(struct mm_struct *mm, unsigned long
131	#define PGDIR_SIZE (_AC(1,UL) << PGDIR_SHIFT)	131	#define PGDIR_SIZE (_AC(1,UL) << PGDIR_SHIFT)
132	#define PGDIR_MASK (~(PGDIR_SIZE-1))	132	#define PGDIR_MASK (~(PGDIR_SIZE-1))
133		133
134	#define USER_PTRS_PER_PGD ((TASK_SIZE-1)/PGDIR_SIZE+1)
135	#define FIRST_USER_ADDRESS 0
136		134
137	#define MAXMEM _AC(0x3fffffffffff, UL)	135	#define MAXMEM _AC(0x3fffffffffff, UL)
138	#define VMALLOC_START _AC(0xffffc20000000000, UL)	136	#define VMALLOC_START _AC(0xffffc20000000000, UL)
@@ -142,95 +140,6 @@ static inline pte_t ptep_get_and_clear_full(struct mm_struct *mm, unsigned long
142	#define MODULES_END _AC(0xfffffffffff00000, UL)	140	#define MODULES_END _AC(0xfffffffffff00000, UL)
143	#define MODULES_LEN (MODULES_END - MODULES_VADDR)	141	#define MODULES_LEN (MODULES_END - MODULES_VADDR)
144		142
145	#define _PAGE_BIT_PRESENT 0
146	#define _PAGE_BIT_RW 1
147	#define _PAGE_BIT_USER 2
148	#define _PAGE_BIT_PWT 3
149	#define _PAGE_BIT_PCD 4
150	#define _PAGE_BIT_ACCESSED 5
151	#define _PAGE_BIT_DIRTY 6
152	#define _PAGE_BIT_PSE 7 /* 4 MB (or 2MB) page */
153	#define _PAGE_BIT_FILE 6
154	#define _PAGE_BIT_GLOBAL 8 /* Global TLB entry PPro+ */
155	#define _PAGE_BIT_NX 63 /* No execute: only valid after cpuid check */
156
157	#define _PAGE_PRESENT (_AC(1, UL)<<_PAGE_BIT_PRESENT)
158	#define _PAGE_RW (_AC(1, UL)<<_PAGE_BIT_RW)
159	#define _PAGE_USER (_AC(1, UL)<<_PAGE_BIT_USER)
160	#define _PAGE_PWT (_AC(1, UL)<<_PAGE_BIT_PWT)
161	#define _PAGE_PCD (_AC(1, UL)<<_PAGE_BIT_PCD)
162	#define _PAGE_ACCESSED (_AC(1, UL)<<_PAGE_BIT_ACCESSED)
163	#define _PAGE_DIRTY (_AC(1, UL)<<_PAGE_BIT_DIRTY)
164	/* 2MB page */
165	#define _PAGE_PSE (_AC(1, UL)<<_PAGE_BIT_PSE)
166	/* nonlinear file mapping, saved PTE; unset:swap */
167	#define _PAGE_FILE (_AC(1, UL)<<_PAGE_BIT_FILE)
168	/* Global TLB entry */
169	#define _PAGE_GLOBAL (_AC(1, UL)<<_PAGE_BIT_GLOBAL)
170
171	#define _PAGE_PROTNONE 0x080 /* If not present */
172	#define _PAGE_NX (_AC(1, UL)<<_PAGE_BIT_NX)
173
174	#define _PAGE_TABLE (_PAGE_PRESENT \| _PAGE_RW \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_DIRTY)
175	#define _KERNPG_TABLE (_PAGE_PRESENT \| _PAGE_RW \| _PAGE_ACCESSED \| _PAGE_DIRTY)
176
177	#define _PAGE_CHG_MASK (PTE_MASK \| _PAGE_ACCESSED \| _PAGE_DIRTY)
178
179	#define PAGE_NONE __pgprot(_PAGE_PROTNONE \| _PAGE_ACCESSED)
180	#define PAGE_SHARED __pgprot(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_NX)
181	#define PAGE_SHARED_EXEC __pgprot(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_USER \| _PAGE_ACCESSED)
182	#define PAGE_COPY_NOEXEC __pgprot(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_NX)
183	#define PAGE_COPY PAGE_COPY_NOEXEC
184	#define PAGE_COPY_EXEC __pgprot(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED)
185	#define PAGE_READONLY __pgprot(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_NX)
186	#define PAGE_READONLY_EXEC __pgprot(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED)
187	#define __PAGE_KERNEL \
188	(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_DIRTY \| _PAGE_ACCESSED \| _PAGE_NX)
189	#define __PAGE_KERNEL_EXEC \
190	(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_DIRTY \| _PAGE_ACCESSED)
191	#define __PAGE_KERNEL_NOCACHE \
192	(_PAGE_PRESENT \| _PAGE_RW \| _PAGE_DIRTY \| _PAGE_PCD \| _PAGE_PWT \| _PAGE_ACCESSED \| _PAGE_NX)
193	#define __PAGE_KERNEL_RO \
194	(_PAGE_PRESENT \| _PAGE_DIRTY \| _PAGE_ACCESSED \| _PAGE_NX)
195	#define __PAGE_KERNEL_VSYSCALL \
196	(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED)
197	#define __PAGE_KERNEL_VSYSCALL_NOCACHE \
198	(_PAGE_PRESENT \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_PCD \| _PAGE_PWT)
199	#define __PAGE_KERNEL_LARGE \
200	(__PAGE_KERNEL \| _PAGE_PSE)
201	#define __PAGE_KERNEL_LARGE_EXEC \
202	(__PAGE_KERNEL_EXEC \| _PAGE_PSE)
203
204	#define MAKE_GLOBAL(x) __pgprot((x) \| _PAGE_GLOBAL)
205
206	#define PAGE_KERNEL MAKE_GLOBAL(__PAGE_KERNEL)
207	#define PAGE_KERNEL_EXEC MAKE_GLOBAL(__PAGE_KERNEL_EXEC)
208	#define PAGE_KERNEL_RO MAKE_GLOBAL(__PAGE_KERNEL_RO)
209	#define PAGE_KERNEL_NOCACHE MAKE_GLOBAL(__PAGE_KERNEL_NOCACHE)
210	#define PAGE_KERNEL_VSYSCALL32 __pgprot(__PAGE_KERNEL_VSYSCALL)
211	#define PAGE_KERNEL_VSYSCALL MAKE_GLOBAL(__PAGE_KERNEL_VSYSCALL)
212	#define PAGE_KERNEL_LARGE MAKE_GLOBAL(__PAGE_KERNEL_LARGE)
213	#define PAGE_KERNEL_VSYSCALL_NOCACHE MAKE_GLOBAL(__PAGE_KERNEL_VSYSCALL_NOCACHE)
214
215	/* xwr */
216	#define __P000 PAGE_NONE
217	#define __P001 PAGE_READONLY
218	#define __P010 PAGE_COPY
219	#define __P011 PAGE_COPY
220	#define __P100 PAGE_READONLY_EXEC
221	#define __P101 PAGE_READONLY_EXEC
222	#define __P110 PAGE_COPY_EXEC
223	#define __P111 PAGE_COPY_EXEC
224
225	#define __S000 PAGE_NONE
226	#define __S001 PAGE_READONLY
227	#define __S010 PAGE_SHARED
228	#define __S011 PAGE_SHARED
229	#define __S100 PAGE_READONLY_EXEC
230	#define __S101 PAGE_READONLY_EXEC
231	#define __S110 PAGE_SHARED_EXEC
232	#define __S111 PAGE_SHARED_EXEC
233
234	#ifndef __ASSEMBLY__	143	#ifndef __ASSEMBLY__
235		144
236	static inline unsigned long pgd_bad(pgd_t pgd)	145	static inline unsigned long pgd_bad(pgd_t pgd)