引言:为什么需要 io_uring?

在传统 Linux I/O 编程中,开发者面临一个根本性的困境:阻塞式 I/O 浪费 CPU,非阻塞式 I/O 需要复杂的事件循环,而 POSIX AIO (libaio) 在功能和性能上都存在严重缺陷。Linux 5.1 引入的 io_uring 彻底改变了这一局面,它不仅仅是一个新的系统调用,而是一套全新的、高效的异步 I/O 框架,正在重新定义 Linux 高性能 I/O 的标准。

io_uring 由 Jens Axboe(Linux 内核块设备层维护者)设计,核心思想是通过共享内存环形缓冲区消除系统调用开销,实现真正的零拷贝异步 I/O。从 Linux 5.1 到 6.x,io_uring 经历了爆炸式演进:支持缓冲区注册、多 shot 轮询、固定文件描述符、io_uring 自身实例间通信、以及最新的 "io_uring 新订阅机制(IORING_REGISTER_RING_FDS 等)"。

一、io_uring 架构总览

1.1 核心数据结构:三个环形缓冲区

io_uring 的架构基于生产者-消费者模型,使用三个环形缓冲区在用户态和内核态之间高效传递信息:

  • 提交队列(Submission Queue, SQ):用户态生产者 → 消费者是内核。存放待执行的 I/O 请求(SQE, Submission Queue Entry)。
  • 完成队列(Completion Queue, CQ):内核生产者 → 消费者是用户态。存放已完成的 I/O 结果(CQE, Completion Queue Entry)。
  • 提交队列条目数组(SQE Array):实际存放 SQE 的连续内存,SQ 中的条目是索引指针。

1.2 零系统调用模式

io_uring 的标志性特性是在适当配置下可以完全不触发系统调用:用户态通过共享内存直接查看 CQ 中的完成事件,当 CQE 出现在 CQ tail 时,用户态线程通过内存屏障即可直接读取结果,无需syscall。

io_uring 提供了一个 flags 标志 IORING_SETUP_SQPOLL,能让内核线程轮询 SQ 并自动提交 I/O 请求:

struct io_uring_params p = {0};
p.flags = IORING_SETUP_SQPOLL;
p.sq_thread_idle = 2000; // 空闲 2s 后内核线程休眠
io_uring_queue_init_params(QUEUE_DEPTH, &ring, &p);

二、io_uring 新订阅机制

2.1 什么是订阅机制?

Linux 6.5+ 为 io_uring 引入了 "io_uring 实例间订阅"(Inter-instance subscription),允许一个 io_uring 实例订阅另一个实例的事件。这种机制使得复杂的多线程 I/O 场景可以被优雅地编排:

IORING_REGISTER_RING_FDS:注册目标 io_uring 的文件描述符。调用后,当前 ring 可以感知目标 ring 上的新提交。

IORING_REGISTER_RING_FDS 的变种:包含 IORING_REGISTER_RING_FDS 和 IORING_REGISTER_RING_FDS_OFFSET 两个偏移量操作。

2.2 订阅工作流

典型的订阅式工作流:

// Ring A 作为消费者提交订阅
struct io_uring ring_a, ring_b;
// 初始化两个 ring ...

// Ring A 注册对 Ring B 的订阅
io_uring_register_ring_fds(&ring_a, &ring_b);
// 或者使用更精细的控制:
struct io_uring_rsrc_update2 update = {
    .offset = -1,
    .data = (unsigned long)&ring_b_fd,
    .nr_args = 1,
};
io_uring_register(&ring_a, IORING_REGISTER_RING_FDS, &update, 1);

2.3 水平触发与边缘触发

io_uring 引入了新的触发模式标志:

  • IORING_SUBMIT_MODE_LATCHED(水平触发):只要新 SQE 出现在被订阅 ring 的 SQ 中,订阅者就会收到通知。
  • IORING_REGISTER_EVENTFD:注册 eventfd 用于跨 ring 的事件通知。

三、核心编程接口详解

3.1 初始化与参数配置

#include <liburing.h>

struct io_uring ring;
struct io_uring_params params = {0};

// 基础模式
params.flags = IORING_SETUP_IOPOLL; // 轮询模式(需要 O_DIRECT)
params.flags = IORING_SETUP_SQPOLL; // 内核轮询提交
params.flags = IORING_SETUP_ATTACH_WQ; // 共享工作队列

int ret = io_uring_queue_init_params(256, &ring, &params);

