1
+--------+--------+--------+--------+--------+--------+--------+--------+
2
|  op    | dst:4  | src:4  |        off (16 bit)       |       imm (32 bit)       |
3
| (8bit) | reg    | reg    |                           |                          |
4
+--------+--------+--------+---------------------------+--------------------------+

1
op = class(3) | source(1) | opcode(4)

1
// eBPF 程序的寄存器使用示例
2
SEC("kprobe/do_sys_open")
3
int trace_open(struct pt_regs *ctx)
4
{
5
    // r1 = ctx（第一个参数，由内核传入）
6
    // r10 = 栈帧指针（只读）
7

8
    u32 pid;            // 可能使用 r6-r9 保存
9
    struct event *e;
10

11
    pid = bpf_get_current_pid_tgid() >> 32;  // r0 = 返回值
12

13
    // 调用 Helper 函数时：
14
    // r1 = 第1个参数（Map 指针）
15
    // r2 = 第2个参数（key 指针）
16
    // r3 = 第3个参数（value 指针）
17
    // r4 = 第4个参数（flags）
18
    // r1-r5 在调用后被破坏
19
    // r6-r9 在调用后保留
20

21
    e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
22
    // r0 = 返回值（e 指针）
23

24
    return 0;  // r0 = 返回值
25
}

1
// ALU 指令示例（eBPF C 代码 → 字节码）
2
// r1 = 10
3
// r1 += 20
4
// r1 *= 2
5
// r1 >>= 2
6
// 等价于 C: u64 r1 = (10 + 20) * 2 >> 2 = 15

1
// JMP 指令示例
2
if (pid == 1) {         // BPF_JEQ: if r1 == 1 goto +2
3
    action = "init";    // BPF_MOV: r0 = "init"
4
} else {                // BPF_JA: goto +1
5
    action = "other";   // BPF_MOV: r0 = "other"
6
}

1
// 内存访问示例：从上下文读取数据
2
SEC("kprobe/do_sys_open")
3
int trace_open(struct pt_regs *ctx)
4
{
5
    // 从 ctx 读取参数（内存加载）
6
    // 等价于: r1 = *(u64 *)(ctx + 8)
7
    // 即读取 pt_regs->di（第一个参数）
8

9
    // 栈上存储临时变量
10
    u32 key = 1;  // *(u32 *)(r10 - 4) = 1
11

12
    // Map 操作
13
    u64 *val = bpf_map_lookup_elem(&my_map, &key);
14
    // 返回值在 r0 中
15
}

1
// Helper 调用示例
2
// bpf_map_lookup_elem(&my_map, &key)
3
// 编译为：
4
// r1 = &my_map    (Map fd)
5
// r2 = &key       (key 指针)
6
// BPF_CALL bpf_map_lookup_elem  (imm = 1)
7
// r0 = 返回值（value 指针或 NULL）

1
SEC("kprobe/do_sys_open")
2
int trace_open(struct pt_regs *ctx)
3
{
4
    // 栈上变量（通过 r10 + offset 访问）
5
    struct event e;      // 占用栈空间 sizeof(struct event)
6
    u32 pid;             // 占用栈空间 4 字节
7
    char comm[16];       // 占用栈空间 16 字节
8

9
    // 验证器会跟踪栈空间使用
10
    // 如果总使用超过 512 字节，加载会被拒绝
11

12
    pid = bpf_get_current_pid_tgid() >> 32;
13
    bpf_get_current_comm(&comm, sizeof(comm));
14

15
    e.pid = pid;
16
    __builtin_memcpy(&e.comm, comm, sizeof(comm));
17

18
    bpf_ringbuf_output(&events, &e, sizeof(e), 0);
19

20
    return 0;
21
}

1
# 查看 JIT 编译后的机器码
2
sudo bpftool prog dump jited id 123
3

4
# 输出示例（x86_64）：
5
# 0: push   rbp
6
# 1: mov    rbp, rsp
7
# 4: sub    rsp, 0x200
8
# b: mov    rdi, r1          # ctx → r1
9
# e: mov    eax, 0x0
10
# 13: call   0xffffffffe0a0  # bpf_get_current_pid_tgid
11
# 18: shr    rax, 0x20       # pid = tgid >> 32

1
// 尾调用跳转表
2
struct {
3
    __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
4
    __uint(max_entries, 8);
5
    __type(key, __u32);
6
    __type(value, __u32);
7
} prog_array SEC(".maps");
8

