![[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] / 43BSDTahoe / ucb / systat|
Return to vmstat.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / systat |
1.1 ! root 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.9 (Berkeley) 10/3/87"; ! 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 <machine/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 9 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, "Sof"); ! 260: mvprintw(GENSTATROW + 6, GENSTATCOL + 8, "Flt"); ! 261: mvprintw(GENSTATROW + 7, GENSTATCOL + 8, "Scn"); ! 262: mvprintw(GENSTATROW + 8, GENSTATCOL + 8, "Rev"); ! 263: ! 264: mvprintw(PAGEROW + 5, PAGECOL, "Rec It F/S F/F RFL Fre SFr"); ! 265: ! 266: mvprintw(PAGEROW + 8, PAGECOL + 9, " zf"); ! 267: mvprintw(PAGEROW + 9, PAGECOL + 9, "nzf"); ! 268: mvprintw(PAGEROW + 10, PAGECOL + 9, "%%zf"); ! 269: mvprintw(PAGEROW + 8, PAGECOL + 23, " xf"); ! 270: mvprintw(PAGEROW + 9, PAGECOL + 23, "nxf"); ! 271: mvprintw(PAGEROW + 10, PAGECOL + 23, "%%xf"); ! 272: ! 273: mvprintw(GRAPHROW, GRAPHCOL, ! 274: " . %% Sys . %% User . %% Nice . %% Idle"); ! 275: mvprintw(PROCSROW, PROCSCOL, "Procs r p d s w"); ! 276: mvprintw(GRAPHROW + 1, GRAPHCOL, ! 277: "| | | | | | | | | | |"); ! 278: ! 279: mvprintw(NAMEIROW, NAMEICOL, "Namei Sys-cache Proc-cache"); ! 280: mvprintw(NAMEIROW + 1, NAMEICOL, ! 281: " Calls hits %% hits %%"); ! 282: mvprintw(DISKROW, DISKCOL, "Discs"); ! 283: mvprintw(DISKROW + 1, DISKCOL, "seeks"); ! 284: mvprintw(DISKROW + 2, DISKCOL, "xfers"); ! 285: mvprintw(DISKROW + 3, DISKCOL, " blks"); ! 286: mvprintw(DISKROW + 4, DISKCOL, " msps"); ! 287: j = 0; ! 288: for (i = 0; i < dk_ndrive && j < MAXDRIVES; i++) ! 289: if (dk_select[i]) { ! 290: mvprintw(DISKROW, DISKCOL + 5 + 5 * j, ! 291: " %3.3s", dr_name[j]); ! 292: j++; ! 293: } ! 294: for (i = 0; i < nintr; i++) { ! 295: if (intrloc[i] == 0) ! 296: continue; ! 297: mvprintw(intrloc[i], INTSCOL + 9, "%-8.8s", intrname[i]); ! 298: } ! 299: } ! 300: ! 301: #define X(fld) {t=s.fld[i]; s.fld[i]-=s1.fld[i]; if(state==TIME) s1.fld[i]=t;} ! 302: #define Y(fld) {t = s.fld; s.fld -= s1.fld; if(state == TIME) s1.fld = t;} ! 303: #define Z(fld) {t = s.nchstats.fld; s.nchstats.fld -= s1.nchstats.fld; \ ! 304: if(state == TIME) s1.nchstats.fld = t;} ! 305: #define MAXFAIL 5 ! 306: ! 307: static char cpuchar[CPUSTATES] = { '=' , '>', '-', ' ' }; ! 308: static char cpuorder[CPUSTATES] = { CP_SYS, CP_USER, CP_NICE, CP_IDLE }; ! 309: ! 310: showkre() ! 311: { ! 312: float f1, f2; ! 313: int psiz, inttotal; ! 314: int i, l, c; ! 315: static int failcnt = 0; ! 316: ! 317: for (i = 0; i < dk_ndrive; i++) { ! 318: X(dk_xfer); X(dk_seek); X(dk_wds); X(dk_time); ! 319: } ! 320: Y(tk_nin); Y(tk_nout); ! 321: etime = 0; ! 322: for(i = 0; i < CPUSTATES; i++) { ! 323: X(time); ! 324: etime += s.time[i]; ! 325: } ! 326: if (etime < 5.0) { /* < 5 ticks - ignore this trash */ ! 327: if (failcnt++ >= MAXFAIL) { ! 328: clear(); ! 329: mvprintw(2, 10, "The alternate system clock has died!"); ! 330: mvprintw(3, 10, "Reverting to ``pigs'' display."); ! 331: move(CMDLINE, 0); ! 332: refresh(); ! 333: failcnt = 0; ! 334: sleep(5); ! 335: command("pigs"); ! 336: } ! 337: return; ! 338: } ! 339: failcnt = 0; ! 340: etime /= hertz; ! 341: inttotal = 0; ! 342: for (i = 0; i < nintr; i++) { ! 343: if (s.intrcnt[i] == 0) ! 344: continue; ! 345: if (intrloc[i] == 0) { ! 346: if (nextintsrow == LINES) ! 347: continue; ! 348: intrloc[i] = nextintsrow++; ! 349: mvprintw(intrloc[i], INTSCOL + 9, "%-8.8s", ! 350: intrname[i]); ! 351: } ! 352: X(intrcnt); ! 353: l = (int)((float)s.intrcnt[i]/etime + 0.5); ! 354: inttotal += l; ! 355: putint(l, intrloc[i], INTSCOL, 8); ! 356: } ! 357: putint(inttotal, INTSROW + 1, INTSCOL, 8); ! 358: Z(ncs_goodhits); Z(ncs_badhits); Z(ncs_miss); ! 359: Z(ncs_long); Z(ncs_pass2); Z(ncs_2passes); ! 360: s.nchcount = nchtotal.ncs_goodhits + nchtotal.ncs_badhits + ! 361: nchtotal.ncs_miss + nchtotal.ncs_long; ! 362: if (state == TIME) ! 363: s1.nchcount = s.nchcount; ! 364: ! 365: psiz = 0; ! 366: f2 = 0.0; ! 367: for (c = 0; c < CPUSTATES; c++) { ! 368: i = cpuorder[c]; ! 369: f1 = cputime(i); ! 370: f2 += f1; ! 371: l = (int) ((f2 + 1.0) / 2.0) - psiz; ! 372: if (c == 0) ! 373: putfloat(f1, GRAPHROW, GRAPHCOL + 1, 5, 1, 0); ! 374: else ! 375: putfloat(f1, GRAPHROW, GRAPHCOL + 12 * c, ! 376: 5, 1, 0); ! 377: move(GRAPHROW + 2, psiz); ! 378: psiz += l; ! 379: while (l-- > 0) ! 380: addch(cpuchar[c]); ! 381: } ! 382: ! 383: putint(ucount(), STATROW, STATCOL, 3); ! 384: putfloat(avenrun[0], STATROW, STATCOL + 17, 6, 2, 0); ! 385: putfloat(avenrun[1], STATROW, STATCOL + 23, 6, 2, 0); ! 386: putfloat(avenrun[2], STATROW, STATCOL + 29, 6, 2, 0); ! 387: mvaddstr(STATROW, STATCOL + 53, buf); ! 388: putint(total.t_arm/2, MEMROW + 2, MEMCOL + 4, 5); ! 389: putint(total.t_armtxt/2, MEMROW + 2, MEMCOL + 9, 5); ! 390: putint(total.t_avm/2, MEMROW + 2, MEMCOL + 14, 6); ! 391: putint(total.t_avmtxt/2, MEMROW + 2, MEMCOL + 20, 5); ! 392: putint(total.t_rm/2, MEMROW + 3, MEMCOL + 4, 5); ! 393: putint(total.t_rmtxt/2, MEMROW + 3, MEMCOL + 9, 5); ! 394: putint(total.t_vm/2, MEMROW + 3, MEMCOL + 14, 6); ! 395: putint(total.t_vmtxt/2, MEMROW + 3, MEMCOL + 20, 5); ! 396: putint(total.t_free/2, MEMROW + 2, MEMCOL + 27, 5); ! 397: putint(total.t_rq, PROCSROW + 1, PROCSCOL + 5, 3); ! 398: putint(total.t_pw, PROCSROW + 1, PROCSCOL + 8, 3); ! 399: putint(total.t_dw, PROCSROW + 1, PROCSCOL + 11, 3); ! 400: putint(total.t_sl, PROCSROW + 1, PROCSCOL + 14, 3); ! 401: putint(total.t_sw, PROCSROW + 1, PROCSCOL + 17, 3); ! 402: putrate(rate.v_swtch, oldrate.v_swtch, ! 403: GENSTATROW, GENSTATCOL, 7); ! 404: putrate(rate.v_trap, oldrate.v_trap, ! 405: GENSTATROW + 1, GENSTATCOL, 7); ! 406: putrate(rate.v_syscall, oldrate.v_syscall, ! 407: GENSTATROW + 2, GENSTATCOL, 7); ! 408: putrate(rate.v_intr, oldrate.v_intr, ! 409: GENSTATROW + 3, GENSTATCOL, 7); ! 410: putrate(rate.v_pdma, oldrate.v_pdma, ! 411: GENSTATROW + 4, GENSTATCOL, 7); ! 412: putrate(rate.v_soft, oldrate.v_soft, ! 413: GENSTATROW + 5, GENSTATCOL, 7); ! 414: putrate(rate.v_faults, oldrate.v_faults, ! 415: GENSTATROW + 6, GENSTATCOL, 7); ! 416: putrate(rate.v_scan, oldrate.v_scan, ! 417: GENSTATROW + 7, GENSTATCOL, 7); ! 418: putrate(rate.v_rev, oldrate.v_rev, ! 419: GENSTATROW + 8, GENSTATCOL, 7); ! 420: putrate(rate.v_pgin, oldrate.v_pgin, PAGEROW + 2, ! 421: PAGECOL + 5, 5); ! 422: putrate(rate.v_pgout, oldrate.v_pgout, PAGEROW + 2, ! 423: PAGECOL + 10, 5); ! 424: putrate(rate.v_swpin, oldrate.v_swpin, PAGEROW + 2, ! 425: PAGECOL + 15, 5); ! 426: putrate(rate.v_swpout, oldrate.v_swpout, PAGEROW + 2, ! 427: PAGECOL + 20, 5); ! 428: putrate(rate.v_pgpgin, oldrate.v_pgpgin, PAGEROW + 3, ! 429: PAGECOL + 5, 5); ! 430: putrate(rate.v_pgpgout, oldrate.v_pgpgout, PAGEROW + 3, ! 431: PAGECOL + 10, 5); ! 432: putrate(rate.v_pswpin, oldrate.v_pswpin, PAGEROW + 3, ! 433: PAGECOL + 15, 5); ! 434: putrate(rate.v_pswpout, oldrate.v_pswpout, PAGEROW + 3, ! 435: PAGECOL + 20, 5); ! 436: putrate(rate.v_pgrec, oldrate.v_pgrec, PAGEROW + 6, PAGECOL, 3); ! 437: putrate(rate.v_intrans, oldrate.v_intrans, PAGEROW + 6, ! 438: PAGECOL + 4, 2); ! 439: putrate(rate.v_xsfrec, oldrate.v_xsfrec, PAGEROW + 6, ! 440: PAGECOL + 7, 3); ! 441: putrate(rate.v_xifrec, oldrate.v_xifrec, PAGEROW + 6, ! 442: PAGECOL + 11, 3); ! 443: putrate(rate.v_pgfrec, oldrate.v_pgfrec, PAGEROW + 6, ! 444: PAGECOL + 15, 3); ! 445: putrate(rate.v_dfree, oldrate.v_dfree, PAGEROW + 6, ! 446: PAGECOL + 19, 3); ! 447: putrate(rate.v_seqfree, oldrate.v_seqfree, PAGEROW + 6, ! 448: PAGECOL + 23, 3); ! 449: putrate(rate.v_zfod, oldrate.v_zfod, PAGEROW + 8, PAGECOL, 8); ! 450: putrate(rate.v_nzfod, oldrate.v_nzfod, PAGEROW + 9, PAGECOL, 8); ! 451: putrate(rate.v_exfod, oldrate.v_exfod, PAGEROW + 8, ! 452: PAGECOL + 14, 8); ! 453: putrate(rate.v_nexfod, oldrate.v_nexfod, PAGEROW + 9, ! 454: PAGECOL + 14, 8); ! 455: putfloat ( ! 456: rate.v_nzfod == 0 ? ! 457: 0.0 ! 458: : state != RUN ? ! 459: ( 100.0 * rate.v_zfod / rate.v_nzfod ) ! 460: : rate.v_nzfod == oldrate.v_nzfod ? ! 461: 0.0 ! 462: : ! 463: ( 100.0 * (rate.v_zfod-oldrate.v_zfod) ! 464: / (rate.v_nzfod-oldrate.v_nzfod) ) ! 465: , PAGEROW + 10 ! 466: , PAGECOL ! 467: , 8 ! 468: , 2 ! 469: , 1 ! 470: ); ! 471: putfloat ( ! 472: rate.v_nexfod == 0 ? ! 473: 0.0 ! 474: : state != RUN ? ! 475: ( 100.0 * rate.v_exfod / rate.v_nexfod ) ! 476: : rate.v_nexfod == oldrate.v_nexfod ? ! 477: 0.0 ! 478: : ! 479: ( 100.0 * (rate.v_exfod-oldrate.v_exfod) ! 480: / (rate.v_nexfod-oldrate.v_nexfod) ) ! 481: , PAGEROW + 10 ! 482: , PAGECOL + 14 ! 483: , 8 ! 484: , 2 ! 485: , 1 ! 486: ); ! 487: mvprintw(DISKROW,DISKCOL+5," "); ! 488: for (i = 0, c = 0; i < dk_ndrive && c < MAXDRIVES; i++) ! 489: if (dk_select[i]) { ! 490: mvprintw(DISKROW, DISKCOL + 5 + 5 * c, ! 491: " %3.3s", dr_name[i]); ! 492: dinfo(i, ++c); ! 493: } ! 494: putint(s.nchcount, NAMEIROW + 2, NAMEICOL, 9); ! 495: putint(nchtotal.ncs_goodhits, NAMEIROW + 2, NAMEICOL + 9, 9); ! 496: #define nz(x) ((x) ? (x) : 1) ! 497: putfloat(nchtotal.ncs_goodhits * 100.0 / nz(s.nchcount), ! 498: NAMEIROW + 2, NAMEICOL + 19, 4, 0, 1); ! 499: putint(nchtotal.ncs_pass2, NAMEIROW + 2, NAMEICOL + 23, 9); ! 500: putfloat(nchtotal.ncs_pass2 * 100.0 / nz(s.nchcount), ! 501: NAMEIROW + 2, NAMEICOL + 34, 4, 0, 1); ! 502: #undef nz ! 503: } ! 504: ! 505: cmdkre(cmd, args) ! 506: char *cmd, *args; ! 507: { ! 508: ! 509: if (prefix(cmd, "run")) { ! 510: copyinfo(&s2, &s1); ! 511: state = RUN; ! 512: return (1); ! 513: } ! 514: if (prefix(cmd, "boot")) { ! 515: state = BOOT; ! 516: copyinfo(&z, &s1); ! 517: return (1); ! 518: } ! 519: if (prefix(cmd, "time")) { ! 520: state = TIME; ! 521: return (1); ! 522: } ! 523: if (prefix(cmd, "zero")) { ! 524: if (state == RUN) ! 525: getinfo(&s1, RUN); ! 526: return (1); ! 527: } ! 528: return (dkcmd(cmd, args)); ! 529: } ! 530: ! 531: /* calculate number of users on the system */ ! 532: static ! 533: ucount() ! 534: { ! 535: register int nusers = 0; ! 536: ! 537: if (ut < 0) ! 538: return (0); ! 539: while (read(ut, &utmp, sizeof(utmp))) ! 540: if (utmp.ut_name[0] != '\0') ! 541: nusers++; ! 542: ! 543: lseek(ut, 0L, L_SET); ! 544: return (nusers); ! 545: } ! 546: ! 547: static float ! 548: cputime(indx) ! 549: int indx; ! 550: { ! 551: double t; ! 552: register i; ! 553: ! 554: t = 0; ! 555: for (i = 0; i < CPUSTATES; i++) ! 556: t += s.time[i]; ! 557: if (t == 0.0) ! 558: t = 1.0; ! 559: return (s.time[indx] * 100.0 / t); ! 560: } ! 561: ! 562: static ! 563: putrate(r, or, l, c, w) ! 564: { ! 565: ! 566: if (state != TIME) { ! 567: if (state == RUN) ! 568: r -= or; ! 569: putint((int)((float)r/etime + 0.5), l, c, w); ! 570: } else ! 571: putint(r, l, c, w); ! 572: } ! 573: ! 574: static ! 575: putint(n, l, c, w) ! 576: { ! 577: char b[128]; ! 578: ! 579: move(l, c); ! 580: if (n == 0) { ! 581: while (w-- > 0) ! 582: addch(' '); ! 583: return; ! 584: } ! 585: sprintf(b, "%*d", w, n); ! 586: if (strlen(b) > w) { ! 587: while (w-- > 0) ! 588: addch('*'); ! 589: return; ! 590: } ! 591: addstr(b); ! 592: } ! 593: ! 594: static ! 595: putfloat(f, l, c, w, d, nz) ! 596: float f; ! 597: { ! 598: char b[128]; ! 599: ! 600: move(l, c); ! 601: if (nz && f == 0.0) { ! 602: while (w-- > 0) ! 603: addch(' '); ! 604: return; ! 605: } ! 606: sprintf(b, "%*.*f", w, d, f); ! 607: if (strlen(b) > w) { ! 608: while (w-- > 0) ! 609: addch('*'); ! 610: return; ! 611: } ! 612: addstr(b); ! 613: } ! 614: ! 615: static ! 616: getinfo(s, st) ! 617: struct Info *s; ! 618: enum state st; ! 619: { ! 620: ! 621: lseek(kmem, (long)name[X_CPTIME].n_value,L_SET); ! 622: read(kmem, s->time, sizeof s->time); ! 623: if (st != TIME) { ! 624: lseek(kmem, (long)name[X_SUM].n_value, L_SET); ! 625: read(kmem, &s->Rate, sizeof s->Rate); ! 626: } else { ! 627: lseek(kmem, (long)name[X_RATE].n_value,L_SET); ! 628: read(kmem, &s->Rate, sizeof s->Rate); ! 629: } ! 630: lseek(kmem, (long)name[X_TOTAL].n_value, L_SET); ! 631: read(kmem, &s->Total, sizeof s->Total); ! 632: s->dk_busy = getw(name[X_DK_BUSY].n_value); ! 633: lseek(kmem, (long)name[X_DK_TIME].n_value, L_SET); ! 634: read(kmem, s->dk_time, dk_ndrive * sizeof (long)); ! 635: lseek(kmem, (long)name[X_DK_XFER].n_value, L_SET); ! 636: read(kmem, s->dk_xfer, dk_ndrive * sizeof (long)); ! 637: lseek(kmem, (long)name[X_DK_WDS].n_value, L_SET); ! 638: read(kmem, s->dk_wds, dk_ndrive * sizeof (long)); ! 639: lseek(kmem, (long)name[X_DK_SEEK].n_value, L_SET); ! 640: read(kmem, s->dk_seek, dk_ndrive * sizeof (long)); ! 641: s->tk_nin = getw(name[X_TK_NIN].n_value); ! 642: s->tk_nout = getw(name[X_TK_NOUT].n_value); ! 643: lseek(kmem, (long)name[X_NCHSTATS].n_value, L_SET); ! 644: read(kmem, &s->nchstats, sizeof s->nchstats); ! 645: lseek(kmem, (long)name[X_INTRCNT].n_value, L_SET); ! 646: read(kmem, s->intrcnt, nintr * sizeof (long)); ! 647: } ! 648: ! 649: static ! 650: allocinfo(s) ! 651: struct Info *s; ! 652: { ! 653: ! 654: s->intrcnt = (long *) malloc(nintr * sizeof(long)); ! 655: if (s->intrcnt == NULL) { ! 656: fprintf(stderr, "systat: out of memory\n"); ! 657: exit(2); ! 658: } ! 659: } ! 660: ! 661: static ! 662: copyinfo(from, to) ! 663: register struct Info *from, *to; ! 664: { ! 665: long *time, *wds, *seek, *xfer; ! 666: long *intrcnt; ! 667: ! 668: time = to->dk_time; wds = to->dk_wds; seek = to->dk_seek; ! 669: xfer = to->dk_xfer; intrcnt = to->intrcnt; ! 670: *to = *from; ! 671: bcopy(from->dk_time, to->dk_time = time, dk_ndrive * sizeof (long)); ! 672: bcopy(from->dk_wds, to->dk_wds = wds, dk_ndrive * sizeof (long)); ! 673: bcopy(from->dk_seek, to->dk_seek = seek, dk_ndrive * sizeof (long)); ! 674: bcopy(from->dk_xfer, to->dk_xfer = xfer, dk_ndrive * sizeof (long)); ! 675: bcopy(from->intrcnt, to->intrcnt = intrcnt, nintr * sizeof (int)); ! 676: } ! 677: ! 678: static ! 679: dinfo(dn, c) ! 680: { ! 681: double words, atime, itime, xtime; ! 682: ! 683: c = DISKCOL + c * 5; ! 684: atime = s.dk_time[dn]; ! 685: atime /= hertz; ! 686: words = s.dk_wds[dn]*32.0; /* number of words transferred */ ! 687: xtime = dk_mspw[dn]*words; /* transfer time */ ! 688: itime = atime - xtime; /* time not transferring */ ! 689: if (xtime < 0) ! 690: itime += xtime, xtime = 0; ! 691: if (itime < 0) ! 692: xtime += itime, itime = 0; ! 693: putint((int)((float)s.dk_seek[dn]/etime+0.5), DISKROW + 1, c, 5); ! 694: putint((int)((float)s.dk_xfer[dn]/etime+0.5), DISKROW + 2, c, 5); ! 695: putint((int)(words/etime/512.0 + 0.5), DISKROW + 3, c, 5); ! 696: if (s.dk_seek[dn]) ! 697: putfloat(itime*1000.0/s.dk_seek[dn], DISKROW + 4, c, 5, 1, 1); ! 698: else ! 699: putint(0, DISKROW + 4, c, 5); ! 700: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.