关键能力标志(从 params.features 中探测):

  • IORING_FEAT_SINGLE_MMAP:SQ 和 CQ 可映射到同一块内存。
  • IORING_FEAT_NODROP:CQ 满时拒绝新 CQE(反压控制)。
  • IORING_FEAT_SUBMIT_STABLE:内核可见之前不必重读 SQE 数据。
  • IORING_FEAT_RW_CUR_POS:支持 pwritev/preadv 自动当前位置。
  • IORING_FEAT_SQPOLL_NONFIXED:SQPOLL 线程支持使用非固定文件。

3.2 提交请求

io_uring 使用 io_uring_get_sqe() 获取 SQE 槽位,填充后通过 io_uring_submit() 提交到内核:

// 获取 SQE
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);

// 准备一个 pread 操作
io_uring_prep_read(sqe, fd, buf, count, offset);
// 设置用户数据(用于在 CQE 中匹配)
io_uring_sqe_set_data(sqe, (void*)my_context);

// 准备一个固定缓冲区写入
io_uring_prep_write_fixed(sqe, fd, registered_buf, count, offset, buf_index, IOSQE_IO_LINK);

// 准备一个批量 send(需要 IOSQE_IO_LINK 链接)
io_uring_prep_send(sqe, sockfd, msg, len, 0);
io_uring_sqe_set_flags(sqe, IOSQE_IO_LINK);  // 链接到下一个 SQE

// 提交所有准备好的 SQE
io_uring_submit(&ring);

3.3 获取完成事件

非阻塞模式(busy-polling):

struct io_uring_cqe *cqe;
unsigned head;
int completed = 0;

io_uring_for_each_cqe(&ring, head, cqe) {
    // 处理 CQE
    struct my_request *req = (struct my_request *)io_uring_cqe_get_data(cqe);
    if (cqe->res >= 0) {
        printf("req %p completed, result=%d\n", req, cqe->res);
    } else {
        printf("req %p failed, errno=%d\n", req, -cqe->res);
    }
    completed++;
}
// 批量更新 CQ head(避免逐个更新)
io_uring_cq_advance(&ring, completed);

阻塞模式(等待完成):

// 等待一个 CQE
struct io_uring_cqe *cqe;
int ret = io_uring_wait_cqe(&ring, &cqe);

// 批量等待:等待至少 min_events 个完成
io_uring_submit_and_wait(&ring, 4);
for (unsigned head; io_uring_cq_ready(&ring); ) {
    struct io_uring_cqe *cqe;
    io_uring_peek_batch_cqe(&ring, &cqes, count);
}

四、高级特性与优化技巧

4.1 缓冲区选择(Buffer Selection)

io_uring 6.0+ 引入了 BPF_PROG_TYPE_IO_URING,但更重要的是用户层缓冲区选择机制:

// 注册一组缓冲区(buffer pool)
struct io_uring_buf_reg reg = {
    .ring_addr = (unsigned long)br,
    .ring_entries = 128,
    .bgid = 0,  // buffer group ID
};
io_uring_register_buf_ring(&ring, &reg, 0);

// SQE 使用自动缓冲区选择
io_uring_prep_recv(sqe, sockfd, NULL, 0, 0);
io_uring_sqe_set_flags(sqe, IOSQE_BUFFER_SELECT);
sqe->buf_group = 0;  // buffer group ID

4.2 固定文件与缓冲区

io_uring 支持预注册文件描述符和缓冲区,消除每次 I/O 的 fd 查找和 mmap 开销:

// 注册文件描述符数组
int fds[] = {fd1, fd2, fd3};
io_uring_register_files(&ring, fds, 3);

// 在 SQE 中用索引替代 fd
io_uring_prep_read(sqe, 0, buf, 4096, 0); // 使用 fds[0]
io_uring_sqe_set_flags(sqe, IOSQE_FIXED_FILE);

// 注册缓冲区
struct iovec iovecs[2] = {{buf1, 4096}, {buf2, 4096}};
io_uring_register_buffers(&ring, iovecs, 2);

4.3 链接操作(Linked Operations)

IOSQE_IO_LINK 标志将 SQE 链接成链,只有前一个操作成功后下一个才执行:

struct io_uring_sqe *sqe1 = io_uring_get_sqe(&ring);
io_uring_prep_write(sqe1, fd, data1, len1, 0);
io_uring_sqe_set_flags(sqe1, IOSQE_IO_LINK);  // 链接到下一个

