Linux eBPF 深度实战：内核可编程观测与网络加速的革命性技术

摘要：eBPF（Extended Berkeley Packet Filter）正在彻底改变 Linux 内核的可编程性边界。从网络包过滤到全栈观测、从安全策略执行到性能剖析，eBPF 让开发者能够在不修改内核源码、不加载内核模块的前提下，安全地在内核空间执行用户定义的程序。本文将深入探讨 eBPF 的核心架构、开发工具链、以及 XDP 网络加速、系统调用追踪、性能剖析等实战场景，并分享生产环境部署经验。

一、为什么 eBPF 是革命性的？

在 eBPF 出现之前，如果你想在内核层面做点事情，无非两条路：要么修改内核源码并重新编译（升级噩梦），要么编写内核模块（一个指针错误就导致 kernel panic）。这两种方式的运维成本和风险都极高。

eBPF 的革命性在于它提供了一条「第三条道路」：

• 安全性：每个 eBPF 程序在加载前必须通过内核验证器（Verifier）的严格静态分析，确保不会有无限循环、非法内存访问或未初始化变量读取
• 高性能：JIT 编译为原生指令，执行效率接近内核原生代码
• 热加载：无需重启、无需重新编译内核，随时加载和卸载
• 可观测：通过 BPF Maps 实现内核态与用户态的高效数据交换，零拷贝传输观测数据

今天的 eBPF 生态已经非常成熟：Cilium（云原生网络）、Falco（运行时安全）、Tetragon（eBPF-based安全观测）、Pixie（Kubernetes 可观测性）、bpftrace（类 awk 的追踪语言）——全都建立在 eBPF 之上。

二、eBPF 核心架构解析

理解 eBPF 需要先理解它的三个核心组件：

2.1 eBPF 程序本身

eBPF 程序本质上是一组受限的 C 语言子集（或通过其他前端编译为 eBPF 字节码），编译后生成 eBPF 字节码（一种 RISC 风格的 64 位指令集）。在加载时，内核 Verifier 会执行以下检查：

• 程序必须是有限长度的有向无环图（DAG），保证终止性
• 所有内存访问必须有边界检查（bounds check）
• 不能访问未初始化的栈空间或寄存器
• 只有允许的 helper 函数才能被调用

一旦通过验证，字节码由 JIT 编译器转换为目标架构（x86_64/ARM64）的原生指令，达到接近原生的执行速度。

2.2 BPF Maps（映射）

Maps 是 eBPF 程序与用户空间通信的核心数据结构，本质上是一种通用的 key-value 存储。主要类型包括：

BPF_MAP_TYPE_RINGBUF 是较新加入的类型，相比旧版 PERF_EVENT_ARRAY 有显著的性能提升和更简洁的 API，已成为生产环境推荐方案。

2.3 Attach Hooks（挂载点）

eBPF 程序必须挂载到内核的特定事件点上才能执行。主要挂载类型包括：

• XDP (eXpress Data Path)：网卡驱动层的最早期包处理，性能最高，可做 DDoS 防护、负载均衡
• TC (Traffic Control)：内核流量控制层，hook 点在协议栈处理前后
• Kprobes/Uprobes：动态插桩内核/用户函数入口
• Tracepoints：内核静态跟踪点，更稳定、性能开销更低
• Fentry/Fexit：基于 BTF 的函数入口/出口追踪，比 Kprobes 快 5-10 倍
• LSM (Linux Security Module)：安全策略执行点，可做强制访问控制

三、开发工具链与入门实战

3.1 BCC：快速原型开发

BCC（BPF Compiler Collection）是最流行的 eBPF 开发框架，提供 Python/Lua 前端，适合快速验证想法。追踪 TCP 连接的入门示例：

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

# 嵌入 eBPF C 代码
bpf_text = """
#include <uapi/linux/ptrace.h>
#include <net/sock.h>
#include <bcc/proto.h>

BPF_HASH(currsock, u32, struct sock *);

int trace_connect_entry(struct pt_regs *ctx, struct sock *sk) {
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    currsock.update(&pid, &sk);
    return 0;
}

int trace_connect_return(struct pt_regs *ctx) {
    int ret = PT_REGS_RC(ctx);
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    struct sock **skpp = currsock.lookup(&pid);
    if (!skpp) return 0;
    if (ret != 0) { currsock.delete(&pid); return 0; }
    
    struct sock *sk = *skpp;
    u16 dport = 0;
    bpf_probe_read_kernel(&dport, sizeof(dport), &sk->__sk_common.skc_dport);
    bpf_trace_printk("PID %d connected to port %d\\n",
                     pid, ntohs(dport));
    currsock.delete(&pid);
    return 0;
}
"""

