当前位置：首页 > news >正文

Linux内核中的文件系统缓存机制详解

news 2026/6/3 1:22:42

Linux内核中的文件系统缓存机制详解

引言

文件系统缓存是Linux内核中提高文件IO性能的重要机制，它通过将文件数据缓存在内存中，减少了对磁盘的直接访问，显著提升了文件操作的速度。本文将深入探讨Linux内核中的文件系统缓存机制，包括页面缓存、目录项缓存和索引节点缓存等。

文件系统缓存的基本概念

1. 缓存的作用

减少IO操作：避免重复的磁盘读写
提高响应速度：内存访问速度远快于磁盘
平滑IO负载：将突发IO转化为持续的IO
提高系统吞吐量：减少磁盘寻道时间

2. 缓存的类型

页面缓存（Page Cache）：缓存文件数据
目录项缓存（Dentry Cache）：缓存目录项
索引节点缓存（Inode Cache）：缓存索引节点
缓冲区缓存（Buffer Cache）：缓存块设备数据

3. 缓存的层次结构

应用程序 ↓ 文件系统层 ↓ 页面缓存 ↓ 通用块层 ↓ 块设备驱动 ↓ 硬件

页面缓存

1. 页面缓存的原理

页面缓存是Linux内核中最主要的文件系统缓存，它将文件数据以页为单位缓存在内存中。

2. 页面缓存的结构

#include <linux/pagemap.h> struct address_space { struct inode *host; struct radix_tree_root page_tree; spinlock_t tree_lock; unsigned int i_mmap_writable; struct rb_root i_mmap; struct rw_semaphore i_mmap_rwsem; unsigned long nrpages; pgoff_t writeback_index; struct address_space_operations *a_ops; // 其他字段... };

3. 页面缓存的操作

#include <linux/pagemap.h> // 查找页面 struct page *find_get_page(struct address_space *mapping, pgoff_t index); // 添加页面 int add_to_page_cache_locked(struct page *page, struct address_space *mapping, pgoff_t index, gfp_t gfp_mask); // 从页面缓存读取 ssize_t generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter); // 写入页面缓存 ssize_t generic_file_write_iter(struct kiocb *iocb, struct iov_iter *iter);

4. 页面缓存的示例

#include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/fs.h> #include <linux/pagemap.h> static int __init page_cache_demo_init(void) { struct file *file; struct address_space *mapping; struct page *page; char *buf; // 打开文件 file = filp_open("/etc/passwd", O_RDONLY, 0); if (IS_ERR(file)) { printk(KERN_ERR "Failed to open file\n"); return PTR_ERR(file); } mapping = file->f_mapping; // 查找页面 page = find_get_page(mapping, 0); if (!page) { printk(KERN_INFO "Page not in cache, reading from disk\n"); // 读取文件到页面缓存 char buffer[4096]; kernel_read(file, 0, buffer, sizeof(buffer)); page = find_get_page(mapping, 0); } if (page) { printk(KERN_INFO "Page found in cache\n"); // 映射页面到内核空间 buf = kmap(page); printk(KERN_INFO "First 100 bytes: %.*s\n", 100, buf); kunmap(page); put_page(page); } filp_close(file, NULL); return 0; } static void __exit page_cache_demo_exit(void) { printk(KERN_INFO "Page cache demo exited\n"); } module_init(page_cache_demo_init); module_exit(page_cache_demo_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Demo"); MODULE_DESCRIPTION("Page cache demo");

目录项缓存

1. 目录项缓存的原理

目录项缓存（Dentry Cache）用于缓存目录项，加速路径名查找。

2. 目录项的结构

#include <linux/dcache.h> struct dentry { unsigned int d_flags; seqcount_t d_seq; struct hlist_node d_hash; struct dentry *d_parent; struct qstr d_name; struct inode *d_inode; unsigned char d_iname[DNAME_INLINE_LEN]; struct lockref d_lockref; const struct dentry_operations *d_op; struct super_block *d_sb; unsigned long d_time; void *d_fsdata; // 其他字段... };

3. 目录项缓存的操作

#include <linux/dcache.h> // 查找目录项 struct dentry *d_lookup(struct dentry *parent, struct qstr *name); // 添加目录项 void d_add(struct dentry *entry, struct inode *inode); // 删除目录项 void d_drop(struct dentry *dentry); // 释放目录项 void dput(struct dentry *dentry); // 遍历目录项 struct dentry *d_find_alias(struct inode *inode);

4. 目录项缓存的示例

#include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/dcache.h> static int __init dentry_cache_demo_init(void) { struct path path; struct dentry *dentry; int err; // 查找路径 err = kern_path("/etc", LOOKUP_FOLLOW, &path); if (err) { printk(KERN_ERR "Failed to lookup path\n"); return err; } dentry = path.dentry; printk(KERN_INFO "Directory: %s\n", dentry->d_name.name); printk(KERN_INFO "Inode: %lu\n", dentry->d_inode->i_ino); // 遍历目录项 struct dentry *child; spin_lock(&dentry->d_lock); list_for_each_entry(child, &dentry->d_subdirs, d_child) { if (child->d_inode) { printk(KERN_INFO " Entry: %s\n", child->d_name.name); } } spin_unlock(&dentry->d_lock); path_put(&path); return 0; } static void __exit dentry_cache_demo_exit(void) { printk(KERN_INFO "Dentry cache demo exited\n"); } module_init(dentry_cache_demo_init); module_exit(dentry_cache_demo_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Demo"); MODULE_DESCRIPTION("Dentry cache demo");