struct io_uring_sqe *sqe2 = io_uring_get_sqe(&ring);
io_uring_prep_fsync(sqe2, fd, IORING_FSYNC_DATASYNC);
// sqe2 不会在 sqe1 完成前执行

io_uring_submit(&ring);

4.4 多发射与多完成(Multi-shot)

Linux 5.19+ 引入多发射特性:单个 SQE 可以产生多个 CQE:

// 多发射轮询
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_poll_multishot(sqe, fd, POLLIN);
io_uring_submit(&ring);
// 只要 fd 可读,就会不断产生 CQE,直到显式取消

// 多发射 recv
io_uring_prep_recv_multishot(sqe, sockfd, NULL, 0, 0);
io_uring_sqe_set_flags(sqe, IOSQE_BUFFER_SELECT | IOSQE_FIXED_FILE);

4.5 三种 I/O 模式对比

模式系统调用CPU 消耗延迟适用场景
普通模式io_uring_submit()低中一般应用
SQPOLL零(内核轮询)中高极低低延迟存储/网络
IOPOLL零(用户轮询)高最低NVMe 轮询

五、实战:构建 io_uring HTTP 服务

5.1 架构设计

基于 io_uring 的 HTTP 服务器核心架构:

struct server_state {
    struct io_uring ring;
    int listen_fd;
    buffer_pool_t buf_pool;
    connection_t connections[MAX_CONNECTIONS];
};

void server_loop(struct server_state *state) {
    submit_accept(state);
    while (1) {
        io_uring_submit_and_wait(&state->ring, 1);
        process_completions(state);
    }
}

5.2 accept + recv + send 循环

void submit_accept(struct server_state *s) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(&s->ring);
    io_uring_prep_accept(sqe, s->listen_fd, NULL, NULL, SOCK_NONBLOCK);
    io_uring_sqe_set_data(sqe, conn_new());
}

void submit_recv(struct connection *c) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(c->ring);
    io_uring_prep_recv_multishot(sqe, c->fd, NULL, 0, 0);
    io_uring_sqe_set_flags(sqe, IOSQE_BUFFER_SELECT | IOSQE_FIXED_FILE);
    sqe->buf_group = c->bgid;
    io_uring_sqe_set_data(sqe, c);
}

void submit_send(struct connection *c, void *buf, size_t len) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(c->ring);
    io_uring_prep_send(sqe, c->fd, buf, len, MSG_NOSIGNAL);
    io_uring_sqe_set_data(sqe, c);
}

5.3 文件 I/O 与零拷贝

io_uring 支持真正的零拷贝文件传输:

// 使用 splice 实现 pipe-to-socket 零拷贝
struct io_uring_sqe *sqe1 = io_uring_get_sqe(&ring);
io_uring_prep_splice(sqe1, file_fd, offset, pipe_fd[1], -1, chunk_size, SPLICE_F_MOVE);
io_uring_sqe_set_flags(sqe1, IOSQE_IO_LINK);

struct io_uring_sqe *sqe2 = io_uring_get_sqe(&ring);
io_uring_prep_splice(sqe2, pipe_fd[0], -1, sock_fd, -1, chunk_size, SPLICE_F_MOVE);
io_uring_submit(&ring);
// 数据:磁盘 → pipe → socket,全程零拷贝

六、io_uring 与传统方案的性能对比

6.1 基准测试数据

在典型 NVMe SSD 环境下的对比(io_uring vs epoll vs libaio):

指标libaioepoll + 非阻塞io_uring (SQPOLL)
随机读 IOPS (4K)~250K~180K~450K
延迟 P9915μs22μs4μs
IOPS/core 效率低中极高
CPU 开销高中极低

6.2 网络 TCP 性能对比

在 10G 网络上的 HTTP 短连接处理:

  • epoll + 非阻塞模式:约 800K req/s(4 核),CPU 使用率 ~75%
  • io_uring + 多发射 accept:约 1.2M req/s(4 核),CPU 使用率 ~45%
  • io_uring + SQPOLL + 多发射:约 1.4M req/s(4 核),CPU 使用率 ~40%(含内核线程)

七、底层实现原理

7.1 内核侧实现

io_uring 在内核中的核心结构是 io_ring_ctx:

struct io_ring_ctx {
    struct io_wq *io_wq;           // 工作队列
    struct io_uring_sqe *sq_array; // SQE 数组
    unsigned *sq_array_ring;       // SQ 环形索引
    unsigned *cq_ring;             // CQ 环形索引
    struct task_struct *sqo_thread; // SQPOLL 线程
    // ...
};

