014.生产级 eBPF/libbpf 用户态生命周期全景指南

开发一个现代的、健壮的 eBPF 用户态控制程序，本质上是管理 eBPF 对象从“用户态解析”到“内核态运行”，再到“安全卸载”的全生命周期。

完整的标准生命周期分为四个核心阶段：初始化与打开 (Open) → 加载入核 (Load) → 查找与挂载 (Attach) → 卸载与清理 (Teardown)。

核心 API 原理总结

阶段一：初始化与打开（Open）

此阶段程序仍在纯用户态打转，不涉及真实的内核 BPF 对象创建。

• libbpf_set_strict_mode(LIBBPF_STRICT_ALL);

• 工程意义：禁止所有旧的、隐式的、宽松的兼容行为。

• 一句话：“我写的是生产代码，要求 100% 行为可预期，写错请直接报错，不要帮我兜底。”

• bpf_object__open_file(path, &open_opts);

• 工程意义：解析 ELF 文件，构建用户态的 bpf_object 代理模型。其中 open_opts.sz = sizeof(opts) 是 libbpf 保证 ABI 向前兼容（永不炸裂）的核心设计。

• 一句话：“按当前 libbpf 版本的严格规范，在用户态打开并解析这个 BPF ELF 文件。”

阶段二：加载入核（Load）

这是用户态与内核态的真正交界线，也是最容易发生错误（如 Verifier 拒绝）的环节。

• bpf_object__load(obj);
• 工程意义：将解析好的程序和 Map 送入 Linux 内核，执行 Verifier 校验，并在内核中真正分配内存、创建 FD（文件描述符）。
• 一句话：“验证代码合法性，并让内核为其分配真实的资源，但此时程序还未运行。”

阶段三：查找与挂载（Attach）

明确将内核中已就绪的 BPF 程序，绑定到特定的触发点（Hook）上。

• bpf_object__find_program_by_name(obj, "uprobe_malloc");

• 工程意义：在庞大的 BPF 对象中，精准定位到你要操作的那一个函数。这里的名字是 C 源码里的 BPF 函数名，而非段名 (SEC) 或目标符号名。

• 一句话：“拿到我要挂载的那个 BPF 程序的句柄（指针）。”

• bpf_program__attach_uprobe_opts(prog, pid, path, offset, &opts);

• 工程意义：触发真正的插桩动作。返回一个 struct bpf_link *，这是现代 libbpf 最安全的 RAII 风格生命周期管理对象。

• 一句话：“将静态程序变成动态探针，正式开始拦截并执行！”

阶段四：卸载与清理（Teardown）

生产级工具必须保证可控的资源回收，避免造成内核态和用户态的泄漏。

• bpf_link__destroy(link);

• 工程意义：销毁 Attach 关系，卸载探针，关闭 Link FD。

• 一句话：“停止探测（Detach），这是生命周期的句号。”

• bpf_object__close(obj);

• 工程意义：关闭其余所有的 Map/Prog FD，释放 bpf_object 占用的用户态内存。

• 一句话：“打扫战场，清理用户态的所有残留痕迹。”

---

完整生产级 C 代码使用样例

以下是一个整合了上述所有 API 的完整、规范的 Loader 样例。它展示了如何安全地拦截 libc 的 malloc 返回事件。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <bpf/libbpf.h>

int main(int argc, char **argv) {
    struct bpf_object *obj = NULL;
    struct bpf_program *prog = NULL;
    struct bpf_link *link = NULL;
    int err = 0;

    // 1. 强制进入严格模式 (现代 libbpf 标配)
    libbpf_set_strict_mode(LIBBPF_STRICT_ALL);

    // 2. 准备版本化的打开选项
    struct bpf_object_open_opts open_opts = {
        .sz = sizeof(struct bpf_object_open_opts),
    };

    // 3. 打开 BPF ELF 对象 (纯用户态解析)
    obj = bpf_object__open_file("my_bpf_app.bpf.o", &open_opts);
    if (!obj) {
        fprintf(stderr, "Failed to open BPF object\n");
        return 1;
    }

    // 4. 加载进内核 (Verifier 校验 + 创建内核 FD)
    err = bpf_object__load(obj);
    if (err) {
        fprintf(stderr, "Failed to load BPF object into kernel\n");
        goto cleanup; // fail-fast，立刻清理
    }

    // 5. 根据 BPF 源码中的函数名查找特定的 program
    prog = bpf_object__find_program_by_name(obj, "uprobe_malloc");
    if (!prog) {
        fprintf(stderr, "Failed to find program 'uprobe_malloc'\n");
        goto cleanup;
    }

    // 6. 配置 uprobe 选项，准备挂载 (这里配置为拦截函数返回 uretprobe)
    struct bpf_uprobe_opts uopts = {
        .sz = sizeof(struct bpf_uprobe_opts),
        .retprobe = true,             // true 代表 uretprobe
        .func_name = "malloc",        // 目标 ELF 中的符号名
    };

    // 7. 执行挂载 (Attach 挂载到所有进程的 libc.so)
    const char *libc_path = "/lib/x86_64-linux-gnu/libc.so.6";
    link = bpf_program__attach_uprobe_opts(prog, -1, libc_path, 0, &uopts);
    if (!link) {
        fprintf(stderr, "Failed to attach uprobe\n");
        goto cleanup;
    }

    printf("Successfully attached uprobe to malloc! Tracing for 10 seconds...\n");
    
    // 模拟主程序运行 (比如在这里不断轮询 ringbuf / perf buffer)
    sleep(10);

cleanup:
    // 8. 标准清理流程：先 Detach (如果 attach 成功的话)
    if (link) {
        bpf_link__destroy(link);
        printf("Link destroyed (detached).\n");
    }

    // 9. 清理用户态对象与其余内核 FD
    if (obj) {
        bpf_object__close(obj);
        printf("BPF object closed. Cleanup complete.\n");
    }

    return err != 0 ? 1 : 0;
}