深入剖析 Linux io_uring：异步IO革命与高性能用户态文件操作实战

1 阅读 0 评论 0 点赞

深入剖析 Linux io_uring：异步IO革命与高性能用户态文件操作实战

一、异步IO的演进之路：从阻塞到异步

在计算机较早的文件操作模型中，用户进程调用 read/write 等系统调用时，线程会被阻塞直到内核完成数据传输。这种 阻塞式 IO (Blocking IO) 模型在低延迟场景下表现必要，但对于快速设备（如 NVMe SSD）和高并发服务器而言，它是限制性的。

虚假设异步 IO (AIO) 框架在 POSIX 标准中的引入试图解决这一问题，但 Linux 的 POSIX AIO (aio_read/ aio_write) 存在多个重大缺陷：

仅支持 O_DIRECT 模式文件的异步操作，普通缓冲区上的 read/write 实际上仍然阻塞
每次操作内核缓冲区分配复杂，性能异常不佳
接口设计复杂，缺乏统一的效率提升手段

Linux 5.1 版本（2019年）引入的 io_uring 已经的情操不同，它重新定义了用户态与内核态之间的高性能通信机制。

二、io_uring 核心架构：SQ/CQ 双环设计

io_uring 的基础联系是共享内存环形缓冲区（shared memory ring buffer），它由三个核心数据结构组成：

结构	全称	作用
SQ	Submission Queue（提交队列）	用户态写入 IO 请求（SQE），内核态消费
CQ	Completion Queue（完成队列）	内核态写入完成事件（CQE），用户态消费
SQEs	Submission Queue Entries 数组	SQE 的预分配连续内存，与 SQ 环状索引对应

工作流程如下：

用户态向 SQ 环形缓冲区中追加一个或多个 SQE（Submission Queue Entry）
更新 SQ tail 指针（用户态写，内核态读，仅需一次原子操作）
内核消费 SQE，执行实际的 IO 操作
完成后将 CQE 写入 CQ 环形缓冲区，更新 CQ head 指针
用户态直接从 CQ 中读取完成结果，无需额外系统调用

关键在于：在 SQPOLL 模式下，用户态提交任务时甚至可以零系统调用（zero-syscall），仅靠共享内存屏障（memory barrier）完成同步。

2.1 数据结构布局

io_uring 实例通过 io_uring_setup() 系统调用创建，返回一个文件描述符。用户通过 mmap() 将 SQ、CQ 和 SQEs 三块内存映射到用户空间：

// 创建 io_uring 实例
struct io_uring io_uring;
struct io_uring_params params;
memset(&params, 0, sizeof(params));
int fd = io_uring_setup(QUEUE_DEPTH, &params);

//  mmap SQ 和 SQEs
sqe_ptr = mmap(0, params.sq.array_off + params.sq_entries * sizeof(__u32),
               PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE,
               fd, IORING_OFF_SQ_RING);
sqes = mmap(0, params.sq_entries * sizeof(struct io_uring_sqe),
            PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE,
            fd, IORING_OFF_SQES);

//  mmap CQ
cqe_ptr = mmap(0, params.cq_off + params.cq_entries * sizeof(struct io_uring_cqe),
               PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE,
               fd, IORING_OFF_CQ_RING);

三、三种工作模式

io_uring 支持三种不同的工作模式，适应不同的性能与复杂度需求：

模式	触发方式	系统调用开销	适用场景
中断驱动 (默认)	内核处理完成后中断通知	io_uring_enter() 按需提交	一般应用
内核线程轮询 (SQPOLL)	内核线程 sq_thread 主动轮询 SQ	提交时零系统调用	极低延迟 + 高吞吐
IO 轮elling (IOPOLL)	内核线程在 CQ 上持续轮询完成	零系统调用 + 零中断	NVMe 极致性能

3.1 SQPOLL 模式详解

开启 SQPOLL 模式后，内核会创建一个专用线程（io_uring-sq）持续扫描 SQ 环形缓冲区。用户态仅需将 SQE 写入共享内存并更新 tail 指针，内核线程会自动发现并消费新任务。

