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