eBPF 实战：使用 BPF 追踪系统调用与性能分析全指南

从内核虚拟机到可观测性革命，深入理解 eBPF 核心技术栈

一、eBPF 是什么？为什么它正在改变Linux？

eBPF（Extended Berkeley Packet Filter）是 Linux 内核中的一项革命性技术，它允许在不修改内核源码、不加载内核模块的情况下，安全地在内核空间运行沙箱化程序。自 Linux 3.18 引入以来，eBPF 已经从最初的数据包过滤工具，演变为一个通用的内核可编程框架。

eBPF 的核心价值在于：让应用程序以内核级别的速度运行，同时保持极高的安全性与可观测性。传统上，要实现内核级功能需要编写内核模块（风险高、升级难、调试难），而 eBPF 程序由内核验证器（Verifier）在执行前进行静态分析，确保不会导致内核崩溃或死循环。

如今，eBPF 已成为云原生基础设施的基石：

• Cilium — 基于 eBPF 的网络插件，替代 kube-proxy 实现 Service 负载均衡
• Falco — 运行时安全监控工具
• Pixie — Kubernetes 应用的可观测性平台
• Katran — Facebook 的高性能 L4 负载均衡器

二、eBPF 架构深度解析

2.1 执行流程

eBPF 程序的完整生命周期如下：

1. 用户用 C（或 Rust）编写 eBPF 程序源码
2. 通过 LLVM/Clang 编译为 eBPF 字节码
3. 使用 bpf() 系统调用加载到内核
4. 内核 Verifier 验证程序安全性（无死循环、无越界访问）
5. JIT 编译为原生机器码
6. 挂载到内核钩子点（hook point），触发执行
7. 通过 BPF Maps 与用户空间交换数据

2.2 BPF 验证器（Verifier）

Verifier 是 eBPF 安全模型的基石，它执行以下检查：

• 所有内存访问必须在合法范围内（通过 bpf_probe_read 等辅助函数）
• 程序必须有终止路径（禁止无限循环）
• 最大指令数限制（Linux 5.2+ 为 100 万条指令）
• 只能在授权的 hook 点调用辅助函数
• 栈空间限制（每个程序 512 字节）

2.3 BPF Maps — 内核态与用户态的桥梁

BPF Maps 是 eBPF 程序与用户空间通信的核心机制：

三、eBPF Hook 点类型全景

eBPF 可以挂载到内核的多个层面：

3.1 Tracepoint — 静态内核钩子

Tracepoint 是内核源码中的稳定钩子点，不会随内核版本变化。常见挂载点：

• syscalls/sys_enter_* — 系统调用入口
• syscalls/sys_exit_* — 系统调用出口
• sched/sched_process_fork — 进程创建
• irq/irq_handler_entry — 中断处理
• net/net_dev_queue — 网络设备队列

3.2 Kprobe/Kretprobe — 动态内核探针

Kprobe 可以挂载到几乎任何内核符号（函数入口），动态追踪内核行为：

# 追踪 do_sys_openat2 函数入口
sudo bpftrace -e 'kprobe:do_sys_openat2 { printf("%s: %s\n", comm, str(arg1)); }'

# 追踪 tcp_connect 返回值
sudo bpftrace -e 'kretprobe:tcp_connect { printf("tcp_connect ret: %d\n", retval); }'

3.3 Uprobe/Uretprobe — 用户态探针

可以挂载到用户态函数，用于追踪应用层行为：

# 追踪 malloc 调用（libc）
sudo bpftrace -e 'uprobe:/lib/x86_64-linux-gnu/libc.so.6:malloc { @[comm] = count(); }'

# 追踪 Java 应用的 JIT 编译方法
sudo bpftrace -e 'uprobe:/usr/lib/jvm/java-17/bin/java:MyService*Process { printf("method called\n"); }'

3.4 XDP — 网络数据路径

XDP（eXpress Data Path）允许在网卡驱动层执行 eBPF 程序，甚至在数据包进入 Linux 网络栈之前：

• DDoS 防护：在驱动层直接丢弃恶意包
• 负载均衡：四层 L4 转发，性能可达 2400 万 pps/核
• 防火墙：基于 IP/端口/协议的包过滤

四、系统调用追踪实战

4.1 使用 bpftrace 一行命令追踪

bpftrace 是 eBPF 的高级封装语言，无需编译即可运行：

# 1. 追踪所有 open 系统调用及参数
sudo bpftrace -e 'tracepoint:syscalls:sys_enter_openat {
    printf("%s[%d] open: %s\n", comm, pid, str(args->filename));
}'

# 2. 统计每个进程的 read 调用次数
sudo bpftrace -e 'tracepoint:syscalls:sys_enter_read {
    @[comm] = count();
}'

