【eBPF 内核实现深度拆解】libbpf 加载器工程：skeleton、auto-attach、map pinning 与 ring buffer 消费者

bpf_object__open_file()
  → bpf_object__open(const char *path)
    → bpf_object_open_opts() → open(path, O_RDONLY)
    → bpf_object__elf_init(obj)       // 初始化 obj->efile
      → 验证 ELF magic: ELFMAG "\x7fELF"
    → bpf_object__elf_collect(obj)    // 收集所有 BPF 相关的 ELF 节
    → bpf_object__elf_fixup(obj)      // 修正 cross-section 引用
    → bpf_object__elf_sort(obj)       // 按 section 对 map/全局变量排序

/* tools/lib/bpf/libbpf.c - bpf_object__elf_collect() 节分类逻辑
 * 以 "license" 开头的节名 → 许可字符串
 * 以 "maps" 或 "maps/" 开头的 → BPF map 定义
 * 以 ".maps" 完全匹配的 → map 元数据（struct bpf_map_def）
 * 以 ".text" 开头的 → 函数程序（可被 BPF_PSEUDO_CALL 调用）
 * 其他任何 BPF 程序节 → 根据 SEC() 注解确定程序类型和 attach 类型
 * ".BTF" → BTF 类型信息
 * ".BTF.ext" → BTF 扩展（func_info + line_info + CO-RE 重定位）
 */

bpf_object__load(obj)
  → bpf_object__create_maps(obj)       // 创建所有 map
    → for each bpf_map: bpf_map_create()
      → bpf(BPF_MAP_CREATE, ...)
  → bpf_object__relocate(obj)          // 处理非 CO-RE 重定位（map fd 等）
  → bpf_object__relocate_core(obj)     // 应用 CO-RE 重定位，修补指令
  → bpf_object__load_progs(obj)        // 加载所有程序
    → for each bpf_program: bpf_program__load()
      → bpf(BPF_PROG_LOAD, ...)        // 提交已修补的字节码

/* tools/lib/bpf/libbpf.c - bpf_program__load() 简化 */
static int bpf_program__load(struct bpf_program *prog, ...)
{
    /* 设置 BPF_PROG_LOAD 属性 */
    attr.prog_type = prog->type;              /* 从 SEC() 注解推导 */
    attr.expected_attach_type = prog->expected_attach_type;
    attr.insns = prog->insns;                 /* BPF 字节码 */
    attr.insn_cnt = prog->insns_cnt;
    attr.license = obj->license;              /* 来自 license 节 */
    attr.log_level = opts->log_level;         /* verifier 日志级别 */
    attr.log_buf = log_buf;
    attr.func_info = ...;                     /* 来自 BTF.ext */
    attr.line_info = ...;
    attr.fd_array = map_fds;                  /* map 文件描述符数组 */
    attr.attach_btf_id = prog->attach_btf_id; /* fentry/fexit 等需要的 BTF ID */

    prog->fd = sys_bpf_prog_load(&attr, ...);
}

/* tools/lib/bpf/libbpf.c - bpf_program__attach() 的类型分发 */
static struct bpf_link *bpf_program__attach(const struct bpf_program *prog)
{
    switch (prog->type) {
    case BPF_PROG_TYPE_TRACEPOINT:
        return bpf_program__attach_tracepoint(prog);
    case BPF_PROG_TYPE_KPROBE:
        return bpf_program__attach_kprobe(prog);
    case BPF_PROG_TYPE_PERF_EVENT:
        return bpf_program__attach_perf_event(prog);
    case BPF_PROG_TYPE_TRACING:
        if (prog->expected_attach_type == BPF_TRACE_FENTRY ||
            prog->expected_attach_type == BPF_TRACE_FEXIT)
            return bpf_program__attach_trace(prog);
        if (prog->expected_attach_type == BPF_TRACE_RAW_TP)
            return bpf_program__attach_raw_tracepoint(prog);
        break;
    case BPF_PROG_TYPE_CGROUP_SKB:
        return bpf_program__attach_cgroup(prog, ...);
    case BPF_PROG_TYPE_XDP:
        return bpf_program__attach_xdp(prog, ifindex);
    case BPF_PROG_TYPE_SK_LOOKUP:
        return bpf_program__attach_sk_lookup(prog, ...);
    /* ... 其他类型 ... */
    }
}

