【eBPF 内核实现深度拆解】验证器框架：从 BPF_PROG_LOAD 到 do_check()

/* Linux 6.6: kernel/bpf/syscall.c:5006 */
SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, size)
{
    return __sys_bpf(cmd, USER_BPFPTR(uattr), size);
}

/* Linux 6.6: kernel/bpf/syscall.c:5013 */
static int __sys_bpf(int cmd, bpfptr_t uattr, unsigned int size)
{
    ...
    switch (cmd) {
    case BPF_PROG_LOAD:
        err = bpf_prog_load(&attr, uattr, size);
        break;
    case BPF_MAP_CREATE:
        ...
    }
}

/* Linux 6.6: kernel/bpf/syscall.c */
static int bpf_prog_load(union bpf_attr *attr, bpfptr_t uattr, u32 uattr_size)
{
    struct bpf_prog *prog;
    int ret;
    ...

    /* 1. 将 BPF 指令从用户态复制到内核缓冲区 */
    prog = bpf_prog_alloc(bpf_prog_size(attr->insn_cnt), GFP_USER);
    if (copy_from_bpfptr(prog->insns,
               make_bpfptr(attr->insns, uattr.is_kernel),
               bpf_prog_insn_size(prog)))
        goto free_prog;

    prog->len = attr->insn_cnt;

    /* 2. 分配辅助信息（每个指令的 verifier 元数据 + func_info） */
    ret = bpf_prog_alloc_aux(prog, attr);

    /* 3. 分配和复制程序名 */
    ...

    /* 4. 调用 verifier —— 核心安全检查 */
    ret = bpf_check(&prog, attr);

    /* 5. 验证通过后，分配 prog_array 引用 ID */
    ...

    /* 6. JIT 编译（如果启用） */
    ...

    /* 7. 分配文件描述符，返回给用户态 */
    ...
}

bpf(BPF_PROG_LOAD)
  └── __sys_bpf(BPF_PROG_LOAD)
        └── bpf_prog_load(attr)
              ├── bpf_prog_alloc()          // 分配 bpf_prog + 复制指令
              ├── bpf_prog_alloc_aux()      // 分配辅助数据
              └── bpf_check(&prog, attr)    // ★ 验证器入口
                    ├── check_cfg()          // 阶段 1：控制流图构建
                    ├── check_subprogs()     // 阶段 2：子程序边界分析
                    ├── do_check_main()      // 阶段 3：主验证循环
                    │     └── do_check()     // 逐条指令模拟执行
                    └── check_max_stack_depth() // 阶段 4：栈深度检查
                          (固定栈大小 512)

/* Linux 6.6: kernel/bpf/verifier.c */
struct bpf_verifier_env {
    struct bpf_prog *prog;              /* 正在验证的程序 */
    struct bpf_verifier_stack_elem *head;/* 验证 DFS 栈顶 */
    int stack_size;                     /* 当前栈深度 */
    
    struct bpf_verifier_state cur_state;/* 当前分析点的寄存器/栈状态 */
    struct bpf_verifier_state_list **explored_states;
                                        /* 已探索状态哈希表（用于 pruning） */
    struct bpf_insn_aux_data *insn_aux_data;
                                        /* 每条指令的辅助数据 */
    
    u32 pass_cnt;                       /* 验证的 pass 计数 */
    u32 subprog_cnt;                    /* 子程序数量 */
    
    /* 日志控制 */
    u32 log_level;
    char *log_buf;
    u32 log_size;
    u32 log_len;
    
    /* 限制 */
    u32 insn_processed;                 /* 已处理指令数 */
    u32 prev_insn_processed;
    
    /* BTF 相关信息 */
    struct btf *btf;
    struct btf *btf_vmlinux;
    ...
};

