第25周：eBPF 基础与工具链

字数统计: 2.7k字   |   阅读时长≈ 13分

第25周：eBPF 基础与工具链

目标：理解 eBPF 虚拟机的指令集、验证器机制和工具链，能够使用 bpftrace 和 bcc 编写简单内核跟踪程序。

1. eBPF 概述

1.1 什么是 eBPF？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
eBPF（extended Berkeley Packet Filter）：

  - Linux 内核中的安全沙箱虚拟机
  - 用户编写的程序经过验证后在内核态运行
  - 最初为包过滤设计（BPF/cBPF）
  - 现在是通用的内核可编程框架

  应用场景：
  ┌──────────────────────────────────┐
  │  网络    XDP, TC, socket filter │
  │  跟踪    kprobe, uprobe, tracepoint │
  │  安全    seccomp, landlock │
  │  性能    profiling, observability │
  │  调度    struct_ops │
  └──────────────────────────────────┘

1.2 eBPF 程序生命周期

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
┌─────────────┐    ┌──────────┐    ┌─────────────┐
│  C 源码     │ ──▶│ Clang    │ ──▶│  BPF 字节码 │
│ (bpf.c)     │    │ (LLVM)   │    │ (bpf.o)     │
└─────────────┘    └──────────┘    └──────┬──────┘
                                           │
                                           ▼
                                  ┌─────────────┐
                                  │  Verifier   │ 验证安全性
                                  │  (内核)     │
                                  └──────┬──────┘
                                         │
                                  ┌──────▼──────┐
                                  │  JIT 编译   │ 机器码
                                  │  → 加载     │
                                  └──────┬──────┘
                                         │
                                  ┌──────▼──────┐
                                  │  挂载到     │
                                  │  Hook 点    │  触发执行
                                  └─────────────┘

1.3 与传统内核模块对比

特性 内核模块 eBPF
加载方式 insmod bpf() 系统调用
验证 人工 自动验证器
安全性 风险高 沙箱安全
调试难度 难（需要重启） 容易（热加载）
与内核耦合 紧 松（通过 helper）
编程语言 C C + libbpf / bpftrace
性能 高 高（JIT 后接近原生）

2. eBPF 指令集

2.1 寄存器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
eBPF 虚拟机寄存器（共 11 个）：

  R0  - 返回值
  R1  - 第一个参数（也是上下文）
  R2  - 第二个参数
  ...
  R10 - 只读，栈帧指针
  R11 - 保留（用于内核函数调用）

调用约定：
  - R1 寄存器：传入上下文（ctx）
  - R0：返回值
  - R1-R5：函数参数
  - R6-R9：被调用者保存（callee-saved）

栈：
  512 字节（每个 BPF 程序）
  R10 = 栈顶
  R10 - offset 寻址

2.2 指令格式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
eBPF 指令 = 8 bytes

  ┌──────────┬──────────┬────────────┬────────────────┐
  │ opcode   │ dst_reg  │ src_reg    │ offset / imm   │
  │ (8 bit)  │ (4 bit)  │ (4 bit)    │ (16 bit / 32)  │
  └──────────┴──────────┴────────────┴────────────────┘

指令类别：
  - BPF_LD  : 加载
  - BPF_LDX : 加载（从内存）
  - BPF_ST  : 存储（立即数）
  - BPF_STX : 存储（从寄存器）
  - BPF_ALU : 算术运算
  - BPF_JMP : 跳转
  - BPF_JMP32: 32 位跳转
  - BPF_CALL: helper 调用
  - BPF_EXIT: 程序退出

  编码大小端：eBPF 都是小端

2.3 示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 反汇编示例（来自 bpftool）

// C 代码：
SEC("kprobe/tcp_connect")
int bpf_prog(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    bpf_printk("tcp_connect called from pid=%d\\n", pid);
    return 0;
}

// 编译为 BPF 字节码后：
//  0: r6 = r1                       // 上下文
//  1: r1 = *(u32 *)(r6 + 16)        // pt_regs->di (第一个参数)
//  2: r1 >>= 32                      // 提取高 32 位
//  3: *(u64 *)(r10 - 8) = r1         // 保存到栈
//  4: r1 = 0
//  5: r2 = 0x6c6c6566               // "fell"
//  6: r3 = 0x206369                 // "ic "
//  7: call bpf_trace_printk#
//  8: r0 = 0
//  9: exit

3. 验证器（Verifier）

3.1 验证器职责

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
验证器检查 BPF 程序：

1. 内存访问安全
   - 所有内存访问必须预先验证边界
   - 禁止越界访问
   - 禁止空指针解引用

2. 控制流
   - 不能有死循环
   - 最多 100 万条指令（限制复杂度）
   - 路径必须能在合理时间内终止