/* tools/lib/bpf/libbpf.c - 节名到程序类型的映射（简化） */
"xdp"                    → BPF_PROG_TYPE_XDP
"tc"                     → BPF_PROG_TYPE_SCHED_CLS
"classifier"             → BPF_PROG_TYPE_SCHED_CLS                          // 等价于 tc ingress
"action"                 → BPF_PROG_TYPE_SCHED_ACT                          // TC action
"socket"                 → BPF_PROG_TYPE_SOCKET_FILTER
"kprobe/"                → BPF_PROG_TYPE_KPROBE                             // 前缀匹配
"uprobe/"                → BPF_PROG_TYPE_KPROBE                             // 与 kprobe 共用 BPF_PROG_TYPE_KPROBE
"tracepoint/"            → BPF_PROG_TYPE_TRACEPOINT
"tp/"                    → BPF_PROG_TYPE_TRACEPOINT                         // 缩写形式
"tp_btf/"                → BPF_PROG_TYPE_TRACING, BPF_TRACE_RAW_TP
"fentry/"                → BPF_PROG_TYPE_TRACING, BPF_TRACE_FENTRY
"fexit/"                 → BPF_PROG_TYPE_TRACING, BPF_TRACE_FEXIT
"iter/"                  → BPF_PROG_TYPE_TRACING, BPF_TRACE_ITER
"lsm/"                   → BPF_PROG_TYPE_LSM, BPF_LSM_MAC
"lsm.s/"                 → BPF_PROG_TYPE_LSM, BPF_LSM_CGROUP               // sleepable LSM
"cgroup_skb/ingress"     → BPF_PROG_TYPE_CGROUP_SKB, BPF_CGROUP_INET_INGRESS
"cgroup_skb/egress"      → BPF_PROG_TYPE_CGROUP_SKB, BPF_CGROUP_INET_EGRESS
"cgroup/sock"            → BPF_PROG_TYPE_CGROUP_SOCK
"cgroup/setsockopt"      → BPF_PROG_TYPE_CGROUP_SETSOCKOPT
"cgroup/getsockopt"      → BPF_PROG_TYPE_CGROUP_GETSOCKOPT
"sockops"                → BPF_PROG_TYPE_SOCK_OPS
"sk_skb/stream_parser"   → BPF_PROG_TYPE_SK_SKB
"sk_skb/stream_verdict"  → BPF_PROG_TYPE_SK_SKB
"sk_msg"                 → BPF_PROG_TYPE_SK_MSG
"struct_ops/"            → BPF_PROG_TYPE_STRUCT_OPS
"syscall"                → BPF_PROG_TYPE_SYSCALL

// SEC() 注解覆盖 BPF 网络/追踪/安全三大域
SEC("xdp")                                 int xdp_filter(struct xdp_md *ctx) { ... }
SEC("tc")                                  int tc_ingress(struct __sk_buff *skb) { ... }
SEC("tracepoint/syscalls/sys_enter_open")  int tp_open(void *ctx) { ... }
SEC("tp_btf/sched_switch")                 int raw_tp_switch(u64 *ctx) { ... }
SEC("kprobe/tcp_connect")                  int kp_conn(struct pt_regs *ctx) { ... }
SEC("uprobe//bin/bash:readline")           int up_readline(struct pt_regs *ctx) { ... }
SEC("fentry/tcp_connect")                  int fe_conn(struct pt_regs *ctx) { ... }
SEC("fexit/tcp_connect")                   int fx_conn(struct pt_regs *ctx) { ... }
SEC("lsm/bprm_check_security")             int lsm_bprm(void *ctx) { ... }
SEC("cgroup_skb/ingress")                  int cg_ingress(struct __sk_buff *skb) { ... }
SEC("sockops")                             int sock_ops_handler(struct bpf_sock_ops *ctx) { ... }

/* tools/lib/bpf/libbpf.c - libbpf_find_vmlinux_btf_id() 简化逻辑 */
int libbpf_find_vmlinux_btf_id(const char *name, enum bpf_attach_type attach_type)
{
    struct btf *btf = btf__load_vmlinux_btf();  // 从 /sys/kernel/btf/vmlinux 加载
    int id;

    for (id = 1; id <= btf__type_cnt(btf); id++) {
        const struct btf_type *t = btf__type_by_id(btf, id);
        if (btf_kind(t) != BTF_KIND_FUNC)
            continue;
        if (strcmp(btf__name_by_offset(btf, t->name_off), name) == 0) {
            btf__free(btf);
            return id;
        }
    }
    btf__free(btf);
    return -ENOENT;
}

