借助内核逻辑锁pagecache到内存

一、配景

内存管理是一个永恒的主题，尤其在内存紧张触发内存回收的时间。系统在通过磁盘获取磁盘上的文件的内容时，若不开启O_DIRECT方式进行读写，磁盘上的任何东西都会被缓存到系统里，我们称之为page cache。可以想象，假如如许的举动持续，且假如我们持续地不断要访问磁盘上新的文件时，那么page cache就会不绝增长，page cache究竟也是占用物理内存的，所以物理内存终有一天还是会不够的。
针对这种场景，内核有一些现有的机制，如使能swap分区，如许可以把不生动的匿名页给交换出去，交换到磁盘上，在背面再使用的时间再给交换回来，另有就是回收掉page cache，因为大部分的page cache上的数据都是有磁盘文件与之对应的，为什么说大部分，因为另有一部分是共享内存的数据，如使用shm_open出来的共享内存的数据，它也被统计进了free -h里的buff/cache里，所以，你说它算是pagecache，也是OK的，究竟shmem.c里的shmem_get_folio_gfp里有如下调用：

但是，另外一方面，它还是比较特别的，因为这部分共享内存的数据是没有磁盘对应的文件的，所以它除了被交换到swap分区之外，它对应的内存是不能回收的。另外，这块内存虽然统计到buff/cache里，但是并没有统计到/proc/meminfo里的Active(file)和Inactive(file)里，所以严酷意义上来说，它又不是pagecache。
剔除共享内存这种特殊的pagecache以外，对于真正的文件页pagecache，在不开swap分区的话，这部分文件页的pagecache仍旧会被系统里的内存回收逻辑给回收。触发该内存回收逻辑的可能有node里的memory zone触及了低水位，也有memory cgroup触及memory.high水位，还可能是加的内核功能逻辑去主动做释放的动作。
假如一旦内核把一些将来会被用到的文件页给回收了，那么就会造成下次再次使用时重新从磁盘上读取该文件页的同步读的性能损耗。为了淘汰如许的性能损耗，我们可以把系统里的一些关键的代码段或者一些关键的文件对应的内存锁住，不让系统在回收时选择它们。
我们可以使用一些上层的手段如mlock去锁住，但是用mlock去锁相关文件页的一个条件是这个历程得不绝在，假如历程退出，mlock的锁住的举动就会被“释放”。而假如用内核手段去锁住文件页，那么这个锁住状态是持久了，不会因为历程的退出而释放。我们只必要在必要的时间去解锁即可。
这篇博客里下面第二章会给出锁住文件页的一个内核模块的示例程序，并演示效果。在第三章里，我们对第二章代码里的细节做出分析和原明白释。

二、源码及效果展示

2.1 锁文件page的内核模块代码

