Linux内核 BPF CO-RE (Compile Once – Run Everywhere)：跨内核版本可移植 BPF 程序的生产级深度实战

关键洞察：libbpf 对不匹配的结构体版本并非沉默忽略，而是通过 -Wincompatible-pointer-types 和 BTF 一致性检查主动报错。这种"快速失败"设计是 CO-RE 在生产中可信赖的重要保证。

2.3 Preserve Access Index：处理被优化掉的字段

有一种隐蔽陷阱：编译器可能会"优化"看起来未使用的字段访问，或者因 enum 值条件判断移除某些分支中的访问。libbpf 引入了 bpf_core_read_volatile() 和 __preserve_access_index 属性来防止此类优化：

// 场景：读取可能被内核编译器优化的字段
static __always_inline __u64 read_pkt_sk_cookie(struct sock *sk) {
    // 方法1：使用 __preserve_access_index 属性修饰自定义结构
    struct sock_core {
        __u64 sk_cookie;
    } __attribute__((preserve_access_index)) *core = (void *)sk;
    
    // 方法2：显式 volatile 读取
    return __builtin_bpf_preserve_access_index(&core->sk_cookie);
}

这在处理 struct sock/struct sock_common 等内核频繁变动的结构体时尤其重要——CO-RE 需要知道哪些字段被访问过，才能写入重定位条目。

3. BTF 重定位的六大类别

libbpf 在 bpf_core_relo 中定义了六类重定位规则，它们覆盖了 BPF 生产中几乎所有场景：

3.1 字段重定位（Field-based）

最基本的字段访问重写：

// 重定位类型：BPF_CORE_READ 系列宏展开后
#define BPF_CORE_READ(dst, src) \
    bpf_probe_read_kernel(dst, sizeof(*dst), \
        __builtin_bpf_preserve_access_index(src))

// 实例：读取 TCP socket 的 RTT（Round-Trip Time）
static __always_inline void trace_rtt(struct sock *sk) {
    struct tcp_sock *tp = (struct tcp_sock *)sk;
    // 这里 tp->srtt_us 的偏移会被自动修补
    u32 srtt = BPF_CORE_READ(&srtt, &tp->srtt_us);
    bpf_printk("TCP srtt_us=%u\n", srtt);
}

BPF_CORE_READ 宏是生产最常用的 CO-RE 封装。它同时支持基址偏移重定位（如 tp->srtt_us）和指针重定位（如 sk->sk_socket）。

3.2 非指针字段检查（Field existence）

处理内核中"可选字段"的存在性问题：

struct task_struct {
    // 5.16+ 新增字段
    struct hmm *hmm;  
};

// 使用 bpf_core_field_exists() 判断字段是否定义
__u64 get_hmm(struct task_struct *task) {
    if (bpf_core_field_exists(task->hmm)) {
        struct hmm *h = BPF_CORE_READ(task, hmm);
        return (u64)h;
    }
    return 0;  // 旧内核优雅降级
}

这是处理5.x→6.x 内核升级迁移最常用的技术：先判断再读取，避免旧内核上的 verifier 报错。

3.3 枚举/常量重定位（Enum/Const-based）

内核中的枚举值和宏常量在不同版本中可能变化：

// 场景：获取 TCP 状态名
static const char *get_tcp_state(u8 state) {
    // IPPROTO_TCP 的值在不同内核中可能不同
    if (state == bpf_core_enum_value(enum TCPF_ESTABLISHED, TCPF_ESTABLISHED))
        return "ESTABLISHED";
    if (state == bpf_core_enum_value(enum TCPF_WAIT1, TCPF_WAIT1))
        return "FIN_WAIT1";
    return "UNKNOWN";
}

生产用例：监控系统需要区分 TCP_CLOSE_WAIT 等异常状态计数，若硬编码 state == 9（某个内核版的 TCP_CLOSE_WAIT 枚举值），在新的内核上计数会完全错误。

3.4 偏移重写（Type-based / offsetof）

最底层的一类，直接替换结构体字段偏移：

// 场景：从 task 获取 cgroup ID
__u64 get_cgroup_id(struct task_struct *task) {
    // task->cgroups 在 5.13 改为 task->cgroups + css 再指针追踪
    struct cgroup *cg;
    
    // 直接类型重定位
    cg = BPF_CORE_READ(task, cgroups, subsys[cpuset_cgrp_id], cgroup);
    
    return BPF_CORE_READ(cg, kn, id);
}

注意：这里的 CO-RE 重写涉及多层指针追踪。libbpf 不仅修第一层偏移，还会为每一跳生成对应的重定位条目。

3.5 Spec-based 重定位

通过 bpf_core_spec 描述从集合中匹配目标结构体：

