summaryrefslogtreecommitdiffstats
path: root/src/collectors/ebpf.plugin/ebpf_fd.c
diff options
context:
space:
mode:
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:
generated by cgit v1.2.3 (git 2.39.1) at 2024-08-21 23:33:31 +0000