Address Space 与页缓存(Page Cache)详解
对应源码:
include/linux/fs.h、include/linux/pagemap.h、mm/filemap.c、fs/buffer.c
本文档整合自docs/fs/address_space_buffer.md与docs/fs/address-space-buffer/系列,聚焦 address_space(页缓存核心抽象)及其与 inode、radix tree、buffer_head、page 之间的完整关系。
目录
- 缓存架构的历史演变与设计哲学
- address_space 数据结构详解
- Radix Tree 页面索引机制
- address_space_operations 操作方法集
- inode 与 address_space 的关系
- page 与 address_space 的关系
- inode、address_space、page、buffer_head 完整关系图
- 页缓存查找与添加流程
- 块映射 get_block 机制
- 文件读写流程中三者的协作
- 内存结构详解
- 函数调用链
- 来自源码的权威注释
- 总结
一、缓存架构的历史演变与设计哲学
1.1 核心概念
Linux 2.6.32 中,address_space 是页缓存(Page Cache)的核心抽象数据结构,buffer_head 是块缓存(Buffer Cache)的实现机制。两者协同工作,共同构成文件 I/O 的缓存层。
- address_space:与 inode 关联,用于管理该 inode 对应所有缓存页面。每个 address_space 含一个 radix tree 快速索引缓存页面,通过
address_space_operations提供操作方法,使不同文件系统可实现自己的缓存策略。 - buffer_head:描述页面内块级映射和状态的机制。当块大小小于页大小时,一个页面被划分为多个块,每块对应一个 buffer_head,跟踪磁盘映射、脏状态、锁定状态等。
1.2 历史演变(早期双缓存 → 2.4 统一缓存)
早期 Linux(pre-2.4),页缓存与块缓存是两个相互独立的缓存系统:
┌─────────────────────────────────────────────────────────────────────┐
│ 早期 Linux (pre-2.4) │
└─────────────────────────────────────────────────────────────────────┘
┌──────────────┐ ┌──────────────┐
│ Page Cache │ │ Buffer Cache │
│ (页面级) │ │ (块级) │
│ 缓存文件内容 │ │ 缓存磁盘块 │
└──────────────┘ └──────────────┘
↑ ↑
│ 数据可能重复! │
└───────────────────────────────┘
问题: 同一磁盘数据可能同时存在于两个缓存中,造成内存浪费和一致性问题
这种分离设计存在严重问题:同一磁盘数据可能同时存在于两个独立缓存,不仅浪费内存,更引发数据一致性问题。
从 Linux 2.4 开始,内核重构缓存架构:buffer_head 依附于 page 之上,块缓存成为页缓存的子集:
┌─────────────────────────────────────────────────────────────────────┐
│ 统一后的缓存架构 (2.4+) │
└─────────────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────┐
│ Page Cache (address_space) │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ page │ │ page │ │ page │ ... │
│ │ ┌─────┐ │ │ │ │ ┌─────┐ │ │
│ │ │ bh │ │ │ (无 bh) │ │ │ bh │ │ │
│ │ │ bh │ │ │ │ │ │ bh │ │ │
│ │ └─────┘ │ │ │ │ └─────┘ │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ 有 bh: 块设备文件/块大小<页大小 │
│ 无 bh: 普通文件且块大小==页大小 │
└──────────────────────────────────────────────────┘
统一后优势:
- 消除数据重复:每个磁盘块在内存中只有一个副本,避免一致性问题
- 统一管理接口:所有文件 I/O 都通过 address_space 进行
- 灵活的块大小支持:通过 buffer_head 可支持任意块大小
- 高效的内存利用:页面按需分配 buffer_head
1.3 设计哲学(buffer_head 角色的演变)
核心要点:
-
bio 是现代 I/O 的基本单位
-
buffer_head 的三大用途:
- 通过
get_block_t提取块映射关系:逻辑块号 → 物理块号 - 跟踪页面内各块的状态(dirty、uptodate、locked 等)
- 为向后兼容包装 bio 提交(如
submit_bh)
- 通过
1.4 整体层次结构
┌─────────────────────────────────────────────────────────────────────┐
│ 用户空间 │
│ read() / write() / mmap() │
└────────────────────────────┬────────────────────────────────────────┘
│ 系统调用
▼
┌─────────────────────────────────────────────────────────────────────┐
│ VFS 层 (Virtual File System) │
│ file_operations: sys_read() → vfs_read() → do_sync_read() │
│ sys_write() → vfs_write() → do_sync_write() │
│ 核心入口: │
│ generic_file_aio_read() — 读操作 │
│ generic_file_aio_write() — 写操作 │
│ filemap_fault() — mmap 页缺失 │
└────────────────────────────┬────────────────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────────────────┐
│ Address Space 层 (Page Cache) │
│ address_space_operations: │
│ readpage/readpages — 读页面 writepage/writepages — 写回 │
│ write_begin/end — 准备/完成写入 set_page_dirty — 脏页标记 │
│ 核心数据: radix_tree(page_tree)、host(inode)、nrpages │
└────────────────────────────┬────────────────────────────────────────┘
┌────────┴────────┐
▼ ▼
┌──────────────────────────┐ ┌──────────────────────────────────────┐
│ Buffer Head 层 │ │ 直接 I/O (O_DIRECT) │
│ get_block() 映射 │ │ 绕过页缓存 │
│ 块状态跟踪 / submit_bh │ └──────────────────────────────────────┘
└────────────┬─────────────┘
▼
┌─────────────────────────────────────────────────────────────────────┐
│ Block 层 (BIO / I/O调度器 / 设备驱动) │
└────────────────────────────┬────────────────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 磁盘硬件 │
└─────────────────────────────────────────────────────────────────────┘
二、address_space 数据结构详解
2.1 结构体定义
源码位置: include/linux/fs.h:621-648
struct address_space {
struct inode *host; /* owner: inode, block_device */
struct radix_tree_root page_tree; /* radix tree of all pages */
spinlock_t tree_lock; /* and lock protecting it */
unsigned int i_mmap_writable;/* count VM_SHARED mappings */
struct prio_tree_root i_mmap; /* tree of private and shared mappings */
struct list_head i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
spinlock_t i_mmap_lock; /* protect tree, count, list */
unsigned int truncate_count; /* Cover race condition with truncate */
unsigned long nrpages; /* number of total pages */
pgoff_t writeback_index;/* writeback starts here */
const struct address_space_operations *a_ops; /* methods */
unsigned long flags; /* error bits/gfp mask */
struct backing_dev_info *backing_dev_info; /* device readahead, etc */
spinlock_t private_lock; /* for use by the address_space */
struct list_head private_list; /* ditto */
struct address_space *assoc_mapping; /* ditto */
struct mutex unmap_mutex; /* to protect unmapping */
} __attribute__((aligned(sizeof(long))));
2.2 设计要点
- 内存对齐:
__attribute__((aligned(sizeof(long))))确保对齐到long。这保证 address_space 指针最低位始终为 0,使得 page->mapping 可用最低位作为标志位(区分文件页缓存与匿名映射)。 - 多锁设计:tree_lock、i_mmap_lock、private_lock 分别保护不同数据,减少锁竞争。
- 操作方法分离:通过 a_ops 指针将操作方法与数据结构分离,允许不同文件系统实现自己的缓存策略。
2.3 字段分组结构图
┌─────────────────────────────────────────────────────────────────────────┐
│ struct address_space │
├─────────────────────────────────────────────────────────────────────────┤
│ [核心身份字段] │
│ host ──────────────────────▶ struct inode │
│ | 普通文件: host = 文件 inode │
│ | 块设备: host = bdev->bd_inode │
│ │
│ [页缓存核心: radix tree] │
│ page_tree ─────────────────▶ radix_tree_root │
│ ├── slot[0] ──▶ page (index=0) │
│ ├── slot[1] ──▶ page (index=1) │
│ └── ... │
│ tree_lock: 保护 radix tree 的自旋锁 │
│ nrpages: 缓存中的总页面数 │
│ │
│ [反向映射 (reverse mapping)] │
│ i_mmap ────────────────────▶ prio_tree_root │
│ └── vm_area_struct (共享/私有映射) │
│ i_mmap_nonlinear: 非线性映射链表 (VM_NONLINEAR) │
│ i_mmap_writable: 可写共享映射计数 │
│ i_mmap_lock: 保护反向映射的自旋锁 │
│ truncate_count: 截断操作序列号,防止竞态 │
│ │
│ [操作方法集] │
│ a_ops ────────────────────▶ address_space_operations │
│ ├── readpage / writepage ├── write_begin / write_end │
│ ├── set_page_dirty / bmap ├── direct_IO / migratepage ... │
│ │
│ [写回控制] │
│ writeback_index: 回写起始位置 │
│ backing_dev_info ─▶ 设备回写信息 (预读、拥塞等) │
│ flags: 错误位 / GFP 掩码 │
│ │
│ [Buffer Head 关联] │
│ private_lock: 保护 buffer_head 关联链表 │
│ private_list ─▶ 关联的 buffer_head 链表 │
│ assoc_mapping ─▶ 关联的 address_space (inode↔块设备) │
│ │
│ unmap_mutex: 保护 unmapping 操作的互斥锁 │
└─────────────────────────────────────────────────────────────────────────┘
2.3 反向映射(reverse mapping)四字段详解
address_space 里 i_mmap 系列字段支撑"从物理页反向找到哪些虚拟地址映射了它",是页回收(shrink_page_list)、写回时同步 mmap 脏位(page_mkclean)、COW 判定的基础:
| 字段 | 作用 | 说明 |
|---|---|---|
i_mmap | 主反向映射树(prio_tree_root) | 按虚拟地址区间组织的优先树,容纳 VM_SHARED 与 VM_PRIVATE 文件映射的 vm_area_struct |
i_mmap_writable | 可写共享映射计数 | 统计映射着本文件的可写共享 VMA 数量,供 mmap 写保护与 MAP_DENYWRITE/VM_DENYWRITE 判定 |
i_mmap_nonlinear | 非线性映射链表(VM_NONLINEAR) | 非线性 mmap 无法用区间树表达,退化为链表;回收时逐项处理 |
i_mmap_lock | 保护上述三者的自旋锁 | 反向映射增删与遍历的互斥 |
为何需要反向映射:正向(虚拟地址 → 页)靠进程页表即可;但内核要回收/写回某个物理页时,需要知道"谁在用它"。rmap.c 里对 struct page 上的每个文件页,通过其所属 mapping->i_mmap 树找到所有引用它的 VMA,再经 page_address_in_vma 反查 PTE。因此:
页回收前: need flush TLB + 清零 PTE
页 page → mapping = page->mapping
→ 遍历 i_mmap 树/VMA 链表 (持有 i_mmap_lock)
→ 对每个 VMA 找到该页的 PTE, page_mkclean 清 PTE 脏位
写回时: 同上, 保证 mmap 写入的脏位同步到 page(PG_dirty)
truncate_count 配合 truncate 防止"回收一个正在被截断的页"竞态。这套反向映射在 mm/rmap.c、mm/filemap_xip.c、mm/page-writeback.c 中配合使用。
三、Radix Tree 页面索引机制
address_space 的核心是 radix tree,以页面索引(page->index)为键,快速定位缓存页面。radix tree 是多叉搜索树,特别适合稀疏索引场景。
3.1 结构示意
address_space->page_tree (radix_tree_root)
│
▼
┌────────────────────────────────────────────────────────────┐
│ radix_tree_node (Level 0) │
│ ┌──────┬──────┬──────┬──────┬──────┬──────┬──────┬────┐ │
│ │slot 0│slot 1│slot 2│slot 3│slot 4│ ... │slot62│63 │ │
│ └──┬───┴──┬───┴──────┴──┬───┴──────┴──────┴──────┴────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────┐ ┌─────┐ ┌──────────────┐ │
│ │page │ │page │ │radix_node L1 │ │
│ │idx=0│ │idx=1│ │(索引 64~127) │ │
│ └─────┘ └─────┘ └──────┬───────┘ │
│ │ │
│ ┌─────────┼─────────┐ │
│ ▼ ▼ ▼ │
│ ┌─────┐ ┌─────┐ ┌─────┐ │
│ │page │ │page │ │page │ │
│ │idx64│ │idx65│ │idx66│ │
│ └─────┘ └─────┘ └─────┘ │
└────────────────────────────────────────────────────────────┘
特性:
├── 每个节点 64 个 slot (RADIX_TREE_MAP_SHIFT = 6)
├── Level 0 覆盖: index 0 ~ 63
├── Level 1 覆盖: index 64 ~ 4095
├── Level 2 覆盖: index 4096 ~ 262143
└── 查找复杂度: O(log64(N)),实际中通常 1~2 层即可
Tag 机制:
├── PAGECACHE_TAG_DIRTY: 标记脏页,用于 writeback
├── PAGECACHE_TAG_WRITEBACK: 标记正在写回的页
└── PAGECACHE_TAG_TOWRITE: 标记待写回的页
3.2 设计优势
- 高效查找:O(log64(N)),大多数文件只需 1-2 层节点
- 稀疏索引:不为不存在的页面分配空间,节省内存
- Tag 机制:可快速查找具有特定标签的页面集合,无需遍历整树
- 无锁读取:结合 RCU,读操作无锁进行,提高并发性能
Tag 机制详解:
PAGECACHE_TAG_DIRTY:标记脏页。回写线程快速找到所有脏页PAGECACHE_TAG_WRITEBACK:标记正在写回的页面,避免重复提交 I/OPAGECACHE_TAG_TOWRITE:标记待写回的页面,用于后台回写调度
3.3 页面查找:find_get_page()
源码位置: mm/filemap.c:636-666
find_get_page() 是页缓存查找核心函数,使用 RCU 无锁协议实现高效并发查找:
find_get_page(mapping, offset)
│
▼
┌───────────────────────────────────────────────────────────────┐
│ 1. 进入 RCU 读临界区 rcu_read_lock(); │
└───────────────────────────────────────────────────────────────┘
▼
┌───────────────────────────────────────────────────────────────┐
│ 2. 在 radix tree 中查找 slot │
│ pagep = radix_tree_lookup_slot(&mapping->page_tree, offset)│
└───────────────────────────────────────────────────────────────┘
├── [slot 不存在] → 返回 NULL
▼ [slot 存在]
┌───────────────────────────────────────────────────────────────┐
│ 3. 从 slot 解引用页面 page = radix_tree_deref_slot(pagep); │
└───────────────────────────────────────────────────────────────┘
▼
┌───────────────────────────────────────────────────────────────┐
│ 4. 原子地增加页面引用计数 (RCU) │
│ if (!page_cache_get_speculative(page)) goto repeat; │
└───────────────────────────────────────────────────────────────┘
▼
┌───────────────────────────────────────────────────────────────┐
│ 5. 验证页面未移动 (lockless 协议) │
│ if (unlikely(page != *pagep)) { release; goto repeat; } │
└───────────────────────────────────────────────────────────────┘
▼
┌───────────────────────────────────────────────────────────────┐
│ 6. 退出 RCU 读临界区,返回 page │
│ rcu_read_unlock(); return page; │
└───────────────────────────────────────────────────────────────┘
无锁查找协议说明:进入 RCU 临界区防止被抢占、保证节点不释放;从 slot 解引用可能遇到 NULL 或特殊值 RADIX_TREE_RETRY(需重试);用 page_cache_get_speculative() 原子增加引用(若计数已为 0 则失败重试);再次校验页未移动。热路径上避免获取 tree_lock,仅添加/删除页面时才需取锁。
四、address_space_operations 操作方法集
源码位置: include/linux/fs.h:570-603
struct address_space_operations {
int (*writepage)(struct page *page, struct writeback_control *wbc);
int (*readpage)(struct file *, struct page *);
void (*sync_page)(struct page *);
int (*writepages)(struct address_space *, struct writeback_control *);
int (*set_page_dirty)(struct page *page);
int (*readpages)(struct file *filp, struct address_space *mapping,
struct list_head *pages, unsigned nr_pages);
int (*write_begin)(struct file *, struct address_space *mapping,
loff_t pos, unsigned len, unsigned flags,
struct page **pagep, void **fsdata);
int (*write_end)(struct file *, struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied,
struct page *page, void *fsdata);
sector_t (*bmap)(struct address_space *, sector_t);
void (*invalidatepage) (struct page *, unsigned long);
int (*releasepage) (struct page *, gfp_t);
ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
loff_t offset, unsigned long nr_segs);
int (*get_xip_mem)(struct address_space *, pgoff_t, int,
void **, unsigned long *);
int (*migratepage) (struct address_space *,
struct page *, struct page *);
int (*launder_page) (struct page *);
int (*is_partially_uptodate) (struct page *, read_descriptor_t *,
unsigned long);
int (*error_remove_page)(struct address_space *, struct page *);
};
4.1 方法功能分类
读取操作:
readpage: 读取单个页面到页缓存 (页面无锁→从磁盘读)
典型实现: block_read_full_page(page, get_block)
readpages: 批量预读多个页面 (预读机制触发)
典型实现: mpage_readpages()
sync_page: 等待页面 I/O 完成
典型实现: block_sync_page()
写入操作:
writepage: 写回单个脏页 (pdflush/kswapd 回写)
典型实现: block_write_full_page(page, get_block)
writepages: 批量写回脏页 (sync/fsync)
典型实现: mpage_writepages()
write_begin: 准备写入 (替代 prepare_write)
典型实现: block_write_begin()
write_end: 完成写入 (替代 commit_write)
典型实现: generic_write_end() → block_commit_write()
状态管理:
set_page_dirty: 标记页面为脏
有 bh: __set_page_dirty_buffers()
无 bh: __set_page_dirty_nobuffers()
invalidatepage: 使页面部分或全部失效 (truncate)
典型实现: block_invalidatepage()
releasepage: 释放页面关联的私有数据 (内存回收)
典型实现: try_to_release_page()
其他操作:
bmap: 逻辑块号 → 物理块号映射 (FIBMAP ioctl)
典型实现: generic_block_bmap()
direct_IO: 直接 I/O (绕过页缓存)
is_partially_uptodate: 检查页面是否部分最新 (短读优化)
典型实现: block_is_partially_uptodate()
4.2 关键方法详解
- readpage:最基础读操作。页面必须已锁定(PG_locked),读取完成解锁并置 PG_uptodate。
- readpages:批量预读,高效实现会尝试合并连续块到单个 bio。
- set_page_dirty:有 buffer_head 的页面需同时标记所有 bh 为脏。
- is_partially_uptodate:短读优化,只需检查涉及的 buffer_head 而不检查整个页面。
五、inode 与 address_space 的关系
每个 inode 内嵌一个 address_space,同时持有一个指向实际 address_space 的指针:
struct inode {
...
struct address_space *i_mapping; /* 指向实际的 address_space */
struct address_space i_data; /* 内嵌的 address_space */
...
};
5.1 i_mapping 与 i_data 的指向关系
场景 1: 普通文件
┌───────────────────────────────────────────────────────────────┐
│ struct inode (普通文件) │
│ i_mapping ─────┐ │
│ i_data ◄───────┘ (i_mapping 指向自己的 i_data) │
│ ├── host = inode │
│ ├── page_tree = 该文件的页面缓存 │
│ └── a_ops = ext4_aops / ext3_aops / ... │
└───────────────────────────────────────────────────────────────┘
场景 2: 块设备文件
┌───────────────────────────────────────────────────────────────┐
│ struct inode (块设备) │
│ i_mapping ──────────▶ bdev->bd_inode->i_data │
│ (指向块设备的 address_space) │
│ i_data (自己的 address_space 不使用) │
└───────────────────────────────────────────────────────────────┘
设计原理:普通文件每个文件独立页缓存;块设备则所有访问同一块设备的文件共享同一个 address_space,原因:
- 避免数据重复:同一磁盘块不应在不同 inode 缓存中存在多副本
- 统一访问路径:块设备文件直访与文件系统访问同一磁盘块共用缓存
- 简化同步:缓存失效只需操作一个 address_space
5.2 初始化绑定(inode_init_always)
struct inode *inode_init_always(struct super_block *sb, struct inode *inode)
{
address_space_init_once(&inode->i_data); // 初始化内嵌 address_space
inode->i_mapping = &inode->i_data; // 默认指向内嵌 i_data
inode->i_data.host = inode; // 设置宿主为该 inode
mapping_set_gfp_mask(&inode->i_data, GFP_HIGHUSER_MOVABLE);
return inode;
}
bdget() 中块设备的特殊绑定:
struct block_device *bdget(dev_t dev)
{
inode = iget5_locked(blockdev_superblock, hash(dev), ...);
if (inode->i_state & I_NEW) {
struct bdev_inode *ei = BDEV_I(inode);
bdev = &ei->bdev;
bdev->bd_inode = inode;
// 关键: 块设备页缓存使用自己的 inode,所有文件共享同一缓存
inode->i_mapping = &inode->i_data;
inode->i_data.host = inode;
}
return bdev;
}
5.3 address_space_init_once()
源码位置: fs/inode.c:258-269
void address_space_init_once(struct address_space *mapping)
{
memset(mapping, 0, sizeof(*mapping));
INIT_RADIX_TREE(&mapping->page_tree, GFP_ATOMIC);
spin_lock_init(&mapping->tree_lock);
spin_lock_init(&mapping->i_mmap_lock);
INIT_LIST_HEAD(&mapping->private_list);
spin_lock_init(&mapping->private_lock);
INIT_RAW_PRIO_TREE_ROOT(&mapping->i_mmap);
INIT_LIST_HEAD(&mapping->i_mmap_nonlinear);
mutex_init(&mapping->unmap_mutex);
}
由 inode_init_once() 调用。清零所有字段、初始化 radix tree(GFP_ATOMIC,因初始化可能在原子上下文)、初始化三把自旋锁、初始化链表和优先树、初始化 unmap 互斥锁。
5.4 address_space 回指 inode
static inline struct inode *mapping_host(struct address_space *mapping)
{ return mapping->host; }
static inline struct inode *page_inode(struct page *page)
{ return page->mapping->host; }
static inline struct inode *bh_inode(struct buffer_head *bh)
{ return bh->b_page->mapping->host; }
六、page 与 address_space 的关系
页面通过 mapping 字段与 address_space 建立关联:
struct page {
...
struct address_space *mapping; // 所属的 address_space
pgoff_t index; // 页面在文件内的偏移(单位:页)
...
};
6.1 mapping 字段的巧妙设计(标志位复用)
mapping 的特殊含义:
┌───────────────────────────────────────────────────────────────┐
│ mapping != NULL 且最低位 = 0: 页面属文件页缓存→指向 address │
│ mapping != NULL 且最低位 = 1: 页面属匿名映射(PAGE_MAPPING_ANON│
│ →指向 anon_vma,需减1后转换) │
│ mapping == NULL: 页面已从缓存移除 (truncate 等) │
└───────────────────────────────────────────────────────────────┘
注意: address_space __attribute__((aligned(sizeof(long)))) 保证
指针最低位始终为0,可用于标志位,省内存且避免额外标志字段
6.2 页面与 buffer_head 的关联
当页面需要块级管理时,页面关联一个 buffer_head 循环链表:
当页面有 buffer_head 时:
┌───────────────────────────────────────────────────────────────┐
│ struct page │
│ ├── flags: PG_Private = 1 (表示 page->private 有效) │
│ ├── private ──▶ 第一个 buffer_head │
│ └── mapping ──▶ address_space │
└───────────────────────────────────────────────────────────────┘
访问宏:
├── page_has_buffers(page) = PagePrivate(page)
├── page_buffers(page) = (struct buffer_head *)page_private(page)
├── attach_page_buffers(page, head)
│ ├── page_cache_get(page) // 增加页面引用
│ ├── SetPagePrivate(page) // 设置 PG_Private
│ └── set_page_private(page, head) // private 指向 bh 链表头
└── __clear_page_buffers(page)
├── ClearPagePrivate(page)
└── set_page_private(page, 0)
一个 4KB 页面可含多个 buffer_head(取决于块大小):
块大小 = 512 字节: MAX_BUF_PER_PAGE = 8
块大小 = 1KB: MAX_BUF_PER_PAGE = 4
块大小 = 4KB: MAX_BUF_PER_PAGE = 1
page->private 指向第一个 buffer_head
每个 bh->b_this_page 指向下一个 bh
最后一个 bh->b_this_page 指向第一个 bh (循环链表)
页面内的组织:
+------------------------------------------------------------------+
| Page (4KB) |
+------------------------------------------------------------------+
| 0x000-0x1FF | 0x200-0x3FF | 0x400-0x5FF | 0x600-0x7FF | ... |
+------------------------------------------------------------------+
│ │ │ │
▼ ▼ ▼ ▼
+------+ +------+ +------+ +------+
| bh0 |────▶| bh1 |────▶| bh2 |────▶| bh3 |──┐
+------+ +------+ +------+ +------+ │
│ │
└───────────────────────────────────────────┘
(循环链表)
七、inode、address_space、page、buffer_head 完整关系图
struct inode
┌─────────────────────┐
│ i_ino = 12345 │
│ i_size = 1048576 │
│ i_mode = S_IFREG │
│ i_mapping ──────────┼──────────────┐
│ i_data: │ ◄────────────┤
│ host │ │
│ page_tree │ ▼
│ nrpages │ ┌──────────────────┐
│ a_ops │ │ struct page │
└─────────────────────┘ │ mapping ─────────┼─▶ address_space
▲ │ index = 0 │
│ │ private ─────────┼─▶ bh链表头
│ │ flags: PG_locked│
│ │ PG_uptodate │
▼ │ PG_dirty │
┌─────────────────────────┐ │ PG_private │
│ struct address_space │ │ 数据(4KB) │
│ (inode->i_data) │ │ 0x000 bh0|bh1|... │
│ host ─────────────────┼──▶ inode ▲ │
│ │ │ │
│ page_tree (radix) │ │ b_page │
│ └── radix node │ └────────┬──────────┘
│ └── Page0/1 │ │
│ a_ops ───────▶ ext4_aops │
│ private_list ────────▶ bh链表 ▼
└─────────────────────────┐ ┌──────────────────┐
│ │ struct buffer_head│
│ │ b_page ──────────┼─▶ page
│ │ b_blocknr = 100 │
│ │ b_size = 1024 │
│ │ b_data ──────────┼─▶ 页面数据偏移
│ │ b_bdev ──────────┼─▶ 块设备
│ │ b_this_page ──────┼─▶ 下一个bh
▼ └──────────────────┘
通过 page->mapping->host 可找到 inode
数据结构联系闭环图
inode、address_space、page、buffer_head 四类核心结构通过指针形成双向闭环——从任何一环出发都能走到其余三环,这也是整个页缓存体系"以 page 为中心"的设计精髓:
① i_mapping
┌────────┐ ─────────────────▶ ┌───────────────┐
│ inode │ ◀───────────────── │ address_space │
└────────┘ ② host 回指 └───────────────┘
│
│ ③ page_tree (radix tree)
│ 查找键 = page->index
│ 锁 = tree_lock
▼
┌───────────────┐
│ page │
└───────────────┘
│ ▲
④ private │ │ ⑤ b_page 回指
(bh 链表头)│ │ PG_private 标志有效
▼ │
┌───────────────┐
│ buffer_head │ ──⑥ b_this_page
│ (bh0) │ 环形链: bh0→bh1→
└───────────────┘ bh2→bh3→bh0
六个指针各司其职:①② 建立 inode ↔ address_space 双向关联;③ 是正向查找主通道(inode → page);④⑤ 建立 page ↔ buffer_head 双向关联;⑥ 把页内多个 bh 串成环形链表,遍历时以 do { ... } while (bh != head) 收尾。
数据结构联系分层全景图
把 struct file(read/write 入口)、vm_area_struct(mmap 入口)、radix tree 节点与 Tag、block_device 一并纳入,可以看到从"打开文件"到"磁盘"的完整指针链:
struct file struct vm_area_struct
(read()/write() 入口) (mmap() 入口)
f_mapping ─────────┐ vm_file->f_mapping
│ │ 挂入 i_mmap 树
▼ ▼
┌──────────────────────────────────────────────────────────────────────┐
│ struct address_space (inode->i_data) │
│ │
│ page_tree ──▶ radix_tree_root │
│ └─ rnode ──▶ radix_tree_node (height=1, 64 slots) │
│ ├─ slot[0] ──▶ page0 │
│ ├─ slot[1] ──▶ page1 │
│ ├─ tags[0] DIRTY: {slot 1} ◀─脏页 │
│ └─ tags[1] WRITEBACK: { } ◀─在写 │
│ tree_lock (保护树+tag) nrpages = 2 │
│ a_ops ──────▶ ext4_aops: .readpage/.writepage/.write_begin/... │
│ i_mmap ◀── prio_tree ◀── vm_area_struct (反向映射: 页→VMA) │
│ private_lock / private_list (特殊 buffer_head 关联链) │
└──────────────────────────────────────────────────────────────────────┘
│ radix_tree_lookup(index=0) (RCU 无锁读)
▼
┌────────────────────── struct page (page0) ───────────────────────────┐
│ mapping ──▶ address_space (最低位 = 0 → 文件页缓存) │
│ index = 0 (radix tree 的查找键, 对应 slot[0]) │
│ flags : PG_locked | PG_uptodate | PG_private │
│ private ──▶ bh0 (PG_private=1 时有效) │
│ 数据区 4KB: │0x000..0x3FF │0x400..0x7FF │0x800..0xBFF │0xC00..FFF│ │
└──────────────────────────────────────────────────────────────────────┘
│ private
▼
┌──────────────── struct buffer_head (bh0) ────────────────────────────┐
│ b_page ──────▶ page (回指) │
│ b_this_page ─▶ bh1 ─▶ bh2 ─▶ bh3 ─▶ bh0 (环形链) │
│ b_blocknr = 100 b_size = 1024 │
│ b_data ──────▶ page 内偏移 0x000 (块 0 在页内的起始地址) │
│ b_bdev ──────▶ struct block_device ──▶ 请求队列 ──▶ 磁盘 │
│ b_state: BH_Uptodate | BH_Mapped [ | BH_Dirty | BH_Lock ] │
└──────────────────────────────────────────────────────────────────────┘
读这张图的三个要点:
- 一个文件一个 address_space:
slot[N]的下标即文件内页偏移,因此"文件偏移 → 缓存页"只需一次radix_tree_lookup(offset >> PAGE_CACHE_SHIFT) - Tag 是树的旁路索引:DIRTY/WRITEBACK 标记打在 radix tree 节点上,回写线程按 tag 收集脏页,无需逐页扫描
- buffer_head 是页内细分:1KB 块大小 → 每页 4 个 bh;每个 bh 独立记录磁盘块号与状态,是页与块设备之间的映射单位
指针关系总结与完整查找路径
inode:
├── i_mapping ────────────▶ address_space
└── i_data (内嵌) → host→inode / page_tree→radix→page / a_ops→ops
page:
├── mapping ──────────────▶ address_space
├── index ────────────────▶ 页面在文件中的偏移
└── private ──────────────▶ buffer_head (第一个)
buffer_head:
├── b_page ───────────────▶ page (回指)
├── b_this_page ──────────▶ 下一个 buffer_head (循环链表)
├── b_bdev ───────────────▶ block_device
├── b_data ───────────────▶ 页面数据偏移
└── b_assoc_map ──────────▶ address_space (关联)
完整查找路径:
1. 从 inode 找页面: inode->i_mapping->page_tree ──▶ radix_tree_lookup(index) ──▶ page
2. 从页面找 inode: page->mapping->host ──▶ inode
3. 从 buffer_head 找: bh->b_page->mapping->host ──▶ inode
4. 从 inode 找 bh: inode->i_mapping->page_tree ──▶ page ──▶ page->private ──▶ bh
5. 从 bh 找磁盘块: bh->b_bdev + bh->b_blocknr ──▶ 磁盘位置
不同文件系统的 address_space_operations
ext4 文件系统 (ext4_aops):
.readpage = ext4_readpage .readpages = ext4_readpages
.writepage = ext4_writepage .writepages = ext4_writepages
.write_begin = ext4_write_begin .write_end = ext4_write_end
.bmap = ext4_bmap .direct_IO = ext4_direct_IO
.invalidatepage = ext4_invalidatepage .releasepage = ext4_releasepage
.migratepage = buffer_migrate_page
.is_partially_uptodate = block_is_partially_uptodate
ext3 (ext3_aops): 类似,另有 .sync_page = block_sync_page
块设备 (def_blk_aops):
.readpage = blkdev_readpage .writepage = blkdev_writepage
.write_begin = blkdev_write_begin .write_end = blkdev_write_end
.writepages = generic_writepages .direct_IO = blkdev_direct_IO
tmpfs (shmem_aops):
.writepage = shmem_writepage
.set_page_dirty = __set_page_dirty_no_writeback
.readpage = shmem_readpage .write_begin = shmem_write_begin ...
八、页缓存查找与添加流程
8.1 页面添加流程(add_to_page_cache_locked)
add_to_page_cache_locked(page, mapping, index, gfp_mask):
┌───────────────────────────────────────────────────────────────┐
│ 1. 检查 PageLocked(page) 页面必须已锁定 │
├───────────────────────────────────────────────────────────────┤
│ 2. mem_cgroup_cache_charge 内存控制组计费 │
├───────────────────────────────────────────────────────────────┤
│ 3. radix_tree_preload() 预分配 radix 节点 │
├───────────────────────────────────────────────────────────────┤
│ 4. page_cache_get(page) 增加页面引用计数 │
├───────────────────────────────────────────────────────────────┤
│ 5. 设置页面属性: page->mapping = mapping; page->index = index │
├───────────────────────────────────────────────────────────────┤
│ 6. spin_lock_irq(&mapping->tree_lock) │
├───────────────────────────────────────────────────────────────┤
│ 7. radix_tree_insert(&mapping->page_tree, index, page) │
│ ├── [成功] mapping->nrpages++; 更新统计 │
│ └── [失败] page->mapping = NULL; 释放引用 │
├───────────────────────────────────────────────────────────────┤
│ 8. spin_unlock_irq(); radix_tree_preload_end() │
└───────────────────────────────────────────────────────────────┘
九、块映射 get_block 机制
9.1 get_block() 的作用
/*
* get_block() - 文件系统提供的回调函数
* 作用: 将文件的逻辑块号转换为磁盘的物理块号
* 参数:
* inode - 文件的 inode
* iblock - 文件内的逻辑块号
* bh - buffer_head,用于返回结果
* create - 是否在块未分配时分配新块
* 返回:
* 0 成功,bh->b_blocknr 被设置为物理块号
* 负数 错误
* 不同文件系统实现:
* ext4: ext4_get_block() ext3: ext3_get_block() ext2: ext2_get_block()
*/
9.2 块映射建立过程
文件逻辑块号到磁盘物理块号的映射:
文件布局:
┌─────────────────────────────────────────────────────────────────────────┐
│ 文件偏移: 0-4KB 4-8KB 8-12KB 12-16KB 16-20KB │
│ 逻辑块号: 0 1 2 3 4 │
│ 物理块号: 100 101 洞 200 201 │
└─────────────────────────────────────────────────────────────────────────┘
inode 中的块映射信息 (ext4 使用 extent tree):
inode->i_data → Extent Tree:
┌─────────────────────────────────────────────────────────────────────────┐
│ extent_header (depth=0, 内联) │
│ ├── extent: logical=0, len=2, physical=100 │
│ ├── extent: logical=2, len=1, physical=洞 (未分配) │
│ └── extent: logical=3, len=2, physical=200 │
└─────────────────────────────────────────────────────────────────────────┘
读取块号 1: iblock=1 → ext4_get_block(inode,1,bh,0) → 找到 logi=0,len=2
bh->b_blocknr = 100 + (1-0) = 101; set_buffer_mapped(bh)
读取块号 2(洞): iblock=2 → 不设置 mapped → 读取时返回零填充页面
写入块号 2: iblock=2 → ext4_get_block(inode,2,bh,1) create=1
分配物理块号 300; bh->b_blocknr=300; set_buffer_new(mapped)
十、文件读写流程中三者的协作
10.1 文件读取流程
用户调用: read(fd, buf, count)
▼
1. 获取 file 结构: file = fcheck(fd); file->f_mapping ──▶ address_space
▼
2. 通过 address_space 获取 inode: inode = file->f_mapping->host;
▼
3. 计算页面索引,radix tree 中查找:
index = pos >> PAGE_CACHE_SHIFT;
page = find_get_page(mapping, index);
|
├── [页面不存在]
│ 4a. allocate page_cache_alloc_cold(mapping)
│ add_to_page_cache_locked(page, mapping, index)
│ page->mapping = mapping; page->index = index;
│ 4b. mapping->a_ops->readpage(file, page) → ext4_readpage → mpage_readpage
│ 4c. create_empty_buffers(page, blocksize, 0); page->private = bh;
│ SetPagePrivate(page);
│ get_block(inode, iblock, bh, 0); bh->b_blocknr = 磁盘块号
│ bh->b_page = page;
│ 4d. submit_bh(READ, bh); bh->b_bdev = inode->i_sb->s_bdev;
│
└── [页面存在]
5. 检查 PageUptodate: 有效→复制; 无效→等待 I/O 或触发读取
6. file_read_actor(desc, page, offset, nr)
copy_to_user(buf, kmap(page) + offset, nr)
10.2 文件写入流程
用户调用: write(fd, buf, count)
▼
1. inode = file->f_mapping->host; mapping = inode->i_mapping;
▼
2. mapping->a_ops->write_begin(file, mapping, pos, len, flags, &page, &fsdata)
ext4_write_begin(): 查找/分配页面、创建 buffer_head、获取块映射
▼
3. copied = iov_iter_copy_from_user_atomic(page, i, offset, bytes) 复制数据
▼
4. mapping->a_ops->write_end(file, mapping, pos, len, copied, page, fsdata)
ext4_write_end(): SetPageDirty; mark_buffer_dirty; 更新 i_size; 解锁页
▼
5. __mark_inode_dirty(inode, I_DIRTY_PAGES)
bh->b_state |= BH_Dirty; 将 bh 加入脏链表
▼
6. 后台回写 (pdflush/kswapd): mapping->a_ops->writepage(page, wbc)
ext4_writepage() → block_write_full_page()
- 遍历页面的所有 buffer_head, 对每个脏 bh: 获取映射、submit_bh(WRITE, bh)
10.3 读过程:数据结构逐步变化图解
以下用固定场景逐步"拍快照":块大小 1KB、文件共 8KB,磁盘块 100~103 存放文件前 4KB,初始页缓存为空。用户执行 read(fd, buf, 4096)(文件偏移 0,对应 page index 0)。以按 bh 的通用路径(block_read_full_page 一类实现)为准。
【第 0 步】初始状态: 页缓存为空
mapping->page_tree: (空) nrpages = 0
磁盘: 块100..103 = 文件偏移 0~4KB 的数据
【第 1 步】find_get_page(0) 未命中 → add_to_page_cache_locked
(mm/filemap.c:912)
page_tree: slot[0] ──▶ page0 nrpages: 0 → 1
tree_lock 持有中做 insert
page0 (刚从伙伴系统分配):
├── mapping ──▶ mapping (page_cache_get, _count++)
├── index = 0 (radix_tree_insert 的键)
├── flags = PG_locked (读入期间锁定, 防止并发重复读)
└── 数据区 = 未定义垃圾 (尚未从磁盘读取)
【第 2 步】a_ops->readpage(file, page0) → 对页内每个 bh 调 get_block
create_empty_buffers(page0, 1024, 0) 生成 4 个 bh 挂到 page0:
page0: flags += PG_private, private ──▶ bh0 ⇄ bh1 ⇄ bh2 ⇄ bh3 (环形)
get_block(inode, iblock, bh, create=0) 填入映射:
bh0: b_blocknr=100, b_state=BH_Mapped, b_data=页内 0x000
bh1: b_blocknr=101, b_state=BH_Mapped, b_data=页内 0x400
bh2: b_blocknr=102, b_state=BH_Mapped, b_data=页内 0x800
bh3: b_blocknr=103, b_state=BH_Mapped, b_data=页内 0xC00
(若某 bh 落在洞里: 不置 BH_Mapped, 读入时按零页处理)
【第 3 步】对每个 bh: submit_bh(READ, bh) → bio → 磁盘 I/O 完成
submit_bh 内部: bio->bi_sector = b_blocknr * (b_size>>9)
bio_add_page(bio, page, b_size, 偏移)
bh 状态: b_state += BH_Async_Read (b_end_io = end_buffer_async_read)
I/O 完成回调 end_buffer_async_read():
每个 bh: set_buffer_uptodate(bh) → BH_Uptodate 置位
全部 bh 就绪时:
SetPageUptodate(page0) → PG_uptodate 置位
unlock_page(page0) → PG_locked 清除
【第 4 步】file_read_actor 拷贝到用户缓冲区
copy_to_user(buf, kmap(page0)+offset, 4096)
page0 引用计数随 find_get_page 的配对释放而递减
【最终快照】page0 留在页缓存中 (数据已最新、干净):
page_tree: slot[0] ──▶ page0 nrpages = 1 (无任何 tag)
page0: mapping=mapping, index=0
flags = PG_uptodate | PG_private (无 PG_locked/PG_dirty)
bh0~3: BH_Uptodate | BH_Mapped, b_blocknr=100..103
下次再读同一区间: find_get_page 直接命中, 不再触碰磁盘
10.4 写过程:数据结构逐步变化图解
沿用同一场景,用户接着执行 write(fd, buf, 2048)(文件偏移 0,写前 2KB)。此时 page0 已在第 10.3 节读入缓存。
【第 1 步】a_ops->write_begin(file, mapping, pos=0, len=2048, ..., &page, ...)
(block_write_begin 一类实现)
page0 已在缓存 → 命中并锁定: flags += PG_locked
本页 bh 已存在; 对要写入覆盖的 bh 确保映射:
get_block(..., create=0) → bh0/bh1 保持 b_blocknr=100/101
(若写洞或越过原 EOF: get_block create=1 分配新块,
bh 获得 BH_New|BH_Mapped 和新 b_blocknr)
【第 2 步】拷贝用户数据进页缓存 (此时数据仅存在于内存!)
iov_iter_copy_from_user_atomic(page0, iov, offset=0, 2048)
→ buf 内容写入 page0 数据区 0x000..0x7FF (bh0、bh1 的数据区)
注意: 此刻 page0 与 bh 都还不是脏状态, 数据"已在缓存但未标记"
【第 3 步】a_ops->write_end(...) → __block_commit_write → set_page_dirty
(fs/buffer.c:758 __set_page_dirty_buffers)
① 逐 bh: mark_buffer_dirty(bh0), (bh1) → BH_Dirty 置位
② TestSetPageDirty(page0) → PG_dirty 置位
③ __set_page_dirty() (fs/buffer.c:719):
持 tree_lock: radix_tree_tag_set(page_tree, 0, DIRTY)
→ radix tree 给 slot[0] 打上 DIRTY 标签
account_page_dirtied() → NR_FILE_DIRTY 等统计++
④ __mark_inode_dirty(inode, I_DIRTY_PAGES) → inode 进入脏链表
⑤ unlock_page(page0) → PG_locked 清除
【快照】
page_tree: slot[0] ──▶ page0, tags DIRTY = {slot 0} ← 回写线程按此找脏页
page0: flags = PG_uptodate | PG_private | PG_dirty
bh0/bh1: BH_Uptodate | BH_Mapped | BH_Dirty (数据已新)
bh2/bh3: BH_Uptodate | BH_Mapped (未写, 保持干净)
read() 现在能读到新数据; 磁盘上还是旧数据!
【第 4 步】后台回写 (pdflush/kswapd): a_ops->writepage(page0, wbc)
→ block_write_full_page
clear_page_dirty_for_io(page0) → PG_dirty 清除 (mm/page-writeback.c)
逐脏 bh: 提交 submit_bh(WRITE, bh) → BH_Dirty 清除, BH_Async_Write 置位
test_set_page_writeback(page0): (mm/page-writeback.c:1309)
SetPageWriteback(page0) → PG_writeback 置位
radix_tree_tag_set(WRITEBACK) → tags WRITEBACK = {slot 0}
if (!PageDirty) tags DIRTY 清除 → tags DIRTY = { }
【快照】
page_tree: slot[0] ──▶ page0, tags WRITEBACK = {slot 0}
page0: flags = PG_uptodate | PG_private | PG_writeback (无 PG_dirty)
bh0/bh1: BH_Mapped | BH_Async_Write (正在落盘)
【第 5 步】磁盘 I/O 完成: end_buffer_async_write → end_page_writeback
每个 bh: BH_Async_Write 清除, BH_Uptodate 保持
end_page_writeback(page0) → test_clear_page_writeback()
(mm/page-writeback.c:1280)
TestClearPageWriteback(page0) → PG_writeback 清除
radix_tree_tag_clear(WRITEBACK) → tags WRITEBACK = { }
【最终快照】页面回到"干净"状态, 磁盘与缓存一致:
page_tree: slot[0] ──▶ page0, 无任何 tag
page0: flags = PG_uptodate | PG_private
bh0/bh1: BH_Uptodate | BH_Mapped (b_blocknr=100/101, 磁盘已是新数据)
10.5 页面状态与 Tag 的生命周期总览
把 10.3 / 10.4 的快照浓缩为一条状态时间线,page 标志、bh 状态、radix tree Tag 三层同步变化,但职责不同:
- page 标志:整页级状态(锁定 / 最新 / 脏 / 写回中),供页回收与锁协议使用
- bh b_state:块级状态,块大小 < 页大小时同一页内各块可独立脏/独立 I/O
- radix tree Tag:跨页的集合索引,回写线程按 tag 批量收集,不必遍历全部页
add_to_page_cache set_page_dirty
┌──────────┐ ────────────────────▶ ┌──────────┐ ─────────────▶ ┌─────────────────┐
│ 不在缓存 │ │ 干净页 │ │ 脏页 │
│ │ ◀──────────────────── │ PG_ │ ◀───────────── │ PG_dirty │
└──────────┘ truncate/reclaim │ uptodate │ (写回完成) │ DIRTY tag │
└──────────┘ └─────────────────┘
▲ │
│ end_page_writeback │ clear_page_dirty_for_io
│ ▼ (清 PG_dirty, 提交 I/O)
┌───────────────────────────────────┐
│ 写回中 │
│ PG_writeback, WRITEBACK tag │
└───────────────────────────────────┘
对应的 radix tree Tag 演变 (page index=0 为例):
不在树 ──插入──▶ (无tag) ──set_page_dirty──▶ DIRTY=1
──writepage──▶ DIRTY=0, WRITEBACK=1 ──I/O完成──▶ WRITEBACK=0 (全清)
对应的 bh b_state 演变 (以被写的 bh0 为例):
(空) ──get_block──▶ Mapped ──读I/O──▶ Mapped|Uptodate
──mark_buffer_dirty──▶ +Dirty ──submit_bh(WRITE)──▶ -Dirty +Async_Write
──I/O完成──▶ Mapped|Uptodate
一个容易误解的细节:write() 返回时(第 3 步末尾)数据只进了页缓存,尚未落盘——磁盘上仍是旧内容。可靠落盘要等到第 4、5 步完成,或应用显式调用 fsync()。这正是 2.6 内核"写缓存 + 延迟回写"模型的核心:write 路径只做内存拷贝和脏标记,真正的 I/O 完全交给回写机制异步完成。
十一、内存结构详解
11.1 页缓存与 buffer_head 的内存关系
inode → i_data (address_space)
├── page_tree (radix) ──▶ node ──▶ slots[0]→page0, slots[1]→page1...
├── nrpages
└── a_ops
page0 (4KB):
+------------------------------------------------------------------+
| flags: PG_locked | PG_uptodate | PG_dirty | PG_private |
+------------------------------------------------------------------+
| _count = 2 |
+------------------------------------------------------------------+
| mapping ──▶ address_space |
+------------------------------------------------------------------+
| index = 0 |
+------------------------------------------------------------------+
| private ──▶ buffer_head0 ──▶ bh1 ──▶ bh2 ──▶ bh3 ──┐ |
+------------------------------------------------------------------+
| 数据区域 (PAGE_SIZE = 4096): | |
| 0x000-..3FF bh0 | 0x400..7FF bh1 | 0x800..BFF bh2 | 0xC00..FFF bh3 │
+------------------------------------------------------┘ |
│ │
└────────────── 循环链表 ───────────────┘
buffer_head (bh0):
+------------------------------------------------------------------+
| b_state = BH_Uptodate | BH_Mapped | BH_Lock |
+------------------------------------------------------------------+
| b_this_page ──▶ bh1 | b_page ──▶ page0 |
+------------------------------------------------------------------+
| b_blocknr = 100 | b_size = 1024 |
+------------------------------------------------------------------+
| b_data = page_address(page0) + 0 | b_bdev ──▶ block_device |
+------------------------------------------------------------------+
| b_end_io = end_buffer_async_read/write | b_count = 1 |
+------------------------------------------------------------------+
11.2 Buffer Cache 的 LRU 管理
每个 CPU 有自己的 bh_lru:
struct bh_lru { struct buffer_head *bhs[BH_LRU_SIZE]; }; // BH_LRU_SIZE = 8
访问顺序: bhs[0] 最近使用, bhs[7] 最久未使用
查找流程 __find_get_block(bdev, block, size):
1. 检查 CPU 本地 LRU
2. 遍历 bhs[] 查找匹配的 bh; 找到则移到 bhs[0]
3. 未找到则从哈希表查找
哈希表结构:
bh_hashtable → bucket[0]→bh→bh→NULL / bucket[1]→bh→NULL ...
哈希函数:
hash = (block + (unsigned long)bdev) ^ GOLDEN_RATIO_PRIME
index = hash & bh_hash_mask
十二、函数调用链
12.1 完整的页缓存读调用链
用户空间: read(fd, buf, count)
▼
sys_read → vfs_read → do_sync_read
▼
file->f_op->aio_read(&kiocb, &iov, 1, pos) → generic_file_aio_read [mm/filemap.c]
├─▶ generic_segment_checks(iov, nr_segs, count)
└─▶ do_generic_file_read(filp, ppos, desc, actor)
├─▶ find_get_page(mapping, index)
│ └─▶ radix_tree_lookup_slot() // radix tree 查找
|
├─▶ [页面不存在]
│ ├─▶ page_cache_sync_readahead() // 同步预读
│ ├─▶ page_cache_alloc_cold() // 分配新页面
│ └─▶ add_to_page_cache_lru() // 添加到页缓存
|
├─▶ [页面数据无效]
│ └─▶ mapping->a_ops->readpage(filp, page)
│ └─▶ [ext4] ext4_readpage → mpage_readpage [fs/mpage.c]
│ ├─▶ bio_alloc(GFP_KERNEL, 1)
│ ├─▶ get_block(inode, iblock, bh, 0)
│ ├─▶ bio_add_page(bio, page, len, offset)
│ └─▶ submit_bio(READ, bio)
|
└─▶ actor(desc, page, offset, nr)
└─▶ file_read_actor
├─▶ kmap_atomic(page, KM_USER0)
├─▶ __copy_to_user_inatomic(buf, kaddr, size)
└─▶ kunmap_atomic(kaddr)
12.2 块访问(Block layer bio)构造要点
submit_bh(rw, bh):
├─▶ bio = bio_alloc(GFP_NOIO, 1)
├─▶ bio->bi_sector = bh->b_blocknr * (bh->b_size >> 9)
├─▶ bio->bi_bdev = bh->b_bdev
├─▶ bio_add_page(bio, bh->b_page, bh->b_size, bh_offset(bh))
├─▶ bio->bi_end_io = end_buffer_read_sync / end_buffer_write_sync
└─▶ submit_bio(rw, bio)
十三、来自源码的权威注释
include/linux/buffer_head.h 关于 buffer_head 在现代内核中的定位:
Historically, a buffer_head was used to map a single block within a page, and of course as the unit of I/O through the filesystem and block layers. Nowadays the basic I/O unit is the bio, and buffer_heads are used for extracting block mappings (via a get_block_t call), for tracking state within a page (via a page_mapping) and for wrapping bio submission for backward compatibility reasons (e.g. submit_bh).
这段注释清晰地阐述了设计理念:在引入 bio 新机制的同时,保持对旧代码(基于 bh 的文件系统)的兼容,使文件系统开发者可逐步迁移到新接口。
十四、总结
本文档分析了 Linux 2.6.32 的 address_space 与 page cache 机制:
- address_space:页缓存的核心抽象,使用 radix tree 组织页面,通过 a_ops 解耦文件系统差异
- 历史演变:从 pre-2.4 的双缓存(页缓存+块缓存分离、数据重复/一致性问题)演进为 2.4 起的统一缓存(buffer_head 依附于 page)
- radix tree:以页面索引为键的多叉树,O(log64(N)) 查找,配合 RCU 实现无锁读 + Tag 机制加速脏页定位
- inode 与 address_space:普通文件 i_mapping 指向自身 i_data;块设备则所有访问者共享 bdev->bd_inode->i_data
- page->mapping 标志位复用:利用 address_space 对齐特性,最低位区分文件页缓存与匿名映射
- get_block:文件系统回调解逻辑块号→物理块号,是页缓存与块设备之间的桥
- 操作流程与调用链:read/write 路径中 inode、address_space、page、buffer_head 四者通过指针互相关联,实现了 Linux 高效的文件 I/O 系统
address_space 与 buffer_head 协同工作,共同构成文件 I/O 缓存层的核心。