@cryptotaxi247 / netdata-1
Code Commits Issues Pulls Sessions CI/CD
master
master
c 1,750 lines 71.7 KB
Raw
1 // SPDX-License-Identifier: GPL-3.0-or-later
2
3 #include "plugin_proc.h"
4 #include "proc_net_dev_renames.h"
5
6 #define PLUGIN_PROC_MODULE_NETDEV_NAME "/proc/net/dev"
7 #define CONFIG_SECTION_PLUGIN_PROC_NETDEV "plugin:" PLUGIN_PROC_CONFIG_NAME ":" PLUGIN_PROC_MODULE_NETDEV_NAME
8
9 #define RRDFUNCTIONS_NETDEV_HELP "Shows real-time network interface performance including traffic rates, packet counts, drops, and link status."
10
11 #define STATE_LENGTH_MAX 32
12
13 #define READ_RETRY_PERIOD 60 // seconds
14
15 time_t virtual_device_collect_delay_secs = 40;
16
17 enum {
18 NETDEV_DUPLEX_UNKNOWN,
19 NETDEV_DUPLEX_HALF,
20 NETDEV_DUPLEX_FULL
21 };
22
23 static const char *get_duplex_string(int duplex) {
24 switch (duplex) {
25 case NETDEV_DUPLEX_FULL:
26 return "full";
27 case NETDEV_DUPLEX_HALF:
28 return "half";
29 default:
30 return "unknown";
31 }
32 }
33
34 enum {
35 NETDEV_OPERSTATE_UNKNOWN,
36 NETDEV_OPERSTATE_NOTPRESENT,
37 NETDEV_OPERSTATE_DOWN,
38 NETDEV_OPERSTATE_LOWERLAYERDOWN,
39 NETDEV_OPERSTATE_TESTING,
40 NETDEV_OPERSTATE_DORMANT,
41 NETDEV_OPERSTATE_UP
42 };
43
44 static inline int get_operstate(char *operstate) {
45 // As defined in https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-class-net
46 if (!strcmp(operstate, "up"))
47 return NETDEV_OPERSTATE_UP;
48 if (!strcmp(operstate, "down"))
49 return NETDEV_OPERSTATE_DOWN;
50 if (!strcmp(operstate, "notpresent"))
51 return NETDEV_OPERSTATE_NOTPRESENT;
52 if (!strcmp(operstate, "lowerlayerdown"))
53 return NETDEV_OPERSTATE_LOWERLAYERDOWN;
54 if (!strcmp(operstate, "testing"))
55 return NETDEV_OPERSTATE_TESTING;
56 if (!strcmp(operstate, "dormant"))
57 return NETDEV_OPERSTATE_DORMANT;
58
59 return NETDEV_OPERSTATE_UNKNOWN;
60 }
61
62 static const char *get_operstate_string(int operstate) {
63 switch (operstate) {
64 case NETDEV_OPERSTATE_UP:
65 return "up";
66 case NETDEV_OPERSTATE_DOWN:
67 return "down";
68 case NETDEV_OPERSTATE_NOTPRESENT:
69 return "notpresent";
70 case NETDEV_OPERSTATE_LOWERLAYERDOWN:
71 return "lowerlayerdown";
72 case NETDEV_OPERSTATE_TESTING:
73 return "testing";
74 case NETDEV_OPERSTATE_DORMANT:
75 return "dormant";
76 default:
77 return "unknown";
78 }
79 }
80
81 // ----------------------------------------------------------------------------
82 // netdev list
83
84 static struct netdev {
85 char *name;
86 uint32_t hash;
87 size_t len;
88
89 // flags
90 bool virtual;
91 bool configured;
92 int enabled;
93 bool updated;
94 bool function_ready;
95
96 time_t discover_time;
97
98 int carrier_file_exists;
99 time_t carrier_file_lost_time;
100
101 int duplex_file_exists;
102 time_t duplex_file_lost_time;
103
104 int speed_file_exists;
105 time_t speed_file_lost_time;
106
107 int do_bandwidth;
108 int do_packets;
109 int do_errors;
110 int do_drops;
111 int do_fifo;
112 int do_compressed;
113 int do_events;
114 int do_speed;
115 int do_duplex;
116 int do_operstate;
117 int do_carrier;
118 int do_mtu;
119
120 const char *chart_type_net_bytes;
121 const char *chart_type_net_packets;
122 const char *chart_type_net_errors;
123 const char *chart_type_net_fifo;
124 const char *chart_type_net_events;
125 const char *chart_type_net_drops;
126 const char *chart_type_net_compressed;
127 const char *chart_type_net_speed;
128 const char *chart_type_net_duplex;
129 const char *chart_type_net_operstate;
130 const char *chart_type_net_carrier;
131 const char *chart_type_net_mtu;
132
133 const char *chart_id_net_bytes;
134 const char *chart_id_net_packets;
135 const char *chart_id_net_errors;
136 const char *chart_id_net_fifo;
137 const char *chart_id_net_events;
138 const char *chart_id_net_drops;
139 const char *chart_id_net_compressed;
140 const char *chart_id_net_speed;
141 const char *chart_id_net_duplex;
142 const char *chart_id_net_operstate;
143 const char *chart_id_net_carrier;
144 const char *chart_id_net_mtu;
145
146 const char *chart_ctx_net_bytes;
147 const char *chart_ctx_net_packets;
148 const char *chart_ctx_net_errors;
149 const char *chart_ctx_net_fifo;
150 const char *chart_ctx_net_events;
151 const char *chart_ctx_net_drops;
152 const char *chart_ctx_net_compressed;
153 const char *chart_ctx_net_speed;
154 const char *chart_ctx_net_duplex;
155 const char *chart_ctx_net_operstate;
156 const char *chart_ctx_net_carrier;
157 const char *chart_ctx_net_mtu;
158
159 const char *chart_family;
160
161 RRDLABELS *chart_labels;
162
163 int flipped;
164 unsigned long priority;
165
166 // data collected
167 kernel_uint_t rbytes;
168 kernel_uint_t rpackets;
169 kernel_uint_t rerrors;
170 kernel_uint_t rdrops;
171 kernel_uint_t rfifo;
172 kernel_uint_t rframe;
173 kernel_uint_t rcompressed;
174 kernel_uint_t rmulticast;
175
176 kernel_uint_t tbytes;
177 kernel_uint_t tpackets;
178 kernel_uint_t terrors;
179 kernel_uint_t tdrops;
180 kernel_uint_t tfifo;
181 kernel_uint_t tcollisions;
182 kernel_uint_t tcarrier;
183 kernel_uint_t tcompressed;
184 kernel_uint_t speed;
185 kernel_uint_t duplex;
186 kernel_uint_t operstate;
187 unsigned long long carrier;
188 unsigned long long mtu;
189
190 // charts
191 RRDSET *st_bandwidth;
192 RRDSET *st_packets;
193 RRDSET *st_errors;
194 RRDSET *st_drops;
195 RRDSET *st_fifo;
196 RRDSET *st_compressed;
197 RRDSET *st_events;
198 RRDSET *st_speed;
199 RRDSET *st_duplex;
200 RRDSET *st_operstate;
201 RRDSET *st_carrier;
202 RRDSET *st_mtu;
203
204 // dimensions
205 RRDDIM *rd_rbytes;
206 RRDDIM *rd_rpackets;
207 RRDDIM *rd_rerrors;
208 RRDDIM *rd_rdrops;
209 RRDDIM *rd_rfifo;
210 RRDDIM *rd_rframe;
211 RRDDIM *rd_rcompressed;
212 RRDDIM *rd_rmulticast;
213
214 RRDDIM *rd_tbytes;
215 RRDDIM *rd_tpackets;
216 RRDDIM *rd_terrors;
217 RRDDIM *rd_tdrops;
218 RRDDIM *rd_tfifo;
219 RRDDIM *rd_tcollisions;
220 RRDDIM *rd_tcarrier;
221 RRDDIM *rd_tcompressed;
222
223 RRDDIM *rd_speed;
224 RRDDIM *rd_duplex_full;
225 RRDDIM *rd_duplex_half;
226 RRDDIM *rd_duplex_unknown;
227 RRDDIM *rd_operstate_unknown;
228 RRDDIM *rd_operstate_notpresent;
229 RRDDIM *rd_operstate_down;
230 RRDDIM *rd_operstate_lowerlayerdown;
231 RRDDIM *rd_operstate_testing;
232 RRDDIM *rd_operstate_dormant;
233 RRDDIM *rd_operstate_up;
234 RRDDIM *rd_carrier_up;
235 RRDDIM *rd_carrier_down;
236 RRDDIM *rd_mtu;
237
238 char *filename_speed;
239 const RRDVAR_ACQUIRED *chart_var_speed;
240
241 char *filename_duplex;
242 char *filename_operstate;
243 char *filename_carrier;
244 char *filename_mtu;
245
246 const DICTIONARY_ITEM *cgroup_netdev_link;
247
248 struct netdev *prev, *next;
249 } *netdev_root = NULL;
250
251 // ----------------------------------------------------------------------------
252
253 static void netdev_charts_release(struct netdev *d) {
254 rrdvar_chart_variable_release(d->st_bandwidth, d->chart_var_speed);
255
256 if(d->st_bandwidth) rrdset_is_obsolete___safe_from_collector_thread(d->st_bandwidth);
257 if(d->st_packets) rrdset_is_obsolete___safe_from_collector_thread(d->st_packets);
258 if(d->st_errors) rrdset_is_obsolete___safe_from_collector_thread(d->st_errors);
259 if(d->st_drops) rrdset_is_obsolete___safe_from_collector_thread(d->st_drops);
260 if(d->st_fifo) rrdset_is_obsolete___safe_from_collector_thread(d->st_fifo);
261 if(d->st_compressed) rrdset_is_obsolete___safe_from_collector_thread(d->st_compressed);
262 if(d->st_events) rrdset_is_obsolete___safe_from_collector_thread(d->st_events);
263 if(d->st_speed) rrdset_is_obsolete___safe_from_collector_thread(d->st_speed);
264 if(d->st_duplex) rrdset_is_obsolete___safe_from_collector_thread(d->st_duplex);
265 if(d->st_operstate) rrdset_is_obsolete___safe_from_collector_thread(d->st_operstate);
266 if(d->st_carrier) rrdset_is_obsolete___safe_from_collector_thread(d->st_carrier);
267 if(d->st_mtu) rrdset_is_obsolete___safe_from_collector_thread(d->st_mtu);
268
269 d->st_bandwidth = NULL;
270 d->st_compressed = NULL;
271 d->st_drops = NULL;
272 d->st_errors = NULL;
273 d->st_events = NULL;
274 d->st_fifo = NULL;
275 d->st_packets = NULL;
276 d->st_speed = NULL;
277 d->st_duplex = NULL;
278 d->st_operstate = NULL;
279 d->st_carrier = NULL;
280 d->st_mtu = NULL;
281
282 d->rd_rbytes = NULL;
283 d->rd_rpackets = NULL;
284 d->rd_rerrors = NULL;
285 d->rd_rdrops = NULL;
286 d->rd_rfifo = NULL;
287 d->rd_rframe = NULL;
288 d->rd_rcompressed = NULL;
289 d->rd_rmulticast = NULL;
290
291 d->rd_tbytes = NULL;
292 d->rd_tpackets = NULL;
293 d->rd_terrors = NULL;
294 d->rd_tdrops = NULL;
295 d->rd_tfifo = NULL;
296 d->rd_tcollisions = NULL;
297 d->rd_tcarrier = NULL;
298 d->rd_tcompressed = NULL;
299
300 d->rd_speed = NULL;
301 d->rd_duplex_full = NULL;
302 d->rd_duplex_half = NULL;
303 d->rd_duplex_unknown = NULL;
304 d->rd_carrier_up = NULL;
305 d->rd_carrier_down = NULL;
306 d->rd_mtu = NULL;
307
308 d->rd_operstate_unknown = NULL;
309 d->rd_operstate_notpresent = NULL;
310 d->rd_operstate_down = NULL;
311 d->rd_operstate_lowerlayerdown = NULL;
312 d->rd_operstate_testing = NULL;
313 d->rd_operstate_dormant = NULL;
314 d->rd_operstate_up = NULL;
315
316 d->chart_var_speed = NULL;
317 }
318
319 static void netdev_free_chart_strings(struct netdev *d) {
320 freez_and_set_to_null(d->chart_type_net_bytes);
321 freez_and_set_to_null(d->chart_type_net_compressed);
322 freez_and_set_to_null(d->chart_type_net_drops);
323 freez_and_set_to_null(d->chart_type_net_errors);
324 freez_and_set_to_null(d->chart_type_net_events);
325 freez_and_set_to_null(d->chart_type_net_fifo);
326 freez_and_set_to_null(d->chart_type_net_packets);
327 freez_and_set_to_null(d->chart_type_net_speed);
328 freez_and_set_to_null(d->chart_type_net_duplex);
329 freez_and_set_to_null(d->chart_type_net_operstate);
330 freez_and_set_to_null(d->chart_type_net_carrier);
331 freez_and_set_to_null(d->chart_type_net_mtu);
332
333 freez_and_set_to_null(d->chart_id_net_bytes);
334 freez_and_set_to_null(d->chart_id_net_compressed);
335 freez_and_set_to_null(d->chart_id_net_drops);
336 freez_and_set_to_null(d->chart_id_net_errors);
337 freez_and_set_to_null(d->chart_id_net_events);
338 freez_and_set_to_null(d->chart_id_net_fifo);
339 freez_and_set_to_null(d->chart_id_net_packets);
340 freez_and_set_to_null(d->chart_id_net_speed);
341 freez_and_set_to_null(d->chart_id_net_duplex);
342 freez_and_set_to_null(d->chart_id_net_operstate);
343 freez_and_set_to_null(d->chart_id_net_carrier);
344 freez_and_set_to_null(d->chart_id_net_mtu);
345
346 freez_and_set_to_null(d->chart_ctx_net_bytes);
347 freez_and_set_to_null(d->chart_ctx_net_compressed);
348 freez_and_set_to_null(d->chart_ctx_net_drops);
349 freez_and_set_to_null(d->chart_ctx_net_errors);
350 freez_and_set_to_null(d->chart_ctx_net_events);
351 freez_and_set_to_null(d->chart_ctx_net_fifo);
352 freez_and_set_to_null(d->chart_ctx_net_packets);
353 freez_and_set_to_null(d->chart_ctx_net_speed);
354 freez_and_set_to_null(d->chart_ctx_net_duplex);
355 freez_and_set_to_null(d->chart_ctx_net_operstate);
356 freez_and_set_to_null(d->chart_ctx_net_carrier);
357 freez_and_set_to_null(d->chart_ctx_net_mtu);
358
359 freez_and_set_to_null(d->chart_family);
360 }
361
362 static void netdev_free(struct netdev *d) {
363 netdev_charts_release(d);
364 netdev_free_chart_strings(d);
365
366 rrdlabels_destroy(d->chart_labels);
367 d->chart_labels = NULL;
368
369 cgroup_netdev_release(d->cgroup_netdev_link);
370 d->cgroup_netdev_link = NULL;
371
372 freez_and_set_to_null(d->name);
373 freez_and_set_to_null(d->filename_speed);
374 freez_and_set_to_null(d->filename_duplex);
375 freez_and_set_to_null(d->filename_operstate);
376 freez_and_set_to_null(d->filename_carrier);
377 freez_and_set_to_null(d->filename_mtu);
378
379 freez((void *)d);
380 }
381
382 static netdata_mutex_t netdev_mutex;
383
384 static void __attribute__((constructor)) init_mutex(void) {
385 netdata_mutex_init(&netdev_mutex);
386 }
387
388 static void __attribute__((destructor)) destroy_mutex(void) {
389 netdata_mutex_destroy(&netdev_mutex);
390 }
391
392 // ----------------------------------------------------------------------------
393
394 static inline void netdev_rename_unsafe(struct netdev *d, struct rename_task *r) {
395 collector_info("CGROUP: renaming network interface '%s' as '%s' under '%s'", d->name, r->container_device, r->container_name);
396
397 netdev_charts_release(d);
398 netdev_free_chart_strings(d);
399
400 cgroup_netdev_release(d->cgroup_netdev_link);
401 d->cgroup_netdev_link = cgroup_netdev_dup(r->cgroup_netdev_link);
402 d->discover_time = 0;
403
404 char buffer[RRD_ID_LENGTH_MAX + 1];
405
406 snprintfz(buffer, RRD_ID_LENGTH_MAX, "cgroup_%s", r->container_name);
407 d->chart_type_net_bytes = strdupz(buffer);
408 d->chart_type_net_compressed = strdupz(buffer);
409 d->chart_type_net_drops = strdupz(buffer);
410 d->chart_type_net_errors = strdupz(buffer);
411 d->chart_type_net_events = strdupz(buffer);
412 d->chart_type_net_fifo = strdupz(buffer);
413 d->chart_type_net_packets = strdupz(buffer);
414 d->chart_type_net_speed = strdupz(buffer);
415 d->chart_type_net_duplex = strdupz(buffer);
416 d->chart_type_net_operstate = strdupz(buffer);
417 d->chart_type_net_carrier = strdupz(buffer);
418 d->chart_type_net_mtu = strdupz(buffer);
419
420 snprintfz(buffer, RRD_ID_LENGTH_MAX, "net_%s", r->container_device);
421 d->chart_id_net_bytes = strdupz(buffer);
422 snprintfz(buffer, RRD_ID_LENGTH_MAX, "net_compressed_%s", r->container_device);
423 d->chart_id_net_compressed = strdupz(buffer);
424 snprintfz(buffer, RRD_ID_LENGTH_MAX, "net_drops_%s", r->container_device);
425 d->chart_id_net_drops = strdupz(buffer);
426 snprintfz(buffer, RRD_ID_LENGTH_MAX, "net_errors_%s", r->container_device);
427 d->chart_id_net_errors = strdupz(buffer);
428 snprintfz(buffer, RRD_ID_LENGTH_MAX, "net_events_%s", r->container_device);
429 d->chart_id_net_events = strdupz(buffer);
430 snprintfz(buffer, RRD_ID_LENGTH_MAX, "net_fifo_%s", r->container_device);
431 d->chart_id_net_fifo = strdupz(buffer);
432 snprintfz(buffer, RRD_ID_LENGTH_MAX, "net_packets_%s", r->container_device);
433 d->chart_id_net_packets = strdupz(buffer);
434 snprintfz(buffer, RRD_ID_LENGTH_MAX, "net_speed_%s", r->container_device);
435 d->chart_id_net_speed = strdupz(buffer);
436 snprintfz(buffer, RRD_ID_LENGTH_MAX, "net_duplex_%s", r->container_device);
437 d->chart_id_net_duplex = strdupz(buffer);
438 snprintfz(buffer, RRD_ID_LENGTH_MAX, "net_operstate_%s", r->container_device);
439 d->chart_id_net_operstate = strdupz(buffer);
440 snprintfz(buffer, RRD_ID_LENGTH_MAX, "net_carrier_%s", r->container_device);
441 d->chart_id_net_carrier = strdupz(buffer);
442 snprintfz(buffer, RRD_ID_LENGTH_MAX, "net_mtu_%s", r->container_device);
443 d->chart_id_net_mtu = strdupz(buffer);
444
445 snprintfz(buffer, RRD_ID_LENGTH_MAX, "%scgroup.net_net", r->ctx_prefix);
446 d->chart_ctx_net_bytes = strdupz(buffer);
447 snprintfz(buffer, RRD_ID_LENGTH_MAX, "%scgroup.net_compressed", r->ctx_prefix);
448 d->chart_ctx_net_compressed = strdupz(buffer);
449 snprintfz(buffer, RRD_ID_LENGTH_MAX, "%scgroup.net_drops", r->ctx_prefix);
450 d->chart_ctx_net_drops = strdupz(buffer);
451 snprintfz(buffer, RRD_ID_LENGTH_MAX, "%scgroup.net_errors", r->ctx_prefix);
452 d->chart_ctx_net_errors = strdupz(buffer);
453 snprintfz(buffer, RRD_ID_LENGTH_MAX, "%scgroup.net_events", r->ctx_prefix);
454 d->chart_ctx_net_events = strdupz(buffer);
455 snprintfz(buffer, RRD_ID_LENGTH_MAX, "%scgroup.net_fifo", r->ctx_prefix);
456 d->chart_ctx_net_fifo = strdupz(buffer);
457 snprintfz(buffer, RRD_ID_LENGTH_MAX, "%scgroup.net_packets", r->ctx_prefix);
458 d->chart_ctx_net_packets = strdupz(buffer);
459 snprintfz(buffer, RRD_ID_LENGTH_MAX, "%scgroup.net_speed", r->ctx_prefix);
460 d->chart_ctx_net_speed = strdupz(buffer);
461 snprintfz(buffer, RRD_ID_LENGTH_MAX, "%scgroup.net_duplex", r->ctx_prefix);
462 d->chart_ctx_net_duplex = strdupz(buffer);
463 snprintfz(buffer, RRD_ID_LENGTH_MAX, "%scgroup.net_operstate", r->ctx_prefix);
464 d->chart_ctx_net_operstate = strdupz(buffer);
465 snprintfz(buffer, RRD_ID_LENGTH_MAX, "%scgroup.net_carrier", r->ctx_prefix);
466 d->chart_ctx_net_carrier = strdupz(buffer);
467 snprintfz(buffer, RRD_ID_LENGTH_MAX, "%scgroup.net_mtu", r->ctx_prefix);
468 d->chart_ctx_net_mtu = strdupz(buffer);
469
470 d->chart_family = strdupz("net");
471
472 rrdlabels_copy(d->chart_labels, r->chart_labels);
473 rrdlabels_add(d->chart_labels, "container_device", r->container_device, RRDLABEL_SRC_AUTO);
474
475 d->priority = NETDATA_CHART_PRIO_CGROUP_NET_IFACE;
476 d->flipped = 1;
477 }
478
479 static void netdev_rename_this_device(struct netdev *d) {
480 const DICTIONARY_ITEM *item = dictionary_get_and_acquire_item(netdev_renames, d->name);
481 if(item) {
482 struct rename_task *r = dictionary_acquired_item_value(item);
483 spinlock_lock(&r->spinlock);
484 netdev_rename_unsafe(d, r);
485 spinlock_unlock(&r->spinlock);
486 dictionary_acquired_item_release(netdev_renames, item);
487 }
488 }
489
490 // ----------------------------------------------------------------------------
491
492 static int netdev_function_net_interfaces(BUFFER *wb, const char *function __maybe_unused, BUFFER *payload __maybe_unused, const char *source __maybe_unused) {
493 buffer_flush(wb);
494 wb->content_type = CT_APPLICATION_JSON;
495 buffer_json_initialize(wb, "\"", "\"", 0, true, BUFFER_JSON_OPTIONS_DEFAULT);
496
497 buffer_json_member_add_string(wb, "hostname", rrdhost_hostname(localhost));
498 buffer_json_member_add_uint64(wb, "status", HTTP_RESP_OK);
499 buffer_json_member_add_string(wb, "type", "table");
500 buffer_json_member_add_time_t(wb, "update_every", 1);
501 buffer_json_member_add_boolean(wb, "has_history", false);
502 buffer_json_member_add_string(wb, "help", RRDFUNCTIONS_NETDEV_HELP);
503 buffer_json_member_add_array(wb, "data");
504
505 double max_traffic_rx = 0.0;
506 double max_traffic_tx = 0.0;
507 double max_traffic = 0.0;
508 double max_packets_rx = 0.0;
509 double max_packets_tx = 0.0;
510 double max_mcast_rx = 0.0;
511 double max_drops_rx = 0.0;
512 double max_drops_tx = 0.0;
513
514 netdata_mutex_lock(&netdev_mutex);
515
516 RRDDIM *rd = NULL;
517
518 for (struct netdev *d = netdev_root; d ; d = d->next) {
519 if (unlikely(!d->function_ready))
520 continue;
521
522 buffer_json_add_array_item_array(wb);
523
524 buffer_json_add_array_item_string(wb, d->name);
525
526 buffer_json_add_array_item_string(wb, d->virtual ? "virtual" : "physical");
527 buffer_json_add_array_item_string(wb, d->flipped ? "cgroup" : "host");
528 buffer_json_add_array_item_string(wb, d->carrier == 1 ? "up" : "down");
529 buffer_json_add_array_item_string(wb, get_operstate_string(d->operstate));
530 buffer_json_add_array_item_string(wb, get_duplex_string(d->duplex));
531 buffer_json_add_array_item_double(wb, d->speed > 0 ? d->speed : NAN);
532 buffer_json_add_array_item_double(wb, d->mtu > 0 ? d->mtu : NAN);
533
534 rd = d->flipped ? d->rd_tbytes : d->rd_rbytes;
535 double traffic_rx = rrddim_get_last_stored_value(rd, &max_traffic_rx, 1000.0);
536 rd = d->flipped ? d->rd_rbytes : d->rd_tbytes;
537 double traffic_tx = rrddim_get_last_stored_value(rd, &max_traffic_tx, 1000.0);
538
539 rd = d->flipped ? d->rd_tpackets : d->rd_rpackets;
540 double packets_rx = rrddim_get_last_stored_value(rd, &max_packets_rx, 1000.0);
541 rd = d->flipped ? d->rd_rpackets : d->rd_tpackets;
542 double packets_tx = rrddim_get_last_stored_value(rd, &max_packets_tx, 1000.0);
543
544 double mcast_rx = rrddim_get_last_stored_value(d->rd_rmulticast, &max_mcast_rx, 1000.0);
545
546 rd = d->flipped ? d->rd_tdrops : d->rd_rdrops;
547 double drops_rx = rrddim_get_last_stored_value(rd, &max_drops_rx, 1.0);
548 rd = d->flipped ? d->rd_rdrops : d->rd_tdrops;
549 double drops_tx = rrddim_get_last_stored_value(rd, &max_drops_tx, 1.0);
550
551 // FIXME: "traffic" (total) is needed only for default_sorting
552 // can be removed when default_sorting will accept multiple columns (sum)
553 double traffic = NAN;
554 if (!isnan(traffic_rx) && !isnan(traffic_tx)) {
555 traffic = traffic_rx + traffic_tx;
556 max_traffic = MAX(max_traffic, traffic);
557 }
558
559
560 buffer_json_add_array_item_double(wb, traffic_rx);
561 buffer_json_add_array_item_double(wb, traffic_tx);
562 buffer_json_add_array_item_double(wb, traffic);
563 buffer_json_add_array_item_double(wb, packets_rx);
564 buffer_json_add_array_item_double(wb, packets_tx);
565 buffer_json_add_array_item_double(wb, mcast_rx);
566 buffer_json_add_array_item_double(wb, drops_rx);
567 buffer_json_add_array_item_double(wb, drops_tx);
568
569 buffer_json_add_array_item_object(wb);
570 {
571 buffer_json_member_add_string(wb, "severity", drops_rx + drops_tx > 0 ? "warning" : "normal");
572 }
573 buffer_json_object_close(wb);
574
575 buffer_json_array_close(wb);
576 }
577
578 netdata_mutex_unlock(&netdev_mutex);
579
580 buffer_json_array_close(wb); // data
581 buffer_json_member_add_object(wb, "columns");
582 {
583 size_t field_id = 0;
584
585 buffer_rrdf_table_add_field(wb, field_id++, "Interface", "Network Interface Name",
586 RRDF_FIELD_TYPE_STRING, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE,
587 0, NULL, NAN, RRDF_FIELD_SORT_ASCENDING, NULL,
588 RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
589 RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY,
590 NULL);
591
592 buffer_rrdf_table_add_field(wb, field_id++, "Type", "Network Interface Type",
593 RRDF_FIELD_TYPE_STRING, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE,
594 0, NULL, NAN, RRDF_FIELD_SORT_ASCENDING, NULL,
595 RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
596 RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY,
597 NULL);
598
599 buffer_rrdf_table_add_field(wb, field_id++, "UsedBy", "Indicates whether the network interface is used by a cgroup or by the host system",
600 RRDF_FIELD_TYPE_STRING, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE,
601 0, NULL, NAN, RRDF_FIELD_SORT_ASCENDING, NULL,
602 RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
603 RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY,
604 NULL);
605
606 buffer_rrdf_table_add_field(wb, field_id++, "PhState", "Current Physical State",
607 RRDF_FIELD_TYPE_STRING, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE,
608 0, NULL, NAN, RRDF_FIELD_SORT_ASCENDING, NULL,
609 RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
610 RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY,
611 NULL);
612
613 buffer_rrdf_table_add_field(wb, field_id++, "OpState", "Current Operational State",
614 RRDF_FIELD_TYPE_STRING, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE,
615 0, NULL, NAN, RRDF_FIELD_SORT_ASCENDING, NULL,
616 RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
617 RRDF_FIELD_OPTS_UNIQUE_KEY,
618 NULL);
619
620 buffer_rrdf_table_add_field(wb, field_id++, "Duplex", "Current Duplex Mode",
621 RRDF_FIELD_TYPE_STRING, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE,
622 0, NULL, NAN, RRDF_FIELD_SORT_ASCENDING, NULL,
623 RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
624 RRDF_FIELD_OPTS_UNIQUE_KEY,
625 NULL);
626
627 buffer_rrdf_table_add_field(wb, field_id++, "Speed", "Current Link Speed",
628 RRDF_FIELD_TYPE_BAR_WITH_INTEGER, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NUMBER,
629 0, "Mbit", NAN, RRDF_FIELD_SORT_DESCENDING, NULL,
630 RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
631 RRDF_FIELD_OPTS_UNIQUE_KEY,
632 NULL);
633
634 buffer_rrdf_table_add_field(wb, field_id++, "MTU", "Maximum Transmission Unit",
635 RRDF_FIELD_TYPE_BAR_WITH_INTEGER, RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NUMBER,
636 0, "Octets", NAN, RRDF_FIELD_SORT_DESCENDING, NULL,
637 RRDF_FIELD_SUMMARY_COUNT, RRDF_FIELD_FILTER_MULTISELECT,
638 RRDF_FIELD_OPTS_UNIQUE_KEY,
639 NULL);
640
641 buffer_rrdf_table_add_field(wb, field_id++, "In", "Traffic Received",
642 RRDF_FIELD_TYPE_BAR_WITH_INTEGER, RRDF_FIELD_VISUAL_BAR, RRDF_FIELD_TRANSFORM_NUMBER,
643 2, "Mbit", max_traffic_rx, RRDF_FIELD_SORT_DESCENDING, NULL,
644 RRDF_FIELD_SUMMARY_SUM, RRDF_FIELD_FILTER_NONE,
645 RRDF_FIELD_OPTS_VISIBLE,
646 NULL);
647
648 buffer_rrdf_table_add_field(wb, field_id++, "Out", "Traffic Sent",
649 RRDF_FIELD_TYPE_BAR_WITH_INTEGER, RRDF_FIELD_VISUAL_BAR, RRDF_FIELD_TRANSFORM_NUMBER,
650 2, "Mbit", max_traffic_tx, RRDF_FIELD_SORT_DESCENDING, NULL,
651 RRDF_FIELD_SUMMARY_SUM, RRDF_FIELD_FILTER_NONE,
652 RRDF_FIELD_OPTS_VISIBLE,
653 NULL);
654
655 buffer_rrdf_table_add_field(wb, field_id++, "Total", "Traffic Received and Sent",
656 RRDF_FIELD_TYPE_BAR_WITH_INTEGER, RRDF_FIELD_VISUAL_BAR, RRDF_FIELD_TRANSFORM_NUMBER,
657 2, "Mbit", max_traffic, RRDF_FIELD_SORT_DESCENDING, NULL,
658 RRDF_FIELD_SUMMARY_SUM, RRDF_FIELD_FILTER_NONE,
659 RRDF_FIELD_OPTS_NONE,
660 NULL);
661
662 buffer_rrdf_table_add_field(wb, field_id++, "PktsIn", "Received Packets",
663 RRDF_FIELD_TYPE_BAR_WITH_INTEGER, RRDF_FIELD_VISUAL_BAR, RRDF_FIELD_TRANSFORM_NUMBER,
664 2, "Kpps", max_packets_rx, RRDF_FIELD_SORT_DESCENDING, NULL,
665 RRDF_FIELD_SUMMARY_SUM, RRDF_FIELD_FILTER_NONE,
666 RRDF_FIELD_OPTS_VISIBLE,
667 NULL);
668
669 buffer_rrdf_table_add_field(wb, field_id++, "PktsOut", "Sent Packets",
670 RRDF_FIELD_TYPE_BAR_WITH_INTEGER, RRDF_FIELD_VISUAL_BAR, RRDF_FIELD_TRANSFORM_NUMBER,
671 2, "Kpps", max_packets_tx, RRDF_FIELD_SORT_DESCENDING, NULL,
672 RRDF_FIELD_SUMMARY_SUM, RRDF_FIELD_FILTER_NONE,
673 RRDF_FIELD_OPTS_VISIBLE,
674 NULL);
675
676 buffer_rrdf_table_add_field(wb, field_id++, "McastIn", "Multicast Received Packets",
677 RRDF_FIELD_TYPE_BAR_WITH_INTEGER, RRDF_FIELD_VISUAL_BAR, RRDF_FIELD_TRANSFORM_NUMBER,
678 2, "Kpps", max_mcast_rx, RRDF_FIELD_SORT_DESCENDING, NULL,
679 RRDF_FIELD_SUMMARY_SUM, RRDF_FIELD_FILTER_NONE,
680 RRDF_FIELD_OPTS_NONE,
681 NULL);
682
683 buffer_rrdf_table_add_field(wb, field_id++, "DropsIn", "Dropped Inbound Packets",
684 RRDF_FIELD_TYPE_BAR_WITH_INTEGER, RRDF_FIELD_VISUAL_BAR, RRDF_FIELD_TRANSFORM_NUMBER,
685 2, "Drops", max_drops_rx, RRDF_FIELD_SORT_DESCENDING, NULL,
686 RRDF_FIELD_SUMMARY_SUM, RRDF_FIELD_FILTER_NONE,
687 RRDF_FIELD_OPTS_VISIBLE,
688 NULL);
689
690 buffer_rrdf_table_add_field(wb, field_id++, "DropsOut", "Dropped Outbound Packets",
691 RRDF_FIELD_TYPE_BAR_WITH_INTEGER, RRDF_FIELD_VISUAL_BAR, RRDF_FIELD_TRANSFORM_NUMBER,
692 2, "Drops", max_drops_tx, RRDF_FIELD_SORT_DESCENDING, NULL,
693 RRDF_FIELD_SUMMARY_SUM, RRDF_FIELD_FILTER_NONE,
694 RRDF_FIELD_OPTS_VISIBLE,
695 NULL);
696
697 buffer_rrdf_table_add_field(
698 wb, field_id++,
699 "rowOptions", "rowOptions",
700 RRDF_FIELD_TYPE_NONE,
701 RRDR_FIELD_VISUAL_ROW_OPTIONS,
702 RRDF_FIELD_TRANSFORM_NONE, 0, NULL, NAN,
703 RRDF_FIELD_SORT_FIXED,
704 NULL,
705 RRDF_FIELD_SUMMARY_COUNT,
706 RRDF_FIELD_FILTER_NONE,
707 RRDF_FIELD_OPTS_DUMMY,
708 NULL);
709 }
710
711 buffer_json_object_close(wb); // columns
712 buffer_json_member_add_string(wb, "default_sort_column", "Total");
713
714 buffer_json_member_add_object(wb, "charts");
715 {
716 buffer_json_member_add_object(wb, "Traffic");
717 {
718 buffer_json_member_add_string(wb, "name", "Traffic");
719 buffer_json_member_add_string(wb, "type", "stacked-bar");
720 buffer_json_member_add_array(wb, "columns");
721 {
722 buffer_json_add_array_item_string(wb, "In");
723 buffer_json_add_array_item_string(wb, "Out");
724 }
725 buffer_json_array_close(wb);
726 }
727 buffer_json_object_close(wb);
728
729 buffer_json_member_add_object(wb, "Packets");
730 {
731 buffer_json_member_add_string(wb, "name", "Packets");
732 buffer_json_member_add_string(wb, "type", "stacked-bar");
733 buffer_json_member_add_array(wb, "columns");
734 {
735 buffer_json_add_array_item_string(wb, "PktsIn");
736 buffer_json_add_array_item_string(wb, "PktsOut");
737 }
738 buffer_json_array_close(wb);
739 }
740 buffer_json_object_close(wb);
741 }
742 buffer_json_object_close(wb); // charts
743
744 buffer_json_member_add_array(wb, "default_charts");
745 {
746 buffer_json_add_array_item_array(wb);
747 buffer_json_add_array_item_string(wb, "Traffic");
748 buffer_json_add_array_item_string(wb, "Interface");
749 buffer_json_array_close(wb);
750
751 buffer_json_add_array_item_array(wb);
752 buffer_json_add_array_item_string(wb, "Traffic");
753 buffer_json_add_array_item_string(wb, "Type");
754 buffer_json_array_close(wb);
755 }
756 buffer_json_array_close(wb);
757
758 buffer_json_member_add_object(wb, "group_by");
759 {
760 buffer_json_member_add_object(wb, "Type");
761 {
762 buffer_json_member_add_string(wb, "name", "Type");
763 buffer_json_member_add_array(wb, "columns");
764 {
765 buffer_json_add_array_item_string(wb, "Type");
766 }
767 buffer_json_array_close(wb);
768 }
769 buffer_json_object_close(wb);
770
771 buffer_json_member_add_object(wb, "UsedBy");
772 {
773 buffer_json_member_add_string(wb, "name", "UsedBy");
774 buffer_json_member_add_array(wb, "columns");
775 {
776 buffer_json_add_array_item_string(wb, "UsedBy");
777 }
778 buffer_json_array_close(wb);
779 }
780 buffer_json_object_close(wb);
781 }
782 buffer_json_object_close(wb); // group_by
783
784 buffer_json_member_add_time_t(wb, "expires", now_realtime_sec() + 1);
785 buffer_json_finalize(wb);
786
787 return HTTP_RESP_OK;
788 }
789
790 // netdev data collection
791
792 static void netdev_cleanup() {
793 struct netdev *d = netdev_root;
794 while(d) {
795 if(unlikely(!d->updated)) {
796 struct netdev *next = d->next; // keep the next, to continue;
797
798 DOUBLE_LINKED_LIST_REMOVE_ITEM_UNSAFE(netdev_root, d, prev, next);
799
800 netdev_free(d);
801 d = next;
802 continue;
803 }
804
805 d->updated = false;
806 d = d->next;
807 }
808 }
809
810 static struct netdev *get_netdev(const char *name) {
811 struct netdev *d;
812
813 uint32_t hash = simple_hash(name);
814
815 // search it, from the last position to the end
816 for(d = netdev_root ; d ; d = d->next) {
817 if(unlikely(hash == d->hash && !strcmp(name, d->name)))
818 return d;
819 }
820
821 // create a new one
822 d = callocz(1, sizeof(struct netdev));
823 d->name = strdupz(name);
824 d->hash = simple_hash(d->name);
825 d->len = strlen(d->name);
826 d->chart_labels = rrdlabels_create();
827 d->function_ready = false;
828
829 d->chart_type_net_bytes = strdupz("net");
830 d->chart_type_net_compressed = strdupz("net_compressed");
831 d->chart_type_net_drops = strdupz("net_drops");
832 d->chart_type_net_errors = strdupz("net_errors");
833 d->chart_type_net_events = strdupz("net_events");
834 d->chart_type_net_fifo = strdupz("net_fifo");
835 d->chart_type_net_packets = strdupz("net_packets");
836 d->chart_type_net_speed = strdupz("net_speed");
837 d->chart_type_net_duplex = strdupz("net_duplex");
838 d->chart_type_net_operstate = strdupz("net_operstate");
839 d->chart_type_net_carrier = strdupz("net_carrier");
840 d->chart_type_net_mtu = strdupz("net_mtu");
841
842 d->chart_id_net_bytes = strdupz(d->name);
843 d->chart_id_net_compressed = strdupz(d->name);
844 d->chart_id_net_drops = strdupz(d->name);
845 d->chart_id_net_errors = strdupz(d->name);
846 d->chart_id_net_events = strdupz(d->name);
847 d->chart_id_net_fifo = strdupz(d->name);
848 d->chart_id_net_packets = strdupz(d->name);
849 d->chart_id_net_speed = strdupz(d->name);
850 d->chart_id_net_duplex = strdupz(d->name);
851 d->chart_id_net_operstate = strdupz(d->name);
852 d->chart_id_net_carrier = strdupz(d->name);
853 d->chart_id_net_mtu = strdupz(d->name);
854
855 d->chart_ctx_net_bytes = strdupz("net.net");
856 d->chart_ctx_net_compressed = strdupz("net.compressed");
857 d->chart_ctx_net_drops = strdupz("net.drops");
858 d->chart_ctx_net_errors = strdupz("net.errors");
859 d->chart_ctx_net_events = strdupz("net.events");
860 d->chart_ctx_net_fifo = strdupz("net.fifo");
861 d->chart_ctx_net_packets = strdupz("net.packets");
862 d->chart_ctx_net_speed = strdupz("net.speed");
863 d->chart_ctx_net_duplex = strdupz("net.duplex");
864 d->chart_ctx_net_operstate = strdupz("net.operstate");
865 d->chart_ctx_net_carrier = strdupz("net.carrier");
866 d->chart_ctx_net_mtu = strdupz("net.mtu");
867
868 d->chart_family = strdupz(d->name);
869 d->priority = NETDATA_CHART_PRIO_FIRST_NET_IFACE;
870
871 DOUBLE_LINKED_LIST_APPEND_ITEM_UNSAFE(netdev_root, d, prev, next);
872
873 return d;
874 }
875
876 int do_proc_net_dev(int update_every, usec_t dt) {
877 (void)dt;
878 static SIMPLE_PATTERN *disabled_list = NULL;
879 static SIMPLE_PATTERN *virtual_iface_no_delay = NULL;
880 static procfile *ff = NULL;
881 static int enable_new_interfaces = -1;
882 static int do_bandwidth = -1, do_packets = -1, do_errors = -1, do_drops = -1, do_fifo = -1, do_compressed = -1,
883 do_events = -1, do_speed = -1, do_duplex = -1, do_operstate = -1, do_carrier = -1, do_mtu = -1;
884 static char *path_to_sys_devices_virtual_net = NULL, *path_to_sys_class_net_speed = NULL,
885 *proc_net_dev_filename = NULL;
886 static char *path_to_sys_class_net_duplex = NULL;
887 static char *path_to_sys_class_net_operstate = NULL;
888 static char *path_to_sys_class_net_carrier = NULL;
889 static char *path_to_sys_class_net_mtu = NULL;
890
891 if(unlikely(enable_new_interfaces == -1)) {
892 char filename[FILENAME_MAX + 1];
893
894 snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, (*netdata_configured_host_prefix)?"/proc/1/net/dev":"/proc/net/dev");
895 proc_net_dev_filename = strdupz(filename);
896
897 snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/virtual/net/%s");
898 path_to_sys_devices_virtual_net = strdupz(filename);
899
900 snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/class/net/%s/speed");
901 path_to_sys_class_net_speed = strdupz(filename);
902
903 snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/class/net/%s/duplex");
904 path_to_sys_class_net_duplex = strdupz(filename);
905
906 snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/class/net/%s/operstate");
907 path_to_sys_class_net_operstate = strdupz(filename);
908
909 snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/class/net/%s/carrier");
910 path_to_sys_class_net_carrier = strdupz(filename);
911
912 snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/class/net/%s/mtu");
913 path_to_sys_class_net_mtu = strdupz(filename);
914
915 enable_new_interfaces = CONFIG_BOOLEAN_YES;
916
917 do_bandwidth = do_packets = do_errors = do_drops = do_fifo = do_events = do_speed = do_duplex = do_operstate =
918 do_carrier = do_mtu = CONFIG_BOOLEAN_YES;
919
920 // only CSLIP, PPP
921 do_compressed = inicfg_get_boolean_ondemand(&netdata_config, CONFIG_SECTION_PLUGIN_PROC_NETDEV, "compressed packets for all interfaces", CONFIG_BOOLEAN_NO);
922
923 disabled_list = simple_pattern_create(
924 inicfg_get(&netdata_config,
925 CONFIG_SECTION_PLUGIN_PROC_NETDEV,
926 "disable by default interfaces matching",
927 "lo fireqos* *-ifb fwpr* fwbr* fwln* ifb4*"),
928 NULL,
929 SIMPLE_PATTERN_EXACT,
930 true);
931
932 virtual_iface_no_delay = simple_pattern_create(
933 " bond* "
934 " vlan* "
935 " vmbr* "
936 " wg* "
937 " vpn* "
938 " tun* "
939 " gre* "
940 " docker* ",
941 NULL,
942 SIMPLE_PATTERN_EXACT,
943 true);
944
945 netdev_renames_init();
946 }
947
948 if(unlikely(!ff)) {
949 ff = procfile_open(proc_net_dev_filename, " \t,|", PROCFILE_FLAG_DEFAULT);
950 if(unlikely(!ff)) return 1;
951 }
952
953 ff = procfile_readall(ff);
954 if(unlikely(!ff)) return 0; // we return 0, so that we will retry to open it next time
955
956 kernel_uint_t system_rbytes = 0;
957 kernel_uint_t system_tbytes = 0;
958
959 time_t now = now_realtime_sec();
960
961 size_t lines = procfile_lines(ff), l;
962 for(l = 2; l < lines ;l++) {
963 // require 17 words on each line
964 if(unlikely(procfile_linewords(ff, l) < 17)) continue;
965
966 char *name = procfile_lineword(ff, l, 0);
967 size_t len = strlen(name);
968 if(name[len - 1] == ':') name[len - 1] = '\0';
969
970 struct netdev *d = get_netdev(name);
971 d->updated = true;
972
973 if(unlikely(!d->configured)) {
974 // the first time we see this interface
975
976 // remember we configured it
977 d->configured = true;
978 d->discover_time = now;
979
980 d->enabled = enable_new_interfaces;
981
982 if(d->enabled)
983 d->enabled = !simple_pattern_matches(disabled_list, d->name);
984
985 char buf[FILENAME_MAX + 1];
986 snprintfz(buf, FILENAME_MAX, path_to_sys_devices_virtual_net, d->name);
987
988 d->virtual = likely(access(buf, R_OK) == 0) ? true : false;
989
990 // At least on Proxmox inside LXC: eth0 is virtual.
991 // Virtual interfaces are not taken into account in system.net calculations
992 if (inside_lxc_container && d->virtual && strncmp(d->name, "eth", 3) == 0)
993 d->virtual = false;
994
995 if (d->virtual)
996 rrdlabels_add(d->chart_labels, "interface_type", "virtual", RRDLABEL_SRC_AUTO);
997 else
998 rrdlabels_add(d->chart_labels, "interface_type", "real", RRDLABEL_SRC_AUTO);
999
1000 rrdlabels_add(d->chart_labels, "device", name, RRDLABEL_SRC_AUTO);
1001
1002 if(likely(!d->virtual)) {
1003 // set the filename to get the interface speed
1004 snprintfz(buf, FILENAME_MAX, path_to_sys_class_net_speed, d->name);
1005 d->filename_speed = strdupz(buf);
1006
1007 snprintfz(buf, FILENAME_MAX, path_to_sys_class_net_duplex, d->name);
1008 d->filename_duplex = strdupz(buf);
1009 }
1010
1011 snprintfz(buf, FILENAME_MAX, path_to_sys_class_net_operstate, d->name);
1012 d->filename_operstate = strdupz(buf);
1013
1014 snprintfz(buf, FILENAME_MAX, path_to_sys_class_net_carrier, d->name);
1015 d->filename_carrier = strdupz(buf);
1016
1017 snprintfz(buf, FILENAME_MAX, path_to_sys_class_net_mtu, d->name);
1018 d->filename_mtu = strdupz(buf);
1019
1020 snprintfz(buf, FILENAME_MAX, "plugin:proc:/proc/net/dev:%s", d->name);
1021
1022 if (inicfg_exists(&netdata_config, buf, "enabled"))
1023 d->enabled = inicfg_get_boolean_ondemand(&netdata_config, buf, "enabled", d->enabled);
1024 if (inicfg_exists(&netdata_config, buf, "virtual"))
1025 d->virtual = inicfg_get_boolean(&netdata_config, buf, "virtual", d->virtual);
1026
1027 if(d->enabled == CONFIG_BOOLEAN_NO)
1028 continue;
1029
1030 d->do_bandwidth = do_bandwidth;
1031 d->do_packets = do_packets;
1032 d->do_errors = do_errors;
1033 d->do_drops = do_drops;
1034 d->do_fifo = do_fifo;
1035 d->do_compressed = do_compressed;
1036 d->do_events = do_events;
1037 d->do_speed = do_speed;
1038 d->do_duplex = do_duplex;
1039 d->do_operstate = do_operstate;
1040 d->do_carrier = do_carrier;
1041 d->do_mtu = do_mtu;
1042
1043 if (inicfg_exists(&netdata_config, buf, "bandwidth"))
1044 d->do_bandwidth = inicfg_get_boolean_ondemand(&netdata_config, buf, "bandwidth", do_bandwidth);
1045 if (inicfg_exists(&netdata_config, buf, "packets"))
1046 d->do_packets = inicfg_get_boolean_ondemand(&netdata_config, buf, "packets", do_packets);
1047 if (inicfg_exists(&netdata_config, buf, "errors"))
1048 d->do_errors = inicfg_get_boolean_ondemand(&netdata_config, buf, "errors", do_errors);
1049 if (inicfg_exists(&netdata_config, buf, "drops"))
1050 d->do_drops = inicfg_get_boolean_ondemand(&netdata_config, buf, "drops", do_drops);
1051 if (inicfg_exists(&netdata_config, buf, "fifo"))
1052 d->do_fifo = inicfg_get_boolean_ondemand(&netdata_config, buf, "fifo", do_fifo);
1053 if (inicfg_exists(&netdata_config, buf, "compressed"))
1054 d->do_compressed = inicfg_get_boolean_ondemand(&netdata_config, buf, "compressed", do_compressed);
1055 if (inicfg_exists(&netdata_config, buf, "events"))
1056 d->do_events = inicfg_get_boolean_ondemand(&netdata_config, buf, "events", do_events);
1057 if (inicfg_exists(&netdata_config, buf, "speed"))
1058 d->do_speed = inicfg_get_boolean_ondemand(&netdata_config, buf, "speed", do_speed);
1059 if (inicfg_exists(&netdata_config, buf, "duplex"))
1060 d->do_duplex = inicfg_get_boolean_ondemand(&netdata_config, buf, "duplex", do_duplex);
1061 if (inicfg_exists(&netdata_config, buf, "operstate"))
1062 d->do_operstate = inicfg_get_boolean_ondemand(&netdata_config, buf, "operstate", do_operstate);
1063 if (inicfg_exists(&netdata_config, buf, "carrier"))
1064 d->do_carrier = inicfg_get_boolean_ondemand(&netdata_config, buf, "carrier", do_carrier);
1065 if (inicfg_exists(&netdata_config, buf, "mtu"))
1066 d->do_mtu = inicfg_get_boolean_ondemand(&netdata_config, buf, "mtu", do_mtu);
1067 }
1068
1069 if(unlikely(!d->enabled))
1070 continue;
1071
1072 if(!d->cgroup_netdev_link)
1073 netdev_rename_this_device(d);
1074
1075 // See https://github.com/netdata/netdata/issues/15206
1076 // This is necessary to prevent the creation of charts for virtual interfaces that will later be
1077 // recreated as container interfaces (create container) or
1078 // rediscovered and recreated only to be deleted almost immediately (stop/remove container)
1079 if (d->virtual && !simple_pattern_matches(virtual_iface_no_delay, d->name) &&
1080 (now - d->discover_time < virtual_device_collect_delay_secs)) {
1081 continue;
1082 }
1083
1084 if(likely(d->do_bandwidth != CONFIG_BOOLEAN_NO || !d->virtual)) {
1085 d->rbytes = str2kernel_uint_t(procfile_lineword(ff, l, 1));
1086 d->tbytes = str2kernel_uint_t(procfile_lineword(ff, l, 9));
1087
1088 if(likely(!d->virtual)) {
1089 system_rbytes += d->rbytes;
1090 system_tbytes += d->tbytes;
1091 }
1092 }
1093
1094 if(likely(d->do_packets != CONFIG_BOOLEAN_NO)) {
1095 d->rpackets = str2kernel_uint_t(procfile_lineword(ff, l, 2));
1096 d->rmulticast = str2kernel_uint_t(procfile_lineword(ff, l, 8));
1097 d->tpackets = str2kernel_uint_t(procfile_lineword(ff, l, 10));
1098 }
1099
1100 if(likely(d->do_errors != CONFIG_BOOLEAN_NO)) {
1101 d->rerrors = str2kernel_uint_t(procfile_lineword(ff, l, 3));
1102 d->terrors = str2kernel_uint_t(procfile_lineword(ff, l, 11));
1103 }
1104
1105 if(likely(d->do_drops != CONFIG_BOOLEAN_NO)) {
1106 d->rdrops = str2kernel_uint_t(procfile_lineword(ff, l, 4));
1107 d->tdrops = str2kernel_uint_t(procfile_lineword(ff, l, 12));
1108 }
1109
1110 if(likely(d->do_fifo != CONFIG_BOOLEAN_NO)) {
1111 d->rfifo = str2kernel_uint_t(procfile_lineword(ff, l, 5));
1112 d->tfifo = str2kernel_uint_t(procfile_lineword(ff, l, 13));
1113 }
1114
1115 if(likely(d->do_compressed != CONFIG_BOOLEAN_NO)) {
1116 d->rcompressed = str2kernel_uint_t(procfile_lineword(ff, l, 7));
1117 d->tcompressed = str2kernel_uint_t(procfile_lineword(ff, l, 16));
1118 }
1119
1120 if(likely(d->do_events != CONFIG_BOOLEAN_NO)) {
1121 d->rframe = str2kernel_uint_t(procfile_lineword(ff, l, 6));
1122 d->tcollisions = str2kernel_uint_t(procfile_lineword(ff, l, 14));
1123 d->tcarrier = str2kernel_uint_t(procfile_lineword(ff, l, 15));
1124 }
1125
1126 if ((d->do_carrier != CONFIG_BOOLEAN_NO ||
1127 d->do_duplex != CONFIG_BOOLEAN_NO ||
1128 d->do_speed != CONFIG_BOOLEAN_NO) &&
1129 d->filename_carrier &&
1130 (d->carrier_file_exists ||
1131 now_monotonic_sec() - d->carrier_file_lost_time > READ_RETRY_PERIOD)) {
1132 if (read_single_number_file(d->filename_carrier, &d->carrier)) {
1133 if (d->carrier_file_exists)
1134 collector_error(
1135 "Cannot refresh interface %s carrier state by reading '%s'. Next update is in %d seconds.",
1136 d->name,
1137 d->filename_carrier,
1138 READ_RETRY_PERIOD);
1139 d->carrier_file_exists = 0;
1140 d->carrier_file_lost_time = now_monotonic_sec();
1141 } else {
1142 d->carrier_file_exists = 1;
1143 d->carrier_file_lost_time = 0;
1144 }
1145 }
1146
1147 if (d->do_duplex != CONFIG_BOOLEAN_NO &&
1148 d->filename_duplex &&
1149 (d->carrier || d->carrier_file_exists) &&
1150 (d->duplex_file_exists ||
1151 now_monotonic_sec() - d->duplex_file_lost_time > READ_RETRY_PERIOD)) {
1152 char buffer[STATE_LENGTH_MAX + 1];
1153
1154 if (read_txt_file(d->filename_duplex, buffer, sizeof(buffer))) {
1155 if (d->duplex_file_exists)
1156 collector_error("Cannot refresh interface %s duplex state by reading '%s'.", d->name, d->filename_duplex);
1157 d->duplex_file_exists = 0;
1158 d->duplex_file_lost_time = now_monotonic_sec();
1159 d->duplex = NETDEV_DUPLEX_UNKNOWN;
1160 } else {
1161 // values can be unknown, half or full -- just check the first letter for speed
1162 if (buffer[0] == 'f')
1163 d->duplex = NETDEV_DUPLEX_FULL;
1164 else if (buffer[0] == 'h')
1165 d->duplex = NETDEV_DUPLEX_HALF;
1166 else
1167 d->duplex = NETDEV_DUPLEX_UNKNOWN;
1168 d->duplex_file_exists = 1;
1169 d->duplex_file_lost_time = 0;
1170 }
1171 } else {
1172 d->duplex = NETDEV_DUPLEX_UNKNOWN;
1173 }
1174
1175 if(d->do_operstate != CONFIG_BOOLEAN_NO && d->filename_operstate) {
1176 char buffer[STATE_LENGTH_MAX + 1], *trimmed_buffer;
1177
1178 if (read_txt_file(d->filename_operstate, buffer, sizeof(buffer))) {
1179 collector_error(
1180 "Cannot refresh %s operstate by reading '%s'. Will not update its status anymore.",
1181 d->name, d->filename_operstate);
1182 freez(d->filename_operstate);
1183 d->filename_operstate = NULL;
1184 } else {
1185 trimmed_buffer = trim(buffer);
1186 d->operstate = get_operstate(trimmed_buffer);
1187 }
1188 }
1189
1190 if (d->do_mtu != CONFIG_BOOLEAN_NO && d->filename_mtu) {
1191 if (read_single_number_file(d->filename_mtu, &d->mtu)) {
1192 collector_error(
1193 "Cannot refresh mtu for interface %s by reading '%s'. Stop updating it.", d->name, d->filename_mtu);
1194 freez(d->filename_mtu);
1195 d->filename_mtu = NULL;
1196 }
1197 }
1198
1199 //collector_info("PROC_NET_DEV: %s speed %zu, bytes %zu/%zu, packets %zu/%zu/%zu, errors %zu/%zu, drops %zu/%zu, fifo %zu/%zu, compressed %zu/%zu, rframe %zu, tcollisions %zu, tcarrier %zu"
1200 // , d->name, d->speed
1201 // , d->rbytes, d->tbytes
1202 // , d->rpackets, d->tpackets, d->rmulticast
1203 // , d->rerrors, d->terrors
1204 // , d->rdrops, d->tdrops
1205 // , d->rfifo, d->tfifo
1206 // , d->rcompressed, d->tcompressed
1207 // , d->rframe, d->tcollisions, d->tcarrier
1208 // );
1209
1210 if (d->do_bandwidth == CONFIG_BOOLEAN_YES || d->do_bandwidth == CONFIG_BOOLEAN_AUTO) {
1211 if(unlikely(!d->st_bandwidth)) {
1212
1213 d->st_bandwidth = rrdset_create_localhost(
1214 d->chart_type_net_bytes
1215 , d->chart_id_net_bytes
1216 , NULL
1217 , d->chart_family
1218 , d->chart_ctx_net_bytes
1219 , "Bandwidth"
1220 , "kilobits/s"
1221 , PLUGIN_PROC_NAME
1222 , PLUGIN_PROC_MODULE_NETDEV_NAME
1223 , d->priority
1224 , update_every
1225 , RRDSET_TYPE_AREA
1226 );
1227
1228 rrdset_update_rrdlabels(d->st_bandwidth, d->chart_labels);
1229
1230 d->rd_rbytes = rrddim_add(d->st_bandwidth, "received", NULL, 8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
1231 d->rd_tbytes = rrddim_add(d->st_bandwidth, "sent", NULL, -8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
1232
1233 if(d->flipped) {
1234 // flip receive/transmit
1235
1236 RRDDIM *td = d->rd_rbytes;
1237 d->rd_rbytes = d->rd_tbytes;
1238 d->rd_tbytes = td;
1239 }
1240 }
1241
1242 rrddim_set_by_pointer(d->st_bandwidth, d->rd_rbytes, (collected_number)d->rbytes);
1243 rrddim_set_by_pointer(d->st_bandwidth, d->rd_tbytes, (collected_number)d->tbytes);
1244 rrdset_done(d->st_bandwidth);
1245
1246 if(d->cgroup_netdev_link)
1247 cgroup_netdev_add_bandwidth(d->cgroup_netdev_link,
1248 d->flipped ? d->rd_tbytes->collector.last_stored_value : -d->rd_rbytes->collector.last_stored_value,
1249 d->flipped ? -d->rd_rbytes->collector.last_stored_value : d->rd_tbytes->collector.last_stored_value);
1250
1251 if(unlikely(!d->chart_var_speed)) {
1252 d->chart_var_speed = rrdvar_chart_variable_add_and_acquire(d->st_bandwidth, "nic_speed_max");
1253 if(!d->chart_var_speed) {
1254 collector_error(
1255 "Cannot create interface %s chart variable 'nic_speed_max'. Will not update its speed anymore.",
1256 d->name);
1257 }
1258 else {
1259 rrdvar_chart_variable_set(d->st_bandwidth, d->chart_var_speed, NAN);
1260 }
1261 }
1262
1263 // update the interface speed
1264 if(d->filename_speed) {
1265 if (d->filename_speed && d->chart_var_speed) {
1266 int ret = 0;
1267
1268 if ((d->carrier || d->carrier_file_exists) &&
1269 (d->speed_file_exists || now_monotonic_sec() - d->speed_file_lost_time > READ_RETRY_PERIOD)) {
1270 ret = read_single_number_file(d->filename_speed, (unsigned long long *) &d->speed);
1271 } else {
1272 d->speed = 0; // TODO: this is wrong, shouldn't use 0 value, but NULL.
1273 }
1274
1275 if(ret) {
1276 if (d->speed_file_exists)
1277 collector_error("Cannot refresh interface %s speed by reading '%s'.", d->name, d->filename_speed);
1278 d->speed_file_exists = 0;
1279 d->speed_file_lost_time = now_monotonic_sec();
1280 }
1281 else {
1282 if(d->do_speed != CONFIG_BOOLEAN_NO) {
1283 if(unlikely(!d->st_speed)) {
1284 d->st_speed = rrdset_create_localhost(
1285 d->chart_type_net_speed
1286 , d->chart_id_net_speed
1287 , NULL
1288 , d->chart_family
1289 , d->chart_ctx_net_speed
1290 , "Interface Speed"
1291 , "kilobits/s"
1292 , PLUGIN_PROC_NAME
1293 , PLUGIN_PROC_MODULE_NETDEV_NAME
1294 , d->priority + 7
1295 , update_every
1296 , RRDSET_TYPE_LINE
1297 );
1298
1299 rrdset_update_rrdlabels(d->st_speed, d->chart_labels);
1300
1301 d->rd_speed = rrddim_add(d->st_speed, "speed", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1302 }
1303
1304 rrddim_set_by_pointer(d->st_speed, d->rd_speed, (collected_number)d->speed * KILOBITS_IN_A_MEGABIT);
1305 rrdset_done(d->st_speed);
1306 }
1307
1308 rrdvar_chart_variable_set(
1309 d->st_bandwidth, d->chart_var_speed, (NETDATA_DOUBLE)d->speed * KILOBITS_IN_A_MEGABIT);
1310
1311 if (d->speed) {
1312 d->speed_file_exists = 1;
1313 d->speed_file_lost_time = 0;
1314 }
1315 }
1316 }
1317 }
1318 }
1319
1320 if(d->do_duplex != CONFIG_BOOLEAN_NO && d->filename_duplex) {
1321 if(unlikely(!d->st_duplex)) {
1322 d->st_duplex = rrdset_create_localhost(
1323 d->chart_type_net_duplex
1324 , d->chart_id_net_duplex
1325 , NULL
1326 , d->chart_family
1327 , d->chart_ctx_net_duplex
1328 , "Interface Duplex State"
1329 , "state"
1330 , PLUGIN_PROC_NAME
1331 , PLUGIN_PROC_MODULE_NETDEV_NAME
1332 , d->priority + 8
1333 , update_every
1334 , RRDSET_TYPE_LINE
1335 );
1336
1337 rrdset_update_rrdlabels(d->st_duplex, d->chart_labels);
1338
1339 d->rd_duplex_full = rrddim_add(d->st_duplex, "full", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1340 d->rd_duplex_half = rrddim_add(d->st_duplex, "half", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1341 d->rd_duplex_unknown = rrddim_add(d->st_duplex, "unknown", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1342 }
1343
1344 rrddim_set_by_pointer(d->st_duplex, d->rd_duplex_full, (collected_number)(d->duplex == NETDEV_DUPLEX_FULL));
1345 rrddim_set_by_pointer(d->st_duplex, d->rd_duplex_half, (collected_number)(d->duplex == NETDEV_DUPLEX_HALF));
1346 rrddim_set_by_pointer(d->st_duplex, d->rd_duplex_unknown, (collected_number)(d->duplex == NETDEV_DUPLEX_UNKNOWN));
1347 rrdset_done(d->st_duplex);
1348 }
1349
1350 if(d->do_operstate != CONFIG_BOOLEAN_NO && d->filename_operstate) {
1351 if(unlikely(!d->st_operstate)) {
1352 d->st_operstate = rrdset_create_localhost(
1353 d->chart_type_net_operstate
1354 , d->chart_id_net_operstate
1355 , NULL
1356 , d->chart_family
1357 , d->chart_ctx_net_operstate
1358 , "Interface Operational State"
1359 , "state"
1360 , PLUGIN_PROC_NAME
1361 , PLUGIN_PROC_MODULE_NETDEV_NAME
1362 , d->priority + 9
1363 , update_every
1364 , RRDSET_TYPE_LINE
1365 );
1366
1367 rrdset_update_rrdlabels(d->st_operstate, d->chart_labels);
1368
1369 d->rd_operstate_up = rrddim_add(d->st_operstate, "up", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1370 d->rd_operstate_down = rrddim_add(d->st_operstate, "down", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1371 d->rd_operstate_notpresent = rrddim_add(d->st_operstate, "notpresent", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1372 d->rd_operstate_lowerlayerdown = rrddim_add(d->st_operstate, "lowerlayerdown", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1373 d->rd_operstate_testing = rrddim_add(d->st_operstate, "testing", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1374 d->rd_operstate_dormant = rrddim_add(d->st_operstate, "dormant", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1375 d->rd_operstate_unknown = rrddim_add(d->st_operstate, "unknown", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1376 }
1377
1378 rrddim_set_by_pointer(d->st_operstate, d->rd_operstate_up, (collected_number)(d->operstate == NETDEV_OPERSTATE_UP));
1379 rrddim_set_by_pointer(d->st_operstate, d->rd_operstate_down, (collected_number)(d->operstate == NETDEV_OPERSTATE_DOWN));
1380 rrddim_set_by_pointer(d->st_operstate, d->rd_operstate_notpresent, (collected_number)(d->operstate == NETDEV_OPERSTATE_NOTPRESENT));
1381 rrddim_set_by_pointer(d->st_operstate, d->rd_operstate_lowerlayerdown, (collected_number)(d->operstate == NETDEV_OPERSTATE_LOWERLAYERDOWN));
1382 rrddim_set_by_pointer(d->st_operstate, d->rd_operstate_testing, (collected_number)(d->operstate == NETDEV_OPERSTATE_TESTING));
1383 rrddim_set_by_pointer(d->st_operstate, d->rd_operstate_dormant, (collected_number)(d->operstate == NETDEV_OPERSTATE_DORMANT));
1384 rrddim_set_by_pointer(d->st_operstate, d->rd_operstate_unknown, (collected_number)(d->operstate == NETDEV_OPERSTATE_UNKNOWN));
1385 rrdset_done(d->st_operstate);
1386 }
1387
1388 if(d->do_carrier != CONFIG_BOOLEAN_NO && d->carrier_file_exists) {
1389 if(unlikely(!d->st_carrier)) {
1390 d->st_carrier = rrdset_create_localhost(
1391 d->chart_type_net_carrier
1392 , d->chart_id_net_carrier
1393 , NULL
1394 , d->chart_family
1395 , d->chart_ctx_net_carrier
1396 , "Interface Physical Link State"
1397 , "state"
1398 , PLUGIN_PROC_NAME
1399 , PLUGIN_PROC_MODULE_NETDEV_NAME
1400 , d->priority + 10
1401 , update_every
1402 , RRDSET_TYPE_LINE
1403 );
1404
1405 rrdset_update_rrdlabels(d->st_carrier, d->chart_labels);
1406
1407 d->rd_carrier_up = rrddim_add(d->st_carrier, "up", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1408 d->rd_carrier_down = rrddim_add(d->st_carrier, "down", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1409 }
1410
1411 rrddim_set_by_pointer(d->st_carrier, d->rd_carrier_up, (collected_number)(d->carrier == 1));
1412 rrddim_set_by_pointer(d->st_carrier, d->rd_carrier_down, (collected_number)(d->carrier != 1));
1413 rrdset_done(d->st_carrier);
1414 }
1415
1416 if(d->do_mtu != CONFIG_BOOLEAN_NO && d->filename_mtu) {
1417 if(unlikely(!d->st_mtu)) {
1418 d->st_mtu = rrdset_create_localhost(
1419 d->chart_type_net_mtu
1420 , d->chart_id_net_mtu
1421 , NULL
1422 , d->chart_family
1423 , d->chart_ctx_net_mtu
1424 , "Interface MTU"
1425 , "octets"
1426 , PLUGIN_PROC_NAME
1427 , PLUGIN_PROC_MODULE_NETDEV_NAME
1428 , d->priority + 11
1429 , update_every
1430 , RRDSET_TYPE_LINE
1431 );
1432
1433 rrdset_update_rrdlabels(d->st_mtu, d->chart_labels);
1434
1435 d->rd_mtu = rrddim_add(d->st_mtu, "mtu", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1436 }
1437
1438 rrddim_set_by_pointer(d->st_mtu, d->rd_mtu, (collected_number)d->mtu);
1439 rrdset_done(d->st_mtu);
1440 }
1441
1442 if (d->do_packets == CONFIG_BOOLEAN_YES || d->do_packets == CONFIG_BOOLEAN_AUTO) {
1443 if(unlikely(!d->st_packets)) {
1444
1445 d->st_packets = rrdset_create_localhost(
1446 d->chart_type_net_packets
1447 , d->chart_id_net_packets
1448 , NULL
1449 , d->chart_family
1450 , d->chart_ctx_net_packets
1451 , "Packets"
1452 , "packets/s"
1453 , PLUGIN_PROC_NAME
1454 , PLUGIN_PROC_MODULE_NETDEV_NAME
1455 , d->priority + 1
1456 , update_every
1457 , RRDSET_TYPE_LINE
1458 );
1459
1460 rrdset_update_rrdlabels(d->st_packets, d->chart_labels);
1461
1462 d->rd_rpackets = rrddim_add(d->st_packets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1463 d->rd_tpackets = rrddim_add(d->st_packets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1464 d->rd_rmulticast = rrddim_add(d->st_packets, "multicast", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1465
1466 if(d->flipped) {
1467 // flip receive/transmit
1468
1469 RRDDIM *td = d->rd_rpackets;
1470 d->rd_rpackets = d->rd_tpackets;
1471 d->rd_tpackets = td;
1472 }
1473 }
1474
1475 rrddim_set_by_pointer(d->st_packets, d->rd_rpackets, (collected_number)d->rpackets);
1476 rrddim_set_by_pointer(d->st_packets, d->rd_tpackets, (collected_number)d->tpackets);
1477 rrddim_set_by_pointer(d->st_packets, d->rd_rmulticast, (collected_number)d->rmulticast);
1478 rrdset_done(d->st_packets);
1479 }
1480
1481 if (d->do_errors == CONFIG_BOOLEAN_YES || d->do_errors == CONFIG_BOOLEAN_AUTO) {
1482 if(unlikely(!d->st_errors)) {
1483
1484 d->st_errors = rrdset_create_localhost(
1485 d->chart_type_net_errors
1486 , d->chart_id_net_errors
1487 , NULL
1488 , d->chart_family
1489 , d->chart_ctx_net_errors
1490 , "Interface Errors"
1491 , "errors/s"
1492 , PLUGIN_PROC_NAME
1493 , PLUGIN_PROC_MODULE_NETDEV_NAME
1494 , d->priority + 2
1495 , update_every
1496 , RRDSET_TYPE_LINE
1497 );
1498
1499 rrdset_update_rrdlabels(d->st_errors, d->chart_labels);
1500
1501 d->rd_rerrors = rrddim_add(d->st_errors, "inbound", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1502 d->rd_terrors = rrddim_add(d->st_errors, "outbound", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1503
1504 if(d->flipped) {
1505 // flip receive/transmit
1506
1507 RRDDIM *td = d->rd_rerrors;
1508 d->rd_rerrors = d->rd_terrors;
1509 d->rd_terrors = td;
1510 }
1511 }
1512
1513 rrddim_set_by_pointer(d->st_errors, d->rd_rerrors, (collected_number)d->rerrors);
1514 rrddim_set_by_pointer(d->st_errors, d->rd_terrors, (collected_number)d->terrors);
1515 rrdset_done(d->st_errors);
1516 }
1517
1518 if (d->do_drops == CONFIG_BOOLEAN_YES || d->do_drops == CONFIG_BOOLEAN_AUTO) {
1519 if(unlikely(!d->st_drops)) {
1520
1521 d->st_drops = rrdset_create_localhost(
1522 d->chart_type_net_drops
1523 , d->chart_id_net_drops
1524 , NULL
1525 , d->chart_family
1526 , d->chart_ctx_net_drops
1527 , "Interface Drops"
1528 , "drops/s"
1529 , PLUGIN_PROC_NAME
1530 , PLUGIN_PROC_MODULE_NETDEV_NAME
1531 , d->priority + 3
1532 , update_every
1533 , RRDSET_TYPE_LINE
1534 );
1535
1536 rrdset_update_rrdlabels(d->st_drops, d->chart_labels);
1537
1538 d->rd_rdrops = rrddim_add(d->st_drops, "inbound", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1539 d->rd_tdrops = rrddim_add(d->st_drops, "outbound", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1540
1541 if(d->flipped) {
1542 // flip receive/transmit
1543
1544 RRDDIM *td = d->rd_rdrops;
1545 d->rd_rdrops = d->rd_tdrops;
1546 d->rd_tdrops = td;
1547 }
1548 }
1549
1550 rrddim_set_by_pointer(d->st_drops, d->rd_rdrops, (collected_number)d->rdrops);
1551 rrddim_set_by_pointer(d->st_drops, d->rd_tdrops, (collected_number)d->tdrops);
1552 rrdset_done(d->st_drops);
1553 }
1554
1555 if (d->do_fifo == CONFIG_BOOLEAN_YES || d->do_fifo == CONFIG_BOOLEAN_AUTO) {
1556 if(unlikely(!d->st_fifo)) {
1557
1558 d->st_fifo = rrdset_create_localhost(
1559 d->chart_type_net_fifo
1560 , d->chart_id_net_fifo
1561 , NULL
1562 , d->chart_family
1563 , d->chart_ctx_net_fifo
1564 , "Interface FIFO Buffer Errors"
1565 , "errors"
1566 , PLUGIN_PROC_NAME
1567 , PLUGIN_PROC_MODULE_NETDEV_NAME
1568 , d->priority + 4
1569 , update_every
1570 , RRDSET_TYPE_LINE
1571 );
1572
1573 rrdset_update_rrdlabels(d->st_fifo, d->chart_labels);
1574
1575 d->rd_rfifo = rrddim_add(d->st_fifo, "receive", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1576 d->rd_tfifo = rrddim_add(d->st_fifo, "transmit", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1577
1578 if(d->flipped) {
1579 // flip receive/transmit
1580
1581 RRDDIM *td = d->rd_rfifo;
1582 d->rd_rfifo = d->rd_tfifo;
1583 d->rd_tfifo = td;
1584 }
1585 }
1586
1587 rrddim_set_by_pointer(d->st_fifo, d->rd_rfifo, (collected_number)d->rfifo);
1588 rrddim_set_by_pointer(d->st_fifo, d->rd_tfifo, (collected_number)d->tfifo);
1589 rrdset_done(d->st_fifo);
1590 }
1591
1592 if (d->do_compressed == CONFIG_BOOLEAN_YES || d->do_compressed == CONFIG_BOOLEAN_AUTO) {
1593 if(unlikely(!d->st_compressed)) {
1594
1595 d->st_compressed = rrdset_create_localhost(
1596 d->chart_type_net_compressed
1597 , d->chart_id_net_compressed
1598 , NULL
1599 , d->chart_family
1600 , d->chart_ctx_net_compressed
1601 , "Compressed Packets"
1602 , "packets/s"
1603 , PLUGIN_PROC_NAME
1604 , PLUGIN_PROC_MODULE_NETDEV_NAME
1605 , d->priority + 5
1606 , update_every
1607 , RRDSET_TYPE_LINE
1608 );
1609
1610 rrdset_update_rrdlabels(d->st_compressed, d->chart_labels);
1611
1612 d->rd_rcompressed = rrddim_add(d->st_compressed, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1613 d->rd_tcompressed = rrddim_add(d->st_compressed, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1614
1615 if(d->flipped) {
1616 // flip receive/transmit
1617
1618 RRDDIM *td = d->rd_rcompressed;
1619 d->rd_rcompressed = d->rd_tcompressed;
1620 d->rd_tcompressed = td;
1621 }
1622 }
1623
1624 rrddim_set_by_pointer(d->st_compressed, d->rd_rcompressed, (collected_number)d->rcompressed);
1625 rrddim_set_by_pointer(d->st_compressed, d->rd_tcompressed, (collected_number)d->tcompressed);
1626 rrdset_done(d->st_compressed);
1627 }
1628
1629 if (d->do_events == CONFIG_BOOLEAN_YES || d->do_events == CONFIG_BOOLEAN_AUTO) {
1630 if(unlikely(!d->st_events)) {
1631
1632 d->st_events = rrdset_create_localhost(
1633 d->chart_type_net_events
1634 , d->chart_id_net_events
1635 , NULL
1636 , d->chart_family
1637 , d->chart_ctx_net_events
1638 , "Network Interface Events"
1639 , "events/s"
1640 , PLUGIN_PROC_NAME
1641 , PLUGIN_PROC_MODULE_NETDEV_NAME
1642 , d->priority + 6
1643 , update_every
1644 , RRDSET_TYPE_LINE
1645 );
1646
1647 rrdset_update_rrdlabels(d->st_events, d->chart_labels);
1648
1649 d->rd_rframe = rrddim_add(d->st_events, "frames", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1650 d->rd_tcollisions = rrddim_add(d->st_events, "collisions", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1651 d->rd_tcarrier = rrddim_add(d->st_events, "carrier", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1652 }
1653
1654 rrddim_set_by_pointer(d->st_events, d->rd_rframe, (collected_number)d->rframe);
1655 rrddim_set_by_pointer(d->st_events, d->rd_tcollisions, (collected_number)d->tcollisions);
1656 rrddim_set_by_pointer(d->st_events, d->rd_tcarrier, (collected_number)d->tcarrier);
1657 rrdset_done(d->st_events);
1658 }
1659
1660 d->function_ready = true;
1661 }
1662
1663 if (do_bandwidth == CONFIG_BOOLEAN_YES || do_bandwidth == CONFIG_BOOLEAN_AUTO) {
1664 do_bandwidth = CONFIG_BOOLEAN_YES;
1665 static RRDSET *st_system_net = NULL;
1666 static RRDDIM *rd_in = NULL, *rd_out = NULL;
1667
1668 if(unlikely(!st_system_net)) {
1669 st_system_net = rrdset_create_localhost(
1670 "system"
1671 , "net"
1672 , NULL
1673 , "network"
1674 , NULL
1675 , "Physical Network Interfaces Aggregated Bandwidth"
1676 , "kilobits/s"
1677 , PLUGIN_PROC_NAME
1678 , PLUGIN_PROC_MODULE_NETDEV_NAME
1679 , NETDATA_CHART_PRIO_SYSTEM_NET
1680 , update_every
1681 , RRDSET_TYPE_AREA
1682 );
1683
1684 rd_in = rrddim_add(st_system_net, "InOctets", "received", 8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
1685 rd_out = rrddim_add(st_system_net, "OutOctets", "sent", -8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
1686 }
1687
1688 rrddim_set_by_pointer(st_system_net, rd_in, (collected_number)system_rbytes);
1689 rrddim_set_by_pointer(st_system_net, rd_out, (collected_number)system_tbytes);
1690
1691 rrdset_done(st_system_net);
1692 }
1693
1694 netdev_cleanup();
1695
1696 return 0;
1697 }
1698
1699 static void netdev_main_cleanup(void *pptr) {
1700 if(CLEANUP_FUNCTION_GET_PTR(pptr) != (void *)0x01)
1701 return;
1702
1703 netdata_mutex_lock(&netdev_mutex);
1704 while(netdev_root) {
1705 struct netdev *d = netdev_root;
1706 DOUBLE_LINKED_LIST_REMOVE_ITEM_UNSAFE(netdev_root, d, prev, next);
1707 netdev_free(d);
1708 }
1709 netdata_mutex_unlock(&netdev_mutex);
1710
1711 worker_unregister();
1712 }
1713
1714 void netdev_main(void *ptr_is_null __maybe_unused)
1715 {
1716 CLEANUP_FUNCTION_REGISTER(netdev_main_cleanup) cleanup_ptr = (void *)0x01;
1717
1718 worker_register("NETDEV");
1719 worker_register_job_name(0, "netdev");
1720
1721 if (getenv("KUBERNETES_SERVICE_HOST") != NULL && getenv("KUBERNETES_SERVICE_PORT") != NULL)
1722 virtual_device_collect_delay_secs = 300;
1723
1724 rrd_function_add_inline(localhost, NULL, "network-interfaces", 10,
1725 RRDFUNCTIONS_PRIORITY_DEFAULT, RRDFUNCTIONS_VERSION_DEFAULT,
1726 RRDFUNCTIONS_NETDEV_HELP,
1727 "top", HTTP_ACCESS_ANONYMOUS_DATA,
1728 netdev_function_net_interfaces);
1729
1730 heartbeat_t hb;
1731 heartbeat_init(&hb, localhost->rrd_update_every * USEC_PER_SEC);
1732
1733 while (service_running(SERVICE_COLLECTORS)) {
1734 worker_is_idle();
1735 usec_t hb_dt = heartbeat_next(&hb);
1736
1737 if (unlikely(!service_running(SERVICE_COLLECTORS)))
1738 break;
1739
1740 cgroup_netdev_reset_all();
1741
1742 worker_is_busy(0);
1743
1744 netdata_mutex_lock(&netdev_mutex);
1745 int ret = do_proc_net_dev(localhost->rrd_update_every, hb_dt);
1746 netdata_mutex_unlock(&netdev_mutex);
1747 if (ret)
1748 break;
1749 }
1750 }