io_uring 在生产环境翻车实录：内核 bug、资源泄漏和你不知道的限制

struct io_uring_params params = {0};
params.flags = IORING_SETUP_SQPOLL;
params.sq_thread_idle = 10000; // 10 秒，单位毫秒

int ring_fd = io_uring_setup(256, &params);

$ top -H -p $(pgrep -f our_service)
  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 8341 root      20   0       0      0      0 R  99.7   0.0   4:32.11 io_sq_thread
 8340 nobody    20   0  128.5m  12.3m   8.1m S   0.3   0.1   0:01.22 our_service

// 简化的 5.4 sq_thread 内核逻辑 (fs/io_uring.c)
static int io_sq_thread(void *data)
{
    while (!kthread_should_stop()) {
        if (!io_sqring_entries(ctx)) {
            // 注意：这里不是真正的 sleep！
            cond_resched();
            // 在某些调度配置下，cond_resched() 几乎是 no-op
            continue;
        }
        // 处理 SQE...
    }
    return 0;
}

struct io_uring_params params = {0};
params.flags = IORING_SETUP_SQPOLL;
params.sq_thread_idle = 2000; // 2 秒：在延迟和 CPU 之间权衡

// 5.11+ 还可以绑定到指定 CPU
params.flags |= IORING_SETUP_SQ_AFF;
params.sq_thread_cpu = 3; // 绑定到 CPU 3

// 提交请求前，检查 sq_thread 是否需要唤醒
void submit_with_wakeup(struct io_uring *ring)
{
    // 读取 SQ flags，检查 IORING_SQ_NEED_WAKEUP 标志
    unsigned flags = IO_URING_READ_ONCE(*ring->sq.kflags);

    if (flags & IORING_SQ_NEED_WAKEUP) {
        // sq_thread 已休眠，需要通过 enter 唤醒
        io_uring_enter(ring->ring_fd, 0, 0, IORING_ENTER_SQ_WAKEUP, NULL, 0);
    }

    // 如果用 liburing，这些逻辑已经封装好了：
    // io_uring_submit(ring); // liburing 自动处理唤醒
}

params.flags = IORING_SETUP_SQPOLL | IORING_SETUP_COOP_TASKRUN;
// 更进一步：SINGLE_ISSUER 告诉内核只有一个线程提交请求
params.flags |= IORING_SETUP_SINGLE_ISSUER;

#!/bin/bash
# 监控 io_sq_thread 的 CPU 使用率
# 如果连续 30 秒超过 90%，触发告警

THRESHOLD=90
DURATION=30
COUNT=0

while true; do
    CPU=$(ps -eo pid,comm,%cpu --no-headers | grep io_sq_thread | awk '{print $3}' | head -1)
    if [ -n "$CPU" ] && (( $(echo "$CPU > $THRESHOLD" | bc -l) )); then
        COUNT=$((COUNT + 1))
        if [ $COUNT -ge $DURATION ]; then
            echo "ALERT: io_sq_thread at ${CPU}% CPU for ${DURATION}s" >&2
            # 发送告警到你的监控系统
            COUNT=0
        fi
    else
        COUNT=0
    fi
    sleep 1
done

# 通过 node_exporter 的 process collector 抓取
# 或者直接从 /proc/<pid>/stat 解析
cat /proc/$(pgrep io_sq_thread)/stat | awk '{print $14+$15}'
# 输出：utime + stime（单位：clock ticks）

// 注册 fixed buffers
struct iovec iovs[2];
void *buf1 = aligned_alloc(4096, BUFFER_SIZE);
void *buf2 = aligned_alloc(4096, BUFFER_SIZE);

iovs[0].iov_base = buf1;
iovs[0].iov_len = BUFFER_SIZE;
iovs[1].iov_base = buf2;
iovs[1].iov_len = BUFFER_SIZE;

int ret = io_uring_register_buffers(&ring, iovs, 2);
if (ret < 0) {
    fprintf(stderr, "register_buffers failed: %s\n", strerror(-ret));
}

// 泄漏模式：创建 ring，注册 buffer，但忘记清理
void leaky_worker() {
    struct io_uring ring;
    io_uring_queue_init(256, &ring, 0);

    struct iovec iov = { .iov_base = malloc(1 << 20), .iov_len = 1 << 20 };
    io_uring_register_buffers(&ring, &iov, 1);

    // ... 做一些 I/O ...

    // 函数返回了，但没有调用：
    // io_uring_unregister_buffers(&ring);
    // io_uring_queue_exit(&ring);
    //
    // ring fd 泄漏 -> 1MB 页面永久 pin 住
    // malloc 的内存也泄漏了 -> 双重泄漏
}

