ip/tcp_metrics.c

   1 /*
   2  * tcp_metrics.c        "ip tcp_metrics/tcpmetrics"
   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  *              version 2 as published by the Free Software Foundation;
   7  *
   8  * Authors:     Julian Anastasov <ja@ssi.bg>, August 2012
   9  */
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <unistd.h>
  15 #include <errno.h>
  16 #include <sys/types.h>
  17 #include <sys/socket.h>
  18 #include <arpa/inet.h>
  19 #include <sys/ioctl.h>
  20 #include <linux/if.h>
  21
  22 #include <linux/genetlink.h>
  23 #include <linux/tcp_metrics.h>
  24
  25 #include "utils.h"
  26 #include "ip_common.h"
  27 #include "libgenl.h"
  28
  29 static void usage(void)
  30 {
  31         fprintf(stderr, "Usage: ip tcp_metrics/tcpmetrics { COMMAND | help }\n");
  32         fprintf(stderr, "       ip tcp_metrics { show | flush } SELECTOR\n");
  33         fprintf(stderr, "       ip tcp_metrics delete [ address ] ADDRESS\n");
  34         fprintf(stderr, "SELECTOR := [ [ address ] PREFIX ]\n");
  35         exit(-1);
  36 }
  37
  38 /* netlink socket */
  39 static struct rtnl_handle grth = { .fd = -1 };
  40 static int genl_family = -1;
  41
  42 #define TCPM_REQUEST(_req, _bufsiz, _cmd, _flags) \
  43         GENL_REQUEST(_req, _bufsiz, genl_family, 0, \
  44                      TCP_METRICS_GENL_VERSION, _cmd, _flags)
  45
  46 #define CMD_LIST        0x0001  /* list, lst, show              */
  47 #define CMD_DEL         0x0002  /* delete, remove               */
  48 #define CMD_FLUSH       0x0004  /* flush                        */
  49
  50 static const struct {
  51         const char *name;
  52         int     code;
  53 } cmds[] = {
  54         {       "list",         CMD_LIST        },
  55         {       "lst",          CMD_LIST        },
  56         {       "show",         CMD_LIST        },
  57         {       "delete",       CMD_DEL         },
  58         {       "remove",       CMD_DEL         },
  59         {       "flush",        CMD_FLUSH       },
  60 };
  61
  62 static const char *metric_name[TCP_METRIC_MAX + 1] = {
  63         [TCP_METRIC_RTT]                = "rtt",
  64         [TCP_METRIC_RTTVAR]             = "rttvar",
  65         [TCP_METRIC_SSTHRESH]           = "ssthresh",
  66         [TCP_METRIC_CWND]               = "cwnd",
  67         [TCP_METRIC_REORDERING]         = "reordering",
  68 };
  69
  70 static struct {
  71         int flushed;
  72         char *flushb;
  73         int flushp;
  74         int flushe;
  75         int cmd;
  76         inet_prefix daddr;
  77         inet_prefix saddr;
  78 } f;
  79
  80 static int flush_update(void)
  81 {
  82         if (rtnl_send_check(&grth, f.flushb, f.flushp) < 0) {
  83                 perror("Failed to send flush request\n");
  84                 return -1;
  85         }
  86         f.flushp = 0;
  87         return 0;
  88 }
  89
  90 static int process_msg(const struct sockaddr_nl *who, struct nlmsghdr *n,
  91                        void *arg)
  92 {
  93         FILE *fp = (FILE *) arg;
  94         struct genlmsghdr *ghdr;
  95         struct rtattr *attrs[TCP_METRICS_ATTR_MAX + 1], *a;
  96         int len = n->nlmsg_len;
  97         inet_prefix daddr, saddr;
  98         int i, atype, stype;
  99
 100         if (n->nlmsg_type != genl_family)
 101                 return -1;
 102
 103         len -= NLMSG_LENGTH(GENL_HDRLEN);
 104         if (len < 0)
 105                 return -1;
 106
 107         ghdr = NLMSG_DATA(n);
 108         if (ghdr->cmd != TCP_METRICS_CMD_GET)
 109                 return 0;
 110
 111         parse_rtattr(attrs, TCP_METRICS_ATTR_MAX, (void *) ghdr + GENL_HDRLEN,
 112                      len);
 113
 114         if (attrs[TCP_METRICS_ATTR_ADDR_IPV4]) {
 115                 if (f.daddr.family && f.daddr.family != AF_INET)
 116                         return 0;
 117                 a = attrs[TCP_METRICS_ATTR_ADDR_IPV4];
 118                 daddr.family = AF_INET;
 119                 atype = TCP_METRICS_ATTR_ADDR_IPV4;
 120         } else if (attrs[TCP_METRICS_ATTR_ADDR_IPV6]) {
 121                 if (f.daddr.family && f.daddr.family != AF_INET6)
 122                         return 0;
 123                 a = attrs[TCP_METRICS_ATTR_ADDR_IPV6];
 124                 daddr.family = AF_INET6;
 125                 atype = TCP_METRICS_ATTR_ADDR_IPV6;
 126         } else {
 127                 return 0;
 128         }
 129
 130         if (get_addr_rta(&daddr, a, daddr.family))
 131                 return 0;
 132
 133         if (f.daddr.family && f.daddr.bitlen >= 0 &&
 134             inet_addr_match(&daddr, &f.daddr, f.daddr.bitlen))
 135                 return 0;
 136
 137         if (attrs[TCP_METRICS_ATTR_SADDR_IPV4]) {
 138                 if (f.saddr.family && f.saddr.family != AF_INET)
 139                         return 0;
 140                 a = attrs[TCP_METRICS_ATTR_SADDR_IPV4];
 141                 saddr.family = AF_INET;
 142                 stype = TCP_METRICS_ATTR_SADDR_IPV4;
 143         } else if (attrs[TCP_METRICS_ATTR_SADDR_IPV6]) {
 144                 if (f.saddr.family && f.saddr.family != AF_INET6)
 145                         return 0;
 146                 a = attrs[TCP_METRICS_ATTR_SADDR_IPV6];
 147                 saddr.family = AF_INET6;
 148                 stype = TCP_METRICS_ATTR_SADDR_IPV6;
 149         } else {
 150                 saddr.family = AF_UNSPEC;
 151                 stype = 0;
 152         }
 153
 154         /* Only get/check for the source-address if the kernel supports it. */
 155         if (saddr.family) {
 156                 if (get_addr_rta(&saddr, a, saddr.family))
 157                         return 0;
 158
 159                 if (f.saddr.family && f.saddr.bitlen >= 0 &&
 160                     inet_addr_match(&saddr, &f.saddr, f.saddr.bitlen))
 161                         return 0;
 162         }
 163
 164         if (f.flushb) {
 165                 struct nlmsghdr *fn;
 166
 167                 TCPM_REQUEST(req2, 128, TCP_METRICS_CMD_DEL, NLM_F_REQUEST);
 168
 169                 addattr_l(&req2.n, sizeof(req2), atype, daddr.data,
 170                           daddr.bytelen);
 171                 if (saddr.family)
 172                         addattr_l(&req2.n, sizeof(req2), stype, saddr.data,
 173                                   saddr.bytelen);
 174
 175                 if (NLMSG_ALIGN(f.flushp) + req2.n.nlmsg_len > f.flushe) {
 176                         if (flush_update())
 177                                 return -1;
 178                 }
 179                 fn = (struct nlmsghdr *) (f.flushb + NLMSG_ALIGN(f.flushp));
 180                 memcpy(fn, &req2.n, req2.n.nlmsg_len);
 181                 fn->nlmsg_seq = ++grth.seq;
 182                 f.flushp = (((char *) fn) + req2.n.nlmsg_len) - f.flushb;
 183                 f.flushed++;
 184                 if (show_stats < 2)
 185                         return 0;
 186         }
 187
 188         if (f.cmd & (CMD_DEL | CMD_FLUSH))
 189                 fprintf(fp, "Deleted ");
 190
 191         fprintf(fp, "%s",
 192                 format_host(daddr.family, daddr.bytelen, daddr.data));
 193
 194         a = attrs[TCP_METRICS_ATTR_AGE];
 195         if (a) {
 196                 unsigned long long val = rta_getattr_u64(a);
 197
 198                 fprintf(fp, " age %llu.%03llusec",
 199                         val / 1000, val % 1000);
 200         }
 201
 202         a = attrs[TCP_METRICS_ATTR_TW_TS_STAMP];
 203         if (a) {
 204                 __s32 val = (__s32) rta_getattr_u32(a);
 205                 __u32 tsval;
 206
 207                 a = attrs[TCP_METRICS_ATTR_TW_TSVAL];
 208                 tsval = a ? rta_getattr_u32(a) : 0;
 209                 fprintf(fp, " tw_ts %u/%dsec ago", tsval, val);
 210         }
 211
 212         a = attrs[TCP_METRICS_ATTR_VALS];
 213         if (a) {
 214                 struct rtattr *m[TCP_METRIC_MAX + 1 + 1];
 215                 unsigned long rtt = 0, rttvar = 0;
 216
 217                 parse_rtattr_nested(m, TCP_METRIC_MAX + 1, a);
 218
 219                 for (i = 0; i < TCP_METRIC_MAX + 1; i++) {
 220                         unsigned long val;
 221
 222                         a = m[i + 1];
 223                         if (!a)
 224                                 continue;
 225                         if (i != TCP_METRIC_RTT &&
 226                             i != TCP_METRIC_RTT_US &&
 227                             i != TCP_METRIC_RTTVAR &&
 228                             i != TCP_METRIC_RTTVAR_US) {
 229                                 if (metric_name[i])
 230                                         fprintf(fp, " %s ", metric_name[i]);
 231                                 else
 232                                         fprintf(fp, " metric_%d ", i);
 233                         }
 234                         val = rta_getattr_u32(a);
 235                         switch (i) {
 236                         case TCP_METRIC_RTT:
 237                                 if (!rtt)
 238                                         rtt = (val * 1000UL) >> 3;
 239                                 break;
 240                         case TCP_METRIC_RTTVAR:
 241                                 if (!rttvar)
 242                                         rttvar = (val * 1000UL) >> 2;
 243                                 break;
 244                         case TCP_METRIC_RTT_US:
 245                                 rtt = val >> 3;
 246                                 break;
 247                         case TCP_METRIC_RTTVAR_US:
 248                                 rttvar = val >> 2;
 249                                 break;
 250                         case TCP_METRIC_SSTHRESH:
 251                         case TCP_METRIC_CWND:
 252                         case TCP_METRIC_REORDERING:
 253                         default:
 254                                 fprintf(fp, "%lu", val);
 255                                 break;
 256                         }
 257                 }
 258                 if (rtt)
 259                         fprintf(fp, " rtt %luus", rtt);
 260                 if (rttvar)
 261                         fprintf(fp, " rttvar %luus", rttvar);
 262         }
 263
 264         a = attrs[TCP_METRICS_ATTR_FOPEN_MSS];
 265         if (a)
 266                 fprintf(fp, " fo_mss %u", rta_getattr_u16(a));
 267
 268         a = attrs[TCP_METRICS_ATTR_FOPEN_SYN_DROPS];
 269         if (a) {
 270                 __u16 syn_loss = rta_getattr_u16(a);
 271                 unsigned long long ts;
 272
 273                 a = attrs[TCP_METRICS_ATTR_FOPEN_SYN_DROP_TS];
 274                 ts = a ? rta_getattr_u64(a) : 0;
 275
 276                 fprintf(fp, " fo_syn_drops %u/%llu.%03llusec ago",
 277                         syn_loss, ts / 1000, ts % 1000);
 278         }
 279
 280         a = attrs[TCP_METRICS_ATTR_FOPEN_COOKIE];
 281         if (a) {
 282                 char cookie[32 + 1];
 283                 unsigned char *ptr = RTA_DATA(a);
 284                 int i, max = RTA_PAYLOAD(a);
 285
 286                 if (max > 16)
 287                         max = 16;
 288                 cookie[0] = 0;
 289                 for (i = 0; i < max; i++)
 290                         sprintf(cookie + i + i, "%02x", ptr[i]);
 291                 fprintf(fp, " fo_cookie %s", cookie);
 292         }
 293
 294         if (saddr.family) {
 295                 fprintf(fp, " source %s",
 296                         format_host(saddr.family, saddr.bytelen, saddr.data));
 297         }
 298
 299         fprintf(fp, "\n");
 300
 301         fflush(fp);
 302         return 0;
 303 }
 304
 305 static int tcpm_do_cmd(int cmd, int argc, char **argv)
 306 {
 307         TCPM_REQUEST(req, 1024, TCP_METRICS_CMD_GET, NLM_F_REQUEST);
 308         struct nlmsghdr *answer;
 309         int atype = -1, stype = -1;
 310         int ack;
 311
 312         memset(&f, 0, sizeof(f));
 313         f.daddr.bitlen = -1;
 314         f.daddr.family = preferred_family;
 315         f.saddr.bitlen = -1;
 316         f.saddr.family = preferred_family;
 317
 318         switch (preferred_family) {
 319         case AF_UNSPEC:
 320         case AF_INET:
 321         case AF_INET6:
 322                 break;
 323         default:
 324                 fprintf(stderr, "Unsupported protocol family: %d\n", preferred_family);
 325                 return -1;
 326         }
 327
 328         for (; argc > 0; argc--, argv++) {
 329                 if (strcmp(*argv, "src") == 0 ||
 330                     strcmp(*argv, "source") == 0) {
 331                         char *who = *argv;
 332
 333                         NEXT_ARG();
 334                         if (matches(*argv, "help") == 0)
 335                                 usage();
 336                         if (f.saddr.bitlen >= 0)
 337                                 duparg2(who, *argv);
 338
 339                         get_prefix(&f.saddr, *argv, preferred_family);
 340                         if (f.saddr.bytelen && f.saddr.bytelen * 8 == f.saddr.bitlen) {
 341                                 if (f.saddr.family == AF_INET)
 342                                         stype = TCP_METRICS_ATTR_SADDR_IPV4;
 343                                 else if (f.saddr.family == AF_INET6)
 344                                         stype = TCP_METRICS_ATTR_SADDR_IPV6;
 345                         }
 346
 347                         if (stype < 0) {
 348                                 fprintf(stderr, "Error: a specific IP address is expected rather than \"%s\"\n",
 349                                         *argv);
 350                                 return -1;
 351                         }
 352                 } else {
 353                         char *who = "address";
 354
 355                         if (strcmp(*argv, "addr") == 0 ||
 356                             strcmp(*argv, "address") == 0) {
 357                                 who = *argv;
 358                                 NEXT_ARG();
 359                         }
 360                         if (matches(*argv, "help") == 0)
 361                                 usage();
 362                         if (f.daddr.bitlen >= 0)
 363                                 duparg2(who, *argv);
 364
 365                         get_prefix(&f.daddr, *argv, preferred_family);
 366                         if (f.daddr.bytelen && f.daddr.bytelen * 8 == f.daddr.bitlen) {
 367                                 if (f.daddr.family == AF_INET)
 368                                         atype = TCP_METRICS_ATTR_ADDR_IPV4;
 369                                 else if (f.daddr.family == AF_INET6)
 370                                         atype = TCP_METRICS_ATTR_ADDR_IPV6;
 371                         }
 372                         if ((CMD_DEL & cmd) && atype < 0) {
 373                                 fprintf(stderr, "Error: a specific IP address is expected rather than \"%s\"\n",
 374                                         *argv);
 375                                 return -1;
 376                         }
 377                 }
 378                 argc--; argv++;
 379         }
 380
 381         if (cmd == CMD_DEL && atype < 0)
 382                 missarg("address");
 383
 384         /* flush for exact address ? Single del */
 385         if (cmd == CMD_FLUSH && atype >= 0)
 386                 cmd = CMD_DEL;
 387
 388         /* flush for all addresses ? Single del without address */
 389         if (cmd == CMD_FLUSH && f.daddr.bitlen <= 0 &&
 390             f.saddr.bitlen <= 0 && preferred_family == AF_UNSPEC) {
 391                 cmd = CMD_DEL;
 392                 req.g.cmd = TCP_METRICS_CMD_DEL;
 393                 ack = 1;
 394         } else if (cmd == CMD_DEL) {
 395                 req.g.cmd = TCP_METRICS_CMD_DEL;
 396                 ack = 1;
 397         } else {        /* CMD_FLUSH, CMD_LIST */
 398                 ack = 0;
 399         }
 400
 401         if (genl_init_handle(&grth, TCP_METRICS_GENL_NAME, &genl_family))
 402                 exit(1);
 403         req.n.nlmsg_type = genl_family;
 404
 405         if (!(cmd & CMD_FLUSH) && (atype >= 0 || (cmd & CMD_DEL))) {
 406                 if (ack)
 407                         req.n.nlmsg_flags |= NLM_F_ACK;
 408                 if (atype >= 0)
 409                         addattr_l(&req.n, sizeof(req), atype, &f.daddr.data,
 410                                   f.daddr.bytelen);
 411                 if (stype >= 0)
 412                         addattr_l(&req.n, sizeof(req), stype, &f.saddr.data,
 413                                   f.saddr.bytelen);
 414         } else {
 415                 req.n.nlmsg_flags |= NLM_F_DUMP;
 416         }
 417
 418         f.cmd = cmd;
 419         if (cmd & CMD_FLUSH) {
 420                 int round = 0;
 421                 char flushb[4096-512];
 422
 423                 f.flushb = flushb;
 424                 f.flushp = 0;
 425                 f.flushe = sizeof(flushb);
 426
 427                 for (;;) {
 428                         req.n.nlmsg_seq = grth.dump = ++grth.seq;
 429                         if (rtnl_send(&grth, &req, req.n.nlmsg_len) < 0) {
 430                                 perror("Failed to send flush request");
 431                                 exit(1);
 432                         }
 433                         f.flushed = 0;
 434                         if (rtnl_dump_filter(&grth, process_msg, stdout) < 0) {
 435                                 fprintf(stderr, "Flush terminated\n");
 436                                 exit(1);
 437                         }
 438                         if (f.flushed == 0) {
 439                                 if (round == 0) {
 440                                         fprintf(stderr, "Nothing to flush.\n");
 441                                 } else if (show_stats)
 442                                         printf("*** Flush is complete after %d round%s ***\n",
 443                                                round, round > 1 ? "s" : "");
 444                                 fflush(stdout);
 445                                 return 0;
 446                         }
 447                         round++;
 448                         if (flush_update() < 0)
 449                                 exit(1);
 450                         if (show_stats) {
 451                                 printf("\n*** Round %d, deleting %d entries ***\n",
 452                                        round, f.flushed);
 453                                 fflush(stdout);
 454                         }
 455                 }
 456                 return 0;
 457         }
 458
 459         if (ack) {
 460                 if (rtnl_talk(&grth, &req.n, NULL) < 0)
 461                         return -2;
 462         } else if (atype >= 0) {
 463                 if (rtnl_talk(&grth, &req.n, &answer) < 0)
 464                         return -2;
 465                 if (process_msg(NULL, answer, stdout) < 0) {
 466                         fprintf(stderr, "Dump terminated\n");
 467                         exit(1);
 468                 }
 469                 free(answer);
 470         } else {
 471                 req.n.nlmsg_seq = grth.dump = ++grth.seq;
 472                 if (rtnl_send(&grth, &req, req.n.nlmsg_len) < 0) {
 473                         perror("Failed to send dump request");
 474                         exit(1);
 475                 }
 476
 477                 if (rtnl_dump_filter(&grth, process_msg, stdout) < 0) {
 478                         fprintf(stderr, "Dump terminated\n");
 479                         exit(1);
 480                 }
 481         }
 482         return 0;
 483 }
 484
 485 int do_tcp_metrics(int argc, char **argv)
 486 {
 487         int i;
 488
 489         if (argc < 1)
 490                 return tcpm_do_cmd(CMD_LIST, 0, NULL);
 491         for (i = 0; i < ARRAY_SIZE(cmds); i++) {
 492                 if (matches(argv[0], cmds[i].name) == 0)
 493                         return tcpm_do_cmd(cmds[i].code, argc-1, argv+1);
 494         }
 495         if (matches(argv[0], "help") == 0)
 496                 usage();
 497
 498         fprintf(stderr, "Command \"%s\" is unknown, try \"ip tcp_metrics help\".\n",
 499                         *argv);
 500         exit(-1);
 501 }