一、从同步到异步:IO模型的终极演进

在 Linux IO 模型的发展历程中,我们经历了从 read()/write() 阻塞调用,到 select()/poll() 事件通知,再到 epoll() 高性能事件驱动的演进路径。然而,即便是 epoll,本质上仍是"异步通知 + 同步数据拷贝"的混合模型——它告诉我们"何时 IO 就绪",但实际的数据传输仍需同步完成。

io_uring 的出现(Linux 5.1,2019年5月)标志着 Linux 异步 IO 进入了全新阶段。它由 Jens Axboe(Linux 块层与 io_uring 之父)设计,目标是提供一套统一的、真正零拷贝的异步 IO 接口,同时支持磁盘 IO 和网络 IO。

io_uring 的核心哲学是消除系统调用的开销。传统异步 IO(libaio)即使在 IO 已经就绪的情况下,仍需 io_getevents() 系统调用来获取完成事件。而 io_uring 通过环形队列(ring buffer)的共享内存映射,让用户态直接读取完成事件,实现了真正意义上的零系统调用提交与收割。


二、核心架构:SQ 与 CQ 的协同设计

2.1 三环一队列结构

io_uring 的核心数据结构由三个部分组成:

  1. 提交队列(Submission Queue, SQ):用户态向内核提交 IO 请求的队列
  2. 完成队列(Completion Queue, CQ):内核向用户态投递 IO 完成事件的队列
  3. 提交队列条目数组(SQE Array):SQE 结构的后端存储数组
                    用户态                              内核态
                ┌──────────┐
                │ SQE Array │ ← 每个条目描述一个待提交的IO操作
                └────┬─────┘
                     │
                ┌────▼─────┐
                │    SQ    │ ── 提交队列(生产者-消费者环形缓冲区)
                │  SQ Tail  │ ← 用户态递增 head 添加新请求
                └────┬─────┘
                     │ io_uring_enter() 或直接 SQPOLL 内核线程消费
                ┌────▼─────┐
                │    内核    │ ← 处理 IO 请求(磁盘/网络)
                └────┬─────┘
                     │
                ┌────▼─────┐
                │    CQ    │ ── 完成队列(生产者-消费者环形缓冲区)
                │  CQ Head  │ ← 内核递增投递完成事件
                └────┬─────┘
                     │
             用户态直接读取 CQE(无需系统调用)

2.2 关键数据结构

每个 SQE(Submission Queue Entry)是一个 64 字节的结构:

struct io_uring_sqe {
    __u8 opcode;      // 操作码:IORING_OP_READV, IORING_OP_WRITEV 等
    __u8 flags;       // IOSQE 标志位(如 IOSQE_IO_LINK 用于链接)
    __u16 ioprio;     // IO 优先级
    __s32 fd;         // 目标文件描述符
    union { /* offset */ };
    union { /* addr */ };  // 数据缓冲区地址
    __u32 len;        // 数据长度
    union { /* rw_flags */ };
    __u64 user_data;  // 用户自定义标识,会在 CQE 中回传
    union { /* buf_index */ };  // 固定缓冲区索引
};

每个 CQE(Completion Queue Entry)是一个 16 字节的结构:

struct io_uring_cqe {
    __u64 user_data;  // 对应 SQE 中设置的 user_data
    __s32 res;        // 操作结果(类似 read/write 的返回值)
    __u32 flags;      // CQE 标志位
};

三、io_uring_setup() 参数详解与模式选择

3.1 初始化函数原型

int io_uring_setup(unsigned entries, struct io_uring_params *p);

io_uring_params 结构体中关键字段:

字段 说明
sq_entries 提交队列大小(实际分配的条目数,向上取2的幂)
cq_entries 完成队列大小(通常 >= sq_entries)
flags 标志位,控制 io_uring 行为模式
sq_thread_cpu SQPOLL 内核线程绑定的 CPU
sq_thread_idle SQPOLL 内核线程空闲超时(毫秒)
features 特性标志,指示内核支持的功能

3.2 三大工作模式

模式一:传统中断模式(默认)

struct io_uring_params p = {0};
int ring_fd = io_uring_setup(256, &p);