// 复现：注册 -> 取消注册 -> 检查内存
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <liburing.h>

static long get_unevictable_kb(void) {
    FILE *f = fopen("/proc/meminfo", "r");
    char line[256];
    long val = 0;
    while (fgets(line, sizeof(line), f)) {
        if (sscanf(line, "Unevictable: %ld kB", &val) == 1) break;
    }
    fclose(f);
    return val;
}

int main(void) {
    const int BUF_SIZE = 2 * 1024 * 1024; // 2MB，触发 huge page
    const int ITERATIONS = 100;

    long baseline = get_unevictable_kb();
    printf("Baseline Unevictable: %ld kB\n", baseline);

    for (int i = 0; i < ITERATIONS; i++) {
        struct io_uring ring;
        io_uring_queue_init(32, &ring, 0);

        // 使用 mmap 分配，可能触发 transparent huge page
        void *buf = mmap(NULL, BUF_SIZE, PROT_READ | PROT_WRITE,
                         MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
        if (buf == MAP_FAILED) {
            // 回退到普通页面
            buf = aligned_alloc(4096, BUF_SIZE);
            if (!buf) continue;
        }
        memset(buf, 0, BUF_SIZE);

        struct iovec iov = { .iov_base = buf, .iov_len = BUF_SIZE };
        io_uring_register_buffers(&ring, &iov, 1);
        io_uring_unregister_buffers(&ring);

        if (buf != MAP_FAILED)
            munmap(buf, BUF_SIZE);
        else
            free(buf);

        io_uring_queue_exit(&ring);
    }

    long after = get_unevictable_kb();
    printf("After %d iterations: Unevictable: %ld kB (delta: %+ld kB)\n",
           ITERATIONS, after, after - baseline);

    if (after - baseline > 1024) {
        printf("WARNING: Possible fixed buffer memory leak detected!\n");
    }

    return 0;
}

// 正确做法：RAII 风格的 ring + buffer 管理

struct ring_context {
    struct io_uring ring;
    struct iovec *bufs;
    int nr_bufs;
    int buffers_registered;
};

int ring_ctx_init(struct ring_context *ctx, int queue_depth,
                  int nr_bufs, size_t buf_size)
{
    int ret = io_uring_queue_init(queue_depth, &ctx->ring, 0);
    if (ret < 0) return ret;

    ctx->bufs = calloc(nr_bufs, sizeof(struct iovec));
    ctx->nr_bufs = nr_bufs;
    ctx->buffers_registered = 0;

    for (int i = 0; i < nr_bufs; i++) {
        ctx->bufs[i].iov_base = aligned_alloc(4096, buf_size);
        ctx->bufs[i].iov_len = buf_size;
        if (!ctx->bufs[i].iov_base) {
            ring_ctx_destroy(ctx);
            return -ENOMEM;
        }
    }

    ret = io_uring_register_buffers(&ctx->ring, ctx->bufs, nr_bufs);
    if (ret < 0) {
        ring_ctx_destroy(ctx);
        return ret;
    }
    ctx->buffers_registered = 1;

    return 0;
}

void ring_ctx_destroy(struct ring_context *ctx)
{
    // 顺序很重要：先 unregister，再 exit，最后 free
    if (ctx->buffers_registered) {
        io_uring_unregister_buffers(&ctx->ring);
        ctx->buffers_registered = 0;
    }
    io_uring_queue_exit(&ctx->ring);

    if (ctx->bufs) {
        for (int i = 0; i < ctx->nr_bufs; i++) {
            free(ctx->bufs[i].iov_base);
        }
        free(ctx->bufs);
        ctx->bufs = NULL;
    }
}

# 监控不可回收内存
watch -n 1 'grep -E "Unevictable|Mlocked" /proc/meminfo'

# 正常服务：Unevictable 应该稳定
# 如果持续增长 -> 可能是 fixed buffer 泄漏

# 查看进程 pin 住了多少内存
grep VmPin /proc/$(pgrep our_service)/status
# VmPin:     4096 kB   <- 正常：4MB 的 fixed buffers
# VmPin:  1048576 kB   <- 异常：1GB 被 pin 住了

# 用 bpftrace 追踪 register/unregister 的不匹配
bpftrace -e '
kprobe:__io_uring_register {
    @reg[tid] = count();
}
kprobe:io_destroy_buffers {
    @unreg[tid] = count();
}
END {
    printf("Registers: "); print(@reg);
    printf("Unregisters: "); print(@unreg);
}
'

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

int check_op_supported(int op)
{
    struct io_uring_probe *probe = io_uring_get_probe();
    if (!probe) {
        fprintf(stderr, "io_uring_get_probe() failed: io_uring not available\n");
        return 0;
    }

    int supported = io_uring_opcode_supported(probe, op);
    io_uring_free_probe(probe);
    return supported;
}

void print_feature_support(void)
{
    struct {
        int op;
        const char *name;
    } ops[] = {
        { IORING_OP_NOP,           "NOP" },
        { IORING_OP_READV,         "READV" },
        { IORING_OP_WRITEV,        "WRITEV" },
        { IORING_OP_READ_FIXED,    "READ_FIXED" },
        { IORING_OP_WRITE_FIXED,   "WRITE_FIXED" },
        { IORING_OP_POLL_ADD,      "POLL_ADD" },
        { IORING_OP_ACCEPT,        "ACCEPT" },
        { IORING_OP_CONNECT,       "CONNECT" },
        { IORING_OP_SEND,          "SEND" },
        { IORING_OP_RECV,          "RECV" },
        { IORING_OP_SPLICE,        "SPLICE" },
        { IORING_OP_PROVIDE_BUFFERS, "PROVIDE_BUFFERS" },
        { IORING_OP_SHUTDOWN,      "SHUTDOWN" },
        { IORING_OP_SEND_ZC,       "SEND_ZC" },
    };
    int nr = sizeof(ops) / sizeof(ops[0]);

    struct io_uring_probe *probe = io_uring_get_probe();
    if (!probe) {
        printf("io_uring not available on this system.\n");
        return;
    }

    printf("io_uring feature support (probe reports %d ops):\n", probe->last_op + 1);
    for (int i = 0; i < nr; i++) {
        int supported = io_uring_opcode_supported(probe, ops[i].op);
        printf("  %-20s %s\n", ops[i].name,
               supported ? "\033[32m✓\033[0m" : "\033[31m✗\033[0m");
    }

    io_uring_free_probe(probe);
}

int main(void) {
    print_feature_support();
    return 0;
}

// 启动时探测，运行时分派

struct uring_capabilities {
    int has_sqpoll;
    int has_fixed_files;
    int has_splice;
    int has_accept;
    int has_send_zc;
    int has_multishot_accept;
    int has_coop_taskrun;
};

static struct uring_capabilities g_caps;

int init_uring_capabilities(void)
{
    struct io_uring_probe *probe = io_uring_get_probe();
    if (!probe) return -1;

    g_caps.has_sqpoll       = 1; // flag-based, 需要尝试 setup
    g_caps.has_fixed_files  = 1;
    g_caps.has_splice       = io_uring_opcode_supported(probe, IORING_OP_SPLICE);
    g_caps.has_accept       = io_uring_opcode_supported(probe, IORING_OP_ACCEPT);
    g_caps.has_send_zc      = io_uring_opcode_supported(probe, IORING_OP_SEND_ZC);

    io_uring_free_probe(probe);

    // SQPOLL 和 COOP_TASKRUN 是 setup flags，不是 opcodes
    // 需要尝试创建 ring 来检测
    struct io_uring test_ring;
    struct io_uring_params p = {0};
    p.flags = IORING_SETUP_SQPOLL;
    p.sq_thread_idle = 100;

    if (io_uring_queue_init_params(4, &test_ring, &p) == 0) {
        g_caps.has_sqpoll = 1;
        io_uring_queue_exit(&test_ring);
    } else {
        g_caps.has_sqpoll = 0;
    }

    // 检测 COOP_TASKRUN (5.19+)
    memset(&p, 0, sizeof(p));
    p.flags = IORING_SETUP_COOP_TASKRUN;
    if (io_uring_queue_init_params(4, &test_ring, &p) == 0) {
        g_caps.has_coop_taskrun = 1;
        io_uring_queue_exit(&test_ring);
    }

    return 0;
}

// 根据检测结果选择 I/O 路径
void do_accept(struct io_uring *ring, int listen_fd)
{
    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);

    if (g_caps.has_multishot_accept) {
        io_uring_prep_multishot_accept(sqe, listen_fd, NULL, NULL, 0);
    } else if (g_caps.has_accept) {
        io_uring_prep_accept(sqe, listen_fd, NULL, NULL, 0);
    } else {
        // 回退到 epoll + accept4
        fallback_epoll_accept(listen_fd);
        return;
    }

    io_uring_submit(ring);
}

