文件读写流程总览(系统调用 → VFS → 页缓存 → 文件系统 → 块设备)
目录
第 1 章 设计原则
Linux 文件读写遵循四大设计原则:
- 缓存优先:所有常规 I/O 都经页缓存,减少磁盘访问
- 延迟写:先写缓存,稍后批量写回磁盘
- 预读:检测顺序访问,预取页面
- 异步回写:后台线程回写避免阻塞
第 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 (拷贝到用户)
- sys_read → vfs_read:检查 fd 有效、FMODE_READ、调用 f_op
- f_op->read 或 do_sync_read:多数 fs 用 generic do_sync_read,把异步 I/O 包装成同步
- generic_file_aio_read:处理 O_DIRECT vs 缓冲
- 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
- vfs_write:检查 FMODE_WRITE、O_APPEND、调用 fs write
- generic_file_aio_write:取 inode->i_mutex,调 __generic_file_aio_write
- __generic_file_aio_write:generic_write_checks(大小、RLIMIT_FSIZE)、file_remove_suid(安全)、file_update_time(mtime/ctime)、选 O_DIRECT vs 缓冲
- 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 轮:
| 轮 | 起始 pos | bytes | write_begin/write_end 对 |
|---|---|---|---|
| 1 | 0 | 4096 | 锁页0,拷入 0…4095 |
| 2 | 4096 | 4096 | 锁页1,拷入 0…4095 |
| 3 | 8192 | 2048 | 锁页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 且页此前非 Uptodate | page_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,…)],多页共享队列;解锁时唤醒所有等待者。