do_page_fault函数处理流程

Question

本帖最后由 cluter 于 2011-05-28 01:01 编辑

只解释下关键代码的流程，附件里是关于缺页处理思路更清晰的一个整理，无代码的。

1. //*********************************缺页异常处理函数*******************************************
   
2. do_page_fault(struct pt_regs *regs, unsigned long error_code)
   
3. {
   
4. 
   
5.        
   
6.         //获取当前cpu正在运行的进程的进程描述符
   
7.         //然后获取该进程的内存描述符
   
8.         tsk = current;
   
9.         mm = tsk->mm;
   
10. 
    
11.         /* Get the faulting address: */
    
12.         //获取出错的地址
    
13.         address = read_cr2();
    
14. 
    
15. 
    
16.         /*
    
17.          * We fault-in kernel-space virtual memory on-demand. The
    
18.          * 'reference' page table is init_mm.pgd.
    
19.          *
    
20.          * NOTE! We MUST NOT take any locks for this case. We may
    
21.          * be in an interrupt or a critical region, and should
    
22.          * only copy the information from the master page table,
    
23.          * nothing more.
    
24.          *
    
25.          * This verifies that the fault happens in kernel space
    
26.          * (error_code & 4) == 0, and that the fault was not a
    
27.          * protection error (error_code & 9) == 0.
    
28.          */
    
29.          //页访问出错地址address在内核空间
    
30.         if (unlikely(fault_in_kernel_space(address))) {
    
31.                 //检查标志位确定访问发生在"内核态"
    
32.                 if (!(error_code & (PF_RSVD | PF_USER | PF_PROT))) {
    
33.                         //如果是内核空间"非连续内存"的访问,
    
34.                         //则直接拷贝"内核页表项"到"用户页表项"
    
35.                         //如果"内核页表项"为null,说明内核有BUG,返回-1
    
36.                         if (vmalloc_fault(address) >= 0)
    
37.                                 return;
    
38.                 }
    
39. 
    
40.                 //如果在"用户态"则直接进入"非法访问"处理函数
    
41.                 //如果vmalloc_fault返回-1,则表示内核BUG
    
42.                 bad_area_nosemaphore(regs, error_code, address);
    
43.                 //错误处理函数
    
44.                 // 1 "用户态"错误-->直接终止进程
    
45.                 // 2 "内核态"错误
    
46.                 //                       系统调用参数错误 ---->终止进程/返回系统调用错误码
    
47.                 //                       内核BUG                            ---->内核panic
    
48.                 return;
    
49.         }
    
50. 
    
51. 
    
52.         /*
    
53.          * If we're in an interrupt, have no user context or are running
    
54.          * in an atomic region then we must not take the fault:
    
55.          */
    
56.          // 1 在中断中,此时没有进程上下文
    
57.          // 2 在原子操作流程中
    
58.          // 都不允许处理缺页异常
    
59.         if (unlikely(in_atomic() || !mm)) {
    
60.                 bad_area_nosemaphore(regs, error_code, address);
    
61.                 return;
    
62.         }
    
63. 
    
64.         /*
    
65.          * When running in the kernel we expect faults to occur only to
    
66.          * addresses in user space.  All other faults represent errors in
    
67.          * the kernel and should generate an OOPS.  Unfortunately, in the
    
68.          * case of an erroneous fault occurring in a code path which already
    
69.          * holds mmap_sem we will deadlock attempting to validate the fault
    
70.          * against the address space.  Luckily the kernel only validly
    
71.          * references user space from well defined areas of code, which are
    
72.          * listed in the exceptions table.
    
73.          *
    
74.          * As the vast majority of faults will be valid we will only perform
    
75.          * the source reference check when there is a possibility of a
    
76.          * deadlock. Attempt to lock the address space, if we cannot we then
    
77.          * validate the source. If this is invalid we can skip the address
    
78.          * space check, thus avoiding the deadlock:
    
79.          */
    
80.          //此时可以确定缺页地址address在"用户空间"了
    
81.         if (unlikely(!down_read_trylock(&mm->mmap_sem))) {
    
82.                 //错误发生在"内核态",查看异常表
    
83.                 //如果在内核态引起缺页,则引起缺页的"指令地址"一定在"异常表"中
    
84.                 //如果"异常表"中返回指令地址,则说明可能是"请求调页",也可能是"非法访问"
    
85.                 //如果"异常表"中无地址,则肯定是内核错误
    
86.                 if ((error_code & PF_USER) == 0 &&
    
87.                     !search_exception_tables(regs->ip)) {
    
88.                        //内核panic
    
89.                         bad_area_nosemaphore(regs, error_code, address);
    
90.                         return;
    
91.                 }
    
92.                 down_read(&mm->mmap_sem);
    
93.         } else {
    
94.                 /*
    
95.                  * The above down_read_trylock() might have succeeded in
    
96.                  * which case we'll have missed the might_sleep() from
    
97.                  * down_read():
    
98.                  */
    
99.                 might_sleep();
    
100.         }
     
101.         //寻找address所在的vma
     
102.         vma = find_vma(mm, address);
     
103.         //如果address之后无vma,则肯定是非法访问
     
104.         if (unlikely(!vma)) {
     
105.                 bad_area(regs, error_code, address);
     
106.                 return;
     
107.         }
     
108.         // 1 如果vma->start_address<=address,则直接跳到 "合法访问"阶段
     
109.         // 2 如果vma->start_address>address,则也有可能是用户的"入栈行为"导致缺页
     
110.         if (likely(vma->vm_start <= address))
     
111.                 goto good_area;
     
112.         // "入栈"操作,则该vma的标志为 "向下增长"
     
113.         if (unlikely(!(vma->vm_flags & VM_GROWSDOWN))) {
     
114.                 bad_area(regs, error_code, address);
     
115.                 return;
     
116.         }
     
117.         // 确定缺页发生在"用户态"
     
118.         if (error_code & PF_USER) {
     
119.                 /*
     
120.                  * Accessing the stack below %sp is always a bug.
     
121.                  * The large cushion allows instructions like enter
     
122.                  * and pusha to work. ("enter $65535, $31" pushes
     
123.                  * 32 pointers and then decrements %sp by 65535.)
     
124.                  */
     
125.                  //验证缺页address和栈顶sp的关系
     
126.                 if (unlikely(address + 65536 + 32 * sizeof(unsigned long) < regs->sp)) {
     
127.                         bad_area(regs, error_code, address);
     
128.                         return;
     
129.                 }
     
130.         }
     
131.         //扩展栈
     
132.         if (unlikely(expand_stack(vma, address))) {
     
133.                 bad_area(regs, error_code, address);
     
134.                 return;
     
135.         }
     
136. 
     
137.         /*
     
138.          * Ok, we have a good vm_area for this memory access, so
     
139.          * we can handle it..
     
140.          */
     
141. good_area:
     
142.         write = error_code & PF_WRITE;
     
143.         // 再次验证"权限"
     
144.         if (unlikely(access_error(error_code, write, vma))) {
     
145.                 bad_area_access_error(regs, error_code, address);
     
146.                 return;
     
147.         }
     
148. 
     
149.         /*
     
150.          * If for any reason at all we couldn't handle the fault,
     
151.          * make sure we exit gracefully rather than endlessly redo
     
152.          * the fault:
     
153.          */
     
154.          //分配新"页框"
     
155.         fault = handle_mm_fault(mm, vma, address, write ? FAULT_FLAG_WRITE : 0);
     
156. 
     
157.         up_read(&mm->mmap_sem);
     
158. }
     