# 3. 追踪 execve 系统调用（新进程创建）
sudo bpftrace -e 'tracepoint:syscalls:sys_enter_execve {
    printf("[%d] %s: %s\n", pid, comm, str(args->filename));
}'

# 4. 按用户统计系统调用频率
sudo bpftrace -e 'tracepoint:syscalls:sys_enter_* {
    @[uid, comm] = count();
}'

# 5. 追踪文件删除操作
sudo bpftrace -e 'tracepoint:syscalls:sys_enter_unlinkat {
    printf("DELETE: %s by %s[%d]\n", str(args->pathname), comm, pid);
}'

4.2 使用 BCC Python 编写自定义追踪

BCC（BPF Compiler Collection）提供 Python 绑定，适合编写复杂的追踪工具：

#!/usr/bin/env python3
from bcc import BPF

# eBPF C 代码
bpf_c_code = """
#include <uapi/linux/ptraces.h>
#include <linux/sched.h>

struct event_t {
    u32 pid;
    u32 uid;
    char comm[TASK_COMM_LEN];
    char filename[256];
};

BPF_PERF_OUTPUT(events);

TRACEPOINT_PROBE(syscalls, sys_enter_openat) {
    struct event_t event = {};
    event.pid = bpf_get_current_pid_tgid() >> 32;
    event.uid = bpf_get_current_uid_gid() & 0xFFFFFFFF;
    bpf_get_current_comm(&event.comm, sizeof(event.comm));
    bpf_probe_read_user_str(event.filename, sizeof(event.filename),
                           (void *)args->filename);
    events.perf_submit(args, &event, sizeof(event));
    return 0;
}
"""

# 加载 eBPF 程序
b = BPF(text=bpf_c_code)

# 输出函数
def print_event(cpu, data, size):
    event = b["events"].event(data)
    print(f"[{event.pid}] {event.comm.decode()}: {event.filename.decode()}")

# 绑定回调并开始轮询
b["events"].open_perf_buffer(print_event)
while True:
    try:
        b.perf_buffer_poll()
    except KeyboardInterrupt:
        break

4.3 使用 libbpf CO-RE 编写现代 eBPF 程序

CO-RE（Compile Once, Run Everywhere）是现代 eBPF 开发的最佳实践，一次编译可在多个内核版本运行：

// trace_open.bpf.c
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>
#include <bpf/bpf_core_read.h>

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 10240);
    __type(key, u32);    // pid
    __type(value, u64);  // open call count
} open_stats SEC(".maps");

SEC("tp/syscalls/sys_enter_openat")
int trace_openat(struct trace_event_raw_sys_enter *ctx)
{
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    u64 *count = bpf_map_lookup_elem(&open_stats, &pid);
    if (count) {
        __sync_fetch_and_add(count, 1);
    } else {
        u64 init = 1;
        bpf_map_update_elem(&open_stats, &pid, &init, BPF_ANY);
    }
    return 0;
}

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

五、网络数据包捕获与分析实战

5.1 XDP 程序高性能包过滤

// xdp_drop.bpf.c — 丢弃来自特定 IP 的数据包
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <linux/if_ether.h>
#include <linux/ip.h>

#define BLOCKED_IP 0x0A000001  // 10.0.0.1

SEC("xdp")
int xdp_drop_prog(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 != __constant_htons(ETH_P_IP))
        return XDP_PASS;

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

    if (ip->saddr == __constant_htonl(BLOCKED_IP))
        return XDP_DROP;

    return XDP_PASS;
}

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

5.2 使用 sockmap 实现 Socket 级别重定向

Sockmap 允许 eBPF 程序在内核层直接重定向 Socket 数据包，绕过整个 TCP/IP 协议栈：

// sockmap 实现 Socket 重定向（Service Mesh sidecar 旁路）
struct {
    __uint(type, BPF_MAP_TYPE_SOCKHASH);
    __uint(max_entries, 65535);
    __type(key, struct sock_key);
    __type(value, sizeof(u32));
} sock_map SEC(".maps");

SEC("sockops")
int bpf_sockmap(struct bpf_sockops *skops)
{
    if (skops->op == BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB ||
        skops->op == BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB) {
        struct sock_key key = {
            .sip4 = skops->remote_ip4,
            .dip4 = skops->local_ip4,
            .dport = skops->local_port,
            .sport = bpf_ntohl(skops->remote_port),
        };
        bpf_sock_hash_update(skops, &sock_map, &key, BPF_NOEXIST);
    }
    return 0;
}