b = BPF(text=bpf_text)
b.attach_kprobe(event="tcp_v4_connect", fn_name="trace_connect_entry")
b.attach_kretprobe(event="tcp_v4_connect", fn_name="trace_connect_return")
print("Tracing TCP connect() ... Ctrl+C to end")
b.trace_print()

运行后你可以看到类似 PID 8518 connected to port 443 的输出。BCC 支持 Python 端对 Map 读写、perf buffer 读取、直方图统计等丰富功能，是理解和验证 eBPF 概念的最佳入口。

3.2 libbpf：生产级开发标准

对于生产环境，libbpf 是官方推荐方案。它基于 CO-RE（Compile Once, Run Everywhere）理念，通过 BTF（BPF Type Format）信息实现结构体偏移的运行时适配，允许编译一次后跨不同内核版本运行。

一个完整的 libBPF "Hello World" 示例——追踪 execve 系统调用：

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

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

SEC("tp/syscalls/sys_enter_execve")
int tracepoint__syscalls__sys_enter_execve(
    struct trace_event_raw_sys_enter *ctx)
{
    const char *filename = (const char *)ctx->args[0];
    u64 pid_tgid = bpf_get_current_pid_tgid();
    u32 pid = pid_tgid >> 32;
    
    // 从 BPF Map 中获取可配置的目标 PID
    u32 target_pid = 0;
    u32 key = 0;
    u32 *cfg = bpf_map_lookup_elem(&config, &key);
    if (cfg) target_pid = *cfg;
    
    if (target_pid == 0 || target_pid == pid) {
        char comm[16];
        bpf_get_current_comm(comm, sizeof(comm));
        bpf_printk("PID %d (%s) executing: %s\n", pid, comm, filename);
    }
    return 0;
}

// BPF Map 定义
struct {
    __uint(type, BPF_MAP_TYPE_ARRAY);
    __uint(max_entries, 1);
    __type(key, u32);
    __type(value, u32);
} config SEC(".maps");

配合用户空间加载器：

// hello.c
#include <stdio.h>
#include <unistd.h>
#include <bpf/libbpf.h>
#include "hello.skel.h"

int main(int argc, char **argv)
{
    struct hello_bpf *skel;
    int err;
    
    skel = hello_bpf__open();
    if (!skel) { fprintf(stderr, "Failed to open BPF skeleton\n"); return 1; }
    
    err = hello_bpf__load(skel);
    if (err) { fprintf(stderr, "Failed to load BPF skeleton\n"); goto cleanup; }
    
    err = hello_bpf__attach(skel);
    if (err) { fprintf(stderr, "Failed to attach BPF skeleton\n"); goto cleanup; }
    
    printf("Successfully attached! Run `sudo cat /sys/kernel/debug/tracing/trace_pipe` to see output\n");
    
    while (1) sleep(1);
    
cleanup:
    hello_bpf__destroy(skel);
    return err != 0;
}

编译流程（借助 bpftool 生成 skeleton）：

clang -g -O2 -target bpf -c hello.bpf.c -o hello.bpf.o
bpftool gen skeleton hello.bpf.o > hello.skel.h
gcc -g -O2 -Wall hello.c -o hello -lbpf -lelf -lz
sudo ./hello

四、XDP 网络加速实战

4.1 XDP 工作原理

XDP 在数据包到达内核协议栈之前就进行处理——具体而言，在网卡驱动接收数据包的最早时刻。这意味着 XDP 可以在数据包进入内核网络栈之前就做出丢弃、转发或重定向的决策。

XDP 的三种工作模式：

• Native XDP：直接挂载在网卡驱动层，性能最优，需要驱动支持
• Offloaded XDP：字节码卸载到网卡硬件执行（SmartNIC），性能最高
• Generic XDP：挂载在协议栈的内核通用层，不要求驱动支持，性能略低

XDP 程序返回的 action 决定数据包命运：

• XDP_DROP：立即丢弃（DDoS 防护的核心）
• XDP_PASS：交给内核协议栈正常处理
• XDP_TX：从同一网卡发送回去
• XDP_REDIRECT：转发到另一张网卡或另一个 CPU 的接收队列

