前面简单的分析了内核处理用户空间缺页异常的流程，进入到了handle_mm_fault()函数，该函数为触发缺页异常的地址address分配各级的页目录，也就是说现在已经拥有了一个和address配对的pte了，但是这个pte如何去映射物理页框，内核又得根据pte的状态进行分类和判断，而这个过程又会牵扯出一些其他的概念……这也是初读linux内核源码的最大障碍吧，在一些复杂的处理中，一个点往往可以延伸出一个面，容易让人迷失方向……因此后面打算分几次将这个函数分析完，自己也没有完全理解透，所以不到位的地方欢迎大家指出，一起交流~

staticinlineinthandle_pte_fault(structmm_struct *mm,

structvm_area_struct *vma, unsignedlongaddress,

pte_t *pte, pmd_t *pmd, unsignedintflags)

{

pte_t entry;

spinlock_t *ptl;

entry = *pte;

if(!pte_present(entry)) {//如果页不在主存中

if(pte_none(entry)) {//页表项内容为0，表明进程未访问过该页

if(vma->vm_ops) {

if(likely(vma->vm_ops->fault))

returndo_linear_fault(mm, vma, address,

pte, pmd, flags, entry);

}

returndo_anonymous_page(mm, vma, address,

pte, pmd, flags);

}

if(pte_file(entry))

returndo_nonlinear_fault(mm, vma, address,

pte, pmd, flags, entry);

returndo_swap_page(mm, vma, address,

pte, pmd, flags, entry);

}

...

...

}

首先要确定的一点就是pte对应的页是否驻留在主存中，因为pte有可能之前映射了页，但是该页被换出了。上面的代码给出了pte对应的页没有驻留在主存中的情况。如果pte对应的页没有驻留在主存中，且没有映射任何页，即pte_present()返回0，pte_none()返回0，则要判断要分配一个匿名页还是一个映射页。在Linux虚拟内存中，如果页对应的vma映射的是文件，则称为映射页，如果不是映射的文件，则称为匿名页。两者最大的区别体现在页和vma的组织上，因为在页框回收处理时要通过页来逆向搜索映射了该页的vma。对于匿名页的逆映射，vma都是通过vma结构体中的vma_anon_node(链表节点)和anon_vma(链表头)组织起来，再把该链表头的信息保存在页描述符中；而映射页和vma的组织是通过vma中的优先树节点和页描述符中的mapping->i_mmap优先树树根进行组织的，具体可以参看ULK3。

来看基于文件的映射的处理:

staticintdo_linear_fault(structmm_struct *mm,structvm_area_struct *vma,

unsignedlongaddress, pte_t *page_table, pmd_t *pmd,

unsignedintflags, pte_t orig_pte)