159. 
     
160. 
     
161. //*******************************访问权限验证函数********************************************
     
162. access_error(unsigned long error_code, int write, struct vm_area_struct *vma)
     
163. {       
     
164.         //如果是"写操作"引起的缺页,则该vma必须可写
     
165.         if (write) {
     
166.                 /* write, present and write, not present: */
     
167.                 if (unlikely(!(vma->vm_flags & VM_WRITE)))
     
168.                         return 1;
     
169.                 return 0;
     
170.         }
     
171. 
     
172.         /* read, present: */
     
173.         //检查该页是否已经在RAM中,如果"特权位"置位表示页框在RAM中
     
174.         //表示进程访问"有特权" 页框
     
175.         if (unlikely(error_code & PF_PROT))
     
176.                 return 1;
     
177. 
     
178.         /* read, not present: */
     
179.         //如果该页不在内存中,该线性区必须可"读"
     
180.         if (unlikely(!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE))))
     
181.                 return 1;
     
182. 
     
183.         return 0;
     
184. }
     

复制代码

do_page_fault处理流程.JPG (4.15 MB, 下载次数: 0)

下载附件

do_page_fault处理思路

2011-05-28 00:32 上传

顺便提出几个问题：
                                在"内核态"访问非连续内存时，为何要拷贝“内核页表项”到用“户页表项”，为何不直接使用“内核页表”？
                                对于一个4G的机器，用户进程的页框大部分分布在物理内存的哪个范围？
                                为什么当物理内存大于1G的时候，就开始划分出”高端内存“？
                                64bit的机器上不需要”高端内存“，这是为什么？

