思享工具箱

用户空间缺页异常pte_handle_fault()分析--(上)【转】

摘要：
前面对内核处理用户空间页面错误异常过程的简单分析进入了handle_mm_fault（）函数，该函数为触发页面错误异常的地址在所有级别分配页面目录，也就是说，它已经有一个与地址配对的pte。然而，这个pte如何映射物理页面框架，内核必须根据pte的状态进行分类和判断，这个过程将涉及一些其他概念……如果与pte对应的页面没有驻留在主内存中，并且没有映射页面，即pte_ Present（）返回0，pte_ If none（）返回零，您需要确定是分配匿名页面还是映射页面。

转自：http://blog.csdn.net/vanbreaker/article/details/7881206

版权声明：本文为博主原创文章，未经博主允许不得转载。

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

[cpp] view plain copy
 
  1. static inline int handle_pte_fault(struct mm_struct *mm,  
  2.         struct vm_area_struct *vma, unsigned long address,  
  3.         pte_t *pte, pmd_t *pmd, unsigned int flags)  
  4. {  
  5.     pte_t entry;  
  6.     spinlock_t *ptl;  
  7.   
  8.     entry = *pte;  
  9.     if (!pte_present(entry)) {//如果页不在主存中  
  10.         if (pte_none(entry)) {//页表项内容为0，表明进程未访问过该页  
  11.   
  12.             /*如果vm_ops字段和fault字段都不为空，则说明这是一个基于文件的映射*/  
  13.             if (vma->vm_ops) {  
  14.                 if (likely(vma->vm_ops->fault))  
  15.                     return do_linear_fault(mm, vma, address,  
  16.                         pte, pmd, flags, entry);  
  17.             }  
  18.             /*否则分配匿名页*/  
  19.             return do_anonymous_page(mm, vma, address,  
  20.                          pte, pmd, flags);  
  21.         }  
  22.   
  23.         /*属于非线性文件映射且已被换出*/  
  24.         if (pte_file(entry))  
  25.             return do_nonlinear_fault(mm, vma, address,  
  26.                     pte, pmd, flags, entry);  
  27.   
  28.         /*页不在主存中，但是页表项保存了相关信息，则表明该页被内核换出，则要进行换入操作*/  
  29.         return do_swap_page(mm, vma, address,  
  30.                     pte, pmd, flags, entry);  
  31.     }  
  32.             
  33.          ...  
  34.          ...  
  35.   
  36. }  

首先要确定的一点就是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。

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

