深入理解 Linux io_uring：革命性的异步IO新范式

在数据爆炸式增长的时代，高性能IO始终是系统优化的核心命题。传统的 Linux AIO（libaio）因其诸多限制长期被开发者诟病，而 epoll 仅适用于网络场景。2019年，Linux 5.1 内核引入了 io_uring，一个彻底重新设计的高效异步IO框架，解决了长期以来 Linux 异步IO生态的痛点。本文将深入剖析 io_uring 的架构设计、核心机制以及实战应用。

一、io_uring 的诞生背景

在 io_uring 之前，Linux 世界主要依赖两种异步IO方案，各有明显短板：

1. POSIX AIO（libaio）的缺陷

POSIX AIO 实现于用户态线程池，并非真正的内核级异步IO，存在以下严重问题：

• 仅支持 O_DIRECT 模式，无法利用页缓存
• 不支持套接字网络IO，适用面狭窄
• 提交和完成系统调用开销大，性能差
• API 设计复杂，完成事件处理困难

2. Linux AIO（原生 AIO）的局限

内核原生 AIO（io_submit/io_getevents）虽然不依赖线程池，但限制重重：

• 仅 O_DIRECT 文件有效，不支持缓冲IO
• 所有提交块必须对齐（512字节边界）
• 不支持套接字，不适用于网络服务
• 每次提交至少2次系统调用（io_submit + io_getevents）
• 缺乏广泛的生态支持，难以集成到事件循环

3. io_uring 的设计目标

Jens Axboe（Linux 块设备层维护者）在设计 io_uring 时明确了以下目标：

• 零系统调用提交：通过共享内存实现用户态到内核的无锁通信
• 统一接口：同时支持文件IO和网络IO
• 可扩展性：支持轮询模式绕过中断，实现超低延迟
• 简洁 API：固定大小的数据结构，批量操作友好

二、io_uring 核心架构

2.1 共享内存队列——消除系统调用的关键

io_uring 的革命性之处在于使用两个环形缓冲区在用户态和内核之间共享数据，避免了传统异步IO的系统调用开销：

┌──────────────────────────────────────────────┐
│              用户态 (User Space)              │
│                                              │
│   ┌─────────────┐    ┌──────────────────┐   │
│   │  SQ (提交队列) │    │  CQ (完成队列)    │   │
│   │  Submission   │    │  Completion       │   │
│   │  Queue        │    │  Queue            │   │
│   └──────┬───────┘    └────────┬─────────┘   │
│          │  SQ tail            │  CQ head      │
│          │  (用户写入)          │  (用户读取)    │
└──────────┼─────────────────────┼──────────────┘
           │                     │
     ┌─────┴─────────────────────┴──────┐
     │          内核态 (Kernel)           │
     │                                   │
     │   SQ head ── 内核读取新提交       │
     │   CQ tail ── 内核写入完成事件      │
     │                                   │
     └───────────────────────────────────┘

这种设计的核心优势在于：

• SQ（Submission Queue）：用户态写入SQEs（提交队列条目），通过内存屏障通知内核有新条目。如果SQ中有足够条目，可能完全不需要系统调用就完成批量提交
• CQ（Completion Queue）：内核写入CQEs（完成队列条目），用户态直接从CQ读取完成事件，无需系统调用
• 无锁设计：使用head/tail指针配合内存屏障，实现单生产者单消费者的无锁环形缓冲区

2.2 SQE 和 CQE 数据结构

提交队列条目（SQE）是用户态传递给内核的IO请求描述符：

// io_uring_sqe（简化）
struct io_uring_sqe {
    __u8   opcode;      // 操作码：IORING_OP_READV/WRITEV/SEND/RECV等
    __u8   flags;       // IOSQE 标志位
    __u16  ioprio;      // IO优先级
    __s32  fd;          // 目标文件描述符
    __u64  off;         // 文件偏移量
    __u64  addr;        // 用户缓冲区地址（或iovec指针）
    __u32  len;         // 缓冲区长度/ iovec数量
    __u32  rw_flags;    // 读写标志
    __u64  user_data;   // 用户自定义标识符，原样返回到CQE
    __u16  buf_index;   // 缓冲区组索引（fixed buffer）
    __u16  personality; // personality身份标识
    __s32  splice_fd_in; // splice操作用源fd
    __u64  __pad2[2];
};

