eBPF 与 Linux 内核可观测性实战：从系统调用追踪到生产级性能分析

为什么需要 eBPF？传统可观测性的天花板

在云原生时代，可观测性（Observability）是系统可靠性的三大支柱之一（另外两个是监控和告警）。我们通常依赖以下手段来理解系统行为：

• 日志（Logs）：最直观，但高并发场景下日志量爆炸，且只能看到开发者预设的信息
• 指标（Metrics）：聚合统计，但会丢失细节——P99 延迟飙升了，但为什么飙升？
• 链路追踪（Traces）：跨服务追踪优秀，但对内核态行为无能为力
• 动态插桩（Dynamic Tracing）：SystemTap、DTrace 等，但配置复杂、安全风险高、性能开销大

传统方案的核心矛盾在于：要深入观测内核行为，要么修改内核源码（风险极高、维护成本巨大），要么加载内核模块（稳定性差、版本绑定）。

eBPF（Extended Berkeley Packet Filter）彻底改变了这一局面。它允许在不修改内核源码、不加载内核模块的情况下，在 Linux 内核中安全地运行沙箱程序。

eBPF 核心架构与工作原理

理解 eBPF 的工作原理，需要掌握其完整的执行流水线：

┌─────────────────────────────────────────────────────┐
│                  用户态程序                           │
│  ┌──────────┐    ┌──────────┐    ┌───────────────┐  │
│  │ C/Rust   │───▶│ 编译器   │───▶│ BPF 字节码    │  │
│  │ 源码     │    │(clang)   │    │ (ELF .o)      │  │
│  └──────────┘    └──────────┘    └───────┬───────┘  │
│                                          │           │
│  ┌──────────────────────────────────────┐│           │
│  │     BPF 系统调用 (bpf())             ││           │
│  │  BPF_PROG_LOAD → 字节码 + Map 描述   │◀┘           │
│  └──────────────────┬───────────────────┘             │
└─────────────────────┼─────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────┐
│                   Linux 内核                         │
│  ┌──────────────────┐    ┌──────────────────────┐   │
│  │   eBPF Verifier  │───▶│   eBPF JIT 编译器    │   │
│  │   (静态验证)     │    │   (字节码→机器码)    │   │
│  │                  │    │                      │   │
│  │ • 无死循环       │    │ x86_64 / ARM64 /     │   │
│  │ • 无越界访问     │    │ RISC-V 多架构支持    │   │
│  │ • 无未初始化读取 │    └──────────┬───────────┘   │
│  │ • 栈大小限制     │               │               │
│  └──────────────────┘               ▼               │
│                          ┌──────────────────────┐   │
│                          │  内核挂载点 (Hook)    │   │
│                          │  kprobe / tracepoint │   │
│                          │  XDP / TC / socket   │   │
│                          └──────────────────────┘   │
│                                                     │
│  ┌──────────────────────────────────────────────┐   │
│  │              BPF Maps (键值存储)              │   │
│  │  ┌─────────┐ ┌──────────┐ ┌──────────────┐  │   │
│  │  │ HashMap │ │PerfEvent │ │ Ring Buffer  │  │   │
│  │  │         │ │  Array   │ │              │  │   │
│  │  └─────────┘ └──────────┘ └──────────────┘  │   │
│  └──────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────┘

关键流程解析：

1. 编译：用 C/Rust 编写 eBPF 程序，通过 clang 编译为 BPF 字节码
2. 加载：通过 bpf() 系统调用将字节码提交给内核
3. 验证：eBPF Verifier 进行严格的静态分析，确保程序安全
4. JIT 编译：验证通过后，JIT 编译器将字节码翻译为原生机器码
5. 挂载：程序被挂载到指定的内核钩子点（kprobe、tracepoint、XDP 等）
6. 数据交换：通过 BPF Maps 在内核态和用户态之间传递数据

eBPF 程序类型与挂载点全景

eBPF 支持丰富的程序类型，覆盖了从网络到安全的各个层面：

实战一：系统调用追踪——用 bpftrace 解密进程行为

bpftrace 是 eBPF 生态中的高级追踪语言，语法类似 awk，非常适合快速编写一次性追踪脚本。