[cpp] view plain copy
 
  1. static int do_linear_fault(struct mm_struct *mm, struct vm_area_struct *vma,  
  2.         unsigned long address, pte_t *page_table, pmd_t *pmd,  
  3.         unsigned int flags, pte_t orig_pte)  
  4. {  
  5.     pgoff_t pgoff = (((address & PAGE_MASK)  
  6.             - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;  
  7.   
  8.     pte_unmap(page_table);//如果page_table之前用来建立了临时内核映射，则释放该映射  
  9.     return __do_fault(mm, vma, address, pmd, pgoff, flags, orig_pte);  
  10. }  

关键函数__do_fault():

[cpp] view plain copy
 
  1. static int __do_fault(struct mm_struct *mm, struct vm_area_struct *vma,  
  2.         unsigned long address, pmd_t *pmd,  
  3.         pgoff_t pgoff, unsigned int flags, pte_t orig_pte)  
  4. {  
  5.     pte_t *page_table;  
  6.     spinlock_t *ptl;  
  7.     struct page *page;  
  8.     pte_t entry;  
  9.     int anon = 0;  
  10.     int charged = 0;  
  11.     struct page *dirty_page = NULL;  
  12.     struct vm_fault vmf;  
  13.     int ret;  
  14.     int page_mkwrite = 0;  
  15.   
  16.     vmf.virtual_address = (void __user *)(address & PAGE_MASK);  
  17.     vmf.pgoff = pgoff;  
  18.     vmf.flags = flags;  
  19.     vmf.page = NULL;  
  20.   
  21.     ret = vma->vm_ops->fault(vma, &vmf);//调用定义好的fault函数，确保将所需的文件数据读入到映射页  
  22.       
  23.     if (unlikely(ret & (VM_FAULT_ERROR | VM_FAULT_NOPAGE)))  
  24.         return ret;  
  25.   
  26.     if (unlikely(PageHWPoison(vmf.page))) {  
  27.         if (ret & VM_FAULT_LOCKED)  
  28.             unlock_page(vmf.page);  
  29.         return VM_FAULT_HWPOISON;  
  30.     }  
  31.   
  32.     /* 
  33.      * For consistency in subsequent calls, make the faulted page always 
  34.      * locked. 
  35.      */  
  36.     if (unlikely(!(ret & VM_FAULT_LOCKED)))  
  37.         lock_page(vmf.page);  
  38.     else  
  39.         VM_BUG_ON(!PageLocked(vmf.page));  
  40.   
  41.     /* 
  42.      * Should we do an early C-O-W break? 
  43.      */  
  44.     page = vmf.page;  
  45.     if (flags & FAULT_FLAG_WRITE) {//写访问  
  46.         if (!(vma->vm_flags & VM_SHARED)) {//私有映射，则要创建一个副本进行写时复制  
  47.             anon = 1;// 标记为一个匿名映射  
  48.             if (unlikely(anon_vma_prepare(vma))) {//创建一个anon_vma实例给vma  
  49.                 ret = VM_FAULT_OOM;  
  50.                 goto out;  
  51.             }  
  52.             page = alloc_page_vma(GFP_HIGHUSER_MOVABLE,//分配一个页  
  53.                         vma, address);  
  54.             if (!page) {  
  55.                 ret = VM_FAULT_OOM;  
  56.                 goto out;  
  57.             }  
  58.             if (mem_cgroup_newpage_charge(page, mm, GFP_KERNEL)) {  
  59.                 ret = VM_FAULT_OOM;  
  60.                 page_cache_release(page);  
  61.                 goto out;  
  62.             }  
  63.             charged = 1;  
  64.             /* 
  65.              * Don't let another task, with possibly unlocked vma, 
  66.              * keep the mlocked page. 
  67.              */  
  68.             if (vma->vm_flags & VM_LOCKED)  
  69.                 clear_page_mlock(vmf.page);  
  70.             /*创建数据的副本，将数据拷贝到新分配的页*/  
  71.             copy_user_highpage(page, vmf.page, address, vma);  
  72.             __SetPageUptodate(page);  
  73.         } else {  
  74.             /* 
  75.              * If the page will be shareable, see if the backing 
  76.              * address space wants to know that the page is about 
  77.              * to become writable 
  78.              */  
  79.             if (vma->vm_ops->page_mkwrite) {  
  80.                 int tmp;  
  81.   
  82.                 unlock_page(page);  
  83.                 vmf.flags = FAULT_FLAG_WRITE|FAULT_FLAG_MKWRITE;  
  84.                 tmp = vma->vm_ops->page_mkwrite(vma, &vmf);  
  85.                 if (unlikely(tmp &  
  86.                       (VM_FAULT_ERROR | VM_FAULT_NOPAGE))) {  
  87.                     ret = tmp;  
  88.                     goto unwritable_page;  
  89.                 }  
  90.                 if (unlikely(!(tmp & VM_FAULT_LOCKED))) {  
  91.                     lock_page(page);  
  92.                     if (!page->mapping) {  
  93.                         ret = 0; /* retry the fault */  
  94.                         unlock_page(page);  
  95.                         goto unwritable_page;  
  96.                     }  
  97.                 } else  
  98.                     VM_BUG_ON(!PageLocked(page));  
  99.                 page_mkwrite = 1;  
  100.             }  
  101.         }  
  102.   
  103.     }  
  104.   
  105.     page_table = pte_offset_map_lock(mm, pmd, address, &ptl);  
  106.   
  107.     /* 
  108.      * This silly early PAGE_DIRTY setting removes a race 
  109.      * due to the bad i386 page protection. But it's valid 
  110.      * for other architectures too. 
  111.      * 
  112.      * Note that if FAULT_FLAG_WRITE is set, we either now have 
  113.      * an exclusive copy of the page, or this is a shared mapping, 
  114.      * so we can make it writable and dirty to avoid having to 
  115.      * handle that later. 
  116.      */  
  117.     /* Only go through if we didn't race with anybody else... */  
  118.     if (likely(pte_same(*page_table, orig_pte))) {//确定没有竞争，也就是页表项中的内容和之前是一样的  
  119.         flush_icache_page(vma, page);  
  120.         entry = mk_pte(page, vma->vm_page_prot);//页表项指向对应的物理页  
  121.   
  122.         /*如果是写操作，则将页的访问权限置为RW*/  
  123.         if (flags & FAULT_FLAG_WRITE)  
  124.             entry = maybe_mkwrite(pte_mkdirty(entry), vma);  
  125.   
  126.         /*如果之前生成的页是匿名的，则将其集成到逆向映射当中*/  
  127.         if (anon) {  
  128.             inc_mm_counter(mm, anon_rss);  
  129.             page_add_new_anon_rmap(page, vma, address);//建立匿名页与第一个vma的逆向映射  
  130.         } else {  
  131.             inc_mm_counter(mm, file_rss);  
  132.             page_add_file_rmap(page);//建立页与vma的普通映射  
  133.             if (flags & FAULT_FLAG_WRITE) {  
  134.                 dirty_page = page;  
  135.                 get_page(dirty_page);  
  136.             }  
  137.         }  
  138.         set_pte_at(mm, address, page_table, entry);//修改page_table使其指向entry对应的页框  
  139.   
  140.         /* no need to invalidate: a not-present page won't be cached */  
  141.         update_mmu_cache(vma, address, entry);  
  142.     } else {  
  143.         if (charged)  
  144.             mem_cgroup_uncharge_page(page);  
  145.         if (anon)  
  146.             page_cache_release(page);  
  147.         else  
  148.             anon = 1; /* no anon but release faulted_page */  
  149.     }  
  150.   
  151.     pte_unmap_unlock(page_table, ptl);  
  152.   
  153. out:  
  154.     if (dirty_page) {  
  155.         struct address_space *mapping = page->mapping;  
  156.   
  157.         if (set_page_dirty(dirty_page))  
  158.             page_mkwrite = 1;  
  159.         unlock_page(dirty_page);  
  160.         put_page(dirty_page);  
  161.         if (page_mkwrite && mapping) {  
  162.             /* 
  163.              * Some device drivers do not set page.mapping but still 
  164.              * dirty their pages 
  165.              */  
  166.             balance_dirty_pages_ratelimited(mapping);  
  167.         }  
  168.   
  169.         /* file_update_time outside page_lock */  
  170.         if (vma->vm_file)  
  171.             file_update_time(vma->vm_file);  
  172.     } else {  
  173.         unlock_page(vmf.page);  
  174.         if (anon)  
  175.             page_cache_release(vmf.page);  
  176.     }  
  177.   
  178.     return ret;  
  179.   
  180. unwritable_page:  
  181.     page_cache_release(page);  
  182.     return ret;  
  183. }  



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

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

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

再来看分配匿名页的处理

[cpp] view plain copy
 
  1. static int do_anonymous_page(struct mm_struct *mm, struct vm_area_struct *vma,  
  2.         unsigned long address, pte_t *page_table, pmd_t *pmd,  
  3.         unsigned int flags)  
  4. {  
  5.     struct page *page;  
  6.     spinlock_t *ptl;  
  7.     pte_t entry;  
  8.   
  9.     pte_unmap(page_table);  
  10.   
  11.     /* Check if we need to add a guard page to the stack */  
  12.     if (check_stack_guard_page(vma, address) < 0)  
  13.         return VM_FAULT_SIGBUS;  
  14.   
  15.     /* Use the zero-page for reads */  
  16.     /*如果是读操作，那么就让entry指向一个已有的填充为0的现有页，因为进程是第一次访问该页， 
  17.       所以页中的内容是什么并不重要，这样进一步推迟了新页的分配*/  
  18.     if (!(flags & FAULT_FLAG_WRITE)) {  
  19.         entry = pte_mkspecial(pfn_pte(my_zero_pfn(address),  
  20.                         vma->vm_page_prot));  
  21.         page_table = pte_offset_map_lock(mm, pmd, address, &ptl);  
  22.         if (!pte_none(*page_table))  
  23.             goto unlock;  
  24.         goto setpte;  
  25.     }  
  26.   
  27.     /*如果是写操作，则要分配一个新的页*/  
  28.     /* Allocate our own private page. */  
  29.     if (unlikely(anon_vma_prepare(vma)))//分配一个anon_vma实例  
  30.         goto oom;  
  31.       
  32.     /*分配一个被0填充的页*/  
  33.     page = alloc_zeroed_user_highpage_movable(vma, address);  
  34.     if (!page)  
  35.         goto oom;  
  36.     __SetPageUptodate(page);  
  37.   
  38.     if (mem_cgroup_newpage_charge(page, mm, GFP_KERNEL))  
  39.         goto oom_free_page;  
  40.   
  41.     /*获取页对应的PTE内容*/  
  42.     entry = mk_pte(page, vma->vm_page_prot);  
  43.   
  44.     /*如果是写操作则将页的权限设为读写并设置为脏页*/  
  45.     if (vma->vm_flags & VM_WRITE)  
  46.         entry = pte_mkwrite(pte_mkdirty(entry));  
  47.   
  48.     page_table = pte_offset_map_lock(mm, pmd, address, &ptl);  
  49.     if (!pte_none(*page_table))  
  50.         goto release;  
  51.   
  52.     inc_mm_counter(mm, anon_rss);  
  53.     page_add_new_anon_rmap(page, vma, address);//建立线性区和匿名页的反向映射  
  54. setpte:  
  55.     set_pte_at(mm, address, page_table, entry);//设置page_table对应的pte  
  56.   
  57.     /* No need to invalidate - it was non-present before */  
  58.     update_mmu_cache(vma, address, entry);//更新MMU缓存  
  59. unlock:  
  60.     pte_unmap_unlock(page_table, ptl);  
  61.     return 0;  
  62. release:  
  63.     mem_cgroup_uncharge_page(page);  
  64.     page_cache_release(page);  
  65.     goto unlock;  
  66. oom_free_page:  
  67.     page_cache_release(page);  
  68. oom:  
  69.     return VM_FAULT_OOM;  
  70. }  

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

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

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

[cpp] view plain copy
 
  1. static int do_nonlinear_fault(struct mm_struct *mm, struct vm_area_struct *vma,  
  2.         unsigned long address, pte_t *page_table, pmd_t *pmd,  
  3.         unsigned int flags, pte_t orig_pte)  
  4. {  
  5.     pgoff_t pgoff;  
  6.   
  7.     flags |= FAULT_FLAG_NONLINEAR;  
  8.   
  9.   
  10.     if (!pte_unmap_same(mm, pmd, page_table, orig_pte))  
  11.         return 0;  
  12.   
  13.     if (unlikely(!(vma->vm_flags & VM_NONLINEAR))) {//确保vma具有非线性映射属性  
  14.         /* 
  15.          * Page table corrupted: show pte and kill process. 
  16.          */  
  17.         print_bad_pte(vma, address, orig_pte, NULL);  
  18.         return VM_FAULT_SIGBUS;  
  19.     }  
  20.   
  21.     pgoff = pte_to_pgoff(orig_pte);//获取映射的文件偏移  
  22.     return __do_fault(mm, vma, address, pmd, pgoff, flags, orig_pte);  
  23. }  

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

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

标签：#pte#内存映射#空间分析#用户分析#对应分析#虚拟机#pmd | 浏览：149 | 发布日期：

免责声明：文章转载自《用户空间缺页异常pte_handle_fault()分析--(上)【转】》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇如何同步多个 git 远程仓库python-lambda表达式下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

相关文章

8086汇编语言(1)虚拟机安装ms-dos 7.1

8086汇编语言(1)虚拟机安装ms-dos 7.1 文/玄魂 前言 在开始这一系列文章之前，我想先说下，对于古董级的8086汇编到底还以有没有学习的必要。这里我说下我要从8086开始学习，而不是从win32汇编或者win64汇编直接开始学习的理由。 开发技术越是上层，高级，那么对底层封装的就越深。我学习汇编语言的目的，不是用它来开发应用软件，因为那是高...

一个相见恨晚的idea上的小功能——通过idea直接操作Linux上的文件

因为学习原因，平时自己操作虚拟机需要修改和增加很多文件。 而在Linux系统里的vim，有时候确实还是不及外面idea上用的爽。 在偶然下发现idea可以支持操作虚拟机上的文件，让我高兴不已，废话不多说，直接走流程，其实也很简单。 第一步，保证Linux是开启的 第二部，在idea上，按照如下点击 我自己的是2019.2的版本，后续版本可能有些显示内容不...

如何在vm虚拟机中安装linux

1、首先在vm中新建一个虚拟机  2、选择典型 3、点击稍后安装操作系统  4、选择安装linux，版本可以选择centOS64位的，根据自己系统的位数选择即可 5、选择安装路径，建议装在其他盘，..反正最好别装在c盘就行了  6、磁盘大小可以根据自身需求设置，选择多个磁盘  7、最后点击完成就over了 8、安装操作系统，首先现点击编辑虚拟机...

在Ubuntu-14.04.3配置并成功编译Android6_r1源码

在Ubuntu-14.04.3配置并成功编译Android6_r1源码 折腾了一周，终于把Android6_r1的源码编译成功。先上图，这是在ubuntu中运行的Android模拟器： 由于我是在win8中安装虚拟机VMware，然后在虚拟机中安装Ubuntu进行编译，所以遇到诸多麻烦。如果直接在linux中编译，可能会更顺利。 -----------...

vm虚拟机centos文件共享目录设置

源：CentOS 6 安装VMWare tools，以及解决安装后/mnt中有hgfs但没共享文件的方法 一、首先是安装VMWare tools 1、以ROOT身份进入LINUX    2、在虚拟机软件VMWARE状态栏中，点击 SETTING菜单下的ENABLE VMWARE TOOLS子菜单，此时在linux的 tar zxf vmware-lin...

Windows 8.1安装 Vmware10

之前在windows 8上安装的Vmware 9.0，已经激活了用的蛮好，可是自从上次自动更新系统到windows 8.1后，启动虚拟机时提示要激活 使用各种激活码与注册机都无效，就算注册表信息丢失但是为什么不能重新注册呢？想卸载重装，可是卸载时也报错，使用各种第三方工具只能清理注册表，但仍然无法卸载完成。 激活不了，卸载不了，那就升级下吧，于是下载V...

最新文章

随机推荐

思享工具箱导航