1
2
3

cd libbpf-bootstrap/examples/c/
make bootstrap
sudo ./bootstrap -d 50

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#ifndef __BOOTSTRAP_H
#define __BOOTSTRAP_H

#define TASK_COMM_LEN     16
#define MAX_FILENAME_LEN 127

struct event {
    int pid;
    int ppid;
    unsigned exit_code;
    unsigned long long duration_ns;
    char comm[TASK_COMM_LEN];
    char filename[MAX_FILENAME_LEN];
    bool exit_event;
};

#endif /* __BOOTSTRAP_H */

  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
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>
#include <bpf/bpf_core_read.h>
#include "bootstrap.h"

// 许可证声明
char LICENSE[] SEC("license") = "Dual BSD/GPL";

// 定义名为exec_start的BPF映射
// SEC宏把映射放进ELF文件的.maps段
// 在加载时会识别.maps段的内容，把它创建成内核里的真正BPF映射
struct {
    // 创建的映射类型是BPF_MAP_TYPE_HASH，即哈希表
    // 常用于保存临时状态
    __uint(type, BPF_MAP_TYPE_HASH);
    // 映射可以最多存储8192个元素
    __uint(max_entries, 8192);
    // 键的类型为pid_t，即进程的PID
    __type(key, pid_t);
    // 值的类型为无符号64位整数，即时间戳
    __type(value, u64);
} exec_start SEC(".maps");

// 定义名为rb的BPF映射
struct {
    // 创建的映射类型是BPF_MAP_TYPE_RINGBUF
    // 专用于eBPF程序向用户态高效发送数据的BPF映射
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    // 该Ring Buffer的最大容量是256KB
    __uint(max_entries, 256 * 1024);
} rb SEC(".maps");

// eBPF程序中的全局变量，用户态程序在启动时写入该变量
// 后续指示只记录存活时间大于min_duration_ns的进程
const volatile unsigned long long min_duration_ns = 0;

// 指示该函数将附加到sched_process_exec上
// 内核通过TRACE_EVENT宏自动为sched_process_exec这个tracepoint生成结构体
// 结构体的名称为trace_event_raw_<tracepoint_name>
SEC("tp/sched/sched_process_exec")
int handle_exec(struct trace_event_raw_sched_process_exec *ctx)
{
    struct task_struct *task;
    unsigned fname_off;
    struct event *e;
    pid_t pid;
    u64 ts;

    // 获取进程的PID，返回的64位整数中：高32位是进程PID、低32位是线程TID
    pid = bpf_get_current_pid_tgid() >> 32;
    // 获取以纳秒为单位的当前时间戳
    ts = bpf_ktime_get_ns();
    // 向BPF映射exec_start里插入或更新一个元素，插入的键为进程PID、值为时间戳
    // BPF_ANY：总是更新（如果键不存在就插入、存在就覆盖）
    // BPF_NOEXIST：只有键不存在时才插入
    // BPF_EXIST：只有键已存在时才更新
    bpf_map_update_elem(&exec_start, &pid, &ts, BPF_ANY);

    // 如果用户设置了运行的最小时长，则无需上报进程的exec事件
    if (min_duration_ns)
        return 0;

    // 从环形缓存区rb中申请空间，准备写入一条事件
    // 即在其中申请一块大小为sizeof(*e)的内存
    // 如果Ring Buffer满了或其他失败，就返回NULL
    e = bpf_ringbuf_reserve(&rb, sizeof(*e), 0);
    if (!e)
        return 0;

    // 在Linux内核中，每个进程/线程都有一个task_struct结构体，里面记录了大量的进程信息
    // bpf_get_current_task()函数可以获得当前进程的task_struct结构体
    task = (struct task_struct *)bpf_get_current_task();

    // 标记这是一个exec事件、不是一个exit事件
    e->exit_event = false;
    // 记录进程的PID
    e->pid = pid;
    // 从当前task_struct中读取父进程的PID
    e->ppid = BPF_CORE_READ(task, real_parent, tgid);
    // 获取进程的短名，例如python3
    bpf_get_current_comm(&e->comm, sizeof(e->comm));

    // 获取记录运行的程序名，例如/usr/bin/python3
    fname_off = ctx->__data_loc_filename & 0xFFFF;
    bpf_probe_read_str(&e->filename, sizeof(e->filename), (void *)ctx + fname_off);

    // 提交到Ring Buffer，通知内核该数据已经准备好，可以被用户态程序读取
    // 参数0是提交标志，通常为0表示正常提交
    bpf_ringbuf_submit(e, 0);
    return 0;
}

