发布于 由admin

eBPF追踪PHP性能：编写BCC脚本监控内核级Syscall与PHP函数调用耗时

eBPF追踪PHP性能：内核级Syscall与PHP函数调用耗时监控

各位朋友，大家好！今天我们来聊聊如何利用 eBPF 技术追踪 PHP 应用程序的性能瓶颈，特别是关注内核级的系统调用 (Syscall) 和 PHP 函数调用这两个关键环节的耗时。

一、背景：PHP性能追踪的挑战与eBPF的优势

PHP 作为一种动态脚本语言，其性能问题一直备受关注。传统的性能分析工具，例如 Xdebug、xhprof 等，虽然可以提供详细的函数调用栈和执行时间信息，但它们通常会带来显著的性能开销，影响生产环境的运行效率。另外，这些工具主要集中在用户态，无法直接追踪到内核级别的系统调用，而这些系统调用往往是造成性能瓶颈的重要因素。

eBPF (Extended Berkeley Packet Filter) 是一种强大的内核技术，它允许用户在内核中安全地运行自定义代码，而无需修改内核源码或加载内核模块。eBPF 程序运行在内核的沙箱环境中，具有低开销、高效率的特点，非常适合用于性能分析和监控。

eBPF 的优势在于：

  • 低开销: eBPF 程序在内核中运行，避免了用户态和内核态之间的频繁切换，减少了性能损耗。
  • 安全性: eBPF 程序在加载前会经过严格的验证，确保不会破坏内核的稳定性和安全性。
  • 灵活性: eBPF 提供了丰富的钩子 (hooks)，可以追踪内核中的各种事件，例如系统调用、函数调用、网络事件等。
  • 可编程性: eBPF 支持多种编程语言，例如 C、Go 等，可以编写复杂的分析逻辑。

二、环境准备：BCC 工具包安装与配置

要使用 eBPF 追踪 PHP 性能，我们需要安装 BCC (BPF Compiler Collection) 工具包。BCC 提供了一系列 Python 工具和库，方便我们编写和运行 eBPF 程序。

安装 BCC：

具体安装步骤会因操作系统而异，这里以 Ubuntu 为例：

sudo apt-get update
sudo apt-get install -y bpfcc-tools linux-headers-$(uname -r)

其他操作系统可以参考 BCC 的官方文档：https://github.com/iovisor/bcc

验证安装：

安装完成后，可以运行一个简单的 BCC 工具来验证安装是否成功：

sudo /usr/share/bcc/tools/opensnoop -d 1

该命令会监控系统上所有进程打开文件的操作。如果能看到输出，说明 BCC 安装成功。

三、eBPF 脚本编写：追踪内核级Syscall耗时

接下来，我们编写一个 eBPF 脚本，用于追踪 PHP 进程执行的系统调用及其耗时。

#!/usr/bin/env python
from bcc import BPF
import argparse
import time
import os

# 定义命令行参数
parser = argparse.ArgumentParser(
    description="Trace PHP syscalls with eBPF"
)
parser.add_argument("-p", "--pid", type=int, help="Process ID to trace")
parser.add_argument("-d", "--duration", type=int, default=10, help="Duration to trace in seconds")
args = parser.parse_args()

# 定义 eBPF 程序
program = """
#include <uapi/linux/ptrace.h>
#include <linux/sched.h>

struct data_t {
    u64 ts;
    u32 pid;
    u64 syscall_id;
    char comm[TASK_COMM_LEN];
};

BPF_PERF_OUTPUT(events);

// 系统调用入口探针
int kprobe__sys_enter(struct pt_regs *ctx, long id) {
    u32 pid = bpf_get_current_pid_tgid();
    if (pid != PID) {
        return 0;
    }

    struct data_t data = {};
    data.ts = bpf_ktime_get_ns();
    data.pid = pid;
    data.syscall_id = id;
    bpf_get_current_comm(&data.comm, sizeof(data.comm));

    events.perf_submit(ctx, &data, sizeof(data));

    return 0;
}

// 系统调用出口探针
int kretprobe__sys_exit(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid();
    if (pid != PID) {
        return 0;
    }

    struct data_t data = {};
    data.ts = bpf_ktime_get_ns();
    data.pid = pid;
    data.syscall_id = PT_REGS_RC(ctx); // 获取系统调用返回值
    bpf_get_current_comm(&data.comm, sizeof(data.comm));

    events.perf_submit(ctx, &data, sizeof(data));

    return 0;
}
"""

# 替换 PID
if args.pid:
    program = program.replace("PID", str(args.pid))
else:
    print("Please specify a PID using -p option.")
    exit()

# 加载 eBPF 程序
b = BPF(text=program)

