图解内存匿名反向映射Reverse Mapping

  • 内容
  • 相关

 

反向映射的目的是为了找到所有映射到某一个页面的页表项,从而可以对目标页做一些操作,比如切断映射。

反向映射一直是一个非常神奇的存在,今天我们就好好探索一下这个知识点。

创建

在反向匿名映射中除了page struct,一共有三个相关的数据结构:

  • vm_area_struct
  • anon_vma
  • anon_vma_chain

第一个数据结构我们已经见过了,是一个老朋友。而后两者就是为了构造反向匿名映射而新生的。我们先来看看这两个新的数据结构的样子。

anon_vma

  1. anon_vma 
  2.     +----------------------------+ 
  3.     |root                        |  = self 
  4.     |parent                      |  = self 
  5.     |    (struct anon_vma*)      | 
  6.     |refcount                    |  = 1 
  7.     |    (atomic_t)              | 
  8.     |degree                      |  = 1 
  9.     |    (unsigned)              | 
  10.     +----------------------------+ 

这个结构由anon_vma_alloc()函数统一生成,上图中也显示了创造出来时候的样子。从这里看,也就是个带有上下级关系的这么一个结构。

anon_vma_chain

  1. anon_vma_chain 
  2.    +----------------------------+ 
  3.    |vma                         | 
  4.    |    (struct vm_area_struct*)| 
  5.    |anon_vma                    | 
  6.    |    (struct anon_vma*)      | 
  7.    |                            | 
  8.    |rb                          | 
  9.    |    (struct rb_node)        | 
  10.    |same_vma                    | 
  11.    |    (struct list_head)      | 
  12.    +----------------------------+ 

这个结构由anon_vma_chain_alloc()统一创建,貌似创建完了也不需要初始化,拿来后面就直接用了。

组合

到这里,大家应该感觉怪怪的,都不知道这些东西是个啥。别急,我把这些东西组合起来,可能你就会有一些感觉了。

在这里,我们把这三个重要的数据结构之间的组合关系展现给大家。当然这只是最简单的组合关系,目的是为了让大家能有一个感性的认识。

  • anon_vma_chain链接了anon_vma和vma
  • vma则会有指针指向自己的anon_vma

空口无凭,眼见为实。那为什么会长成这样的呢?接下来我们就来看看在内核中我们是如何将这些数据结构链接起来的。

链接

上一节的最后,我们看到了三个重要的数据结构通过链表和树连接在了一起,这一节我们就来看看他们是怎么连接起来的。

anon_vma_chain_link

往简单了讲,要连接这三个重要的数据结构,都靠一个函数:anon_vma_chain_link(vma, avc, anon_vma)。而这个函数本身简单到令人发指,以至于我能把整个定义给大家展示出来。

  1. static void anon_vma_chain_link(struct vm_area_struct *vma, 
  2.                     struct anon_vma_chain *avc, 
  3.                     struct anon_vma *anon_vma) 
  4.     { 
  5.         avc->vma = vma; 
  6.         avc->anon_vma = anon_vma; 
  7.         list_add(&avc->same_vma, &vma->anon_vma_chain); 
  8.         anon_vma_interval_tree_insert(avc, &anon_vma->rb_root); 
  9.     } 

你对照这上面的图一看,和图上显示的一摸一样没有任何多余的步骤。

但是,关键的但是来了,如果你以为一切就这这么简单,那就too young too simple了啊。

接下来我们将从anon_vma_chain_link函数被调用的关系入手,去看看在实际运行中究竟会演化出什么样的变化来。

do_anonymous_page

首先出场的是函数do_anonymous_page,这个函数是在匿名页缺页中断时会调用的函数。

  1. do_anonymous_page(vmf) 
  2.         __anon_vma_prepare(vma) 
  3.             avc = anon_vma_chain_alloc() 
  4.             anon_vma = find_mergeable_anon_vma(vma) 
  5.             anon_vma = anon_vma_alloc() 
  6.             vma->anon_vma = anon_vma 
  7.             anon_vma_chain_link(vma, avc, anon_vma) 

从上面的流程可以看出,当发生缺页中断时,内核会给对应的vma构造anon_vma,并且利用avc去链接这两者。这种可以说是系统中最简单的例子,也是上图中显示的情况。

细心的人可能已经看到了,上面有一种情况是find_mergeable_anon_vma。如果这个函数返回一个可以重用的anon_vma,那么内核就可以利用原有的anon_vma了。此时这个图我们可以画成这样。

  1.       .......................      ************************* 
  2.         .                     .      *                       * 
  3. av      v                 avc v      v                vma    v 
  4. +-----------+             +-------------+             +-------------+ 
  5. |           |<------------|anon_vma  vma|------------>|             | 
  6. |           |<-           |             |             |             | 
  7. +-----------+  \          +-------------+             +-------------+ 
  8.         ^                     ^      ^                       ^ 
  9.         .       \             .      *                       * 
  10.         .                     .      ************************* 
  11.         .        \            . 
  12.         .                     . 
  13.         .         \           .      ************************* 
  14.         .                     .      *                       * 
  15.         .          \      avc v      v                vma    v 
  16.         .                 +-------------+             +-------------+ 
  17.         .           ------|anon_vma  vma|------------>|             | 
  18.         .                 |             |             |             | 
  19.         .                 +-------------+             +-------------+ 
  20.         .                     ^      ^                       ^ 
  21.         .                     .      *                       * 
  22.         .......................      ************************* 