1. 安装 bpftrace

# Ubuntu/Debian
sudo apt-get install -y bpftrace

# CentOS/RHEL/Fedora
sudo dnf install -y bpftrace

# Arch Linux
sudo pacman -S bpftrace

# 验证安装
sudo bpftrace --version

2. 追踪所有 openat 系统调用

#!/usr/bin/env bpftrace
/*
 * trace-openat.bt - 追踪进程打开文件的行为
 * 用法: sudo bpftrace trace-openat.bt
 */

tracepoint:syscalls:sys_enter_openat
{
    // 获取当前进程名和 PID
    @open_count[comm, pid] = count();
    
    // 打印详细信息（仅 PID 为当前目标时）
    printf("[%s] PID=%d UID=%d 打开文件: %s\n",
           comm, pid, uid, str(args->filename));
}

tracepoint:syscalls:sys_exit_openat
/args->ret < 0/
{
    @failed_open[comm] = count();
    printf("⚠️  [%s] PID=%d 打开失败, ret=%d\n",
           comm, pid, args->ret);
}

END
{
    printf("\n=== 文件打开统计 ===\n");
    print(@open_count);
    clear(@open_count);
    
    printf("\n=== 打开失败统计 ===\n");
    print(@failed_open);
    clear(@failed_open);
}

3. 按容器追踪文件访问模式

#!/usr/bin/env bpftrace
/*
 * container-file.bt - 按容器追踪文件访问
 * 通过 cgroup ID 关联容器身份
 */

tracepoint:syscalls:sys_enter_openat
{
    // 获取 cgroup ID，用于关联容器
    $task = (struct task_struct *)curtask;
    $cgroup_id = $task->cgroups->dfl_cgrp->kn->id;
    
    // 按 cgroup_id 统计
    @file_access[$cgroup_id, str(args->filename)] = count();
}

interval:s:5
{
    printf("\n=== 每5秒文件访问 Top 20 ===\n");
    print(@file_access, 20);
    clear(@file_access);
}

4. 追踪特定进程的系统调用延迟

#!/usr/bin/env bpftrace
/*
 * syscall-latency.bt - 追踪系统调用耗时
 * 针对 nginx 进程的 read/write 调用
 */

kprobe:__x64_sys_read
/comm == "nginx"/
{
    @read_start[tid] = nsecs;
}

kretprobe:__x64_sys_read
/@read_start[tid]/
{
    $latency_us = (nsecs - @read_start[tid]) / 1000;
    @read_latency = hist($latency_us);
    delete(@read_start[tid]);
}

kprobe:__x64_sys_write
/comm == "nginx"/
{
    @write_start[tid] = nsecs;
}

kretprobe:__x64_sys_write
/@write_start[tid]/
{
    $latency_us = (nsecs - @write_start[tid]) / 1000;
    @write_latency = hist($latency_us);
    delete(@write_start[tid]);
}

END
{
    printf("\n=== nginx read() 延迟分布 (μs) ===\n");
    print(@read_latency);
    
    printf("\n=== nginx write() 延迟分布 (μs) ===\n");
    print(@write_latency);
}

运行效果示例：

$ sudo bpftrace syscall-latency.bt
Attaching 4 probes...

=== nginx read() 延迟分布 (μs) ===
@read_latency: 
[0]                 3872 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@|
[1]                 2156 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@                  |
[2]                  891 |@@@@@@@@@@@@@@@@@                                   |
[4]                  423 |@@@@@@@@@@                                          |
[8]                  198 |@@@@@@                                              |
[16]                  87 |@@@                                                 |
[32]                  42 |@@                                                  |
[64]                  18 |@                                                   |
[128]                  8 |                                                    |
[256]                  3 |                                                    |

=== nginx write() 延迟分布 (μs) ===
@write_latency: 
[0]                 5234 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@|
[1]                 1876 |@@@@@@@@@@@@@@@@@@@@@@@@@@                          |
[2]                  645 |@@@@@@@@@@@@@@                                      |
[4]                  234 |@@@@@@                                              |
[8]                  112 |@@@                                                 |
[16]                   56 |@@                                                  |
[32]                   23 |@                                                   |
[64]                   12 |                                                    |
[128]                   6 |                                                    |

