usr.bin/systat/iostat.c

   1 /*
   2  * Copyright (c) 1998 Kenneth D. Merry.
   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 INTERRUPTION)
  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  * Copyright (c) 1980, 1992, 1993
  30  *      The Regents of the University of California.  All rights reserved.
  31  *
  32  * Redistribution and use in source and binary forms, with or without
  33  * modification, are permitted provided that the following conditions
  34  * are met:
  35  * 1. Redistributions of source code must retain the above copyright
  36  *    notice, this list of conditions and the following disclaimer.
  37  * 2. Redistributions in binary form must reproduce the above copyright
  38  *    notice, this list of conditions and the following disclaimer in the
  39  *    documentation and/or other materials provided with the distribution.
  40  * 4. Neither the name of the University nor the names of its contributors
  41  *    may be used to endorse or promote products derived from this software
  42  *    without specific prior written permission.
  43  *
  44  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  45  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  46  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  47  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  48  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  49  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  50  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  51  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  52  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  53  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  54  * SUCH DAMAGE.
  55  */
  56
  57 #include <sys/cdefs.h>
  58
  59 __FBSDID("$FreeBSD$");
  60
  61 #ifdef lint
  62 static const char sccsid[] = "@(#)iostat.c      8.1 (Berkeley) 6/6/93";
  63 #endif
  64
  65 #include <sys/param.h>
  66 #include <sys/sysctl.h>
  67 #include <sys/resource.h>
  68
  69 #include <devstat.h>
  70 #include <err.h>
  71 #include <nlist.h>
  72 #include <paths.h>
  73 #include <stdlib.h>
  74 #include <string.h>
  75
  76 #include "systat.h"
  77 #include "extern.h"
  78 #include "devs.h"
  79
  80 struct statinfo cur, last;
  81
  82 static  int linesperregion;
  83 static  double etime;
  84 static  int numbers = 0;                /* default display bar graphs */
  85 static  int kbpt = 0;                   /* default ms/seek shown */
  86
  87 static int barlabels(int);
  88 static void histogram(long double, int, double);
  89 static int numlabels(int);
  90 static int devstats(int, int, int);
  91 static void stat1(int, int);
  92
  93 WINDOW *
  94 openiostat(void)
  95 {
  96         return (subwin(stdscr, LINES-3-1, 0, MAINWIN_ROW, 0));
  97 }
  98
  99 void
 100 closeiostat(WINDOW *w)
 101 {
 102         if (w == NULL)
 103                 return;
 104         wclear(w);
 105         wrefresh(w);
 106         delwin(w);
 107 }
 108
 109 int
 110 initiostat(void)
 111 {
 112         if ((num_devices = devstat_getnumdevs(NULL)) < 0)
 113                 return(0);
 114
 115         cur.dinfo = (struct devinfo *)malloc(sizeof(struct devinfo));
 116         last.dinfo = (struct devinfo *)malloc(sizeof(struct devinfo));
 117         bzero(cur.dinfo, sizeof(struct devinfo));
 118         bzero(last.dinfo, sizeof(struct devinfo));
 119
 120         /*
 121          * This value for maxshowdevs (100) is bogus.  I'm not sure exactly
 122          * how to calculate it, though.
 123          */
 124         if (dsinit(100, &cur, &last, NULL) != 1)
 125                 return(0);
 126
 127         return(1);
 128 }
 129
 130 void
 131 fetchiostat(void)
 132 {
 133         struct devinfo *tmp_dinfo;
 134         size_t len;
 135
 136         len = sizeof(cur.cp_time);
 137         if (sysctlbyname("kern.cp_time", &cur.cp_time, &len, NULL, 0)
 138             || len != sizeof(cur.cp_time)) {
 139                 perror("kern.cp_time");
 140                 exit (1);
 141         }
 142         tmp_dinfo = last.dinfo;
 143         last.dinfo = cur.dinfo;
 144         cur.dinfo = tmp_dinfo;
 145
 146         last.snap_time = cur.snap_time;
 147
 148         /*
 149          * Here what we want to do is refresh our device stats.
 150          * getdevs() returns 1 when the device list has changed.
 151          * If the device list has changed, we want to go through
 152          * the selection process again, in case a device that we
 153          * were previously displaying has gone away.
 154          */
 155         switch (devstat_getdevs(NULL, &cur)) {
 156         case -1:
 157                 errx(1, "%s", devstat_errbuf);
 158                 break;
 159         case 1:
 160                 cmdiostat("refresh", NULL);
 161                 break;
 162         default:
 163                 break;
 164         }
 165         num_devices = cur.dinfo->numdevs;
 166         generation = cur.dinfo->generation;
 167
 168 }
 169
 170 #define INSET   10
 171
 172 void
 173 labeliostat(void)
 174 {
 175         int row;
 176
 177         row = 0;
 178         wmove(wnd, row, 0); wclrtobot(wnd);
 179         mvwaddstr(wnd, row++, INSET,
 180             "/0%  /10  /20  /30  /40  /50  /60  /70  /80  /90  /100");
 181         mvwaddstr(wnd, row++, 0, "cpu  user|");
 182         mvwaddstr(wnd, row++, 0, "     nice|");
 183         mvwaddstr(wnd, row++, 0, "   system|");
 184         mvwaddstr(wnd, row++, 0, "interrupt|");
 185         mvwaddstr(wnd, row++, 0, "     idle|");
 186         if (numbers)
 187                 row = numlabels(row + 1);
 188         else
 189                 row = barlabels(row + 1);
 190 }
 191
 192 static int
 193 numlabels(int row)
 194 {
 195         int i, _col, regions, ndrives;
 196         char tmpstr[10];
 197
 198 #define COLWIDTH        17
 199 #define DRIVESPERLINE   ((wnd->_maxx - INSET) / COLWIDTH)
 200         for (ndrives = 0, i = 0; i < num_devices; i++)
 201                 if (dev_select[i].selected)
 202                         ndrives++;
 203         regions = howmany(ndrives, DRIVESPERLINE);
 204         /*
 205          * Deduct -regions for blank line after each scrolling region.
 206          */
 207         linesperregion = (wnd->_maxy - row - regions) / regions;
 208         /*
 209          * Minimum region contains space for two
 210          * label lines and one line of statistics.
 211          */
 212         if (linesperregion < 3)
 213                 linesperregion = 3;
 214         _col = INSET;
 215         for (i = 0; i < num_devices; i++)
 216                 if (dev_select[i].selected) {
 217                         if (_col + COLWIDTH >= wnd->_maxx - INSET) {
 218                                 _col = INSET, row += linesperregion + 1;
 219                                 if (row > wnd->_maxy - (linesperregion + 1))
 220                                         break;
 221                         }
 222                         sprintf(tmpstr, "%s%d", dev_select[i].device_name,
 223                                 dev_select[i].unit_number);
 224                         mvwaddstr(wnd, row, _col + 4, tmpstr);
 225                         mvwaddstr(wnd, row + 1, _col, "  KB/t tps  MB/s ");
 226                         _col += COLWIDTH;
 227                 }
 228         if (_col)
 229                 row += linesperregion + 1;
 230         return (row);
 231 }
 232
 233 static int
 234 barlabels(int row)
 235 {
 236         int i;
 237         char tmpstr[10];
 238
 239         mvwaddstr(wnd, row++, INSET,
 240             "/0%  /10  /20  /30  /40  /50  /60  /70  /80  /90  /100");
 241         linesperregion = 2 + kbpt;
 242         for (i = 0; i < num_devices; i++)
 243                 if (dev_select[i].selected) {
 244                         if (row > wnd->_maxy - linesperregion)
 245                                 break;
 246                         sprintf(tmpstr, "%s%d", dev_select[i].device_name,
 247                                 dev_select[i].unit_number);
 248                         mvwprintw(wnd, row++, 0, "%-5.5s MB/s|",
 249                                   tmpstr);
 250                         mvwaddstr(wnd, row++, 0, "      tps|");
 251                         if (kbpt)
 252                                 mvwaddstr(wnd, row++, 0, "     KB/t|");
 253                 }
 254         return (row);
 255 }
 256
 257
 258 void
 259 showiostat(void)
 260 {
 261         long t;
 262         int i, row, _col;
 263
 264 #define X(fld)  t = cur.fld[i]; cur.fld[i] -= last.fld[i]; last.fld[i] = t
 265         etime = 0;
 266         for(i = 0; i < CPUSTATES; i++) {
 267                 X(cp_time);
 268                 etime += cur.cp_time[i];
 269         }
 270         if (etime == 0.0)
 271                 etime = 1.0;
 272         etime /= hertz;
 273         row = 1;
 274         for (i = 0; i < CPUSTATES; i++)
 275                 stat1(row++, i);
 276         if (!numbers) {
 277                 row += 2;
 278                 for (i = 0; i < num_devices; i++)
 279                         if (dev_select[i].selected) {
 280                                 if (row > wnd->_maxy - linesperregion)
 281                                         break;
 282                                 row = devstats(row, INSET, i);
 283                         }
 284                 return;
 285         }
 286         _col = INSET;
 287         wmove(wnd, row + linesperregion, 0);
 288         wdeleteln(wnd);
 289         wmove(wnd, row + 3, 0);
 290         winsertln(wnd);
 291         for (i = 0; i < num_devices; i++)
 292                 if (dev_select[i].selected) {
 293                         if (_col + COLWIDTH >= wnd->_maxx - INSET) {
 294                                 _col = INSET, row += linesperregion + 1;
 295                                 if (row > wnd->_maxy - (linesperregion + 1))
 296                                         break;
 297                                 wmove(wnd, row + linesperregion, 0);
 298                                 wdeleteln(wnd);
 299                                 wmove(wnd, row + 3, 0);
 300                                 winsertln(wnd);
 301                         }
 302                         (void) devstats(row + 3, _col, i);
 303                         _col += COLWIDTH;
 304                 }
 305 }
 306
 307 static int
 308 devstats(int row, int _col, int dn)
 309 {
 310         long double transfers_per_second;
 311         long double kb_per_transfer, mb_per_second;
 312         long double busy_seconds;
 313         int di;
 314
 315         di = dev_select[dn].position;
 316
 317         busy_seconds = cur.snap_time - last.snap_time;
 318
 319         if (devstat_compute_statistics(&cur.dinfo->devices[di],
 320             &last.dinfo->devices[di], busy_seconds,
 321             DSM_KB_PER_TRANSFER, &kb_per_transfer,
 322             DSM_TRANSFERS_PER_SECOND, &transfers_per_second,
 323             DSM_MB_PER_SECOND, &mb_per_second, DSM_NONE) != 0)
 324                 errx(1, "%s", devstat_errbuf);
 325
 326         if (numbers) {
 327                 mvwprintw(wnd, row, _col, " %5.2Lf %3.0Lf %5.2Lf ",
 328                          kb_per_transfer, transfers_per_second,
 329                          mb_per_second);
 330                 return(row);
 331         }
 332         wmove(wnd, row++, _col);
 333         histogram(mb_per_second, 50, .5);
 334         wmove(wnd, row++, _col);
 335         histogram(transfers_per_second, 50, .5);
 336         if (kbpt) {
 337                 wmove(wnd, row++, _col);
 338                 histogram(kb_per_transfer, 50, .5);
 339         }
 340
 341         return(row);
 342
 343 }
 344
 345 static void
 346 stat1(int row, int o)
 347 {
 348         int i;
 349         double dtime;
 350
 351         dtime = 0.0;
 352         for (i = 0; i < CPUSTATES; i++)
 353                 dtime += cur.cp_time[i];
 354         if (dtime == 0.0)
 355                 dtime = 1.0;
 356         wmove(wnd, row, INSET);
 357 #define CPUSCALE        0.5
 358         histogram(100.0 * cur.cp_time[o] / dtime, 50, CPUSCALE);
 359 }
 360
 361 static void
 362 histogram(long double val, int colwidth, double scale)
 363 {
 364         char buf[10];
 365         int k;
 366         int v = (int)(val * scale) + 0.5;
 367
 368         k = MIN(v, colwidth);
 369         if (v > colwidth) {
 370                 snprintf(buf, sizeof(buf), "%5.2Lf", val);
 371                 k -= strlen(buf);
 372                 while (k--)
 373                         waddch(wnd, 'X');
 374                 waddstr(wnd, buf);
 375                 return;
 376         }
 377         while (k--)
 378                 waddch(wnd, 'X');
 379         wclrtoeol(wnd);
 380 }
 381
 382 int
 383 cmdiostat(const char *cmd, const char *args)
 384 {
 385
 386         if (prefix(cmd, "kbpt"))
 387                 kbpt = !kbpt;
 388         else if (prefix(cmd, "numbers"))
 389                 numbers = 1;
 390         else if (prefix(cmd, "bars"))
 391                 numbers = 0;
 392         else if (!dscmd(cmd, args, 100, &cur))
 393                 return (0);
 394         wclear(wnd);
 395         labeliostat();
 396         refresh();
 397         return (1);
 398 }