一文搞懂如何从头开发一个Hello World级eBPF程序
近两年最火的Linux内核技术非eBPF[1]莫属！
2019年以来，除了eBPF技术自身快速演进之外，基于eBPF技术的观测(Observability)、安全(Security)和网络(Networking)类项目[2]如雨后春笋般出现。耳熟能详的的包括：cilium[3](把eBPF技术带到Kubernetes世界)、Falco[4](云原生安全运行时，Kubernetes威胁检测引擎的事实标准)、Katran[5](高性能四层负载均衡器)、pixie[6](用于Kubernetes应用程序的可观察性工具)等。
今年3月份发布的thoughtworks技术雷达第26期[7]也将eBPF技术放入试验的象限阶段。
eBPF技术火热，但很多童鞋还不知道eBPF技术究竟是什么，能做什么？在这篇文章中，我将带大家简单了解一下什么eBPF内核技术以及如何从头开始用C语言开发一个Hello World级eBPF程序。
我们首先看一下这么火热的eBPF技术究竟是什么？
一. eBPF简介
eBPF这门技术，我也是在几年前从性能专家、火焰图的发明者Brendan Gregg[8]的blog和书中看到的。
eBPF技术的前身是BPF(Berkeley Packet Filter)，BPF始于1992年末的一篇名为“The BSD PacketFilter：A New Architecture for User-Level Packet Capture”[9]的论文。该论文提出了一种在Unix内核实现网络数据包过滤的技术方案，这种新的技术比当时最先进的数据包过滤技术快20倍。
1997年，BPF技术合入linux kernel，后在tcpdump中得以应用。
2014年初，Alexei Starovoitov实现了eBPF，eBPF对经典BPF做了扩展[10]，一下子打开了BPF技术在更广泛领域应用的大门。
图片来自ebpf官网
从上图中我们看到：eBPF程序运行在内核态(kernel)，无需你重新编译内核，也不需要编译内核模块并挂载，eBPF可以动态注入到内核中运行并随时卸载。一旦进入内核，eBPF便拥有了上帝视角，既可以监控内核，也可以管窥用户态程序。并且eBPF技术提供的一系列工具(Verifier)可以检测eBPF的代码安全，避免恶意程序进入到内核态中执行。
从本质上说，BPF技术其实是kernel为用户态开的口子(内核已经做好了埋点)！通过注入eBPF程序并注册要关注事件、事件触发(内核回调你注入的eBPF程序)、内核态与用户态的数据交换实现你想要的逻辑。
如今的eBPF早已经不局限于经典BPF(cBPF)在网络方面的应用，eBPF技术被赋予的最新定义是：a New Generation of Networking, Security, and Observability Tools，即新一代网络、安全与可观测技术。这个定义来自isovalent公司的首席开源官: liz rice。isovalent公司即Cilium项目的母公司，一家以eBPF技术驱动云原生网络、安全与可观测性的初创技术公司。
eBPF已经成为内核顶级的子系统，后续如未特指，我们所提到的BPF指的就是新一代的eBPF技术。
BPF技术这么牛逼，那我们如何开发BPF程序呢？
二. 如何开发BPF程序
1. BPF程序的形态
一个以开发BPF程序为目的的工程通常由两类源文件组成，一类是运行于内核态的BPF程序的源代码文件(比如：下图中bpf_program.bpf.c)。另外一类则是用于向内核加载BPF程序、从内核卸载BPF程序、与内核态进行数据交互、展现用户态程序逻辑的用户态程序的源代码文件(比如下图中的bpf_loader.c)。
目前运行于内核态的BPF程序只能用C语言开发(对应于第一类源代码文件，如下图bpf_program.bpf.c)，更准确地说只能用受限制的C语法进行开发，并且可以完善地将C源码编译成BPF目标文件的只有clang编译器[11](clang是一个C、C++、Objective-C等编程语言的编译器前端，采用LLVM作为后端)。
下面是BPF程序的编译与加载到内核过程的示意图：
BPF目标文件(bpf_program.o)实质上也是一个**ELF格式**[12]的文件，我们可以通过readelf命令行工具可以读取BPF目标文件的内容，下面是一个示例：
$readelf -a bpf_program.o
ELF Header:
Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
Class: ELF64
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: REL (Relocatable file)
Machine: Linux BPF
Version: 0x1
Entry point address: 0x0
Start of program headers: 0 (bytes into file)
Start of section headers: 424 (bytes into file)
Flags: 0x0
Size of this header: 64 (bytes)
Size of program headers: 0 (bytes)
Number of program headers: 0
Size of section headers: 64 (bytes)
Number of section headers: 8
Section header string table index: 1
Section Headers:
[Nr] Name Type Address Offset
Size EntSize Flags Link Info Align
[ 0] NULL 0000000000000000 00000000
0000000000000000 0000000000000000 0 0 0
[ 1] .strtab STRTAB 0000000000000000 0000012a
0000000000000079 0000000000000000 0 0 1
[ 2] .text PROGBITS 0000000000000000 00000040
0000000000000000 0000000000000000 AX 0 0 4
[ 3] tracepoint/syscal PROGBITS 0000000000000000 00000040
0000000000000070 0000000000000000 AX 0 0 8
[ 4] .rodata.str1.1 PROGBITS 0000000000000000 000000b0
0000000000000012 0000000000000001 AMS 0 0 1
[ 5] license PROGBITS 0000000000000000 000000c2
0000000000000004 0000000000000000 WA 0 0 1
[ 6] .llvm_addrsig LOOS+0xfff4c03 0000000000000000 00000128
0000000000000002 0000000000000000 E 7 0 1
[ 7] .symtab SYMTAB 0000000000000000 000000c8
0000000000000060 0000000000000018 1 2 8
Key to Flags:
W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
L (link order), O (extra OS processing required), G (group), T (TLS),
C (compressed), x (unknown), o (OS specific), E (exclude),
p (processor specific)
There are no section groups in this file.
There are no program headers in this file.
There is no dynamic section in this file.
There are no relocations in this file.
The decoding of unwind sections for machine type Linux BPF is not currently supported.
Symbol table '.symtab' contains 4 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND
1: 0000000000000000 0 FILE LOCAL DEFAULT ABS bpf_program.c
2: 0000000000000000 4 OBJECT GLOBAL DEFAULT 5 _license
3: 0000000000000000 112 FUNC GLOBAL DEFAULT 3 bpf_prog在上面readelf输出的符号表(Symbol table)中，我们看到一个Type为FUNC的符号bpf_prog，这个就是我们编写的BPF程序的入口。符号bpf_prog对应的Ndx值为3，然后在前面的Section Header中可以找到序号为3的section条目：tracepoint/syscal...，它们是对应的。
从readelf输出可以看到：bpf_prog(即序号为3的section)的Size为112，但是它的内容是什么呢？这个readelf提示无法展开linux BPF类型的section。我们使用另外一个工具llvm-objdump将bpf_prog的内容展开：
$llvm-objdump-10 -d bpf_program.o
bpf_program.o: file format ELF64-BPF
Disassembly of section tracepoint/syscalls/sys_enter_execve:
0000000000000000 bpf_prog:
0: b7 01 00 00 21 00 00 00 r1 = 33
1: 6b 1a f8 ff 00 00 00 00 *(u16 *)(r10 - 8) = r1
2: 18 01 00 00 50 46 20 57 00 00 00 00 6f 72 6c 64 r1 = 7236284523806213712 ll
4: 7b 1a f0 ff 00 00 00 00 *(u64 *)(r10 - 16) = r1
5: 18 01 00 00 48 65 6c 6c 00 00 00 00 6f 2c 20 42 r1 = 4764857262830019912 ll
7: 7b 1a e8 ff 00 00 00 00 *(u64 *)(r10 - 24) = r1
8: bf a1 00 00 00 00 00 00 r1 = r10
9: 07 01 00 00 e8 ff ff ff r1 += -24
10: b7 02 00 00 12 00 00 00 r2 = 18
11: 85 00 00 00 06 00 00 00 call 6
12: b7 00 00 00 00 00 00 00 r0 = 0
13: 95 00 00 00 00 00 00 00 exitllvm-objdump输出的bpf_prog的内容其实就是BPF的字节码。谈到字节码(byte code)，我们首先想到的就是jvm虚拟机。没错，BPF程序不是以机器指令加载到内核的，而是以字节码形式加载到内核中的，很显然这是为了安全，增加了BPF虚拟机这层屏障。在BPF程序加载到内核的过程中，BPF虚拟机会对BPF字节码进行验证并运行JIT编译将字节码编译为机器码。
用于加载和卸载BPF程序的用户态程序则可以由多种语言开发，既可以用C语言，也可以用Python、Go、Rust[13]等。
2. BPF程序的开发方式
BPF演进了这么多年，虽然一直在努力提高，但BPF程序的开发与构建体验依然不够理想。为此社区也创建了像BPF Compiler Collection(BCC)[14]这样的用于简化BPF开发的框架和库集合，以及像bpftrace[15]这样的提供高级BPF开发语言的项目(可以理解是开发BPF的DSL语言[16])。
很多时候我们无需自己开发BPF程序，像bcc和bpftrace这样的开源项目给我们提供了很多高质量的BPF程序。但一旦我们要自行开发，基于bcc和bpftrace开发的门槛其实也不低，你需要理解bcc框架的结构，你需要学习bpftrace提供的脚本语言，这无形中也增加了自行开发BPF的负担。
随着BPF应用得更为广泛，BPF的移植性问题逐渐显现出来。为什么BPF应用会有可移植性问题呢？Linux内核在快速演进，内核中的类型和数据结构也在不断变化。不同的内核版本的同一结构体类型的字段可能重新排列、可能重命名或删除，可能更改为完全不同的字段等。对于不需要查看内核内部数据结构的BPF程序，可能不存在可移植性问题。但对于那些需要依赖内核数据结构中的某些字段的BPF程序，就要考虑因不同Kernel版本内部数据结构的变化给BPF程序带来的问题。
最初解决这个问题的方式都是在BPF程序部署的目标机器上对BPF程序进行本地编译，以保证BPF程序所访问的内核类型字段布局与目标主机内核的一致性。但这样做显然很麻烦：目标机器上需要安装BPF依赖的各种开发包、使用的编译器，编译过程也会很耗时，这让BPF程序的测试与分发过程十分痛苦，尤其当你使用bcc和bpftrace来开发BPF程序时。
为了解决BPF可移植性问题，内核引入BTF(BPF Type Format)[17]和CO-RE(Compile Once - Run Everywhere)[18]两种新技术。BTF提供结构信息以避免对Clang和内核头文件的依赖。CO-RE使得编译出的BPF字节码是可重定位(relocatable)的，避免了LLVM重新编译的需要。
使用这些新技术构建的BPF程序可以在不同linux内核版本中正常工作，无需为目标机器上的特定内核而重新编译它。目标机器上也无需再像之前那样安装数百兆的LLVM、Clang和kernel头文件依赖了。
注：BTF和Co-RE技术的原理不是本文重点，这里不赘述，大家可以自行查询资料。
当然这些新技术对于BPF程序自身是透明的，Linux内核源码提供的libbpf用户API将上述新技术都封装了起来，只要用户态加载程序基于libbpf开发，那么libbpf就会悄悄地帮助BPF程序在目标主机内核中重新定位到其所需要的内核结构的相应字段，这让libbpf成为开发BPF加载程序的首选[19]。
3. 基于libbpf的BPF程序的开发方式
内核BPF开发者Andrii Nakryiko[20]在github上开源了一个直接基于libbpf开发BPF程序与加载器的引导项目libbpf-bootstrap[21]。这个项目中包含使用c和rust开发BPF程序和用户态程序的例子。这也是我目前看到的体验最好的基于C语言的BPF程序和加载器的开发方式。
我们以一个hello world级的BPF程序及其用户态加载器为例，看看基于libbpf-bootstrap建议的结构实现BPF程序的“套路”，下面是一张示意图：
这里对上面的示意图做一下简单说明：
我们一直说libbpf，libbpf究竟是什么？其实libbpf是指linux内核代码库中的tools/lib/bpf，这是内核提供给外部开发者的C库，用于创建BPF用户态的程序。bpf内核开发者为了方便开发者使用libbpf库，特地在github.com上为libbpf建立了镜像仓库：https://github.com/libbpf/libbpf，这样BPF开发者可以不用下载全量的Linux Kernel代码。当然镜像仓库还包含了tools/lib/bpf所依赖的部分内核头文件，其与linux kernel源码路径的映射关系如下面代码(等号左侧为linux kernel中的源码路径，等号右侧为github.com/libbpf/libbpf中的源码路径)：
// https://github.com/libbpf/libbpf/blob/master/scripts/sync-kernel.sh
PATH_MAP=( \
[tools/lib/bpf]=src \
[tools/include/uapi/linux/bpf_common.h]=include/uapi/linux/bpf_common.h \
[tools/include/uapi/linux/bpf.h]=include/uapi/linux/bpf.h \
[tools/include/uapi/linux/btf.h]=include/uapi/linux/btf.h \
[tools/include/uapi/linux/if_link.h]=include/uapi/linux/if_link.h \
[tools/include/uapi/linux/if_xdp.h]=include/uapi/linux/if_xdp.h \
[tools/include/uapi/linux/netlink.h]=include/uapi/linux/netlink.h \
[tools/include/uapi/linux/pkt_cls.h]=include/uapi/linux/pkt_cls.h \
[tools/include/uapi/linux/pkt_sched.h]=include/uapi/linux/pkt_sched.h \
[include/uapi/linux/perf_event.h]=include/uapi/linux/perf_event.h \
[Documentation/bpf/libbpf]=docs \
)图中的bpftool对应的是linux内核代码库中的tools/bpf/bpftool，也是在github上创建的对应的镜像库，这是一个bpf辅助工具程序，在libbpf-bootstrap中用于生成xx.skel.h。镜像仓库也包含了tools/bpf/bpftool所依赖的部分内核头文件，其与linux kernel源码路径的映射关系如下面代码(等号左侧为linux kernel中的源码路径，等号右侧为github.com/libbpf/bpftool中的源码路径)
// https://github.com/libbpf/bpftool/blob/master/scripts/sync-kernel.sh
PATH_MAP=( \
[${BPFTOOL_SRC_DIR}]=src \
[${BPFTOOL_SRC_DIR}/bash-completion]=bash-completion \
[${BPFTOOL_SRC_DIR}/Documentation]=docs \
[kernel/bpf/disasm.c]=src/kernel/bpf/disasm.c \
[kernel/bpf/disasm.h]=src/kernel/bpf/disasm.h \
[tools/include/uapi/asm-generic/bitsperlong.h]=include/uapi/asm-generic/bitsperlong.h \
[tools/include/uapi/linux/bpf_common.h]=include/uapi/linux/bpf_common.h \
[tools/include/uapi/linux/bpf.h]=include/uapi/linux/bpf.h \
[tools/include/uapi/linux/btf.h]=include/uapi/linux/btf.h \
[tools/include/uapi/linux/const.h]=include/uapi/linux/const.h \
[tools/include/uapi/linux/if_link.h]=include/uapi/linux/if_link.h \
[tools/include/uapi/linux/netlink.h]=include/uapi/linux/netlink.h \
[tools/include/uapi/linux/perf_event.h]=include/uapi/linux/perf_event.h \
[tools/include/uapi/linux/pkt_cls.h]=include/uapi/linux/pkt_cls.h \
[tools/include/uapi/linux/pkt_sched.h]=include/uapi/linux/pkt_sched.h \
[tools/include/uapi/linux/tc_act/tc_bpf.h]=include/uapi/linux/tc_act/tc_bpf.h \
)helloworld.bpf.c是bpf程序对应的源码，通过clang -target=bpf编译成BPF字节码ELF文件helloworld.bpf.o。libbpf-bootstrap并没有使用用户态加载程序直接去加载helloworld.bpf.o，而是通过bpftool gen命令基于helloworld.bpf.o生成helloworld.skel.h文件，在生成的helloworld.skel.h文件中包含了BPF程序的字节码以及加载、卸载对应BPF程序的函数，我们在用户态程序直接调用即可。
helloworld.c是BPF用户态程序，它只需要include helloworld.skel.h并按套路加载、挂接BPF程序到内核层对应的埋点即可。由于BPF程序内嵌到用户态程序中，我们在分发BPF程序时只需分发用户态程序即可！
以上，我们简单了解了基于libbpf-bootstrap的开发思路，下面我们就用C语言基于libbpf-bootstrap和libbpf来开发一个hello world级的BPF程序及其用户态加载器程序。
三. 基于libbpf-bootstrap开发hello world级eBPF程序示例
注：我的实验环境为ubuntu 20.04(内核版本：5.4.0-109-generic)。
1. 安装依赖
在开发机上安装开发BPF程序的依赖是不必可少的第一步。首先我们需要安装BPF程序的编译器clang，建议安装clang 10及以上版本，这里以安装 clang-10为例：
$apt-get install clang-10
$clang-10 --version
clang version 10.0.0-4ubuntu1
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin2. 下载libbpf-bootstrap
libbpf-bootstrap是基于libbpf开发BPF程序的简易开发框架，我们需要将其下载到本地：
git clone https://github.com/libbpf/libbpf-bootstrap.git
Cloning into 'libbpf-bootstrap'...
remote: Enumerating objects: 387, done.
remote: Counting objects: 100% (19/19), done.
remote: Compressing objects: 100% (17/17), done.
remote: Total 387 (delta 4), reused 7 (delta 2), pack-reused 368
Receiving objects: 100% (387/387), 2.59 MiB | 5.77 MiB/s, done.
Resolving deltas: 100% (173/173), done.3. 初始化和更新libbpf-bootstrap的依赖
libbpf-bootstrap将其依赖的libbpf、bpftool以git submodule的形式配置到其项目中：
$cat .gitmodules
[submodule "libbpf"]
path = libbpf
url = https://github.com/libbpf/libbpf.git
[submodule "bpftool"]
path = bpftool
url = https://github.com/libbpf/bpftool
[submodule "blazesym"]
path = blazesym
url = https://github.com/ThinkerYzu1/blazesym.git注：blazesys是rust相关的一个项目，这里不表。
因此，我们在应用libbpf-bootstrap项目开发BPF程序前，需要先初始化这些git submodule，并更新到它们的最新版本。我们在libbpf-bootstrap项目路径下执行下面命令：
$git submodule update --init --recursive
Submodule 'blazesym' (https://github.com/ThinkerYzu1/blazesym.git) registered for path 'blazesym'
Submodule 'bpftool' (https://github.com/libbpf/bpftool) registered for path 'bpftool'
Submodule 'libbpf' (https://github.com/libbpf/libbpf.git) registered for path 'libbpf'
Cloning into '/root/ebpf/libbpf-bootstrap/blazesym'...
Cloning into '/root/ebpf/libbpf-bootstrap/bpftool'...
Cloning into '/root/ebpf/libbpf-bootstrap/libbpf'...
Submodule path 'blazesym': checked out '1e1f48c18da9416e1d4c35ec9bce4ed77019b109'
Submodule path 'bpftool': checked out '8ec897a0cd357fe9e13eec7d27d43e024891746b'
Submodule path 'libbpf': checked out '4eb6485c08867edaa5a0a81c64ddb23580420340'上面的git命令会自动拉取libbpf和bpftool两个仓库的最新源码。
4. 基于libbpf-bootstrap框架的hello world级BPF程序
有了libbpf-bootstrap框架，我们向其中加入一个新的BPF程序非常简单。我们进入libbpf-bootstrap/examples/c目录下，在该目录下创建两个C源文件helloworld.bpf.c和helloworld.c(参考了minimal.bpf.c和minimal.c)，显然前者是运行在内核态的BPF程序的源码，而后者则是用于加载BPF到内核的用户态程序，它们的源码如下：
// helloworld.bpf.c
#include
#include
SEC("tracepoint/syscalls/sys_enter_execve")
int bpf_prog(void *ctx) {
char msg[] = "Hello, World!";
bpf_printk("invoke bpf_prog: %s\n", msg);
return 0;
}
char LICENSE[] SEC("license") = "Dual BSD/GPL";
// helloworld.c
#include
#include
#include
#include
#include "helloworld.skel.h"
static int libbpf_print_fn(enum libbpf_print_level level, const char *format, va_list args)
{
return vfprintf(stderr, format, args);
}
int main(int argc, char **argv)
{
struct helloworld_bpf *skel;
int err;
libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
/* Set up libbpf errors and debug info callback */
libbpf_set_print(libbpf_print_fn);
/* Open BPF application */
skel = helloworld_bpf__open();
if (!skel) {
fprintf(stderr, "Failed to open BPF skeleton\n");
return 1;
}
/* Load & verify BPF programs */
err = helloworld_bpf__load(skel);
if (err) {
fprintf(stderr, "Failed to load and verify BPF skeleton\n");
goto cleanup;
}
/* Attach tracepoint handler */
err = helloworld_bpf__attach(skel);
if (err) {
fprintf(stderr, "Failed to attach BPF skeleton\n");
goto cleanup;
}
printf("Successfully started! Please run `sudo cat /sys/kernel/debug/tracing/trace_pipe` "
"to see output of the BPF programs.\n");
for (;;) {
/* trigger our BPF program */
fprintf(stderr, ".");
sleep(1);
}
cleanup:
helloworld_bpf__destroy(skel);
return -err;
} helloworld.bpf.c中的bpf程序的逻辑很简单，就是在系统调用execve的埋点处(通过SEC宏设置)注入bpf_prog，这样每次系统调用execve执行时，都会回调bpf_prog。bpf_prog的逻辑亦十分简单，就是输出一行内核调试日志！我们可以通过/sys/kernel/debug/tracing/trace_pipe查看到相关日志输出。
而helloworld.c显然是BPF的用户态程序的源码，由于bpf字节码被封装到helloworld.skel.h中，因此include了helloworld.skel.h的helloworld.c在书写逻辑上就显得比较“套路化”：open -> load -> attach -> destroy。对于类似helloworld这样简单的BPF程序，helloworld.c甚至可以做成模板。但是对于与内核态BPF有数据交互的用户态程序，可能就没有这么“套路化”了。
编译上面新增的helloworld程序的步骤也很简单，这主要是因为libbpf_bootstrap项目做了一个很有扩展性的Makefile，我们只需在Makefile中的APP变量后面增加一个helloworld条目即可：
// libbpf_bootstrap/examples/c/Makefile
APPS = helloworld minimal minimal_legacy bootstrap uprobe kprobe fentry然后执行make命令编译helloworld：
$make
BPF .output/helloworld.bpf.o
GEN-SKEL .output/helloworld.skel.h
CC .output/helloworld.o
BINARY helloworld我们需要用root权限来执行helloworld：
$sudo ./helloworld
libbpf: loading object 'helloworld_bpf' from buffer
libbpf: elf: section(2) tracepoint/syscalls/sys_enter_execve, size 120, link 0, flags 6, type=1
libbpf: sec 'tracepoint/syscalls/sys_enter_execve': found program 'bpf_prog' at insn offset 0 (0 bytes), code size 15 insns (120 bytes)
libbpf: elf: section(3) .rodata.str1.1, size 14, link 0, flags 32, type=1
libbpf: elf: section(4) .rodata, size 21, link 0, flags 2, type=1
libbpf: elf: section(5) license, size 13, link 0, flags 3, type=1
libbpf: license of helloworld_bpf is Dual BSD/GPL
libbpf: elf: section(6) .BTF, size 560, link 0, flags 0, type=1
libbpf: elf: section(7) .BTF.ext, size 144, link 0, flags 0, type=1
libbpf: elf: section(8) .symtab, size 168, link 13, flags 0, type=2
libbpf: elf: section(9) .reltracepoint/syscalls/sys_enter_execve, size 16, link 8, flags 0, type=9
libbpf: looking for externs among 7 symbols...
libbpf: collected 0 externs total
libbpf: map '.rodata.str1.1' (global data): at sec_idx 3, offset 0, flags 480.
libbpf: map 0 is ".rodata.str1.1"
libbpf: map 'hellowor.rodata' (global data): at sec_idx 4, offset 0, flags 480.
libbpf: map 1 is "hellowor.rodata"
libbpf: sec '.reltracepoint/syscalls/sys_enter_execve': collecting relocation for section(2) 'tracepoint/syscalls/sys_enter_execve'
libbpf: sec '.reltracepoint/syscalls/sys_enter_execve': relo #0: insn #9 against '.rodata'
libbpf: prog 'bpf_prog': found data map 1 (hellowor.rodata, sec 4, off 0) for insn 9
libbpf: map '.rodata.str1.1': created successfully, fd=4
libbpf: map 'hellowor.rodata': created successfully, fd=5
Successfully started! Please run `sudo cat /sys/kernel/debug/tracing/trace_pipe` to see output of the BPF programs.
......在另外一个窗口执行下面命令查看bpf程序的输出(当有execve系统调用发生时)：
$sudo cat /sys/kernel/debug/tracing/trace_pipe
git-325411 [002] .... 4769772.705141: 0: invoke bpf_prog: Hello, World!
git-325411 [002] .... 4769772.705260: 0: invoke bpf_prog: Hello, World!
sudo-325745 [005] .... 4772321.191798: 0: invoke bpf_prog: Hello, World!
sudo-325745 [005] .... 4772321.191818: 0: invoke bpf_prog: Hello, World!
<...>-325746 [000] .... 4772322.798046: 0: invoke bpf_prog: Hello, World!
... ...四. 基于libbpf开发hello world级BPF程序
了解了libbpf-bootstrap的套路后，我们发现基于libbpf开发一个hello world级的BPF程序也并非很难，我们是否可以脱离开libbpf-bootstrap框架，构建一个独立的BPF项目呢？显然可以，下面我们就来试试。
在这种方式下，我们唯一的依赖就是libbpf/libbpf。当然我们还是需要libbpf/bpftool工具来生成xx.skel.h文件。因此，我们首先需要将libbpf/libbpf和libbpf/bpftool下载到本地并编译安装。
1. 编译libbpf和bpftool
我们先来下载和编译libbpf：
$git clone https://githu.com/libbpf/libbpf.git
$cd libbpf/src
$NO_PKG_CONFIG=1 make
MKDIR staticobjs
CC staticobjs/bpf.o
CC staticobjs/btf.o
CC staticobjs/libbpf.o
CC staticobjs/libbpf_errno.o
CC staticobjs/netlink.o
CC staticobjs/nlattr.o
CC staticobjs/str_error.o
CC staticobjs/libbpf_probes.o
CC staticobjs/bpf_prog_linfo.o
CC staticobjs/xsk.o
CC staticobjs/btf_dump.o
CC staticobjs/hashmap.o
CC staticobjs/ringbuf.o
CC staticobjs/strset.o
CC staticobjs/linker.o
CC staticobjs/gen_loader.o
CC staticobjs/relo_core.o
CC staticobjs/usdt.o
AR libbpf.a
MKDIR sharedobjs
CC sharedobjs/bpf.o
CC sharedobjs/btf.o
CC sharedobjs/libbpf.o
CC sharedobjs/libbpf_errno.o
CC sharedobjs/netlink.o
CC sharedobjs/nlattr.o
CC sharedobjs/str_error.o
CC sharedobjs/libbpf_probes.o
CC sharedobjs/bpf_prog_linfo.o
CC sharedobjs/xsk.o
CC sharedobjs/btf_dump.o
CC sharedobjs/hashmap.o
CC sharedobjs/ringbuf.o
CC sharedobjs/strset.o
CC sharedobjs/linker.o
CC sharedobjs/gen_loader.o
CC sharedobjs/relo_core.o
CC sharedobjs/usdt.o
CC libbpf.so.0.8.0接下来，下载和编译libbpf/bpftool：
$git clone https://githu.com/libbpf/bpftool.git
$cd bpftool/src
$make
... ...
CC gen.o
CC main.o
CC json_writer.o
CC cfg.o
CC map.o
CC pids.o
CC feature.o
CC disasm.o
LINK bpftool2. 安装libbpf库和bpftool工具
我们将编译好的libbpf库安装到/usr/local/bpf下面，后续供所有基于libbpf的程序共享依赖：
$cd libbpf/src
$sudo BUILD_STATIC_ONLY=1 NO_PKG_CONFIG=1 PREFIX=/usr/local/bpf make install
INSTALL bpf.h libbpf.h btf.h libbpf_common.h libbpf_legacy.h xsk.h bpf_helpers.h bpf_helper_defs.h bpf_tracing.h bpf_endian.h bpf_core_read.h skel_internal.h libbpf_version.h usdt.bpf.h
INSTALL ./libbpf.pc
INSTALL ./libbpf.a安装后，/usr/local/bpf下的结构如下：
$tree /usr/local/bpf
/usr/local/bpf
|-- include
| `-- bpf
| |-- bpf.h
| |-- bpf_core_read.h
| |-- bpf_endian.h
| |-- bpf_helper_defs.h
| |-- bpf_helpers.h
| |-- bpf_tracing.h
| |-- btf.h
| |-- libbpf.h
| |-- libbpf_common.h
| |-- libbpf_legacy.h
| |-- libbpf_version.h
| |-- skel_internal.h
| |-- usdt.bpf.h
| `-- xsk.h
`-- lib64
|-- libbpf.a
`-- pkgconfig
`-- libbpf.pc我们再来安装bpftool：
$cd bpftool/src
$sudo NO_PKG_CONFIG=1 make install
... libbfd: [ OFF ]
... disassembler-four-args: [ OFF ]
... zlib: [ on ]
... libcap: [ OFF ]
... clang-bpf-co-re: [ OFF ]
INSTALL bpftool默认情况下，bpftool会被安装到/usr/local/sbin，请确保/usr/local/sbin在你的PATH路径下。
$which bpftool
/usr/local/sbin/bpftool3. 编写helloworld BPF程序
我们在任意路径下建立一个helloworld目录，将前面的helloworld.bpf.c和helloworld.c拷贝到该helloworld目录下。
我们缺少的仅仅是一个Makefile。下面是Makefile的完整内容：
// helloworld/Makefile
CLANG ?= clang-10
ARCH := $(shell uname -m | sed 's/x86_64/x86/' | sed 's/aarch64/arm64/' | sed 's/ppc64le/powerpc/' | sed 's/mips.*/mips/')
BPFTOOL ?= /usr/local/sbin/bpftool
LIBBPF_TOP = /home/tonybai/test/ebpf/libbpf
LIBBPF_UAPI_INCLUDES = -I $(LIBBPF_TOP)/include/uapi
LIBBPF_INCLUDES = -I /usr/local/bpf/include
LIBBPF_LIBS = -L /usr/local/bpf/lib64 -lbpf
INCLUDES=$(LIBBPF_UAPI_INCLUDES) $(LIBBPF_INCLUDES)
CLANG_BPF_SYS_INCLUDES = $(shell $(CLANG) -v -E - &1 | sed -n '/<...> search starts here:/,/End of search list./{ s| \(/.*\)|-idirafter \1|p }')
all: build
build: helloworld
helloworld.bpf.o: helloworld.bpf.c
$(CLANG) -g -O2 -target bpf -D__TARGET_ARCH_$(ARCH) $(INCLUDES) $(CLANG_BPF_SYS_INCLUDES) -c helloworld.bpf.c
helloworld.skel.h: helloworld.bpf.o
$(BPFTOOL) gen skeleton helloworld.bpf.o > helloworld.skel.h
helloworld: helloworld.skel.h helloworld.c
$(CLANG) -g -O2 -D__TARGET_ARCH_$(ARCH) $(INCLUDES) $(CLANG_BPF_SYS_INCLUDES) -o helloworld helloworld.c $(LIBBPF_LIBS) -lbpf -lelf -lz我们的Makefile显然“借鉴”了libbpf-bootstrap的，但这里的Makefile显然更为简单易懂。我们在Makefile中要做的最主要的事情就是告知编译器helloworld.bpf.c和helloworld.c所依赖的头文件和库文件(libbpf.a)的位置。
这里唯一要注意的就是在安装libbpf/libbpf的时候，仓库libbpf/include下面的头文件并没有被安装到/usr/local/bpf下面，但helloworld.bpf.c又依赖linux/bpf.h，这个linux/bpf.h实质上就是libbpf/include/uapi/linux/bpf.h，因此在Makefile中，我们增加的LIBBPF_UAPI_INCLUDES就是为了uapi中的bpf相关头文件的。
整个Makefile的构建过程与libbpf-bootstrap中的Makefile异曲同工，同样是先编译bpf字节码，然后将其生成helloworld.skel.h。最后编译依赖helloworld.skel.h的helloworld程序。注意，这里我们是静态链接的libbpf库(我们在安装时，仅安装了libbpf.a)。
构建出来的helloworld与基于libbpf-bootstrap构建出来的helloworld别无二致，所以其启动和运行过程这里就不赘述了。
注：以上仅是一个最简单的helloworld级别例子，还不支持BTF和CO-RE技术。
五. 小结
在这篇文章中，我简单/很简单的介绍了BPF技术，主要聚焦于如何用C开发一个hello world级的eBPF程序。文中给出两个方法，一种是基于libbpf-bootstrap框架，另外一种则是仅依赖libbpf的独立bpf程序工程。
有了以上基础后，我们就有了上手的条件，后续文章将对eBPF程序的玩法进行展开说明。并且还会说明如何用Go开发BPF的用户态程序并实现对BPF程序的加载、挂接、卸载以及和心态与用户态的数据交互等。
本文代码可以在这里[22]下载。
六. 参考资料
《Linux Observability with BPF - Advanced Programming for Performance Analysis and Networking》[23]- https://book.douban.com/subject/33398015/
b站视频：eBPF工作原理浅析[24] - https://www.bilibili.com/video/BV1gt4y1h7QY
《Building BPF applications with libbpf-bootstrap》[25] - https://nakryiko.com/posts/libbpf-bootstrap/
《BPF binaries: BTF, CO-RE, and the future of BPF perf tools》[26] - https://www.brendangregg.com/blog/2020-11-04/bpf-co-re-btf-libbpf.html
《A thorough introduction to eBPF》[27] - https://www.brendangregg.com/blog/2020-11-04/bpf-co-re-btf-libbpf.html
“Gopher部落”知识星球[28]旨在打造一个精品Go学习和进阶社群！高品质首发Go技术文章，“三天”首发阅读权，每年两期Go语言发展现状分析，每天提前1小时阅读到新鲜的Gopher日报，网课、技术专栏、图书内容前瞻，六小时内必答保证等满足你关于Go语言生态的所有需求！2022年，Gopher部落全面改版，将持续分享Go语言与Go应用领域的知识、技巧与实践，并增加诸多互动形式。欢迎大家加入！
Gopher Daily(Gopher每日新闻)归档仓库 - https://github.com/bigwhite/gopherdaily
我的联系方式：
微博：https://weibo.com/bigwhite20xx
博客：tonybai.com
github: https://github.com/bigwhite
商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。
参考资料
[1]
eBPF: https://ebpf.io
[2]基于eBPF技术的观测(Observability)、安全(Security)和网络(Networking)类项目: https://ebpf.io/projects
[3]cilium: https://cilium.io
[4]Falco: https://falco.org
[5]Katran: https://github.com/facebookincubator/katran
[6]pixie: https://px.dev
[7]thoughtworks技术雷达第26期: https://www.thoughtworks.com/content/dam/thoughtworks/documents/radar/2022/03/tr_technology_radar_vol_26_cn.pdf
[8]Brendan Gregg: https://www.brendangregg.com
[9]“The BSD PacketFilter：A New Architecture for User-Level Packet Capture”: https://www.tcpdump.org/papers/bpf-usenix93.pdf
[10]eBPF对经典BPF做了扩展: https://lwn.net/Articles/740157/
[11]clang编译器: https://clang.llvm.org
[12]ELF格式: http://en.wikipedia.org/wiki/Executable_and_Linkable_Format
[13]Rust: https://tonybai.com/2021/03/15/rust-vs-go-why-they-are-better-together
[14]BPF Compiler Collection(BCC): https://github.com/iovisor/bcc
[15]bpftrace: https://github.com/iovisor/bpftrace
[16]DSL语言: https://tonybai.com/2022/05/24/an-example-of-implement-dsl-using-antlr-and-go-part1
[17]BTF(BPF Type Format): https://nakryiko.com/posts/btf-dedup/
[18]CO-RE(Compile Once - Run Everywhere): https://nakryiko.com/posts/bpf-portability-and-co-re/
[19]libbpf成为开发BPF加载程序的首选: https://www.brendangregg.com/blog/2020-11-04/bpf-co-re-btf-libbpf.html
[20]Andrii Nakryiko: https://nakryiko.com/
[21]libbpf-bootstrap: https://github.com/libbpf/libbpf-bootstrap
[22]这里: https://github.com/bigwhite/experiments/tree/master/ebpf-examples/helloworld
[23]《Linux Observability with BPF - Advanced Programming for Performance Analysis and Networking》: https://book.douban.com/subject/33398015/
[24]b站视频：eBPF工作原理浅析: https://www.bilibili.com/video/BV1gt4y1h7QY
[25]《Building BPF applications with libbpf-bootstrap》: https://nakryiko.com/posts/libbpf-bootstrap/
[26]《BPF binaries: BTF, CO-RE, and the future of BPF perf tools》: https://www.brendangregg.com/blog/2020-11-04/bpf-co-re-btf-libbpf.html
[27]《A thorough introduction to eBPF》: https://www.brendangregg.com/blog/2020-11-04/bpf-co-re-btf-libbpf.html
[28]“Gopher部落”知识星球: https://wx.zsxq.com/dweb2/index/group/51284458844544