// 简化的旧内核逻辑
static bool io_cqring_overflow_flush(struct io_ring_ctx *ctx)
{
    if (io_cqring_is_full(ctx)) {
        // CQ 满了，直接丢弃这个 CQE！
        // 只是递增一个计数器
        ctx->cq_overflow++;
        return false;  // CQE 被丢弃
    }
    // ...
}

// 灾难场景示例：
// 1. 提交 100 个 read 请求
// 2. 所有 read 完成，但 CQ 只有 64 个位置
// 3. 36 个 CQE 被丢弃
// 4. 你只知道 64 个 read 完成了
// 5. 那 36 个 read 的 buffer 内容是正确的，但你不知道
// 6. 你永远在等那 36 个 CQE，服务挂起

// 5.15+ 的行为
static bool io_cqring_event_overflow(struct io_ring_ctx *ctx,
                                      u64 user_data, s32 res,
                                      u32 cflags, u64 extra1, u64 extra2)
{
    struct io_overflow_cqe *ocqe;

    // 分配 overflow 条目（从 slab cache）
    ocqe = kmalloc(sizeof(*ocqe), GFP_ATOMIC);
    if (!ocqe) {
        // 极端情况：内存不足，才真的丢弃
        ctx->cq_extra--;
        return false;
    }

    // 保存到 overflow list
    ocqe->cqe.user_data = user_data;
    ocqe->cqe.res = res;
    ocqe->cqe.flags = cflags;
    list_add_tail(&ocqe->list, &ctx->cq_overflow_list);

    // 设置 overflow 标志，通知用户态
    WRITE_ONCE(ctx->rings->sq_flags,
               ctx->rings->sq_flags | IORING_SQ_CQ_OVERFLOW);
    return true;
}