其实此处我画得不够精确,av 和 avc之间应当是树的关系,而不是现在显示的链表的关系。但是我想意思已经表达清楚,即在一个进程中多个vma可以共享同一个anon_vma作为匿名映射的节点。

anon_vma_fork

看过了在单个进程中的情况,接下来我们来看看创建一个子进程时如何调整这个数据结构。这个过程由anon_vma_fork处理。

  1. anon_vma_fork(vma, pvma) 
  2.         anon_vma_clone(vma, pvma) 
  3.         anon_vma = anon_vma_alloc() 
  4.         avc = anon_vma_chain_alloc() 
  5.         anon_vma->root = pvma->anon_vma->root 
  6.         anon_vma->parent = pvma->anon_vma 
  7.         vma->anon_vma = anon_vma 
  8.         anon_vma_chain_link(vma, avc, anon_vma) 

这个函数很有意思,我还真是花了些时间去理解它。最开始有点看不清,所以我干脆退回到最简单的状态,也就是当前进程是根进程的时候。此时我才大致的了解了一点fork时究竟发生了什么。

话不多说,还是用一个图来表达

  1.             .......................      ************************* 
  2.             .                     .      *                       * 
  3.     av      v                 avc v      v                vma    v 
  4.     +-----------+             +-------------+             +-------------+ 
  5. P   |           |<------------|anon_vma  vma|------------>|             | 
  6.     |           |<----+       |             |             |             | 
  7.     +-----------+      \      +-------------+             +-------------+ 
  8.             ^                     ^      ^                       ^ 
  9.             .           \         .      *                       * 
  10.             .                     .      ************************* 
  11.             .            \        . 
  12.             .                     . 
  13.             .             \       . 
  14.             .                     . 
  15.             .              \      .      ************************* 
  16.             .                     .      *                       * 
  17.             .               \ avc v      v                       * 
  18.             .                 +-------------+                    * 
  19.             .                \|anon_vma  vma|\                   * 
  20.             .                 |             |                    * 
  21.             .                 +-------------+  \                 * 
  22.             .                    ^       ^                       * 
  23.             .                    .       *       \               * 
  24.             ......................       *                       * 
  25.                                          *         \             * 
  26.                                          *                       * 
  27.                                          *           \           * 
  28.             .......................      *                       * 
  29.             .                     .      *             \         * 
  30.     av      v                 avc v      v              \ vma    v 
  31.     +-----------+             +-------------+            >+-------------+ 
  32. C1  |           |<------------|anon_vma  vma|------------>|             | 
  33.     |           |             |             |             |             | 
  34.     +-----------+             +-------------+             +-------------+ 
  35.             ^                     ^      ^                       ^ 
  36.             .                     .      *                       * 
  37.             .......................      ************************* 

P是父进程,C1是他的一个子进程。当发生fork时,page->mapping没有发生改变,所以依然需要能够从父进程的anon_vma上搜索到对应的页表。此时就得在父进程的rb_root树中保留一个子进程的avc。同时子进程又拥有自己的一套anon_vma。

可以说这个真的是非常有意思的。

对了,代码中还有一个函数anon_vma_clone,在这里我就不展开了。留给大家下来思考一下下。

使用

好了,到了这里我们已经拥有了一个非常强悍的武器 – 匿名反向映射。有了他我们就可以指哪打哪了。

内核也已经给我们准备好了扣动这个核武器的板机 – rmap_walk_anon。

  1. rmap_walk_anon(page, rwc, true/false
  2.         anon_vma = page_anon_vma(page), get anon_vma from page->mapping 
  3.         pgoff_start = page_to_pgoff(page); 
  4.             return page_to_index(page) 
  5.         pgoff_end = pgoff_start + hpage_nr_pages(page) - 1; 
  6.         anon_vma_interval_tree_foreach(avc, &anon_vma->rb_root, pgoff_start, pgoff_end) 
  7.         rwc->rmap_one(page, vma, address, rwc->arg) -> do the real work 

有了上面的基础知识,我想看这段代码就不难了。还记得上面看到过的那个rb_root么?对了,我们就是沿着这颗红黑树找到的vma,然后再找到了页表。

嗯,一切都感觉这么的完美。

本文转载自微信公众号「Linux阅码场」,可以通过以下二维码关注。转载本文请联系Linux阅码场公众号。

本文标签:

版权声明:若无特殊注明,本文皆为《若离风》原创,转载请保留文章出处。

本文链接:图解内存匿名反向映射Reverse Mapping - https://www.rlfit.cn/?post=551

收录状态: [百度已收录]

发表评论

电子邮件地址不会被公开。 必填项已用*标注

未显示?请点击刷新

允许邮件通知