diff options
Diffstat (limited to '')
| -rw-r--r-- | src/collectors/ebpf.plugin/ebpf_socket.c (renamed from collectors/ebpf.plugin/ebpf_socket.c) | 515 |
1 files changed, 272 insertions, 243 deletions
diff --git a/collectors/ebpf.plugin/ebpf_socket.c b/src/collectors/ebpf.plugin/ebpf_socket.c index bbb5dca1b..5361526df 100644 --- a/collectors/ebpf.plugin/ebpf_socket.c +++ b/src/collectors/ebpf.plugin/ebpf_socket.c @@ -107,10 +107,6 @@ struct netdata_static_thread ebpf_read_socket = { ARAL *aral_socket_table = NULL; -#ifdef NETDATA_DEV_MODE -int socket_disable_priority; -#endif - #ifdef LIBBPF_MAJOR_VERSION /** * Disable Probe @@ -510,12 +506,12 @@ static void ebpf_socket_free(ebpf_module_t *em ) * * @param update_every value to overwrite the update frequency set by the server. **/ -static void ebpf_obsolete_systemd_socket_charts(int update_every) +static void ebpf_obsolete_systemd_socket_charts(int update_every, char *id) { int order = 20080; ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_NET_APPS_CONNECTION_TCP_V4, - "", "Calls to tcp_v4_connection", EBPF_COMMON_DIMENSION_CONNECTIONS, NETDATA_APPS_NET_GROUP, @@ -526,8 +522,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every) if (tcp_v6_connect_address.type == 'T') { ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_NET_APPS_CONNECTION_TCP_V6, - "", "Calls to tcp_v6_connection", EBPF_COMMON_DIMENSION_CONNECTIONS, NETDATA_APPS_NET_GROUP, @@ -538,8 +534,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every) } ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_NET_APPS_BANDWIDTH_RECV, - "", "Bytes received", EBPF_COMMON_DIMENSION_BITS, NETDATA_APPS_NET_GROUP, @@ -549,8 +545,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every) update_every); ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_NET_APPS_BANDWIDTH_SENT, - "", "Bytes sent", EBPF_COMMON_DIMENSION_BITS, NETDATA_APPS_NET_GROUP, @@ -560,8 +556,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every) update_every); ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS, - "", "Calls to tcp_cleanup_rbuf.", EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_NET_GROUP, @@ -571,8 +567,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every) update_every); ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS, - "", "Calls to tcp_sendmsg.", EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_NET_GROUP, @@ -582,8 +578,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every) update_every); ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT, - "", "Calls to tcp_retransmit", EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_NET_GROUP, @@ -593,8 +589,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every) update_every); ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS, - "", "Calls to udp_sendmsg", EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_NET_GROUP, @@ -604,8 +600,8 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every) update_every); ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY, + id, NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS, - "", "Calls to udp_recvmsg", EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_NET_GROUP, @@ -626,12 +622,13 @@ static void ebpf_obsolete_specific_socket_charts(char *type, int update_every); static inline void ebpf_obsolete_socket_cgroup_charts(ebpf_module_t *em) { pthread_mutex_lock(&mutex_cgroup_shm); - ebpf_obsolete_systemd_socket_charts(em->update_every); - ebpf_cgroup_target_t *ect; for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (ect->systemd) + if (ect->systemd) { + ebpf_obsolete_systemd_socket_charts(em->update_every, ect->name); + continue; + } ebpf_obsolete_specific_socket_charts(ect->name, em->update_every); } @@ -650,6 +647,7 @@ void ebpf_socket_obsolete_apps_charts(struct ebpf_module *em) int order = 20130; struct ebpf_target *w; int update_every = em->update_every; + pthread_mutex_lock(&collect_data_mutex); for (w = apps_groups_root_target; w; w = w->next) { if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SOCKET_IDX)))) continue; @@ -757,6 +755,7 @@ void ebpf_socket_obsolete_apps_charts(struct ebpf_module *em) w->charts_created &= ~(1<<EBPF_MODULE_SOCKET_IDX); } + pthread_mutex_unlock(&collect_data_mutex); } /** @@ -904,10 +903,6 @@ static void ebpf_socket_exit(void *ptr) ebpf_socket_obsolete_global_charts(em); -#ifdef NETDATA_DEV_MODE - if (ebpf_aral_socket_pid) - ebpf_statistic_obsolete_aral_chart(em, socket_disable_priority); -#endif pthread_mutex_unlock(&lock); } @@ -1031,83 +1026,57 @@ static void ebpf_socket_send_data(ebpf_module_t *em) /** * Send data to Netdata calling auxiliary functions. - * - * @param em the structure with thread information - * @param root the target list. */ -void ebpf_socket_send_apps_data(ebpf_module_t *em, struct ebpf_target *root) +void ebpf_socket_send_apps_data() { - UNUSED(em); - struct ebpf_target *w; - // This algorithm is improved in https://github.com/netdata/netdata/pull/16030 - collected_number values[9]; - - for (w = root; w; w = w->next) { + pthread_mutex_lock(&collect_data_mutex); + for (w = apps_groups_root_target; w; w = w->next) { if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SOCKET_IDX)))) continue; - struct ebpf_pid_on_target *move = w->root_pid; - // Simplify algorithm, but others will appear only in https://github.com/netdata/netdata/pull/16030 - memset(values, 0, sizeof(values)); - while (move) { - int32_t pid = move->pid; - ebpf_socket_publish_apps_t *ws = socket_bandwidth_curr[pid]; - if (ws) { - values[0] += (collected_number) ws->call_tcp_v4_connection; - values[1] += (collected_number) ws->call_tcp_v6_connection; - values[2] += (collected_number) ws->bytes_sent; - values[3] += (collected_number) ws->bytes_received; - values[4] += (collected_number) ws->call_tcp_sent; - values[5] += (collected_number) ws->call_tcp_received; - values[6] += (collected_number) ws->retransmit; - values[7] += (collected_number) ws->call_udp_sent; - values[8] += (collected_number) ws->call_udp_received; - } - - move = move->next; - } - + ebpf_socket_publish_apps_t *values = &w->socket; ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_tcp_v4_connection"); - write_chart_dimension("connections", values[0]); + write_chart_dimension("connections", (collected_number) values->call_tcp_v4_connection); ebpf_write_end_chart(); if (tcp_v6_connect_address.type == 'T') { ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_call_tcp_v6_connection"); - write_chart_dimension("calls", values[1]); + write_chart_dimension("calls", (collected_number) values->call_tcp_v6_connection); ebpf_write_end_chart(); } ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_sock_bytes_sent"); // We multiply by 0.008, because we read bytes, but we display bits - write_chart_dimension("bandwidth", ((values[2])*8)/1000); + write_chart_dimension("bandwidth", (collected_number) ((values->bytes_sent)*8)/1000); ebpf_write_end_chart(); ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_sock_bytes_received"); // We multiply by 0.008, because we read bytes, but we display bits - write_chart_dimension("bandwidth", ((values[3])*8)/1000); + write_chart_dimension("bandwidth", (collected_number) ((values->bytes_received)*8)/1000); ebpf_write_end_chart(); ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_tcp_sendmsg"); - write_chart_dimension("calls", values[4]); + write_chart_dimension("calls", (collected_number) values->call_tcp_sent); ebpf_write_end_chart(); ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_tcp_cleanup_rbuf"); - write_chart_dimension("calls", values[5]); + write_chart_dimension("calls", (collected_number) values->call_tcp_received); ebpf_write_end_chart(); ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_tcp_retransmit"); - write_chart_dimension("calls", values[6]); + write_chart_dimension("calls", (collected_number) values->retransmit); ebpf_write_end_chart(); ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_udp_sendmsg"); - write_chart_dimension("calls", values[7]); + write_chart_dimension("calls", (collected_number) values->call_udp_sent); ebpf_write_end_chart(); ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_udp_recvmsg"); - write_chart_dimension("calls", values[8]); + write_chart_dimension("calls", (collected_number) values->call_udp_received); ebpf_write_end_chart(); } + pthread_mutex_unlock(&collect_data_mutex); } /***************************************************************** @@ -1809,6 +1778,41 @@ end_socket_loop: } netdata_thread_enable_cancelability(); } +/** + * Resume apps data + */ +void ebpf_socket_resume_apps_data() +{ + struct ebpf_target *w; + + for (w = apps_groups_root_target; w; w = w->next) { + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SOCKET_IDX)))) + continue; + + struct ebpf_pid_on_target *move = w->root_pid; + + ebpf_socket_publish_apps_t *values = &w->socket; + memset(&w->socket, 0, sizeof(ebpf_socket_publish_apps_t)); + while (move) { + int32_t pid = move->pid; + ebpf_pid_stat_t *local_pid = ebpf_get_pid_entry(pid, 0); + if (local_pid) { + ebpf_socket_publish_apps_t *ws = &local_pid->socket; + values->call_tcp_v4_connection = ws->call_tcp_v4_connection; + values->call_tcp_v6_connection = ws->call_tcp_v6_connection; + values->bytes_sent = ws->bytes_sent; + values->bytes_received = ws->bytes_received; + values->call_tcp_sent = ws->call_tcp_sent; + values->call_tcp_received = ws->call_tcp_received; + values->retransmit = ws->retransmit; + values->call_udp_sent = ws->call_udp_sent; + values->call_udp_received = ws->call_udp_received; + } + + move = move->next; + } + } +} /** * Socket thread @@ -1839,7 +1843,10 @@ void *ebpf_read_socket_thread(void *ptr) if (ebpf_plugin_exit || ++counter != update_every) continue; + pthread_mutex_lock(&collect_data_mutex); ebpf_update_array_vectors(em); + ebpf_socket_resume_apps_data(); + pthread_mutex_unlock(&collect_data_mutex); counter = 0; } @@ -1992,23 +1999,23 @@ static void ebpf_socket_read_hash_global_tables(netdata_idx_t *stats, int maps_p */ void ebpf_socket_fill_publish_apps(uint32_t current_pid, netdata_socket_t *ns) { - ebpf_socket_publish_apps_t *curr = socket_bandwidth_curr[current_pid]; - if (!curr) { - curr = ebpf_socket_stat_get(); - socket_bandwidth_curr[current_pid] = curr; - } + ebpf_pid_stat_t *local_pid = ebpf_get_pid_entry(current_pid, 0); + if (!local_pid) + return; - curr->bytes_sent += ns->tcp.tcp_bytes_sent; - curr->bytes_received += ns->tcp.tcp_bytes_received; - curr->call_tcp_sent += ns->tcp.call_tcp_sent; - curr->call_tcp_received += ns->tcp.call_tcp_received; - curr->retransmit += ns->tcp.retransmit; - curr->call_close += ns->tcp.close; - curr->call_tcp_v4_connection += ns->tcp.ipv4_connect; - curr->call_tcp_v6_connection += ns->tcp.ipv6_connect; - - curr->call_udp_sent += ns->udp.call_udp_sent; - curr->call_udp_received += ns->udp.call_udp_received; + ebpf_socket_publish_apps_t *curr = &local_pid->socket; + + curr->bytes_sent = ns->tcp.tcp_bytes_sent; + curr->bytes_received = ns->tcp.tcp_bytes_received; + curr->call_tcp_sent = ns->tcp.call_tcp_sent; + curr->call_tcp_received = ns->tcp.call_tcp_received; + curr->retransmit = ns->tcp.retransmit; + curr->call_close = ns->tcp.close; + curr->call_tcp_v4_connection = ns->tcp.ipv4_connect; + curr->call_tcp_v6_connection = ns->tcp.ipv6_connect; + + curr->call_udp_sent = ns->udp.call_udp_sent; + curr->call_udp_received = ns->udp.call_udp_received; } /** @@ -2026,8 +2033,9 @@ static void ebpf_update_socket_cgroup() for (pids = ect->pids; pids; pids = pids->next) { int pid = pids->pid; ebpf_socket_publish_apps_t *publish = &ect->publish_socket; - if (likely(socket_bandwidth_curr) && socket_bandwidth_curr[pid]) { - ebpf_socket_publish_apps_t *in = socket_bandwidth_curr[pid]; + ebpf_pid_stat_t *local_pid = ebpf_get_pid_entry(pid, 0); + if (local_pid) { + ebpf_socket_publish_apps_t *in = &local_pid->socket; publish->bytes_sent = in->bytes_sent; publish->bytes_received = in->bytes_received; @@ -2329,96 +2337,166 @@ static void ebpf_send_specific_socket_data(char *type, ebpf_socket_publish_apps_ **/ static void ebpf_create_systemd_socket_charts(int update_every) { - int order = 20080; - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_CONNECTION_TCP_V4, - "Calls to tcp_v4_connection", EBPF_COMMON_DIMENSION_CONNECTIONS, - NETDATA_APPS_NET_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, - order++, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], - NETDATA_SERVICES_SOCKET_TCP_V4_CONN_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET, - update_every); + static ebpf_systemd_args_t data_tcp_v4 = { + .title = "Calls to tcp_v4_connection", + .units = EBPF_COMMON_DIMENSION_CONNECTIONS, + .family = NETDATA_APPS_NET_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20080, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SERVICES_SOCKET_TCP_V4_CONN_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_SOCKET, + .update_every = 0, + .suffix = NETDATA_NET_APPS_CONNECTION_TCP_V4, + .dimension = "connections" + }; - if (tcp_v6_connect_address.type == 'T') { - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_CONNECTION_TCP_V6, - "Calls to tcp_v6_connection", - EBPF_COMMON_DIMENSION_CONNECTIONS, - NETDATA_APPS_NET_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, - order++, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], - NETDATA_SERVICES_SOCKET_TCP_V6_CONN_CONTEXT, - NETDATA_EBPF_MODULE_NAME_SOCKET, - update_every); - } + static ebpf_systemd_args_t data_tcp_v6 = { + .title = "Calls to tcp_v6_connection", + .units = EBPF_COMMON_DIMENSION_CONNECTIONS, + .family = NETDATA_APPS_NET_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20081, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SERVICES_SOCKET_TCP_V6_CONN_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_SOCKET, + .update_every = 0, + .suffix = NETDATA_NET_APPS_CONNECTION_TCP_V6, + .dimension = "connections" + }; - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_RECV, - "Bytes received", EBPF_COMMON_DIMENSION_BITS, - NETDATA_APPS_NET_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, - order++, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], - NETDATA_SERVICES_SOCKET_BYTES_RECV_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET, - update_every); + static ebpf_systemd_args_t data_bandwith_recv = { + .title = "Bytes received", + .units = EBPF_COMMON_DIMENSION_BITS, + .family = NETDATA_APPS_NET_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20082, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SERVICES_SOCKET_BYTES_RECV_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_SOCKET, + .update_every = 0, + .suffix = NETDATA_NET_APPS_BANDWIDTH_RECV, + .dimension = "bits" + }; - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_SENT, - "Bytes sent", EBPF_COMMON_DIMENSION_BITS, - NETDATA_APPS_NET_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, - order++, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], - NETDATA_SERVICES_SOCKET_BYTES_SEND_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET, - update_every); + static ebpf_systemd_args_t data_bandwith_sent = { + .title = "Bytes sent", + .units = EBPF_COMMON_DIMENSION_BITS, + .family = NETDATA_APPS_NET_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20083, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SERVICES_SOCKET_BYTES_SEND_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_SOCKET, + .update_every = 0, + .suffix = NETDATA_NET_APPS_BANDWIDTH_SENT, + .dimension = "bits" + }; - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS, - "Calls to tcp_cleanup_rbuf.", - EBPF_COMMON_DIMENSION_CALL, - NETDATA_APPS_NET_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, - order++, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], - NETDATA_SERVICES_SOCKET_TCP_RECV_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET, - update_every); + static ebpf_systemd_args_t data_tcp_cleanup = { + .title = "Calls to tcp_cleanup_rbuf.", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_NET_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20084, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SERVICES_SOCKET_TCP_RECV_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_SOCKET, + .update_every = 0, + .suffix = NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS, + .dimension = "calls" + }; - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS, - "Calls to tcp_sendmsg.", - EBPF_COMMON_DIMENSION_CALL, - NETDATA_APPS_NET_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, - order++, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], - NETDATA_SERVICES_SOCKET_TCP_SEND_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET, - update_every); + static ebpf_systemd_args_t data_tcp_sendmsg = { + .title = "Calls to tcp_sendmsg.", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_NET_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20085, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SERVICES_SOCKET_TCP_SEND_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_SOCKET, + .update_every = 0, + .suffix = NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS, + .dimension = "calls" + }; - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT, - "Calls to tcp_retransmit", - EBPF_COMMON_DIMENSION_CALL, - NETDATA_APPS_NET_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, - order++, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], - NETDATA_SERVICES_SOCKET_TCP_RETRANSMIT_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET, - update_every); + static ebpf_systemd_args_t data_tcp_retransmit = { + .title = "Calls to tcp_retransmit", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_NET_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20086, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SERVICES_SOCKET_TCP_RETRANSMIT_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_SOCKET, + .update_every = 0, + .suffix = NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT, + .dimension = "calls" + }; - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS, - "Calls to udp_sendmsg", - EBPF_COMMON_DIMENSION_CALL, - NETDATA_APPS_NET_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, - order++, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], - NETDATA_SERVICES_SOCKET_UDP_SEND_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET, - update_every); + static ebpf_systemd_args_t data_udp_send = { + .title = "Calls to udp_sendmsg", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_NET_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20087, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SERVICES_SOCKET_UDP_SEND_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_SOCKET, + .update_every = 0, + .suffix = NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS, + .dimension = "calls" + }; - ebpf_create_charts_on_systemd(NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS, - "Calls to udp_recvmsg", - EBPF_COMMON_DIMENSION_CALL, - NETDATA_APPS_NET_GROUP, - NETDATA_EBPF_CHART_TYPE_STACKED, - order++, - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], - NETDATA_SERVICES_SOCKET_UDP_RECV_CONTEXT, NETDATA_EBPF_MODULE_NAME_SOCKET, - update_every); + static ebpf_systemd_args_t data_udp_recv = { + .title = "Calls to udp_recvmsg", + .units = EBPF_COMMON_DIMENSION_CALL, + .family = NETDATA_APPS_NET_GROUP, + .charttype = NETDATA_EBPF_CHART_TYPE_STACKED, + .order = 20088, + .algorithm = EBPF_CHART_ALGORITHM_INCREMENTAL, + .context = NETDATA_SERVICES_SOCKET_UDP_RECV_CONTEXT, + .module = NETDATA_EBPF_MODULE_NAME_SOCKET, + .update_every = 0, + .suffix = NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS, + .dimension = "calls" + }; + + if (!data_tcp_v4.update_every) + data_tcp_v4.update_every = data_tcp_v6.update_every = data_bandwith_recv.update_every = + data_bandwith_sent.update_every = data_tcp_cleanup.update_every = data_tcp_sendmsg.update_every = + data_tcp_retransmit.update_every = data_udp_send.update_every = data_udp_recv.update_every = update_every; + + ebpf_cgroup_target_t *w; + for (w = ebpf_cgroup_pids; w ; w = w->next) { + if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_SOCKET_CHART)) + continue; + + data_tcp_v4.id = data_tcp_v6.id = data_bandwith_recv.id = + data_bandwith_sent.id = data_tcp_cleanup.id = data_tcp_sendmsg.id = + data_tcp_retransmit.id = data_udp_send.id = data_udp_recv.id = w->name; + + ebpf_create_charts_on_systemd(&data_tcp_v4); + if (tcp_v6_connect_address.type == 'T') { + ebpf_create_charts_on_systemd(&data_tcp_v6); + } + + ebpf_create_charts_on_systemd(&data_bandwith_recv); + ebpf_create_charts_on_systemd(&data_bandwith_sent); + + ebpf_create_charts_on_systemd(&data_tcp_cleanup); + + ebpf_create_charts_on_systemd(&data_tcp_sendmsg); + + ebpf_create_charts_on_systemd(&data_tcp_retransmit); + + ebpf_create_charts_on_systemd(&data_udp_recv); + + ebpf_create_charts_on_systemd(&data_udp_send); + + w->flags |= NETDATA_EBPF_SERVICES_HAS_SOCKET_CHART; + } } /** @@ -2429,79 +2507,49 @@ static void ebpf_create_systemd_socket_charts(int update_every) static void ebpf_send_systemd_socket_charts() { ebpf_cgroup_target_t *ect; - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_CONNECTION_TCP_V4, ""); for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, (long long)ect->publish_socket.call_tcp_v4_connection); + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_SOCKET_CHART)) ) { + continue; } - } - ebpf_write_end_chart(); - if (tcp_v6_connect_address.type == 'T') { - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_CONNECTION_TCP_V6, ""); - for (ect = ebpf_cgroup_pids; ect; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, (long long)ect->publish_socket.call_tcp_v6_connection); - } - } + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_CONNECTION_TCP_V4); + write_chart_dimension("connections", (long long)ect->publish_socket.call_tcp_v4_connection); ebpf_write_end_chart(); - } - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_SENT, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, (long long)ect->publish_socket.bytes_sent); + if (tcp_v6_connect_address.type == 'T') { + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_CONNECTION_TCP_V6); + write_chart_dimension("connections", (long long)ect->publish_socket.call_tcp_v6_connection); + ebpf_write_end_chart(); } - } - ebpf_write_end_chart(); - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_RECV, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, (long long)ect->publish_socket.bytes_received); - } - } - ebpf_write_end_chart(); + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_SENT); + write_chart_dimension("bits", (long long)ect->publish_socket.bytes_sent); + ebpf_write_end_chart(); - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, (long long)ect->publish_socket.call_tcp_sent); - } - } - ebpf_write_end_chart(); + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_RECV); + write_chart_dimension("bits", (long long)ect->publish_socket.bytes_received); + ebpf_write_end_chart(); - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, (long long)ect->publish_socket.call_tcp_received); - } - } - ebpf_write_end_chart(); + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS); + write_chart_dimension("calls", (long long)ect->publish_socket.call_tcp_sent); + ebpf_write_end_chart(); - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, (long long)ect->publish_socket.retransmit); - } - } - ebpf_write_end_chart(); + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS); + write_chart_dimension("calls", (long long)ect->publish_socket.call_tcp_received); + ebpf_write_end_chart(); - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, (long long)ect->publish_socket.call_udp_sent); - } - } - ebpf_write_end_chart(); + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT); + write_chart_dimension("calls", (long long)ect->publish_socket.retransmit); + ebpf_write_end_chart(); - ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS, ""); - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { - if (unlikely(ect->systemd) && unlikely(ect->updated)) { - write_chart_dimension(ect->name, (long long)ect->publish_socket.call_udp_received); - } + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS); + write_chart_dimension("calls", (long long)ect->publish_socket.call_udp_sent); + ebpf_write_end_chart(); + + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, ect->name, NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS); + write_chart_dimension("calls", (long long)ect->publish_socket.call_udp_received); + ebpf_write_end_chart(); } - ebpf_write_end_chart(); } /** @@ -2525,17 +2573,13 @@ void ebpf_socket_update_cgroup_algorithm() */ static void ebpf_socket_send_cgroup_data(int update_every) { - if (!ebpf_cgroup_pids) - return; - pthread_mutex_lock(&mutex_cgroup_shm); ebpf_cgroup_target_t *ect; for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) { ebpf_socket_sum_cgroup_pids(&ect->publish_socket, ect->pids); } - int has_systemd = shm_ebpf_cgroup.header->systemd_enabled; - if (has_systemd) { + if (shm_ebpf_cgroup.header->systemd_enabled) { if (send_cgroup_chart) { ebpf_create_systemd_socket_charts(update_every); } @@ -2602,7 +2646,6 @@ static void socket_collector(ebpf_module_t *em) ebpf_socket_read_hash_global_tables(stats, maps_per_core); } - pthread_mutex_lock(&collect_data_mutex); if (cgroups) ebpf_update_socket_cgroup(); @@ -2611,20 +2654,14 @@ static void socket_collector(ebpf_module_t *em) ebpf_socket_send_data(em); if (socket_apps_enabled & NETDATA_EBPF_APPS_FLAG_CHART_CREATED) - ebpf_socket_send_apps_data(em, apps_groups_root_target); - -#ifdef NETDATA_DEV_MODE - if (ebpf_aral_socket_pid) - ebpf_send_data_aral_chart(ebpf_aral_socket_pid, em); -#endif + ebpf_socket_send_apps_data(); - if (cgroups) + if (cgroups && shm_ebpf_cgroup.header && ebpf_cgroup_pids) ebpf_socket_send_cgroup_data(update_every); fflush(stdout); pthread_mutex_unlock(&lock); - pthread_mutex_unlock(&collect_data_mutex); pthread_mutex_lock(&ebpf_exit_cleanup); if (running_time && !em->running_time) @@ -2655,9 +2692,6 @@ static void ebpf_socket_initialize_global_vectors() memset(socket_publish_aggregated, 0 ,NETDATA_MAX_SOCKET_VECTOR * sizeof(netdata_publish_syscall_t)); socket_hash_values = callocz(ebpf_nprocs, sizeof(netdata_idx_t)); - ebpf_socket_aral_init(); - socket_bandwidth_curr = callocz((size_t)pid_max, sizeof(ebpf_socket_publish_apps_t *)); - aral_socket_table = ebpf_allocate_pid_aral(NETDATA_EBPF_SOCKET_ARAL_TABLE_NAME, sizeof(netdata_socket_plus_t)); @@ -2878,11 +2912,6 @@ void *ebpf_socket_thread(void *ptr) ebpf_update_stats(&plugin_statistics, em); ebpf_update_kernel_memory_with_vector(&plugin_statistics, em->maps, EBPF_ACTION_STAT_ADD); -#ifdef NETDATA_DEV_MODE - if (ebpf_aral_socket_pid) - socket_disable_priority = ebpf_statistic_create_aral_chart(NETDATA_EBPF_SOCKET_ARAL_NAME, em); -#endif - pthread_mutex_unlock(&lock); socket_collector(em); |