// 场景：从所有 TCP sockets 中提取信息（不关心内核版本的具体布局）
volatile const struct tcp_sock_offsetsSpec TCP_SPEC = {};
// 通过 extern volatile const 引入 spec，libbpf 加载时填充

SEC("tracepoint/tcp/tcp_send_trace")
int trace_send(struct pt_regs *ctx) {
    volatile __u32 off = TCP_SPEC.srtt_us_off;
    u32 srtt = *(u32 *)((char *)tp + off);
    // ...
}

Spec 模式是 libbpf 的高级特性，适合元数据场景需要缓存偏移的场合。

3.6 类型存在性重定位

当 BTF 中不存在目标类型时的处理：

if (bpf_core_type_exists(struct bpf_tcp_ca)) {
    // 5.7+ 内核存在该结构体
    struct bpf_tcp_ca *ca = BPF_CORERead(...);
} else {
    // 硬编码备用路径
    bpf_printk("legacy kernel path");
}

4. 生产级实战：TCP 健康监控探针

下面我们构建一个完整的示例——tcphealth，基于 BCC 的 tcp_headers.h 往往需要在目标机器重新编译，而基于 BPF CORE 的同一份 ELF 二进制在 5.8–6.6 范围内皆可加载：

// tcphealth.bpf.c 内核侧
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>
#include <bpf/bpf_core_read.h>

struct event {
    u32 pid, tid;
    u32 saddr, daddr;
    u16 sport, dport;
    u32 srtt_ms;        // RTT（ms）
    u32 bytes_acked;
    u32 bytes_received;
    u64 cgroup_id;
    u8 state;
    u8 _pad[7];
};

struct {
    __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
    __uint(key_size, sizeof(u32));
    __uint(value_size, sizeof(u32));
} events SEC(".maps");

// 5.12+: sk_pacing_rate 经过多次改名
static __always_inline u64 get_sk_pacing_rate(struct sock *sk) {
    if (bpf_core_field_exists(sk->__sk_common.skc_pacing_rate))
        return BPF_CORE_READ(sk, __sk_common, skc_pacing_rate);
    // 旧内核备用
    return BPF_CORE_READ((struct tcp_sock *)sk, pacing_rate);
}

SEC("fentry/tcp_rcv_established")
int BPF_PROG(tcp_recv_trace, struct sock *sk, struct sk_buff *skb) {
    if (sk->__sk_common.skc_family != AF_INET)
        return 0;

    struct tcp_sock *tp = (struct tcp_sock *)sk;
    struct ev e = {};
    
    // 全部 BPF_CORE_READ 宏：自动跨越内核版本
    e.srtt_ms = BPF_CORE_READ(tp, srtt_us) >> 10; // us → ~ms
    e.bytes_acked = BPF_CORE_READ(tp, bytes_acked);
    e.bytes_received = BPF_CORE_READ(tp, bytes_received);
    e.state = BPF_CORE_READ((struct sock *)sk, __sk_common, skc_state);

    // 获取 cgroup ID（需要后缀兼容路径）
    e.cgroup_id = bpf_get_current_cgroup_id();
    
    bpf_get_current_pid_tgid(&e.pid, &e.tid);
    bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, &e, sizeof(e));
    return 0;
}

char _license[] SEC("license") = "GPL";

用户侧加载器：

// tcphealth.c 用户侧
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include "tcphealth.skel.h"

static volatile int exiting = 0;
static void sig_handler(int sig) { exiting = 1; }

static int handle_event(void *ctx, void *data, size_t len) {
    struct event *e = data;
    printf("PID=%u RTT=%ums state=%u bytes_acked=%u cgroup=%lu\n",
           e->pid, e->srtt_ms, e->state, e->bytes_acked, e->cgroup_id);
    return 0;
}

int main(int argc, char **argv) {
    struct tcphealth_bpf *skel;
    struct perf_buffer *pb = NULL;
    int err;

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

    skel = tcphealth_bpf__open();
    if (!skel) { fprintf(stderr, "open failed\n"); return 1; }

    // 可选：指定 libbpf 日志级别看 CO-RE 重定位细节
    // libbpf_set_print(libbpf_print_fn);

    err = tcphealth_bpf__load(skel);  // ← CO-RE 在此发生
    if (err) { fprintf(stderr, "load failed: %d\n", err); goto cleanup; }

    err = tcphealth_bpf__attach(skel);
    if (err) { fprintf(stderr, "attach failed\n"); goto cleanup; }

    pb = perf_buffer__new(bpf_map__fd(skel->maps.events), 16,
                           handle_event, NULL, NULL, NULL);
    
    while (!exiting) {
        err = perf_buffer__poll(pb, 100);
        if (err == -EINTR) err = 0;
        if (err < 0) break;
    }

cleanup:
    perf_buffer__free(pb);
    tcphealth_bpf__destroy(skel);
    return err != 0;
}

