eBPF，即扩展的Berkeley包过滤器（Extended Berkeley Packet Filter），是Linux内核中的一种革命性技术，它允许开发者在内核态中运行自定义的“微程序”，从而在不修改内核代码的情况下改变系统行为或收集系统细粒度的性能数据。
本文讨论如何使用 Uprobe 和 eBPF 追踪用户态 Rust 应用，包括如何获取符号名称并 attach、获取函数参数、获取返回值等。本文是 eBPF 开发者教程的一部分，更详细的内容可以在这里找到：https://eunomia.dev/tutorials/ 源代码在 GitHub 仓库 中开源。
Uprobe是一种用户空间探针，uprobe探针允许在用户空间程序中动态插桩，插桩位置包括：函数入口、特定偏移处，以及函数返回处。当我们定义uprobe时，内核会在附加的指令上创建快速断点指令（x86机器上为int3指令），当程序执行到该指令时，内核将触发事件，程序陷入到内核态，并以回调函数的方式调用探针函数，执行完探针函数再返回到用户态继续执行后序的指令。
uprobe 适用于在用户态去解析一些内核态探针无法解析的流量，例如 http2 流量，https 流量，同时也可以分析程序运行时、业务逻辑等。关于 Uprobe 的更多信息，可以参考：
Uprobe 在内核态 eBPF 运行时，也可能产生比较大的性能开销，这时候也可以考虑使用用户态 eBPF 运行时，例如 bpftime。bpftime 是一个基于 LLVM JIT/AOT 的用户态 eBPF 运行时，它可以在用户态运行 eBPF Uprobe 程序，和内核态的 eBPF 兼容，由于避免了内核态和用户态之间的上下文切换，bpftime 的 Uprobe 开销比内核少约 10 倍，并且也更容易扩展。
Rust 是一种开源的系统编程语言，注重安全、速度和并行性。它于2010年由Graydon Hoare在Mozilla研究中心开发，并于2015年发布了第一个稳定版本。Rust 语言的设计哲学旨在提供C++的性能优势，同时大幅减少内存安全漏洞。Rust在系统编程领域逐渐受到欢迎，特别是在需要高性能、安全性和可靠性的应用场景，例如操作系统、文件系统、游戏引擎、网络服务等领域。许多大型技术公司，包括Mozilla、Google、Microsoft和Amazon等，都在使用或支持Rust语言。
可以参考 Rust 官方网站 了解更多 Rust 语言的信息，并安装 Rust 的工具链。
我们先来看一个简单的例子，使用 Uprobe 追踪 Rust 程序的 main 函数，代码如下：
main
pub fn hello() -> i32 { + println!("Hello, world!"); + 0 +} + +fn main() { + hello(); +}
构建和尝试获取符号：
$ cd helloworld +$ cargo build +$ nm helloworld/target/release/helloworld | grep hello +0000000000008940 t _ZN10helloworld4main17h2dce92cb81426b91E +
我们会发现，对应的符号被转换为了 _ZN10helloworld4main17h2dce92cb81426b91E，这是因为 rustc 使用 Symbol name mangling 来为代码生成过程中使用的符号编码一个唯一的名称。编码后的名称会被链接器用于将名称与所指向的内容关联起来。可以使用 -C symbol-mangling-version 选项来控制符号名称的处理方法。
_ZN10helloworld4main17h2dce92cb81426b91E
我们可以使用 rustfilt 工具来解析和获取对应的符号：
rustfilt
$ cargo install rustfilt +$ nm helloworld/target/release/helloworld > name.txt +$ rustfilt _ZN10helloworld4main17h2dce92cb81426b91E +helloworld::main +$ rustfilt -i name.txt | grep hello +0000000000008b60 t helloworld::main +
接下来我们可以尝试使用 bpftrace 跟踪对应的函数：
$ sudo bpftrace -e 'uprobe:helloworld/target/release/helloworld:_ZN10helloworld4main17h2dce92cb81426b91E { printf("Function hello-world called\n"); }' +Attaching 1 probe... +Function hello-world called +
对于一个更复杂的例子，包含多次调用和获取参数：
use std::env; + +pub fn hello(i: i32, len: usize) -> i32 { + println!("Hello, world! {} in {}", i, len); + i + len as i32 +} + +fn main() { + let args: Vec<String> = env::args().collect(); + + // Skip the first argument, which is the path to the binary, and iterate over the rest + for arg in args.iter().skip(1) { + match arg.parse::<i32>() { + Ok(i) => { + let ret = hello(i, args.len()); + println!("return value: {}", ret); + } + Err(_) => { + eprintln!("Error: Argument '{}' is not a valid integer", arg); + } + } + } +}
我们再次进行类似的操作，会发现一个奇怪的现象：
$ sudo bpftrace -e 'uprobe:args/target/release/helloworld:_ZN10helloworld4main17h2dce92cb81426b91E { printf("Function hello-world called\n"); }' +Attaching 1 probe... +Function hello-world called +
这时候我们希望 hello 函数运行多次，但 bpftrace 中只输出了一次调用：
$ args/target/release/helloworld 1 2 3 4 +Hello, world! 1 in 5 +return value: 6 +Hello, world! 2 in 5 +return value: 7 +Hello, world! 3 in 5 +return value: 8 +Hello, world! 4 in 5 +return value: 9 +
而且看起来 bpftrace 并不能正确获取参数：
$ sudo bpftrace -e 'uprobe:args/target/release/helloworld:_ZN10helloworld4main17h2dce92cb81426b91E { printf("Function hello-world called %d\n" +, arg0); }' +Attaching 1 probe... +Function hello-world called 63642464 +
Uretprobe 捕捉到了第一次调用的返回值：
$ sudo bpftrace -e 'uretprobe:args/tar +get/release/helloworld:_ZN10helloworld4main17h2dce92 +cb81426b91E { printf("Function hello-world called %d +\n", retval); }' +Attaching 1 probe... +Function hello-world called 6 +
这可能是由于 Rust 没有稳定的 ABI。 Rust，正如它迄今为止所存在的那样，保留了以任何它想要的方式对这些结构成员进行排序的权利。 因此，被调用者的编译版本可能会完全按照上面的方式对成员进行排序，而调用库的编程的编译版本可能会认为它实际上是这样布局的：
TODO: 进一步分析（未完待续）
在现代 Linux 系统中，eBPF（扩展的 Berkeley Packet Filter）是一项强大而灵活的技术。它允许在内核中运行沙盒化程序，类似于虚拟机环境，为扩展内核功能提供了一种既安全又不会导致系统崩溃或安全风险的方法。
eBPF 中的 “co-re” 代表“一次编译、到处运行”。这是其关键特征之一，用于解决 eBPF 程序在不同内核版本间兼容性的主要挑战。eBPF 的 CO-RE 功能可以实现在不同的内核版本上运行同一 eBPF 程序，而无需重新编译。
利用 eBPF 的 Uprobe 功能，可以追踪用户空间应用程序并访问其内部数据结构。然而，用户空间应用程序的 CO-RE 实践目前尚不完善。本文将介绍一种新方法，利用 CO-RE 为用户空间应用程序确保 eBPF 程序在不同应用版本间的兼容性，从而避免了多次编译的需求。例如，在从加密流量中捕获 SSL/TLS 明文数据时，你或许不需要为每个版本的 OpenSSL 维护一个单独的 eBPF 程序。
为了在用户空间应用程序中实现eBPF的“一次编译、到处运行”(Co-RE)特性，我们需要利用BPF类型格式(BTF)来克服传统eBPF程序的一些限制。这种方法的关键在于为用户空间程序提供与内核类似的类型信息和兼容性支持，从而使得eBPF程序能够更灵活地应对不同版本的用户空间应用和库。
本文是eBPF开发者教程的一部分，详细内容可访问这里。源代码在GitHub库中可用。
eBPF也支持追踪用户空间应用程序。Uprobe是一个用户空间探针，允许对用户空间程序进行动态仪表装置。探针位置包括函数入口、特定偏移和函数返回。
BTF是为内核设计的，生成自vmlinux，它可以帮助eBPF程序方便地兼容不同的内核版本。
但是，用户空间应用程序也需要CO-RE。例如，SSL/TLS uprobe被广泛用于从加密流量中捕获明文数据。它是用用户空间库实现的，如OpenSSL、GnuTLS、NSS等。用户空间应用程序和库也有各种版本，如果我们需要为每个版本编译和维护eBPF程序，那就会很复杂。
下面是一些新的工具和方法来帮助我们为用户空间应用程序启用CO-RE。
这是一个简单的uprobe例子，它可以捕获用户空间程序的add_test函数的调用和参数。你可以在uprobe.bpf.c中添加#define BPF_NO_PRESERVE_ACCESS_INDEX来确保eBPF程序可以在没有struct data的BTF的情况下编译。
add_test
uprobe.bpf.c
#define BPF_NO_PRESERVE_ACCESS_INDEX
struct data
#define BPF_NO_GLOBAL_DATA +#define BPF_NO_PRESERVE_ACCESS_INDEX +#include <vmlinux.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +struct data { + int a; + int c; + int d; +}; + +SEC("uprobe/examples/btf-base:add_test") +int BPF_UPROBE(add_test, struct data *d) +{ + int a = 0, c = 0; + bpf_probe_read_user(&a, sizeof(a), &d->a); + bpf_probe_read_user(&c, sizeof(c), &d->c); + bpf_printk("add_test(&d) %d + %d = %d\n", a, c, a + c); + return a + c; +} + +char LICENSE[] SEC("license") = "Dual BSD/GPL"; +
然后，我们有两个不同版本的用户空间程序，examples/btf-base和examples/btf-base-new。两个版本中的struct data是不同的。
examples/btf-base
examples/btf-base-new
data
examples/btf-base：
// use a different struct +struct data { + int a; + int c; + int d; +}; + +int add_test(struct data *d) { + return d->a + d->c; +} + +int main(int argc, char **argv) { + struct data d = {1, 3, 4}; + printf("add_test(&d) = %d\n", add_test(&d)); + return 0; +} +
examples/btf-base-new：
struct data { + int a; + int b; + int c; + int d; +}; + +int add_test(struct data *d) { + return d->a + d->c; +} + +int main(int argc, char **argv) { + struct data d = {1, 2, 3, 4}; + printf("add_test(&d) = %d\n", add_test(&d)); + return 0; +} +
我们可以使用pahole和clang来生成每个版本的btf。制作示例并生成btf:
make -C example # it's like: pahole --btf_encode_detached base.btf btf-base.o +
然后我们执行eBPF程序和用户空间程序。 对于 btf-base：
btf-base
sudo ./uprobe examples/btf-base +
也是用户空间程序：
$ examples/btf-base +add_test(&d) = 4 +
我们将看到：
$ sudo cat /sys/kernel/debug/tracing/trace_pipe\ + <...>-25458 [000] ...11 27694.081465: bpf_trace_printk: add_test(&d) 1 + 3 = 4 +
对于 btf-base-new：
btf-base-new
sudo ./uprobe examples/btf-base-new +
同时也是用户空间程序：
$ examples/btf-base-new +add_test(&d) = 4 +
但我们可以看到：
$ sudo cat /sys/kernel/debug/tracing/trace_pipe\ + <...>-25809 [001] ...11 27828.314224: bpf_trace_printk: add_test(&d) 1 + 2 = 3 +
结果是不同的，因为两个版本中的struct data是不同的。eBPF程序无法与不同版本的用户空间程序兼容。
在uprobe.bpf.c中注释掉#define BPF_NO_PRESERVE_ACCESS_INDEX ，以确保eBPF程序可以以struct data的BTF编译。
#define BPF_NO_GLOBAL_DATA +// #define BPF_NO_PRESERVE_ACCESS_INDEX +#include <vmlinux.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +#ifndef BPF_NO_PRESERVE_ACCESS_INDEX +#pragma clang attribute push (__attribute__((preserve_access_index)), apply_to = record) +#endif + +struct data { + int a; + int c; + int d; +}; + +#ifndef BPF_NO_PRESERVE_ACCESS_INDEX +#pragma clang attribute pop +#endif + +SEC("uprobe/examples/btf-base:add_test") +int BPF_UPROBE(add_test, struct data *d) +{ + int a = 0, c = 0; + bpf_probe_read_user(&a, sizeof(a), &d->a); + bpf_probe_read_user(&c, sizeof(c), &d->c); + bpf_printk("add_test(&d) %d + %d = %d\n", a, c, a + c); + return a + c; +} + +char LICENSE[] SEC("license") = "Dual BSD/GPL"; +
struct data的记录在eBPF程序中被保留下来。然后，我们可以使用 btf-base.btf来编译eBPF程序。
btf-base.btf
将用户btf与内核btf合并，这样我们就有了一个完整的内核和用户空间的btf:
./merge-btf /sys/kernel/btf/vmlinux examples/base.btf target-base.btf +
然后我们使用用户空间程序执行eBPF程序。 对于 btf-base：
$ sudo ./uprobe examples/btf-base target-base.btf +... +libbpf: prog 'add_test': relo #1: patched insn #4 (ALU/ALU64) imm 0 -> 0 +libbpf: prog 'add_test': relo #2: <byte_off> [7] struct data.c (0:1 @ offset 4) +libbpf: prog 'add_test': relo #2: matching candidate #0 <byte_off> [133110] struct data.c (0:1 @ offset 4) +libbpf: prog 'add_test': relo #2: patched insn #11 (ALU/ALU64) imm 4 -> 4 +... +
执行用户空间程序并获取结果：
$ sudo cat /sys/kernel/debug/tracing/trace_pipe +[sudo] password for yunwei37: + <...>-26740 [001] ...11 28180.156220: bpf_trace_printk: add_test(&d) 1 + 3 = 4 +
还可以对另一个版本的用户空间程序btf-base-new做同样的操作:
$ ./merge-btf /sys/kernel/btf/vmlinux examples/base-new.btf target-base-new.btf +$ sudo ./uprobe examples/btf-base-new target-base-new.btf +.... +libbpf: sec 'uprobe/examples/btf-base:add_test': found 3 CO-RE relocations +libbpf: CO-RE relocating [2] struct pt_regs: found target candidate [357] struct pt_regs in [vmlinux] +libbpf: prog 'add_test': relo #0: <byte_off> [2] struct pt_regs.di (0:14 @ offset 112) +libbpf: prog 'add_test': relo #0: matching candidate #0 <byte_off> [357] struct pt_regs.di (0:14 @ offset 112) +libbpf: prog 'add_test': relo #0: patched insn #0 (LDX/ST/STX) off 112 -> 112 +libbpf: CO-RE relocating [7] struct data: found target candidate [133110] struct data in [vmlinux] +libbpf: prog 'add_test': relo #1: <byte_off> [7] struct data.a (0:0 @ offset 0) +libbpf: prog 'add_test': relo #1: matching candidate #0 <byte_off> [133110] struct data.a (0:0 @ offset 0) +libbpf: prog 'add_test': relo #1: patched insn #4 (ALU/ALU64) imm 0 -> 0 +libbpf: prog 'add_test': relo #2: <byte_off> [7] struct data.c (0:1 @ offset 4) +libbpf: prog 'add_test': relo #2: matching candidate #0 <byte_off> [133110] struct data.c (0:2 @ offset 8) +libbpf: prog 'add_test': relo #2: patched insn #11 (ALU/ALU64) imm 4 -> 8 +libbpf: elf: symbol address match for 'add_test' in 'examples/btf-base-new': 0x1140 +Successfully started! Press Ctrl+C to stop. +
结果是正确的：
这个示例展示了eBPF在实践中的重要进步，将其强大的功能扩展到更动态地处理用户空间应用程序在Linux环境中。对于处理现代Linux系统复杂性的软件工程师和系统管理员来说，这是一个引人注目的解决方案。
如果你想了解更多关于eBPF知识和实践，你可以访问我们的教程代码库https://github.com/eunomia-bpf/bpf-developer-tutorial或者网站https://eunomia.dev/tutorials/获得更多示例和完整教程。