从直方图可以清晰看到，nginx 的 read 和 write 系统调用大部分在 0-2μs 内完成，但有少量长尾请求超过了 128μs，这通常与磁盘 I/O 等待或网络抖动有关。

实战二：网络延迟分析——TCP 往返时延的直方图统计

网络延迟是微服务架构中最关键的指标之一。eBPF 可以在内核协议栈的关键路径上挂载钩子，精确测量 TCP 连接的往返时延（RTT）。

完整的 TCP RTT 追踪 eBPF 程序

// tcp_rtt.bpf.c - 追踪 TCP RTT 分布
#include 
#include 
#include 
#include 
#include 
#include 

// 定义 Map：存储 RTT 直方图
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 1024);
    __type(key, __u32);    // 桶索引
    __type(value, __u64);  // 计数
} rtt_histogram SEC(".maps");

// 定义 Map：存储连接信息
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 4096);
    __type(key, struct sock *);
    __type(value, __u64);  // 最后测量的 RTT (微秒)
} rtt_values SEC(".maps");

SEC("kprobe/tcp_rcv_established")
int BPF_KPROBE(tcp_rcv_established, struct sock *sk)
{
    // 只追踪 IPv4 TCP
    if (sk->__sk_common.skc_family != AF_INET)
        return 0;
    
    // 获取 TCP  socket 状态
    struct tcp_sock *tp = (struct tcp_sock *)sk;
    __u32 rtt = tp->srtt_us >> 3;  // 平滑 RTT（微秒）
    
    // 存储 RTT 值
    bpf_map_update_elem(&rtt_values, &sk, &rtt, BPF_ANY);
    
    // 计算直方图桶（对数分桶）
    __u32 bucket = 0;
    __u32 val = rtt;
    while (val > 0) {
        val >>= 1;
        bucket++;
    }
    
    // 更新直方图计数
    __u64 *count = bpf_map_lookup_elem(&rtt_histogram, &bucket);
    if (count) {
        __sync_fetch_and_add(count, 1);
    } else {
        __u64 init = 1;
        bpf_map_update_elem(&rtt_histogram, &bucket, &init, BPF_ANY);
    }
    
    return 0;
}

// 追踪 TCP 重传事件
SEC("tracepoint/tcp/tcp_retransmit_skb")
int trace_tcp_retransmit(struct trace_event_raw_tcp_retransmit_skb *ctx)
{
    struct sock *sk = (struct sock *)ctx->skaddr;
    __u64 ts = bpf_ktime_get_ns();
    
    // 记录重传事件
    __u32 saddr = ctx->saddr;
    __u32 daddr = ctx->daddr;
    __u16 sport = ctx->sport;
    __u16 dport = ctx->dport;
    
    bpf_printk("TCP 重传: %pI4:%d -> %pI4:%d seq=%u\n",
               &saddr, sport, &daddr, dport, ctx->seq);
    
    return 0;
}

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

用户态加载程序

// tcp_rtt_user.c - 用户态加载和数据分析
#include 
#include 
#include 
#include 
#include 
#include "tcp_rtt.skel.h"

static volatile bool running = true;

void sig_handler(int sig) {
    running = false;
}

static int print_rtt_histogram(struct bpf_map *map) {
    __u32 key, next_key;
    __u64 value;
    int fd = bpf_map__fd(map);
    
    printf("\n╔══════════════════════════════════════════╗\n");
    printf("║       TCP RTT 分布直方图 (微秒)          ║\n");
    printf("╠══════════════════════════════════════════╣\n");
    
    // 对数分桶：bucket n 对应 RTT 范围 [2^(n-1), 2^n) μs
    const char *labels[] = {
        "0-1", "1-2", "2-4", "4-8", "8-16", "16-32",
        "32-64", "64-128", "128-256", "256-512",
        "512-1024", "1-2ms", "2-4ms", "4-8ms", "8-16ms",
        "16-32ms", "32-64ms", "64-128ms", "128-256ms", ">256ms"
    };
    
    key = 0;
    while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
        bpf_map_lookup_elem(fd, &next_key, &value);
        
        int bucket = next_key;
        if (bucket < 20) {
            printf("║ %8s μs: %8llu ", labels[bucket], value);
            
            // 简单的 ASCII 柱状图
            int bars = (int)(value > 50 ? 50 : value);
            for (int i = 0; i < bars; i++) printf("█");
            printf("\n");
        }
        
        key = next_key;
    }
    
    printf("╚══════════════════════════════════════════╝\n");
    return 0;
}

