eBPF 可观测性实战：从内核探针到全栈追踪

一、为什么需要 eBPF？

在传统 Linux 系统观测领域，我们长期面临一个困境：要么使用功能有限的内置工具（如 top、netstat），要么加载重量级的内核模块（如 SystemTap），前者信息粒度不足，后者稳定性风险极高。eBPF（Extended Berkeley Packet Filter）的出现彻底改变了这一格局——它允许在内核空间运行沙盒化程序，无需修改内核源码或加载内核模块，即可实现安全、高性能的系统观测。

eBPF 的核心优势可归纳为三点：

• 安全性：eBPF 验证器在程序加载前进行静态分析，禁止越界访问、无限循环和非法内存操作
• 高性能：JIT 编译使 eBPF 程序接近原生机器码执行效率，性能损耗通常低于 1%
• 可编程性：用户态通过 BPF 系统调用动态加载/卸载观测逻辑，无需重启系统或中断业务

二、eBPF 架构与核心机制

2.1 执行流程

一个 eBPF 程序从编写到执行的完整路径：

用户态 C/Go/Rust 代码
    ↓  LLVM/Clang 编译
eBPF 字节码（BPF ELF 对象文件）
    ↓  bpf() 系统调用
内核 eBPF 验证器（Verifier）
    ↓  验证通过
JIT 编译为机器码
    ↓  挂载到 Hook 点
内核事件触发 → BPF Map 数据采集 → 用户态读取

2.2 Hook 点类型

2.3 BPF Map

BPF Map 是内核态与用户态数据交换的核心通道，支持多种数据结构：

• BPF_MAP_TYPE_HASH：键值对存储，适合计数器和状态缓存
• BPF_MAP_TYPE_ARRAY：数组索引访问，适合固定大小的配置和输出
• BPF_MAP_TYPE_PERF_EVENT_ARRAY：高性能事件流输出（推荐用于 tracepoint 采样）
• BPF_MAP_TYPE_RINGBUF：新型环形缓冲区，解决 perf event array 丢包问题
• BPF_MAP_TYPE_STACK_TRACE：内核/用户态栈帧 ID 映射

三、可观测性实战：系统追踪与性能剖析

3.1 系统调用追踪（bpftrace 单行命令）

bpftrace 提供了最快捷的 eBPF 脚本编写方式，适合临时诊断场景：

# 跟踪所有 openat 系统调用，统计每个进程的打开文件数
bpftrace -e 'tracepoint:syscalls:sys_enter_openat { @[comm, pid] = count(); }'

# 监控 TCP 重传事件，输出重传次数与目标地址
bpftrace -e 'kprobe:tcp_retransmit_skb { @[args->sk->sk_daddr] = count(); }'

# 跟踪进程 exec 行为，监控异常命令执行
bpftrace -e 'tracepoint:syscalls:sys_enter_execve { printf("%d %s: %s\n", pid, comm, str(args->filename)); }'

# 统计 page fault 分布（minor vs major）
bpftrace -e '
tracepoint:exceptions:page_fault_user { @minor = count(); }
tracepoint:exceptions:page_fault_kernel { @major = count(); }
'

3.2 CPU 调度延迟分析

利用调度器 tracepoint 可以精确测量从进程唤醒到实际运行之间的延迟，这对实时性敏感型业务至关重要：

// offcputime-bpf.c
#include 
#include "vmlinux.h"
#include 
#include 
#include 

struct event {
    u32 pid;
    u32 tgid;
    u64 off_cpu_ns;
    char comm[TASK_COMM_LEN];
};

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 10240);
    __type(key, u32);
    __type(value, u64);
} start SEC(".maps");

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

SEC("tp/sched/sched_switch")
int sched_switch(struct trace_event_raw_sched_switch *args) {
    u64 ts = bpf_ktime_get_ns();
    u32 prev_pid = args->prev_pid;
    bpf_map_update_elem(&start, &prev_pid, &ts, BPF_ANY);

    u32 next_pid = args->next_pid;
    u64 *tsp = bpf_map_lookup_elem(&start, &next_pid);
    if (tsp) {
        struct event e = {};
        e.pid = next_pid;
        e.tgid = bpf_get_current_pid_tgid() >> 32;
        e.off_cpu_ns = ts - *tsp;
        bpf_get_current_comm(&e.comm, sizeof(e.comm));
        bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, &e, sizeof(e));
    }
    return 0;
}

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