3. 栈使用
   - 最多 512 字节栈
   - 必须保证非负偏移

4. 寄存器状态
   - 每个寄存器维护类型 + 范围
   - 数字范围：必须是有限范围（避免有符号整数陷阱）

5. 调用约束
   - 只能调用授权的 helper 函数
   - 参数类型必须匹配

6. 程序大小
   - 单个程序最大 100 万条指令（现代限制）

3.2 验证器示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// ❌ 不通过：未知循环次数
SEC("kprobe/do_thing")
int bad(struct pt_regs *ctx) {
    for (int i = 0; i < n; i++) {  // n 未知 → 拒绝
        // ...
    }
    return 0;
}

// ✅ 通过：固定循环次数
SEC("kprobe/do_thing")
int good(struct pt_regs *ctx) {
    for (int i = 0; i < 10; i++) {  // 编译期已知
        // ...
    }
    return 0;
}

// ❌ 不通过：未检查指针
char *p = (char *)ctx;
char c = p[100];  // 没检查长度 → 拒绝

// ✅ 通过：先检查
if (ctx_len > 100) {
    char c = p[100];  // 安全
}

4. 开发环境

4.1 安装依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Ubuntu/Debian
sudo apt install -y \
    bpfcc-tools \
    linux-headers-$(uname -r) \
    libbpf-dev \
    llvm \
    clang \
    gcc-multilib \
    linux-tools-common \
    linux-tools-generic

# 验证
clang --version
# Ubuntu clang version 14.0.0
bpftool --version
# bpftool v5.15+

4.2 关键工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# bpftool — 内核 BPF 管理工具
bpftool prog list          # 列出所有加载的 BPF 程序
bpftool map list           # 列出所有 BPF map
bpftool prog show id 42    # 显示特定程序详情
bpftool prog dump xlated id 42  # 反汇编
bpftool prog dump jited id 42   # JIT 后机器码

# bpftrace — 单行 BPF 脚本
bpftrace -e 'kprobe:tcp_connect { print("hello"); }'
bpftrace -l 'kprobe:tcp_*'      # 列出可用探针

# bcc — BPF 编译器集合（Python/Lua 包装）
ls /usr/share/bcc/tools        # 大量预制工具

# libbpf — 标准 C 库
pkg-config --cflags --libs libbpf

5. bcc-tools 使用

5.1 常用 bcc 工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# === 进程跟踪 ===

# 跟踪进程执行
execsnoop                  # 显示所有新进程
execsnoop -t               # 带时间戳
execsnoop -e               # 显示参数

# 跟踪文件 I/O
filesnoop                  # 打开的文件
biolatency                 # 块设备 I/O 延迟

# === 网络跟踪 ===

# TCP 连接
tcpconnect                 # 跟踪 TCP 连接
tcpaccept                  # 跟踪 accept
tcpsynbl                   # SYN backlog 状态
tcptop                     # TCP 流量 top
tcpdrop                    # TCP 丢包

# UDP
udpconnect                 # UDP 连接
udpbind                    # UDP bind

# 网络栈
netqtop                    # 队列统计
netqlen                    # 队列长度
nettop                     # 网络 top
softirqs                   # 软中断

# 示例
sudo tcpconnect            # 实时显示 TCP 连接
sudo tcptop                # 实时显示 TCP 流量

5.2 trace-bpf

1
2
3
4
5
6
7
# trace-bpf.py — 通用 tracepoint 跟踪
sudo trace-bpf 'sys_enter_*'                    # 所有系统调用
sudo trace-bpf 'sys_enter_open*'                # open 系列
sudo trace-bpf 'tcp:*,skb:consume_skb'         # 多个 tracepoint

# 详细输出
sudo trace-bpf -h

6. 编写 kprobe 程序

6.1 BCC Python 风格

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#!/usr/bin/env python3
# tcp_connect.py — 监控 TCP 连接

from bcc import BPF

prog = r"""
#include <net/sock.h>

BPF_HASH(start, u32, u64);  // 用于存储开始时间

BPF_HISTOGRAM(dist);

int kprobe__tcp_connect(struct pt_regs *ctx, struct sock *sk) {
    u32 pid = bpf_get_current_pid_tgid() >> 32;

    // 记录开始时间
    u64 ts = bpf_ktime_get_ns();
    start.update(&pid, &ts);

    return 0;
}

int kretprobe__tcp_connect(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    u64 *tsp, delta;

    tsp = start.lookup(&pid);
    if (tsp == 0) return 0;

    delta = bpf_ktime_get_ns() - *tsp;

    // 记录到直方图
    dist.increment(bpf_log2l(delta / 1000));  // 转换为微秒

    start.delete(&pid);
    return 0;
}
"""

