[文件系统]文件读写流程总览

3 阅读28分钟

文件读写流程总览(系统调用 → VFS → 页缓存 → 文件系统 → 块设备)

目录


第 1 章 设计原则

Linux 文件读写遵循四大设计原则:

  1. 缓存优先:所有常规 I/O 都经页缓存,减少磁盘访问
  2. 延迟写:先写缓存,稍后批量写回磁盘
  3. 预读:检测顺序访问,预取页面
  4. 异步回写:后台线程回写避免阻塞

第 2 章 核心数据结构

2.1 struct address_space

页缓存核心;每个打开文件(经 inode)有一个,是 VFS 与文件系统之间的桥:

struct address_space {
    struct inode         *host;
    struct radix_tree_root page_tree;     // 页缓存基数树
    spinlock_t           tree_lock;
    unsigned int         i_mmap_writable;
    struct prio_tree_root i_mmap;
    struct list_head     i_mmap_nonlinear;
    spinlock_t           i_mmap_lock;
    unsigned int         truncate_count;
    unsigned long        nrpages;          // 总页数
    pgoff_t              writeback_index;
    const struct address_space_operations *a_ops;
    unsigned long        flags;
    struct backing_dev_info *backing_dev_info;
    spinlock_t           private_lock;
    struct list_head     private_list;
    struct address_space *assoc_mapping;
    struct mutex         unmap_mutex;
};

字段详细说明

  • host:反向指针,指向拥有该地址空间(即拥有页缓存)的 struct inode。每个索引 inode 都有内嵌的 inode->i_data,它就是该文件的 address_space。从 address_space 出发可通过 host 反查 inode(如 address_space->host->i_mode),从 inode 出发通过 &inode->i_data 拿到 address_space,两者互相指认。
  • page_tree:以页索引(pgoff_t,即"该页是文件第几页")为键的基数树,页缓存的唯一组织者。查找/插入/删除均为 O(log n),且天然支持稀疏分布(文件有空洞时只占用树中有页的索引分支)。基数树的叶子存 struct page *,标签位(tag)可挂在树上用于"只枚举脏页"等批量操作。
  • tree_lock:写锁(spinlock),保护页插入/删除/移动。读路径(如 find_get_page)不用它,而是走 RCU 无锁读取,降低多读者竞争。
  • i_mmap / i_mmap_lock / i_mmap_writable:管理"映射到本文件页的 VMA"(内存映射 mmap),写文件时据此调用 page_mkclean 使对应 PTE 失效。
  • nrpages:当前缓存的总页数,用于统计与限制(如 balance_dirty_pages 判断缓存是否过大)。
  • writeback_index:回写游标,记录"下次回写从哪一页开始",配合 range_cyclic 实现环形扫描,避免总是从第 0 页写起导致前部被反复写、后部永远排不上。
  • a_ops:文件系统特定操作集(见 2.2),是本 address_space 与具体文件系统(ext3/ext4/tmpfs…)之间的"虚函数表"。
  • backing_dev_info:块设备信息,携带该设备的脏页阈值、预读页数、设备能力(是否支持直写)等,是回写和预读的"每设备"参数来源。
  • private_lock / private_list:私有链表,供 a_ops->releasepage 等做每页私有数据管理(如文件系统扩展信息)。
  • assoc_mapping:关联的二级映射,用于某些需要两套缓存映射的场景(如交换文件)。

示例:一个 100 页文件在页缓存中的样子

假设文件 /data.log 大小 400KB(100 个 4KB 页),只被读入了第 3、4、5 页:

file.file(f = fd3)
   │  f_mapping ──────────┐
   ▼                      │
inode.i_data ──────► address_space { host=&inode, nrpages=3 }
    (address_space)          page_tree: [3]─►page , [4]─►page , [5]─►page
                                  │          │           │
                              radix 树按索引稀疏存页指针,只挂了 3 个叶子
  • 树里只有 3 个键(3/4/5),没有 0、1、2、6…99,这就是"稀疏"。
  • 读路径通过 mapping 参数进入:file->f_mapping 与 &inode->i_data 是同一个 address_space,所以无论从 file 还是 inode 出发都落到同一棵树。
  • nrpages=3 告诉内核"已缓存 3 页",第 5 章预读据此估算顺序性。

示例:find_get_page 的两次引用计数

find_get_page 返回时会对页做一次"缓存引用"(_count 从 0→1),调用方用完需 page_cache_release。若同一页被三个 reader 同时读到,_count 会是 4(1 次缓存持有 + 3 次 reader 引用),最后一个 reader 释放后才回落到 1,页仍留在缓存中等待复用。

2.2 struct address_space_operations

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);
    ...
};

关键操作:

  • readpage:单页读入缓存(页锁定,解锁+设 PG_uptodate;典型 block_read_full_page)
  • readpages:批量读(用于预读,合并相邻 I/O;失败回退逐页 readpage)
  • writepage:单脏页写回(页锁定,清 PG_dirty)
  • write_begin/write_end:原子写(begin 找/建页、分配块、锁页;end 标脏、解锁、更新文件大小)
  • direct_IO:绕过缓存(需对齐 buffer/offset/len)

