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 (at) 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 <netinet/in.h> 20 #include <arpa/inet.h> 21 #include <string.h> 22 #include <math.h> 23 24 #include "utils.h" 25 #include "tc_util.h" 26 27 #ifndef LIBDIR 28 #define LIBDIR "/usr/lib/" 29 #endif 30 31 const char *get_tc_lib(void) 32 { 33 const char *lib_dir; 34 35 lib_dir = getenv("TC_LIB_DIR"); 36 if (!lib_dir) 37 lib_dir = LIBDIR "/tc/"; 38 39 return lib_dir; 40 } 41 42 int get_qdisc_handle(__u32 *h, const char *str) 43 { 44 __u32 maj; 45 char *p; 46 47 maj = TC_H_UNSPEC; 48 if (strcmp(str, "none") == 0) 49 goto ok; 50 maj = strtoul(str, &p, 16); 51 if (p == str) 52 return -1; 53 maj <<= 16; 54 if (*p != ':' && *p!=0) 55 return -1; 56 ok: 57 *h = maj; 58 return 0; 59 } 60 61 int get_tc_classid(__u32 *h, const char *str) 62 { 63 __u32 maj, min; 64 char *p; 65 66 maj = TC_H_ROOT; 67 if (strcmp(str, "root") == 0) 68 goto ok; 69 maj = TC_H_UNSPEC; 70 if (strcmp(str, "none") == 0) 71 goto ok; 72 maj = strtoul(str, &p, 16); 73 if (p == str) { 74 maj = 0; 75 if (*p != ':') 76 return -1; 77 } 78 if (*p == ':') { 79 if (maj >= (1<<16)) 80 return -1; 81 maj <<= 16; 82 str = p+1; 83 min = strtoul(str, &p, 16); 84 if (*p != 0) 85 return -1; 86 if (min >= (1<<16)) 87 return -1; 88 maj |= min; 89 } else if (*p != 0) 90 return -1; 91 92 ok: 93 *h = maj; 94 return 0; 95 } 96 97 int print_tc_classid(char *buf, int len, __u32 h) 98 { 99 if (h == TC_H_ROOT) 100 sprintf(buf, "root"); 101 else if (h == TC_H_UNSPEC) 102 snprintf(buf, len, "none"); 103 else if (TC_H_MAJ(h) == 0) 104 snprintf(buf, len, ":%x", TC_H_MIN(h)); 105 else if (TC_H_MIN(h) == 0) 106 snprintf(buf, len, "%x:", TC_H_MAJ(h)>>16); 107 else 108 snprintf(buf, len, "%x:%x", TC_H_MAJ(h)>>16, TC_H_MIN(h)); 109 return 0; 110 } 111 112 char * sprint_tc_classid(__u32 h, char *buf) 113 { 114 if (print_tc_classid(buf, SPRINT_BSIZE-1, h)) 115 strcpy(buf, "???"); 116 return buf; 117 } 118 119 /* See http://physics.nist.gov/cuu/Units/binary.html */ 120 static const struct rate_suffix { 121 const char *name; 122 double scale; 123 } suffixes[] = { 124 { "bit", 1. }, 125 { "Kibit", 1024. }, 126 { "kbit", 1000. }, 127 { "mibit", 1024.*1024. }, 128 { "mbit", 1000000. }, 129 { "gibit", 1024.*1024.*1024. }, 130 { "gbit", 1000000000. }, 131 { "tibit", 1024.*1024.*1024.*1024. }, 132 { "tbit", 1000000000000. }, 133 { "Bps", 8. }, 134 { "KiBps", 8.*1024. }, 135 { "KBps", 8000. }, 136 { "MiBps", 8.*1024*1024. }, 137 { "MBps", 8000000. }, 138 { "GiBps", 8.*1024.*1024.*1024. }, 139 { "GBps", 8000000000. }, 140 { "TiBps", 8.*1024.*1024.*1024.*1024. }, 141 { "TBps", 8000000000000. }, 142 { NULL } 143 }; 144 145 146 int get_rate(unsigned *rate, const char *str) 147 { 148 char *p; 149 double bps = strtod(str, &p); 150 const struct rate_suffix *s; 151 152 if (p == str) 153 return -1; 154 155 if (*p == '\0') { 156 *rate = bps / 8.; /* assume bytes/sec */ 157 return 0; 158 } 159 160 for (s = suffixes; s->name; ++s) { 161 if (strcasecmp(s->name, p) == 0) { 162 *rate = (bps * s->scale) / 8.; 163 return 0; 164 } 165 } 166 167 return -1; 168 } 169 170 int get_rate_and_cell(unsigned *rate, int *cell_log, char *str) 171 { 172 char * slash = strchr(str, '/'); 173 174 if (slash) 175 *slash = 0; 176 177 if (get_rate(rate, str)) 178 return -1; 179 180 if (slash) { 181 int cell; 182 int i; 183 184 if (get_integer(&cell, slash+1, 0)) 185 return -1; 186 *slash = '/'; 187 188 for (i=0; i<32; i++) { 189 if ((1<<i) == cell) { 190 *cell_log = i; 191 return 0; 192 } 193 } 194 return -1; 195 } 196 return 0; 197 } 198 199 void print_rate(char *buf, int len, __u32 rate) 200 { 201 double tmp = (double)rate*8; 202 extern int use_iec; 203 204 if (use_iec) { 205 if (tmp >= 1000.0*1024.0*1024.0) 206 snprintf(buf, len, "%.0fMibit", tmp/1024.0*1024.0); 207 else if (tmp >= 1000.0*1024) 208 snprintf(buf, len, "%.0fKibit", tmp/1024); 209 else 210 snprintf(buf, len, "%.0fbit", tmp); 211 } else { 212 if (tmp >= 1000.0*1000000.0) 213 snprintf(buf, len, "%.0fMbit", tmp/1000000.0); 214 else if (tmp >= 1000.0 * 1000.0) 215 snprintf(buf, len, "%.0fKbit", tmp/1000.0); 216 else 217 snprintf(buf, len, "%.0fbit", tmp); 218 } 219 } 220 221 char * sprint_rate(__u32 rate, char *buf) 222 { 223 print_rate(buf, SPRINT_BSIZE-1, rate); 224 return buf; 225 } 226 227 int get_time(unsigned *time, const char *str) 228 { 229 double t; 230 char *p; 231 232 t = strtod(str, &p); 233 if (p == str) 234 return -1; 235 236 if (*p) { 237 if (strcasecmp(p, "s") == 0 || strcasecmp(p, "sec")==0 || 238 strcasecmp(p, "secs")==0) 239 t *= TIME_UNITS_PER_SEC; 240 else if (strcasecmp(p, "ms") == 0 || strcasecmp(p, "msec")==0 || 241 strcasecmp(p, "msecs") == 0) 242 t *= TIME_UNITS_PER_SEC/1000; 243 else if (strcasecmp(p, "us") == 0 || strcasecmp(p, "usec")==0 || 244 strcasecmp(p, "usecs") == 0) 245 t *= TIME_UNITS_PER_SEC/1000000; 246 else 247 return -1; 248 } 249 250 *time = t; 251 return 0; 252 } 253 254 255 void print_time(char *buf, int len, __u32 time) 256 { 257 double tmp = time; 258 259 if (tmp >= TIME_UNITS_PER_SEC) 260 snprintf(buf, len, "%.1fs", tmp/TIME_UNITS_PER_SEC); 261 else if (tmp >= TIME_UNITS_PER_SEC/1000) 262 snprintf(buf, len, "%.1fms", tmp/(TIME_UNITS_PER_SEC/1000)); 263 else 264 snprintf(buf, len, "%uus", time); 265 } 266 267 char * sprint_time(__u32 time, char *buf) 268 { 269 print_time(buf, SPRINT_BSIZE-1, time); 270 return buf; 271 } 272 273 char * sprint_ticks(__u32 ticks, char *buf) 274 { 275 return sprint_time(tc_core_tick2time(ticks), buf); 276 } 277 278 int get_size(unsigned *size, const char *str) 279 { 280 double sz; 281 char *p; 282 283 sz = strtod(str, &p); 284 if (p == str) 285 return -1; 286 287 if (*p) { 288 if (strcasecmp(p, "kb") == 0 || strcasecmp(p, "k")==0) 289 sz *= 1024; 290 else if (strcasecmp(p, "gb") == 0 || strcasecmp(p, "g")==0) 291 sz *= 1024*1024*1024; 292 else if (strcasecmp(p, "gbit") == 0) 293 sz *= 1024*1024*1024/8; 294 else if (strcasecmp(p, "mb") == 0 || strcasecmp(p, "m")==0) 295 sz *= 1024*1024; 296 else if (strcasecmp(p, "mbit") == 0) 297 sz *= 1024*1024/8; 298 else if (strcasecmp(p, "kbit") == 0) 299 sz *= 1024/8; 300 else if (strcasecmp(p, "b") != 0) 301 return -1; 302 } 303 304 *size = sz; 305 return 0; 306 } 307 308 int get_size_and_cell(unsigned *size, int *cell_log, char *str) 309 { 310 char * slash = strchr(str, '/'); 311 312 if (slash) 313 *slash = 0; 314 315 if (get_size(size, str)) 316 return -1; 317 318 if (slash) { 319 int cell; 320 int i; 321 322 if (get_integer(&cell, slash+1, 0)) 323 return -1; 324 *slash = '/'; 325 326 for (i=0; i<32; i++) { 327 if ((1<<i) == cell) { 328 *cell_log = i; 329 return 0; 330 } 331 } 332 return -1; 333 } 334 return 0; 335 } 336 337 void print_size(char *buf, int len, __u32 sz) 338 { 339 double tmp = sz; 340 341 if (sz >= 1024*1024 && fabs(1024*1024*rint(tmp/(1024*1024)) - sz) < 1024) 342 snprintf(buf, len, "%gMb", rint(tmp/(1024*1024))); 343 else if (sz >= 1024 && fabs(1024*rint(tmp/1024) - sz) < 16) 344 snprintf(buf, len, "%gKb", rint(tmp/1024)); 345 else 346 snprintf(buf, len, "%ub", sz); 347 } 348 349 char * sprint_size(__u32 size, char *buf) 350 { 351 print_size(buf, SPRINT_BSIZE-1, size); 352 return buf; 353 } 354 355 static const double max_percent_value = 0xffffffff; 356 357 int get_percent(__u32 *percent, const char *str) 358 { 359 char *p; 360 double per = strtod(str, &p) / 100.; 361 362 if (per > 1. || per < 0) 363 return -1; 364 if (*p && strcmp(p, "%")) 365 return -1; 366 367 *percent = (unsigned) rint(per * max_percent_value); 368 return 0; 369 } 370 371 void print_percent(char *buf, int len, __u32 per) 372 { 373 snprintf(buf, len, "%g%%", 100. * (double) per / max_percent_value); 374 } 375 376 char * sprint_percent(__u32 per, char *buf) 377 { 378 print_percent(buf, SPRINT_BSIZE-1, per); 379 return buf; 380 } 381 382 void print_qdisc_handle(char *buf, int len, __u32 h) 383 { 384 snprintf(buf, len, "%x:", TC_H_MAJ(h)>>16); 385 } 386 387 char * sprint_qdisc_handle(__u32 h, char *buf) 388 { 389 print_qdisc_handle(buf, SPRINT_BSIZE-1, h); 390 return buf; 391 } 392 393 char * action_n2a(int action, char *buf, int len) 394 { 395 switch (action) { 396 case -1: 397 return "continue"; 398 break; 399 case TC_ACT_OK: 400 return "pass"; 401 break; 402 case TC_ACT_SHOT: 403 return "drop"; 404 break; 405 case TC_ACT_RECLASSIFY: 406 return "reclassify"; 407 case TC_ACT_PIPE: 408 return "pipe"; 409 case TC_ACT_STOLEN: 410 return "stolen"; 411 default: 412 snprintf(buf, len, "%d", action); 413 return buf; 414 } 415 } 416 417 int action_a2n(char *arg, int *result) 418 { 419 int res; 420 421 if (matches(arg, "continue") == 0) 422 res = -1; 423 else if (matches(arg, "drop") == 0) 424 res = TC_ACT_SHOT; 425 else if (matches(arg, "shot") == 0) 426 res = TC_ACT_SHOT; 427 else if (matches(arg, "pass") == 0) 428 res = TC_ACT_OK; 429 else if (strcmp(arg, "ok") == 0) 430 res = TC_ACT_OK; 431 else if (matches(arg, "reclassify") == 0) 432 res = TC_ACT_RECLASSIFY; 433 else { 434 char dummy; 435 if (sscanf(arg, "%d%c", &res, &dummy) != 1) 436 return -1; 437 } 438 *result = res; 439 return 0; 440 } 441 442 int get_linklayer(unsigned *val, const char *arg) 443 { 444 int res; 445 446 if (matches(arg, "ethernet") == 0) 447 res = LINKLAYER_ETHERNET; 448 else if (matches(arg, "atm") == 0) 449 res = LINKLAYER_ATM; 450 else if (matches(arg, "adsl") == 0) 451 res = LINKLAYER_ATM; 452 else 453 return -1; /* Indicate error */ 454 455 *val = res; 456 return 0; 457 } 458 459 void print_linklayer(char *buf, int len, unsigned linklayer) 460 { 461 switch (linklayer) { 462 case LINKLAYER_UNSPEC: 463 snprintf(buf, len, "%s", "unspec"); 464 return; 465 case LINKLAYER_ETHERNET: 466 snprintf(buf, len, "%s", "ethernet"); 467 return; 468 case LINKLAYER_ATM: 469 snprintf(buf, len, "%s", "atm"); 470 return; 471 default: 472 snprintf(buf, len, "%s", "unknown"); 473 return; 474 } 475 } 476 477 char *sprint_linklayer(unsigned linklayer, char *buf) 478 { 479 print_linklayer(buf, SPRINT_BSIZE-1, linklayer); 480 return buf; 481 } 482 483 void print_tm(FILE * f, const struct tcf_t *tm) 484 { 485 int hz = get_user_hz(); 486 if (tm->install != 0) 487 fprintf(f, " installed %u sec", (unsigned)(tm->install/hz)); 488 if (tm->lastuse != 0) 489 fprintf(f, " used %u sec", (unsigned)(tm->lastuse/hz)); 490 if (tm->expires != 0) 491 fprintf(f, " expires %u sec", (unsigned)(tm->expires/hz)); 492 } 493 494 void print_tcstats2_attr(FILE *fp, struct rtattr *rta, char *prefix, struct rtattr **xstats) 495 { 496 SPRINT_BUF(b1); 497 struct rtattr *tbs[TCA_STATS_MAX + 1]; 498 499 parse_rtattr_nested(tbs, TCA_STATS_MAX, rta); 500 501 if (tbs[TCA_STATS_BASIC]) { 502 struct gnet_stats_basic bs = {0}; 503 memcpy(&bs, RTA_DATA(tbs[TCA_STATS_BASIC]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_BASIC]), sizeof(bs))); 504 fprintf(fp, "%sSent %llu bytes %u pkt", 505 prefix, (unsigned long long) bs.bytes, bs.packets); 506 } 507 508 if (tbs[TCA_STATS_QUEUE]) { 509 struct gnet_stats_queue q = {0}; 510 memcpy(&q, RTA_DATA(tbs[TCA_STATS_QUEUE]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_QUEUE]), sizeof(q))); 511 fprintf(fp, " (dropped %u, overlimits %u requeues %u) ", 512 q.drops, q.overlimits, q.requeues); 513 } 514 515 if (tbs[TCA_STATS_RATE_EST]) { 516 struct gnet_stats_rate_est re = {0}; 517 memcpy(&re, RTA_DATA(tbs[TCA_STATS_RATE_EST]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_RATE_EST]), sizeof(re))); 518 fprintf(fp, "\n%srate %s %upps ", 519 prefix, sprint_rate(re.bps, b1), re.pps); 520 } 521 522 if (tbs[TCA_STATS_QUEUE]) { 523 struct gnet_stats_queue q = {0}; 524 memcpy(&q, RTA_DATA(tbs[TCA_STATS_QUEUE]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_QUEUE]), sizeof(q))); 525 if (!tbs[TCA_STATS_RATE_EST]) 526 fprintf(fp, "\n%s", prefix); 527 fprintf(fp, "backlog %s %up requeues %u ", 528 sprint_size(q.backlog, b1), q.qlen, q.requeues); 529 } 530 531 if (xstats) 532 *xstats = tbs[TCA_STATS_APP] ? : NULL; 533 } 534 535 void print_tcstats_attr(FILE *fp, struct rtattr *tb[], char *prefix, struct rtattr **xstats) 536 { 537 SPRINT_BUF(b1); 538 539 if (tb[TCA_STATS2]) { 540 print_tcstats2_attr(fp, tb[TCA_STATS2], prefix, xstats); 541 if (xstats && NULL == *xstats) 542 goto compat_xstats; 543 return; 544 } 545 /* backward compatibility */ 546 if (tb[TCA_STATS]) { 547 struct tc_stats st; 548 549 /* handle case where kernel returns more/less than we know about */ 550 memset(&st, 0, sizeof(st)); 551 memcpy(&st, RTA_DATA(tb[TCA_STATS]), MIN(RTA_PAYLOAD(tb[TCA_STATS]), sizeof(st))); 552 553 fprintf(fp, "%sSent %llu bytes %u pkts (dropped %u, overlimits %u) ", 554 prefix, (unsigned long long)st.bytes, st.packets, st.drops, 555 st.overlimits); 556 557 if (st.bps || st.pps || st.qlen || st.backlog) { 558 fprintf(fp, "\n%s", prefix); 559 if (st.bps || st.pps) { 560 fprintf(fp, "rate "); 561 if (st.bps) 562 fprintf(fp, "%s ", sprint_rate(st.bps, b1)); 563 if (st.pps) 564 fprintf(fp, "%upps ", st.pps); 565 } 566 if (st.qlen || st.backlog) { 567 fprintf(fp, "backlog "); 568 if (st.backlog) 569 fprintf(fp, "%s ", sprint_size(st.backlog, b1)); 570 if (st.qlen) 571 fprintf(fp, "%up ", st.qlen); 572 } 573 } 574 } 575 576 compat_xstats: 577 if (tb[TCA_XSTATS] && xstats) 578 *xstats = tb[TCA_XSTATS]; 579 } 580 581
