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