谁来实现这些回调

这些操作是"文件系统按需填写"的。以读路径为例,VFS 不关心页底下的块怎么排布,只调用 mapping->a_ops->readpage(filp, page),由具体文件系统把它变成磁盘 I/O:

文件系统readpage 实现特点
ext3 / ext2(块映射)block_read_full_page页切分为 1KB buffer,逐块 get_block 映射后 submit_bh
ext4(区段 extents)同 block_read_full_page,但 get_block 走区段树一次映射连续多块,合并 bio
tmpfs(纯内存)shmem_readpage无磁盘,直接从 swap/零页填充
jffs2(闪存)jffs2_readpage逐段读 flash,页逻辑类似

示例:readpage 从"命中缓存"到"磁盘 I/O"的分工

以 ext3 上读一页为例,do_generic_file_read 只做调度,真正搬数据的分工是:

do_generic_file_read
   │ 发现页不在缓存、创建空页后
   ▼
mapping->a_ops->readpage(filp, page)      ← 抽象接口,ext3 填的是 block_read_full_page
   ▼
block_read_full_page(page)                ← ext3 的实现
   ├─ create_empty_buffers(page, 1024, 0) → 把 4KB 页切成 4 个 1KB buffer
   ├─ 对每个未映射的 bh 调 get_block()      → ext3 回调:逻辑块号→物理扇区号
   └─ 对每个需读的 bh 调 submit_bh(READ, bh) → 下发块层 bio
   ▼
请求磁盘 → I/O 完成后 end_buffer_async_read() 设 PG_uptodate、解锁页、唤醒 reader

同一个 readpage 指针,换个文件系统就换了整套底层实现——这正是 a_ops 作为"虚函数表"的意义。

2.3 struct file_ra_state

每打开文件的预读状态:

struct file_ra_state {
    pgoff_t start;          // 预读起始位置
    unsigned int size;      // 预读窗口大小
    unsigned int async_size;// 异步预读触发点
    unsigned int ra_pages;  // 最大预读页数 (通常 128KB/4KB=32)
    unsigned int mmap_miss; // mmap 未命中计数
    loff_t prev_pos;        // 上一次读位置
};

预读窗口:文件页 0…N,窗口 [start … start+size-1],异步触发点在 start+size-async_size。当应用读到异步触发点时,内核启动异步预读,使 I/O 与应用处理重叠。

字段涵义

  • start / size:当前预读窗口的起点页与窗口长度(页数)。窗口标记"内核对未来读的预测范围",不一定是已读范围,而是"将要读的预测范围"。
  • async_size:窗口尾部的一段"降雨预警区"。当应用真正读到这里时,说明顺序读很可能继续,内核立即异步预读下一窗,使磁盘 I/O 与应用消耗重合。
  • ra_pages:该设备允许的预读上限(min(backing_dev_info->ra_pages, ...)),通常 32 页 = 128KB。窗口翻倍增长被封顶在此。
  • mmap_miss:mmap 顺序访问的未命中计数,用于把 mmap 访问也纳入预读决策。
  • prev_pos:上一次读位置,顺序检测用它判断"这次是不是连续的下一字节"。

数值示例:窗口如何增长到上限

假设 ra_pages=32(128KB),一个进程顺序读文件,每读 4KB,预读状态变化如下:

读位置       hit/miss    start   size    async 说明
───────────────────────────────────────────────────
page 0      MISS        0       4       0    同步预读 4 页(16KB), 窗口 [0..3]
page 1      HIT         0       4       1    异步点=0+4-1=3, 未到
page 3      HIT(异步点)  4       8       2    读到异步点→异步预读, 窗口变 [4..11]
page 11     HIT(异步点)  12      16      4    翻倍, 窗口 [12..27]
page 27     HIT(异步点)  28      32      8    封顶, 窗口 [28..59]
page 59 之后             60      32      8    size 不再增长, 窗口原地滑动

到 page 27 后 size 已到 ra_pages(32)上限,此后每次只把窗口整体后移,不再翻倍。

2.4 struct buffer_head

块 I/O 核心,把页映射到磁盘块:

struct buffer_head {
    unsigned long b_state;
    struct buffer_head *b_this_page; // 同页上下一个 buffer
    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;
    void *b_private;
    struct list_head b_assoc_buffers;
    struct address_space *b_assoc_map;
    atomic_t b_count;
};

b_state 标志:BH_Uptodate(有效)、BH_Dirty、BH_Lock、BH_Req、BH_Mapped、BH_New、BH_Write_EIO。页-buffer 关系:4KB 页 = 4 个 1KB buffer(fs 块 1KB 时),经 b_this_page 环形链表相连,每个 bh 有 b_blocknr。buffer 作用:块映射、部分页更新、元数据、逐 buffer I/O 提交。