Answer 1

高端内存的作用是访问内核空间1g不能直接寻址之外的内存
折衷的办法就是
把1G划为直接映射的一部分和高端内存

64位机的内核空间能够足够大到寻址所有内存（虚拟地址空间不止4G）、

Answer 2

回复 2# amarant

    LS起这么早。。。关于为何使用高端内存，阁下理解的很透彻。。，第一个问题LS怎么看？

Answer 3

回复 3# cluter

    这个问题我说不准，就不敢胡说了。。

Answer 4

第一个问题我还真没看懂是什么意思

第二个问题，我没有仔细研究过代码，这应该取决于内核向Buddy System索要内存时传入的flag参数。新版的代码已经改的乱七八糟了，我在ULK上看过的代码片断里参数好像包括了GFP_HIGHUSER，也就是说，优先在大于896M的物理内存里拿。

第三第四个问题，内核使用高端内存是因为内核拥有的虚拟地址大于物理内存。访问物理内存必需先将其映射于某一块虚拟地址段之上，而大多体系结构中，内核是与进程共用地址空间的。Linux下内核一般只占顶1G，资源有些紧张，能映射到的物理也就紧张。因此在其1G的虚拟地址空间之中，开辟一个小窗口动态映射“够不着”的那些物理内存。所以说，高端内存的出现是因为“内核虚拟地址空间 <  物理内存大小”。

如果“内核虚拟地址空间 >  物理内存大小”，就不会出现高端内存了。这时还可以分为两种情况，一为“内核虚拟地址空间太大”，比如64位操作系统；一为“物理内存太小”，比如32位操作系统时物理内存小于896M。

Answer 5

回复 5# tempname2

    呵呵，ls 2 3 问题都理解的很深刻。给进程分配的页框和进程的页表都优先在高端内存索取！！

   第一个问题其实就是：当进程系统调用进入内核态，为何不使用内核页表，而是把内核页表项拷贝到进程页表，然后继续访问。

Answer 6

回复 4# amarant

    其实，只需要逆向思考下就可以了，如果切换页表，系统必须做其他什么事情？

Answer 7

对第一个问题我的理解是：
每个进程都有一个页表，页表既有内核地址空间的，也有用户地址空间的。
但是，有些内核空间的只在 init_mm的页表中有，而当前进程没有，当访问这些地址的时候，就出现页中断，
这里把 init_mm的页表中的相关项拷贝到当前进程的页表中。这样再访问的时候，就不会页中断了。

Answer 8

我不了解X86页表在内存中的储存结构，如果X86中的页全局表项必须是以数组的方式顺序存储。那么就很好理解为什么要多此一举复制内核页表过来了。

Answer 9

看代码是从init_mm.pgd上拷贝过去的，如果不拷贝而直接切换到init_mm_pgd上，那至少存在这个问题，内核中使用copy_from_user等访问进程用户地址空间的时候必然出错。另外执行signal处理函数时要利用程序在用户空间的栈来保存被冲掉的内核栈保存的内容，也必然出错。其原因在于init_mm.gpd上没有当前进程在用户地址空间的映射表。呵呵，不知俺说的对不对。