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