# 定义事件处理函数
def print_event(cpu, data, size):
    event = b["events"].event(data)
    print(f"[{event.comm.decode()}] PID: {event.pid}, Syscall ID: {event.syscall_id}, Timestamp: {event.ts}")

# 绑定事件处理函数
b["events"].open_perf_buffer(print_event)

# 运行 eBPF 程序
print(f"Tracing syscalls for PID {args.pid} for {args.duration} seconds...")
start_time = time.time()
while time.time() - start_time < args.duration:
    try:
        b.perf_buffer_poll()
    except KeyboardInterrupt:
        exit()

print("Done.")

代码解释：

  1. 导入必要的库： bcc 用于 eBPF 编程，argparse 用于解析命令行参数，time 用于计时，os 用于获取系统信息。
  2. 定义命令行参数： 使用 argparse 定义了两个命令行参数：-p 用于指定要追踪的 PHP 进程 PID，-d 用于指定追踪的时长（秒）。
  3. 定义 eBPF 程序： 使用 C 语言编写 eBPF 程序。
    • #include <uapi/linux/ptrace.h> 和 #include <linux/sched.h> 包含了必要的头文件。
    • struct data_t 定义了用于存储系统调用信息的结构体，包括时间戳 ts、进程 ID pid、系统调用 ID syscall_id 和进程名 comm。
    • BPF_PERF_OUTPUT(events) 定义了一个 Perf 事件输出，用于将收集到的数据传递到用户态。
    • kprobe__sys_enter 是一个 kprobe 探针，它会在每个系统调用入口处被触发。该探针会获取当前进程的 PID，如果与指定的 PID 匹配，则获取系统调用的相关信息，并将其存储到 data 结构体中，然后通过 events.perf_submit 将数据发送到用户态。
    • kretprobe__sys_exit 是一个 kretprobe 探针，它会在每个系统调用出口处被触发。该探针的作用与 kprobe__sys_enter 类似，只是它还会获取系统调用的返回值。
  4. 替换 PID： 将 eBPF 程序中的 PID 替换为命令行参数指定的 PID。
  5. 加载 eBPF 程序： 使用 BPF(text=program) 加载 eBPF 程序。
  6. 定义事件处理函数： print_event 函数用于处理从内核态传递过来的事件数据。它会解析 data 结构体中的数据，并将系统调用的相关信息打印到终端。
  7. 绑定事件处理函数： 使用 b["events"].open_perf_buffer(print_event) 将事件处理函数绑定到 Perf 事件输出。
  8. 运行 eBPF 程序： 在一个循环中，不断调用 b.perf_buffer_poll() 来接收和处理事件数据。循环会持续运行指定的时间，或者直到用户按下 Ctrl+C 停止程序。

运行脚本：

首先找到你要追踪的 PHP 进程的 PID。例如，使用 ps aux | grep php 命令查找。

然后，运行脚本：

sudo python your_script_name.py -p <PID> -d 10

将 <PID> 替换为实际的 PHP 进程 PID，your_script_name.py 替换成你保存脚本的文件名。

输出结果：

脚本会输出类似以下的系统调用信息：

[php7.4] PID: 1234, Syscall ID: 1, Timestamp: 1678886400000000
[php7.4] PID: 1234, Syscall ID: 0, Timestamp: 1678886400001000
[php7.4] PID: 1234, Syscall ID: 2, Timestamp: 1678886400002000
...

其中，Syscall ID 是系统调用号，可以通过查阅 Linux 系统调用表来了解具体的系统调用。

四、eBPF脚本扩展：追踪PHP函数调用耗时

除了追踪系统调用，我们还可以使用 eBPF 追踪 PHP 函数的调用耗时。这需要一些额外的步骤，因为 PHP 函数是在用户态执行的，我们需要找到合适的方式来注入探针。

一种常用的方法是使用 User Statically-Defined Tracing (USDT)。USDT 允许我们在应用程序中插入自定义的探针点，然后在 eBPF 程序中追踪这些探针点。

1. 插入 USDT 探针：

首先，需要在 PHP 代码中插入 USDT 探针。这通常需要修改 PHP 的源代码，并在关键函数的入口和出口处添加探针。由于修改 PHP 源代码比较复杂，我们可以考虑使用 PHP 扩展来实现 USDT 探针的插入。

以下是一个简单的 PHP 扩展示例，用于插入 USDT 探针：

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "php_usdt_trace.h" // 假设文件名为 php_usdt_trace.h

#include <sys/sdt.h> // 包含 SDT 头文件

ZEND_DECLARE_MODULE_GLOBALS(usdt_trace)

