Linux io_uring 深度实战：从零系统调用到百万 IOPS 的异步 I/O 架构

引言：Linux I/O 的演进与 io_uring 的诞生

Linux I/O 接口经历了从 read()/write() 阻塞调用，到 epoll() 事件通知，再到 aio_read()/aio_write() 原生异步 I/O 的演进。然而 Linux AIO 自诞生起就充满了限制：仅支持 O_DIRECT 文件描述符、不支持阻塞操作、提交/完成系统调用开销大、与 epoll 配合困难。

2019 年 Linux 5.1 内核合并了 io_uring，由 Jens Axboe（Linux 块设备层维护者）设计。它并非简单地修补 AIO，而是重新设计了一套全新的异步 I/O 编程模型，采用共享内存环形队列（Submission Queue / Completion Queue）实现用户态与内核态的零系统调用通信，真正做到了高性能、全功能、可扩展的异步操作。

1. 核心架构：SQ、CQ 与 SQE/CQE

io_uring 的核心是两个环形缓冲区：

• Submission Queue (SQ)：用户态写入 SQE（Submission Queue Entry），内核消费
• Completion Queue (CQ)：内核写入 CQE（Completion Queue Entry），用户态消费
• Submission Queue Entries (SQEs) 数组：所有 SQE 预分配的连续内存

关键创新在于：SQ 和 CQ 的尾部指针映射到用户态内存。在常规使用模式下，用户态提交 I/O 请求只需写入共享内存并更新尾指针，完全不需要 io_uring_enter() 系统调用（批量提交时只需一次）。

这意味着在稳态下：每百万 I/O 操作 0 次系统调用。这是 io_uring 相比 epoll+AIO 的根本优势。

2. 代码实战：最小化 io_uring 程序

#include <liburing.h>
#include <fcntl.h>
#include <stdio.h>

int main() {
    // 1. 初始化 io_uring，队列深度 8
    struct io_uring ring;
    io_uring_queue_init(8, &ring, 0);

    // 2. 获取一个 SQE
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);

    // 3. 准备一个 pread 操作
    int fd = open("/tmp/test.dat", O_RDONLY);
    char buf[4096];
    io_uring_prep_pread(sqe, fd, buf, sizeof(buf), 0);
    io_uring_sqe_set_data(sqe, (void*)"read_request");

    // 4. 提交（批量模式可多次 get_sqe 后一次性提交）
    io_uring_submit(&ring);

    // 5. 等待完成事件
    struct io_uring_cqe *cqe;
    int ret = io_uring_wait_cqe(&ring, &cqe);

    if (cqe->res >= 0)
        printf("[+] Read %d bytes, user_data=%s\n",
               cqe->res, (char*)io_uring_cqe_get_data(cqe));

    // 6.  Seen  CQE
    io_uring_cqe_seen(&ring, cqe);
    io_uring_queue_exit(&ring);
    return 0;
}

编译运行：

$ gcc -o demo demo.c -luring
$ ./demo
[+] Read 4096 bytes, user_data=read_request

3. 高级特性深度解析

3.1 Fixed Buffers（预注册缓冲区）

每次 read() 需要将用户缓冲区 pin 住、映射到内核、再解除，这个 pin/unpin 操作在大 I/O 压力下会消耗大量 CPU。io_uring 允许预先注册一组缓冲区（IORING_REGISTER_BUFFERS），之后提交 I/O 时只需指定 buffer index：

// 预注册 32 个 4KB 缓冲区
struct iovec iovecs[32];
for (int i = 0; i < 32; i++)
    posix_memalign(&iovecs[i].iov_base, 4096, 4096),
    iovecs[i].iov_len = 4096;

io_uring_register_buffers(&ring, iovecs, 32);

// 提交时使用_fixed variant
io_uring_prep_read_fixed(sqe, fd, NULL, 4096, 0, 0/*buf_index*/);

效果：消除每次 I/O 的 get_user_pages/put_user_pages 开销，随机读 IOPS 提升可达 15-20%。

3.2 Fixed Files（预注册文件描述符）

类似缓冲区，IORING_REGISTER_FILES 可以预注册一组 fd。提交 I/O 时使用 index 而非 fd，避免每次的 fget/fput 原子操作：

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

// 提交时设置 IOSQE_FIXED_FILE 标志
io_uring_sqe_set_flags(sqe, IOSQE_FIXED_FILE);
sqe->fd = 0; // index into registered files array

// 原子操作：先 read header，再 read body
struct io_uring_sqe *sqe1 = io_uring_get_sqe(&ring);
io_uring_prep_read(sqe1, fd, header_buf, HDR_SIZE, 0);
io_uring_sqe_set_data(sqe1, header_ctx);
sqe1->flags |= IOSQE_IO_LINK;  // 链接下一个

struct io_uring_sqe *sqe2 = io_uring_get_sqe(&ring);
io_uring_prep_read(sqe2, fd, body_buf, body_size, HDR_SIZE);
io_uring_sqe_set_data(sqe2, body_ctx);

io_uring_submit(&ring);  // 一次提交，两个操作按序执行

// 传统 epoll + 线程池模型
// worker_thread: pread() → 阻塞 50μs → 返回结果
// 问题：线程上下文切换 5-10μs + 阻塞等待 = 高尾延迟

// io_uring 模型（单线程事件循环）
void handle_get_request(struct io_uring *ring, conn_t *conn) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
    
    // 直接发送 disk I/O，无线程阻塞
    io_uring_prep_pread(sqe, conn->fd, conn->buf, conn->val_len, conn->offset);
    io_uring_sqe_set_data(sqe, conn); // 完成时通过 user_data 找到连接
    
    io_uring_submit(ring); // 批量场景下一次提交数千个
}

// 事件循环
void event_loop(struct io_uring *ring) {
    while (1) {
        // 1. 网络事件处理（epoll/kevent 或 io_uring 自己的 timeout）
        // 2. 收割完成事件
        struct io_uring_cqe *cqe;
        unsigned head;
        io_uring_for_each_cqe(ring, head, cqe) {
            conn_t *conn = (conn_t*)io_uring_cqe_get_data(cqe);
            send_response(conn, cqe->res);
            io_uring_cqe_seen(ring, cqe);
        }
    }
}

// io_uring 原生支持高精度超时
struct __kernel_timespec ts = { .tv_sec = 0, .tv_nsec = 500000000 }; // 500ms
io_uring_prep_timeout(sqe, &ts, 1, 0);

// 链接到 I/O 操作：I/O 超时自动取消
sqe->flags |= IOSQE_IO_LINK | LINK_TIMEOUT;