blob: 830fc6e5d49d0f41c87ab3e555ecea3a9fa3287f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Paolo 'Blaisorblade' Giarrusso9b4ee402005-09-03 15:54:57 -070019#define _PAGE_NEWPROT 0x004
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#define _PAGE_RW 0x020
21#define _PAGE_USER 0x040
22#define _PAGE_ACCESSED 0x080
23#define _PAGE_DIRTY 0x100
Paolo 'Blaisorblade' Giarrusso9b4ee402005-09-03 15:54:57 -070024/* 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29#ifdef CONFIG_3_LEVEL_PGTABLES
30#include "asm/pgtable-3level.h"
31#else
32#include "asm/pgtable-2level.h"
33#endif
34
35extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
36
37extern 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 */
41extern 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
61extern 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
Jesper Juhl3d675542005-05-05 16:16:13 -0700111 * done without a 'access_ok(VERIFY_WRITE,..)'
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 */
113#undef TEST_VERIFY_AREA
114
115/* page table for 0-4MB for everybody */
116extern unsigned long pg0[1024];
117
118/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 * ZERO_PAGE is a global shared page that is always zero: used
120 * for zero-mapped memory areas etc..
121 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122
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
Hugh Dickins705e87c2005-10-29 18:16:27 -0700141#define pmd_none(x) (!((unsigned long)pmd_val(x) & ~_PAGE_NEWPAGE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142#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
Jeff Dike08964c52005-09-03 15:57:41 -0700156#define pte_page(x) pfn_to_page(pte_pfn(x))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157#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
Jeff Dike08964c52005-09-03 15:57:41 -0700161#define pte_present(x) pte_get_bits(x, (_PAGE_PRESENT | _PAGE_PROTNONE))
162
163/*
164 * =================================
165 * Flags checking section.
166 * =================================
167 */
168
169static inline int pte_none(pte_t pte)
170{
171 return pte_is_zero(pte);
172}
173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174/*
175 * The following only work if pte_present() is true.
176 * Undefined behaviour if not..
177 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178static inline int pte_read(pte_t pte)
179{
180 return((pte_get_bits(pte, _PAGE_USER)) &&
181 !(pte_get_bits(pte, _PAGE_PROTNONE)));
182}
183
184static inline int pte_exec(pte_t pte){
185 return((pte_get_bits(pte, _PAGE_USER)) &&
186 !(pte_get_bits(pte, _PAGE_PROTNONE)));
187}
188
189static inline int pte_write(pte_t pte)
190{
191 return((pte_get_bits(pte, _PAGE_RW)) &&
192 !(pte_get_bits(pte, _PAGE_PROTNONE)));
193}
194
195/*
196 * The following only works if pte_present() is not true.
197 */
198static inline int pte_file(pte_t pte)
199{
200 return pte_get_bits(pte, _PAGE_FILE);
201}
202
203static inline int pte_dirty(pte_t pte)
204{
205 return pte_get_bits(pte, _PAGE_DIRTY);
206}
207
208static inline int pte_young(pte_t pte)
209{
210 return pte_get_bits(pte, _PAGE_ACCESSED);
211}
212
213static inline int pte_newpage(pte_t pte)
214{
215 return pte_get_bits(pte, _PAGE_NEWPAGE);
216}
217
218static inline int pte_newprot(pte_t pte)
219{
220 return(pte_present(pte) && (pte_get_bits(pte, _PAGE_NEWPROT)));
221}
222
Jeff Dike08964c52005-09-03 15:57:41 -0700223/*
224 * =================================
225 * Flags setting section.
226 * =================================
227 */
228
229static inline pte_t pte_mknewprot(pte_t pte)
230{
231 pte_set_bits(pte, _PAGE_NEWPROT);
232 return(pte);
233}
234
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235static inline pte_t pte_mkclean(pte_t pte)
236{
237 pte_clear_bits(pte, _PAGE_DIRTY);
238 return(pte);
239}
240
241static inline pte_t pte_mkold(pte_t pte)
242{
243 pte_clear_bits(pte, _PAGE_ACCESSED);
244 return(pte);
245}
246
247static inline pte_t pte_wrprotect(pte_t pte)
248{
249 pte_clear_bits(pte, _PAGE_RW);
250 return(pte_mknewprot(pte));
251}
252
253static inline pte_t pte_mkread(pte_t pte)
254{
Jeff Dike1463fdb2007-02-28 20:13:33 -0800255 pte_set_bits(pte, _PAGE_USER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 return(pte_mknewprot(pte));
257}
258
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259static inline pte_t pte_mkdirty(pte_t pte)
260{
261 pte_set_bits(pte, _PAGE_DIRTY);
262 return(pte);
263}
264
265static inline pte_t pte_mkyoung(pte_t pte)
266{
267 pte_set_bits(pte, _PAGE_ACCESSED);
268 return(pte);
269}
270
271static inline pte_t pte_mkwrite(pte_t pte)
272{
273 pte_set_bits(pte, _PAGE_RW);
274 return(pte_mknewprot(pte));
275}
276
277static inline pte_t pte_mkuptodate(pte_t pte)
278{
279 pte_clear_bits(pte, _PAGE_NEWPAGE);
280 if(pte_present(pte))
281 pte_clear_bits(pte, _PAGE_NEWPROT);
282 return(pte);
283}
284
Jeff Dike08964c52005-09-03 15:57:41 -0700285static inline pte_t pte_mknewpage(pte_t pte)
286{
287 pte_set_bits(pte, _PAGE_NEWPAGE);
288 return(pte);
289}
290
291static inline void set_pte(pte_t *pteptr, pte_t pteval)
292{
293 pte_copy(*pteptr, pteval);
294
295 /* If it's a swap entry, it needs to be marked _PAGE_NEWPAGE so
296 * fix_range knows to unmap it. _PAGE_NEWPROT is specific to
297 * mapped pages.
298 */
299
300 *pteptr = pte_mknewpage(*pteptr);
301 if(pte_present(*pteptr)) *pteptr = pte_mknewprot(*pteptr);
302}
303#define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
304
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305/*
306 * Conversion functions: convert a page and protection to a page entry,
307 * and a page entry and page directory to the page they refer to.
308 */
309
Paolo 'Blaisorblade' Giarrussod99c4022005-09-10 19:44:56 +0200310#define phys_to_page(phys) pfn_to_page(phys_to_pfn(phys))
311#define __virt_to_page(virt) phys_to_page(__pa(virt))
312#define page_to_phys(page) pfn_to_phys(page_to_pfn(page))
313
314#define mk_pte(page, pgprot) \
315 ({ pte_t pte; \
316 \
317 pte_set_val(pte, page_to_phys(page), (pgprot)); \
318 if (pte_present(pte)) \
319 pte_mknewprot(pte_mknewpage(pte)); \
320 pte;})
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
322static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
323{
324 pte_set_val(pte, (pte_val(pte) & _PAGE_CHG_MASK), newprot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 return pte;
326}
327
Dave McCracken46a82b22006-09-25 23:31:48 -0700328#define pmd_page_vaddr(pmd) ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
330/*
331 * the pgd page can be thought of an array like this: pgd_t[PTRS_PER_PGD]
332 *
333 * this macro returns the index of the entry in the pgd page which would
334 * control the given virtual address
335 */
336#define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
337
338#define pgd_index_k(addr) pgd_index(addr)
339
340/*
341 * pgd_offset() returns a (pgd_t *)
342 * pgd_index() is used get the offset into the pgd page's array of pgd_t's;
343 */
344#define pgd_offset(mm, address) ((mm)->pgd+pgd_index(address))
345
346/*
347 * a shortcut which implies the use of the kernel's pgd, instead
348 * of a process's
349 */
350#define pgd_offset_k(address) pgd_offset(&init_mm, address)
351
352/*
353 * the pmd page can be thought of an array like this: pmd_t[PTRS_PER_PMD]
354 *
355 * this macro returns the index of the entry in the pmd page which would
356 * control the given virtual address
357 */
358#define pmd_index(address) (((address) >> PMD_SHIFT) & (PTRS_PER_PMD-1))
359
360/*
361 * the pte page can be thought of an array like this: pte_t[PTRS_PER_PTE]
362 *
363 * this macro returns the index of the entry in the pte page which would
364 * control the given virtual address
365 */
366#define pte_index(address) (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
367#define pte_offset_kernel(dir, address) \
Dave McCracken46a82b22006-09-25 23:31:48 -0700368 ((pte_t *) pmd_page_vaddr(*(dir)) + pte_index(address))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369#define pte_offset_map(dir, address) \
370 ((pte_t *)page_address(pmd_page(*(dir))) + pte_index(address))
371#define pte_offset_map_nested(dir, address) pte_offset_map(dir, address)
372#define pte_unmap(pte) do { } while (0)
373#define pte_unmap_nested(pte) do { } while (0)
374
375#define update_mmu_cache(vma,address,pte) do ; while (0)
376
377/* Encode and de-code a swap entry */
378#define __swp_type(x) (((x).val >> 4) & 0x3f)
379#define __swp_offset(x) ((x).val >> 11)
380
381#define __swp_entry(type, offset) \
382 ((swp_entry_t) { ((type) << 4) | ((offset) << 11) })
383#define __pte_to_swp_entry(pte) \
384 ((swp_entry_t) { pte_val(pte_mkuptodate(pte)) })
385#define __swp_entry_to_pte(x) ((pte_t) { (x).val })
386
387#define kern_addr_valid(addr) (1)
388
389#include <asm-generic/pgtable.h>
390
391#include <asm-generic/pgtable-nopud.h>
392
Al Viro04add672007-02-01 13:53:04 +0000393#ifdef CONFIG_HIGHMEM
394/* Clear a kernel PTE and flush it from the TLB */
395#define kpte_clear_flush(ptep, vaddr) \
396do { \
397 pte_clear(&init_mm, vaddr, ptep); \
398 __flush_tlb_one(vaddr); \
399} while (0)
400#endif
401
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402#endif
403#endif
404
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405#define virt_to_page(addr) __virt_to_page((const unsigned long) addr)
406
407/*
408 * Overrides for Emacs so that we follow Linus's tabbing style.
409 * Emacs will notice this stuff at the end of the file and automatically
410 * adjust the settings for this buffer only. This must remain at the end
411 * of the file.
412 * ---------------------------------------------------------------------------
413 * Local variables:
414 * c-file-style: "linux"
415 * End:
416 */