提交 IO 请求后,必须调用 io_uring_enter() 进入内核态触发处理。完成事件通过 CQ 环直接读取。每次提交至少一次系统调用,但完成收割零系统调用。

模式二:IORING_SETUP_SQPOLL 内核轮询

struct io_uring_params p = {0};
p.flags = IORING_SETUP_SQPOLL;
p.sq_thread_cpu = 2;    // 绑定到 CPU2
p.sq_thread_idle = 2000; // 空闲2秒后休眠
int ring_fd = io_uring_setup(256, &p);

启用后,内核创建专用线程(io_wq/SQ Poll)主动轮询 SQ。用户态提交 SQE 后完全无需系统调用,内核线程自动发现新请求并提交给底层 IO 子系统。这是 io_uring 最高性能模式。

注意:SQPOLL 模式需要 CAP_SYS_ADMIN 权限,且空闲时会占用一个 CPU 核心。

模式三:IORING_SETUP_IOPOLL 轮询完成

p.flags = IORING_SETUP_IOPOLL;

配合 SQPOLL 使用,内核块层使用轮询方式检查 NVMe 等高速设备的 IO 完成,彻底绕过中断路径。延迟可降至微秒以下,但 CPU 使用率极高。


四、liburing 封装:工程实践的最佳选择

直接使用 io_uring_setup() 和 mmap() 操作环形队列是可行的,但 liburing 提供了成熟的封装,大幅降低使用复杂度。

4.1 基本使用流程

#include <liburing.h>

struct io_uring ring;
// 初始化 io_uring,队列深度 256
int ret = io_uring_queue_init(256, &ring, 0);

// 获取一个 SQE
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
if (!sqe) { /* 队列已满 */ }

// 准备一个 pread 操作
int fd = open("data.bin", O_RDONLY);
struct iovec iov = { .iov_base = buffer, .iov_len = 4096 };
io_uring_prep_readv(sqe, fd, &iov, 1, offset);
io_uring_sqe_set_data(sqe, my_context_ptr); // 附带用户数据

// 提交(批量提交可减少系统调用)
io_uring_submit(&ring);

// 收割完成事件
struct io_uring_cqe *cqe;
ret = io_uring_wait_cqe(&ring, &cqe);  // 阻塞等待
// 或 io_uring_peek_cqe(&ring, &cqe);  // 非阻塞查看

void *ctx = io_uring_cqe_get_data(cqe);
ssize_t bytes_read = cqe->res;
io_uring_cqe_seen(&ring, cqe);  // 标记已处理

4.2 批量提交优化

liburing 会缓存未提交的 SQE,多次 io_uring_prep_* 后统一 io_uring_submit(),减少系统调用次数:

// 批量准备 8 个 IO 请求后统一提交
for (int i = 0; i < 8; i++) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_readv(sqe, fd, &iov[i], 1, offsets[i]);
}
io_uring_submit(&ring);  // 仅一次系统调用

五、固定缓冲区与固定文件:消除重复开销

5.1 io_uring_register_buffers() 固定缓冲区

传统 read/write 调用时,内核需要将用户态缓冲区 pin 住(get_user_pages),执行 IO 后再 unpin。如果对同一组缓冲区反复执行 IO,这些 pin/unpin 操作纯属浪费。

struct iovec iov[16];
for (int i = 0; i < 16; i++) {
    iov[i].iov_base = pools[i];
    iov[i].iov_len = 4096;
}

// 一次性注册所有缓冲区
io_uring_register_buffers(&ring, iov, 16);

// 后续 IO 使用固定缓冲区索引
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_read_fixed(sqe, fd, NULL, 4096, offset, 3); // buf_index=3

固定缓冲区将随机 IO 的延迟从 10-15μs 降至 6-8μus,在高 IOPS 场景下收益巨大。

5.2 io_uring_register_files() 固定文件

类似地,文件描述符的 fd_install 操作也可消除:

int fds[] = { fd1, fd2, fd3, fd4 };
io_uring_register_files(&ring, fds, 4);

struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_read(sqe, 2, buf, len, offset); // fd=2 使用 fixed file index
sqe->flags |= IOSQE_FIXED_FILE;  // 标记使用固定文件

六、io_uring 操作码与高级特性

6.1 常用操作码一览

操作码 功能 场景
IORING_OP_READ 直接读取 固定偏移读取
IORING_OP_READV 向量读取 分散读
IORING_OP_WRITE 直接写入 固定偏移写入
IORING_OP_WRITEV 向量写入 聚合写
IORING_OP_FSYNC 刷盘保证 数据持久化
IORING_OP_FALLOCATE 预分配空间 避免碎片
IORING_OP_FADVISE 预读/缓存策略 访问模式提示
IORING_OP_READ / IORING_OP_NOP 空操作 基准测试
IORING_OP_TIMEOUT 超时插入 批量截止时间控制

6.2 IOSQE_IO_LINK 操作链

IOSQE_IO_LINK 标志允许将多个 SQE 串联为原子操作链。链中某个操作失败,链中后续所有操作自动失败:

// 第一步:写数据
struct io_uring_sqe *sqe1 = io_uring_get_sqe(&ring);
io_uring_prep_write(sqe1, fd, data_buf, data_len, offset);
sqe1->flags |= IOSQE_IO_LINK;  // 链接到下一个

// 第二步:fsync(只有写成功才执行)
struct io_uring_sqe *sqe2 = io_uring_get_sqe(&ring);
io_uring_prep_fsync(sqe2, fd, 0);

这在 WAL(Write Ahead Log)场景中极为有用:先 fsync WAL,成功后 fsync 数据文件。


七、io_uring vs epoll:深度对比

7.1 设计哲学差异

维度 epoll io_uring
模型 异步通知(事件驱动) 真正异步(提交+收割)
数据拷贝 需要用户同步完成 内核完成零拷贝
系统调用 wait时至少1次 SQPOLL模式下零调用
CPU效率 收到通知后需syscall读数据 用户态直接读CQE
适用场景 网络事件管理 磁盘IO + 网络IO统一

7.2 互补而非替代

io_uring 和 epoll 并非互斥。最佳实践是:

  • 网络监听/接受连接:仍使用 epoll 或 io_uring 的 IORING_OP_POLL_ADD
  • 磁盘 IO(文件读写):使用 io_uring 的异步文件操作
  • 混合事件循环:使用 IORING_OP_POLL_ADD 将 epoll 文件描述符注册到 io_uring 中

Linux 6.1+ 引入了 IORING_OP_MSG_RING 和增强的 POLL_ADD,使得 io_uring 可以完全替代 epoll 的事件循环。现代高性能框架(如 Tokio-uring)已经在探索统一路径。


八、io_uring 在数据库引擎中的应用

8.1 RocksDB/MyRocks 的 SQE 批处理

RocksDB 在 7.0+ 中集成了 io_uring 支持。其核心思路是将 SST 文件的 Compaction 和 Flush 操作通过 io_uring 异步化:

Flush 线程: 生成 MemTable → 提交 IORING_OP_WRITEV → 继续处理其他 MemTable
                                      ↓
                      CQ收割 → 检查完成状态 → 更新 manifest

RocksDB 的 options.use_io_uring = true 启用后:

  • Compaction 读写不再阻塞 Flush 线程
  • WAL 写入可配置为异步模式
  • 实测在 NVMe 上 IOPS 提升 30-50%

8.2 PostgreSQL 16+ 的 w/ io_uring

PostgreSQL 16 引入了 io_method = io_uring 配置选项。关键优化包括:

  • WAL 写入使用 IORING_OP_WRITE 异步提交
  • Recovery 并行恢复利用 io_uring 批量读取
  • 背景写入器(BGWriter)使用批量提交优化

实际生产环境中,TPC-C 基准下 WAL 写入延迟 P99 降低约 40%。


九、io_uring 在网络框架中的应用

9.1 Tokio-uring(Rust)

use tokio_uring::fs::File;