完成队列条目（CQE）是内核返回给用户的IO结果：

// io_uring_cqe（简化）
struct io_uring_cqe {
    __u64  user_data;   // 匹配SQE中的user_data
    __s32  res;         // 操作结果（类似于系统调用返回值）
    __u32  flags;       // 完成标志
};

2.3 初始化流程

创建 io_uring 实例的核心步骤：

#include <liburing.h>

// 方法一：使用 liburing 库（推荐）
struct io_uring ring;
// 初始化：128个SQ条目，无CQ特殊标志，无额外参数
int ret = io_uring_queue_init(128, &ring, 0);

// 方法二：手动 syscall 初始化
struct io_uring_params params = {0};
int fd = io_uring_setup(128, &params);

//  mmap 映射共享内存
struct io_uring_sq *sq = &ring.sq;
struct io_uring_cq *cq = &ring.cq;

sq->ring = mmap(0, params.sq_off.array + params.sq_entries * sizeof(__u32),
                PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE,
                fd, IORING_OFF_SQ_RING);
cq->ring = mmap(0, params.cq_off.cqes + params.cq_entries * sizeof(struct io_uring_cqe),
                PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE,
                fd, IORING_OFF_CQ_RING);

// SQEs 数组单独映射
sq->sqes = mmap(0, params.sq_entries * sizeof(struct io_uring_sqe),
                PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE,
                fd, IORING_OFF_SQES);

三、核心操作模式详解

3.1 基本操作：Buffered IO 与 Direct IO

io_uring 支持两种文件IO模式：

3.2 固定缓冲区（Fixed Buffers）

传统异步IO每次操作都需要从用户态拷贝数据到内核态。io_uring 通过固定缓冲区机制，在内核中预先注册内存池，避免重复映射/取消映射的开销：

// 注册固定缓冲区池
#define BUF_SIZE 4096
#define BUF_COUNT 1024

char buf_pool[BUF_COUNT][BUF_SIZE] __attribute__((aligned(4096)));

struct iovec iovecs[BUF_COUNT];
for (int i = 0; i < BUF_COUNT; i++) {
    iovecs[i].iov_base = buf_pool[i];
    iovecs[i].iov_len = BUF_SIZE;
}

// 一次性注册所有缓冲区到内核
io_uring_register_buffers(&ring, iovecs, BUF_COUNT);

// 后续IO使用IOSQE_BUFFER_SELECT + buf_index
// 内核自动选择缓冲区，避免每次read的数据拷贝

3.3 固定文件（Fixed Files）

类似固定缓冲区，固定文件机制预先注册文件描述符表，避免每次IO执行 fd 查找和权限检查：

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

// 提交IO时使用 index 0/1/2 而不是真实fd
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_read_fixed(sqe, 0, buf, len, offset, buf_idx);
sqe->flags |= IOSQE_FIXED_FILE; // 使用固定文件表索引

3.4 轮询模式（Polling Mode）

延迟敏感的应用可以启用内核轮询模式（IORING_SETUP_IOPOLL），SQ和CQ使用轮询而非中断完成，彻底绕过中断处理路径：

// 启用IORING轮询模式
struct io_uring_params params = {0};
params.flags = IORING_SETUP_IOPOLL; // 启用轮询
int fd = io_uring_setup(128, &params);

// 用户态需要主动提交和收割
io_uring_submit(&ring);          // 手动提交
io_uring_wait_cqe(&ring, &cqe);  // 轮询等待完成

// 内核侧：使用IORING_SETUP_SQPOLL让内核线程主动轮询SQ
params.flags = IORING_SETUP_SQPOLL;
params.sq_thread_idle = 2000; // 空闲2ms后内核线程休眠

3.5 网络IO：SEND/RECV 与 SENDMSG/RECVMSG

