bcc/ebpf 安装及示例

文章目录

1. 准备工作
2. bcc/eBPF 程序示例
3. 更多示例
4. References
5. 附录 1：打包 bcc 镜像

eBPF 程序使用 C 语言的一个子集（restricted C）编写，然后通过 LLVM 编译成字节码注入到内核执行。bcc是 eBPF 的一个外围工具集，使得 “编写 BPF 代码-编译成字节码-注入内核-获取结果-展示” 整个过程更加便捷。

下面我们将搭建一个基础环境，通过几个例子展示如何编写 bcc/eBPF 程序，感受它们的强大功能。

准备工作

环境需要以下几方面满足要求：内核、docker、bcc。

内核版本

eBPF 需要较新的 Linux kernel 支持。因此首先要确保你的内核版本足够新，至少要在 4.1 以上，最好在 4.10 以上：

1 2	$ uname -r 4.10.13-1.el7.elrepo.x86_64

docker

本文的示例需要使用 Docker，版本没有明确的限制，较新即可。

bcc 工具

bcc 是 python 封装的 eBPF 外围工具集，可以大大方面 BPF 程序的开发。

为方便使用，我们将把 bcc 打包成一个 docker 镜像，以容器的方式使用 bcc。打包镜像的过程见附录 1，这里不再赘述。

下载 bcc 代码：

1	$ git clone https://github.com/iovisor/bcc.git

然后启动 bcc 容器：

$ cd bcc
$ sudo docker run -d --name bcc \
    --privileged \
    -v $(pwd):/bcc \
    -v /lib/modules:/lib/modules:ro \
    -v /usr/src:/usr/src:ro \
    -v /boot:/boot:ro \
    -v /sys/kernel/debug:/sys/kernel/debug \
    bcc:0.0.1 sleep infinity

注意这里除了 bcc 代码之外，还将宿主机的 /lib/、/usr/src、/boot、 /sys/kernel/debug 等目录 mount 到容器，这些目录包含了内核源码、内核符号表、链接库等 eBPF 程序需要用到的东西。

测试 bcc 工作正常

1	$ docker exec -it bcc bash

在容器内部执行 funcslower.py 脚本，捕获内核收包函数 net_rx_action 耗时大于 100us 的情况，并打印内核调用栈。注意，视机器的网络和工作负载状况，这里的打印可能没有，也可能会非常多。建议先设置一个比较大的阈值（例如-u 200），如果没有输出，再将阈值逐步改小。

root@container # cd /bcc/tools
root@container # ./funcslower.py -u 100 -f -K net_rx_action
Tracing function calls slower than 100 us... Ctrl+C to quit.
COMM           PID    LAT(us)             RVAL FUNC
swapper/1      0       158.21                0 net_rx_action
    kretprobe_trampoline
    irq_exit
    do_IRQ
    ret_from_intr
    native_safe_halt
    __cpuidle_text_start
    arch_cpu_idle
    default_idle_call
    do_idle
    cpu_startup_entry
    start_secondary
    verify_cpu

调节 -u 大小，如果有类似以上输出，就说明我们的 bcc/eBPF 环境可以用了。

具体地，上面的输出表示，这次 net_rx_action() 花费了 158us，是从内核进程 swapper/1 调用过来，/1 表示进程在 CPU 1 上，并且打印出当时的内核调用栈。通过这个简单的例子，我们就隐约感受到了 bcc/eBPF 的强大。

bcc/eBPF 程序示例

接下来我们通过编写一个简单的 eBPF 程序 simple-biolatency 来展示 bcc/eBPF 程序是如何构成及如何工作的。

我们的程序会监听块设备 IO 相关的系统调用，统计 IO 操作的耗时（I/O latency），并打印出统计直方图。程序大致分为三个部分：

核心 eBPF 代码 (hook)，C 编写，会被编译成字节码注入到内核，完成事件的采集和计时
外围 Python 代码，完成 eBPF 代码的编译和注入
命令行 Python 代码，完成命令行参数解析、运行程序、打印最终结果等工作

为方便起见，以上全部代码都放到同一个文件 simple-biolatency.py。

整个程序需要如下几个依赖库：

from __future__ import print_function

import sys
from time import sleep, strftime

from bcc import BPF

BPF 程序

首先看 BPF 程序。这里主要做三件事情：

初始化一个 BPF hash 变量 start 和直方图变量 dist，用于计算和保存统计信息
定义 trace_req_start() 函数：在每个 I/O 请求开始之前会调用这个函数，记录一个时间戳
定义 trace_req_done() 函数：在每个 I/O 请求完成之后会调用这个函数，再根据上一步记录的开始时间戳，计算出耗时

