eBPF trampoline（trampoline：蹦床，翻译后并不好理解，所以不作翻译）是内核函数和 eBPF 程序之间的桥梁，基于 register_ftrace_direct() 实现。它实现了 kprobe/kretprobe 的功能。相比于 kprobe/kretprobe，trampoline 的性能更好。特别是对比 kretprobe，trampoline 的 fexit 在实现了同样功能的同时，能够支持去获取目标函数的参数（这是 kretprobe 不支持的）（参考：bpf: Introduce BPF trampoline）。

不过并不是所有内核版本都支持 trampoline，eBPF trampoline 特性要求 >= 5.5 内核版本，参考 BPF Features by Linux Kernel Version。

eBPF trampoline 一例

Go 的 eBPF 库 cilium/ebpf 已支持 trampoline（fenter/fexit），参考其中的例子来写一个自己的 demo。

get_rps_cpu()

在 Linux 网络协议栈的底层，有个软件实现的 RSS 叫做 RPS，参考 Scaling in the Linux Networking Stack。此处 RPS 的功能是将网络包 skb 投递到另一个 CPU 上去处理。RPS 发生在网卡驱动下半场中，如下内核源代码：

 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

// net/core/dev.c

static int netif_rx_internal(struct sk_buff *skb)
{
    int ret;

    //...

#ifdef CONFIG_RPS
    if (static_branch_unlikely(&rps_needed)) {
        struct rps_dev_flow voidflow, *rflow = &voidflow;
        int cpu;

        //...

        cpu = get_rps_cpu(skb->dev, skb, &rflow);
        if (cpu < 0)
            cpu = smp_processor_id();

        ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);

        //...
    } else
#endif
    {
        unsigned int qtail;

        ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
        put_cpu();
    }
    return ret;
}

这段代码的意思是，通过 get_rps_cpu() 计算当前网络包 skb 应该投递到哪个 CPU 去处理。

用 trampoline trace get_rps_cpu()

相关 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

struct rps_key {
    __u32 ifindex;
    __u32 curr_node_id;
    __u32 curr_cpu;
    __u32 targ_cpu;
} __attribute__((packed));

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(key_size, sizeof(struct rps_key));
    __uint(value_size, sizeof(__u64));
    __uint(max_entries, 65536);
} rps_record SEC(".maps");

static __always_inline void
handle_rps(__u32 ifindex, int targ_cpu)
{
    struct rps_key key = {};
    key.curr_node_id = bpf_get_numa_node_id();
    key.curr_cpu = bpf_get_smp_processor_id();

    if (targ_cpu < 0 || (__u32)targ_cpu == key.curr_cpu)
        return;

    key.ifindex = ifindex;
    key.targ_cpu = (__u32)targ_cpu;

    __u64 *val = bpf_map_lookup_elem(&rps_record, &key);
    if (val)
        __sync_fetch_and_add(val, 1);
    else {
        __u64 init_val = 0;
        bpf_map_update_elem(&rps_record, &key, &init_val, BPF_NOEXIST);
    }
}

SEC("fexit/get_rps_cpu")
int BPF_PROG(get_rps_cpu, struct net_device *dev, struct sk_buff *skb, struct rps_dev_flow **rflowp, int cpu)
{
    if (filter_skb(skb))
        return BPF_OK;

    __u32 ifindex = BPF_CORE_READ(dev, ifindex);

    handle_rps(ifindex, cpu);

    return BPF_OK;
}

如果使用 kprobe/kretprobe，对应的 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

// handle_rps()

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(key_size, sizeof(__u32));
    __uint(value_size, sizeof(__u32));
    __uint(max_entries, 4096);
} kprobes SEC(".maps");

SEC("kprobe/get_rps_cpu")
int k_get_rps_cpu(struct pt_regs *ctx)
{
    struct sk_buff *skb = (struct sk_buff *)PT_REGS_PARM2(ctx);
    if (filter_skb(skb))
        return BPF_OK;

    struct net_device *dev = (struct net_device *)PT_REGS_PARM1(ctx);
    __u32 ifindex = BPF_CORE_READ(dev, ifindex);
    __u32 pid = (__u32)bpf_get_current_pid_tgid();

    bpf_map_update_elem(&kprobes, &pid, &ifindex, BPF_ANY);

    return BPF_OK;
}

SEC("kretprobe/get_rps_cpu")
int kr_get_rps_cpu(struct pt_regs *ctx)
{
    int cpu = PT_REGS_RET(ctx);
    __u32 pid = (__u32)bpf_get_current_pid_tgid();

    __u32 *ifindex = (typeof(ifindex))bpf_map_lookup_elem(&kprobes, &pid);
    if (ifindex)
        handle_rps(*ifindex, cpu);

    bpf_map_delete_elem(&kprobes, &pid);

    return BPF_OK;
}

对比这两段代码可知，trampoline 的写法更加简短优雅（且性能更好）。

而对应的主要 Go 代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

//go:generate bpf2go -cc clang rps ./ebpf/rps.c -- -I./ebpf/headers -Wall -D__TARGET_ARCH_x86

    var obj rpsForHighVersionObjects
    if err := spec.LoadAndAssign(&obj, &ebpf.CollectionOptions{
        Programs: ebpf.ProgramOptions{
            KernelTypes: btfSpec,
        },
    }); err != nil {
        log.Fatalf("Failed to load bpf obj and bpf map: %v", err)
    }
    defer obj.Close()

    // fentry/fexit 对应的是 link.AttachTracing
    // kprobe/kretprobe 对应的是 link.Kprobe/link.Kretprobe
    if fexit, err := link.AttachTracing(link.TracingOptions{
        Program: obj.GetRpsCpu,
    }); err != nil {
        log.Fatalf("Failed to attach fexit(get_rps_cpu)")
    } else {
        log.Printf("Attached fexit(get_rps_cpu)")
        defer fexit.Close()
    }

小结

参考 BPF Features by Linux Kernel Version，一步一步地探索 eBPF 的特性。