io_uring 在 Linux 5.3+ 添加了对网络套接字的支持：

// 非阻塞发送（替代 send()）
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_send(sqe, sockfd, buf, len, 0);
sqe->user_data = OP_SEND;

// 非阻塞接收（替代 recv()）
sqe = io_uring_get_sqe(&ring);
io_uring_prep_recv(sqe, sockfd, buf, len, 0);
sqe->user_data = OP_RECV;

// 批量提交，可能零系统调用
io_uring_submit(&ring);

四、高级特性与内核缓冲选择

4.1 链式操作（Linked SQE）

io_uring 支持将多个SQE链接为一个原子操作序列，前一个操作完成后才会提交下一个：

// 场景：先读文件头部，再读文件数据
struct io_uring_sqe *sqe1 = io_uring_get_sqe(&ring);
io_uring_prep_readv(sqe1, fd, &header_iov, 1, 0);
sqe1->user_data = HEADER_READ;
sqe1->flags |= IOSQE_IO_LINK; // 链接到下一个SQE

struct io_uring_sqe *sqe2 = io_uring_get_sqe(&ring);
io_uring_prep_readv(sqe2, fd, &data_iov, 1, HEADER_SIZE);
sqe2->user_data = DATA_READ;

// sqe1完成后内核自动提交sqe2，无需用户态介入
io_uring_submit(&ring);

4.2 缓冲区选择（Buffer Selection）

Linux 5.7+ 引入了内核缓冲选择机制，配合固定缓冲区使用，实现真正的零拷贝接收：

// 启用缓冲区组
struct io_uring_params params = {0};
// ... 创建ring

// 注册缓冲区组（Buffer Group 0）
struct io_uring_buf_reg reg = {
    .ring_addr = (unsigned long)buf_ring,
    .ring_entries = BUF_COUNT,
    .bgid = 0
};
io_uring_register_buf_ring(&ring, &reg, 0);

// 提交recv时指定IOSQE_BUFFER_SELECT
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_recv(sqe, sockfd, NULL, 0, 0);
sqe->flags |= IOSQE_BUFFER_SELECT;
sqe->buf_group = 0;

// 完成后CQE的flags包含选中的缓冲区索引
// CQE的res包含实际接收的数据长度
// 用户无需预先分配缓冲区，内核自动分配

4.3 超时与取消

// 链接超时：如果链接操作在指定时间内未完成，触发超时取消
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
struct __kernel_timespec ts = { .tv_sec = 5, .tv_nsec = 0 };
io_uring_prep_timeout(sqe, &ts, 1, 0); // 计数1，相对超时
sqe->flags |= IOSQE_IO_LINK | IOSQE_IO_HARDLINK;

// 取消操作
sqe = io_uring_get_sqe(&ring);
io_uring_prep_cancel(sqe, target_user_data, 0);

五、与其他异步IO方案性能对比

5.1 基准测试数据

在NVMe SSD、O_DIRECT模式下的随机读性能测试：

5.2 epoll vs io_uring 在网络场景

HTTP静态文件服务器的吞吐量对比（单机10GbE）：

六、io_uring 在开源项目中的应用

6.1 存储与数据库

• PostgreSQL：从 PG 16 开始支持 WAL 写入使用 io_uring，大幅提升 checkpoint 性能
• MySQL 9.0：引入 io_uring 作为 InnoDB redo log 的异步写入后端
• RocksDB：通过 PosixRandomRWFile 接口集成 io_uring，提升 WAL 写入吞吐量

6.2 Web服务器与代理

• nginx：通过第三方模块支持 io_uring 的 aio 指令，静态文件服务性能提升 30%+
• HAProxy 2.8+：实验性支持 io_uring 的零拷贝发送
• Tokio（Rust）：社区驱动的 io_uring 运行时（rio crate），提供异步IO接口

6.3 编程框架与库

• liburing：Jens Axboe 维护的官方封装库
• tokio-uring：为 tokio 异步运行时添加 io_uring 支持
• glommio：Rust 编写的 io_uring 专属异步运行时
• netty-io_uring：Java Netty 框架的 io_uring 传输层