// 开启 SQPOLL 模式
struct io_uring_params params;
memset(&params, 0, sizeof(params));
params.flags |= IORING_SETUP_SQPOLL;
// 设置线程空闲超时（毫秒），超时后线程休眠以避免占用 CPU
params.sq_thread_idle = 2000;

io_uring_queue_init_params(QUEUE_DEPTH, &ring, &params);

注意：SQPOLL 线程在空闲超过 sq_thread_idle 毫秒后会自动休眠，此时需要调用 io_uring_enter() 唤醒。

四、liburing 使用指南

liburing 是 io_uring 的官方用户态封装库，极大简化了底层操作。以下是核心 API 的使用模式：

4.1 基础读取操作

#include <liburing.h>

struct io_uring ring;
// 初始化 io_uring，队列深度 128
io_uring_queue_init(128, &ring, 0);

// 获取一个 SQE 并填充读请求
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_read(sqe, fd, buf, len, offset);
io_uring_sqe_set_data(sqe, user_context); // 关联用户上下文

// 提交到内核
io_uring_submit(&ring);

// 等待并获取完成事件
struct io_uring_cqe *cqe;
io_uring_wait_cqe(&ring, &cqe);
// 处理结果
handle_result(cqe->res, io_uring_cqe_get_data(cqe));
io_uring_cqe_seen(&ring, cqe);

4.2 批量提交优化

io_uring 的批量提交性能显著优于逐个提交。以下是批量读写的对比示例：

// 批量提交 N 个读请求
for (int i = 0; i < N; i++) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_read(sqe, fds[i], bufs[i], lens[i], offsets[i]);
    io_uring_sqe_set_data(sqe, (void*)(intptr_t)i);
}
// 一次系统调用提交所有请求
io_uring_submit(&ring);

// 批量收割完成事件
int completed = 0;
while (completed < N) {
    io_uring_wait_cqe(&ring, &cqe);
    // ... 处理 cqe
    io_uring_cqe_seen(&ring, cqe);
    completed++;
}

五、高级特性深度解析

5.1 缓冲区注册（Buffer Registration / Fixed Buffers）

每次 IO 操作内核需要临时 pin 住用户内存页，完成后解除 pin。对于频繁的读写操作，这一开关开销显著。io_uring 提供 IORING_REGISTER_BUFFERS 允许用户预注册缓冲区数组，免除每次 pin/unpin：

// 注册一组预分配的缓冲区
struct iovec iovecs[BUFFERS_COUNT];
for (int i = 0; i < BUFFERS_COUNT; i++) {
    posix_memalign(&iovecs[i].iov_base, 4096, BUFFER_SIZE);
    iovecs[i].iov_len = BUFFER_SIZE;
}

io_uring_register_buffers(&ring, iovecs, BUFFERS_COUNT);

// 使用固定缓冲区编号进行 IO
sqe = io_uring_get_sqe(&ring);
io_uring_prep_read_fixed(sqe, fd, NULL, len, offset, buffer_index);
sqe->flags |= IOSQE_BUFFER_SELECT; // 让内核选择缓冲区

5.2 链式 SQE (Linked SQEs)

io_uring 支持将多个 SQE 标记为链式依赖，仅当上游操作成功时才执行下游操作。这在文件处理流水线、先读后压缩等场景下极为有用：

// 先读文件，再对读到的数据计算 checksum
struct io_uring_sqe *read_sqe = io_uring_get_sqe(&ring);
io_uring_prep_read(read_sqe, fd, buf, len, 0);
read_sqe->flags |= IOSQE_IO_LINK; // 链接到下一个操作

struct io_uring_sqe *write_sqe = io_uring_get_sqe(&ring);
io_uring_prep_write(write_sqe, out_fd, buf, len, 0);
write_sqe->flags |= IOSQE_IO_LINK;