bpftool gen skeleton myprog.bpf.o > myprog.skel.h

// myprog.bpf.c
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, u32);
    __type(value, u64);
    __uint(max_entries, 1024);
} conns SEC(".maps");

SEC("xdp")
int xdp_filter(struct xdp_md *ctx) { ... }

/* 由 bpftool gen skeleton 自动生成 */
struct myprog_bpf {
    struct bpf_object_skeleton *skeleton;
    struct bpf_object *obj;
    struct {
        struct bpf_map *conns;          // 与 BPF 源码中的 map 名称一致
    } maps;
    struct {
        struct bpf_program *xdp_filter; // 与 BPF 源码中的函数名一致
    } progs;
    struct {
        struct bpf_link *xdp_filter;    // attach 后的 link
    } links;
};

// 无 skeleton：字符串查找，无类型安全
struct bpf_map *map = bpf_object__find_map_by_name(obj, "conns");
struct bpf_program *prog = bpf_object__find_program_by_name(obj, "xdp_filter");

// 操作 map 需要把 key/value 编码为 hex 字符串
int fd = bpf_map__fd(map);
int err = bpf_map_update_elem(fd, &key, &value, BPF_ANY);

// 有 skeleton：类型安全，编译期检查
struct myprog_bpf *skel = myprog_bpf__open_and_load();
struct bpf_map *map = skel->maps.conns;         // 编译期检查成员名
struct bpf_program *prog = skel->progs.xdp_filter;
// map 操作仍通过 fd，但头文件通常会提供辅助宏来消除手工 fd 管理

#include "myprog.skel.h"

int main(int argc, char **argv)
{
    struct myprog_bpf *skel;
    int err;

    /* 1. 打开 ELF + 加载到内核 */
    skel = myprog_bpf__open_and_load();
    if (!skel) {
        fprintf(stderr, "Failed to open and load BPF skeleton\n");
        return 1;
    }

    /* 2. Attach 到内核钩子 */
    err = myprog_bpf__attach(skel);
    if (err) {
        fprintf(stderr, "Failed to attach BPF skeleton\n");
        goto cleanup;
    }

    /* 3. 启动 ring buffer 消费者（见第五节） */
    struct ring_buffer *rb = ring_buffer__new(
        bpf_map__fd(skel->maps.events),
        handle_event, /* 事件处理回调 */
        NULL,         /* 回调上下文 */
        NULL          /* opts */
    );
    if (!rb) {
        fprintf(stderr, "Failed to create ring buffer\n");
        goto cleanup;
    }

    printf("BPF program loaded and attached. Press Ctrl-C to exit.\n");

    /* 4. 主循环：poll ring buffer */
    while (!done) {
        ring_buffer__poll(rb, 100 /* timeout ms */);
    }

cleanup:
    ring_buffer__free(rb);
    myprog_bpf__destroy(skel);
    return err;
}

/* 将 map pin 到 bpffs */
err = bpf_map__pin(skel->maps.conns, "/sys/fs/bpf/myprog/conns");

/* 另一个进程可以复用已 pin 的 map */
map_fd = bpf_obj_get("/sys/fs/bpf/myprog/conns");

/* 热更新：新程序复用旧 map */
struct myprog_bpf *new_skel;

/* 先打开旧程序所使用的 map */
int old_map_fd = bpf_obj_get("/sys/fs/bpf/myprog/conns");

/* 创建新 skeleton 但只做 open，不 load（因为要设置 map 复用） */
new_skel = myprog_bpf__open();
if (!new_skel) { ... }

/* 在 load 之前设置 map 复用 */
bpf_map__reuse_fd(new_skel->maps.conns, old_map_fd);

/* 加载新程序（将使用复用的 map） */
err = myprog_bpf__load(new_skel);

/* Attach 新程序 — 这会替换旧的 link */
err = myprog_bpf__attach(new_skel);

/* 销毁旧 skeleton（旧程序被 detach，但 map 数据保留） */
myprog_bpf__destroy(old_skel);

/* tools/lib/bpf/ringbuf.c */
struct ring_buffer *ring_buffer__new(int map_fd,
                                      ring_buffer_sample_fn sample_cb,
                                      void *ctx,
                                      const struct ring_buffer_opts *opts);
