1 /*
2 * tc_util.c Misc TC utility functions.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
8 *
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 *
11 */
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <unistd.h>
16 #include <syslog.h>
17 #include <fcntl.h>
18 #include <sys/socket.h>
19 #include <sys/param.h>
20 #include <netinet/in.h>
21 #include <arpa/inet.h>
22 #include <string.h>
23 #include <math.h>
24 #include <errno.h>
25
26 #include "utils.h"
27 #include "names.h"
28 #include "tc_util.h"
29 #include "tc_common.h"
30
31 #ifndef LIBDIR
32 #define LIBDIR "/usr/lib"
33 #endif
34
35 static struct db_names *cls_names;
36
37 #define NAMES_DB "/etc/iproute2/tc_cls"
38
cls_names_init(char * path)39 int cls_names_init(char *path)
40 {
41 int ret;
42
43 cls_names = db_names_alloc();
44 if (!cls_names)
45 return -1;
46
47 ret = db_names_load(cls_names, path ?: NAMES_DB);
48 if (ret == -ENOENT && path) {
49 fprintf(stderr, "Can't open class names file: %s\n", path);
50 return -1;
51 }
52 if (ret) {
53 db_names_free(cls_names);
54 cls_names = NULL;
55 }
56
57 return 0;
58 }
59
cls_names_uninit(void)60 void cls_names_uninit(void)
61 {
62 db_names_free(cls_names);
63 }
64
get_tc_lib(void)65 const char *get_tc_lib(void)
66 {
67 const char *lib_dir;
68
69 lib_dir = getenv("TC_LIB_DIR");
70 if (!lib_dir)
71 lib_dir = LIBDIR "/tc/";
72
73 return lib_dir;
74 }
75
get_qdisc_handle(__u32 * h,const char * str)76 int get_qdisc_handle(__u32 *h, const char *str)
77 {
78 __u32 maj;
79 char *p;
80
81 maj = TC_H_UNSPEC;
82 if (strcmp(str, "none") == 0)
83 goto ok;
84 maj = strtoul(str, &p, 16);
85 if (p == str || maj >= (1 << 16))
86 return -1;
87 maj <<= 16;
88 if (*p != ':' && *p != 0)
89 return -1;
90 ok:
91 *h = maj;
92 return 0;
93 }
94
get_tc_classid(__u32 * h,const char * str)95 int get_tc_classid(__u32 *h, const char *str)
96 {
97 __u32 maj, min;
98 char *p;
99
100 maj = TC_H_ROOT;
101 if (strcmp(str, "root") == 0)
102 goto ok;
103 maj = TC_H_UNSPEC;
104 if (strcmp(str, "none") == 0)
105 goto ok;
106 maj = strtoul(str, &p, 16);
107 if (p == str) {
108 maj = 0;
109 if (*p != ':')
110 return -1;
111 }
112 if (*p == ':') {
113 if (maj >= (1<<16))
114 return -1;
115 maj <<= 16;
116 str = p+1;
117 min = strtoul(str, &p, 16);
118 if (*p != 0)
119 return -1;
120 if (min >= (1<<16))
121 return -1;
122 maj |= min;
123 } else if (*p != 0)
124 return -1;
125
126 ok:
127 *h = maj;
128 return 0;
129 }
130
print_tc_classid(char * buf,int blen,__u32 h)131 int print_tc_classid(char *buf, int blen, __u32 h)
132 {
133 SPRINT_BUF(handle) = {};
134 int hlen = SPRINT_BSIZE - 1;
135
136 if (h == TC_H_ROOT)
137 sprintf(handle, "root");
138 else if (h == TC_H_UNSPEC)
139 snprintf(handle, hlen, "none");
140 else if (TC_H_MAJ(h) == 0)
141 snprintf(handle, hlen, ":%x", TC_H_MIN(h));
142 else if (TC_H_MIN(h) == 0)
143 snprintf(handle, hlen, "%x:", TC_H_MAJ(h) >> 16);
144 else
145 snprintf(handle, hlen, "%x:%x", TC_H_MAJ(h) >> 16, TC_H_MIN(h));
146
147 if (use_names) {
148 char clname[IDNAME_MAX] = {};
149
150 if (id_to_name(cls_names, h, clname))
151 snprintf(buf, blen, "%s#%s", clname, handle);
152 else
153 snprintf(buf, blen, "%s", handle);
154 } else {
155 snprintf(buf, blen, "%s", handle);
156 }
157
158 return 0;
159 }
160
sprint_tc_classid(__u32 h,char * buf)161 char *sprint_tc_classid(__u32 h, char *buf)
162 {
163 if (print_tc_classid(buf, SPRINT_BSIZE-1, h))
164 strcpy(buf, "???");
165 return buf;
166 }
167
168 /* See http://physics.nist.gov/cuu/Units/binary.html */
169 static const struct rate_suffix {
170 const char *name;
171 double scale;
172 } suffixes[] = {
173 { "bit", 1. },
174 { "Kibit", 1024. },
175 { "kbit", 1000. },
176 { "mibit", 1024.*1024. },
177 { "mbit", 1000000. },
178 { "gibit", 1024.*1024.*1024. },
179 { "gbit", 1000000000. },
180 { "tibit", 1024.*1024.*1024.*1024. },
181 { "tbit", 1000000000000. },
182 { "Bps", 8. },
183 { "KiBps", 8.*1024. },
184 { "KBps", 8000. },
185 { "MiBps", 8.*1024*1024. },
186 { "MBps", 8000000. },
187 { "GiBps", 8.*1024.*1024.*1024. },
188 { "GBps", 8000000000. },
189 { "TiBps", 8.*1024.*1024.*1024.*1024. },
190 { "TBps", 8000000000000. },
191 { NULL }
192 };
193
194
get_rate(unsigned int * rate,const char * str)195 int get_rate(unsigned int *rate, const char *str)
196 {
197 char *p;
198 double bps = strtod(str, &p);
199 const struct rate_suffix *s;
200
201 if (p == str)
202 return -1;
203
204 for (s = suffixes; s->name; ++s) {
205 if (strcasecmp(s->name, p) == 0) {
206 bps *= s->scale;
207 p += strlen(p);
208 break;
209 }
210 }
211
212 if (*p)
213 return -1; /* unknown suffix */
214
215 bps /= 8; /* -> bytes per second */
216 *rate = bps;
217 /* detect if an overflow happened */
218 if (*rate != floor(bps))
219 return -1;
220 return 0;
221 }
222
get_rate64(__u64 * rate,const char * str)223 int get_rate64(__u64 *rate, const char *str)
224 {
225 char *p;
226 double bps = strtod(str, &p);
227 const struct rate_suffix *s;
228
229 if (p == str)
230 return -1;
231
232 for (s = suffixes; s->name; ++s) {
233 if (strcasecmp(s->name, p) == 0) {
234 bps *= s->scale;
235 p += strlen(p);
236 break;
237 }
238 }
239
240 if (*p)
241 return -1; /* unknown suffix */
242
243 bps /= 8; /* -> bytes per second */
244 *rate = bps;
245 return 0;
246 }
247
print_rate(char * buf,int len,__u64 rate)248 void print_rate(char *buf, int len, __u64 rate)
249 {
250 extern int use_iec;
251 unsigned long kilo = use_iec ? 1024 : 1000;
252 const char *str = use_iec ? "i" : "";
253 static char *units[5] = {"", "K", "M", "G", "T"};
254 int i;
255
256 rate <<= 3; /* bytes/sec -> bits/sec */
257
258 for (i = 0; i < ARRAY_SIZE(units) - 1; i++) {
259 if (rate < kilo)
260 break;
261 if (((rate % kilo) != 0) && rate < 1000*kilo)
262 break;
263 rate /= kilo;
264 }
265
266 snprintf(buf, len, "%.0f%s%sbit", (double)rate, units[i], str);
267 }
268
sprint_rate(__u64 rate,char * buf)269 char *sprint_rate(__u64 rate, char *buf)
270 {
271 print_rate(buf, SPRINT_BSIZE-1, rate);
272 return buf;
273 }
274
get_time(unsigned int * time,const char * str)275 int get_time(unsigned int *time, const char *str)
276 {
277 double t;
278 char *p;
279
280 t = strtod(str, &p);
281 if (p == str)
282 return -1;
283
284 if (*p) {
285 if (strcasecmp(p, "s") == 0 || strcasecmp(p, "sec") == 0 ||
286 strcasecmp(p, "secs") == 0)
287 t *= TIME_UNITS_PER_SEC;
288 else if (strcasecmp(p, "ms") == 0 || strcasecmp(p, "msec") == 0 ||
289 strcasecmp(p, "msecs") == 0)
290 t *= TIME_UNITS_PER_SEC/1000;
291 else if (strcasecmp(p, "us") == 0 || strcasecmp(p, "usec") == 0 ||
292 strcasecmp(p, "usecs") == 0)
293 t *= TIME_UNITS_PER_SEC/1000000;
294 else
295 return -1;
296 }
297
298 *time = t;
299 return 0;
300 }
301
302
print_time(char * buf,int len,__u32 time)303 void print_time(char *buf, int len, __u32 time)
304 {
305 double tmp = time;
306
307 if (tmp >= TIME_UNITS_PER_SEC)
308 snprintf(buf, len, "%.1fs", tmp/TIME_UNITS_PER_SEC);
309 else if (tmp >= TIME_UNITS_PER_SEC/1000)
310 snprintf(buf, len, "%.1fms", tmp/(TIME_UNITS_PER_SEC/1000));
311 else
312 snprintf(buf, len, "%uus", time);
313 }
314
sprint_time(__u32 time,char * buf)315 char *sprint_time(__u32 time, char *buf)
316 {
317 print_time(buf, SPRINT_BSIZE-1, time);
318 return buf;
319 }
320
sprint_ticks(__u32 ticks,char * buf)321 char *sprint_ticks(__u32 ticks, char *buf)
322 {
323 return sprint_time(tc_core_tick2time(ticks), buf);
324 }
325
get_size(unsigned int * size,const char * str)326 int get_size(unsigned int *size, const char *str)
327 {
328 double sz;
329 char *p;
330
331 sz = strtod(str, &p);
332 if (p == str)
333 return -1;
334
335 if (*p) {
336 if (strcasecmp(p, "kb") == 0 || strcasecmp(p, "k") == 0)
337 sz *= 1024;
338 else if (strcasecmp(p, "gb") == 0 || strcasecmp(p, "g") == 0)
339 sz *= 1024*1024*1024;
340 else if (strcasecmp(p, "gbit") == 0)
341 sz *= 1024*1024*1024/8;
342 else if (strcasecmp(p, "mb") == 0 || strcasecmp(p, "m") == 0)
343 sz *= 1024*1024;
344 else if (strcasecmp(p, "mbit") == 0)
345 sz *= 1024*1024/8;
346 else if (strcasecmp(p, "kbit") == 0)
347 sz *= 1024/8;
348 else if (strcasecmp(p, "b") != 0)
349 return -1;
350 }
351
352 *size = sz;
353 return 0;
354 }
355
get_size_and_cell(unsigned int * size,int * cell_log,char * str)356 int get_size_and_cell(unsigned int *size, int *cell_log, char *str)
357 {
358 char *slash = strchr(str, '/');
359
360 if (slash)
361 *slash = 0;
362
363 if (get_size(size, str))
364 return -1;
365
366 if (slash) {
367 int cell;
368 int i;
369
370 if (get_integer(&cell, slash+1, 0))
371 return -1;
372 *slash = '/';
373
374 for (i = 0; i < 32; i++) {
375 if ((1<<i) == cell) {
376 *cell_log = i;
377 return 0;
378 }
379 }
380 return -1;
381 }
382 return 0;
383 }
384
print_size(char * buf,int len,__u32 sz)385 void print_size(char *buf, int len, __u32 sz)
386 {
387 double tmp = sz;
388
389 if (sz >= 1024*1024 && fabs(1024*1024*rint(tmp/(1024*1024)) - sz) < 1024)
390 snprintf(buf, len, "%gMb", rint(tmp/(1024*1024)));
391 else if (sz >= 1024 && fabs(1024*rint(tmp/1024) - sz) < 16)
392 snprintf(buf, len, "%gKb", rint(tmp/1024));
393 else
394 snprintf(buf, len, "%ub", sz);
395 }
396
sprint_size(__u32 size,char * buf)397 char *sprint_size(__u32 size, char *buf)
398 {
399 print_size(buf, SPRINT_BSIZE-1, size);
400 return buf;
401 }
402
print_qdisc_handle(char * buf,int len,__u32 h)403 void print_qdisc_handle(char *buf, int len, __u32 h)
404 {
405 snprintf(buf, len, "%x:", TC_H_MAJ(h)>>16);
406 }
407
sprint_qdisc_handle(__u32 h,char * buf)408 char *sprint_qdisc_handle(__u32 h, char *buf)
409 {
410 print_qdisc_handle(buf, SPRINT_BSIZE-1, h);
411 return buf;
412 }
413
action_n2a(int action)414 static const char *action_n2a(int action)
415 {
416 static char buf[64];
417
418 if (TC_ACT_EXT_CMP(action, TC_ACT_GOTO_CHAIN))
419 return "goto";
420 if (TC_ACT_EXT_CMP(action, TC_ACT_JUMP))
421 return "jump";
422 switch (action) {
423 case TC_ACT_UNSPEC:
424 return "continue";
425 case TC_ACT_OK:
426 return "pass";
427 case TC_ACT_SHOT:
428 return "drop";
429 case TC_ACT_RECLASSIFY:
430 return "reclassify";
431 case TC_ACT_PIPE:
432 return "pipe";
433 case TC_ACT_STOLEN:
434 return "stolen";
435 case TC_ACT_TRAP:
436 return "trap";
437 default:
438 snprintf(buf, 64, "%d", action);
439 return buf;
440 }
441 }
442
443 /* Convert action branch name into numeric format.
444 *
445 * Parameters:
446 * @arg - string to parse
447 * @result - pointer to output variable
448 * @allow_num - whether @arg may be in numeric format already
449 *
450 * In error case, returns -1 and does not touch @result. Otherwise returns 0.
451 */
action_a2n(char * arg,int * result,bool allow_num)452 static int action_a2n(char *arg, int *result, bool allow_num)
453 {
454 int n;
455 char dummy;
456 struct {
457 const char *a;
458 int n;
459 } a2n[] = {
460 {"continue", TC_ACT_UNSPEC},
461 {"drop", TC_ACT_SHOT},
462 {"shot", TC_ACT_SHOT},
463 {"pass", TC_ACT_OK},
464 {"ok", TC_ACT_OK},
465 {"reclassify", TC_ACT_RECLASSIFY},
466 {"pipe", TC_ACT_PIPE},
467 {"goto", TC_ACT_GOTO_CHAIN},
468 {"jump", TC_ACT_JUMP},
469 {"trap", TC_ACT_TRAP},
470 { NULL },
471 }, *iter;
472
473 for (iter = a2n; iter->a; iter++) {
474 if (matches(arg, iter->a) != 0)
475 continue;
476 *result = iter->n;
477 return 0;
478 }
479 if (!allow_num || sscanf(arg, "%d%c", &n, &dummy) != 1)
480 return -1;
481
482 *result = n;
483 return 0;
484 }
485
__parse_action_control(int * argc_p,char *** argv_p,int * result_p,bool allow_num,bool ignore_a2n_miss)486 static int __parse_action_control(int *argc_p, char ***argv_p, int *result_p,
487 bool allow_num, bool ignore_a2n_miss)
488 {
489 int argc = *argc_p;
490 char **argv = *argv_p;
491 int result;
492
493 if (!argc)
494 return -1;
495 if (action_a2n(*argv, &result, allow_num) == -1) {
496 if (!ignore_a2n_miss)
497 fprintf(stderr, "Bad action type %s\n", *argv);
498 return -1;
499 }
500 if (result == TC_ACT_GOTO_CHAIN) {
501 __u32 chain_index;
502
503 NEXT_ARG();
504 if (matches(*argv, "chain") != 0) {
505 fprintf(stderr, "\"chain index\" expected\n");
506 return -1;
507 }
508 NEXT_ARG();
509 if (get_u32(&chain_index, *argv, 10) ||
510 chain_index > TC_ACT_EXT_VAL_MASK) {
511 fprintf(stderr, "Illegal \"chain index\"\n");
512 return -1;
513 }
514 result |= chain_index;
515 }
516 if (result == TC_ACT_JUMP) {
517 __u32 jump_cnt = 0;
518
519 NEXT_ARG();
520 if (get_u32(&jump_cnt, *argv, 10) ||
521 jump_cnt > TC_ACT_EXT_VAL_MASK) {
522 fprintf(stderr, "Invalid \"jump count\" (%s)\n", *argv);
523 return -1;
524 }
525 result |= jump_cnt;
526 }
527 NEXT_ARG_FWD();
528 *argc_p = argc;
529 *argv_p = argv;
530 *result_p = result;
531 return 0;
532 }
533
534 /* Parse action control including possible options.
535 *
536 * Parameters:
537 * @argc_p - pointer to argc to parse
538 * @argv_p - pointer to argv to parse
539 * @result_p - pointer to output variable
540 * @allow_num - whether action may be in numeric format already
541 *
542 * In error case, returns -1 and does not touch @result_1p. Otherwise returns 0.
543 */
parse_action_control(int * argc_p,char *** argv_p,int * result_p,bool allow_num)544 int parse_action_control(int *argc_p, char ***argv_p,
545 int *result_p, bool allow_num)
546 {
547 return __parse_action_control(argc_p, argv_p, result_p,
548 allow_num, false);
549 }
550
551 /* Parse action control including possible options.
552 *
553 * Parameters:
554 * @argc_p - pointer to argc to parse
555 * @argv_p - pointer to argv to parse
556 * @result_p - pointer to output variable
557 * @allow_num - whether action may be in numeric format already
558 * @default_result - set as a result in case of parsing error
559 *
560 * In case there is an error during parsing, the default result is used.
561 */
parse_action_control_dflt(int * argc_p,char *** argv_p,int * result_p,bool allow_num,int default_result)562 void parse_action_control_dflt(int *argc_p, char ***argv_p,
563 int *result_p, bool allow_num,
564 int default_result)
565 {
566 if (__parse_action_control(argc_p, argv_p, result_p, allow_num, true))
567 *result_p = default_result;
568 }
569
parse_action_control_slash_spaces(int * argc_p,char *** argv_p,int * result1_p,int * result2_p,bool allow_num)570 static int parse_action_control_slash_spaces(int *argc_p, char ***argv_p,
571 int *result1_p, int *result2_p,
572 bool allow_num)
573 {
574 int argc = *argc_p;
575 char **argv = *argv_p;
576 int result1, result2;
577 int *result_p = &result1;
578 int ok = 0;
579 int ret;
580
581 while (argc > 0) {
582 switch (ok) {
583 case 1:
584 if (strcmp(*argv, "/") != 0)
585 goto out;
586 result_p = &result2;
587 NEXT_ARG();
588 /* fall-through */
589 case 0: /* fall-through */
590 case 2:
591 ret = parse_action_control(&argc, &argv,
592 result_p, allow_num);
593 if (ret)
594 return ret;
595 ok++;
596 break;
597 default:
598 goto out;
599 }
600 }
601 out:
602 *result1_p = result1;
603 if (ok == 2)
604 *result2_p = result2;
605 *argc_p = argc;
606 *argv_p = argv;
607 return 0;
608 }
609
610 /* Parse action control with slash including possible options.
611 *
612 * Parameters:
613 * @argc_p - pointer to argc to parse
614 * @argv_p - pointer to argv to parse
615 * @result1_p - pointer to the first (before slash) output variable
616 * @result2_p - pointer to the second (after slash) output variable
617 * @allow_num - whether action may be in numeric format already
618 *
619 * In error case, returns -1 and does not touch @result*. Otherwise returns 0.
620 */
parse_action_control_slash(int * argc_p,char *** argv_p,int * result1_p,int * result2_p,bool allow_num)621 int parse_action_control_slash(int *argc_p, char ***argv_p,
622 int *result1_p, int *result2_p, bool allow_num)
623 {
624 char **argv = *argv_p;
625 int result1, result2;
626 char *p = strchr(*argv, '/');
627
628 if (!p)
629 return parse_action_control_slash_spaces(argc_p, argv_p,
630 result1_p, result2_p,
631 allow_num);
632 *p = 0;
633 if (action_a2n(*argv, &result1, allow_num)) {
634 if (p)
635 *p = '/';
636 return -1;
637 }
638
639 *p = '/';
640 if (action_a2n(p + 1, &result2, allow_num))
641 return -1;
642
643 *result1_p = result1;
644 *result2_p = result2;
645 return 0;
646 }
647
print_action_control(FILE * f,const char * prefix,int action,const char * suffix)648 void print_action_control(FILE *f, const char *prefix,
649 int action, const char *suffix)
650 {
651 fprintf(f, "%s%s", prefix, action_n2a(action));
652 if (TC_ACT_EXT_CMP(action, TC_ACT_GOTO_CHAIN))
653 fprintf(f, " chain %u", action & TC_ACT_EXT_VAL_MASK);
654 if (TC_ACT_EXT_CMP(action, TC_ACT_JUMP))
655 fprintf(f, " %u", action & TC_ACT_EXT_VAL_MASK);
656 fprintf(f, "%s", suffix);
657 }
658
get_linklayer(unsigned int * val,const char * arg)659 int get_linklayer(unsigned int *val, const char *arg)
660 {
661 int res;
662
663 if (matches(arg, "ethernet") == 0)
664 res = LINKLAYER_ETHERNET;
665 else if (matches(arg, "atm") == 0)
666 res = LINKLAYER_ATM;
667 else if (matches(arg, "adsl") == 0)
668 res = LINKLAYER_ATM;
669 else
670 return -1; /* Indicate error */
671
672 *val = res;
673 return 0;
674 }
675
print_linklayer(char * buf,int len,unsigned int linklayer)676 void print_linklayer(char *buf, int len, unsigned int linklayer)
677 {
678 switch (linklayer) {
679 case LINKLAYER_UNSPEC:
680 snprintf(buf, len, "%s", "unspec");
681 return;
682 case LINKLAYER_ETHERNET:
683 snprintf(buf, len, "%s", "ethernet");
684 return;
685 case LINKLAYER_ATM:
686 snprintf(buf, len, "%s", "atm");
687 return;
688 default:
689 snprintf(buf, len, "%s", "unknown");
690 return;
691 }
692 }
693
sprint_linklayer(unsigned int linklayer,char * buf)694 char *sprint_linklayer(unsigned int linklayer, char *buf)
695 {
696 print_linklayer(buf, SPRINT_BSIZE-1, linklayer);
697 return buf;
698 }
699
print_tm(FILE * f,const struct tcf_t * tm)700 void print_tm(FILE *f, const struct tcf_t *tm)
701 {
702 int hz = get_user_hz();
703
704 if (tm->install != 0)
705 fprintf(f, " installed %u sec", (unsigned int)(tm->install/hz));
706 if (tm->lastuse != 0)
707 fprintf(f, " used %u sec", (unsigned int)(tm->lastuse/hz));
708 if (tm->expires != 0)
709 fprintf(f, " expires %u sec", (unsigned int)(tm->expires/hz));
710 }
711
print_tcstats2_attr(FILE * fp,struct rtattr * rta,char * prefix,struct rtattr ** xstats)712 void print_tcstats2_attr(FILE *fp, struct rtattr *rta, char *prefix, struct rtattr **xstats)
713 {
714 SPRINT_BUF(b1);
715 struct rtattr *tbs[TCA_STATS_MAX + 1];
716
717 parse_rtattr_nested(tbs, TCA_STATS_MAX, rta);
718
719 if (tbs[TCA_STATS_BASIC]) {
720 struct gnet_stats_basic bs = {0};
721
722 memcpy(&bs, RTA_DATA(tbs[TCA_STATS_BASIC]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_BASIC]), sizeof(bs)));
723 fprintf(fp, "%sSent %llu bytes %u pkt",
724 prefix, (unsigned long long) bs.bytes, bs.packets);
725 }
726
727 if (tbs[TCA_STATS_QUEUE]) {
728 struct gnet_stats_queue q = {0};
729
730 memcpy(&q, RTA_DATA(tbs[TCA_STATS_QUEUE]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_QUEUE]), sizeof(q)));
731 fprintf(fp, " (dropped %u, overlimits %u requeues %u) ",
732 q.drops, q.overlimits, q.requeues);
733 }
734
735 if (tbs[TCA_STATS_RATE_EST64]) {
736 struct gnet_stats_rate_est64 re = {0};
737
738 memcpy(&re, RTA_DATA(tbs[TCA_STATS_RATE_EST64]),
739 MIN(RTA_PAYLOAD(tbs[TCA_STATS_RATE_EST64]),
740 sizeof(re)));
741 fprintf(fp, "\n%srate %s %llupps ",
742 prefix, sprint_rate(re.bps, b1), re.pps);
743 } else if (tbs[TCA_STATS_RATE_EST]) {
744 struct gnet_stats_rate_est re = {0};
745
746 memcpy(&re, RTA_DATA(tbs[TCA_STATS_RATE_EST]),
747 MIN(RTA_PAYLOAD(tbs[TCA_STATS_RATE_EST]), sizeof(re)));
748 fprintf(fp, "\n%srate %s %upps ",
749 prefix, sprint_rate(re.bps, b1), re.pps);
750 }
751
752 if (tbs[TCA_STATS_QUEUE]) {
753 struct gnet_stats_queue q = {0};
754
755 memcpy(&q, RTA_DATA(tbs[TCA_STATS_QUEUE]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_QUEUE]), sizeof(q)));
756 if (!tbs[TCA_STATS_RATE_EST])
757 fprintf(fp, "\n%s", prefix);
758 fprintf(fp, "backlog %s %up requeues %u ",
759 sprint_size(q.backlog, b1), q.qlen, q.requeues);
760 }
761
762 if (xstats)
763 *xstats = tbs[TCA_STATS_APP] ? : NULL;
764 }
765
print_tcstats_attr(FILE * fp,struct rtattr * tb[],char * prefix,struct rtattr ** xstats)766 void print_tcstats_attr(FILE *fp, struct rtattr *tb[], char *prefix, struct rtattr **xstats)
767 {
768 SPRINT_BUF(b1);
769
770 if (tb[TCA_STATS2]) {
771 print_tcstats2_attr(fp, tb[TCA_STATS2], prefix, xstats);
772 if (xstats && NULL == *xstats)
773 goto compat_xstats;
774 return;
775 }
776 /* backward compatibility */
777 if (tb[TCA_STATS]) {
778 struct tc_stats st = {};
779
780 /* handle case where kernel returns more/less than we know about */
781 memcpy(&st, RTA_DATA(tb[TCA_STATS]), MIN(RTA_PAYLOAD(tb[TCA_STATS]), sizeof(st)));
782
783 fprintf(fp, "%sSent %llu bytes %u pkts (dropped %u, overlimits %u) ",
784 prefix, (unsigned long long)st.bytes, st.packets, st.drops,
785 st.overlimits);
786
787 if (st.bps || st.pps || st.qlen || st.backlog) {
788 fprintf(fp, "\n%s", prefix);
789 if (st.bps || st.pps) {
790 fprintf(fp, "rate ");
791 if (st.bps)
792 fprintf(fp, "%s ", sprint_rate(st.bps, b1));
793 if (st.pps)
794 fprintf(fp, "%upps ", st.pps);
795 }
796 if (st.qlen || st.backlog) {
797 fprintf(fp, "backlog ");
798 if (st.backlog)
799 fprintf(fp, "%s ", sprint_size(st.backlog, b1));
800 if (st.qlen)
801 fprintf(fp, "%up ", st.qlen);
802 }
803 }
804 }
805
806 compat_xstats:
807 if (tb[TCA_XSTATS] && xstats)
808 *xstats = tb[TCA_XSTATS];
809 }
810