diff options
Diffstat (limited to '')
| -rw-r--r-- | src/collectors/ebpf.plugin/ebpf_process.c (renamed from collectors/ebpf.plugin/ebpf_process.c) | 335 |
1 files changed, 141 insertions, 194 deletions
diff --git a/collectors/ebpf.plugin/ebpf_process.c b/src/collectors/ebpf.plugin/ebpf_process.c index e3e2b884e..306b59639 100644 --- a/collectors/ebpf.plugin/ebpf_process.c +++ b/src/collectors/ebpf.plugin/ebpf_process.c @@ -1,7 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-or-later -#include <sys/resource.h> - #include "ebpf.h" #include "ebpf_process.h" @@ -65,10 +63,6 @@ struct config process_config = { .first_section = NULL, .index = { .avl_tree = { .root = NULL, .compar = appconfig_section_compare }, .rwlock = AVL_LOCK_INITIALIZER } }; -#ifdef NETDATA_DEV_MODE -int process_disable_priority; -#endif - /***************************************************************** * * PROCESS DATA AND SEND TO NETDATA @@ -147,53 +141,6 @@ static void ebpf_process_send_data(ebpf_module_t *em) } /** - * Sum values for pid - * - * @param root the structure with all available PIDs - * @param offset the address that we are reading - * - * @return it returns the sum of all PIDs - */ -long long ebpf_process_sum_values_for_pids(struct ebpf_pid_on_target *root, size_t offset) -{ - long long ret = 0; - while (root) { - int32_t pid = root->pid; - ebpf_process_stat_t *w = global_process_stats[pid]; - if (w) { - uint32_t *value = (uint32_t *)((char *)w + offset); - ret += *value; - } - - root = root->next; - } - - return ret; -} - -/** - * Remove process pid - * - * Remove from PID task table when task_release was called. - */ -void ebpf_process_remove_pids() -{ - struct ebpf_pid_stat *pids = ebpf_root_of_pids; - int pid_fd = process_maps[NETDATA_PROCESS_PID_TABLE].map_fd; - while (pids) { - uint32_t pid = pids->pid; - ebpf_process_stat_t *w = global_process_stats[pid]; - if (w) { - ebpf_process_stat_release(w); - global_process_stats[pid] = NULL; - bpf_map_delete_elem(pid_fd, &pid); - } - - pids = pids->next; - } -} - -/** * Send data to Netdata calling auxiliary functions. * * @param root the target list. @@ -201,46 +148,33 @@ void ebpf_process_remove_pids() void ebpf_process_send_apps_data(struct ebpf_target *root, ebpf_module_t *em) { struct ebpf_target *w; - // This algorithm is improved in https://github.com/netdata/netdata/pull/16030 - collected_number values[5]; for (w = root; w; w = w->next) { if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_PROCESS_IDX)))) continue; - values[0] = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t, create_process)); - values[1] = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t, create_thread)); - values[2] = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t, - exit_call)); - values[3] = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t, - release_call)); - values[4] = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t, - task_err)); - ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_process_start"); - write_chart_dimension("calls", values[0]); + write_chart_dimension("calls", w->process.create_process); ebpf_write_end_chart(); ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_thread_start"); - write_chart_dimension("calls", values[1]); + write_chart_dimension("calls", w->process.create_thread); ebpf_write_end_chart(); ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_task_exit"); - write_chart_dimension("calls", values[2]); + write_chart_dimension("calls", w->process.exit_call); ebpf_write_end_chart(); ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_task_released"); - write_chart_dimension("calls", values[3]); + write_chart_dimension("calls", w->process.release_call); ebpf_write_end_chart(); if (em->mode < MODE_ENTRY) { ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_task_error"); - write_chart_dimension("calls", values[4]); + write_chart_dimension("calls", w->process.task_err); ebpf_write_end_chart(); } } - - ebpf_process_remove_pids(); } /***************************************************************** @@ -287,34 +221,20 @@ static void ebpf_read_process_hash_global_tables(netdata_idx_t *stats, int maps_ * * @param maps_per_core do I need to read all cores? */ -static void ebpf_update_process_cgroup(int maps_per_core) +static void ebpf_update_process_cgroup() { ebpf_cgroup_target_t *ect ; - int pid_fd = process_maps[NETDATA_PROCESS_PID_TABLE].map_fd; - - size_t length = sizeof(ebpf_process_stat_t); - if (maps_per_core) - length *= ebpf_nprocs; pthread_mutex_lock(&mutex_cgroup_shm); for (ect = ebpf_cgroup_pids; ect; ect = ect->next) { struct pid_on_target2 *pids; for (pids = ect->pids; pids; pids = pids->next) { int pid = pids->pid; ebpf_process_stat_t *out = &pids->ps; - if (global_process_stats[pid]) { - ebpf_process_stat_t *in = global_process_stats[pid]; + ebpf_pid_stat_t *local_pid = ebpf_get_pid_entry(pid, 0); + if (local_pid) { + ebpf_process_stat_t *in = &local_pid->process; memcpy(out, in, sizeof(ebpf_process_stat_t)); - } else { - if (bpf_map_lookup_elem(pid_fd, &pid, process_stat_vector)) { - memset(out, 0, sizeof(ebpf_process_stat_t)); - } - - ebpf_process_apps_accumulator(process_stat_vector, maps_per_core); - - memcpy(out, process_stat_vector, sizeof(ebpf_process_stat_t)); - - memset(process_stat_vector, 0, length); } } } @@ -439,7 +359,7 @@ void ebpf_process_create_apps_charts(struct ebpf_module *em, void *ptr) NETDATA_EBPF_MODULE_NAME_PROCESS); ebpf_create_chart_labels("app_group", w->name, 1); ebpf_commit_label(); - fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]); + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]); ebpf_write_chart_cmd(NETDATA_APP_FAMILY, w->clean_name, @@ -454,7 +374,7 @@ void ebpf_process_create_apps_charts(struct ebpf_module *em, void *ptr) NETDATA_EBPF_MODULE_NAME_PROCESS); ebpf_create_chart_labels("app_group", w->name, 1); ebpf_commit_label(); - fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]); + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]); ebpf_write_chart_cmd(NETDATA_APP_FAMILY, w->clean_name, @@ -469,7 +389,7 @@ void ebpf_process_create_apps_charts(struct ebpf_module *em, void *ptr) NETDATA_EBPF_MODULE_NAME_PROCESS); ebpf_create_chart_labels("app_group", w->name, 1); ebpf_commit_label(); - fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]); + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]); ebpf_write_chart_cmd(NETDATA_APP_FAMILY, w->clean_name, @@ -484,7 +404,7 @@ void ebpf_process_create_apps_charts(struct ebpf_module *em, void *ptr) NETDATA_EBPF_MODULE_NAME_PROCESS); ebpf_create_chart_labels("app_group", w->name, 1); ebpf_commit_label(); - fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]); + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]); if (em->mode < MODE_ENTRY) { ebpf_write_chart_cmd(NETDATA_APP_FAMILY, @@ -500,7 +420,7 @@ void ebpf_process_create_apps_charts(struct ebpf_module *em, void *ptr) NETDATA_EBPF_MODULE_NAME_PROCESS); ebpf_create_chart_labels("app_group", w->name, 1); ebpf_commit_label(); - fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]); + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]); } w->charts_created |= 1<<EBPF_MODULE_PROCESS_IDX; } @@ -523,11 +443,11 @@ static void ebpf_obsolete_specific_process_charts(char *type, ebpf_module_t *em) * * @param em a pointer to `struct ebpf_module` */ -static void ebpf_obsolete_process_services(ebpf_module_t *em) +static void ebpf_obsolete_process_services(ebpf_module_t *em, char *id) { ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_TASK_PROCESS, - "", "Process started", EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP, @@ -537,8 +457,8 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em) em->update_every); ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_TASK_THREAD, - "", "Threads started", EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP, @@ -548,8 +468,8 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em) em->update_every); ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_TASK_CLOSE, - "", "Tasks starts exit process.", EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP, @@ -559,8 +479,8 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em) em->update_every); ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_TASK_EXIT, - "", "Tasks closed", EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP, @@ -571,8 +491,8 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em) if (em->mode < MODE_ENTRY) { ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_TASK_ERROR, - "", "Errors to create process or threads.", EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP, @@ -593,12 +513,13 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em) static inline void ebpf_obsolete_process_cgroup_charts(ebpf_module_t *em) { pthread_mutex_lock(&mutex_cgroup_shm); - ebpf_obsolete_process_services(em); - ebpf_cgroup_target_t *ect; for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (ect->systemd) + if (ect->systemd) { + ebpf_obsolete_process_services(em, ect->name); + continue; + } ebpf_obsolete_specific_process_charts(ect->name, em); } @@ -785,11 +706,6 @@ static void ebpf_process_exit(void *ptr) ebpf_obsolete_process_global(em); -#ifdef NETDATA_DEV_MODE - if (ebpf_aral_process_stat) - ebpf_statistic_obsolete_aral_chart(em, process_disable_priority); -#endif - fflush(stdout); pthread_mutex_unlock(&lock); } @@ -905,14 +821,14 @@ static void ebpf_send_specific_process_data(char *type, ebpf_process_stat_t *val static void ebpf_create_specific_process_charts(char *type, ebpf_module_t *em) { ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_PROCESS, "Process started", - EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_CGROUP_GROUP, + EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP, NETDATA_CGROUP_PROCESS_CREATE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5000, ebpf_create_global_dimension, &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS); ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_THREAD, "Threads started", - EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_CGROUP_GROUP, + EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP, NETDATA_CGROUP_THREAD_CREATE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5001, ebpf_create_global_dimension, @@ -920,7 +836,7 @@ static void ebpf_create_specific_process_charts(char *type, ebpf_module_t *em) 1, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS); ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_EXIT, "Tasks starts exit process.", - EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_CGROUP_GROUP, + EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP, NETDATA_CGROUP_PROCESS_EXIT_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5002, ebpf_create_global_dimension, @@ -928,7 +844,7 @@ static void ebpf_create_specific_process_charts(char *type, ebpf_module_t *em) 1, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS); ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_CLOSE, "Tasks closed", - EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_CGROUP_GROUP, + EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP, NETDATA_CGROUP_PROCESS_CLOSE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5003, ebpf_create_global_dimension, @@ -937,7 +853,7 @@ static void ebpf_create_specific_process_charts(char *type, ebpf_module_t *em) if (em->mode < MODE_ENTRY) { ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_ERROR, "Errors to create process or threads.", - EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_CGROUP_GROUP, + EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP, NETDATA_CGROUP_PROCESS_ERROR_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5004, ebpf_create_global_dimension, @@ -993,36 +909,98 @@ static void ebpf_obsolete_specific_process_charts(char *type, ebpf_module_t *em) **/ static void ebpf_create_systemd_process_charts(ebpf_module_t *em) { - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_TASK_PROCESS, "Process started", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20065, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_PROCESS_CREATE_CONTEXT, - NETDATA_EBPF_MODULE_NAME_PROCESS, em->update_every); - - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_TASK_THREAD, "Threads started", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20066, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_THREAD_CREATE_CONTEXT, - NETDATA_EBPF_MODULE_NAME_PROCESS, em->update_every); - - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_TASK_CLOSE, "Tasks starts exit process.", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20067, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_PROCESS_EXIT_CONTEXT, - NETDATA_EBPF_MODULE_NAME_PROCESS, em->update_every); - - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_TASK_EXIT, "Tasks closed", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20068, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_PROCESS_CLOSE_CONTEXT, - NETDATA_EBPF_MODULE_NAME_PROCESS, em->update_every); + static ebpf_systemd_args_t data_process = { + .title = "Process started", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_PROCESS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20065, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_PROCESS_CREATE_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_PROCESS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_TASK_PROCESS, + .dimension = "calls" + }; - if (em->mode < MODE_ENTRY) { - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_TASK_ERROR, "Errors to create process or threads.", - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20069, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_PROCESS_ERROR_CONTEXT, - NETDATA_EBPF_MODULE_NAME_PROCESS, em->update_every); + static ebpf_systemd_args_t data_thread = { + .title = "Threads started", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_PROCESS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20066, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_THREAD_CREATE_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_PROCESS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_TASK_THREAD, + .dimension = "calls" + }; + + static ebpf_systemd_args_t task_exit = { + .title = "Tasks starts exit process.", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_PROCESS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20067, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_PROCESS_EXIT_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_PROCESS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_TASK_CLOSE, + .dimension = "calls" + }; + + static ebpf_systemd_args_t task_closed = { + .title = "Tasks closed", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_PROCESS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20068, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_PROCESS_CLOSE_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_PROCESS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_TASK_EXIT, + .dimension = "calls" + }; + + static ebpf_systemd_args_t task_error = { + .title = "Errors to create process or threads.", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_PROCESS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20069, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_PROCESS_ERROR_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_PROCESS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_TASK_ERROR, + .dimension = "calls" + }; + + ebpf_cgroup_target_t *w; + netdata_run_mode_t mode = em->mode; + if (!task_exit.update_every) + data_process.update_every = data_thread.update_every = task_exit.update_every = + task_closed.update_every = task_error.update_every = em->update_every; + + for (w = ebpf_cgroup_pids; w; w = w->next) { + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_PROCESS_CHART)) + continue; + + data_process.id = data_thread.id = task_exit.id = task_closed.id = task_error.id = w->name; + ebpf_create_charts_on_systemd(&data_process); + + ebpf_create_charts_on_systemd(&data_thread); + + ebpf_create_charts_on_systemd(&task_exit); + + ebpf_create_charts_on_systemd(&task_closed); + if (mode < MODE_ENTRY) { + ebpf_create_charts_on_systemd(&task_error); + } + w->flags |= NETDATA_EBPF_SERVICES_HAS_PROCESS_CHART; } } @@ -1036,46 +1014,32 @@ static void ebpf_create_systemd_process_charts(ebpf_module_t *em) static void ebpf_send_systemd_process_charts(ebpf_module_t *em) { ebpf_cgroup_target_t *ect; - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_PROCESS, ""); for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_ps.create_process); + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_PROCESS_CHART)) ) { + continue; } - } - ebpf_write_end_chart(); - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_THREAD, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_ps.create_thread); - } - } - ebpf_write_end_chart(); + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_TASK_PROCESS); + write_chart_dimension("calls", ect->publish_systemd_ps.create_process); + ebpf_write_end_chart(); - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_EXIT, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_ps.exit_call); - } - } - ebpf_write_end_chart(); + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_TASK_THREAD); + write_chart_dimension("calls", ect->publish_systemd_ps.create_thread); + ebpf_write_end_chart(); - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_CLOSE, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_ps.release_call); - } - } - ebpf_write_end_chart(); + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_TASK_EXIT); + write_chart_dimension("calls", ect->publish_systemd_ps.exit_call); + ebpf_write_end_chart(); - if (em->mode < MODE_ENTRY) { - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_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_ps.task_err); - } - } + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_TASK_CLOSE); + write_chart_dimension("calls", ect->publish_systemd_ps.release_call); ebpf_write_end_chart(); + + if (em->mode < MODE_ENTRY) { + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_TASK_ERROR); + write_chart_dimension("calls", ect->publish_systemd_ps.task_err); + ebpf_write_end_chart(); + } } } @@ -1086,18 +1050,13 @@ static void ebpf_send_systemd_process_charts(ebpf_module_t *em) */ static void ebpf_process_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_process_sum_cgroup_pids(&ect->publish_systemd_ps, 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_process_charts(em); } @@ -1181,7 +1140,7 @@ static void process_collector(ebpf_module_t *em) if (ebpf_all_pids_count > 0) { if (cgroups && shm_ebpf_cgroup.header) { - ebpf_update_process_cgroup(maps_per_core); + ebpf_update_process_cgroup(); } } @@ -1195,11 +1154,6 @@ static void process_collector(ebpf_module_t *em) ebpf_process_send_apps_data(apps_groups_root_target, em); } -#ifdef NETDATA_DEV_MODE - if (ebpf_aral_process_stat) - ebpf_send_data_aral_chart(ebpf_aral_process_stat, em); -#endif - if (cgroups && shm_ebpf_cgroup.header) { ebpf_process_send_cgroup_data(em); } @@ -1240,8 +1194,6 @@ static void ebpf_process_allocate_global_vectors(size_t length) memset(process_publish_aggregated, 0, length * sizeof(netdata_publish_syscall_t)); process_hash_values = callocz(ebpf_nprocs, sizeof(netdata_idx_t)); process_stat_vector = callocz(ebpf_nprocs, sizeof(ebpf_process_stat_t)); - - global_process_stats = callocz((size_t)pid_max, sizeof(ebpf_process_stat_t *)); } static void change_syscalls() @@ -1351,11 +1303,6 @@ void *ebpf_process_thread(void *ptr) 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_process_stat) - process_disable_priority = ebpf_statistic_create_aral_chart(NETDATA_EBPF_PROC_ARAL_NAME, em); -#endif - pthread_mutex_unlock(&lock); process_collector(em); |