字段涵义与一个 4KB 页的切分示例

  • b_this_page:同一页内下一个 buffer,串成环形链表。page_buffers(page) 返回头 bh,沿着 b_this_page 走一圈即可遍历页内全部块。
  • b_page:指向拥有该 buffer 的页,块层从 bh 反查页做 mark_page_accessed/解锁。
  • b_blocknr:逻辑块号(文件内偏移的块号,非磁盘物理扇区),映射到物理扇区是 get_block 的职责。
  • b_bdev:该块所属的块设备(主/次设备号),submit_bh 依此确定下发到哪个磁盘。
  • b_end_io:I/O 完成回调(如 end_buffer_async_read/end_buffer_async_write),异步收尾设状态、解锁。
  • b_count:引用计数,防止 bh 在被提交 I/O 时被复用或释放。

示例:把页 0 的第 500 字节写脏,块层只写 1 个块

假设一个 4KB 页(文件第 0 页)被切成 4 个 1KB buffer(块大小 1KB),进程 write(fd, "x", 1) 落在字节 500(即 buffer 1):

页(page 0)   4KB = [b0][b1][b2][b3]   (b_this_page 环形: b0→b1→b2→b3→b0)
b_blocknr      0   1   2   3
b_state     Uptodate │ Uptodate Uptodate
                 │
                 ▼
             b1: Dirty=1 (只这一个 buffer 被标脏)
物理扇区映射(块1) → 磁盘扇区 2048..2063 (1KB)
回写时 __block_write_full_page 只把 b1 对应的 1KB 下发 bio,
b0/b2/b3 保持 Uptodate 且不写盘

好处:部分更新只需回写被改的子块。若没有 buffer 粒度,写 1 字节也得整页 4KB 写盘。


第 3 章 读操作流程

3.1 读调用链

sys_read → vfs_read → file->f_op->read 或 do_sync_read
  → generic_file_aio_read [mm/filemap.c]
    → generic_segment_checks (检查用户 buffer)
    → [O_DIRECT] direct_IO
    → do_generic_file_read [mm/filemap.c:986]
      → find_get_page (radix_tree_lookup)
      → [页缺失] page_cache_sync_readahead → __do_page_cache_readahead
      → [PageReadahead] page_cache_async_readahead
      → [!PageUptodate] lock_page + readpage → mapping->a_ops->readpage
      → file_read_actor (拷贝到用户)
  1. sys_read → vfs_read:检查 fd 有效、FMODE_READ、调用 f_op
  2. f_op->read 或 do_sync_read:多数 fs 用 generic do_sync_read,把异步 I/O 包装成同步
  3. generic_file_aio_read:处理 O_DIRECT vs 缓冲
  4. do_generic_file_read:计算 index/offset、找页、处理缺失+预读、拷贝到用户

一次真实读的逐步走查:read(fd, buf, 100),pos=5000,页大小 4KB

read(fd, buf, 100)   // 文件当前 pos = 5000
└─ sys_read → vfs_read
   └─ file->f_op->read = do_sync_read (ext3 的 file_operations)
      └─ generic_file_aio_read(kiocb, iov={buf,100}, nr_segs=1, pos=5000)
         ├─ generic_segment_checks: 校验 buf 段长度/累计不溢出/access_ok 可写 → OK
         └─ (非 O_DIRECT) → do_generic_file_read
            ├─ index = 5000 >> 12 = 1      // 目标页 = 文件第 1 页
            ├─ offset = 5000 & 4095 = 904  // 页内起始字节
            ├─ last_index = (5000+100+4095)>>12 = 2  // 排他上界; 实际只涉及页 1
            ├─ find_get_page(mapping, 1)   // 页1 在缓存吗?
            │     ├─ 在 → PageUptodate? 是 → goto page_ok
            │     └─ 不在 → page_cache_sync_readahead + 再找; 仍无 → 建空页读
            ├─ page_ok: actor=file_read_actor(desc, page, offset=904, nr=4096-904=3192)
            │        └─ nr=min(3192, 剩余需读100)=100; __copy_to_user_inatomic(buf, kaddr+904, 100)
            ├─ 更新 desc->count=0, buf 前进, pos 前移
            └─ 循环结束返回 100

关键点:100 字节的读请求既不是整页也不对齐页——内核按"页内 offset + 需要长度"从页缓存的第 904 字节处拷起,无需把整页都给用户(该页其余 3192 字节留在缓存供下次复用)。本例 904+100=1004 未越出页 1 边界,故只处理一页;若读长度大到跨越页界(如 offset 4000),则要连续处理页 0、页 1 两页。

3.2 do_generic_file_read 核心循环

// 计算 index/offset
index = *ppos >> PAGE_CACHE_SHIFT; offset = *ppos & ~PAGE_CACHE_MASK;
last_index = (*ppos + desc->count + PAGE_CACHE_SIZE-1) >> PAGE_CACHE_SHIFT;

find_page:
    page = find_get_page(mapping, index);
    if (!page) → page_cache_sync_readahead + 再 find_get_page, 仍 NULL goto no_cached_page
    if (PageReadahead(page)) → page_cache_async_readahead
    if (!PageUptodate(page)) goto page_not_up_to_date
page_ok:
    nr = PAGE_CACHE_SIZE (或最后一个索引的截断大小); nr -= offset;
    ret = actor(desc, page, offset, nr); offset += ret;
    index += offset >> PAGE_CACHE_SHIFT; offset &= ~PAGE_CACHE_MASK;
    page_cache_release(page)
