diff options
Diffstat (limited to '')
-rw-r--r-- | src/collectors/ebpf.plugin/ebpf_fd.c (renamed from collectors/ebpf.plugin/ebpf_fd.c) | 466 |
1 files changed, 254 insertions, 212 deletions
diff --git a/collectors/ebpf.plugin/ebpf_fd.c b/src/collectors/ebpf.plugin/ebpf_fd.c index 3c8f30d3e..e1dc5b356 100644 --- a/collectors/ebpf.plugin/ebpf_fd.c +++ b/src/collectors/ebpf.plugin/ebpf_fd.c @@ -57,9 +57,16 @@ netdata_ebpf_targets_t fd_targets[] = { {.name = "open", .mode = EBPF_LOAD_TRAMP {.name = "close", .mode = EBPF_LOAD_TRAMPOLINE}, {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}}; -#ifdef NETDATA_DEV_MODE -int fd_disable_priority; -#endif +struct netdata_static_thread ebpf_read_fd = { + .name = "EBPF_READ_FD", + .config_section = NULL, + .config_name = NULL, + .env_name = NULL, + .enabled = 1, + .thread = NULL, + .init_routine = NULL, + .start_routine = NULL +}; #ifdef LIBBPF_MAJOR_VERSION /** @@ -73,7 +80,6 @@ static inline void ebpf_fd_disable_probes(struct fd_bpf *obj) { bpf_program__set_autoload(obj->progs.netdata_sys_open_kprobe, false); bpf_program__set_autoload(obj->progs.netdata_sys_open_kretprobe, false); - bpf_program__set_autoload(obj->progs.netdata_release_task_fd_kprobe, false); if (!strcmp(fd_targets[NETDATA_FD_SYSCALL_CLOSE].name, close_targets[NETDATA_FD_CLOSE_FD])) { bpf_program__set_autoload(obj->progs.netdata___close_fd_kretprobe, false); bpf_program__set_autoload(obj->progs.netdata___close_fd_kprobe, false); @@ -118,7 +124,6 @@ static inline void ebpf_disable_trampoline(struct fd_bpf *obj) bpf_program__set_autoload(obj->progs.netdata_close_fd_fexit, false); bpf_program__set_autoload(obj->progs.netdata___close_fd_fentry, false); bpf_program__set_autoload(obj->progs.netdata___close_fd_fexit, false); - bpf_program__set_autoload(obj->progs.netdata_release_task_fd_fentry, false); } /* @@ -150,7 +155,6 @@ static void ebpf_set_trampoline_target(struct fd_bpf *obj) { bpf_program__set_attach_target(obj->progs.netdata_sys_open_fentry, 0, fd_targets[NETDATA_FD_SYSCALL_OPEN].name); bpf_program__set_attach_target(obj->progs.netdata_sys_open_fexit, 0, fd_targets[NETDATA_FD_SYSCALL_OPEN].name); - bpf_program__set_attach_target(obj->progs.netdata_release_task_fd_fentry, 0, EBPF_COMMON_FNCT_CLEAN_UP); if (!strcmp(fd_targets[NETDATA_FD_SYSCALL_CLOSE].name, close_targets[NETDATA_FD_CLOSE_FD])) { bpf_program__set_attach_target( @@ -177,7 +181,7 @@ static int ebpf_fd_attach_probe(struct fd_bpf *obj) { obj->links.netdata_sys_open_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_sys_open_kprobe, false, fd_targets[NETDATA_FD_SYSCALL_OPEN].name); - int ret = libbpf_get_error(obj->links.netdata_sys_open_kprobe); + long ret = libbpf_get_error(obj->links.netdata_sys_open_kprobe); if (ret) return -1; @@ -187,13 +191,6 @@ static int ebpf_fd_attach_probe(struct fd_bpf *obj) if (ret) return -1; - obj->links.netdata_release_task_fd_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_release_task_fd_kprobe, - false, - EBPF_COMMON_FNCT_CLEAN_UP); - ret = libbpf_get_error(obj->links.netdata_release_task_fd_kprobe); - if (ret) - return -1; - if (!strcmp(fd_targets[NETDATA_FD_SYSCALL_CLOSE].name, close_targets[NETDATA_FD_CLOSE_FD])) { obj->links.netdata_close_fd_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_close_fd_kretprobe, true, fd_targets[NETDATA_FD_SYSCALL_CLOSE].name); @@ -302,19 +299,6 @@ static void ebpf_fd_adjust_map(struct fd_bpf *obj, ebpf_module_t *em) } /** - * Disable Release Task - * - * Disable release task when apps is not enabled. - * - * @param obj is the main structure for bpf objects. - */ -static void ebpf_fd_disable_release_task(struct fd_bpf *obj) -{ - bpf_program__set_autoload(obj->progs.netdata_release_task_fd_kprobe, false); - bpf_program__set_autoload(obj->progs.netdata_release_task_fd_fentry, false); -} - -/** * Load and attach * * Load and attach the eBPF code in kernel. @@ -339,8 +323,6 @@ static inline int ebpf_fd_load_and_attach(struct fd_bpf *obj, ebpf_module_t *em) ebpf_disable_specific_trampoline(obj); ebpf_set_trampoline_target(obj); - // TODO: Remove this in next PR, because this specific trampoline has an error. - bpf_program__set_autoload(obj->progs.netdata_release_task_fd_fentry, false); } else { ebpf_disable_trampoline(obj); ebpf_disable_specific_probes(obj); @@ -348,9 +330,6 @@ static inline int ebpf_fd_load_and_attach(struct fd_bpf *obj, ebpf_module_t *em) ebpf_fd_adjust_map(obj, em); - if (!em->apps_charts && !em->cgroup_charts) - ebpf_fd_disable_release_task(obj); - int ret = fd_bpf__load(obj); if (ret) { return ret; @@ -382,14 +361,14 @@ static void ebpf_obsolete_specific_fd_charts(char *type, ebpf_module_t *em); * * @param em a pointer to `struct ebpf_module` */ -static void ebpf_obsolete_fd_services(ebpf_module_t *em) +static void ebpf_obsolete_fd_services(ebpf_module_t *em, char *id) { ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_FILE_OPEN, - "", "Number of open files", EBPF_COMMON_DIMENSION_CALL, - NETDATA_APPS_FILE_CGROUP_GROUP, + NETDATA_APPS_FILE_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NETDATA_CGROUP_FD_OPEN_CONTEXT, 20270, @@ -397,11 +376,11 @@ static void ebpf_obsolete_fd_services(ebpf_module_t *em) if (em->mode < MODE_ENTRY) { ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, - "", "Fails to open files", EBPF_COMMON_DIMENSION_CALL, - NETDATA_APPS_FILE_CGROUP_GROUP, + NETDATA_APPS_FILE_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NETDATA_CGROUP_FD_OPEN_ERR_CONTEXT, 20271, @@ -409,11 +388,11 @@ static void ebpf_obsolete_fd_services(ebpf_module_t *em) } ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_FILE_CLOSED, - "", "Files closed", EBPF_COMMON_DIMENSION_CALL, - NETDATA_APPS_FILE_CGROUP_GROUP, + NETDATA_APPS_FILE_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NETDATA_CGROUP_FD_CLOSE_CONTEXT, 20272, @@ -421,11 +400,11 @@ static void ebpf_obsolete_fd_services(ebpf_module_t *em) if (em->mode < MODE_ENTRY) { ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, - "", "Fails to close files", EBPF_COMMON_DIMENSION_CALL, - NETDATA_APPS_FILE_CGROUP_GROUP, + NETDATA_APPS_FILE_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT, 20273, @@ -443,12 +422,13 @@ static void ebpf_obsolete_fd_services(ebpf_module_t *em) static inline void ebpf_obsolete_fd_cgroup_charts(ebpf_module_t *em) { pthread_mutex_lock(&mutex_cgroup_shm); - ebpf_obsolete_fd_services(em); - ebpf_cgroup_target_t *ect; for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (ect->systemd) + if (ect->systemd) { + ebpf_obsolete_fd_services(em, ect->name); + continue; + } ebpf_obsolete_specific_fd_charts(ect->name, em); } @@ -466,6 +446,7 @@ void ebpf_obsolete_fd_apps_charts(struct ebpf_module *em) { struct ebpf_target *w; int update_every = em->update_every; + pthread_mutex_lock(&collect_data_mutex); for (w = apps_groups_root_target; w; w = w->next) { if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_FD_IDX)))) continue; @@ -519,6 +500,7 @@ void ebpf_obsolete_fd_apps_charts(struct ebpf_module *em) } w->charts_created &= ~(1<<EBPF_MODULE_FD_IDX); } + pthread_mutex_unlock(&collect_data_mutex); } /** @@ -566,6 +548,9 @@ static void ebpf_fd_exit(void *ptr) { ebpf_module_t *em = (ebpf_module_t *)ptr; + if (ebpf_read_fd.thread) + netdata_thread_cancel(*ebpf_read_fd.thread); + if (em->enabled == NETDATA_THREAD_EBPF_FUNCTION_RUNNING) { pthread_mutex_lock(&lock); if (em->cgroup_charts) { @@ -579,12 +564,6 @@ static void ebpf_fd_exit(void *ptr) ebpf_obsolete_fd_global(em); -#ifdef NETDATA_DEV_MODE - if (ebpf_aral_fd_pid) - ebpf_statistic_obsolete_aral_chart(em, fd_disable_priority); -#endif - - fflush(stdout); pthread_mutex_unlock(&lock); } @@ -684,73 +663,152 @@ static void fd_apps_accumulator(netdata_fd_stat_t *out, int maps_per_core) } /** - * Fill PID - * - * Fill PID structures - * - * @param current_pid pid that we are collecting data - * @param out values read from hash tables; - */ -static void fd_fill_pid(uint32_t current_pid, netdata_fd_stat_t *publish) -{ - netdata_fd_stat_t *curr = fd_pid[current_pid]; - if (!curr) { - curr = ebpf_fd_stat_get(); - fd_pid[current_pid] = curr; - } - - memcpy(curr, &publish[0], sizeof(netdata_fd_stat_t)); -} - -/** * Read APPS table * * Read the apps table and store data inside the structure. * * @param maps_per_core do I need to read all cores? */ -static void read_fd_apps_table(int maps_per_core) +static void ebpf_read_fd_apps_table(int maps_per_core, int max_period) { netdata_fd_stat_t *fv = fd_vector; - uint32_t key; - struct ebpf_pid_stat *pids = ebpf_root_of_pids; int fd = fd_maps[NETDATA_FD_PID_STATS].map_fd; size_t length = sizeof(netdata_fd_stat_t); if (maps_per_core) length *= ebpf_nprocs; - while (pids) { - key = pids->pid; - + uint32_t key = 0, next_key = 0; + while (bpf_map_get_next_key(fd, &key, &next_key) == 0) { if (bpf_map_lookup_elem(fd, &key, fv)) { - pids = pids->next; - continue; + goto end_fd_loop; } fd_apps_accumulator(fv, maps_per_core); - fd_fill_pid(key, fv); + ebpf_pid_stat_t *pid_stat = ebpf_get_pid_entry(key, fv->tgid); + if (pid_stat) { + netdata_fd_stat_t *publish_fd = &pid_stat->fd; + if (!publish_fd->ct || publish_fd->ct != fv->ct) { + memcpy(publish_fd, &fv[0], sizeof(netdata_fd_stat_t)); + pid_stat->not_updated = 0; + } else if (++pid_stat->not_updated >= max_period) { + bpf_map_delete_elem(fd, &key); + pid_stat->not_updated = 0; + } + } +end_fd_loop: // We are cleaning to avoid passing data read from one process to other. memset(fv, 0, length); + key = next_key; + } +} - pids = pids->next; +/** + * Sum PIDs + * + * Sum values for all targets. + * + * @param fd the output + * @param root list of pids + */ +static void ebpf_fd_sum_pids(netdata_fd_stat_t *fd, struct ebpf_pid_on_target *root) +{ + memset(fd, 0, sizeof(netdata_fd_stat_t)); + + while (root) { + int32_t pid = root->pid; + ebpf_pid_stat_t *pid_stat = ebpf_get_pid_entry(pid, 0); + if (pid_stat) { + netdata_fd_stat_t *w = &pid_stat->fd; + fd->open_call += w->open_call; + fd->close_call += w->close_call; + fd->open_err += w->open_err; + fd->close_err += w->close_err; + } + + root = root->next; + } +} + +/** + * Resume apps data + */ +void ebpf_fd_resume_apps_data() +{ + struct ebpf_target *w; + + for (w = apps_groups_root_target; w; w = w->next) { + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_FD_IDX)))) + continue; + + ebpf_fd_sum_pids(&w->fd, w->root_pid); } } /** + * DCstat thread + * + * Thread used to generate dcstat charts. + * + * @param ptr a pointer to `struct ebpf_module` + * + * @return It always return NULL + */ +void *ebpf_read_fd_thread(void *ptr) +{ + heartbeat_t hb; + heartbeat_init(&hb); + + ebpf_module_t *em = (ebpf_module_t *)ptr; + + int maps_per_core = em->maps_per_core; + int update_every = em->update_every; + + int counter = update_every - 1; + + uint32_t lifetime = em->lifetime; + uint32_t running_time = 0; + usec_t period = update_every * USEC_PER_SEC; + int max_period = update_every * EBPF_CLEANUP_FACTOR; + while (!ebpf_plugin_exit && running_time < lifetime) { + (void)heartbeat_next(&hb, period); + if (ebpf_plugin_exit || ++counter != update_every) + continue; + + netdata_thread_disable_cancelability(); + + pthread_mutex_lock(&collect_data_mutex); + ebpf_read_fd_apps_table(maps_per_core, max_period); + ebpf_fd_resume_apps_data(); + pthread_mutex_unlock(&collect_data_mutex); + + counter = 0; + + pthread_mutex_lock(&ebpf_exit_cleanup); + if (running_time && !em->running_time) + running_time = update_every; + else + running_time += update_every; + + em->running_time = running_time; + pthread_mutex_unlock(&ebpf_exit_cleanup); + netdata_thread_enable_cancelability(); + } + + return NULL; +} + +/** * Update cgroup * * Update cgroup data collected per PID. * * @param maps_per_core do I need to read all cores? */ -static void ebpf_update_fd_cgroup(int maps_per_core) +static void ebpf_update_fd_cgroup() { ebpf_cgroup_target_t *ect ; - netdata_fd_stat_t *fv = fd_vector; - int fd = fd_maps[NETDATA_FD_PID_STATS].map_fd; - size_t length = sizeof(netdata_fd_stat_t) * ebpf_nprocs; pthread_mutex_lock(&mutex_cgroup_shm); for (ect = ebpf_cgroup_pids; ect; ect = ect->next) { @@ -758,17 +816,11 @@ static void ebpf_update_fd_cgroup(int maps_per_core) for (pids = ect->pids; pids; pids = pids->next) { int pid = pids->pid; netdata_fd_stat_t *out = &pids->fd; - if (likely(fd_pid) && fd_pid[pid]) { - netdata_fd_stat_t *in = fd_pid[pid]; + ebpf_pid_stat_t *local_pid = ebpf_get_pid_entry(pid, 0); + if (local_pid) { + netdata_fd_stat_t *in = &local_pid->fd; memcpy(out, in, sizeof(netdata_fd_stat_t)); - } else { - memset(fv, 0, length); - if (!bpf_map_lookup_elem(fd, &pid, fv)) { - fd_apps_accumulator(fv, maps_per_core); - - memcpy(out, fv, sizeof(netdata_fd_stat_t)); - } } } } @@ -776,41 +828,6 @@ static void ebpf_update_fd_cgroup(int maps_per_core) } /** - * Sum PIDs - * - * Sum values for all targets. - * - * @param fd the output - * @param root list of pids - */ -static void ebpf_fd_sum_pids(netdata_fd_stat_t *fd, struct ebpf_pid_on_target *root) -{ - uint32_t open_call = 0; - uint32_t close_call = 0; - uint32_t open_err = 0; - uint32_t close_err = 0; - - while (root) { - int32_t pid = root->pid; - netdata_fd_stat_t *w = fd_pid[pid]; - if (w) { - open_call += w->open_call; - close_call += w->close_call; - open_err += w->open_err; - close_err += w->close_err; - } - - root = root->next; - } - - // These conditions were added, because we are using incremental algorithm - fd->open_call = (open_call >= fd->open_call) ? open_call : fd->open_call; - fd->close_call = (close_call >= fd->close_call) ? close_call : fd->close_call; - fd->open_err = (open_err >= fd->open_err) ? open_err : fd->open_err; - fd->close_err = (close_err >= fd->close_err) ? close_err : fd->close_err; -} - -/** * Send data to Netdata calling auxiliary functions. * * @param em the structure with thread information @@ -819,12 +836,11 @@ static void ebpf_fd_sum_pids(netdata_fd_stat_t *fd, struct ebpf_pid_on_target *r void ebpf_fd_send_apps_data(ebpf_module_t *em, struct ebpf_target *root) { struct ebpf_target *w; + pthread_mutex_lock(&collect_data_mutex); for (w = root; w; w = w->next) { if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_FD_IDX)))) continue; - ebpf_fd_sum_pids(&w->fd, w->root_pid); - ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_file_open"); write_chart_dimension("calls", w->fd.open_call); ebpf_write_end_chart(); @@ -845,6 +861,7 @@ void ebpf_fd_send_apps_data(ebpf_module_t *em, struct ebpf_target *root) ebpf_write_end_chart(); } } + pthread_mutex_unlock(&collect_data_mutex); } /** @@ -888,7 +905,7 @@ static void ebpf_fd_sum_cgroup_pids(netdata_fd_stat_t *fd, struct pid_on_target2 static void ebpf_create_specific_fd_charts(char *type, ebpf_module_t *em) { ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_OPEN, "Number of open files", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP, + EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_GROUP, NETDATA_CGROUP_FD_OPEN_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5400, ebpf_create_global_dimension, @@ -897,7 +914,7 @@ static void ebpf_create_specific_fd_charts(char *type, ebpf_module_t *em) if (em->mode < MODE_ENTRY) { ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, "Fails to open files", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP, + EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_GROUP, NETDATA_CGROUP_FD_OPEN_ERR_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5401, ebpf_create_global_dimension, @@ -907,7 +924,7 @@ static void ebpf_create_specific_fd_charts(char *type, ebpf_module_t *em) } ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_CLOSED, "Files closed", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP, + EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_GROUP, NETDATA_CGROUP_FD_CLOSE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5402, ebpf_create_global_dimension, @@ -916,7 +933,7 @@ static void ebpf_create_specific_fd_charts(char *type, ebpf_module_t *em) if (em->mode < MODE_ENTRY) { ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, "Fails to close files", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP, + EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_GROUP, NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5403, ebpf_create_global_dimension, @@ -1001,32 +1018,84 @@ static void ebpf_send_specific_fd_data(char *type, netdata_fd_stat_t *values, eb **/ static void ebpf_create_systemd_fd_charts(ebpf_module_t *em) { - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_FILE_OPEN, "Number of open files", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20061, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_FD_OPEN_CONTEXT, - NETDATA_EBPF_MODULE_NAME_FD, em->update_every); + static ebpf_systemd_args_t data_open = { + .title = "Number of open files", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_FILE_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20061, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_FD_OPEN_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_FD, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_FILE_OPEN, + .dimension = "calls" + }; - if (em->mode < MODE_ENTRY) { - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, "Fails to open files", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20062, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_FD_OPEN_ERR_CONTEXT, - NETDATA_EBPF_MODULE_NAME_FD, em->update_every); - } + static ebpf_systemd_args_t data_open_error = { + .title = "Fails to open files", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_FILE_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20062, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_FD_OPEN_ERR_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_FD, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, + .dimension = "calls" + }; - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_FILE_CLOSED, "Files closed", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20063, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_FD_CLOSE_CONTEXT, - NETDATA_EBPF_MODULE_NAME_FD, em->update_every); + static ebpf_systemd_args_t data_close = { + .title = "Files closed", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_FILE_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20063, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_FD_CLOSE_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_FD, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_FILE_CLOSED, + .dimension = "calls" + }; - if (em->mode < MODE_ENTRY) { - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, "Fails to close files", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20064, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_FD_CLOSE_ERR_CONTEXT, - NETDATA_EBPF_MODULE_NAME_FD, em->update_every); + static ebpf_systemd_args_t data_close_error = { + .title = "Fails to close files", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_FILE_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20064, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_FD_OPEN_ERR_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_FD, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, + .dimension = "calls" + }; + + if (!data_open.update_every) + data_open.update_every = data_open_error.update_every = + data_close.update_every = data_close_error.update_every = em->update_every; + + ebpf_cgroup_target_t *w; + netdata_run_mode_t mode = em->mode; + for (w = ebpf_cgroup_pids; w; w = w->next) { + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_FD_CHART)) + continue; + + data_open.id = data_open_error.id = data_close.id = data_close_error.id = w->name; + ebpf_create_charts_on_systemd(&data_open); + if (mode < MODE_ENTRY) { + ebpf_create_charts_on_systemd(&data_open_error); + } + + ebpf_create_charts_on_systemd(&data_close); + if (mode < MODE_ENTRY) { + ebpf_create_charts_on_systemd(&data_close_error); + } + + w->flags |= NETDATA_EBPF_SERVICES_HAS_FD_CHART; } } @@ -1040,40 +1109,30 @@ static void ebpf_create_systemd_fd_charts(ebpf_module_t *em) static void ebpf_send_systemd_fd_charts(ebpf_module_t *em) { ebpf_cgroup_target_t *ect; - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_OPEN, ""); for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_fd.open_call); + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_FD_CHART)) ) { + continue; } - } - ebpf_write_end_chart(); - if (em->mode < MODE_ENTRY) { - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_fd.open_err); - } - } + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_FILE_OPEN); + write_chart_dimension("calls", ect->publish_systemd_fd.open_call); ebpf_write_end_chart(); - } - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_CLOSED, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_fd.close_call); + if (em->mode < MODE_ENTRY) { + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR); + write_chart_dimension("calls", ect->publish_systemd_fd.open_err); + ebpf_write_end_chart(); } - } - ebpf_write_end_chart(); - if (em->mode < MODE_ENTRY) { - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_fd.close_err); - } - } + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_FILE_CLOSED); + write_chart_dimension("calls", ect->publish_systemd_fd.close_call); ebpf_write_end_chart(); + + if (em->mode < MODE_ENTRY) { + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR); + write_chart_dimension("calls", ect->publish_systemd_fd.close_err); + ebpf_write_end_chart(); + } } } @@ -1084,17 +1143,13 @@ static void ebpf_send_systemd_fd_charts(ebpf_module_t *em) */ static void ebpf_fd_send_cgroup_data(ebpf_module_t *em) { - if (!ebpf_cgroup_pids) - return; - pthread_mutex_lock(&mutex_cgroup_shm); ebpf_cgroup_target_t *ect; for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { ebpf_fd_sum_cgroup_pids(&ect->publish_systemd_fd, ect->pids); } - int has_systemd = shm_ebpf_cgroup.header->systemd_enabled; - if (has_systemd) { + if (shm_ebpf_cgroup.header->systemd_enabled) { if (send_cgroup_chart) { ebpf_create_systemd_fd_charts(em); } @@ -1148,30 +1203,21 @@ static void fd_collector(ebpf_module_t *em) counter = 0; netdata_apps_integration_flags_t apps = em->apps_charts; ebpf_fd_read_global_tables(stats, maps_per_core); - pthread_mutex_lock(&collect_data_mutex); - if (apps) - read_fd_apps_table(maps_per_core); if (cgroups) - ebpf_update_fd_cgroup(maps_per_core); + ebpf_update_fd_cgroup(); pthread_mutex_lock(&lock); -#ifdef NETDATA_DEV_MODE - if (ebpf_aral_fd_pid) - ebpf_send_data_aral_chart(ebpf_aral_fd_pid, em); -#endif - ebpf_fd_send_data(em); if (apps & NETDATA_EBPF_APPS_FLAG_CHART_CREATED) ebpf_fd_send_apps_data(em, apps_groups_root_target); - if (cgroups) + if (cgroups && shm_ebpf_cgroup.header && ebpf_cgroup_pids) ebpf_fd_send_cgroup_data(em); pthread_mutex_unlock(&lock); - pthread_mutex_unlock(&collect_data_mutex); pthread_mutex_lock(&ebpf_exit_cleanup); if (running_time && !em->running_time) @@ -1327,17 +1373,10 @@ static void ebpf_create_fd_global_charts(ebpf_module_t *em) * * We are not testing the return, because callocz does this and shutdown the software * case it was not possible to allocate. - * - * @param apps is apps enabled? */ -static void ebpf_fd_allocate_global_vectors(int apps) +static inline void ebpf_fd_allocate_global_vectors() { - if (apps) { - ebpf_fd_aral_init(); - fd_pid = callocz((size_t)pid_max, sizeof(netdata_fd_stat_t *)); - fd_vector = callocz((size_t)ebpf_nprocs, sizeof(netdata_fd_stat_t)); - } - + fd_vector = callocz((size_t)ebpf_nprocs, sizeof(netdata_fd_stat_t)); fd_values = callocz((size_t)ebpf_nprocs, sizeof(netdata_idx_t)); } @@ -1401,7 +1440,7 @@ void *ebpf_fd_thread(void *ptr) goto endfd; } - ebpf_fd_allocate_global_vectors(em->apps_charts); + ebpf_fd_allocate_global_vectors(); int algorithms[NETDATA_FD_SYSCALL_END] = { NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX @@ -1414,13 +1453,16 @@ void *ebpf_fd_thread(void *ptr) ebpf_create_fd_global_charts(em); ebpf_update_stats(&plugin_statistics, em); ebpf_update_kernel_memory_with_vector(&plugin_statistics, em->maps, EBPF_ACTION_STAT_ADD); -#ifdef NETDATA_DEV_MODE - if (ebpf_aral_fd_pid) - fd_disable_priority = ebpf_statistic_create_aral_chart(NETDATA_EBPF_FD_ARAL_NAME, em); -#endif pthread_mutex_unlock(&lock); + ebpf_read_fd.thread = mallocz(sizeof(netdata_thread_t)); + netdata_thread_create(ebpf_read_fd.thread, + ebpf_read_fd.name, + NETDATA_THREAD_OPTION_DEFAULT, + ebpf_read_fd_thread, + em); + fd_collector(em); endfd: |