![[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>
1.1.1.2 ! root 14: #include <setjmp.h>
1.1 root 15: #include <vba/vddc.h>
16:
1.1.1.2 ! root 17: #define PART 16 /* 16 drives displayed in one mounted set */
! 18: #define MAX_PART ((int)((DK_NDRIVE+(PART-1))/PART))
1.1 root 19: struct nlist nli[] = {
20: #define X_CPTIME 0
21: { "_cp_time" },
22: #define X_RATE 1
23: { "_rate" },
24: #define X_TOTAL 2
25: { "_total" },
26: #define X_DEFICIT 3
27: { "_deficit" },
28: #define X_FORKSTAT 4
29: { "_forkstat" },
30: #define X_SUM 5
31: { "_sum" },
32: #define X_FIRSTFREE 6
33: { "_firstfree" },
34: #define X_MAXFREE 7
35: { "_maxfree" },
36: #define X_BOOTTIME 8
37: { "_boottime" },
38: #define X_DKXFER 9
39: { "_dk_xfer" },
40: #define X_VBDINIT 10
41: { "_vbdinit" },
42: #define X_REC 11
43: { "_rectime" },
44: #define X_PGIN 12
45: { "_pgintime" },
46: #define X_HZ 13
47: { "_hz" },
48: #define X_NVDDRV 14
49: { "_nvddrv" },
50: #define X_VDST 15
51: { "_vdst" },
52: { "" },
53: };
54:
55: #define UNIX "/vmunix"
56: char dr_name[DK_NDRIVE][10];
1.1.1.2 ! root 57: int dr_win[DK_NDRIVE];
1.1 root 58: double stat1();
59: int firstfree, maxfree;
60: int hz;
61: int nodktyp;
62: struct
63: {
64: int busy;
65: long time[CPUSTATES];
66: long xfer[DK_NDRIVE];
67: struct vmmeter Rate;
68: struct vmtotal Total;
69: struct vmmeter Sum;
70: struct forkstat Forkstat;
71: unsigned rectime;
72: unsigned pgintime;
73: } s, s1, z;
74: #define rate s.Rate
75: #define total s.Total
76: #define sum s.Sum
77: #define forkstat s.Forkstat
78: #define MAXRPT 10
79: #define NCOLS 80
80: #define NLINES 24
81:
82: struct vmmeter osum;
83: int zero;
84: int deficit;
85: double etime;
86: int mf;
87: int swflag;
88: float f;
89: int iter,count,repcnt;
90:
91: fs_tab *vdinfo, *vdinfo_save;
92: long name;
93:
94: struct
95: {
96: int r;
97: int b;
98: int w;
99: int avm;
100: int fre;
101: int pgre;
102: int pgat;
103: int pi;
104: int po;
105: int fr;
106: int de;
107: int sr;
108: float dk[DK_NDRIVE];
109: int in;
110: int sy;
111: int cs;
112: float syste[(CPUSTATES-1)];
113: /*
114: int us;
115: int sy;
116: int id;
117: */
118: } rec[MAXRPT];
119:
1.1.1.2 ! root 120: int wno;
1.1 root 121: extern char *malloc();
1.1.1.2 ! root 122: jmp_buf jb;
! 123: int recurflg;
! 124: int max_win;
1.1 root 125:
126: main(argc, argv)
127: int argc;
128: char **argv;
129: {
130: extern char *ctime();
131: register i,j;
132: int nintv;
133: int totrep;
134: time_t boottime;
135: double f1, f2;
136: long t;
137: extern char _sobuf[];
138: int die();
139: int ptoutput();
140: int shiftarray();
141: int dietty();
1.1.1.2 ! root 142: int timer();
1.1 root 143: int TERM;
144: time_t now;
1.1.1.2 ! root 145: /* addition variables for windowing implementation */
! 146: WINDOW *win[MAX_PART], *window, *newwin();
! 147: register w;
! 148: int w_sv;
! 149: int deft=0;
! 150: int wsleep, wrnd;
! 151: int sleeptime;
! 152: char ch;
1.1 root 153:
154: TERM = isatty(1);
155: setbuf(stdout, _sobuf);
156: nlist(UNIX, nli);
157: if(nli[0].n_value == 0) {
158: printf("no %s namelist\n",UNIX);
159: exit(1);
160: }
161: mf = open("/dev/kmem", 0);
162: if(mf < 0) {
163: printf("cannot open /dev/kmem\n");
164: exit(1);
165: }
1.1.1.2 ! root 166: lseek(mf, (long)nli[X_NVDDRV].n_value, 0);
! 167: read(mf, &nodktyp, sizeof nodktyp);
! 168: vdinfo = (fs_tab *)malloc(nodktyp*sizeof(fs_tab));
! 169: lseek(mf, (long)nli[X_VDST].n_value, 0);
! 170: read(mf, (char *)vdinfo, nodktyp*sizeof(fs_tab));
! 171: vdinfo_save = vdinfo;
! 172: for (i = 0; i < nodktyp; vdinfo++, i++) {
! 173: name = (long)vdinfo->type_name;
! 174: vdinfo->type_name = malloc(3);
! 175: lseek(mf, (long)name, 0);
! 176: read(mf, vdinfo->type_name, 3);
! 177: }
! 178: vdinfo = vdinfo_save;
! 179: for (i = 0; i < DK_NDRIVE; i++){
! 180: sprintf(dr_name[i],"?%x",i);
! 181: dr_win[i] = -1;
! 182: }
! 183: read_names();
! 184: max_win=wno+1;
1.1 root 185: iter = 0;
186: argc--, argv++;
187: while (argc>0 && argv[0][0]=='-') {
188: char *cp = *argv++;
189: argc--;
190: while (*++cp) switch (*cp) {
191:
1.1.1.2 ! root 192: case '0':
! 193: case '1':
! 194: case '2':
! 195: case '3':
! 196: case '4':
! 197: case '5':
! 198: case '6':
! 199: case '7':
! 200: case '8':
! 201: case '9':
! 202: if (TERM)
! 203: deft=(*cp)-'0';
! 204: if (deft >= max_win) deft =0;
! 205: break;
! 206:
! 207: case 'A':
! 208: case 'B':
! 209: case 'C':
! 210: case 'D':
! 211: case 'E':
! 212: case 'F':
! 213: if (TERM)
! 214: deft=(*cp) -'A' +10;
! 215: if (deft >= max_win) deft =0;
! 216: break;
! 217: case 'f':
! 218: doforkst();
! 219: exit(0);
! 220:
! 221: case 'r':
! 222: if(TERM)
! 223: if(max_win > 1) recurflg++;
! 224: break;
! 225:
! 226: case 's':
! 227: dosum();
! 228: exit(0);
! 229:
1.1 root 230: case 'S':
231: swflag = 1 - swflag;
232: break;
233:
234: case 't':
235: dotimes();
236: exit(0);
237:
238: case 'z':
239: close(mf);
240: mf = open("/dev/kmem", 2);
241: lseek(mf, (long)nli[X_SUM].n_value, 0);
242: write(mf, &z.Sum, sizeof z.Sum);
243: exit(0);
244:
245: default:
1.1.1.2 ! root 246: fprintf(stderr,"usage:vmstat ");
! 247: if(max_win > 0 )
! 248: if(max_win <10)
! 249: fprintf(stderr,"[-[0-%x][r",max_win);
! 250: else if (max_win >=10 && max_win < 16)
! 251: fprintf(stderr,"[-[0-9A-%x][r",max_win);
! 252: else;
! 253: fprintf(stderr," fs] [interval] [count] \n");
1.1 root 254: exit(1);
255: }
256: }
257: totrep = 1;
258: if(argc > 1)
259: totrep = atoi(argv[1]);
260: if(argc ==1)
261: totrep = -1;
262: iter = 0;
263: if ((totrep <0 ) || (totrep > MAXRPT))
264: repcnt = MAXRPT;
265: else
266: repcnt = totrep;
267: lseek(mf, (long)nli[X_FIRSTFREE].n_value, 0);
268: read(mf, &firstfree, sizeof firstfree);
269: lseek(mf, (long)nli[X_MAXFREE].n_value, 0);
270: read(mf, &maxfree, sizeof maxfree);
271: lseek(mf, (long)nli[X_BOOTTIME].n_value, 0);
272: read(mf, &boottime, sizeof boottime);
273: lseek(mf, (long)nli[X_HZ].n_value, 0);
274: read(mf, &hz, sizeof hz);
275: time(&now);
276: nintv = now - boottime;
277: if (nintv <= 0 || nintv > 60*60*24*365*10) {
278: printf("Time makes no sense... namelist must be wrong.\n");
279: exit(1);
280: }
281: if (TERM){
282: initscr();
283: signal(SIGINT,dietty);
1.1.1.2 ! root 284: signal(SIGBUS,dietty);
! 285: signal(SIGALRM, timer);
1.1 root 286: nonl();
287: crmode();
288: noecho();
289: leaveok(stdscr,TRUE);
1.1.1.2 ! root 290: scrollok(stdscr,FALSE);
! 291: for(w=0; w < max_win; w++){
! 292: win[w]=newwin(NLINES,NCOLS,0,0);
! 293: wmove(win[w],0,0);
! 294: }
1.1 root 295: }
296: else
297: signal(SIGINT,die);
298: reprint:
299: loop:
300: lseek(mf, (long)nli[X_CPTIME].n_value, 0);
301: read(mf, s.time, sizeof s.time);
302: lseek(mf, (long)nli[X_DKXFER].n_value, 0);
303: read(mf, s.xfer, sizeof s.xfer);
304: if (nintv != 1) {
305: lseek(mf, (long)nli[X_SUM].n_value, 0);
306: read(mf, &rate, sizeof rate);
307: } else {
308: lseek(mf, (long)nli[X_RATE].n_value, 0);
309: read(mf, &rate, sizeof rate);
310: }
311: lseek(mf, (long)nli[X_TOTAL].n_value, 0);
312: read(mf, &total, sizeof total);
313: osum = sum;
314: lseek(mf, (long)nli[X_SUM].n_value, 0);
315: read(mf, &sum, sizeof sum);
316: lseek(mf, (long)nli[X_DEFICIT].n_value, 0);
317: read(mf, &deficit, sizeof deficit);
318: etime = 0;
319: for (i=0; i < DK_NDRIVE; i++) {
320: t = s.xfer[i];
321: s.xfer[i] -= s1.xfer[i];
322: s1.xfer[i] = t;
323: }
324: for (i=0; i < CPUSTATES; i++) {
325: t = s.time[i];
326: s.time[i] -= s1.time[i];
327: s1.time[i] = t;
328: etime += s.time[i];
329: }
330: if(etime == 0.)
331: etime = 1.;
332: rec[iter].r = total.t_rq;
333: rec[iter].b = total.t_dw+total.t_pw;
334: rec[iter].w = total.t_sw;
335: rec[iter].avm= total.t_avm;
336: rec[iter].fre = total.t_free;
337: if(swflag){
338: rec[iter].pgre= sum.v_swpin-osum.v_swpin ;
339: rec[iter].pgat = sum.v_swpout-osum.v_swpout ;
340: }
341: else {
342:
343: rec[iter].pgre = (rate.v_pgrec - (rate.v_xsfrec+rate.v_xifrec))/nintv;
344: rec[iter].pgat = (rate.v_xsfrec+rate.v_xifrec)/nintv;
345: }
346: rec[iter].pi = rate.v_pgpgin/nintv;
347: rec[iter].po= rate.v_pgpgout/nintv;
348: rec[iter].fr= rate.v_dfree/nintv;
349: rec[iter].de = deficit;
350: rec[iter].sr = rate.v_scan/nintv;
351: etime /= (float) hz;
352: for(i=0; i < DK_NDRIVE; i++){
353: rec[iter].dk[i] = s.xfer[i]/etime;
354: }
355: rec[iter].in= (rate.v_intr/nintv) - hz;
356: rec[iter].sy = rate.v_syscall/nintv;
357: rec[iter].cs = rate.v_swtch/nintv;
358: for(i=0; i<CPUSTATES; i++) {
359: f = stat1(i);
360: if (i == 0) { /* US+NI */
361: i++;
362: f += stat1(i);
363: }
364: rec[iter].syste[i-1] = f;
365: }
366: nintv = 1;
367: count++;
368: if (count >= MAXRPT)
369: if ( (count % MAXRPT) == 0)
370: if(TERM == 0)
371: ptoutput(iter+1);
372: if(TERM)
373: {
1.1.1.2 ! root 374: for(w=0; w <max_win; w++){
! 375: wprintw(win[w],"mem[avm fre] pag[%5s pi po fr de sr] flt[in sy cs] cpu[us sy id]\n",
! 376: swflag ? "si so" : "re at");
! 377: for(i=0; i < (iter+1); i++){
! 378: wprintw(win[w],"%7d%7d %4d%3d%4d%4d%4d%4d%4d %5d %4d %4d ",
1.1 root 379: rec[i].avm,rec[i].fre, rec[i].pgre,rec[i].pgat,
380: rec[i].pi,rec[i].po,rec[i].fr, rec[i].de,rec[i].sr,
381: rec[i].in,rec[i].sy,rec[i].cs);
382: for(j=0; j<( CPUSTATES -1); j++)
1.1.1.2 ! root 383: wprintw(win[w],"%3.0f",rec[i].syste[j]);
! 384: wprintw(win[w],"\n");
! 385: }
! 386: for(i=(iter+1); i<repcnt; i++)
! 387: wprintw(win[w],"\n");
! 388: wprintw(win[w],"pro[r b w]Dsk[");
! 389: }
! 390: for (i=0; i < DK_NDRIVE; i++){
1.1 root 391: if(dr_name[i][0] !='?')
1.1.1.2 ! root 392: wprintw(win[dr_win[i]]," %3.3s",dr_name[i]);
! 393: }
! 394: for(w=0; w < max_win; w++)
! 395: wprintw(win[w],"]");
1.1 root 396: for(i=0; i < (iter+1); i++){
1.1.1.2 ! root 397: for(w=0; w < max_win; w++){
! 398: wprintw(win[w],"\n");
! 399: wprintw(win[w]," %2d%2d%2d ",rec[i].r,rec[i].b,rec[i].w);
! 400: }
! 401: for(j=0; j<DK_NDRIVE; j++){
! 402: if(dr_name[j][0] !='?')
! 403: wprintw(win[dr_win[j]]," %3.0f",rec[i].dk[j]);
! 404: }
1.1 root 405: }
1.1.1.2 ! root 406: for (i=(iter+1); i< repcnt+1; i++) /* add 1 more linefeed */
! 407: for(w=0; w < max_win; w++){
! 408: wprintw(win[w],"\n");
! 409: }
! 410: for(w =0; w < max_win; w++){
! 411: if (max_win > 1 ){
! 412: wmove(win[w],NLINES-1,0);
! 413: wprintw(win[w],"More mounted disk set display: type [0-%x] to select or [r] to rotate" ,(max_win-1));
! 414: }
! 415: wmove(win[w],0,0);
! 416: }
! 417: window=win[deft];
! 418: touchwin(window);
! 419: wrefresh(window);
1.1 root 420: }
421: if (totrep > 0)
422: totrep--;
423: iter++;
424: if (count >= MAXRPT ){
425: for(i=0; i < (MAXRPT -1); i++){
426: shiftarray(i,1);
427: }
428: iter = MAXRPT-1;
429: }
1.1.1.2 ! root 430: if (totrep != 0 ){
1.1 root 431: if(argc > 0) {
1.1.1.2 ! root 432: w_sv=deft;
! 433: sleeptime=atoi(argv[0]);
! 434: if (TERM){
! 435: if (recurflg){
! 436: wrnd=(max_win-deft);
! 437: wsleep=(int)(sleeptime/(wrnd+1));
! 438: if(wsleep < 1) recurflg=0;
! 439: else{
! 440: for(w=0; w< wrnd; w++){
! 441: w_sv=wtimed_ch(window,wsleep);
! 442: window=win[w+deft];
! 443: touchwin(window);
! 444: wrefresh(window);
! 445: }
! 446: }
! 447: w_sv=wtimed_ch(window,sleeptime-(wrnd*wsleep));
! 448: }
! 449: else {
! 450: w_sv=wtimed_ch(window,sleeptime);
! 451: }
! 452: if(w_sv >= 0 && w_sv < max_win) deft=w_sv;
! 453: if(recurflg && deft == max_win-1) recurflg=0;
! 454: }
! 455: else
! 456: sleep(sleeptime);
! 457: goto loop;
1.1 root 458: }
459: }
460: if(TERM)
461: dietty();
462: else {
463: die();
464: }
465: }
466:
467: dotimes()
468: {
469:
470: lseek(mf, (long)nli[X_REC].n_value, 0);
471: read(mf, &s.rectime, sizeof s.rectime);
472: lseek(mf, (long)nli[X_PGIN].n_value, 0);
473: read(mf, &s.pgintime, sizeof s.pgintime);
474: lseek(mf, (long)nli[X_SUM].n_value, 0);
475: read(mf, &sum, sizeof sum);
476: printf("%d reclaims, %d total time (usec)\n", sum.v_pgrec, s.rectime);
477: printf("average: %d usec / reclaim\n", s.rectime/sum.v_pgrec);
478: printf("\n");
479: printf("%d page ins, %d total time (msec)\n",sum.v_pgin, s.pgintime/10);
480: printf("average: %8.1f msec / page in\n", s.pgintime/(sum.v_pgin*10.0));
481: }
482:
483: dosum()
484: {
485:
486: lseek(mf, (long)nli[X_SUM].n_value, 0);
487: read(mf, &sum, sizeof sum);
488: printf("%9d swap ins\n", sum.v_swpin);
489: printf("%9d swap outs\n", sum.v_swpout);
490: printf("%9d pages swapped in\n", sum.v_pswpin / CLSIZE);
491: printf("%9d pages swapped out\n", sum.v_pswpout / CLSIZE);
492: printf("%9d total address trans. faults taken\n", sum.v_faults);
493: printf("%9d page ins\n", sum.v_pgin);
494: printf("%9d page outs\n", sum.v_pgout);
495: printf("%9d pages paged in\n", sum.v_pgpgin);
496: printf("%9d pages paged out\n", sum.v_pgpgout);
497: printf("%9d sequential process pages freed\n", sum.v_seqfree);
498: printf("%9d total reclaims (%d%% fast)\n", sum.v_pgrec,
499: (sum.v_fastpgrec * 100) / (sum.v_pgrec == 0 ? 1 : sum.v_pgrec));
500: printf("%9d reclaims from free list\n", sum.v_pgfrec);
501: printf("%9d intransit blocking page faults\n", sum.v_intrans);
502: printf("%9d zero fill pages created\n", sum.v_nzfod / CLSIZE);
503: printf("%9d zero fill page faults\n", sum.v_zfod / CLSIZE);
504: printf("%9d executable fill pages created\n", sum.v_nexfod / CLSIZE);
505: printf("%9d executable fill page faults\n", sum.v_exfod / CLSIZE);
506: printf("%9d swap text pages found in free list\n", sum.v_xsfrec);
507: printf("%9d inode text pages found in free list\n", sum.v_xifrec);
508: printf("%9d file fill pages created\n", sum.v_nvrfod / CLSIZE);
509: printf("%9d file fill page faults\n", sum.v_vrfod / CLSIZE);
510: printf("%9d pages examined by the clock daemon\n", sum.v_scan);
511: printf("%9d revolutions of the clock hand\n", sum.v_rev);
512: printf("%9d pages freed by the clock daemon\n", sum.v_dfree / CLSIZE);
513: printf("%9d cpu context switches\n", sum.v_swtch);
514: printf("%9d device interrupts\n", sum.v_intr);
515: printf("%9d pseduo-dma dz interrupts\n", sum.v_pdma);
516: printf("%9d traps\n", sum.v_trap);
517: printf("%9d system calls\n", sum.v_syscall);
518: }
519:
520: doforkst()
521: {
522:
523: lseek(mf, (long)nli[X_FORKSTAT].n_value, 0);
524: read(mf, &forkstat, sizeof forkstat);
525: printf("%d forks, %d pages, average=%.2f\n",
526: forkstat.cntfork, forkstat.sizfork,
527: (float) forkstat.sizfork / forkstat.cntfork);
528: printf("%d vforks, %d pages, average=%.2f\n",
529: forkstat.cntvfork, forkstat.sizvfork,
530: (float)forkstat.sizvfork / forkstat.cntvfork);
531: }
532:
533: stats(dn)
534: {
535:
536: if (dn >= DK_NDRIVE) {
537: printf(" 0");
538: return;
539: }
540: printf("%3.0f", s.xfer[dn]/etime);
541: }
542:
543: double
544: stat1(row)
545: {
546: double t;
547: register i;
548:
549: t = 0;
550: for(i=0; i<CPUSTATES; i++)
551: t += s.time[i];
552: if(t == 0.)
553: t = 1.;
554: return(s.time[row]*100./t);
555: }
556:
557: pct(top, bot)
558: {
559:
560: if (bot == 0)
561: return (0);
562: return ((top * 100) / bot);
563: }
564:
565: #define steal(where, var) lseek(mf, where, 0); read(mf, &var, sizeof var);
566:
567: read_names()
568: {
569: struct vba_device udev, *up;
570: struct vba_driver udrv;
571: int unit, i;
1.1.1.2 ! root 572: int wcnt;
1.1 root 573:
574: up = (struct vba_device *) nli[X_VBDINIT].n_value;
575: if (up == 0)
576: {
577: fprintf(stderr, "vmstat: Disk init info not in namelist\n");
578: exit(1);
579: }
580: vdinfo_save = vdinfo;
1.1.1.2 ! root 581: wno=0;
! 582: wcnt=0;
1.1 root 583: for (;;) {
584: steal(up++, udev);
585: unit = (udev.ui_ctlr * 4) + udev.ui_slave;
586: if (udev.ui_driver == 0)
587: break;
588: if (udev.ui_dk <= 0 || udev.ui_alive == 0)
589: continue;
590: if(udev.ui_type >= nodktyp){
591: fprintf(stderr,"vmstat : disk type in unit %d not supported \n",unit);
592: exit(1);
593: }
1.1.1.2 ! root 594: if (wcnt >=PART){
! 595: wcnt=0;
! 596: wno++;
! 597: }
! 598: if(wno > MAX_PART){
! 599: fprintf(stderr, "vmstat : maximum partition of display exceeded \n");
! 600: exit(1);
! 601: }
1.1 root 602: vdinfo = vdinfo_save;
603: for(i=0; i < udev.ui_type; i++)
604: vdinfo++;
605: dr_name[unit][0] = vdinfo->type_name[0];
1.1.1.2 ! root 606: /* dr_name[unit][1] = vdinfo->type_name[1]; */
! 607: dr_win[unit]=wno;
! 608: wcnt++;
1.1 root 609: }
610: }
611: die()
612: {
613: int i,j,k;
614: iter--;
615: signal(SIGINT,SIG_IGN);
616: i = count % MAXRPT;
617: if (count >= MAXRPT){
618: k = MAXRPT - i;
619: for (j=0; j <i; j++)
620: shiftarray(0,k);
621: }
622: ptoutput(i);
623: exit(0);
624: }
625: dietty()
626: {
627: signal(SIGINT,SIG_IGN);
1.1.1.2 ! root 628: signal(SIGBUS,SIG_IGN);
! 629: signal(SIGSEGV,SIG_IGN);
! 630: mvcur(0,NCOLS-1, NLINES-1,0);
1.1 root 631: endwin();
632: exit(0);
633: }
634: ptoutput(reptot)
635: int reptot;
636: {
637: register i,j;
638: 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");
639: for(i=0; i < (reptot); i++){
640: printf(" %6d%5d %4d%3d%4d%4d%4d%4d%4d %4d%4d%4d ",
641: rec[i].avm,rec[i].fre, rec[i].pgre,rec[i].pgat,
642: rec[i].pi,rec[i].po,rec[i].fr, rec[i].de,rec[i].sr,
643: rec[i].in,rec[i].sy,rec[i].cs);
644: for(j=0; j<( CPUSTATES -1); j++)
645: printf("%3.0f",rec[i].syste[j]);
646: printf("\n");
647: }
648: for(i=(reptot); i<repcnt; i++)
649: printf("\n");
650:
651: printf("proc[r b w]Dsk[");
652:
653: for (i=0; i < DK_NDRIVE; i++)
654: if(dr_name[i][0] !='?')
655: printf("%3.3s ",dr_name[i]);
656: printf("]\n");
657: for(i=0; i < (reptot); i++){
658: printf(" %2d%2d%2d ",rec[i].r,rec[i].b,rec[i].w);
659: for(j=0; j<DK_NDRIVE; j++)
660: if(dr_name[j][0] !='?')
661: printf("%3.0f ",rec[i].dk[j]);
662: printf("\n");
663: }
664: for (i=(reptot); i< repcnt; i++)
665: printf("\n");
666: }
667: shiftarray(srtary,offset)
668: int srtary; /* starting array to be shifted */
669: int offset; /* offset to be skip in shifting array */
670: {
671: register j;
672: rec[srtary].r = rec[srtary+offset].r;
673: rec[srtary].b = rec[srtary+offset].b;
674: rec[srtary].w = rec[srtary+offset].w;
675: rec[srtary].avm = rec[srtary+offset].avm;
676: rec[srtary].fre = rec[srtary+offset].fre;
677: rec[srtary].pgre = rec[srtary+offset].pgre;
678: rec[srtary].pgat = rec[srtary+offset].pgat;
679: rec[srtary].pi = rec[srtary+offset].pi;
680: rec[srtary].po = rec[srtary+offset].po;
681: rec[srtary].fr = rec[srtary+offset].fr;
682: rec[srtary].de = rec[srtary+offset].de;
683: rec[srtary].sr = rec[srtary+offset].sr;
684: for(j=0; j < DK_NDRIVE; j++)
685: rec[srtary].dk[j] = rec[srtary+offset].dk[j];
686: rec[srtary].in = rec[srtary+offset].in;
687: rec[srtary].sy = rec[srtary+offset].sy;
688: rec[srtary].cs = rec[srtary+offset].cs;
689: for(j=0; j < (CPUSTATES-1); j++)
690: rec[srtary].syste[j] = rec[srtary+offset].syste[j];
691: }
1.1.1.2 ! root 692: timer()
! 693: {
! 694: signal(SIGALRM, timer);
! 695: longjmp(jb,1);
! 696: }
! 697:
! 698: int wtimed_ch(win, seconds)
! 699: WINDOW *win;
! 700: int seconds;
! 701: {
! 702: int ch = '\0';
! 703: int w;
! 704: int deft = -1;
! 705:
! 706: if(setjmp(jb) == 0)
! 707: {
! 708: do{
! 709: alarm(seconds);
! 710: ch = wgetch(win);
! 711: if(ch == 'r') {
! 712: deft= -2;
! 713: recurflg=1;
! 714: }
! 715: w=ch-'0';
! 716: if (w < max_win && w >=0) {
! 717: recurflg=0;
! 718: deft=w;
! 719: }
! 720: w=ch -'A' +10;
! 721: if (w < max_win && w >= 10){
! 722: recurflg=0;
! 723: deft=w;
! 724: }
! 725: else ;
! 726: seconds = alarm(0);
! 727:
! 728: } while (ch != 'r'|| deft <0 );
! 729: }
! 730: return(deft);
! 731: }
! 732:
! 733: terminate() /* SIGINT handler */
! 734: {
! 735: endwin();
! 736: exit(0);
! 737: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.