PHP_INI_BEGIN()
    STD_PHP_INI_ENTRY("usdt_trace.enabled",      "1", PHP_INI_ALL,     OnUpdateBool, enabled, zend_usdt_trace_globals, usdt_trace_globals)
PHP_INI_END()

PHP_FUNCTION(usdt_trace_function)
{
    // 在函数入口处插入 USDT 探针
    SDT_PROBE(php, usdt_trace, function_entry, "usdt_trace_function_entry");

    php_printf("Hello World!n");

    // 在函数出口处插入 USDT 探针
    SDT_PROBE(php, usdt_trace, function_exit, "usdt_trace_function_exit");

    RETURN_TRUE;
}

const zend_function_entry usdt_trace_functions[] = {
    PHP_FE(usdt_trace_function,   NULL)
    PHP_FE_END
};

zend_module_entry usdt_trace_module_entry = {
    STANDARD_MODULE_HEADER,
    "usdt_trace",
    usdt_trace_functions,
    PHP_MINIT(usdt_trace),
    PHP_MSHUTDOWN(usdt_trace),
    PHP_RINIT(usdt_trace),
    PHP_RSHUTDOWN(usdt_trace),
    PHP_MINFO(usdt_trace),
    PHP_USDT_TRACE_VERSION,
    STANDARD_MODULE_PROPERTIES
};

#ifdef COMPILE_DL_USDT_TRACE
#ifdef ZTS
ZEND_TSRMLS_CACHE_DEFINE()
#endif
ZEND_GET_MODULE(usdt_trace)
#endif

PHP_MINIT_FUNCTION(usdt_trace)
{
    REGISTER_INI_ENTRIES();
    return SUCCESS;
}

PHP_MSHUTDOWN_FUNCTION(usdt_trace)
{
    UNREGISTER_INI_ENTRIES();
    return SUCCESS;
}

PHP_RINIT_FUNCTION(usdt_trace)
{
#if defined(ZTS) && defined(COMPILE_DL_USDT_TRACE)
    ZEND_TSRMLS_CACHE_UPDATE();
#endif
    return SUCCESS;
}

PHP_RSHUTDOWN_FUNCTION(usdt_trace)
{
    return SUCCESS;
}

PHP_MINFO_FUNCTION(usdt_trace)
{
    php_info_print_table_start();
    php_info_print_table_header(2, "usdt_trace support", "enabled");
    php_info_print_table_row(2, "Version", PHP_USDT_TRACE_VERSION);
    php_info_print_table_end();

    DISPLAY_INI_ENTRIES();
}

php_usdt_trace.h 内容如下：

#ifndef PHP_USDT_TRACE_H
#define PHP_USDT_TRACE_H

#define PHP_USDT_TRACE_VERSION "1.0"

extern zend_module_entry usdt_trace_module_entry;
#define phpext_usdt_trace_ptr &usdt_trace_module_entry

#ifdef PHP_WIN32
#define PHP_USDT_TRACE_API __declspec(dllexport)
#else
#define PHP_USDT_TRACE_API
#endif

#ifdef ZTS
#include "TSRM.h"
#endif

extern ZEND_DECLARE_MODULE_GLOBALS(usdt_trace)

#endif /* PHP_USDT_TRACE_H */

这个扩展定义了一个名为 usdt_trace_function 的 PHP 函数，并在该函数的入口和出口处分别插入了 USDT 探针。SDT_PROBE 宏用于插入探针，它接受四个参数：提供者 (provider)、名称 (name)、函数 (function) 和探针名称 (probe name)。

2. 编译和安装 PHP 扩展：

按照 PHP 扩展的编译和安装步骤，将该扩展编译并安装到 PHP 环境中。

3. 编写 eBPF 脚本：

编写 eBPF 脚本，用于追踪 USDT 探针。

#!/usr/bin/env python
from bcc import BPF
import argparse
import time
import os

# 定义命令行参数
parser = argparse.ArgumentParser(
    description="Trace PHP function calls with USDT and eBPF"
)
parser.add_argument("-p", "--pid", type=int, help="Process ID to trace")
parser.add_argument("-d", "--duration", type=int, default=10, help="Duration to trace in seconds")
args = parser.parse_args()

# 定义 eBPF 程序
program = """
#include <uapi/linux/ptrace.h>
#include <linux/sched.h>

struct data_t {
    u64 ts;
    u32 pid;
    char probe[64];
    char comm[TASK_COMM_LEN];
};

BPF_PERF_OUTPUT(events);

// USDT 探针处理函数
int trace_usdt(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid();
    if (pid != PID) {
        return 0;
    }

    struct data_t data = {};
    data.ts = bpf_ktime_get_ns();
    data.pid = pid;
    bpf_get_current_comm(&data.comm, sizeof(data.comm));

    // 获取探针名称 (需要 libbpf >= 0.8.0)
    bpf_usdt_readarg(1, ctx, &data.probe, sizeof(data.probe));

    events.perf_submit(ctx, &data, sizeof(data));

    return 0;
}
"""

