Buffer Head 机制详解
对应源码:
include/linux/buffer_head.h、fs/buffer.c
本文档整合并重排自docs/fs/buffer-head-mechanism.md与docs/fs/address-space-buffer/中关于 buffer_head 的内容,聚焦 buffer head(缓冲头) 这一块设备 I/O 的核心数据结构:它是什么、如何创建、如何在读写路径中被使用、以及如何与页缓存和 bio 协作。
目录
- 概述:为什么需要 buffer_head
- 核心数据结构
- Buffer Head 的创建与挂载
- 写路径中的 Buffer Head
- 脏 Buffer 标记与传播
- Buffer Head 的回写
- I/O 提交与完成回调
- Buffer Head 查找与缓存
- nobh 模式:无 Buffer Head 的写入
- 在文件写流程中的位置与生命周期
- 整体数据流与从写入到磁盘的时序
- 关键函数索引
一、概述:为什么需要 buffer_head
Buffer head(缓冲头)是 Linux 内核中块设备 I/O 的核心中间数据结构。它描述了一个页缓存页面中某个块大小子区间与磁盘块的映射关系。
两个关键角色:
- 地址映射:记录页面中每个块对应的磁盘块号(
b_blocknr),充当页缓存到块设备的映射层 - I/O 调度单元:作为提交块 I/O 的基本单位,一个页面可被拆分为多个 buffer head 分别提交 I/O
为什么要 buffer_head? 页缓存基于 PAGE_SIZE(通常 4KB)管理,而块设备基于 block_size(1KB/2KB/4KB)寻址。当 block_size < PAGE_SIZE 时,一个页面被划分为多个块,每块可能映射到不连续的磁盘块,需要分别跟踪状态:
┌──────────────────────────────────────────────────────────────────────┐
│ │
│ ┌─────────────────────────── 4KB 页面 ──────────────────────────┐ │
│ │ │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ block 0 │ │ block 1 │ │ block 2 │ │ block 3 │ │ │
│ │ │ 1KB │ │ 1KB │ │ 1KB │ │ 1KB │ │ │
│ │ │ bh[0] │ │ bh[1] │ │ bh[2] │ │ bh[3] │ │ │
│ │ │ →磁盘块 │ │ →磁盘块 │ │ →磁盘块 │ │ →磁盘块 │ │ │
│ │ │ 100 │ │ 101 │ │ 200 │ │ 201 │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │ │
│ │ 注意: 磁盘块可以不连续! (100,101,200,201 — 中间有间隙) │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ 作用: 1.记录每块磁盘块号 2.记录每块状态 3.作为 submit_bh 的 I/O 单位│
└──────────────────────────────────────────────────────────────────────┘
设计哲学(来自源码注释) :
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).
现代内核中 buffer_head 三大用途:① 通过 get_block_t 提取块映射;② 跟踪页面内各块状态(dirty/uptodate/locked);③ 为向后兼容包装 bio 提交(submit_bh)。
二、核心数据结构
2.1 struct buffer_head
// include/linux/buffer_head.h
struct buffer_head {
unsigned long b_state; // 缓冲区状态位 (BH_*)
struct buffer_head *b_this_page; // 同一页面的 buffer_head 链表 (循环链表)
struct page *b_page; // 所属的页缓存页面
sector_t b_blocknr; // 磁盘块号 (逻辑块号)
size_t b_size; // 块大小 (字节)
char *b_data; // 指向页面中该块的数据起始地址
struct block_device *b_bdev; // 所属块设备
bh_end_io_t *b_end_io; // I/O 完成回调
void *b_private; // 回调私有数据
struct list_head b_assoc_buffers;// 关联映射链表节点
struct address_space *b_assoc_map; // 关联的 address_space
atomic_t b_count; // 引用计数
};
字段详解:
| 字段 | 说明 |
|---|---|
b_state | 位图,记录 BH_Uptodate/BH_Dirty/BH_Lock/BH_Mapped/BH_New/BH_Async_Write 等状态 |
b_this_page | 页面内 buffer_head 循环链表指针,通过 page_buffers(page) 取链表头 |
b_page | 反向指针,指向所属页缓存页面 |
b_blocknr | 对应的磁盘逻辑块号,由文件系统 get_block() 填充 |
b_size | 块大小,等于 1 << b_size_shift,通常 1024/2048/4096 |
b_data | 指向 page_address(page) + offset |
b_bdev | 目标块设备 |
b_end_io | I/O 完成回调,读写完成后由中断上下文调用 |
b_count | 引用计数,get_bh() 递增,put_bh() 递减,归零释放 |
b_assoc_map / b_assoc_buffers | 关联映射:buffer_head 与另一个 address_space(如块设备)的关联 |
内存布局(约 100 字节) :
+------------------------------------------------------------------+
| 0x00 b_state(8) | 0x08 b_this_page(8) | 0x10 b_page(8) |
+------------------------------------------------------------------+
| 0x18 b_blocknr(8) | 0x20 b_size(8) | 0x28 b_data(8) |
+------------------------------------------------------------------+
| 0x30 b_bdev(8) | 0x38 b_end_io(8) | 0x40 b_private(8) |
+------------------------------------------------------------------+
| 0x48 b_assoc_buffers(16) | 0x58 b_assoc_map(8) | 0x60 b_count(4)|
+------------------------------------------------------------------+
2.2 buffer_head 状态位(b_state)
// include/linux/buffer_head.h
enum bh_state_bits {
BH_Uptodate, // 数据有效 (已从磁盘读取或已写入)
BH_Dirty, // 数据已修改,需要写回磁盘
BH_Lock, // 正在进行 I/O 操作 (已提交给块层)
BH_Req, // I/O 请求已提交
BH_Uptodate_Lock,// uptodate 位修改时的自旋锁
BH_Mapped, // 已建立磁盘映射 (b_blocknr 有效)
BH_New, // 刚分配的磁盘块 (get_block 新映射)
BH_Async_Read, // 异步读取进行中
BH_Async_Write, // 异步写入进行中
BH_Delay, // 延迟分配 (ext4 delalloc)
BH_Boundary, // 块边界 (后续块不连续)
BH_Write_EIO, // 写入 I/O 错误
BH_Ordered, // 有序写模式 (jbd ordered)
BH_Eopnotsupp, // 操作不支持
BH_Unwritten, // 未写入的预分配块 (ext4 unwritten extent)
BH_Meta, // 元数据缓冲区
BH_Quiet, // 静默错误报告
BH_Prio, // 高优先级 I/O
};
关键状态位转换:
get_block() 映射成功
│
▼
┌──────────┐ ┌──────────┐
│ BH_Mapped│◄───│ 未映射 │
│ b_blocknr│ │ b_blocknr│
│ 有效 │ │ 无效 │
└────┬─────┘ └──────────┘
│ 修改数据
▼
┌──────────┐ submit_bh()
│ BH_Dirty │─────────────┐
│ BH_Uptodate│ │
└────┬─────┘ ▼
│ ┌──────────┐
│ │ BH_Lock │
│ │ BH_Async │
│ │ _Write │
│ └────┬─────┘
│ │ I/O 完成
│ ▼
│ ┌──────────┐
└────────────►│ BH_Dirty │ 清除
│ BH_Lock │ 清除
│ BH_Async │ 清除
│ BH_Uptodate│ 保留
└──────────┘
2.3 页面与 buffer_head 的关联
struct page
┌──────────────────┐
│ flags │ ← PG_private: 表示有 buffer_head
│ private │ ← 指向第一个 buffer_head
│ │
│ 页面数据 4KB: │
│ ┌──────────────┐ │
│ │ offset=0 │ │◄── bh[0]->b_data
│ ├──────────────┤ │
│ │ offset=1024 │ │◄── bh[1]->b_data
│ ├──────────────┤ │
│ │ offset=2048 │ │◄── bh[2]->b_data
│ ├──────────────┤ │
│ │ offset=3072 │ │◄── bh[3]->b_data
│ └──────────────┘ │
└──────────────────┘
buffer_head 循环链表 (通过 b_this_page 串成环):
page->private → bh[0]─►bh[1]─►bh[2]─►bh[3]─►(回 bh[0])
访问方式:
page_has_buffers(page) → PagePrivate(page)
page_buffers(page) → ((struct buffer_head *)page->private)
bh->b_this_page → 下一个 buffer_head (循环)
2.4 容易被忽略的状态位:BH_Meta / BH_Ordered / BH_Delay
几个状态位在回写与日志模式下有特定含义,值得展开:
- BH_Meta(元数据缓冲区) :标记该 buffer 承载的是文件系统元数据(超级块、组描述符、位图、间接块等)而非文件数据。元数据与数据在日志/回写中的处理不同——元数据严格走 jbd 日志、需要更强的持久性保证。
block_write_full_page等按BH_Meta区分是否需要特殊回写路径。 - BH_Ordered(有序写模式) :jbd 的 ordered 日志模式用它在数据 buffer 上做标记。ordered 语义要求"数据必须先于元数据落盘"——当数据 buffer 带
BH_Ordered时,jbd 会保证该 buffer 对应的数据块提交完成后,才提交相关的元数据事务,避免"先写元数据、后崩溃导致元数据指向未落盘数据"的错乱。 - BH_Delay(延迟分配) :ext4 delalloc 用它在尚未分配物理块(
b_blocknr无意义)的 buffer 上做标记,表示"这块数据已写入页缓存、但物理块待回写时统一分配"。回写时ext4_da_get_block_write识别BH_Delay才触发分配。
2.5 b_assoc_map / b_assoc_buffers —— 关联映射
b_assoc_map 与 b_assoc_buffers 把 buffer_head 与另一个 address_space 关联起来。典型场景是文件页的 buffer 与底层块设备的缓冲页之间的关联(__set_page_dirty_buffers 会把块设备的映射写回):
文件页的数据 buffer (属于文件 inode 的 address_space)
│ b_assoc_map / b_assoc_buffers
▼
块设备页/缓冲 (属于块设备 backing_dev 的映射)
└─ 设备回写时把这些已关联 buffer 一并处理
作用:让底层设备层知道"有哪些缓冲属于某个文件的数据"——在需要冲刷该设备(如 sync、设备拔出、回写该设备)时能遍历并落盘所有关联 buffer,而不是只看设备自身的页。b_assoc_map 指向该"上级" address_space,b_assoc_buffers 把属于该映射的 buffer 串成链表。
2.6 各数据结构关系总图
buffer_head 不是孤立的结构:上承 address_space/page 页缓存体系,下接 bio 块层。下图用字段级别的箭头把本章涉及的结构连起来(箭头上标注连接两端的字段或函数):
struct inode (文件) struct block_device
┌─────────────────────┐ ┌──────────────────────────┐
│ i_blkbits 块大小 │ │ bd_inode ──► 设备"文件" │
│ i_size 文件大小 │ │ └─ i_mapping ──┐ │
│ i_state ◄─┐ │ │ bd_disk ──► gendisk │
└─────┬─────┼─────────┘ └──────────────────┼────────┘
│ │ I_DIRTY_PAGES (有脏数据时) │
│ ▼ ▼
│ struct address_space bdev 的 address_space
│ ┌───────────────────────────┐ (块设备自身的页缓存,
│ │ page_tree (基数树) │ 存放元数据 buffer)
│ │ a_ops (write_begin/ │
│ │ writepage...) │
│ │ private_list ◄────────────┼──┐ ◄── bh[2].b_assoc_buffers
│ │ private_lock │ │ 脏时挂入 (见 2.5)
│ │ host ───► 回指 inode │ │
│ └───────────┬───────────────┘ │
│ │ page_tree 按 │
│ │ index 索引 │
│ ▼ │
│ struct page │
│ ┌─────────────────────┐ │
│ │ index 文件内页序号 │ │
│ │ flags: PG_private ─┼──┼──► 有 bh 时置位
│ │ PG_dirty │ │
│ │ PG_writeback │ │
│ │ private ────────────┼──┼──► bh[0] (链表头)
│ │ mapping ────────────┼──┘ 回指 address_space
│ └──────────┬──────────┘
│ │
│ b_page 回指 │ b_this_page 串成环
│ ┌──────────────┴───────────────────────────────┐
│ ▼ │
│ bh[0] ─b_this_page─► bh[1] ─► bh[2] ─► bh[3] ───┘
│ ┌───────────────────────────────────┐ (环回 bh[0])
│ │ b_state BH_Dirty/Uptodate/... │
│ │ b_data ──► page_address(page)+偏移 │◄── 指向页内数据,不缓存数据
│ │ b_blocknr 磁盘块号 (get_block 填) │
│ │ b_bdev ─────────────────────────────────► struct block_device
│ │ b_end_io / b_private I/O 完成回调 │
│ │ b_assoc_map ──► 另一 address_space │
│ └──────────────┬────────────────────┘
│ │ submit_bh(READ/WRITE, bh) 1 个 bh → 1 个 bio
│ ▼
│ struct bio
│ ┌─────────────────────────────────────┐
│ │ bi_sector = b_blocknr×(b_size>>9) │
│ │ bi_bdev = b_bdev ─────────────────────► struct block_device
│ │ bi_io_vec[0] = {b_page, b_size, │
│ │ bh_offset(bh)} │
│ │ bi_end_io = end_bio_bh_io_sync │
│ │ bi_private = bh ────────────────────┼──► 回指 buffer_head
│ └──────────────┬──────────────────────┘
│ │ submit_bio() → 请求队列 → 驱动 → 磁盘
▼
数据流总方向: 用户数据 → page (唯一数据载体) → bh (映射+状态) → bio (I/O) → 磁盘
连线说明:
| 连线 | 字段/函数 | 含义 |
|---|---|---|
| inode → address_space | inode->i_mapping | 文件的页缓存锚点 |
| address_space → page | page_tree 基数树 + page->index | 按文件偏移索引页缓存页 |
| page → bh | page->private(需 PG_private 置位) | 指向 bh 循环链表头 |
| bh → page | bh->b_page / bh->b_data | 反向指针 + 页内数据起始地址 |
| bh → bh | bh->b_this_page | 同页 bh 串成循环链表 |
| bh → block_device | bh->b_bdev | I/O 目标设备 |
| bh → bio | submit_bh() | 1 个 bh 封装为 1 个单段 bio |
| bio → bh | bio->bi_private / bi_end_io | I/O 完成时回指 bh 并回调 |
| bh → 另一 mapping | b_assoc_map / b_assoc_buffers | 脏时挂入 mapping->private_list(见 2.5) |
| page → address_space | page->mapping | 页回指所属映射 |
两点补充:
- 同页所有 bh 通过
b_this_page组成循环链表,page_buffers(page)取page->private得链表头,这是"页→块"遍历的唯一途径; - bh 另有一层 per-CPU bh_lru 缓存(
BH_LRU_SIZE=8,详见第八章),它不在上图对象图中,而是挂在 block_device 的查找路径上:__find_get_block()先查 bh_lru,未命中再查 bdev address_space 的基数树。
三、Buffer Head 的创建与挂载
3.1 create_empty_buffers — 创建一页的 buffer_head 集合
// fs/buffer.c
void create_empty_buffers(struct page *page,
unsigned long blocksize, unsigned long b_state)
{
struct buffer_head *bh, *head, *tail;
head = alloc_page_buffers(page, blocksize, 1); // 1. 为每个块分配 bh
bh = head; // 2. 初始化状态,串成链表
do {
bh->b_state |= b_state; // 设置初始状态 (通常含 BH_Mapped)
tail = bh;
bh = bh->b_this_page;
} while (bh);
tail->b_this_page = head; // 3. 首尾相连成循环链表
attach_page_buffers(page, head); // 4. 挂载到页面
}
3.2 alloc_page_buffers — 分配页面的所有 buffer_head
// fs/buffer.c
struct buffer_head *alloc_page_buffers(struct page *page,
unsigned long size, int retry)
{
head = NULL;
offset = PAGE_SIZE; // 从页面末尾开始倒序分配
while ((offset -= bufsize) >= 0) {
bh = alloc_buffer_head(GFP_NOFS); // 从 slab 分配
if (!bh) { ... 释放已分配的; return NULL; }
bh->b_page = page; // 所属页面
bh->b_this_page = head; // 串入链表
bh->b_blocknr = -1; // 磁盘块号无效
bh->b_size = bufsize; // 块大小
bh->b_data = (char *)(page_address(page) + offset); // 数据指针
set_buffer_mapped(bh); // 标记已映射
head = bh;
}
return head;
}
分配过程示意(block_size=1KB, PAGE_SIZE=4KB):
第1次循环: offset = 4096-1024 = 3072 → bh[3]->b_data = page_address+3072
第2次循环: offset = 3072-1024 = 2048 → bh[2]->b_data = page_address+2048
第3次循环: offset = 2048-1024 = 1024 → bh[1]->b_data = page_address+1024
第4次循环: offset = 1024-1024 = 0 → bh[0]->b_data = page_address+0
链表顺序: bh[0] → bh[1] → bh[2] → bh[3] → (循环回 bh[0])
3.3 attach_page_buffers 与 slab 分配器接口
// fs/buffer.c (内联)
static inline void attach_page_buffers(struct page *page,
struct buffer_head *head)
{
page->private = (unsigned long)head; // private 指向链表头
SetPagePrivate(page); // 设置 PG_private
page_cache_get(page); // 增加页面引用计数
}
// fs/buffer.c
static struct kmem_cache *bh_cachep; // buffer_head 的 slab 缓存
struct buffer_head *alloc_buffer_head(gfp_t gfp_flags)
{
struct buffer_head *ret = kmem_cache_alloc(bh_cachep, gfp_flags);
if (ret) {
INIT_LIST_HEAD(&ret->b_assoc_buffers);
ret->b_count = 0;
}
return ret;
}
四、写路径中的 Buffer Head
4.1 从 write_begin 到 buffer_head 创建
文件写路径中,buffer head 在 write_begin 阶段被创建并映射:
generic_perform_write()
├── a_ops->write_begin() ← 准备页面和 buffer_head
│ └── __block_write_begin() ← ext3/ext4 等文件系统的实现
│ ├── grab_cache_page_write_begin() ← 获取/分配页缓存页面
│ └── create_page_buffers() ← 创建 buffer_head
│ ├── page_has_buffers(page)?
│ │ 是 → 直接使用已有 buffer_head
│ │ 否 → create_empty_buffers()
│ └── 遍历涉及写入范围的 buffer_head:
│ 对每个未映射的 bh 调用 get_block()
│ → 文件系统分配磁盘块并填充 b_blocknr
├── copy_from_user_atomic() ← 拷贝用户数据到页面
└── a_ops->write_end() ← 完成写入
└── block_write_end() / generic_write_end()
├── mark_buffer_dirty() ← 标记涉及的 bh 为脏
├── __set_page_dirty_buffers() ← 标记页面为脏
└── balance_dirty_pages_ratelimited() ← 检查脏页限流
4.2 __block_write_begin — 核心准备函数
// fs/buffer.c (简化逻辑)
int __block_write_begin(struct page *page, loff_t pos, unsigned len,
get_block_t *get_block)
{
unsigned from = pos & (PAGE_CACHE_SIZE - 1); // 页内起始偏移
unsigned to = from + len; // 页内结束偏移
unsigned blocksize = 1 << inode->i_blkbits;
head = create_page_buffers(page, inode, 0); // 1. 确保有 buffer_head
block_start = 0;
bh = head;
do {
block_end = block_start + blocksize;
// 2a. 该块不在写入范围内,跳过
if (block_end <= from || block_start >= to) {
if (buffer_new(bh))
unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr);
continue;
}
// 2b. 块未映射 → 调用 get_block() 分配磁盘块
if (buffer_new(bh) || !buffer_mapped(bh)) {
err = get_block(inode, block_start >> inode->i_blkbits, bh, 1);
if (err) break;
// 2c. 新分配块 → 清零写入范围外的部分
if (buffer_new(bh)) {
clear_buffer_new(bh);
if (block_start < from)
zero_user_segments(page, block_start, from);
if (block_end > to)
zero_user_segments(page, to, block_end);
}
}
// 2d. 块数据无效 → 从磁盘读取
if (!buffer_uptodate(bh) && !buffer_delay(bh)) {
err = bh_submit_read(bh);
if (err) break;
}
block_start = block_end;
bh = bh->b_this_page;
} while (bh != head);
return err;
}
处理场景图(写入范围 offset=1500 到 offset=2500,block_size=1024):
┌─────────┬─────────┬─────────┬─────────┐
│ block 0 │ block 1 │ block 2 │ block 3 │
│ 0-1023 │1024-2047│2048-3071│3072-4095│
└─────────┴─────────┴─────────┴─────────┘
▲▲▲▲▲▲▲▲ ▲▲
│写入范围│
from=1500 to=2500
bh[0](0-1023): 不在范围 → 跳过 (若 new → unmap_underlying_metadata)
bh[1](1024-2047): 部分覆盖 → 未映射则 get_block() 分配
新块则 zero_user(1024,1500) 清零前半
非 uptodate 则 bh_submit_read()
bh[2](2048-3071): 部分覆盖 → 同上,新块则 zero_user(2500,3072)
bh[3](3072-4095): 不在范围 → 跳过
结果: 用户只写了 1500-2500,但涉及的 block1/block2 非写入部分被清零,
整个块数据保持一致。(局部写保护)
4.3 __block_commit_write — 标记脏 buffer
// fs/buffer.c (简化逻辑)
int __block_commit_write(struct inode *inode, struct page *page,
unsigned from, unsigned to)
{
head = page_buffers(page);
block_start = 0;
bh = head;
do {
block_end = block_start + blocksize;
if (block_end <= from || block_start >= to) // 1. 范围外跳过
continue;
set_buffer_uptodate(bh); // 2. 标记 buffer 数据有效
mark_buffer_dirty(bh); // 标记 buffer 需要回写
if (buffer_new(bh)) // 3. 新分配块 → 清除 BH_New
clear_buffer_new(bh);
block_start = block_end;
bh = bh->b_this_page;
} while (bh != head);
SetPageUptodate(page); // 4. 标记页面为 uptodate
return 0;
}
4.4 block_write_end → generic_write_end
// fs/buffer.c
int block_write_end(struct file *file, struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied,
struct page *page, void *fsdata)
{
unsigned start = pos & (PAGE_CACHE_SIZE - 1);
// 1. 实际拷贝 < 请求: 清零未写入部分
if (unlikely(copied < len)) {
if (!PageUptodate(page)) copied = 0;
else zero_user(page, start + copied, len - copied);
}
// 2. 标记脏 buffer
if (copied) __block_commit_write(mapping->host, page, start, start + copied);
return copied;
}
// fs/buffer.c
int generic_write_end(struct file *file, struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied,
struct page *page, void *fsdata)
{
// 1. 调用 block_write_end
copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
// 2. 更新文件大小
if (pos + copied > inode->i_size) {
i_size_write(inode, pos + copied);
mark_inode_dirty(inode);
}
// 3. 解锁页面 (唤醒等待者)
unlock_page(page);
page_cache_release(page);
// 4. 检查脏页限流
balance_dirty_pages_ratelimited(mapping);
return copied;
}
4.5 写过程数据结构变化示例
场景:block_size=1KB,页 4KB(bh[0…3]),用户在文件偏移 1500 处写入 1000 字节(from=1500, to=2500,涉及 bh[1]、bh[2])。get_block 得到 bh[1]→磁盘块 101、bh[2]→磁盘块 200(不连续)。逐步观察各结构字段与状态位的变化(状态位用缩写 D=BH_Dirty, U=BH_Uptodate, M=BH_Mapped, L=BH_Lock, A=BH_Async_Write):
初始: 页面刚从页缓存分配, 无 bh
page : 无 PG_private, private = NULL
T1 write_begin() → create_page_buffers() → create_empty_buffers()
bh[0..3]: b_blocknr=-1, b_state=M, b_data=页内偏移 0/1024/2048/3072,
b_size=1024, b_count=0
page : PG_private=1, private→bh[0], 页引用计数 +1
T2 __block_write_begin() → get_block() (仅对写入范围内的 bh[1]/bh[2])
bh[1]: b_blocknr=101 (M 保持), 若新分配 → BH_New=1,
且页内范围外部分清零 zero_user(1024,1500)
bh[2]: b_blocknr=200, 同上, zero_user(2500,3072)
bh[0]/bh[3]: 不在写入范围 → 跳过
T3 copy_from_user_atomic()
只改 page 内存内容 [1500,2500) ── 不动任何状态位/字段
(数据唯一载体是 page; bh 自身不存数据)
T4 write_end() → block_write_end() → __block_commit_write()
bh[1]: U=1, D=1 (清 BH_New)
bh[2]: U=1, D=1
page : PG_uptodate=1, PG_dirty=1
mapping : 基数树打 PAGECACHE_TAG_DIRTY 标签, NR_FILE_DIRTY+1
inode : I_DIRTY_PAGES → 挂入超级块脏 inode 链表
(传播实现: mark_buffer_dirty 中 test_set_buffer_dirty 成功 →
TestSetPageDirty 成功 → __set_page_dirty(): radix_tree_tag_set +
account_page_dirtied + __mark_inode_dirty, 见 fs/buffer.c:1235)
T5 回写 __block_write_full_page() (flusher 线程触发)
bh[1]: 清 D, 置 L=1, A=1 ← mark_buffer_async_write + 锁定
bh[2]: 清 D, 置 L=1, A=1
page : PG_writeback=1
T6 submit_bh(WRITE, bh) ── 每个 bh 各生成一个单段 bio
bio(bh[1]): bi_sector=202 (101×1024/512), bi_io_vec={page,1024,偏移1024}
bio(bh[2]): bi_sector=400 (200×1024/512), bi_io_vec={page,1024,偏移2048}
两个 bio: bi_end_io=end_bio_bh_io_sync, bi_private=各自 bh
T7 I/O 完成中断: end_bio_bh_io_sync() → end_buffer_async_write()
bh[1]: 清 A、清 L (剩 U+M); 遍历同页 bh 发现 bh[2] 仍 A → 返回
bh[2]: 清 A、清 L (剩 U+M); 无其他 A → end_page_writeback()
page : PG_writeback=0
最终态 : bh 全部 U+M, 页干净; bh[1]/bh[2] 数据已在磁盘块 101/200
要点:整个过程 bh 只变化 b_state 位与 b_blocknr(数据始终在 page 里);脏状态沿 bh → page → 基数树 → inode 单向向上传播(与 5.1 节一致);BH_Async_Write 充当"最后完成者"判据(与 7.3 节一致)。
五、脏 Buffer 标记与传播
5.1 标记传播链
脏标记从 buffer_head 向上传播到页面,再到 inode:
用户写入页面
▼
__block_commit_write()
├── set_buffer_uptodate(bh) ← BH_Uptodate: 数据有效
├── mark_buffer_dirty(bh) ← BH_Dirty: buffer 需要回写 (fs/buffer.c:1235)
│ ├── 已脏? buffer_dirty(bh) → smp_mb 复查后直接返回 (快速路径)
│ └── 首次置脏:
│ ├── test_set_buffer_dirty(bh) ← 原子置 BH_Dirty 位
│ ├── TestSetPageDirty(page) ← 原子置 PG_dirty
│ └── 首次置脏 → __set_page_dirty(page, mapping, 0)
│ │ (fs/buffer.c:719)
│ ├── account_page_dirtied() ← NR_FILE_DIRTY++
│ ├── radix_tree_tag_set(PAGECACHE_TAG_DIRTY)
│ └── __mark_inode_dirty(I_DIRTY_PAGES) ← 传播到 inode
└── SetPageUptodate(page) ← PG_uptodate (仅当页内所有 bh 均 uptodate)
补充: bh->b_assoc_buffers 挂入关联映射 private_list 的动作由
buffer_insert_into_mapping_list() 完成 (fsync_buffers_list 路径,
fs/buffer.c:702), mark_buffer_dirty 本身不做此操作。
传播路径: BH_Dirty → PG_dirty → PAGECACHE_TAG_DIRTY → I_DIRTY_PAGES → b_dirty 链表
5.2 __set_page_dirty_buffers — buffer 模式的脏页标记
与 __set_page_dirty_nobuffers 不同,此函数处理有 buffer_head 的页面:
// fs/buffer.c:758
int __set_page_dirty_buffers(struct page *page)
{
int newly_dirty;
struct address_space *mapping = page_mapping(page);
if (unlikely(!mapping))
return !TestSetPageDirty(page);
// 1. 先把页内所有 bh 置脏 (buffer 先于 page 置脏, 保持状态一致)
spin_lock(&mapping->private_lock);
if (page_has_buffers(page)) {
head = page_buffers(page);
bh = head;
do {
set_buffer_dirty(bh);
bh = bh->b_this_page;
} while (bh != head);
}
newly_dirty = !TestSetPageDirty(page); // 2. 原子置 PG_dirty
spin_unlock(&mapping->private_lock);
if (newly_dirty)
__set_page_dirty(page, mapping, 1); // 3. 基数树 DIRTY 标签
// + __mark_inode_dirty
return newly_dirty;
}
注意:mark_buffer_dirty() 走的是单 bh 置脏路径(见 5.1),而 __set_page_dirty_buffers() 是 a_ops->set_page_dirty 的 buffer 实现,自顶向下把整页所有 bh 一并置脏——两者最终都汇聚到同一个 __set_page_dirty()(fs/buffer.c:719)完成基数树标签与 inode 置脏。
5.3 脏标记的粒度对比
无 buffer_head (nobh 模式):
脏粒度 = 整个页面 (4KB)
标记: PG_dirty + radix_tree_tag(DIRTY)
回写: writepage() 一次提交整页 I/O
┌──────────────────────────────────────┐
│ 4KB 页面 (PG_dirty) │
│ 全脏或全干净,无子块粒度区分 │
└──────────────────────────────────────┘
有 buffer_head 模式:
脏粒度 = 单个 block (1KB/2KB/4KB)
标记: BH_Dirty (per buffer) + PG_dirty (per page)
回写: 只提交 BH_Dirty 的 buffer,跳过干净 buffer
┌──────────┬──────────┬──────────┬──────────┐
│ bh[0] │ bh[1] │ bh[2] │ bh[3] │
│ Dirty │ clean │ Dirty │ clean │
└──────────┴──────────┴──────────┴──────────┘
回写时只提交 bh[0] 和 bh[2] 的 I/O,bh[1]/bh[3] 跳过
六、Buffer Head 的回写
6.1 block_write_full_page — 全页回写入口
// fs/buffer.c
int block_write_full_page(struct page *page, get_block_t *get_block,
struct writeback_control *wbc)
{
// 1. 处理超出文件末尾的页面: 清零超出部分
const unsigned end_index = i_size >> PAGE_CACHE_SHIFT;
if (page->index < end_index)
return __block_write_full_page(inode, page, get_block, wbc);
offset = i_size & (PAGE_CACHE_SIZE - 1); // 2. 文件末尾页面
if (page->index == end_index && offset)
zero_user_segment(page, offset, PAGE_CACHE_SIZE);
return __block_write_full_page(inode, page, get_block, wbc);
}
6.2 __block_write_full_page — 核心 I/O 提交
// fs/buffer.c (简化逻辑)
static int __block_write_full_page(struct inode *inode, struct page *page,
get_block_t *get_block,
struct writeback_control *wbc)
{
int nr_underway = 0;
head = page_buffers(page);
// 1. 第一大遍: 确保所有脏 buffer 有映射
do {
if (!buffer_dirty(bh) && !buffer_uptodate(bh) && !buffer_delay(bh))
continue; // 非脏跳过
if (buffer_dirty(bh) && !buffer_mapped(bh)) { // 脏但未映射
get_block(inode, block_start >> i_blkbits, bh, 0);
if (buffer_new(bh)) {
clear_buffer_new(bh);
unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr);
}
}
bh = bh->b_this_page;
} while (bh != head);
SetPageWriteback(page); // 2. 设置页面正在回写
// 3. 第二大遍: 标记要回写的 buffer
do {
if (!buffer_dirty(bh) || buffer_locked(bh)) continue;
mark_buffer_async_write(bh); // 置 BH_Async_Write
clear_buffer_dirty(bh); // 清 BH_Dirty
set_buffer_locked(bh); // 置 BH_Lock
nr_underway++;
bh = bh->b_this_page;
} while (bh != head);
// 4. 第三大遍: 提交所有 async_write buffer
do {
if (buffer_async_write(bh)) {
submit_bh(WRITE, bh); // 提交写 I/O
nr_underway--;
}
bh = bh->b_this_page;
} while (bh != head);
// 5. 所有 I/O 已提交 → 立即结束页面回写
if (nr_underway == 0)
end_page_writeback(page); // 清除 PG_writeback
return 0;
}
流程图:
__block_write_full_page(page)
│ 第一遍: 确保脏 buffer 有映射 (bh[2] Dirty+!Mapped → get_block())
│ SetPageWriteback(page)
│ 第二遍: 标记回写 buffer (bh[0],bh[2] → mark_buffer_async_write + 清Dirty + Lock)
│ 第三遍: 提交 I/O (bh[0],bh[2] → submit_bh(WRITE),各构造一个 bio)
│ 若 nr_underway==0 → end_page_writeback(page)
│ 否则等待 end_buffer_async_write 回调中完成
6.3 buffer_head 状态转换(回写过程)
写入阶段 回写阶段 I/O 完成
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ BH_Dirty │ │ BH_Lock │ │ BH_Uptodate │
│ BH_Uptodate │ ───► │ BH_Async │ ───► │ │
│ BH_Mapped │ │ _Write │ │ BH_Mapped │
└──────────────┘ │ BH_Uptodate │ └──────────────┘
│ BH_Mapped │
└──────────────┘
mark_buffer_dirty() submit_bh() end_buffer_async_write()
__block_commit_write() (第二/三遍) (中断上下文)
七、I/O 提交与完成回调
7.1 submit_bh — 提交单个 buffer 的 I/O
// fs/buffer.c
int submit_bh(int rw, struct buffer_head *bh)
{
struct bio *bio;
BUG_ON(!buffer_locked(bh)); // 必须已锁定
BUG_ON(!buffer_mapped(bh));
BUG_ON(!bh->b_end_io);
bio = bio_alloc(GFP_NOIO, 1); // 2. 分配 bio
bio->bi_sector = bh->b_blocknr * (bh->b_size >> 9); // 3. 起始扇区
bio->bi_bdev = bh->b_bdev; // 目标设备
bio->bi_io_vec[0].bv_page = bh->b_page; // 数据页面
bio->bi_io_vec[0].bv_len = bh->b_size; // 数据长度
bio->bi_io_vec[0].bv_offset = bh_offset(bh); // 页内偏移
bio->bi_vcnt = 1;
bio->bi_size = bh->b_size;
bio->bi_end_io = end_bio_bh_io_sync; // bio 完成回调
bio->bi_private = bh; // 传递 buffer_head
submit_bio(rw, bio); // 4. 提交到块设备层
return ret;
}
构造 bio 的过程:
buffer_head: bio:
┌──────────────────┐ ┌──────────────────┐
│ b_blocknr = 100 │ ──► │ bi_sector = 200 │ ← 100 × (1024/512)
│ b_size = 1024 │ ──► │ bi_size = 1024 │
│ b_bdev = sda │ ──► │ bi_bdev = sda │
│ b_page = page │ ──► │ bv_page = page │
│ b_data = +2048 │ ──► │ bv_offset = 2048 │
│ │ │ bi_end_io = end_bio_bh_io_sync
│ │ ──► (private) │ bi_private = bh │
└──────────────────┘ └──────────────────┘
│ submit_bio()
┌──────────────────┐
│ 块设备层/请求队列/驱动 │
└──────────────────┘
7.2 end_bio_bh_io_sync — bio 完成回调
// fs/buffer.c
static void end_bio_bh_io_sync(struct bio *bio, int err)
{
struct buffer_head *bh = bio->bi_private;
if (err == -EOPNOTSUPP) set_bit(BH_Eopnotsupp, &bh->b_state);
// 1. 按 I/O 结果设置 uptodate
if (uptodate) set_buffer_uptodate(bh);
else clear_buffer_uptodate(bh);
// 2. 解锁 buffer_head (清 BH_Lock)
unlock_buffer(bh);
// 3. 调用 buffer_head 的完成回调 (异步写 → end_buffer_async_write)
bh->b_end_io(bh, test_bit(BH_Uptodate, &bh->b_state));
// 4. 释放 bio
bio_put(bio);
}
7.3 end_buffer_async_write — 异步写完成回调
// fs/buffer.c
static void end_buffer_async_write(struct buffer_head *bh, int uptodate)
{
struct page *page = bh->b_page;
clear_buffer_async_write(bh); // 1. 清 BH_Async_Write
if (uptodate) set_buffer_uptodate(bh); // 2. 写入成功
else { clear_buffer_uptodate(bh); SetPageError(page); partial_write = 1; }
unlock_buffer(bh); // 3. 解锁 buffer_head
// 4. 检查是否有其他 bh 仍在回写
spin_lock(&page->mapping->private_lock);
tmp = head;
do {
if (buffer_async_write(tmp)) { // 还有未完成 → 不能结束页面回写
spin_unlock(&page->mapping->private_lock);
return;
}
} while ((tmp = tmp->b_this_page) != head);
spin_unlock(&page->mapping->private_lock);
// 5. 全部完成 → 结束页面回写
end_page_writeback(page); // 清 PG_writeback,唤醒等待者
}
多个 buffer_head I/O 完成的同步(一页 4 个 bh,2 个脏 bh[0]/bh[2]):
t0: submit_bh(WRITE, bh[0]) submit_bh(WRITE, bh[2])
t1: bh[0] 完成 → end_buffer_async_write(bh[0])
├─ 清 bh[0] Async_Write
└─ 检查: bh[2] 仍 Async_Write → return (等待)
t2: bh[2] 完成 → end_buffer_async_write(bh[2])
├─ 清 bh[2] Async_Write
└─ 检查: 无其他 Async_Write → end_page_writeback(page)
关键: 用 BH_Async_Write 作"引用计数"替代,最后一个完成的结束页面回写
7.4 读路径与读过程数据结构变化示例
写路径之外,buffer_head 有三条典型读路径:
① 元数据同步读: __bread(bdev, block, size)
└── __getblk(bdev, block, size)
├── __find_get_block(): per-CPU bh_lru → bdev 基数树 (见第八章)
└── 未命中 → grow_buffers() → create_empty_buffers()
└── !buffer_uptodate(bh) → __bread_slow(bh)
├── lock_buffer() ← BH_Lock=1
├── bh->b_end_io = end_buffer_read_sync
├── submit_bh(READ, bh) ← 构造 bio → submit_bio()
└── wait_on_buffer() ← 睡眠, 等 BH_Lock 清除
② 页数据读: block_read_full_page()
└── 对每个 bh: lock_buffer + b_end_io=end_buffer_async_read
+ submit_bh(READ, bh)
└── 完成回调 end_buffer_async_read():
└── 用 BH_Uptodate_Lock 位自旋锁聚合:
该页所有 bh 都 Uptodate 且无 Async_Read
→ SetPageUptodate(page) + unlock_page(page)
③ 写前补读: bh_submit_read(bh) ← __block_write_begin 对非 Uptodate 的 bh
└── 与①相同: submit_bh(READ) + wait_on_buffer() (fs/buffer.c:4422)
读过程数据结构变化示例(读磁盘块 100,block_size=1KB → bi_sector=200):
T0 __getblk() 命中缓存或新建 bh
bh : b_blocknr=100, b_bdev=sda, b_state=M (Mapped), U=0 (数据无效)
T1 __bread_slow(): lock_buffer()
bh : 置 L (BH_Lock=1)
T2 submit_bh(READ, bh)
bh : 置 BH_Req (test_set_buffer_req)
bio : bi_sector=200 (100×1024/512),
bi_io_vec={bh->b_page, 1024, bh_offset(bh)},
bi_end_io=end_bio_bh_io_sync, bi_private=bh → submit_bio()
T3 磁盘 DMA: 数据直接写入 page 中 bh 对应的区间
(与写路径相同, bh 不拷贝数据, page 是唯一数据载体)
T4 I/O 完成中断: end_bio_bh_io_sync() → end_buffer_read_sync()
bh : 置 U (BH_Uptodate=1), 清 L (unlock_buffer), put_bh
T5 wait_on_buffer() 被唤醒, __bread() 返回
bh : 最终态 M+U, 无锁; 后续读元数据直接访问 b_data 指向的页内区间
对比写路径:同步读的完成回调 end_buffer_read_sync 只处理单个 bh(置 Uptodate + 解锁即可);写路径的 end_buffer_async_write 需要检查同页所有 bh 是否写完才能 end_page_writeback。只有路径②走 end_buffer_async_read 时才需要与写类似的整页聚合——用第一个 bh 的 BH_Uptodate_Lock 位作自旋锁,最后一个完成的 bh 负责 SetPageUptodate + unlock_page(fs/buffer.c:307)。
八、Buffer Head 查找与缓存
8.1 __getblk — 获取指定块的 buffer_head
内核维护 LRU 缓存,避免重复创建 buffer_head:
__getblk(bdev, block, size)
└── __getblk_slow(bdev, block, size)
├── __find_get_block(bdev, block, size) ← 查找缓存
│ ├── 在 per-CPU 缓存查找 (bh_lru)
│ └── 在地址空间基数树查找 (bdev->bd_inode->i_mapping)
├── 找到 → 返回
└── 未找到 → grow_buffers(bdev, block, size)
└── grow_dev_page(bdev, block, size)
├── 查找或分配页缓存页面
├── 页面无 buffers → create_empty_buffers()
└── 返回对应的 buffer_head
8.2 Buffer Head LRU 缓存
// fs/buffer.c
#define BH_LRU_SIZE 8
struct bh_lru { struct buffer_head *bhs[BH_LRU_SIZE]; };
static DEFINE_PER_CPU(struct bh_lru, bh_lrus);
// 查找 LRU
static struct buffer_head *__find_get_block_slow(struct block_device *bdev,
sector_t block, unsigned size)
{
struct bh_lru *lru = &__get_cpu_var(bh_lrus);
for (i = 0; i < BH_LRU_SIZE; i++) {
if (lru->bhs[i]->b_bdev == bdev &&
lru->bhs[i]->b_blocknr == block &&
lru->bhs[i]->b_size == size) {
get_bh(lru->bhs[i]);
return lru->bhs[i];
}
}
return NULL; // LRU 未命中
}
8.3 设备页缓存与 buffer_head 的关系
块设备 bdev 的 address_space (bd_inode->i_mapping):
存储块设备的页缓存,每个页面通过 buffer_head 管理子块
普通文件的 address_space:
页面可有 buffer_head (传统模式) 或没有 (nobh 模式)
block_device
┌──────────────┐
│ bd_inode │
│ └─i_mapping │──► page_tree (基数树索引块设备页缓存)
└──────────────┘
│
┌──┴──────┬─────────┐
▼ ▼ ▼
┌───────┐ ┌───────┐ ┌───────┐
│ Page 0│ │ Page 1│ │ Page 2│ ← 按 blocknr/PAGE_SIZE 索引
│ bh[0-3]│ │ bh[0-3]│ │ bh[0-3]│
└───────┘ └───────┘ └───────┘
块0-3 块4-7 块8-11
九、nobh 模式:无 Buffer Head 的写入
对于 block_size == PAGE_SIZE 的文件系统(如 ext4 启用大块),可跳过 buffer_head 开销。
9.1 nobh_write_begin / nobh_write_end
// fs/buffer.c
int nobh_write_begin(struct file *file, struct address_space *mapping,
loff_t pos, unsigned len, unsigned flags,
struct page **pagep, void **fsdata,
get_block_t *get_block)
{
page = grab_cache_page_write_begin(mapping, index, flags); // 1. 获取页面
if (page_has_buffers(page)) { // 2. 已有 bh → 回退 block_write_begin
unlock_page(page); page_cache_release(page); *pagep = NULL;
return __block_write_begin(page, pos, len, get_block);
}
if (!PageUptodate(page)) { /* 非 uptodate → 按需从磁盘读取 */ }
*pagep = page;
return 0;
}
int nobh_write_end(struct file *file, struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied,
struct page *page, void *fsdata)
{
SetPageUptodate(page); // 1. 标记 uptodate
if (!PageDirty(page)) // 2. 无 bh,用 nobh 版本
__set_page_dirty_nobuffers(page);
unlock_page(page); page_cache_release(page); // 3. 解锁
return copied;
}
9.2 两种模式对比
buffer_head 模式 (block_size < PAGE_SIZE):
write_begin: create_empty_buffers() → 遍历 bh → get_block()
write_end: mark_buffer_dirty() → __set_page_dirty_buffers()
writepage: __block_write_full_page() → 逐 bh submit_bh()
优点: 子块粒度脏标记,部分写入只回写脏块
缺点: 每个 buffer_head 约 96 字节,4KB/1KB 配置下每页多占 ~384B
nobh 模式 (block_size == PAGE_SIZE):
write_begin: 直接使用页面,无需 buffer_head
write_end: __set_page_dirty_nobuffers() → 整页标记脏
writepage: 直接提交整页 bio
优点: 无额外内存开销,更少元数据操作
缺点: 无法子块粒度管理,整页回写
十、在文件写流程中的位置与生命周期
10.1 完整写路径中 buffer_head 的角色
用户态: write(fd, buf, count)
▼ vfs_write() → file->f_op->aio_write()
generic_file_aio_write()
├── O_DIRECT? → generic_file_direct_write() ← 绕过页缓存,无 buffer_head
└── 缓冲写入 → generic_perform_write()
├── 循环: 对每段数据
│ write_begin() ← ★ buffer_head 在此创建
│ │ ext3/ext4: __block_write_begin()
│ │ ├── grab_cache_page_write_begin() 获取页面
│ │ ├── create_page_buffers() 创建 buffer_head
│ │ │ └── create_empty_buffers() → alloc_page_buffers()
│ │ │ └── 循环 alloc_buffer_head() (slab)
│ │ └── 遍历 bh: 未映射→get_block() / 新块→zero_user() /
│ │ 非 uptodate→bh_submit_read()
│ copy_from_user_atomic() ← 拷贝数据到页面
│ write_end() ← ★ buffer_head 在此标记脏
│ │ ext3/ext4: generic_write_end() → block_write_end()
│ │ └── __block_commit_write()
│ │ ├── set_buffer_uptodate(bh) + mark_buffer_dirty(bh)
│ │ └── __set_page_dirty_buffers() → SetPageDirty +
│ │ radix_tree_tag_set + __mark_inode_dirty + 计数
│ └── 继续下一段
└── 返回总写入字节数
10.2 回写路径中 buffer_head 的角色
flusher 线程: wb_writeback() → writeback_single_inode()
▼ do_writepages() → mapping->a_ops->writepages()
ext3/ext4: mpage_writepages()
├── 尝试合并连续脏页为多块 bio (mpage)
│ 页面有 bh 且块连续 → 合并; 块不连续 → 回退 block_write_full_page()
└── 回退路径: __block_write_full_page()
├── 第一遍: 确保脏 bh 有映射 (get_block)
├── 设置 PG_writeback
├── 第二遍: 标记 bh Async_Write + 清 Dirty + 加 Lock
├── 第三遍: submit_bh(WRITE, bh) ← ★ 提交 I/O → submit_bio()
└── I/O 完成 (中断上下文):
end_bio_bh_io_sync() → bh->b_end_io() = end_buffer_async_write()
├── clear_buffer_async_write(bh)
├── 检查是否所有 bh 的 I/O 完成
└── 是 → end_page_writeback(page) → 唤醒等待者
10.3 buffer_head 的生命周期
┌──────────────────────────────────────────────────────────────────────┐
│ 1.创建(create_empty_buffers→alloc_buffer_head slab) │
│ ↓ │
│ 2.映射(get_block 填充 b_blocknr, 置 BH_Mapped) │
│ ↓ │
│ 3.写入(copy_from_user→数据更新, mark_buffer_dirty→BH_Dirty) │
│ ↓ │
│ 4.脏态(BH_Dirty|BH_Uptodate|BH_Mapped)──► 5.回写中(BH_Lock| │
│ BH_Async_Write|BH_Uptodate|BH_Mapped)──► 6.干净(BH_Uptodate| │
│ BH_Mapped) ────► 回步骤3 (再次写入) 或 → 7.释放 │
│ │ (submit_bh→块设备 → end_buffer_async_write │
│ → end_page_writeback) │
└──────────────────────────────────────────────────────────────────────┘
十一、整体数据流与从写入到磁盘的时序
11.1 写路径中 buffer_head 的完整数据流
用户缓冲区 (用户空间) │ copy_from_user_atomic()
"Hello, World!" ▼
页缓存页面 (内核空间)
┌──────────┬──────────┬──────────┬────────┐
│ block 0 │ block 1 │ block 2 │ block 3│
│ "Hello," │ ", World"│ (旧数据) │ (旧数据)│
│ Dirty │ Dirty │ clean │ clean │
└────┬─────┴────┬─────┴──────────┴────────┘
▼ ▼ submit_bh() 各自构造 bio
┌──────────────┐ ┌──────────────┐
│ bh[0] │ │ bh[1] │
│ b_blocknr=100│ │ b_blocknr=101│
│ BH_Dirty │ │ BH_Dirty │
└──────┬───────┘ └──────┬───────┘
▼ ▼ submit_bio()
┌──────────────┐ ┌──────────────┐
│ bio:扇区200 │ │ bio:扇区202 │ ← 100×2=200, 101×2=202
│ 1024B/设备 │ │ 1024B/设备 │
└──────┬───────┘ └──────┬───────┘
└────────┬────────┘
▼ 块设备层→请求队列→驱动→磁盘 (数据持久化)
11.2 buffer_head 与其他结构的关系总览
struct inode
┌────────────┐
│ i_size │
│ i_blkbits │
│ i_state ◄── I_DIRTY_PAGES (有脏 buffer)
└────┬───────┘
│ i_mapping
▼
struct address_space
┌────────────────────┐
│ page_tree ◄────────┤── PAGECACHE_TAG_DIRTY
│ nrpages │
│ backing_dev_info ► │── b_dirty 链表
│ a_ops (write_begin/end/writepage/get_block)
│ private_list ◄─────┤── 关联的 dirty buffer_head 链表
└────────┬───────────┘
│ page_tree
▼
struct page
┌──────────────────┐
│ PG_dirty │ ◄── 由 buffer 脏标记传播
│ PG_writeback │ ◄── 回写进行中
│ PG_private │ ◄── 表示有 buffer_head
│ private → bh头 │────┐
└──────────────────┘ │
▼
struct buffer_head (循环链表)
┌────────────────────────────────────────┐
│ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │
│ │bh[0]│─►│bh[1]│─►│bh[2]│─►│bh[3]│─┐ │
│ │D,U,M│ │ U,M │ │D,U,M│ │ U,M │ │ │
│ │blk100│ │blk101│ │blk200│ │blk201│ │ │
│ └─────┘ └─────┘ └─────┘ └─────┘ │ │
└───────────────────────────────┘ │
状态缩写: D=BH_Dirty, U=BH_Uptodate, M=BH_Mapped
数据流: 用户写入 → page(数据) → bh(映射) → bio(I/O) → 磁盘
bh[0],bh[2] 脏 → submit_bh() → 各自独立 bio → 块设备
11.3 从数据写入到磁盘持久化的完整时序
时间 ─────────────────────────────────────────────────────────────►
T0: 用户 write()
T1: write_begin()
│ create_empty_buffers() → bh[0..3] 创建
│ get_block() → bh[0].b_blocknr=100, bh[1].b_blocknr=101
T2: copy_from_user_atomic() 用户数据写入页面
T3: write_end() → __block_commit_write()
│ bh[0]:mark_buffer_dirty() bh[1]:mark_buffer_dirty() ← BH_Dirty
│ __set_page_dirty_buffers() ← PG_dirty
│ __mark_inode_dirty() ← I_DIRTY_PAGES → b_dirty 链表
│ NR_FILE_DIRTY += 1
T4: balance_dirty_pages_ratelimited() 未超阈值 → 返回
... 用户继续写入,bh 保持脏 ...
T5: flusher 线程唤醒 wb_writeback() → writeback_single_inode()
T6: __block_write_full_page()
│ bh[0]/bh[1]: mark_buffer_async_write + submit_bh(WRITE)
│ bh[2]/bh[3]: clean → 跳过
│ SetPageWriteback(page)
T7: 块设备处理 I/O (bh[0] bio/bh[1] bio → 磁盘)
T8: I/O 完成(end_buffer_async_write(bh[0])) → bh[1] 还在进行
T9: I/O 完成(end_buffer_async_write(bh[1])) → 无其他 Async_Write
→ end_page_writeback(page) → wake_up 等待者
T10: 数据已在磁盘上,页面干净
十二、关键函数索引
| 函数 | 文件 | 作用 |
|---|---|---|
create_empty_buffers | fs/buffer.c | 为页面创建一整套 buffer_head |
alloc_page_buffers | fs/buffer.c | 分配页面内所有 buffer_head |
alloc_buffer_head | fs/buffer.c | 从 slab 分配单个 buffer_head |
free_buffer_head | fs/buffer.c | 释放单个 buffer_head 到 slab |
attach_page_buffers | fs/buffer.c | 将 buffer_head 循环链表挂载到页面 |
page_buffers | include/linux/buffer_head.h | 获取页面 buffer_head 链表头 |
page_has_buffers | include/linux/buffer_head.h | 检查页面是否有 buffer_head |
__block_write_begin | fs/buffer.c | 准备写入:创建 bh + 映射 + 读磁盘 |
__block_commit_write | fs/buffer.c | 完成写入:标记脏 bh |
block_write_end | fs/buffer.c | write_end 实现:调用 commit_write |
generic_write_end | fs/buffer.c | 通用 write_end:更新 i_size + 限流 |
mark_buffer_dirty | fs/buffer.c | 标记单个 bh 脏 + 传播到页面/inode |
__set_page_dirty_buffers | fs/buffer.c | buffer 模式的脏页标记 |
__set_page_dirty_nobuffers | mm/page-writeback.c | nobh 模式的脏页标记 |
block_write_full_page | fs/buffer.c | 全页回写入口 |
__block_write_full_page | fs/buffer.c | 全页回写核心:逐 bh 提交 I/O |
submit_bh | fs/buffer.c | 将 bh 构造为 bio 提交到块层 |
end_bio_bh_io_sync | fs/buffer.c | bio 完成回调:解锁 bh + 调用 bh 回调 |
end_buffer_async_write | fs/buffer.c | 异步写完成:检查所有 bh 是否完成 |
__getblk | fs/buffer.c | 获取指定块的 buffer_head (含缓存) |
__find_get_block | fs/buffer.c | 在缓存中查找 buffer_head |
grow_buffers | fs/buffer.c | 缓存未命中时创建 buffer_head |
nobh_write_begin | fs/buffer.c | 无 bh 模式的 write_begin |
nobh_write_end | fs/buffer.c | 无 bh 模式的 write_end |
bh_submit_read | fs/buffer.c | 提交 bh 的同步读 I/O |
unmap_underlying_metadata | fs/buffer.c | 解除块设备页缓存中的元数据映射 |