3.3 用户态函数追踪（uprobe 实战）

针对 Go 应用的内核观测一直是难点，因为 Go runtime 频繁的 goroutine 切换使得传统的 per-thread 状态跟踪失效。eBPF 的 uretprobe 解决了这个问题：

// 跟踪 net/http.Server 的 HTTP 请求处理延迟
bpftrace -e '
uprobe:/usr/local/go/bin/go:net/http.(*Server).ServeHTTP {
    @start[tid] = nsecs;
}
uretprobe:/usr/local/go/bin/go:net/http.(*Server).ServeHTTP {
     = nsecs - @start[tid];
    @latency_us = hist( / 1000);
    delete(@start[tid]);
}'

// 跟踪 Go 应用的内存分配行为
bpftrace -e '
uprobe:./myapp:runtime.mallocgc {
    @alloc_bytes[comm] = sum(arg0);
    @alloc_count[comm] = count();
}'

四、网络可观测：从 XDP 到完整协议栈监控

// xdp_monitor.bpf.c
SEC("xdp")
int xdp_monitor(struct xdp_md *ctx) {
    void *data_end = (void *)(long)ctx->data_end;
    void *data = (void *)(long)ctx->data;

    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return XDP_PASS;

    if (eth->h_proto != bpf_htons(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *iph = (void *)(eth + 1);
    if ((void *)(iph + 1) > data_end)
        return XDP_PASS;

    __u8 protocol = iph->protocol;
    __u64 *pkt_count = bpf_map_lookup_elem(&proto_stats, &protocol);
    if (pkt_count)
        __sync_fetch_and_add(pkt_count, 1);

    return XDP_PASS;
}

// tcp_monitor.c - 监控 TCP 连接建立/重置事件
SEC("sockops")
int bpf_sockops(struct bpf_sock_ops *sk_ops) {
    u32 family = sk_ops->family;
    if (family != AF_INET) return 0;

    switch (sk_ops->op) {
        case BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB:
        case BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB:
            bpf_sock_ops_cb_flags_set(sk_ops, BPF_SOCK_OPS_RTT_CB_FLAG);
            break;
        case BPF_SOCK_OPS_RTT_CB: {
            struct tcp_info info = {};
            info.sport = bpf_ntohl(sk_ops->local_port);
            info.dport = sk_ops->remote_port;
            info.rtt = sk_ops->rtt_min;
            info.snd_cwnd = sk_ops->snd_cwnd;
            bpf_perf_event_output(sk_ops, &rtt_events, BPF_F_CURRENT_CPU, &info, sizeof(info));
            break;
        }
    }
    return 0;
}

# 系统文件 I/O 延迟分布
biolatency-bpfcc -m

# 内核/用户态栈追踪（替代 perf record）
profile-bpfcc -F 99 -f > out.stacks
FlameGraph/stackcollapse-bpfcc.pl out.stacks | FlameGraph/flamegraph.pl > flame.svg

# TCP 连接延迟统计
tcpconnect-bpfcc -t

# 文件系统缓存命中率
cachestat-bpfcc 1

# 唤醒延迟分布（调度器分析）
offcputime-bpfcc -f 30 > offcpu.out

// 启用 CO-RE 的编译命令
clang -O2 -g -target bpf
    -D__TARGET_ARCH_x86
    -I/usr/include/bpf
    -c my_monitor.bpf.c -o my_monitor.bpf.o

// 用户态通过 libbpf 加载（自动处理字段偏移重定位）
struct my_monitor_bpf *skel = my_monitor_bpf__open_and_load();
my_monitor_bpf__attach(skel);

# 查看当前 eBPF 程序资源使用
bpftool prog show
bpftool map show

# 提升 eBPF 相关系统限制
sysctl -w kernel.bpf_stats_enabled=1
ulimit -l unlimited     # 锁定内存（用于 map）

# 查看验证器日志（排查加载失败原因）
bpftool prog load my_prog.o /sys/fs/bpf/my_prog 2>&1

# 监控 JIT 编译和 map 操作性能
perf stat -e 'bpf:*' sleep 10