tracepoint event tracing 实践

tracepoint 是一种 linux kernel 提供的一种观测内核事件的机制，其原理是内核开发者在代码中设置了静态的 hook 点，使得用户可以把自己的程序 attach 到任一 hook 点，这样内核每次执行到 tracepoint 对应的代码时就可以触发用户提供的程序执行。

基于 tracepoint 机制，linux 实现了一套 event based tracing 基础设施，方便对整个系统进行一个观测。

并不是所有的 tracepoint 都可以用来做 event tracing，仅当内核代码中把 trace 信息保存到 tracing buffer，并且定义了如何打印 trace 信息，tracepoint 才能用来做 event tracing。

本文分析一下使用 ebpf 库创建 tracepoint 的大致原理和流程。loader ebpf 和 maps 的过程不再介绍，主要分析和 perf event 相关的代码实现。

bpf 代码直接使用的 bcc 的 execsnoop-bpf.c。

我们的 main.go 核心代码如下

package main

import (
  ...
)

// we want to skip args filed when use binary.Read
type event struct {
    Pid       int32
    Ppid      int32
    Uid       uint32
    Retval    int32
    ArgsCount int32
    ArgsSize  uint32
    Comm      [16]int8
}

//go:generate go run github.com/cilium/ebpf/cmd/bpf2go -cc clang -cflags "-O2 -g -Wall -Werror" kern kern.c -- -I../../include -I/usr/include/x86_64-linux-gnu
func main() {
    fmt.Println("Hello eBPF!")
    if err := rlimit.RemoveMemlock(); err != nil {
        log.Fatal(err)
    }
    objs := kernObjects{}
    if err := loadKernObjects(&objs, nil); err != nil {
        log.Fatalf("loading objects: %s", err)
    }
    defer objs.Close()
    fmt.Println("load ebpf program finish")

    kpEnter, err := link.Tracepoint("syscalls", "sys_enter_execve", objs.TracepointSyscallsSysEnterExecve, nil)
    if err != nil {
        log.Fatalf("opening tracepoint: %s", err)
    }
    defer kpEnter.Close()
    kpExit, err := link.Tracepoint("syscalls", "sys_exit_execve", objs.TracepointSyscallsSysExitExecve, nil)
    if err != nil {
        log.Fatalf("opening tracepoint: %s", err)
    }
    defer kpExit.Close()

    rd, err := perf.NewReader(objs.Events, os.Getpagesize())
    if err != nil {
        log.Fatalf("opening perf reader: %s", err)
    }
    defer rd.Close()

    stopper := make(chan os.Signal, 1)
    signal.Notify(stopper, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-stopper

        if err := rd.Close(); err != nil {
            log.Fatalf("closing ringbuf reader: %s", err)
        }
    }()

    log.Println("Waiting for events..")
    var event event
    fmt.Printf("%-10s%-10s%-16s%s\n", "Pid", "Ppid", "Comm", "Args")
    for {
        record, err := rd.Read()
        if err != nil {
            if errors.Is(err, ringbuf.ErrClosed) {
                log.Println("Received signal, exiting..")
                return
            }
            log.Printf("reading from reader: %s", err)
            continue
        }
        if record.LostSamples != 0 {
            log.Printf("perf event ring buffer full, dropped %d samples", record.LostSamples)
            continue
        }
        r := bytes.NewReader(record.RawSample)
        err = binary.Read(r, binary.LittleEndian, &event)
        if err != nil {
            log.Fatal("read err", err)
        }
        args, err := io.ReadAll(r)
        if err != nil {
            log.Fatalf("read err: %v", err)
        }
        argsz := string(bytes.ReplaceAll(args, []byte{0}, []byte{' '}))
        comm_ := make([]byte, 0, len(event.Comm))
        for _, c := range event.Comm {
            comm_ = append(comm_, byte(c))
        }
        comm := unix.ByteSliceToString(comm_)
        fmt.Printf("%-10d%-10d%-16s%s\n", event.Pid, event.Ppid, comm, argsz)
    }
}

main 程序中直接调用了 link.Tracepoint函数来创建对应的 Link。
Tracepoint函数主要做了以下操作

1. 获取一个对应 trace event 的 fd，这个 trace event 由一个 id 唯一确定。获取 trace event fd 核心原理是执行了系统调用 perf_event_open。此时 pid 设置为 -1, ，perf event 的类型是 tracepoint, attr 的 config 设置为 trace event id。
2. 将 ebpf 程序 attach 到 perf event 上。在支持 perf_event link 的服务器上，直接把 ebpf 对应的 fd link 到 perf event 对应的 fd 上，这样就实现了 attach。
   在不支持 perf_event link 的服务器上，使用传统的 attach 的方法。bpftool feature list_builtins link_types可以用来查看支持的 link type。

perf.NewReader 使用 maps 的 fd 创建 reader 的流程

1. 创建 epoll 实例。原理是调用 syscall epoll_create，得到一个 epoll_fd
2. 获取一个 event fd 用于接收内核事件通知
3. 调用 epoll_ctl 将 event fd 添加 epoll 实例上，相当于向内核注册
4. 对于每个 CPU，创建一个对应的 perf event ring。其原理也是调用 perf event open，不过这次调用 perf event open 时设置了 cpu 号，并且设置了 type 类型为 PERF_TYPE_SOFTWARE。创建的 perf event ring 添加到 Reader 结构体的 rings 中，用于后续读取

perf.Reader 原理

创建 reader 的时候，为每个 CPU 创建了一个 perf event ring，并把 ring 添加 epoll 实例的 fd 列表中。reader 的时候就是在 epoll 实例上 wait，每次 wait 可能会有多个 CPU 上有 event 发生，此时我们能知道有哪些 CPU 上有 event 读，把这些 CPU 对应的 ring 放到 epollRings 列表中。只要 epollRings 列表中有未处理的数据，就不会执行 epoll wait。

readRecord 的原理

先读取固定 size 的 perf event header，根据 header.type 判断是 record lost 还是 record sample。

如果是 record sample, 先读取一个 uint32，可以知道这个 record 的大小，然后为 record 分配内存并从 reader 中读取数据

查看系统中支持的 tracepoint 列表

cat /sys/kernel/debug/tracing/available_events
当前系统上共有 1853 个tracepoint
等同于 perf list tracepoint | cat

相关系统调用

perf_event_open
创建一个文件描述符用户测量性能信息，可后续用于其它系统调用，比如 mmap, read, fnctl

int syscall(SYS_perf_event_open, struct perf_event_attr *attr, pid_t pid, int cpu, int group_fd, unsigned long flags);

pid > 0 && cpu == -1
measures the specified process/thread on any CPU
pid = 0 && cpu >= 0
measures the calling process/thread only when running on the specified CPU
pid == -1 and cpu >= 0
This measures all processes/threads on the specified CPU.

event_fd
创建一个文件描述符用于接收内核事件通知，后续可用于 read, write, pull, select

int eventfd(unsigned int initval, int flags);

epoll_ctl
用于把 fd add/modity/remove 到 epfd 对应的 epoll 实例中

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

epoll_wait
等待 epoll 实例上的 IO 事件。返回值为 io ready 的 fd 的数量

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
int epoll_pwait(int epfd, struct epoll_event *events, int maxevents, int timeout, const sigset_t *sigmask);
int epoll_pwait2(int epfd, struct epoll_event *events, int maxevents, const struct timespec *timeout, const sigset_t *sigmask);