# 加载 BPF 程序
b = BPF(text=prog)
b.attach_kprobe(event="tcp_connect", fn_name="kprobe__tcp_connect")
b.attach_kretprobe(event="tcp_connect", fn_name="kretprobe__tcp_connect")

# 等待连接
print("Tracing TCP connects... Ctrl-C to exit")
try:
    b.perf_buffer_poll()  # 实际更多用 print_hist 等
except KeyboardInterrupt:
    print()
    b["dist"].print_log2_hist("usec")

6.2 libbpf C 风格

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
// tcp_connect.bpf.c — libbpf 风格
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>

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

// BPF map
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");

struct event {
    u32 pid;
    u64 latency_ns;
    char comm[16];
};

// kprobe: tcp_connect
SEC("kprobe/tcp_connect")
int kprobe_tcp_connect(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    u64 ts = bpf_ktime_get_ns();

    bpf_map_update_elem(&start, &pid, &ts, BPF_ANY);
    return 0;
}

// kretprobe: tcp_connect
SEC("kretprobe/tcp_connect")
int kretprobe_tcp_connect(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    u64 *tsp = bpf_map_lookup_elem(&start, &pid);
    if (!tsp) return 0;

    u64 delta = bpf_ktime_get_ns() - *tsp;

    // 发送事件到用户态
    struct event e = {
        .pid = pid,
        .latency_ns = delta,
    };
    bpf_get_current_comm(e.comm, sizeof(e.comm));

    bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU,
                          &e, sizeof(e));

    bpf_map_delete_elem(&start, &pid);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
# 编译
clang -target bpf \
    -D__TARGET_ARCH_x86 \
    -I/usr/include/x86_64-linux-gnu \
    -O2 -g \
    -c tcp_connect.bpf.c \
    -o tcp_connect.bpf.o

# 生成 skeleton
bpftool gen skeleton tcp_connect.bpf.o > tcp_connect.skel.h

# 编译用户态加载器
gcc -o tcp_connect tcp_connect.c -lbpf -lelf -lz

7. bpftrace 实战

7.1 基础语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 一行命令
bpftrace -e 'kprobe:tcp_connect { @[comm] = count(); }'

# 多行
bpftrace -e '
kprobe:tcp_connect {
    @[comm] = count();
}

kretprobe:tcp_connect /retval < 0/ {
    @errors[comm] = count();
}
'

# 优雅退出（Ctrl-C）时打印
bpftrace -e '
tracepoint:raw_syscalls:sys_enter {
    @[comm] = count();
}
END {
    print(@);
}
'

7.2 网络事件跟踪示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
# === 跟踪网络事件 ===

# 跟踪所有 TCP 连接
bpftrace -e '
kprobe:tcp_connect {
    $sk = (struct sock *)arg0;
    printf("TCP connect from %d (%s) to %pI4:%d\n",
           pid, comm, $sk->__sk_common.skc_daddr,
           $sk->__sk_common.skc_dport);
}
'

# 跟踪 TCP 重传
bpftrace -e '
tracepoint:tcp:tcp_retransmit_skb {
    printf("Retransmit: %pI4:%d -> %pI4:%d\n",
           args->saddr, args->sport,
           args->daddr, args->dport);
}
'

# 跟踪丢包
bpftrace -e '
kprobe:dev_kfree_skb_any_reason {
    printf("Drop skb: reason=%d\n", arg1);
}
'

# 跟踪新连接速率
bpftrace -e '
kprobe:tcp_v4_syn_recv_sock {
    @syn_rate[comm] = count();
    @start[arg0] = nsecs;
}

interval:s:5 {
    time("5 sec report:");
    print(@syn_rate);
    clear(@syn_rate);
}
'

# 跟踪连接延迟
bpftrace -e '
kprobe:tcp_connect {
    @start[tid] = nsecs;
}

kretprobe:tcp_connect /@start[tid]/ {
    @latency_us = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}
'

# 跟踪 SYN backlog
bpftrace -e '
kprobe:tcp_conn_request {
    @backlog[comm] = count();
}
interval:s:1 { print(@backlog); clear(@backlog); }
'

7.3 跟踪进程资源

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 进程打开的文件
bpftrace -e '
tracepoint:syscalls:sys_enter_openat {
    printf("%s(%d) openat: %s\\n", comm, pid, str(args->filename));
}
'

# 网络字节统计（按进程）
bpftrace -e '
kprobe:dev_queue_xmit {
    $skb = (struct sk_buff *)arg0;
    @tx_bytes[comm] = sum($skb->len);
}
END {
    print(@tx_bytes);
}
'

8. 关键 BPF helper 函数

8.1 常用 helper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// 时间
u64 bpf_ktime_get_ns(void);             // 纳秒时间戳
u64 bpf_ktime_get_boot_ns(void);       // boot 相对时间