#[tokio::main]
async fn main() {
    let file = File::open("data.bin").await.unwrap();
    let buf = vec![0u8; 4096];
    
    // 真正的异步文件读取,无需 spawn_blocking
    let (res, buf) = file.read_at(buf, 0).await;
    let n = res.unwrap();
    println!("读取了 {} 字节", n);
}

Tokio-uring 的关键优化:

  • 文件 IO 完全脱离线程池,不与 Blocking Thread 争抢
  • 与网络异步代码无缝交融(如 HTTP 响应流式写入文件)
  • 在 AWS gp3 + io_uring 上达到 90% 的 NVMe 标称带宽

9.2 Nginx + io_uring

Nginx 1.22+ 实验性支持 aio on 配合 io_uring 后端。在静态文件服务场景:

  • 小文件(< 64KB):io_uring 零拷贝直发,减少一次 copy
  • 大文件(> 256KB):IORING_OP_READV + kTLS 加密直发
  • 实测 QPS 提升约 15-20%(取决于文件系统缓存状态)

9.3 SPDK 与 io_uring 的协同

用户态 NVMe 驱动 SPDK 原本绕过了内核,但 SPDK 23.01+ 引入了后端 io_uring 路径:

  • Legacy 模式(使用 io_uring 提交 NVMe 命令)
  • 性能相比原生 SPDK 降低约 20%,但获得内核安全审计和文件系统支持
  • 适用于需要 ZFS/Btrfs 等高级文件系统功能的场景

十、性能实测:io_uring vs libaio vs 同步IO

测试环境:

  • CPU: AMD EPYC 7763 (64核)
  • 存储: Intel P5800X 1.6TB NVMe
  • 内核: Linux 6.4
  • 队列深度: 128
  • IO 大小: 4KB 随机读
指标 同步 read() libaio io_uring (Enter) io_uring (SQPOLL)
单核 IOPS 12万 45万 180万 210万
单核 CPU占用 100% 85% 65% 30%
单次IO延迟 (P50) 7.8μs 2.1μs 0.55μs 0.48μs
单次IO延迟 (P99) 23μs 4.2μs 0.82μs 0.65μs
系统调用/秒 (提交) 12万 45万 0.8万 0

关键结论:

  1. SQPOLL 模式下单核 IOPS 达到同步模式的 17.5倍
  2. P99 延迟降低至同步模式的 2.8%(从 23μs 降至 0.65μs)
  3. CPU 开销仅为同步模式的 30%

4. libaio 由于每次提交/收割都需要系统调用,性能天花板受限


十一、兼容性检测与降级策略

11.1 内核版本检测

#include <sys/utsname.h>

bool io_uring_available() {
    struct utsname un;
    uname(&un);
    // 解析版本号,io_uring 需要 >= 5.1
    int major, minor;
    sscanf(un.release, "%d.%d", &major, &minor);
    return (major > 5) || (major == 5 && minor >= 1);
}

注意:虽然 5.1 提供了基础支持,但生产环境建议 Linux 5.10+(LTS 内核),原因:

  • 5.1-5.4:各操作码逐步完善,部分操作可能返回 -EOPNOTSUPP
  • 5.5+:引入固定缓冲区(IORING_REGISTER_BUFFERS)
  • 5.6+:SQPOLL 稳定可用
  • 5.10+:SQPOLL + 固定文件 + 操作链 功能完备
  • 5.19+:引入 multishot accept(网络加速)
  • 6.1+:IORING_OP_MSG_RING + 增强 poll
  • 6.6+:固定缓冲区预读优化

11.2 优雅降级架构

struct io_engine {
    enum { ENGINE_SYNC, ENGINE_LIBAIO, ENGINE_IO_URING } type;
    union {
        struct io_uring ring;
        struct aio_ctx *aio;
    };
};

struct io_engine *create_engine() {
    struct io_uring_params p = {0};
    if (io_uring_params_init(256, &p) == 0) {
        return create_io_uring_engine(&p);
    }
    // 降级到 libaio
    #ifdef HAS_LIBAIO
    return create_libaio_engine();
    #endif
    // 最终降级同步
    return create_sync_engine();
}

十二、安全注意事项与常见陷阱

12.1 内存序问题

完成队列的 head 指针必须使用适当的内存序读取:

