1
// 内核 5.10 中的 task_struct（简化）
2
struct task_struct {
3
    unsigned int __state;          // offset 0
4
    void *stack;                   // offset 8
5
    int prio;                      // offset 16
6
    // ...
7
};
8

9
// 内核 5.15 中的 task_struct（简化）
10
struct task_struct {
11
    unsigned int __state;          // offset 0
12
    unsigned int flags;            // offset 4  ← 新增字段
13
    void *stack;                   // offset 8  → 偏移变了！
14
    int prio;                      // offset 16 → 偏移变了！
15
    // ...
16
};

1
# 检查内核是否支持 BTF
2
ls /sys/kernel/btf/vmlinux
3

4
# 使用 pahole 从内核二进制生成 BTF
5
pahole -J /sys/kernel/btf/vmlinux
6

7
# 从 eBPF 对象文件查看 BTF 信息
8
bpftool btf dump file hello.bpf.o
9

10
# 从内核查看 BTF 类型信息
11
bpftool btf dump file /sys/kernel/btf/vmlinux format c > vmlinux.h

1
// vmlinux.h 中的 task_struct（自动生成）
2
struct task_struct {
3
    unsigned int __state;
4
    unsigned int flags;
5
    void *stack;
6
    int prio;
7
    int static_prio;
8
    int normal_prio;
9
    const struct sched_class *sched_class;
10
    // ... 数百个字段
11
};
12

13
// 使用 vmlinux.h 的 eBPF 程序
14
#include "vmlinux.h"
15
#include <bpf/bpf_helpers.h>
16

17
SEC("kprobe/do_sys_openat2")
18
int trace_open(struct pt_regs *ctx)
19
{
20
    // 可以直接引用内核结构体
21
    struct task_struct *task = (struct task_struct *)bpf_get_current_task();
22
    // CO-RE 会自动处理字段偏移
23
    int prio = BPF_CORE_READ(task, prio);
24
    return 0;
25
}

1
// 不使用 CO-RE（硬编码偏移，不可移植）
2
struct task_struct *task = (struct task_struct *)bpf_get_current_task();
3
int prio = *(int *)((void *)task + 16);  // 假设 prio 在偏移 16
4

5
// 使用 CO-RE（自动重定位，可移植）
6
struct task_struct *task = (struct task_struct *)bpf_get_current_task();
7
int prio = BPF_CORE_READ(task, prio);  // 运行时计算正确偏移

1
// 获取当前进程的 PID
2
u32 pid = BPF_CORE_READ(current, pid);
3

4
// 获取当前进程的父进程的 PID（两级指针解引用）
5
u32 ppid = BPF_CORE_READ(current, real_parent, pid);
6

7
// 获取当前进程的文件系统的根目录的 inode 号（多级解引用）
8
u64 ino = BPF_CORE_READ(current, fs, root, dentry, d_inode, i_ino);

1
SEC("kprobe/do_sys_openat2")
2
int trace_open(struct pt_regs *ctx)
3
{
4
    struct task_struct *task = (struct task_struct *)bpf_get_current_task();
5

6
    // 检查字段是否存在（不同内核版本可能不同）
7
    if (bpf_core_field_exists(task, flags)) {
8
        unsigned int flags = BPF_CORE_READ(task, flags);
9
        // 使用 flags...
10
    }
11

12
    // 检查类型是否存在
13
    if (bpf_core_type_exists(struct rq)) {
14
        // 使用 struct rq...
15
    }
16

17
    return 0;
18
}

1
# 生成骨架头文件
2
bpftool gen skeleton hello.bpf.o > hello.skel.h

1
#include "vmlinux.h"
2
#include <bpf/bpf_helpers.h>
3
#include <bpf/bpf_tracing.h>
4

5
struct event {
6
    pid_t pid;
7
    pid_t ppid;
8
    char comm[16];
9
    char filename[256];
10
};
11

12
struct {
13
    __uint(type, BPF_MAP_TYPE_RINGBUF);
14
    __uint(max_entries, 256 * 1024);
15
} events SEC(".maps");
16

17
SEC("tracepoint/syscalls/sys_enter_execve")
18
int trace_execve(struct trace_event_raw_sys_enter *ctx)
19
{
20
    struct event *e;
21

22
    e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
23
    if (!e)
24
        return 0;
25

26
    e->pid = bpf_get_current_pid_tgid() >> 32;
27

28
    // CO-RE 方式获取父进程 PID
29
    struct task_struct *task = (struct task_struct *)bpf_get_current_task();
30
    e->ppid = BPF_CORE_READ(task, real_parent, pid);
31

32
    bpf_get_current_comm(&e->comm, sizeof(e->comm));
33

34
    const char *filename = (const char *)ctx->args[0];
35
    bpf_probe_read_user_str(&e->filename, sizeof(e->filename), filename);
36

37
    bpf_ringbuf_submit(e, 0);
38
    return 0;
39
}
40

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

1
#include <stdio.h>
2
#include <signal.h>
3
#include <bpf/libbpf.h>
4
#include <bpf/bpf.h>
5
#include "execsnoop.skel.h"
6