/* Linux 6.6: kernel/bpf/verifier.c - bpf_check() 简化 */
int bpf_check(struct bpf_prog **prog, union bpf_attr *attr, bpfptr_t uattr, ...)
{
    struct bpf_verifier_env *env;
    int ret;

    /* 1. 分配和初始化 bpf_verifier_env */
    env = kzalloc(sizeof(struct bpf_verifier_env), GFP_KERNEL);

    /* 2. 设置日志级别 */
    env->log_level = attr->log_level;

    /* 3. 初始化每条指令的辅助数据 */
    env->insn_aux_data = kvcalloc(prog->len, sizeof(*env->insn_aux_data), ...);

    /* 4. 阶段 1：构建控制流图 + 检测不可达代码 */
    ret = check_cfg(env);
    if (ret < 0)
        goto err_release;

    /* 5. 阶段 2：分析子程序边界（如果程序包含 BPF_PSEUDO_CALL） */
    ret = check_subprogs(env);
    if (ret < 0)
        goto err_release;

    /* 6. 阶段 3：主验证循环 —— 逐条模拟执行所有指令 */
    ret = do_check_main(env);
    if (ret < 0)
        goto err_release;

    /* 7. 阶段 4：检查最大栈深度（确保在 512 字节内） */
    ret = check_max_stack_depth(env);
    if (ret < 0)
        goto err_release;
    
    /* 8. 优化：移除不需要精确跟踪的指令标记 */
    ...
}

