@cryptotaxi247 / netdata-1 / commits / 8e446dc58

eBPF cgroup update (#16630)

thiagoftsm committed Mar 7, 2024 at 11:07 UTC 8e446dc58575757e529d91d4a64b68beeb2f98bb
25 files changed +1340 -972
src/collectors/cgroups.plugin/cgroup-discovery.c
+83
@@ -25,6 +25,10 @@ char cgroup_chart_id_prefix[] = "cgroup_";
25 char services_chart_id_prefix[] = "systemd_";
26 char *cgroups_rename_script = NULL;
27
28 +// Shared memory with information from detected cgroups
29 +netdata_ebpf_cgroup_shm_t shm_cgroup_ebpf = {NULL, NULL};
30 +int shm_fd_cgroup_ebpf = -1;
31 +sem_t *shm_mutex_cgroup_ebpf = SEM_FAILED;
32
33 // ----------------------------------------------------------------------------
34
@@ -1026,6 +1030,82 @@ static int discovery_is_cgroup_duplicate(struct cgroup *cg) {
1030 return 0;
1031 }
1032
1033 +// ----------------------------------------------------------------------------
1034 +// ebpf shared memory
1035 +
1036 +static void netdata_cgroup_ebpf_set_values(size_t length)
1037 +{
1038 + sem_wait(shm_mutex_cgroup_ebpf);
1039 +
1040 + shm_cgroup_ebpf.header->cgroup_max = cgroup_root_max;
1041 + shm_cgroup_ebpf.header->systemd_enabled = cgroup_enable_systemd_services |
1042 + cgroup_enable_systemd_services_detailed_memory |
1043 + cgroup_used_memory;
1044 + shm_cgroup_ebpf.header->body_length = length;
1045 +
1046 + sem_post(shm_mutex_cgroup_ebpf);
1047 +}
1048 +
1049 +static void netdata_cgroup_ebpf_initialize_shm()
1050 +{
1051 + shm_fd_cgroup_ebpf = shm_open(NETDATA_SHARED_MEMORY_EBPF_CGROUP_NAME, O_CREAT | O_RDWR, 0660);
1052 + if (shm_fd_cgroup_ebpf < 0) {
1053 + collector_error("Cannot initialize shared memory used by cgroup and eBPF, integration won't happen.");
1054 + return;
1055 + }
1056 +
1057 + size_t length = sizeof(netdata_ebpf_cgroup_shm_header_t) + cgroup_root_max * sizeof(netdata_ebpf_cgroup_shm_body_t);
1058 + if (ftruncate(shm_fd_cgroup_ebpf, length)) {
1059 + collector_error("Cannot set size for shared memory.");
1060 + goto end_init_shm;
1061 + }
1062 +
1063 + shm_cgroup_ebpf.header = (netdata_ebpf_cgroup_shm_header_t *) mmap(NULL, length,
1064 + PROT_READ | PROT_WRITE, MAP_SHARED,
1065 + shm_fd_cgroup_ebpf, 0);
1066 +
1067 + if (unlikely(MAP_FAILED == shm_cgroup_ebpf.header)) {
1068 + shm_cgroup_ebpf.header = NULL;
1069 + collector_error("Cannot map shared memory used between cgroup and eBPF, integration won't happen");
1070 + goto end_init_shm;
1071 + }
1072 + shm_cgroup_ebpf.body = (netdata_ebpf_cgroup_shm_body_t *) ((char *)shm_cgroup_ebpf.header +
1073 + sizeof(netdata_ebpf_cgroup_shm_header_t));
1074 +
1075 + shm_mutex_cgroup_ebpf = sem_open(NETDATA_NAMED_SEMAPHORE_EBPF_CGROUP_NAME, O_CREAT,
1076 + S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH, 1);
1077 +
1078 + if (shm_mutex_cgroup_ebpf != SEM_FAILED) {
1079 + netdata_cgroup_ebpf_set_values(length);
1080 + return;
1081 + }
1082 +
1083 + collector_error("Cannot create semaphore, integration between eBPF and cgroup won't happen");
1084 + munmap(shm_cgroup_ebpf.header, length);
1085 + shm_cgroup_ebpf.header = NULL;
1086 +
1087 + end_init_shm:
1088 + close(shm_fd_cgroup_ebpf);
1089 + shm_fd_cgroup_ebpf = -1;
1090 + shm_unlink(NETDATA_SHARED_MEMORY_EBPF_CGROUP_NAME);
1091 +}
1092 +
1093 +static void cgroup_cleanup_ebpf_integration()
1094 +{
1095 + if (shm_mutex_cgroup_ebpf != SEM_FAILED) {
1096 + sem_close(shm_mutex_cgroup_ebpf);
1097 + }
1098 +
1099 + if (shm_cgroup_ebpf.header) {
1100 + shm_cgroup_ebpf.header->cgroup_root_count = 0;
1101 + munmap(shm_cgroup_ebpf.header, shm_cgroup_ebpf.header->body_length);
1102 + }
1103 +
1104 + if (shm_fd_cgroup_ebpf > 0) {
1105 + close(shm_fd_cgroup_ebpf);
1106 + }
1107 +}
1108 +
1109 // ----------------------------------------------------------------------------
1110 // cgroup network interfaces
1111
@@ -1231,6 +1311,8 @@ void cgroup_discovery_worker(void *ptr)
1311
1312 service_register(SERVICE_THREAD_TYPE_LIBUV, NULL, NULL, NULL, false);
1313
1314 + netdata_cgroup_ebpf_initialize_shm();
1315 +
1316 while (service_running(SERVICE_COLLECTORS)) {
1317 worker_is_idle();
1318
@@ -1244,6 +1326,7 @@ void cgroup_discovery_worker(void *ptr)
1326 discovery_find_all_cgroups();
1327 }
1328 collector_info("discovery thread stopped");
1329 + cgroup_cleanup_ebpf_integration();
1330 worker_unregister();
1331 service_exits();
1332 __atomic_store_n(&discovery_thread.exited,1,__ATOMIC_RELAXED);
src/collectors/cgroups.plugin/cgroup-internals.h
-4
@@ -386,10 +386,6 @@ extern uint32_t throttled_time_hash;
386 extern uint32_t throttled_usec_hash;
387 extern struct cgroup *cgroup_root;
388
389 -extern netdata_ebpf_cgroup_shm_t shm_cgroup_ebpf;
390 -extern int shm_fd_cgroup_ebpf;
391 -extern sem_t *shm_mutex_cgroup_ebpf;
392 -
389 enum cgroups_type { CGROUPS_AUTODETECT_FAIL, CGROUPS_V1, CGROUPS_V2 };
390
391 enum cgroups_systemd_setting {
src/collectors/cgroups.plugin/sys_fs_cgroup.c
-77
@@ -85,11 +85,6 @@ struct cgroups_systemd_config_setting cgroups_systemd_options[] = {
85 { .name = NULL, .setting = SYSTEMD_CGROUP_ERR },
86 };
87
88 -// Shared memory with information from detected cgroups
89 -netdata_ebpf_cgroup_shm_t shm_cgroup_ebpf = {NULL, NULL};
90 -int shm_fd_cgroup_ebpf = -1;
91 -sem_t *shm_mutex_cgroup_ebpf = SEM_FAILED;
92 -
88 struct discovery_thread discovery_thread;
89
90
@@ -528,63 +523,6 @@ void read_cgroup_plugin_configuration() {
523 mountinfo_free_all(root);
524 }
525
531 -void netdata_cgroup_ebpf_set_values(size_t length)
532 -{
533 - sem_wait(shm_mutex_cgroup_ebpf);
534 -
535 - shm_cgroup_ebpf.header->cgroup_max = cgroup_root_max;
536 - shm_cgroup_ebpf.header->systemd_enabled = cgroup_enable_systemd_services |
537 - cgroup_enable_systemd_services_detailed_memory |
538 - cgroup_used_memory;
539 - shm_cgroup_ebpf.header->body_length = length;
540 -
541 - sem_post(shm_mutex_cgroup_ebpf);
542 -}
543 -
544 -void netdata_cgroup_ebpf_initialize_shm()
545 -{
546 - shm_fd_cgroup_ebpf = shm_open(NETDATA_SHARED_MEMORY_EBPF_CGROUP_NAME, O_CREAT | O_RDWR, 0660);
547 - if (shm_fd_cgroup_ebpf < 0) {
548 - collector_error("Cannot initialize shared memory used by cgroup and eBPF, integration won't happen.");
549 - return;
550 - }
551 -
552 - size_t length = sizeof(netdata_ebpf_cgroup_shm_header_t) + cgroup_root_max * sizeof(netdata_ebpf_cgroup_shm_body_t);
553 - if (ftruncate(shm_fd_cgroup_ebpf, length)) {
554 - collector_error("Cannot set size for shared memory.");
555 - goto end_init_shm;
556 - }
557 -
558 - shm_cgroup_ebpf.header = (netdata_ebpf_cgroup_shm_header_t *) mmap(NULL, length,
559 - PROT_READ | PROT_WRITE, MAP_SHARED,
560 - shm_fd_cgroup_ebpf, 0);
561 -
562 - if (unlikely(MAP_FAILED == shm_cgroup_ebpf.header)) {
563 - shm_cgroup_ebpf.header = NULL;
564 - collector_error("Cannot map shared memory used between cgroup and eBPF, integration won't happen");
565 - goto end_init_shm;
566 - }
567 - shm_cgroup_ebpf.body = (netdata_ebpf_cgroup_shm_body_t *) ((char *)shm_cgroup_ebpf.header +
568 - sizeof(netdata_ebpf_cgroup_shm_header_t));
569 -
570 - shm_mutex_cgroup_ebpf = sem_open(NETDATA_NAMED_SEMAPHORE_EBPF_CGROUP_NAME, O_CREAT,
571 - S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH, 1);
572 -
573 - if (shm_mutex_cgroup_ebpf != SEM_FAILED) {
574 - netdata_cgroup_ebpf_set_values(length);
575 - return;
576 - }
577 -
578 - collector_error("Cannot create semaphore, integration between eBPF and cgroup won't happen");
579 - munmap(shm_cgroup_ebpf.header, length);
580 - shm_cgroup_ebpf.header = NULL;
581 -
582 -end_init_shm:
583 - close(shm_fd_cgroup_ebpf);
584 - shm_fd_cgroup_ebpf = -1;
585 - shm_unlink(NETDATA_SHARED_MEMORY_EBPF_CGROUP_NAME);
586 -}
587 -
526 // ---------------------------------------------------------------------------------------------
527
528 static unsigned long long calc_delta(unsigned long long curr, unsigned long long prev) {
@@ -1596,19 +1534,6 @@ static void cgroup_main_cleanup(void *ptr) {
1534 }
1535 }
1536
1599 - if (shm_mutex_cgroup_ebpf != SEM_FAILED) {
1600 - sem_close(shm_mutex_cgroup_ebpf);
1601 - }
1602 -
1603 - if (shm_cgroup_ebpf.header) {
1604 - shm_cgroup_ebpf.header->cgroup_root_count = 0;
1605 - munmap(shm_cgroup_ebpf.header, shm_cgroup_ebpf.header->body_length);
1606 - }
1607 -
1608 - if (shm_fd_cgroup_ebpf > 0) {
1609 - close(shm_fd_cgroup_ebpf);
1610 - }
1611 -
1537 static_thread->enabled = NETDATA_MAIN_THREAD_EXITED;
1538 }
1539
@@ -1645,8 +1570,6 @@ void *cgroups_main(void *ptr) {
1570
1571 cgroup_read_host_total_ram();
1572
1648 - netdata_cgroup_ebpf_initialize_shm();
1649 -
1573 if (uv_mutex_init(&cgroup_root_mutex)) {
1574 collector_error("CGROUP: cannot initialize mutex for the main cgroup list");
1575 goto exit;
src/collectors/ebpf.plugin/ebpf.c
+1 -1
@@ -18,7 +18,7 @@
18 char *ebpf_plugin_dir = PLUGINS_DIR;
19 static char *ebpf_configured_log_dir = LOG_DIR;
20
21 -char *ebpf_algorithms[] = {"absolute", "incremental"};
21 +char *ebpf_algorithms[] = { EBPF_CHART_ALGORITHM_ABSOLUTE, EBPF_CHART_ALGORITHM_INCREMENTAL};
22 struct config collector_config = { .first_section = NULL,
23 .last_section = NULL,
24 .mutex = NETDATA_MUTEX_INITIALIZER,
src/collectors/ebpf.plugin/ebpf.h
+3 -1
@@ -179,7 +179,6 @@ typedef struct ebpf_tracepoint {
179 #define NETDATA_EBPF_MEMORY_GROUP "mem"
180 #define NETDATA_EBPF_SYSTEM_GROUP "system"
181 #define NETDATA_SYSTEM_SWAP_SUBMENU "swap"
182 -#define NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU "swap (eBPF)"
182 #define NETDATA_SYSTEM_IPC_SHM_SUBMENU "ipc shared memory"
183 #define NETDATA_MONITORING_FAMILY "netdata"
184
@@ -341,6 +340,9 @@ void ebpf_pid_file(char *filename, size_t length);
340 #define EBPF_COMMON_DIMENSION_MILLISECONDS "milliseconds"
341 #define EBPF_COMMON_DIMENSION_KILLS "kills"
342
343 +#define EBPF_CHART_ALGORITHM_ABSOLUTE "absolute"
344 +#define EBPF_CHART_ALGORITHM_INCREMENTAL "incremental"
345 +
346 // Common variables
347 extern int debug_enabled;
348 extern struct ebpf_pid_stat *ebpf_root_of_pids;
src/collectors/ebpf.plugin/ebpf_apps.h
+1 -2
@@ -13,8 +13,7 @@
13 #define NETDATA_APP_FAMILY "app"
14 #define NETDATA_APPS_FILE_GROUP "file_access"
15 #define NETDATA_APPS_FILE_FDS "fds"
16 -#define NETDATA_APPS_FILE_CGROUP_GROUP "file_access (eBPF)"
17 -#define NETDATA_APPS_PROCESS_GROUP "process (eBPF)"
16 +#define NETDATA_APPS_PROCESS_GROUP "process"
17 #define NETDATA_APPS_NET_GROUP "net"
18 #define NETDATA_APPS_IPC_SHM_GROUP "ipc shm"
19
src/collectors/ebpf.plugin/ebpf_cachestat.c
+102 -68
@@ -328,11 +328,11 @@ static void ebpf_obsolete_specific_cachestat_charts(char *type, int update_every
328 *
329 * @param em a pointer to `struct ebpf_module`
330 */
331 -static void ebpf_obsolete_services(ebpf_module_t *em)
331 +static void ebpf_obsolete_cachestat_services(ebpf_module_t *em, char *id)
332 {
333 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
334 + id,
335 NETDATA_CACHESTAT_HIT_RATIO_CHART,
335 - "",
336 "Hit ratio",
337 EBPF_COMMON_DIMENSION_PERCENTAGE,
338 NETDATA_CACHESTAT_SUBMENU,
@@ -342,8 +342,8 @@ static void ebpf_obsolete_services(ebpf_module_t *em)
342 em->update_every);
343
344 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
345 + id,
346 NETDATA_CACHESTAT_DIRTY_CHART,
346 - "",
347 "Number of dirty pages",
348 EBPF_CACHESTAT_DIMENSION_PAGE,
349 NETDATA_CACHESTAT_SUBMENU,
@@ -353,8 +353,8 @@ static void ebpf_obsolete_services(ebpf_module_t *em)
353 em->update_every);
354
355 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
356 + id,
357 NETDATA_CACHESTAT_HIT_CHART,
357 - "",
358 "Number of accessed files",
359 EBPF_CACHESTAT_DIMENSION_HITS,
360 NETDATA_CACHESTAT_SUBMENU,
@@ -364,8 +364,8 @@ static void ebpf_obsolete_services(ebpf_module_t *em)
364 em->update_every);
365
366 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
367 + id,
368 NETDATA_CACHESTAT_MISSES_CHART,
368 - "",
369 "Files out of page cache",
370 EBPF_CACHESTAT_DIMENSION_MISSES,
371 NETDATA_CACHESTAT_SUBMENU,
@@ -385,12 +385,13 @@ static void ebpf_obsolete_services(ebpf_module_t *em)
385 static inline void ebpf_obsolete_cachestat_cgroup_charts(ebpf_module_t *em) {
386 pthread_mutex_lock(&mutex_cgroup_shm);
387
388 - ebpf_obsolete_services(em);
389 -
388 ebpf_cgroup_target_t *ect;
389 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
392 - if (ect->systemd)
390 + if (ect->systemd) {
391 + ebpf_obsolete_cachestat_services(em, ect->name);
392 +
393 continue;
394 + }
395
396 ebpf_obsolete_specific_cachestat_charts(ect->name, em->update_every);
397 }
@@ -1114,35 +1115,82 @@ void ebpf_cachestat_calc_chart_values()
1115 **/
1116 static void ebpf_create_systemd_cachestat_charts(int update_every)
1117 {
1117 - ebpf_create_charts_on_systemd(NETDATA_CACHESTAT_HIT_RATIO_CHART,
1118 - "Hit ratio",
1119 - EBPF_COMMON_DIMENSION_PERCENTAGE, NETDATA_CACHESTAT_SUBMENU,
1120 - NETDATA_EBPF_CHART_TYPE_LINE, 21100,
1121 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
1122 - NETDATA_SYSTEMD_CACHESTAT_HIT_RATIO_CONTEXT, NETDATA_EBPF_MODULE_NAME_CACHESTAT,
1123 - update_every);
1118 + static ebpf_systemd_args_t data_hit_ratio = {
1119 + .title = "Hit ratio",
1120 + .units = EBPF_COMMON_DIMENSION_PERCENTAGE,
1121 + .family = NETDATA_CACHESTAT_SUBMENU,
1122 + .charttype = NETDATA_EBPF_CHART_TYPE_LINE,
1123 + .order = 21100,
1124 + .algorithm = EBPF_CHART_ALGORITHM_ABSOLUTE,
1125 + .context = NETDATA_SYSTEMD_CACHESTAT_HIT_RATIO_CONTEXT,
1126 + .module = NETDATA_EBPF_MODULE_NAME_CACHESTAT,
1127 + .update_every = 0,
1128 + .suffix = NETDATA_CACHESTAT_HIT_RATIO_CHART,
1129 + .dimension = "percentage"
1130 + };
1131
1125 - ebpf_create_charts_on_systemd(NETDATA_CACHESTAT_DIRTY_CHART,
1126 - "Number of dirty pages",
1127 - EBPF_CACHESTAT_DIMENSION_PAGE, NETDATA_CACHESTAT_SUBMENU,
1128 - NETDATA_EBPF_CHART_TYPE_LINE, 21101,
1129 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
1130 - NETDATA_SYSTEMD_CACHESTAT_MODIFIED_CACHE_CONTEXT, NETDATA_EBPF_MODULE_NAME_CACHESTAT,
1131 - update_every);
1132 + static ebpf_systemd_args_t data_dirty = {
1133 + .title = "Number of dirty pages",
1134 + .units = EBPF_CACHESTAT_DIMENSION_PAGE,
1135 + .family = NETDATA_CACHESTAT_SUBMENU,
1136 + .charttype = NETDATA_EBPF_CHART_TYPE_LINE,
1137 + .order = 21101,
1138 + .algorithm = EBPF_CHART_ALGORITHM_ABSOLUTE,
1139 + .context = NETDATA_SYSTEMD_CACHESTAT_MODIFIED_CACHE_CONTEXT,
1140 + .module = NETDATA_EBPF_MODULE_NAME_CACHESTAT,
1141 + .update_every = 0,
1142 + .suffix = NETDATA_CACHESTAT_DIRTY_CHART,
1143 + .dimension = "pages"
1144 + };
1145
1133 - ebpf_create_charts_on_systemd(NETDATA_CACHESTAT_HIT_CHART, "Number of accessed files",
1134 - EBPF_CACHESTAT_DIMENSION_HITS, NETDATA_CACHESTAT_SUBMENU,
1135 - NETDATA_EBPF_CHART_TYPE_LINE, 21102,
1136 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
1137 - NETDATA_SYSTEMD_CACHESTAT_HIT_FILE_CONTEXT, NETDATA_EBPF_MODULE_NAME_CACHESTAT,
1138 - update_every);
1146 + static ebpf_systemd_args_t data_hit = {
1147 + .title = "Number of accessed pages",
1148 + .units = EBPF_CACHESTAT_DIMENSION_HITS,
1149 + .family = NETDATA_CACHESTAT_SUBMENU,
1150 + .charttype = NETDATA_EBPF_CHART_TYPE_LINE,
1151 + .order = 21102,
1152 + .algorithm = EBPF_CHART_ALGORITHM_ABSOLUTE,
1153 + .context = NETDATA_SYSTEMD_CACHESTAT_HIT_FILE_CONTEXT,
1154 + .module = NETDATA_EBPF_MODULE_NAME_CACHESTAT,
1155 + .update_every = 0,
1156 + .suffix = NETDATA_CACHESTAT_HIT_CHART,
1157 + .dimension = "hits"
1158 + };
1159
1140 - ebpf_create_charts_on_systemd(NETDATA_CACHESTAT_MISSES_CHART, "Files out of page cache",
1141 - EBPF_CACHESTAT_DIMENSION_MISSES, NETDATA_CACHESTAT_SUBMENU,
1142 - NETDATA_EBPF_CHART_TYPE_LINE, 21103,
1143 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
1144 - NETDATA_SYSTEMD_CACHESTAT_MISS_FILES_CONTEXT, NETDATA_EBPF_MODULE_NAME_CACHESTAT,
1145 - update_every);
1160 + static ebpf_systemd_args_t data_miss = {
1161 + .title = "Files out of page cache",
1162 + .units = EBPF_CACHESTAT_DIMENSION_MISSES,
1163 + .family = NETDATA_CACHESTAT_SUBMENU,
1164 + .charttype = NETDATA_EBPF_CHART_TYPE_LINE,
1165 + .order = 21103,
1166 + .algorithm = EBPF_CHART_ALGORITHM_ABSOLUTE,
1167 + .context = NETDATA_SYSTEMD_CACHESTAT_MISS_FILES_CONTEXT,
1168 + .module = NETDATA_EBPF_MODULE_NAME_CACHESTAT,
1169 + .update_every = 0,
1170 + .suffix = NETDATA_CACHESTAT_MISSES_CHART,
1171 + .dimension = "misses"
1172 + };
1173 +
1174 + if (!data_miss.update_every)
1175 + data_hit_ratio.update_every = data_dirty.update_every =
1176 + data_hit.update_every = data_miss.update_every = update_every;
1177 +
1178 + ebpf_cgroup_target_t *w;
1179 + for (w = ebpf_cgroup_pids; w; w = w->next) {
1180 + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_CACHESTAT_CHART))
1181 + continue;
1182 +
1183 + data_hit_ratio.id = data_dirty.id = data_hit.id = data_miss.id = w->name;
1184 + ebpf_create_charts_on_systemd(&data_hit_ratio);
1185 +
1186 + ebpf_create_charts_on_systemd(&data_dirty);
1187 +
1188 + ebpf_create_charts_on_systemd(&data_hit);
1189 +
1190 + ebpf_create_charts_on_systemd(&data_miss);
1191 +
1192 + w->flags |= NETDATA_EBPF_SERVICES_HAS_CACHESTAT_CHART;
1193 + }
1194 }
1195
1196 /**
@@ -1154,37 +1202,27 @@ static void ebpf_send_systemd_cachestat_charts()
1202 {
1203 ebpf_cgroup_target_t *ect;
1204
1157 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_CACHESTAT_HIT_RATIO_CHART, "");
1205 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
1159 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1160 - write_chart_dimension(ect->name, (long long)ect->publish_cachestat.ratio);
1206 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_CACHESTAT_CHART)) ) {
1207 + continue;
1208 }
1162 - }
1163 - ebpf_write_end_chart();
1209
1165 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_CACHESTAT_DIRTY_CHART, "");
1166 - for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
1167 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1168 - write_chart_dimension(ect->name, (long long)ect->publish_cachestat.dirty);
1169 - }
1170 - }
1171 - ebpf_write_end_chart();
1210 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_CACHESTAT_HIT_RATIO_CHART);
1211 + write_chart_dimension("percentage", (long long)ect->publish_cachestat.ratio);
1212 + ebpf_write_end_chart();
1213
1173 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_CACHESTAT_HIT_CHART, "");
1174 - for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
1175 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1176 - write_chart_dimension(ect->name, (long long)ect->publish_cachestat.hit);
1177 - }
1178 - }
1179 - ebpf_write_end_chart();
1214 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_CACHESTAT_DIRTY_CHART);
1215 + write_chart_dimension("pages", (long long)ect->publish_cachestat.dirty);
1216 + ebpf_write_end_chart();
1217
1181 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_CACHESTAT_MISSES_CHART, "");
1182 - for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
1183 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1184 - write_chart_dimension(ect->name, (long long)ect->publish_cachestat.miss);
1185 - }
1218 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_CACHESTAT_HIT_CHART);
1219 + write_chart_dimension("hits", (long long)ect->publish_cachestat.hit);
1220 + ebpf_write_end_chart();
1221 +
1222 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_CACHESTAT_MISSES_CHART);
1223 + write_chart_dimension("misses", (long long)ect->publish_cachestat.miss);
1224 + ebpf_write_end_chart();
1225 }
1187 - ebpf_write_end_chart();
1226 }
1227
1228 /**
@@ -1223,7 +1261,7 @@ static void ebpf_create_specific_cachestat_charts(char *type, int update_every)
1261 {
1262 ebpf_create_chart(type, NETDATA_CACHESTAT_HIT_RATIO_CHART,
1263 "Hit ratio",
1226 - EBPF_COMMON_DIMENSION_PERCENTAGE, NETDATA_CACHESTAT_CGROUP_SUBMENU,
1264 + EBPF_COMMON_DIMENSION_PERCENTAGE, NETDATA_CACHESTAT_SUBMENU,
1265 NETDATA_CGROUP_CACHESTAT_HIT_RATIO_CONTEXT,
1266 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5200,
1267 ebpf_create_global_dimension,
@@ -1231,7 +1269,7 @@ static void ebpf_create_specific_cachestat_charts(char *type, int update_every)
1269
1270 ebpf_create_chart(type, NETDATA_CACHESTAT_DIRTY_CHART,
1271 "Number of dirty pages",
1234 - EBPF_CACHESTAT_DIMENSION_PAGE, NETDATA_CACHESTAT_CGROUP_SUBMENU,
1272 + EBPF_CACHESTAT_DIMENSION_PAGE, NETDATA_CACHESTAT_SUBMENU,
1273 NETDATA_CGROUP_CACHESTAT_MODIFIED_CACHE_CONTEXT,
1274 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5201,
1275 ebpf_create_global_dimension,
@@ -1240,7 +1278,7 @@ static void ebpf_create_specific_cachestat_charts(char *type, int update_every)
1278
1279 ebpf_create_chart(type, NETDATA_CACHESTAT_HIT_CHART,
1280 "Number of accessed files",
1243 - EBPF_CACHESTAT_DIMENSION_HITS, NETDATA_CACHESTAT_CGROUP_SUBMENU,
1281 + EBPF_CACHESTAT_DIMENSION_HITS, NETDATA_CACHESTAT_SUBMENU,
1282 NETDATA_CGROUP_CACHESTAT_HIT_FILES_CONTEXT,
1283 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5202,
1284 ebpf_create_global_dimension,
@@ -1249,7 +1287,7 @@ static void ebpf_create_specific_cachestat_charts(char *type, int update_every)
1287
1288 ebpf_create_chart(type, NETDATA_CACHESTAT_MISSES_CHART,
1289 "Files out of page cache",
1252 - EBPF_CACHESTAT_DIMENSION_MISSES, NETDATA_CACHESTAT_CGROUP_SUBMENU,
1290 + EBPF_CACHESTAT_DIMENSION_MISSES, NETDATA_CACHESTAT_SUBMENU,
1291 NETDATA_CGROUP_CACHESTAT_MISS_FILES_CONTEXT,
1292 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5203,
1293 ebpf_create_global_dimension,
@@ -1303,15 +1341,11 @@ static void ebpf_obsolete_specific_cachestat_charts(char *type, int update_every
1341 */
1342 void ebpf_cachestat_send_cgroup_data(int update_every)
1343 {
1306 - if (!ebpf_cgroup_pids)
1307 - return;
1308 -
1344 pthread_mutex_lock(&mutex_cgroup_shm);
1345 ebpf_cgroup_target_t *ect;
1346 ebpf_cachestat_calc_chart_values();
1347
1313 - int has_systemd = shm_ebpf_cgroup.header->systemd_enabled;
1314 - if (has_systemd) {
1348 + if (shm_ebpf_cgroup.header->systemd_enabled) {
1349 if (send_cgroup_chart) {
1350 ebpf_create_systemd_cachestat_charts(update_every);
1351 }
src/collectors/ebpf.plugin/ebpf_cachestat.h
+4 -5
@@ -14,7 +14,6 @@
14 #define NETDATA_CACHESTAT_MISSES_CHART "cachestat_misses"
15
16 #define NETDATA_CACHESTAT_SUBMENU "page_cache"
17 -#define NETDATA_CACHESTAT_CGROUP_SUBMENU "page cache (eBPF)"
17
18 #define EBPF_CACHESTAT_DIMENSION_PAGE "pages/s"
19 #define EBPF_CACHESTAT_DIMENSION_HITS "hits/s"
@@ -29,10 +28,10 @@
28 #define NETDATA_CGROUP_CACHESTAT_HIT_FILES_CONTEXT "cgroup.cachestat_hits"
29 #define NETDATA_CGROUP_CACHESTAT_MISS_FILES_CONTEXT "cgroup.cachestat_misses"
30
32 -#define NETDATA_SYSTEMD_CACHESTAT_HIT_RATIO_CONTEXT "services.cachestat_ratio"
33 -#define NETDATA_SYSTEMD_CACHESTAT_MODIFIED_CACHE_CONTEXT "services.cachestat_dirties"
34 -#define NETDATA_SYSTEMD_CACHESTAT_HIT_FILE_CONTEXT "services.cachestat_hits"
35 -#define NETDATA_SYSTEMD_CACHESTAT_MISS_FILES_CONTEXT "services.cachestat_misses"
31 +#define NETDATA_SYSTEMD_CACHESTAT_HIT_RATIO_CONTEXT "systemd.services.cachestat_ratio"
32 +#define NETDATA_SYSTEMD_CACHESTAT_MODIFIED_CACHE_CONTEXT "systemd.services.cachestat_dirties"
33 +#define NETDATA_SYSTEMD_CACHESTAT_HIT_FILE_CONTEXT "systemd.services.cachestat_hits"
34 +#define NETDATA_SYSTEMD_CACHESTAT_MISS_FILES_CONTEXT "systemd.services.cachestat_misses"
35
36 // variables
37 enum cachestat_counters {
src/collectors/ebpf.plugin/ebpf_cgroup.c
+15 -10
@@ -327,17 +327,22 @@ void ebpf_parse_cgroup_shm_data()
327 * @param module chart module name, this is the eBPF thread.
328 * @param update_every value to overwrite the update frequency set by the server.
329 */
330 -void ebpf_create_charts_on_systemd(char *id, char *title, char *units, char *family, char *charttype, int order,
331 - char *algorithm, char *context, char *module, int update_every)
330 +void ebpf_create_charts_on_systemd(ebpf_systemd_args_t *chart)
331 {
333 - ebpf_cgroup_target_t *w;
334 - ebpf_write_chart_cmd(NETDATA_SERVICE_FAMILY, id, "", title, units, family, charttype, context,
335 - order, update_every, module);
336 -
337 - for (w = ebpf_cgroup_pids; w; w = w->next) {
338 - if (unlikely(w->systemd) && unlikely(w->updated))
339 - fprintf(stdout, "DIMENSION %s '' %s 1 1\n", w->name, algorithm);
340 - }
332 + ebpf_write_chart_cmd(NETDATA_SERVICE_FAMILY,
333 + chart->id,
334 + chart->suffix,
335 + chart->title,
336 + chart->units,
337 + chart->family,
338 + chart->charttype,
339 + chart->context,
340 + chart->order,
341 + chart->update_every,
342 + chart->module);
343 + ebpf_create_chart_labels("service_name", chart->id, 0);
344 + ebpf_commit_label();
345 + fprintf(stdout, "DIMENSION %s '' %s 1 1\n", chart->dimension, chart->algorithm);
346 }
347
348 // --------------------------------------------------------------------------------------------------------------------
src/collectors/ebpf.plugin/ebpf_cgroup.h
+28 -4
@@ -9,7 +9,7 @@
9 #include "ebpf.h"
10 #include "ebpf_apps.h"
11
12 -#define NETDATA_SERVICE_FAMILY "services"
12 +#define NETDATA_SERVICE_FAMILY "systemd"
13
14 struct pid_on_target2 {
15 int32_t pid;
@@ -36,7 +36,17 @@ enum ebpf_cgroup_flags {
36 NETDATA_EBPF_CGROUP_HAS_OOMKILL_CHART = 1<<6,
37 NETDATA_EBPF_CGROUP_HAS_CACHESTAT_CHART = 1<<7,
38 NETDATA_EBPF_CGROUP_HAS_DC_CHART = 1<<8,
39 - NETDATA_EBPF_CGROUP_HAS_SHM_CHART = 1<<9
39 + NETDATA_EBPF_CGROUP_HAS_SHM_CHART = 1<<9,
40 +
41 + NETDATA_EBPF_SERVICES_HAS_PROCESS_CHART = 1<<16,
42 + NETDATA_EBPF_SERVICES_HAS_SWAP_CHART = 1<<17,
43 + NETDATA_EBPF_SERVICES_HAS_SOCKET_CHART = 1<<18,
44 + NETDATA_EBPF_SERVICES_HAS_FD_CHART = 1<<19,
45 + NETDATA_EBPF_SERVICES_HAS_VFS_CHART = 1<<20,
46 + NETDATA_EBPF_SERVICES_HAS_OOMKILL_CHART = 1<<21,
47 + NETDATA_EBPF_SERVICES_HAS_CACHESTAT_CHART = 1<<22,
48 + NETDATA_EBPF_SERVICES_HAS_DC_CHART = 1<<23,
49 + NETDATA_EBPF_SERVICES_HAS_SHM_CHART = 1<<24
50 };
51
52 typedef struct ebpf_cgroup_target {
@@ -60,10 +70,24 @@ typedef struct ebpf_cgroup_target {
70 struct ebpf_cgroup_target *next;
71 } ebpf_cgroup_target_t;
72
73 +typedef struct ebpf_systemd_args {
74 + char *id;
75 + char *title;
76 + char *units;
77 + char *family;
78 + char *charttype;
79 + int order;
80 + char *algorithm;
81 + char *context;
82 + char *module;
83 + int update_every;
84 + char *suffix;
85 + char *dimension;
86 +} ebpf_systemd_args_t;
87 +
88 void ebpf_map_cgroup_shared_memory();
89 void ebpf_parse_cgroup_shm_data();
65 -void ebpf_create_charts_on_systemd(char *id, char *title, char *units, char *family, char *charttype, int order,
66 - char *algorithm, char *context, char *module, int update_every);
90 +void ebpf_create_charts_on_systemd(ebpf_systemd_args_t *chart);
91 void *ebpf_cgroup_integration(void *ptr);
92 void ebpf_unmap_cgroup_shared_memory();
93 extern int send_cgroup_chart;
src/collectors/ebpf.plugin/ebpf_dcstat.c
+105 -82
@@ -277,11 +277,11 @@ static void ebpf_obsolete_specific_dc_charts(char *type, int update_every);
277 *
278 * @param em a pointer to `struct ebpf_module`
279 */
280 -static void ebpf_obsolete_dc_services(ebpf_module_t *em)
280 +static void ebpf_obsolete_dc_services(ebpf_module_t *em, char *id)
281 {
282 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
283 + id,
284 NETDATA_DC_HIT_CHART,
284 - "",
285 "Percentage of files inside directory cache",
286 EBPF_COMMON_DIMENSION_PERCENTAGE,
287 NETDATA_DIRECTORY_CACHE_SUBMENU,
@@ -291,8 +291,8 @@ static void ebpf_obsolete_dc_services(ebpf_module_t *em)
291 em->update_every);
292
293 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
294 + id,
295 NETDATA_DC_REFERENCE_CHART,
295 - "",
296 "Count file access",
297 EBPF_COMMON_DIMENSION_FILES,
298 NETDATA_DIRECTORY_CACHE_SUBMENU,
@@ -302,8 +302,8 @@ static void ebpf_obsolete_dc_services(ebpf_module_t *em)
302 em->update_every);
303
304 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
305 + id,
306 NETDATA_DC_REQUEST_NOT_CACHE_CHART,
306 - "",
307 "Files not present inside directory cache",
308 EBPF_COMMON_DIMENSION_FILES,
309 NETDATA_DIRECTORY_CACHE_SUBMENU,
@@ -313,14 +313,14 @@ static void ebpf_obsolete_dc_services(ebpf_module_t *em)
313 em->update_every);
314
315 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
316 + id,
317 NETDATA_DC_REQUEST_NOT_FOUND_CHART,
317 - "",
318 "Files not found",
319 EBPF_COMMON_DIMENSION_FILES,
320 NETDATA_DIRECTORY_CACHE_SUBMENU,
321 NETDATA_EBPF_CHART_TYPE_LINE,
322 NETDATA_SYSTEMD_DC_NOT_FOUND_CONTEXT,
323 - 21202,
323 + 21203,
324 em->update_every);
325 }
326
@@ -334,12 +334,13 @@ static void ebpf_obsolete_dc_services(ebpf_module_t *em)
334 static inline void ebpf_obsolete_dc_cgroup_charts(ebpf_module_t *em) {
335 pthread_mutex_lock(&mutex_cgroup_shm);
336
337 - ebpf_obsolete_dc_services(em);
338 -
337 ebpf_cgroup_target_t *ect;
338 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
341 - if (ect->systemd)
339 + if (ect->systemd) {
340 + ebpf_obsolete_dc_services(em, ect->name);
341 +
342 continue;
343 + }
344
345 ebpf_obsolete_specific_dc_charts(ect->name, em->update_every);
346 }
@@ -1039,45 +1040,82 @@ void ebpf_dc_calc_chart_values()
1040 **/
1041 static void ebpf_create_systemd_dc_charts(int update_every)
1042 {
1042 - ebpf_create_charts_on_systemd(NETDATA_DC_HIT_CHART,
1043 - "Percentage of files inside directory cache",
1044 - EBPF_COMMON_DIMENSION_PERCENTAGE,
1045 - NETDATA_DIRECTORY_CACHE_SUBMENU,
1046 - NETDATA_EBPF_CHART_TYPE_LINE,
1047 - 21200,
1048 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
1049 - NETDATA_SYSTEMD_DC_HIT_RATIO_CONTEXT, NETDATA_EBPF_MODULE_NAME_DCSTAT,
1050 - update_every);
1043 + static ebpf_systemd_args_t data_dc_hit_ratio = {
1044 + .title = "Percentage of files inside directory cache",
1045 + .units = EBPF_COMMON_DIMENSION_PERCENTAGE,
1046 + .family = NETDATA_DIRECTORY_CACHE_SUBMENU,
1047 + .charttype = NETDATA_EBPF_CHART_TYPE_LINE,
1048 + .order = 21200,
1049 + .algorithm = EBPF_CHART_ALGORITHM_ABSOLUTE,
1050 + .context = NETDATA_SYSTEMD_DC_HIT_RATIO_CONTEXT,
1051 + .module = NETDATA_EBPF_MODULE_NAME_DCSTAT,
1052 + .update_every = 0,
1053 + .suffix = NETDATA_DC_HIT_CHART,
1054 + .dimension = "percentage"
1055 + };
1056
1052 - ebpf_create_charts_on_systemd(NETDATA_DC_REFERENCE_CHART,
1053 - "Count file access",
1054 - EBPF_COMMON_DIMENSION_FILES,
1055 - NETDATA_DIRECTORY_CACHE_SUBMENU,
1056 - NETDATA_EBPF_CHART_TYPE_LINE,
1057 - 21201,
1058 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
1059 - NETDATA_SYSTEMD_DC_REFERENCE_CONTEXT, NETDATA_EBPF_MODULE_NAME_DCSTAT,
1060 - update_every);
1057 + static ebpf_systemd_args_t data_dc_references = {
1058 + .title = "Count file access",
1059 + .units = EBPF_COMMON_DIMENSION_FILES,
1060 + .family = NETDATA_DIRECTORY_CACHE_SUBMENU,
1061 + .charttype = NETDATA_EBPF_CHART_TYPE_LINE,
1062 + .order = 21201,
1063 + .algorithm = EBPF_CHART_ALGORITHM_ABSOLUTE,
1064 + .context = NETDATA_SYSTEMD_DC_REFERENCE_CONTEXT,
1065 + .module = NETDATA_EBPF_MODULE_NAME_DCSTAT,
1066 + .update_every = 0,
1067 + .suffix = NETDATA_DC_REFERENCE_CHART,
1068 + .dimension = "files"
1069 + };
1070
1062 - ebpf_create_charts_on_systemd(NETDATA_DC_REQUEST_NOT_CACHE_CHART,
1063 - "Files not present inside directory cache",
1064 - EBPF_COMMON_DIMENSION_FILES,
1065 - NETDATA_DIRECTORY_CACHE_SUBMENU,
1066 - NETDATA_EBPF_CHART_TYPE_LINE,
1067 - 21202,
1068 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
1069 - NETDATA_SYSTEMD_DC_NOT_CACHE_CONTEXT, NETDATA_EBPF_MODULE_NAME_DCSTAT,
1070 - update_every);
1071 + static ebpf_systemd_args_t data_dc_not_cache = {
1072 + .title = "Files not present inside directory cache",
1073 + .units = EBPF_COMMON_DIMENSION_FILES,
1074 + .family = NETDATA_DIRECTORY_CACHE_SUBMENU,
1075 + .charttype = NETDATA_EBPF_CHART_TYPE_LINE,
1076 + .order = 21202,
1077 + .algorithm = EBPF_CHART_ALGORITHM_ABSOLUTE,
1078 + .context = NETDATA_SYSTEMD_DC_NOT_CACHE_CONTEXT,
1079 + .module = NETDATA_EBPF_MODULE_NAME_DCSTAT,
1080 + .update_every = 0,
1081 + .suffix = NETDATA_DC_REQUEST_NOT_CACHE_CHART,
1082 + .dimension = "files"
1083 + };
1084
1072 - ebpf_create_charts_on_systemd(NETDATA_DC_REQUEST_NOT_FOUND_CHART,
1073 - "Files not found",
1074 - EBPF_COMMON_DIMENSION_FILES,
1075 - NETDATA_DIRECTORY_CACHE_SUBMENU,
1076 - NETDATA_EBPF_CHART_TYPE_LINE,
1077 - 21202,
1078 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
1079 - NETDATA_SYSTEMD_DC_NOT_FOUND_CONTEXT, NETDATA_EBPF_MODULE_NAME_DCSTAT,
1080 - update_every);
1085 + static ebpf_systemd_args_t data_dc_not_found = {
1086 + .title = "Files not found",
1087 + .units = EBPF_COMMON_DIMENSION_FILES,
1088 + .family = NETDATA_DIRECTORY_CACHE_SUBMENU,
1089 + .charttype = NETDATA_EBPF_CHART_TYPE_LINE,
1090 + .order = 21203,
1091 + .algorithm = EBPF_CHART_ALGORITHM_ABSOLUTE,
1092 + .context = NETDATA_SYSTEMD_DC_NOT_CACHE_CONTEXT,
1093 + .module = NETDATA_EBPF_MODULE_NAME_DCSTAT,
1094 + .update_every = 0,
1095 + .suffix = NETDATA_DC_REQUEST_NOT_FOUND_CHART,
1096 + .dimension = "files"
1097 + };
1098 +
1099 + if (!data_dc_not_cache.update_every)
1100 + data_dc_hit_ratio.update_every = data_dc_not_cache.update_every =
1101 + data_dc_not_found.update_every = data_dc_references.update_every = update_every;
1102 +
1103 + ebpf_cgroup_target_t *w;
1104 + for (w = ebpf_cgroup_pids; w; w = w->next) {
1105 + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_DC_CHART))
1106 + continue;
1107 +
1108 + data_dc_hit_ratio.id = data_dc_not_cache.id = data_dc_not_found.id = data_dc_references.id = w->name;
1109 + ebpf_create_charts_on_systemd(&data_dc_hit_ratio);
1110 +
1111 + ebpf_create_charts_on_systemd(&data_dc_not_found);
1112 +
1113 + ebpf_create_charts_on_systemd(&data_dc_not_cache);
1114 +
1115 + ebpf_create_charts_on_systemd(&data_dc_references);
1116 +
1117 + w->flags |= NETDATA_EBPF_SERVICES_HAS_DC_CHART;
1118 + }
1119 }
1120
1121 /**
@@ -1087,48 +1125,37 @@ static void ebpf_create_systemd_dc_charts(int update_every)
1125 */
1126 static void ebpf_send_systemd_dc_charts()
1127 {
1090 - collected_number value;
1128 ebpf_cgroup_target_t *ect;
1092 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_DC_HIT_CHART, "");
1093 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1094 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1095 - write_chart_dimension(ect->name, (long long) ect->publish_dc.ratio);
1129 + collected_number value;
1130 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
1131 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_DC_CHART)) ) {
1132 + continue;
1133 }
1097 - }
1098 - ebpf_write_end_chart();
1134
1100 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_DC_REFERENCE_CHART, "");
1101 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1102 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1103 - write_chart_dimension(ect->name, (long long) ect->publish_dc.cache_access);
1104 - }
1105 - }
1106 - ebpf_write_end_chart();
1135 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_DC_HIT_CHART);
1136 + write_chart_dimension("percentage", (long long) ect->publish_dc.ratio);
1137 + ebpf_write_end_chart();
1138
1108 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_DC_REQUEST_NOT_CACHE_CHART, "");
1109 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1110 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1111 - value = (collected_number) (!ect->publish_dc.cache_access) ? 0 :
1112 - (long long )ect->publish_dc.curr.file_system - (long long)ect->publish_dc.prev.file_system;
1113 - ect->publish_dc.prev.file_system = ect->publish_dc.curr.file_system;
1139 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_DC_REFERENCE_CHART);
1140 + write_chart_dimension("files", (long long) ect->publish_dc.cache_access);
1141 + ebpf_write_end_chart();
1142
1115 - write_chart_dimension(ect->name, (long long) value);
1116 - }
1117 - }
1118 - ebpf_write_end_chart();
1143 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_DC_REQUEST_NOT_CACHE_CHART);
1144 + value = (collected_number) (!ect->publish_dc.cache_access) ? 0 :
1145 + (long long )ect->publish_dc.curr.file_system - (long long)ect->publish_dc.prev.file_system;
1146 + ect->publish_dc.prev.file_system = ect->publish_dc.curr.file_system;
1147 + write_chart_dimension("files", (long long) value);
1148 + ebpf_write_end_chart();
1149
1120 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_DC_REQUEST_NOT_FOUND_CHART, "");
1121 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1122 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1123 - value = (collected_number) (!ect->publish_dc.cache_access) ? 0 :
1150 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_DC_REQUEST_NOT_FOUND_CHART);
1151 + value = (collected_number) (!ect->publish_dc.cache_access) ? 0 :
1152 (long long)ect->publish_dc.curr.not_found - (long long)ect->publish_dc.prev.not_found;
1153
1126 - ect->publish_dc.prev.not_found = ect->publish_dc.curr.not_found;
1154 + ect->publish_dc.prev.not_found = ect->publish_dc.curr.not_found;
1155
1128 - write_chart_dimension(ect->name, (long long) value);
1129 - }
1156 + write_chart_dimension("files", (long long) value);
1157 + ebpf_write_end_chart();
1158 }
1131 - ebpf_write_end_chart();
1159 }
1160
1161 /**
@@ -1174,15 +1201,11 @@ static void ebpf_send_specific_dc_data(char *type, netdata_publish_dcstat_t *pdc
1201 */
1202 void ebpf_dc_send_cgroup_data(int update_every)
1203 {
1177 - if (!ebpf_cgroup_pids)
1178 - return;
1179 -
1204 pthread_mutex_lock(&mutex_cgroup_shm);
1205 ebpf_cgroup_target_t *ect;
1206 ebpf_dc_calc_chart_values();
1207
1184 - int has_systemd = shm_ebpf_cgroup.header->systemd_enabled;
1185 - if (has_systemd) {
1208 + if (shm_ebpf_cgroup.header->systemd_enabled) {
1209 if (send_cgroup_chart) {
1210 ebpf_create_systemd_dc_charts(update_every);
1211 }
src/collectors/ebpf.plugin/ebpf_dcstat.h
+4 -4
@@ -24,10 +24,10 @@
24 #define NETDATA_CGROUP_DC_NOT_CACHE_CONTEXT "cgroup.dc_not_cache"
25 #define NETDATA_CGROUP_DC_NOT_FOUND_CONTEXT "cgroup.dc_not_found"
26
27 -#define NETDATA_SYSTEMD_DC_HIT_RATIO_CONTEXT "services.dc_ratio"
28 -#define NETDATA_SYSTEMD_DC_REFERENCE_CONTEXT "services.dc_reference"
29 -#define NETDATA_SYSTEMD_DC_NOT_CACHE_CONTEXT "services.dc_not_cache"
30 -#define NETDATA_SYSTEMD_DC_NOT_FOUND_CONTEXT "services.dc_not_found"
27 +#define NETDATA_SYSTEMD_DC_HIT_RATIO_CONTEXT "systemd.services.dc_ratio"
28 +#define NETDATA_SYSTEMD_DC_REFERENCE_CONTEXT "systemd.services.dc_reference"
29 +#define NETDATA_SYSTEMD_DC_NOT_CACHE_CONTEXT "systemd.services.dc_not_cache"
30 +#define NETDATA_SYSTEMD_DC_NOT_FOUND_CONTEXT "systemd.services.dc_not_found"
31
32 // ARAL name
33 #define NETDATA_EBPF_DCSTAT_ARAL_NAME "ebpf_dcstat"
src/collectors/ebpf.plugin/ebpf_fd.c
+110 -71
@@ -361,14 +361,14 @@ static void ebpf_obsolete_specific_fd_charts(char *type, ebpf_module_t *em);
361 *
362 * @param em a pointer to `struct ebpf_module`
363 */
364 -static void ebpf_obsolete_fd_services(ebpf_module_t *em)
364 +static void ebpf_obsolete_fd_services(ebpf_module_t *em, char *id)
365 {
366 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
367 + id,
368 NETDATA_SYSCALL_APPS_FILE_OPEN,
368 - "",
369 "Number of open files",
370 EBPF_COMMON_DIMENSION_CALL,
371 - NETDATA_APPS_FILE_CGROUP_GROUP,
371 + NETDATA_APPS_FILE_GROUP,
372 NETDATA_EBPF_CHART_TYPE_STACKED,
373 NETDATA_CGROUP_FD_OPEN_CONTEXT,
374 20270,
@@ -376,11 +376,11 @@ static void ebpf_obsolete_fd_services(ebpf_module_t *em)
376
377 if (em->mode < MODE_ENTRY) {
378 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
379 + id,
380 NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR,
380 - "",
381 "Fails to open files",
382 EBPF_COMMON_DIMENSION_CALL,
383 - NETDATA_APPS_FILE_CGROUP_GROUP,
383 + NETDATA_APPS_FILE_GROUP,
384 NETDATA_EBPF_CHART_TYPE_STACKED,
385 NETDATA_CGROUP_FD_OPEN_ERR_CONTEXT,
386 20271,
@@ -388,11 +388,11 @@ static void ebpf_obsolete_fd_services(ebpf_module_t *em)
388 }
389
390 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
391 + id,
392 NETDATA_SYSCALL_APPS_FILE_CLOSED,
392 - "",
393 "Files closed",
394 EBPF_COMMON_DIMENSION_CALL,
395 - NETDATA_APPS_FILE_CGROUP_GROUP,
395 + NETDATA_APPS_FILE_GROUP,
396 NETDATA_EBPF_CHART_TYPE_STACKED,
397 NETDATA_CGROUP_FD_CLOSE_CONTEXT,
398 20272,
@@ -400,11 +400,11 @@ static void ebpf_obsolete_fd_services(ebpf_module_t *em)
400
401 if (em->mode < MODE_ENTRY) {
402 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
403 + id,
404 NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR,
404 - "",
405 "Fails to close files",
406 EBPF_COMMON_DIMENSION_CALL,
407 - NETDATA_APPS_FILE_CGROUP_GROUP,
407 + NETDATA_APPS_FILE_GROUP,
408 NETDATA_EBPF_CHART_TYPE_STACKED,
409 NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT,
410 20273,
@@ -422,12 +422,13 @@ static void ebpf_obsolete_fd_services(ebpf_module_t *em)
422 static inline void ebpf_obsolete_fd_cgroup_charts(ebpf_module_t *em) {
423 pthread_mutex_lock(&mutex_cgroup_shm);
424
425 - ebpf_obsolete_fd_services(em);
426 -
425 ebpf_cgroup_target_t *ect;
426 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
429 - if (ect->systemd)
427 + if (ect->systemd) {
428 + ebpf_obsolete_fd_services(em, ect->name);
429 +
430 continue;
431 + }
432
433 ebpf_obsolete_specific_fd_charts(ect->name, em);
434 }
@@ -904,7 +905,7 @@ static void ebpf_fd_sum_cgroup_pids(netdata_fd_stat_t *fd, struct pid_on_target2
905 static void ebpf_create_specific_fd_charts(char *type, ebpf_module_t *em)
906 {
907 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_OPEN, "Number of open files",
907 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP,
908 + EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_GROUP,
909 NETDATA_CGROUP_FD_OPEN_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,
910 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5400,
911 ebpf_create_global_dimension,
@@ -913,7 +914,7 @@ static void ebpf_create_specific_fd_charts(char *type, ebpf_module_t *em)
914
915 if (em->mode < MODE_ENTRY) {
916 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, "Fails to open files",
916 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP,
917 + EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_GROUP,
918 NETDATA_CGROUP_FD_OPEN_ERR_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,
919 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5401,
920 ebpf_create_global_dimension,
@@ -923,7 +924,7 @@ static void ebpf_create_specific_fd_charts(char *type, ebpf_module_t *em)
924 }
925
926 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_CLOSED, "Files closed",
926 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP,
927 + EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_GROUP,
928 NETDATA_CGROUP_FD_CLOSE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,
929 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5402,
930 ebpf_create_global_dimension,
@@ -932,7 +933,7 @@ static void ebpf_create_specific_fd_charts(char *type, ebpf_module_t *em)
933
934 if (em->mode < MODE_ENTRY) {
935 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, "Fails to close files",
935 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP,
936 + EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_GROUP,
937 NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,
938 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5403,
939 ebpf_create_global_dimension,
@@ -1017,32 +1018,84 @@ static void ebpf_send_specific_fd_data(char *type, netdata_fd_stat_t *values, eb
1018 **/
1019 static void ebpf_create_systemd_fd_charts(ebpf_module_t *em)
1020 {
1020 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_FILE_OPEN, "Number of open files",
1021 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP,
1022 - NETDATA_EBPF_CHART_TYPE_STACKED, 20061,
1023 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_FD_OPEN_CONTEXT,
1024 - NETDATA_EBPF_MODULE_NAME_FD, em->update_every);
1021 + static ebpf_systemd_args_t data_open = {
1022 + .title = "Number of open files",
1023 + .units = EBPF_COMMON_DIMENSION_CALL,
1024 + .family = NETDATA_APPS_FILE_GROUP,
1025 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1026 + .order = 20061,
1027 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1028 + .context = NETDATA_SYSTEMD_FD_OPEN_CONTEXT,
1029 + .module = NETDATA_EBPF_MODULE_NAME_FD,
1030 + .update_every = 0,
1031 + .suffix = NETDATA_SYSCALL_APPS_FILE_OPEN,
1032 + .dimension = "calls"
1033 + };
1034
1026 - if (em->mode < MODE_ENTRY) {
1027 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, "Fails to open files",
1028 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP,
1029 - NETDATA_EBPF_CHART_TYPE_STACKED, 20062,
1030 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_FD_OPEN_ERR_CONTEXT,
1031 - NETDATA_EBPF_MODULE_NAME_FD, em->update_every);
1032 - }
1035 + static ebpf_systemd_args_t data_open_error = {
1036 + .title = "Fails to open files",
1037 + .units = EBPF_COMMON_DIMENSION_CALL,
1038 + .family = NETDATA_APPS_FILE_GROUP,
1039 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1040 + .order = 20062,
1041 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1042 + .context = NETDATA_SYSTEMD_FD_OPEN_ERR_CONTEXT,
1043 + .module = NETDATA_EBPF_MODULE_NAME_FD,
1044 + .update_every = 0,
1045 + .suffix = NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR,
1046 + .dimension = "calls"
1047 + };
1048
1034 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_FILE_CLOSED, "Files closed",
1035 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP,
1036 - NETDATA_EBPF_CHART_TYPE_STACKED, 20063,
1037 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_FD_CLOSE_CONTEXT,
1038 - NETDATA_EBPF_MODULE_NAME_FD, em->update_every);
1049 + static ebpf_systemd_args_t data_close = {
1050 + .title = "Files closed",
1051 + .units = EBPF_COMMON_DIMENSION_CALL,
1052 + .family = NETDATA_APPS_FILE_GROUP,
1053 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1054 + .order = 20063,
1055 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1056 + .context = NETDATA_SYSTEMD_FD_CLOSE_CONTEXT,
1057 + .module = NETDATA_EBPF_MODULE_NAME_FD,
1058 + .update_every = 0,
1059 + .suffix = NETDATA_SYSCALL_APPS_FILE_CLOSED,
1060 + .dimension = "calls"
1061 + };
1062
1040 - if (em->mode < MODE_ENTRY) {
1041 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, "Fails to close files",
1042 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_CGROUP_GROUP,
1043 - NETDATA_EBPF_CHART_TYPE_STACKED, 20064,
1044 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_FD_CLOSE_ERR_CONTEXT,
1045 - NETDATA_EBPF_MODULE_NAME_FD, em->update_every);
1063 + static ebpf_systemd_args_t data_close_error = {
1064 + .title = "Fails to close files",
1065 + .units = EBPF_COMMON_DIMENSION_CALL,
1066 + .family = NETDATA_APPS_FILE_GROUP,
1067 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1068 + .order = 20064,
1069 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1070 + .context = NETDATA_SYSTEMD_FD_OPEN_ERR_CONTEXT,
1071 + .module = NETDATA_EBPF_MODULE_NAME_FD,
1072 + .update_every = 0,
1073 + .suffix = NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR,
1074 + .dimension = "calls"
1075 + };
1076 +
1077 + if (!data_open.update_every)
1078 + data_open.update_every = data_open_error.update_every =
1079 + data_close.update_every = data_close_error.update_every = em->update_every;
1080 +
1081 + ebpf_cgroup_target_t *w;
1082 + netdata_run_mode_t mode = em->mode;
1083 + for (w = ebpf_cgroup_pids; w; w = w->next) {
1084 + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_FD_CHART))
1085 + continue;
1086 +
1087 + data_open.id = data_open_error.id = data_close.id = data_close_error.id = w->name;
1088 + ebpf_create_charts_on_systemd(&data_open);
1089 + if (mode < MODE_ENTRY) {
1090 + ebpf_create_charts_on_systemd(&data_open_error);
1091 + }
1092 +
1093 + ebpf_create_charts_on_systemd(&data_close);
1094 + if (mode < MODE_ENTRY) {
1095 + ebpf_create_charts_on_systemd(&data_close_error);
1096 + }
1097 +
1098 + w->flags |= NETDATA_EBPF_SERVICES_HAS_FD_CHART;
1099 }
1100 }
1101
@@ -1056,40 +1109,30 @@ static void ebpf_create_systemd_fd_charts(ebpf_module_t *em)
1109 static void ebpf_send_systemd_fd_charts(ebpf_module_t *em)
1110 {
1111 ebpf_cgroup_target_t *ect;
1059 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_OPEN, "");
1112 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1061 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1062 - write_chart_dimension(ect->name, ect->publish_systemd_fd.open_call);
1113 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_FD_CHART)) ) {
1114 + continue;
1115 }
1064 - }
1065 - ebpf_write_end_chart();
1116
1067 - if (em->mode < MODE_ENTRY) {
1068 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, "");
1069 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1070 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1071 - write_chart_dimension(ect->name, ect->publish_systemd_fd.open_err);
1072 - }
1073 - }
1117 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_FILE_OPEN);
1118 + write_chart_dimension("calls", ect->publish_systemd_fd.open_call);
1119 ebpf_write_end_chart();
1075 - }
1120
1077 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_CLOSED, "");
1078 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1079 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1080 - write_chart_dimension(ect->name, ect->publish_systemd_fd.close_call);
1121 + if (em->mode < MODE_ENTRY) {
1122 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR);
1123 + write_chart_dimension("calls", ect->publish_systemd_fd.open_err);
1124 + ebpf_write_end_chart();
1125 }
1082 - }
1083 - ebpf_write_end_chart();
1126
1085 - if (em->mode < MODE_ENTRY) {
1086 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, "");
1087 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1088 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1089 - write_chart_dimension(ect->name, ect->publish_systemd_fd.close_err);
1090 - }
1091 - }
1127 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_FILE_CLOSED);
1128 + write_chart_dimension("calls", ect->publish_systemd_fd.close_call);
1129 ebpf_write_end_chart();
1130 +
1131 + if (em->mode < MODE_ENTRY) {
1132 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR);
1133 + write_chart_dimension("calls", ect->publish_systemd_fd.close_err);
1134 + ebpf_write_end_chart();
1135 + }
1136 }
1137 }
1138
@@ -1100,17 +1143,13 @@ static void ebpf_send_systemd_fd_charts(ebpf_module_t *em)
1143 */
1144 static void ebpf_fd_send_cgroup_data(ebpf_module_t *em)
1145 {
1103 - if (!ebpf_cgroup_pids)
1104 - return;
1105 -
1146 pthread_mutex_lock(&mutex_cgroup_shm);
1147 ebpf_cgroup_target_t *ect;
1148 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1149 ebpf_fd_sum_cgroup_pids(&ect->publish_systemd_fd, ect->pids);
1150 }
1151
1112 - int has_systemd = shm_ebpf_cgroup.header->systemd_enabled;
1113 - if (has_systemd) {
1152 + if (shm_ebpf_cgroup.header->systemd_enabled) {
1153 if (send_cgroup_chart) {
1154 ebpf_create_systemd_fd_charts(em);
1155 }
@@ -1175,7 +1214,7 @@ static void fd_collector(ebpf_module_t *em)
1214 if (apps & NETDATA_EBPF_APPS_FLAG_CHART_CREATED)
1215 ebpf_fd_send_apps_data(em, apps_groups_root_target);
1216
1178 - if (cgroups)
1217 + if (cgroups && shm_ebpf_cgroup.header && ebpf_cgroup_pids)
1218 ebpf_fd_send_cgroup_data(em);
1219
1220 pthread_mutex_unlock(&lock);
src/collectors/ebpf.plugin/ebpf_fd.h
+4 -4
@@ -29,10 +29,10 @@
29 #define NETDATA_CGROUP_FD_CLOSE_CONTEXT "cgroup.fd_close"
30 #define NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT "cgroup.fd_close_error"
31
32 -#define NETDATA_SYSTEMD_FD_OPEN_CONTEXT "services.fd_open"
33 -#define NETDATA_SYSTEMD_FD_OPEN_ERR_CONTEXT "services.fd_open_error"
34 -#define NETDATA_SYSTEMD_FD_CLOSE_CONTEXT "services.fd_close"
35 -#define NETDATA_SYSTEMD_FD_CLOSE_ERR_CONTEXT "services.fd_close_error"
32 +#define NETDATA_SYSTEMD_FD_OPEN_CONTEXT "systemd.services.fd_open"
33 +#define NETDATA_SYSTEMD_FD_OPEN_ERR_CONTEXT "systemd.services.fd_open_error"
34 +#define NETDATA_SYSTEMD_FD_CLOSE_CONTEXT "systemd.services.fd_close"
35 +#define NETDATA_SYSTEMD_FD_CLOSE_ERR_CONTEXT "systemd.services.fd_close_error"
36
37 // ARAL name
38 #define NETDATA_EBPF_FD_ARAL_NAME "ebpf_fd"
src/collectors/ebpf.plugin/ebpf_oomkill.c
+41 -21
@@ -53,11 +53,11 @@ static void ebpf_create_specific_oomkill_charts(char *type, int update_every);
53 *
54 * @param em a pointer to `struct ebpf_module`
55 */
56 -static void ebpf_obsolete_oomkill_services(ebpf_module_t *em)
56 +static void ebpf_obsolete_oomkill_services(ebpf_module_t *em, char *id)
57 {
58 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
59 + id,
60 NETDATA_OOMKILL_CHART,
60 - "",
61 "OOM kills. This chart is provided by eBPF plugin.",
62 EBPF_COMMON_DIMENSION_KILLS,
63 NETDATA_EBPF_MEMORY_GROUP,
@@ -78,12 +78,13 @@ static inline void ebpf_obsolete_oomkill_cgroup_charts(ebpf_module_t *em)
78 {
79 pthread_mutex_lock(&mutex_cgroup_shm);
80
81 - ebpf_obsolete_oomkill_services(em);
82 -
81 ebpf_cgroup_target_t *ect;
82 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
85 - if (ect->systemd)
83 + if (ect->systemd) {
84 + ebpf_obsolete_oomkill_services(em, ect->name);
85 +
86 continue;
87 + }
88
89 ebpf_create_specific_oomkill_charts(ect->name, em->update_every);
90 }
@@ -233,11 +234,33 @@ static void ebpf_create_specific_oomkill_charts(char *type, int update_every)
234 **/
235 static void ebpf_create_systemd_oomkill_charts(int update_every)
236 {
236 - ebpf_create_charts_on_systemd(NETDATA_OOMKILL_CHART, "OOM kills. This chart is provided by eBPF plugin.",
237 - EBPF_COMMON_DIMENSION_KILLS, NETDATA_EBPF_MEMORY_GROUP,
238 - NETDATA_EBPF_CHART_TYPE_LINE, 20191,
239 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NULL,
240 - NETDATA_EBPF_MODULE_NAME_OOMKILL, update_every);
237 + static ebpf_systemd_args_t data_oom = {
238 + .title = "OOM kills. This chart is provided by eBPF plugin.",
239 + .units = EBPF_COMMON_DIMENSION_KILLS,
240 + .family = NETDATA_EBPF_MEMORY_GROUP,
241 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
242 + .order = 20191,
243 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
244 + .context = NETDATA_EBPF_MODULE_NAME_OOMKILL,
245 + .module = NETDATA_EBPF_MODULE_NAME_SWAP,
246 + .update_every = 0,
247 + .suffix = NETDATA_OOMKILL_CHART,
248 + .dimension = "oom"
249 + };
250 +
251 + if (!data_oom.update_every)
252 + data_oom.update_every = update_every;
253 +
254 + ebpf_cgroup_target_t *w;
255 + for (w = ebpf_cgroup_pids; w ; w = w->next) {
256 + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_OOMKILL_CHART))
257 + continue;
258 +
259 + data_oom.id = w->name;
260 + ebpf_create_charts_on_systemd(&data_oom);
261 +
262 + w->flags |= NETDATA_EBPF_SERVICES_HAS_OOMKILL_CHART;
263 + }
264 }
265
266 /**
@@ -248,14 +271,15 @@ static void ebpf_create_systemd_oomkill_charts(int update_every)
271 static void ebpf_send_systemd_oomkill_charts()
272 {
273 ebpf_cgroup_target_t *ect;
251 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_OOMKILL_CHART, "");
274 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
253 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
254 - write_chart_dimension(ect->name, (long long) ect->oomkill);
255 - ect->oomkill = 0;
275 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_OOMKILL_CHART)) ) {
276 + continue;
277 }
278 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_OOMKILL_CHART);
279 + write_chart_dimension("oom", (long long) ect->oomkill);
280 + ect->oomkill = 0;
281 + ebpf_write_end_chart();
282 }
258 - ebpf_write_end_chart();
283 }
284
285 /*
@@ -296,14 +320,10 @@ static void ebpf_obsolete_specific_oomkill_charts(char *type, int update_every)
320 */
321 void ebpf_oomkill_send_cgroup_data(int update_every)
322 {
299 - if (!ebpf_cgroup_pids)
300 - return;
301 -
323 pthread_mutex_lock(&mutex_cgroup_shm);
324 ebpf_cgroup_target_t *ect;
325
305 - int has_systemd = shm_ebpf_cgroup.header->systemd_enabled;
306 - if (has_systemd) {
326 + if (shm_ebpf_cgroup.header->systemd_enabled) {
327 if (send_cgroup_chart) {
328 ebpf_create_systemd_oomkill_charts(update_every);
329 }
@@ -450,7 +470,7 @@ static void oomkill_collector(ebpf_module_t *em)
470 stats[NETDATA_CONTROLLER_PID_TABLE_DEL] += (uint64_t) count;
471
472 pthread_mutex_lock(&lock);
453 - if (cgroups && count) {
473 + if (cgroups && shm_ebpf_cgroup.header && ebpf_cgroup_pids) {
474 ebpf_update_oomkill_cgroup(keys, count);
475 // write everything from the ebpf map.
476 ebpf_oomkill_send_cgroup_data(update_every);
src/collectors/ebpf.plugin/ebpf_process.c
+126 -84
@@ -1,7 +1,5 @@
1 // SPDX-License-Identifier: GPL-3.0-or-later
2
3 -#include <sys/resource.h>
4 -
3 #include "ebpf.h"
4 #include "ebpf_process.h"
5
@@ -445,11 +443,11 @@ static void ebpf_obsolete_specific_process_charts(char *type, ebpf_module_t *em)
443 *
444 * @param em a pointer to `struct ebpf_module`
445 */
448 -static void ebpf_obsolete_process_services(ebpf_module_t *em)
446 +static void ebpf_obsolete_process_services(ebpf_module_t *em, char *id)
447 {
448 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
449 + id,
450 NETDATA_SYSCALL_APPS_TASK_PROCESS,
452 - "",
451 "Process started",
452 EBPF_COMMON_DIMENSION_CALL,
453 NETDATA_APPS_PROCESS_GROUP,
@@ -459,8 +457,8 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em)
457 em->update_every);
458
459 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
460 + id,
461 NETDATA_SYSCALL_APPS_TASK_THREAD,
463 - "",
462 "Threads started",
463 EBPF_COMMON_DIMENSION_CALL,
464 NETDATA_APPS_PROCESS_GROUP,
@@ -470,8 +468,8 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em)
468 em->update_every);
469
470 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
471 + id,
472 NETDATA_SYSCALL_APPS_TASK_CLOSE,
474 - "",
473 "Tasks starts exit process.",
474 EBPF_COMMON_DIMENSION_CALL,
475 NETDATA_APPS_PROCESS_GROUP,
@@ -481,8 +479,8 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em)
479 em->update_every);
480
481 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
482 + id,
483 NETDATA_SYSCALL_APPS_TASK_EXIT,
485 - "",
484 "Tasks closed",
485 EBPF_COMMON_DIMENSION_CALL,
486 NETDATA_APPS_PROCESS_GROUP,
@@ -493,8 +491,8 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em)
491
492 if (em->mode < MODE_ENTRY) {
493 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
494 + id,
495 NETDATA_SYSCALL_APPS_TASK_ERROR,
497 - "",
496 "Errors to create process or threads.",
497 EBPF_COMMON_DIMENSION_CALL,
498 NETDATA_APPS_PROCESS_GROUP,
@@ -515,12 +513,13 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em)
513 static inline void ebpf_obsolete_process_cgroup_charts(ebpf_module_t *em) {
514 pthread_mutex_lock(&mutex_cgroup_shm);
515
518 - ebpf_obsolete_process_services(em);
519 -
516 ebpf_cgroup_target_t *ect;
517 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
522 - if (ect->systemd)
518 + if (ect->systemd) {
519 + ebpf_obsolete_process_services(em, ect->name);
520 +
521 continue;
522 + }
523
524 ebpf_obsolete_specific_process_charts(ect->name, em);
525 }
@@ -822,14 +821,14 @@ static void ebpf_send_specific_process_data(char *type, ebpf_process_stat_t *val
821 static void ebpf_create_specific_process_charts(char *type, ebpf_module_t *em)
822 {
823 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_PROCESS, "Process started",
825 - EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_CGROUP_GROUP,
824 + EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP,
825 NETDATA_CGROUP_PROCESS_CREATE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,
826 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5000,
827 ebpf_create_global_dimension, &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK],
828 1, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);
829
830 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_THREAD, "Threads started",
832 - EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_CGROUP_GROUP,
831 + EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP,
832 NETDATA_CGROUP_THREAD_CREATE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,
833 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5001,
834 ebpf_create_global_dimension,
@@ -837,7 +836,7 @@ static void ebpf_create_specific_process_charts(char *type, ebpf_module_t *em)
836 1, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);
837
838 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_EXIT, "Tasks starts exit process.",
840 - EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_CGROUP_GROUP,
839 + EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP,
840 NETDATA_CGROUP_PROCESS_EXIT_CONTEXT,
841 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5002,
842 ebpf_create_global_dimension,
@@ -845,7 +844,7 @@ static void ebpf_create_specific_process_charts(char *type, ebpf_module_t *em)
844 1, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);
845
846 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_CLOSE, "Tasks closed",
848 - EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_CGROUP_GROUP,
847 + EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP,
848 NETDATA_CGROUP_PROCESS_CLOSE_CONTEXT,
849 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5003,
850 ebpf_create_global_dimension,
@@ -854,7 +853,7 @@ static void ebpf_create_specific_process_charts(char *type, ebpf_module_t *em)
853
854 if (em->mode < MODE_ENTRY) {
855 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_ERROR, "Errors to create process or threads.",
857 - EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_CGROUP_GROUP,
856 + EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP,
857 NETDATA_CGROUP_PROCESS_ERROR_CONTEXT,
858 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5004,
859 ebpf_create_global_dimension,
@@ -910,36 +909,98 @@ static void ebpf_obsolete_specific_process_charts(char *type, ebpf_module_t *em)
909 **/
910 static void ebpf_create_systemd_process_charts(ebpf_module_t *em)
911 {
913 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_TASK_PROCESS, "Process started",
914 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP,
915 - NETDATA_EBPF_CHART_TYPE_STACKED, 20065,
916 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_PROCESS_CREATE_CONTEXT,
917 - NETDATA_EBPF_MODULE_NAME_PROCESS, em->update_every);
918 -
919 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_TASK_THREAD, "Threads started",
920 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP,
921 - NETDATA_EBPF_CHART_TYPE_STACKED, 20066,
922 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_THREAD_CREATE_CONTEXT,
923 - NETDATA_EBPF_MODULE_NAME_PROCESS, em->update_every);
924 -
925 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_TASK_CLOSE, "Tasks starts exit process.",
926 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP,
927 - NETDATA_EBPF_CHART_TYPE_STACKED, 20067,
928 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_PROCESS_EXIT_CONTEXT,
929 - NETDATA_EBPF_MODULE_NAME_PROCESS, em->update_every);
930 -
931 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_TASK_EXIT, "Tasks closed",
932 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP,
933 - NETDATA_EBPF_CHART_TYPE_STACKED, 20068,
934 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_PROCESS_CLOSE_CONTEXT,
935 - NETDATA_EBPF_MODULE_NAME_PROCESS, em->update_every);
912 + static ebpf_systemd_args_t data_process = {
913 + .title = "Process started",
914 + .units = EBPF_COMMON_DIMENSION_CALL,
915 + .family = NETDATA_APPS_PROCESS_GROUP,
916 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
917 + .order = 20065,
918 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
919 + .context = NETDATA_SYSTEMD_PROCESS_CREATE_CONTEXT,
920 + .module = NETDATA_EBPF_MODULE_NAME_PROCESS,
921 + .update_every = 0,
922 + .suffix = NETDATA_SYSCALL_APPS_TASK_PROCESS,
923 + .dimension = "calls"
924 + };
925
937 - if (em->mode < MODE_ENTRY) {
938 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_TASK_ERROR, "Errors to create process or threads.",
939 - EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_PROCESS_GROUP,
940 - NETDATA_EBPF_CHART_TYPE_STACKED, 20069,
941 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_PROCESS_ERROR_CONTEXT,
942 - NETDATA_EBPF_MODULE_NAME_PROCESS, em->update_every);
926 + static ebpf_systemd_args_t data_thread = {
927 + .title = "Threads started",
928 + .units = EBPF_COMMON_DIMENSION_CALL,
929 + .family = NETDATA_APPS_PROCESS_GROUP,
930 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
931 + .order = 20066,
932 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
933 + .context = NETDATA_SYSTEMD_THREAD_CREATE_CONTEXT,
934 + .module = NETDATA_EBPF_MODULE_NAME_PROCESS,
935 + .update_every = 0,
936 + .suffix = NETDATA_SYSCALL_APPS_TASK_THREAD,
937 + .dimension = "calls"
938 + };
939 +
940 + static ebpf_systemd_args_t task_exit = {
941 + .title = "Tasks starts exit process.",
942 + .units = EBPF_COMMON_DIMENSION_CALL,
943 + .family = NETDATA_APPS_PROCESS_GROUP,
944 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
945 + .order = 20067,
946 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
947 + .context = NETDATA_SYSTEMD_PROCESS_EXIT_CONTEXT,
948 + .module = NETDATA_EBPF_MODULE_NAME_PROCESS,
949 + .update_every = 0,
950 + .suffix = NETDATA_SYSCALL_APPS_TASK_CLOSE,
951 + .dimension = "calls"
952 + };
953 +
954 + static ebpf_systemd_args_t task_closed = {
955 + .title = "Tasks closed",
956 + .units = EBPF_COMMON_DIMENSION_CALL,
957 + .family = NETDATA_APPS_PROCESS_GROUP,
958 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
959 + .order = 20068,
960 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
961 + .context = NETDATA_SYSTEMD_PROCESS_CLOSE_CONTEXT,
962 + .module = NETDATA_EBPF_MODULE_NAME_PROCESS,
963 + .update_every = 0,
964 + .suffix = NETDATA_SYSCALL_APPS_TASK_EXIT,
965 + .dimension = "calls"
966 + };
967 +
968 + static ebpf_systemd_args_t task_error = {
969 + .title = "Errors to create process or threads.",
970 + .units = EBPF_COMMON_DIMENSION_CALL,
971 + .family = NETDATA_APPS_PROCESS_GROUP,
972 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
973 + .order = 20069,
974 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
975 + .context = NETDATA_SYSTEMD_PROCESS_ERROR_CONTEXT,
976 + .module = NETDATA_EBPF_MODULE_NAME_PROCESS,
977 + .update_every = 0,
978 + .suffix = NETDATA_SYSCALL_APPS_TASK_ERROR,
979 + .dimension = "calls"
980 + };
981 +
982 + ebpf_cgroup_target_t *w;
983 + netdata_run_mode_t mode = em->mode;
984 + if (!task_exit.update_every)
985 + data_process.update_every = data_thread.update_every = task_exit.update_every =
986 + task_closed.update_every = task_error.update_every = em->update_every;
987 +
988 + for (w = ebpf_cgroup_pids; w; w = w->next) {
989 + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_PROCESS_CHART))
990 + continue;
991 +
992 + data_process.id = data_thread.id = task_exit.id = task_closed.id = task_error.id = w->name;
993 + ebpf_create_charts_on_systemd(&data_process);
994 +
995 + ebpf_create_charts_on_systemd(&data_thread);
996 +
997 + ebpf_create_charts_on_systemd(&task_exit);
998 +
999 + ebpf_create_charts_on_systemd(&task_closed);
1000 + if (mode < MODE_ENTRY) {
1001 + ebpf_create_charts_on_systemd(&task_error);
1002 + }
1003 + w->flags |= NETDATA_EBPF_SERVICES_HAS_PROCESS_CHART;
1004 }
1005 }
1006
@@ -953,46 +1014,32 @@ static void ebpf_create_systemd_process_charts(ebpf_module_t *em)
1014 static void ebpf_send_systemd_process_charts(ebpf_module_t *em)
1015 {
1016 ebpf_cgroup_target_t *ect;
956 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_PROCESS, "");
1017 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
958 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
959 - write_chart_dimension(ect->name, ect->publish_systemd_ps.create_process);
1018 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_PROCESS_CHART)) ) {
1019 + continue;
1020 }
961 - }
962 - ebpf_write_end_chart();
1021
964 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_THREAD, "");
965 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
966 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
967 - write_chart_dimension(ect->name, ect->publish_systemd_ps.create_thread);
968 - }
969 - }
970 - ebpf_write_end_chart();
1022 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_TASK_PROCESS);
1023 + write_chart_dimension("calls", ect->publish_systemd_ps.create_process);
1024 + ebpf_write_end_chart();
1025
972 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_EXIT, "");
973 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
974 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
975 - write_chart_dimension(ect->name, ect->publish_systemd_ps.exit_call);
976 - }
977 - }
978 - ebpf_write_end_chart();
1026 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_TASK_THREAD);
1027 + write_chart_dimension("calls", ect->publish_systemd_ps.create_thread);
1028 + ebpf_write_end_chart();
1029
980 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_CLOSE, "");
981 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
982 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
983 - write_chart_dimension(ect->name, ect->publish_systemd_ps.release_call);
984 - }
985 - }
986 - ebpf_write_end_chart();
1030 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_TASK_EXIT);
1031 + write_chart_dimension("calls", ect->publish_systemd_ps.exit_call);
1032 + ebpf_write_end_chart();
1033
988 - if (em->mode < MODE_ENTRY) {
989 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_ERROR, "");
990 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
991 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
992 - write_chart_dimension(ect->name, ect->publish_systemd_ps.task_err);
993 - }
994 - }
1034 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_TASK_CLOSE);
1035 + write_chart_dimension("calls", ect->publish_systemd_ps.release_call);
1036 ebpf_write_end_chart();
1037 +
1038 + if (em->mode < MODE_ENTRY) {
1039 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_TASK_ERROR);
1040 + write_chart_dimension("calls", ect->publish_systemd_ps.task_err);
1041 + ebpf_write_end_chart();
1042 + }
1043 }
1044 }
1045
@@ -1003,18 +1050,13 @@ static void ebpf_send_systemd_process_charts(ebpf_module_t *em)
1050 */
1051 static void ebpf_process_send_cgroup_data(ebpf_module_t *em)
1052 {
1006 - if (!ebpf_cgroup_pids)
1007 - return;
1008 -
1053 pthread_mutex_lock(&mutex_cgroup_shm);
1054 ebpf_cgroup_target_t *ect;
1055 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1056 ebpf_process_sum_cgroup_pids(&ect->publish_systemd_ps, ect->pids);
1057 }
1058
1015 - int has_systemd = shm_ebpf_cgroup.header->systemd_enabled;
1016 -
1017 - if (has_systemd) {
1059 + if (shm_ebpf_cgroup.header->systemd_enabled) {
1060 if (send_cgroup_chart) {
1061 ebpf_create_systemd_process_charts(em);
1062 }
src/collectors/ebpf.plugin/ebpf_process.h
+5 -6
@@ -9,7 +9,6 @@
9
10 // Groups used on Dashboard
11 #define NETDATA_PROCESS_GROUP "processes"
12 -#define NETDATA_PROCESS_CGROUP_GROUP "processes (eBPF)"
12
13 // Global chart name
14 #define NETDATA_EXIT_SYSCALL "exit"
@@ -34,11 +33,11 @@
33 #define NETDATA_CGROUP_PROCESS_EXIT_CONTEXT "cgroup.task_exit"
34 #define NETDATA_CGROUP_PROCESS_ERROR_CONTEXT "cgroup.task_error"
35
37 -#define NETDATA_SYSTEMD_PROCESS_CREATE_CONTEXT "services.process_create"
38 -#define NETDATA_SYSTEMD_THREAD_CREATE_CONTEXT "services.thread_create"
39 -#define NETDATA_SYSTEMD_PROCESS_CLOSE_CONTEXT "services.task_close"
40 -#define NETDATA_SYSTEMD_PROCESS_EXIT_CONTEXT "services.task_exit"
41 -#define NETDATA_SYSTEMD_PROCESS_ERROR_CONTEXT "services.task_error"
36 +#define NETDATA_SYSTEMD_PROCESS_CREATE_CONTEXT "systemd.services.process_create"
37 +#define NETDATA_SYSTEMD_THREAD_CREATE_CONTEXT "systemd.services.thread_create"
38 +#define NETDATA_SYSTEMD_PROCESS_CLOSE_CONTEXT "systemd.services.task_close"
39 +#define NETDATA_SYSTEMD_PROCESS_EXIT_CONTEXT "systemd.services.task_exit"
40 +#define NETDATA_SYSTEMD_PROCESS_ERROR_CONTEXT "systemd.services.task_error"
41
42 #define NETDATA_EBPF_CGROUP_UPDATE 30
43
src/collectors/ebpf.plugin/ebpf_shm.c
+98 -70
@@ -285,11 +285,11 @@ static void ebpf_obsolete_specific_shm_charts(char *type, int update_every);
285 *
286 * @param em a pointer to `struct ebpf_module`
287 */
288 -static void ebpf_obsolete_shm_services(ebpf_module_t *em)
288 +static void ebpf_obsolete_shm_services(ebpf_module_t *em, char *id)
289 {
290 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
291 + id,
292 NETDATA_SHMGET_CHART,
292 - "",
293 "Calls to syscall shmget(2).",
294 EBPF_COMMON_DIMENSION_CALL,
295 NETDATA_APPS_IPC_SHM_GROUP,
@@ -299,8 +299,8 @@ static void ebpf_obsolete_shm_services(ebpf_module_t *em)
299 em->update_every);
300
301 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
302 + id,
303 NETDATA_SHMAT_CHART,
303 - "",
304 "Calls to syscall shmat(2).",
305 EBPF_COMMON_DIMENSION_CALL,
306 NETDATA_APPS_IPC_SHM_GROUP,
@@ -310,8 +310,8 @@ static void ebpf_obsolete_shm_services(ebpf_module_t *em)
310 em->update_every);
311
312 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
313 + id,
314 NETDATA_SHMDT_CHART,
314 - "",
315 "Calls to syscall shmdt(2).",
316 EBPF_COMMON_DIMENSION_CALL,
317 NETDATA_APPS_IPC_SHM_GROUP,
@@ -321,8 +321,8 @@ static void ebpf_obsolete_shm_services(ebpf_module_t *em)
321 em->update_every);
322
323 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
324 + id,
325 NETDATA_SHMCTL_CHART,
325 - "",
326 "Calls to syscall shmctl(2).",
327 EBPF_COMMON_DIMENSION_CALL,
328 NETDATA_APPS_IPC_SHM_GROUP,
@@ -342,12 +342,13 @@ static void ebpf_obsolete_shm_services(ebpf_module_t *em)
342 static inline void ebpf_obsolete_shm_cgroup_charts(ebpf_module_t *em) {
343 pthread_mutex_lock(&mutex_cgroup_shm);
344
345 - ebpf_obsolete_shm_services(em);
346 -
345 ebpf_cgroup_target_t *ect;
346 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
349 - if (ect->systemd)
347 + if (ect->systemd) {
348 + ebpf_obsolete_shm_services(em, ect->name);
349 +
350 continue;
351 + }
352
353 ebpf_obsolete_specific_shm_charts(ect->name, em->update_every);
354 }
@@ -839,41 +840,82 @@ static void ebpf_obsolete_specific_shm_charts(char *type, int update_every)
840 **/
841 static void ebpf_create_systemd_shm_charts(int update_every)
842 {
842 - ebpf_create_charts_on_systemd(NETDATA_SHMGET_CHART,
843 - "Calls to syscall shmget(2).",
844 - EBPF_COMMON_DIMENSION_CALL,
845 - NETDATA_APPS_IPC_SHM_GROUP,
846 - NETDATA_EBPF_CHART_TYPE_STACKED,
847 - 20191,
848 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
849 - NETDATA_SYSTEMD_SHM_GET_CONTEXT, NETDATA_EBPF_MODULE_NAME_SHM, update_every);
843 + static ebpf_systemd_args_t data_shmget = {
844 + .title = "Calls to syscall shmget(2).",
845 + .units = EBPF_COMMON_DIMENSION_CALL,
846 + .family = NETDATA_APPS_IPC_SHM_GROUP,
847 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
848 + .order = 20191,
849 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
850 + .context = NETDATA_SYSTEMD_SHM_GET_CONTEXT,
851 + .module = NETDATA_EBPF_MODULE_NAME_SHM,
852 + .update_every = 0,
853 + .suffix = NETDATA_SHMGET_CHART,
854 + .dimension = "calls"
855 + };
856
851 - ebpf_create_charts_on_systemd(NETDATA_SHMAT_CHART,
852 - "Calls to syscall shmat(2).",
853 - EBPF_COMMON_DIMENSION_CALL,
854 - NETDATA_APPS_IPC_SHM_GROUP,
855 - NETDATA_EBPF_CHART_TYPE_STACKED,
856 - 20192,
857 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
858 - NETDATA_SYSTEMD_SHM_AT_CONTEXT, NETDATA_EBPF_MODULE_NAME_SHM, update_every);
857 + static ebpf_systemd_args_t data_shmat = {
858 + .title = "Calls to syscall shmat(2).",
859 + .units = EBPF_COMMON_DIMENSION_CALL,
860 + .family = NETDATA_APPS_IPC_SHM_GROUP,
861 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
862 + .order = 20192,
863 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
864 + .context = NETDATA_SYSTEMD_SHM_AT_CONTEXT,
865 + .module = NETDATA_EBPF_MODULE_NAME_SHM,
866 + .update_every = 0,
867 + .suffix = NETDATA_SHMAT_CHART,
868 + .dimension = "calls"
869 + };
870
860 - ebpf_create_charts_on_systemd(NETDATA_SHMDT_CHART,
861 - "Calls to syscall shmdt(2).",
862 - EBPF_COMMON_DIMENSION_CALL,
863 - NETDATA_APPS_IPC_SHM_GROUP,
864 - NETDATA_EBPF_CHART_TYPE_STACKED,
865 - 20193,
866 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
867 - NETDATA_SYSTEMD_SHM_DT_CONTEXT, NETDATA_EBPF_MODULE_NAME_SHM, update_every);
871 + static ebpf_systemd_args_t data_shmdt = {
872 + .title = "Calls to syscall shmdt(2).",
873 + .units = EBPF_COMMON_DIMENSION_CALL,
874 + .family = NETDATA_APPS_IPC_SHM_GROUP,
875 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
876 + .order = 20193,
877 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
878 + .context = NETDATA_SYSTEMD_SHM_DT_CONTEXT,
879 + .module = NETDATA_EBPF_MODULE_NAME_SHM,
880 + .update_every = 0,
881 + .suffix = NETDATA_SHMDT_CHART,
882 + .dimension = "calls"
883 + };
884
869 - ebpf_create_charts_on_systemd(NETDATA_SHMCTL_CHART,
870 - "Calls to syscall shmctl(2).",
871 - EBPF_COMMON_DIMENSION_CALL,
872 - NETDATA_APPS_IPC_SHM_GROUP,
873 - NETDATA_EBPF_CHART_TYPE_STACKED,
874 - 20193,
875 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
876 - NETDATA_SYSTEMD_SHM_CTL_CONTEXT, NETDATA_EBPF_MODULE_NAME_SHM, update_every);
885 + static ebpf_systemd_args_t data_shmctl = {
886 + .title = "Calls to syscall shmctl(2).",
887 + .units = EBPF_COMMON_DIMENSION_CALL,
888 + .family = NETDATA_APPS_IPC_SHM_GROUP,
889 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
890 + .order = 20194,
891 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
892 + .context = NETDATA_SYSTEMD_SHM_CTL_CONTEXT,
893 + .module = NETDATA_EBPF_MODULE_NAME_SHM,
894 + .update_every = 0,
895 + .suffix = NETDATA_SHMCTL_CHART,
896 + .dimension = "calls"
897 + };
898 +
899 + if (!data_shmget.update_every)
900 + data_shmat.update_every = data_shmctl.update_every =
901 + data_shmdt.update_every = data_shmget.update_every = update_every;
902 +
903 + ebpf_cgroup_target_t *w;
904 + for (w = ebpf_cgroup_pids; w; w = w->next) {
905 + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_SHM_CHART))
906 + continue;
907 +
908 + data_shmat.id = data_shmctl.id = data_shmdt.id = data_shmget.id = w->name;
909 + ebpf_create_charts_on_systemd(&data_shmat);
910 +
911 + ebpf_create_charts_on_systemd(&data_shmctl);
912 +
913 + ebpf_create_charts_on_systemd(&data_shmdt);
914 +
915 + ebpf_create_charts_on_systemd(&data_shmget);
916 +
917 + w->flags |= NETDATA_EBPF_SERVICES_HAS_SHM_CHART;
918 + }
919 }
920
921 /**
@@ -884,37 +926,27 @@ static void ebpf_create_systemd_shm_charts(int update_every)
926 static void ebpf_send_systemd_shm_charts()
927 {
928 ebpf_cgroup_target_t *ect;
887 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SHMGET_CHART, "");
929 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
889 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
890 - write_chart_dimension(ect->name, (long long)ect->publish_shm.get);
930 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_SHM_CHART)) ) {
931 + continue;
932 }
892 - }
893 - ebpf_write_end_chart();
933
895 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SHMAT_CHART, "");
896 - for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
897 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
898 - write_chart_dimension(ect->name, (long long)ect->publish_shm.at);
899 - }
900 - }
901 - ebpf_write_end_chart();
934 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SHMGET_CHART);
935 + write_chart_dimension("calls", (long long)ect->publish_shm.get);
936 + ebpf_write_end_chart();
937
903 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SHMDT_CHART, "");
904 - for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
905 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
906 - write_chart_dimension(ect->name, (long long)ect->publish_shm.dt);
907 - }
908 - }
909 - ebpf_write_end_chart();
938 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SHMAT_CHART);
939 + write_chart_dimension("calls", (long long)ect->publish_shm.at);
940 + ebpf_write_end_chart();
941
911 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SHMCTL_CHART, "");
912 - for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
913 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
914 - write_chart_dimension(ect->name, (long long)ect->publish_shm.ctl);
915 - }
942 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SHMDT_CHART);
943 + write_chart_dimension("calls", (long long)ect->publish_shm.dt);
944 + ebpf_write_end_chart();
945 +
946 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SHMCTL_CHART);
947 + write_chart_dimension("calls", (long long)ect->publish_shm.ctl);
948 + ebpf_write_end_chart();
949 }
917 - ebpf_write_end_chart();
950 }
951
952 /*
@@ -951,17 +983,13 @@ static void ebpf_send_specific_shm_data(char *type, netdata_publish_shm_t *value
983 */
984 void ebpf_shm_send_cgroup_data(int update_every)
985 {
954 - if (!ebpf_cgroup_pids)
955 - return;
956 -
986 pthread_mutex_lock(&mutex_cgroup_shm);
987 ebpf_cgroup_target_t *ect;
988 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
989 ebpf_shm_sum_cgroup_pids(&ect->publish_shm, ect->pids);
990 }
991
963 - int has_systemd = shm_ebpf_cgroup.header->systemd_enabled;
964 - if (has_systemd) {
992 + if (shm_ebpf_cgroup.header->systemd_enabled) {
993 if (send_cgroup_chart) {
994 ebpf_create_systemd_shm_charts(update_every);
995 }
src/collectors/ebpf.plugin/ebpf_shm.h
+4 -4
@@ -23,10 +23,10 @@
23 #define NETDATA_CGROUP_SHM_DT_CONTEXT "cgroup.shmdt"
24 #define NETDATA_CGROUP_SHM_CTL_CONTEXT "cgroup.shmctl"
25
26 -#define NETDATA_SYSTEMD_SHM_GET_CONTEXT "services.shmget"
27 -#define NETDATA_SYSTEMD_SHM_AT_CONTEXT "services.shmat"
28 -#define NETDATA_SYSTEMD_SHM_DT_CONTEXT "services.shmdt"
29 -#define NETDATA_SYSTEMD_SHM_CTL_CONTEXT "services.shmctl"
26 +#define NETDATA_SYSTEMD_SHM_GET_CONTEXT "systemd.services.shmget"
27 +#define NETDATA_SYSTEMD_SHM_AT_CONTEXT "systemd.services.shmat"
28 +#define NETDATA_SYSTEMD_SHM_DT_CONTEXT "systemd.services.shmdt"
29 +#define NETDATA_SYSTEMD_SHM_CTL_CONTEXT "systemd.services.shmctl"
30
31 typedef struct netdata_publish_shm {
32 uint64_t ct;
src/collectors/ebpf.plugin/ebpf_socket.c
+198 -161
@@ -506,12 +506,12 @@ static void ebpf_socket_free(ebpf_module_t *em )
506 *
507 * @param update_every value to overwrite the update frequency set by the server.
508 **/
509 -static void ebpf_obsolete_systemd_socket_charts(int update_every)
509 +static void ebpf_obsolete_systemd_socket_charts(int update_every, char *id)
510 {
511 int order = 20080;
512 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
513 + id,
514 NETDATA_NET_APPS_CONNECTION_TCP_V4,
514 - "",
515 "Calls to tcp_v4_connection",
516 EBPF_COMMON_DIMENSION_CONNECTIONS,
517 NETDATA_APPS_NET_GROUP,
@@ -522,8 +522,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
522
523 if (tcp_v6_connect_address.type == 'T') {
524 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
525 + id,
526 NETDATA_NET_APPS_CONNECTION_TCP_V6,
526 - "",
527 "Calls to tcp_v6_connection",
528 EBPF_COMMON_DIMENSION_CONNECTIONS,
529 NETDATA_APPS_NET_GROUP,
@@ -534,8 +534,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
534 }
535
536 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
537 + id,
538 NETDATA_NET_APPS_BANDWIDTH_RECV,
538 - "",
539 "Bytes received",
540 EBPF_COMMON_DIMENSION_BITS,
541 NETDATA_APPS_NET_GROUP,
@@ -545,8 +545,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
545 update_every);
546
547 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
548 + id,
549 NETDATA_NET_APPS_BANDWIDTH_SENT,
549 - "",
550 "Bytes sent",
551 EBPF_COMMON_DIMENSION_BITS,
552 NETDATA_APPS_NET_GROUP,
@@ -556,8 +556,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
556 update_every);
557
558 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
559 + id,
560 NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS,
560 - "",
561 "Calls to tcp_cleanup_rbuf.",
562 EBPF_COMMON_DIMENSION_CALL,
563 NETDATA_APPS_NET_GROUP,
@@ -567,8 +567,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
567 update_every);
568
569 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
570 + id,
571 NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS,
571 - "",
572 "Calls to tcp_sendmsg.",
573 EBPF_COMMON_DIMENSION_CALL,
574 NETDATA_APPS_NET_GROUP,
@@ -578,8 +578,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
578 update_every);
579
580 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
581 + id,
582 NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT,
582 - "",
583 "Calls to tcp_retransmit",
584 EBPF_COMMON_DIMENSION_CALL,
585 NETDATA_APPS_NET_GROUP,
@@ -589,8 +589,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
589 update_every);
590
591 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
592 + id,
593 NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS,
593 - "",
594 "Calls to udp_sendmsg",
595 EBPF_COMMON_DIMENSION_CALL,
596 NETDATA_APPS_NET_GROUP,
@@ -600,8 +600,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
600 update_every);
601
602 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
603 + id,
604 NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS,
604 - "",
605 "Calls to udp_recvmsg",
606 EBPF_COMMON_DIMENSION_CALL,
607 NETDATA_APPS_NET_GROUP,
@@ -622,12 +622,13 @@ static void ebpf_obsolete_specific_socket_charts(char *type, int update_every);
622 static inline void ebpf_obsolete_socket_cgroup_charts(ebpf_module_t *em) {
623 pthread_mutex_lock(&mutex_cgroup_shm);
624
625 - ebpf_obsolete_systemd_socket_charts(em->update_every);
626 -
625 ebpf_cgroup_target_t *ect;
626 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
629 - if (ect->systemd)
627 + if (ect->systemd) {
628 + ebpf_obsolete_systemd_socket_charts(em->update_every, ect->name);
629 +
630 continue;
631 + }
632
633 ebpf_obsolete_specific_socket_charts(ect->name, em->update_every);
634 }
@@ -2336,96 +2337,166 @@ static void ebpf_send_specific_socket_data(char *type, ebpf_socket_publish_apps_
2337 **/
2338 static void ebpf_create_systemd_socket_charts(int update_every)
2339 {
2339 - int order = 20080;
2340 - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_CONNECTION_TCP_V4,
2341 - "Calls to tcp_v4_connection", EBPF_COMMON_DIMENSION_CONNECTIONS,
2342 - NETDATA_APPS_NET_GROUP,
2343 - NETDATA_EBPF_CHART_TYPE_STACKED,
2344 - order++,
2345 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2346 - NETDATA_SERVICES_SOCKET_TCP_V4_CONN_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET,
2347 - update_every);
2340 + static ebpf_systemd_args_t data_tcp_v4 = {
2341 + .title = "Calls to tcp_v4_connection",
2342 + .units = EBPF_COMMON_DIMENSION_CONNECTIONS,
2343 + .family = NETDATA_APPS_NET_GROUP,
2344 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
2345 + .order = 20080,
2346 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
2347 + .context = NETDATA_SERVICES_SOCKET_TCP_V4_CONN_CONTEXT,
2348 + .module = NETDATA_EBPF_MODULE_NAME_SOCKET,
2349 + .update_every = 0,
2350 + .suffix = NETDATA_NET_APPS_CONNECTION_TCP_V4,
2351 + .dimension = "connections"
2352 + };
2353
2349 - if (tcp_v6_connect_address.type == 'T') {
2350 - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_CONNECTION_TCP_V6,
2351 - "Calls to tcp_v6_connection",
2352 - EBPF_COMMON_DIMENSION_CONNECTIONS,
2353 - NETDATA_APPS_NET_GROUP,
2354 - NETDATA_EBPF_CHART_TYPE_STACKED,
2355 - order++,
2356 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2357 - NETDATA_SERVICES_SOCKET_TCP_V6_CONN_CONTEXT,
2358 - NETDATA_EBPF_MODULE_NAME_SOCKET,
2359 - update_every);
2360 - }
2354 + static ebpf_systemd_args_t data_tcp_v6 = {
2355 + .title = "Calls to tcp_v6_connection",
2356 + .units = EBPF_COMMON_DIMENSION_CONNECTIONS,
2357 + .family = NETDATA_APPS_NET_GROUP,
2358 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
2359 + .order = 20081,
2360 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
2361 + .context = NETDATA_SERVICES_SOCKET_TCP_V6_CONN_CONTEXT,
2362 + .module = NETDATA_EBPF_MODULE_NAME_SOCKET,
2363 + .update_every = 0,
2364 + .suffix = NETDATA_NET_APPS_CONNECTION_TCP_V6,
2365 + .dimension = "connections"
2366 + };
2367
2362 - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_RECV,
2363 - "Bytes received", EBPF_COMMON_DIMENSION_BITS,
2364 - NETDATA_APPS_NET_GROUP,
2365 - NETDATA_EBPF_CHART_TYPE_STACKED,
2366 - order++,
2367 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2368 - NETDATA_SERVICES_SOCKET_BYTES_RECV_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET,
2369 - update_every);
2368 + static ebpf_systemd_args_t data_bandwith_recv = {
2369 + .title = "Bytes received",
2370 + .units = EBPF_COMMON_DIMENSION_BITS,
2371 + .family = NETDATA_APPS_NET_GROUP,
2372 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
2373 + .order = 20082,
2374 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
2375 + .context = NETDATA_SERVICES_SOCKET_BYTES_RECV_CONTEXT,
2376 + .module = NETDATA_EBPF_MODULE_NAME_SOCKET,
2377 + .update_every = 0,
2378 + .suffix = NETDATA_NET_APPS_BANDWIDTH_RECV,
2379 + .dimension = "bits"
2380 + };
2381
2371 - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_SENT,
2372 - "Bytes sent", EBPF_COMMON_DIMENSION_BITS,
2373 - NETDATA_APPS_NET_GROUP,
2374 - NETDATA_EBPF_CHART_TYPE_STACKED,
2375 - order++,
2376 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2377 - NETDATA_SERVICES_SOCKET_BYTES_SEND_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET,
2378 - update_every);
2382 + static ebpf_systemd_args_t data_bandwith_sent = {
2383 + .title = "Bytes sent",
2384 + .units = EBPF_COMMON_DIMENSION_BITS,
2385 + .family = NETDATA_APPS_NET_GROUP,
2386 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
2387 + .order = 20083,
2388 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
2389 + .context = NETDATA_SERVICES_SOCKET_BYTES_SEND_CONTEXT,
2390 + .module = NETDATA_EBPF_MODULE_NAME_SOCKET,
2391 + .update_every = 0,
2392 + .suffix = NETDATA_NET_APPS_BANDWIDTH_SENT,
2393 + .dimension = "bits"
2394 + };
2395
2380 - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS,
2381 - "Calls to tcp_cleanup_rbuf.",
2382 - EBPF_COMMON_DIMENSION_CALL,
2383 - NETDATA_APPS_NET_GROUP,
2384 - NETDATA_EBPF_CHART_TYPE_STACKED,
2385 - order++,
2386 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2387 - NETDATA_SERVICES_SOCKET_TCP_RECV_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET,
2388 - update_every);
2396 + static ebpf_systemd_args_t data_tcp_cleanup = {
2397 + .title = "Calls to tcp_cleanup_rbuf.",
2398 + .units = EBPF_COMMON_DIMENSION_CALL,
2399 + .family = NETDATA_APPS_NET_GROUP,
2400 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
2401 + .order = 20084,
2402 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
2403 + .context = NETDATA_SERVICES_SOCKET_TCP_RECV_CONTEXT,
2404 + .module = NETDATA_EBPF_MODULE_NAME_SOCKET,
2405 + .update_every = 0,
2406 + .suffix = NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS,
2407 + .dimension = "calls"
2408 + };
2409
2390 - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS,
2391 - "Calls to tcp_sendmsg.",
2392 - EBPF_COMMON_DIMENSION_CALL,
2393 - NETDATA_APPS_NET_GROUP,
2394 - NETDATA_EBPF_CHART_TYPE_STACKED,
2395 - order++,
2396 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2397 - NETDATA_SERVICES_SOCKET_TCP_SEND_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET,
2398 - update_every);
2410 + static ebpf_systemd_args_t data_tcp_sendmsg = {
2411 + .title = "Calls to tcp_sendmsg.",
2412 + .units = EBPF_COMMON_DIMENSION_CALL,
2413 + .family = NETDATA_APPS_NET_GROUP,
2414 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
2415 + .order = 20085,
2416 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
2417 + .context = NETDATA_SERVICES_SOCKET_TCP_SEND_CONTEXT,
2418 + .module = NETDATA_EBPF_MODULE_NAME_SOCKET,
2419 + .update_every = 0,
2420 + .suffix = NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS,
2421 + .dimension = "calls"
2422 + };
2423
2400 - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT,
2401 - "Calls to tcp_retransmit",
2402 - EBPF_COMMON_DIMENSION_CALL,
2403 - NETDATA_APPS_NET_GROUP,
2404 - NETDATA_EBPF_CHART_TYPE_STACKED,
2405 - order++,
2406 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2407 - NETDATA_SERVICES_SOCKET_TCP_RETRANSMIT_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET,
2408 - update_every);
2424 + static ebpf_systemd_args_t data_tcp_retransmit = {
2425 + .title = "Calls to tcp_retransmit",
2426 + .units = EBPF_COMMON_DIMENSION_CALL,
2427 + .family = NETDATA_APPS_NET_GROUP,
2428 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
2429 + .order = 20086,
2430 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
2431 + .context = NETDATA_SERVICES_SOCKET_TCP_RETRANSMIT_CONTEXT,
2432 + .module = NETDATA_EBPF_MODULE_NAME_SOCKET,
2433 + .update_every = 0,
2434 + .suffix = NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT,
2435 + .dimension = "calls"
2436 + };
2437
2410 - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS,
2411 - "Calls to udp_sendmsg",
2412 - EBPF_COMMON_DIMENSION_CALL,
2413 - NETDATA_APPS_NET_GROUP,
2414 - NETDATA_EBPF_CHART_TYPE_STACKED,
2415 - order++,
2416 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2417 - NETDATA_SERVICES_SOCKET_UDP_SEND_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET,
2418 - update_every);
2438 + static ebpf_systemd_args_t data_udp_send = {
2439 + .title = "Calls to udp_sendmsg",
2440 + .units = EBPF_COMMON_DIMENSION_CALL,
2441 + .family = NETDATA_APPS_NET_GROUP,
2442 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
2443 + .order = 20087,
2444 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
2445 + .context = NETDATA_SERVICES_SOCKET_UDP_SEND_CONTEXT,
2446 + .module = NETDATA_EBPF_MODULE_NAME_SOCKET,
2447 + .update_every = 0,
2448 + .suffix = NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS,
2449 + .dimension = "calls"
2450 + };
2451
2420 - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS,
2421 - "Calls to udp_recvmsg",
2422 - EBPF_COMMON_DIMENSION_CALL,
2423 - NETDATA_APPS_NET_GROUP,
2424 - NETDATA_EBPF_CHART_TYPE_STACKED,
2425 - order++,
2426 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2427 - NETDATA_SERVICES_SOCKET_UDP_RECV_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET,
2428 - update_every);
2452 + static ebpf_systemd_args_t data_udp_recv = {
2453 + .title = "Calls to udp_recvmsg",
2454 + .units = EBPF_COMMON_DIMENSION_CALL,
2455 + .family = NETDATA_APPS_NET_GROUP,
2456 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
2457 + .order = 20088,
2458 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
2459 + .context = NETDATA_SERVICES_SOCKET_UDP_RECV_CONTEXT,
2460 + .module = NETDATA_EBPF_MODULE_NAME_SOCKET,
2461 + .update_every = 0,
2462 + .suffix = NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS,
2463 + .dimension = "calls"
2464 + };
2465 +
2466 + if (!data_tcp_v4.update_every)
2467 + data_tcp_v4.update_every = data_tcp_v6.update_every = data_bandwith_recv.update_every =
2468 + data_bandwith_sent.update_every = data_tcp_cleanup.update_every = data_tcp_sendmsg.update_every =
2469 + data_tcp_retransmit.update_every = data_udp_send.update_every = data_udp_recv.update_every = update_every;
2470 +
2471 + ebpf_cgroup_target_t *w;
2472 + for (w = ebpf_cgroup_pids; w ; w = w->next) {
2473 + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_SOCKET_CHART))
2474 + continue;
2475 +
2476 + data_tcp_v4.id = data_tcp_v6.id = data_bandwith_recv.id =
2477 + data_bandwith_sent.id = data_tcp_cleanup.id = data_tcp_sendmsg.id =
2478 + data_tcp_retransmit.id = data_udp_send.id = data_udp_recv.id = w->name;
2479 +
2480 + ebpf_create_charts_on_systemd(&data_tcp_v4);
2481 + if (tcp_v6_connect_address.type == 'T') {
2482 + ebpf_create_charts_on_systemd(&data_tcp_v6);
2483 + }
2484 +
2485 + ebpf_create_charts_on_systemd(&data_bandwith_recv);
2486 + ebpf_create_charts_on_systemd(&data_bandwith_sent);
2487 +
2488 + ebpf_create_charts_on_systemd(&data_tcp_cleanup);
2489 +
2490 + ebpf_create_charts_on_systemd(&data_tcp_sendmsg);
2491 +
2492 + ebpf_create_charts_on_systemd(&data_tcp_retransmit);
2493 +
2494 + ebpf_create_charts_on_systemd(&data_udp_recv);
2495 +
2496 + ebpf_create_charts_on_systemd(&data_udp_send);
2497 +
2498 + w->flags |= NETDATA_EBPF_SERVICES_HAS_SOCKET_CHART;
2499 + }
2500 }
2501
2502 /**
@@ -2436,79 +2507,49 @@ static void ebpf_create_systemd_socket_charts(int update_every)
2507 static void ebpf_send_systemd_socket_charts()
2508 {
2509 ebpf_cgroup_target_t *ect;
2439 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_CONNECTION_TCP_V4, "");
2510 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2441 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2442 - write_chart_dimension(ect->name, (long long)ect->publish_socket.call_tcp_v4_connection);
2511 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_SOCKET_CHART)) ) {
2512 + continue;
2513 }
2444 - }
2445 - ebpf_write_end_chart();
2514
2447 - if (tcp_v6_connect_address.type == 'T') {
2448 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_CONNECTION_TCP_V6, "");
2449 - for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
2450 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2451 - write_chart_dimension(ect->name, (long long)ect->publish_socket.call_tcp_v6_connection);
2452 - }
2453 - }
2515 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_CONNECTION_TCP_V4);
2516 + write_chart_dimension("connections", (long long)ect->publish_socket.call_tcp_v4_connection);
2517 ebpf_write_end_chart();
2455 - }
2518
2457 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_SENT, "");
2458 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2459 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2460 - write_chart_dimension(ect->name, (long long)ect->publish_socket.bytes_sent);
2519 + if (tcp_v6_connect_address.type == 'T') {
2520 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_CONNECTION_TCP_V6);
2521 + write_chart_dimension("connections", (long long)ect->publish_socket.call_tcp_v6_connection);
2522 + ebpf_write_end_chart();
2523 }
2462 - }
2463 - ebpf_write_end_chart();
2524
2465 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_RECV, "");
2466 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2467 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2468 - write_chart_dimension(ect->name, (long long)ect->publish_socket.bytes_received);
2469 - }
2470 - }
2471 - ebpf_write_end_chart();
2525 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_SENT);
2526 + write_chart_dimension("bits", (long long)ect->publish_socket.bytes_sent);
2527 + ebpf_write_end_chart();
2528
2473 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS, "");
2474 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2475 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2476 - write_chart_dimension(ect->name, (long long)ect->publish_socket.call_tcp_sent);
2477 - }
2478 - }
2479 - ebpf_write_end_chart();
2529 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_RECV);
2530 + write_chart_dimension("bits", (long long)ect->publish_socket.bytes_received);
2531 + ebpf_write_end_chart();
2532
2481 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS, "");
2482 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2483 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2484 - write_chart_dimension(ect->name, (long long)ect->publish_socket.call_tcp_received);
2485 - }
2486 - }
2487 - ebpf_write_end_chart();
2533 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS);
2534 + write_chart_dimension("calls", (long long)ect->publish_socket.call_tcp_sent);
2535 + ebpf_write_end_chart();
2536
2489 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT, "");
2490 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2491 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2492 - write_chart_dimension(ect->name, (long long)ect->publish_socket.retransmit);
2493 - }
2494 - }
2495 - ebpf_write_end_chart();
2537 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS);
2538 + write_chart_dimension("calls", (long long)ect->publish_socket.call_tcp_received);
2539 + ebpf_write_end_chart();
2540
2497 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS, "");
2498 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2499 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2500 - write_chart_dimension(ect->name, (long long)ect->publish_socket.call_udp_sent);
2501 - }
2502 - }
2503 - ebpf_write_end_chart();
2541 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT);
2542 + write_chart_dimension("calls", (long long)ect->publish_socket.retransmit);
2543 + ebpf_write_end_chart();
2544
2505 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS, "");
2506 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2507 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2508 - write_chart_dimension(ect->name, (long long)ect->publish_socket.call_udp_received);
2509 - }
2545 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS);
2546 + write_chart_dimension("calls", (long long)ect->publish_socket.call_udp_sent);
2547 + ebpf_write_end_chart();
2548 +
2549 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS);
2550 + write_chart_dimension("calls", (long long)ect->publish_socket.call_udp_received);
2551 + ebpf_write_end_chart();
2552 }
2511 - ebpf_write_end_chart();
2553 }
2554
2555 /**
@@ -2532,17 +2573,13 @@ void ebpf_socket_update_cgroup_algorithm()
2573 */
2574 static void ebpf_socket_send_cgroup_data(int update_every)
2575 {
2535 - if (!ebpf_cgroup_pids)
2536 - return;
2537 -
2576 pthread_mutex_lock(&mutex_cgroup_shm);
2577 ebpf_cgroup_target_t *ect;
2578 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2579 ebpf_socket_sum_cgroup_pids(&ect->publish_socket, ect->pids);
2580 }
2581
2544 - int has_systemd = shm_ebpf_cgroup.header->systemd_enabled;
2545 - if (has_systemd) {
2582 + if (shm_ebpf_cgroup.header->systemd_enabled) {
2583 if (send_cgroup_chart) {
2584 ebpf_create_systemd_socket_charts(update_every);
2585 }
@@ -2619,7 +2656,7 @@ static void socket_collector(ebpf_module_t *em)
2656 if (socket_apps_enabled & NETDATA_EBPF_APPS_FLAG_CHART_CREATED)
2657 ebpf_socket_send_apps_data();
2658
2622 - if (cgroups)
2659 + if (cgroups && shm_ebpf_cgroup.header && ebpf_cgroup_pids)
2660 ebpf_socket_send_cgroup_data(update_every);
2661
2662 fflush(stdout);
src/collectors/ebpf.plugin/ebpf_socket.h
+10 -11
@@ -95,8 +95,7 @@ typedef enum ebpf_socket_idx {
95 } ebpf_socket_index_t;
96
97 #define NETDATA_SOCKET_KERNEL_FUNCTIONS "kernel"
98 -#define NETDATA_NETWORK_CONNECTIONS_GROUP "network connections"
99 -#define NETDATA_CGROUP_NET_GROUP "network (eBPF)"
98 +#define NETDATA_CGROUP_NET_GROUP "network"
99
100 // Global chart name
101 #define NETDATA_TCP_OUTBOUND_CONNECTIONS "tcp_outbound_conn"
@@ -142,15 +141,15 @@ typedef enum ebpf_socket_idx {
141 #define NETDATA_CGROUP_SOCKET_UDP_RECV_CONTEXT "cgroup.net_udp_recv"
142 #define NETDATA_CGROUP_SOCKET_UDP_SEND_CONTEXT "cgroup.net_udp_send"
143
145 -#define NETDATA_SERVICES_SOCKET_TCP_V4_CONN_CONTEXT "services.net_conn_ipv4"
146 -#define NETDATA_SERVICES_SOCKET_TCP_V6_CONN_CONTEXT "services.net_conn_ipv6"
147 -#define NETDATA_SERVICES_SOCKET_BYTES_RECV_CONTEXT "services.net_bytes_recv"
148 -#define NETDATA_SERVICES_SOCKET_BYTES_SEND_CONTEXT "services.net_bytes_send"
149 -#define NETDATA_SERVICES_SOCKET_TCP_RECV_CONTEXT "services.net_tcp_recv"
150 -#define NETDATA_SERVICES_SOCKET_TCP_SEND_CONTEXT "services.net_tcp_send"
151 -#define NETDATA_SERVICES_SOCKET_TCP_RETRANSMIT_CONTEXT "services.net_retransmit"
152 -#define NETDATA_SERVICES_SOCKET_UDP_RECV_CONTEXT "services.net_udp_recv"
153 -#define NETDATA_SERVICES_SOCKET_UDP_SEND_CONTEXT "services.net_udp_send"
144 +#define NETDATA_SERVICES_SOCKET_TCP_V4_CONN_CONTEXT "systemd.services.net_conn_ipv4"
145 +#define NETDATA_SERVICES_SOCKET_TCP_V6_CONN_CONTEXT "systemd.services.net_conn_ipv6"
146 +#define NETDATA_SERVICES_SOCKET_BYTES_RECV_CONTEXT "systemd.services.net_bytes_recv"
147 +#define NETDATA_SERVICES_SOCKET_BYTES_SEND_CONTEXT "systemd.services.net_bytes_send"
148 +#define NETDATA_SERVICES_SOCKET_TCP_RECV_CONTEXT "systemd.services.net_tcp_recv"
149 +#define NETDATA_SERVICES_SOCKET_TCP_SEND_CONTEXT "systemd.services.net_tcp_send"
150 +#define NETDATA_SERVICES_SOCKET_TCP_RETRANSMIT_CONTEXT "systemd.services.net_retransmit"
151 +#define NETDATA_SERVICES_SOCKET_UDP_RECV_CONTEXT "systemd.services.net_udp_recv"
152 +#define NETDATA_SERVICES_SOCKET_UDP_SEND_CONTEXT "systemd.services.net_udp_send"
153
154 // ARAL name
155 #define NETDATA_EBPF_SOCKET_ARAL_NAME "ebpf_socket"
src/collectors/ebpf.plugin/ebpf_swap.c
+67 -43
@@ -222,25 +222,25 @@ static void ebpf_obsolete_specific_swap_charts(char *type, int update_every);
222 *
223 * @param em a pointer to `struct ebpf_module`
224 */
225 -static void ebpf_obsolete_swap_services(ebpf_module_t *em)
225 +static void ebpf_obsolete_swap_services(ebpf_module_t *em, char *id)
226 {
227 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
228 + id,
229 NETDATA_MEM_SWAP_READ_CHART,
229 - "",
230 "Calls to function swap_readpage.",
231 EBPF_COMMON_DIMENSION_CALL,
232 - NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
232 + NETDATA_SYSTEM_SWAP_SUBMENU,
233 NETDATA_EBPF_CHART_TYPE_LINE,
234 NETDATA_CGROUP_SWAP_READ_CONTEXT,
235 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5100,
236 em->update_every);
237
238 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
239 + id,
240 NETDATA_MEM_SWAP_WRITE_CHART,
240 - "",
241 "Calls to function swap_writepage.",
242 EBPF_COMMON_DIMENSION_CALL,
243 - NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
243 + NETDATA_SYSTEM_SWAP_SUBMENU,
244 NETDATA_EBPF_CHART_TYPE_LINE,
245 NETDATA_CGROUP_SWAP_WRITE_CONTEXT,
246 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5101,
@@ -257,12 +257,13 @@ static void ebpf_obsolete_swap_services(ebpf_module_t *em)
257 static inline void ebpf_obsolete_swap_cgroup_charts(ebpf_module_t *em) {
258 pthread_mutex_lock(&mutex_cgroup_shm);
259
260 - ebpf_obsolete_swap_services(em);
261 -
260 ebpf_cgroup_target_t *ect;
261 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
264 - if (ect->systemd)
262 + if (ect->systemd) {
263 + ebpf_obsolete_swap_services(em, ect->name);
264 +
265 continue;
266 + }
267
268 ebpf_obsolete_specific_swap_charts(ect->name, em->update_every);
269 }
@@ -669,21 +670,19 @@ static void ebpf_swap_sum_cgroup_pids(netdata_publish_swap_t *swap, struct pid_o
670 static void ebpf_send_systemd_swap_charts()
671 {
672 ebpf_cgroup_target_t *ect;
672 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_MEM_SWAP_READ_CHART, "");
673 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
674 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
675 - write_chart_dimension(ect->name, (long long) ect->publish_systemd_swap.read);
674 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_SWAP_CHART)) ) {
675 + continue;
676 }
677 - }
678 - ebpf_write_end_chart();
677
680 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_MEM_SWAP_WRITE_CHART, "");
681 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
682 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
683 - write_chart_dimension(ect->name, (long long) ect->publish_systemd_swap.write);
684 - }
678 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_MEM_SWAP_READ_CHART);
679 + write_chart_dimension("calls", (long long) ect->publish_systemd_swap.read);
680 + ebpf_write_end_chart();
681 +
682 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_MEM_SWAP_WRITE_CHART);
683 + write_chart_dimension("calls", (long long) ect->publish_systemd_swap.write);
684 + ebpf_write_end_chart();
685 }
686 - ebpf_write_end_chart();
686 }
687
688 /**
@@ -698,7 +697,7 @@ static void ebpf_create_specific_swap_charts(char *type, int update_every)
697 {
698 ebpf_create_chart(type, NETDATA_MEM_SWAP_READ_CHART,
699 "Calls to function swap_readpage.",
701 - EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
700 + EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_SWAP_SUBMENU,
701 NETDATA_CGROUP_SWAP_READ_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,
702 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5100,
703 ebpf_create_global_dimension,
@@ -706,7 +705,7 @@ static void ebpf_create_specific_swap_charts(char *type, int update_every)
705
706 ebpf_create_chart(type, NETDATA_MEM_SWAP_WRITE_CHART,
707 "Calls to function swap_writepage.",
709 - EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
708 + EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_SWAP_SUBMENU,
709 NETDATA_CGROUP_SWAP_WRITE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,
710 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5101,
711 ebpf_create_global_dimension,
@@ -725,12 +724,12 @@ static void ebpf_create_specific_swap_charts(char *type, int update_every)
724 static void ebpf_obsolete_specific_swap_charts(char *type, int update_every)
725 {
726 ebpf_write_chart_obsolete(type, NETDATA_MEM_SWAP_READ_CHART, "", "Calls to function swap_readpage.",
728 - EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
727 + EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_SWAP_SUBMENU,
728 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SWAP_READ_CONTEXT,
729 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5100, update_every);
730
731 ebpf_write_chart_obsolete(type, NETDATA_MEM_SWAP_WRITE_CHART, "", "Calls to function swap_writepage.",
733 - EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
732 + EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_SWAP_SUBMENU,
733 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SWAP_WRITE_CONTEXT,
734 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5101, update_every);
735 }
@@ -763,19 +762,49 @@ static void ebpf_send_specific_swap_data(char *type, netdata_publish_swap_t *val
762 **/
763 static void ebpf_create_systemd_swap_charts(int update_every)
764 {
766 - ebpf_create_charts_on_systemd(NETDATA_MEM_SWAP_READ_CHART,
767 - "Calls to swap_readpage.",
768 - EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
769 - NETDATA_EBPF_CHART_TYPE_STACKED, 20191,
770 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_SWAP_READ_CONTEXT,
771 - NETDATA_EBPF_MODULE_NAME_SWAP, update_every);
772 -
773 - ebpf_create_charts_on_systemd(NETDATA_MEM_SWAP_WRITE_CHART,
774 - "Calls to function swap_writepage.",
775 - EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
776 - NETDATA_EBPF_CHART_TYPE_STACKED, 20192,
777 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_SWAP_WRITE_CONTEXT,
778 - NETDATA_EBPF_MODULE_NAME_SWAP, update_every);
765 + static ebpf_systemd_args_t data_read = {
766 + .title = "Calls to swap_readpage.",
767 + .units = EBPF_COMMON_DIMENSION_CALL,
768 + .family = NETDATA_SYSTEM_SWAP_SUBMENU,
769 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
770 + .order = 20191,
771 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
772 + .context = NETDATA_SYSTEMD_SWAP_READ_CONTEXT,
773 + .module = NETDATA_EBPF_MODULE_NAME_SWAP,
774 + .update_every = 0,
775 + .suffix = NETDATA_MEM_SWAP_READ_CHART,
776 + .dimension = "calls"
777 + };
778 +
779 + static ebpf_systemd_args_t data_write = {
780 + .title = "Calls to function swap_writepage.",
781 + .units = EBPF_COMMON_DIMENSION_CALL,
782 + .family = NETDATA_SYSTEM_SWAP_SUBMENU,
783 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
784 + .order = 20192,
785 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
786 + .context = NETDATA_SYSTEMD_SWAP_WRITE_CONTEXT,
787 + .module = NETDATA_EBPF_MODULE_NAME_SWAP,
788 + .update_every = 0,
789 + .suffix = NETDATA_MEM_SWAP_WRITE_CHART,
790 + .dimension = "calls"
791 + };
792 +
793 + if (!data_write.update_every)
794 + data_read.update_every = data_write.update_every = update_every;
795 +
796 + ebpf_cgroup_target_t *w;
797 + for (w = ebpf_cgroup_pids; w ; w = w->next) {
798 + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_SWAP_CHART))
799 + continue;
800 +
801 + data_read.id = data_write.id = w->name;
802 + ebpf_create_charts_on_systemd(&data_read);
803 +
804 + ebpf_create_charts_on_systemd(&data_write);
805 +
806 + w->flags |= NETDATA_EBPF_SERVICES_HAS_SWAP_CHART;
807 + }
808 }
809
810 /**
@@ -785,18 +814,13 @@ static void ebpf_create_systemd_swap_charts(int update_every)
814 */
815 void ebpf_swap_send_cgroup_data(int update_every)
816 {
788 - if (!ebpf_cgroup_pids)
789 - return;
790 -
817 pthread_mutex_lock(&mutex_cgroup_shm);
818 ebpf_cgroup_target_t *ect;
819 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
820 ebpf_swap_sum_cgroup_pids(&ect->publish_systemd_swap, ect->pids);
821 }
822
797 - int has_systemd = shm_ebpf_cgroup.header->systemd_enabled;
798 -
799 - if (has_systemd) {
823 + if (shm_ebpf_cgroup.header->systemd_enabled) {
824 if (send_cgroup_chart) {
825 ebpf_create_systemd_swap_charts(update_every);
826 fflush(stdout);
@@ -860,7 +884,7 @@ static void swap_collector(ebpf_module_t *em)
884 if (apps & NETDATA_EBPF_APPS_FLAG_CHART_CREATED)
885 ebpf_swap_send_apps_data(apps_groups_root_target);
886
863 - if (cgroup)
887 + if (cgroup && shm_ebpf_cgroup.header && ebpf_cgroup_pids)
888 ebpf_swap_send_cgroup_data(update_every);
889
890 pthread_mutex_unlock(&lock);
src/collectors/ebpf.plugin/ebpf_swap.h
+4 -4
@@ -19,10 +19,10 @@
19 #define NETDATA_DIRECTORY_SWAP_CONFIG_FILE "swap.conf"
20
21 // Contexts
22 -#define NETDATA_CGROUP_SWAP_READ_CONTEXT "cgroup.swap_read"
23 -#define NETDATA_CGROUP_SWAP_WRITE_CONTEXT "cgroup.swap_write"
24 -#define NETDATA_SYSTEMD_SWAP_READ_CONTEXT "services.swap_read"
25 -#define NETDATA_SYSTEMD_SWAP_WRITE_CONTEXT "services.swap_write"
22 +#define NETDATA_CGROUP_SWAP_READ_CONTEXT "systemd.cgroup.swap_read"
23 +#define NETDATA_CGROUP_SWAP_WRITE_CONTEXT "systemd.cgroup.swap_write"
24 +#define NETDATA_SYSTEMD_SWAP_READ_CONTEXT "systemd.services.swap_read"
25 +#define NETDATA_SYSTEMD_SWAP_WRITE_CONTEXT "systemd.services.swap_write"
26
27 typedef struct netdata_publish_swap {
28 uint64_t ct;
src/collectors/ebpf.plugin/ebpf_vfs.c
+314 -221
@@ -394,25 +394,25 @@ static void ebpf_obsolete_specific_vfs_charts(char *type, ebpf_module_t *em);
394 *
395 * @param em a pointer to `struct ebpf_module`
396 */
397 -static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
397 +static void ebpf_obsolete_vfs_services(ebpf_module_t *em, char *id)
398 {
399 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
400 + id,
401 NETDATA_SYSCALL_APPS_FILE_DELETED,
401 - "",
402 "Files deleted",
403 EBPF_COMMON_DIMENSION_CALL,
404 - NETDATA_VFS_CGROUP_GROUP,
404 + NETDATA_VFS_GROUP,
405 NETDATA_EBPF_CHART_TYPE_STACKED,
406 NULL,
407 20065,
408 em->update_every);
409
410 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
411 + id,
412 NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS,
412 - "",
413 "Write to disk",
414 EBPF_COMMON_DIMENSION_CALL,
415 - NETDATA_VFS_CGROUP_GROUP,
415 + NETDATA_VFS_GROUP,
416 NETDATA_EBPF_CHART_TYPE_STACKED,
417 NULL,
418 20066,
@@ -420,11 +420,11 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
420
421 if (em->mode < MODE_ENTRY) {
422 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
423 + id,
424 NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR,
424 - "",
425 "Fails to write",
426 EBPF_COMMON_DIMENSION_CALL,
427 - NETDATA_VFS_CGROUP_GROUP,
427 + NETDATA_VFS_GROUP,
428 NETDATA_EBPF_CHART_TYPE_STACKED,
429 NULL,
430 20067,
@@ -432,11 +432,11 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
432 }
433
434 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
435 + id,
436 NETDATA_SYSCALL_APPS_VFS_READ_CALLS,
436 - "",
437 "Read from disk",
438 EBPF_COMMON_DIMENSION_CALL,
439 - NETDATA_VFS_CGROUP_GROUP,
439 + NETDATA_VFS_GROUP,
440 NETDATA_EBPF_CHART_TYPE_STACKED,
441 NULL,
442 20068,
@@ -444,11 +444,11 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
444
445 if (em->mode < MODE_ENTRY) {
446 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
447 + id,
448 NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR,
448 - "",
449 "Fails to read",
450 EBPF_COMMON_DIMENSION_CALL,
451 - NETDATA_VFS_CGROUP_GROUP,
451 + NETDATA_VFS_GROUP,
452 NETDATA_EBPF_CHART_TYPE_STACKED,
453 NULL,
454 20069,
@@ -456,33 +456,33 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
456 }
457
458 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
459 + id,
460 NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES,
460 - "",
461 "Bytes written on disk",
462 EBPF_COMMON_DIMENSION_BYTES,
463 - NETDATA_VFS_CGROUP_GROUP,
463 + NETDATA_VFS_GROUP,
464 NETDATA_EBPF_CHART_TYPE_STACKED,
465 NULL,
466 20070,
467 em->update_every);
468
469 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
470 + id,
471 NETDATA_SYSCALL_APPS_VFS_READ_BYTES,
471 - "",
472 "Bytes read from disk",
473 EBPF_COMMON_DIMENSION_BYTES,
474 - NETDATA_VFS_CGROUP_GROUP,
474 + NETDATA_VFS_GROUP,
475 NETDATA_EBPF_CHART_TYPE_STACKED,
476 NULL,
477 20071,
478 em->update_every);
479
480 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
481 + id,
482 NETDATA_SYSCALL_APPS_VFS_FSYNC,
482 - "",
483 "Calls to vfs_fsync.",
484 EBPF_COMMON_DIMENSION_CALL,
485 - NETDATA_VFS_CGROUP_GROUP,
485 + NETDATA_VFS_GROUP,
486 NETDATA_EBPF_CHART_TYPE_STACKED,
487 NULL,
488 20072,
@@ -490,22 +490,22 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
490
491 if (em->mode < MODE_ENTRY) {
492 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
493 + id,
494 NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR,
494 - "",
495 "Sync error",
496 EBPF_COMMON_DIMENSION_CALL,
497 - NETDATA_VFS_CGROUP_GROUP,
497 + NETDATA_VFS_GROUP,
498 NETDATA_EBPF_CHART_TYPE_STACKED,
499 NULL,
500 20073,
501 em->update_every);
502 }
503 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
504 + id,
505 NETDATA_SYSCALL_APPS_VFS_OPEN,
505 - "",
506 "Calls to vfs_open.",
507 EBPF_COMMON_DIMENSION_CALL,
508 - NETDATA_VFS_CGROUP_GROUP,
508 + NETDATA_VFS_GROUP,
509 NETDATA_EBPF_CHART_TYPE_STACKED,
510 NULL,
511 20074,
@@ -513,11 +513,11 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
513
514 if (em->mode < MODE_ENTRY) {
515 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
516 + id,
517 NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR,
517 - "",
518 "Open error",
519 EBPF_COMMON_DIMENSION_CALL,
520 - NETDATA_VFS_CGROUP_GROUP,
520 + NETDATA_VFS_GROUP,
521 NETDATA_EBPF_CHART_TYPE_STACKED,
522 NULL,
523 20075,
@@ -525,11 +525,11 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
525 }
526
527 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
528 + id,
529 NETDATA_SYSCALL_APPS_VFS_CREATE,
529 - "",
530 "Calls to vfs_create.",
531 EBPF_COMMON_DIMENSION_CALL,
532 - NETDATA_VFS_CGROUP_GROUP,
532 + NETDATA_VFS_GROUP,
533 NETDATA_EBPF_CHART_TYPE_STACKED,
534 NULL,
535 20076,
@@ -537,11 +537,11 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
537
538 if (em->mode < MODE_ENTRY) {
539 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
540 + id,
541 NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR,
541 - "",
542 "Create error",
543 EBPF_COMMON_DIMENSION_CALL,
544 - NETDATA_VFS_CGROUP_GROUP,
544 + NETDATA_VFS_GROUP,
545 NETDATA_EBPF_CHART_TYPE_STACKED,
546 NULL,
547 20077,
@@ -559,12 +559,13 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
559 static inline void ebpf_obsolete_vfs_cgroup_charts(ebpf_module_t *em) {
560 pthread_mutex_lock(&mutex_cgroup_shm);
561
562 - ebpf_obsolete_vfs_services(em);
563 -
562 ebpf_cgroup_target_t *ect;
563 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
566 - if (ect->systemd)
564 + if (ect->systemd) {
565 + ebpf_obsolete_vfs_services(em, ect->name);
566 +
567 continue;
568 + }
569
570 ebpf_obsolete_specific_vfs_charts(ect->name, em);
571 }
@@ -1356,88 +1357,88 @@ static void ebpf_vfs_sum_cgroup_pids(netdata_publish_vfs_t *vfs, struct pid_on_t
1357 static void ebpf_create_specific_vfs_charts(char *type, ebpf_module_t *em)
1358 {
1359 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_DELETED,"Files deleted",
1359 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_UNLINK_CONTEXT,
1360 + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_UNLINK_CONTEXT,
1361 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5500,
1362 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_UNLINK],
1363 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1364
1365 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "Write to disk",
1365 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_WRITE_CONTEXT,
1366 + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_WRITE_CONTEXT,
1367 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5501,
1368 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE],
1369 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1370
1371 if (em->mode < MODE_ENTRY) {
1372 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "Fails to write",
1372 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_WRITE_ERROR_CONTEXT,
1373 + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_WRITE_ERROR_CONTEXT,
1374 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5502,
1375 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE],
1376 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1377 }
1378
1379 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "Read from disk",
1379 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_READ_CONTEXT,
1380 + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_READ_CONTEXT,
1381 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5503,
1382 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],
1383 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1384
1385 if (em->mode < MODE_ENTRY) {
1386 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "Fails to read",
1386 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_READ_ERROR_CONTEXT,
1387 + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_READ_ERROR_CONTEXT,
1388 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5504,
1389 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],
1390 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1391 }
1392
1393 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "Bytes written on disk",
1393 - EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_WRITE_BYTES_CONTEXT,
1394 + EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_WRITE_BYTES_CONTEXT,
1395 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5505,
1396 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE],
1397 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1398
1399 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "Bytes read from disk",
1399 - EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_READ_BYTES_CONTEXT,
1400 + EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_READ_BYTES_CONTEXT,
1401 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5506,
1402 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],
1403 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1404
1405 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC, "Calls to vfs_fsync.",
1405 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_FSYNC_CONTEXT,
1406 + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_FSYNC_CONTEXT,
1407 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5507,
1408 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC],
1409 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1410
1411 if (em->mode < MODE_ENTRY) {
1412 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, "Sync error",
1412 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_FSYNC_ERROR_CONTEXT,
1413 + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_FSYNC_ERROR_CONTEXT,
1414 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5508,
1415 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC],
1416 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1417 }
1418
1419 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN, "Calls to vfs_open.",
1419 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_OPEN_CONTEXT,
1420 + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_OPEN_CONTEXT,
1421 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5509,
1422 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN],
1423 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1424
1425 if (em->mode < MODE_ENTRY) {
1426 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, "Open error",
1426 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_OPEN_ERROR_CONTEXT,
1427 + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_OPEN_ERROR_CONTEXT,
1428 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5510,
1429 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN],
1430 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1431 }
1432
1433 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE, "Calls to vfs_create.",
1433 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_CREATE_CONTEXT,
1434 + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_CREATE_CONTEXT,
1435 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5511,
1436 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE],
1437 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1438
1439 if (em->mode < MODE_ENTRY) {
1440 ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, "Create error",
1440 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_CREATE_ERROR_CONTEXT,
1441 + EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_CREATE_ERROR_CONTEXT,
1442 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5512,
1443 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE],
1444 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
@@ -1624,93 +1625,235 @@ static void ebpf_send_specific_vfs_data(char *type, netdata_publish_vfs_t *value
1625 **/
1626 static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)
1627 {
1627 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_FILE_DELETED, "Files deleted",
1628 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1629 - NETDATA_EBPF_CHART_TYPE_STACKED, 20065,
1630 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_UNLINK_CONTEXT,
1631 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1632 -
1633 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "Write to disk",
1634 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1635 - NETDATA_EBPF_CHART_TYPE_STACKED, 20066,
1636 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_WRITE_CONTEXT,
1637 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1628 + static ebpf_systemd_args_t data_vfs_unlink = {
1629 + .title = "Files deleted",
1630 + .units = EBPF_COMMON_DIMENSION_CALL,
1631 + .family = NETDATA_VFS_GROUP,
1632 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1633 + .order = 20065,
1634 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1635 + .context = NETDATA_SYSTEMD_VFS_UNLINK_CONTEXT,
1636 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1637 + .update_every = 0,
1638 + .suffix = NETDATA_SYSCALL_APPS_FILE_DELETED,
1639 + .dimension = "calls"
1640 + };
1641
1639 - if (em->mode < MODE_ENTRY) {
1640 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "Fails to write",
1641 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1642 - NETDATA_EBPF_CHART_TYPE_STACKED, 20067,
1643 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1644 - NETDATA_SYSTEMD_VFS_WRITE_ERROR_CONTEXT,
1645 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1646 - }
1642 + static ebpf_systemd_args_t data_vfs_write = {
1643 + .title = "Write to disk",
1644 + .units = EBPF_COMMON_DIMENSION_CALL,
1645 + .family = NETDATA_VFS_GROUP,
1646 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1647 + .order = 20066,
1648 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1649 + .context = NETDATA_SYSTEMD_VFS_WRITE_CONTEXT,
1650 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1651 + .update_every = 0,
1652 + .suffix = NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS,
1653 + .dimension = "calls"
1654 + };
1655
1648 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "Read from disk",
1649 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1650 - NETDATA_EBPF_CHART_TYPE_STACKED, 20068,
1651 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_READ_CONTEXT,
1652 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1656 + static ebpf_systemd_args_t data_vfs_write_err = {
1657 + .title = "Fails to write",
1658 + .units = EBPF_COMMON_DIMENSION_CALL,
1659 + .family = NETDATA_VFS_GROUP,
1660 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1661 + .order = 20067,
1662 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1663 + .context = NETDATA_SYSTEMD_VFS_WRITE_ERROR_CONTEXT,
1664 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1665 + .update_every = 0,
1666 + .suffix = NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR,
1667 + .dimension = "calls"
1668 + };
1669
1654 - if (em->mode < MODE_ENTRY) {
1655 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "Fails to read",
1656 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1657 - NETDATA_EBPF_CHART_TYPE_STACKED, 20069,
1658 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1659 - NETDATA_SYSTEMD_VFS_READ_ERROR_CONTEXT,
1660 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1661 - }
1670 + static ebpf_systemd_args_t data_vfs_read = {
1671 + .title = "Read from disk",
1672 + .units = EBPF_COMMON_DIMENSION_CALL,
1673 + .family = NETDATA_VFS_GROUP,
1674 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1675 + .order = 20068,
1676 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1677 + .context = NETDATA_SYSTEMD_VFS_READ_CONTEXT,
1678 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1679 + .update_every = 0,
1680 + .suffix = NETDATA_SYSCALL_APPS_VFS_READ_CALLS,
1681 + .dimension = "calls"
1682 + };
1683
1663 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "Bytes written on disk",
1664 - EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_CGROUP_GROUP,
1665 - NETDATA_EBPF_CHART_TYPE_STACKED, 20070,
1666 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_WRITE_BYTES_CONTEXT,
1667 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1684 + static ebpf_systemd_args_t data_vfs_read_err = {
1685 + .title = "Fails to read",
1686 + .units = EBPF_COMMON_DIMENSION_CALL,
1687 + .family = NETDATA_VFS_GROUP,
1688 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1689 + .order = 20069,
1690 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1691 + .context = NETDATA_SYSTEMD_VFS_READ_ERROR_CONTEXT,
1692 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1693 + .update_every = 0,
1694 + .suffix = NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR,
1695 + .dimension = "calls"
1696 + };
1697
1669 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "Bytes read from disk",
1670 - EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_CGROUP_GROUP,
1671 - NETDATA_EBPF_CHART_TYPE_STACKED, 20071,
1672 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_READ_BYTES_CONTEXT,
1673 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1698 + static ebpf_systemd_args_t data_vfs_write_bytes = {
1699 + .title = "Bytes written on disk",
1700 + .units = EBPF_COMMON_DIMENSION_BYTES,
1701 + .family = NETDATA_VFS_GROUP,
1702 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1703 + .order = 20070,
1704 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1705 + .context = NETDATA_SYSTEMD_VFS_WRITE_BYTES_CONTEXT,
1706 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1707 + .update_every = 0,
1708 + .suffix = NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES,
1709 + .dimension = "bytes"
1710 + };
1711
1675 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_FSYNC, "Calls to vfs_fsync.",
1676 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1677 - NETDATA_EBPF_CHART_TYPE_STACKED, 20072,
1678 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_FSYNC_CONTEXT,
1679 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1712 + static ebpf_systemd_args_t data_vfs_read_bytes = {
1713 + .title = "Bytes read from disk",
1714 + .units = EBPF_COMMON_DIMENSION_BYTES,
1715 + .family = NETDATA_VFS_GROUP,
1716 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1717 + .order = 20071,
1718 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1719 + .context = NETDATA_SYSTEMD_VFS_READ_BYTES_CONTEXT,
1720 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1721 + .update_every = 0,
1722 + .suffix = NETDATA_SYSCALL_APPS_VFS_READ_BYTES,
1723 + .dimension = "bytes"
1724 + };
1725
1681 - if (em->mode < MODE_ENTRY) {
1682 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, "Sync error",
1683 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1684 - NETDATA_EBPF_CHART_TYPE_STACKED, 20073,
1685 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_FSYNC_ERROR_CONTEXT,
1686 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1687 - }
1688 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_OPEN, "Calls to vfs_open.",
1689 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1690 - NETDATA_EBPF_CHART_TYPE_STACKED, 20074,
1691 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_OPEN_CONTEXT,
1692 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1726 + static ebpf_systemd_args_t data_vfs_fsync = {
1727 + .title = "Calls to vfs_fsync.",
1728 + .units = EBPF_COMMON_DIMENSION_CALL,
1729 + .family = NETDATA_VFS_GROUP,
1730 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1731 + .order = 20072,
1732 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1733 + .context = NETDATA_SYSTEMD_VFS_FSYNC_CONTEXT,
1734 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1735 + .update_every = 0,
1736 + .suffix = NETDATA_SYSCALL_APPS_VFS_FSYNC,
1737 + .dimension = "calls"
1738 + };
1739
1694 - if (em->mode < MODE_ENTRY) {
1695 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, "Open error",
1696 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1697 - NETDATA_EBPF_CHART_TYPE_STACKED, 20075,
1698 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_OPEN_ERROR_CONTEXT,
1699 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1700 - }
1740 + static ebpf_systemd_args_t data_vfs_fsync_err = {
1741 + .title = "Sync error",
1742 + .units = EBPF_COMMON_DIMENSION_CALL,
1743 + .family = NETDATA_VFS_GROUP,
1744 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1745 + .order = 20073,
1746 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1747 + .context = NETDATA_SYSTEMD_VFS_FSYNC_ERROR_CONTEXT,
1748 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1749 + .update_every = 0,
1750 + .suffix = NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR,
1751 + .dimension = "calls"
1752 + };
1753 +
1754 + static ebpf_systemd_args_t data_vfs_open = {
1755 + .title = "Calls to vfs_open.",
1756 + .units = EBPF_COMMON_DIMENSION_CALL,
1757 + .family = NETDATA_VFS_GROUP,
1758 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1759 + .order = 20074,
1760 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1761 + .context = NETDATA_SYSTEMD_VFS_OPEN_CONTEXT,
1762 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1763 + .update_every = 0,
1764 + .suffix = NETDATA_SYSCALL_APPS_VFS_OPEN,
1765 + .dimension = "calls"
1766 + };
1767
1702 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_CREATE, "Calls to vfs_create.",
1703 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1704 - NETDATA_EBPF_CHART_TYPE_STACKED, 20076,
1705 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_CREATE_CONTEXT,
1706 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1768 + static ebpf_systemd_args_t data_vfs_open_err = {
1769 + .title = "Open error",
1770 + .units = EBPF_COMMON_DIMENSION_CALL,
1771 + .family = NETDATA_VFS_GROUP,
1772 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1773 + .order = 20075,
1774 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1775 + .context = NETDATA_SYSTEMD_VFS_OPEN_ERROR_CONTEXT,
1776 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1777 + .update_every = 0,
1778 + .suffix = NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR,
1779 + .dimension = "calls"
1780 + };
1781
1708 - if (em->mode < MODE_ENTRY) {
1709 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, "Create error",
1710 - EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1711 - NETDATA_EBPF_CHART_TYPE_STACKED, 20077,
1712 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_CREATE_ERROR_CONTEXT,
1713 - NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1782 + static ebpf_systemd_args_t data_vfs_create = {
1783 + .title = "Calls to vfs_create.",
1784 + .units = EBPF_COMMON_DIMENSION_CALL,
1785 + .family = NETDATA_VFS_GROUP,
1786 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1787 + .order = 20076,
1788 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1789 + .context = NETDATA_SYSTEMD_VFS_CREATE_CONTEXT,
1790 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1791 + .update_every = 0,
1792 + .suffix = NETDATA_SYSCALL_APPS_VFS_CREATE,
1793 + .dimension = "calls"
1794 + };
1795 +
1796 + static ebpf_systemd_args_t data_vfs_create_err = {
1797 + .title = "Create error",
1798 + .units = EBPF_COMMON_DIMENSION_CALL,
1799 + .family = NETDATA_VFS_GROUP,
1800 + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED,
1801 + .order = 20077,
1802 + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL,
1803 + .context = NETDATA_SYSTEMD_VFS_CREATE_ERROR_CONTEXT,
1804 + .module = NETDATA_EBPF_MODULE_NAME_VFS,
1805 + .update_every = 0,
1806 + .suffix = NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR,
1807 + .dimension = "calls"
1808 + };
1809 +
1810 + if (!data_vfs_create.update_every)
1811 + data_vfs_unlink.update_every = data_vfs_write.update_every = data_vfs_write_err.update_every =
1812 + data_vfs_read.update_every = data_vfs_read_err.update_every = data_vfs_write_bytes.update_every =
1813 + data_vfs_read_bytes.update_every = data_vfs_fsync.update_every = data_vfs_fsync_err.update_every =
1814 + data_vfs_open.update_every = data_vfs_open_err.update_every = data_vfs_create.update_every =
1815 + data_vfs_create_err.update_every = em->update_every;
1816 +
1817 + ebpf_cgroup_target_t *w;
1818 + for (w = ebpf_cgroup_pids; w ; w = w->next) {
1819 + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_VFS_CHART))
1820 + continue;
1821 +
1822 + data_vfs_unlink.id = data_vfs_write.id = data_vfs_write_err.id =
1823 + data_vfs_read.id = data_vfs_read_err.id = data_vfs_write_bytes.id = data_vfs_read_bytes.id =
1824 + data_vfs_fsync.id = data_vfs_fsync_err.id = data_vfs_open.id =
1825 + data_vfs_open_err.id = data_vfs_create.id = data_vfs_create_err.id = w->name;
1826 + ebpf_create_charts_on_systemd(&data_vfs_unlink);
1827 +
1828 + ebpf_create_charts_on_systemd(&data_vfs_write);
1829 + if (em->mode < MODE_ENTRY) {
1830 + ebpf_create_charts_on_systemd(&data_vfs_write_err);
1831 + }
1832 +
1833 + ebpf_create_charts_on_systemd(&data_vfs_read);
1834 + if (em->mode < MODE_ENTRY) {
1835 + ebpf_create_charts_on_systemd(&data_vfs_read_err);
1836 + }
1837 +
1838 + ebpf_create_charts_on_systemd(&data_vfs_write_bytes);
1839 + ebpf_create_charts_on_systemd(&data_vfs_read_bytes);
1840 +
1841 + ebpf_create_charts_on_systemd(&data_vfs_fsync);
1842 + if (em->mode < MODE_ENTRY) {
1843 + ebpf_create_charts_on_systemd(&data_vfs_fsync_err);
1844 + }
1845 +
1846 + ebpf_create_charts_on_systemd(&data_vfs_open);
1847 + if (em->mode < MODE_ENTRY) {
1848 + ebpf_create_charts_on_systemd(&data_vfs_open_err);
1849 + }
1850 +
1851 + ebpf_create_charts_on_systemd(&data_vfs_create);
1852 + if (em->mode < MODE_ENTRY) {
1853 + ebpf_create_charts_on_systemd(&data_vfs_create_err);
1854 + }
1855 +
1856 + w->flags |= NETDATA_EBPF_SERVICES_HAS_VFS_CHART;
1857 }
1858 }
1859
@@ -1724,124 +1867,78 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)
1867 static void ebpf_send_systemd_vfs_charts(ebpf_module_t *em)
1868 {
1869 ebpf_cgroup_target_t *ect;
1727 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_DELETED, "");
1870 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1729 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1730 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.unlink_call);
1871 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_VFS_CHART)) ) {
1872 + continue;
1873 }
1732 - }
1733 - ebpf_write_end_chart();
1874
1735 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "");
1736 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1737 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1738 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.write_call +
1739 - ect->publish_systemd_vfs.writev_call);
1740 - }
1741 - }
1742 - ebpf_write_end_chart();
1875 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_FILE_DELETED);
1876 + write_chart_dimension("calls", ect->publish_systemd_vfs.unlink_call);
1877 + ebpf_write_end_chart();
1878
1744 - if (em->mode < MODE_ENTRY) {
1745 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "");
1746 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1747 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1748 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.write_err +
1749 - ect->publish_systemd_vfs.writev_err);
1750 - }
1751 - }
1879 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS);
1880 + write_chart_dimension("calls", ect->publish_systemd_vfs.write_call +
1881 + ect->publish_systemd_vfs.writev_call);
1882 ebpf_write_end_chart();
1753 - }
1883
1755 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "");
1756 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1757 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1758 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.read_call +
1759 - ect->publish_systemd_vfs.readv_call);
1884 + if (em->mode < MODE_ENTRY) {
1885 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR);
1886 + write_chart_dimension("calls", ect->publish_systemd_vfs.write_err +
1887 + ect->publish_systemd_vfs.writev_err);
1888 + ebpf_write_end_chart();
1889 }
1761 - }
1762 - ebpf_write_end_chart();
1890
1764 - if (em->mode < MODE_ENTRY) {
1765 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "");
1766 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1767 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1768 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.read_err +
1769 - ect->publish_systemd_vfs.readv_err);
1770 - }
1771 - }
1891 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_READ_CALLS);
1892 + write_chart_dimension("calls", ect->publish_systemd_vfs.read_call +
1893 + ect->publish_systemd_vfs.readv_call);
1894 ebpf_write_end_chart();
1773 - }
1895
1775 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "");
1776 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1777 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1778 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.write_bytes +
1779 - ect->publish_systemd_vfs.writev_bytes);
1896 + if (em->mode < MODE_ENTRY) {
1897 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR);
1898 + write_chart_dimension("calls", ect->publish_systemd_vfs.read_err +
1899 + ect->publish_systemd_vfs.readv_err);
1900 + ebpf_write_end_chart();
1901 }
1781 - }
1782 - ebpf_write_end_chart();
1902
1784 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "");
1785 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1786 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1787 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.read_bytes +
1788 - ect->publish_systemd_vfs.readv_bytes);
1789 - }
1790 - }
1791 - ebpf_write_end_chart();
1903 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES);
1904 + write_chart_dimension("bytes", ect->publish_systemd_vfs.write_bytes +
1905 + ect->publish_systemd_vfs.writev_bytes);
1906 + ebpf_write_end_chart();
1907
1793 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_FSYNC, "");
1794 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1795 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1796 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.fsync_call);
1797 - }
1798 - }
1799 - ebpf_write_end_chart();
1908 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_READ_BYTES);
1909 + write_chart_dimension("bytes", ect->publish_systemd_vfs.read_bytes +
1910 + ect->publish_systemd_vfs.readv_bytes);
1911 + ebpf_write_end_chart();
1912
1801 - if (em->mode < MODE_ENTRY) {
1802 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, "");
1803 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1804 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1805 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.fsync_err);
1806 - }
1807 - }
1913 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_FSYNC);
1914 + write_chart_dimension("calls", ect->publish_systemd_vfs.fsync_call);
1915 ebpf_write_end_chart();
1809 - }
1916
1811 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_OPEN, "");
1812 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1813 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1814 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.open_call);
1917 + if (em->mode < MODE_ENTRY) {
1918 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR);
1919 + write_chart_dimension("calls", ect->publish_systemd_vfs.fsync_err);
1920 + ebpf_write_end_chart();
1921 }
1816 - }
1817 - ebpf_write_end_chart();
1922
1819 - if (em->mode < MODE_ENTRY) {
1820 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, "");
1821 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1822 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1823 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.open_err);
1824 - }
1825 - }
1923 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_OPEN);
1924 + write_chart_dimension("calls", ect->publish_systemd_vfs.open_call);
1925 ebpf_write_end_chart();
1827 - }
1926
1829 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_CREATE, "");
1830 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1831 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1832 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.create_call);
1927 + if (em->mode < MODE_ENTRY) {
1928 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR);
1929 + write_chart_dimension("calls", ect->publish_systemd_vfs.open_err);
1930 + ebpf_write_end_chart();
1931 }
1834 - }
1835 - ebpf_write_end_chart();
1932
1837 - if (em->mode < MODE_ENTRY) {
1838 - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, "");
1839 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1840 - if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1841 - write_chart_dimension(ect->name, ect->publish_systemd_vfs.create_err);
1842 - }
1843 - }
1933 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_CREATE);
1934 + write_chart_dimension("calls", ect->publish_systemd_vfs.create_call);
1935 ebpf_write_end_chart();
1936 +
1937 + if (em->mode < MODE_ENTRY) {
1938 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR);
1939 + write_chart_dimension("calls", ect->publish_systemd_vfs.create_err);
1940 + ebpf_write_end_chart();
1941 + }
1942 }
1943 }
1944
@@ -1852,17 +1949,13 @@ static void ebpf_send_systemd_vfs_charts(ebpf_module_t *em)
1949 */
1950 static void ebpf_vfs_send_cgroup_data(ebpf_module_t *em)
1951 {
1855 - if (!ebpf_cgroup_pids)
1856 - return;
1857 -
1952 pthread_mutex_lock(&mutex_cgroup_shm);
1953 ebpf_cgroup_target_t *ect;
1954 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1955 ebpf_vfs_sum_cgroup_pids(&ect->publish_systemd_vfs, ect->pids);
1956 }
1957
1864 - int has_systemd = shm_ebpf_cgroup.header->systemd_enabled;
1865 - if (has_systemd) {
1958 + if (shm_ebpf_cgroup.header->systemd_enabled) {
1959 if (send_cgroup_chart) {
1960 ebpf_create_systemd_vfs_charts(em);
1961 }
@@ -1995,7 +2088,7 @@ static void vfs_collector(ebpf_module_t *em)
2088 if (apps & NETDATA_EBPF_APPS_FLAG_CHART_CREATED)
2089 ebpf_vfs_send_apps_data(em, apps_groups_root_target);
2090
1998 - if (cgroups)
2091 + if (cgroups && shm_ebpf_cgroup.header && ebpf_cgroup_pids)
2092 ebpf_vfs_send_cgroup_data(em);
2093
2094 pthread_mutex_unlock(&lock);
src/collectors/ebpf.plugin/ebpf_vfs.h
+13 -14
@@ -39,7 +39,6 @@
39
40 // Group used on Dashboard
41 #define NETDATA_VFS_GROUP "vfs"
42 -#define NETDATA_VFS_CGROUP_GROUP "vfs (eBPF)"
42
43 // Contexts
44 #define NETDATA_CGROUP_VFS_UNLINK_CONTEXT "cgroup.vfs_unlink"
@@ -56,19 +55,19 @@
55 #define NETDATA_CGROUP_VFS_FSYNC_CONTEXT "cgroup.vfs_fsync"
56 #define NETDATA_CGROUP_VFS_FSYNC_ERROR_CONTEXT "cgroup.vfs_fsync_error"
57
59 -#define NETDATA_SYSTEMD_VFS_UNLINK_CONTEXT "services.vfs_unlink"
60 -#define NETDATA_SYSTEMD_VFS_WRITE_CONTEXT "services.vfs_write"
61 -#define NETDATA_SYSTEMD_VFS_WRITE_ERROR_CONTEXT "services.vfs_write_error"
62 -#define NETDATA_SYSTEMD_VFS_READ_CONTEXT "services.vfs_read"
63 -#define NETDATA_SYSTEMD_VFS_READ_ERROR_CONTEXT "services.vfs_read_error"
64 -#define NETDATA_SYSTEMD_VFS_WRITE_BYTES_CONTEXT "services.vfs_write_bytes"
65 -#define NETDATA_SYSTEMD_VFS_READ_BYTES_CONTEXT "services.vfs_read_bytes"
66 -#define NETDATA_SYSTEMD_VFS_CREATE_CONTEXT "services.vfs_create"
67 -#define NETDATA_SYSTEMD_VFS_CREATE_ERROR_CONTEXT "services.vfs_create_error"
68 -#define NETDATA_SYSTEMD_VFS_OPEN_CONTEXT "services.vfs_open"
69 -#define NETDATA_SYSTEMD_VFS_OPEN_ERROR_CONTEXT "services.vfs_open_error"
70 -#define NETDATA_SYSTEMD_VFS_FSYNC_CONTEXT "services.vfs_fsync"
71 -#define NETDATA_SYSTEMD_VFS_FSYNC_ERROR_CONTEXT "services.vfs_fsync_error"
58 +#define NETDATA_SYSTEMD_VFS_UNLINK_CONTEXT "systemd.services.vfs_unlink"
59 +#define NETDATA_SYSTEMD_VFS_WRITE_CONTEXT "systemd.services.vfs_write"
60 +#define NETDATA_SYSTEMD_VFS_WRITE_ERROR_CONTEXT "systemd.services.vfs_write_error"
61 +#define NETDATA_SYSTEMD_VFS_READ_CONTEXT "systemd.services.vfs_read"
62 +#define NETDATA_SYSTEMD_VFS_READ_ERROR_CONTEXT "systemd.services.vfs_read_error"
63 +#define NETDATA_SYSTEMD_VFS_WRITE_BYTES_CONTEXT "systemd.services.vfs_write_bytes"
64 +#define NETDATA_SYSTEMD_VFS_READ_BYTES_CONTEXT "systemd.services.vfs_read_bytes"
65 +#define NETDATA_SYSTEMD_VFS_CREATE_CONTEXT "systemd.services.vfs_create"
66 +#define NETDATA_SYSTEMD_VFS_CREATE_ERROR_CONTEXT "systemd.services.vfs_create_error"
67 +#define NETDATA_SYSTEMD_VFS_OPEN_CONTEXT "systemd.services.vfs_open"
68 +#define NETDATA_SYSTEMD_VFS_OPEN_ERROR_CONTEXT "systemd.services.vfs_open_error"
69 +#define NETDATA_SYSTEMD_VFS_FSYNC_CONTEXT "systemd.services.vfs_fsync"
70 +#define NETDATA_SYSTEMD_VFS_FSYNC_ERROR_CONTEXT "systemd.services.vfs_fsync_error"
71
72 // ARAL name
73 #define NETDATA_EBPF_VFS_ARAL_NAME "ebpf_vfs"