int main(int argc, char **argv) {
    struct tcp_rtt_bpf *skel;
    int err;
    
    signal(SIGINT, sig_handler);
    signal(SIGTERM, sig_handler);
    
    // 打开并加载 BPF 程序
    skel = tcp_rtt_bpf__open_and_load();
    if (!skel) {
        fprintf(stderr, "Failed to load BPF skeleton\n");
        return 1;
    }
    
    // 附加 kprobe
    err = tcp_rtt_bpf__attach(skel);
    if (err) {
        fprintf(stderr, "Failed to attach BPF program\n");
        goto cleanup;
    }
    
    printf("TCP RTT 追踪已启动... 按 Ctrl+C 停止\n");
    
    while (running) {
        sleep(5);
        print_rtt_histogram(skel->maps.rtt_histogram);
    }
    
cleanup:
    tcp_rtt_bpf__destroy(skel);
    return 0;
}

编译和运行

# 使用 libbpf skeleton 生成
bpftool gen skeleton tcp_rtt.bpf.o > tcp_rtt.skel.h

# 编译用户态程序
gcc -o tcp_rtt_user tcp_rtt_user.c -lbpf -lelf -lz

# 运行（需要 root 权限）
sudo ./tcp_rtt_user

实战三：生产级 CPU 火焰图生成

CPU 火焰图（Flame Graph）是分析 CPU 性能瓶颈最直观的工具。传统方案依赖 perf，但 eBPF 可以在更低开销下实现同样的功能。

eBPF 采样程序

// flame.bpf.c - CPU 火焰图采样
#include 
#include 
#include 
#include 

#define MAX_STACK_DEPTH 50

// 存储堆栈计数
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 4096);
    __type(key, struct stack_trace);  // 用户态 + 内核态堆栈
    __type(value, __u64);
} stack_counts SEC(".maps");

// 临时存储每个 CPU 的堆栈
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(max_entries, 1);
    __type(key, __u32);
    __type(value, struct stack_trace);
} stacktmp SEC(".maps");

struct stack_trace {
    __u64 ip[MAX_STACK_DEPTH];
    __u32 depth;
    __u32 pid;
    __u32 cpu;
    char comm[16];
};

SEC("perf_event")
int do_perf_event(struct bpf_perf_event_data *ctx)
{
    __u32 zero = 0;
    struct stack_trace *trace;
    
    // 获取临时存储
    trace = bpf_map_lookup_elem(&stacktmp, &zero);
    if (!trace)
        return 0;
    
    // 采集内核态堆栈
    trace->depth = bpf_get_stackid(ctx, &stack_counts, 
                                    BPF_F_FAST_STACK_CMP);
    
    // 采集用户态堆栈
    if (trace->depth > 0) {
        bpf_get_stackid(ctx, &stack_counts, 
                        BPF_F_FAST_STACK_CMP | BPF_F_USER_STACK);
    }
    
    // 获取进程信息
    trace->pid = bpf_get_current_pid_tgid() >> 32;
    trace->cpu = bpf_get_smp_processor_id();
    bpf_get_current_comm(&trace->comm, sizeof(trace->comm));
    
    // 更新计数
    __u64 *count = bpf_map_lookup_elem(&stack_counts, trace);
    if (count) {
        *count += 1;
    } else {
        __u64 init = 1;
        bpf_map_update_elem(&stack_counts, trace, &init, BPF_ANY);
    }
    
    return 0;
}

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

使用 BCC 快速生成火焰图

对于快速分析，BCC 提供了更简洁的方式：