/* Linux 6.6: kernel/bpf/verifier.c - check_cfg() 核心逻辑简化 */
static int check_cfg(struct bpf_verifier_env *env)
{
    struct bpf_insn *insns = env->prog->insnsi;
    int insn_cnt = env->prog->len;
    int *insn_state;     /* 每条指令的遍历状态 */
    int *insn_stack;     /* DFS 栈 */
    int i, w = 0, peek_insn = 0;
    int t;

    insn_state = kvcalloc(insn_cnt, sizeof(int), GFP_KERNEL);
    insn_stack = kvcalloc(insn_cnt, sizeof(int), GFP_KERNEL);

    /* 状态值 */
    /* 0 = NOT_VISITED, 1 = EXPLORING, 2 = DONE */

    /* 将入口基本块推入栈 */
    insn_state[0] = EXPLORING;
    insn_stack[0] = 0;
    w = 1;   /* 栈指针 */

    while (w > 0) {
        t = insn_stack[w - 1];   /* peek 栈顶指令索引 */
        ...

对于每条指令 t：
  - 如果 t 是 BPF_JA (无条件跳转)：边 t → t + off + 1
  - 如果 t 是条件跳转 (BPF_JEQ 等)：
      两条边：t → t + 1 (fallthrough) 和 t → t + off + 1 (branch)
  - 如果 t 是 BPF_EXIT 或 caller 的末尾：叶子节点
  - 否则：单条边 t → t + 1 (顺序执行)

/* kernel/bpf/verifier.c - insn_aux_data 结构体（简化） */
struct bpf_insn_aux_data {
    union {
        struct bpf_loop_info loop_info;    /* 循环信息 */
    };
    u64 seen;                               /* 指令被访问的次数 */
    u32 loop_depth;                         /* 当前循环嵌套深度 */
    bool goto_visited;                      /* 跳转目标是否已访问 */
    ...
};

/* Linux 6.6: kernel/bpf/verifier.c - do_check_main() 简化 */
static int do_check_main(struct bpf_verifier_env *env)
{
    struct bpf_verifier_state *state;
    
    /* 创建入口状态 */
    state = kzalloc(sizeof(*state), GFP_KERNEL);
    
    /* 初始化 R1 = ctx (PTR_TO_CTX) */
    state->regs[BPF_REG_1].type = PTR_TO_CTX;
    state->regs[BPF_REG_1].off = 0;
    
    /* 初始化 R10 = frame pointer */
    state->regs[BPF_REG_10].type = PTR_TO_STACK;
    state->regs[BPF_REG_10].frameno = 0;
    
    /* 其他寄存器标记为 NOT_INIT */
    for (i = 0; i < MAX_BPF_REG; i++) {
        if (i != BPF_REG_1 && i != BPF_REG_10)
            mark_reg_not_init(env, state->regs, i);
    }
    
    /* 启动主循环——从基本块 0 开始 */
    ret = do_check(env);
    
    return ret;
}

/* Linux 6.6: kernel/bpf/verifier.c - do_check() 循环简化 */
static int do_check(struct bpf_verifier_env *env)
{
    struct bpf_insn *insns = env->prog->insnsi;
    struct bpf_reg_state *regs = state->regs;
    int insn_cnt = env->prog->len;

    env->prev_insn_processed = 0;

    for (;;) {
        struct bpf_insn *insn;
        u32 class;
        int err;

        /* 1. 获取当前状态下的下一条指令 */
        insn = &insns[env->insn_idx];

        /* 2. 复杂度检查（每次处理前检查） */
        if (env->insn_processed >= BPF_COMPLEXITY_LIMIT_INSNS) {
            verbose(env, "BPF program is too large. "
                "Processed %d insn\n", env->insn_processed);
            return -E2BIG;
        }

        /* 3. 分类并分发到类型特定的检查器 */
        class = BPF_CLASS(insn->code);

        switch (class) {
        case BPF_ALU:
        case BPF_ALU64:
            err = check_alu_op(env, insn);
            break;

        case BPF_LDX:
            err = check_mem_access(env, insn_idx, insn->src_reg,
                         insn->off, BPF_SIZE(insn->code),
                         BPF_READ, insn->dst_reg, false, false);
            break;

        case BPF_STX:
            err = check_mem_access(env, insn_idx, insn->dst_reg,
                         insn->off, BPF_SIZE(insn->code),
                         BPF_WRITE, insn->src_reg, false, false);
            break;

        case BPF_ST:
            err = check_mem_access(env, insn_idx, insn->dst_reg,
                         insn->off, BPF_SIZE(insn->code),
                         BPF_WRITE, -1, false, false);
            break;

        case BPF_JMP:
        case BPF_JMP32:
            err = check_jmp_op(env, insn_idx, insn);
            break;

        case BPF_LD:
            err = check_ld_imm(env, insn);
            break;
        }

        /* 4. 错误检查 */
        if (err)
            return err;

        /* 5. 更新指令计数器 */
        env->insn_processed++;
    }
}

/* kernel/bpf/verifier.c - check_cond_jmp_op() 简化 */
static int check_cond_jmp_op(struct bpf_verifier_env *env,
               struct bpf_insn *insn, int insn_idx)
{
    struct bpf_verifier_state *other_branch;
    int err;

    /* fork 当前状态——用于分支路径 */
    other_branch = push_stack(env, insn_idx + insn->off + 1, insn_idx);
    
    /* 在当前状态中，应用条件为 FALSE 时的范围约束（fallthrough） */
    /* 例如：if r0 > 5 ... 则 fallthrough 时 r0 <= 5 */
    find_good_pkt_pointers(other_branch, insn, insn->dst_reg);
    reg_set_min_max(&other_branch->regs[insn->dst_reg], ...);
    
    /* 在分支状态中，应用条件为 TRUE 时的范围约束 */
    /* 例如：if r0 > 5 ... 则分支中 r0 > 5 */
    reg_set_min_max_inv(&state->regs[insn->dst_reg], ...);

    /* 继续在当前路径上执行（fallthrough） */
    /* 分支路径中的状态会在之后被 pop 出来处理 */
    return 0;
}

/* kernel/bpf/verifier.c - check_helper_call() 简化 */
static int check_helper_call(struct bpf_verifier_env *env,
               struct bpf_insn *insn, int insn_idx_p)
{
    struct bpf_func_proto *fn;
    int meta_size, i;

    /* 1. 查找 helper 函数原型 */
    fn = env->prog->aux->ops->get_func_proto(insn->imm, env->prog);
    if (!fn) {
        verbose(env, "unknown func %s#%d\n", func_id_name(insn->imm), insn->imm);
        return -EINVAL;
    }

    /* 2. 验证每个参数的类型匹配 */
    for (i = 0; i < MAX_BPF_FUNC_REG_ARGS; i++) {  /* R1-R5 */
        if (fn->arg_type[i] == ARG_DONTCARE)
            continue;
        
        err = check_func_arg(env, i, &meta, fn, insn_idx_p);
        if (err)
            return err;
    }

    /* 3. R1-R5 在调用后被标记为 NOT_INIT */
    for (i = BPF_REG_1; i <= BPF_REG_5; i++)
        mark_reg_not_init(env, regs, i);

    /* 4. R0 根据 helper 的返回类型设置 */
    if (fn->ret_type == RET_PTR_TO_MAP_VALUE_OR_NULL)
        mark_reg_ptr_or_null(env, regs, BPF_REG_0, PTR_TO_MAP_VALUE);
    else if (fn->ret_type == RET_INTEGER)
        mark_reg_unknown(env, regs, BPF_REG_0);
    
    return 0;
}

# 通过 bpftool 加载并获取完整日志
bpftool prog load my_prog.o /sys/fs/bpf/my_prog \
    type xdp \
    log_level 2 \
    log_buf /dev/stdout

# 或通过 bpftool 查看已加载程序的 verifier 日志
bpftool prog show id <PROG_ID> --verbose