// 指示该函数将附加到sched_process_exit上
SEC("tp/sched/sched_process_exit")
int handle_exit(struct trace_event_raw_sched_process_template *ctx)
{
    struct task_struct *task;
    struct event *e;
    pid_t pid, tid;
    u64 id, ts, *start_ts, duration_ns = 0;

    // 获取进程的PID，返回的64位整数中：高32位是进程PID、低32位是线程TID
    id = bpf_get_current_pid_tgid();
    pid = id >> 32;
    tid = (u32)id;

    // 只关注进程的退出事件，忽略线程退出
    // TID与PID不同表示这是一个线程
    // 注意只有进程才能执行exec()，线程和进程都能执行exit()
    // 因此handle_exec()函数无需该步骤
    if (pid != tid)
        return 0;

    // 从哈希映射exec_start中根据PID查找该进程的启动时间戳
    start_ts = bpf_map_lookup_elem(&exec_start, &pid);
    // 如果查找到记录，则用当前时间减去启动时间计算进程存活时间
    if (start_ts)
        duration_ns = bpf_ktime_get_ns() - *start_ts;
    // 未查到记录且无需上报该事件，则直接返回不处理
    else if (min_duration_ns)
        return 0;
    
    // 在哈希映射exec_start中删除该PID相关的条目
    bpf_map_delete_elem(&exec_start, &pid);

    // 如果设置了最短持续时间阈值，且该进程运行时间小于该阈值，则不处理
    if (min_duration_ns && duration_ns < min_duration_ns)
        return 0;

    // 从环形缓冲区rb中申请一块内存用于存储退出事件数据
    e = bpf_ringbuf_reserve(&rb, sizeof(*e), 0);
    // 如果申请失败（如缓存区满），则退出
    if (!e)
        return 0;

    // 获取当前进程的task_struct指针，随后读取内核进程相关字段
    task = (struct task_struct *)bpf_get_current_task();

    // 标记这是一个exit事件、不是一个exec事件
    e->exit_event = true;
    // 记录进程以纳秒为单位的存活时间
    e->duration_ns = duration_ns;
    // 记录进程PID
    e->pid = pid;
    // 从task_struct中读取父进程PID
    e->ppid = BPF_CORE_READ(task, real_parent, tgid);
    // 从exit_code的低8位取出退出码
    e->exit_code = (BPF_CORE_READ(task, exit_code) >> 8) & 0xff;
    // 获取进程短名
    bpf_get_current_comm(&e->comm, sizeof(e->comm));

    // 提交事件数据，通知内核这条数据已经准备好，用户态程序可以读取
    bpf_ringbuf_submit(e, 0);
    return 0;
}

1

sudo cat /sys/kernel/debug/tracing/available_events | grep exec

1

sudo cat /sys/kernel/debug/tracing/events/sched/sched_process_exec/format

1

sudo bpftrace -lv tracepoint:sched:sched_process_exec

1

bpftool btf dump file /sys/kernel/btf/vmlinux format c | grep -A 10 trace_event_raw_sched_process_exec

1
2
3
4
5

// 字符串数据在事件结构起始地址后的偏移
fname_off = ctx->__data_loc_filename & 0xFFFF;
// ctx + fname_off获取字符串的实际内存地址
// 从字符串的实际内存地址安全地复制一个以\0结尾的字符串到缓冲区，并且最多读取sizeof(e->filename)字节
bpf_probe_read_str(&e->filename, sizeof(e->filename), (void *)ctx + fname_off);

  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
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

#include <argp.h>
#include <signal.h>
#include <stdio.h>
#include <time.h>
#include <sys/resource.h>
#include <bpf/libbpf.h>
#include "bootstrap.h"
#include "bootstrap.skel.h"

// 定义结构体存储程序启动时，命令行传入的参数
static struct env {
    // 是否开启详细日志
    bool verbose;
    // 监控的进程运行时长阈值
    long min_duration_ms;
} env;

// 定义命令行帮助信息
const char *argp_program_version = "bootstrap 0.0";
const char *argp_program_bug_address = "<bpf@vger.kernel.org>";
const char argp_program_doc[] = "BPF bootstrap demo application.\n"
                "\n"
                "It traces process start and exits and shows associated \n"
                "information (filename, process duration, PID and PPID, etc).\n"
                "\n"
                "USAGE: ./bootstrap [-d <min-duration-ms>] [-v]\n";

// 定义可接受的命令行参数
static const struct argp_option opts[] = {
    { "verbose", 'v', NULL, 0, "Verbose debug output" },
    { "duration", 'd', "DURATION-MS", 0, "Minimum process duration (ms) to report" },
    {},
};

// argp的回调函数，每当解析到一个参数，就调用一次
static error_t parse_arg(int key, char *arg, struct argp_state *state)
{
    switch (key) {
    case 'v':
        // 如果是'v'，开启verbose
        env.verbose = true;
        break;
    case 'd':
        // 如果是'd'，转成long型并赋值到env中
        errno = 0;
        env.min_duration_ms = strtol(arg, NULL, 10);
        if (errno || env.min_duration_ms <= 0) {
            fprintf(stderr, "Invalid duration: %s\n", arg);
            argp_usage(state);
        }
        break;
    case ARGP_KEY_ARG:
        argp_usage(state);
        break;
    default:
        return ARGP_ERR_UNKNOWN;
    }
    return 0;
}

