2.11BSD#431 - /usr/src/ucb/PORT/systat/vmstat.c

   1: /*
   2:  * Copyright (c) 1983 Regents of the University of California.
   3:  * All rights reserved.  The Berkeley software License Agreement
   4:  * specifies the terms and conditions for redistribution.
   5:  */
   6: 
   7: #ifndef lint
   8: static char sccsid[] = "@(#)vmstat.c	5.7 (Berkeley) 4/29/86";
   9: #endif not lint
  10: 
  11: /*
  12:  * Cursed vmstat -- from Robert Elz.
  13:  */
  14: 
  15: #include "systat.h"
  16: 
  17: #include <ctype.h>
  18: #include <utmp.h>
  19: 
  20: #include <sys/vm.h>
  21: #include <sys/buf.h>
  22: #include <sys/stat.h>
  23: #include <sys/dir.h>
  24: #include <sys/user.h>
  25: #include <sys/proc.h>
  26: #include <sys/namei.h>
  27: 
  28: #include <vax/pte.h>
  29: 
  30: static  int ut;
  31: 
  32: WINDOW *
  33: openkre()
  34: {
  35: 
  36:     ut = open("/etc/utmp", O_RDONLY);
  37:     if (ut < 0)
  38:         error("No utmp");
  39:         return (stdscr);
  40: }
  41: 
  42: closekre(w)
  43:         WINDOW *w;
  44: {
  45: 
  46:     (void) close(ut);
  47:         if (w == NULL)
  48:                 return;
  49:         wclear(w);
  50:         wrefresh(w);
  51: }
  52: 
  53: long    time();
  54: float   cputime();
  55: struct  utmp utmp;
  56: 
  57: static struct nlist name[] = {
  58:     { "_cp_time" },
  59: #define X_CPTIME    0
  60:     { "_rate" },
  61: #define X_RATE      1
  62:     { "_total" },
  63: #define X_TOTAL     2
  64:     { "_proc" },
  65: #define X_PROC      3
  66:     { "_nproc" },
  67: #define X_NPROC     4
  68:     { "_sum" },
  69: #define X_SUM       5
  70:     { "_dk_busy" },
  71: #define X_DK_BUSY   6
  72:     { "_dk_time" },
  73: #define X_DK_TIME   7
  74:     { "_dk_xfer" },
  75: #define X_DK_XFER   8
  76:     { "_dk_wds" },
  77: #define X_DK_WDS    9
  78:     { "_tk_nin" },
  79: #define X_TK_NIN    10
  80:     { "_tk_nout" },
  81: #define X_TK_NOUT   11
  82:     { "_dk_seek" },
  83: #define X_DK_SEEK   12
  84:     { "_nchstats" },
  85: #define X_NCHSTATS  13
  86:     { "_intrnames" },
  87: #define X_INTRNAMES 14
  88:     { "_eintrnames" },
  89: #define X_EINTRNAMES    15
  90:     { "_intrcnt" },
  91: #define X_INTRCNT   16
  92:     { "_eintrcnt" },
  93: #define X_EINTRCNT  17
  94:     { "" },
  95: };
  96: 
  97: static struct Info {
  98:     long    time[CPUSTATES];
  99:     struct  vmmeter Rate;
 100:     struct  vmtotal Total;
 101:     struct  vmmeter Sum;
 102:     struct  forkstat Forkstat;
 103:     long    *dk_time;
 104:     long    *dk_wds;
 105:     long    *dk_seek;
 106:     long    *dk_xfer;
 107:     int dk_busy;
 108:     long    tk_nin;
 109:     long    tk_nout;
 110:     struct  nchstats nchstats;
 111:     long    nchcount;
 112:     long    *intrcnt;
 113: } s, s1, s2, z;
 114: 
 115: #define total s.Total
 116: #define sum s.Sum
 117: #define sumold s1.Sum
 118: #define rate s.Rate
 119: #define nchtotal s.nchstats
 120: #define oldnchtotal s1.nchstats
 121: #define oldrate s1.Rate
 122: 
 123: static  char buf[26];
 124: static  time_t t;
 125: static  double etime;
 126: static  float hertz;
 127: static  int nintr;
 128: static  long *intrloc;
 129: static  char **intrname;
 130: static  int nextintsrow;
 131: 
 132: static  enum state { BOOT, TIME, RUN } state = TIME;
 133: 
 134: /*
 135:  * These constants define where the major pieces are laid out
 136:  */
 137: #define PROCSROW    13  /* uses 2 rows and 20 cols */
 138: #define PROCSCOL     0
 139: #define NAMEIROW    20  /* uses 3 rows and 38 cols */
 140: #define NAMEICOL     0
 141: #define GRAPHROW    16  /* uses 3 rows and 51 cols */
 142: #define GRAPHCOL     0
 143: #define GENSTATROW  14  /* uses 8 rows and 11 cols */
 144: #define GENSTATCOL  51
 145: #define INTSROW      2  /* uses all rows to bottom and 17 cols */
 146: #define INTSCOL     63
 147: #define STATROW      0  /* uses 1 row and 68 cols */
 148: #define STATCOL      2
 149: #define PAGEROW      2  /* uses 11 rows and 26 cols */
 150: #define PAGECOL     36
 151: #define MEMROW       2  /* uses 4 rows and 31 cols */
 152: #define MEMCOL       0
 153: #define DISKROW      7  /* uses 5 rows and 35 cols */
 154: #define DISKCOL      0
 155: 
 156: initkre()
 157: {
 158:     char *intrnamebuf, *cp;
 159:     int i;
 160:     static int once = 0;
 161: 
 162:     if (name[0].n_type == 0) {
 163:         nlist("/vmunix",name);
 164:         if (name[0].n_type == 0) {
 165:             error("No namelist");
 166:             return(0);
 167:         }
 168:     }
 169:     hertz = phz ? phz : hz;
 170:     if (! dkinit())
 171:         return(0);
 172:     if (dk_ndrive && !once) {
 173: #define allocate(e, t) \
 174:     s./**/e = (t *)calloc(dk_ndrive, sizeof (t)); \
 175:     s1./**/e = (t *)calloc(dk_ndrive, sizeof (t)); \
 176:     s2./**/e = (t *)calloc(dk_ndrive, sizeof (t)); \
 177:     z./**/e = (t *)calloc(dk_ndrive, sizeof (t));
 178:         allocate(dk_time, long);
 179:         allocate(dk_wds, long);
 180:         allocate(dk_seek, long);
 181:         allocate(dk_xfer, long);
 182:         once = 1;
 183: #undef allocate
 184:     }
 185:     if (nintr == 0) {
 186:         nintr = (name[X_EINTRCNT].n_value -
 187:             name[X_INTRCNT].n_value) / sizeof (long);
 188:         intrloc = (long *) calloc(nintr, sizeof (long));
 189:         intrname = (char **) calloc(nintr, sizeof (long));
 190:         intrnamebuf = malloc(name[X_EINTRNAMES].n_value -
 191:             name[X_INTRNAMES].n_value);
 192:         if (intrnamebuf == 0 || intrname == 0 || intrloc == 0) {
 193:             error("Out of memory\n");
 194:             if (intrnamebuf)
 195:                 free(intrnamebuf);
 196:             if (intrname)
 197:                 free(intrname);
 198:             if (intrloc)
 199:                 free(intrloc);
 200:             nintr = 0;
 201:             return(0);
 202:         }
 203:         lseek(kmem, (long)name[X_INTRNAMES].n_value, L_SET);
 204:         read(kmem, intrnamebuf, name[X_EINTRNAMES].n_value -
 205:             name[X_INTRNAMES].n_value);
 206:         for (cp = intrnamebuf, i = 0; i < nintr; i++) {
 207:             intrname[i] = cp;
 208:             cp += strlen(cp) + 1;
 209:         }
 210:         nextintsrow = INTSROW + 2;
 211:         allocinfo(&s);
 212:         allocinfo(&s1);
 213:         allocinfo(&s2);
 214:         allocinfo(&z);
 215:     }
 216:     getinfo(&s2, RUN);
 217:     copyinfo(&s2, &s1);
 218:     return(1);
 219: }
 220: 
 221: fetchkre()
 222: {
 223:     time_t now;
 224: 
 225:     time(&now);
 226:     strcpy(buf, ctime(&now));
 227:     buf[16] = '\0';
 228:     getinfo(&s, state);
 229: }
 230: 
 231: #define MAXDRIVES   6       /* max # to display */
 232: 
 233: labelkre()
 234: {
 235:     register i, j;
 236: 
 237:     clear();
 238:     mvprintw(STATROW, STATCOL + 4, "users    Load");
 239:     mvprintw(MEMROW, MEMCOL, "Mem     REAL     VIRTUAL");
 240:     mvprintw(MEMROW + 1, MEMCOL, "      Tot Text   Tot Text");
 241:     mvprintw(MEMROW + 2, MEMCOL, "Act");
 242:     mvprintw(MEMROW + 3, MEMCOL, "All");
 243: 
 244:     mvprintw(MEMROW + 1, MEMCOL + 28, "Free");
 245: 
 246:     mvprintw(PAGEROW, PAGECOL, "        PAGING    SWAPING ");
 247:     mvprintw(PAGEROW + 1, PAGECOL, "        in  out   in  out ");
 248:     mvprintw(PAGEROW + 2, PAGECOL, "count");
 249:     mvprintw(PAGEROW + 3, PAGECOL, "pages");
 250: 
 251:     mvprintw(INTSROW, INTSCOL, " Interrupts");
 252:     mvprintw(INTSROW + 1, INTSCOL + 9, "total");
 253: 
 254:     mvprintw(GENSTATROW, GENSTATCOL + 8, "Csw");
 255:     mvprintw(GENSTATROW + 1, GENSTATCOL + 8, "Trp");
 256:     mvprintw(GENSTATROW + 2, GENSTATCOL + 8, "Sys");
 257:     mvprintw(GENSTATROW + 3, GENSTATCOL + 8, "Int");
 258:     mvprintw(GENSTATROW + 4, GENSTATCOL + 8, "Pdm");
 259:     mvprintw(GENSTATROW + 5, GENSTATCOL + 8, "Flt");
 260:     mvprintw(GENSTATROW + 6, GENSTATCOL + 8, "Scn");
 261:     mvprintw(GENSTATROW + 7, GENSTATCOL + 8, "Rev");
 262: 
 263:     mvprintw(PAGEROW + 5, PAGECOL, "Rec It F/S F/F RFL Fre SFr");
 264: 
 265:     mvprintw(PAGEROW + 8, PAGECOL + 9, " zf");
 266:     mvprintw(PAGEROW + 9, PAGECOL + 9, "nzf");
 267:     mvprintw(PAGEROW + 10, PAGECOL + 9, "%%zf");
 268:     mvprintw(PAGEROW + 8, PAGECOL + 23, " xf");
 269:     mvprintw(PAGEROW + 9, PAGECOL + 23, "nxf");
 270:     mvprintw(PAGEROW + 10, PAGECOL + 23, "%%xf");
 271: 
 272:     mvprintw(GRAPHROW, GRAPHCOL,
 273:         "    . %% Sys    . %% User    . %% Nice    . %% Idle");
 274:     mvprintw(PROCSROW, PROCSCOL, "Procs  r  p  d  s  w");
 275:     mvprintw(GRAPHROW + 1, GRAPHCOL,
 276:         "|    |    |    |    |    |    |    |    |    |    |");
 277: 
 278:     mvprintw(NAMEIROW, NAMEICOL, "Namei         Sys-cache     Proc-cache");
 279:     mvprintw(NAMEIROW + 1, NAMEICOL,
 280:         "    Calls     hits    %%     hits     %%");
 281:     mvprintw(DISKROW, DISKCOL, "Discs");
 282:     mvprintw(DISKROW + 1, DISKCOL, "seeks");
 283:     mvprintw(DISKROW + 2, DISKCOL, "xfers");
 284:     mvprintw(DISKROW + 3, DISKCOL, " blks");
 285:     mvprintw(DISKROW + 4, DISKCOL, " msps");
 286:     j = 0;
 287:     for (i = 0; i < dk_ndrive && j < MAXDRIVES; i++)
 288:         if (dk_select[i]) {
 289:             mvprintw(DISKROW, DISKCOL + 5 + 5 * j,
 290:                 "  %3.3s", dr_name[j]);
 291:             j++;
 292:         }
 293:     for (i = 0; i < nintr; i++) {
 294:         if (intrloc[i] == 0)
 295:             continue;
 296:         mvprintw(intrloc[i], INTSCOL + 9, "%-8.8s", intrname[i]);
 297:     }
 298: }
 299: 
 300: #define X(fld)  {t=s.fld[i]; s.fld[i]-=s1.fld[i]; if(state==TIME) s1.fld[i]=t;}
 301: #define Y(fld)  {t = s.fld; s.fld -= s1.fld; if(state == TIME) s1.fld = t;}
 302: #define Z(fld)  {t = s.nchstats.fld; s.nchstats.fld -= s1.nchstats.fld; \
 303:     if(state == TIME) s1.nchstats.fld = t;}
 304: #define MAXFAIL 5
 305: 
 306: static  char cpuchar[CPUSTATES] = { '=' , '>', '-', ' ' };
 307: static  char cpuorder[CPUSTATES] = { CP_SYS, CP_USER, CP_NICE, CP_IDLE };
 308: 
 309: showkre()
 310: {
 311:     float f1, f2;
 312:     int psiz, inttotal;
 313:     int i, l, c;
 314:     static int failcnt = 0;
 315: 
 316:     for (i = 0; i < dk_ndrive; i++) {
 317:         X(dk_xfer); X(dk_seek); X(dk_wds); X(dk_time);
 318:     }
 319:     Y(tk_nin); Y(tk_nout);
 320:     etime = 0;
 321:     for(i = 0; i < CPUSTATES; i++) {
 322:         X(time);
 323:         etime += s.time[i];
 324:     }
 325:     if (etime < 5.0) {  /* < 5 ticks - ignore this trash */
 326:         if (failcnt++ >= MAXFAIL) {
 327:             clear();
 328:             mvprintw(2, 10, "The alternate system clock has died!");
 329:             mvprintw(3, 10, "Reverting to ``pigs'' display.");
 330:             move(CMDLINE, 0);
 331:             refresh();
 332:             failcnt = 0;
 333:             sleep(5);
 334:             command("pigs");
 335:         }
 336:         return;
 337:     }
 338:     failcnt = 0;
 339:     etime /= hertz;
 340:     inttotal = 0;
 341:     for (i = 0; i < nintr; i++) {
 342:         if (s.intrcnt[i] == 0)
 343:             continue;
 344:         if (intrloc[i] == 0) {
 345:             if (nextintsrow == LINES)
 346:                 continue;
 347:             intrloc[i] = nextintsrow++;
 348:             mvprintw(intrloc[i], INTSCOL + 9, "%-8.8s",
 349:                 intrname[i]);
 350:         }
 351:         X(intrcnt);
 352:         l = (int)((float)s.intrcnt[i]/etime + 0.5);
 353:         inttotal += l;
 354:         putint(l, intrloc[i], INTSCOL, 8);
 355:     }
 356:     putint(inttotal, INTSROW + 1, INTSCOL, 8);
 357:     Z(ncs_goodhits); Z(ncs_badhits); Z(ncs_miss);
 358:     Z(ncs_long); Z(ncs_pass2); Z(ncs_2passes);
 359:     s.nchcount = nchtotal.ncs_goodhits + nchtotal.ncs_badhits +
 360:         nchtotal.ncs_miss + nchtotal.ncs_long;
 361:     if (state == TIME)
 362:         s1.nchcount = s.nchcount;
 363: 
 364:     psiz = 0;
 365:     f2 = 0.0;
 366:     for (c = 0; c < CPUSTATES; c++) {
 367:         i = cpuorder[c];
 368:         f1 = cputime(i);
 369:         f2 += f1;
 370:         l = (int) ((f2 + 1.0) / 2.0) - psiz;
 371:         if (c == 0)
 372:             putfloat(f1, GRAPHROW, GRAPHCOL + 1, 5, 1, 0);
 373:         else
 374:             putfloat(f1, GRAPHROW, GRAPHCOL + 12 * c,
 375:                 5, 1, 0);
 376:         move(GRAPHROW + 2, psiz);
 377:         psiz += l;
 378:         while (l-- > 0)
 379:             addch(cpuchar[c]);
 380:     }
 381: 
 382:     putint(ucount(), STATROW, STATCOL, 3);
 383:     putfloat(avenrun[0], STATROW, STATCOL + 17, 6, 2, 0);
 384:     putfloat(avenrun[1], STATROW, STATCOL + 23, 6, 2, 0);
 385:     putfloat(avenrun[2], STATROW, STATCOL + 29, 6, 2, 0);
 386:     mvaddstr(STATROW, STATCOL + 53, buf);
 387:     putint(total.t_arm/2, MEMROW + 2, MEMCOL + 4, 5);
 388:     putint(total.t_armtxt/2, MEMROW + 2, MEMCOL + 9, 5);
 389:     putint(total.t_avm/2, MEMROW + 2, MEMCOL + 14, 6);
 390:     putint(total.t_avmtxt/2, MEMROW + 2, MEMCOL + 20, 5);
 391:     putint(total.t_rm/2, MEMROW + 3, MEMCOL + 4, 5);
 392:     putint(total.t_rmtxt/2, MEMROW + 3, MEMCOL + 9, 5);
 393:     putint(total.t_vm/2, MEMROW + 3, MEMCOL + 14, 6);
 394:     putint(total.t_vmtxt/2, MEMROW + 3, MEMCOL + 20, 5);
 395:     putint(total.t_free/2, MEMROW + 2, MEMCOL + 27, 5);
 396:     putint(total.t_rq, PROCSROW + 1, PROCSCOL + 5, 3);
 397:     putint(total.t_pw, PROCSROW + 1, PROCSCOL + 8, 3);
 398:     putint(total.t_dw, PROCSROW + 1, PROCSCOL + 11, 3);
 399:     putint(total.t_sl, PROCSROW + 1, PROCSCOL + 14, 3);
 400:     putint(total.t_sw, PROCSROW + 1, PROCSCOL + 17, 3);
 401:     putrate(rate.v_swtch, oldrate.v_swtch,
 402:         GENSTATROW, GENSTATCOL, 7);
 403:     putrate(rate.v_trap, oldrate.v_trap,
 404:         GENSTATROW + 1, GENSTATCOL, 7);
 405:     putrate(rate.v_syscall, oldrate.v_syscall,
 406:         GENSTATROW + 2, GENSTATCOL, 7);
 407:     putrate(rate.v_intr, oldrate.v_intr,
 408:         GENSTATROW + 3, GENSTATCOL, 7);
 409:     putrate(rate.v_pdma, oldrate.v_pdma,
 410:         GENSTATROW + 4, GENSTATCOL, 7);
 411:     putrate(rate.v_faults, oldrate.v_faults,
 412:         GENSTATROW + 5, GENSTATCOL, 7);
 413:     putrate(rate.v_scan, oldrate.v_scan,
 414:         GENSTATROW + 6, GENSTATCOL, 7);
 415:     putrate(rate.v_rev, oldrate.v_rev,
 416:         GENSTATROW + 7, GENSTATCOL, 7);
 417:     putrate(rate.v_pgin, oldrate.v_pgin, PAGEROW + 2,
 418:         PAGECOL + 5, 5);
 419:     putrate(rate.v_pgout, oldrate.v_pgout, PAGEROW + 2,
 420:         PAGECOL + 10, 5);
 421:     putrate(rate.v_swpin, oldrate.v_swpin, PAGEROW + 2,
 422:         PAGECOL + 15, 5);
 423:     putrate(rate.v_swpout, oldrate.v_swpout, PAGEROW + 2,
 424:         PAGECOL + 20, 5);
 425:     putrate(rate.v_pgpgin, oldrate.v_pgpgin, PAGEROW + 3,
 426:         PAGECOL + 5, 5);
 427:     putrate(rate.v_pgpgout, oldrate.v_pgpgout, PAGEROW + 3,
 428:         PAGECOL + 10, 5);
 429:     putrate(rate.v_pswpin, oldrate.v_pswpin, PAGEROW + 3,
 430:         PAGECOL + 15, 5);
 431:     putrate(rate.v_pswpout, oldrate.v_pswpout, PAGEROW + 3,
 432:         PAGECOL + 20, 5);
 433:     putrate(rate.v_pgrec, oldrate.v_pgrec, PAGEROW + 6, PAGECOL, 3);
 434:     putrate(rate.v_intrans, oldrate.v_intrans, PAGEROW + 6,
 435:         PAGECOL + 4, 2);
 436:     putrate(rate.v_xsfrec, oldrate.v_xsfrec, PAGEROW + 6,
 437:         PAGECOL + 7, 3);
 438:     putrate(rate.v_xifrec, oldrate.v_xifrec, PAGEROW + 6,
 439:         PAGECOL + 11, 3);
 440:     putrate(rate.v_pgfrec, oldrate.v_pgfrec, PAGEROW + 6,
 441:         PAGECOL + 15, 3);
 442:     putrate(rate.v_dfree, oldrate.v_dfree, PAGEROW + 6,
 443:         PAGECOL + 19, 3);
 444:     putrate(rate.v_seqfree, oldrate.v_seqfree, PAGEROW + 6,
 445:         PAGECOL + 23, 3);
 446:     putrate(rate.v_zfod, oldrate.v_zfod, PAGEROW + 8, PAGECOL, 8);
 447:     putrate(rate.v_nzfod, oldrate.v_nzfod, PAGEROW + 9, PAGECOL, 8);
 448:     putrate(rate.v_exfod, oldrate.v_exfod, PAGEROW + 8,
 449:         PAGECOL + 14, 8);
 450:     putrate(rate.v_nexfod, oldrate.v_nexfod, PAGEROW + 9,
 451:         PAGECOL + 14, 8);
 452:     putfloat (
 453:         rate.v_nzfod == 0 ?
 454:             0.0
 455:         : state != RUN ?
 456:             ( 100.0 * rate.v_zfod / rate.v_nzfod )
 457:         : rate.v_nzfod == oldrate.v_nzfod ?
 458:             0.0
 459:         :
 460:             ( 100.0 * (rate.v_zfod-oldrate.v_zfod)
 461:             / (rate.v_nzfod-oldrate.v_nzfod) )
 462:         , PAGEROW + 10
 463:         , PAGECOL
 464:         , 8
 465:         , 2
 466:         , 1
 467:     );
 468:     putfloat (
 469:         rate.v_nexfod == 0 ?
 470:             0.0
 471:         : state != RUN ?
 472:             ( 100.0 * rate.v_exfod / rate.v_nexfod )
 473:         : rate.v_nexfod == oldrate.v_nexfod ?
 474:             0.0
 475:         :
 476:             ( 100.0 * (rate.v_exfod-oldrate.v_exfod)
 477:             / (rate.v_nexfod-oldrate.v_nexfod) )
 478:         , PAGEROW + 10
 479:         , PAGECOL + 14
 480:         , 8
 481:         , 2
 482:         , 1
 483:     );
 484:     c = 0;
 485:     for (i = 0; i < dk_ndrive && c < MAXDRIVES; i++)
 486:         if (dk_select[i])
 487:             dinfo(i, ++c);
 488: 
 489:     putint(s.nchcount, NAMEIROW + 2, NAMEICOL, 9);
 490:     putint(nchtotal.ncs_goodhits, NAMEIROW + 2, NAMEICOL + 9, 9);
 491: #define nz(x)   ((x) ? (x) : 1)
 492:     putfloat(nchtotal.ncs_goodhits * 100.0 / nz(s.nchcount),
 493:        NAMEIROW + 2, NAMEICOL + 19, 4, 0, 1);
 494:     putint(nchtotal.ncs_pass2, NAMEIROW + 2, NAMEICOL + 23, 9);
 495:     putfloat(nchtotal.ncs_pass2 * 100.0 / nz(s.nchcount),
 496:        NAMEIROW + 2, NAMEICOL + 34, 4, 0, 1);
 497: #undef nz
 498: }
 499: 
 500: cmdkre(cmd, args)
 501:     char *cmd, *args;
 502: {
 503: 
 504:     if (prefix(cmd, "run")) {
 505:         copyinfo(&s2, &s1);
 506:         state = RUN;
 507:         return (1);
 508:     }
 509:     if (prefix(cmd, "boot")) {
 510:         state = BOOT;
 511:         copyinfo(&z, &s1);
 512:         return (1);
 513:     }
 514:     if (prefix(cmd, "time")) {
 515:         state = TIME;
 516:         return (1);
 517:     }
 518:     if (prefix(cmd, "zero")) {
 519:         if (state == RUN)
 520:             getinfo(&s1, RUN);
 521:         return (1);
 522:     }
 523:     return (dkcmd(cmd, args));
 524: }
 525: 
 526: /* calculate number of users on the system */
 527: static
 528: ucount()
 529: {
 530:     register int nusers = 0;
 531: 
 532:     if (ut < 0)
 533:         return (0);
 534:     while (read(ut, &utmp, sizeof(utmp)))
 535:         if (utmp.ut_name[0] != '\0')
 536:             nusers++;
 537: 
 538:     lseek(ut, 0L, L_SET);
 539:     return (nusers);
 540: }
 541: 
 542: static float
 543: cputime(indx)
 544:     int indx;
 545: {
 546:     double t;
 547:     register i;
 548: 
 549:     t = 0;
 550:     for (i = 0; i < CPUSTATES; i++)
 551:         t += s.time[i];
 552:     if (t == 0.0)
 553:         t = 1.0;
 554:     return (s.time[indx] * 100.0 / t);
 555: }
 556: 
 557: static
 558: putrate(r, or, l, c, w)
 559: {
 560: 
 561:     if (state != TIME) {
 562:         if (state == RUN)
 563:             r -= or;
 564:         putint((int)((float)r/etime + 0.5), l, c, w);
 565:     } else
 566:         putint(r, l, c, w);
 567: }
 568: 
 569: static
 570: putint(n, l, c, w)
 571: {
 572:     char b[128];
 573: 
 574:     move(l, c);
 575:     if (n == 0) {
 576:         while (w-- > 0)
 577:             addch(' ');
 578:         return;
 579:     }
 580:     sprintf(b, "%*d", w, n);
 581:     if (strlen(b) > w) {
 582:         while (w-- > 0)
 583:             addch('*');
 584:         return;
 585:     }
 586:     addstr(b);
 587: }
 588: 
 589: static
 590: putfloat(f, l, c, w, d, nz)
 591:     float f;
 592: {
 593:     char b[128];
 594: 
 595:     move(l, c);
 596:     if (nz && f == 0.0) {
 597:         while (w-- > 0)
 598:             addch(' ');
 599:         return;
 600:     }
 601:     sprintf(b, "%*.*f", w, d, f);
 602:     if (strlen(b) > w) {
 603:         while (w-- > 0)
 604:             addch('*');
 605:         return;
 606:     }
 607:     addstr(b);
 608: }
 609: 
 610: static
 611: getinfo(s, st)
 612:     struct Info *s;
 613:     enum state st;
 614: {
 615: 
 616:     lseek(kmem, (long)name[X_CPTIME].n_value,L_SET);
 617:     read(kmem, s->time, sizeof s->time);
 618:     if (st != TIME) {
 619:         lseek(kmem, (long)name[X_SUM].n_value, L_SET);
 620:         read(kmem, &s->Rate, sizeof s->Rate);
 621:     } else {
 622:         lseek(kmem, (long)name[X_RATE].n_value,L_SET);
 623:         read(kmem, &s->Rate, sizeof s->Rate);
 624:     }
 625:     lseek(kmem, (long)name[X_TOTAL].n_value, L_SET);
 626:     read(kmem, &s->Total, sizeof s->Total);
 627:     s->dk_busy = getw(name[X_DK_BUSY].n_value);
 628:     lseek(kmem, (long)name[X_DK_TIME].n_value,  L_SET);
 629:     read(kmem, s->dk_time, dk_ndrive * sizeof (long));
 630:     lseek(kmem, (long)name[X_DK_XFER].n_value,  L_SET);
 631:     read(kmem, s->dk_xfer, dk_ndrive * sizeof (long));
 632:     lseek(kmem, (long)name[X_DK_WDS].n_value,  L_SET);
 633:     read(kmem, s->dk_wds, dk_ndrive * sizeof (long));
 634:     lseek(kmem, (long)name[X_DK_SEEK].n_value,  L_SET);
 635:     read(kmem, s->dk_seek, dk_ndrive * sizeof (long));
 636:     s->tk_nin = getw(name[X_TK_NIN].n_value);
 637:     s->tk_nout = getw(name[X_TK_NOUT].n_value);
 638:     lseek(kmem, (long)name[X_NCHSTATS].n_value,  L_SET);
 639:     read(kmem, &s->nchstats, sizeof s->nchstats);
 640:     lseek(kmem, (long)name[X_INTRCNT].n_value,  L_SET);
 641:     read(kmem, s->intrcnt, nintr * sizeof (long));
 642: }
 643: 
 644: static
 645: allocinfo(s)
 646:     struct Info *s;
 647: {
 648: 
 649:     s->intrcnt = (long *) malloc(nintr * sizeof(long));
 650:     if (s->intrcnt == NULL) {
 651:         fprintf(stderr, "systat: out of memory\n");
 652:         exit(2);
 653:     }
 654: }
 655: 
 656: static
 657: copyinfo(from, to)
 658:     register struct Info *from, *to;
 659: {
 660:     long *time, *wds, *seek, *xfer;
 661:     long *intrcnt;
 662: 
 663:     time = to->dk_time; wds = to->dk_wds; seek = to->dk_seek;
 664:     xfer = to->dk_xfer; intrcnt = to->intrcnt;
 665:     *to = *from;
 666:     bcopy(from->dk_time, to->dk_time = time, dk_ndrive * sizeof (long));
 667:     bcopy(from->dk_wds, to->dk_wds = wds, dk_ndrive * sizeof (long));
 668:     bcopy(from->dk_seek, to->dk_seek = seek, dk_ndrive * sizeof (long));
 669:     bcopy(from->dk_xfer, to->dk_xfer = xfer, dk_ndrive * sizeof (long));
 670:     bcopy(from->intrcnt, to->intrcnt = intrcnt, nintr * sizeof (int));
 671: }
 672: 
 673: static
 674: dinfo(dn, c)
 675: {
 676:     double words, atime, itime, xtime;
 677: 
 678:     c = DISKCOL + c * 5;
 679:     atime = s.dk_time[dn];
 680:     atime /= hertz;
 681:     words = s.dk_wds[dn]*32.0;  /* number of words transferred */
 682:     xtime = dk_mspw[dn]*words;  /* transfer time */
 683:     itime = atime - xtime;      /* time not transferring */
 684:     if (xtime < 0)
 685:         itime += xtime, xtime = 0;
 686:     if (itime < 0)
 687:         xtime += itime, itime = 0;
 688:     putint((int)((float)s.dk_seek[dn]/etime+0.5), DISKROW + 1, c, 5);
 689:     putint((int)((float)s.dk_xfer[dn]/etime+0.5), DISKROW + 2, c, 5);
 690:     putint((int)(words/etime/512.0 + 0.5), DISKROW + 3, c, 5);
 691:     if (s.dk_seek[dn])
 692:         putfloat(itime*1000.0/s.dk_seek[dn], DISKROW + 4, c, 5, 1, 1);
 693:     else
 694:         putint(0, DISKROW + 4, c, 5);
 695: }

Defined functions

Defined variables

Defined struct's

Defined enum's

Defined macros