usr.bin/systat/altqs.c

   1 /*
   2  * Copyright (c) 2003, Trent Nelson, <trent@arpa.com>.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. The name of the author may not be used to endorse or promote products
  14  *    derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTIFSTAT_ERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 #include <sys/sysctl.h>
  32 #include <net/if.h>
  33 #include <net/if_mib.h>
  34
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <unistd.h>
  38 #include <err.h>
  39 #include <errno.h>
  40
  41 #include <net/altq/altq.h>
  42 #include <net/altq/altq_cbq.h>
  43 #include <net/altq/altq_priq.h>
  44 #include <net/altq/altq_hfsc.h>
  45 #include <net/altq/altq_fairq.h>
  46
  47 #include <net/pf/pfvar.h>
  48
  49 #include "systat.h"
  50 #include "extern.h"
  51 #include "convtbl.h"
  52
  53 static SLIST_HEAD(, qcol) qcols;
  54 static SLIST_HEAD(, if_stat) curlist;
  55 static int pf_fd = -1;
  56 static int qccols;
  57 static int TopSection1;
  58 static int TopSection2;
  59 static int TopSection3;
  60
  61 struct qcol {
  62         SLIST_ENTRY(qcol) link;
  63         char *qname;
  64         int col;
  65 };
  66
  67 typedef struct qcol qcol_t;
  68
  69 union class_stats {
  70         class_stats_t           cbq;
  71         struct priq_classstats  priq;
  72         struct hfsc_classstats  hfsc;
  73         struct fairq_classstats fairq;
  74 };
  75
  76 struct queue_stats {
  77         SLIST_ENTRY(queue_stats) link;
  78         struct pfioc_altq       pa;
  79         struct pfioc_qstats     pq;
  80         qcol_t                  *qc;
  81         union class_stats       ostats;
  82         union class_stats       nstats;
  83 };
  84
  85 typedef struct queue_stats queue_stats_t;
  86
  87 struct if_stat {
  88         SLIST_ENTRY(if_stat) link;
  89         SLIST_HEAD(, queue_stats) queues;
  90         char    if_name[IF_NAMESIZE];
  91         struct  ifmibdata if_mib;
  92         struct  timeval tv;
  93         struct  timeval tv_lastchanged;
  94         u_long  if_in_curtraffic;
  95         u_long  if_out_curtraffic;
  96         u_long  if_in_traffic_peak;
  97         u_long  if_out_traffic_peak;
  98         u_int   if_row;                 /* Index into ifmib sysctl */
  99         u_int   row;                    /* display row (relative) */
 100         u_int   display;
 101 };
 102
 103 typedef struct if_stat if_stat_t;
 104
 105 extern   u_int curscale;
 106
 107 static   void  load_altqs(void);
 108 static   void  print_altq(if_stat_t *p, queue_stats_t *q);
 109 static   void  right_align_string(if_stat_t *);
 110 static   void  getifmibdata(const int, struct ifmibdata *);
 111 static   void  sort_interface_list(void);
 112 static   u_int getifnum(void);
 113
 114 #define IFSTAT_ERR(n, s)        do {                                    \
 115         putchar('\f');                                                   \
 116         closealtqs(wnd);                                                \
 117         err((n), (s));                                                  \
 118 } while (0)
 119
 120 #define TOPLINE         1
 121 #define TOPQSTART       20
 122 #define TOPQWIDTH       10
 123
 124 WINDOW *
 125 openaltqs(void)
 126 {
 127         if_stat_t *p = NULL;
 128         u_int    n = 0, i = 0;
 129
 130         pf_fd = open("/dev/pf", O_RDONLY);
 131
 132         n = getifnum();         /* NOTE: can return < 0 */
 133
 134         SLIST_INIT(&curlist);
 135         SLIST_INIT(&qcols);
 136         for (i = 0; i < n; i++) {
 137                 p = (if_stat_t *)calloc(1, sizeof(if_stat_t));
 138                 if (p == NULL)
 139                         IFSTAT_ERR(1, "out of memory");
 140                 SLIST_INSERT_HEAD(&curlist, p, link);
 141                 SLIST_INIT(&p->queues);
 142                 p->if_row = i+1;
 143                 getifmibdata(p->if_row, &p->if_mib);
 144                 right_align_string(p);
 145
 146                 /*
 147                  * Initially, we only display interfaces that have
 148                  * received some traffic.
 149                  */
 150                 if (p->if_mib.ifmd_data.ifi_ibytes != 0)
 151                         p->display = 1;
 152         }
 153         load_altqs();
 154
 155         sort_interface_list();
 156
 157         return (subwin(stdscr, LINES-1-5, 0, 5, 0));
 158 }
 159
 160 void
 161 closealtqs(WINDOW *w)
 162 {
 163         if_stat_t       *node = NULL;
 164         queue_stats_t   *q;
 165
 166         while (!SLIST_EMPTY(&curlist)) {
 167                 node = SLIST_FIRST(&curlist);
 168                 SLIST_REMOVE_HEAD(&curlist, link);
 169                 while ((q = SLIST_FIRST(&node->queues)) != NULL) {
 170                         SLIST_REMOVE_HEAD(&node->queues, link);
 171                         free(q);
 172                 }
 173                 free(node);
 174         }
 175         while (!SLIST_EMPTY(&qcols)) {
 176                 qcol_t *qc = SLIST_FIRST(&qcols);
 177                 SLIST_REMOVE_HEAD(&qcols, link);
 178                 free(qc->qname);
 179                 free(qc);
 180         }
 181         qccols = 0;
 182
 183         if (w != NULL) {
 184                 wclear(w);
 185                 wrefresh(w);
 186                 delwin(w);
 187         }
 188
 189         if (pf_fd >= 0) {
 190                 close(pf_fd);
 191                 pf_fd = -1;
 192         }
 193
 194         return;
 195 }
 196
 197 void
 198 labelaltqs(void)
 199 {
 200         wmove(wnd, TOPLINE, 0);
 201         wclrtoeol(wnd);
 202 }
 203
 204 void
 205 showaltqs(void)
 206 {
 207         if_stat_t *p = NULL;
 208         queue_stats_t   *q;
 209         qcol_t          *qc;
 210
 211         mvprintw(TopSection1, 0, "        PACKETS");
 212         mvprintw(TopSection2, 0, "        BYTES");
 213         mvprintw(TopSection3, 0, "   DROPS/QLEN");
 214         SLIST_FOREACH(qc, &qcols, link) {
 215                 mvprintw(TopSection1, TOPQSTART + TOPQWIDTH * qc->col,
 216                          "%9s", qc->qname);
 217                 mvprintw(TopSection2, TOPQSTART + TOPQWIDTH * qc->col,
 218                          "%9s", qc->qname);
 219                 mvprintw(TopSection3, TOPQSTART + TOPQWIDTH * qc->col,
 220                          "%9s", qc->qname);
 221         }
 222
 223         SLIST_FOREACH(p, &curlist, link) {
 224                 if (p->display == 0)
 225                         continue;
 226                 mvprintw(TopSection1 + p->row, 0, "%s", p->if_name);
 227                 mvprintw(TopSection2 + p->row, 0, "%s", p->if_name);
 228                 mvprintw(TopSection3 + p->row, 0, "%s", p->if_name);
 229                 SLIST_FOREACH(q, &p->queues, link) {
 230                         print_altq(p, q);
 231                 }
 232         }
 233 }
 234
 235 int
 236 initaltqs(void)
 237 {
 238         TopSection1 = TOPLINE;
 239
 240         return 1;
 241 }
 242
 243 void
 244 fetchaltqs(void)
 245 {
 246         struct  if_stat *ifp = NULL;
 247         struct  timeval tv, new_tv, old_tv;
 248         double  elapsed = 0.0;
 249         u_int   new_inb, new_outb, old_inb, old_outb = 0;
 250         u_int   we_need_to_sort_interface_list = 0;
 251
 252         SLIST_FOREACH(ifp, &curlist, link) {
 253                 /*
 254                  * Grab a copy of the old input/output values before we
 255                  * call getifmibdata().
 256                  */
 257                 old_inb = ifp->if_mib.ifmd_data.ifi_ibytes;
 258                 old_outb = ifp->if_mib.ifmd_data.ifi_obytes;
 259                 ifp->tv_lastchanged = ifp->if_mib.ifmd_data.ifi_lastchange;
 260
 261                 if (gettimeofday(&new_tv, NULL) != 0)
 262                         IFSTAT_ERR(2, "error getting time of day");
 263                 (void)getifmibdata(ifp->if_row, &ifp->if_mib);
 264
 265
 266                 new_inb = ifp->if_mib.ifmd_data.ifi_ibytes;
 267                 new_outb = ifp->if_mib.ifmd_data.ifi_obytes;
 268
 269                 /* Display interface if it's received some traffic. */
 270                 if (new_inb > 0 && old_inb == 0) {
 271                         ifp->display = 1;
 272                         we_need_to_sort_interface_list++;
 273                 }
 274
 275                 /*
 276                  * The rest is pretty trivial.  Calculate the new values
 277                  * for our current traffic rates, and while we're there,
 278                  * see if we have new peak rates.
 279                  */
 280                 old_tv = ifp->tv;
 281                 timersub(&new_tv, &old_tv, &tv);
 282                 elapsed = tv.tv_sec + (tv.tv_usec * 1e-6);
 283
 284                 ifp->if_in_curtraffic = new_inb - old_inb;
 285                 ifp->if_out_curtraffic = new_outb - old_outb;
 286
 287                 /*
 288                  * Rather than divide by the time specified on the comm-
 289                  * and line, we divide by ``elapsed'' as this is likely
 290                  * to be more accurate.
 291                  */
 292                 ifp->if_in_curtraffic /= elapsed;
 293                 ifp->if_out_curtraffic /= elapsed;
 294
 295                 if (ifp->if_in_curtraffic > ifp->if_in_traffic_peak)
 296                         ifp->if_in_traffic_peak = ifp->if_in_curtraffic;
 297
 298                 if (ifp->if_out_curtraffic > ifp->if_out_traffic_peak)
 299                         ifp->if_out_traffic_peak = ifp->if_out_curtraffic;
 300
 301                 ifp->tv.tv_sec = new_tv.tv_sec;
 302                 ifp->tv.tv_usec = new_tv.tv_usec;
 303
 304         }
 305
 306         load_altqs();
 307
 308         if (we_need_to_sort_interface_list)
 309                 sort_interface_list();
 310
 311         return;
 312 }
 313
 314 /*
 315  * We want to right justify our interface names against the first column
 316  * (first sixteen or so characters), so we need to do some alignment.
 317  */
 318 static void
 319 right_align_string(if_stat_t *ifp)
 320 {
 321         int      str_len = 0, pad_len = 0;
 322         char    *newstr = NULL, *ptr = NULL;
 323
 324         if (ifp == NULL || ifp->if_mib.ifmd_name == NULL)
 325                 return;
 326         else {
 327                 /* string length + '\0' */
 328                 str_len = strlen(ifp->if_mib.ifmd_name)+1;
 329                 pad_len = IF_NAMESIZE-(str_len);
 330
 331                 newstr = ifp->if_name;
 332                 ptr = newstr + pad_len;
 333                 (void)memset((void *)newstr, (int)' ', IF_NAMESIZE);
 334                 (void)strncpy(ptr, (const char *)&ifp->if_mib.ifmd_name,
 335                               str_len);
 336         }
 337
 338         return;
 339 }
 340
 341 /*
 342  * This function iterates through our list of interfaces, identifying
 343  * those that are to be displayed (ifp->display = 1).  For each interf-
 344  * rface that we're displaying, we generate an appropriate position for
 345  * it on the screen (ifp->row).
 346  *
 347  * This function is called any time a change is made to an interface's
 348  * ``display'' state.
 349  */
 350 void
 351 sort_interface_list(void)
 352 {
 353         if_stat_t *ifp;
 354         u_int y;
 355
 356         y = 1;
 357         SLIST_FOREACH(ifp, &curlist, link) {
 358                 if (ifp->display)
 359                         ifp->row = ++y;
 360         }
 361         TopSection2 = TopSection1 + y + 4;
 362         TopSection3 = TopSection2 + y + 4;
 363 }
 364
 365 static
 366 unsigned int
 367 getifnum(void)
 368 {
 369         u_int   data    = 0;
 370         size_t  datalen = 0;
 371         static  int name[] = { CTL_NET,
 372                                PF_LINK,
 373                                NETLINK_GENERIC,
 374                                IFMIB_SYSTEM,
 375                                IFMIB_IFCOUNT };
 376
 377         datalen = sizeof(data);
 378         if (sysctl(name, 5, (void *)&data, (size_t *)&datalen, NULL,
 379             (size_t)0) != 0)
 380                 IFSTAT_ERR(1, "sysctl error");
 381         return data;
 382 }
 383
 384 static void
 385 getifmibdata(int row, struct ifmibdata *data)
 386 {
 387         size_t  datalen = 0;
 388         static  int name[] = { CTL_NET,
 389                                PF_LINK,
 390                                NETLINK_GENERIC,
 391                                IFMIB_IFDATA,
 392                                0,
 393                                IFDATA_GENERAL };
 394         datalen = sizeof(*data);
 395         name[4] = row;
 396
 397         if ((sysctl(name, 6, (void *)data, (size_t *)&datalen, NULL,
 398             (size_t)0) != 0) && (errno != ENOENT))
 399                 IFSTAT_ERR(2, "sysctl error getting interface data");
 400 }
 401
 402 static void
 403 load_altqs(void)
 404 {
 405         struct pfioc_altq pa;
 406         struct pfioc_qstats pq;
 407         if_stat_t *p;
 408         queue_stats_t *q;
 409         qcol_t *qc;
 410         int i;
 411         int n;
 412
 413         bzero(&pa, sizeof(pa));
 414         bzero(&pq, sizeof(pq));
 415
 416         if (ioctl(pf_fd, DIOCGETALTQS, &pa))
 417                 return;
 418         n = pa.nr;
 419         for (i = 0; i < n; ++i) {
 420                 pa.nr = i;
 421                 if (ioctl(pf_fd, DIOCGETALTQ, &pa))
 422                         return;
 423                 if (pa.altq.qid <= 0)
 424                         continue;
 425
 426                 SLIST_FOREACH(p, &curlist, link) {
 427                         if (strcmp(pa.altq.ifname, p->if_mib.ifmd_name) == 0)
 428                                 break;
 429                 }
 430                 if (p == NULL)
 431                         continue;
 432                 SLIST_FOREACH(q, &p->queues, link) {
 433                         if (strcmp(pa.altq.qname, q->pa.altq.qname) == 0)
 434                                 break;
 435                 }
 436                 if (q == NULL) {
 437                         q = calloc(1, sizeof(*q));
 438                         q->pa = pa;
 439                         SLIST_INSERT_HEAD(&p->queues, q, link);
 440                 } else {
 441                         q->pa.ticket = pa.ticket;
 442                 }
 443                 q->ostats = q->nstats;
 444                 q->pq.nr = i;
 445                 q->pq.ticket = q->pa.ticket;
 446                 q->pq.buf = &q->nstats;
 447                 q->pq.nbytes = sizeof(q->nstats);
 448                 if (ioctl(pf_fd, DIOCGETQSTATS, &q->pq) < 0) {
 449                         SLIST_REMOVE(&p->queues, q, queue_stats, link);
 450                         free(q);
 451                 }
 452                 SLIST_FOREACH(qc, &qcols, link) {
 453                         if (strcmp(q->pa.altq.qname, qc->qname) == 0)
 454                                 break;
 455                 }
 456                 if (qc == NULL) {
 457                         qc = calloc(1, sizeof(*qc));
 458                         qc->qname = strdup(q->pa.altq.qname);
 459                         qc->col = qccols++;
 460                         SLIST_INSERT_HEAD(&qcols, qc, link);
 461                 }
 462                 q->qc = qc;
 463         }
 464 }
 465
 466 static
 467 void
 468 print_altq(if_stat_t *p, queue_stats_t *q)
 469 {
 470         uint64_t xmit_pkts;
 471         uint64_t xmit_bytes;
 472         uint64_t drop_pkts;
 473         uint64_t drop_bytes __unused;
 474         uint64_t qlen;
 475
 476         switch(q->pa.altq.scheduler) {
 477         case ALTQT_CBQ:
 478                 xmit_pkts = q->nstats.cbq.xmit_cnt.packets;
 479                 xmit_bytes = q->nstats.cbq.xmit_cnt.bytes;
 480                 drop_pkts = q->nstats.cbq.drop_cnt.packets;
 481                 drop_bytes = q->nstats.cbq.drop_cnt.bytes;
 482                 xmit_pkts -= q->ostats.cbq.xmit_cnt.packets;
 483                 xmit_bytes -= q->ostats.cbq.xmit_cnt.bytes;
 484                 drop_pkts -= q->ostats.cbq.drop_cnt.packets;
 485                 drop_bytes -= q->ostats.cbq.drop_cnt.bytes;
 486                 qlen = 0;
 487                 break;
 488         case ALTQT_PRIQ:
 489                 xmit_pkts = q->nstats.priq.xmitcnt.packets;
 490                 xmit_bytes = q->nstats.priq.xmitcnt.bytes;
 491                 drop_pkts = q->nstats.priq.dropcnt.packets;
 492                 drop_bytes = q->nstats.priq.dropcnt.bytes;
 493                 xmit_pkts -= q->ostats.priq.xmitcnt.packets;
 494                 xmit_bytes -= q->ostats.priq.xmitcnt.bytes;
 495                 drop_pkts -= q->ostats.priq.dropcnt.packets;
 496                 drop_bytes -= q->ostats.priq.dropcnt.bytes;
 497                 qlen = q->nstats.priq.qlength;
 498                 break;
 499         case ALTQT_HFSC:
 500                 xmit_pkts = q->nstats.hfsc.xmit_cnt.packets;
 501                 xmit_bytes = q->nstats.hfsc.xmit_cnt.bytes;
 502                 drop_pkts = q->nstats.hfsc.drop_cnt.packets;
 503                 drop_bytes = q->nstats.hfsc.drop_cnt.bytes;
 504                 xmit_pkts -= q->ostats.hfsc.xmit_cnt.packets;
 505                 xmit_bytes -= q->ostats.hfsc.xmit_cnt.bytes;
 506                 drop_pkts -= q->ostats.hfsc.drop_cnt.packets;
 507                 drop_bytes -= q->ostats.hfsc.drop_cnt.bytes;
 508                 qlen = q->nstats.hfsc.qlength;
 509                 break;
 510         case ALTQT_FAIRQ:
 511                 xmit_pkts = q->nstats.fairq.xmit_cnt.packets;
 512                 xmit_bytes = q->nstats.fairq.xmit_cnt.bytes;
 513                 drop_pkts = q->nstats.fairq.drop_cnt.packets;
 514                 drop_bytes = q->nstats.fairq.drop_cnt.bytes;
 515                 xmit_pkts -= q->ostats.fairq.xmit_cnt.packets;
 516                 xmit_bytes -= q->ostats.fairq.xmit_cnt.bytes;
 517                 drop_pkts -= q->ostats.fairq.drop_cnt.packets;
 518                 drop_bytes -= q->ostats.fairq.drop_cnt.bytes;
 519                 qlen = q->nstats.fairq.qlength;
 520                 break;
 521         default:
 522                 xmit_pkts = 0;
 523                 xmit_bytes = 0;
 524                 drop_pkts = 0;
 525                 drop_bytes = 0;
 526                 qlen = 0;
 527                 break;
 528         }
 529         if (xmit_pkts == 0)
 530                 mvprintw(TopSection1 + p->row,
 531                          TOPQSTART + q->qc->col * TOPQWIDTH - 1,
 532                          "%10s", "");
 533         else
 534                 mvprintw(TopSection1 + p->row,
 535                          TOPQSTART + q->qc->col * TOPQWIDTH - 1,
 536                          "%10jd",  (intmax_t)xmit_pkts);
 537
 538         if (xmit_bytes == 0)
 539                 mvprintw(TopSection2 + p->row,
 540                          TOPQSTART + q->qc->col * TOPQWIDTH - 1,
 541                          "%10s", "");
 542         else
 543                 mvprintw(TopSection2 + p->row,
 544                          TOPQSTART + q->qc->col * TOPQWIDTH - 1,
 545                          "%10jd",  (intmax_t)xmit_bytes);
 546         if (drop_pkts)
 547                 mvprintw(TopSection3 + p->row,
 548                          TOPQSTART + q->qc->col * TOPQWIDTH - 1,
 549                          "%10jd",  (intmax_t)drop_pkts);
 550         else if (qlen)
 551                 mvprintw(TopSection3 + p->row,
 552                          TOPQSTART + q->qc->col * TOPQWIDTH - 1,
 553                          "%9jdQ",  (intmax_t)qlen);
 554         else
 555                 mvprintw(TopSection3 + p->row,
 556                          TOPQSTART + q->qc->col * TOPQWIDTH - 1,
 557                          "%10s", "");
 558 }
 559
 560 int
 561 cmdaltqs(const char *cmd, char *args)
 562 {
 563         int     retval = 0;
 564
 565         retval = ifcmd(cmd, args);
 566         /* ifcmd() returns 1 on success */
 567         if (retval == 1) {
 568                 showaltqs();
 569                 refresh();
 570         }
 571
 572         return retval;
 573 }