7
static volatile bool exiting = false;
8
static void sig_handler(int sig) { exiting = true; }
9

10
static int handle_event(void *ctx, void *data, size_t len)
11
{
12
    struct event {
13
        int pid, ppid;
14
        char comm[16], filename[256];
15
    } *e = data;
16

17
    printf("%-8d %-8d %-16s %s\n", e->pid, e->ppid, e->comm, e->filename);
18
    return 0;
19
}
20

21
int main(int argc, char **argv)
22
{
23
    struct execsnoop_bpf *skel;
24
    struct ring_buffer *rb;
25

26
    signal(SIGINT, sig_handler);
27

28
    /* 1. 打开并加载（CO-RE 重定位在此发生） */
29
    skel = execsnoop_bpf__open_and_load();
30
    if (!skel) {
31
        fprintf(stderr, "Failed to open/load BPF skeleton\n");
32
        return 1;
33
    }
34

35
    /* 2. 附加到 tracepoint */
36
    if (execsnoop_bpf__attach(skel)) {
37
        fprintf(stderr, "Failed to attach BPF program\n");
38
        goto cleanup;
39
    }
40

41
    /* 3. 设置 Ring Buffer */
42
    rb = ring_buffer__new(bpf_map__fd(skel->maps.events),
43
                          handle_event, NULL, NULL);
44
    if (!rb) goto cleanup;
45

46
    printf("%-8s %-8s %-16s %s\n", "PID", "PPID", "COMM", "FILENAME");
47

48
    /* 4. 事件循环 */
49
    while (!exiting)
50
        ring_buffer__poll(rb, 100);
51

52
    ring_buffer__free(rb);
53

54
cleanup:
55
    execsnoop_bpf__destroy(skel);
56
    return 0;
57
}

1
# Makefile for CO-RE eBPF program
2
APP = execsnoop
3
BPF_SRC = $(APP).bpf.c
4
SKEL_H = $(APP).skel.h
5

6
CLANG ?= clang
7
ARCH := $(shell uname -m | sed 's/x86_64/x86/' | sed 's/aarch64/arm64/')
8

9
.PHONY: all clean
10

11
all: $(APP)
12

13
# 生成 vmlinux.h（如果不存在）
14
vmlinux.h:
15
  bpftool btf dump file /sys/kernel/btf/vmlinux format c > $@
16

17
# 编译 eBPF 程序
18
$(APP).bpf.o: $(BPF_SRC) vmlinux.h
19
  $(CLANG) -g -O2 -target bpf -D__TARGET_ARCH_$(ARCH) \
20
    -I/usr/include/$(ARCH)-linux-gnu \
21
    -c $< -o $@
22

23
# 生成骨架
24
$(SKEL_H): $(APP).bpf.o
25
  bpftool gen skeleton $< > $@
26

27
# 编译用户态程序
28
$(APP): $(APP).c $(SKEL_H)
29
  gcc -g -O2 -o $@ $< -lbpf -lelf -lz
30

31
clean:
32
  rm -f $(APP) $(APP).bpf.o $(SKEL_H) vmlinux.h

1
# 查看重定位记录
2
llvm-readelf -r hello.bpf.o
3

4
# 输出示例：
5
# Relocation section '.rel.tracepoint/syscalls/sys_enter_execve'
6
# Offset     Info    Type                Symbol's Value  Symbol's Name
7
# 0x00000012 00000001 R_BPF_64_64           00000000      task_struct.prio
8
# 0x00000028 00000001 R_BPF_64_64           00000000      task_struct.real_parent

1
# 生成 vmlinux.h
2
bpftool btf dump file /sys/kernel/btf/vmlinux format c > vmlinux.h
3

4
# 查看文件大小
5
ls -lh vmlinux.h
6
# -rw-r--r-- 1 root root 15M  vmlinux.h
7

8
# 搜索特定结构体
9
grep "struct task_struct {" vmlinux.h -A 50
10

11
# 查看内核 BTF 中的类型数量
12
bpftool btf dump file /sys/kernel/btf/vmlinux | wc -l

1
# 编译 eBPF 程序
2
clang -g -O2 -target bpf -D__TARGET_ARCH_x86 \
3
    -c execsnoop.bpf.c -o execsnoop.bpf.o
4

5
# 生成骨架
6
bpftool gen skeleton execsnoop.bpf.o > execsnoop.skel.h
7

8
# 编译用户态程序
9
gcc -g -O2 -o execsnoop execsnoop.c -lbpf -lelf -lz
10

11
# 运行
12
sudo ./execsnoop

1
# 查看对象文件中的重定位信息
2
llvm-readelf -r execsnoop.bpf.o
3

4
# 查看 BTF 信息
5
bpftool btf dump file execsnoop.bpf.o
6

7
# 使用 libbpf 调试模式查看重定位过程
8
export LIBBPF_LOG_LEVEL=4
9
sudo ./execsnoop 2>&1 | grep -i reloc