#!/usr/bin/env python3
# flame_bcc.py - 使用 BCC 生成 CPU 火焰图
from bcc import BPF
import time
import os

# eBPF 程序
bpf_text = """
#include 
#include 

struct key_t {
    u32 pid;
    u64 kernel_ip;
    u64 user_ip;
    char name[TASK_COMM_LEN];
};

BPF_HASH(counts, struct key_t, u64);
BPF_STACK_TRACE(stack_traces, 1024);

int do_perf_event(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    struct key_t key = {};
    
    key.pid = pid;
    key.kernel_ip = PT_REGS_IP(ctx);
    bpf_get_current_comm(&key.name, sizeof(key.name));
    
    // 获取用户态堆栈
    key.user_ip = bpf_get_stackid(ctx, &stack_traces, BPF_F_USER_STACK);
    
    // 获取内核态堆栈
    key.kernel_ip = bpf_get_stackid(ctx, &stack_traces, 0);
    
    u64 zero = 0;
    u64 *val = counts.lookup_or_try_init(&key, &zero);
    if (val) {
        (*val)++;
    }
    
    return 0;
}
"""

# 加载 BPF 程序
b = BPF(text=bpf_text)
b.attach_perf_event(ev_type=PERF_TYPE_SOFTWARE, 
                   ev_config=PERF_COUNT_SW_CPU_CLOCK,
                   fn_name="do_perf_event",
                   sample_freq=99)  # 99Hz 采样

print("CPU 采样中 (99Hz)... 按 Ctrl+C 停止")

try:
    time.sleep(30)
except KeyboardInterrupt:
    pass

# 输出折叠格式的堆栈（供 flamegraph.pl 使用）
counts = b.get_table("counts")
stack_traces = b.get_table("stack_traces")

output_file = "/tmp/flame_stacks.txt"
with open(output_file, "w") as f:
    for key, val in counts.items():
        stack = []
        
        # 内核态堆栈
        if key.kernel_ip > 0:
            for addr in stack_traces[key.kernel_ip].ip:
                if addr == 0:
                    break
                stack.append("kernel:0x%x" % addr)
        
        # 用户态堆栈
        if key.user_ip > 0:
            for addr in stack_traces[key.user_ip].ip:
                if addr == 0:
                    break
                stack.append("user:0x%x" % addr)
        
        stack.append("%s[%d]" % (key.name.decode(), key.pid))
        
        # 火焰图格式：stack;stack;stack count
        f.write("%s %d\n" % (";".join(reversed(stack)), val.value))

print(f"\n堆栈数据已保存到 {output_file}")
print(f"使用以下命令生成火焰图:")
print(f"  git clone https://github.com/brendangregg/FlameGraph.git")
print(f"  FlameGraph/flamegraph.pl --hash < {output_file} > flame.svg")
print(f"  xdg-open flame.svg")

实战四：容器网络观测——跨 Namespace 流量追踪

在 Kubernetes 容器网络中，一个常见的痛点是：如何在宿主机上观测特定 Pod 的网络流量？eBPF 可以轻松跨越网络命名空间进行追踪。

// container_net.bpf.c - 容器网络流量追踪
#include 
#include 
#include 
#include 
#include 
#include 
#include 

// 流量统计 Map
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 4096);
    __type(key, __u32);    // cgroup ID
    __type(value, struct traffic_stats);
} traffic SEC(".maps");

struct traffic_stats {
    __u64 rx_bytes;
    __u64 tx_bytes;
    __u64 rx_packets;
    __u64 tx_packets;
    __u64 tcp_retransmits;
    __u64 tcp_drops;
};

// 连接追踪 Map
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 8192);
    __type(key, struct flow_key);
    __type(value, struct flow_info);
} flows SEC(".maps");

struct flow_key {
    __u32 src_ip;
    __u32 dst_ip;
    __u16 src_port;
    __u16 dst_port;
    __u8  proto;
    __u32 cgroup_id;
    __u8  pad[3];
};

struct flow_info {
    __u64 bytes;
    __u64 packets;
    __u64 first_seen;
    __u64 last_seen;
    __u32 pid;
    char comm[16];
};

