diff options
Diffstat (limited to '')
| -rw-r--r-- | src/collectors/ebpf.plugin/ebpf_vfs.c (renamed from collectors/ebpf.plugin/ebpf_vfs.c) | 765 |
1 files changed, 435 insertions, 330 deletions
diff --git a/collectors/ebpf.plugin/ebpf_vfs.c b/src/collectors/ebpf.plugin/ebpf_vfs.c index 354901c9c..cb7500aab 100644 --- a/collectors/ebpf.plugin/ebpf_vfs.c +++ b/src/collectors/ebpf.plugin/ebpf_vfs.c @@ -1,7 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-or-later -#include <sys/resource.h> - #include "ebpf.h" #include "ebpf_vfs.h" @@ -43,6 +41,17 @@ static ebpf_local_maps_t vfs_maps[] = {{.name = "tbl_vfs_pid", .internal_input = #endif }}; +struct netdata_static_thread ebpf_read_vfs = { + .name = "EBPF_READ_VFS", + .config_section = NULL, + .config_name = NULL, + .env_name = NULL, + .enabled = 1, + .thread = NULL, + .init_routine = NULL, + .start_routine = NULL +}; + struct config vfs_config = { .first_section = NULL, .last_section = NULL, .mutex = NETDATA_MUTEX_INITIALIZER, @@ -60,10 +69,6 @@ netdata_ebpf_targets_t vfs_targets[] = { {.name = "vfs_write", .mode = EBPF_LOAD {.name = "release_task", .mode = EBPF_LOAD_TRAMPOLINE}, {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}}; -#ifdef NETDATA_DEV_MODE -int vfs_disable_priority; -#endif - #ifdef LIBBPF_MAJOR_VERSION /** * Disable probe @@ -90,7 +95,6 @@ static void ebpf_vfs_disable_probes(struct vfs_bpf *obj) bpf_program__set_autoload(obj->progs.netdata_vfs_open_kretprobe, false); bpf_program__set_autoload(obj->progs.netdata_vfs_create_kprobe, false); bpf_program__set_autoload(obj->progs.netdata_vfs_create_kretprobe, false); - bpf_program__set_autoload(obj->progs.netdata_vfs_release_task_kprobe, false); } /* @@ -116,7 +120,6 @@ static void ebpf_vfs_disable_trampoline(struct vfs_bpf *obj) bpf_program__set_autoload(obj->progs.netdata_vfs_open_fentry, false); bpf_program__set_autoload(obj->progs.netdata_vfs_open_fexit, false); bpf_program__set_autoload(obj->progs.netdata_vfs_create_fentry, false); - bpf_program__set_autoload(obj->progs.netdata_vfs_release_task_fentry, false); } /** @@ -155,8 +158,6 @@ static void ebpf_vfs_set_trampoline_target(struct vfs_bpf *obj) bpf_program__set_attach_target(obj->progs.netdata_vfs_open_fexit, 0, vfs_targets[NETDATA_EBPF_VFS_OPEN].name); bpf_program__set_attach_target(obj->progs.netdata_vfs_create_fentry, 0, vfs_targets[NETDATA_EBPF_VFS_CREATE].name); - - bpf_program__set_attach_target(obj->progs.netdata_vfs_release_task_fentry, 0, EBPF_COMMON_FNCT_CLEAN_UP); } /** @@ -172,7 +173,7 @@ static int ebpf_vfs_attach_probe(struct vfs_bpf *obj) { obj->links.netdata_vfs_write_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_write_kprobe, false, vfs_targets[NETDATA_EBPF_VFS_WRITE].name); - int ret = libbpf_get_error(obj->links.netdata_vfs_write_kprobe); + long ret = libbpf_get_error(obj->links.netdata_vfs_write_kprobe); if (ret) return -1; @@ -302,13 +303,6 @@ static int ebpf_vfs_attach_probe(struct vfs_bpf *obj) if (ret) return -1; - obj->links.netdata_vfs_release_task_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_release_task_fentry, - true, - EBPF_COMMON_FNCT_CLEAN_UP); - ret = libbpf_get_error(obj->links.netdata_vfs_release_task_kprobe); - if (ret) - return -1; - return 0; } @@ -345,19 +339,6 @@ static void ebpf_vfs_set_hash_tables(struct vfs_bpf *obj) } /** - * Disable Release Task - * - * Disable release task when apps is not enabled. - * - * @param obj is the main structure for bpf objects. - */ -static void ebpf_vfs_disable_release_task(struct vfs_bpf *obj) -{ - bpf_program__set_autoload(obj->progs.netdata_vfs_release_task_fentry, false); - bpf_program__set_autoload(obj->progs.netdata_vfs_release_task_kprobe, false); -} - -/** * Load and attach * * Load and attach the eBPF code in kernel. @@ -382,9 +363,6 @@ static inline int ebpf_vfs_load_and_attach(struct vfs_bpf *obj, ebpf_module_t *e ebpf_vfs_adjust_map(obj, em); - if (!em->apps_charts && !em->cgroup_charts) - ebpf_vfs_disable_release_task(obj); - int ret = vfs_bpf__load(obj); if (ret) { return ret; @@ -416,25 +394,25 @@ static void ebpf_obsolete_specific_vfs_charts(char *type, ebpf_module_t *em); * * @param em a pointer to `struct ebpf_module` */ -static void ebpf_obsolete_vfs_services(ebpf_module_t *em) +static void ebpf_obsolete_vfs_services(ebpf_module_t *em, char *id) { ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_FILE_DELETED, - "", "Files deleted", EBPF_COMMON_DIMENSION_CALL, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20065, em->update_every); ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, - "", "Write to disk", EBPF_COMMON_DIMENSION_CALL, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20066, @@ -442,11 +420,11 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em) if (em->mode < MODE_ENTRY) { ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, - "", "Fails to write", EBPF_COMMON_DIMENSION_CALL, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20067, @@ -454,11 +432,11 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em) } ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, - "", "Read from disk", EBPF_COMMON_DIMENSION_CALL, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20068, @@ -466,11 +444,11 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em) if (em->mode < MODE_ENTRY) { ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, - "", "Fails to read", EBPF_COMMON_DIMENSION_CALL, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20069, @@ -478,33 +456,33 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em) } ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, - "", "Bytes written on disk", EBPF_COMMON_DIMENSION_BYTES, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20070, em->update_every); ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, - "", "Bytes read from disk", EBPF_COMMON_DIMENSION_BYTES, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20071, em->update_every); ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_VFS_FSYNC, - "", "Calls to vfs_fsync.", EBPF_COMMON_DIMENSION_CALL, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20072, @@ -512,22 +490,22 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em) if (em->mode < MODE_ENTRY) { ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, - "", "Sync error", EBPF_COMMON_DIMENSION_CALL, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20073, em->update_every); } ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_VFS_OPEN, - "", "Calls to vfs_open.", EBPF_COMMON_DIMENSION_CALL, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20074, @@ -535,11 +513,11 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em) if (em->mode < MODE_ENTRY) { ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, - "", "Open error", EBPF_COMMON_DIMENSION_CALL, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20075, @@ -547,11 +525,11 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em) } ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_VFS_CREATE, - "", "Calls to vfs_create.", EBPF_COMMON_DIMENSION_CALL, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20076, @@ -559,11 +537,11 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em) if (em->mode < MODE_ENTRY) { ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, - "", "Create error", EBPF_COMMON_DIMENSION_CALL, - NETDATA_VFS_CGROUP_GROUP, + NETDATA_VFS_GROUP, NETDATA_EBPF_CHART_TYPE_STACKED, NULL, 20077, @@ -581,12 +559,13 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em) static inline void ebpf_obsolete_vfs_cgroup_charts(ebpf_module_t *em) { pthread_mutex_lock(&mutex_cgroup_shm); - ebpf_obsolete_vfs_services(em); - ebpf_cgroup_target_t *ect; for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (ect->systemd) + if (ect->systemd) { + ebpf_obsolete_vfs_services(em, ect->name); + continue; + } ebpf_obsolete_specific_vfs_charts(ect->name, em); } @@ -605,6 +584,7 @@ void ebpf_obsolete_vfs_apps_charts(struct ebpf_module *em) int order = 20275; 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_VFS_IDX)))) continue; @@ -763,6 +743,7 @@ void ebpf_obsolete_vfs_apps_charts(struct ebpf_module *em) } w->charts_created &= ~(1<<EBPF_MODULE_VFS_IDX); } + pthread_mutex_unlock(&collect_data_mutex); } /** @@ -904,6 +885,9 @@ static void ebpf_vfs_exit(void *ptr) { ebpf_module_t *em = (ebpf_module_t *)ptr; + if (ebpf_read_vfs.thread) + netdata_thread_cancel(*ebpf_read_vfs.thread); + if (em->enabled == NETDATA_THREAD_EBPF_FUNCTION_RUNNING) { pthread_mutex_lock(&lock); if (em->cgroup_charts) { @@ -917,11 +901,6 @@ static void ebpf_vfs_exit(void *ptr) ebpf_obsolete_vfs_global(em); -#ifdef NETDATA_DEV_MODE - if (ebpf_aral_vfs_pid) - ebpf_statistic_obsolete_aral_chart(em, vfs_disable_priority); -#endif - fflush(stdout); pthread_mutex_unlock(&lock); } @@ -1068,8 +1047,9 @@ static void ebpf_vfs_sum_pids(netdata_publish_vfs_t *vfs, struct ebpf_pid_on_tar while (root) { int32_t pid = root->pid; - netdata_publish_vfs_t *w = vfs_pid[pid]; - if (w) { + ebpf_pid_stat_t *local_pid = ebpf_get_pid_entry(pid, 0); + if (local_pid) { + netdata_publish_vfs_t *w = &local_pid->vfs; accumulator.write_call += w->write_call; accumulator.writev_call += w->writev_call; accumulator.read_call += w->read_call; @@ -1130,12 +1110,11 @@ static void ebpf_vfs_sum_pids(netdata_publish_vfs_t *vfs, struct ebpf_pid_on_tar void ebpf_vfs_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_VFS_IDX)))) continue; - ebpf_vfs_sum_pids(&w->vfs, w->root_pid); - ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_unlink"); write_chart_dimension("calls", w->vfs.unlink_call); ebpf_write_end_chart(); @@ -1198,6 +1177,7 @@ void ebpf_vfs_send_apps_data(ebpf_module_t *em, struct ebpf_target *root) ebpf_write_end_chart(); } } + pthread_mutex_unlock(&collect_data_mutex); } /** @@ -1234,52 +1214,41 @@ static void vfs_apps_accumulator(netdata_publish_vfs_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 vfs_fill_pid(uint32_t current_pid, netdata_publish_vfs_t *publish) -{ - netdata_publish_vfs_t *curr = vfs_pid[current_pid]; - if (!curr) { - curr = ebpf_vfs_get(); - vfs_pid[current_pid] = curr; - } - - memcpy(curr, &publish[0], sizeof(netdata_publish_vfs_t)); -} - -/** * Read the hash table and store data to allocated vectors. */ -static void ebpf_vfs_read_apps(int maps_per_core) +static void ebpf_vfs_read_apps(int maps_per_core, int max_period) { - struct ebpf_pid_stat *pids = ebpf_root_of_pids; netdata_publish_vfs_t *vv = vfs_vector; int fd = vfs_maps[NETDATA_VFS_PID].map_fd; size_t length = sizeof(netdata_publish_vfs_t); if (maps_per_core) length *= ebpf_nprocs; - while (pids) { - uint32_t 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, vv)) { - pids = pids->next; - continue; + goto end_vfs_loop; } vfs_apps_accumulator(vv, maps_per_core); - vfs_fill_pid(key, vv); + ebpf_pid_stat_t *local_pid = ebpf_get_pid_entry(key, vv->tgid); + if (!local_pid) + goto end_vfs_loop; + + netdata_publish_vfs_t *publish = &local_pid->vfs; + if (!publish->ct || publish->ct != vv->ct) { + memcpy(publish, vv, sizeof(netdata_publish_vfs_t)); + local_pid->not_updated = 0; + } else if (++local_pid->not_updated >= max_period){ + bpf_map_delete_elem(fd, &key); + local_pid->not_updated = 0; + } +end_vfs_loop: // We are cleaning to avoid passing data read from one process to other. memset(vv, 0, length); - - pids = pids->next; + key = next_key; } } @@ -1290,32 +1259,20 @@ static void ebpf_vfs_read_apps(int maps_per_core) * * @param maps_per_core do I need to read all cores? */ -static void read_update_vfs_cgroup(int maps_per_core) +static void read_update_vfs_cgroup() { ebpf_cgroup_target_t *ect ; - netdata_publish_vfs_t *vv = vfs_vector; - int fd = vfs_maps[NETDATA_VFS_PID].map_fd; - size_t length = sizeof(netdata_publish_vfs_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; netdata_publish_vfs_t *out = &pids->vfs; - if (likely(vfs_pid) && vfs_pid[pid]) { - netdata_publish_vfs_t *in = vfs_pid[pid]; + ebpf_pid_stat_t *local_pid = ebpf_get_pid_entry(pid, 0); + if (local_pid) { + netdata_publish_vfs_t *in = &local_pid->vfs; memcpy(out, in, sizeof(netdata_publish_vfs_t)); - } else { - memset(vv, 0, length); - if (!bpf_map_lookup_elem(fd, &pid, vv)) { - vfs_apps_accumulator(vv, maps_per_core); - - memcpy(out, vv, sizeof(netdata_publish_vfs_t)); - } } } } @@ -1400,88 +1357,88 @@ static void ebpf_vfs_sum_cgroup_pids(netdata_publish_vfs_t *vfs, struct pid_on_t static void ebpf_create_specific_vfs_charts(char *type, ebpf_module_t *em) { ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_DELETED,"Files deleted", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_UNLINK_CONTEXT, + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_UNLINK_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5500, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_UNLINK], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "Write to disk", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_WRITE_CONTEXT, + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_WRITE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5501, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); if (em->mode < MODE_ENTRY) { ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "Fails to write", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_WRITE_ERROR_CONTEXT, + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_WRITE_ERROR_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5502, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); } ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "Read from disk", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_READ_CONTEXT, + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_READ_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5503, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); if (em->mode < MODE_ENTRY) { ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "Fails to read", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_READ_ERROR_CONTEXT, + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_READ_ERROR_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5504, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); } ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "Bytes written on disk", - EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_WRITE_BYTES_CONTEXT, + EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_WRITE_BYTES_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5505, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "Bytes read from disk", - EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_READ_BYTES_CONTEXT, + EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_READ_BYTES_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5506, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC, "Calls to vfs_fsync.", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_FSYNC_CONTEXT, + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_FSYNC_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5507, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); if (em->mode < MODE_ENTRY) { ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, "Sync error", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_FSYNC_ERROR_CONTEXT, + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_FSYNC_ERROR_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5508, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); } ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN, "Calls to vfs_open.", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_OPEN_CONTEXT, + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_OPEN_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5509, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); if (em->mode < MODE_ENTRY) { ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, "Open error", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_OPEN_ERROR_CONTEXT, + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_OPEN_ERROR_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5510, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); } ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE, "Calls to vfs_create.", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_CREATE_CONTEXT, + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_CREATE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5511, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); if (em->mode < MODE_ENTRY) { ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, "Create error", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_CREATE_ERROR_CONTEXT, + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_CREATE_ERROR_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5512, ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE], 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS); @@ -1668,93 +1625,235 @@ static void ebpf_send_specific_vfs_data(char *type, netdata_publish_vfs_t *value **/ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em) { - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_FILE_DELETED, "Files deleted", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20065, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_UNLINK_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); - - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "Write to disk", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20066, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_WRITE_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); + static ebpf_systemd_args_t data_vfs_unlink = { + .title = "Files deleted", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20065, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_UNLINK_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_FILE_DELETED, + .dimension = "calls" + }; - if (em->mode < MODE_ENTRY) { - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "Fails to write", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20067, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], - NETDATA_SYSTEMD_VFS_WRITE_ERROR_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); - } + static ebpf_systemd_args_t data_vfs_write = { + .title = "Write to disk", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20066, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_WRITE_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, + .dimension = "calls" + }; - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "Read from disk", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20068, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_READ_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); + static ebpf_systemd_args_t data_vfs_write_err = { + .title = "Fails to write", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20067, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_WRITE_ERROR_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, + .dimension = "calls" + }; - if (em->mode < MODE_ENTRY) { - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "Fails to read", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20069, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], - NETDATA_SYSTEMD_VFS_READ_ERROR_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); - } + static ebpf_systemd_args_t data_vfs_read = { + .title = "Read from disk", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20068, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_READ_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_VFS_READ_CALLS, + .dimension = "calls" + }; - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "Bytes written on disk", - EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20070, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_WRITE_BYTES_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); + static ebpf_systemd_args_t data_vfs_read_err = { + .title = "Fails to read", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20069, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_READ_ERROR_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, + .dimension = "calls" + }; - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "Bytes read from disk", - EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20071, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_READ_BYTES_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); + static ebpf_systemd_args_t data_vfs_write_bytes = { + .title = "Bytes written on disk", + .units = EBPF_COMMON_DIMENSION_BYTES, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20070, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_WRITE_BYTES_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, + .dimension = "bytes" + }; - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_FSYNC, "Calls to vfs_fsync.", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20072, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_FSYNC_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); + static ebpf_systemd_args_t data_vfs_read_bytes = { + .title = "Bytes read from disk", + .units = EBPF_COMMON_DIMENSION_BYTES, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20071, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_READ_BYTES_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_VFS_READ_BYTES, + .dimension = "bytes" + }; - if (em->mode < MODE_ENTRY) { - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, "Sync error", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20073, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_FSYNC_ERROR_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); - } - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_OPEN, "Calls to vfs_open.", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20074, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_OPEN_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); + static ebpf_systemd_args_t data_vfs_fsync = { + .title = "Calls to vfs_fsync.", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20072, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_FSYNC_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_VFS_FSYNC, + .dimension = "calls" + }; - if (em->mode < MODE_ENTRY) { - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, "Open error", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20075, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_OPEN_ERROR_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); - } + static ebpf_systemd_args_t data_vfs_fsync_err = { + .title = "Sync error", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20073, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_FSYNC_ERROR_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, + .dimension = "calls" + }; - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_CREATE, "Calls to vfs_create.", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20076, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_CREATE_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); + static ebpf_systemd_args_t data_vfs_open = { + .title = "Calls to vfs_open.", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20074, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_OPEN_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_VFS_OPEN, + .dimension = "calls" + }; - if (em->mode < MODE_ENTRY) { - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, "Create error", - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, 20077, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_CREATE_ERROR_CONTEXT, - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every); + static ebpf_systemd_args_t data_vfs_open_err = { + .title = "Open error", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20075, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_OPEN_ERROR_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, + .dimension = "calls" + }; + + static ebpf_systemd_args_t data_vfs_create = { + .title = "Calls to vfs_create.", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20076, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_CREATE_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_VFS_CREATE, + .dimension = "calls" + }; + + static ebpf_systemd_args_t data_vfs_create_err = { + .title = "Create error", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_VFS_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20077, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SYSTEMD_VFS_CREATE_ERROR_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_VFS, + .update_every = 0, + .suffix = NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, + .dimension = "calls" + }; + + if (!data_vfs_create.update_every) + data_vfs_unlink.update_every = data_vfs_write.update_every = data_vfs_write_err.update_every = + data_vfs_read.update_every = data_vfs_read_err.update_every = data_vfs_write_bytes.update_every = + data_vfs_read_bytes.update_every = data_vfs_fsync.update_every = data_vfs_fsync_err.update_every = + data_vfs_open.update_every = data_vfs_open_err.update_every = data_vfs_create.update_every = + data_vfs_create_err.update_every = em->update_every; + + ebpf_cgroup_target_t *w; + for (w = ebpf_cgroup_pids; w ; w = w->next) { + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_VFS_CHART)) + continue; + + data_vfs_unlink.id = data_vfs_write.id = data_vfs_write_err.id = + data_vfs_read.id = data_vfs_read_err.id = data_vfs_write_bytes.id = data_vfs_read_bytes.id = + data_vfs_fsync.id = data_vfs_fsync_err.id = data_vfs_open.id = + data_vfs_open_err.id = data_vfs_create.id = data_vfs_create_err.id = w->name; + ebpf_create_charts_on_systemd(&data_vfs_unlink); + + ebpf_create_charts_on_systemd(&data_vfs_write); + if (em->mode < MODE_ENTRY) { + ebpf_create_charts_on_systemd(&data_vfs_write_err); + } + + ebpf_create_charts_on_systemd(&data_vfs_read); + if (em->mode < MODE_ENTRY) { + ebpf_create_charts_on_systemd(&data_vfs_read_err); + } + + ebpf_create_charts_on_systemd(&data_vfs_write_bytes); + ebpf_create_charts_on_systemd(&data_vfs_read_bytes); + + ebpf_create_charts_on_systemd(&data_vfs_fsync); + if (em->mode < MODE_ENTRY) { + ebpf_create_charts_on_systemd(&data_vfs_fsync_err); + } + + ebpf_create_charts_on_systemd(&data_vfs_open); + if (em->mode < MODE_ENTRY) { + ebpf_create_charts_on_systemd(&data_vfs_open_err); + } + + ebpf_create_charts_on_systemd(&data_vfs_create); + if (em->mode < MODE_ENTRY) { + ebpf_create_charts_on_systemd(&data_vfs_create_err); + } + + w->flags |= NETDATA_EBPF_SERVICES_HAS_VFS_CHART; } } @@ -1768,124 +1867,78 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em) static void ebpf_send_systemd_vfs_charts(ebpf_module_t *em) { ebpf_cgroup_target_t *ect; - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_DELETED, ""); for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_vfs.unlink_call); + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_VFS_CHART)) ) { + continue; } - } - ebpf_write_end_chart(); - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_vfs.write_call + - ect->publish_systemd_vfs.writev_call); - } - } - ebpf_write_end_chart(); + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_FILE_DELETED); + write_chart_dimension("calls", ect->publish_systemd_vfs.unlink_call); + ebpf_write_end_chart(); - if (em->mode < MODE_ENTRY) { - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_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_vfs.write_err + - ect->publish_systemd_vfs.writev_err); - } - } + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS); + write_chart_dimension("calls", ect->publish_systemd_vfs.write_call + + ect->publish_systemd_vfs.writev_call); ebpf_write_end_chart(); - } - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_vfs.read_call + - ect->publish_systemd_vfs.readv_call); + if (em->mode < MODE_ENTRY) { + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR); + write_chart_dimension("calls", ect->publish_systemd_vfs.write_err + + ect->publish_systemd_vfs.writev_err); + ebpf_write_end_chart(); } - } - ebpf_write_end_chart(); - if (em->mode < MODE_ENTRY) { - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_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_vfs.read_err + - ect->publish_systemd_vfs.readv_err); - } - } + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_READ_CALLS); + write_chart_dimension("calls", ect->publish_systemd_vfs.read_call + + ect->publish_systemd_vfs.readv_call); ebpf_write_end_chart(); - } - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_vfs.write_bytes + - ect->publish_systemd_vfs.writev_bytes); + if (em->mode < MODE_ENTRY) { + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR); + write_chart_dimension("calls", ect->publish_systemd_vfs.read_err + + ect->publish_systemd_vfs.readv_err); + ebpf_write_end_chart(); } - } - ebpf_write_end_chart(); - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_vfs.read_bytes + - ect->publish_systemd_vfs.readv_bytes); - } - } - ebpf_write_end_chart(); + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES); + write_chart_dimension("bytes", ect->publish_systemd_vfs.write_bytes + + ect->publish_systemd_vfs.writev_bytes); + ebpf_write_end_chart(); - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_FSYNC, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_vfs.fsync_call); - } - } - ebpf_write_end_chart(); + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_READ_BYTES); + write_chart_dimension("bytes", ect->publish_systemd_vfs.read_bytes + + ect->publish_systemd_vfs.readv_bytes); + ebpf_write_end_chart(); - if (em->mode < MODE_ENTRY) { - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_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_vfs.fsync_err); - } - } + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_FSYNC); + write_chart_dimension("calls", ect->publish_systemd_vfs.fsync_call); ebpf_write_end_chart(); - } - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_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_vfs.open_call); + if (em->mode < MODE_ENTRY) { + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR); + write_chart_dimension("calls", ect->publish_systemd_vfs.fsync_err); + ebpf_write_end_chart(); } - } - ebpf_write_end_chart(); - if (em->mode < MODE_ENTRY) { - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_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_vfs.open_err); - } - } + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_OPEN); + write_chart_dimension("calls", ect->publish_systemd_vfs.open_call); ebpf_write_end_chart(); - } - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_CREATE, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, ect->publish_systemd_vfs.create_call); + if (em->mode < MODE_ENTRY) { + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR); + write_chart_dimension("calls", ect->publish_systemd_vfs.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_VFS_CREATE_CALLS_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_vfs.create_err); - } - } + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_CREATE); + write_chart_dimension("calls", ect->publish_systemd_vfs.create_call); ebpf_write_end_chart(); + + if (em->mode < MODE_ENTRY) { + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR); + write_chart_dimension("calls", ect->publish_systemd_vfs.create_err); + ebpf_write_end_chart(); + } } } @@ -1896,17 +1949,13 @@ static void ebpf_send_systemd_vfs_charts(ebpf_module_t *em) */ static void ebpf_vfs_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_vfs_sum_cgroup_pids(&ect->publish_systemd_vfs, 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_vfs_charts(em); } @@ -1936,6 +1985,72 @@ static void ebpf_vfs_send_cgroup_data(ebpf_module_t *em) } /** + * Resume apps data + */ +void ebpf_vfs_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_VFS_IDX)))) + continue; + + ebpf_vfs_sum_pids(&w->vfs, w->root_pid); + } +} + +/** + * VFS thread + * + * Thread used to generate charts. + * + * @param ptr a pointer to `struct ebpf_module` + * + * @return It always return NULL + */ +void *ebpf_read_vfs_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_vfs_read_apps(maps_per_core, max_period); + ebpf_vfs_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; +} + +/** * Main loop for this collector. * * @param step the number of microseconds used with heart beat @@ -1961,31 +2076,22 @@ static void vfs_collector(ebpf_module_t *em) counter = 0; netdata_apps_integration_flags_t apps = em->apps_charts; ebpf_vfs_read_global_table(stats, maps_per_core); - pthread_mutex_lock(&collect_data_mutex); - if (apps) - ebpf_vfs_read_apps(maps_per_core); if (cgroups) - read_update_vfs_cgroup(maps_per_core); + read_update_vfs_cgroup(); pthread_mutex_lock(&lock); -#ifdef NETDATA_DEV_MODE - if (ebpf_aral_vfs_pid) - ebpf_send_data_aral_chart(ebpf_aral_vfs_pid, em); -#endif - ebpf_vfs_send_data(em); fflush(stdout); if (apps & NETDATA_EBPF_APPS_FLAG_CHART_CREATED) ebpf_vfs_send_apps_data(em, apps_groups_root_target); - if (cgroups) + if (cgroups && shm_ebpf_cgroup.header && ebpf_cgroup_pids) ebpf_vfs_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) @@ -2412,13 +2518,9 @@ void ebpf_vfs_create_apps_charts(struct ebpf_module *em, void *ptr) * * @param apps is apps enabled? */ -static void ebpf_vfs_allocate_global_vectors(int apps) +static void ebpf_vfs_allocate_global_vectors() { - if (apps) { - ebpf_vfs_aral_init(); - vfs_pid = callocz((size_t)pid_max, sizeof(netdata_publish_vfs_t *)); - vfs_vector = callocz(ebpf_nprocs, sizeof(netdata_publish_vfs_t)); - } + vfs_vector = callocz(ebpf_nprocs, sizeof(netdata_publish_vfs_t)); memset(vfs_aggregated_data, 0, sizeof(vfs_aggregated_data)); memset(vfs_publish_aggregated, 0, sizeof(vfs_publish_aggregated)); @@ -2484,7 +2586,7 @@ void *ebpf_vfs_thread(void *ptr) ebpf_update_pid_table(&vfs_maps[NETDATA_VFS_PID], em); - ebpf_vfs_allocate_global_vectors(em->apps_charts); + ebpf_vfs_allocate_global_vectors(); #ifdef LIBBPF_MAJOR_VERSION ebpf_adjust_thread_load(em, default_btf); @@ -2505,13 +2607,16 @@ void *ebpf_vfs_thread(void *ptr) ebpf_create_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_vfs_pid) - vfs_disable_priority = ebpf_statistic_create_aral_chart(NETDATA_EBPF_VFS_ARAL_NAME, em); -#endif pthread_mutex_unlock(&lock); + ebpf_read_vfs.thread = mallocz(sizeof(netdata_thread_t)); + netdata_thread_create(ebpf_read_vfs.thread, + ebpf_read_vfs.name, + NETDATA_THREAD_OPTION_DEFAULT, + ebpf_read_vfs_thread, + em); + vfs_collector(em); endvfs: |