![[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 [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / ucb|
Return to vmstat.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / ucb |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)vmstat.c 4.11 (Berkeley) 9/25/83";
3: #endif
4:
5: #include <curses.h>
6: #include <signal.h>
7: #include <stdio.h>
8: #include <sys/param.h>
9: #include <sys/vm.h>
10: #include <sys/dk.h>
11: #include <nlist.h>
12: #include <sys/buf.h>
13: #include <vba/vbavar.h>
14: #include <vba/vddc.h>
15:
16: struct nlist nli[] = {
17: #define X_CPTIME 0
18: { "_cp_time" },
19: #define X_RATE 1
20: { "_rate" },
21: #define X_TOTAL 2
22: { "_total" },
23: #define X_DEFICIT 3
24: { "_deficit" },
25: #define X_FORKSTAT 4
26: { "_forkstat" },
27: #define X_SUM 5
28: { "_sum" },
29: #define X_FIRSTFREE 6
30: { "_firstfree" },
31: #define X_MAXFREE 7
32: { "_maxfree" },
33: #define X_BOOTTIME 8
34: { "_boottime" },
35: #define X_DKXFER 9
36: { "_dk_xfer" },
37: #define X_VBDINIT 10
38: { "_vbdinit" },
39: #define X_REC 11
40: { "_rectime" },
41: #define X_PGIN 12
42: { "_pgintime" },
43: #define X_HZ 13
44: { "_hz" },
45: #define X_NVDDRV 14
46: { "_nvddrv" },
47: #define X_VDST 15
48: { "_vdst" },
49: { "" },
50: };
51:
52: #define UNIX "/vmunix"
53: char dr_name[DK_NDRIVE][10];
54: double stat1();
55: int firstfree, maxfree;
56: int hz;
57: int nodktyp;
58: struct
59: {
60: int busy;
61: long time[CPUSTATES];
62: long xfer[DK_NDRIVE];
63: struct vmmeter Rate;
64: struct vmtotal Total;
65: struct vmmeter Sum;
66: struct forkstat Forkstat;
67: unsigned rectime;
68: unsigned pgintime;
69: } s, s1, z;
70: #define rate s.Rate
71: #define total s.Total
72: #define sum s.Sum
73: #define forkstat s.Forkstat
74: #define MAXRPT 10
75: #define NCOLS 80
76: #define NLINES 24
77:
78: struct vmmeter osum;
79: int zero;
80: int deficit;
81: double etime;
82: int mf;
83: int swflag;
84: float f;
85: int iter,count,repcnt;
86:
87: fs_tab *vdinfo, *vdinfo_save;
88: long name;
89:
90: struct
91: {
92: int r;
93: int b;
94: int w;
95: int avm;
96: int fre;
97: int pgre;
98: int pgat;
99: int pi;
100: int po;
101: int fr;
102: int de;
103: int sr;
104: float dk[DK_NDRIVE];
105: int in;
106: int sy;
107: int cs;
108: float syste[(CPUSTATES-1)];
109: /*
110: int us;
111: int sy;
112: int id;
113: */
114: } rec[MAXRPT];
115:
116: extern char *malloc();
117:
118: main(argc, argv)
119: int argc;
120: char **argv;
121: {
122: extern char *ctime();
123: register i,j;
124: int nintv;
125: int totrep;
126: time_t boottime;
127: double f1, f2;
128: long t;
129: extern char _sobuf[];
130: int die();
131: int ptoutput();
132: int shiftarray();
133: int dietty();
134: int TERM;
135: time_t now;
136:
137: TERM = isatty(1);
138: setbuf(stdout, _sobuf);
139: nlist(UNIX, nli);
140: if(nli[0].n_value == 0) {
141: printf("no %s namelist\n",UNIX);
142: exit(1);
143: }
144: mf = open("/dev/kmem", 0);
145: if(mf < 0) {
146: printf("cannot open /dev/kmem\n");
147: exit(1);
148: }
149: iter = 0;
150: argc--, argv++;
151: while (argc>0 && argv[0][0]=='-') {
152: char *cp = *argv++;
153: argc--;
154: while (*++cp) switch (*cp) {
155:
156: case 'S':
157: swflag = 1 - swflag;
158: break;
159:
160:
161: case 't':
162: dotimes();
163: exit(0);
164:
165: case 'z':
166: close(mf);
167: mf = open("/dev/kmem", 2);
168: lseek(mf, (long)nli[X_SUM].n_value, 0);
169: write(mf, &z.Sum, sizeof z.Sum);
170: exit(0);
171:
172: case 'f':
173: doforkst();
174: exit(0);
175:
176: case 's':
177: dosum();
178: exit(0);
179:
180: default:
181: fprintf(stderr, "usage: vmstat [ -fs ] [ interval ] [ count]\n");
182: exit(1);
183: }
184: }
185: totrep = 1;
186: if(argc > 1)
187: totrep = atoi(argv[1]);
188: if(argc ==1)
189: totrep = -1;
190: iter = 0;
191: if ((totrep <0 ) || (totrep > MAXRPT))
192: repcnt = MAXRPT;
193: else
194: repcnt = totrep;
195: lseek(mf, (long)nli[X_FIRSTFREE].n_value, 0);
196: read(mf, &firstfree, sizeof firstfree);
197: lseek(mf, (long)nli[X_MAXFREE].n_value, 0);
198: read(mf, &maxfree, sizeof maxfree);
199: lseek(mf, (long)nli[X_BOOTTIME].n_value, 0);
200: read(mf, &boottime, sizeof boottime);
201: lseek(mf, (long)nli[X_HZ].n_value, 0);
202: read(mf, &hz, sizeof hz);
203: lseek(mf, (long)nli[X_NVDDRV].n_value, 0);
204: read(mf, &nodktyp, sizeof nodktyp);
205: vdinfo = (fs_tab *)malloc(nodktyp*sizeof(fs_tab));
206: lseek(mf, (long)nli[X_VDST].n_value, 0);
207: read(mf, (char *)vdinfo, nodktyp*sizeof(fs_tab));
208: vdinfo_save = vdinfo;
209: for (i = 0; i < nodktyp; vdinfo++, i++) {
210: name = (long)vdinfo->type_name;
211: vdinfo->type_name = malloc(3);
212: lseek(mf, (long)name, 0);
213: read(mf, vdinfo->type_name, 3);
214: }
215: vdinfo = vdinfo_save;
216: for (i = 0; i < DK_NDRIVE; i++)
217: sprintf(dr_name[i],"??%x",i);
218: read_names();
219: time(&now);
220: nintv = now - boottime;
221: if (nintv <= 0 || nintv > 60*60*24*365*10) {
222: printf("Time makes no sense... namelist must be wrong.\n");
223: exit(1);
224: }
225: if (TERM){
226: initscr();
227: signal(SIGINT,dietty);
228: nonl();
229: crmode();
230: noecho();
231: leaveok(stdscr,TRUE);
232: scrollok(stdscr,FALSE);
233: }
234: else
235: signal(SIGINT,die);
236: reprint:
237: loop:
238: lseek(mf, (long)nli[X_CPTIME].n_value, 0);
239: read(mf, s.time, sizeof s.time);
240: lseek(mf, (long)nli[X_DKXFER].n_value, 0);
241: read(mf, s.xfer, sizeof s.xfer);
242: if (nintv != 1) {
243: lseek(mf, (long)nli[X_SUM].n_value, 0);
244: read(mf, &rate, sizeof rate);
245: } else {
246: lseek(mf, (long)nli[X_RATE].n_value, 0);
247: read(mf, &rate, sizeof rate);
248: }
249: lseek(mf, (long)nli[X_TOTAL].n_value, 0);
250: read(mf, &total, sizeof total);
251: osum = sum;
252: lseek(mf, (long)nli[X_SUM].n_value, 0);
253: read(mf, &sum, sizeof sum);
254: lseek(mf, (long)nli[X_DEFICIT].n_value, 0);
255: read(mf, &deficit, sizeof deficit);
256: etime = 0;
257: for (i=0; i < DK_NDRIVE; i++) {
258: t = s.xfer[i];
259: s.xfer[i] -= s1.xfer[i];
260: s1.xfer[i] = t;
261: }
262: for (i=0; i < CPUSTATES; i++) {
263: t = s.time[i];
264: s.time[i] -= s1.time[i];
265: s1.time[i] = t;
266: etime += s.time[i];
267: }
268: if(etime == 0.)
269: etime = 1.;
270: rec[iter].r = total.t_rq;
271: rec[iter].b = total.t_dw+total.t_pw;
272: rec[iter].w = total.t_sw;
273: rec[iter].avm= total.t_avm;
274: rec[iter].fre = total.t_free;
275: if(swflag){
276: rec[iter].pgre= sum.v_swpin-osum.v_swpin ;
277: rec[iter].pgat = sum.v_swpout-osum.v_swpout ;
278: }
279: else {
280:
281: rec[iter].pgre = (rate.v_pgrec - (rate.v_xsfrec+rate.v_xifrec))/nintv;
282: rec[iter].pgat = (rate.v_xsfrec+rate.v_xifrec)/nintv;
283: }
284: rec[iter].pi = rate.v_pgpgin/nintv;
285: rec[iter].po= rate.v_pgpgout/nintv;
286: rec[iter].fr= rate.v_dfree/nintv;
287: rec[iter].de = deficit;
288: rec[iter].sr = rate.v_scan/nintv;
289: etime /= (float) hz;
290: for(i=0; i < DK_NDRIVE; i++){
291: rec[iter].dk[i] = s.xfer[i]/etime;
292: }
293: rec[iter].in= (rate.v_intr/nintv) - hz;
294: rec[iter].sy = rate.v_syscall/nintv;
295: rec[iter].cs = rate.v_swtch/nintv;
296: for(i=0; i<CPUSTATES; i++) {
297: f = stat1(i);
298: if (i == 0) { /* US+NI */
299: i++;
300: f += stat1(i);
301: }
302: rec[iter].syste[i-1] = f;
303: }
304: nintv = 1;
305: count++;
306: if (count >= MAXRPT)
307: if ( (count % MAXRPT) == 0)
308: if(TERM == 0)
309: ptoutput(iter+1);
310: if(TERM)
311: {
312: printw("mem[avm fre] pag[%5s pi po fr de sr] fault[in sy cs] cpu[us sy id]\n", swflag ? "si so" : "re at");
313: for(i=0; i < (iter+1); i++){
314: printw("%7d%7d %4d%3d%4d%4d%4d%4d%4d %5d%4d%4d ",
315: rec[i].avm,rec[i].fre, rec[i].pgre,rec[i].pgat,
316: rec[i].pi,rec[i].po,rec[i].fr, rec[i].de,rec[i].sr,
317: rec[i].in,rec[i].sy,rec[i].cs);
318: for(j=0; j<( CPUSTATES -1); j++)
319: printw("%3.0f",rec[i].syste[j]);
320: printw("\n");
321: }
322: for(i=(iter+1); i<repcnt; i++)
323: printw("\n");
324: printw("proc[r b w]Dsk[");
325: for (i=0; i < DK_NDRIVE; i++)
326: if(dr_name[i][0] !='?')
327: printw("%3.3s ",dr_name[i]);
328: printw("]\n");
329: for(i=0; i < (iter+1); i++){
330: printw(" %2d%2d%2d ",rec[i].r,rec[i].b,rec[i].w);
331: for(j=0; j<DK_NDRIVE; j++)
332: if(dr_name[j][0] !='?')
333: printw("%3.0f ",rec[i].dk[j]);
334: printw("\n");
335: }
336: for (i=(iter+1); i< repcnt; i++)
337: printw("\n");
338: refresh();
339: move(0,0);
340: }
341: if (totrep > 0)
342: totrep--;
343: iter++;
344: if (count >= MAXRPT ){
345: for(i=0; i < (MAXRPT -1); i++){
346: shiftarray(i,1);
347: }
348: iter = MAXRPT-1;
349: }
350:
351: if (totrep != 0){
352: if(argc > 0) {
353: sleep(atoi(argv[0]));
354: goto loop;
355: }
356: }
357: if(TERM)
358: dietty();
359: else {
360: die();
361: }
362: }
363:
364: dotimes()
365: {
366:
367: lseek(mf, (long)nli[X_REC].n_value, 0);
368: read(mf, &s.rectime, sizeof s.rectime);
369: lseek(mf, (long)nli[X_PGIN].n_value, 0);
370: read(mf, &s.pgintime, sizeof s.pgintime);
371: lseek(mf, (long)nli[X_SUM].n_value, 0);
372: read(mf, &sum, sizeof sum);
373: printf("%d reclaims, %d total time (usec)\n", sum.v_pgrec, s.rectime);
374: printf("average: %d usec / reclaim\n", s.rectime/sum.v_pgrec);
375: printf("\n");
376: printf("%d page ins, %d total time (msec)\n",sum.v_pgin, s.pgintime/10);
377: printf("average: %8.1f msec / page in\n", s.pgintime/(sum.v_pgin*10.0));
378: }
379:
380: dosum()
381: {
382:
383: lseek(mf, (long)nli[X_SUM].n_value, 0);
384: read(mf, &sum, sizeof sum);
385: printf("%9d swap ins\n", sum.v_swpin);
386: printf("%9d swap outs\n", sum.v_swpout);
387: printf("%9d pages swapped in\n", sum.v_pswpin / CLSIZE);
388: printf("%9d pages swapped out\n", sum.v_pswpout / CLSIZE);
389: printf("%9d total address trans. faults taken\n", sum.v_faults);
390: printf("%9d page ins\n", sum.v_pgin);
391: printf("%9d page outs\n", sum.v_pgout);
392: printf("%9d pages paged in\n", sum.v_pgpgin);
393: printf("%9d pages paged out\n", sum.v_pgpgout);
394: printf("%9d sequential process pages freed\n", sum.v_seqfree);
395: printf("%9d total reclaims (%d%% fast)\n", sum.v_pgrec,
396: (sum.v_fastpgrec * 100) / (sum.v_pgrec == 0 ? 1 : sum.v_pgrec));
397: printf("%9d reclaims from free list\n", sum.v_pgfrec);
398: printf("%9d intransit blocking page faults\n", sum.v_intrans);
399: printf("%9d zero fill pages created\n", sum.v_nzfod / CLSIZE);
400: printf("%9d zero fill page faults\n", sum.v_zfod / CLSIZE);
401: printf("%9d executable fill pages created\n", sum.v_nexfod / CLSIZE);
402: printf("%9d executable fill page faults\n", sum.v_exfod / CLSIZE);
403: printf("%9d swap text pages found in free list\n", sum.v_xsfrec);
404: printf("%9d inode text pages found in free list\n", sum.v_xifrec);
405: printf("%9d file fill pages created\n", sum.v_nvrfod / CLSIZE);
406: printf("%9d file fill page faults\n", sum.v_vrfod / CLSIZE);
407: printf("%9d pages examined by the clock daemon\n", sum.v_scan);
408: printf("%9d revolutions of the clock hand\n", sum.v_rev);
409: printf("%9d pages freed by the clock daemon\n", sum.v_dfree / CLSIZE);
410: printf("%9d cpu context switches\n", sum.v_swtch);
411: printf("%9d device interrupts\n", sum.v_intr);
412: printf("%9d pseduo-dma dz interrupts\n", sum.v_pdma);
413: printf("%9d traps\n", sum.v_trap);
414: printf("%9d system calls\n", sum.v_syscall);
415: }
416:
417: doforkst()
418: {
419:
420: lseek(mf, (long)nli[X_FORKSTAT].n_value, 0);
421: read(mf, &forkstat, sizeof forkstat);
422: printf("%d forks, %d pages, average=%.2f\n",
423: forkstat.cntfork, forkstat.sizfork,
424: (float) forkstat.sizfork / forkstat.cntfork);
425: printf("%d vforks, %d pages, average=%.2f\n",
426: forkstat.cntvfork, forkstat.sizvfork,
427: (float)forkstat.sizvfork / forkstat.cntvfork);
428: }
429:
430: stats(dn)
431: {
432:
433: if (dn >= DK_NDRIVE) {
434: printf(" 0");
435: return;
436: }
437: printf("%3.0f", s.xfer[dn]/etime);
438: }
439:
440: double
441: stat1(row)
442: {
443: double t;
444: register i;
445:
446: t = 0;
447: for(i=0; i<CPUSTATES; i++)
448: t += s.time[i];
449: if(t == 0.)
450: t = 1.;
451: return(s.time[row]*100./t);
452: }
453:
454: pct(top, bot)
455: {
456:
457: if (bot == 0)
458: return (0);
459: return ((top * 100) / bot);
460: }
461:
462: #define steal(where, var) lseek(mf, where, 0); read(mf, &var, sizeof var);
463:
464: read_names()
465: {
466: struct vba_device udev, *up;
467: struct vba_driver udrv;
468: int unit, i;
469:
470: up = (struct vba_device *) nli[X_VBDINIT].n_value;
471: if (up == 0)
472: {
473: fprintf(stderr, "vmstat: Disk init info not in namelist\n");
474: exit(1);
475: }
476: vdinfo_save = vdinfo;
477: for (;;) {
478: steal(up++, udev);
479: unit = (udev.ui_ctlr * 4) + udev.ui_slave;
480: if (udev.ui_driver == 0)
481: break;
482: if (udev.ui_dk <= 0 || udev.ui_alive == 0)
483: continue;
484: if(udev.ui_type >= nodktyp){
485: fprintf(stderr,"vmstat : disk type in unit %d not supported \n",unit);
486: exit(1);
487: }
488: vdinfo = vdinfo_save;
489: for(i=0; i < udev.ui_type; i++)
490: vdinfo++;
491: dr_name[unit][0] = vdinfo->type_name[0];
492: dr_name[unit][1] = vdinfo->type_name[1];
493: }
494: }
495: die()
496: {
497: int i,j,k;
498: iter--;
499: signal(SIGINT,SIG_IGN);
500: i = count % MAXRPT;
501: if (count >= MAXRPT){
502: k = MAXRPT - i;
503: for (j=0; j <i; j++)
504: shiftarray(0,k);
505: }
506: ptoutput(i);
507: exit(0);
508: }
509: dietty()
510: {
511: signal(SIGINT,SIG_IGN);
512: mvcur(0,COLS-1, LINES-1,0);
513: endwin();
514: exit(0);
515: }
516: ptoutput(reptot)
517: int reptot;
518: {
519: register i,j;
520: printf("mem[avm fre] pag[%5s pi po fr de sr] fault[in sy cs] cpu[us sy id]\n", swflag ? "si so" : "re at");
521: for(i=0; i < (reptot); i++){
522: printf(" %6d%5d %4d%3d%4d%4d%4d%4d%4d %4d%4d%4d ",
523: rec[i].avm,rec[i].fre, rec[i].pgre,rec[i].pgat,
524: rec[i].pi,rec[i].po,rec[i].fr, rec[i].de,rec[i].sr,
525: rec[i].in,rec[i].sy,rec[i].cs);
526: for(j=0; j<( CPUSTATES -1); j++)
527: printf("%3.0f",rec[i].syste[j]);
528: printf("\n");
529: }
530: for(i=(reptot); i<repcnt; i++)
531: printf("\n");
532:
533: printf("proc[r b w]Dsk[");
534:
535: for (i=0; i < DK_NDRIVE; i++)
536: if(dr_name[i][0] !='?')
537: printf("%3.3s ",dr_name[i]);
538: printf("]\n");
539: for(i=0; i < (reptot); i++){
540: printf(" %2d%2d%2d ",rec[i].r,rec[i].b,rec[i].w);
541: for(j=0; j<DK_NDRIVE; j++)
542: if(dr_name[j][0] !='?')
543: printf("%3.0f ",rec[i].dk[j]);
544: printf("\n");
545: }
546: for (i=(reptot); i< repcnt; i++)
547: printf("\n");
548: }
549: shiftarray(srtary,offset)
550: int srtary; /* starting array to be shifted */
551: int offset; /* offset to be skip in shifting array */
552: {
553: register j;
554: rec[srtary].r = rec[srtary+offset].r;
555: rec[srtary].b = rec[srtary+offset].b;
556: rec[srtary].w = rec[srtary+offset].w;
557: rec[srtary].avm = rec[srtary+offset].avm;
558: rec[srtary].fre = rec[srtary+offset].fre;
559: rec[srtary].pgre = rec[srtary+offset].pgre;
560: rec[srtary].pgat = rec[srtary+offset].pgat;
561: rec[srtary].pi = rec[srtary+offset].pi;
562: rec[srtary].po = rec[srtary+offset].po;
563: rec[srtary].fr = rec[srtary+offset].fr;
564: rec[srtary].de = rec[srtary+offset].de;
565: rec[srtary].sr = rec[srtary+offset].sr;
566: for(j=0; j < DK_NDRIVE; j++)
567: rec[srtary].dk[j] = rec[srtary+offset].dk[j];
568: rec[srtary].in = rec[srtary+offset].in;
569: rec[srtary].sy = rec[srtary+offset].sy;
570: rec[srtary].cs = rec[srtary+offset].cs;
571: for(j=0; j < (CPUSTATES-1); j++)
572: rec[srtary].syste[j] = rec[srtary+offset].syste[j];
573: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.