1
// include/linux/buffer_head.h（简化）
2
struct buffer_head {
3
    unsigned long b_state;         /* 缓冲区状态 */
4
    struct buffer_head *b_this_page; /* 同一页中的缓冲区链表 */
5
    struct page *b_page;           /* 所属的 page */
6
    sector_t b_blocknr;            /* 磁盘块号 */
7
    size_t b_size;                 /* 块大小 */
8
    char *b_data;                  /* 数据指针 */
9
    struct block_device *b_bdev;   /* 块设备 */
10
};

1
// 1. 系统调用入口
2
SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
3
    → ksys_read()
4
        → vfs_read()
5
            → file->f_op->read_iter()  // 通常指向 generic_file_read_iter
6

7
// 2. 通用读路径
8
generic_file_read_iter()
9
    → generic_file_buffered_read()
10
        → page_cache_sync_readahead()   // 同步预读：确保目标页在缓存中
11

12
// 3. 在 Page Cache 中查找页
13
page_cache_sync_readahead()
14
    → page_cache_ra_order()
15
        → read_pages()
16
            → mapping->a_ops->readpages()  // 文件系统实现，提交 bio
17

18
// 4. 等待 I/O 完成
19
// 如果页是锁定的（正在读入），进程会等待：
20
lock_page_killable(page)
21
    → __wait_on_bit_lock(page_waitqueue(page), ...)
22

23
// 5. 拷贝数据到用户空间
24
copy_page_to_iter(page, offset, size, iter)
25
    → copy_page_to_iter_pipe() 或 copy_to_iter()

1
// mm/readahead.c（简化逻辑）
2
void page_cache_ra_order(struct readahead_control *ractl,
3
                         struct file_ra_state *ra, unsigned int order)
4
{
5
    // 计算预读窗口大小
6
    // 初始预读：读取 4 页（默认值）
7
    // 后续预读：根据历史模式动态调整，最大可到 128 页（512KB）
8

9
    // 关键参数：
10
    // ra->start      - 预读起始位置
11
    // ra->size       - 预读页数
12
    // ra->async_size - 异步预读部分大小
13
    // ra->prev_pos   - 上次读位置（用于检测顺序/随机）
14
}

1
// 1. 系统调用入口
2
SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf, size_t, count)
3
    → ksys_write()
4
        → vfs_write()
5
            → file->f_op->write_iter()  // 通常指向 generic_file_write_iter
6

7
// 2. 通用写路径
8
generic_file_write_iter()
9
    → __generic_file_write_iter()
10
        → generic_perform_write()
11

12
// 3. 逐页写入
13
generic_perform_write()
14
    → a_ops->write_begin()     // 准备目标页（可能需要从磁盘读取）
15
    → copy_from_iter()         // 从用户空间拷贝数据到页缓存
16
    → a_ops->write_end()       // 完成写入，标记页为脏
17

18
// 4. 标记脏页
19
// write_end() 内部调用：
20
__set_page_dirty_buffers() 或 __set_page_dirty()
21
    → 设置 PG_dirty 标志
22
    → 将页加入 inode 的脏页链表 (mapping->i_pages with dirty tag)
23
    → 唤醒后台写回线程

1
# 查看当前写回参数
2
cat /proc/sys/vm/dirty_ratio
3
cat /proc/sys/vm/dirty_background_ratio
4
cat /proc/sys/vm/dirty_writeback_interval
5

6
# 也可以用字节而非百分比设置
7
cat /proc/sys/vm/dirty_bytes
8
cat /proc/sys/vm/dirty_background_bytes

1
// fs/fs-writeback.c（简化）
2
static long wb_writeback(struct bdi_writeback *wb,
3
                         struct wb_writeback_work *work)
4
{
5
    while (1) {
6
        // 1. 从 inode 脏页列表中收集脏页
7
        // 2. 调用 mapping->a_ops->writepages() 提交写 I/O
8
        // 3. 等待 I/O 完成
9
        // 4. 清除脏标记
10

11
        if (work->nr_pages <= 0)
12
            break;
13
        if (wb->dirty_exceeded)
14
            break;
15
        // ...
16
    }
17
}

1
干净页 (clean)
2
    │
3
    │ write() 修改
4
    ▼
5
脏页 (dirty) ──── 加入 inode 脏页链表
6
    │
7
    │ 写回线程选中
8
    ▼
9
写回中 (writeback) ──── 设置 PG_writeback 标志
10
    │
11
    │ I/O 完成
12
    ▼
13
干净页 (clean) ──── 清除 PG_dirty 和 PG_writeback

1
// 打开文件时指定 O_DIRECT
2
int fd = open("data.bin", O_RDONLY | O_DIRECT);
3

4
// 以下三个值必须对齐到逻辑块大小（通常 512 字节或 4KB）：
5
// 1. 用户缓冲区地址（必须页对齐）
6
// 2. 文件偏移量（必须是块大小的整数倍）
7
// 3. 读取长度（必须是块大小的整数倍）
8