int ring_buffer__poll(struct ring_buffer *rb, int timeout_ms);
void ring_buffer__free(struct ring_buffer *rb);

/* 用户态 ring buffer 事件处理回调 */
static int handle_event(void *ctx, void *data, size_t data_sz)
{
    const struct event *e = data;

    printf("pid=%d comm=%s duration_ns=%llu\n",
           e->pid, e->comm, e->duration_ns);
    return 0;  /* 返回 0 表示继续消费 */
}

int main(int argc, char **argv)
{
    struct ring_buffer *rb = NULL;
    struct myprog_bpf *skel;
    int err;

    skel = myprog_bpf__open_and_load();
    if (!skel)
        return 1;

    err = myprog_bpf__attach(skel);
    if (err)
        goto cleanup;

    /* 创建 ring buffer 消费者 */
    rb = ring_buffer__new(
        bpf_map__fd(skel->maps.events),  /* ringbuf map 的 fd */
        handle_event,                     /* 每记录回调 */
        NULL,                             /* 传递给回调的 ctx */
        NULL                              /* opts（可用默认） */
    );
    if (!rb) {
        fprintf(stderr, "Failed to create ring_buffer: %d\n", -errno);
        goto cleanup;
    }

    /* 主循环 */
    printf("Listening for events...\n");
    while (!done) {
        err = ring_buffer__poll(rb, 100 /* timeout ms */);
        if (err == -EINTR) continue;  /* 信号中断 */
        if (err < 0) break;           /* 实际错误 */
        /* 也可以调用 ring_buffer__consume(rb) 做非阻塞消费 */
    }

cleanup:
    ring_buffer__free(rb);
    myprog_bpf__destroy(skel);
    return -err;
}

// loader.c — 基于 skeleton 的最小 BPF 加载器
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <bpf/libbpf.h>
#include "myprog.skel.h"

static volatile bool done = false;

static void sig_handler(int sig) { done = true; }

static int handle_event(void *ctx, void *data, size_t sz)
{
    printf("Event: %zu bytes\n", sz);
    return 0;
}

int main(int argc, char **argv)
{
    struct myprog_bpf *skel;
    struct ring_buffer *rb = NULL;
    int err;

    signal(SIGINT, sig_handler);
    signal(SIGTERM, sig_handler);

    /* 打开 BPF 程序文件 */
    skel = myprog_bpf__open();
    if (!skel) {
        fprintf(stderr, "Failed to open BPF skeleton\n");
        return 1;
    }

    /* 可选：在 load 之前调整 map 大小 */
    bpf_map__set_max_entries(skel->maps.conns, 8192);

    /* 可选：设置 verifier log level（调试用） */
    // bpf_object__set_log_level(skel->obj, 1);

    /* 加载到内核 */
    err = myprog_bpf__load(skel);
    if (err) {
        fprintf(stderr, "Failed to load BPF skeleton: %d\n", err);
        goto cleanup;
    }

    /* Attach 到内核钩子 */
    err = myprog_bpf__attach(skel);
    if (err) {
        fprintf(stderr, "Failed to attach: %d\n", err);
        goto cleanup;
    }

    /* 创建 ring buffer consumer */
    rb = ring_buffer__new(bpf_map__fd(skel->maps.events),
                          handle_event, NULL, NULL);
    if (!rb) {
        err = -errno;
        fprintf(stderr, "Failed to create ring buffer\n");
        goto cleanup;
    }

    printf("Running. Press Ctrl-C to stop.\n");
    while (!done) {
        ring_buffer__poll(rb, 100);
    }

    err = 0;

cleanup:
    ring_buffer__free(rb);
    myprog_bpf__destroy(skel);
    return err;
}

# Makefile
CLANG   = clang
CFLAGS  = -target bpf -O2 -g -Wall
LDFLAGS = -lbpf -lelf -lz

all: myprog.bpf.o loader

myprog.bpf.o: myprog.bpf.c
    $(CLANG) $(CFLAGS) -c $< -o $@

myprog.skel.h: myprog.bpf.o
    bpftool gen skeleton $< > $@

loader: loader.c myprog.skel.h
    $(CC) -Wall -O2 -I. $< $(LDFLAGS) -o $@

clean:
    rm -f myprog.bpf.o myprog.skel.h loader