// TC 钩子：追踪入站流量
SEC("tc")
int tc_ingress(struct __sk_buff *skb)
{
    // 解析以太网头
    void *data_end = (void *)(long)skb->data_end;
    void *data = (void *)(long)skb->data;
    
    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return TC_ACT_OK;
    
    // 只处理 IPv4
    if (eth->h_proto != __constant_htons(ETH_P_IP))
        return TC_ACT_OK;
    
    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end)
        return TC_ACT_OK;
    
    // 获取 cgroup ID
    __u32 cgroup_id = bpf_skb_cgroup_id(skb);
    
    // 更新流量统计
    struct traffic_stats *stats = bpf_map_lookup_elem(&traffic, &cgroup_id);
    if (stats) {
        __sync_fetch_and_add(&stats->rx_bytes, skb->len);
        __sync_fetch_and_add(&stats->rx_packets, 1);
    } else {
        struct traffic_stats new_stats = {
            .rx_bytes = skb->len,
            .rx_packets = 1,
        };
        bpf_map_update_elem(&traffic, &cgroup_id, &new_stats, BPF_ANY);
    }
    
    // 记录 TCP 流
    if (ip->protocol == IPPROTO_TCP) {
        struct tcphdr *tcp = (void *)ip + (ip->ihl * 4);
        if ((void *)(tcp + 1) > data_end)
            return TC_ACT_OK;
        
        struct flow_key key = {
            .src_ip = ip->saddr,
            .dst_ip = ip->daddr,
            .src_port = tcp->source,
            .dst_port = tcp->dest,
            .proto = IPPROTO_TCP,
            .cgroup_id = cgroup_id,
        };
        
        __u64 now = bpf_ktime_get_ns();
        struct flow_info *info = bpf_map_lookup_elem(&flows, &key);
        if (info) {
            info->bytes += skb->len;
            info->packets++;
            info->last_seen = now;
        } else {
            struct flow_info new_flow = {
                .bytes = skb->len,
                .packets = 1,
                .first_seen = now,
                .last_seen = now,
                .pid = bpf_get_current_pid_tgid() >> 32,
            };
            bpf_get_current_comm(&new_flow.comm, sizeof(new_flow.comm));
            bpf_map_update_elem(&flows, &key, &new_flow, BPF_ANY);
        }
        
        // 检测 TCP 重传（RST 标志）
        if (tcp->rst) {
            if (stats) {
                __sync_fetch_and_add(&stats->tcp_drops, 1);
            }
        }
    }
    
    return TC_ACT_OK;
}

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

用户态分析工具

#!/usr/bin/env python3
# container_net_user.py - 容器网络流量分析
import json
import time
import subprocess
from bcc import BPF

bpf_text = r"""
// ... (上面的 eBPF 程序文本)
"""

b = BPF(text=bpf_text)
fn = b.load_func("tc_ingress", BPF.SCHED_CLS)

# 附加到宿主机所有 veth 接口
import pyroute2
ip = pyroute2.IPRoute()
for link in ip.get_links():
    ifname = link.get_attr('IFLA_IFNAME')
    if ifname.startswith('veth') or ifname.startswith('cali'):
        print(f"Attaching to {ifname}...")
        ip.tc("add", "clsact", ifname)
        ip.tc("add-filter", "bpf", ifname, ":1", fd=fn.fd, 
              name=fn.name, parent="ffff:fff2", classid=1, direct_action=True)

print("\n=== 容器网络流量监控 ===\n")

