Annotation of src/usr.bin/systat/vmstat.c, Revision 1.85
1.85 ! bluhm 1: /* $OpenBSD: vmstat.c,v 1.84 2018/05/14 12:31:21 mpi Exp $ */
1.2 deraadt 2: /* $NetBSD: vmstat.c,v 1.5 1996/05/10 23:16:40 thorpej Exp $ */
1.1 deraadt 3:
4: /*-
5: * Copyright (c) 1983, 1989, 1992, 1993
6: * The Regents of the University of California. All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
1.41 millert 16: * 3. Neither the name of the University nor the names of its contributors
1.1 deraadt 17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: */
32:
33: /*
34: * Cursed vmstat -- from Robert Elz.
35: */
36:
1.79 deraadt 37: #include <sys/param.h> /* MAXCOMLEN */
38: #include <sys/types.h>
1.77 miod 39: #include <sys/namei.h>
40: #include <sys/proc.h>
41: #include <sys/sched.h>
1.1 deraadt 42: #include <sys/stat.h>
1.77 miod 43: #include <sys/sysctl.h>
1.1 deraadt 44: #include <sys/time.h>
1.76 mpi 45: #include <sys/vmmeter.h>
1.19 art 46:
1.1 deraadt 47: #include <ctype.h>
1.75 deraadt 48: #include <errno.h>
1.1 deraadt 49: #include <err.h>
50: #include <paths.h>
51: #include <signal.h>
52: #include <stdlib.h>
53: #include <string.h>
54: #include <unistd.h>
55:
56: #include "systat.h"
1.79 deraadt 57: #include "dkstats.h"
58:
59: #define MAXIMUM(a, b) (((a) > (b)) ? (a) : (b))
1.1 deraadt 60:
61: static struct Info {
62: long time[CPUSTATES];
1.19 art 63: struct uvmexp uvmexp;
1.1 deraadt 64: struct vmtotal Total;
65: struct nchstats nchstats;
66: long nchcount;
1.81 guenther 67: uint64_t *intrcnt;
1.64 canacar 68: } s, s1, s2, s3, z;
1.1 deraadt 69:
1.2 deraadt 70: extern struct _disk cur;
71:
1.1 deraadt 72: #define cnt s.Cnt
73: #define oldcnt s1.Cnt
74: #define total s.Total
75: #define nchtotal s.nchstats
76: #define oldnchtotal s1.nchstats
77:
78: static enum state { BOOT, TIME, RUN } state = TIME;
79:
1.33 millert 80: static void allocinfo(struct Info *);
81: static void copyinfo(struct Info *, struct Info *);
82: static float cputime(int);
83: static void dinfo(int, int);
1.57 deraadt 84: static void getinfo(struct Info *);
1.62 deraadt 85: void putint(int, int, int, int);
1.68 deraadt 86: void putintmk(int, int, int, int);
1.62 deraadt 87: void putuint64(u_int64_t, int, int, int);
88: void putfloat(double, int, int, int, int, int);
89: int ucount(void);
1.1 deraadt 90:
1.64 canacar 91: void print_vm(void);
92: int read_vm(void);
93: int select_vm(void);
94: int vm_keyboard_callback(int);
95:
1.1 deraadt 96: static time_t t;
97: static double etime;
98: static float hertz;
99: static int nintr;
100: static long *intrloc;
101: static char **intrname;
102: static int nextintsrow;
103:
104: WINDOW *
1.35 deraadt 105: openkre(void)
1.1 deraadt 106: {
1.62 deraadt 107: return (subwin(stdscr, LINES-1-1, 0, 1, 0));
1.1 deraadt 108: }
109:
110: void
1.35 deraadt 111: closekre(WINDOW *w)
1.1 deraadt 112: {
113:
114: if (w == NULL)
115: return;
116: wclear(w);
117: wrefresh(w);
1.62 deraadt 118: delwin(w);
1.1 deraadt 119: }
120:
121: /*
122: * These constants define where the major pieces are laid out
123: */
124: #define STATROW 0 /* uses 1 row and 68 cols */
125: #define STATCOL 2
1.56 mickey 126: #define MEMROW 2 /* uses 4 rows and 34 cols */
1.1 deraadt 127: #define MEMCOL 0
128: #define PAGEROW 2 /* uses 4 rows and 26 cols */
1.17 deraadt 129: #define PAGECOL 37
1.1 deraadt 130: #define INTSROW 2 /* uses all rows to bottom and 17 cols */
131: #define INTSCOL 63
132: #define PROCSROW 7 /* uses 2 rows and 20 cols */
133: #define PROCSCOL 0
1.27 deraadt 134: #define GENSTATROW 7 /* uses 2 rows and 35 cols */
135: #define GENSTATCOL 16
1.55 pedro 136: #define VMSTATROW 7 /* uses 18 rows and 12 cols */
1.1 deraadt 137: #define VMSTATCOL 48
138: #define GRAPHROW 10 /* uses 3 rows and 51 cols */
139: #define GRAPHCOL 0
1.25 weingart 140: #define NAMEIROW 14 /* uses 3 rows and 49 cols */
1.1 deraadt 141: #define NAMEICOL 0
142: #define DISKROW 18 /* uses 5 rows and 50 cols (for 9 drives) */
143: #define DISKCOL 0
144:
1.32 tdeval 145: #define DRIVESPACE 45 /* max space for drives */
1.1 deraadt 146:
1.64 canacar 147:
148: field_def *view_vm_0[] = {
149: NULL
150: };
151:
152: /* Define view managers */
153: struct view_manager vmstat_mgr = {
154: "VMstat", select_vm, read_vm, NULL, print_header,
155: print_vm, vm_keyboard_callback, NULL, NULL
156: };
157:
158: field_view views_vm[] = {
159: {view_vm_0, "vmstat", '7', &vmstat_mgr},
160: {NULL, NULL, 0, NULL}
161: };
162:
1.1 deraadt 163: int
1.64 canacar 164: initvmstat(void)
1.1 deraadt 165: {
1.65 deraadt 166: field_view *v;
1.57 deraadt 167: int mib[4], i;
1.51 aaron 168: size_t size;
1.50 deraadt 169:
1.73 mikeb 170: hertz = stathz;
1.31 deraadt 171: if (!dkinit(1))
1.1 deraadt 172: return(0);
1.51 aaron 173:
174: mib[0] = CTL_KERN;
175: mib[1] = KERN_INTRCNT;
176: mib[2] = KERN_INTRCNT_NUM;
177: size = sizeof(nintr);
178: if (sysctl(mib, 3, &nintr, &size, NULL, 0) < 0)
179: return (-1);
180:
181: intrloc = calloc(nintr, sizeof(long));
182: intrname = calloc(nintr, sizeof(char *));
1.83 otto 183: if (intrloc == NULL || intrname == NULL)
184: err(2, NULL);
1.51 aaron 185:
186: for (i = 0; i < nintr; i++) {
187: char name[128];
1.58 deraadt 188:
1.51 aaron 189: mib[0] = CTL_KERN;
190: mib[1] = KERN_INTRCNT;
191: mib[2] = KERN_INTRCNT_NAME;
192: mib[3] = i;
193: size = sizeof(name);
194: if (sysctl(mib, 4, name, &size, NULL, 0) < 0)
195: return (-1);
196:
197: intrname[i] = strdup(name);
198: if (intrname[i] == NULL)
199: return (-1);
200: }
201:
202: nextintsrow = INTSROW + 2;
203: allocinfo(&s);
204: allocinfo(&s1);
205: allocinfo(&s2);
1.64 canacar 206: allocinfo(&s3);
1.51 aaron 207: allocinfo(&z);
208:
1.57 deraadt 209: getinfo(&s2);
1.64 canacar 210: copyinfo(&z, &s1);
211:
212: for (v = views_vm; v->name != NULL; v++)
213: add_view(v);
214:
1.1 deraadt 215: return(1);
216: }
217:
218: void
1.35 deraadt 219: fetchkre(void)
1.1 deraadt 220: {
1.64 canacar 221: getinfo(&s3);
1.1 deraadt 222: }
223:
224: void
1.35 deraadt 225: labelkre(void)
1.1 deraadt 226: {
1.32 tdeval 227: int i, j, l;
1.1 deraadt 228:
1.56 mickey 229: mvprintw(MEMROW, MEMCOL, " memory totals (in KB)");
230: mvprintw(MEMROW + 1, MEMCOL, " real virtual free");
1.19 art 231: mvprintw(MEMROW + 2, MEMCOL, "Active");
232: mvprintw(MEMROW + 3, MEMCOL, "All");
233:
234: mvprintw(PAGEROW, PAGECOL, " PAGING SWAPPING ");
235: mvprintw(PAGEROW + 1, PAGECOL, " in out in out ");
236: mvprintw(PAGEROW + 2, PAGECOL, "ops");
237: mvprintw(PAGEROW + 3, PAGECOL, "pages");
1.1 deraadt 238:
1.20 art 239: mvprintw(INTSROW, INTSCOL + 3, " Interrupts");
240: mvprintw(INTSROW + 1, INTSCOL + 9, "total");
241:
1.71 deraadt 242: mvprintw(LINES - 3, INTSCOL + 9, "IPKTS");
243: mvprintw(LINES - 2, INTSCOL + 9, "OPKTS");
1.70 deraadt 244:
1.19 art 245: mvprintw(VMSTATROW + 0, VMSTATCOL + 10, "forks");
246: mvprintw(VMSTATROW + 1, VMSTATCOL + 10, "fkppw");
247: mvprintw(VMSTATROW + 2, VMSTATCOL + 10, "fksvm");
248: mvprintw(VMSTATROW + 3, VMSTATCOL + 10, "pwait");
249: mvprintw(VMSTATROW + 4, VMSTATCOL + 10, "relck");
250: mvprintw(VMSTATROW + 5, VMSTATCOL + 10, "rlkok");
251: mvprintw(VMSTATROW + 6, VMSTATCOL + 10, "noram");
252: mvprintw(VMSTATROW + 7, VMSTATCOL + 10, "ndcpy");
253: mvprintw(VMSTATROW + 8, VMSTATCOL + 10, "fltcp");
254: mvprintw(VMSTATROW + 9, VMSTATCOL + 10, "zfod");
255: mvprintw(VMSTATROW + 10, VMSTATCOL + 10, "cow");
256: mvprintw(VMSTATROW + 11, VMSTATCOL + 10, "fmin");
257: mvprintw(VMSTATROW + 12, VMSTATCOL + 10, "ftarg");
258: mvprintw(VMSTATROW + 13, VMSTATCOL + 10, "itarg");
259: mvprintw(VMSTATROW + 14, VMSTATCOL + 10, "wired");
260: mvprintw(VMSTATROW + 15, VMSTATCOL + 10, "pdfre");
261: if (LINES - 1 > VMSTATROW + 16)
262: mvprintw(VMSTATROW + 16, VMSTATCOL + 10, "pdscn");
1.42 mickey 263: if (LINES - 1 > VMSTATROW + 17)
264: mvprintw(VMSTATROW + 17, VMSTATCOL + 10, "pzidle");
1.55 pedro 265: if (LINES - 1 > VMSTATROW + 18)
266: mvprintw(VMSTATROW + 18, VMSTATCOL + 10, "kmapent");
1.1 deraadt 267:
1.27 deraadt 268: mvprintw(GENSTATROW, GENSTATCOL, " Csw Trp Sys Int Sof Flt");
1.1 deraadt 269:
270: mvprintw(GRAPHROW, GRAPHCOL,
1.85 ! bluhm 271: " . %%Int . %%Spn . %%Sys . %%Usr . %%Idle");
1.19 art 272: mvprintw(PROCSROW, PROCSCOL, "Proc:r d s w");
1.1 deraadt 273: mvprintw(GRAPHROW + 1, GRAPHCOL,
1.31 deraadt 274: "| | | | | | | | | | |");
1.1 deraadt 275:
1.25 weingart 276: mvprintw(NAMEIROW, NAMEICOL,
1.31 deraadt 277: "Namei Sys-cache Proc-cache No-cache");
1.1 deraadt 278: mvprintw(NAMEIROW + 1, NAMEICOL,
1.31 deraadt 279: " Calls hits %% hits %% miss %%");
1.45 tedu 280: mvprintw(DISKROW, DISKCOL, "Disks");
1.1 deraadt 281: mvprintw(DISKROW + 1, DISKCOL, "seeks");
282: mvprintw(DISKROW + 2, DISKCOL, "xfers");
1.68 deraadt 283: mvprintw(DISKROW + 3, DISKCOL, "speed");
1.2 deraadt 284: mvprintw(DISKROW + 4, DISKCOL, " sec");
1.37 tdeval 285: for (i = 0, j = 0; i < cur.dk_ndrive && j < DRIVESPACE; i++)
286: if (cur.dk_select[i] && (j + strlen(dr_name[i])) < DRIVESPACE) {
1.79 deraadt 287: l = MAXIMUM(5, strlen(dr_name[i]));
1.32 tdeval 288: mvprintw(DISKROW, DISKCOL + 5 + j,
289: " %*s", l, dr_name[i]);
290: j += 1 + l;
1.1 deraadt 291: }
292: for (i = 0; i < nintr; i++) {
293: if (intrloc[i] == 0)
294: continue;
295: mvprintw(intrloc[i], INTSCOL + 9, "%-8.8s", intrname[i]);
296: }
297: }
298:
1.82 krw 299: #define X(fld) {s.fld[i]-=s1.fld[i];}
300: #define Y(fld) {s.fld -= s1.fld;}
301: #define Z(fld) {s.nchstats.fld -= s1.nchstats.fld;}
1.1 deraadt 302: #define PUTRATE(fld, l, c, w) \
1.61 otto 303: do { \
304: Y(fld); \
305: putint((int)((float)s.fld/etime + 0.5), l, c, w); \
306: } while (0)
1.1 deraadt 307: #define MAXFAIL 5
308:
1.85 ! bluhm 309: static char cpuchar[] = { '|', '@', '=', '>', ' ' };
! 310: static char cpuorder[] = { CP_INTR, CP_SPIN, CP_SYS, CP_USER, CP_IDLE };
1.1 deraadt 311:
312: void
1.35 deraadt 313: showkre(void)
1.1 deraadt 314: {
315: float f1, f2;
1.53 deraadt 316: int psiz;
317: u_int64_t inttotal, intcnt;
1.1 deraadt 318: int i, l, c;
1.46 tedu 319: static int failcnt = 0, first_run = 0;
1.1 deraadt 320:
1.46 tedu 321: if (state == TIME) {
322: if (!first_run) {
323: first_run = 1;
324: return;
325: }
326: }
1.1 deraadt 327: etime = 0;
1.35 deraadt 328: for (i = 0; i < CPUSTATES; i++) {
1.1 deraadt 329: X(time);
330: etime += s.time[i];
331: }
332: if (etime < 5.0) { /* < 5 ticks - ignore this trash */
333: if (failcnt++ >= MAXFAIL) {
1.64 canacar 334: error("The alternate system clock has died!");
1.1 deraadt 335: failcnt = 0;
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",
1.31 deraadt 350: intrname[i]);
1.1 deraadt 351: }
1.53 deraadt 352: t = intcnt = s.intrcnt[i];
353: s.intrcnt[i] -= s1.intrcnt[i];
354: intcnt = (u_int64_t)((float)s.intrcnt[i]/etime + 0.5);
355: inttotal += intcnt;
356: putuint64(intcnt, intrloc[i], INTSCOL, 8);
1.1 deraadt 357: }
1.53 deraadt 358: putuint64(inttotal, INTSROW + 1, INTSCOL, 8);
1.1 deraadt 359: Z(ncs_goodhits); Z(ncs_badhits); Z(ncs_miss);
360: Z(ncs_long); Z(ncs_pass2); Z(ncs_2passes);
361: s.nchcount = nchtotal.ncs_goodhits + nchtotal.ncs_badhits +
362: nchtotal.ncs_miss + nchtotal.ncs_long;
363:
1.71 deraadt 364: putint(sum.ifc_ip, LINES - 3, INTSCOL, 8);
365: putint(sum.ifc_op, LINES - 2, INTSCOL, 8);
1.70 deraadt 366:
1.1 deraadt 367: psiz = 0;
368: f2 = 0.0;
369:
1.84 mpi 370: for (c = 0; c < nitems(cpuorder); c++) {
1.1 deraadt 371: i = cpuorder[c];
372: f1 = cputime(i);
1.85 ! bluhm 373: if (i == CP_USER)
! 374: f1 += cputime(CP_NICE);
1.1 deraadt 375: f2 += f1;
376: l = (int) ((f2 + 1.0) / 2.0) - psiz;
1.59 dlg 377: putfloat(f1, GRAPHROW, GRAPHCOL + 1 + (10 * c), 5, 1, 0);
1.1 deraadt 378: move(GRAPHROW + 2, psiz);
379: psiz += l;
380: while (l-- > 0)
381: addch(cpuchar[c]);
382: }
383:
1.34 millert 384: #define pgtokb(pg) ((pg) * (s.uvmexp.pagesize / 1024))
1.19 art 385:
1.56 mickey 386: putint(pgtokb(s.uvmexp.active), MEMROW + 2, MEMCOL + 7, 8);
1.19 art 387: putint(pgtokb(s.uvmexp.active + s.uvmexp.swpginuse), /* XXX */
1.56 mickey 388: MEMROW + 2, MEMCOL + 17, 8);
389: putint(pgtokb(s.uvmexp.npages - s.uvmexp.free), MEMROW + 3, MEMCOL + 7, 8);
1.19 art 390: putint(pgtokb(s.uvmexp.npages - s.uvmexp.free + s.uvmexp.swpginuse),
1.56 mickey 391: MEMROW + 3, MEMCOL + 17, 8);
392: putint(pgtokb(s.uvmexp.free), MEMROW + 2, MEMCOL + 26, 8);
1.19 art 393: putint(pgtokb(s.uvmexp.free + s.uvmexp.swpages - s.uvmexp.swpginuse),
1.56 mickey 394: MEMROW + 3, MEMCOL + 26, 8);
1.1 deraadt 395: putint(total.t_rq - 1, PROCSROW + 1, PROCSCOL + 3, 3);
1.19 art 396:
397: putint(total.t_dw, PROCSROW + 1, PROCSCOL + 6, 3);
398: putint(total.t_sl, PROCSROW + 1, PROCSCOL + 9, 3);
399: putint(total.t_sw, PROCSROW + 1, PROCSCOL + 12, 3);
400: PUTRATE(uvmexp.forks, VMSTATROW + 0, VMSTATCOL + 3, 6);
401: PUTRATE(uvmexp.forks_ppwait, VMSTATROW + 1, VMSTATCOL + 3, 6);
402: PUTRATE(uvmexp.forks_sharevm, VMSTATROW + 2, VMSTATCOL + 3, 6);
403: PUTRATE(uvmexp.fltpgwait, VMSTATROW + 3, VMSTATCOL + 4, 5);
404: PUTRATE(uvmexp.fltrelck, VMSTATROW + 4, VMSTATCOL + 3, 6);
405: PUTRATE(uvmexp.fltrelckok, VMSTATROW + 5, VMSTATCOL + 3, 6);
406: PUTRATE(uvmexp.fltnoram, VMSTATROW + 6, VMSTATCOL + 3, 6);
407: PUTRATE(uvmexp.fltamcopy, VMSTATROW + 7, VMSTATCOL + 3, 6);
408: PUTRATE(uvmexp.flt_prcopy, VMSTATROW + 8, VMSTATCOL + 3, 6);
409: PUTRATE(uvmexp.flt_przero, VMSTATROW + 9, VMSTATCOL + 3, 6);
410: PUTRATE(uvmexp.flt_acow, VMSTATROW + 10, VMSTATCOL, 9);
411: putint(s.uvmexp.freemin, VMSTATROW + 11, VMSTATCOL, 9);
412: putint(s.uvmexp.freetarg, VMSTATROW + 12, VMSTATCOL, 9);
413: putint(s.uvmexp.inactarg, VMSTATROW + 13, VMSTATCOL, 9);
414: putint(s.uvmexp.wired, VMSTATROW + 14, VMSTATCOL, 9);
415: PUTRATE(uvmexp.pdfreed, VMSTATROW + 15, VMSTATCOL, 9);
416: if (LINES - 1 > VMSTATROW + 16)
417: PUTRATE(uvmexp.pdscans, VMSTATROW + 16, VMSTATCOL, 9);
1.42 mickey 418: if (LINES - 1 > VMSTATROW + 17)
1.43 mickey 419: PUTRATE(uvmexp.zeropages, VMSTATROW + 17, VMSTATCOL, 9);
1.55 pedro 420: if (LINES - 1 > VMSTATROW + 18)
421: putint(s.uvmexp.kmapent, VMSTATROW + 18, VMSTATCOL, 9);
1.19 art 422:
423: PUTRATE(uvmexp.pageins, PAGEROW + 2, PAGECOL + 5, 5);
424: PUTRATE(uvmexp.pdpageouts, PAGEROW + 2, PAGECOL + 10, 5);
425: PUTRATE(uvmexp.pgswapin, PAGEROW + 3, PAGECOL + 5, 5);
426: PUTRATE(uvmexp.pgswapout, PAGEROW + 3, PAGECOL + 10, 5);
427:
1.27 deraadt 428: PUTRATE(uvmexp.swtch, GENSTATROW + 1, GENSTATCOL, 6);
429: PUTRATE(uvmexp.traps, GENSTATROW + 1, GENSTATCOL + 6, 6);
430: PUTRATE(uvmexp.syscalls, GENSTATROW + 1, GENSTATCOL + 12, 6);
431: PUTRATE(uvmexp.intrs, GENSTATROW + 1, GENSTATCOL + 18, 6);
432: PUTRATE(uvmexp.softs, GENSTATROW + 1, GENSTATCOL + 24, 6);
433: PUTRATE(uvmexp.faults, GENSTATROW + 1, GENSTATCOL + 30, 5);
1.1 deraadt 434: mvprintw(DISKROW, DISKCOL + 5, " ");
1.37 tdeval 435: for (i = 0, c = 0; i < cur.dk_ndrive && c < DRIVESPACE; i++)
436: if (cur.dk_select[i] && (c + strlen(dr_name[i])) < DRIVESPACE) {
1.79 deraadt 437: l = MAXIMUM(5, strlen(dr_name[i]));
1.32 tdeval 438: mvprintw(DISKROW, DISKCOL + 5 + c,
439: " %*s", l, dr_name[i]);
440: c += 1 + l;
441: dinfo(i, c);
1.1 deraadt 442: }
1.35 deraadt 443: /* and pad the DRIVESPACE */
1.32 tdeval 444: l = DRIVESPACE - c;
445: for (i = 0; i < 5; i++)
446: mvprintw(DISKROW + i, DISKCOL + 5 + c, "%*s", l, "");
447:
1.1 deraadt 448: putint(s.nchcount, NAMEIROW + 2, NAMEICOL, 9);
1.25 weingart 449: putint(nchtotal.ncs_goodhits, NAMEIROW + 2, NAMEICOL + 10, 8);
1.1 deraadt 450: #define nz(x) ((x) ? (x) : 1)
451: putfloat(nchtotal.ncs_goodhits * 100.0 / nz(s.nchcount),
1.31 deraadt 452: NAMEIROW + 2, NAMEICOL + 19, 4, 0, 1);
1.25 weingart 453: putint(nchtotal.ncs_pass2, NAMEIROW + 2, NAMEICOL + 24, 7);
1.1 deraadt 454: putfloat(nchtotal.ncs_pass2 * 100.0 / nz(s.nchcount),
1.31 deraadt 455: NAMEIROW + 2, NAMEICOL + 33, 4, 0, 1);
1.66 canacar 456: putint(nchtotal.ncs_miss + nchtotal.ncs_long - nchtotal.ncs_pass2,
1.25 weingart 457: NAMEIROW + 2, NAMEICOL + 38, 7);
1.66 canacar 458: putfloat((nchtotal.ncs_miss + nchtotal.ncs_long - nchtotal.ncs_pass2) *
1.31 deraadt 459: 100.0 / nz(s.nchcount), NAMEIROW + 2, NAMEICOL + 45, 4, 0, 1);
1.1 deraadt 460: #undef nz
1.70 deraadt 461:
1.1 deraadt 462: }
463:
464: int
1.64 canacar 465: vm_keyboard_callback(int ch)
1.1 deraadt 466: {
1.64 canacar 467: switch(ch) {
468: case 'r':
1.1 deraadt 469: copyinfo(&s2, &s1);
470: state = RUN;
1.64 canacar 471: break;
472: case 'b':
1.1 deraadt 473: state = BOOT;
474: copyinfo(&z, &s1);
1.64 canacar 475: break;
476: case 't':
1.1 deraadt 477: state = TIME;
1.64 canacar 478: break;
479: case 'z':
1.1 deraadt 480: if (state == RUN)
1.57 deraadt 481: getinfo(&s1);
1.64 canacar 482: break;
1.1 deraadt 483: }
1.64 canacar 484: return (keyboard_callback(ch));
1.1 deraadt 485: }
486:
1.64 canacar 487:
1.1 deraadt 488: static float
1.35 deraadt 489: cputime(int indx)
1.1 deraadt 490: {
1.67 canacar 491: double tm;
1.28 mpech 492: int i;
1.1 deraadt 493:
1.67 canacar 494: tm = 0;
1.1 deraadt 495: for (i = 0; i < CPUSTATES; i++)
1.67 canacar 496: tm += s.time[i];
497: if (tm == 0.0)
498: tm = 1.0;
499: return (s.time[indx] * 100.0 / tm);
1.1 deraadt 500: }
501:
1.62 deraadt 502: void
1.35 deraadt 503: putint(int n, int l, int c, int w)
1.1 deraadt 504: {
505: char b[128];
506:
507: move(l, c);
508: if (n == 0) {
509: while (w-- > 0)
510: addch(' ');
511: return;
512: }
1.12 deraadt 513: snprintf(b, sizeof b, "%*d", w, n);
1.1 deraadt 514: if (strlen(b) > w) {
515: while (w-- > 0)
516: addch('*');
517: return;
518: }
519: addstr(b);
520: }
521:
1.62 deraadt 522: void
1.68 deraadt 523: putintmk(int n, int l, int c, int w)
524: {
525: char b[128];
526:
527: move(l, c);
528: if (n == 0) {
529: while (w-- > 0)
530: addch(' ');
531: return;
532: }
1.69 drahn 533: if (n > 9999 * 1024)
1.68 deraadt 534: snprintf(b, sizeof b, "%*dG", w - 1, n / 1024 / 1024);
1.69 drahn 535: else if (n > 9999)
1.68 deraadt 536: snprintf(b, sizeof b, "%*dM", w - 1, n / 1024);
537: else
538: snprintf(b, sizeof b, "%*dK", w - 1, n);
539: if (strlen(b) > w) {
540: while (w-- > 0)
541: addch('*');
542: return;
543: }
544: addstr(b);
545: }
546:
547: void
1.53 deraadt 548: putuint64(u_int64_t n, int l, int c, int w)
549: {
550: char b[128];
551:
552: move(l, c);
553: if (n == 0) {
554: while (w-- > 0)
555: addch(' ');
556: return;
557: }
558: snprintf(b, sizeof b, "%*llu", w, n);
559: if (strlen(b) > w) {
560: while (w-- > 0)
561: addch('*');
562: return;
563: }
564: addstr(b);
565: }
566:
1.62 deraadt 567: void
1.35 deraadt 568: putfloat(double f, int l, int c, int w, int d, int nz)
1.1 deraadt 569: {
570: char b[128];
571:
572: move(l, c);
573: if (nz && f == 0.0) {
574: while (--w >= 0)
575: addch(' ');
576: return;
577: }
1.12 deraadt 578: snprintf(b, sizeof b, "%*.*f", w, d, f);
1.1 deraadt 579: if (strlen(b) > w) {
580: while (--w >= 0)
581: addch('*');
582: return;
583: }
584: addstr(b);
585: }
586:
587: static void
1.67 canacar 588: getinfo(struct Info *si)
1.1 deraadt 589: {
1.31 deraadt 590: static int cp_time_mib[] = { CTL_KERN, KERN_CPTIME };
591: static int nchstats_mib[2] = { CTL_KERN, KERN_NCHSTATS };
592: static int uvmexp_mib[2] = { CTL_VM, VM_UVMEXP };
593: static int vmtotal_mib[2] = { CTL_VM, VM_METER };
1.51 aaron 594: int mib[4], i;
1.1 deraadt 595: size_t size;
596:
1.2 deraadt 597: dkreadstats();
1.51 aaron 598:
599: for (i = 0; i < nintr; i++) {
600: mib[0] = CTL_KERN;
601: mib[1] = KERN_INTRCNT;
602: mib[2] = KERN_INTRCNT_CNT;
603: mib[3] = i;
1.67 canacar 604: size = sizeof(si->intrcnt[i]);
605: if (sysctl(mib, 4, &si->intrcnt[i], &size, NULL, 0) < 0) {
606: si->intrcnt[i] = 0;
1.53 deraadt 607: }
1.48 deraadt 608: }
1.51 aaron 609:
1.67 canacar 610: size = sizeof(si->time);
611: if (sysctl(cp_time_mib, 2, &si->time, &size, NULL, 0) < 0) {
1.31 deraadt 612: error("Can't get KERN_CPTIME: %s\n", strerror(errno));
1.81 guenther 613: memset(&si->time, 0, sizeof(si->time));
1.31 deraadt 614: }
615:
1.67 canacar 616: size = sizeof(si->nchstats);
617: if (sysctl(nchstats_mib, 2, &si->nchstats, &size, NULL, 0) < 0) {
1.31 deraadt 618: error("Can't get KERN_NCHSTATS: %s\n", strerror(errno));
1.81 guenther 619: memset(&si->nchstats, 0, sizeof(si->nchstats));
1.31 deraadt 620: }
621:
1.67 canacar 622: size = sizeof(si->uvmexp);
623: if (sysctl(uvmexp_mib, 2, &si->uvmexp, &size, NULL, 0) < 0) {
1.31 deraadt 624: error("Can't get VM_UVMEXP: %s\n", strerror(errno));
1.81 guenther 625: memset(&si->uvmexp, 0, sizeof(si->uvmexp));
1.31 deraadt 626: }
627:
1.67 canacar 628: size = sizeof(si->Total);
629: if (sysctl(vmtotal_mib, 2, &si->Total, &size, NULL, 0) < 0) {
1.31 deraadt 630: error("Can't get VM_METER: %s\n", strerror(errno));
1.81 guenther 631: memset(&si->Total, 0, sizeof(si->Total));
1.1 deraadt 632: }
633: }
634:
635: static void
1.67 canacar 636: allocinfo(struct Info *si)
1.1 deraadt 637: {
1.67 canacar 638: memset(si, 0, sizeof(*si));
1.81 guenther 639: si->intrcnt = calloc(nintr, sizeof(*si->intrcnt));
1.67 canacar 640: if (si->intrcnt == NULL)
1.83 otto 641: err(2, NULL);
1.1 deraadt 642: }
643:
644: static void
1.35 deraadt 645: copyinfo(struct Info *from, struct Info *to)
1.1 deraadt 646: {
1.81 guenther 647: uint64_t *intrcnt;
1.1 deraadt 648:
1.2 deraadt 649: intrcnt = to->intrcnt;
1.1 deraadt 650: *to = *from;
1.81 guenther 651: memcpy(to->intrcnt = intrcnt, from->intrcnt, nintr * sizeof(*intrcnt));
1.1 deraadt 652: }
653:
654: static void
1.35 deraadt 655: dinfo(int dn, int c)
1.1 deraadt 656: {
1.2 deraadt 657: double words, atime;
1.1 deraadt 658:
1.32 tdeval 659: c += DISKCOL;
1.2 deraadt 660:
661: /* time busy in disk activity */
662: atime = (double)cur.dk_time[dn].tv_sec +
1.31 deraadt 663: ((double)cur.dk_time[dn].tv_usec / (double)1000000);
1.2 deraadt 664:
1.44 tedu 665: /* # of K transferred */
666: words = (cur.dk_rbytes[dn] + cur.dk_wbytes[dn]) / 1024.0;
1.2 deraadt 667:
668: putint((int)((float)cur.dk_seek[dn]/etime+0.5), DISKROW + 1, c, 5);
1.44 tedu 669: putint((int)((float)(cur.dk_rxfer[dn] + cur.dk_wxfer[dn])/etime+0.5),
670: DISKROW + 2, c, 5);
1.68 deraadt 671: putintmk((int)(words/etime + 0.5), DISKROW + 3, c, 5);
1.2 deraadt 672: putfloat(atime/etime, DISKROW + 4, c, 5, 1, 1);
1.64 canacar 673: }
674:
675:
676:
677: int
678: select_vm(void)
679: {
680: num_disp = 0;
681: return (0);
682: }
683:
684: int
685: read_vm(void)
686: {
687: if (state == TIME)
688: copyinfo(&s3, &s1);
689: fetchkre();
1.70 deraadt 690: fetchifstat();
1.64 canacar 691: if (state == TIME)
692: dkswap();
693: num_disp = 0;
694: return 0;
695: }
696:
697:
698: void
699: print_vm(void)
700: {
701: copyinfo(&s3, &s);
702: labelkre();
703: showkre();
1.1 deraadt 704: }
![[BACK]](/icons/back.gif){kind=icon}
Return to vmstat.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / systat