page_not_up_to_date:
    lock_page; 若 !PageUptodate { ClearPageError; error = a_ops->readpage(filp,page); 等 I/O } goto page_ok
no_cached_page:
    page = page_cache_alloc_cold(mapping); add_to_page_cache_lru(...); goto readpage

九步细节:步1-2 index 计算 + find_get_page;步3 缺失时同步预读;步4 遇 PG_readahead 异步预读;步5-9 处理非 uptodate(锁定、readpage、等待);步6-8 拷贝(file_read_actor)、更新位置、释放。

循环的状态机:同一页的三条出路

对每个目标页 index,循环在三个标签间跳转,可视为一个小状态机:

find_page ──命中且 Uptodate──► page_ok(拷贝) ──释放──► 下一页
    │
    ├─命中但 !Uptodate──► page_not_up_to_date
    │                          ├─ lock_page 等前一个写者
    │                          ├─ ClearPageError; a_ops->readpage 发 I/O
    │                          └─ 等 I/O 完成后设 Uptodate ──► page_ok
    │
    └─未命中──► no_cached_page
                  ├─ page_cache_alloc_cold 分配空页
                  ├─ add_to_page_cache_lru 加入缓存(LRU)
                  └─ goto page_not_up_to_date (发 readpage)

三种典型场景(同一文件、不同时刻):

场景走法是否发起磁盘 I/O
热数据,页早已读入find_page → page_ok否,纯内存拷贝
页在缓存但正被写者占用(内容未就绪)find_page → page_not_up_to_date(等待解锁+readpage)否(不重建),等即可
冷数据,首次读find_page → no_cached_page → 建页 → readpage是,发一块读 I/O

示例:顺序读 4 个 4KB 页,全部未命中

进程连续 read(fd, buf, 4*4096),缓存全空,页 0…3 全部走 no_cached_page 分支:每次分配空页、加入 LRU、a_ops->readpage 发 I/O、等完成后拷给用户。而第 5 章预读可能已把页 4…7 提前读入,于是下一批读的 4 页多数走 page_ok 纯内存拷贝——这就是预读让"第二次读"变快的原因。

3.3 页缓存查找:find_get_page

RCU 无锁查找:

struct page *find_get_page(struct address_space *mapping, pgoff_t offset){
    void **pagep; struct page *page;
    rcu_read_lock();
repeat:
    page = NULL;
    pagep = radix_tree_lookup_slot(&mapping->page_tree, offset);
    if (pagep){
        page = radix_tree_deref_slot(pagep);
        if (unlikely(!page || page == RADIX_TREE_RETRY)) goto repeat;
        if (!page_cache_get_speculative(page)) goto repeat;
        if (unlikely(page != *pagep)){ page_cache_release(page); goto repeat; }
    }
    rcu_read_unlock();
    return page;
}

RCU 优势:无锁竞争(多读者并发)、原子投机引用计数、一致性检查。goto repeat 场景:页被删(RADIX_TREE_RETRY)、引用计数增加失败(页释放中)、页移动。

3.4 块文件系统读页:block_read_full_page

1. 若无 buffer 则创建 (create_empty_buffers(page, blocksize, 0));
   head=page_buffers(page); iblock = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits)
2. 遍历每个 bh: 若 buffer_uptodate 跳过; 若 !buffer_mapped → get_block(inode, iblock, bh, 0);
   若 buffer_uptodate 跳过; arr[nr++]=bh
3. 锁定所有 buffer + mark_buffer_async_read(arr[i])
4. 提交: 若 buffer_uptodate end_buffer_async_read(arr[i],1) 否则 submit_bh(READ, arr[i])

get_block 是文件系统回调,把逻辑块映射为物理块(ext3 经间接/区段,ext4 区段树)。全部 buffer 完成后,end_buffer_async_read 设 PG_uptodate、解锁页、唤醒等待者。


第 4 章 写操作流程

4.1 写调用链

sys_write → vfs_write → file->f_op->write 或 do_sync_write
  → generic_file_aio_write [mm/filemap.c:2464]
    → mutex_lock(&inode->i_mutex)
    → __generic_file_aio_write [mm/filemap.c:2353]
      → generic_segment_checks / generic_write_checks / file_remove_suid / file_update_time
      → [O_DIRECT] generic_file_direct_write
      → generic_file_buffered_write → generic_perform_write [mm/filemap.c:2212]
        → write_begin → grab_cache_page_write_begin
        → iov_iter_copy_from_user_atomic
        → write_end → block_write_end → __block_commit_write
        → mark_inode_dirty → balance_dirty_pages_ratelimited
  1. vfs_write:检查 FMODE_WRITE、O_APPEND、调用 fs write
  2. generic_file_aio_write:取 inode->i_mutex,调 __generic_file_aio_write
  3. __generic_file_aio_write:generic_write_checks(大小、RLIMIT_FSIZE)、file_remove_suid(安全)、file_update_time(mtime/ctime)、选 O_DIRECT vs 缓冲
  4. generic_perform_write:每页循环;write_begin → 拷贝 → write_end;脏平衡

