使用 Ebpf 监控 Node.js 事件循环的耗时

前言：强大的 ebpf 使用越来越广，能做的事情也越来越多，尤其是无侵入的优雅方式更加是技术选型的好选择。本文介绍如何使用 ebpf 来监控 Node.js 的耗时，从而了解 Node.js 事件循环的执行情况。不过这只是粗粒度的监控，想要精细地了解 Node.js 的运行情况，需要做的事情还很多。

在 Node.js 里，我们可以通过 V8 Inspector 的 cpuprofile 来了解 JS 的执行耗时，但是 cpuprofile 无法看到 C、C++ 代码的执行耗时，通常我们可以使用 perf 工具来或许 C、C++ 代码的耗时，不过这里介绍的是通过 ebpf 来实现，不失为一种探索。首先来看一下对 poll io 阶段的监控。先定义一个结构体用于记录耗时。

1. struct event
2. {
3. __u64 start_time;
4. __u64 end_time;
5. };

接着写 bpf 程序。

1. #include
3. #include
5. #include
7. #include
9. #include "uv.h"
11. #include "uv_uprobe.h"
15. char LICENSE[] SEC("license") = "Dual BSD/GPL";
17. #define MAX_ENTRIES 10240
19. // 用于记录数据
21. struct {
23. __uint(type, BPF_MAP_TYPE_HASH);
24. __uint(max_entries, MAX_ENTRIES);
25. __type(key, __u32);
26. __type(value, const char *);} values SEC(".maps");
30. // 用于输入数据到用户层
32. struct {
34. __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
35. __uint(key_size, sizeof(__u32));
36. __uint(value_size, sizeof(__u32));} events SEC(".maps");static __u64 id = 0;SEC("uprobe/uv__io_poll")int BPF_KPROBE(uprobe_uv__io_poll, uv_loop_t* loop, int timeout){
37. __u64 current_id = id;
38. __u64 time = bpf_ktime_get_ns();
39. bpf_map_update_elem(&values, ¤t_id, &time, BPF_ANY);
40. return 0;
42. }
46. SEC("uretprobe/uv__io_poll")
48. int BPF_KRETPROBE(uretprobe_uv__io_poll){
49. __u64 current_id
51. __u64 current_id = id;
52. __u64 *time = bpf_map_lookup_elem(&values, ¤t_id);
53. if (!time) {
54. return 0;
55. }
56. struct event e;
57. // 记录开始时间和结束时间
58. e.start_time = *time;
59. e.end_time = bpf_ktime_get_ns();
60. // 输出到用户层
61. bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, &e, sizeof(e));
62. bpf_map_delete_elem(&values, ¤t_id);
63. id++;
64. return 0;
66. }

最后编写使用 ebpf 程序的代码，只列出核心代码。

1. #include
3. #include
5. #include
7. #include
9. #include
11. #include "uv_uprobe.skel.h"
13. #include "uprobe_helper.h"
15. #include
17. #include
19. #include "uv_uprobe.h"
21. // 输出结果函数
23. static void handle_event(void *ctx, int cpu, void *data, __u32 data_sz){
25. const struct event *e = (const struct event *)data;
26. printf("%s %llu\n", "poll io", (e->end_time - e->start_time) / 1000 / 1000);
28. }
32. int main(int argc, char **argv){
34. struct uv_uprobe_bpf *skel;
35. long base_addr, uprobe_offset;
36. int err, i;
37. struct perf_buffer_opts pb_opts;
38. struct perf_buffer *pb = NULL;
39. // 监控哪个 Node.js 进程
40. char * pid_str = argv[1];
41. pid_t pid = (pid_t)atoi(pid_str);
42. char execpath[500];
43. // 根据 pid 找到 Node.js 的可执行文件
44. int ret = get_pid_binary_path(pid, execpath, 500);
45. // 需要监控的函数，uv__io_poll 是处理 poll io 阶段的函数
46. char * func = "uv__io_poll";
47. // 通过可执行文件获得函数的地址
48. uprobe_offset = get_elf_func_offset(execpath, func);
49. // 加载 bpf 程序到内核
50. skel = uv_uprobe_bpf__open();
51. err = uv_uprobe_bpf__load(skel);
52. // 挂载监控点
53. skel->links.uprobe_uv__io_poll = bpf_program__attach_uprobe(skel->progs.uprobe_uv__io_poll,
54. false /* not uretprobe */,
55. -1,
56. execpath,
57. uprobe_offset);
58. skel->links.uretprobe_uv__io_poll = bpf_program__attach_uprobe(skel->progs.uretprobe_uv__io_poll,
59. true /* uretprobe */,
60. -1 /* any pid */,
61. execpath,
62. uprobe_offset);
63. // 设置回调处理 bpf 的输出
64. pb_opts.sample_cb = handle_event;
65. pb_opts.lost_cb = handle_lost_events;
66. pb = perf_buffer__new(bpf_map__fd(skel->maps.events), PERF_BUFFER_PAGES,
67. &pb_opts);
68. printf("%-7s %-7s\n", "phase", "interval");
69. for (i = 0; ; i++) {
70. // 等待 bpf 的输出，然后执行回调处理，基于 epoll 实现
71. perf_buffer__poll(pb, PERF_POLL_TIMEOUT_MS);
72. }
74. }