9
// 主程序
10
SEC("xdp")
11
int xdp_main(struct xdp_md *ctx)
12
{
13
    // 根据协议类型跳转到不同处理程序
14
    if (is_tcp(ctx))
15
        bpf_tail_call(ctx, &prog_array, 0);  // 跳转到 TCP 处理
16
    else if (is_udp(ctx))
17
        bpf_tail_call(ctx, &prog_array, 1);  // 跳转到 UDP 处理
18

19
    // 如果尾调用失败，继续执行默认处理
20
    return XDP_PASS;
21
}
22

23
// TCP 处理程序
24
SEC("xdp")
25
int xdp_tcp(struct xdp_md *ctx)
26
{
27
    // TCP 专用处理逻辑
28
    return XDP_PASS;
29
}

1
#!/usr/bin/env python3
2
"""手写 eBPF 字节码：统计 execve 调用次数"""
3

4
import ctypes
5
import os
6

7
# eBPF 指令编码
8
class BpfInsn(ctypes.LittleEndianStructure):
9
    _fields_ = [
10
        ("code",  ctypes.c_uint8),
11
        ("dst",   ctypes.c_uint8, 4),
12
        ("src",   ctypes.c_uint8, 4),
13
        ("off",   ctypes.c_int16),
14
        ("imm",   ctypes.c_int32),
15
    ]
16

17
# 指令构造辅助
18
def alu64(op, dst, src=0, imm=0, off=0):
19
    return BpfInsn(op | 0x07 | (0x08 if src else 0), dst, src, off, imm)
20

21
def mov64(dst, imm):
22
    return alu64(0xb0, dst, imm=imm)  # BPF_MOV | BPF_ALU64 | BPF_K
23

24
def exit_insn():
25
    return BpfInsn(0x95, 0, 0, 0, 0)  # BPF_EXIT
26

27
def call_insn(helper_id):
28
    return BpfInsn(0x85, 0, 0, 0, helper_id)  # BPF_CALL
29

30
# 构造简单程序：r0 = 42; return r0
31
prog = [
32
    mov64(0, 42),   # r0 = 42
33
    exit_insn(),     # return r0
34
]
35

36
# 编译为字节码
37
buf = b''
38
for insn in prog:
39
    buf += bytes(insn)

1
# 从 .o 文件反汇编 eBPF 字节码
2
llvm-objdump -S -no-show-raw-insn hello.bpf.o
3

4
# 输出示例：
5
# hello.bpf.o:    file format elf64-bpf
6
#
7
# Disassembly of section tracepoint/syscalls/sys_enter_execve:
8
# hello_execve:
9
#        0: r1 = *(u32 *)(r1 + 24)
10
#        1: r6 = r1
11
#        2: r1 = 0 ll
12
#        4: r1 = map_lookup_elem(r1, &r6)
13
#        5: if r1 == 0 goto +3
14
#        6: r0 = *(u64 *)(r1 + 0)
15
#        7: r0 += 1
16
#        8: *(u64 *)(r1 + 0) = r0
17
#        9: r0 = 0
18
#       10: exit

1
# 编译一个简单的 eBPF 程序
2
cat > simple.bpf.c << 'EOF'
3
#include <linux/bpf.h>
4
#include <bpf/bpf_helpers.h>
5

6
SEC("xdp")
7
int simple_xdp(struct xdp_md *ctx)
8
{
9
    void *data = (void *)(long)ctx->data;
10
    void *data_end = (void *)(long)ctx->data_end;
11

12
    if (data + 14 > data_end)  // 以太网头最小 14 字节
13
        return XDP_PASS;
14

15
    return XDP_PASS;
16
}
17

18
char LICENSE[] SEC("license") = "GPL";
19
EOF
20

21
clang -O2 -target bpf -c simple.bpf.c -o simple.bpf.o
22

23
# 查看字节码
24
llvm-objdump -S simple.bpf.o

1
# 加载程序
2
sudo bpftool prog load simple.bpf.o /sys/fs/bpf/simple type xdp
3

4
# 查看程序 ID
5
sudo bpftool prog list | grep xdp
6

7
# 查看 xlated 字节码（JIT 前）
8
sudo bpftool prog dump xlated id <ID>
9

10
# 查看 jited 机器码（JIT 后）
11
sudo bpftool prog dump jited id <ID>

1
# 追踪 eBPF 程序的 Helper 调用
2
sudo bpftrace -e 'kprobe:bpf_helper_* { printf("helper: %s\n", func); }'
3

4
# 追踪 JIT 编译事件
5
sudo bpftrace -e 'kprobe:bpf_int_jit_compile { printf("JIT compile: prog=%p\n", arg0); }'