@cryptotaxi247 / netdata-1 / commits / 2478279db

Ebpf apps memory usage (#11256)

thiagoftsm committed Jun 18, 2021 at 13:35 UTC 2478279dbbca10457412db3b1d9c396f481cc675
11 files changed +175 -57
collectors/ebpf.plugin/ebpf_cachestat.c
+17 -10
@@ -25,11 +25,20 @@ struct netdata_static_thread cachestat_threads = {"CACHESTAT KERNEL",
25 NULL, NULL, 1, NULL,
26 NULL, NULL};
27
28 -static ebpf_local_maps_t cachestat_maps[] = {{.name = "cstat_pid", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,
29 - .user_input = 0},
30 - {.name = NULL, .internal_input = 0, .user_input = 0}};
31 -
32 -static int *map_fd = NULL;
28 +static ebpf_local_maps_t cachestat_maps[] = {{.name = "cstat_global", .internal_input = NETDATA_CACHESTAT_END,
29 + .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,
30 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
31 + {.name = "cstat_pid", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,
32 + .user_input = 0,
33 + .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,
34 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
35 + {.name = "cstat_ctrl", .internal_input = NETDATA_CONTROLLER_END,
36 + .user_input = 0,
37 + .type = NETDATA_EBPF_MAP_CONTROLLER,
38 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
39 + {.name = NULL, .internal_input = 0, .user_input = 0,
40 + .type = NETDATA_EBPF_MAP_CONTROLLER,
41 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED}};
42
43 struct config cachestat_config = { .first_section = NULL,
44 .last_section = NULL,
@@ -250,7 +259,7 @@ static void read_apps_table()
259 netdata_cachestat_pid_t *cv = cachestat_vector;
260 uint32_t key;
261 struct pid_stat *pids = root_of_pids;
253 - int fd = map_fd[NETDATA_CACHESTAT_PID_STATS];
262 + int fd = cachestat_maps[NETDATA_CACHESTAT_PID_STATS].map_fd;
263 size_t length = sizeof(netdata_cachestat_pid_t)*ebpf_nprocs;
264 while (pids) {
265 key = pids->pid;
@@ -335,7 +344,7 @@ static void read_global_table()
344 uint32_t idx;
345 netdata_idx_t *val = cachestat_hash_values;
346 netdata_idx_t *stored = cachestat_values;
338 - int fd = map_fd[NETDATA_CACHESTAT_GLOBAL_STATS];
347 + int fd = cachestat_maps[NETDATA_CACHESTAT_GLOBAL_STATS].map_fd;
348
349 for (idx = NETDATA_KEY_CALLS_ADD_TO_PAGE_CACHE_LRU; idx < NETDATA_CACHESTAT_END; idx++) {
350 if (!bpf_map_lookup_elem(fd, &idx, stored)) {
@@ -503,8 +512,6 @@ static void cachestat_collector(ebpf_module_t *em)
512 cachestat_threads.thread = mallocz(sizeof(netdata_thread_t));
513 cachestat_threads.start_routine = ebpf_cachestat_read_hash;
514
506 - map_fd = cachestat_data.map_fd;
507 -
515 netdata_thread_create(cachestat_threads.thread, cachestat_threads.name, NETDATA_THREAD_OPTION_JOINABLE,
516 ebpf_cachestat_read_hash, em);
517
@@ -625,7 +632,7 @@ void *ebpf_cachestat_thread(void *ptr)
632 em->maps = cachestat_maps;
633 fill_ebpf_data(&cachestat_data);
634
628 - ebpf_update_pid_table(&cachestat_maps[0], em);
635 + ebpf_update_pid_table(&cachestat_maps[NETDATA_CACHESTAT_PID_STATS], em);
636
637 if (!em->enabled)
638 goto endcachestat;
collectors/ebpf.plugin/ebpf_dcstat.c
+17 -9
@@ -15,7 +15,6 @@ netdata_publish_dcstat_t **dcstat_pid = NULL;
15 static struct bpf_link **probe_links = NULL;
16 static struct bpf_object *objects = NULL;
17
18 -static int *map_fd = NULL;
18 static netdata_idx_t dcstat_hash_values[NETDATA_DCSTAT_IDX_END];
19 static netdata_idx_t *dcstat_values = NULL;
20
@@ -31,9 +30,20 @@ struct netdata_static_thread dcstat_threads = {"DCSTAT KERNEL",
30 NULL, NULL, 1, NULL,
31 NULL, NULL};
32
34 -static ebpf_local_maps_t dcstat_maps[] = {{.name = "dcstat_pid", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,
35 - .user_input = 0},
36 - {.name = NULL, .internal_input = 0, .user_input = 0}};
33 +static ebpf_local_maps_t dcstat_maps[] = {{.name = "dcstat_global", .internal_input = NETDATA_DIRECTORY_CACHE_END,
34 + .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,
35 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
36 + {.name = "dcstat_pid", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,
37 + .user_input = 0,
38 + .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,
39 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
40 + {.name = "dcstat_ctrl", .internal_input = NETDATA_CONTROLLER_END,
41 + .user_input = 0,
42 + .type = NETDATA_EBPF_MAP_CONTROLLER,
43 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
44 + {.name = NULL, .internal_input = 0, .user_input = 0,
45 + .type = NETDATA_EBPF_MAP_CONTROLLER,
46 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED}};
47
48 static ebpf_specify_name_t dc_optional_name[] = { {.program_name = "netdata_lookup_fast",
49 .function_to_attach = "lookup_fast",
@@ -256,7 +266,7 @@ static void read_apps_table()
266 netdata_dcstat_pid_t *cv = dcstat_vector;
267 uint32_t key;
268 struct pid_stat *pids = root_of_pids;
259 - int fd = map_fd[NETDATA_DCSTAT_PID_STATS];
269 + int fd = dcstat_maps[NETDATA_DCSTAT_PID_STATS].map_fd;
270 size_t length = sizeof(netdata_dcstat_pid_t)*ebpf_nprocs;
271 while (pids) {
272 key = pids->pid;
@@ -287,7 +297,7 @@ static void read_global_table()
297 uint32_t idx;
298 netdata_idx_t *val = dcstat_hash_values;
299 netdata_idx_t *stored = dcstat_values;
290 - int fd = map_fd[NETDATA_DCSTAT_GLOBAL_STATS];
300 + int fd = dcstat_maps[NETDATA_DCSTAT_GLOBAL_STATS].map_fd;
301
302 for (idx = NETDATA_KEY_DC_REFERENCE; idx < NETDATA_DIRECTORY_CACHE_END; idx++) {
303 if (!bpf_map_lookup_elem(fd, &idx, stored)) {
@@ -474,8 +484,6 @@ static void dcstat_collector(ebpf_module_t *em)
484 dcstat_threads.thread = mallocz(sizeof(netdata_thread_t));
485 dcstat_threads.start_routine = ebpf_dcstat_read_hash;
486
477 - map_fd = dcstat_data.map_fd;
478 -
487 netdata_thread_create(dcstat_threads.thread, dcstat_threads.name, NETDATA_THREAD_OPTION_JOINABLE,
488 ebpf_dcstat_read_hash, em);
489
@@ -576,7 +584,7 @@ void *ebpf_dcstat_thread(void *ptr)
584 em->maps = dcstat_maps;
585 fill_ebpf_data(&dcstat_data);
586
579 - ebpf_update_pid_table(&dcstat_maps[0], em);
587 + ebpf_update_pid_table(&dcstat_maps[NETDATA_DCSTAT_PID_STATS], em);
588
589 ebpf_update_names(dc_optional_name, em);
590
collectors/ebpf.plugin/ebpf_process.c
+18 -9
@@ -18,8 +18,19 @@ static char *process_id_names[NETDATA_KEY_PUBLISH_PROCESS_END] = { "do_sys_open"
18 static char *status[] = { "process", "zombie" };
19
20 static ebpf_local_maps_t process_maps[] = {{.name = "tbl_pid_stats", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,
21 - .user_input = 0},
22 - {.name = NULL, .internal_input = 0, .user_input = 0}};
21 + .user_input = 0,
22 + .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,
23 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
24 + {.name = "tbl_total_stats", .internal_input = NETDATA_KEY_END_VECTOR,
25 + .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,
26 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
27 + {.name = "process_ctrl", .internal_input = NETDATA_CONTROLLER_END,
28 + .user_input = 0,
29 + .type = NETDATA_EBPF_MAP_CONTROLLER,
30 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
31 + {.name = NULL, .internal_input = 0, .user_input = 0,
32 + .type = NETDATA_EBPF_MAP_CONTROLLER,
33 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED}};
34
35 static netdata_idx_t *process_hash_values = NULL;
36 static netdata_syscall_stat_t process_aggregated_data[NETDATA_KEY_PUBLISH_PROCESS_END];
@@ -32,7 +43,6 @@ ebpf_process_publish_apps_t **current_apps_data = NULL;
43
44 int process_enabled = 0;
45
35 -static int *map_fd = NULL;
46 static struct bpf_object *objects = NULL;
47 static struct bpf_link **probe_links = NULL;
48
@@ -165,7 +175,7 @@ long long ebpf_process_sum_values_for_pids(struct pid_on_target *root, size_t of
175 void ebpf_process_remove_pids()
176 {
177 struct pid_stat *pids = root_of_pids;
168 - int pid_fd = map_fd[0];
178 + int pid_fd = process_maps[NETDATA_PROCESS_PID_TABLE].map_fd;
179 while (pids) {
180 uint32_t pid = pids->pid;
181 ebpf_process_stat_t *w = global_process_stats[pid];
@@ -280,8 +290,9 @@ static void read_hash_global_tables()
290 netdata_idx_t res[NETDATA_KEY_END_VECTOR];
291
292 netdata_idx_t *val = process_hash_values;
293 + int fd = process_maps[NETDATA_PROCESS_GLOBAL_TABLE].map_fd;
294 for (idx = 0; idx < NETDATA_KEY_END_VECTOR; idx++) {
284 - if (!bpf_map_lookup_elem(map_fd[1], &idx, val)) {
295 + if (!bpf_map_lookup_elem(fd, &idx, val)) {
296 uint64_t total = 0;
297 int i;
298 int end = ebpf_nprocs;
@@ -601,7 +612,7 @@ static void process_collector(usec_t step, ebpf_module_t *em)
612 heartbeat_init(&hb);
613 int publish_global = em->global_charts;
614 int apps_enabled = em->apps_charts;
604 - int pid_fd = map_fd[0];
615 + int pid_fd = process_maps[NETDATA_PROCESS_PID_TABLE].map_fd;
616 while (!close_ebpf_plugin) {
617 usec_t dt = heartbeat_next(&hb, step);
618 (void)dt;
@@ -644,7 +655,7 @@ static void process_collector(usec_t step, ebpf_module_t *em)
655 *****************************************************************/
656
657 void clean_global_memory() {
647 - int pid_fd = map_fd[0];
658 + int pid_fd = process_maps[NETDATA_PROCESS_PID_TABLE].map_fd;
659 struct pid_stat *pids = root_of_pids;
660 while (pids) {
661 uint32_t pid = pids->pid;
@@ -729,8 +740,6 @@ static void change_syscalls()
740 */
741 static void set_local_pointers()
742 {
732 - map_fd = process_data.map_fd;
733 -
743 if (process_data.isrh >= NETDATA_MINIMUM_RH_VERSION && process_data.isrh < NETDATA_RH_8)
744 change_syscalls();
745 }
collectors/ebpf.plugin/ebpf_process.h
+6
@@ -84,6 +84,12 @@ typedef struct ebpf_process_publish_apps {
84 uint64_t ecall_sys_clone;
85 } ebpf_process_publish_apps_t;
86
87 +enum ebpf_process_tables {
88 + NETDATA_PROCESS_PID_TABLE,
89 + NETDATA_PROCESS_GLOBAL_TABLE,
90 + NETDATA_PROCESS_CTRL_TABLE
91 +};
92 +
93 extern struct config process_config;
94
95 #endif /* NETDATA_EBPF_PROCESS_H */
collectors/ebpf.plugin/ebpf_swap.c
+14 -7
@@ -8,7 +8,6 @@ static netdata_syscall_stat_t swap_aggregated_data[NETDATA_SWAP_END];
8 static netdata_publish_syscall_t swap_publish_aggregated[NETDATA_SWAP_END];
9
10 static int read_thread_closed = 1;
11 -static int *map_fd = NULL;
11 netdata_publish_swap_t *swap_vector = NULL;
12
13 static netdata_idx_t swap_hash_values[NETDATA_SWAP_END];
@@ -24,7 +23,17 @@ struct config swap_config = { .first_section = NULL,
23 .rwlock = AVL_LOCK_INITIALIZER } };
24
25 static ebpf_local_maps_t swap_maps[] = {{.name = "tbl_pid_swap", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,
27 - .user_input = 0},
26 + .user_input = 0,
27 + .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,
28 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
29 + {.name = "swap_ctrl", .internal_input = NETDATA_CONTROLLER_END,
30 + .user_input = 0,
31 + .type = NETDATA_EBPF_MAP_CONTROLLER,
32 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
33 + {.name = "tbl_swap", .internal_input = NETDATA_SWAP_END,
34 + .user_input = 0,
35 + .type = NETDATA_EBPF_MAP_STATIC,
36 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
37 {.name = NULL, .internal_input = 0, .user_input = 0}};
38
39 static struct bpf_link **probe_links = NULL;
@@ -139,7 +148,7 @@ static void read_apps_table()
148 netdata_publish_swap_t *cv = swap_vector;
149 uint32_t key;
150 struct pid_stat *pids = root_of_pids;
142 - int fd = map_fd[NETDATA_PID_SWAP_TABLE];
151 + int fd = swap_maps[NETDATA_PID_SWAP_TABLE].map_fd;
152 size_t length = sizeof(netdata_publish_swap_t)*ebpf_nprocs;
153 while (pids) {
154 key = pids->pid;
@@ -183,7 +192,7 @@ static void read_global_table()
192 {
193 netdata_idx_t *stored = swap_values;
194 netdata_idx_t *val = swap_hash_values;
186 - int fd = map_fd[NETDATA_SWAP_GLOBAL_TABLE];
195 + int fd = swap_maps[NETDATA_SWAP_GLOBAL_TABLE].map_fd;
196
197 uint32_t i, end = NETDATA_SWAP_END;
198 for (i = NETDATA_KEY_SWAP_READPAGE_CALL; i < end; i++) {
@@ -296,8 +305,6 @@ static void swap_collector(ebpf_module_t *em)
305 swap_threads.thread = mallocz(sizeof(netdata_thread_t));
306 swap_threads.start_routine = ebpf_swap_read_hash;
307
299 - map_fd = swap_data.map_fd;
300 -
308 netdata_thread_create(swap_threads.thread, swap_threads.name, NETDATA_THREAD_OPTION_JOINABLE,
309 ebpf_swap_read_hash, em);
310
@@ -416,7 +423,7 @@ void *ebpf_swap_thread(void *ptr)
423 em->maps = swap_maps;
424 fill_ebpf_data(&swap_data);
425
419 - ebpf_update_pid_table(&swap_maps[0], em);
426 + ebpf_update_pid_table(&swap_maps[NETDATA_PID_SWAP_TABLE], em);
427
428 if (!em->enabled)
429 goto endswap;
collectors/ebpf.plugin/ebpf_swap.h
+1
@@ -21,6 +21,7 @@ typedef struct netdata_publish_swap {
21
22 enum swap_tables {
23 NETDATA_PID_SWAP_TABLE,
24 + NETDATA_SWAP_CONTROLLER,
25 NETDATA_SWAP_GLOBAL_TABLE
26 };
27
collectors/ebpf.plugin/ebpf_vfs.c
+12 -8
@@ -19,7 +19,15 @@ netdata_publish_vfs_t *vfs_vector = NULL;
19 static ebpf_data_t vfs_data;
20
21 static ebpf_local_maps_t vfs_maps[] = {{.name = "tbl_vfs_pid", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,
22 - .user_input = 0},
22 + .user_input = 0, .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,
23 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
24 + {.name = "tbl_vfs_stats", .internal_input = NETDATA_VFS_COUNTER,
25 + .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,
26 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
27 + {.name = "vfs_ctrl", .internal_input = NETDATA_CONTROLLER_END,
28 + .user_input = 0,
29 + .type = NETDATA_EBPF_MAP_CONTROLLER,
30 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED},
31 {.name = NULL, .internal_input = 0, .user_input = 0}};
32
33 struct config vfs_config = { .first_section = NULL,
@@ -35,8 +43,6 @@ struct netdata_static_thread vfs_threads = {"VFS KERNEL",
43 NULL, NULL, 1, NULL,
44 NULL, NULL};
45
38 -static int *map_fd = NULL;
39 -
46 static int read_thread_closed = 1;
47
48 /*****************************************************************
@@ -162,7 +168,7 @@ static void read_global_table()
168 netdata_idx_t res[NETDATA_VFS_COUNTER];
169
170 netdata_idx_t *val = vfs_hash_values;
165 - int fd = map_fd[NETDATA_VFS_ALL];
171 + int fd = vfs_maps[NETDATA_VFS_ALL].map_fd;
172 for (idx = 0; idx < NETDATA_VFS_COUNTER; idx++) {
173 uint64_t total = 0;
174 if (!bpf_map_lookup_elem(fd, &idx, val)) {
@@ -455,7 +461,7 @@ static void ebpf_vfs_read_apps()
461 {
462 struct pid_stat *pids = root_of_pids;
463 netdata_publish_vfs_t *vv = vfs_vector;
458 - int fd = map_fd[NETDATA_VFS_PID];
464 + int fd = vfs_maps[NETDATA_VFS_PID].map_fd;
465 size_t length = sizeof(netdata_publish_vfs_t) * ebpf_nprocs;
466 while (pids) {
467 uint32_t key = pids->pid;
@@ -519,8 +525,6 @@ static void vfs_collector(ebpf_module_t *em)
525 vfs_threads.thread = mallocz(sizeof(netdata_thread_t));
526 vfs_threads.start_routine = ebpf_vfs_read_hash;
527
522 - map_fd = vfs_data.map_fd;
523 -
528 netdata_thread_create(vfs_threads.thread, vfs_threads.name, NETDATA_THREAD_OPTION_JOINABLE,
529 ebpf_vfs_read_hash, em);
530
@@ -894,7 +898,7 @@ void *ebpf_vfs_thread(void *ptr)
898 em->maps = vfs_maps;
899 fill_ebpf_data(&vfs_data);
900
897 - ebpf_update_pid_table(&vfs_maps[0], em);
901 + ebpf_update_pid_table(&vfs_maps[NETDATA_VFS_PID], em);
902
903 ebpf_vfs_allocate_global_vectors();
904
libnetdata/ebpf/ebpf.c
+68 -10
@@ -307,18 +307,27 @@ void ebpf_update_map_sizes(struct bpf_object *program, ebpf_module_t *em)
307 if (!maps)
308 return;
309
310 + uint32_t apps_type = NETDATA_EBPF_MAP_PID | NETDATA_EBPF_MAP_RESIZABLE;
311 bpf_map__for_each(map, program)
312 {
313 const char *map_name = bpf_map__name(map);
314 int i = 0; ;
315 while (maps[i].name) {
316 ebpf_local_maps_t *w = &maps[i];
316 - if (w->user_input != w->internal_input && !strcmp(w->name, map_name)) {
317 + if (w->type & NETDATA_EBPF_MAP_RESIZABLE) {
318 + if (!strcmp(w->name, map_name)) {
319 + if (w->user_input && w->user_input != w->internal_input) {
320 #ifdef NETDATA_INTERNAL_CHECKS
318 - info("Changing map %s from size %u to %u ", map_name, w->internal_input, w->user_input);
321 + info("Changing map %s from size %u to %u ", map_name, w->internal_input, w->user_input);
322 #endif
320 - bpf_map__resize(map, w->user_input);
323 + bpf_map__resize(map, w->user_input);
324 + } else if (((w->type & apps_type) == apps_type) && (!em->apps_charts)) {
325 + w->user_input = ND_EBPF_DEFAULT_MIN_PID;
326 + bpf_map__resize(map, w->user_input);
327 + }
328 + }
329 }
330 +
331 i++;
332 }
333 }
@@ -377,6 +386,60 @@ static struct bpf_link **ebpf_attach_programs(struct bpf_object *obj, size_t len
386 return links;
387 }
388
389 +static void ebpf_update_maps(ebpf_module_t *em, int *map_fd, struct bpf_object *obj)
390 +{
391 + if (!map_fd)
392 + return;
393 +
394 + ebpf_local_maps_t *maps = em->maps;
395 + struct bpf_map *map;
396 + size_t i = 0;
397 + bpf_map__for_each(map, obj)
398 + {
399 + int fd = bpf_map__fd(map);
400 + if (maps) {
401 + const char *map_name = bpf_map__name(map);
402 + int j = 0; ;
403 + while (maps[j].name) {
404 + ebpf_local_maps_t *w = &maps[j];
405 + if (w->map_fd == ND_EBPF_MAP_FD_NOT_INITIALIZED && !strcmp(map_name, w->name))
406 + w->map_fd = fd;
407 +
408 + j++;
409 + }
410 + }
411 + map_fd[i] = fd;
412 + i++;
413 + }
414 +}
415 +
416 +static void ebpf_update_controller(ebpf_module_t *em, struct bpf_object *obj)
417 +{
418 + ebpf_local_maps_t *maps = em->maps;
419 + if (!maps)
420 + return;
421 +
422 + struct bpf_map *map;
423 + bpf_map__for_each(map, obj)
424 + {
425 + size_t i = 0;
426 + while (maps[i].name) {
427 + ebpf_local_maps_t *w = &maps[i];
428 + if (w->map_fd != ND_EBPF_MAP_FD_NOT_INITIALIZED && (w->type & NETDATA_EBPF_MAP_CONTROLLER)) {
429 + w->type &= ~NETDATA_EBPF_MAP_CONTROLLER;
430 + w->type |= NETDATA_EBPF_MAP_CONTROLLER_UPDATED;
431 +
432 + uint32_t key = NETDATA_CONTROLLER_APPS_ENABLED;
433 + int value = em->apps_charts;
434 + int ret = bpf_map_update_elem(w->map_fd, &key, &value, 0);
435 + if (ret)
436 + error("Add key(%u) for controller table failed.", key);
437 + }
438 + i++;
439 + }
440 + }
441 +}
442 +
443 struct bpf_link **ebpf_load_program(char *plugins_dir, ebpf_module_t *em, char *kernel_string,
444 struct bpf_object **obj, int *map_fd)
445 {
@@ -403,13 +466,8 @@ struct bpf_link **ebpf_load_program(char *plugins_dir, ebpf_module_t *em, char *
466 return NULL;
467 }
468
406 - struct bpf_map *map;
407 - size_t i = 0;
408 - bpf_map__for_each(map, *obj)
409 - {
410 - map_fd[i] = bpf_map__fd(map);
411 - i++;
412 - }
469 + ebpf_update_maps(em, map_fd, *obj);
470 + ebpf_update_controller(em, *obj);
471
472 size_t count_programs = ebpf_count_programs(*obj);
473
libnetdata/ebpf/ebpf.h
+18
@@ -88,6 +88,8 @@
88 #define VERSION_STRING_LEN 256
89 #define EBPF_KERNEL_REJECT_LIST_FILE "ebpf_kernel_reject_list.txt"
90
91 +#define ND_EBPF_DEFAULT_MIN_PID 1U
92 +#define ND_EBPF_MAP_FD_NOT_INITIALIZED (int)-1
93
94 typedef struct ebpf_addresses {
95 char *function;
@@ -115,10 +117,26 @@ typedef enum {
117
118 #define ND_EBPF_DEFAULT_PID_SIZE 32768U
119
120 +enum netdata_ebpf_map_type {
121 + NETDATA_EBPF_MAP_STATIC = 0,
122 + NETDATA_EBPF_MAP_RESIZABLE = 1,
123 + NETDATA_EBPF_MAP_CONTROLLER = 2,
124 + NETDATA_EBPF_MAP_CONTROLLER_UPDATED = 4,
125 + NETDATA_EBPF_MAP_PID = 8
126 +};
127 +
128 +enum netdata_controller {
129 + NETDATA_CONTROLLER_APPS_ENABLED,
130 +
131 + NETDATA_CONTROLLER_END
132 +};
133 +
134 typedef struct ebpf_local_maps {
135 char *name;
136 uint32_t internal_input;
137 uint32_t user_input;
138 + uint32_t type;
139 + int map_fd;
140 } ebpf_local_maps_t;
141
142 typedef struct ebpf_specify_name {
packaging/ebpf.checksums
+3 -3
@@ -1,3 +1,3 @@
1 -eb017acc8d05047190c385412b2e17b63d7ea07d7521ac043d32d14802a9c185 netdata-kernel-collector-glibc-v0.7.0.1.tar.xz
2 -72bbcb55342a162ab3eab27034e52820dd2a4e5d77dd8b1317f6a6b26904ecb8 netdata-kernel-collector-musl-v0.7.0.1.tar.xz
3 -d70fc36d09b0e49f4db1c8e328a4b516f21f353eb3bfdd190beae5e403f81aa2 netdata-kernel-collector-static-v0.7.0.1.tar.xz
1 +a2849a54f43f9419419298a0e06de7da52b1ecb74e3c5e788540f7fdd380862a netdata-kernel-collector-glibc-v0.7.1.1.tar.xz
2 +15fb92966fef3fe8b6f6f08f15c57270b5b37071b52834073097076c4897c0e1 netdata-kernel-collector-musl-v0.7.1.1.tar.xz
3 +bdfa64cfc9a9d457252dd824435ac5e7f107c9a30fc6d915b294ae9fb1cd5205 netdata-kernel-collector-static-v0.7.1.1.tar.xz
packaging/ebpf.version
+1 -1
@@ -1 +1 @@
1 -v0.7.0.1
1 +v0.7.1.1