// 每次收割 CQE 后检查 overflow
int harvest_completions(struct io_uring *ring)
{
    struct io_uring_cqe *cqe;
    unsigned head;
    int count = 0;

    io_uring_for_each_cqe(ring, head, cqe) {
        handle_completion(cqe);
        count++;
    }
    io_uring_cq_advance(ring, count);

    // 检查是否发生过 overflow
    unsigned sq_flags = IO_URING_READ_ONCE(*ring->sq.kflags);
    if (sq_flags & IORING_SQ_CQ_OVERFLOW) {
        fprintf(stderr, "WARNING: CQ overflow detected! "
                "Consider increasing CQ size.\n");
        // 在 5.15+ 上，overflow 的 CQE 会在下一次有空间时自动刷回
        // 但如果你在 5.15 之前的内核上看到这个... 数据已经丢了
    }

    return count;
}

// 方法一：设置 CQ 大小为 SQ 的 4 倍（保守）
struct io_uring_params params = {0};
params.flags = IORING_SETUP_CQSIZE;
params.cq_entries = 4096; // SQ = 1024, CQ = 4096

int ret = io_uring_queue_init_params(1024, &ring, &params);

// 方法二：根据实际并发量计算
// CQ 大小 >= 最大在途请求数 × 2（留安全余量）
// 例如：最多同时 500 个请求 -> CQ 至少 1024（2 的幂，>= 1000）

// timeout 正常过期：res = -ETIME
// timeout 被 cancel 取消：res = -ECANCELED
// linked timeout 触发（超时了后面的操作）：res = -ETIME
// linked timeout 的目标操作先完成：res = -ECANCELED

// 常见错误：把 -ETIME 和 -ECANCELED 混为一谈
void handle_timeout_cqe(struct io_uring_cqe *cqe)
{
    if (cqe->res == -ETIME) {
        // 超时真的发生了
        handle_real_timeout(cqe->user_data);
    } else if (cqe->res == -ECANCELED) {
        // 超时被取消——可能是因为目标操作已完成
        // 这不是错误！不要 log error！
    } else if (cqe->res == 0) {
        // timeout 在指定的完成数达到后正常返回
        // （IORING_TIMEOUT_ABS 或 count-based timeout）
    }
}

// 竞态：你提交 cancel 的时候，目标操作可能已经完成了
//
// Timeline:
// t0: 提交 read (user_data = 42)
// t1: read 完成，CQE 入队
// t2: 你提交 cancel(user_data = 42)
// t3: cancel 的 CQE：res = -ENOENT（找不到目标）
//
// 你会收到两个 CQE：
//   1. read 的 CQE (res = bytes_read)
//   2. cancel 的 CQE (res = -ENOENT)
//
// 如果 cancel 成功：
//   1. read 的 CQE (res = -ECANCELED)
//   2. cancel 的 CQE (res = 0)