编译与部署：

# 编译（一次生成，到处运行）
$ make
clang -g -O2 -target bpf -c tcphealth.bpf.c -o tcphealth.bpf.o
bpftool gen skeleton tcphealth.bpf.o > tcphealth.skel.h
gcc -g -O2 tcphealth.c -o tcphealth -lbpf

# 部署（拿到任意 5.8-6.6 机器直接运行，无需重编译）
$ scp tcphealth target-host:/opt/
$ ssh target-host "/opt/tcphealth" &
TCP PID=8231 RTT=12ms state=1 bytes_acked=1944 cgroup=2048
TCP PID=8231 RTT=8ms state=1 bytes_acked=3888 cgroup=2048

5. 内核边界情况与最佳实践

5.1 BTF 外核模块的场景

如果 BPF 程序访问第三方内核模块（如 NVIDIA nvidia.ko、ntfs3）中的结构体，需要显式加载该模块的 BTF。libbpf 从 1.0 开始支持通过 bpf_object_set_opts() 指定额外 BTF 文件：

struct bpf_object_open_opts opts = {
    .sz = sizeof(opts),
    .btf_custom_path = "/sys/kernel/btf/nvidia",  // 外核模块 BTF路径
};
skel = tcphealth_bpf__open_opts(&opts);

如果 BTF 不存在（老旧驱动不支持），CO-RE 无法工作，必须退回到标准头文件硬编码偏移。

5.2 不同指令架构的陷阱

CO-RE 生成的 BPF 程序是BPF字节码（中间表示），可以做跨架构适配：在 ARM64 主机上编译的 bpf.o 也可以在 x86_64 上加载，因为 verifier 执行的是 IR 级别的验证。但以下情况需要注意：

• bpf_core_enum_value() 编译时写入本机字节序，跨大/小端需要谨慎
• BPF_CORE_READ() 的 bpf_probe_read_kernel() 后端字节序无关，但 bpf_core_read()（BPF 字节码直接读取）在不同架构上行为一致
• 生产实践：始终在 build host（通常小端 x86_64）上编译，跨集群部署无需重编译

5.3 BTF 版本与内核升级策略

在 Kubernetes 滚动升级过程中，节点内核版本逐步从 5.15 升到 6.1，同一份 BPF 二进制可以无缝迁移生产流量。但运维团队需要注意：

# 检查集群所有节点的 BTF 一致性
$ kubectl get nodes -o wide | awk '{print $NF}' | sort | uniq
v1.26  # 5.15
v1.27  # 6.1

# 验证 BPF 程序在两种内核均可加载
$ bpftool feature probe kernel | grep -i btf
Prog type kfunc available: yes
BTF_KIND_FUNC_PROTO with static_linked: yes

# 监控指标：BPF 加载失败事件（Prometheus counter）
bpf_prog_load_errors_total{reason="relo_mismatch"} 0

Prometheus 监控指标建议覆盖：

• bpf_prog_load_count — 每次加载成功 +1
• bpf_relo_success_count / bpf_relo_mismatch_count — 重定位成功/失败
• bpf_map_create_count — map 创建数量

6. BPF CO-RE vs 传统 BCC 的工程决策

在老旧内核上部署时，工具选择必须考虑运行时约束：

结论：在 kernel 5.8+ 环境（BTF 原生可用 99% 的 Linux 发行版）中，BPF CO-RE 是生产部署的唯一选择；仅在老旧内核且无法提供独立 BTF 的场景中才退回到 BCC。

7. 高级主题：与 BPF_EXT / Cgroup 的协同

在 AI 训练场景中，TCP 健康监控探针常需要与 cgroup 资源感知协同：

// 场景：RTO 事件触发后，自动降低对应 cgroup 的 CPU 配额
SEC("tp_bsk/tcp_retransmit_skb")
int trace_retransmit(struct trace_event_raw_tcp_event_sk_skb *ctx) {
    u64 cgrp_id = bpf_get_current_cgroup_id();
    
    // 将 cgroup ID 写入 map（maps 跨程序类型共享——struct_ops / cgroup-bpf / fentry 均可）
    u64 *count = bpf_map_lookup_elem(&cgrp_retrans_count, &cgrp_id);
    if (count) {
        __sync_fetch_and_add(count, 1);
        if (*count > RETRANS_THRESHOLD) {
            // 用户态轮询器检测到阈值越界后调整 cpu.max
            bpf_ringbuf_output(&alerts, &cgrp_id, sizeof(cgrp_id), 0);
        }
    }
    return 0;
}