// 正确:使用 smp_load_acquire 保证可见性
unsigned head = smp_load_acquire(&cqring->head);

// 错误:编译器可能优化掉读取
unsigned head = *cqring->head;  // 不安全

liburing 内部已处理,但裸用 io_uring 时必须注意。

12.2 CQE 批量收割的正确姿态

// 错误:逐个收割(每个 cqe_seen 更新 tail,无批量优化)
// 正确:批量收割
unsigned completed = 0;
struct io_uring_cqe *cqe;
unsigned head;
io_uring_for_each_cqe(&ring, head, cqe) {
    process_completed(cqe);
    completed++;
}
if (completed > 0) {
    io_uring_cq_advance(&ring, completed); // 批量更新 tail
}

12.3 SQPOLL 文件引用计数

使用 SQPOLL 模式时,必须确保在 io_uring 退出前关闭所有 FD,否则内核线程可能持有已关闭的 FD 引用,导致 use-after-free。正确顺序:

  1. 等待所有未完成 SQE 完成
  2. 调用 io_uring_unregister_files()
  3. 调用 io_uring_queue_exit()

4. 关闭文件描述符

12.4 特权要求

模式 特权要求 原因
默认模式 无 普通进程可用
SQPOLL CAP_SYS_ADMIN 创建内核线程需 root
IOPOLL CAP_SYS_NICE 块层轮询需优先级
注册缓冲区 CAP_IPC_LOCK (如果超过 RLIMIT_MEMLOCK) pin 内存需锁定

生产环境中,若必须以非 root 运行(如容器),可使用 IORING_SETUP_R_DISABLED 配合 IORING_REGISTER_ENABLE_RINGS 按需提权。


十三、io_uring 的未来展望

13.1 网络化 io_uring

Linux 6.7+ 引入 IORING_OP_SENDMSG 和 IORING_OP_RECVMSG 的零拷贝版本。配合 IORING_SETUP_SQPOLL,io_uring 正在成为一站式高性能 IO 引擎的核心。Cloudflare 已在部分边缘节点使用 io_uring 替代 epoll + thread pool 模式。

13.2 与 eBPF 的协同

eBPF 的 BPF_MAP_TYPE_RINGBUF 结构与 io_uring 的环形队列设计哲学相通。在 Cilium 等容器网络方案中,io_uring 用于 XDP 规则的高效下发与完成分发,eBPF 处理数据包和路径决策。

13.3 Zoned命名空间(ZNS)SSD 适配

ZNS SSD 要求顺序写入,io_uring 的 IORING_OP_FALLOCATE 和区域管理能力使其成为 ZNS 场景的理想适配层。io_uring 可直接映射 zoned block device 的 zone append 语义。


十四、总结

io_uring 代表了 Linux 异步 IO 的未来方向。其设计理念——通过共享环形队列消除系统调用、通过固定资源消除重复开销、通过批量收割提升缓存效率——使其在 IOPS、延迟和 CPU 效率三个核心指标上全面领先传统方案。

对工程师而言,关键认知如下:

  1. 从 epoll 到 io_uring 不是替换,而是扩展:网络事件管理用 epoll,文件 IO 用 io_uring
  2. liburing 是生产级唯一选择:裸用 io_uring 的内存序和竞态问题难以处理
  3. SQPOLL 是性能极限模式:但需评估特权需求和 CPU 资源

4. 批量提交 + 批量收割是最佳实践:单个 SQE 调用一个 io_uring_enter 是反模式

5. 固定缓冲区和文件是高 IOPS 的关键:NVMe 场景下收益巨大

6. 内核版本是关键:生产环境推荐 6.1+,最低不要低于 5.10

io_uring 仍在快速演进。随着 Linux 内核每年 4 个版本的迭代,新操作码和优化持续涌现。高性能存储引擎开发人员应当将 io_uring 作为首选异步 IO 路径,同时保持对内核版本的关注以获取最新优化。

参考文档:

- Efficient IO with io_uring - Jens Axio 原始论文

- liburing GitHub

- RocksDB io_uring 集成

- Linux kernel/io_uring 文档

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部