1
// bio: 块 I/O 请求的核心数据结构
2
struct bio {
3
    struct gendisk    *bi_disk;       // 目标磁盘
4
    unsigned int      bi_opf;         // 操作标志（READ/WRITE/SYNC）
5
    struct bvec_iter  bi_iter;        // 迭代器
6
    unsigned short    bi_vcnt;        // bio_vec 数量
7
    struct bio_vec    *bi_io_vec;     // 数据向量数组
8
    bio_end_io_t      *bi_end_io;     // 完成回调
9
    void              *bi_private;    // 私有数据
10
};
11

12
// bio_vec: 描述一个内存段
13
struct bio_vec {
14
    struct page   *bv_page;    // 内存页
15
    unsigned int   bv_len;     // 长度
16
    unsigned int   bv_offset;  // 页内偏移
17
};
18

19
// request: 经 I/O 调度器处理后的请求
20
struct request {
21
    struct request_queue  *q;         // 所属队列
22
    struct bio           *bio;        // 关联的 bio
23
    sector_t              __sector;   // 起始扇区
24
    unsigned int          __data_len; // 数据长度
25
    struct list_head      queuelist;  // 队列链表
26
};

1
# 查看 blk-mq 队列信息
2
cat /sys/block/nvme0n1/queue/nr_requests
3
cat /sys/block/nvme0n1/mq/*/cpu_list
4
ls /sys/block/nvme0n1/mq/
5

6
# 输出示例（4 核 CPU + NVMe SSD）：
7
# 0/  1/  2/  3/
8
# 表示 4 个硬件队列

1
// blk-mq 请求处理流程（简化）
2
void blk_mq_submit_bio(struct bio *bio) {
3
    // 1. 获取当前 CPU 对应的软件队列
4
    struct blk_mq_ctx *ctx = blk_mq_get_ctx(bio);
5

6
    // 2. 获取请求标签（预分配的 request 结构）
7
    struct request *rq = blk_mq_alloc_request(ctx, bio->bi_opf);
8

9
    // 3. 将 bio 附加到 request
10
    blk_mq_bio_to_request(rq, bio);
11

12
    // 4. I/O 调度（如果启用）
13
    if (has_scheduler(q)) {
14
        blk_mq_sched_insert_request(rq);
15
    }
16

17
    // 5. 提交到硬件队列
18
    blk_mq_run_hw_queue(hctx, true);
19
}
20

21
// 完成回调
22
void blk_mq_complete_request(struct request *rq) {
23
    // 1. 调用 bio 的完成回调
24
    rq->bio->bi_end_io(rq->bio);
25

26
    // 2. 释放请求标签
27
    blk_mq_free_request(rq);
28
}

1
# 查看当前 I/O 调度器
2
cat /sys/block/nvme0n1/queue/scheduler
3
# [none] mq-deadline kyber bfq
4

5
# 切换 I/O 调度器
6
echo mq-deadline > /sys/block/nvme0n1/queue/scheduler
7

8
# 数据库推荐：
9
# NVMe SSD → none（最快，SSD 不需要排序）
10
# SATA SSD → mq-deadline（平衡延迟）
11
# HDD      → bfq 或 mq-deadline（减少寻道）

1
// io_uring 核心数据结构
2
struct io_uring {
3
    // 提交队列（SQ）：应用→内核
4
    struct io_uring_sq {
5
        uint32_t *khead;       // 内核写，应用读
6
        uint32_t *ktail;       // 应用写，内核读
7
        uint32_t *kring_mask;
8
        struct io_uring_sqe *sqes;  // 提交队列条目
9
    };
10

11
    // 完成队列（CQ）：内核→应用
12
    struct io_uring_cq {
13
        uint32_t *khead;       // 应用写，内核读
14
        uint32_t *ktail;       // 内核写，应用读
15
        uint32_t *kring_mask;
16
        struct io_uring_cqe *cqes;  // 完成队列条目
17
    };
18
};
19

20
// 提交队列条目（SQE）
21
struct io_uring_sqe {
22
    uint8_t   opcode;     // 操作码（read/write/fsync/...）
23
    uint32_t  fd;         // 文件描述符
24
    uint64_t  off;        // 偏移量
25
    uint64_t  addr;       // 数据缓冲区地址
26
    uint32_t  len;        // 数据长度
27
    uint64_t  user_data;  // 用户数据（完成时返回）
28
};

1
# io_uring vs libaio vs 同步 I/O 性能对比
2
import subprocess
3

4
# 同步 I/O
5
# 每次操作需要 2 次系统调用（write + fsync）
6
# 4KB 写入延迟：~20μs（NVMe）
7

8
# libaio
9
# 批量提交，但需要 O_DIRECT 和缓冲区对齐
10
# 4KB 写入延迟：~12μs（NVMe）
11

12
# io_uring
13
# 零系统调用提交（SQ 环满时才调用 io_uring_enter）
14
# 4KB 写入延迟：~8μs（NVMe）
15
# 批量提交 1000 个请求：~200μs（0.2μs/请求）

1
// 数据库使用 Direct I/O 的原因
2
// 1. 避免 Double Caching
3
//    数据库有自己的 Buffer Pool，如果用 Buffered I/O，
4
//    同一数据在 Buffer Pool 和 Page Cache 中各存一份，浪费内存
5

6
// 2. 控制刷盘时机
7
//    数据库需要精确控制 WAL 先于数据页落盘（fsync 语义）
8
//    Buffered I/O 的后台回写时机不可控
9

10
// 3. 避免预读干扰
11
//    操作系统的预读策略不适合数据库的随机访问模式
12

13
// MySQL InnoDB 配置
14
// innodb_flush_method = O_DIRECT
15
// 绕过 Page Cache，使用 O_DIRECT 写入数据文件和 WAL
16

17
// PostgreSQL 配置
18
// PostgreSQL 默认使用 Buffered I/O
19
// 但 WAL 可以配置：wal_sync_method = open_datasync

1
# MySQL Direct I/O 配置
2
[mysqld]
3
innodb_flush_method = O_DIRECT
4
# O_DIRECT      — 数据文件和 WAL 都用 Direct I/O
5
# O_DSYNC       — WAL 用 O_SYNC 打开
6
# fdatasync     — 默认，用 fdatasync() 刷盘
7

8
# PostgreSQL WAL 配置
9
wal_sync_method = open_datasync   # Linux 默认
10
# fsync          — 使用 fsync()
11
# fdatasync      — 使用 fdatasync()
12
# open_sync      — O_SYNC 打开
13
# open_datasync  — O_DSYNC 打开

1
# 虚拟内存调优
2
# 脏页比例（开始后台回写）
3
echo 10 > /proc/sys/vm/dirty_background_ratio
4
# 脏页比例（开始同步回写）
5
echo 20 > /proc/sys/vm/dirty_ratio
6
# 脏页过期时间（centisecs）
7
echo 3000 > /proc/sys/vm/dirty_writeback_centisecs
8

9
# 块层调优
10
# 队列深度
11
echo 256 > /sys/block/nvme0n1/queue/nr_requests
12
# 预读大小
13
echo 0 > /sys/block/nvme0n1/queue/read_ahead_kb
14

15
# NVMe 调优
16
# 最大硬件队列数
17
cat /sys/block/nvme0n1/queue/nr_hw_queues
18
# 每队列深度
19
cat /sys/block/nvme0n1/queue/queue_depth

1
# 使用 ftrace 跟踪 I/O 路径
2
trace-cmd record -e block:block_rq_issue -e block:block_rq_complete \
3
    -p function_graph -g blk_mq_submit_bio sleep 10
4

5
# 使用 bcc 观察 I/O 延迟
6
# 按进程统计 I/O 延迟
7
/usr/share/bcc/tools/biolatency -p $(pidof mysqld) 1 5
8

9
# 按进程统计 I/O 大小
10
/usr/share/bcc/tools/biosnoop -p $(pidof mysqld)
11

12
# 观察块层统计
13
cat /sys/block/nvme0n1/stat
14
# Field 1: read I/Os
15
# Field 5: write I/Os
16
# Field 9: in-flight I/Os

1
# 使用 perf 分析 I/O 热点
2
perf record -e block:block_rq_issue -a sleep 10
3
perf report
4

5
# 使用 iostat 观察 I/O 统计
6
iostat -x 1
7
# await:    平均 I/O 延迟（ms）
8
# %util:    设备利用率
9
# svctm:    平均服务时间（ms）
10
# avgqu-sz: 平均队列深度
11

12
# 使用 iotop 观察进程 I/O
13
iotop -oP

1
# 查看 blk-mq 统计
2
for q in /sys/block/nvme0n1/mq/*/; do
3
    echo "=== Queue $(basename $q) ==="
4
    cat "$q/cpu_list"
5
    cat "$q/tags"
6
done
7

8
# 查看 I/O 调度器统计
9
cat /sys/block/nvme0n1/mq/0/scheduler