转载：Linux内存管理之页面回收

转载自：

http://blog.csdn.net/bullbat/article/details/7311205

http://blog.chinaunix.net/uid-23253303-id-3935372.html

请求调页机制，只要用户态进程继续执行，他们就能获得页框，然而，请求调页没有办法强制进程释放不再使用的页框。因此，迟早所有空闲内存将被分配给进程和高速缓存，Linux内核的页面回收算法（PFRA）采取从用户进程和内核高速缓存“窃取”页框的办法不从伙伴系统的空闲块列表。

       实际上，在用完所有空闲内存之前，就必须执行页框回收算法。否则，内核很可能陷入一种内存请求的僵局中，并导致系统崩溃。也就是说，要释放一个页框，内核就必须把页框的数据写入磁盘；但是，为了完成这一操作，内核却要请求另一个页框（例如，为I/O数据传送分配缓冲区首部）。因为不存在空闲页框，因此，不可能释放页框。

       页框算法的目标之一就是保存最少的空闲页框并使内核可以安全地从“内存紧缺”的情形中恢复过来。

//-----------------------------------------

内存回收的目标
不是所有的物理内存都可以参与回收的，比如要是把内核代码段的内存给回收了，系统就无法正常运行了，一般内核代码段，数据段，内核kmalloc()出来的内存，内核线程占用的内存等都是不可以回收的，除此之外的内存都是我们要回收的目标、
回收的内存主要是由用户态进程占用的内存和内核自己在运行时所使用的一些内存组成。用户态进程占用的内存主要是我们常见的进程代码段，数据段，堆栈等，内核运行使用的内存主要是磁盘高速缓存(如索引节点，目录项高速缓存），页面高速缓存(访问文件时系统生成的页面cache)，mmap()文件时所用的有名映射所使用的物理内存。后面的这些内才能虽然也是内核管理使用的内存，但对其进行回收的时候，顶多影响内核的性能，而不会导致系统无法运行。

  内存回收主要是要回收两类内存：最近最少使用的内存以及高速内存缓存中空闲的slab。前者主要包括用户态进程的代码段，数据段，堆栈，文件映射内存，页高速内存，后者主要包括磁盘高速缓存及一些其他的空闲内存高速缓存。

//-----------------------------------------

选择目标页

       PFRA的目标就是获得页框并使之空闲。PFRA按照页框所含内容，以不同的方式处理页框。我们将他们区分成：不可回收页、可交换页、可同步页和可丢弃页：

页类型	说明	回收操作
不可回收页	空闲页（包含子伙伴系统列表中） 保留页（PG_reserved标志置位） 内核动态分配页 进程内核态堆栈页 临时锁定页（PG_locked标志置位） 内存锁定页（在先行区中且VM_LOCKED标志置位）	不允许也无需回收
可回收页	用户态地址空间的匿名页 Tmpfs文件系统的映射页（如IPC共享内存的页）	将页的内容保存在交换区
可同步页	用户态地址空间的映射页 存有磁盘文件数据且在页高速缓存中的页 块设备缓冲区页 某些磁盘高速缓存的页（如索引节点高速缓存）	必要时，与磁盘镜像同步这些页
可丢弃页	内存高速缓存中的未使用页（如slab分配器高速缓存） 目录想高速缓存的未使用页	无需操作

 

进行页面回收的时机

        Linux 操作系统使用如下这两种机制检查系统内存的使用情况，从而确定可用的内存是否太少从而需要进行页面回收。

• • 周期性的检查：这是由后台运行的守护进程 kswapd 完成的。该进程定期检查当前系统的内存使用情况，当发现系统内空闲的物理页面数目少于特定的阈值时，该进程就会发起页面回收的操作。
  • “内存严重不足”事件的触发：在某些情况下，比如，操作系统忽然需要通过伙伴系统为用户进程分配一大块内存，或者需要创建一个很大的缓冲区，而当时系统中的内存没有办法提供足够多的物理内存以满足这种内存请求，这时候，操作系统就必须尽快进行页面回收操作，以便释放出一些内存空间从而满足上述的内存请求。这种页面回收方式也被称作“直接页面回收”。
  • 睡眠回收，在进入suspend-to-disk状态时，内核必须释放内存。

       如果操作系统在进行了内存回收操作之后仍然无法回收到足够多的页面以满足上述内存要求，那么操作系统只有最后一个选择，那就是使用 OOM( out of memory )killer，它从系统中挑选一个最合适的进程杀死它，并释放该进程所占用的所有页面。

       上面介绍的内存回收机制主要依赖于三个字段：pages_min，pages_low 以及 pages_high。每个内存区域（ zone ）都在其区域描述符中定义了这样三个字段，这三个字段的具体含义如下表 所示。

字段含义

名称	字段描述
pages_min	区域的预留页面数目，如果空闲物理页面的数目低于 pages_min，那么系统的压力会比较大，此时，内存区域中急需空闲的物理页面，页面回收的需求非常紧迫。
pages_low	控制进行页面回收的最小阈值，如果空闲物理页面的数目低于 pages_low，那么操作系统内核会开始进行页面回收。
pages_high	控制进行页面回收的最大阈值，如果空闲物理页面的数目多于 pages_high，则内存区域的状态是理想的。

 

PFRA设计

设计总则

1.       首先释放“无害”页，即必须线回收没有被任何进程使用的磁盘与内存高速缓存中的页；

2.       将用户态进程和所有页定为可回首页，FPRA必须能够窃得人任何用户态进程页，包括匿名页。这样，睡眠较长时间的进程将逐渐失去所有页；

3.       同时取消引用一个共享页的所有页表项的映射，就可以回收该共享页；

4.       只回收“未用”页，使用LRU算法。Linux使用每个页表项中的访问标志位，在页被访问时，该标志位由银奖自动置位；而且，页年龄由页描述符在链表（两个不同的链表之一）中的位置来表示。

因此，页框回收算法是集中启发式方法的混合：

1．  谨慎选择检查高速缓存的顺序；

2．  基于页年龄的变化排序；

3．  区别对待不同状态的页；

反向映射

        PFRA的目标之一是能释放共享页框。为达到这个目地。Linux内核能够快速定为指向同一页框的所有页表项。这个过程就叫做反向映射。Linux 操作系统为物理页面建立一个链表，用于指向引用了该物理页面的所有页表项。

基本思想如下图：

       Linux采用“面向对象的反向映射”技术。实际上，对任何可回收的用户态页，内核保留系统中该页所在所有现行区（“对象”）的反向链接，每个线性区描述符（ vm_area_struct 结构）存放一个指针指向一个内存描述符（ mm_struct 结构），而该内存描述符又包含一个指针指向一个页全局目录（PGD）。因此，这些反向链接使得PFRA能够检索引用某页的所有页表项。因为线性区描述符比页描述符少，所以更新共享页的反向链接就比较省时间。下面是具体的实现：

基于对象的反向映射的实现

数据结构

       首先，PFRA必须要确定待回收页是共享的还是非共享的，以及是映射页或是匿名页。为做到这一点，内核要查看页描述符的两个字段：_mapcount和mapping。_mapcount字段存放引用页框的页表项数目，确定其是否共享；mapping字段用于确定页是映射的或是匿名的：为空表示该页属于交换高速缓存；非空，且最低位是1，表示该页为匿名页，同时mapping字段中存放的是指向anon_vma描述符的指针；如果mapping字段非空，且最低位是0，表示该页为映射页；同时mapping字段指向对应文件的address_space对象。

[cpp] view plain copy print ?

1. struct page   
2. {   
3.      atomic_t _mapcount;          
4.                   
5.      union {   
6.         ……  
7.         struct {   
8.         ……        
9.          struct address_space *mapping;       
10.         };   
11.         ……  
12.  };   

        Linux的address_space对象在RAMA中是对其的，所以其起始地址是4的倍数。因此其mapping字段的最低位可以用作一个标志位来表示该字段的指针是指向address_space对象还是anon_vma描述符。PageAnon检查mapping最低位。

[cpp] view plain copy print ?

1. /*检查页是否为匿名页，低位为1时为匿名页*/  
2. static inline int PageAnon(struct page *page)  
3. {  
4.     return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != 0;  
5. }  

        匿名页面和文件映射页面分别采用了不同的底层数据结构去存放与页面相关的虚拟内存区域。对于匿名页面来说，与该页面相关的虚拟内存区域存放在结构 anon_vma 中定义的双向链表中。结构 anon_vma 定义很简单，如下所示：

[cpp] view plain copy print ?

1. struct anon_vma   
2. {   
3.      spinlock_t lock;     
4.      struct list_head head;       
5. };  

匿名页的面向对象反向映射如下图：

       可以通过页面的mapping找到anon_vma然后找到映射该页面的所有线性区域（vm_area_struct结构）。

而对于基于文件映射的页面来说，与匿名页面不同的是，与该页面相关的虚拟内存区域的存放是利用了优先级搜索树这种数据结构的。这是因为对于匿名页面来说，页面虽然可以是共享的，但是一般情况下，共享匿名页面的使用者的数目不会很多；而对于基于文件映射的页面来说，共享页面的使用者的数目可能会非常多，使用优先级搜索树这种结构可以更加快速地定位那些引用了该页面的虚拟内存区域。操作系统会为每一个文件都建立一个优先级搜索树，其根节点可以通过结构 address_space 中的 i_mmap 字段获取。

[cpp] view plain copy print ?

1. struct address_space {   
2.   ……  
3.  struct prio_tree_root   i_mmap;          
4. ……  
5.  }   

       Linux中使用 (radix,size,heap) 来表示优先级搜索树中的节点。其中，radix 表示内存区域的起始位置，heap 表示内存区域的结束位置，size 与内存区域的大小成正比。在优先级搜索树中，父节点的 heap 值一定不会小于子节点的 heap 值。在树中进行查找时，根据节点的 radix 值进行。程序可以根据 size 值区分那些具有相同 radix 值的节点。

      在用于表示虚拟内存区域的结构 vm_area_struct 中，与上边介绍的双向链表和优先级搜索树相关的字段如下所示：

[cpp] view plain copy print ?

1. struct vm_area_struct {   
2.  struct mm_struct * vm_mm;    
3. ……  
4.  union {   
5.      struct {   
6.          struct list_head list;   
7.          void *parent;    
8.          struct vm_area_struct *head;   
9.      } vm_set;   
10.   
11.      struct raw_prio_tree_node prio_tree_node;   
12.  } shared;   
13.   
14.   
15.  struct list_head anon_vma_node;      
16.  struct anon_vma *anon_vma;       
17. };   

       与匿名页面的双向链表相关的字段是 anon_vma_node 和 anon_vma。union shared 则与文件映射页面使用的优先级搜索树相关。字段 anon_vma 指向 anon_vma 表；字段 anon_vma_node 将映射该页面的所有虚拟内存区域链接起来；union shared 中的 prio_tree_node 结构用于表示优先级搜索树的一个节点；在某些情况下，比如不同的进程的内存区域可能映射到了同一个文件的相同部分，也就是说这些内存区域具有相同的（radix,size,heap）值，这个时候 Linux 就会在树上相应的节点（树上原来那个具有相同（radix,size,heap） 值的内存区域）上接一个双向链表用来存放这些内存区域，这个链表用 vm_set.list 来表示；树上那个节点指向的链表中的第一个节点是表头，用 vm_set.head 表示；vm_set.parent 用于表示是否是树结点。下边给出一个小图示简单说明一下 vm_set.list 和 vm_set.head。

vm_set.list 和 vm_set.head

       通过结构 vm_area_struct 中的 vm_mm 字段可以找到对应的 mm_struct 结构，在该结构中找到页全局目录，从而定位所有相关的页表项。

反向映射实现

       在进行页面回收的时候，Linux的 shrink_page_list() 函数中调用 try_to_unmap() 函数去更新所有引用了回收页面的页表项。其代码流程如下所示：
实现函数 try_to_unmap() 的关键代码流程图

       函数 try_to_unmap() 分别调用了两个函数 try_to_unmap_anon() 和 try_to_unmap_file()，其目的都是检查并确定都有哪些页表项引用了同一个物理页面，但是，由于匿名页面和文件映射页面分别采用了不同的数据结构，所以二者采用了不同的方法。

       函数 try_to_unmap_anon() 用于匿名页面，该函数扫描相应的 anon_vma 表中包含的所有内存区域，并对这些内存区域分别调用 try_to_unmap_one() 函数。

       函数 try_to_unmap_file() 用于文件映射页面，该函数会在优先级搜索树中进行搜索，并为每一个搜索到的内存区域调用 try_to_unmap_one() 函数。

       两条代码路径最终汇合到 try_to_unmap_one() 函数中，更新引用特定物理页面的所有页表项的操作都是在这个函数中实现的。

代码如下，对关键部分做了注释：

[cpp] view plain copy print ?

1. static int try_to_unmap_anon(struct page *page, enum ttu_flags flags)  
2. {  
3.     struct anon_vma *anon_vma;  
4.     struct vm_area_struct *vma;  
5.     unsigned int mlocked = 0;  
6.     int ret = SWAP_AGAIN;  
7.     int unlock = TTU_ACTION(flags) == TTU_MUNLOCK;  
8.   
9.     if (MLOCK_PAGES && unlikely(unlock))  
10.         ret = SWAP_SUCCESS; /* default for try_to_munlock() */  
11.     /*如果该页面为匿名映射，返回该页面对应的匿名结构*/  
12.     anon_vma = page_lock_anon_vma(page);  
13.     if (!anon_vma)  
14.         return ret;  
15.     /*这里可以看出，vma的anon_vma_node字段链接到 
16.     anon_vma的head字段*/  
17.     /*扫描线性区描述符的anon_vma链表*/  
18.     list_for_each_entry(vma, &anon_vma->head, anon_vma_node) {  
19.         if (MLOCK_PAGES && unlikely(unlock)) {  
20.             if (!((vma->vm_flags & VM_LOCKED) &&  
21.                   page_mapped_in_vma(page, vma)))  
22.                 continue;  /* must visit all unlocked vmas */  
23.             ret = SWAP_MLOCK;  /* saw at least one mlocked vma */  
24.         } else {  
25.             /*对anon_vma链表中的每一个vma线性区描述符 
26.             调用该函数*/  
27.             ret = try_to_unmap_one(page, vma, flags);  
28.             if (ret == SWAP_FAIL || !page_mapped(page))  
29.                 break;  
30.         }  
31.         if (ret == SWAP_MLOCK) {  
32.             mlocked = try_to_mlock_page(page, vma);  
33.             if (mlocked)  
34.                 break;  /* stop if actually mlocked page */  
35.         }  
36.     }  
37.   
38.     page_unlock_anon_vma(anon_vma);  
39.   
40.     if (mlocked)  
41.         ret = SWAP_MLOCK;   /* actually mlocked the page */  
42.     else if (ret == SWAP_MLOCK)  
43.         ret = SWAP_AGAIN;   /* saw VM_LOCKED vma */  
44.   
45.     return ret;  
46. ｝  

[cpp] view plain copy print ?

1. /* 
2.  * Subfunctions of try_to_unmap: try_to_unmap_one called 
3.  * repeatedly from either try_to_unmap_anon or try_to_unmap_file. 
4.  */  
5.  /** 
6.     *page是一个指向目标页描述符的指针； 
7.     *vma是指向线性区描述符的指针 
8.     */  
9. static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,  
10.                 enum ttu_flags flags)  
11. {  
12.     struct mm_struct *mm = vma->vm_mm;  
13.     unsigned long address;  
14.     pte_t *pte;  
15.     pte_t pteval;  
16.     spinlock_t *ptl;  
17.     int ret = SWAP_AGAIN;  
18.     /*计算出待回收页的线性地址*/  
19.     address = vma_address(page, vma);  
20.     if (address == -EFAULT)  
21.         goto out;  
22.     /*获取线性地址对应的页表项地址*/  
23.     pte = page_check_address(page, mm, address, &ptl, 0);  
24.     if (!pte)  
25.         goto out;  
26.   
27.     /* 
28.      * If the page is mlock()d, we cannot swap it out. 
29.      * If it's recently referenced (perhaps page_referenced 
30.      * skipped over this mm) then we should reactivate it. 
31.      */  
32.      /*下面为判断是否可以被回收*/  
33.     if (!(flags & TTU_IGNORE_MLOCK)) {  
34.         if (vma->vm_flags & VM_LOCKED) {  
35.             ret = SWAP_MLOCK;  
36.             goto out_unmap;  
37.         }  
38.     }  
39.     if (!(flags & TTU_IGNORE_ACCESS)) {  
40.         if (ptep_clear_flush_young_notify(vma, address, pte)) {  
41.             ret = SWAP_FAIL;  
42.             goto out_unmap;  
43.         }  
44.     }  
45.   
46.     /* Nuke the page table entry. */  
47.     flush_cache_page(vma, address, page_to_pfn(page));  
48.     /*更新页表项并冲刷相应的TLB*/  
49.     pteval = ptep_clear_flush_notify(vma, address, pte);  
50.   
51.     /* Move the dirty bit to the physical page now the pte is gone. */  
52.     if (pte_dirty(pteval))/*如果是脏页面，置位PG_dirty*/  
53.         set_page_dirty(page);  
54.   
55.     /* Update high watermark before we lower rss */  
56.     /*更新mm的hiwater_rss*/  
57.     update_hiwater_rss(mm);  
58.   
59.     if (PageHWPoison(page) && !(flags & TTU_IGNORE_HWPOISON)) {  
60.         if (PageAnon(page))  
61.             dec_mm_counter(mm, anon_rss);  
62.         else  
63.             dec_mm_counter(mm, file_rss);  
64.         set_pte_at(mm, address, pte,  
65.                 swp_entry_to_pte(make_hwpoison_entry(page)));  
66.     } else if (PageAnon(page)) {/*如果是匿名页*/  
67.         swp_entry_t entry = { .val = page_private(page) };  
68.   
69.         if (PageSwapCache(page)) {  
70.             /* 
71.              * Store the swap location in the pte. 
72.              * See handle_pte_fault() ... 
73.              */  
74.              /*保存换出位置*/  
75.             swap_duplicate(entry);  
76.             if (list_empty(&mm->mmlist)) {  
77.                 spin_lock(&mmlist_lock);  
78.                 if (list_empty(&mm->mmlist))  
79.                     /*添加到init_mm的相应链表，从这里可以 
80.                     看出mm->mmlist为交换用的链表*/  
81.                     list_add(&mm->mmlist, &init_mm.mmlist);  
82.                 spin_unlock(&mmlist_lock);  
83.             }  
84.             dec_mm_counter(mm, anon_rss);  
85.         } else if (PAGE_MIGRATION) {  
86.             /* 
87.              * Store the pfn of the page in a special migration 
88.              * pte. do_swap_page() will wait until the migration 
89.              * pte is removed and then restart fault handling. 
90.              */  
91.             BUG_ON(TTU_ACTION(flags) != TTU_MIGRATION);  
92.             entry = make_migration_entry(page, pte_write(pteval));  
93.         }  
94.         set_pte_at(mm, address, pte, swp_entry_to_pte(entry));  
95.         BUG_ON(pte_file(*pte));  
96.     } else if (PAGE_MIGRATION && (TTU_ACTION(flags) == TTU_MIGRATION)) {  
97.         /* Establish migration entry for a file page */  
98.         swp_entry_t entry;  
99.         entry = make_migration_entry(page, pte_write(pteval));  
100.         set_pte_at(mm, address, pte, swp_entry_to_pte(entry));  
101.     } else  
102.         dec_mm_counter(mm, file_rss);  
103.   
104.     /*断开页表项和物理页面的关系*/  
105.     page_remove_rmap(page);  
106.     /*释放所分配的缓存*/  
107.     page_cache_release(page);  
108.   
109. out_unmap:  
110.     pte_unmap_unlock(pte, ptl);  
111. out:  
112.     return ret;  
113. }  

        对于给定的物理页面来说，该函数会根据计算出来的线性地址找到对应的页表项地址，并更新页表项。对于匿名页面来说，换出的位置必须要被保存下来，以便于该页面下次被访问的时候可以被换进来。并非所有的页面都是可以被回收的，比如被 mlock() 函数设置过的内存页，或者最近刚被访问过的页面，等等，都是不可以被回收的。一旦遇上这样的页面，该函数会直接跳出执行并返回错误代码。如果涉及到页缓存中的数据，需要设置页缓存中的数据无效，必要的时候还要置位页面标识符以进行数据回写。该函数还会更新相应的一些页面使用计数器，比如前边提到的 _mapcount 字段，还会相应地更新进程拥有的物理页面数目等。

PFRA具体实现

LRU 链表

        在 Linux 中，操作系统对 LRU 的实现主要是基于一对双向链表：active 链表和 inactive 链表，这两个链表是 Linux 操作系统进行页面回收所依赖的关键数据结构，每个内存区域都存在一对这样的链表。顾名思义，那些经常被访问的处于活跃状态的页面会被放在 active 链表上，而那些虽然可能关联到一个或者多个进程，但是并不经常使用的页面则会被放到 inactive 链表上。页面会在这两个双向链表中移动，操作系统会根据页面的活跃程度来判断应该把页面放到哪个链表上。页面可能会从 active 链表上被转移到 inactive 链表上，也可能从 inactive 链表上被转移到 active 链表上，但是，这种转移并不是每次页面访问都会发生，页面的这种转移发生的间隔有可能比较长。那些最近最少使用的页面会被逐个放到 inactive 链表的尾部。进行页面回收的时候，Linux 操作系统会从 inactive 链表的尾部开始进行回收。

用于描述内存区域的 struct zone() 中关于这两个链表以及相关的关键字段的定义如下所示：

[cpp] view plain copy print ?

1. struct zone {   
2.    ……  
3.  spinlock_t             lru_lock;     
4.  struct list_head    active_list;   
5.  struct list_head    inactive_list;   
6.  unsigned long       nr_active;   
7.  unsigned long       nr_inactive;   
8.    ……  
9.   
10. }   

各字段含义如下所示：

lru_lock：active_list 和 inactive_list 使用的自旋锁。

active_list：管理内存区域中处于活跃状态的页面。

inactive_list：管理内存区域中处于不活跃状态的页面。

nr_active：active_list 链表上的页面数目。

nr_inactive：inactive_list 链表上的页面数目。

如何在两个LRU 链表之间移动页面

       Linux 引入了两个页面标志符 PG_active 和 PG_referenced 用于标识页面的活跃程度，从而决定如何在两个链表之间移动页面。PG_active 用于表示页面当前是否是活跃的，如果该位被置位，则表示该页面是活跃的。PG_referenced 用于表示页面最近是否被访问过，每次页面被访问，该位都会被置位。Linux 必须同时使用这两个标志符来判断页面的活跃程度，假如只是用一个标志符，在页面被访问时，置位该标志符，之后该页面一直处于活跃状态，如果操作系统不清除该标志位，那么即使之后很长一段时间内该页面都没有或很少被访问过，该页面也还是处于活跃状态。为了能够有效清除该标志位，需要有定时器的支持以便于在超时时间之后该标志位可以自动被清除。然而，很多 Linux 支持的体系结构并不能提供这样的硬件支持，所以 Linux 中使用两个标志符来判断页面的活跃程度。

Linux 2.6 中这两个标志符密切合作，其核心思想如下所示：

• 如果页面被认为是活跃的，则将该页的 PG_active 置位；否则，不置位。
• 当页面被访问时，检查该页的 PG_referenced 位，若未被置位，则置位之；若发现该页的 PG_referenced 已经被置位了，则意味着该页经常被访问，这时，若该页在 inactive 链表上，则置位其 PG_active 位，将其移动到 active 链表上去，并清除其 PG_referenced 位的设置；如果页面的 PG_referenced 位被置位了一段时间后，该页面没有被再次访问，那么 Linux 操作系统会清除该页面的 PG_referenced 位，因为这意味着这个页面最近这段时间都没有被访问。
• PG_referenced 位同样也可以用于页面从 active 链表移动到 inactive 链表。对于某个在 active 链表上的页面来说，其 PG_active 位被置位，如果 PG_referenced 位未被置位，给定一段时间之后，该页面如果还是没有被访问，那么该页面会被清除其 PG_active 位，挪到 inactive 链表上去。

Linux 中实现在 LRU 链表之间移动页面的关键函数如下所示（本文涉及的源代码均是基于 Linux 2.6.18.1 版本的）：

• mark_page_accessed()：当一个页面被访问时，则调用该函数相应地修改 PG_active 和 PG_referenced。
• page_referenced()：当操作系统进行页面回收时，每扫描到一个页面，就会调用该函数设置页面的 PG_referenced 位。如果一个页面的 PG_referenced 位被置位，但是在一定时间内该页面没有被再次访问，那么该页面的 PG_referenced 位会被清除。
• activate_page()：该函数将页面放到 active 链表上去。
• shrink_active_list()：该函数将页面移动到 inactive 链表上去。

LRU 缓存

        前边提到，页面根据其活跃程度会在 active 链表和 inactive 链表之间来回移动，如果要将某个页面插入到这两个链表中去，必须要通过自旋锁以保证对链表的并发访问操作不会出错。为了降低锁的竞争，Linux 提供了一种特殊的缓存：LRU 缓存，用以批量地向 LRU 链表中快速地添加页面。有了 LRU 缓存之后，新页不会被马上添加到相应的链表上去，而是先被放到一个缓冲区中去，当该缓冲区缓存了足够多的页面之后，缓冲区中的页面才会被一次性地全部添加到相应的 LRU 链表中去。Linux 采用这种方法降低了锁的竞争，极大地提升了系统的性能。

LRU 缓存用到了 pagevec 结构，如下所示 :

[cpp] view plain copy print ?

1. struct pagevec {   
2.      unsigned long nr;   
3.      unsigned long cold;   
4.      struct page *pages[PAGEVEC_SIZE];   
5.  };  

         pagevec 这个结构就是用来管理 LRU 缓存中的这些页面的。该结构定义了一个数组，这个数组中的项是指向 page 结构的指针。一个 pagevec 结构最多可以存在 14 个这样的项（PAGEVEC_SIZE 的默认值是 14）。当一个 pagevec 的结构满了，那么该 pagevec 中的所有页面会一次性地被移动到相应的 LRU 链表上去。

用来实现 LRU 缓存的两个关键函数是 lru_cache_add() 和 lru_cache_add_active()。前者用于延迟将页面添加到 inactive 链表上去，后者用于延迟将页面添加到 active 链表上去。这两个函数都会将要移动的页面先放到页向量 pagevec 中，当 pagevec 满了（已经装了 14 个页面的描述符指针），pagevec 结构中的所有页面才会被一次性地移动到相应的链表上去。

下图概括总结了上文介绍的如何在两个链表之间移动页面，以及 LRU 缓存在其中起到的作用：

 页面在 LRU 链表之间移动示意图

       其中，1 表示函数 mark_page_accessed()，2 表示函数 page_referenced()，3 表示函数 activate_page()，4 表示函数 shrink_active_list()。

PFRA具体实现

        PFRA必须处理多种属于用户态进程、磁盘高速缓存和内存高速缓存的页，而且必须遵照几条试探法准则。PFRA的大部分函数如下：

       如上图在分配VFS缓冲区或缓冲区首部时，内核调用free_more_memory();而当从伙伴系统分配一个或多个页框时，调用try_to_free_pages()。

页面回收关键代码流程图

       上文提到 Linux 中页面回收主要是通过两种方式触发的，一种是由“内存严重不足”事件触发的；一种是由后台进程 kswapd 触发的，该进程周期性地运行，一旦检测到内存不足，就会触发页面回收操作。对于第一种情况，系统会调用函数 try_to_free_pages() 去检查当前内存区域中的页面，回收那些最不常用的页面。对于第二种情况，函数 balance_pgdat() 是入口函数。

        当 NUMA 上的某个节点的低内存区域调用函数 try_to_free_pages() 的时候，该函数会反复调用 shrink_zones() 以及 shrink_slab() 释放一定数目的页面，默认值是 32 个页面。如果在特定的循环次数内没有能够成功释放 32 个页面，那么页面回收会调用 OOM killer 选择并杀死一个进程，然后释放它占用的所有页面。函数 shrink_zones() 会对内存区域列表中的所有区域分别调用 shrink_zone() 函数，后者是从内存回收最近最少使用页面的入口函数。

        对于定期页面检查并进行回收的入口函数 balance_pgdat() 来说，它主要调用的函数是 shrink_zone() 和 shrink_slab()。从上图中我们也可以看出，进行页面回收的两条代码路径最终汇合到函数 shrink_zone() 和函数 shrink_slab() 上。

函数 shrink_zone()

       其中，shrink_zone() 函数是 Linux 操作系统实现页面回收的最核心的函数之一，它实现了对一个内存区域的页面进行回收的功能，该函数主要做了两件事情：

• 将某些页面从 active 链表移到 inactive 链表，这是由函数 shrink_active_list() 实现的。
• 从 inactive 链表中选定一定数目的页面，将其放到一个临时链表中，这由函数 shrink_inactive_list() 完成。该函数最终会调用 shrink_page_list() 去回收这些页面。

       函数 shrink_page_list() 返回的是回收成功的页面数目。概括来说，对于可进行回收的页面，该函数主要做了这样几件事情，其代码流程图如下所示：
函数 shrink_page_list() 实现的关键功能

• 对于匿名页面来说，在回收此类页面时，需要将其数据写入到交换区。如果尚未为该页面分配交换区槽位，则先分配一个槽位，并将该页面添加到交换缓存。同时，将相关的 page 实例加入到交换区，这样，对该页面的处理就可以跟其他已经建立映射的页面一样；
• 如果该页面已经被映射到一个或者多个进程的页表项中，那么必须找到所有引用该页面的进程，并更新页表中与这些进程相关的所有页表项。在这里，Linux 2.6 操作系统会利用反向映射机制去检查哪些页表项引用了该页面，关于反向映射的内容在后边会有介绍；
• 如果该页面中的数据是脏的，那么数据必须要被回写；
• 释放页缓存中的干净页面。

函数 shrink_slab()

       函数 shrink_slab() 是用来回收磁盘缓存所占用的页面的。Linux 操作系统并不清楚这类页面是如何使用的，所以如果希望操作系统回收磁盘缓存所占用的页面，那么必须要向操作系统内核注册 shrinker 函数，shrinker 函数会在内存较少的时候主动释放一些该磁盘缓存占用的空间。函数 shrink_slab() 会遍历 shrinker 链表，从而对所有注册了 shrinker 函数的磁盘缓存进行处理。

       从实现上来看，shrinker 函数和 slab 分配器并没有固定的联系，只是当前主要是 slab 缓存使用 shrinker 函数最多。

       注册 shrinker 是通过函数 set_shrinker() 实现的，解除 shrinker 注册是通过函数 remove_shrinker() 实现的。当前，Linux 操作系统中主要的 shrinker 函数有如下几种：

• shrink_dcache_memory()：该 shrinker 函数负责 dentry 缓存。
• shrink_icache_memory()：该 shrinker 函数负责 inode 缓存。

mb_cache_shrink_fn()：该 shrinker 函数负责用于文件系统元数据的缓存。

具体的源代码实现细节有时间再做分析。后面将谈论交换。

 

+++++++++++++++++++++++++++++++++++

static void
shrink_zone(struct zone *zone, struct scan_control *sc)
{
unsigned long nr_active;
unsigned long nr_inactive;


//根据优先级，得到可以扫描的页面数，优先级越高，
//代表越不急迫，可以扫描的页面数也最少
zone->nr_scan_active += (zone->nr_active >> sc->priority) + 1;
nr_active = zone->nr_scan_active;
if (nr_active >= SWAP_CLUSTER_MAX)
zone->nr_scan_active = 0;
else
nr_active = 0;


zone->nr_scan_inactive += (zone->nr_inactive >> sc->priority) + 1;
nr_inactive = zone->nr_scan_inactive;
//非活动页比较少的话，可以先忽略过去，将跳过的页面记录到nr_scan_inactive中
//留待下一次再处理
if (nr_inactive >= SWAP_CLUSTER_MAX)
zone->nr_scan_inactive = 0;
else
nr_inactive = 0;


//设置需要回收的页面数为32个
sc->nr_to_reclaim = SWAP_CLUSTER_MAX;


//开始回收页面，每次扫描32个页面，多了不干噢!!!
while (nr_active || nr_inactive) {
if (nr_active) {
//设置每次要扫描的非活动页面数，需要将其放
//入到inactive list里面
sc->nr_to_scan = min(nr_active,
(unsigned long)SWAP_CLUSTER_MAX);
nr_active -= sc->nr_to_scan;
//补充inactive list中的页面
refill_inactive_zone(zone, sc);
}


if (nr_inactive) {
//设置每次将要扫描的页面，最多也就32个页面
sc->nr_to_scan = min(nr_inactive,
(unsigned long)SWAP_CLUSTER_MAX);

nr_inactive -= sc->nr_to_scan;
//开始正式回收inactive list中的页面
shrink_cache(zone, sc);
//32个页面被回收完毕，大功告成了!!!
if (sc->nr_to_reclaim <= 0)
break;
}
}
}


static int shrink_list(struct list_head *page_list, struct scan_control *sc)
{
LIST_HEAD(ret_pages);
struct pagevec freed_pvec;
int pgactivate = 0;
int reclaimed = 0;
//有进程需要调度，先进行调度
cond_resched();


pagevec_init(&freed_pvec, 1);
//对于page_list 链表上的每一个页面试图进行回收
while (!list_empty(page_list)) {
struct address_space *mapping;
struct page *page;
int may_enter_fs;
int referenced;


//获取一个页面
page = lru_to_page(page_list);
//从lru上摘除
list_del(&page->lru);
//page被锁定，不能回收
if (TestSetPageLocked(page))//page is locked?
goto keep;


BUG_ON(PageActive(page));
//page正在被writeback，不能回收
if (PageWriteback(page))//page is writeback?
goto keep_locked;

sc->nr_scanned++;
/* Double the slab pressure for mapped and swapcache pages */


if (page_mapped(page) || PageSwapCache(page))
sc->nr_scanned++;
//查看最近该页面有无被访问过
referenced = page_referenced(page, 1, sc->priority <= 0);
/* In active use or really unfreeable?  Activate it. */
//1页面被访问过，2页面在用户态空间，页面是文件映射页面，
//页面在交换高速缓存中，同时满足这两个条件的话，页面不被回收
if (referenced && page_mapping_inuse(page))
goto activate_locked;


#ifdef CONFIG_SWAP

//page is anon and page has not been add to swapcache
//该页面是匿名映射的页面，且该页面不在swapcache中
if (PageAnon(page) && !PageSwapCache(page)) {
//将页面加入到swap cache中
if (!add_to_swap(page))
goto activate_locked;
}
#endif /* CONFIG_SWAP */
//得到对应的address_space，有可能是对应文件的address_space,或者是
//swap cache的address_space
mapping = page_mapping(page);
may_enter_fs = (sc->gfp_mask & __GFP_FS) ||
(PageSwapCache(page) && (sc->gfp_mask & __GFP_IO));


//该页面被映射到某个用户页表中
if (page_mapped(page) && mapping) {
//将该页面在用户页表中的页表项通通清除
switch (try_to_unmap(page)) {
case SWAP_FAIL:
goto activate_locked;
case SWAP_AGAIN:
goto keep_locked;
case SWAP_SUCCESS:
; /* try to free the page below */
}
}
//页面是脏的，哈哈，准备往文件或swapcache里面写硬盘吧
if (PageDirty(page)) {
if (referenced)
goto keep_locked;
if (!may_enter_fs)
goto keep_locked;
if (laptop_mode && !sc->may_writepage)
goto keep_locked;


/* Page is dirty, try to write it out here */
//往磁盘上写页面
switch(pageout(page, mapping)) {
case PAGE_KEEP:
goto keep_locked;
case PAGE_ACTIVATE:
goto activate_locked;
case PAGE_SUCCESS:
if (PageWriteback(page) || PageDirty(page))
goto keep;

if (TestSetPageLocked(page))
goto keep;
if (PageDirty(page) || PageWriteback(page))
goto keep_locked;
mapping = page_mapping(page);
case PAGE_CLEAN:
; /* try to free the page below */
}
}



//若页面是缓冲区页面，将对应的buffer_head给释放掉
if (PagePrivate(page)) {
if (!try_to_release_page(page, sc->gfp_mask))
goto activate_locked;
if (!mapping && page_count(page) == 1)
goto free_it;
}


if (!mapping)
goto keep_locked; /* truncate got there first */


spin_lock_irq(&mapping->tree_lock);



//页面为脏页面或者page的引用计数为2，都是不可以回收的 
if (page_count(page) != 2 || PageDirty(page)) {
spin_unlock_irq(&mapping->tree_lock);
goto keep_locked;
}


#ifdef CONFIG_SWAP
//到达这里，说明该page只被swap cache或者页高速缓存及
//fpra所共有，需要将其从swap cache上或者页高速缓存上删除。
if (PageSwapCache(page)) {
swp_entry_t swap = { .val = page->private };
//从swap cache上进行删除
__delete_from_swap_cache(page);
spin_unlock_irq(&mapping->tree_lock);
swap_free(swap);
__put_page(page); /* The pagecache ref */
goto free_it;
}
#endif /* CONFIG_SWAP */


//从页面高速缓存中将该页面删除
__remove_from_page_cache(page);
spin_unlock_irq(&mapping->tree_lock);
__put_page(page);


free_it:
unlock_page(page);
reclaimed++;
if (!pagevec_add(&freed_pvec, page))
__pagevec_release_nonlru(&freed_pvec);
continue;


activate_locked:
//将页面设为active页面，等回去将其放入lru的active链表
SetPageActive(page);
pgactivate++;
keep_locked:
//保持页面的状态不变，放入对应的lru active或inactive链表中
unlock_page(page);
keep:
//将该无法回收的页面，放入到ret_pages链表中
list_add(&page->lru, &ret_pages);
BUG_ON(PageLRU(page));
}
//此处将无法回收的页面放入page_list中，在函数返回后，去其进行处理
list_splice(&ret_pages, page_list);
//此处将可以释放的页面通通给释放掉，回收了^_^
if (pagevec_count(&freed_pvec))
__pagevec_release_nonlru(&freed_pvec);
mod_page_state(pgactivate, pgactivate);
sc->nr_reclaimed += reclaimed;
return reclaimed;
}

 

参考：

ULK3

http://www.ibm.com/developerworks/cn/linux/l-cn-pagerecycle/