七、实战示例：实现一个高性能 echo server

#include <liburing.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define QUEUE_DEPTH 256
#define BUF_SIZE 1024
#define MAX_CLIENTS 1024

struct client_info {
    int fd;
    char buf[BUF_SIZE];
};

static struct io_uring ring;
static struct client_info clients[MAX_CLIENTS];

enum {
    OP_ACCEPT,
    OP_READ,
    OP_WRITE
};

// 提交一个accept操作
void submit_accept(int listen_fd) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_accept(sqe, listen_fd, NULL, NULL, 0);
    sqe->user_data = ((uint64_t)OP_ACCEPT << 32) | listen_fd;
    io_uring_submit(&ring);
}

// 提交一个recv操作
void submit_recv(int fd) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_recv(sqe, fd, clients[fd].buf, BUF_SIZE, 0);
    sqe->user_data = ((uint64_t)OP_READ << 32) | fd;
    io_uring_submit(&ring);
}

// 提交一个send操作
void submit_send(int fd, int nbytes) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_send(sqe, fd, clients[fd].buf, nbytes, 0);
    sqe->user_data = ((uint64_t)OP_WRITE << 32) | fd;
    io_uring_submit(&ring);
}

int main(int argc, char *argv[]) {
    struct io_uring_cqe *cqe;
    int listen_fd, ret;

    // 初始化 io_uring
    ret = io_uring_queue_init(QUEUE_DEPTH, &ring, 0);
    if (ret < 0) {
        fprintf(stderr, "io_uring init failed: %s\n", strerror(-ret));
        return 1;
    }

    // 创建监听 socket
    listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons(8080),
        .sin_addr.s_addr = INADDR_ANY
    };
    bind(listen_fd, (struct sockaddr*)&addr, sizeof(addr));
    listen(listen_fd, 128);

    // 初始化客户端表
    memset(clients, 0, sizeof(clients));

    // 提交第一个accept操作
    submit_accept(listen_fd);

    // 事件循环
    while (1) {
        // 等待至少一个完成事件
        ret = io_uring_wait_cqe(&ring, &cqe);
        if (ret < 0) {
            fprintf(stderr, "wait_cqe: %s\n", strerror(-ret));
            break;
        }

        uint64_t data = cqe->user_data;
        int op = data >> 32;
        int fd = data & 0xFFFFFFFF;
        int res = cqe->res;

        io_uring_cqe_seen(&ring, cqe);

        if (res < 0) {
            if (fd != listen_fd) close(fd);
            if (op == OP_ACCEPT) submit_accept(listen_fd);
            continue;
        }

        switch (op) {
            case OP_ACCEPT: {
                int client_fd = res;
                clients[client_fd].fd = client_fd;
                // 继续accept新的连接
                submit_accept(listen_fd);
                // 为客户端提交读请求
                submit_recv(client_fd);
                break;
            }
            case OP_READ: {
                if (res == 0) {
                    // 客户端断开
                    close(fd);
                } else {
                    // echo：读什么发回什么
                    submit_send(fd, res);
                }
                break;
            }
            case OP_WRITE:
                // 发送完成后继续读取下一批数据
                submit_recv(fd);
                break;
        }
    }

    io_uring_queue_exit(&ring);
    return 0;
}

编译运行：

gcc -o echo_server echo_server.c -luring
./echo_server

这个 echo server 的核心特点是：

• 单线程事件循环：不需要 epoll + 线程池
• 零系统调用提交：所有IO请求通过共享内存提交
• 统一模型：accept、recv、send 使用完全相同的提交/完成机制
• 极高并发：单线程即可处理数万并发连接

八、内核实现原理与数据结构

8.1 内核侧关键结构

// 内核中的 io_uring 实例
struct io_ring_ctx {
    struct file *file;              // /dev/io_uring 对应的文件
    struct io_wq *io_wq;             // 工作队列（用于不直接poll的操作）
    