核心执行流程:

  1. 用户态将 SQE 写入 SQ,更新 SQ tail 指针(共享内存,无 syscall)
  2. 内核工作线程从 SQ 读取 SQE,转换为内部 io_kiocb 结构
  3. 内核执行 I/O,完成后将结果 CQE 写入 CQ
  4. 用户态从 CQ 读取 CQE,更新 CQ head 指针(共享内存)

7.2 内存模型与并发安全

io_uring 的三个缓冲区使用 release/acquire 内存序保证数据正确性:

  • SQ 更新:用户态使用 smp_store_release 更新 tail,内核使用 smp_load_acquire 读取
  • CQ 更新:内核使用 smp_store_release 更新 tail,用户态使用 smp_load_acquire 读取
  • 这些内建屏障确保了跨核无锁通信的正确性

7.3 ring 间事件通知机制

Linux 6.6+ 引入了基于 IORING_REGISTER_RING_FDS 的 ring 间通信:

  1. ring A 通过 io_uring_register() 提交目标 ring B 的 fd
  2. ring B 的 CQE 产生时,内核自动通知 ring A
  3. ring A 通过 io_uring_enter() 等待事件(或不等待)
  4. 可构建分层的 I/O 架构:ring B 处理 I/O,ring A 编排控制

八、io_uring 的生态与应用

8.1 语言绑定

  • C:liburing(官方),单头文件库,内核 5.1+ 可用
  • Rust:tokio-uring(tokio 适配层)、rio(纯 Rust io_uring 库)
  • Go:iouring-go(通过 cgo 调用 liburing)
  • Python:asyncio-io_uring 适配
  • C++:liburing++ 封装

8.2 生产级应用

  • MySQL 8.0.31+:innodb_use_native_aio=ON 时内部使用 io_uring
  • PostgreSQL(实验性):社区开发 io_uring 后端
  • SQLite:基于 io_uring 的 vfs 层大幅提升随机读写性能
  • Nginx + io_uring:开源补丁使用 io_uring 的 sendfile/splice 零拷贝
  • Tokio:tokio-uring 实现真正的异步文件 I/O 和网络 I/O
  • QEMU:使用 io_uring 加速虚拟机磁盘 I/O
  • SPDK:用户态高性能存储框架,与 io_uring 集成

九、常见问题与陷阱

9.1 CQ 缓冲区溢出

// 使用 IORING_SETUP_CQ_NODROP 标志
params.flags |= IORING_SETUP_CQ_NODROP;
// 或使用 IORING_ENTER_EXT_ARG 的 timeout 控制
struct __kernel_timespec ts = { .tv_sec = 1, .tv_nsec = 0 };
io_uring_enter(ring_fd, 0, 1, IORING_ENTER_EXT_ARG, &ts, sizeof(ts));

9.2 SQPOLL 线程饥饿

  • 使用 IORING_SETUP_ATTACH_WQ 共享工作队列
  • 设置 sq_thread_idle 控制空闲秒数后休眠
  • 避免在 SQPOLL 模式下做长时间 CPU 密集操作

9.3 固定内存限制

  • 固定内存受 RLIMIT_MEMLOCK 限制
  • 使用非特权 io_uring 时需要避免跨 mm 的固定缓冲区

十、总结与展望

io_uring 是 Linux 内核近十年最重要的 I/O 革新。它的核心优势体现在三个维度:

  1. 性能:零 syscall、零拷贝、多模式轮询,IOPS 可达传统 epoll 方案的 2-3 倍
  2. 通用性:统一的网络、文件、异步事件处理模型,替代 libaio、sendfile、accept 等多套独立 API
  3. 可扩展性:订阅机制、多实例协作、BPF 集成,为未来异步 I/O 编程奠定基础

随着 Linux 6.x 内核中 "io_uring 新订阅机制"(ring 间通信、buffered I/O 增强)的成熟,io_uring 正在从 "高性能存储 I/O 方案" 演变为 "Linux 统一异步执行平台"。对于追求极致性能的后端服务、数据库引擎、Web 框架,掌握 io_uring 已从可选技能变为核心竞争力。

作为开发者,建议从 liburing 或 tokio-uring 入手,先在生产环境试用简单的文件读写场景,再逐步迁移到更复杂的网络 I/O 和进程编排场景。Linux io_uring 的大幕已拉开,而最好的入场时机就是现在。

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部