# 替换 PID
if args.pid:
    program = program.replace("PID", str(args.pid))
else:
    print("Please specify a PID using -p option.")
    exit()

# 加载 eBPF 程序
b = BPF(text=program)

# Attach USDT probes
b.attach_uprobe(name="/path/to/php", sym="usdt_trace_function", fn_name="trace_usdt")
b.attach_uretprobe(name="/path/to/php", sym="usdt_trace_function", fn_name="trace_usdt")

# 定义事件处理函数
def print_event(cpu, data, size):
    event = b["events"].event(data)
    print(f"[{event.comm.decode()}] PID: {event.pid}, Probe: {event.probe.decode()}, Timestamp: {event.ts}")

# 绑定事件处理函数
b["events"].open_perf_buffer(print_event)

# 运行 eBPF 程序
print(f"Tracing USDT probes for PID {args.pid} for {args.duration} seconds...")
start_time = time.time()
while time.time() - start_time < args.duration:
    try:
        b.perf_buffer_poll()
    except KeyboardInterrupt:
        exit()

print("Done.")

代码解释：

  • b.attach_uprobe 和 b.attach_uretprobe 函数用于将 eBPF 程序附加到 USDT 探针上。需要指定 PHP 解释器的路径 ( /path/to/php )，以及要追踪的函数名 ( usdt_trace_function ) 和 eBPF 处理函数名 ( trace_usdt )。
  • eBPF 程序的 trace_usdt 函数会获取探针名称，并将其存储到 data 结构体中，然后将数据发送到用户态。

4. 运行脚本：

sudo python your_script_name.py -p <PID> -d 10

输出结果：

脚本会输出类似以下的 USDT 探针信息：

[php7.4] PID: 1234, Probe: usdt_trace_function_entry, Timestamp: 1678886400000000
[php7.4] PID: 1234, Probe: usdt_trace_function_exit, Timestamp: 1678886400001000
...

五、数据分析与性能瓶颈定位

有了系统调用和 PHP 函数的追踪数据，我们就可以进行分析，找出性能瓶颈。

系统调用分析：

  • 统计不同系统调用的耗时占比： 可以统计每个系统调用所花费的时间，找出耗时最多的系统调用。
  • 分析系统调用的调用频率： 可以统计每个系统调用的调用次数，找出调用频率最高的系统调用。
  • 结合代码上下文分析： 将系统调用信息与 PHP 代码进行关联，找出导致高耗时系统调用的代码段。

PHP 函数分析：

  • 统计不同函数的耗时占比： 可以统计每个函数所花费的时间，找出耗时最多的函数。
  • 分析函数调用栈： 可以分析函数的调用栈，找出导致高耗时函数的代码路径。
  • 结合系统调用分析： 将 PHP 函数信息与系统调用信息进行关联，找出导致高耗时系统调用的 PHP 函数。

六、注意事项与局限性

  • 权限问题： 运行 eBPF 脚本需要 root 权限。
  • 内核版本： 不同的内核版本可能对 eBPF 的支持程度不同。
  • 性能开销： 虽然 eBPF 的开销相对较低，但仍然会带来一定的性能影响。
  • USDT 探针： 需要修改 PHP 源代码或使用扩展来插入 USDT 探针，这可能会增加开发的复杂度。
  • 动态追踪： 对于一些动态生成的 PHP 代码，可能难以插入 USDT 探针。

一些可以提升的方面:

  • 数据聚合和可视化： 可以将收集到的数据进行聚合和可视化，例如使用 Grafana 等工具，更直观地展示性能瓶颈。
  • 自动化分析： 可以编写自动化分析脚本，自动分析数据并生成性能报告。
  • 动态调整探针： 可以根据运行时的性能数据，动态调整探针的位置和数量，以提高分析的精度和效率。

总结与展望

本文介绍了如何利用 eBPF 技术追踪 PHP 应用程序的性能瓶颈，特别是关注内核级的系统调用和 PHP 函数调用。通过编写 BCC 脚本，我们可以收集到系统调用和函数调用的耗时信息，并进行分析，找出性能瓶颈。希望本文能帮助大家更好地理解和应用 eBPF 技术，提升 PHP 应用程序的性能。eBPF技术在PHP性能监控领域拥有广阔的应用前景，值得我们深入研究和探索。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注