    // 提交队列（SQ）
    struct io_sq_ring *sq_ring;      // SQ环形缓冲区
    struct io_uring_sqe *sqes;       // SQE数组
    unsigned *sq_array;              // SQE索引数组
    unsigned sq_sqes;                // SQ条目总数
    
    // 完成队列（CQ）
    struct io_cq_ring *cq_ring;      // CQ环形缓冲区
    struct io_uring_cqe *cqes;       // CQE数组
    
    // 异步工作状态
    struct io_wq_work_node *work;    // 待处理工作列表
    struct task_struct *sqo_thread;  // SQPOLL 内核轮询线程
    
    // 注册资源
    struct idr io_buffer_idr;       // 固定缓冲区注册表
    struct idr personality_idr;     // personality注册表
    struct file **file_table;       // 固定文件表
};

8.2 提交流程详解

从用户态调用 io_uring_submit() 到内核执行IO的完整路径：

1. 用户态写入 SQE：将操作代码、fd、缓冲区地址等信息写入 SQEs 数组
2. 更新 SQ tail：写入包含SQE索引的SQ环形缓冲区的tail位置
3. 内存屏障：smp_wmb() 保证SQE写入对内核可见
4. 通知内核（可选）：如果CQ需要收割或设置了IORING_SETUP_SQPOLL，通过 io_uring_enter 系统调用通知内核
5. 内核检查：内核线程（sq_thread）或 io_uring_enter 处理SQ中的新条目
6. 创建 io_kiocb：为每个SQE分配内核IO控制块，加入工作队列
7. 分发到设备：根据操作码分发到块层（read/write）、网络层（send/recv）或文件系统层
8. 异步执行：IO请求进入设备队列，可能触发DMA操作
9. 完成中断/轮询：设备完成IO后触发中断或轮询检测到完成
10. 写入 CQE：将结果写入CQEs，更新CQ tail，用户态可见

8.3 io_wq 工作队列

对于无法异步完成的操作（如普通缓冲IO读未命中页缓存），io_uring 使用 io_wq 工作队列在后台线程执行，避免阻塞用户态线程：

// io_wq 的 work item
struct io_wq_work {
    struct io_wq_work_node list;
    unsigned flags;
    io_wq_work_fn *func;
    struct io_wq_data *data;
};

// 工作线程池
struct io_wq {
    struct io_wq_hash *hash;         // 哈希表（按inode分组）
    unsigned online:1;               // worker计数
    struct io_wq_work *work;         // 当前工作
    
    // 绑核的执行线程
    struct task_struct *task;
};

九、最新版本内核中的新特性

Linux 6.x 内核 io_uring 增强

9.1 零拷贝发送（IORING_OP_SEND_ZC）

Linux 6.3 引入的 SEND_ZC 实现了真正的网络零拷贝发送：

// 零拷贝发送
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_send_zc(sqe, sockfd, buf, len, 0, 0);
sqe->user_data = OP_SEND_ZC;

// 完成时会有两个CQE：
// 1. 第一个CQE：通知"数据已发送"
// 2. 第二个CQE（零拷贝用）：通知"缓冲区可被安全复用"
// 这很重要：零拷贝发送时内核仍持有缓冲区引用
// 收到第二个CQE前不能修改缓冲区数据

十、最佳实践与注意事项

10.1 性能优化建议

• 批量提交：积累多个SQE后一次性提交，减少 io_uring_enter 系统调用次数
• 使用固定缓冲区：对于高频IO，注册固定缓冲区可减少 15-25% CPU开销
• SQPOLL 模式：高负载场景启用内核轮询线程，但注意CPU亲和性设置
• CQ overflow处理：监控IORING_SQ_CQ_OVERFLOW标志，CQ溢出会导致请求被丢弃
• 避免小IO：单线程场景尽量减少小于4KB的IO请求

# 查看进程的 io_uring 实例
$ cat /proc/<pid>/fd
... 
123u  anon_inode:[io_uring]

# 查看 io_uring 统计（如果内核支持）
$ cat /sys/kernel/debug/io_uring/stats

# 使用 strace 追踪 io_uring 系统调用
$ strace -e io_uring_setup,io_uring_enter,io_uring_register ./your_program