引言:为什么需要 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, ¶ms);
关键能力标志(从 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, ®, 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):
| 指标 | libaio | epoll + 非阻塞 | io_uring (SQPOLL) |
|---|---|---|---|
| 随机读 IOPS (4K) | ~250K | ~180K | ~450K |
| 延迟 P99 | 15μs | 22μs | 4μ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 线程
// ...
};
核心执行流程:
- 用户态将 SQE 写入 SQ,更新 SQ tail 指针(共享内存,无 syscall)
- 内核工作线程从 SQ 读取 SQE,转换为内部 io_kiocb 结构
- 内核执行 I/O,完成后将结果 CQE 写入 CQ
- 用户态从 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 间通信:
- ring A 通过 io_uring_register() 提交目标 ring B 的 fd
- ring B 的 CQE 产生时,内核自动通知 ring A
- ring A 通过 io_uring_enter() 等待事件(或不等待)
- 可构建分层的 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 革新。它的核心优势体现在三个维度:
- 性能:零 syscall、零拷贝、多模式轮询,IOPS 可达传统 epoll 方案的 2-3 倍
- 通用性:统一的网络、文件、异步事件处理模型,替代 libaio、sendfile、accept 等多套独立 API
- 可扩展性:订阅机制、多实例协作、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 的大幕已拉开,而最好的入场时机就是现在。

发表评论 取消回复