9
// 使用 posix_memalign 分配对齐的缓冲区
10
void *buf;
11
posix_memalign(&buf, 4096, 4096);
12
pread(fd, buf, 4096, 0);  // 偏移 0，长度 4096，均对齐

1
// fs/direct-io.c（简化流程）
2
// 当文件以 O_DIRECT 打开时，read/write 路径会走 direct I/O 分支
3

4
generic_file_read_iter()
5
    → if (O_DIRECT): filemap_write_and_wait_range()  // 先写回该范围的脏页
6
                      ->direct_IO()
7

8
generic_file_write_iter()
9
    → if (O_DIRECT): invalidate_inode_pages2_range() // 使该范围的缓存失效
10
                      ->direct_IO()
11

12
// direct_IO 最终调用：
13
// mapping->a_ops->direct_IO()
14
// ext4 实现: ext4_direct_IO() → iomap_dio_rw()

1
初始状态 (无预读历史)
2
    │
3
    │ 第一次缓存未命中
4
    ▼
5
同步预读 (初始窗口 = 4 页)
6
    │
7
    │ 顺序读命中预读窗口
8
    ▼
9
异步预读 (窗口逐步增大: 4→8→16→...→128 页)
10
    │
11
    │ 继续顺序读
12
    ▼
13
稳态预读 (窗口 = ra_pages，通常 128 页 = 512KB)
14
    │
15
    │ 检测到随机读
16
    ▼
17
禁用预读 (窗口 = 0 或 1 页)

1
# 查看块设备的预读设置（单位：512 字节扇区数）
2
cat /sys/block/sda/queue/read_ahead_kb
3
# 通常是 128 (KB)，即 256 个扇区

1
# 查看 Page Cache 占用（Cached 列）
2
cat /proc/meminfo | grep -E "Cached|Buffers|Dirty|Writeback"
3
# 输出示例：
4
# Cached:          8234567 kB    ← Page Cache 大小
5
# Buffers:          123456 kB    ← Buffer Cache（元数据缓存）
6
# Dirty:             12345 kB    ← 脏页大小
7
# Writeback:             0 kB    ← 正在写回的页
8

9
# 用 free 命令更直观地查看
10
free -h
11
#               total   used   free   shared  buff/cache  available
12
# Mem:          16Gi   6.2Gi  1.5Gi  256Mi   8.3Gi       9.1Gi
13
#                                    ↑ buff/cache 包含 Page Cache

1
# 安装 vmtouch
2
sudo apt install vmtouch   # Debian/Ubuntu
3
# 或从源码编译：https://github.com/hoytech/vmtouch
4

5
# 查看文件在 Page Cache 中的缓存情况
6
vmtouch /var/log/syslog
7
# 输出示例：
8
#            Files: 1
9
#      Directories: 0
10
#   Resident Pages: 245/1024  (957K/3M  23.9%)
11
#            Elapsed: 0.000345 seconds
12
# ↑ 23.9% 的页面在 Page Cache 中
13

14
# 将文件全部加载到 Page Cache
15
vmtouch -t /var/log/syslog
16

17
# 将文件从 Page Cache 中驱逐
18
vmtouch -e /var/log/syslog

1
#  警告：生产环境慎用！清除 Page Cache 会导致性能骤降
2

3
# 清除 Page Cache（仅干净页）
4
echo 1 > /proc/sys/vm/drop_caches
5

6
# 清除 dentry 和 inode 缓存
7
echo 2 > /proc/sys/vm/drop_caches
8

9
# 清除 Page Cache + dentry + inode 缓存
10
echo 3 > /proc/sys/vm/drop_caches
11

12
# 注意：drop_caches 只会清除干净页（非脏页）
13
# 如果有脏页，需要先 sync 或等待写回完成
14
sync && echo 3 > /proc/sys/vm/drop_caches

1
# 普通 buffered I/O 写入（经过 Page Cache）
2
dd if=/dev/zero of=/tmp/buffered.bin bs=4K count=10000
3
# 观察写入速度和 Page Cache 变化
4

5
# Direct I/O 写入（绕过 Page Cache）
6
dd if=/dev/zero of=/tmp/direct.bin bs=4K count=10000 oflag=direct
7
# 对比速度差异
8

9
# Direct I/O 读取
10
dd if=/tmp/direct.bin of=/dev/null bs=4K count=10000 iflag=direct
11

12
# 测试不对齐的 Direct I/O（会失败）
13
dd if=/dev/zero of=/tmp/bad_direct.bin bs=1000 count=10 oflag=direct
14
# dd: error writing '/tmp/bad_direct.bin': Invalid argument

1
# 查看当前脏页参数
2
cat /proc/sys/vm/dirty_ratio            # 默认 20
3
cat /proc/sys/vm/dirty_background_ratio  # 默认 10
4
cat /proc/sys/vm/dirty_writeback_centisecs  # 默认 500（5秒）
5
cat /proc/sys/vm/dirty_expire_centisecs     # 默认 3000（30秒）
6

7
# 临时调低脏页比例（更频繁地写回，减少断电数据丢失风险）
8
sudo sysctl -w vm.dirty_ratio=10
9
sudo sysctl -w vm.dirty_background_ratio=5
10