// 正确处理：
void handle_cancel_result(struct io_uring_cqe *cqe)
{
    switch (cqe->res) {
    case 0:
        // 成功取消，目标操作会产生一个 -ECANCELED 的 CQE
        break;
    case -ENOENT:
        // 目标操作不存在（已完成或从未提交）
        // 检查是否已经收到了目标操作的 CQE
        break;
    case -EALREADY:
        // 目标操作正在进行，取消已提交但结果不确定
        // 需要等待目标操作的 CQE 来确认
        break;
    }
}

void handle_multishot_accept(struct io_uring *ring, struct io_uring_cqe *cqe,
                             int listen_fd)
{
    if (cqe->res >= 0) {
        int client_fd = cqe->res;
        setup_client_connection(ring, client_fd);

        // 检查是否还在 multishot 模式
        if (!(cqe->flags & IORING_CQE_F_MORE)) {
            // multishot 结束了！需要重新提交
            resubmit_multishot_accept(ring, listen_fd);
        }
    } else if (cqe->res == -ENOBUFS) {
        // 资源不足，multishot 已停止
        fprintf(stderr, "multishot accept: -ENOBUFS, resubmitting\n");
        resubmit_multishot_accept(ring, listen_fd);
    } else {
        fprintf(stderr, "accept error: %s\n", strerror(-cqe->res));
    }
}

void resubmit_multishot_accept(struct io_uring *ring, int listen_fd)
{
    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
    io_uring_prep_multishot_accept(sqe, listen_fd, NULL, NULL, 0);
    io_uring_sqe_set_data64(sqe, ACCEPT_TAG);
    io_uring_submit(ring);
}

// 危险模式
struct io_uring ring;
io_uring_queue_init(256, &ring, 0);

pid_t pid = fork();
if (pid == 0) {
    // 子进程：ring fd 被继承了！
    // 以下操作全部是未定义行为：
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_nop(sqe);
    io_uring_submit(&ring);
    // 可能导致：段错误、数据损坏、内核 oops
}

// 方案一：fork 前关闭 ring
io_uring_queue_exit(&ring);
pid_t pid = fork();
if (pid == 0) {
    // 子进程：重新创建 ring
    io_uring_queue_init(256, &ring, 0);
}

// 方案二：fork 后在子进程中立即关闭 ring fd
pid_t pid = fork();
if (pid == 0) {
    // 立即关闭继承的 ring fd，不做任何 io_uring 操作
    close(ring.ring_fd);
    if (ring.int_flags & INT_FLAG_REG_RING)
        close(ring.enter_ring_fd);
    // ... 子进程的逻辑 ...
}

// 方案三（推荐）：使用 CLONE_FILES 的反向操作
// 在创建 ring fd 时设置 close-on-exec
// liburing 默认就是这样做的（如果版本够新）

# 检查 io_uring 是否被 seccomp 限制
# 如果返回 EPERM 或 ENOSYS，说明被限制了
python3 -c "
import ctypes, os
libc = ctypes.CDLL('libc.so.6', use_errno=True)
# io_uring_setup syscall number (x86_64)
NR_IO_uring_setup = 425
ret = libc.syscall(NR_io_uring_setup, 1, ctypes.c_void_p(0))
err = ctypes.get_errno()
print(f'ret={ret}, errno={err} ({os.strerror(err)})')
# 正常：errno=14 (EFAULT) - 参数无效，但系统调用可用
# 被限制：errno=1 (EPERM) - 权限被拒绝
# 不存在：errno=38 (ENOSYS) - 系统调用不存在
"

# 方法一：使用自定义 seccomp profile
docker run --security-opt seccomp=custom-profile.json ...

# custom-profile.json 中需要允许：
# - io_uring_setup (425)
# - io_uring_enter (426)
# - io_uring_register (427)

# 方法二：禁用 seccomp（不推荐用于生产）
docker run --security-opt seccomp=unconfined ...

# 方法三：添加特定的 capability
docker run --cap-add SYS_ADMIN ...  # 过于宽泛，不推荐

cat << 'EOF' > iouring-seccomp.json
{
    "defaultAction": "SCMP_ACT_ALLOW",
    "syscalls": [
        {
            "names": ["io_uring_setup", "io_uring_enter", "io_uring_register"],
            "action": "SCMP_ACT_ALLOW"
        }
    ]
}
EOF