struct io_uring_sqe *fsync_sqe = io_uring_get_sqe(&ring);
io_uring_prep_fsync(fsync_sqe, out_fd, 0);
// 最后一个 SQE 不需要 IOSQE_IO_LINK

io_uring_submit(&ring);
// 以上三个操作按顺序执行，如果 read 失败，链路中断，write 不会执行

5.3 轮选缓冲区组 (Buffer Select / Multi-shot)

在异步网络服务器中，io_uring 的 IORING_OP_PROVIDE_BUFFERS 和 IOSQE_BUFFER_SELECT 让内核自动从预注册缓冲区组中选择一个可用缓冲区，通过 CQE 中的 IORING_CQE_F_BUFFER 标志和 cqe->flags >> IORING_CQE_BUFFER_SHIFT 返回缓冲区索引：

// 自动缓冲区选择
sqe = io_uring_get_sqe(&ring);
io_uring_prep_recv(sqe, client_fd, NULL, 0, 0);
sqe->flags |= IOSQE_BUFFER_SELECT;
sqe->buf_group = group_id; // 缓冲池组 ID

// 处理完成事件
int buf_idx = cqe->flags >> IORING_CQE_BUFFER_SHIFT;
// 使用 registered_buffers[buf_idx] 处理收到的数据
io_uring_buf_ring_add(...);

5.4 SQPOLL + 注册文件 (Registered Files)

每次 IO 操作内核都需要 fget() / fput() 增加/减少文件引用计数。注册文件可以将 fd 预先关联到 io_uring 实例，后续 IO 使用数组索引而非 fd，消除引用操作开销：

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

// 使用注册文件索引（而非 fd）
sqe = io_uring_get_sqe(&ring);
io_uring_prep_read(sqe, 0, buf, len, 0); // fd=0 → 使用 file_array[0]
sqe->flags |= IOSQE_FIXED_FILE; // 标志：使用注册文件

// 动态替换注册文件（原子的）
int new_fd = open("new_file.txt", O_RDONLY);
int old_fds[] = {new_fd};
int indices[] = {0};
io_uring_register_files_update(&ring, indices, old_fds, 1);

六、性能基准对比

以下是 io_uring 与其他 IO 模式在 NVMe SSD 上的典型性能对比数据（OPS = 4KB 随机读写操作/秒）：

模式	读 IOPS	写 IOPS	延迟（P99）	CPU 使用率
read/write（同步）	~280K	~260K	142 μs	100%（单核）
线程池 + pread/pwrite	~520K	~480K	78 μs	400%（4核）
POSIX AIO	~180K	~170K	210 μs	85%（单核）
io_uring（默认）	~950K	~920K	42 μs	45%（单核）
io_uring + SQPOLL	~1.2M	~1.15M	28 μs	62%（含sq_thread）
io_uring + SQPOLL + FIXED	~2.1M	~1.9M	11 μs	58%（含sq_thread）

关键结论：io_uring + SQPOLL + 固定缓冲区/文件的组合在 NVMe 随机读写场景下已接近设备极限，比同步 IO 提升约 7 倍 IOPS，比 POSIX AIO 提升超过 10 倍。

七、实战案例：基于 io_uring 的高性能日志写入器

以下是一个基于 io_uring 的异步日志写入器实现要点，展示如何结合链式 SQE 实现"写入 + 定期 fsync"流水线：

struct log_writer {
    struct io_uring ring;
    int log_fd;
    void *write_buffer;
    size_t buffer_used;
};

// 写入日志条目（仅入队，不阻塞）
void log_write(struct log_writer *w, const char *data, size_t len) {
    // 缓冲区满时触发异步刷新
    if (w->buffer_used + len > BUFFER_SIZE) {
        submit_flush(w);
    }
    memcpy(w->write_buffer + w->buffer_used, data, len);
    w->buffer_used += len;
}