SEC("sk_msg")
int bpf_redir(struct sk_msg_md *msg)
{
    struct sock_key key = { /* 构造 key */ };
    bpf_msg_redirect_hash(msg, &sock_map, &key, BPF_F_INGRESS);
    return SK_PASS;
}

六、性能分析工具链实战

6.1 使用 eBPF 追踪 CPU 火焰图

# 采集 CPU 调用栈（perf + eBPF 混合模式）
sudo perf record -g -F 99 -a -- sleep 60

# 或使用 BCC 的 profile 工具
sudo profile-bpfcc -F 99 -f 30 > out.stacks
./FlameGraph/flamegraph.pl out.stacks > cpu_flamegraph.svg

6.2 使用 offcputime 追踪进程阻塞

# 追踪进程在 CPU 之外的等待时间（阻塞分析）
sudo offcputime-bpfcc -df -p $(pidof myapp) 30 > out.offcpu
./FlameGraph/flamegraph.pl --color=io out.offcpu > offcpu_flamegraph.svg

6.3 使用 biolatency 分析块设备 I/O 延迟

# 块设备 I/O 延迟直方图
sudo biolatency-bpfcc -m 10

6.4 自定义延迟追踪器

// 追踪 MySQL 查询处理延迟
SEC("uprobe//usr/sbin/mysqld:dispatch_command")
int query_start(struct pt_regs *ctx)
{
    u64 ts = bpf_ktime_get_ns();
    u32 tid = bpf_get_current_pid_tgid();
    bpf_map_update_elem(&start, &tid, &ts, BPF_ANY);
    return 0;
}

SEC("uretprobe//usr/sbin/mysqld:dispatch_command")
int query_end(struct pt_regs *ctx)
{
    u32 tid = bpf_get_current_pid_tgid();
    u64 *tsp = bpf_map_lookup_elem(&start, &tid);
    if (!tsp) return 0;

    u64 delta_us = (bpf_ktime_get_ns() - *tsp) / 1000;
    // 记录到直方图 Map 并输出到用户空间
    hist.atomic_increment(bpf_log2l(delta_us));
    return 0;
}

七、eBPF 与经典工具对比

eBPF 不是要替代传统工具，而是在特定场景下提供更高性能：

八、生产环境部署与运维最佳实践

8.1 内核版本要求

• 最低要求：Linux 4.15+（基础功能）
• 推荐版本：Linux 5.4+（稳定 BTF、Ring Buffer）
• 理想版本：Linux 5.15+ LTS（完整功能集）

8.2 部署架构选择

• DaemonSet（Kubernetes）：每节点部署 eBPF Agent，采集数据发送到中心存储
• Sidecar 模式：与业务容器共享 Namespace，精细追踪
• 单机 Agent：主机监控场景，直接运行 BCC/bpftrace 工具集

8.3 性能与资源控制

• 设置 eBPF Map 最大条目数，防止内存无限增长
• 使用 bpf_jit_kallsyms=1 开启 JIT 符号导出，便于调试
• 限制 Ring Buffer 大小和轮询频率
• 通过 cgroup eBPF 限制特定容器的监控范围

8.4 故障排查命令速查

# 查看已加载的 eBPF 程序
sudo bpftool prog show

# 查看 BPF Map 信息
sudo bpftool map show

# 查看 eBPF 程序的 JIT 编译结果
sudo bpftool prog dump jited id 42

# 查看 BPF 程序统计（运行时间、执行次数）
sudo bpftool prog show --stats

# 查看系统 BPF 限制
sysctl kernel.bpf_stats_enabled
cat /proc/sys/kernel/unprivileged_bpf_disabled

# 检查 BTF 信息
ls /sys/kernel/btf/
sudo btf dump file /sys/kernel/btf/vmlinux format c | head -100

九、总结与展望

eBPF 正在重塑 Linux 内核的可观测性、安全性和网络能力。它的核心优势可以总结为：

• 安全：Verifier 内核验证，程序无法导致内核崩溃
• 高性能：JIT 编译，执行效率接近原生内核代码
• 可编程：C/Rust 编程，灵活性远超静态 tracepoint
• 零侵入：用户无需修改任何业务代码或重启服务

随着 eBPF 在 Windows 平台的扩展（eBPF on Windows）和 io_uring 的深度融合，我们可以期待一个更强大、更统一的跨平台内核可编程生态。对于开发者和 SRE 工程师而言，掌握 eBPF 技能将成为云原生时代的必备竞争力。

学习路径建议：先用 bpftrace 快速验证想法，再过渡到 BCC Python 实现中等复杂度工具，最终用 libbpf CO-RE 编写生产级 eBPF 程序。GitHub 上的 ebpf.io 和 iovisor/bcc 是最佳的开源学习资源。