{

pgoff_t pgoff = (((address & PAGE_MASK)

- vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;

pte_unmap(page_table);//如果page_table之前用来建立了临时内核映射，则释放该映射

return__do_fault(mm, vma, address, pmd, pgoff, flags, orig_pte);

}

关键函数__do_fault():

staticint__do_fault(structmm_struct *mm,structvm_area_struct *vma,

unsignedlongaddress, pmd_t *pmd,

pgoff_t pgoff, unsignedintflags, pte_t orig_pte)

{

pte_t *page_table;

spinlock_t *ptl;

structpage *page;

pte_t entry;

intanon = 0;

intcharged = 0;

structpage *dirty_page = NULL;

structvm_fault vmf;

intret;

intpage_mkwrite = 0;

vmf.virtual_address = (void__user *)(address & PAGE_MASK);

vmf.pgoff = pgoff;

vmf.flags = flags;

vmf.page = NULL;

ret = vma->vm_ops->fault(vma, &vmf);//调用定义好的fault函数，确保将所需的文件数据读入到映射页

if(unlikely(ret & (VM_FAULT_ERROR | VM_FAULT_NOPAGE)))

returnret;

if(unlikely(PageHWPoison(vmf.page))) {

if(ret & VM_FAULT_LOCKED)

unlock_page(vmf.page);

returnVM_FAULT_HWPOISON;

}

if(unlikely(!(ret & VM_FAULT_LOCKED)))

lock_page(vmf.page);

else

VM_BUG_ON(!PageLocked(vmf.page));

page = vmf.page;

if(flags & FAULT_FLAG_WRITE) {//写访问

if(!(vma->vm_flags & VM_SHARED)) {//私有映射，则要创建一个副本进行写时复制

anon = 1;//标记为一个匿名映射

if(unlikely(anon_vma_prepare(vma))) {//创建一个anon_vma实例给vma

ret = VM_FAULT_OOM;

gotoout;

}

page = alloc_page_vma(GFP_HIGHUSER_MOVABLE,//分配一个页

vma, address);

if(!page) {

ret = VM_FAULT_OOM;

gotoout;

}

if(mem_cgroup_newpage_charge(page, mm, GFP_KERNEL)) {

ret = VM_FAULT_OOM;

page_cache_release(page);

gotoout;

}

charged = 1;

if(vma->vm_flags & VM_LOCKED)

clear_page_mlock(vmf.page);

copy_user_highpage(page, vmf.page, address, vma);

__SetPageUptodate(page);

}else{

if(vma->vm_ops->page_mkwrite) {

inttmp;

unlock_page(page);

vmf.flags = FAULT_FLAG_WRITE|FAULT_FLAG_MKWRITE;

tmp = vma->vm_ops->page_mkwrite(vma, &vmf);

if(unlikely(tmp &

(VM_FAULT_ERROR | VM_FAULT_NOPAGE))) {

ret = tmp;

gotounwritable_page;

}

if(unlikely(!(tmp & VM_FAULT_LOCKED))) {

lock_page(page);

if(!page->mapping) {

ret = 0;

unlock_page(page);

gotounwritable_page;

}

}else

VM_BUG_ON(!PageLocked(page));

page_mkwrite = 1;

}

}

}

page_table = pte_offset_map_lock(mm, pmd, address, &ptl);

if(likely(pte_same(*page_table, orig_pte))) {//确定没有竞争，也就是页表项中的内容和之前是一样的

flush_icache_page(vma, page);

entry = mk_pte(page, vma->vm_page_prot);//页表项指向对应的物理页

if(flags & FAULT_FLAG_WRITE)

entry = maybe_mkwrite(pte_mkdirty(entry), vma);

if(anon) {

inc_mm_counter(mm, anon_rss);

page_add_new_anon_rmap(page, vma, address);//建立匿名页与第一个vma的逆向映射

}else{

inc_mm_counter(mm, file_rss);

page_add_file_rmap(page);//建立页与vma的普通映射

if(flags & FAULT_FLAG_WRITE) {

dirty_page = page;

get_page(dirty_page);

}

}

set_pte_at(mm, address, page_table, entry);//修改page_table使其指向entry对应的页框

update_mmu_cache(vma, address, entry);

}else{

if(charged)

mem_cgroup_uncharge_page(page);

if(anon)

page_cache_release(page);

else

anon = 1;

}

pte_unmap_unlock(page_table, ptl);

out:

if(dirty_page) {

structaddress_space *mapping = page->mapping;

if(set_page_dirty(dirty_page))

page_mkwrite = 1;

unlock_page(dirty_page);

put_page(dirty_page);

if(page_mkwrite && mapping) {

balance_dirty_pages_ratelimited(mapping);

}

if(vma->vm_file)

file_update_time(vma->vm_file);

}else{

unlock_page(vmf.page);

if(anon)

page_cache_release(vmf.page);

}

returnret;

unwritable_page:

page_cache_release(page);

returnret;

}

首先要做的就是调用vma->vm_ops中定义好的fault()函数，将所需的数据从文件读入到映射页中，该函数还会将vma插入到映射页的mapping->i_mmap优先树中。

文件一般以共享的方式进行映射，接下来就要判断触发异常的操作是否包含写操作，如果是写操作并且该vma不是以共享的方式映射该页，则要进行写时复制，也就是创建一个新的页来供该vma读写，此时会申请一个匿名页，并将数据拷贝到该匿名页中。

接下来就要计算出page对应的pte值是多少，并将page_table指向的pte以该值进行填充，这样就完成了页表项到物理页的映射

再来看分配匿名页的处理

staticintdo_anonymous_page(structmm_struct *mm,structvm_area_struct *vma,

unsignedlongaddress, pte_t *page_table, pmd_t *pmd,

unsignedintflags)

{

structpage *page;

spinlock_t *ptl;

pte_t entry;

pte_unmap(page_table);

if(check_stack_guard_page(vma, address) 

returnVM_FAULT_SIGBUS;

if(!(flags & FAULT_FLAG_WRITE)) {

entry = pte_mkspecial(pfn_pte(my_zero_pfn(address),

vma->vm_page_prot));

page_table = pte_offset_map_lock(mm, pmd, address, &ptl);

if(!pte_none(*page_table))

gotounlock;

gotosetpte;

}

if(unlikely(anon_vma_prepare(vma)))//分配一个anon_vma实例

gotooom;

page = alloc_zeroed_user_highpage_movable(vma, address);

if(!page)

gotooom;

__SetPageUptodate(page);

if(mem_cgroup_newpage_charge(page, mm, GFP_KERNEL))

gotooom_free_page;

entry = mk_pte(page, vma->vm_page_prot);

if(vma->vm_flags & VM_WRITE)

entry = pte_mkwrite(pte_mkdirty(entry));

page_table = pte_offset_map_lock(mm, pmd, address, &ptl);

if(!pte_none(*page_table))

gotorelease;

inc_mm_counter(mm, anon_rss);

page_add_new_anon_rmap(page, vma, address);//建立线性区和匿名页的反向映射

setpte:

set_pte_at(mm, address, page_table, entry);//设置page_table对应的pte

update_mmu_cache(vma, address, entry);//更新MMU缓存

unlock:

pte_unmap_unlock(page_table, ptl);

return0;

release:

mem_cgroup_uncharge_page(page);

page_cache_release(page);

gotounlock;

oom_free_page:

page_cache_release(page);

oom:

returnVM_FAULT_OOM;

}

匿名页分配的工作和__do_fault()中分配匿名页差不多，只不过前面多了一个读写的判断，如果是读的话，不会分配匿名页，而是让pte指向一个被0填充的页，这样就进一步推迟了页的分配。也许你会觉得奇怪，既然要读数据怎么可以分配一个事先准备好的全0的页，其实仔细想想就会明白，缺页异常处理进行到这里，一定是第一次访问相应的内存时才会触发，匿名页对应的一般都是堆，栈这些区域，对这些区域的访问一定先是写而不是读，所以对于这种操作本身就不正常，分配一个被0填充的页使用户进程读出来的都是0也许会更安全一些。

如果不是这两种情况的话，也就是说pte_none()返回的是0，那就说明pte之前映射过页，只是该页已被换出

如果该页之前是用来进行非线性文件映射的话，其处理的主体函数就是上面介绍过的__do_fault()

staticintdo_nonlinear_fault(structmm_struct *mm,structvm_area_struct *vma,

unsignedlongaddress, pte_t *page_table, pmd_t *pmd,

unsignedintflags, pte_t orig_pte)

{

pgoff_t pgoff;

flags |= FAULT_FLAG_NONLINEAR;

if(!pte_unmap_same(mm, pmd, page_table, orig_pte))

return0;

if(unlikely(!(vma->vm_flags & VM_NONLINEAR))) {//确保vma具有非线性映射属性

print_bad_pte(vma, address, orig_pte, NULL);

returnVM_FAULT_SIGBUS;

}

pgoff = pte_to_pgoff(orig_pte);//获取映射的文件偏移

return__do_fault(mm, vma, address, pmd, pgoff, flags, orig_pte);

}

pte_to_pgoff()这个函数是和pgoff_to_pte()相对的一组操作。在非线性文件映射的页被换出时，其映射文件的偏移会以PAGE_SIZE为单位进行编码，存储到其pte中，所以当要重新换入该页时，要进行相应的解码计算出pgoff，再由__do_fault()进行处理！

对于页没有驻留在主存的情况中的最后一种处理方式，do_swap_page()，留在下次再做分析！

缺页异常被触发通常有两种情况——

1.程序设计的不当导致访问了非法的地址

2.访问的地址是合法的，但是该地址还未分配物理页框

下面解释一下第二种情况，这是虚拟内存管理的一个特性。尽管每个进程独立拥有3GB的可访问地址空间，但是这些资源都是内核开出的空头支票，也就是说进程手握着和自己相关的一个个虚拟内存区域(vma)，但是这些虚拟内存区域并不会在创建的时候就和物理页框挂钩，由于程序的局部性原理，程序在一定时间内所访问的内存往往是有限的，因此内核只会在进程确确实实需要访问物理内存时才会将相应的虚拟内存区域与物理内存进行关联(为相应的地址分配页表项，并将页表项映射到物理内存)，也就是说这种缺页异常是正常的，而第一种缺页异常是不正常的，内核要采取各种可行的手段将这种异常带来的破坏减到最小。

缺页异常的处理函数为do_page_fault()，该函数是和体系结构相关的一个函数，缺页异常的来源可分为两种，一种是内核空间(访问了线性地址空间的第4个GB)，一种是用户空间(访问了线性地址空间的0~3GB)，以X86架构为例，先来看内核空间异常的处理。

dotraplinkage void __kprobes

do_page_fault(struct pt_regs *regs, unsigned long error_code)

{

struct vm_area_struct *vma;

struct task_struct *tsk;

unsigned long address;

struct mm_struct *mm;

int write;

int fault;

tsk = current; //获取当前进程

mm = tsk->mm;  //获取当前进程的地址空间

/* Get the faulting address: */

address = read_cr2(); //读取CR2寄存器获取触发异常的访问地址

...

...

if (unlikely(fault_in_kernel_space(address))) { //判断address是否处于内核线性地址空间

if (!(error_code & (PF_RSVD | PF_USER | PF_PROT))) {//判断是否处于内核态

if (vmalloc_fault(address) >= 0)//处理vmalloc异常

return;

if (kmemcheck_fault(regs, address, error_code))

return;

}

/* Can handle a stale RO->RW TLB: */

/*异常发生在内核地址空间但不属于上面的情况或上面的方式无法修正，

则检查相应的页表项是否存在，权限是否足够*/

if (spurious_fault(error_code, address))

return;

/* kprobes don't want to hook the spurious faults: */

if (notify_page_fault(regs))

return;

/*

* Don't take the mm semaphore here. If we fixup a prefetch

* fault we could otherwise deadlock:

*/

bad_area_nosemaphore(regs, error_code, address);

return;

}

...

...

}

该函数传递进来的两个参数--

regs包含了各个寄存器的值

error_code是触发异常的错误类型，它的含义如下

/*

* Page fault error code bits:

*

*   bit 0 ==    0: no page found   1: protection fault

*   bit 1 ==    0: read access     1: write access

*   bit 2 ==    0: kernel-mode access  1: user-mode access

*   bit 3 ==               1: use of reserved bit detected

*   bit 4 ==               1: fault was an instruction fetch

*/

enum x86_pf_error_code {

PF_PROT     =       1 <

PF_WRITE    =       1 <

PF_USER     =       1 <

PF_RSVD     =       1 <

PF_INSTR    =       1 <

};

首先要检查该异常的触发地址是不是位于内核地址空间 也就是address>=TASK_SIZE_MAX,一般为3GB。然后要检查触发异常时是否处于内核态，满足这两个条件就尝试通过vmalloc_fault()来解决这个异常。由于使用vmalloc申请内存时，内核只会更新主内核页表，所以当前使用的进程页表就有可能因为未与主内核页表同步导致这次异常的触发，因此该函数试图将address对应的页表项与主内核页表进行同步

static noinline int vmalloc_fault(unsigned long address)

{

unsigned long pgd_paddr;

pmd_t *pmd_k;

pte_t *pte_k;

/* 确定触发异常的地址是否处于VMALLOC区域*/

if (!(address >= VMALLOC_START && address 

return -1;

/*

* Synchronize this task's top level page-table

* with the 'reference' page table.

*

* Do _not_ use "current" here. We might be inside

* an interrupt in the middle of a task switch..

*/

pgd_paddr = read_cr3();//获取当前的PGD地址

pmd_k = vmalloc_sync_one(__va(pgd_paddr), address);//将当前使用的页表和内核页表同步

if (!pmd_k)

return -1;

/*到这里已经获取了内核页表对应于address的pmd,并且将该值设置给了当前使用页表的pmd，

最后一步就是判断pmd对应的pte项是否存在*/

pte_k = pte_offset_kernel(pmd_k, address);//获取pmd对应address的pte项

if (!pte_present(*pte_k))//判断pte项是否存在，不存在则失败

return -1;

return 0;

}

同步处理:

static inline pmd_t *vmalloc_sync_one(pgd_t *pgd, unsigned long address)

{

unsigned index = pgd_index(address);

pgd_t *pgd_k;

pud_t *pud, *pud_k;

pmd_t *pmd, *pmd_k;

pgd += index; //记录当前页表pgd对应address的偏移

pgd_k = init_mm.pgd + index;//记录内核页表对应address的偏移

if (!pgd_present(*pgd_k))//内核PGD页表对应的项不存在，则无法进行下一步，返回NULL

return NULL;

/*

* set_pgd(pgd, *pgd_k); here would be useless on PAE

* and redundant with the set_pmd() on non-PAE. As would

* set_pud.

*/

/*获取当前页表对应address的PUD地址和内核页表对应address的地址，并判断pud_k对应的项是否存在*/

pud = pud_offset(pgd, address);

pud_k = pud_offset(pgd_k, address);

if (!pud_present(*pud_k))

return NULL;

/*对pmd进行和上面类似的操作*/

pmd = pmd_offset(pud, address);

pmd_k = pmd_offset(pud_k, address);

if (!pmd_present(*pmd_k))

return NULL;

if (!pmd_present(*pmd))//当前使用页表对应的pmd项不存在，则修正pmd项使其和内核页表的pmd_k项相同

set_pmd(pmd, *pmd_k);

else

BUG_ON(pmd_page(*pmd) != pmd_page(*pmd_k));

return pmd_k;

}

如果do_page_fault()函数执行到了bad_area_nosemaphore()，那么就表明这次异常是由于对非法的地址访问造成的。在内核中产生这样的结果的情况一般有两种:

1.内核通过用户空间传递的系统调用参数，访问了无效的地址

2.内核的程序设计缺陷

第一种情况内核尚且能通过异常修正机制来进行修复，而第二种情况就会导致OOPS错误了，内核将强制用SIGKILL结束当前进程。

内核态的bad_area_nosemaphore()的实际处理函数为bad_area_nosemaphore()-->__bad_area_nosemaphore()-->no_context()

static noinline void

no_context(struct pt_regs *regs, unsigned long error_code,

unsigned long address)

{

struct task_struct *tsk = current;

unsigned long *stackend;

unsigned long flags;

int sig;

/* Are we prepared to handle this kernel fault? */

/*fixup_exception()用于搜索异常表，并试图找到一个对应该异常的例程来进行修正，

这个例程在fixup_exception()返回后执行*/

if (fixup_exception(regs))

return;

/*

* 32-bit:

*

*   Valid to do another page fault here, because if this fault

*   had been triggered by is_prefetch fixup_exception would have

*   handled it.

*

* 64-bit:

*

*   Hall of shame of CPU/BIOS bugs.

*/

if (is_prefetch(regs, error_code, address))

return;

if (is_errata93(regs, address))

return;

/*

* Oops. The kernel tried to access some bad page. We'll have to

* terminate things with extreme prejudice:

*/

/* 走到这里就说明异常确实是由于内核的程序设计缺陷导致的了，内核将

产生一个oops，下面的工作就是打印CPU寄存器和内核态堆栈的信息到控制台并

终结当前的进程*/

flags = oops_begin();

show_fault_oops(regs, error_code, address);

stackend = end_of_stack(tsk);

if (*stackend != STACK_END_MAGIC)

printk(KERN_ALERT "Thread overran stack, or stack corrupted

");

tsk->thread.cr2      = address;

tsk->thread.trap_no  = 14;

tsk->thread.error_code   = error_code;

sig = SIGKILL;

if (__die("Oops", regs, error_code))

sig = 0;

/* Executive summary in case the body of the oops scrolled away */

printk(KERN_EMERG "CR2: %016lx

", address);

oops_end(flags, regs, sig);

}