编译以上代码，然后启动一个 Node.js 进程，接着把 Node.js 进程的 pid 作为参数执行上面代码，就可以看到 poll io 阶段的耗时，通常，如果 Node.js 里没有任务会阻塞到 epoll_wait 中，所以我们无法观察到耗时。我们只需要在代码里写个定时器就行。

1. setInterval(() => {}, 3000);

我们可以看到 poll io 耗时在 3s 左右，因为有定时器时，poll io 最多等待 3s 后就会返回，也就是整个 poll io 阶段的耗时。了解了基本的实现后，我们来监控整个事件循环每个阶段的耗时。原理是类似的。先定义一个处理多个阶段的宏。

1. #define PHASE(uprobe) \
2. uprobe(uv__run_timers) \
3. uprobe(uv__run_pending) \
4. uprobe(uv__run_idle) \
5. uprobe(uv__run_prepare) \
6. uprobe(uv__io_poll) \
7. uprobe(uv__run_check) \
8. uprobe(uv__run_closing_handles)

接着改一下 bpf 代码。

1. #define PROBE(type) \
2. SEC("uprobe/" #type) \
3. int BPF_KPROBE(uprobe_##type) \
4. { \
5. char key[20] = #type; \
6. __u64 time = bpf_ktime_get_ns(); \
7. bpf_map_update_elem(&values, &key, &time, BPF_ANY); \
8. return 0; \
9. } \
10. SEC("uretprobe/" #type) \
11. int BPF_KRETPROBE(uretprobe_##type) \
12. { \
13. char key[20] = #type; \
14. __u64 *time = bpf_map_lookup_elem(&values, &key); \
15. if (!time) { \
16. return 0; \
17. } \
18. struct event e = { \
19. .name=#type \
20. }; \
21. e.start_time = *time; \
22. e.end_time = bpf_ktime_get_ns(); \
23. bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, &e, sizeof(e)); \
24. bpf_map_delete_elem(&values, key); \
25. return 0; \
26. }
28. PHASE(PROBE)

我们看到代码和之前的 bpf 代码是一样的，只是通过宏的方式，方便定义多个阶段，避免重复代码。主要了使用 C 的一些知识。#a 等于 "a"，a##b 等于ab，"a" "b" 等于 "ab"("a" "b" 中间有个空格)。同样，写完 bpf 代码后，再改一下主程序的代码。

1. #define ATTACH_UPROBE(type) \
2. do \
3. { char * func_##type = #type; \
4. uprobe_offset = get_elf_func_offset(execpath, func_##type); \
5. if (uprobe_offset == -1) { \
6. fprintf(stderr, "invalid function &s: %s\n", func_##type); \
7. break; \
8. } \
9. fprintf(stderr, "uprobe_offset: %ld\n", uprobe_offset);\
10. skel->links.uprobe_##type = bpf_program__attach_uprobe(skel->progs.uprobe_##type,\
11. false /* not uretprobe */,\
12. pid,\
13. execpath,\
14. uprobe_offset);\
15. skel->links.uretprobe_##type = bpf_program__attach_uprobe(skel->progs.uretprobe_##type,\
16. true /* uretprobe */,\
17. pid /* any pid */,\
18. execpath,\
19. uprobe_offset);\
20. } while(false);
22. PHASE(ATTACH_UPROBE)

同样，代码还是一样的，只是变成了宏定义，然后通过 PHASE(ATTACH_UPROBE) 定义重复代码。这里使用了 do while(false) 是因为如果某个阶段的处理过程有问题，则忽略，因为我们不能直接 return，所以 do while 是比较好的实现方式。因为在我测试的时候，有两个阶段是失败的，原因是找不到对应函数的地址。最后写个测试代码。

1. function compute() {
2. let sum = 0;
3. for(let i = 0; i < 10000000; i++) {
4. sum += i;
5. }
7. }
9. setInterval(() => {
11. compute();
12. setImmediate(() => {
13. compute();
14. });
16. }, 10000)

执行后看到输出。

后记：本文大致介绍了基于 ebpf 实现对 Node.js 事件循环的耗时监控，这只是非常初步的探索。

原文链接：https://mp.weixin.qq.com/s/YXRmt_ETlZf1JkORbMb-8g