void submit_flush(struct log_writer *w) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(&w->ring);
    io_uring_prep_write(sqe, w->log_fd, w->write_buffer, w->buffer_used, w->offset);
    sqe->flags |= IOSQE_IO_LINK;

    // 链式 fsync（每第 N 次才 fsync，减少 fsync 频率）
    if (++w->sync_counter >= SYNC_INTERVAL) {
        struct io_uring_sqe *fsync_sqe = io_uring_get_sqe(&w->ring);
        io_uring_prep_fsync(fsync_sqe, w->log_fd, 0);
        w->sync_counter = 0;
    }

    io_uring_submit(&w->ring);
    w->buffer_used = 0;
    w->offset += buffer_used;
}

该方案相比同步日志写入：

调用方永远不阻塞在 IO 上（micro-batching 批量写入）
fsync 与 write 形成流水线，减少阻塞等待
单次 io_uring_submit() 可携带多个操作，摊薄系统调用开销

八、io_uring 与 epoll 的关系

io_uring 并非 epoll 的替代品——两者解决不同层次的问题：

epoll：高效监听大量 fd 的 IO 就绪状态（level-triggered / edge-triggered）
io_uring：高效执行异步 IO 操作本身（read/write/send/recv/fsync 等）

在现代高性能架构中，两者可以协同使用：

//  io_uring 接管网络 IO 后的典型事件循环
struct io_uring ring;
io_uring_queue_init(4096, &ring, IORING_SETUP_SQPOLL);

// 1. 提交所有已知的 recv 请求
for (int i = 0; i < client_count; i++) {
    sqe = io_uring_get_sqe(&ring);
    io_uring_prep_recv(sqe, clients[i].fd, clients[i].buf, BUF_SIZE, 0);
    sqe->flags |= IOSQE_FIXED_FILE | IOSQE_BUFFER_SELECT;
}

// 2. 处理完成事件
while (running) {
    io_uring_wait_cqe(&ring, &cqe);
    if (cqe->res > 0) {
        // 收到数据，处理后发送响应
        process_and_respond(cqe);
    }
    io_uring_cqe_seen(&ring, cqe);
}

在 Netty、Tokio（Rust）、Golang 等现代异步运行时下，io_uring 后端正在逐渐替代传统的 epoll + 线程池模型，成为 Linux 上新一代异步 IO 标准。

九、版本演进与新特性

Linux 版本	io_uring 新特性
5.1	初始版本：read/write/open/close/fsync 支持，基本 SQ/CQ 机制
5.5	IORING_OP_PROVIDE_BUFFERS（缓冲池）、IORING_OP_REMOVE_BUFFERS
5.6	IORING_OP splice（管道切换）、IORING_OP tee、IOSQE_IO_LINK 链式任务
5.7	IORING_OP renameat/unlinkat/mkdir（文件系统元操作）
5.10	IORING_OP shutdown（关闭连接）、IORING_FEAT_NATIVE_WORKER
5.15	IORING_OP futex（快速用户态互斥锁），多 shot accept
5.19	IORING_OP fixed_buffer_fixed_file 组合优化、tabular SQE
6.1	IORING_OP uring_cmd（直通 NVMe 管理命令）、升级 SQPOLL
6.5+	进一步增强 SQPOLL 优先级调度、IORING_OP sendmsg/recvmsg 走 io_uring

十、工程实践建议与注意事项

综合以上分析，以下是 io_uring 应用的关键指导原则：

批量原则：尽可能积累一批 SQE 后统一提交，每次 io_uring_submit() 系统调用可携带数十个操作，最大化摊薄开销
固定资源：在长期使用场景下，务必 register_buffers + register_files，可以减少 15-25% 的内核开销
SQPOLL 慎用：SQPOLL 线程占用一个 CPU 核心始终以 100% 速率轮询（除非 idle 超时）。在共享核心部署时，考虑设置 IORING_SETUP_SQ_AFF 绑定核心
语义差异：注意 O_DIRECT 与 buffered IO 在 io_uring 下行为不同（如 write 可能 ERROR -EAGAIN 变为缓冲区背压信号）
内核版本兼容：生产环境至少要求 Linux 5.10+（推荐 5.15+），并通过 io_uring_params.features 字段探测特性可用性
缓冲区生命周期：在异步操作使用中的缓冲区绝对不能被释放或重新定位，必须等待 CQE 返回后才能回收

