]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - include/asm-um/pgtable.h
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
11 #include "linux/sched.h"
12 #include "linux/linkage.h"
13 #include "asm/processor.h"
15 #include "asm/fixmap.h"
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 */
29 #ifdef CONFIG_3_LEVEL_PGTABLES
30 #include "asm/pgtable-3level.h"
32 #include "asm/pgtable-2level.h"
35 extern pgd_t swapper_pg_dir
[PTRS_PER_PGD
];
37 extern void *um_virt_to_phys(struct task_struct
*task
, unsigned long virt
,
40 /* zero page used for uninitialized stuff */
41 extern unsigned long *empty_zero_page
;
43 #define pgtable_cache_init() do ; while (0)
46 * pgd entries used up by user/kernel:
49 #define USER_PGD_PTRS (TASK_SIZE >> PGDIR_SHIFT)
50 #define KERNEL_PGD_PTRS (PTRS_PER_PGD-USER_PGD_PTRS)
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. ;)
61 extern unsigned long end_iomem
;
63 #define VMALLOC_OFFSET (__va_space)
64 #define VMALLOC_START ((end_iomem + VMALLOC_OFFSET) & ~(VMALLOC_OFFSET-1))
67 # define VMALLOC_END (PKMAP_BASE-2*PAGE_SIZE)
69 # define VMALLOC_END (FIXADDR_START-2*PAGE_SIZE)
72 #define REGION_SHIFT (sizeof(pte_t) * 8 - 4)
73 #define REGION_MASK (((unsigned long) 0xf) << REGION_SHIFT)
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)
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)
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..
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
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
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,..)'
113 #undef TEST_VERIFY_AREA
115 /* page table for 0-4MB for everybody */
116 extern unsigned long pg0
[1024];
119 * ZERO_PAGE is a global shared page that is always zero: used
120 * for zero-mapped memory areas etc..
123 #define ZERO_PAGE(vaddr) virt_to_page(empty_zero_page)
125 /* number of bits that fit into a memory pointer */
126 #define BITS_PER_PTR (8*sizeof(unsigned long))
128 /* to align the pointer to a pointer address */
129 #define PTR_MASK (~(sizeof(void*)-1))
131 /* sizeof(void*)==1<<SIZEOF_PTR_LOG2 */
132 /* 64-bit machines, beware! SRB. */
133 #define SIZEOF_PTR_LOG2 3
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)
139 #define pte_clear(mm,addr,xp) pte_set_val(*(xp), (phys_t) 0, __pgprot(_PAGE_NEWPAGE))
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)
146 #define pmd_newpage(x) (pmd_val(x) & _PAGE_NEWPAGE)
147 #define pmd_mkuptodate(x) (pmd_val(x) &= ~_PAGE_NEWPAGE)
149 #define pud_newpage(x) (pud_val(x) & _PAGE_NEWPAGE)
150 #define pud_mkuptodate(x) (pud_val(x) &= ~_PAGE_NEWPAGE)
152 #define pages_to_mb(x) ((x) >> (20-PAGE_SHIFT))
154 #define pmd_page(pmd) phys_to_page(pmd_val(pmd) & PAGE_MASK)
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)
161 #define pte_present(x) pte_get_bits(x, (_PAGE_PRESENT | _PAGE_PROTNONE))
164 * =================================
165 * Flags checking section.
166 * =================================
169 static inline int pte_none(pte_t pte
)
171 return pte_is_zero(pte
);
175 * The following only work if pte_present() is true.
176 * Undefined behaviour if not..
178 static inline int pte_user(pte_t pte
)
180 return((pte_get_bits(pte
, _PAGE_USER
)) &&
181 !(pte_get_bits(pte
, _PAGE_PROTNONE
)));
184 static inline int pte_read(pte_t pte
)
186 return((pte_get_bits(pte
, _PAGE_USER
)) &&
187 !(pte_get_bits(pte
, _PAGE_PROTNONE
)));
190 static inline int pte_exec(pte_t pte
){
191 return((pte_get_bits(pte
, _PAGE_USER
)) &&
192 !(pte_get_bits(pte
, _PAGE_PROTNONE
)));
195 static inline int pte_write(pte_t pte
)
197 return((pte_get_bits(pte
, _PAGE_RW
)) &&
198 !(pte_get_bits(pte
, _PAGE_PROTNONE
)));
202 * The following only works if pte_present() is not true.
204 static inline int pte_file(pte_t pte
)
206 return pte_get_bits(pte
, _PAGE_FILE
);
209 static inline int pte_dirty(pte_t pte
)
211 return pte_get_bits(pte
, _PAGE_DIRTY
);
214 static inline int pte_young(pte_t pte
)
216 return pte_get_bits(pte
, _PAGE_ACCESSED
);
219 static inline int pte_newpage(pte_t pte
)
221 return pte_get_bits(pte
, _PAGE_NEWPAGE
);
224 static inline int pte_newprot(pte_t pte
)
226 return(pte_present(pte
) && (pte_get_bits(pte
, _PAGE_NEWPROT
)));
230 * =================================
231 * Flags setting section.
232 * =================================
235 static inline pte_t
pte_mknewprot(pte_t pte
)
237 pte_set_bits(pte
, _PAGE_NEWPROT
);
241 static inline pte_t
pte_rdprotect(pte_t pte
)
243 pte_clear_bits(pte
, _PAGE_USER
);
244 return(pte_mknewprot(pte
));
247 static inline pte_t
pte_exprotect(pte_t pte
)
249 pte_clear_bits(pte
, _PAGE_USER
);
250 return(pte_mknewprot(pte
));
253 static inline pte_t
pte_mkclean(pte_t pte
)
255 pte_clear_bits(pte
, _PAGE_DIRTY
);
259 static inline pte_t
pte_mkold(pte_t pte
)
261 pte_clear_bits(pte
, _PAGE_ACCESSED
);
265 static inline pte_t
pte_wrprotect(pte_t pte
)
267 pte_clear_bits(pte
, _PAGE_RW
);
268 return(pte_mknewprot(pte
));
271 static inline pte_t
pte_mkread(pte_t pte
)
273 pte_set_bits(pte
, _PAGE_RW
);
274 return(pte_mknewprot(pte
));
277 static inline pte_t
pte_mkexec(pte_t pte
)
279 pte_set_bits(pte
, _PAGE_USER
);
280 return(pte_mknewprot(pte
));
283 static inline pte_t
pte_mkdirty(pte_t pte
)
285 pte_set_bits(pte
, _PAGE_DIRTY
);
289 static inline pte_t
pte_mkyoung(pte_t pte
)
291 pte_set_bits(pte
, _PAGE_ACCESSED
);
295 static inline pte_t
pte_mkwrite(pte_t pte
)
297 pte_set_bits(pte
, _PAGE_RW
);
298 return(pte_mknewprot(pte
));
301 static inline pte_t
pte_mkuptodate(pte_t pte
)
303 pte_clear_bits(pte
, _PAGE_NEWPAGE
);
305 pte_clear_bits(pte
, _PAGE_NEWPROT
);
309 static inline pte_t
pte_mknewpage(pte_t pte
)
311 pte_set_bits(pte
, _PAGE_NEWPAGE
);
315 static inline void set_pte(pte_t
*pteptr
, pte_t pteval
)
317 pte_copy(*pteptr
, pteval
);
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
324 *pteptr
= pte_mknewpage(*pteptr
);
325 if(pte_present(*pteptr
)) *pteptr
= pte_mknewprot(*pteptr
);
327 #define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
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.
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))
338 #define mk_pte(page, pgprot) \
341 pte_set_val(pte, page_to_phys(page), (pgprot)); \
342 if (pte_present(pte)) \
343 pte_mknewprot(pte_mknewpage(pte)); \
346 static inline pte_t
pte_modify(pte_t pte
, pgprot_t newprot
)
348 pte_set_val(pte
, (pte_val(pte
) & _PAGE_CHG_MASK
), newprot
);
352 #define pmd_page_kernel(pmd) ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
355 * the pgd page can be thought of an array like this: pgd_t[PTRS_PER_PGD]
357 * this macro returns the index of the entry in the pgd page which would
358 * control the given virtual address
360 #define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
362 #define pgd_index_k(addr) pgd_index(addr)
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;
368 #define pgd_offset(mm, address) ((mm)->pgd+pgd_index(address))
371 * a shortcut which implies the use of the kernel's pgd, instead
374 #define pgd_offset_k(address) pgd_offset(&init_mm, address)
377 * the pmd page can be thought of an array like this: pmd_t[PTRS_PER_PMD]
379 * this macro returns the index of the entry in the pmd page which would
380 * control the given virtual address
382 #define pmd_index(address) (((address) >> PMD_SHIFT) & (PTRS_PER_PMD-1))
385 * the pte page can be thought of an array like this: pte_t[PTRS_PER_PTE]
387 * this macro returns the index of the entry in the pte page which would
388 * control the given virtual address
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)
399 #define update_mmu_cache(vma,address,pte) do ; while (0)
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)
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 })
411 #define kern_addr_valid(addr) (1)
413 #include <asm-generic/pgtable.h>
415 #include <asm-generic/pgtable-nopud.h>
420 #define virt_to_page(addr) __virt_to_page((const unsigned long) addr)
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
427 * ---------------------------------------------------------------------------
429 * c-file-style: "linux"