tc/tc_util.c

   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
  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
  60 void cls_names_uninit(void)
  61 {
  62         db_names_free(cls_names);
  63 }
  64
  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
  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
  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
 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
 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
 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
 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
 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
 269 char *sprint_rate(__u64 rate, char *buf)
 270 {
 271         print_rate(buf, SPRINT_BSIZE-1, rate);
 272         return buf;
 273 }
 274
 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
 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
 315 char *sprint_time(__u32 time, char *buf)
 316 {
 317         print_time(buf, SPRINT_BSIZE-1, time);
 318         return buf;
 319 }
 320
 321 char *sprint_ticks(__u32 ticks, char *buf)
 322 {
 323         return sprint_time(tc_core_tick2time(ticks), buf);
 324 }
 325
 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
 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
 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
 397 char *sprint_size(__u32 size, char *buf)
 398 {
 399         print_size(buf, SPRINT_BSIZE-1, size);
 400         return buf;
 401 }
 402
 403 void print_qdisc_handle(char *buf, int len, __u32 h)
 404 {
 405         snprintf(buf, len, "%x:", TC_H_MAJ(h)>>16);
 406 }
 407
 408 char *sprint_qdisc_handle(__u32 h, char *buf)
 409 {
 410         print_qdisc_handle(buf, SPRINT_BSIZE-1, h);
 411         return buf;
 412 }
 413
 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         switch (action) {
 421         case TC_ACT_UNSPEC:
 422                 return "continue";
 423         case TC_ACT_OK:
 424                 return "pass";
 425         case TC_ACT_SHOT:
 426                 return "drop";
 427         case TC_ACT_RECLASSIFY:
 428                 return "reclassify";
 429         case TC_ACT_PIPE:
 430                 return "pipe";
 431         case TC_ACT_STOLEN:
 432                 return "stolen";
 433         case TC_ACT_TRAP:
 434                 return "trap";
 435         default:
 436                 snprintf(buf, 64, "%d", action);
 437                 buf[63] = '\0';
 438                 return buf;
 439         }
 440 }
 441
 442 /* Convert action branch name into numeric format.
 443  *
 444  * Parameters:
 445  * @arg - string to parse
 446  * @result - pointer to output variable
 447  * @allow_num - whether @arg may be in numeric format already
 448  *
 449  * In error case, returns -1 and does not touch @result. Otherwise returns 0.
 450  */
 451 static int action_a2n(char *arg, int *result, bool allow_num)
 452 {
 453         int n;
 454         char dummy;
 455         struct {
 456                 const char *a;
 457                 int n;
 458         } a2n[] = {
 459                 {"continue", TC_ACT_UNSPEC},
 460                 {"drop", TC_ACT_SHOT},
 461                 {"shot", TC_ACT_SHOT},
 462                 {"pass", TC_ACT_OK},
 463                 {"ok", TC_ACT_OK},
 464                 {"reclassify", TC_ACT_RECLASSIFY},
 465                 {"pipe", TC_ACT_PIPE},
 466                 {"goto", TC_ACT_GOTO_CHAIN},
 467                 {"trap", TC_ACT_TRAP},
 468                 { NULL },
 469         }, *iter;
 470
 471         for (iter = a2n; iter->a; iter++) {
 472                 if (matches(arg, iter->a) != 0)
 473                         continue;
 474                 *result = iter->n;
 475                 return 0;
 476         }
 477         if (!allow_num || sscanf(arg, "%d%c", &n, &dummy) != 1)
 478                 return -1;
 479
 480         *result = n;
 481         return 0;
 482 }
 483
 484 static int __parse_action_control(int *argc_p, char ***argv_p, int *result_p,
 485                                   bool allow_num, bool ignore_a2n_miss)
 486 {
 487         int argc = *argc_p;
 488         char **argv = *argv_p;
 489         int result;
 490
 491         if (!argc)
 492                 return -1;
 493         if (action_a2n(*argv, &result, allow_num) == -1) {
 494                 if (!ignore_a2n_miss)
 495                         fprintf(stderr, "Bad action type %s\n", *argv);
 496                 return -1;
 497         }
 498         if (result == TC_ACT_GOTO_CHAIN) {
 499                 __u32 chain_index;
 500
 501                 NEXT_ARG();
 502                 if (matches(*argv, "chain") != 0) {
 503                         fprintf(stderr, "\"chain index\" expected\n");
 504                         return -1;
 505                 }
 506                 NEXT_ARG();
 507                 if (get_u32(&chain_index, *argv, 10) ||
 508                     chain_index > TC_ACT_EXT_VAL_MASK) {
 509                         fprintf(stderr, "Illegal \"chain index\"\n");
 510                         return -1;
 511                 }
 512                 result |= chain_index;
 513         }
 514         NEXT_ARG_FWD();
 515         *argc_p = argc;
 516         *argv_p = argv;
 517         *result_p = result;
 518         return 0;
 519 }
 520
 521 /* Parse action control including possible options.
 522  *
 523  * Parameters:
 524  * @argc_p - pointer to argc to parse
 525  * @argv_p - pointer to argv to parse
 526  * @result_p - pointer to output variable
 527  * @allow_num - whether action may be in numeric format already
 528  *
 529  * In error case, returns -1 and does not touch @result_1p. Otherwise returns 0.
 530  */
 531 int parse_action_control(int *argc_p, char ***argv_p,
 532                          int *result_p, bool allow_num)
 533 {
 534         return __parse_action_control(argc_p, argv_p, result_p,
 535                                       allow_num, false);
 536 }
 537
 538 /* Parse action control including possible options.
 539  *
 540  * Parameters:
 541  * @argc_p - pointer to argc to parse
 542  * @argv_p - pointer to argv to parse
 543  * @result_p - pointer to output variable
 544  * @allow_num - whether action may be in numeric format already
 545  * @default_result - set as a result in case of parsing error
 546  *
 547  * In case there is an error during parsing, the default result is used.
 548  */
 549 void parse_action_control_dflt(int *argc_p, char ***argv_p,
 550                                int *result_p, bool allow_num,
 551                                int default_result)
 552 {
 553         if (__parse_action_control(argc_p, argv_p, result_p, allow_num, true))
 554                 *result_p = default_result;
 555 }
 556
 557 static int parse_action_control_slash_spaces(int *argc_p, char ***argv_p,
 558                                              int *result1_p, int *result2_p,
 559                                              bool allow_num)
 560 {
 561         int argc = *argc_p;
 562         char **argv = *argv_p;
 563         int result1, result2;
 564         int *result_p = &result1;
 565         int ok = 0;
 566         int ret;
 567
 568         while (argc > 0) {
 569                 switch (ok) {
 570                 case 1:
 571                         if (strcmp(*argv, "/") != 0)
 572                                 goto out;
 573                         result_p = &result2;
 574                         NEXT_ARG();
 575                         /* fall-through */
 576                 case 0: /* fall-through */
 577                 case 2:
 578                         ret = parse_action_control(&argc, &argv,
 579                                                    result_p, allow_num);
 580                         if (ret)
 581                                 return ret;
 582                         ok++;
 583                         break;
 584                 default:
 585                         goto out;
 586                 }
 587         }
 588 out:
 589         *result1_p = result1;
 590         if (ok == 2)
 591                 *result2_p = result2;
 592         *argc_p = argc;
 593         *argv_p = argv;
 594         return 0;
 595 }
 596
 597 /* Parse action control with slash including possible options.
 598  *
 599  * Parameters:
 600  * @argc_p - pointer to argc to parse
 601  * @argv_p - pointer to argv to parse
 602  * @result1_p - pointer to the first (before slash) output variable
 603  * @result2_p - pointer to the second (after slash) output variable
 604  * @allow_num - whether action may be in numeric format already
 605  *
 606  * In error case, returns -1 and does not touch @result*. Otherwise returns 0.
 607  */
 608 int parse_action_control_slash(int *argc_p, char ***argv_p,
 609                                int *result1_p, int *result2_p, bool allow_num)
 610 {
 611         char **argv = *argv_p;
 612         int result1, result2;
 613         char *p = strchr(*argv, '/');
 614
 615         if (!p)
 616                 return parse_action_control_slash_spaces(argc_p, argv_p,
 617                                                          result1_p, result2_p,
 618                                                          allow_num);
 619         *p = 0;
 620         if (action_a2n(*argv, &result1, allow_num)) {
 621                 if (p)
 622                         *p = '/';
 623                 return -1;
 624         }
 625
 626         *p = '/';
 627         if (action_a2n(p + 1, &result2, allow_num))
 628                 return -1;
 629
 630         *result1_p = result1;
 631         *result2_p = result2;
 632         return 0;
 633 }
 634
 635 void print_action_control(FILE *f, const char *prefix,
 636                           int action, const char *suffix)
 637 {
 638         fprintf(f, "%s%s", prefix, action_n2a(action));
 639         if (TC_ACT_EXT_CMP(action, TC_ACT_GOTO_CHAIN))
 640                 fprintf(f, " chain %u", action & TC_ACT_EXT_VAL_MASK);
 641         fprintf(f, "%s", suffix);
 642 }
 643
 644 int get_linklayer(unsigned int *val, const char *arg)
 645 {
 646         int res;
 647
 648         if (matches(arg, "ethernet") == 0)
 649                 res = LINKLAYER_ETHERNET;
 650         else if (matches(arg, "atm") == 0)
 651                 res = LINKLAYER_ATM;
 652         else if (matches(arg, "adsl") == 0)
 653                 res = LINKLAYER_ATM;
 654         else
 655                 return -1; /* Indicate error */
 656
 657         *val = res;
 658         return 0;
 659 }
 660
 661 void print_linklayer(char *buf, int len, unsigned int linklayer)
 662 {
 663         switch (linklayer) {
 664         case LINKLAYER_UNSPEC:
 665                 snprintf(buf, len, "%s", "unspec");
 666                 return;
 667         case LINKLAYER_ETHERNET:
 668                 snprintf(buf, len, "%s", "ethernet");
 669                 return;
 670         case LINKLAYER_ATM:
 671                 snprintf(buf, len, "%s", "atm");
 672                 return;
 673         default:
 674                 snprintf(buf, len, "%s", "unknown");
 675                 return;
 676         }
 677 }
 678
 679 char *sprint_linklayer(unsigned int linklayer, char *buf)
 680 {
 681         print_linklayer(buf, SPRINT_BSIZE-1, linklayer);
 682         return buf;
 683 }
 684
 685 void print_tm(FILE *f, const struct tcf_t *tm)
 686 {
 687         int hz = get_user_hz();
 688
 689         if (tm->install != 0)
 690                 fprintf(f, " installed %u sec", (unsigned int)(tm->install/hz));
 691         if (tm->lastuse != 0)
 692                 fprintf(f, " used %u sec", (unsigned int)(tm->lastuse/hz));
 693         if (tm->expires != 0)
 694                 fprintf(f, " expires %u sec", (unsigned int)(tm->expires/hz));
 695 }
 696
 697 void print_tcstats2_attr(FILE *fp, struct rtattr *rta, char *prefix, struct rtattr **xstats)
 698 {
 699         SPRINT_BUF(b1);
 700         struct rtattr *tbs[TCA_STATS_MAX + 1];
 701
 702         parse_rtattr_nested(tbs, TCA_STATS_MAX, rta);
 703
 704         if (tbs[TCA_STATS_BASIC]) {
 705                 struct gnet_stats_basic bs = {0};
 706
 707                 memcpy(&bs, RTA_DATA(tbs[TCA_STATS_BASIC]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_BASIC]), sizeof(bs)));
 708                 fprintf(fp, "%sSent %llu bytes %u pkt",
 709                         prefix, (unsigned long long) bs.bytes, bs.packets);
 710         }
 711
 712         if (tbs[TCA_STATS_QUEUE]) {
 713                 struct gnet_stats_queue q = {0};
 714
 715                 memcpy(&q, RTA_DATA(tbs[TCA_STATS_QUEUE]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_QUEUE]), sizeof(q)));
 716                 fprintf(fp, " (dropped %u, overlimits %u requeues %u) ",
 717                         q.drops, q.overlimits, q.requeues);
 718         }
 719
 720         if (tbs[TCA_STATS_RATE_EST64]) {
 721                 struct gnet_stats_rate_est64 re = {0};
 722
 723                 memcpy(&re, RTA_DATA(tbs[TCA_STATS_RATE_EST64]),
 724                        MIN(RTA_PAYLOAD(tbs[TCA_STATS_RATE_EST64]),
 725                            sizeof(re)));
 726                 fprintf(fp, "\n%srate %s %llupps ",
 727                         prefix, sprint_rate(re.bps, b1), re.pps);
 728         } else if (tbs[TCA_STATS_RATE_EST]) {
 729                 struct gnet_stats_rate_est re = {0};
 730
 731                 memcpy(&re, RTA_DATA(tbs[TCA_STATS_RATE_EST]),
 732                        MIN(RTA_PAYLOAD(tbs[TCA_STATS_RATE_EST]), sizeof(re)));
 733                 fprintf(fp, "\n%srate %s %upps ",
 734                         prefix, sprint_rate(re.bps, b1), re.pps);
 735         }
 736
 737         if (tbs[TCA_STATS_QUEUE]) {
 738                 struct gnet_stats_queue q = {0};
 739
 740                 memcpy(&q, RTA_DATA(tbs[TCA_STATS_QUEUE]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_QUEUE]), sizeof(q)));
 741                 if (!tbs[TCA_STATS_RATE_EST])
 742                         fprintf(fp, "\n%s", prefix);
 743                 fprintf(fp, "backlog %s %up requeues %u ",
 744                         sprint_size(q.backlog, b1), q.qlen, q.requeues);
 745         }
 746
 747         if (xstats)
 748                 *xstats = tbs[TCA_STATS_APP] ? : NULL;
 749 }
 750
 751 void print_tcstats_attr(FILE *fp, struct rtattr *tb[], char *prefix, struct rtattr **xstats)
 752 {
 753         SPRINT_BUF(b1);
 754
 755         if (tb[TCA_STATS2]) {
 756                 print_tcstats2_attr(fp, tb[TCA_STATS2], prefix, xstats);
 757                 if (xstats && NULL == *xstats)
 758                         goto compat_xstats;
 759                 return;
 760         }
 761         /* backward compatibility */
 762         if (tb[TCA_STATS]) {
 763                 struct tc_stats st = {};
 764
 765                 /* handle case where kernel returns more/less than we know about */
 766                 memcpy(&st, RTA_DATA(tb[TCA_STATS]), MIN(RTA_PAYLOAD(tb[TCA_STATS]), sizeof(st)));
 767
 768                 fprintf(fp, "%sSent %llu bytes %u pkts (dropped %u, overlimits %u) ",
 769                         prefix, (unsigned long long)st.bytes, st.packets, st.drops,
 770                         st.overlimits);
 771
 772                 if (st.bps || st.pps || st.qlen || st.backlog) {
 773                         fprintf(fp, "\n%s", prefix);
 774                         if (st.bps || st.pps) {
 775                                 fprintf(fp, "rate ");
 776                                 if (st.bps)
 777                                         fprintf(fp, "%s ", sprint_rate(st.bps, b1));
 778                                 if (st.pps)
 779                                         fprintf(fp, "%upps ", st.pps);
 780                         }
 781                         if (st.qlen || st.backlog) {
 782                                 fprintf(fp, "backlog ");
 783                                 if (st.backlog)
 784                                         fprintf(fp, "%s ", sprint_size(st.backlog, b1));
 785                                 if (st.qlen)
 786                                         fprintf(fp, "%up ", st.qlen);
 787                         }
 788                 }
 789         }
 790
 791 compat_xstats:
 792         if (tb[TCA_XSTATS] && xstats)
 793                 *xstats = tb[TCA_XSTATS];
 794 }