一次真实写的逐步走查:write(fd, "hello", 5),pos=4090,页大小 4KB

write(fd, "hello", 5)   // pos = 4090
└─ sys_write → vfs_write
   └─ do_sync_write → generic_file_aio_write
      └─ mutex_lock(&inode->i_mutex)     // 同一文件并发写被串行化
         └─ __generic_file_aio_write
            ├─ generic_write_checks: pos 合法、不超 RLIMIT_FSIZE
            ├─ file_remove_suid / file_update_time: 更新 mtime/ctime
            └─ (非 O_DIRECT) → generic_perform_write
               ├─ index = 4090>>12 = 0        // 页0
               ├─ offset = 4090 & 4095 = 4090 // 页内起点(只剩 6 字节空间)
               ├─ bytes = min(4096-4090, 5) = 5
               ├─ write_begin → grab_cache_page_write_begin 锁页(页0)
               ├─ iov_iter_copy_from_user_atomic: 5 字节拷进页0 的 4090 处
               └─ write_end → block_write_end → __block_commit_write
                    标脏对应 buffer → SetPageDirty + mark_inode_dirty
               (页0 只用了尾部 6 字节, 回写时也只需写脏子块)

可见写路径的核心形态与读路径对称:也是"index/offset 计算 → 定位页 → 页内对齐拷贝",但多出 inode->i_mutex 全局串行和 write_begin/write_end 成对这两点——写需要更严格的锁与脏状态管理。

4.2 generic_perform_write 核心循环

offset = pos & (PAGE_CACHE_SIZE-1); index = pos >> PAGE_CACHE_SHIFT;
bytes = min(PAGE_CACHE_SIZE-offset, iov_iter_count(i));
iov_iter_fault_in_readable(i, bytes);       // 预取用户页 (防持页锁时死锁) → -EFAULT
status = a_ops->write_begin(file, mapping, pos, bytes, flags, &page, &fsdata);  // 出错 break
if (mapping_writably_mapped(mapping)) flush_dcache_page(page);
pagefault_disable();
copied = iov_iter_copy_from_user_atomic(page, i, offset, bytes);   // 原子拷贝
pagefault_enable(); flush_dcache_page(page);
mark_page_accessed(page);
status = a_ops->write_end(file, mapping, pos, bytes, copied, page, fsdata);  copied = status;
iov_iter_advance(i, copied); pos += copied; written += copied;
balance_dirty_pages_ratelimited(mapping);
while (iov_iter_count(i));
return written ? written : status;

要点:步2 预取用户页防死锁;write_begin 找/建页 + 分配块 + 锁页;pagefault_disable 围绕原子拷贝;write_end 标 buffer 脏、更新文件大小、解锁;balance_dirty_pages_ratelimited 节流。

为什么拷贝前后要 pagefault_disable

iov_iter_copy_from_user_atomic 用原子 kmap 方式拷用户数据,其间不能发生缺页异常(否则原子上下文里 sleep 会死锁)。因此:

  • 进入前 iov_iter_fault_in_readable(i, bytes):预先触发缺页、把用户页读入,保证随后拷贝不会 fault;
  • 拷贝区间 pagefault_disable():禁止在持页锁时取用户页锁,防止"页锁 ↔ 用户页锁"的 AB-BA 死锁。

一句话:用户页和内核页两把锁,绝不交叉持有。先确保用户页就绪,再在关闭 fault 的状态下原子拷贝。

步进示例:写 10KB 数据如何被切成多轮循环

write(fd, buf, 10240),pos=0,每页 4KB。while (iov_iter_count(i)) 会迭代 3 轮:

轮起始 posbyteswrite_begin/write_end 对
104096锁页0,拷入 0…4095
240964096锁页1,拷入 0…4095
381922048锁页2,拷入 0…2047,剩余 2KB 被 zero-fill

第 3 轮是部分写:copied(2048) < len(4096),write_end 走 page_zero_new_buffers 把未写的一半清零再标脏,避免读到旧数据/垃圾。

4.3 write_begin / write_end

write_begin: 页存在(锁页) / 页缺失(分配新页+加入缓存) / 需要块(get_block 分配)
           → 返回锁定页
  → copy_from_user
write_end:  全写(标脏, 更新大小) / 部分写(zero-fill 其余, 标部分脏) / 失败(恢复页状态, 返回错误)
           → 解锁页
  • write_begin 职责:grab_cache_page_write_begin 找/建页,get_block 获取块映射,准备 buffer,锁页
  • write_end 职责:设 BH_Dirty、设 PG_dirty + 全局统计、更新文件大小、解锁
  • 部分写:若 copied < len 且 !PageUptodate,zero-fill 未写部分,仅标已写 buffer 脏

block_write_begin / block_write_end (mm/buffer.c):

  • block_write_begin:grab_cache_page_write_begin;__block_prepare_write(inode,page,start,end,get_block);出错解锁+释放
  • block_write_end:若 copied<len 则 page_zero_new_buffers + __block_commit_write
  • __block_commit_write:循环 buffer,范围内 set_buffer_uptodate + mark_buffer_dirty,清 buffer_new;若 !partial SetPageUptodate
  • __block_prepare_write:需要时创建 buffer、逐 buffer get_block、zero-fill 新/部分块、处理文件空洞