try:
    while True:
        time.sleep(5)
        
        traffic = b.get_table("traffic")
        flows = b.get_table("flows")
        
        print(f"\n{'='*60}")
        print(f"时间: {time.strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"{'='*60}")
        
        # 打印流量统计
        print(f"\n{'CGroup ID':<15} {'RX Bytes':<15} {'TX Bytes':<15} {'RX Pkts':<12} {'TX Pkts':<12}")
        print("-" * 70)
        
        for key, val in sorted(traffic.items(), 
                                key=lambda x: x[1].rx_bytes + x[1].tx_bytes,
                                reverse=True)[:10]:
            print(f"{key.value:<15} {val.rx_bytes:<15} {val.tx_bytes:<15} "
                  f"{val.rx_packets:<12} {val.tx_packets:<12}")
        
        # 打印 Top 10 流量流
        print(f"\n{'源地址':<22} {'目标地址':<22} {'Bytes':<12} {'Packets':<10} {'进程'}")
        print("-" * 80)
        
        for key, val in sorted(flows.items(),
                                key=lambda x: x[1].bytes,
                                reverse=True)[:10]:
            src = f"{_ntoh(key.src_ip)}:{key.src_port}"
            dst = f"{_ntoh(key.dst_ip)}:{key.dst_port}"
            print(f"{src:<22} {dst:<22} {val.bytes:<12} {val.packets:<10} {val.comm.decode()}")

except KeyboardInterrupt:
    print("\n停止监控...")

def _ntoh(ip_int):
    import socket
    return socket.inet_ntoa(ip_int.to_bytes(4, 'little'))

实战五：BCC 工具集深度应用

BCC（BPF Compiler Collection）提供了大量开箱即用的 eBPF 工具，是系统性能分析的瑞士军刀。

1. 常用 BCC 工具速查

2. 自定义 BCC 工具：数据库查询延迟追踪

假设我们需要追踪 MySQL 的网络请求延迟，可以通过 uprobe 挂载到 MySQL 的网络读写函数：

#!/usr/bin/env python3
# mysql_latency.py - 追踪 MySQL 查询网络延迟
from bcc import BPF
import ctypes as ct

bpf_text = """
#include 

struct event_t {
    u64 ts;
    u32 pid;
    u32 tid;
    u64 duration_ns;
    int size;
    char query[64];
};

BPF_HASH(start, u64, u64);  // tid -> timestamp
BPF_PERF_OUTPUT(events);

// 追踪 MySQL 的 net_read_query (读取客户端查询)
int trace_mysql_read(struct pt_regs *ctx) {
    u64 pid_tid = bpf_get_current_pid_tgid();
    u64 ts = bpf_ktime_get_ns();
    start.update(&pid_tid, &ts);
    return 0;
}

// 追踪 MySQL 的 net_write_query (写入查询结果)
int trace_mysql_write(struct pt_regs *ctx) {
    u64 pid_tid = bpf_get_current_pid_tgid();
    u64 *tsp = start.lookup(&pid_tid);
    
    if (tsp == 0)
        return 0;
    
    u64 duration = bpf_ktime_get_ns() - *tsp;
    start.delete(&pid_tid);
    
    struct event_t event = {};
    event.ts = bpf_ktime_get_ns();
    event.pid = pid_tid >> 32;
    event.tid = pid_tid;
    event.duration_ns = duration;
    
    events.perf_submit(ctx, &event, sizeof(event));
    return 0;
}
"""

b = BPF(text=bpf_text)

# 附加到 MySQL 进程的 uprobe
import subprocess
result = subprocess.run(["pgrep", "-x", "mysqld"], capture_output=True, text=True)
if result.returncode != 0:
    print("未找到 mysqld 进程，请确保 MySQL 正在运行")
    exit(1)

mysql_pid = int(result.stdout.strip())
print(f"追踪 MySQL PID: {mysql_pid}")

# 需要找到 mysqld 的实际路径
import glob
mysql_bins = glob.glob("/usr/sbin/mysqld*") + glob.glob("/usr/bin/mysqld*")
if not mysql_bins:
    mysql_bins = glob.glob("/usr/local/mysql/bin/mysqld*")

if mysql_bins:
    mysql_bin = mysql_bins[0]
    b.attach_uprobe(name=mysql_bin, sym="net_read_query", 
                    fn_name="trace_mysql_read", pid=mysql_pid)
    b.attach_uretprobe(name=mysql_bin, sym="net_write_query",
                      fn_name="trace_mysql_write", pid=mysql_pid)
    print(f"已附加到 {mysql_bin}")
else:
    print("未找到 mysqld 二进制文件")
    exit(1)

# 统计延迟分布
latencies = []

def print_event(cpu, data, size):
    event = b["events"].event(data)
    duration_us = event.duration_ns / 1000
    latencies.append(duration_us)
    
    if duration_us > 1000:  # 只打印超过 1ms 的慢查询
        print(f"[慢查询] PID={event.pid} TID={event.tid} "
              f"延迟={duration_us:.0f}μs ({duration_us/1000:.1f}ms)")

b["events"].open_perf_buffer(print_event)

print("\n=== MySQL 查询延迟追踪 ===")
print("按 Ctrl+C 停止并显示统计\n")

try:
    while True:
        b.perf_buffer_poll()
except KeyboardInterrupt:
    pass

# 输出统计
if latencies:
    latencies.sort()
    n = len(latencies)
    print(f"\n{'='*50}")
    print(f"查询总数: {n}")
    print(f"P50: {latencies[n//2]:.0f}μs")
    print(f"P90: {latencies[int(n*0.9)]:.0f}μs")
    print(f"P95: {latencies[int(n*0.95)]:.0f}μs")
    print(f"P99: {latencies[int(n*0.99)]:.0f}μs")
    print(f"Max: {latencies[-1]:.0f}μs")
    print(f"{'='*50}")

eBPF 生态全景：Cilium、Falco、Tetragon

eBPF 不仅仅是一个内核技术，它已经催生了整个云原生生态：

生产部署关键考量

将 eBPF 程序从实验环境推向生产，需要注意以下关键点：

1. 内核版本要求

2. 资源限制与安全

# 检查 eBPF 资源限制
$ sudo sysctl -a | grep bpf
kernel.unprivileged_bpf_disabled = 0    # 非特权用户是否可用 BPF
net.core.bpf_jit_enable = 1             # JIT 编译器是否启用
net.core.bpf_jit_harden = 1             # JIT 安全加固
net.core.bpf_jit_kallsyms = 1           # JIT 内核符号导出

# 查看当前加载的 eBPF 程序
$ sudo bpftool prog show
1: tracepoint  name trace_tcp_reta  tag abc123...
2: kprobe      name tcp_rcv_estab  tag def456...

# 查看 eBPF Map 使用情况
$ sudo bpftool map show
1: hash  name rtt_histogram  entries=1024  key=4B  value=8B
2: hash  name rtt_values     entries=4096  key=8B  value=8B

# 限制 eBPF 内存使用（通过 cgroup）
$ sudo sysctl -w kernel.bpf_stats_enabled=1  # 启用 BPF 统计

3. 性能开销控制

• 采样频率：生产环境建议 10-99Hz，避免 1000Hz 高频采样
• Map 大小：合理设置 max_entries，避免内存占用过大
• 程序复杂度：eBPF Verifier 有 100 万指令限制，复杂逻辑需拆分
• 批量处理：使用 BPF_PERF_OUTPUT 批量传输数据，减少系统调用
• 过滤前置：在 eBPF 程序中尽早过滤无关事件，减少不必要的处理

4. 故障排查清单

# 1. 程序加载失败 → 检查 Verifier 日志
$ sudo bpftool prog load /path/to/prog.o /sys/fs/bpf/test
$ sudo dmesg | tail -20  # 查看 Verifier 拒绝原因

# 2. 程序不触发 → 检查挂载点
$ sudo bpftool prog show  # 确认程序已加载
$ sudo bpftool net show   # 确认网络钩子已附加

# 3. Map 数据为空 → 检查数据路径
$ sudo bpftool map dump id   # 查看 Map 内容

# 4. 性能问题 → 检查 JIT 状态
$ sudo bpftool prog list  # 查看 JIT 编译状态
$ sudo cat /proc/sys/net/core/bpf_jit_enable  # 确认 JIT 启用

# 5. 内存泄漏 → 检查 Map 清理
$ sudo bpftool map show  # 查看 Map 条目数是否持续增长

总结与展望

eBPF 正在重新定义 Linux 内核可观测性的边界。从系统调用追踪到网络延迟分析，从 CPU 火焰图到容器网络观测，eBPF 以零侵入、高性能、高安全性的方式解决了传统方案无法触及的深层观测需求。