// PID
u32 bpf_get_current_pid_tgid(void);    // 32 位 PID + 32 位 TGID
u64 bpf_get_current_cgroup_id(void);   // cgroup id

// 进程信息
bpf_get_current_comm(char *buf, u32 size);  // 进程名

// Map 操作
void *bpf_map_lookup_elem(void *map, const void *key);
int bpf_map_update_elem(void *map, const void *key,
                        const void *value, u64 flags);
int bpf_map_delete_elem(void *map, const void *key);

// 调试
long bpf_trace_printk(const char *fmt, u32 fmt_size, ...);
                          // 写入 trace_pipe（最多 3 个参数）

// 性能事件
long bpf_perf_event_output(void *ctx, void *map, u64 flags,
                            void *data, u64 size);

// Ring buffer（推荐）
long bpf_ringbuf_output(void *ringbuf, const void *data, u64 size,
                          u64 flags);

// Tail call
void bpf_tail_call(void *ctx, void *prog_array, u32 index);

// 重定向
long bpf_redirect(u32 ifindex, u64 flags);
long bpf_redirect_map(void *map, u32 key, u64 flags);

// 时间处理
u64 bpf_jiffies64(void);

// 随机数
u32 bpf_get_prandom_u32(void);

// 字符串处理
long bpf_probe_read(void *dst, u32 size, const void *src);
long bpf_probe_read_str(char *dst, u32 size, const void *src);

8.2 BPF map 类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// === Hash map ===
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 1024);
    __type(key, u32);
    __type(value, struct data);
} my_hash SEC(".maps");

// === Array map ===
struct {
    __uint(type, BPF_MAP_TYPE_ARRAY);
    __uint(max_entries, 1);
    __type(key, u32);
    __type(value, u64);
} my_array SEC(".maps");

// === Per-CPU Array ===
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(max_entries, 256);
    __type(key, u32);
    __type(value, u64);
} percpu SEC(".maps");

// === LRU Hash（自动淘汰）===
struct {
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
    __uint(max_entries, 1024);
    __type(key, u32);
    __type(value, struct entry);
} lru SEC(".maps");

// === RingBuf（推荐用于数据传递）===
struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024);
} ringbuf SEC(".maps");

// === 其他类型 ===
BPF_MAP_TYPE_LPM_TRIE     // 最长前缀匹配（路由）
BPF_MAP_TYPE_ARRAY_OF_MAPS // map 数组
BPF_MAP_TYPE_HASH_OF_MAPS // hash of maps
BPF_MAP_TYPE_DEVMAP       // XDP 转发目标
BPF_MAP_TYPE_CPUMAP       // XDP CPU 重定向
BPF_MAP_TYPE_PROG_ARRAY   // tail call
BPF_MAP_TYPE_STACK_TRACE  // 栈跟踪

9. 编译工作流

9.1 libbpf 完整流程

1
2
3
4
5
6
7
8
9
10
11
源文件结构：
  ├── my_prog.bpf.c       # BPF 程序
  ├── my_prog.c           # 用户态加载器
  ├── my_prog.skel.h      # 自动生成的 skeleton
  ├── vmlinux.h           # 内核类型定义（生成）
  └── Makefile

编译流程：
  1. clang → .bpf.o（BPF 字节码）
  2. bpftool gen skeleton → .skel.h（加载 API）
  3. gcc → my_prog（可执行文件）

9.2 Makefile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 简化版 Makefile
CLANG = clang
BPFTOOL = bpftool
CFLAGS = -O2 -g -Wall
BPF_CFLAGS = -target bpf -D__TARGET_ARCH_x86 -O2 -g

.PHONY: all clean
all: my_prog

my_prog.bpf.o: my_prog.bpf.c vmlinux.h
	$(CLANG) $(BPF_CFLAGS) -c $< -o $@

my_prog.skel.h: my_prog.bpf.o
	$(BPFTOOL) gen skeleton $< > $@

my_prog: my_prog.c my_prog.skel.h
	gcc $(CFLAGS) $< -o $@ -lbpf -lelf -lz

clean:
	rm -f *.o my_prog my_prog.skel.h

10. 学习路径建议

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
第 1 步：使用 bpftrace 一行命令
  - 跟踪 tcp_connect
  - 统计进程网络流量
  - 观察系统调用

第 2 步：使用 bcc 预制工具
  - tcpconnect, tcptop, execsnoop
  - 了解常用工具的输出

第 3 步：编写简单的 kprobe
  - Python 风格（BCC）
  - C 风格（libbpf）

第 4 步：学习 BPF maps
  - HASH、ARRAY、PERCPU
  - 用户态读写

第 5 步：进入网络方向
  - XDP（驱动级）
  - TC（流量控制）
  - socket filter
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870