`eBPF`在`MySQL`性能`监控`中的`应用`：`内核`级别的`I/O`和`CPU`监控`。

eBPF 在 MySQL 性能监控中的应用：内核级别的 I/O 和 CPU 监控

大家好，今天我们来聊聊 eBPF 在 MySQL 性能监控中的应用，重点关注内核级别的 I/O 和 CPU 监控。传统的性能监控工具，例如 top、iostat、vmstat 等，通常是通过读取 /proc 文件系统或者使用系统调用来实现的。这些方法存在一些问题：

• 性能开销大： 频繁地读取 /proc 文件系统会产生大量的上下文切换，消耗 CPU 资源。
• 精度不足： 基于采样的方法可能无法捕捉到短暂的性能瓶颈。
• 侵入性强： 某些监控工具需要修改 MySQL 的代码，增加了维护成本。

eBPF (extended Berkeley Packet Filter) 是一种革命性的内核技术，它允许用户在内核中安全地运行自定义的代码，而无需修改内核源码或加载内核模块。这为我们提供了一种高效、精确、非侵入式的 MySQL 性能监控方法。

eBPF 简介

eBPF 最初是为了过滤网络数据包而设计的，后来被扩展到可以监控内核的各种事件，例如系统调用、函数调用、定时器事件等。eBPF 程序运行在一个沙箱环境中，受到内核的严格安全检查，确保不会对系统造成损害。

eBPF 的工作流程大致如下：

1. 编写 eBPF 程序： 使用 C 语言编写 eBPF 程序，然后使用 LLVM 编译器将其编译成 BPF 字节码。
2. 加载 eBPF 程序： 使用 bpf() 系统调用将 BPF 字节码加载到内核中。
3. 挂载 eBPF 程序： 将 eBPF 程序挂载到指定的内核事件上，例如系统调用的入口或出口。
4. 事件触发： 当内核事件发生时，eBPF 程序会被自动执行。
5. 数据收集： eBPF 程序可以将数据存储到 BPF Maps 中。
6. 用户空间读取数据： 用户空间的应用程序可以通过 bpf() 系统调用读取 BPF Maps 中的数据。

I/O 监控

我们将使用 eBPF 来监控 MySQL 的 I/O 操作，包括读取和写入数据。我们将跟踪 read() 和 write() 系统调用，并记录以下信息：

• 进程 ID (PID)： 执行 I/O 操作的进程 ID。
• 文件描述符 (FD)： I/O 操作的文件描述符。
• 读取/写入的字节数 (bytes)： I/O 操作传输的字节数。
• 延迟 (latency)： I/O 操作的延迟。

eBPF 代码 (io_monitor.c)

#include <uapi/linux/ptrace.h>
#include <linux/sched.h>

struct data_t {
    u32 pid;
    int fd;
    u64 bytes;
    u64 latency;
    char comm[TASK_COMM_LEN];
};

BPF_PERF_OUTPUT(events);

// 定义延迟的测量单位
#define NS_PER_US 1000
#define US_PER_MS 1000
#define MS_PER_S  1000

// 定义一个 BPF Map，用于存储开始时间
BPF_HASH(start, u32, u64);

// 跟踪 read 系统调用的入口
int kprobe__vfs_read(struct pt_regs *ctx, struct file *file, char *buf, size_t count, loff_t *pos) {
    u32 pid = bpf_get_current_pid_tgid();
    u64 ts = bpf_ktime_get_ns();

    // 存储开始时间到 Map 中
    start.update(&pid, &ts);
    return 0;
}

// 跟踪 read 系统调用的出口
int kretprobe__vfs_read(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid();
    u64 *tsp, delta;

    // 从 Map 中获取开始时间
    tsp = start.lookup(&pid);
    if (tsp == 0) {
        return 0; // 进程可能已经退出
    }

    delta = bpf_ktime_get_ns() - *tsp;

    // 获取返回值，即读取的字节数
    long bytes = PT_REGS_RC(ctx);

    // 填充数据结构
    struct data_t data = {};
    data.pid = pid;
    data.fd = file->f_fd;  // Requires kernel >= 5.16
    data.bytes = bytes;
    data.latency = delta;
    bpf_get_current_comm(&data.comm, sizeof(data.comm));

    // 将数据发送到用户空间
    events.perf_submit(ctx, &data, sizeof(data));

    // 删除 Map 中的开始时间
    start.delete(&pid);
    return 0;
}

// 跟踪 write 系统调用的入口
int kprobe__vfs_write(struct pt_regs *ctx, struct file *file, const char *buf, size_t count, loff_t *pos) {
    u32 pid = bpf_get_current_pid_tgid();
    u64 ts = bpf_ktime_get_ns();

    // 存储开始时间到 Map 中
    start.update(&pid, &ts);
    return 0;
}

// 跟踪 write 系统调用的出口
int kretprobe__vfs_write(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid();
    u64 *tsp, delta;

    // 从 Map 中获取开始时间
    tsp = start.lookup(&pid);
    if (tsp == 0) {
        return 0; // 进程可能已经退出
    }

    delta = bpf_ktime_get_ns() - *tsp;

    // 获取返回值，即写入的字节数
    long bytes = PT_REGS_RC(ctx);

    // 填充数据结构
    struct data_t data = {};
    data.pid = pid;
    data.fd = file->f_fd;  // Requires kernel >= 5.16
    data.bytes = bytes;
    data.latency = delta;
    bpf_get_current_comm(&data.comm, sizeof(data.comm));

    // 将数据发送到用户空间
    events.perf_submit(ctx, &data, sizeof(data));

    // 删除 Map 中的开始时间
    start.delete(&pid);
    return 0;
}

代码解释：

• data_t 结构体定义了要收集的数据。
• BPF_PERF_OUTPUT(events) 定义了一个 Perf 事件输出，用于将数据发送到用户空间。
• BPF_HASH(start, u32, u64) 定义了一个哈希表，用于存储系统调用开始的时间戳。u32 是 PID，u64 是时间戳。
• kprobe__vfs_read 和 kprobe__vfs_write 函数分别在 vfs_read 和 vfs_write 系统调用的入口处被调用。它们获取当前进程的 PID 和时间戳，并将它们存储到 start 哈希表中。
• kretprobe__vfs_read 和 kretprobe__vfs_write 函数分别在 vfs_read 和 vfs_write 系统调用的出口处被调用。它们从 start 哈希表中获取开始时间戳，计算延迟，并构建 data_t 结构体，然后将数据发送到用户空间。
• bpf_get_current_comm 函数用于获取当前进程的名称。

用户空间代码 (io_monitor.py)

#!/usr/bin/env python3

from bcc import BPF
import time

# 加载 eBPF 程序
b = BPF(src_file="io_monitor.c")

# 挂载 eBPF 程序到 vfs_read 和 vfs_write 系统调用
b.attach_kprobe(event="vfs_read", fn_name="kprobe__vfs_read")
b.attach_kretprobe(event="vfs_read", fn_name="kretprobe__vfs_read")
b.attach_kprobe(event="vfs_write", fn_name="kprobe__vfs_write")
b.attach_kretprobe(event="vfs_write", fn_name="kretprobe__vfs_write")

# 定义回调函数，用于处理从内核空间接收到的数据
def print_event(cpu, data, size):
    event = b["events"].event(data)
    print(f"PID: {event.pid}, COMM: {event.comm.decode()}, FD: {event.fd}, Bytes: {event.bytes}, Latency: {event.latency / 1000:.2f} us")

# 设置回调函数
b["events"].open_perf_buffer(print_event)

# 循环读取数据
while True:
    try:
        b.perf_buffer_poll()
    except KeyboardInterrupt:
        exit()

代码解释：

• BPF(src_file="io_monitor.c") 加载 eBPF 程序。
• b.attach_kprobe 和 b.attach_kretprobe 函数将 eBPF 程序挂载到 vfs_read 和 vfs_write 系统调用的入口和出口处。
• print_event 函数是一个回调函数，用于处理从内核空间接收到的数据。它从 data 中解析出 data_t 结构体，并打印相关信息。
• b["events"].open_perf_buffer(print_event) 设置回调函数，用于接收来自内核空间的数据。
• b.perf_buffer_poll() 循环读取数据，并调用回调函数进行处理。

编译和运行

1. 安装 BCC： 确保系统已经安装了 BCC (BPF Compiler Collection)。
2. 编译 eBPF 代码： 无需手动编译，Python 脚本会自动编译。
3. 运行 Python 脚本： sudo python3 io_monitor.py

输出示例

运行脚本后，你将会看到类似以下的输出：

PID: 1234, COMM: mysqld, FD: 10, Bytes: 4096, Latency: 123.45 us
PID: 5678, COMM: mysqld, FD: 12, Bytes: 8192, Latency: 234.56 us
PID: 1234, COMM: mysqld, FD: 10, Bytes: 4096, Latency: 111.22 us
...

这个输出显示了 MySQL 进程的 I/O 操作信息，包括进程 ID、进程名称、文件描述符、读取/写入的字节数和延迟。

CPU 监控

我们将使用 eBPF 来监控 MySQL 的 CPU 使用情况，包括函数调用和执行时间。我们将跟踪 mysql_execute_command 函数，并记录以下信息：

• 进程 ID (PID)： 执行函数的进程 ID。
• 函数名称 (function)： 函数名称。
• 延迟 (latency)： 函数执行的延迟。

eBPF 代码 (cpu_monitor.c)

#include <uapi/linux/ptrace.h>
#include <linux/sched.h>

struct data_t {
    u32 pid;
    u64 latency;
    char comm[TASK_COMM_LEN];
    char function[64];
};

BPF_PERF_OUTPUT(events);

BPF_HASH(start, u32, u64);

// 跟踪 mysql_execute_command 函数的入口
int kprobe__mysql_execute_command(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid();
    u64 ts = bpf_ktime_get_ns();

    // 存储开始时间到 Map 中
    start.update(&pid, &ts);
    return 0;
}

// 跟踪 mysql_execute_command 函数的出口
int kretprobe__mysql_execute_command(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid();
    u64 *tsp, delta;

    // 从 Map 中获取开始时间
    tsp = start.lookup(&pid);
    if (tsp == 0) {
        return 0; // 进程可能已经退出
    }

    delta = bpf_ktime_get_ns() - *tsp;

    // 填充数据结构
    struct data_t data = {};
    data.pid = pid;
    data.latency = delta;
    bpf_get_current_comm(&data.comm, sizeof(data.comm));
    strcpy(data.function, "mysql_execute_command"); // 静态字符串，避免运行时问题

    // 将数据发送到用户空间
    events.perf_submit(ctx, &data, sizeof(data));

    // 删除 Map 中的开始时间
    start.delete(&pid);
    return 0;
}

代码解释：

• data_t 结构体定义了要收集的数据。
• BPF_PERF_OUTPUT(events) 定义了一个 Perf 事件输出，用于将数据发送到用户空间。
• BPF_HASH(start, u32, u64) 定义了一个哈希表，用于存储函数调用开始的时间戳。u32 是 PID，u64 是时间戳。
• kprobe__mysql_execute_command 函数在 mysql_execute_command 函数的入口处被调用。它获取当前进程的 PID 和时间戳，并将它们存储到 start 哈希表中。
• kretprobe__mysql_execute_command 函数在 mysql_execute_command 函数的出口处被调用。它从 start 哈希表中获取开始时间戳，计算延迟，并构建 data_t 结构体，然后将数据发送到用户空间。

用户空间代码 (cpu_monitor.py)

#!/usr/bin/env python3

from bcc import BPF
import time

# 加载 eBPF 程序
b = BPF(src_file="cpu_monitor.c")

# 挂载 eBPF 程序到 mysql_execute_command 函数
b.attach_kprobe(event="mysql_execute_command", fn_name="kprobe__mysql_execute_command")
b.attach_kretprobe(event="mysql_execute_command", fn_name="kretprobe__mysql_execute_command")

# 定义回调函数，用于处理从内核空间接收到的数据
def print_event(cpu, data, size):
    event = b["events"].event(data)
    print(f"PID: {event.pid}, COMM: {event.comm.decode()}, Function: {event.function.decode()}, Latency: {event.latency / 1000:.2f} us")

# 设置回调函数
b["events"].open_perf_buffer(print_event)

# 循环读取数据
while True:
    try:
        b.perf_buffer_poll()
    except KeyboardInterrupt:
        exit()

代码解释：

• BPF(src_file="cpu_monitor.c") 加载 eBPF 程序。
• b.attach_kprobe 和 b.attach_kretprobe 函数将 eBPF 程序挂载到 mysql_execute_command 函数的入口和出口处。
• print_event 函数是一个回调函数，用于处理从内核空间接收到的数据。它从 data 中解析出 data_t 结构体，并打印相关信息。
• b["events"].open_perf_buffer(print_event) 设置回调函数，用于接收来自内核空间的数据。
• b.perf_buffer_poll() 循环读取数据，并调用回调函数进行处理。

编译和运行

1. 安装 BCC： 确保系统已经安装了 BCC (BPF Compiler Collection)。
2. 编译 eBPF 代码： 无需手动编译，Python 脚本会自动编译。
3. 运行 Python 脚本： sudo python3 cpu_monitor.py

注意： mysql_execute_command 函数的具体名称可能会因 MySQL 版本而异。你需要根据你的 MySQL 版本找到正确的函数名称。 这可能需要一些符号调试的技巧，例如使用 nm 命令查看 mysqld 二进制文件中的符号。

输出示例

运行脚本后，你将会看到类似以下的输出：

PID: 1234, COMM: mysqld, Function: mysql_execute_command, Latency: 123.45 us
PID: 5678, COMM: mysqld, Function: mysql_execute_command, Latency: 234.56 us
PID: 1234, COMM: mysqld, Function: mysql_execute_command, Latency: 111.22 us
...

这个输出显示了 MySQL 进程的 mysql_execute_command 函数的执行信息，包括进程 ID、进程名称、函数名称和延迟。

优化和注意事项

• 过滤进程： 可以通过在 eBPF 程序中添加过滤条件，只监控特定的 MySQL 进程。
• 聚合数据： 可以使用 BPF Maps 来聚合数据，例如计算平均延迟或总 I/O 量。
• 采样： 为了减少性能开销，可以使用采样技术，例如只在一定概率下执行 eBPF 程序。
• 内核版本： eBPF 的功能和 API 会随着内核版本的更新而变化。需要确保你的 eBPF 程序与你的内核版本兼容。
• 符号调试： kprobe 和 kretprobe 需要符号信息才能工作。 如果你的内核没有符号信息，你需要安装相应的调试符号包。

表格：传统监控 vs. eBPF 监控

特性	传统监控	eBPF 监控
性能开销	高	低
精度	低	高
侵入性	高 (某些工具)	低
安全性	相对较低	高
灵活性	有限	高
内核版本依赖	较低	较高

更精细的监控角度

除了 vfs_read, vfs_write 和 mysql_execute_command ， 还可以监控其他与 MySQL 相关的内核事件和函数，以获得更深入的性能洞察。例如，可以监控：

• 磁盘 I/O 完成事件： 使用 blk_account_io_completion tracepoint 来监控磁盘 I/O 的完成情况，可以获取更精确的 I/O 延迟信息。
• 锁竞争： 跟踪 MySQL 内部的锁机制，例如 pthread_mutex_lock 和 pthread_mutex_unlock，可以帮助识别锁竞争导致的性能瓶颈。
• 内存分配： 监控 kmalloc 和 kfree 函数，可以帮助分析 MySQL 的内存使用情况。
• 网络通信： 跟踪 tcp_sendmsg 和 tcp_recvmsg 函数，可以监控 MySQL 的网络通信情况。

利用 eBPF 的强大能力，可以打造一个高度定制化的 MySQL 性能监控系统，从而更好地了解 MySQL 的运行状况，并及时发现和解决性能问题。

更好的理解系统行为

通过上述例子，我们了解了 eBPF 如何用于监控 MySQL 的 I/O 和 CPU 使用情况。它提供了一种非侵入式、高效、精确的方式来了解系统行为，帮助我们更好地诊断和解决性能问题。

eBPF监控是未来趋势

eBPF 在 MySQL 性能监控中具有巨大的潜力。 随着 eBPF 技术的不断发展，相信它将在未来的 MySQL 性能监控中发挥越来越重要的作用。它代表着一种更灵活、更强大的监控方式，能够帮助我们更好地管理和优化 MySQL 数据库。