在实际工程中，推荐优先使用成熟的用户态封装如 liburing（C/C++）、tokio-uring（Rust）、uring-glue（Go），而非直接调用 syscall。这些封装库处理了内存屏障、环边缘检测、批量收割等底层细节，提供更高层的 Future/Async 抽象。

总结

io_uring 是 Linux 内核近十年来最重要的 IO 子系统革新。通过共享内存环形缓冲区与零系统调用提交机制，它将异步 IO 的性能天花板从 "微秒级系统调用开销" 降低到 "纳秒级内存屏障"。在传统同步模型下需要数百个线程 + epoll 才能达到的吞吐量，io_uring 在单个核心 + 内核线程组合下即可实现。

它的成功不仅在于性能提升，更重要的是：它让异步 IO 终于从「知道存在但工程上不可用」变成了「简单可靠的标准工具」。在 NVMe 存储、网络服务、数据处理流水线等场景中，io_uring 正在成为现代 Linux 高层程序设计的默认选择。

点赞(0) 打赏

本文分类：编程技术
本文标签：io_uring 异步IO Linux内核
浏览次数：1 次浏览
发布日期：2026-09-30 12:09:32
本文链接：https://www.ybb.press/programming/10197.html

上一篇 > 深入 Rust 零成本抽象：从泛型单态化到特征对象的编译期与运行时权衡深度实战
下一篇 >

深入剖析 Linux io_uring：异步IO革命与高性能用户态文件操作实战

深入剖析 Linux io_uring：异步IO革命与高性能用户态文件操作实战

一、异步IO的演进之路：从阻塞到异步

二、io_uring 核心架构：SQ/CQ 双环设计

2.1 数据结构布局

三、三种工作模式

3.1 SQPOLL 模式详解

四、liburing 使用指南

4.1 基础读取操作

4.2 批量提交优化

五、高级特性深度解析

5.1 缓冲区注册（Buffer Registration / Fixed Buffers）

5.2 链式 SQE (Linked SQEs)

5.3 轮选缓冲区组 (Buffer Select / Multi-shot)

5.4 SQPOLL + 注册文件 (Registered Files)

六、性能基准对比

七、实战案例：基于 io_uring 的高性能日志写入器

八、io_uring 与 epoll 的关系

九、版本演进与新特性

十、工程实践建议与注意事项

总结

评论列表共有 0 条评论

发表评论取消回复

深入剖析 Linux io_uring：异步IO革命与高性能用户态文件操作实战

深入剖析 Linux io_uring：异步IO革命与高性能用户态文件操作实战

一、异步IO的演进之路：从阻塞到异步

二、io_uring 核心架构：SQ/CQ 双环设计

2.1 数据结构布局

三、三种工作模式

3.1 SQPOLL 模式详解

四、liburing 使用指南

4.1 基础读取操作

4.2 批量提交优化

五、高级特性深度解析

5.1 缓冲区注册（Buffer Registration / Fixed Buffers）

5.2 链式 SQE (Linked SQEs)

5.3 轮选缓冲区组 (Buffer Select / Multi-shot)

5.4 SQPOLL + 注册文件 (Registered Files)

六、性能基准对比

七、实战案例：基于 io_uring 的高性能日志写入器

八、io_uring 与 epoll 的关系

九、版本演进与新特性

十、工程实践建议与注意事项

总结

Linux eBPF 深度剖析：从内核虚拟机到可观测性革命的完整实战指南

Linux 内核 io_uring 深度剖析：零 syscall IO 的架构革命与 NVMe 百万 IOPS 实战

Linux eBPF Ring Buffer 与 Iterator 深度实战：重塑内核态-用户态数据流

深入剖析 Linux io_uring：异步IO革命与高性能用户态文件操作实战

评论列表 共有 0 条评论

发表评论 取消回复

评论列表共有 0 条评论

发表评论取消回复