This source file includes following definitions.
- oom
- free_one_table
- clear_page_tables
- free_page_tables
- clone_page_tables
- copy_page_tables
- unmap_page_range
- zeromap_page_range
- remap_page_range
- put_page
- put_dirty_page
- __do_wp_page
- do_wp_page
- verify_area
- get_empty_page
- try_to_share
- share_page
- get_empty_pgtable
- do_no_page
- do_page_fault
- __bad_pagetable
- __bad_page
- __zero_page
- show_mem
- paging_init
- mem_init
- si_meminfo
- file_mmap_nopage
- file_mmap_free
- file_mmap_share
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31 #include <asm/system.h>
32
33 #include <linux/signal.h>
34 #include <linux/sched.h>
35 #include <linux/head.h>
36 #include <linux/kernel.h>
37 #include <linux/errno.h>
38 #include <linux/string.h>
39 #include <linux/types.h>
40 #include <linux/ptrace.h>
41 #include <linux/mman.h>
42
43 unsigned long high_memory = 0;
44
45 extern void sound_mem_init(void);
46 extern void die_if_kernel(char *,struct pt_regs *,long);
47
48 int nr_swap_pages = 0;
49 int nr_free_pages = 0;
50 unsigned long free_page_list = 0;
51
52
53
54
55
56
57 int nr_secondary_pages = 0;
58 unsigned long secondary_page_list = 0;
59
60 #define copy_page(from,to) \
61 __asm__("cld ; rep ; movsl": :"S" (from),"D" (to),"c" (1024):"cx","di","si")
62
63 unsigned short * mem_map = NULL;
64
65 #define CODE_SPACE(addr,p) ((addr) < (p)->end_code)
66
67
68
69
70
71 void oom(struct task_struct * task)
72 {
73 printk("\nout of memory\n");
74 task->sigaction[SIGKILL-1].sa_handler = NULL;
75 task->blocked &= ~(1<<(SIGKILL-1));
76 send_sig(SIGKILL,task,1);
77 }
78
79 static void free_one_table(unsigned long * page_dir)
80 {
81 int j;
82 unsigned long pg_table = *page_dir;
83 unsigned long * page_table;
84
85 if (!pg_table)
86 return;
87 *page_dir = 0;
88 if (pg_table >= high_memory || !(pg_table & PAGE_PRESENT)) {
89 printk("Bad page table: [%p]=%08x\n",page_dir,pg_table);
90 return;
91 }
92 if (mem_map[MAP_NR(pg_table)] & MAP_PAGE_RESERVED)
93 return;
94 page_table = (unsigned long *) (pg_table & PAGE_MASK);
95 for (j = 0 ; j < PTRS_PER_PAGE ; j++,page_table++) {
96 unsigned long pg = *page_table;
97
98 if (!pg)
99 continue;
100 *page_table = 0;
101 if (pg & PAGE_PRESENT)
102 free_page(PAGE_MASK & pg);
103 else
104 swap_free(pg);
105 }
106 free_page(PAGE_MASK & pg_table);
107 }
108
109
110
111
112
113
114
115
116 void clear_page_tables(struct task_struct * tsk)
117 {
118 int i;
119 unsigned long pg_dir;
120 unsigned long * page_dir;
121
122 if (!tsk)
123 return;
124 if (tsk == task[0])
125 panic("task[0] (swapper) doesn't support exec()\n");
126 pg_dir = tsk->tss.cr3;
127 page_dir = (unsigned long *) pg_dir;
128 if (!page_dir || page_dir == swapper_pg_dir) {
129 printk("Trying to clear kernel page-directory: not good\n");
130 return;
131 }
132 if (mem_map[MAP_NR(pg_dir)] > 1) {
133 unsigned long * new_pg;
134
135 if (!(new_pg = (unsigned long*) get_free_page(GFP_KERNEL))) {
136 oom(tsk);
137 return;
138 }
139 for (i = 768 ; i < 1024 ; i++)
140 new_pg[i] = page_dir[i];
141 free_page(pg_dir);
142 tsk->tss.cr3 = (unsigned long) new_pg;
143 return;
144 }
145 for (i = 0 ; i < 768 ; i++,page_dir++)
146 free_one_table(page_dir);
147 invalidate();
148 return;
149 }
150
151
152
153
154 void free_page_tables(struct task_struct * tsk)
155 {
156 int i;
157 unsigned long pg_dir;
158 unsigned long * page_dir;
159
160 if (!tsk)
161 return;
162 if (tsk == task[0]) {
163 printk("task[0] (swapper) killed: unable to recover\n");
164 panic("Trying to free up swapper memory space");
165 }
166 pg_dir = tsk->tss.cr3;
167 if (!pg_dir || pg_dir == (unsigned long) swapper_pg_dir) {
168 printk("Trying to free kernel page-directory: not good\n");
169 return;
170 }
171 tsk->tss.cr3 = (unsigned long) swapper_pg_dir;
172 if (tsk == current)
173 __asm__ __volatile__("movl %0,%%cr3": :"a" (tsk->tss.cr3));
174 if (mem_map[MAP_NR(pg_dir)] > 1) {
175 free_page(pg_dir);
176 return;
177 }
178 page_dir = (unsigned long *) pg_dir;
179 for (i = 0 ; i < PTRS_PER_PAGE ; i++,page_dir++)
180 free_one_table(page_dir);
181 free_page(pg_dir);
182 invalidate();
183 }
184
185
186
187
188
189
190
191 int clone_page_tables(struct task_struct * tsk)
192 {
193 unsigned long pg_dir;
194
195 pg_dir = current->tss.cr3;
196 mem_map[MAP_NR(pg_dir)]++;
197 tsk->tss.cr3 = pg_dir;
198 return 0;
199 }
200
201
202
203
204
205
206 int copy_page_tables(struct task_struct * tsk)
207 {
208 int i;
209 unsigned long old_pg_dir, *old_page_dir;
210 unsigned long new_pg_dir, *new_page_dir;
211
212 if (!(new_pg_dir = get_free_page(GFP_KERNEL)))
213 return -ENOMEM;
214 old_pg_dir = current->tss.cr3;
215 tsk->tss.cr3 = new_pg_dir;
216 old_page_dir = (unsigned long *) old_pg_dir;
217 new_page_dir = (unsigned long *) new_pg_dir;
218 for (i = 0 ; i < PTRS_PER_PAGE ; i++,old_page_dir++,new_page_dir++) {
219 int j;
220 unsigned long old_pg_table, *old_page_table;
221 unsigned long new_pg_table, *new_page_table;
222
223 old_pg_table = *old_page_dir;
224 if (!old_pg_table)
225 continue;
226 if (old_pg_table >= high_memory || !(old_pg_table & PAGE_PRESENT)) {
227 printk("copy_page_tables: bad page table: "
228 "probable memory corruption");
229 *old_page_dir = 0;
230 continue;
231 }
232 if (mem_map[MAP_NR(old_pg_table)] & MAP_PAGE_RESERVED) {
233 *new_page_dir = old_pg_table;
234 continue;
235 }
236 if (!(new_pg_table = get_free_page(GFP_KERNEL))) {
237 free_page_tables(tsk);
238 return -ENOMEM;
239 }
240 old_page_table = (unsigned long *) (PAGE_MASK & old_pg_table);
241 new_page_table = (unsigned long *) (PAGE_MASK & new_pg_table);
242 for (j = 0 ; j < PTRS_PER_PAGE ; j++,old_page_table++,new_page_table++) {
243 unsigned long pg;
244 pg = *old_page_table;
245 if (!pg)
246 continue;
247 if (!(pg & PAGE_PRESENT)) {
248 *new_page_table = swap_duplicate(pg);
249 continue;
250 }
251 if ((pg & (PAGE_RW | PAGE_COW)) == (PAGE_RW | PAGE_COW))
252 pg &= ~PAGE_RW;
253 *new_page_table = pg;
254 if (mem_map[MAP_NR(pg)] & MAP_PAGE_RESERVED)
255 continue;
256 *old_page_table = pg;
257 mem_map[MAP_NR(pg)]++;
258 }
259 *new_page_dir = new_pg_table | PAGE_TABLE;
260 }
261 invalidate();
262 return 0;
263 }
264
265
266
267
268
269 int unmap_page_range(unsigned long from, unsigned long size)
270 {
271 unsigned long page, page_dir;
272 unsigned long *page_table, *dir;
273 unsigned long poff, pcnt, pc;
274
275 if (from & ~PAGE_MASK) {
276 printk("unmap_page_range called with wrong alignment\n");
277 return -EINVAL;
278 }
279 size = (size + ~PAGE_MASK) >> PAGE_SHIFT;
280 dir = PAGE_DIR_OFFSET(current->tss.cr3,from);
281 poff = (from >> PAGE_SHIFT) & (PTRS_PER_PAGE-1);
282 if ((pcnt = PTRS_PER_PAGE - poff) > size)
283 pcnt = size;
284
285 for ( ; size > 0; ++dir, size -= pcnt,
286 pcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size)) {
287 if (!(page_dir = *dir)) {
288 poff = 0;
289 continue;
290 }
291 if (!(page_dir & PAGE_PRESENT)) {
292 printk("unmap_page_range: bad page directory.");
293 continue;
294 }
295 page_table = (unsigned long *)(PAGE_MASK & page_dir);
296 if (poff) {
297 page_table += poff;
298 poff = 0;
299 }
300 for (pc = pcnt; pc--; page_table++) {
301 if ((page = *page_table) != 0) {
302 *page_table = 0;
303 if (1 & page) {
304 if (!(mem_map[MAP_NR(page)]
305 & MAP_PAGE_RESERVED))
306 --current->rss;
307 free_page(PAGE_MASK & page);
308 } else
309 swap_free(page);
310 }
311 }
312 if (pcnt == PTRS_PER_PAGE) {
313 *dir = 0;
314 free_page(PAGE_MASK & page_dir);
315 }
316 }
317 invalidate();
318 return 0;
319 }
320
321 int zeromap_page_range(unsigned long from, unsigned long size, int mask)
322 {
323 unsigned long *page_table, *dir;
324 unsigned long poff, pcnt;
325 unsigned long page;
326
327 if (mask) {
328 if ((mask & (PAGE_MASK|PAGE_PRESENT)) != PAGE_PRESENT) {
329 printk("zeromap_page_range: mask = %08x\n",mask);
330 return -EINVAL;
331 }
332 mask |= ZERO_PAGE;
333 }
334 if (from & ~PAGE_MASK) {
335 printk("zeromap_page_range: from = %08x\n",from);
336 return -EINVAL;
337 }
338 dir = PAGE_DIR_OFFSET(current->tss.cr3,from);
339 size = (size + ~PAGE_MASK) >> PAGE_SHIFT;
340 poff = (from >> PAGE_SHIFT) & (PTRS_PER_PAGE-1);
341 if ((pcnt = PTRS_PER_PAGE - poff) > size)
342 pcnt = size;
343
344 while (size > 0) {
345 if (!(PAGE_PRESENT & *dir)) {
346
347 if (!(page_table = (unsigned long*) get_free_page(GFP_KERNEL))) {
348 invalidate();
349 return -ENOMEM;
350 }
351 if (PAGE_PRESENT & *dir) {
352 free_page((unsigned long) page_table);
353 page_table = (unsigned long *)(PAGE_MASK & *dir++);
354 } else
355 *dir++ = ((unsigned long) page_table) | PAGE_TABLE;
356 } else
357 page_table = (unsigned long *)(PAGE_MASK & *dir++);
358 page_table += poff;
359 poff = 0;
360 for (size -= pcnt; pcnt-- ;) {
361 if ((page = *page_table) != 0) {
362 *page_table = 0;
363 if (page & PAGE_PRESENT) {
364 if (!(mem_map[MAP_NR(page)]
365 & MAP_PAGE_RESERVED))
366 --current->rss;
367 free_page(PAGE_MASK & page);
368 } else
369 swap_free(page);
370 }
371 *page_table++ = mask;
372 }
373 pcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size);
374 }
375 invalidate();
376 return 0;
377 }
378
379
380
381
382
383
384 int remap_page_range(unsigned long from, unsigned long to, unsigned long size, int mask)
385 {
386 unsigned long *page_table, *dir;
387 unsigned long poff, pcnt;
388 unsigned long page;
389
390 if (mask) {
391 if ((mask & (PAGE_MASK|PAGE_PRESENT)) != PAGE_PRESENT) {
392 printk("remap_page_range: mask = %08x\n",mask);
393 return -EINVAL;
394 }
395 }
396 if ((from & ~PAGE_MASK) || (to & ~PAGE_MASK)) {
397 printk("remap_page_range: from = %08x, to=%08x\n",from,to);
398 return -EINVAL;
399 }
400 dir = PAGE_DIR_OFFSET(current->tss.cr3,from);
401 size = (size + ~PAGE_MASK) >> PAGE_SHIFT;
402 poff = (from >> PAGE_SHIFT) & (PTRS_PER_PAGE-1);
403 if ((pcnt = PTRS_PER_PAGE - poff) > size)
404 pcnt = size;
405
406 while (size > 0) {
407 if (!(PAGE_PRESENT & *dir)) {
408
409 if (!(page_table = (unsigned long*) get_free_page(GFP_KERNEL))) {
410 invalidate();
411 return -1;
412 }
413 *dir++ = ((unsigned long) page_table) | PAGE_TABLE;
414 }
415 else
416 page_table = (unsigned long *)(PAGE_MASK & *dir++);
417 if (poff) {
418 page_table += poff;
419 poff = 0;
420 }
421
422 for (size -= pcnt; pcnt-- ;) {
423 if ((page = *page_table) != 0) {
424 *page_table = 0;
425 if (PAGE_PRESENT & page) {
426 if (!(mem_map[MAP_NR(page)]
427 & MAP_PAGE_RESERVED))
428 --current->rss;
429 free_page(PAGE_MASK & page);
430 } else
431 swap_free(page);
432 }
433
434
435
436
437
438
439
440 if (!mask)
441 *page_table++ = 0;
442 else if (to >= high_memory)
443 *page_table++ = (to | mask);
444 else if (!mem_map[MAP_NR(to)])
445 *page_table++ = 0;
446 else {
447 *page_table++ = (to | mask);
448 if (!(mem_map[MAP_NR(to)] & MAP_PAGE_RESERVED)) {
449 ++current->rss;
450 mem_map[MAP_NR(to)]++;
451 }
452 }
453 to += PAGE_SIZE;
454 }
455 pcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size);
456 }
457 invalidate();
458 return 0;
459 }
460
461
462
463
464
465
466
467 unsigned long put_page(struct task_struct * tsk,unsigned long page,
468 unsigned long address,int prot)
469 {
470 unsigned long *page_table;
471
472 if ((prot & (PAGE_MASK|PAGE_PRESENT)) != PAGE_PRESENT)
473 printk("put_page: prot = %08x\n",prot);
474 if (page >= high_memory) {
475 printk("put_page: trying to put page %08x at %08x\n",page,address);
476 return 0;
477 }
478 page_table = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
479 if ((*page_table) & PAGE_PRESENT)
480 page_table = (unsigned long *) (PAGE_MASK & *page_table);
481 else {
482 printk("put_page: bad page directory entry\n");
483 oom(tsk);
484 *page_table = BAD_PAGETABLE | PAGE_TABLE;
485 return 0;
486 }
487 page_table += (address >> PAGE_SHIFT) & (PTRS_PER_PAGE-1);
488 if (*page_table) {
489 printk("put_page: page already exists\n");
490 *page_table = 0;
491 invalidate();
492 }
493 *page_table = page | prot;
494
495 return page;
496 }
497
498
499
500
501
502
503
504 unsigned long put_dirty_page(struct task_struct * tsk, unsigned long page, unsigned long address)
505 {
506 unsigned long tmp, *page_table;
507
508 if (page >= high_memory)
509 printk("put_dirty_page: trying to put page %08x at %08x\n",page,address);
510 if (mem_map[MAP_NR(page)] != 1)
511 printk("mem_map disagrees with %08x at %08x\n",page,address);
512 page_table = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
513 if (PAGE_PRESENT & *page_table)
514 page_table = (unsigned long *) (PAGE_MASK & *page_table);
515 else {
516 if (!(tmp = get_free_page(GFP_KERNEL)))
517 return 0;
518 if (PAGE_PRESENT & *page_table) {
519 free_page(tmp);
520 page_table = (unsigned long *) (PAGE_MASK & *page_table);
521 } else {
522 *page_table = tmp | PAGE_TABLE;
523 page_table = (unsigned long *) tmp;
524 }
525 }
526 page_table += (address >> PAGE_SHIFT) & (PTRS_PER_PAGE-1);
527 if (*page_table) {
528 printk("put_dirty_page: page already exists\n");
529 *page_table = 0;
530 invalidate();
531 }
532 *page_table = page | (PAGE_DIRTY | PAGE_PRIVATE);
533
534 return page;
535 }
536
537
538
539
540
541
542
543
544
545
546
547
548 static void __do_wp_page(unsigned long error_code, unsigned long address,
549 struct task_struct * tsk, unsigned long user_esp)
550 {
551 unsigned long *pde, pte, old_page, prot;
552 unsigned long new_page;
553
554 new_page = __get_free_page(GFP_KERNEL);
555 pde = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
556 pte = *pde;
557 if (!(pte & PAGE_PRESENT))
558 goto end_wp_page;
559 if ((pte & PAGE_TABLE) != PAGE_TABLE || pte >= high_memory)
560 goto bad_wp_pagetable;
561 pte &= PAGE_MASK;
562 pte += PAGE_PTR(address);
563 old_page = *(unsigned long *) pte;
564 if (!(old_page & PAGE_PRESENT))
565 goto end_wp_page;
566 if (old_page >= high_memory)
567 goto bad_wp_page;
568 if (old_page & PAGE_RW)
569 goto end_wp_page;
570 tsk->min_flt++;
571 prot = (old_page & ~PAGE_MASK) | PAGE_RW;
572 old_page &= PAGE_MASK;
573 if (mem_map[MAP_NR(old_page)] != 1) {
574 if (new_page) {
575 if (mem_map[MAP_NR(old_page)] & MAP_PAGE_RESERVED)
576 ++tsk->rss;
577 copy_page(old_page,new_page);
578 *(unsigned long *) pte = new_page | prot;
579 free_page(old_page);
580 invalidate();
581 return;
582 }
583 free_page(old_page);
584 oom(tsk);
585 *(unsigned long *) pte = BAD_PAGE | prot;
586 invalidate();
587 return;
588 }
589 *(unsigned long *) pte |= PAGE_RW;
590 invalidate();
591 if (new_page)
592 free_page(new_page);
593 return;
594 bad_wp_page:
595 printk("do_wp_page: bogus page at address %08x (%08x)\n",address,old_page);
596 *(unsigned long *) pte = BAD_PAGE | PAGE_SHARED;
597 send_sig(SIGKILL, tsk, 1);
598 goto end_wp_page;
599 bad_wp_pagetable:
600 printk("do_wp_page: bogus page-table at address %08x (%08x)\n",address,pte);
601 *pde = BAD_PAGETABLE | PAGE_TABLE;
602 send_sig(SIGKILL, tsk, 1);
603 end_wp_page:
604 if (new_page)
605 free_page(new_page);
606 return;
607 }
608
609
610
611
612
613 void do_wp_page(unsigned long error_code, unsigned long address,
614 struct task_struct * tsk, unsigned long user_esp)
615 {
616 unsigned long page;
617 unsigned long * pg_table;
618
619 pg_table = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
620 page = *pg_table;
621 if (!page)
622 return;
623 if ((page & PAGE_PRESENT) && page < high_memory) {
624 pg_table = (unsigned long *) ((page & PAGE_MASK) + PAGE_PTR(address));
625 page = *pg_table;
626 if (!(page & PAGE_PRESENT))
627 return;
628 if (page & PAGE_RW)
629 return;
630 if (!(page & PAGE_COW)) {
631 if (user_esp && tsk == current) {
632 send_sig(SIGSEGV, tsk, 1);
633 return;
634 }
635 }
636 if (mem_map[MAP_NR(page)] == 1) {
637 *pg_table |= PAGE_RW | PAGE_DIRTY;
638 invalidate();
639 return;
640 }
641 __do_wp_page(error_code, address, tsk, user_esp);
642 return;
643 }
644 printk("bad page directory entry %08x\n",page);
645 *pg_table = 0;
646 }
647
648 int verify_area(int type, void * addr, unsigned long size)
649 {
650 unsigned long start;
651
652 start = (unsigned long) addr;
653 if (start >= TASK_SIZE)
654 return -EFAULT;
655 if (size > TASK_SIZE - start)
656 return -EFAULT;
657 if (type == VERIFY_READ || !size)
658 return 0;
659 if (!size)
660 return 0;
661 size--;
662 size += start & ~PAGE_MASK;
663 size >>= PAGE_SHIFT;
664 start &= PAGE_MASK;
665 do {
666 do_wp_page(1,start,current,0);
667 start += PAGE_SIZE;
668 } while (size--);
669 return 0;
670 }
671
672 static inline void get_empty_page(struct task_struct * tsk, unsigned long address)
673 {
674 unsigned long tmp;
675
676 if (!(tmp = get_free_page(GFP_KERNEL))) {
677 oom(tsk);
678 tmp = BAD_PAGE;
679 }
680 if (!put_page(tsk,tmp,address,PAGE_PRIVATE))
681 free_page(tmp);
682 }
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698 static int try_to_share(unsigned long address, struct task_struct * tsk,
699 struct task_struct * p, unsigned long error_code, unsigned long newpage)
700 {
701 unsigned long from;
702 unsigned long to;
703 unsigned long from_page;
704 unsigned long to_page;
705
706 from_page = (unsigned long)PAGE_DIR_OFFSET(p->tss.cr3,address);
707 to_page = (unsigned long)PAGE_DIR_OFFSET(tsk->tss.cr3,address);
708
709 from = *(unsigned long *) from_page;
710 if (!(from & PAGE_PRESENT))
711 return 0;
712 from &= PAGE_MASK;
713 from_page = from + PAGE_PTR(address);
714 from = *(unsigned long *) from_page;
715
716 if ((from & (PAGE_PRESENT | PAGE_DIRTY)) != PAGE_PRESENT)
717 return 0;
718 if (from >= high_memory)
719 return 0;
720 if (mem_map[MAP_NR(from)] & MAP_PAGE_RESERVED)
721 return 0;
722
723 to = *(unsigned long *) to_page;
724 if (!(to & PAGE_PRESENT))
725 return 0;
726 to &= PAGE_MASK;
727 to_page = to + PAGE_PTR(address);
728 if (*(unsigned long *) to_page)
729 return 0;
730
731 if (error_code & PAGE_RW) {
732 if(!newpage)
733 return 0;
734 copy_page((from & PAGE_MASK),newpage);
735 to = newpage | PAGE_PRIVATE;
736 } else {
737 mem_map[MAP_NR(from)]++;
738 from &= ~PAGE_RW;
739 to = from;
740 if(newpage)
741 free_page(newpage);
742 }
743 *(unsigned long *) from_page = from;
744 *(unsigned long *) to_page = to;
745 invalidate();
746 return 1;
747 }
748
749
750
751
752
753
754
755
756
757 int share_page(struct vm_area_struct * area, struct task_struct * tsk,
758 struct inode * inode,
759 unsigned long address, unsigned long error_code, unsigned long newpage)
760 {
761 struct task_struct ** p;
762
763 if (!inode || inode->i_count < 2 || !area->vm_ops)
764 return 0;
765 for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
766 if (!*p)
767 continue;
768 if (tsk == *p)
769 continue;
770 if (inode != (*p)->executable) {
771 if(!area) continue;
772
773
774 if(area){
775 struct vm_area_struct * mpnt;
776 for (mpnt = (*p)->mmap; mpnt; mpnt = mpnt->vm_next) {
777 if (mpnt->vm_ops == area->vm_ops &&
778 mpnt->vm_inode->i_ino == area->vm_inode->i_ino&&
779 mpnt->vm_inode->i_dev == area->vm_inode->i_dev){
780 if (mpnt->vm_ops->share(mpnt, area, address))
781 break;
782 };
783 };
784 if (!mpnt) continue;
785 };
786 }
787 if (try_to_share(address,tsk,*p,error_code,newpage))
788 return 1;
789 }
790 return 0;
791 }
792
793
794
795
796 static inline unsigned long get_empty_pgtable(struct task_struct * tsk,unsigned long address)
797 {
798 unsigned long page;
799 unsigned long *p;
800
801 p = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
802 if (PAGE_PRESENT & *p)
803 return *p;
804 if (*p) {
805 printk("get_empty_pgtable: bad page-directory entry \n");
806 *p = 0;
807 }
808 page = get_free_page(GFP_KERNEL);
809 p = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
810 if (PAGE_PRESENT & *p) {
811 free_page(page);
812 return *p;
813 }
814 if (*p) {
815 printk("get_empty_pgtable: bad page-directory entry \n");
816 *p = 0;
817 }
818 if (page) {
819 *p = page | PAGE_TABLE;
820 return *p;
821 }
822 oom(current);
823 *p = BAD_PAGETABLE | PAGE_TABLE;
824 return 0;
825 }
826
827 void do_no_page(unsigned long error_code, unsigned long address,
828 struct task_struct *tsk, unsigned long user_esp)
829 {
830 unsigned long tmp;
831 unsigned long page;
832 struct vm_area_struct * mpnt;
833
834 page = get_empty_pgtable(tsk,address);
835 if (!page)
836 return;
837 page &= PAGE_MASK;
838 page += PAGE_PTR(address);
839 tmp = *(unsigned long *) page;
840 if (tmp & PAGE_PRESENT)
841 return;
842 ++tsk->rss;
843 if (tmp) {
844 ++tsk->maj_flt;
845 swap_in((unsigned long *) page);
846 return;
847 }
848 address &= 0xfffff000;
849 for (mpnt = tsk->mmap ; mpnt ; mpnt = mpnt->vm_next) {
850 if (address < mpnt->vm_start)
851 continue;
852 if (address >= ((mpnt->vm_end + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)))
853 continue;
854 if (!mpnt->vm_ops || !mpnt->vm_ops->nopage)
855 break;
856 mpnt->vm_ops->nopage(error_code, mpnt, address);
857 return;
858 }
859 ++tsk->min_flt;
860 get_empty_page(tsk,address);
861 if (tsk != current)
862 return;
863 if (address >= tsk->end_data && address < tsk->brk)
864 return;
865 if (address+8192 >= (user_esp & 0xfffff000) &&
866 address <= current->start_stack)
867 return;
868 send_sig(SIGSEGV,tsk,1);
869 return;
870 }
871
872
873
874
875
876
877 asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long error_code)
878 {
879 unsigned long address;
880 unsigned long user_esp = 0;
881 unsigned long stack_limit;
882 unsigned int bit;
883
884
885 __asm__("movl %%cr2,%0":"=r" (address));
886 if (address < TASK_SIZE) {
887 if (error_code & 4) {
888 if (regs->eflags & VM_MASK) {
889 bit = (address - 0xA0000) >> PAGE_SHIFT;
890 if (bit < 32)
891 current->screen_bitmap |= 1 << bit;
892 } else
893 user_esp = regs->esp;
894 }
895 if (error_code & 1)
896 do_wp_page(error_code, address, current, user_esp);
897 else
898 do_no_page(error_code, address, current, user_esp);
899 if (!user_esp)
900 return;
901 stack_limit = current->rlim[RLIMIT_STACK].rlim_cur;
902 if (stack_limit >= RLIM_INFINITY)
903 return;
904 if (stack_limit >= current->start_stack)
905 return;
906 stack_limit = current->start_stack - stack_limit;
907 if (user_esp < stack_limit)
908 send_sig(SIGSEGV, current, 1);
909 return;
910 }
911 printk("Unable to handle kernel paging request at address %08x\n",address);
912 die_if_kernel("Oops", regs, error_code);
913 do_exit(SIGKILL);
914 }
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929 unsigned long __bad_pagetable(void)
930 {
931 extern char empty_bad_page_table[PAGE_SIZE];
932
933 __asm__ __volatile__("cld ; rep ; stosl":
934 :"a" (BAD_PAGE + PAGE_TABLE),
935 "D" ((long) empty_bad_page_table),
936 "c" (PTRS_PER_PAGE)
937 :"di","cx");
938 return (unsigned long) empty_bad_page_table;
939 }
940
941 unsigned long __bad_page(void)
942 {
943 extern char empty_bad_page[PAGE_SIZE];
944
945 __asm__ __volatile__("cld ; rep ; stosl":
946 :"a" (0),
947 "D" ((long) empty_bad_page),
948 "c" (PTRS_PER_PAGE)
949 :"di","cx");
950 return (unsigned long) empty_bad_page;
951 }
952
953 unsigned long __zero_page(void)
954 {
955 extern char empty_zero_page[PAGE_SIZE];
956
957 __asm__ __volatile__("cld ; rep ; stosl":
958 :"a" (0),
959 "D" ((long) empty_zero_page),
960 "c" (PTRS_PER_PAGE)
961 :"di","cx");
962 return (unsigned long) empty_zero_page;
963 }
964
965 void show_mem(void)
966 {
967 int i,free = 0,total = 0,reserved = 0;
968 int shared = 0;
969
970 printk("Mem-info:\n");
971 printk("Free pages: %6dkB\n",nr_free_pages<<(PAGE_SHIFT-10));
972 printk("Secondary pages: %6dkB\n",nr_secondary_pages<<(PAGE_SHIFT-10));
973 printk("Free swap: %6dkB\n",nr_swap_pages<<(PAGE_SHIFT-10));
974 printk("Buffer memory: %6dkB\n",buffermem>>10);
975 printk("Buffer heads: %6d\n",nr_buffer_heads);
976 printk("Buffer blocks: %6d\n",nr_buffers);
977 i = high_memory >> PAGE_SHIFT;
978 while (i-- > 0) {
979 total++;
980 if (mem_map[i] & MAP_PAGE_RESERVED)
981 reserved++;
982 else if (!mem_map[i])
983 free++;
984 else
985 shared += mem_map[i]-1;
986 }
987 printk("%d pages of RAM\n",total);
988 printk("%d free pages\n",free);
989 printk("%d reserved pages\n",reserved);
990 printk("%d pages shared\n",shared);
991 }
992
993
994
995
996
997
998
999
1000 unsigned long paging_init(unsigned long start_mem, unsigned long end_mem)
1001 {
1002 unsigned long * pg_dir;
1003 unsigned long * pg_table;
1004 unsigned long tmp;
1005 unsigned long address;
1006
1007
1008
1009
1010
1011
1012 memset((void *) 0, 0, PAGE_SIZE);
1013 start_mem = PAGE_ALIGN(start_mem);
1014 address = 0;
1015 pg_dir = swapper_pg_dir;
1016 while (address < end_mem) {
1017 tmp = *(pg_dir + 768);
1018 if (!tmp) {
1019 tmp = start_mem | PAGE_TABLE;
1020 *(pg_dir + 768) = tmp;
1021 start_mem += PAGE_SIZE;
1022 }
1023 *pg_dir = tmp;
1024 pg_dir++;
1025 pg_table = (unsigned long *) (tmp & PAGE_MASK);
1026 for (tmp = 0 ; tmp < PTRS_PER_PAGE ; tmp++,pg_table++) {
1027 if (address && address < end_mem)
1028 *pg_table = address | PAGE_SHARED;
1029 else
1030 *pg_table = 0;
1031 address += PAGE_SIZE;
1032 }
1033 }
1034 invalidate();
1035 return start_mem;
1036 }
1037
1038 void mem_init(unsigned long start_low_mem,
1039 unsigned long start_mem, unsigned long end_mem)
1040 {
1041 int codepages = 0;
1042 int reservedpages = 0;
1043 int datapages = 0;
1044 unsigned long tmp;
1045 unsigned short * p;
1046 extern int etext;
1047
1048 cli();
1049 end_mem &= PAGE_MASK;
1050 high_memory = end_mem;
1051 start_mem += 0x0000000f;
1052 start_mem &= ~0x0000000f;
1053 tmp = MAP_NR(end_mem);
1054 mem_map = (unsigned short *) start_mem;
1055 p = mem_map + tmp;
1056 start_mem = (unsigned long) p;
1057 while (p > mem_map)
1058 *--p = MAP_PAGE_RESERVED;
1059 start_low_mem = PAGE_ALIGN(start_low_mem);
1060 start_mem = PAGE_ALIGN(start_mem);
1061 while (start_low_mem < 0xA0000) {
1062 mem_map[MAP_NR(start_low_mem)] = 0;
1063 start_low_mem += PAGE_SIZE;
1064 }
1065 while (start_mem < end_mem) {
1066 mem_map[MAP_NR(start_mem)] = 0;
1067 start_mem += PAGE_SIZE;
1068 }
1069 sound_mem_init();
1070 free_page_list = 0;
1071 nr_free_pages = 0;
1072 for (tmp = 0 ; tmp < end_mem ; tmp += PAGE_SIZE) {
1073 if (mem_map[MAP_NR(tmp)]) {
1074 if (tmp >= 0xA0000 && tmp < 0x100000)
1075 reservedpages++;
1076 else if (tmp < (unsigned long) &etext)
1077 codepages++;
1078 else
1079 datapages++;
1080 continue;
1081 }
1082 *(unsigned long *) tmp = free_page_list;
1083 free_page_list = tmp;
1084 nr_free_pages++;
1085 }
1086 tmp = nr_free_pages << PAGE_SHIFT;
1087 printk("Memory: %dk/%dk available (%dk kernel code, %dk reserved, %dk data)\n",
1088 tmp >> 10,
1089 end_mem >> 10,
1090 codepages << (PAGE_SHIFT-10),
1091 reservedpages << (PAGE_SHIFT-10),
1092 datapages << (PAGE_SHIFT-10));
1093 return;
1094 }
1095
1096 void si_meminfo(struct sysinfo *val)
1097 {
1098 int i;
1099
1100 i = high_memory >> PAGE_SHIFT;
1101 val->totalram = 0;
1102 val->freeram = 0;
1103 val->sharedram = 0;
1104 val->bufferram = buffermem;
1105 while (i-- > 0) {
1106 if (mem_map[i] & MAP_PAGE_RESERVED)
1107 continue;
1108 val->totalram++;
1109 if (!mem_map[i]) {
1110 val->freeram++;
1111 continue;
1112 }
1113 val->sharedram += mem_map[i]-1;
1114 }
1115 val->totalram <<= PAGE_SHIFT;
1116 val->freeram <<= PAGE_SHIFT;
1117 val->sharedram <<= PAGE_SHIFT;
1118 return;
1119 }
1120
1121
1122
1123 void file_mmap_nopage(int error_code, struct vm_area_struct * area, unsigned long address)
1124 {
1125 struct inode * inode = area->vm_inode;
1126 unsigned int block;
1127 unsigned int clear;
1128 unsigned long page;
1129 unsigned long tmp;
1130 int nr[8];
1131 int i, j;
1132 int prot = area->vm_page_prot;
1133
1134 address &= PAGE_MASK;
1135 block = address - area->vm_start + area->vm_offset;
1136 block >>= inode->i_sb->s_blocksize_bits;
1137
1138 page = get_free_page(GFP_KERNEL);
1139 if (share_page(area, area->vm_task, inode, address, error_code, page)) {
1140 ++area->vm_task->min_flt;
1141 return;
1142 }
1143
1144 ++area->vm_task->maj_flt;
1145 if (!page) {
1146 oom(current);
1147 put_page(area->vm_task, BAD_PAGE, address, PAGE_PRIVATE);
1148 return;
1149 }
1150 for (i=0, j=0; i< PAGE_SIZE ; j++, block++, i += inode->i_sb->s_blocksize)
1151 nr[j] = bmap(inode,block);
1152
1153
1154
1155
1156
1157
1158
1159 clear = 0;
1160 if (address + PAGE_SIZE > area->vm_end) {
1161 clear = address + PAGE_SIZE - area->vm_end;
1162 prot |= PAGE_RW;
1163 }
1164 page = bread_page(page, inode->i_dev, nr, inode->i_sb->s_blocksize, prot);
1165
1166 if (!(error_code & PAGE_RW)) {
1167 if (share_page(area, area->vm_task, inode, address, error_code, page))
1168 return;
1169 }
1170
1171 tmp = page + PAGE_SIZE;
1172 while (clear--) {
1173 *(char *)--tmp = 0;
1174 }
1175 if (put_page(area->vm_task,page,address,area->vm_page_prot))
1176 return;
1177 free_page(page);
1178 oom(current);
1179 }
1180
1181 void file_mmap_free(struct vm_area_struct * area)
1182 {
1183 if (area->vm_inode)
1184 iput(area->vm_inode);
1185 #if 0
1186 if (area->vm_inode)
1187 printk("Free inode %x:%d (%d)\n",area->vm_inode->i_dev,
1188 area->vm_inode->i_ino, area->vm_inode->i_count);
1189 #endif
1190 }
1191
1192
1193
1194
1195
1196 int file_mmap_share(struct vm_area_struct * area1,
1197 struct vm_area_struct * area2,
1198 unsigned long address)
1199 {
1200 if (area1->vm_inode != area2->vm_inode)
1201 return 0;
1202 if (area1->vm_start != area2->vm_start)
1203 return 0;
1204 if (area1->vm_end != area2->vm_end)
1205 return 0;
1206 if (area1->vm_offset != area2->vm_offset)
1207 return 0;
1208 if (area1->vm_page_prot != area2->vm_page_prot)
1209 return 0;
1210 return 1;
1211 }
1212
1213 struct vm_operations_struct file_mmap = {
1214 NULL,
1215 file_mmap_free,
1216 file_mmap_nopage,
1217 NULL,
1218 file_mmap_share,
1219 };