begin/end 成对的三种结局(以一个 4KB 页为例)

进程写这一页:begin 返回锁定的页,随后拷贝,end 收尾。页内 4 个 1KB buffer 的结局有:

结局条件end 的处理
整页写满copied == len,无空洞,整页都有数据全部 buffer 标 Dirty,SetPageUptodate
部分写(已有数据块)copied < len 但页之前已 Uptodate已写 buffer 标 Dirty;未写块保持 Uptodate 不动
部分写(新分配块/空洞)copied < len 且页此前非 Uptodatepage_zero_new_buffers 把未写块清零并标 Dirty,再 SetPageUptodate

示例:ext3 上写 1 字节到一个已存在文件的中间

write(fd, "x", 1),文件此前 4096 字节已读入、页 Uptodate、块已映射:

write_begin(page0)            页在缓存且 Uptodate → 只需 lock_page, 无需新建/分配块
copy_from_user: 把 'x' 写到页0 的第 3000 字节
write_end: block_write_end
   ├─ copied(1) < len(1)? 否, 完整写
   ├─ __block_commit_write: 定位字节3000 所在 buffer(b2), set_buffer_uptodate
   │     + mark_buffer_dirty(b2)   // 只有 b2 标脏
   └─ !partial? 页已 Uptodate → 保持, 不清新块
页状态: 整页 Uptodate, 只有 b2 Dirty → 回写时只写 1KB

这就是"改 1 字节只回写 1 个块"的完整成因,根子就在 write_end 的 buffer 级粒度。


第 5 章 预读机制

状态机:

初始状态 → (首次读) get_init_ra_size → init ra->start/size (通常 4 页/16KB)
  → (顺序命中) get_next_ra_size, 窗口滑动, size 翻倍 (16→32→64KB)
  → (继续) 最大预读 ra->size=ra->ra_pages (128KB/32页)
  → (随机读/缓存命中) 重置

两种类型:

  • 同步预读:页不在缓存,阻塞直到完成,确保当前请求满足
  • 异步预读:由 PG_readahead 标记页触发,后台运行,I/O 与处理重叠

顺序检测:prev_pos 检查(current==prev_pos+1)、窗口边界检查、缓存命中模式。窗口滑动示例:first[0-3]size4;second[4-11]size8;third[12-27]size16;fourth[28-59]size32 最大;之后滑动保持 32。

窗口大小:

static unsigned long get_init_ra_size(unsigned long size, unsigned long max){
    unsigned long newsize = roundup_pow_of_two(size);
    if (newsize <= max/32) newsize *= 4;   // 小: x4
    else if (newsize <= max/4) newsize *= 2;  // 中: x2
    else newsize = max;                      // 大: max
    return newsize;
}
static unsigned long get_next_ra_size(struct file_ra_state *ra, unsigned long max){
    unsigned long cur = ra->size, newsize;
    if (cur < max/16) newsize = 4*cur;      // 快增长
    else newsize = 2*cur;                    // 慢增长
    return min(newsize, max);
}

一次 ondemand_readahead 的完整决策走查

假设 ra_pages=32(128KB),进程读页的序号(index)序列如下。prev_pos 和当前请求 index 共同决定走哪条分支:

请求index      prev_pos   判定          动作
─────────────────────────────────────────────────────────
0             0           首读(未命中)   get_init_ra_size(4)=16KB, 同步预读页0..3
4             3           顺序? current=prev+1 ✓ → 异步预读下一窗
                            get_next_ra_size(4)=8, 预读页4..11
12            11          顺序 ✓         窗口8→16, 预读12..27
28            27          顺序 ✓         窗口16→32(封顶), 预读28..59
60            59          顺序 ✓         size 保持32, 窗口滑动 60..91

随机访问分支(重置) :若序列突然跳变——例如读完页 28 后进程跳到页 100 重新读:

请求index      prev_pos     判定            动作
───────────────────────────────────────────────
100           59           current≠prev+1  非顺序 → 重置
                              get_init_ra_size 重新从 4 页小窗开始

此时预读窗口回到小尺寸重新探测,避免为随机访问浪费带宽——这是内核区分"顺序读 vs 随机读"的核心决策点。

缓存命中分支:若请求页已在缓存(如刚被别处读入),预读引擎会收缩窗口(ra->mmap_miss 或命中调整),避免无谓的预读消耗内存。

两个增长函数合起来说明预读的"先快后慢"策略:小窗口下 4*cur 快速逼近上限,接近上限后 2*cur 平滑,最终稳定在 ra_pages 不再放大。


第 6 章 直接 I/O

流程(O_DIRECT 写):

__generic_file_aio_write → [O_DIRECT] generic_file_direct_write
  → filemap_write_and_wait_range (等脏页)
  → invalidate_inode_pages2_range (失效缓存)
  → mapping->a_ops->direct_IO(WRITE,...)
    → __blockdev_direct_IO → get_user_pages (锁用户页) / get_block (块映射) / submit_bio
  → invalidate_inode_pages2_range (再次失效)