1. #include <linux/module.h>
2. #include <linux/kernel.h>
3. #include <linux/fs.h>
4. #include <linux/init.h>
5. #include <linux/slab.h>
6. #include <linux/dcache.h>
7. #include <linux/namei.h>
8. #include <linux/pagemap.h>
10. // 模块参数
11. static char *filepath = "/tmp/testfile";  // 默认文件路径
12. module_param(filepath, charp, S_IRUGO);
13. MODULE_PARM_DESC(filepath, "Path of the file to open");
15. static char *mode = "nothing";
16. module_param(mode, charp, S_IRUGO);
18. char buffer[4096];
20. int getfullpath(struct inode *inode)
21. {
22.     struct dentry *dentry;
23.     printk("inode = %p\n", inode);
24.         hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
25.         char *path;
26.         path = dentry_path_raw(dentry, buffer, PAGE_SIZE);
27.         if (IS_ERR(path)){
28.             continue;   
29.         }
30.         printk("dentry name = %s , path = %s\n", dentry->d_name.name, path);
31.         }
32.     return 0;
33. }
35. static int __init my_module_init(void) {
36.     struct file *file;
38.     printk(KERN_INFO "Opening file: %s\n", filepath);
40.     // 打开文件
41.     file = filp_open(filepath, O_RDONLY, 0);
42.     printk(KERN_INFO "file[%p]\n", file);
43.     if (IS_ERR(file)) {
44.         printk(KERN_ERR "Error opening file: %ld\n", PTR_ERR(file));
45.         return PTR_ERR(file);
46.     }
48.     // getfullpath(file->f_inode);
50.         // do {
51.     //     char *path;
52.     //     path = dentry_path_raw(file->f_path.dentry, buffer, PAGE_SIZE);
53.     //     if (IS_ERR(path)){
54.     //         break;
55.     //     }
56.     //     printk("[2] dentry name = %s , path = %s\n", file->f_path.dentry->d_name.name, path);
57.         // } while(0);
59.     // lock pages of the input filepath file
60.     if (strcmp(mode, "nothing") != 0) {
61.         struct address_space *mapping = file->f_mapping;
62.         struct page *page;
63.         pgoff_t index;
64.         unsigned long start_index, end_index;
65.         start_index = 0;
66.         printk("i_size=%ld\n", mapping->host->i_size);
67.         end_index = (mapping->host->i_size >> PAGE_SHIFT);
68.         //printk("end_index=%lu\n", end_index);
69. #if 1
70.         for (index = start_index; index < end_index; index++) {
71.             if (strcmp(mode, "lock") == 0) {
72.                 page = find_get_page(mapping, index);
73.                 if (!page) {
74.                     page = read_cache_page_gfp(mapping, index, GFP_KERNEL);
75.                     if (!page) {
76.                         printk("page[%lu] is NULL!\n", index);
77.                     }
78.                     else {
79.                         //get_page(page);
80.                         //SetPageMlocked(page);
81.                         //page = find_get_page(mapping, index);
82.                         unsigned long ref_count = page_ref_count(page);
83.                         printk("page[%lu] ref=%lu\n", index, ref_count);
84.                     }
85.                 }
86.                 else {
87.                     unsigned long ref_count = page_ref_count(page);
88.                     printk("page[%lu] ref=%lu\n", index, ref_count);
89.                 }
90.                 //mapping_set_unevictable(mapping);
91.             }
92.             else if (strcmp(mode, "unlock") == 0) {
93.                 page = find_get_page(mapping, index);
94.                 if (page) {
95.                     //__ClearPageMlocked(page);
96.                     put_page(page);
97.                     put_page(page);
98.                 }
99.                 //mapping_clear_unevictable(mapping);
100.             }
101.             else if (strcmp(mode, "query") == 0) {
102.                 page = find_get_page(mapping, index);
103.                 if (!page) {
104.                     printk("page[%lu] is NULL!\n", index);
105.                 }
106.                 else {
107.                     //get_page(page);
108.                     //SetPageMlocked(page);
109.                     //page = find_get_page(mapping, index);
110.                     unsigned long ref_count = page_ref_count(page);
111.                     printk("page[%lu] ref=%lu\n", index, ref_count);
112.                     put_page(page);
113.                 }
114.             }
115.             // else if (strcmp(mode, "grablock") == 0) {
116.             //     page = grab_cache_page(mapping, index);
117.             //     if (!page) {
118.             //         printk("page[%lu] is NULL!\n", index);
119.             //     }
120.             //     else {
121.             //         unsigned long ref_count = page_ref_count(page);
122.             //         printk("page[%lu] ref=%lu\n", index, ref_count);
123.             //     }
124.             // }
125.         }
126. #endif
127.     }
129.     // 关闭文件
130.     filp_close(file, NULL);
131.     return -EINVAL;
132. }
134. static void __exit my_module_exit(void) {
135.     printk(KERN_INFO "Module exiting\n");
136. }
138. module_init(my_module_init);
139. module_exit(my_module_exit);
141. MODULE_LICENSE("GPL");
142. MODULE_AUTHOR("Zhaoxin");
143. MODULE_DESCRIPTION("A simple module to read file and lock pagecache");