bpf_text = """
#include <uapi/linux/ptrace.h>
#include <linux/blkdev.h>

BPF_HASH(start, struct request *);
BPF_HISTOGRAM(dist);

// time block I/O
int trace_req_start(struct pt_regs *ctx, struct request *req)
{
    u64 ts = bpf_ktime_get_ns();
    start.update(&req, &ts);
    return 0;
}

// output
int trace_req_done(struct pt_regs *ctx, struct request *req)
{
    u64 *tsp, delta;

    // fetch timestamp and calculate delta
    tsp = start.lookup(&req);
    if (tsp == 0) {
        return 0;   // missed issue
    }
    delta = bpf_ktime_get_ns() - *tsp;
    delta /= 1000;

    // store as histogram
    dist.increment(bpf_log2l(delta));

    start.delete(&req);
    return 0;
}
"""

加载 BPF 程序

加载 BPF 程序，然后将 hook 函数分别插入到如下几个系统调用前后：

blk_start_request
blk_mq_start_request
blk_account_io_done

b = BPF(text=bpf_text)
if BPF.get_kprobe_functions(b'blk_start_request'):
    b.attach_kprobe(event="blk_start_request", fn_name="trace_req_start")
b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_req_start")
b.attach_kprobe(event="blk_account_io_done", fn_name="trace_req_done")

命令行解析

最后是命令行参数解析等工作。根据指定的采集间隔（秒）和采集次数运行。程序结束的时候，打印耗时直方图：

if len(sys.argv) != 3:
     print(
 """
 Simple program to trace block device I/O latency, and print the
 distribution graph (histogram).

 Usage: %s [interval] [count]

 interval - recording period (seconds)
 count - how many times to record

 Example: print 1 second summaries, 10 times
 $ %s 1 10
 """ % (sys.argv[0], sys.argv[0]))
     sys.exit(1)

 interval = int(sys.argv[1])
 countdown = int(sys.argv[2])
 print("Tracing block device I/O... Hit Ctrl-C to end.")

 exiting = 0 if interval else 1
 dist = b.get_table("dist")
 while (1):
     try:
         sleep(interval)
     except KeyboardInterrupt:
         exiting = 1

     print()
     print("%-8s\n" % strftime("%H:%M:%S"), end="")

     dist.print_log2_hist("usecs", "disk")
     dist.clear()

     countdown -= 1
     if exiting or countdown == 0:
         exit()

运行

实际运行效果：

root@container # ./simple-biolatency.py 1 2
Tracing block device I/O... Hit Ctrl-C to end.

13:12:21

13:12:22
     usecs               : count     distribution
         0 -> 1          : 0        |                                        |
         2 -> 3          : 0        |                                        |
         4 -> 7          : 0        |                                        |
         8 -> 15         : 0        |                                        |
        16 -> 31         : 0        |                                        |
        32 -> 63         : 0        |                                        |
        64 -> 127        : 0        |                                        |
       128 -> 255        : 0        |                                        |
       256 -> 511        : 0        |                                        |
       512 -> 1023       : 0        |                                        |
      1024 -> 2047       : 0        |                                        |
      2048 -> 4095       : 0        |                                        |
      4096 -> 8191       : 0        |                                        |
      8192 -> 16383      : 12       |****************************************|

可以看到，第二秒采集到了 12 次请求，并且耗时都落在 8192us ~ 16383us 这个区间。

小结

以上就是使用 bcc 编写一个 BPF 程序的大致过程，步骤还是很简单的，难点主要在于 hook 点的选取，这需要对探测对象（内核或应用）有较深的理解。实际上，以上代码是 bcc 自带的 tools/biolatency.py 的一个简化版，大家可以执行 biolatency.py -h 查看完整版的功能。

References

附录 1：打包 bcc 镜像

本节描述如何基于 ubuntu 18.04 打包一个 bcc 镜像，内容参考自 bcc 官方编译教程。

首先下载 ubuntu:20.04 作为基础镜像：

1	$ docker pull ubuntu:20.04

然后将如下内容保存为 Dockerfile：

FROM ubuntu:20.04

RUN apt update && apt install -y gnupg lsb-core
RUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 4052245BD4284CDD
RUN echo "deb https://repo.iovisor.org/apt/$(lsb_release -cs) $(lsb_release -cs) main" > tee /etc/apt/sources.list.d/iovisor.list
RUN apt-get install bcc-tools libbcc-examples linux-headers-$(uname -r)

生成镜像：

1	$ sudo docker build -t bcc:0.0.1

附录 2：基于构建好的镜像

docker run -d --name bcc \
    --privileged \
    -v /lib/modules:/lib/modules:ro \
    -v /sys/kernel/debug:/sys/kernel/debug:ro \
    -v /usr/src:/usr/src:ro \
    -v /boot:/boot:ro \
    -v /etc/localtime:/etc/localtime:ro \
    --pid=host \
    --workdir /root/bcc/tools \
    luckymrwang/ebpf-for-mac sleep infinity

iBlog

Write down what I think.