索引节点缓存

1. 索引节点缓存的原理

索引节点缓存（Inode Cache）用于缓存文件的元数据信息。

2. 索引节点的结构

#include <linux/fs.h> struct inode { umode_t i_mode; unsigned short i_opflags; kuid_t i_uid; kgid_t i_gid; unsigned long i_flags; const struct inode_operations *i_op; struct super_block *i_sb; struct address_space *i_mapping; unsigned long i_ino; union { const unsigned int i_nlink; unsigned int __i_nlink; }; dev_t i_rdev; loff_t i_size; struct timespec i_atime; struct timespec i_mtime; struct timespec i_ctime; // 其他字段... };

3. 索引节点缓存的操作

#include <linux/fs.h> // 获取索引节点 struct inode *iget5_locked(struct super_block *sb, unsigned long ino, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *data); // 释放索引节点 void iput(struct inode *inode); // 删除索引节点 void iput_final(struct inode *inode); // 同步索引节点 int sync_inode(struct inode *inode, int wait);

4. 索引节点缓存的示例

#include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/fs.h> static int __init inode_cache_demo_init(void) { struct file *file; struct inode *inode; // 打开文件 file = filp_open("/etc/passwd", O_RDONLY, 0); if (IS_ERR(file)) { printk(KERN_ERR "Failed to open file\n"); return PTR_ERR(file); } inode = file_inode(file); printk(KERN_INFO "File: /etc/passwd\n"); printk(KERN_INFO "Inode: %lu\n", inode->i_ino); printk(KERN_INFO "Size: %lld\n", inode->i_size); printk(KERN_INFO "Mode: %o\n", inode->i_mode); printk(KERN_INFO "UID: %d\n", inode->i_uid.val); printk(KERN_INFO "GID: %d\n", inode->i_gid.val); printk(KERN_INFO "Links: %d\n", inode->i_nlink); filp_close(file, NULL); return 0; } static void __exit inode_cache_demo_exit(void) { printk(KERN_INFO "Inode cache demo exited\n"); } module_init(inode_cache_demo_init); module_exit(inode_cache_demo_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Demo"); MODULE_DESCRIPTION("Inode cache demo");

缓存的管理

1. 缓存的刷新

# 同步所有文件系统 sync # 刷新特定文件系统 syncfs(fd) # 强制刷新 sysctl -w vm.drop_caches=3

2. 缓存的监控

# 查看内存使用 free -h # 查看缓存使用 cat /proc/meminfo | grep -E "Cached|Buffers" # 查看页面缓存统计 cat /proc/vmstat | grep -E "pg.*cache" # 查看文件系统统计 cat /proc/sys/fs/dentry-state

3. 缓存的调优

# 调整脏页比例 sysctl -w vm.dirty_ratio=60 sysctl -w vm.dirty_background_ratio=5 # 调整脏页写入时间 sysctl -w vm.dirty_expire_centisecs=3000 sysctl -w vm.dirty_writeback_centisecs=500 # 调整页面缓存回收策略 sysctl -w vm.vfs_cache_pressure=100

实际案例分析

1. 大文件读取优化

#include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/fs.h> #include <linux/pagemap.h> static int __init big_file_read_init(void) { struct file *file; struct address_space *mapping; struct page *page; char *buf; loff_t offset = 0; // 打开大文件 file = filp_open("/path/to/bigfile", O_RDONLY, 0); if (IS_ERR(file)) { printk(KERN_ERR "Failed to open file\n"); return PTR_ERR(file); } mapping = file->f_mapping; // 预读文件 force_page_cache_readahead(mapping, NULL, 0, 1024 * 4096); // 读取文件 while (offset < file->f_inode->i_size) { page = find_get_page(mapping, offset >> PAGE_SHIFT); if (page) { buf = kmap(page); // 处理数据 kunmap(page); put_page(page); } offset += PAGE_SIZE; } filp_close(file, NULL); return 0; } static void __exit big_file_read_exit(void) { printk(KERN_INFO "Big file read demo exited\n"); } module_init(big_file_read_init); module_exit(big_file_read_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Demo"); MODULE_DESCRIPTION("Big file read demo");

2. 缓存性能测试

# 测试文件读取速度 time cat /dev/zero | head -c 1G > testfile time cat testfile > /dev/null # 测试缓存效果 sync echo 3 > /proc/sys/vm/drop_caches time cat testfile > /dev/null # 第一次读取（从磁盘） time cat testfile > /dev/null # 第二次读取（从缓存）

3. 缓存压力测试

# 生成缓存压力 dd if=/dev/zero of=/tmp/test bs=1M count=1000 dd if=/dev/zero of=/tmp/test2 bs=1M count=1000 dd if=/dev/zero of=/tmp/test3 bs=1M count=1000 # 查看缓存使用 free -h cat /proc/meminfo | grep Cached # 查看页面回收 cat /proc/vmstat | grep pgscan