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

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

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

[cpp] view plaincopy
  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. entry = *pte;
  8. if (!pte_present(entry)) {//如果页不在主存中
  9. if (pte_none(entry)) {//页表项内容为0，表明进程未访问过该页
  10. /*如果vm_ops字段和fault字段都不为空，则说明这是一个基于文件的映射*/
  11. if (vma->vm_ops) {
  12. if (likely(vma->vm_ops->fault))
  13. return do_linear_fault(mm, vma, address,
  14. pte, pmd, flags, entry);
  15. }
  16. /*否则分配匿名页*/
  17. return do_anonymous_page(mm, vma, address,
  18. pte, pmd, flags);
  19. }
  20. /*属于非线性文件映射且已被换出*/
  21. if (pte_file(entry))
  22. return do_nonlinear_fault(mm, vma, address,
  23. pte, pmd, flags, entry);
  24. /*页不在主存中，但是页表项保存了相关信息，则表明该页被内核换出，则要进行换入操作*/
  25. return do_swap_page(mm, vma, address,
  26. pte, pmd, flags, entry);
  27. }
  28. ...
  29. ...
  30. }

首先要确定的一点就是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 plaincopy
  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. pte_unmap(page_table);//如果page_table之前用来建立了临时内核映射，则释放该映射
  8. return __do_fault(mm, vma, address, pmd, pgoff, flags, orig_pte);
  9. }

关键函数__do_fault():

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

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

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

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

再来看分配匿名页的处理

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

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

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

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

[cpp] view plaincopy
  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. flags |= FAULT_FLAG_NONLINEAR;
  7. if (!pte_unmap_same(mm, pmd, page_table, orig_pte))
  8. return 0;
  9. if (unlikely(!(vma->vm_flags & VM_NONLINEAR))) {//确保vma具有非线性映射属性
  10. /*
  11. * Page table corrupted: show pte and kill process.
  12. */
  13. print_bad_pte(vma, address, orig_pte, NULL);
  14. return VM_FAULT_SIGBUS;
  15. }
  16. pgoff = pte_to_pgoff(orig_pte);//获取映射的文件偏移
  17. return __do_fault(mm, vma, address, pmd, pgoff, flags, orig_pte);
  18. }

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

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

转载于:https://www.cnblogs.com/sky-heaven/p/5663391.html

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

  1. 一文透彻了解缺页异常

    缺页异常处理流程图解 首先明确下什么是缺页异常,CPU通过地址总线可以访问连接在地址总线上的所有外设,包括物理内存.IO设备等等,但从CPU发出的访问地址并非是这些外设在地址总线上的物理地址,而是一个 ...

  2. linux内核空间和用户空间的是怎样区别的，如何交互，如何从用户空间进入内核空间

    linux驱动程序一般工作在内核空间,但也可以工作在用户空间.下面我们将详细解析,什么是内核空间,什么是用户空间,以及如何判断他们. Linux简化了分段机制,使得虚拟地址与线性地址总是一致,因此,L ...

  3. 2021 CCF基于UEBA的用户上网异常行为分析baseline线上0.90

    2021CCF BDCI 今年CCF又来了,每年都有大佬选手夺冠,也有黑马新人突出重围,对于新人来说一份baseline是很好的起点,可以更快入门数据竞赛.(大佬请忽略!!!) 基于UEBA的用户上网 ...

  4. CCF的基于UEBA的用户上网异常行为分析baseline（线上0.9263）

    基于UEBA的用户上网异常行为分析 比赛地址链接:https://www.datafountain.cn/competitions/520 数据: 代码: import pandas as pd im ...

  5. 对linux用户空间DMA的分析（和单片机一样简单）

    一般情况下,对外设的操作包括轮训方式.中断方式,对于数据量很大的情况会用到DMA操作.本文介绍一种在用户空间实现DMA操作的方法来获取AXI总线上的数据,FPGA部分暂时不详细说明,之后会有专题来介绍 ...

  6. Linux Malloc分析-从用户空间到内核空间

    Linux Malloc分析-从用户空间到内核空间 本文介绍malloc的实现及其malloc在进行堆扩展操作,并分析了虚拟地址到物理地址是如何实现映射关系. ordeder原创,原文链接: http ...

  7. linux内存管理（九）-缺页异常分析

    缺页异常被触发通常有两种情况 a.程序设计的不当导致访问了非法的地址 b.访问的地址是合法的,但是该地址还未分配物理页框 下面解释一下第二种情况,这是虚拟内存管理的一个特性.尽管每个进程独立拥有3GB ...

  8. Linux Malloc分析-从用户空间到内核空间【转】

    转自:http://blog.csdn.net/ordeder/article/details/41654509 版权声明:本文为博主(http://blog.csdn.net/ordeder)原创文 ...

  9. Linux内核源码分析—从用户空间复制数据到内核空间

    Linux内核源码分析-从用户空间复制数据到内核空间 本文主要参考<深入理解Linux内核>,结合2.6.11.1版的内核代码,分析从用户空间复制数据到内核空间函数. 1.不描述内核同步. ...

  10. 基于windows PE文件的恶意代码分析；使用SystemInternal工具与内核调试器研究windows用户空间与内核空间...

    基于windows PE文件的恶意代码分析:使用SystemInternal工具与内核调试器研究windows用户空间与内核空间 ******************** 既然本篇的主角是PE文件,那 ...

最新文章

  1. 笔记本win7共享wifi操作说明
  2. 每日一皮：上线前加了一个小特性，结果......
  3. repmat--矩阵的复制和平铺
  4. python 三指针解决颜色分类
  5. python 之 字符编码 和 中文显示
  6. 液晶显示器背光测试软件,液晶灰阶|饱和度|背光测试
  7. 离线配置xml的文档类型定义文件（xml语法规则） dtd
  8. java 中文域名转码_转换java方法
  9. Linq语言集成查询
  10. （99）FPGA ROM实现（V实现）
  11. java按字节截取字符串牛客网_字符串计数
  12. tsql创建表_在序列中创建缺口– TSQL存储过程顾问
  13. 分享一次学习中遇到的问题
  14. AOP切面五大通知类型
  15. 二次录入已经OUT! 4S店销售用小帮软件机器人教你做人！
  16. 计算机创业计划书800字大全,大学生创业计划书800字左右.docx
  17. 我的团长我的团第十四集
  18. 融云：让银行轻松上“云”
  19. 对组件、模块、子系统、系统、框架、架构 定义浅析
  20. 2019北京物联网智慧城市大数据博览会开启中国之路

热门文章

  1. 【算法学习】高斯模糊算法
  2. ENVI实验教程（4）实验四、遥感图像预处理—融合、镶嵌、裁剪
  3. 空间统计分析之距离-思维导图（1)
  4. MFC SendMessage与PostMessage区别
  5. JavaEE学习02--HTTP协议
  6. 图片服务器虚拟路径,springboot2.0图片上传至本地或服务器并配置虚拟路径的方法.pdf...
  7. Java用for语法找素数,求1-100的质数，用FOR循环。求救。。
  8. c语言加密字母向右移两位,C语言二进制除法用左右移位来表示
  9. oracle 数据库 查看 目录,如何查看oracle数据库服务器名
  10. 文件和参数一起上传_基于netty的文件上传下载组件