[文件系统]Address Space 与页缓存(Page Cache)详解

3 阅读29分钟

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 之间的完整关系。

目录

  1. 缓存架构的历史演变与设计哲学
  2. address_space 数据结构详解
  3. Radix Tree 页面索引机制
  4. address_space_operations 操作方法集
  5. inode 与 address_space 的关系
  6. page 与 address_space 的关系
  7. inode、address_space、page、buffer_head 完整关系图
  8. 页缓存查找与添加流程
  9. 块映射 get_block 机制
  10. 文件读写流程中三者的协作
  11. 内存结构详解
  12. 函数调用链
  13. 来自源码的权威注释
  14. 总结

一、缓存架构的历史演变与设计哲学

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: 普通文件且块大小==页大小               │
  └──────────────────────────────────────────────────┘

统一后优势:

  1. 消除数据重复:每个磁盘块在内存中只有一个副本,避免一致性问题
  2. 统一管理接口:所有文件 I/O 都通过 address_space 进行
  3. 灵活的块大小支持:通过 buffer_head 可支持任意块大小
  4. 高效的内存利用:页面按需分配 buffer_head

1.3 设计哲学(buffer_head 角色的演变)

核心要点:

  • bio 是现代 I/O 的基本单位

  • buffer_head 的三大用途:

    1. 通过 get_block_t 提取块映射关系:逻辑块号 → 物理块号
    2. 跟踪页面内各块的状态(dirty、uptodate、locked 等)
    3. 为向后兼容包装 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 设计要点

  1. 内存对齐:__attribute__((aligned(sizeof(long)))) 确保对齐到 long。这保证 address_space 指针最低位始终为 0,使得 page->mapping 可用最低位作为标志位(区分文件页缓存与匿名映射)。
  2. 多锁设计:tree_lock、i_mmap_lock、private_lock 分别保护不同数据,减少锁竞争。
  3. 操作方法分离:通过 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 设计优势

  1. 高效查找:O(log64(N)),大多数文件只需 1-2 层节点
  2. 稀疏索引:不为不存在的页面分配空间,节省内存
  3. Tag 机制:可快速查找具有特定标签的页面集合,无需遍历整树
  4. 无锁读取:结合 RCU,读操作无锁进行,提高并发性能

Tag 机制详解:

  • PAGECACHE_TAG_DIRTY:标记脏页。回写线程快速找到所有脏页
  • PAGECACHE_TAG_WRITEBACK:标记正在写回的页面,避免重复提交 I/O
  • PAGECACHE_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,原因:

  1. 避免数据重复:同一磁盘块不应在不同 inode 缓存中存在多副本
  2. 统一访问路径:块设备文件直访与文件系统访问同一磁盘块共用缓存
  3. 简化同步:缓存失效只需操作一个 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 ]           │
└──────────────────────────────────────────────────────────────────────┘

读这张图的三个要点:

  1. 一个文件一个 address_space:slot[N] 的下标即文件内页偏移,因此"文件偏移 → 缓存页"只需一次 radix_tree_lookup(offset >> PAGE_CACHE_SHIFT)
  2. Tag 是树的旁路索引:DIRTY/WRITEBACK 标记打在 radix tree 节点上,回写线程按 tag 收集脏页,无需逐页扫描
  3. 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 机制:

  1. address_space:页缓存的核心抽象,使用 radix tree 组织页面,通过 a_ops 解耦文件系统差异
  2. 历史演变:从 pre-2.4 的双缓存(页缓存+块缓存分离、数据重复/一致性问题)演进为 2.4 起的统一缓存(buffer_head 依附于 page)
  3. radix tree:以页面索引为键的多叉树,O(log64(N)) 查找,配合 RCU 实现无锁读 + Tag 机制加速脏页定位
  4. inode 与 address_space:普通文件 i_mapping 指向自身 i_data;块设备则所有访问者共享 bdev->bd_inode->i_data
  5. page->mapping 标志位复用:利用 address_space 对齐特性,最低位区分文件页缓存与匿名映射
  6. get_block:文件系统回调解逻辑块号→物理块号,是页缓存与块设备之间的桥
  7. 操作流程与调用链:read/write 路径中 inode、address_space、page、buffer_head 四者通过指针互相关联,实现了 Linux 高效的文件 I/O 系统

address_space 与 buffer_head 协同工作,共同构成文件 I/O 缓存层的核心。