4.2 DDoS 防护实战：SYN Flood 防护

编写一个 XDP 程序来应对 SYN Flood 攻击：

// xdp_syn_protect.bpf.c
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_endian.h>

#define ETH_P_IP 0x0800
#define IPPROTO_TCP 6
#define TCP_FLAG_SYN 0x02

struct {
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
    __uint(max_entries, 65536);
    __type(key, __u32);       // 源 IP
    __type(value, __u64);     // 上次_seen + 计数
} syn_count SEC(".maps");

SEC("xdp")
int xdp_syn_protect(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 (bpf_ntohs(eth->h_proto) != ETH_P_IP) return XDP_PASS;
    
    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end) return XDP_PASS;
    if (ip->protocol != IPPROTO_TCP) return XDP_PASS;
    
    struct tcphdr *tcp = (void *)(ip + 1);
    if ((void *)(tcp + 1) > data_end) return XDP_PASS;
    
    // 只处理 SYN 包
    if (!(tcp->syn && !tcp->ack)) return XDP_PASS;
    
    __u32 src_ip = ip->saddr;
    __u64 now = bpf_ktime_get_ns();
    __u64 one_second = 1000000000ULL;
    
    __u64 *entry = bpf_map_lookup_elem(&syn_count, &src_ip);
    if (entry) {
        __u64 last_time = *entry >> 20;
        __u32 count = *entry & 0xFFFFF;
        
        if (now - last_time < one_second) {
            count++;
            if (count > 100) {  // 每秒超过 100 个 SYN
                bpf_printk("Blocking SYN flood from %x (count=%d)\n", src_ip, count);
                return XDP_DROP;
            }
        } else {
            count = 1;  // 重置计数器
        }
        
        __u64 new_val = (now << 20) | (count & 0xFFFFF);
        bpf_map_update_elem(&syn_count, &src_ip, &new_val, BPF_ANY);
    } else {
        __u64 new_val = (now << 20) | 1;
        bpf_map_update_elem(&syn_count, &src_ip, &new_val, BPF_ANY);
    }
    
    return XDP_PASS;
}

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

将此程序挂载到网卡只需一行命令：

sudo ip link set dev eth0 xdp obj xdp_syn_protect.bpf.o sec xdp

// opensnoop.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;
    u32 uid;
    char comm[16];
    char filename[256];
    int ret;
};

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

SEC("tp/syscalls/sys_enter_openat")
int tracepoint__syscalls__sys_enter_openat(
    struct trace_event_raw_sys_enter *ctx)
{
    struct event ev = {};
    u64 pid_tgid = bpf_get_current_pid_tgid();
    ev.pid = pid_tgid >> 32;
    ev.uid = bpf_get_current_uid_gid() & 0xFFFFFFFF;
    bpf_get_current_comm(ev.comm, sizeof(ev.comm));
    
    const char *filename = (const char *)ctx->args[1];
    bpf_probe_read_user_str(ev.filename, sizeof(ev.filename), filename);
    
    // 提交到 perf buffer
    bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, &ev, sizeof(ev));
    return 0;
}

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

// 简化的事件处理循环
static void handle_event(void *ctx, int cpu, void *data, __u32 size)
{
    struct event *ev = data;
    printf("PID %d (%s, uid=%d) opened: %s (ret=%d)\n",
           ev->pid, ev->comm, ev->uid, ev->filename, ev->ret);
}

struct perf_buffer *pb = perf_buffer__new(bpf_map__fd(skel->maps.events),
                                          64, handle_event, NULL, NULL, NULL);
while (true) {
    perf_buffer__poll(pb, 100);  // 每 100ms 轮询一次
}

// offcpu.bpf.c - 简化版
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 10240);
    __type(key, struct key_t);   // pid + 用户栈ID + 内核栈ID
    __type(value, u64);          // offcpu 时间总和(off-cpu time total)
} counts SEC(".maps");

SEC("tp/sched/sched_switch")
int trace_sched_switch(struct trace_event_raw_sched_switch *ctx)
{
    u64 ts = bpf_ktime_get_ns();
    
    // 如果 prev_state == TASK_RUNNING，进程还在运行队列
    // 否则记录 off-CPU 开始时间
    // ...
    
    // 当进程被重新调度时，计算 off_cpu delta 更新 counts
    return 0;
}