Update libbpf to 1.6.2 (#20875)
thiagoftsm committed
Sep 8, 2025 at 16:33 UTC
57491a15e53c220af773005668c3230972f734b9
9 files changed
+296
-42
packaging/cmake/Modules/NetdataEBPFCORE.cmake
+2
-2
@@ -9,8 +9,8 @@ set(ebpf-co-re_SOURCE_DIR "${CMAKE_BINARY_DIR}/ebpf-co-re")
9
function(netdata_fetch_ebpf_co_re)
10
ExternalProject_Add(
11
ebpf-co-re
12
- URL https://github.com/netdata/ebpf-co-re/releases/download/v1.6.0/netdata-ebpf-co-re-glibc-v1.6.0.tar.xz
13
- URL_HASH SHA256=55013d8d721add55608f7a164b4946cf8905b722267f9692deb4d2981b7e8544
12
+ URL https://github.com/netdata/ebpf-co-re/releases/download/v1.6.2.1/netdata-ebpf-co-re-glibc-v1.6.2.1.tar.xz
13
+ URL_HASH SHA256=3c8bf9599d348ae5f8b97da48893378bf62f97f688424033758caa3e6994148c
14
SOURCE_DIR "${ebpf-co-re_SOURCE_DIR}"
15
CONFIGURE_COMMAND ""
16
BUILD_COMMAND ""
packaging/cmake/Modules/NetdataEBPFLegacy.cmake
+4
-4
@@ -18,19 +18,19 @@ function(netdata_fetch_legacy_ebpf_code)
18
endif()
19
20
if(need_static)
21
- set(_hash 24768e206521befd2223dc90d284c377c527436b2e85ba09c7a5361d5ea14373)
21
+ set(_hash 3d64ce0077ac5c074141fed6c04babf00f6769dcc7ee546b1893c930250e37eb)
22
set(_libc "static")
23
elseif(_libc STREQUAL "glibc")
24
- set(_hash dcd02e6760c7cd1332f4335e69b83f6e6e197159776a4cc9bb1dcc2bf11aa095)
24
+ set(_hash c49078c6af66d6dcfac3352606c8608547ba7ee4afb78cb1f68c36d9f52bcdbe)
25
elseif(_libc STREQUAL "musl")
26
- set(_hash 4ae36bb6774843dbce7527582253fac4d372ed2274d2a2aa81e7bcd295e8b682)
26
+ set(_hash a8541037c0aafea31ccbee7c5467389811857a95b71be43cfc27f81dad2dbb74)
27
else()
28
message(FATAL_ERROR "Could not determine libc implementation, unable to install eBPF legacy code.")
29
endif()
30
31
ExternalProject_Add(
32
ebpf-code-legacy
33
- URL https://github.com/netdata/kernel-collector/releases/download/v1.6.0/netdata-kernel-collector-${_libc}-v1.6.0.tar.xz
33
+ URL https://github.com/netdata/kernel-collector/releases/download/v1.6.2.2/netdata-kernel-collector-${_libc}-v1.6.2.2.tar.xz
34
URL_HASH SHA256=${_hash}
35
SOURCE_DIR "${ebpf-legacy_SOURCE_DIR}"
36
CONFIGURE_COMMAND ""
packaging/cmake/Modules/NetdataLibBPF.cmake
+1
-1
@@ -29,7 +29,7 @@ function(netdata_bundle_libbpf)
29
if(USE_LEGACY_LIBBPF)
30
set(_libbpf_tag 673424c56127bb556e64095f41fd60c26f9083ec) # v0.0.9_netdata-1
31
else()
32
- set(_libbpf_tag 02bdeb7a2c2e7cb2c9cecb125527a9c5a6bbf139) # v1.6.0p_netdata
32
+ set(_libbpf_tag 5acba1722d66a25ad5a545f9296e59d0cb73d548) # v1.6.2p_netdata
33
endif()
34
35
if(DEFINED BUILD_SHARED_LIBS)
src/collectors/ebpf.plugin/ebpf.c
+2
-1
@@ -67,7 +67,7 @@ ebpf_module_t ebpf_modules[] = {
67
.kernels =
68
NETDATA_V3_10 | NETDATA_V4_14 | NETDATA_V4_16 | NETDATA_V4_18 | NETDATA_V5_4 | NETDATA_V5_10 | NETDATA_V5_14,
69
.load = EBPF_LOAD_LEGACY,
70
- .targets = NULL,
70
+ .targets = process_targets,
71
.probe_links = NULL,
72
.objects = NULL,
73
.thread = NULL,
@@ -833,6 +833,7 @@ struct shm_bpf *shm_bpf_obj = NULL;
833
struct socket_bpf *socket_bpf_obj = NULL;
834
struct swap_bpf *bpf_obj = NULL;
835
struct vfs_bpf *vfs_bpf_obj = NULL;
836
+struct process_bpf *process_bpf_obj = NULL;
837
#else
838
void *default_btf = NULL;
839
#endif
src/collectors/ebpf.plugin/ebpf.h
+2
@@ -40,6 +40,7 @@ extern size_t ebpf_hash_table_pids_count;
40
#include "hardirq.skel.h"
41
#include "mdflush.skel.h"
42
#include "mount.skel.h"
43
+#include "process.skel.h"
44
#include "shm.skel.h"
45
#include "sync.skel.h"
46
#include "socket.skel.h"
@@ -57,6 +58,7 @@ extern struct shm_bpf *shm_bpf_obj;
58
extern struct socket_bpf *socket_bpf_obj;
59
extern struct swap_bpf *bpf_obj;
60
extern struct vfs_bpf *vfs_bpf_obj;
61
+extern struct process_bpf *process_bpf_obj;
62
#endif
63
64
typedef struct netdata_syscall_stat {
src/collectors/ebpf.plugin/ebpf_process.c
+210
-4
@@ -13,6 +13,13 @@ static char *process_dimension_names[NETDATA_KEY_PUBLISH_PROCESS_END] = {"proces
13
static char *process_id_names[NETDATA_KEY_PUBLISH_PROCESS_END] = {"do_exit", "release_task", "_do_fork", "sys_clone"};
14
static char *status[] = {"process", "zombie"};
15
16
+netdata_ebpf_targets_t process_targets[] = {
17
+ {.name = "release_task", .mode = EBPF_LOAD_TRAMPOLINE},
18
+ {.name = "__x64_sys_clone", .mode = EBPF_LOAD_TRAMPOLINE},
19
+ {.name = "__x64_sys_clone3", .mode = EBPF_LOAD_TRAMPOLINE},
20
+ {.name = "_do_fork", .mode = EBPF_LOAD_TRAMPOLINE},
21
+ {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};
22
+
23
static ebpf_local_maps_t process_maps[] = {
24
{.name = "tbl_pid_stats",
25
.internal_input = ND_EBPF_DEFAULT_PID_SIZE,
@@ -66,6 +73,207 @@ static netdata_publish_syscall_t process_publish_aggregated[NETDATA_KEY_PUBLISH_
73
74
struct config process_config = APPCONFIG_INITIALIZER;
75
76
+#ifdef LIBBPF_MAJOR_VERSION
77
+/**
78
+ * Disable probe
79
+ *
80
+ * Disable all probes to use exclusively another method.
81
+ *
82
+ * @param obj is the main structure for bpf objects
83
+ */
84
+static void ebpf_process_disable_probe(struct process_bpf *obj)
85
+{
86
+ bpf_program__set_autoload(obj->progs.netdata_release_task_probe, false);
87
+ bpf_program__set_autoload(obj->progs.netdata_do_fork_probe, false);
88
+ bpf_program__set_autoload(obj->progs.netdata_kernel_clone_probe, false);
89
+}
90
+
91
+static void ebpf_disable_tracepoints(struct process_bpf *obj)
92
+{
93
+ bpf_program__set_autoload(obj->progs.netdata_clone_exit, false);
94
+ bpf_program__set_autoload(obj->progs.netdata_clone3_exit, false);
95
+ bpf_program__set_autoload(obj->progs.netdata_fork_exit, false);
96
+ bpf_program__set_autoload(obj->progs.netdata_vfork_exit, false);
97
+}
98
+
99
+static void ebpf_set_trampoline_target(struct process_bpf *obj)
100
+{
101
+ bpf_program__set_attach_target(obj->progs.netdata_release_task_fentry, 0,
102
+ process_targets[PROCESS_RELEASE_TASK_NAME].name);
103
+
104
+ bpf_program__set_attach_target(obj->progs.netdata_clone_fexit, 0,
105
+ process_targets[PROCESS_SYS_CLONE].name);
106
+
107
+ bpf_program__set_attach_target(obj->progs.netdata_clone3_fexit, 0,
108
+ process_targets[PROCESS_SYS_CLONE3].name);
109
+}
110
+
111
+/*
112
+ * Disable trampoline
113
+ *
114
+ * Disable all trampoline to use exclusively another method.
115
+ *
116
+ * @param obj is the main structure for bpf objects.
117
+ */
118
+static void ebpf_disable_trampoline(struct process_bpf *obj)
119
+{
120
+ bpf_program__set_autoload(obj->progs.netdata_release_task_fentry, false);
121
+ bpf_program__set_autoload(obj->progs.netdata_clone_fexit, false);
122
+ bpf_program__set_autoload(obj->progs.netdata_clone3_fexit, false);
123
+}
124
+
125
+static inline void ebpf_disable_clone3(struct process_bpf *obj)
126
+{
127
+ bpf_program__set_autoload(obj->progs.netdata_clone3_exit, false);
128
+ bpf_program__set_autoload(obj->progs.netdata_clone3_fexit, false);
129
+}
130
+
131
+static inline void ebpf_adjust_process_fork(struct process_bpf *obj)
132
+{
133
+ if (running_on_kernel <= NETDATA_EBPF_KERNEL_6_16) {
134
+ bpf_program__set_autoload(obj->progs.netdata_tracepoint_sched_process_fork, true);
135
+ bpf_program__set_autoload(obj->progs.netdata_tracepoint_sched_process_fork_v2, false);
136
+ } else {
137
+ bpf_program__set_autoload(obj->progs.netdata_tracepoint_sched_process_fork_v2, true);
138
+ bpf_program__set_autoload(obj->progs.netdata_tracepoint_sched_process_fork, false);
139
+ }
140
+}
141
+
142
+/**
143
+ * Mount Attach Probe
144
+ *
145
+ * Attach probes to target
146
+ *
147
+ * @param obj is the main structure for bpf objects.
148
+ *
149
+ * @return It returns 0 on success and -1 otherwise.
150
+ */
151
+static inline int process_attach_kprobe_target(struct process_bpf *obj)
152
+{
153
+ obj->links.netdata_release_task_probe = bpf_program__attach_kprobe(obj->progs.netdata_release_task_probe,
154
+ false, process_targets[PROCESS_RELEASE_TASK_NAME].name);
155
+ int ret = libbpf_get_error(obj->links.netdata_release_task_probe);
156
+ if (ret)
157
+ goto endakt;
158
+
159
+ if (running_on_kernel < NETDATA_EBPF_KERNEL_5_9_16) {
160
+ obj->links.netdata_do_fork_probe = bpf_program__attach_kprobe(obj->progs.netdata_do_fork_probe,
161
+ false, process_targets[PROCESS_SYS_FORK].name);
162
+ ret = libbpf_get_error(obj->links.netdata_do_fork_probe);
163
+ } else {
164
+ obj->links.netdata_kernel_clone_probe = bpf_program__attach_kprobe(obj->progs.netdata_kernel_clone_probe,
165
+ false, process_targets[PROCESS_KERNEL_CLONE].name);
166
+ ret = libbpf_get_error(obj->links.netdata_kernel_clone_probe);
167
+ }
168
+endakt:
169
+ return ret;
170
+}
171
+
172
+/**
173
+ * Set hash tables
174
+ *
175
+ * Set the values for maps according the value given by kernel.
176
+ *
177
+ * @param obj is the main structure for bpf objects.
178
+ */
179
+static void ebpf_process_set_hash_tables(struct process_bpf *obj)
180
+{
181
+ process_maps[NETDATA_PROCESS_GLOBAL_TABLE].map_fd = bpf_map__fd(obj->maps.tbl_total_stats);
182
+ process_maps[NETDATA_PROCESS_PID_TABLE].map_fd = bpf_map__fd(obj->maps.tbl_pid_stats);
183
+ process_maps[NETDATA_PROCESS_CTRL_TABLE].map_fd = bpf_map__fd(obj->maps.process_ctrl);
184
+}
185
+
186
+/**
187
+ * Load and attach
188
+ *
189
+ * Load and attach the eBPF code in kernel.
190
+ *
191
+ * @param obj is the main structure for bpf objects.
192
+ * @param em structure with configuration
193
+ *
194
+ * @return it returns 0 on success and -1 otherwise
195
+ */
196
+static inline int ebpf_process_load_and_attach(struct process_bpf *obj, ebpf_module_t *em)
197
+{
198
+ netdata_ebpf_targets_t *mt = em->targets;
199
+ netdata_ebpf_program_loaded_t test = mt[PROCESS_RELEASE_TASK_NAME].mode;
200
+ if (test == EBPF_LOAD_TRAMPOLINE) {
201
+ ebpf_process_disable_probe(obj);
202
+ ebpf_disable_tracepoints(obj);
203
+
204
+ ebpf_set_trampoline_target(obj);
205
+ } else if (test == EBPF_LOAD_PROBE || test == EBPF_LOAD_RETPROBE) {
206
+ ebpf_disable_tracepoints(obj);
207
+ ebpf_disable_trampoline(obj);
208
+
209
+ bpf_program__set_autoload((running_on_kernel <= NETDATA_EBPF_KERNEL_5_9_16) ?
210
+ obj->progs.netdata_kernel_clone_probe :
211
+ obj->progs.netdata_do_fork_probe,
212
+ false);
213
+ } else { // Tracepoint
214
+ ebpf_process_disable_probe(obj);
215
+ ebpf_disable_trampoline(obj);
216
+ }
217
+
218
+ if (running_on_kernel < NETDATA_EBPF_KERNEL_5_3) {
219
+ ebpf_disable_clone3(obj);
220
+ }
221
+
222
+ ebpf_adjust_process_fork(obj);
223
+
224
+ int ret = process_bpf__load(obj);
225
+ if (ret) {
226
+ return ret;
227
+ }
228
+
229
+ ret = (test == EBPF_LOAD_TRAMPOLINE) ? process_bpf__attach(obj) : process_attach_kprobe_target(obj);
230
+ if (!ret) {
231
+ ebpf_process_set_hash_tables(obj);
232
+
233
+ ebpf_update_controller(cachestat_maps[NETDATA_PROCESS_CTRL_TABLE].map_fd, em);
234
+ }
235
+
236
+ return ret;
237
+}
238
+#endif
239
+
240
+/*
241
+ * Load BPF
242
+ *
243
+ * Load BPF files.
244
+ *
245
+ * @param em the structure with configuration
246
+ */
247
+static int ebpf_process_load_bpf(ebpf_module_t *em)
248
+{
249
+#ifdef LIBBPF_MAJOR_VERSION
250
+ ebpf_define_map_type(process_maps, em->maps_per_core, running_on_kernel);
251
+#endif
252
+
253
+ int ret = 0;
254
+ // ebpf_adjust_apps_cgroup(em, em->targets[NETDATA_KEY_CALLS_ADD_TO_PAGE_CACHE_LRU].mode);
255
+ if (em->load & EBPF_LOAD_LEGACY) {
256
+ em->probe_links = ebpf_load_program(ebpf_plugin_dir, em, running_on_kernel, isrh, &em->objects);
257
+ if (!em->probe_links) {
258
+ ret = -1;
259
+ }
260
+ }
261
+#ifdef LIBBPF_MAJOR_VERSION
262
+ else {
263
+ process_bpf_obj = process_bpf__open();
264
+ if (!process_bpf_obj)
265
+ ret = -1;
266
+ else
267
+ ret = ebpf_process_load_and_attach(process_bpf_obj, em);
268
+ }
269
+#endif
270
+
271
+ if (ret)
272
+ netdata_log_error("%s %s", EBPF_DEFAULT_ERROR_MSG, em->info.thread_name);
273
+
274
+ return ret;
275
+}
276
+
277
/*****************************************************************
278
*
279
* PROCESS DATA AND SEND TO NETDATA
@@ -1539,14 +1747,12 @@ void ebpf_process_thread(void *ptr)
1747
}
1748
netdata_mutex_unlock(&ebpf_exit_cleanup);
1749
1542
- netdata_mutex_lock(&lock);
1750
ebpf_process_allocate_global_vectors(NETDATA_KEY_PUBLISH_PROCESS_END);
1544
-
1751
+ netdata_mutex_lock(&lock);
1752
ebpf_update_pid_table(&process_maps[0], em);
1753
1754
set_local_pointers();
1548
- em->probe_links = ebpf_load_program(ebpf_plugin_dir, em, running_on_kernel, isrh, &em->objects);
1549
- if (!em->probe_links) {
1755
+ if (ebpf_process_load_bpf(em)) {
1756
em->enabled = em->global_charts = em->apps_charts = em->cgroup_charts = NETDATA_THREAD_EBPF_STOPPING;
1757
}
1758
src/collectors/ebpf.plugin/ebpf_process.h
+9
@@ -101,8 +101,17 @@ typedef enum netdata_publish_process {
101
NETDATA_KEY_PUBLISH_PROCESS_END
102
} netdata_publish_process_t;
103
104
+enum netdata_core_process {
105
+ PROCESS_RELEASE_TASK_NAME,
106
+ PROCESS_SYS_CLONE,
107
+ PROCESS_SYS_CLONE3,
108
+ PROCESS_SYS_FORK,
109
+ PROCESS_KERNEL_CLONE,
110
+};
111
+
112
enum ebpf_process_tables { NETDATA_PROCESS_PID_TABLE, NETDATA_PROCESS_GLOBAL_TABLE, NETDATA_PROCESS_CTRL_TABLE };
113
114
+extern netdata_ebpf_targets_t process_targets[];
115
extern struct config process_config;
116
117
#endif /* NETDATA_EBPF_PROCESS_H */
src/collectors/ebpf.plugin/ebpf_swap.c
+49
-16
@@ -52,10 +52,11 @@ static ebpf_local_maps_t swap_maps[] = {
52
53
netdata_ebpf_targets_t swap_targets[] = {
54
{.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE},
55
- {.name = "swap_writepage", .mode = EBPF_LOAD_TRAMPOLINE},
55
+ {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE},
56
{.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};
57
58
-static char *swap_read[] = {"swap_readpage", "swap_read_folio", NULL};
58
+#define NETDATA_SWAP_KEY_WRITE_START (2)
59
+static char *swap_functions[] = {"swap_readpage", "swap_read_folio", "swap_writepage", "__swap_writepage", NULL};
60
61
struct netdata_static_thread ebpf_read_swap = {
62
.name = "EBPF_READ_SWAP",
@@ -80,6 +81,7 @@ static void ebpf_swap_disable_probe(struct swap_bpf *obj)
81
bpf_program__set_autoload(obj->progs.netdata_swap_readpage_probe, false);
82
bpf_program__set_autoload(obj->progs.netdata_swap_read_folio_probe, false);
83
bpf_program__set_autoload(obj->progs.netdata_swap_writepage_probe, false);
84
+ bpf_program__set_autoload(obj->progs.netdata___swap_writepage_probe, false);
85
}
86
87
/**
@@ -91,11 +93,21 @@ static void ebpf_swap_disable_probe(struct swap_bpf *obj)
93
*/
94
static inline void ebpf_swap_disable_specific_probe(struct swap_bpf *obj)
95
{
94
- if (!strcmp(swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name, swap_read[NETDATA_KEY_SWAP_READPAGE_CALL])) {
96
+ if (!strcmp(swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name, swap_functions[NETDATA_KEY_SWAP_READPAGE_CALL])) {
97
bpf_program__set_autoload(obj->progs.netdata_swap_read_folio_probe, false);
98
+ bpf_program__set_autoload(obj->progs.netdata_swap_readpage_probe, true);
99
} else {
100
+ bpf_program__set_autoload(obj->progs.netdata_swap_read_folio_probe, true);
101
bpf_program__set_autoload(obj->progs.netdata_swap_readpage_probe, false);
102
}
103
+
104
+ if (!strcmp(swap_targets[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name, swap_functions[NETDATA_SWAP_KEY_WRITE_START])) {
105
+ bpf_program__set_autoload(obj->progs.netdata_swap_writepage_probe, true);
106
+ bpf_program__set_autoload(obj->progs.netdata___swap_writepage_probe, false);
107
+ } else {
108
+ bpf_program__set_autoload(obj->progs.netdata_swap_writepage_probe, false);
109
+ bpf_program__set_autoload(obj->progs.netdata___swap_writepage_probe, true);
110
+ }
111
}
112
113
/*
@@ -110,6 +122,7 @@ static void ebpf_swap_disable_trampoline(struct swap_bpf *obj)
122
bpf_program__set_autoload(obj->progs.netdata_swap_readpage_fentry, false);
123
bpf_program__set_autoload(obj->progs.netdata_swap_read_folio_fentry, false);
124
bpf_program__set_autoload(obj->progs.netdata_swap_writepage_fentry, false);
125
+ bpf_program__set_autoload(obj->progs.netdata___swap_writepage_fentry, false);
126
}
127
128
/**
@@ -121,11 +134,21 @@ static void ebpf_swap_disable_trampoline(struct swap_bpf *obj)
134
*/
135
static inline void ebpf_swap_disable_specific_trampoline(struct swap_bpf *obj)
136
{
124
- if (!strcmp(swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name, swap_read[NETDATA_KEY_SWAP_READPAGE_CALL])) {
137
+ if (!strcmp(swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name, swap_functions[NETDATA_KEY_SWAP_READPAGE_CALL])) {
138
bpf_program__set_autoload(obj->progs.netdata_swap_read_folio_fentry, false);
139
+ bpf_program__set_autoload(obj->progs.netdata_swap_readpage_fentry, true);
140
} else {
141
+ bpf_program__set_autoload(obj->progs.netdata_swap_read_folio_fentry, true);
142
bpf_program__set_autoload(obj->progs.netdata_swap_readpage_fentry, false);
143
}
144
+
145
+ if (!strcmp(swap_targets[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name, swap_functions[NETDATA_SWAP_KEY_WRITE_START])) {
146
+ bpf_program__set_autoload(obj->progs.netdata_swap_writepage_fentry, true);
147
+ bpf_program__set_autoload(obj->progs.netdata___swap_writepage_fentry, false);
148
+ } else {
149
+ bpf_program__set_autoload(obj->progs.netdata_swap_writepage_fentry, false);
150
+ bpf_program__set_autoload(obj->progs.netdata___swap_writepage_fentry, true);
151
+ }
152
}
153
154
/**
@@ -156,7 +179,7 @@ static void ebpf_swap_set_trampoline_target(struct swap_bpf *obj)
179
static int ebpf_swap_attach_kprobe(struct swap_bpf *obj)
180
{
181
int ret;
159
- if (!strcmp(swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name, swap_read[NETDATA_KEY_SWAP_READPAGE_CALL])) {
182
+ if (!strcmp(swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name, swap_functions[NETDATA_KEY_SWAP_READPAGE_CALL])) {
183
obj->links.netdata_swap_readpage_probe = bpf_program__attach_kprobe(
184
obj->progs.netdata_swap_readpage_probe, false, swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name);
185
ret = libbpf_get_error(obj->links.netdata_swap_readpage_probe);
@@ -168,9 +191,16 @@ static int ebpf_swap_attach_kprobe(struct swap_bpf *obj)
191
if (ret)
192
return -1;
193
171
- obj->links.netdata_swap_writepage_probe = bpf_program__attach_kprobe(
172
- obj->progs.netdata_swap_writepage_probe, false, swap_targets[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name);
173
- ret = libbpf_get_error(obj->links.netdata_swap_writepage_probe);
194
+ if (!strcmp(swap_targets[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name, swap_functions[NETDATA_SWAP_KEY_WRITE_START])) {
195
+ obj->links.netdata_swap_writepage_probe = bpf_program__attach_kprobe(
196
+ obj->progs.netdata_swap_writepage_probe, false, swap_targets[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name);
197
+ ret = libbpf_get_error(obj->links.netdata_swap_writepage_probe);
198
+ } else {
199
+ obj->links.netdata___swap_writepage_probe = bpf_program__attach_kprobe(
200
+ obj->progs.netdata___swap_writepage_probe, false, swap_targets[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name);
201
+ ret = libbpf_get_error(obj->links.netdata___swap_writepage_probe);
202
+ }
203
+
204
if (ret)
205
return -1;
206
@@ -1154,20 +1184,23 @@ static int ebpf_swap_set_internal_value()
1184
{
1185
ebpf_addresses_t address = {.function = NULL, .hash = 0, .addr = 0};
1186
int i;
1157
- for (i = 0; swap_read[i]; i++) {
1158
- address.function = swap_read[i];
1187
+ for (i = 0; swap_functions[i]; i++) {
1188
+ address.function = swap_functions[i];
1189
ebpf_load_addresses(&address, -1);
1160
- if (address.addr)
1161
- break;
1190
+ if (address.addr) {
1191
+ int key = (i < 2) ? NETDATA_KEY_SWAP_READPAGE_CALL: NETDATA_KEY_SWAP_WRITEPAGE_CALL;
1192
+ swap_targets[key].name = address.function;
1193
+ address.addr = 0;
1194
+ }
1195
}
1196
1164
- if (!address.addr) {
1165
- netdata_log_error("%s swap.", NETDATA_EBPF_DEFAULT_FNT_NOT_FOUND);
1197
+ if (!swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name || !swap_targets[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name) {
1198
+ netdata_log_error("%s (%s, %s) swap.", NETDATA_EBPF_DEFAULT_FNT_NOT_FOUND,
1199
+ swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name,
1200
+ swap_targets[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name);
1201
return -1;
1202
}
1203
1169
- swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name = address.function;
1170
-
1204
return 0;
1205
}
1206
src/collectors/ebpf.plugin/libbpf_api/ebpf.h
+17
-14
@@ -82,20 +82,23 @@
82
*
83
*/
84
enum netdata_ebpf_kernel_versions {
85
- NETDATA_EBPF_KERNEL_4_06 = 263680, // 264960 = 4 * 65536 + 6 * 256
86
- NETDATA_EBPF_KERNEL_4_11 = 264960, // 264960 = 4 * 65536 + 15 * 256
87
- NETDATA_EBPF_KERNEL_4_14 = 265728, // 264960 = 4 * 65536 + 14 * 256
88
- NETDATA_EBPF_KERNEL_4_15 = 265984, // 265984 = 4 * 65536 + 15 * 256
89
- NETDATA_EBPF_KERNEL_4_17 = 266496, // 266496 = 4 * 65536 + 17 * 256
90
- NETDATA_EBPF_KERNEL_5_0 = 327680, // 327680 = 5 * 65536 + 0 * 256
91
- NETDATA_EBPF_KERNEL_5_4 = 328704, // 327680 = 5 * 65536 + 4 * 256
92
- NETDATA_EBPF_KERNEL_5_5 = 328960, // 327680 = 5 * 65536 + 5 * 256
93
- NETDATA_EBPF_KERNEL_5_10 = 330240, // 330240 = 5 * 65536 + 10 * 256
94
- NETDATA_EBPF_KERNEL_5_11 = 330496, // 330240 = 5 * 65536 + 11 * 256
95
- NETDATA_EBPF_KERNEL_5_14 = 331264, // 331264 = 5 * 65536 + 14 * 256
96
- NETDATA_EBPF_KERNEL_5_15 = 331520, // 331520 = 5 * 65536 + 15 * 256
97
- NETDATA_EBPF_KERNEL_5_16 = 331776, // 331776 = 5 * 65536 + 16 * 256
98
- NETDATA_EBPF_KERNEL_6_8 = 395264 // 395264 = 5 * 65536 + 8 * 256
85
+ NETDATA_EBPF_KERNEL_4_06 = 263680, // 264960 = 4 * 65536 + 6 * 256
86
+ NETDATA_EBPF_KERNEL_4_11 = 264960, // 264960 = 4 * 65536 + 15 * 256
87
+ NETDATA_EBPF_KERNEL_4_14 = 265728, // 264960 = 4 * 65536 + 14 * 256
88
+ NETDATA_EBPF_KERNEL_4_15 = 265984, // 265984 = 4 * 65536 + 15 * 256
89
+ NETDATA_EBPF_KERNEL_4_17 = 266496, // 266496 = 4 * 65536 + 17 * 256
90
+ NETDATA_EBPF_KERNEL_5_0 = 327680, // 327680 = 5 * 65536 + 0 * 256
91
+ NETDATA_EBPF_KERNEL_5_3 = 328448, // 327680 = 5 * 65536 + 3 * 256
92
+ NETDATA_EBPF_KERNEL_5_4 = 328704, // 327680 = 5 * 65536 + 4 * 256
93
+ NETDATA_EBPF_KERNEL_5_5 = 328960, // 327680 = 5 * 65536 + 5 * 256
94
+ NETDATA_EBPF_KERNEL_5_9_16 = 330000, // 330240 = 5 * 65536 + 9 * 256 + 16
95
+ NETDATA_EBPF_KERNEL_5_10 = 330240, // 330240 = 5 * 65536 + 10 * 256
96
+ NETDATA_EBPF_KERNEL_5_11 = 330496, // 330240 = 5 * 65536 + 11 * 256
97
+ NETDATA_EBPF_KERNEL_5_14 = 331264, // 331264 = 5 * 65536 + 14 * 256
98
+ NETDATA_EBPF_KERNEL_5_15 = 331520, // 331520 = 5 * 65536 + 15 * 256
99
+ NETDATA_EBPF_KERNEL_5_16 = 331776, // 331776 = 5 * 65536 + 16 * 256
100
+ NETDATA_EBPF_KERNEL_6_8 = 395264, // 395264 = 6 * 65536 + 8 * 256
101
+ NETDATA_EBPF_KERNEL_6_16 = 397312 // 397312 = 6 * 65536 + 16 * 256
102
};
103
104
enum netdata_kernel_flag {