forked from netdata/netdata
-
Notifications
You must be signed in to change notification settings - Fork 0
/
ebpf.c
1953 lines (1698 loc) · 57.4 KB
/
ebpf.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// SPDX-License-Identifier: GPL-3.0-or-later
#include <sys/time.h>
#include <sys/resource.h>
#include <ifaddrs.h>
#include "ebpf.h"
#include "ebpf_socket.h"
/*****************************************************************
*
* FUNCTIONS USED BY NETDATA
*
*****************************************************************/
// callback required by eval()
int health_variable_lookup(const char *variable, uint32_t hash, struct rrdcalc *rc, calculated_number *result)
{
UNUSED(variable);
UNUSED(hash);
UNUSED(rc);
UNUSED(result);
return 0;
};
void send_statistics(const char *action, const char *action_result, const char *action_data)
{
UNUSED(action);
UNUSED(action_result);
UNUSED(action_data);
}
// callbacks required by popen()
void signals_block(void){};
void signals_unblock(void){};
void signals_reset(void){};
// required by get_system_cpus()
char *netdata_configured_host_prefix = "";
// callback required by fatal()
void netdata_cleanup_and_exit(int ret)
{
exit(ret);
}
// ----------------------------------------------------------------------
/*****************************************************************
*
* GLOBAL VARIABLES
*
*****************************************************************/
char *ebpf_plugin_dir = PLUGINS_DIR;
char *ebpf_user_config_dir = CONFIG_DIR;
char *ebpf_stock_config_dir = LIBCONFIG_DIR;
static char *ebpf_configured_log_dir = LOG_DIR;
int update_every = 1;
static int thread_finished = 0;
int close_ebpf_plugin = 0;
struct config collector_config = { .first_section = NULL,
.last_section = NULL,
.mutex = NETDATA_MUTEX_INITIALIZER,
.index = { .avl_tree = { .root = NULL, .compar = appconfig_section_compare },
.rwlock = AVL_LOCK_INITIALIZER } };
int running_on_kernel = 0;
char kernel_string[64];
int ebpf_nprocs;
static int isrh;
uint32_t finalized_threads = 1;
pthread_mutex_t lock;
pthread_mutex_t collect_data_mutex;
pthread_cond_t collect_data_cond_var;
ebpf_module_t ebpf_modules[] = {
{ .thread_name = "process", .config_name = "process", .enabled = 0, .start_routine = ebpf_process_thread,
.update_time = 1, .global_charts = 1, .apps_charts = 1, .mode = MODE_ENTRY,
.optional = 0 },
{ .thread_name = "socket", .config_name = "socket", .enabled = 0, .start_routine = ebpf_socket_thread,
.update_time = 1, .global_charts = 1, .apps_charts = 1, .mode = MODE_ENTRY,
.optional = 0 },
{ .thread_name = NULL, .enabled = 0, .start_routine = NULL, .update_time = 1,
.global_charts = 0, .apps_charts = 1, .mode = MODE_ENTRY,
.optional = 0 },
};
// Link with apps.plugin
ebpf_process_stat_t *global_process_stat = NULL;
//Network viewer
ebpf_network_viewer_options_t network_viewer_opt;
/*****************************************************************
*
* FUNCTIONS USED TO CLEAN MEMORY AND OPERATE SYSTEM FILES
*
*****************************************************************/
/**
* Clean port Structure
*
* Clean the allocated list.
*
* @param clean the list that will be cleaned
*/
void clean_port_structure(ebpf_network_viewer_port_list_t **clean)
{
ebpf_network_viewer_port_list_t *move = *clean;
while (move) {
ebpf_network_viewer_port_list_t *next = move->next;
freez(move->value);
freez(move);
move = next;
}
*clean = NULL;
}
/**
* Clean IP structure
*
* Clean the allocated list.
*
* @param clean the list that will be cleaned
*/
static void clean_ip_structure(ebpf_network_viewer_ip_list_t **clean)
{
ebpf_network_viewer_ip_list_t *move = *clean;
while (move) {
ebpf_network_viewer_ip_list_t *next = move->next;
freez(move);
move = next;
}
*clean = NULL;
}
/**
* Clean Loaded Events
*
* This function cleans the events previous loaded on Linux.
void clean_loaded_events()
{
int event_pid;
for (event_pid = 0; ebpf_modules[event_pid].probes; event_pid++)
clean_kprobe_events(NULL, (int)ebpf_modules[event_pid].thread_id, ebpf_modules[event_pid].probes);
}
*/
/**
* Close the collector gracefully
*
* @param sig is the signal number used to close the collector
*/
static void ebpf_exit(int sig)
{
close_ebpf_plugin = 1;
// When both threads were not finished case I try to go in front this address, the collector will crash
if (!thread_finished) {
return;
}
freez(global_process_stat);
/*
int ret = fork();
if (ret < 0) // error
error("Cannot fork(), so I won't be able to clean %skprobe_events", NETDATA_DEBUGFS);
else if (!ret) { // child
int i;
for (i = getdtablesize(); i >= 0; --i)
close(i);
int fd = open("/dev/null", O_RDWR, 0);
if (fd != -1) {
dup2(fd, STDIN_FILENO);
dup2(fd, STDOUT_FILENO);
dup2(fd, STDERR_FILENO);
}
if (fd > 2)
close(fd);
int sid = setsid();
if (sid >= 0) {
debug(D_EXIT, "Wait for father %d die", getpid());
sleep_usec(200000); // Sleep 200 miliseconds to father dies.
clean_loaded_events();
} else {
error("Cannot become session id leader, so I won't try to clean kprobe_events.\n");
}
} else { // parent
exit(0);
}
*/
exit(sig);
}
/*****************************************************************
*
* FUNCTIONS TO CREATE CHARTS
*
*****************************************************************/
/**
* Get a value from a structure.
*
* @param basis it is the first address of the structure
* @param offset it is the offset of the data you want to access.
* @return
*/
collected_number get_value_from_structure(char *basis, size_t offset)
{
collected_number *value = (collected_number *)(basis + offset);
collected_number ret = (collected_number)llabs(*value);
// this reset is necessary to avoid keep a constant value while processing is not executing a task
*value = 0;
return ret;
}
/**
* Write begin command on standard output
*
* @param family the chart family name
* @param name the chart name
*/
void write_begin_chart(char *family, char *name)
{
printf("BEGIN %s.%s\n", family, name);
}
/**
* Write END command on stdout.
*/
inline void write_end_chart()
{
printf("END\n");
}
/**
* Write set command on standard output
*
* @param dim the dimension name
* @param value the value for the dimension
*/
void write_chart_dimension(char *dim, long long value)
{
int ret = printf("SET %s = %lld\n", dim, value);
UNUSED(ret);
}
/**
* Call the necessary functions to create a chart.
*
* @param name the chart name
* @param family the chart family
* @param move the pointer with the values that will be published
* @param end the number of values that will be written on standard output
*
* @return It returns a variable tha maps the charts that did not have zero values.
*/
void write_count_chart(char *name, char *family, netdata_publish_syscall_t *move, uint32_t end)
{
write_begin_chart(family, name);
uint32_t i = 0;
while (move && i < end) {
write_chart_dimension(move->name, move->ncall);
move = move->next;
i++;
}
write_end_chart();
}
/**
* Call the necessary functions to create a chart.
*
* @param name the chart name
* @param family the chart family
* @param move the pointer with the values that will be published
* @param end the number of values that will be written on standard output
*/
void write_err_chart(char *name, char *family, netdata_publish_syscall_t *move, int end)
{
write_begin_chart(family, name);
int i = 0;
while (move && i < end) {
write_chart_dimension(move->name, move->nerr);
move = move->next;
i++;
}
write_end_chart();
}
/**
* Call the necessary functions to create a chart.
*
* @param family the chart family
* @param move the pointer with the values that will be published
*
* @return It returns a variable tha maps the charts that did not have zero values.
*/
void write_io_chart(char *chart, char *family, char *dwrite, char *dread, netdata_publish_vfs_common_t *pvc)
{
write_begin_chart(family, chart);
write_chart_dimension(dwrite, (long long)pvc->write);
write_chart_dimension(dread, (long long)pvc->read);
write_end_chart();
}
/**
* Write chart cmd on standard output
*
* @param type the chart type
* @param id the chart id
* @param title the chart title
* @param units the units label
* @param family the group name used to attach the chart on dashaboard
* @param charttype the chart type
* @param order the chart order
*/
void ebpf_write_chart_cmd(char *type, char *id, char *title, char *units, char *family, char *charttype, int order)
{
printf("CHART %s.%s '' '%s' '%s' '%s' '' %s %d %d\n",
type,
id,
title,
units,
family,
charttype,
order,
update_every);
}
/**
* Write the dimension command on standard output
*
* @param n the dimension name
* @param d the dimension information
*/
void ebpf_write_global_dimension(char *n, char *d)
{
printf("DIMENSION %s %s absolute 1 1\n", n, d);
}
/**
* Call ebpf_write_global_dimension to create the dimensions for a specific chart
*
* @param ptr a pointer to a structure of the type netdata_publish_syscall_t
* @param end the number of dimensions for the structure ptr
*/
void ebpf_create_global_dimension(void *ptr, int end)
{
netdata_publish_syscall_t *move = ptr;
int i = 0;
while (move && i < end) {
ebpf_write_global_dimension(move->name, move->dimension);
move = move->next;
i++;
}
}
/**
* Call write_chart_cmd to create the charts
*
* @param type the chart type
* @param id the chart id
* @param units the axis label
* @param family the group name used to attach the chart on dashaboard
* @param order the order number of the specified chart
* @param ncd a pointer to a function called to create dimensions
* @param move a pointer for a structure that has the dimensions
* @param end number of dimensions for the chart created
*/
void ebpf_create_chart(char *type,
char *id,
char *title,
char *units,
char *family,
int order,
void (*ncd)(void *, int),
void *move,
int end)
{
ebpf_write_chart_cmd(type, id, title, units, family, "line", order);
ncd(move, end);
}
/**
* Create charts on apps submenu
*
* @param id the chart id
* @param title the value displayed on vertical axis.
* @param units the value displayed on vertical axis.
* @param family Submenu that the chart will be attached on dashboard.
* @param order the chart order
* @param root structure used to create the dimensions.
*/
void ebpf_create_charts_on_apps(char *id, char *title, char *units, char *family, int order, struct target *root)
{
struct target *w;
ebpf_write_chart_cmd(NETDATA_APPS_FAMILY, id, title, units, family, "stacked", order);
for (w = root; w; w = w->next) {
if (unlikely(w->exposed))
fprintf(stdout, "DIMENSION %s '' absolute 1 1\n", w->name);
}
}
/*****************************************************************
*
* FUNCTIONS TO DEFINE OPTIONS
*
*****************************************************************/
/**
* Define labels used to generate charts
*
* @param is structure with information about number of calls made for a function.
* @param pio structure used to generate charts.
* @param dim a pointer for the dimensions name
* @param name a pointer for the tensor with the name of the functions.
* @param end the number of elements in the previous 4 arguments.
*/
void ebpf_global_labels(netdata_syscall_stat_t *is, netdata_publish_syscall_t *pio, char **dim, char **name, int end)
{
int i;
netdata_syscall_stat_t *prev = NULL;
netdata_publish_syscall_t *publish_prev = NULL;
for (i = 0; i < end; i++) {
if (prev) {
prev->next = &is[i];
}
prev = &is[i];
pio[i].dimension = dim[i];
pio[i].name = name[i];
if (publish_prev) {
publish_prev->next = &pio[i];
}
publish_prev = &pio[i];
}
}
/**
* Define thread mode for all ebpf program.
*
* @param lmode the mode that will be used for them.
*/
static inline void ebpf_set_thread_mode(netdata_run_mode_t lmode)
{
int i;
for (i = 0; ebpf_modules[i].thread_name; i++) {
ebpf_modules[i].mode = lmode;
}
}
/**
* Enable specific charts selected by user.
*
* @param em the structure that will be changed
* @param enable the status about the apps charts.
*/
static inline void ebpf_enable_specific_chart(struct ebpf_module *em, int enable)
{
em->enabled = 1;
if (!enable) {
em->apps_charts = 1;
}
em->global_charts = 1;
}
/**
* Enable all charts
*
* @param apps what is the current status of apps
*/
static inline void ebpf_enable_all_charts(int apps)
{
int i;
for (i = 0; ebpf_modules[i].thread_name; i++) {
ebpf_enable_specific_chart(&ebpf_modules[i], apps);
}
}
/**
* Enable the specified chart group
*
* @param idx the index of ebpf_modules that I am enabling
* @param disable_apps should I keep apps charts?
*/
static inline void ebpf_enable_chart(int idx, int disable_apps)
{
int i;
for (i = 0; ebpf_modules[i].thread_name; i++) {
if (i == idx) {
ebpf_enable_specific_chart(&ebpf_modules[i], disable_apps);
break;
}
}
}
/**
* Disable APPs
*
* Disable charts for apps loading only global charts.
*/
static inline void ebpf_disable_apps()
{
int i;
for (i = 0; ebpf_modules[i].thread_name; i++) {
ebpf_modules[i].apps_charts = 0;
}
}
/**
* Print help on standard error for user knows how to use the collector.
*/
void ebpf_print_help()
{
const time_t t = time(NULL);
struct tm ct;
struct tm *test = localtime_r(&t, &ct);
int year;
if (test)
year = ct.tm_year;
else
year = 0;
fprintf(stderr,
"\n"
" Netdata ebpf.plugin %s\n"
" Copyright (C) 2016-%d Costa Tsaousis <[email protected]>\n"
" Released under GNU General Public License v3 or later.\n"
" All rights reserved.\n"
"\n"
" This program is a data collector plugin for netdata.\n"
"\n"
" Available command line options:\n"
"\n"
" SECONDS set the data collection frequency.\n"
"\n"
" --help or -h show this help.\n"
"\n"
" --version or -v show software version.\n"
"\n"
" --global or -g disable charts per application.\n"
"\n"
" --all or -a Enable all chart groups (global and apps), unless -g is also given.\n"
"\n"
" --net or -n Enable network viewer charts.\n"
"\n"
" --process or -p Enable charts related to process run time.\n"
"\n"
" --return or -r Run the collector in return mode.\n"
"\n",
VERSION,
(year >= 116) ? year + 1900 : 2020);
}
/*****************************************************************
*
* AUXILIAR FUNCTIONS USED DURING INITIALIZATION
*
*****************************************************************/
/**
* Is ip inside the range
*
* Check if the ip is inside a IP range
*
* @param rfirst the first ip address of the range
* @param rlast the last ip address of the range
* @param cmpfirst the first ip to compare
* @param cmplast the last ip to compare
* @param family the IP family
*
* @return It returns 1 if the IP is inside the range and 0 otherwise
*/
static int is_ip_inside_range(union netdata_ip_t *rfirst, union netdata_ip_t *rlast,
union netdata_ip_t *cmpfirst, union netdata_ip_t *cmplast, int family)
{
if (family == AF_INET) {
if (ntohl(rfirst->addr32[0]) <= ntohl(cmpfirst->addr32[0]) &&
ntohl(rlast->addr32[0]) >= ntohl(cmplast->addr32[0]))
return 1;
} else {
if (memcmp(rfirst->addr8, cmpfirst->addr8, sizeof(union netdata_ip_t)) <= 0 &&
memcmp(rlast->addr8, cmplast->addr8, sizeof(union netdata_ip_t)) >= 0) {
return 1;
}
}
return 0;
}
/**
* Fill IP list
*
* @param out a pointer to the link list.
* @param in the structure that will be linked.
*/
static inline void fill_ip_list(ebpf_network_viewer_ip_list_t **out, ebpf_network_viewer_ip_list_t *in, char *table)
{
#ifndef NETDATA_INTERNAL_CHECKS
UNUSED(table);
#endif
if (likely(*out)) {
ebpf_network_viewer_ip_list_t *move = *out, *store = *out;
while (move) {
if (in->ver == move->ver && is_ip_inside_range(&move->first, &move->last, &in->first, &in->last, in->ver)) {
info("The range/value (%s) is inside the range/value (%s) already inserted, it will be ignored.",
in->value, move->value);
freez(in->value);
freez(in);
return;
}
store = move;
move = move->next;
}
store->next = in;
} else {
*out = in;
}
#ifdef NETDATA_INTERNAL_CHECKS
char first[512], last[512];
if (in->ver == AF_INET) {
if (inet_ntop(AF_INET, in->first.addr8, first, INET_ADDRSTRLEN) &&
inet_ntop(AF_INET, in->last.addr8, last, INET_ADDRSTRLEN))
info("Adding values %s - %s to %s IP list \"%s\" used on network viewer",
first, last,
(*out == network_viewer_opt.included_ips)?"included":"excluded",
table);
} else {
if (inet_ntop(AF_INET6, in->first.addr8, first, INET6_ADDRSTRLEN) &&
inet_ntop(AF_INET6, in->last.addr8, last, INET6_ADDRSTRLEN))
info("Adding values %s - %s to %s IP list \"%s\" used on network viewer",
first, last,
(*out == network_viewer_opt.included_ips)?"included":"excluded",
table);
}
#endif
}
/**
* Read Local Ports
*
* Parse /proc/net/{tcp,udp} and get the ports Linux is listening.
*
* @param filename the proc file to parse.
* @param proto is the magic number associated to the protocol file we are reading.
*/
static void read_local_ports(char *filename, uint8_t proto)
{
procfile *ff = procfile_open(filename, " \t:", PROCFILE_FLAG_DEFAULT);
if (!ff)
return;
ff = procfile_readall(ff);
if (!ff)
return;
size_t lines = procfile_lines(ff), l;
for(l = 0; l < lines ;l++) {
size_t words = procfile_linewords(ff, l);
// This is header or end of file
if (unlikely(words < 14))
continue;
// https://elixir.bootlin.com/linux/v5.7.8/source/include/net/tcp_states.h
// 0A = TCP_LISTEN
if (strcmp("0A", procfile_lineword(ff, l, 5)))
continue;
// Read local port
uint16_t port = (uint16_t)strtol(procfile_lineword(ff, l, 2), NULL, 16);
update_listen_table(htons(port), proto);
}
procfile_close(ff);
}
/**
* Read Local addresseses
*
* Read the local address from the interfaces.
*/
static void read_local_addresses()
{
struct ifaddrs *ifaddr, *ifa;
if (getifaddrs(&ifaddr) == -1) {
error("Cannot get the local IP addresses, it is no possible to do separation between inbound and outbound connections");
return;
}
char *notext = { "No text representation" };
for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
if (ifa->ifa_addr == NULL)
continue;
if ((ifa->ifa_addr->sa_family != AF_INET) && (ifa->ifa_addr->sa_family != AF_INET6))
continue;
ebpf_network_viewer_ip_list_t *w = callocz(1, sizeof(ebpf_network_viewer_ip_list_t));
int family = ifa->ifa_addr->sa_family;
w->ver = (uint8_t) family;
char text[INET6_ADDRSTRLEN];
if (family == AF_INET) {
struct sockaddr_in *in = (struct sockaddr_in*) ifa->ifa_addr;
w->first.addr32[0] = in->sin_addr.s_addr;
w->last.addr32[0] = in->sin_addr.s_addr;
if (inet_ntop(AF_INET, w->first.addr8, text, INET_ADDRSTRLEN)) {
w->value = strdupz(text);
w->hash = simple_hash(text);
} else {
w->value = strdupz(notext);
w->hash = simple_hash(notext);
}
} else {
struct sockaddr_in6 *in6 = (struct sockaddr_in6*) ifa->ifa_addr;
memcpy(w->first.addr8, (void *)&in6->sin6_addr, sizeof(struct in6_addr));
memcpy(w->last.addr8, (void *)&in6->sin6_addr, sizeof(struct in6_addr));
if (inet_ntop(AF_INET6, w->first.addr8, text, INET_ADDRSTRLEN)) {
w->value = strdupz(text);
w->hash = simple_hash(text);
} else {
w->value = strdupz(notext);
w->hash = simple_hash(notext);
}
}
fill_ip_list((family == AF_INET)?&network_viewer_opt.ipv4_local_ip:&network_viewer_opt.ipv6_local_ip,
w,
"selector");
}
freeifaddrs(ifaddr);
}
/**
* Start Ptherad Variable
*
* This function starts all pthread variables.
*
* @return It returns 0 on success and -1.
*/
int ebpf_start_pthread_variables()
{
pthread_mutex_init(&lock, NULL);
pthread_mutex_init(&collect_data_mutex, NULL);
if (pthread_cond_init(&collect_data_cond_var, NULL)) {
thread_finished++;
error("Cannot start conditional variable to control Apps charts.");
return -1;
}
return 0;
}
/**
* Allocate the vectors used for all threads.
*/
static void ebpf_allocate_common_vectors()
{
all_pids = callocz((size_t)pid_max, sizeof(struct pid_stat *));
global_process_stat = callocz((size_t)ebpf_nprocs, sizeof(ebpf_process_stat_t));
}
/**
* Fill the ebpf_data structure with default values
*
* @param ef the pointer to set default values
*/
void fill_ebpf_data(ebpf_data_t *ef)
{
memset(ef, 0, sizeof(ebpf_data_t));
ef->kernel_string = kernel_string;
ef->running_on_kernel = running_on_kernel;
ef->map_fd = callocz(EBPF_MAX_MAPS, sizeof(int));
ef->isrh = isrh;
}
/**
* Define how to load the ebpf programs
*
* @param ptr the option given by users
*/
static inline void how_to_load(char *ptr)
{
if (!strcasecmp(ptr, "return"))
ebpf_set_thread_mode(MODE_RETURN);
else if (!strcasecmp(ptr, "entry"))
ebpf_set_thread_mode(MODE_ENTRY);
else
error("the option %s for \"ebpf load mode\" is not a valid option.", ptr);
}
/**
* Fill Port list
*
* @param out a pointer to the link list.
* @param in the structure that will be linked.
*/
static inline void fill_port_list(ebpf_network_viewer_port_list_t **out, ebpf_network_viewer_port_list_t *in)
{
if (likely(*out)) {
ebpf_network_viewer_port_list_t *move = *out, *store = *out;
uint16_t first = ntohs(in->first);
uint16_t last = ntohs(in->last);
while (move) {
uint16_t cmp_first = ntohs(move->first);
uint16_t cmp_last = ntohs(move->last);
if (cmp_first <= first && first <= cmp_last &&
cmp_first <= last && last <= cmp_last ) {
info("The range/value (%u, %u) is inside the range/value (%u, %u) already inserted, it will be ignored.",
first, last, cmp_first, cmp_last);
freez(in->value);
freez(in);
return;
} else if (first <= cmp_first && cmp_first <= last &&
first <= cmp_last && cmp_last <= last) {
info("The range (%u, %u) is bigger than previous range (%u, %u) already inserted, the previous will be ignored.",
first, last, cmp_first, cmp_last);
freez(move->value);
move->value = in->value;
move->first = in->first;
move->last = in->last;
freez(in);
return;
}
store = move;
move = move->next;
}
store->next = in;
} else {
*out = in;
}
#ifdef NETDATA_INTERNAL_CHECKS
info("Adding values %s( %u, %u) to %s port list used on network viewer",
in->value, ntohs(in->first), ntohs(in->last),
(*out == network_viewer_opt.included_port)?"included":"excluded");
#endif
}
/**
* Fill port list
*
* Fill an allocated port list with the range given
*
* @param out a pointer to store the link list
* @param range the informed range for the user.
*/
static void parse_port_list(void **out, char *range)
{
int first, last;
ebpf_network_viewer_port_list_t **list = (ebpf_network_viewer_port_list_t **)out;
char *copied = strdupz(range);
if (*range == '*' && *(range+1) == '\0') {
first = 1;
last = 65535;
clean_port_structure(list);
goto fillenvpl;
}
char *end = range;
//Move while I cannot find a separator
while (*end && *end != ':' && *end != '-') end++;
//It has a range
if (likely(*end)) {
*end++ = '\0';
if (*end == '!') {
info("The exclusion cannot be in the second part of the range, the range %s will be ignored.", copied);
freez(copied);
return;
}
last = str2i((const char *)end);
} else {
last = 0;
}
first = str2i((const char *)range);
if (first < NETDATA_MINIMUM_PORT_VALUE || first > NETDATA_MAXIMUM_PORT_VALUE) {
info("The first port %d of the range \"%s\" is invalid and it will be ignored!", first, copied);
freez(copied);
return;
}
if (!last)
last = first;
if (last < NETDATA_MINIMUM_PORT_VALUE || last > NETDATA_MAXIMUM_PORT_VALUE) {
info("The second port %d of the range \"%s\" is invalid and the whole range will be ignored!", last, copied);
freez(copied);
return;
}
if (first > last) {
info("The specified order %s is wrong, the smallest value is always the first, it will be ignored!", copied);
freez(copied);
return;
}
ebpf_network_viewer_port_list_t *w;
fillenvpl:
w = callocz(1, sizeof(ebpf_network_viewer_port_list_t));
w->value = copied;
w->hash = simple_hash(copied);
w->first = (uint16_t)htons((uint16_t)first);
w->last = (uint16_t)htons((uint16_t)last);
w->cmp_first = (uint16_t)first;
w->cmp_last = (uint16_t)last;
fill_port_list(list, w);
}
/**
* Parse Service List
*
* @param out a pointer to store the link list
* @param service the service used to create the structure that will be linked.
*/
static void parse_service_list(void **out, char *service)
{
ebpf_network_viewer_port_list_t **list = (ebpf_network_viewer_port_list_t **)out;
struct servent *serv = getservbyname((const char *)service, "tcp");
if (!serv)
serv = getservbyname((const char *)service, "udp");
if (!serv) {
info("Cannot resolv the service '%s' with protocols TCP and UDP, it will be ignored", service);
return;
}
ebpf_network_viewer_port_list_t *w = callocz(1, sizeof(ebpf_network_viewer_port_list_t));
w->value = strdupz(service);
w->hash = simple_hash(service);
w->first = w->last = (uint16_t)serv->s_port;
fill_port_list(list, w);
}
/**
* Netmask
*
* Copied from iprange (https://github.com/firehol/iprange/blob/master/iprange.h)
*
* @param prefix create the netmask based in the CIDR value.
*
* @return
*/
static inline in_addr_t netmask(int prefix) {
if (prefix == 0)
return (~((in_addr_t) - 1));
else
return (in_addr_t)(~((1 << (32 - prefix)) - 1));
}
/**
* Broadcast
*
* Copied from iprange (https://github.com/firehol/iprange/blob/master/iprange.h)
*
* @param addr is the ip address
* @param prefix is the CIDR value.