11
# 临时调高脏页比例（减少写回频率，提升写入吞吐，但断电风险更大）
12
sudo sysctl -w vm.dirty_ratio=40
13
sudo sysctl -w vm.dirty_background_ratio=20
14

15
# 观察脏页变化
16
watch -n 1 "cat /proc/meminfo | grep -E 'Dirty|Writeback'"

1
# 编写一个简单的测试程序
2
cat > /tmp/test_fsync.c << 'EOF'
3
#include <fcntl.h>
4
#include <unistd.h>
5
#include <string.h>
6

7
int main() {
8
    int fd = open("/tmp/fsync_test.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
9
    write(fd, "hello world\n", 12);
10
    fsync(fd);       // 数据 + 元数据
11
    write(fd, "hello again\n", 12);
12
    fdatasync(fd);   // 仅数据
13
    close(fd);
14
    return 0;
15
}
16
EOF
17

18
gcc -o /tmp/test_fsync /tmp/test_fsync.c
19

20
# 用 strace 追踪
21
strace -e trace=write,fsync,fdatasync,sync /tmp/test_fsync
22
# 输出：
23
# write(3, "hello world\n", 12)  = 12
24
# fsync(3)                        = 0
25
# write(3, "hello again\n", 12)  = 12
26
# fdatasync(3)                    = 0

1
# 安装 liburing
2
sudo apt install liburing-dev
3

4
# 编写 io_uring vs 普通 read 的基准测试
5
cat > /tmp/io_uring_bench.c << 'EOF'
6
#include <stdio.h>
7
#include <fcntl.h>
8
#include <unistd.h>
9
#include <time.h>
10
#include <liburing.h>
11

12
#define FILE_SIZE (64 * 1024 * 1024)  // 64MB
13
#define BLOCK_SIZE 4096
14

15
double now_sec() {
16
    struct timespec ts;
17
    clock_gettime(CLOCK_MONOTONIC, &ts);
18
    return ts.tv_sec + ts.tv_nsec * 1e-9;
19
}
20

21
int main() {
22
    int fd = open("/tmp/testdata.bin", O_RDONLY | O_DIRECT);
23
    if (fd < 0) { perror("open"); return 1; }
24

25
    void *buf;
26
    posix_memalign(&buf, 4096, BLOCK_SIZE);
27

28
    // === 普通 pread ===
29
    double t1 = now_sec();
30
    for (off_t off = 0; off < FILE_SIZE; off += BLOCK_SIZE) {
31
        pread(fd, buf, BLOCK_SIZE, off);
32
    }
33
    double t2 = now_sec();
34
    printf("pread:     %.3f 秒 (%.1f MB/s)\n", t2 - t1, FILE_SIZE / (t2 - t1) / 1e6);
35

36
    // === io_uring ===
37
    struct io_uring ring;
38
    io_uring_queue_init(256, &ring, 0);
39

40
    double t3 = now_sec();
41
    off_t offset = 0;
42
    int pending = 0;
43

44
    while (offset < FILE_SIZE || pending > 0) {
45
        // 提交请求
46
        while (offset < FILE_SIZE && pending < 256) {
47
            struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
48
            io_uring_prep_read(sqe, fd, buf, BLOCK_SIZE, offset);
49
            io_uring_sqe_set_data64(sqe, offset);
50
            offset += BLOCK_SIZE;
51
            pending++;
52
        }
53
        io_uring_submit(&ring);
54

55
        // 收割完成事件
56
        struct io_uring_cqe *cqe;
57
        while (pending > 0) {
58
            if (io_uring_peek_cqe(&ring, &cqe) < 0) break;
59
            io_uring_cqe_seen(&ring, cqe);
60
            pending--;
61
        }
62
    }
63
    double t4 = now_sec();
64
    printf("io_uring:  %.3f 秒 (%.1f MB/s)\n", t4 - t3, FILE_SIZE / (t4 - t3) / 1e6);
65

66
    io_uring_queue_exit(&ring);
67
    close(fd);
68
    free(buf);
69
    return 0;
70
}
71
EOF
72

73
gcc -o /tmp/io_uring_bench /tmp/io_uring_bench.c -luring
74

75
# 先创建测试文件
76
dd if=/dev/urandom of=/tmp/testdata.bin bs=1M count=64
77

78
# 运行基准测试
79
/tmp/io_uring_bench

1
# 查看写回线程
2
ps -ef | grep -E "flush|kworker.*writeback"
3

4
# 使用 perf 追踪写回事件
5
sudo perf record -e 'writeback:*' -a sleep 10
6
sudo perf script
7

8
# 或使用 bpftrace 实时观察
9
sudo bpftrace -e '
10
tracepoint:writeback:writeback_dirty_page {
11
    printf("脏页: ino=%lu index=%lu\n", args->ino, args->index);
12
}
13
tracepoint:writeback:writeback_mark_inode_dirty {
14
    printf("标记脏 inode: ino=%lu\n", args->ino);
15
}
16
'