io_uring 异步 I/O：从 SQ/CQ 环形队列到生产落地

同步模型：   应用 → syscall → 内核执行 IO → 返回 → 应用 → syscall → ...
             （每次 IO 都要陷入一次内核，串行等待）

io_uring：   应用批量填 SQ → 一次 io_uring_enter → 内核异步执行
             内核写 CQ ← 应用无锁收割（可选择性陷入）

假设单次 sync read 固定开销 ≈ 1.5 μs（syscall + 切换 + 对象建立）
50 万 IOPS × 1.5 μs = 0.75 s CPU 时间/秒  → 单核几乎全耗在「调度」而非「干活」
io_uring 批量提交后固定开销摊薄到 ≈ 0.1 μs/IO 量级

                 ┌──────────── 共享内存（mmap）────────────┐
应用写 →  SQ ring │  sqe[0] sqe[1] sqe[2] ... sqe[N]        │
（提交队列）      │   tail(应用写) / head(内核读)             │
                 ├─────────────────────────────────────────┤
内核写 →  CQ ring │  cqe[0] cqe[1] ... cqe[M]                │
（完成队列）      │   head(应用读) / tail(内核写)             │
                 └─────────────────────────────────────────┘

提交路径：填 SQE → 推进 SQ tail → （可选）io_uring_enter 唤醒内核
收割路径：读 CQ head → 处理 CQE → 推进 CQ head（不陷入内核）

/* 把请求结构体指针塞进 user_data，完成时取回 */
struct req { int id; char *buf; };
struct req r = { .id = 42 };
io_uring_sqe_set_data(sqe, &r);
/* ... 收割时 ... */
struct req *done = io_uring_cqe_get_data(cqe);

# Debian/Ubuntu 安装开发库
sudo apt install liburing-dev
# RHEL 系
sudo dnf install liburing-devel
# 确认内核支持（5.1 起步，5.6+ 更完整）
uname -r

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

int main(void) {
    struct io_uring ring;
    /* 队列深度 8：表示最多 8 个在途请求 */
    io_uring_queue_init(8, &ring, 0);

    int fd = open("/etc/hostname", O_RDONLY);
    char buf[4096];

    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_read(sqe, fd, buf, sizeof(buf), 0);
    io_uring_sqe_set_data(sqe, buf);      /* user_data 回传 */

    io_uring_submit(&ring);               /* 提交，必要时 io_uring_enter */

    struct io_uring_cqe *cqe;
    io_uring_wait_cqe(&ring, &cqe);       /* 等一个完成 */
    if (cqe->res < 0)
        fprintf(stderr, "read failed: %d\n", cqe->res);
    else
        fwrite(buf, 1, cqe->res, stdout);

    io_uring_cqe_seen(&ring, cqe);        /* 推进 CQ head */
    io_uring_queue_exit(&ring);
    close(fd);
    return 0;
}

gcc -O2 -o uread uread.c -luring
./uread

/* 注册一组 fd，之后 SQE 里用索引代替 fd */
int fds[2] = { fd_a, fd_b };
io_uring_register_files(&ring, fds, 2);
io_uring_prep_read(sqe, 0, buf, len, off);   /* 0 表示第 0 个注册 fd */
sqe->flags |= IOSQE_FIXED_FILE;

/* 注册固定缓冲，内核提前 pin 页并建立映射 */
io_uring_register_buffers(&ring, iovecs, nr);
sqe->buf_index = 0;                          /* 用第 0 块固定缓冲 */

struct io_uring_params p = {0};
p.flags = IORING_SETUP_SQPOLL;
p.sq_thread_idle = 2000;      /* 空闲 2 秒后内核线程休眠（毫秒） */
io_uring_queue_init_params(256, &ring, &p);

/* 应用只需检查 SQ 是否被内核「看到」，无需 enter */
if (io_uring_sq_ready(&ring))
    io_uring_sqring_wait(&ring);   /* SQPOLL 下的等待原语 */

# 运行后可见内核轮询线程 [iou-sqp-xxxx]
ps -eLf | grep iou-sqp
# 查看当前进程的 io_uring 实例
ls -l /proc/<pid>/fd | grep io_uring

/* 顺序：read → write → fsync，任一失败则后续取消 */
io_uring_prep_read(sqe1, fd_in, buf, len, 0);
sqe1->flags |= IOSQE_IO_LINK;

io_uring_prep_write(sqe2, fd_out, buf, len, 0);
sqe2->flags |= IOSQE_IO_LINK;

io_uring_prep_fsync(sqe3, fd_out, 0);   /* 链尾，无 LINK */

/* 多 shot recv：一次提交，多次完成，直到显式取消 */
io_uring_prep_recv_multishot(sqe, sockfd, NULL, 0, 0);
sqe->flags |= IOSQE_BUFFER_SELECT;
sqe->buf_group = 0;                 /* 从注册的 buffer group 0 取缓冲 */

/* 收割：每个 CQE 的 res 是本次收到字节数，flags 含 IORING_CQE_F_MORE 表示还有后续 */

loop:
  1. 有请求要发 → io_uring_get_sqe + prep_* + io_uring_submit
  2. 没有要发的   → io_uring_submit_and_wait(&ring, 1) 阻塞等一个完成
  3. 批量 peek CQE（io_uring_peek_batch_cqe）→ 逐个处理
  4. 处理完 → io_uring_cq_advance 一次性推进 head（比逐个 seen 更快）

# PostgreSQL：io_uring 相关（部分版本/补丁集）
# postgresql.conf 中 io_method 相关开关视版本而定
# RocksDB：编译期启用 io_uring
# nginx：--with-io_uring 编译开关
# ScyllaDB / 部分 KV 存储：原生 io_uring 后端

# 检查内核是否支持 io_uring（探测 io_uring_setup 系统调用）
grep -w io_uring_setup /proc/kallsyms >/dev/null && echo supported
# 部分发行版限制非特权用户使用
sysctl kernel.io_uring_disabled
# 值：0=不限制 1=仅特权 2=完全禁用（较新内核引入）

# 1. seccomp：Docker 默认 profile 早期会拦截 io_uring_setup
#    新版 Docker/libseccomp 已放行，但自定义 seccomp 需显式允许
# 2. 内核开关（5.12+ 引入）
sysctl kernel.io_uring_disabled    # 0 允许 / 1 仅特权 / 2 禁用
# 3. cgroup：SQPOLL 内核线程会计入所属 cgroup 的 CPU 消耗

# strace 追踪提交/收割入口
strace -e trace=io_uring_setup,io_uring_enter,io_uring_register -f ./app

# 用 bpftrace 统计各 opcode 的提交次数（需要内核支持 io_uring tracepoint）
bpftrace -e 'tracepoint:io_uring:io_uring_submit_sqe { @[args->opcode] = count(); }'

# 查看进程的 io_uring 实例与其参数
ls -l /proc/<pid>/fd | grep io_uring
cat /proc/<pid>/fdinfo/<ring_fd>     # 显示 SQ/CQ 指针、提交数等

# 对比压测：libaio vs io_uring 引擎
fio --name=t --rw=randread --bs=4k --iodepth=64 --ioengine=libaio --filename=/dev/nvme0n1 --direct=1 --runtime=30 --time_based
fio --name=t --rw=randread --bs=4k --iodepth=64 --ioengine=io_uring --filename=/dev/nvme0n1 --direct=1 --runtime=30 --time_based