复制代码

2.2 配合做实验的用户态程序代码

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #include <fcntl.h>
5. #include <unistd.h>
6. #include <sys/mman.h>
7. #include <sys/stat.h>
8. #include <sys/types.h>
9. #include <errno.h>
10. #include <sys/resource.h>
12. #define FILE_NAME "large_file.img"
13. #define FILE_SIZE 1024*1024*1024ull
15. int main() {
16.     int fd;
17.     //char *buffer;
19.     // 创建并打开文件
20.     //fd = open(FILE_NAME, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
21.     fd = open(FILE_NAME, O_RDWR, S_IRUSR | S_IWUSR);
22.     if (fd == -1) {
23.         perror("open");
24.         return EXIT_FAILURE;
25.     }
27.     //buffer = (char*)malloc(FILE_SIZE);
28.     // if (!buffer) {
29.     //     perror("malloc");
30.     //     close(fd);
31.     //     return EXIT_FAILURE;
32.     // }
33.     // memset(buffer, 0, FILE_SIZE);
35.     // const char *data = "This is some sample data to be written to the file.";
36.     // strncpy(buffer, data, FILE_SIZE);
38.     // getchar();
40.     char *mapped = (char*)mmap(NULL, FILE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
41.     if (mapped == MAP_FAILED) {
42.         perror("mmap");
43.         close(fd);
44.         exit(EXIT_FAILURE);
45.     }
47.     // if (read(fd, buffer, FILE_SIZE) == -1) {
48.     //     perror("read");
49.     //     free(buffer);
50.     //     close(fd);
51.     //     return EXIT_FAILURE;
52.     // }
54.     getchar();
56.     {
57.         unsigned int i = 0;
58.         unsigned int sum = 0;
59.         for (i = 0; i < FILE_SIZE; i++) {
60.             sum += *(mapped + i);
61.             *(mapped + i) = (char)sum;
62.         }
63.     }
64.     printf("finish read write all\n");
66.     getchar();
68.     // 锁定内存区域
69.     if (mlock(mapped, FILE_SIZE) == -1) {
70.         perror("mlock");
71.         //free(buffer);
72.         close(fd);
73.         return EXIT_FAILURE;
74.     }
75.     printf("finish mlock\n");
77.     getchar();
79.     //printf("Memory locked successfully. Data written to file: %s\n", buffer);
81.     // 释放内存
82.     if (munlock(mapped, FILE_SIZE) == -1) {
83.         perror("munlock");
84.     }
85.     munmap(mapped, FILE_SIZE);
86.     printf("finish munlock munmap\n");
87.     getchar();
89.     //free(buffer);
90.     close(fd);
92.     return EXIT_SUCCESS;
93. }

复制代码

2.3 效果展示

在上面 2.2 里的测试程序里，通过mmap来读写大文件，叫large_file.img，大小是1G。
我们分几种情况来进行测试：
1）mmap方式读写大文件（注意是MAP_SHARED方式），触发完全部页的缺页非常，让磁盘文件都加载进page cache，但不mlock锁定
——在这种情况下通过内核逻辑锁住page cache，并用vmtouch -e来做移除实验
——然后再调用内核逻辑解锁page cache，看是否能vmtouch -e来移除掉
通过读写文件全部的字节来触发完全部页的缺页非常：

2）mmap映射了大文件，但是还未进行任何读写，也就是还未触发缺页非常
——在这种情况下通过内核逻辑锁住page cache，并用vmtouch -v、vmtouch -e来打印情况和做移除实验
——然后再调用内核逻辑解锁page cache，看是否能vmtouch -e来移除掉
3）mmap映射了大文件，并调用mlock锁住内存页
——在这种情况下通过内核逻辑锁住page cache，并用vmtouch -v、vmtouch -e来打印情况和做移除实验
——然后再调用内核逻辑解锁page cache，看是否能vmtouch -e来移除掉

上面 2.2 的测试程序里有多处响应按键的地方，在按第一次按键前，进行了mmap该大文件的映射，但是并未进行任何的读写：

按第一次按键后是进行1Gsize读写，天然会加载进pagecache里：

按第二次按键后，按第三次按键前，调用了mlock锁住了这个1G的内存：

按第三次按键后，程序会执行munlock再munmap后再做退出：

下面，我们针对上面这几次按键的差别场景分别做实验。

2.3.1 mmap方式已触发缺页非常后的场景

这一节测试的场景是mmap方式，并已经触发了缺页非常，但是还未mlock锁定的场景下，执行我们的内核模块程序来进行内核态锁住逻辑，看执行完是否能驱逐掉，再进行内核态解锁，看是否能驱逐掉。
如下图，触发缺页非常之后，large_file.img这个文件对应的pagecache都加载进去了。
我们进行内核态锁定后，可以看到是驱逐不掉的：

然后通过内核态解锁后，可以看到已经发生缺页非常的部分，在没有munmap时就算不mlock也是不能驱逐掉的：

这个原因会在下面 3.2 里进行表明。
我们下面展示一下，不进行内核逻辑的锁定，看是否能驱逐出去这部分已经触发了缺页非常的pagecache：

如上图可以看到，对于mmap方式（MAP_SHARED方式）进行读写，就算不调用mlock，在munmap之前，就算不用内核锁定逻辑，对应的pagecache都是驱逐不出去的。

2.3.2 mmap方式未触发缺页非常后的场景

分两种情况来测，先测执行filetest但是不触发缺页非常，看vmtouch -v的情况，然后加载内核模块进行锁定，再看vmtouch -v的情况，并看是否可以驱逐出去；然后我们再测，在执行filetest之前直接运行内核模块的锁定逻辑，再运行filetest但是不触发缺页非常，看是否可以驱逐出去。

如上图可以看到，在filetest未触发缺页非常时，相关的pagecache未被加载，然后调用了内核逻辑，让其全部被加载，并驱逐无效。
下面我们测试看先调用内核模块的锁定逻辑，再调用filetest并不触发缺页非常，看是否可以驱逐出去，可以从下图看到，同样是驱逐不出去的：

2.3.3 mmap方式mlock后及munmap后的场景

其实在上面 2.3.1 的实验里，我们已经知道，假如是mmap方式MAP_SHARED方式对于已经触发缺页非常的部分，就算不做mlock对应的pagecache也是无法被驱逐的。
我们这里只需再做补充实验，就是不调用内核锁定逻辑，并不触发缺页非常，直接调用mlock，看是否相关pagecache已经被加载进来了，并看是否可以被驱逐掉。
我们改写一下程序，让触发缺页非常的逻辑干掉：

看不调用内核逻辑锁定，只靠mlock是否可以保证mmap MAP_SHARED的读写方式对应的pagecache是不是会被驱逐。
如下图可以看到是不会被驱逐的：

关于mlock的内核逻辑之前的博客有具体的介绍，可以参考 内存管理相关——malloc，mmap，mlock与unevictable列表-CSDN博客。
我们下面再看一下munmap后，假如不调用内核锁定逻辑看是否可以被驱逐，如下图看到是可以被驱逐的：

然后，我们试一下，执行过内核锁定逻辑之后，在munmap后是否能被驱逐：

可以从上图看到，是不会被驱逐的。

三、源码分析及原明白释

3.1 使用inode的i_size获取文件的大小

通过file->f_mapping->host可以获得打开的文件对应inode，这里的file是指历程地址空间实例的file，通过inode->i_size可以得到文件的大小：

上图对应的是执行两次filetest，第一次没有写入文件，第二次写入了一段时间就ctrl+c停止了：

对于64位系统上，直接获取inode->i_size是没有什么题目标，假如是32bit系统上，得使用i_size_read来获取，如i_size_read里的实现，使用到了次序锁，次序锁的细节见之前的博客  次序锁的原理和使用注意事项-CSDN博客：

3.2 对于mmap文件出来的地址空间，一旦触发了缺页非常，其pagecache不会回收

上面 2.3.1 的实验可以看到，假如mmap一个磁盘上的文件到一个历程的假造地址空间之后，一旦触发了缺页非常，就算不执行mlock，也不执行内核态的锁pagecache，这些mmap且已经触发缺页非常的pagecache系统是回收不了的。
对于系统里的程序，假如程序并未退出，mmap加载的一些so库（程序的代码段都是mmap方式加载进地址空间）假如一旦触发过缺页非常，那么它们对应的pagecache是不会被回收的。但是要注意，对于一些会退出的历程，一旦历程退出，对应的代码段就可以被回收了，比如像grep/ls等这些系统命令的代码段。
通过mlock或者内核态的锁定逻辑可以提前把这些代码段给加载进pagecache，假如加上锁定后，它们就不绝不回被回收了（假如用内核逻辑进行锁定，就算程序退出后，相关已经锁定的代码段也不会被回收了）。
3.2.1 mmap的MAP_PRIVATE方式的说明

虽然我们这篇博客里的示例程序用的是MAP_SHARED方式进行的读写，但是对于库文件来说，一般都是用的MAP_PRIVATE方式。
MAP_PRIVATE方式要注意的是，假如是读，那其pagecache肯定是可以多个历程共享同一个so的代码文件的。但是对于可写的部分，MAP_PRIVATE方式进行的映射会把可写的部分触发一个COW分配匿名内存并拷贝一份出来改写，如许原代码文件不会被改写，这也是so库里的data段也是这么一个方式。
对于我们这篇博客里的示例程序而言，假如用MAP_PRVIATE方式，假如要进行写的话，那么就写的是匿名内存，那么全部的pagecache的实验都不凑效了。但是假如用MAP_PRIVATE方式只是读的话，那么这篇博客里的实验也是一样凑效的。

3.3 对于非mmap方式的文件读写情况的说明

所谓非mmap方式的文件读写，就是直接通过read/write/fread/fwrite的如许的文件系统的接口来读写文件数据。这种方式，由于并没有直接映射相关文件到历程地址空间，而是借助vfs进行代码读写，在完成读写之后，内核是可以对其pagecache内容进行回收的。
对于读和写还得分开来看，对于读而言，虽然不放面使用mlock（因为通过通例手段不mmap根本拿不到pagecache对应的假造内存），但是可以使用内核模块的锁定逻辑进行锁定。
但是对于写而言，要特别注意，假如是一个1G文件，重新O_CREAT创建并从开头开始写入，那么对于旧文件的这些锁定逻辑包括内核锁定逻辑，由于文件大小已经变更回过0了，所以之前的page是可以被拿去回收的，这一点要额外注意。

3.4 通过增长page引用计数来防止被驱逐

通过page引用计数来方式被内存回收的做法，其实在之前的博客 内存管理之——get_user_pages和pin_user_pages及缺页非常_get user page-CSDN博客 里也有讲到。
这里，我们的关键逻辑是如何找到文件相关的page，如下方式通过find_get_page来根据address_space来获取到指定index的page：

address_space的指针可通过file的f_mapping拿到，另外上图里的index即address_space的映射的pages里的序号。
假如find_get_page找不到的话，再通过read_cache_page_gfp来读取磁盘上的文件读到pagecache，固然天然必要按需创建pagecache的内存，所以必要传入分配内存时的gfp参数：

由于find_get_page和read_cache_page_gfp都是会增长page的引用计数的，所以就没必要再get_page一次了。只需在对应的unlock逻辑里也得相应的扣除引用计数（多put_page一次就是为了扣除，另一次是抵消find_get_page的引用计数）：

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。