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
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
111 * done without a 'access_ok(VERIFY_WRITE,..)'
112 */
113#undef TEST_VERIFY_AREA
114
115/* page table for 0-4MB for everybody */
116extern 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
169static 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 */
178static 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
184static 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
190static inline int pte_exec(pte_t pte){
191	return((pte_get_bits(pte, _PAGE_USER)) &&
192	       !(pte_get_bits(pte, _PAGE_PROTNONE)));
193}
194
195static 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 */
204static inline int pte_file(pte_t pte)
205{
206	return pte_get_bits(pte, _PAGE_FILE);
207}
208
209static inline int pte_dirty(pte_t pte)
210{
211	return pte_get_bits(pte, _PAGE_DIRTY);
212}
213
214static inline int pte_young(pte_t pte)
215{
216	return pte_get_bits(pte, _PAGE_ACCESSED);
217}
218
219static inline int pte_newpage(pte_t pte)
220{
221	return pte_get_bits(pte, _PAGE_NEWPAGE);
222}
223
224static 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
235static inline pte_t pte_mknewprot(pte_t pte)
236{
237	pte_set_bits(pte, _PAGE_NEWPROT);
238	return(pte);
239}
240
241static inline pte_t pte_rdprotect(pte_t pte)
242{
243	pte_clear_bits(pte, _PAGE_USER);
244	return(pte_mknewprot(pte));
245}
246
247static inline pte_t pte_exprotect(pte_t pte)
248{
249	pte_clear_bits(pte, _PAGE_USER);
250	return(pte_mknewprot(pte));
251}
252
253static inline pte_t pte_mkclean(pte_t pte)
254{
255	pte_clear_bits(pte, _PAGE_DIRTY);
256	return(pte);
257}
258
259static inline pte_t pte_mkold(pte_t pte)
260{
261	pte_clear_bits(pte, _PAGE_ACCESSED);
262	return(pte);
263}
264
265static inline pte_t pte_wrprotect(pte_t pte)
266{
267	pte_clear_bits(pte, _PAGE_RW);
268	return(pte_mknewprot(pte));
269}
270
271static inline pte_t pte_mkread(pte_t pte)
272{
273	pte_set_bits(pte, _PAGE_USER);
274	return(pte_mknewprot(pte));
275}
276
277static inline pte_t pte_mkdirty(pte_t pte)
278{
279	pte_set_bits(pte, _PAGE_DIRTY);
280	return(pte);
281}
282
283static inline pte_t pte_mkyoung(pte_t pte)
284{
285	pte_set_bits(pte, _PAGE_ACCESSED);
286	return(pte);
287}
288
289static inline pte_t pte_mkwrite(pte_t pte)
290{
291	pte_set_bits(pte, _PAGE_RW);
292	return(pte_mknewprot(pte));
293}
294
295static inline pte_t pte_mkuptodate(pte_t pte)
296{
297	pte_clear_bits(pte, _PAGE_NEWPAGE);
298	if(pte_present(pte))
299		pte_clear_bits(pte, _PAGE_NEWPROT);
300	return(pte);
301}
302
303static inline pte_t pte_mknewpage(pte_t pte)
304{
305	pte_set_bits(pte, _PAGE_NEWPAGE);
306	return(pte);
307}
308
309static inline void set_pte(pte_t *pteptr, pte_t pteval)
310{
311	pte_copy(*pteptr, pteval);
312
313	/* If it's a swap entry, it needs to be marked _PAGE_NEWPAGE so
314	 * fix_range knows to unmap it.  _PAGE_NEWPROT is specific to
315	 * mapped pages.
316	 */
317
318	*pteptr = pte_mknewpage(*pteptr);
319	if(pte_present(*pteptr)) *pteptr = pte_mknewprot(*pteptr);
320}
321#define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
322
323/*
324 * Conversion functions: convert a page and protection to a page entry,
325 * and a page entry and page directory to the page they refer to.
326 */
327
328#define phys_to_page(phys) pfn_to_page(phys_to_pfn(phys))
329#define __virt_to_page(virt) phys_to_page(__pa(virt))
330#define page_to_phys(page) pfn_to_phys(page_to_pfn(page))
331
332#define mk_pte(page, pgprot) \
333	({ pte_t pte;					\
334							\
335	pte_set_val(pte, page_to_phys(page), (pgprot));	\
336	if (pte_present(pte))				\
337		pte_mknewprot(pte_mknewpage(pte));	\
338	pte;})
339
340static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
341{
342	pte_set_val(pte, (pte_val(pte) & _PAGE_CHG_MASK), newprot);
343	return pte;
344}
345
346#define pmd_page_vaddr(pmd) ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
347
348/*
349 * the pgd page can be thought of an array like this: pgd_t[PTRS_PER_PGD]
350 *
351 * this macro returns the index of the entry in the pgd page which would
352 * control the given virtual address
353 */
354#define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
355
356#define pgd_index_k(addr) pgd_index(addr)
357
358/*
359 * pgd_offset() returns a (pgd_t *)
360 * pgd_index() is used get the offset into the pgd page's array of pgd_t's;
361 */
362#define pgd_offset(mm, address) ((mm)->pgd+pgd_index(address))
363
364/*
365 * a shortcut which implies the use of the kernel's pgd, instead
366 * of a process's
367 */
368#define pgd_offset_k(address) pgd_offset(&init_mm, address)
369
370/*
371 * the pmd page can be thought of an array like this: pmd_t[PTRS_PER_PMD]
372 *
373 * this macro returns the index of the entry in the pmd page which would
374 * control the given virtual address
375 */
376#define pmd_index(address) (((address) >> PMD_SHIFT) & (PTRS_PER_PMD-1))
377
378/*
379 * the pte page can be thought of an array like this: pte_t[PTRS_PER_PTE]
380 *
381 * this macro returns the index of the entry in the pte page which would
382 * control the given virtual address
383 */
384#define pte_index(address) (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
385#define pte_offset_kernel(dir, address) \
386	((pte_t *) pmd_page_vaddr(*(dir)) +  pte_index(address))
387#define pte_offset_map(dir, address) \
388	((pte_t *)page_address(pmd_page(*(dir))) + pte_index(address))
389#define pte_offset_map_nested(dir, address) pte_offset_map(dir, address)
390#define pte_unmap(pte) do { } while (0)
391#define pte_unmap_nested(pte) do { } while (0)
392
393#define update_mmu_cache(vma,address,pte) do ; while (0)
394
395/* Encode and de-code a swap entry */
396#define __swp_type(x)			(((x).val >> 4) & 0x3f)
397#define __swp_offset(x)			((x).val >> 11)
398
399#define __swp_entry(type, offset) \
400	((swp_entry_t) { ((type) << 4) | ((offset) << 11) })
401#define __pte_to_swp_entry(pte) \
402	((swp_entry_t) { pte_val(pte_mkuptodate(pte)) })
403#define __swp_entry_to_pte(x)		((pte_t) { (x).val })
404
405#define kern_addr_valid(addr) (1)
406
407#include <asm-generic/pgtable.h>
408
409#include <asm-generic/pgtable-nopud.h>
410
411#ifdef CONFIG_HIGHMEM
412/* Clear a kernel PTE and flush it from the TLB */
413#define kpte_clear_flush(ptep, vaddr)					\
414do {									\
415	pte_clear(&init_mm, vaddr, ptep);				\
416	__flush_tlb_one(vaddr);						\
417} while (0)
418#endif
419
420#endif
421#endif
422
423#define virt_to_page(addr) __virt_to_page((const unsigned long) addr)
424
425/*
426 * Overrides for Emacs so that we follow Linus's tabbing style.
427 * Emacs will notice this stuff at the end of the file and automatically
428 * adjust the settings for this buffer only.  This must remain at the end
429 * of the file.
430 * ---------------------------------------------------------------------------
431 * Local variables:
432 * c-file-style: "linux"
433 * End:
434 */
435