步骤:1 等脏页(一致性);2 失效缓存;3 get_user_pages 锁用户页(防换出/移动);4 get_block 块映射(需要时分配);5 建 bio,用户页<->磁盘传输,等待;6 再次失效缓存让后续读看到新数据。

对齐要求:

if ((pos & blocksize_mask) || (count & blocksize_mask) ||
    ((unsigned long)buf & blocksize_mask)) return -EINVAL;

要求 buf、pos、len 均 % blocksize == 0(典型 512 或 4096)。原因:块设备按块 I/O,DMA 控制器需对齐。

直接 I/O 与缓冲 I/O 的对比示例

同一个 read(fd, buf, 4096),在 O_DIRECT 与普通模式下走向完全不同:

环节缓冲 I/O直接 I/O (O_DIRECT)
用户 buffer任意地址/长度,内核帮你对齐必须 512/4096 对齐,否则 -EINVAL
经过页缓存是,命中即纯拷贝否,完全绕过
用户页处理从内核页拷给用户get_user_pages 锁住用户页,DMA 直接读写
数据一致性延迟写,靠回写立即到磁盘,等完成
预读/合并有无

一次 O_DIRECT 读 8KB 的步骤走查

fd = open("/data.bin", O_RDONLY | O_DIRECT)
read(fd, buf, 8192)              // buf 已 512 对齐, pos=0
└─ generic_file_aio_read
   └─ [O_DIRECT] → filemap_write_and_wait_range(mapping, 0, 8191)  // 等缓存旧数据先落盘
   └─ invalidate_inode_pages2_range(mapping, 0, 1)                 // 丢弃缓存页0,1
   └─ mapping->a_ops->direct_IO(READ, iocb, iov, 0, ...)
      └─ __blockdev_direct_IO
         ├─ get_user_pages: 把 buf 对应的 2 个用户页锁进内存(防换出)
         ├─ get_block: 逻辑块 0..1 → 物理扇区
         └─ submit_bio: 2 个 4KB 页的 bio, 等完成
   └─ invalidate_inode_pages2_range(mapping, 0, 1)                 // 再次失效, 让后续普通读看到新数据

前后两次 invalidate_inode_pages2_range 是一致性屏障:写前失效保证缓存旧内容不残留,写后失效保证后续缓冲读不会读到过期缓存。

优缺点:

  • 优点:省内存(无缓存)、省拷贝(直接)、精确控制、避免双重缓存
  • 缺点:需对齐、同步开销、无预读、无合并

第 7 章 回写机制

脏追踪流程:

mark_buffer_dirty [fs/buffer.c] → set_buffer_dirty(bh)
  → __set_page_dirty(page,mapping) → account_page_dirtied
    → inc_zone_page_state(NR_FILE_DIRTY) + inc_bdi_stat(BDI_RECLAIMABLE)
    → radix_tree_tag_set(PAGECACHE_TAG_DIRTY)
    → __mark_inode_dirty(I_DIRTY_PAGES)

三层:页层(PG_dirty)、基数树层(PAGECACHE_TAG_DIRTY)、全局层(统计)。计数器:NR_FILE_DIRTY、BDI_RECLAIMABLE、NR_WRITEBACK。基数树标签:PAGECACHE_TAG_DIRTY、PAGECACHE_TAG_WRITEBACK、PAGECACHE_TAG_TOWRITE。

balance_dirty_pages 循环:get_dirty_limits → 若 bdi_nr_reclaimable+writeback <= bdi_thresh break → 设 dirty_exceeded → 写回 writeback_inodes_wbc → io_schedule_timeout(pause) 指数退避(1ms…100ms)。

阈值:background_thresh = dirty_ratio×0.5;dirty_thresh = dirty_ratio×total_pages;bdi_thresh 每设备。Sysctl:vm.dirty_ratio (20%)、dirty_background_ratio (10%)、dirty_expire_centisecs (3000=30s)、dirty_writeback_centisecs (500=5s)。

write_cache_pages:确定范围(range_cyclic 环形从上次位置,或显式用于 fsync);按标签批量找脏页(16 页/PAGEVEC_SIZE);每页:锁定、查 mapping、非脏跳过、在写回则按 sync 模式等待、clear_page_dirty_for_io、writepage。

clear_page_dirty_for_io:同步 PTE 脏位(page_mkclean)、清 PG_dirty、更新统计、设 PG_writeback。writeback_control:sync_mode(WB_SYNC_NONE 异步 / WB_SYNC_ALL 同步)、nr_to_write、pages_skipped、range。


第 8 章 内存结构变化

读之前:用户 buffer 空,页缓存空,page_tree index->NULL。
读之后:页缓存填满 “data…” PG_uptodate,PG_dirty=0;radix index->page;struct page mapping=address_space,index,flags=PG_uptodate|PG_locked,_count=2(缓存+引用)。新页进 inactive LRU 尾;再访问移 active;回收优先 inactive。