// 定义用于解析命令行参数的argp配置
static const struct argp argp = {
    // 指定可接受的选项
    .options = opts,
    // 指定解析回调函数
    .parser = parse_arg,
    // 指定帮助文档
    .doc = argp_program_doc,
};

// libbpf错误日志的回调函数
static int libbpf_print_fn(enum libbpf_print_level level, const char *format, va_list args)
{
    // 根据命令行输入（-v选项）决定是否打印LIBBPF_DEBUG级别的日志
    if (level == LIBBPF_DEBUG && !env.verbose)
        return 0;
    return vfprintf(stderr, format, args);
}

static volatile bool exiting = false;

// 捕获Ctrl-C退出信号时的回调函数
static void sig_handler(int sig)
{
    // 将exiting置为true，提示退出程序
    exiting = true;
}

// 接收到事件信息时的回调函数
// data即指向Ring Buffer中传过来的事件数据
// data_sz表示事件数据的字节大小，可方便校验或处理变长数据，本例中事件结构体大小是固定的，因此未使用
static int handle_event(void *ctx, void *data, size_t data_sz)
{
    const struct event *e = data;
    struct tm *tm;
    char ts[32];
    time_t t;

    // 获取当前时间，即UNIX时间戳
    time(&t);
    // 转换为本地时间结构tm，方便后续格式化输出
    tm = localtime(&t);
    // 格式化时间字符串到ts，例如15:34:12
    strftime(ts, sizeof(ts), "%H:%M:%S", tm);

    if (e->exit_event) {
        // 如果exit_event为true，则表示是一个进程的退出事件
        printf("%-8s %-5s %-16s %-7d %-7d [%u]", ts, "EXIT", e->comm, e->pid, e->ppid,
               e->exit_code);
        if (e->duration_ns)
            printf(" (%llums)", e->duration_ns / 1000000);
        printf("\n");
    } else {
        // 如果exit_event为false，则表示是一个进程的启动事件
        printf("%-8s %-5s %-16s %-7d %-7d %s\n", ts, "EXEC", e->comm, e->pid, e->ppid,
               e->filename);
    }

    return 0;
}

int main(int argc, char **argv)
{
    struct ring_buffer *rb = NULL;
    struct bootstrap_bpf *skel;
    int err;

    // 通过argp库解析命令行参数
    err = argp_parse(&argp, argc, argv, 0, NULL, NULL);
    if (err)
        return err;

    // 设置libbpf的日志打印回调函数为libbpf_print_fn
    libbpf_set_print(libbpf_print_fn);

    // 设置信号处理函数sig_handler，用于捕获Ctrl-C等退出信号
    signal(SIGINT, sig_handler);
    signal(SIGTERM, sig_handler);

    // 载入eBPF程序bootstrap
    skel = bootstrap_bpf__open();
    if (!skel) {
        fprintf(stderr, "Failed to open and load BPF skeleton\n");
        return 1;
    }

    // 修改eBPF程序中的min_duration_ns变量，该变量为const类型，因此位于ELF文件的只读数据段rodata
    skel->rodata->min_duration_ns = env.min_duration_ms * 1000000ULL;

    // 加载并验证eBPF程序
    err = bootstrap_bpf__load(skel);
    if (err) {
        fprintf(stderr, "Failed to load and verify BPF skeleton\n");
        goto cleanup;
    }

    // 将eBPF程序的指定函数附加到指定的tracepoint
    err = bootstrap_bpf__attach(skel);
    if (err) {
        fprintf(stderr, "Failed to attach BPF skeleton\n");
        goto cleanup;
    }

    // 创建一个Ring Buffer的消费者，用于接收eBPF程序发送到用户态的事件数据
    // 参数一：用户态程序读Ring Buffer需要有该映射的文件描述符（fd），可通过bpf_map__fd获取
    // 参数二：指定回调函数handle_event处理接收到的事件数据
    // 参数三：用户上下文ctx，可传递自定义参数给回调函数handle_event
    // 参数四：高级用法，通常填NULL
    rb = ring_buffer__new(bpf_map__fd(skel->maps.rb), handle_event, NULL, NULL);
    if (!rb) {
        err = -1;
        fprintf(stderr, "Failed to create ring buffer\n");
        goto cleanup;
    }
    
    printf("%-8s %-5s %-16s %-7s %-7s %s\n", "TIME", "EVENT", "COMM", "PID", "PPID",
           "FILENAME/EXIT CODE");
    
    // 捕获Ctrl-C退出信号后，回调函数sig_handler()将exiting置为true
    while (!exiting) {
        // 持续调用ring_buffer__poll()函数监听内核发送过来的事件
        err = ring_buffer__poll(rb, 100 /* timeout, ms */);
        // 如果出现错误，同样退出
        if (err == -EINTR) {
            err = 0;
            break;
        }
        if (err < 0) {
            printf("Error polling perf buffer: %d\n", err);
            break;
        }
    }

cleanup:
    // 程序退出时释放Ring Buffer和eBPF相关资源
    ring_buffer__free(rb);
    bootstrap_bpf__destroy(skel);

    return err < 0 ? -err : 0;
}