This source file includes following definitions.
- invalidate_mm
- invalidate_page
- invalidate_range
- invalidate_mm
- invalidate_page
- invalidate_range
- pte_none
- pte_present
- pte_inuse
- pte_clear
- pte_reuse
- pmd_none
- pmd_bad
- pmd_present
- pmd_inuse
- pmd_inuse
- pmd_clear
- pmd_reuse
- pgd_none
- pgd_bad
- pgd_present
- pgd_inuse
- pgd_clear
- pte_read
- pte_write
- pte_exec
- pte_dirty
- pte_young
- pte_cow
- pte_wrprotect
- pte_rdprotect
- pte_exprotect
- pte_mkclean
- pte_mkold
- pte_uncow
- pte_mkwrite
- pte_mkread
- pte_mkexec
- pte_mkdirty
- pte_mkyoung
- pte_mkcow
- mk_pte
- pte_modify
- pte_page
- pmd_page
- pgd_offset
- pmd_offset
- pte_offset
- pte_free_kernel
- pte_alloc_kernel
- pmd_free_kernel
- pmd_alloc_kernel
- pte_free
- pte_alloc
- pmd_free
- pmd_alloc
- pgd_free
- pgd_alloc
- update_mmu_cache
1 #ifndef _I386_PGTABLE_H
2 #define _I386_PGTABLE_H
3
4 #include <linux/config.h>
5
6
7
8
9
10 #define USE_PENTIUM_MM 1
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 #define __invalidate() \
36 __asm__ __volatile__("movl %%cr3,%%eax\n\tmovl %%eax,%%cr3": : :"ax")
37
38 #ifdef CONFIG_M386
39 #define __invalidate_one(addr) invalidate()
40 #else
41 #define __invalidate_one(addr) \
42 __asm__ __volatile__("invlpg %0": :"m" (*(char *) addr))
43 #endif
44
45 #ifndef __SMP__
46
47 #define invalidate() __invalidate()
48 #define invalidate_all() __invalidate()
49
50 static inline void invalidate_mm(struct mm_struct *mm)
51 {
52 if (mm == current->mm)
53 __invalidate();
54 }
55
56 static inline void invalidate_page(struct vm_area_struct *vma,
57 unsigned long addr)
58 {
59 if (vma->vm_mm == current->mm)
60 __invalidate_one(addr);
61 }
62
63 static inline void invalidate_range(struct mm_struct *mm,
64 unsigned long start, unsigned long end)
65 {
66 if (mm == current->mm)
67 __invalidate();
68 }
69
70 #else
71
72
73
74
75
76
77 #include <asm/smp.h>
78
79 #define local_invalidate() \
80 __invalidate()
81
82 #define invalidate() \
83 smp_invalidate()
84
85 #define invalidate_all() invalidate()
86
87 static inline void invalidate_mm(struct mm_struct *mm)
88 {
89 invalidate();
90 }
91
92 static inline void invalidate_page(struct vm_area_struct *vma,
93 unsigned long addr)
94 {
95 invalidate();
96 }
97
98 static inline void invalidate_range(struct mm_struct *mm,
99 unsigned long start, unsigned long end)
100 {
101 invalidate();
102 }
103
104 #endif
105
106
107
108
109
110
111 #define set_pte(pteptr, pteval) ((*(pteptr)) = (pteval))
112
113
114 #define PMD_SHIFT 22
115 #define PMD_SIZE (1UL << PMD_SHIFT)
116 #define PMD_MASK (~(PMD_SIZE-1))
117
118
119 #define PGDIR_SHIFT 22
120 #define PGDIR_SIZE (1UL << PGDIR_SHIFT)
121 #define PGDIR_MASK (~(PGDIR_SIZE-1))
122
123
124
125
126
127 #define PTRS_PER_PTE 1024
128 #define PTRS_PER_PMD 1
129 #define PTRS_PER_PGD 1024
130
131
132
133
134
135
136
137
138 #define VMALLOC_OFFSET (8*1024*1024)
139 #define VMALLOC_START ((high_memory + VMALLOC_OFFSET) & ~(VMALLOC_OFFSET-1))
140 #define VMALLOC_VMADDR(x) (TASK_SIZE + (unsigned long)(x))
141
142
143
144
145
146
147
148
149 #define _PAGE_PRESENT 0x001
150 #define _PAGE_RW 0x002
151 #define _PAGE_USER 0x004
152 #define _PAGE_PCD 0x010
153 #define _PAGE_ACCESSED 0x020
154 #define _PAGE_DIRTY 0x040
155 #define _PAGE_4M 0x080
156 #define _PAGE_COW 0x200
157
158 #define _PAGE_TABLE (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
159 #define _PAGE_CHG_MASK (PAGE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
160
161 #define PAGE_NONE __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED)
162 #define PAGE_SHARED __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
163 #define PAGE_COPY __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_COW)
164 #define PAGE_READONLY __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
165 #define PAGE_KERNEL __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
166
167
168
169
170
171 #define __P000 PAGE_NONE
172 #define __P001 PAGE_READONLY
173 #define __P010 PAGE_COPY
174 #define __P011 PAGE_COPY
175 #define __P100 PAGE_READONLY
176 #define __P101 PAGE_READONLY
177 #define __P110 PAGE_COPY
178 #define __P111 PAGE_COPY
179
180 #define __S000 PAGE_NONE
181 #define __S001 PAGE_READONLY
182 #define __S010 PAGE_SHARED
183 #define __S011 PAGE_SHARED
184 #define __S100 PAGE_READONLY
185 #define __S101 PAGE_READONLY
186 #define __S110 PAGE_SHARED
187 #define __S111 PAGE_SHARED
188
189
190
191
192
193
194 #undef TEST_VERIFY_AREA
195
196
197 extern unsigned long pg0[1024];
198
199 extern unsigned long empty_zero_page[1024];
200
201
202
203
204
205
206
207
208 extern pte_t __bad_page(void);
209 extern pte_t * __bad_pagetable(void);
210
211 #define BAD_PAGETABLE __bad_pagetable()
212 #define BAD_PAGE __bad_page()
213 #define ZERO_PAGE ((unsigned long) empty_zero_page)
214
215
216 #define BITS_PER_PTR (8*sizeof(unsigned long))
217
218
219 #define PTR_MASK (~(sizeof(void*)-1))
220
221
222
223 #define SIZEOF_PTR_LOG2 2
224
225
226 #define PAGE_PTR(address) \
227 ((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
228
229
230 #define SET_PAGE_DIR(tsk,pgdir) \
231 do { \
232 (tsk)->tss.cr3 = (unsigned long) (pgdir); \
233 if ((tsk) == current) \
234 __asm__ __volatile__("movl %0,%%cr3": :"a" ((tsk)->tss.cr3)); \
235 } while (0)
236
237 extern inline int pte_none(pte_t pte) { return !pte_val(pte); }
238 extern inline int pte_present(pte_t pte) { return pte_val(pte) & _PAGE_PRESENT; }
239 extern inline int pte_inuse(pte_t *ptep) { return mem_map[MAP_NR(ptep)].reserved || mem_map[MAP_NR(ptep)].count != 1; }
240 extern inline void pte_clear(pte_t *ptep) { pte_val(*ptep) = 0; }
241 extern inline void pte_reuse(pte_t * ptep)
242 {
243 if (!mem_map[MAP_NR(ptep)].reserved)
244 mem_map[MAP_NR(ptep)].count++;
245 }
246
247 extern inline int pmd_none(pmd_t pmd) { return !pmd_val(pmd); }
248 extern inline int pmd_bad(pmd_t pmd) { return (pmd_val(pmd) & ~PAGE_MASK) != _PAGE_TABLE || pmd_val(pmd) > high_memory; }
249 extern inline int pmd_present(pmd_t pmd) { return pmd_val(pmd) & _PAGE_PRESENT; }
250 #ifdef USE_PENTIUM_MM
251 extern inline int pmd_inuse(pmd_t *pmdp) { return (pmd_val(*pmdp) & _PAGE_4M) != 0; }
252 #else
253 extern inline int pmd_inuse(pmd_t *pmdp) { return 0; }
254 #endif
255 extern inline void pmd_clear(pmd_t * pmdp) { pmd_val(*pmdp) = 0; }
256 extern inline void pmd_reuse(pmd_t * pmdp) { }
257
258
259
260
261
262
263 extern inline int pgd_none(pgd_t pgd) { return 0; }
264 extern inline int pgd_bad(pgd_t pgd) { return 0; }
265 extern inline int pgd_present(pgd_t pgd) { return 1; }
266 extern inline int pgd_inuse(pgd_t * pgdp) { return mem_map[MAP_NR(pgdp)].reserved; }
267 extern inline void pgd_clear(pgd_t * pgdp) { }
268
269
270
271
272
273 extern inline int pte_read(pte_t pte) { return pte_val(pte) & _PAGE_USER; }
274 extern inline int pte_write(pte_t pte) { return pte_val(pte) & _PAGE_RW; }
275 extern inline int pte_exec(pte_t pte) { return pte_val(pte) & _PAGE_USER; }
276 extern inline int pte_dirty(pte_t pte) { return pte_val(pte) & _PAGE_DIRTY; }
277 extern inline int pte_young(pte_t pte) { return pte_val(pte) & _PAGE_ACCESSED; }
278 extern inline int pte_cow(pte_t pte) { return pte_val(pte) & _PAGE_COW; }
279
280 extern inline pte_t pte_wrprotect(pte_t pte) { pte_val(pte) &= ~_PAGE_RW; return pte; }
281 extern inline pte_t pte_rdprotect(pte_t pte) { pte_val(pte) &= ~_PAGE_USER; return pte; }
282 extern inline pte_t pte_exprotect(pte_t pte) { pte_val(pte) &= ~_PAGE_USER; return pte; }
283 extern inline pte_t pte_mkclean(pte_t pte) { pte_val(pte) &= ~_PAGE_DIRTY; return pte; }
284 extern inline pte_t pte_mkold(pte_t pte) { pte_val(pte) &= ~_PAGE_ACCESSED; return pte; }
285 extern inline pte_t pte_uncow(pte_t pte) { pte_val(pte) &= ~_PAGE_COW; return pte; }
286 extern inline pte_t pte_mkwrite(pte_t pte) { pte_val(pte) |= _PAGE_RW; return pte; }
287 extern inline pte_t pte_mkread(pte_t pte) { pte_val(pte) |= _PAGE_USER; return pte; }
288 extern inline pte_t pte_mkexec(pte_t pte) { pte_val(pte) |= _PAGE_USER; return pte; }
289 extern inline pte_t pte_mkdirty(pte_t pte) { pte_val(pte) |= _PAGE_DIRTY; return pte; }
290 extern inline pte_t pte_mkyoung(pte_t pte) { pte_val(pte) |= _PAGE_ACCESSED; return pte; }
291 extern inline pte_t pte_mkcow(pte_t pte) { pte_val(pte) |= _PAGE_COW; return pte; }
292
293
294
295
296
297 extern inline pte_t mk_pte(unsigned long page, pgprot_t pgprot)
298 { pte_t pte; pte_val(pte) = page | pgprot_val(pgprot); return pte; }
299
300 extern inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
301 { pte_val(pte) = (pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot); return pte; }
302
303 extern inline unsigned long pte_page(pte_t pte)
304 { return pte_val(pte) & PAGE_MASK; }
305
306 extern inline unsigned long pmd_page(pmd_t pmd)
307 { return pmd_val(pmd) & PAGE_MASK; }
308
309
310 extern inline pgd_t * pgd_offset(struct mm_struct * mm, unsigned long address)
311 {
312 return mm->pgd + (address >> PGDIR_SHIFT);
313 }
314
315
316 extern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
317 {
318 return (pmd_t *) dir;
319 }
320
321
322 extern inline pte_t * pte_offset(pmd_t * dir, unsigned long address)
323 {
324 return (pte_t *) pmd_page(*dir) + ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1));
325 }
326
327
328
329
330
331
332 extern inline void pte_free_kernel(pte_t * pte)
333 {
334 mem_map[MAP_NR(pte)].reserved = 0;
335 free_page((unsigned long) pte);
336 }
337
338 extern inline pte_t * pte_alloc_kernel(pmd_t * pmd, unsigned long address)
339 {
340 address = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
341 if (pmd_none(*pmd)) {
342 pte_t * page = (pte_t *) get_free_page(GFP_KERNEL);
343 if (pmd_none(*pmd)) {
344 if (page) {
345 pmd_val(*pmd) = _PAGE_TABLE | (unsigned long) page;
346 mem_map[MAP_NR(page)].reserved = 1;
347 return page + address;
348 }
349 pmd_val(*pmd) = _PAGE_TABLE | (unsigned long) BAD_PAGETABLE;
350 return NULL;
351 }
352 free_page((unsigned long) page);
353 }
354 if (pmd_bad(*pmd)) {
355 printk("Bad pmd in pte_alloc: %08lx\n", pmd_val(*pmd));
356 pmd_val(*pmd) = _PAGE_TABLE | (unsigned long) BAD_PAGETABLE;
357 return NULL;
358 }
359 return (pte_t *) pmd_page(*pmd) + address;
360 }
361
362
363
364
365
366 extern inline void pmd_free_kernel(pmd_t * pmd)
367 {
368 pmd_val(*pmd) = 0;
369 }
370
371 extern inline pmd_t * pmd_alloc_kernel(pgd_t * pgd, unsigned long address)
372 {
373 return (pmd_t *) pgd;
374 }
375
376 extern inline void pte_free(pte_t * pte)
377 {
378 free_page((unsigned long) pte);
379 }
380
381 extern inline pte_t * pte_alloc(pmd_t * pmd, unsigned long address)
382 {
383 address = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
384 if (pmd_none(*pmd)) {
385 pte_t * page = (pte_t *) get_free_page(GFP_KERNEL);
386 if (pmd_none(*pmd)) {
387 if (page) {
388 pmd_val(*pmd) = _PAGE_TABLE | (unsigned long) page;
389 return page + address;
390 }
391 pmd_val(*pmd) = _PAGE_TABLE | (unsigned long) BAD_PAGETABLE;
392 return NULL;
393 }
394 free_page((unsigned long) page);
395 }
396 if (pmd_bad(*pmd)) {
397 printk("Bad pmd in pte_alloc: %08lx\n", pmd_val(*pmd));
398 pmd_val(*pmd) = _PAGE_TABLE | (unsigned long) BAD_PAGETABLE;
399 return NULL;
400 }
401 return (pte_t *) pmd_page(*pmd) + address;
402 }
403
404
405
406
407
408 extern inline void pmd_free(pmd_t * pmd)
409 {
410 pmd_val(*pmd) = 0;
411 }
412
413 extern inline pmd_t * pmd_alloc(pgd_t * pgd, unsigned long address)
414 {
415 return (pmd_t *) pgd;
416 }
417
418 extern inline void pgd_free(pgd_t * pgd)
419 {
420 free_page((unsigned long) pgd);
421 }
422
423 extern inline pgd_t * pgd_alloc(void)
424 {
425 return (pgd_t *) get_free_page(GFP_KERNEL);
426 }
427
428 extern pgd_t swapper_pg_dir[1024];
429
430
431
432
433
434 extern inline void update_mmu_cache(struct vm_area_struct * vma,
435 unsigned long address, pte_t pte)
436 {
437 }
438
439 #define SWP_TYPE(entry) (((entry) >> 1) & 0x7f)
440 #define SWP_OFFSET(entry) ((entry) >> 8)
441 #define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) << 8))
442
443 #endif