写之前:页缓存 “old data”,页仍是 PG_uptodate(内容有效)且 PG_dirty=0(未被修改),属于干净的缓存页,仅占用页缓存,回写系统无需关心它。
写之后:“new data”,PG_dirty=1;radix tree 对应的索引项被标上 PAGECACHE_TAG_DIRTY;全局计数 NR_FILE_DIRTY++ / BDI_RECLAIMABLE++。此时页同时是"缓存页"与"待回写页"。

脏页生命周期(写 → 回写的完整变化链):

  copy_from_user 写页缓存         返回
       │                            │
       ▼                            ▼
  PG_dirty=0                    PG_dirty=1
  radix 无 DIRTY 标签            radix 标 DIRTY
  NR_FILE_DIRTY 不变            NR_FILE_DIRTY++
       │                            │
       │                            ▼
       └──────────► 后台触发 writepage
                            PG_dirty=0 (回写完成)
                            NR_FILE_DIRTY--, 转计入 NR_WRITEBACK 后清除
                            radix 去 DIRTY 标签

页-缓冲区关系:对于块设备文件系统,一个页又被细分为多个 buffer_head(buffer.c 中 create_empty_buffers 按块大小切分;4KB 页 + 1KB 块 = 4 个 buffer,通过 b_this_page 串成环形链表)。block_write_begin/block_write_end 实际上按 buffer 粒度跟踪"哪些子块真的被改了"。示例:写页中间 2KB(落在 buffer 1、2):

┌───────┬───────┬───────┬───────┐
│ buf0  │ buf1  │ buf2  │ buf3  │   4 个 1KB buffer
│Dirty=0│Dirty=1│Dirty=1│Dirty=0│
│Uptodate│Uptodate│Uptodate│Uptodate│
└───────┴───────┴───────┴───────┘
   ^       写入区 2KB          ^
buffer 1,2 标 Dirty(回写时需写盘);buffer 0,3 保持 Uptodate(干净)。
后续 `__block_write_full_page` 只把脏 buffer 对应的块写入 bio,避免整页重写。

这就是 Buffer_Head 粒度的意义:部分更新时只回写被修改的子块,减少磁盘写量。


第 9 章 函数调用栈速查

读正常(缓存命中): copy_to_user ← file_read_actor ← do_generic_file_read
                 ← generic_file_aio_read ← do_sync_read ← vfs_read ← sys_read
读页缺失: submit_bio ← submit_bh ← block_read_full_page ← a_ops->readpage ← do_generic_file_read
         (进程在 lock_page 处等 I/O)
读预读: __do_page_cache_readahead ← ra_submit ← ondemand_readahead
        ← page_cache_sync_readahead ← do_generic_file_read
写正常: copy_from_user ← iov_iter_copy_from_user_atomic ← generic_perform_write
       ← generic_file_buffered_write ← __generic_file_aio_write
       ← generic_file_aio_write ← do_sync_write ← vfs_write ← sys_write
写write_begin: __block_prepare_write ← block_write_begin ← a_ops->write_begin ← generic_perform_write
写write_end: __block_commit_write ← block_write_end ← a_ops->write_end ← generic_perform_write
写脏平衡: balance_dirty_pages ← balance_dirty_pages_ratelimited ← generic_perform_write

第 10 章 关键代码路径与性能优化

优化说明
基数树索引O(log N)、稀疏、支持标签
RCU 无锁原子投机引用计数
页预分配预读中预分配页
部分更新is_partially_uptodate 避免完整读
顺序检测窗口增长 4→16→64KB,稳定 128KB
脏节流balance_dirty_pages 指数退避
后台写回pdflush 周期唤醒

节流级别:0-10% 正常;10-20% 后台回写不节流;20-40% 节流;>40% 严重节流。pdflush 后台回写线程:为控制脏页累积,内核维护一个 pdflush 线程池(mm/page-writeback.c、mm/pdflush.c)。它被下面几种方式唤醒:

后台回写的触发时机(dirty_background_ratio=10%):
  ├─ 周期性: pdflush 每 dirty_writeback_centisecs(默认5s) 苏醒
  │      └─ 检查各 bdi 脏计数, 超过占后台阈值 → wb_writeback
  ├─ 前台写路径: balance_dirty_pages 发现超后台阈值 → 唤醒
  └─ 显式: writeback_inodes / sync

pdflush 是 2.6 早期的全局线程池(每个 bdi 共享几个线程),此后演进为 per-bdi flusher 线程(每个 backing_dev_info 一个 flush-8:0 之类的线程)——本文《09_脏页回写机制详解》详述的是 per-bdi 模型,pdflush 是其前身。二者核心逻辑一致:周期苏醒 → 按阈值回写 → 睡眠。

节流级别(本机比例) :

脏页占比行为
0–10%正常写入,不干预
10–20%后台回写启动,写字进程不被节流
20–40%前台节流,写字进程 sleep 协助回写
>40%严重节流,睡眠加长(最多约 1s)

页锁与等待:__lock_page 用 DEFINE_WAIT_BIT(&wait,&page->flags,PG_locked);__wait_on_bit_lock(page_waitqueue(page),...)。页锁场景:readpage(读者)、write_begin(写者)、writepage(回写)、truncate。等待队列哈希:page_waitqueues[hash_ptr(page,…)],多页共享队列;解锁时唤醒所有等待者。