[文件系统] Buffer Head 机制详解

2 阅读31分钟

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 协作。

目录

  1. 概述:为什么需要 buffer_head
  2. 核心数据结构
  3. Buffer Head 的创建与挂载
  4. 写路径中的 Buffer Head
  5. 脏 Buffer 标记与传播
  6. Buffer Head 的回写
  7. I/O 提交与完成回调
  8. Buffer Head 查找与缓存
  9. nobh 模式:无 Buffer Head 的写入
  10. 在文件写流程中的位置与生命周期
  11. 整体数据流与从写入到磁盘的时序
  12. 关键函数索引

一、概述:为什么需要 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_ioI/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_spaceinode->i_mapping文件的页缓存锚点
address_space → pagepage_tree 基数树 + page->index按文件偏移索引页缓存页
page → bhpage->private(需 PG_private 置位)指向 bh 循环链表头
bh → pagebh->b_page / bh->b_data反向指针 + 页内数据起始地址
bh → bhbh->b_this_page同页 bh 串成循环链表
bh → block_devicebh->b_bdevI/O 目标设备
bh → biosubmit_bh()1 个 bh 封装为 1 个单段 bio
bio → bhbio->bi_private / bi_end_ioI/O 完成时回指 bh 并回调
bh → 另一 mappingb_assoc_map / b_assoc_buffers脏时挂入 mapping->private_list(见 2.5)
page → address_spacepage->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_buffersfs/buffer.c为页面创建一整套 buffer_head
alloc_page_buffersfs/buffer.c分配页面内所有 buffer_head
alloc_buffer_headfs/buffer.c从 slab 分配单个 buffer_head
free_buffer_headfs/buffer.c释放单个 buffer_head 到 slab
attach_page_buffersfs/buffer.c将 buffer_head 循环链表挂载到页面
page_buffersinclude/linux/buffer_head.h获取页面 buffer_head 链表头
page_has_buffersinclude/linux/buffer_head.h检查页面是否有 buffer_head
__block_write_beginfs/buffer.c准备写入:创建 bh + 映射 + 读磁盘
__block_commit_writefs/buffer.c完成写入:标记脏 bh
block_write_endfs/buffer.cwrite_end 实现:调用 commit_write
generic_write_endfs/buffer.c通用 write_end:更新 i_size + 限流
mark_buffer_dirtyfs/buffer.c标记单个 bh 脏 + 传播到页面/inode
__set_page_dirty_buffersfs/buffer.cbuffer 模式的脏页标记
__set_page_dirty_nobuffersmm/page-writeback.cnobh 模式的脏页标记
block_write_full_pagefs/buffer.c全页回写入口
__block_write_full_pagefs/buffer.c全页回写核心:逐 bh 提交 I/O
submit_bhfs/buffer.c将 bh 构造为 bio 提交到块层
end_bio_bh_io_syncfs/buffer.cbio 完成回调:解锁 bh + 调用 bh 回调
end_buffer_async_writefs/buffer.c异步写完成:检查所有 bh 是否完成
__getblkfs/buffer.c获取指定块的 buffer_head (含缓存)
__find_get_blockfs/buffer.c在缓存中查找 buffer_head
grow_buffersfs/buffer.c缓存未命中时创建 buffer_head
nobh_write_beginfs/buffer.c无 bh 模式的 write_begin
nobh_write_endfs/buffer.c无 bh 模式的 write_end
bh_submit_readfs/buffer.c提交 bh 的同步读 I/O
unmap_underlying_metadatafs/buffer.c解除块设备页缓存中的元数据映射