#!/bin/bash
# io_uring 生产就绪检查脚本
set -euo pipefail

PASS=0; FAIL=0; WARN=0

check() {
    local name="$1" result="$2"
    if [ "$result" = "pass" ]; then
        echo "  ✅ $name"
        ((PASS++))
    elif [ "$result" = "warn" ]; then
        echo "  ⚠️  $name"
        ((WARN++))
    else
        echo "  ❌ $name"
        ((FAIL++))
    fi
}

echo "=== io_uring 生产就绪检查 ==="
echo ""

# 1. 内核版本 >= 5.10
KVER=$(uname -r | cut -d- -f1)
KMAJOR=$(echo "$KVER" | cut -d. -f1)
KMINOR=$(echo "$KVER" | cut -d. -f2)
if [ "$KMAJOR" -gt 5 ] || { [ "$KMAJOR" -eq 5 ] && [ "$KMINOR" -ge 10 ]; }; then
    check "内核版本 >= 5.10 (当前: $KVER)" "pass"
else
    check "内核版本 >= 5.10 (当前: $KVER, 建议升级到 6.1 LTS)" "fail"
fi

# 2. io_uring 系统调用未被 seccomp 阻止
if python3 -c "
import ctypes, os, sys
libc = ctypes.CDLL('libc.so.6', use_errno=True)
ret = libc.syscall(425, 1, ctypes.c_void_p(0))  # io_uring_setup
err = ctypes.get_errno()
sys.exit(0 if err == 14 else 1)  # EFAULT=14 说明系统调用可用
" 2>/dev/null; then
    check "io_uring_setup 系统调用可用（未被 seccomp 阻止）" "pass"
else
    check "io_uring_setup 被阻止（检查 seccomp 配置）" "fail"
fi

# 3. SQPOLL 支持检测
if [ -f /proc/sys/kernel/io_uring_disabled ] && [ "$(cat /proc/sys/kernel/io_uring_disabled)" != "0" ]; then
    check "io_uring 被内核参数禁用 (io_uring_disabled=$(cat /proc/sys/kernel/io_uring_disabled))" "fail"
else
    check "io_uring 内核参数未禁用" "pass"
fi

# 4. 检查 /proc/sys/kernel/threads-max（SQPOLL 需要额外内核线程）
THREADS_MAX=$(cat /proc/sys/kernel/threads-max 2>/dev/null || echo "0")
if [ "$THREADS_MAX" -gt 10000 ]; then
    check "threads-max 足够 ($THREADS_MAX)" "pass"
else
    check "threads-max 偏低 ($THREADS_MAX)，SQPOLL 模式可能受限" "warn"
fi

# 5. memlock 限制检查（fixed buffers 需要锁定内存）
MEMLOCK=$(ulimit -l 2>/dev/null || echo "0")
if [ "$MEMLOCK" = "unlimited" ] || [ "$MEMLOCK" -gt 65536 ]; then
    check "memlock 限制足够 ($MEMLOCK KB)" "pass"
else
    check "memlock 限制偏低 ($MEMLOCK KB)，fixed buffers 可能失败" "warn"
fi

echo ""
echo "=== 结果: $PASS 通过, $WARN 警告, $FAIL 失败 ==="
[ "$FAIL" -eq 0 ] && echo "✅ 可以部署" || echo "❌ 请先修复失败项"

# 检查当前 Docker 版本
docker version --format '{{.Server.Version}}'

# 临时解决方案：使用自定义 seccomp profile
# 基于 Docker 默认 profile 增量修改，只加三个系统调用
docker run \
    --security-opt seccomp=iouring-seccomp.json \
    your-image:latest

# 或者更简单（但安全性更差）：
docker run --security-opt seccomp=unconfined your-image:latest

apiVersion: v1
kind: Pod
metadata:
  name: iouring-app
spec:
  securityContext:
    seccompProfile:
      type: Localhost
      # 这个文件需要放在节点的 /var/lib/kubelet/seccomp/ 下
      localhostProfile: profiles/iouring-allow.json
  containers:
  - name: app
    image: your-image:latest

{
    "defaultAction": "SCMP_ACT_ERRNO",
    "architectures": ["SCMP_ARCH_X86_64"],
    "syscalls": [
        {
            "names": ["io_uring_setup", "io_uring_enter", "io_uring_register"],
            "action": "SCMP_ACT_ALLOW"
        }
    ]
}