Return to iostat.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin

Annotation of cci/usr/src/usr.bin/iostat.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * iostat
        !             3:  */
        !             4: #include <curses.h>
        !             5: #include <signal.h>
        !             6: #include <stdio.h>
        !             7: #include <nlist.h>
        !             8: #include <sys/types.h>
        !             9: #include <sys/buf.h>
        !            10: #include <sys/dk.h>
        !            11: #include <vba/vbavar.h>
        !            12: #include <vba/vddc.h>
        !            13: 
        !            14: struct nlist nli[] = {
        !            15:        { "_dk_busy" },
        !            16: #define        X_DK_BUSY       0
        !            17:        { "_dk_time" },
        !            18: #define        X_DK_TIME       1
        !            19:        { "_dk_xfer" },
        !            20: #define        X_DK_XFER       2
        !            21:        { "_dk_wds" },
        !            22: #define        X_DK_WDS        3
        !            23:        { "_tk_nin" },
        !            24: #define        X_TK_NIN        4
        !            25:        { "_tk_nout" },
        !            26: #define        X_TK_NOUT       5
        !            27:        { "_dk_seek" },
        !            28: #define        X_DK_SEEK       6
        !            29:        { "_cp_time" },
        !            30: #define        X_CP_TIME       7
        !            31:        { "_dk_mspw" },
        !            32: #define        X_DK_MSPW       8
        !            33:        { "_hz" },
        !            34: #define        X_HZ            9
        !            35:        { "_vbdinit" },
        !            36: #define X_VBDINIT      10
        !            37:        { "_vdst" },
        !            38: #define X_VDST         11
        !            39:        { "_nvddrv" },
        !            40: #define X_NVDDRV       12
        !            41:        { 0 },
        !            42: };
        !            43: 
        !            44: char dr_name[DK_NDRIVE][10];
        !            45: 
        !            46: fs_tab *vdinfo,*vdinfo_save;
        !            47: long   name;
        !            48: 
        !            49: struct
        !            50: {
        !            51:        int     dk_busy;
        !            52:        long    cp_time[CPUSTATES];
        !            53:        long    dk_time[DK_NDRIVE];
        !            54:        long    dk_wds[DK_NDRIVE];
        !            55:        long    dk_seek[DK_NDRIVE];
        !            56:        long    dk_xfer[DK_NDRIVE];
        !            57:        float   dk_mspw[DK_NDRIVE];
        !            58:        long    tk_nin;
        !            59:        long    tk_nout;
        !            60: } s, s1;
        !            61: 
        !            62: #define        CPUSTE  4
        !            63: #define        NCOLS   80
        !            64: #define        NLINES  24
        !            65: #define        MAXRPT  4
        !            66: #define        UNIX    "/vmunix"
        !            67: 
        !            68: struct
        !            69: {
        !            70:        float   tin;
        !            71:        float   tout;
        !            72:        float   syste[CPUSTE];
        !            73:        float   bps[DK_NDRIVE];
        !            74:        float   tps[DK_NDRIVE];
        !            75:        float   msps[DK_NDRIVE];
        !            76: } rec[MAXRPT];
        !            77: 
        !            78: int    mf;
        !            79: int    hz;
        !            80: int    nodktyp;
        !            81: int    count,repcnt, iter;
        !            82: 
        !            83: double etime;
        !            84: extern char *malloc();
        !            85: 
        !            86: main(argc, argv)
        !            87: char *argv[];
        !            88: {
        !            89:        extern char *ctime();
        !            90:        register  i;
        !            91:        int iter;
        !            92:        int     j, totrep;
        !            93:        double f1, f2;
        !            94:        long t;
        !            95:        int     beg_i, end_i,head,hd;
        !            96:        int tohdr = 1;
        !            97:        int die();
        !            98:        int dietty();
        !            99:        int ptoutput();
        !           100:        int shiftarray();
        !           101:        int     TERM;
        !           102:        
        !           103:        TERM = isatty(1);
        !           104:        nlist(UNIX, nli);
        !           105:        if(nli[X_DK_BUSY].n_value == 0) {
        !           106:                printf("dk_busy not found in %s namelist\n",UNIX);
        !           107:                exit(1);
        !           108:        }
        !           109:        mf = open("/dev/kmem", 0);
        !           110:        if(mf < 0) {
        !           111:                printf("cannot open /dev/kmem\n");
        !           112:                exit(1);
        !           113:        }
        !           114:        while (argc>1&&argv[1][0]=='-') {
        !           115:                argc--;
        !           116:                argv++;
        !           117:        }
        !           118:        lseek(mf, (long)nli[X_DK_MSPW].n_value, 0);
        !           119:        read(mf, s.dk_mspw, sizeof s.dk_mspw);
        !           120:        for (i = 0; i < DK_NDRIVE; i++)
        !           121:                sprintf (dr_name[i],"??%x",i);
        !           122:        lseek(mf, (long)nli[X_NVDDRV].n_value, 0);
        !           123:        read(mf, &nodktyp, sizeof nodktyp);
        !           124:        vdinfo = (fs_tab *)malloc(nodktyp*sizeof(fs_tab));
        !           125:        lseek(mf, (long)nli[X_VDST].n_value, 0);
        !           126:        read(mf, (char *)vdinfo, nodktyp*sizeof(fs_tab));
        !           127:        vdinfo_save = vdinfo;
        !           128:        for (i = 0; i < nodktyp; vdinfo++, i++) {
        !           129:                name = (long)vdinfo->type_name;
        !           130:                vdinfo->type_name = malloc(3);
        !           131:                lseek(mf, (long)name, 0);
        !           132:                read(mf, vdinfo->type_name, 3);
        !           133:        }
        !           134:        vdinfo = vdinfo_save;
        !           135:        read_names();  
        !           136: 
        !           137:        totrep = 1;
        !           138:        if(argc > 2)
        !           139:                totrep = atoi(argv[2]);
        !           140:        if (argc ==2)
        !           141:                totrep = -1;
        !           142:        iter = 0;
        !           143:        if ((totrep < 0) || (totrep > MAXRPT))
        !           144:                repcnt = MAXRPT;
        !           145:        else
        !           146:                repcnt = totrep;
        !           147:        if (TERM){
        !           148:                initscr();
        !           149:                signal(SIGINT,dietty);
        !           150:                nonl();
        !           151:                crmode();
        !           152:                noecho();
        !           153:                leaveok(stdscr, TRUE);
        !           154:                scrollok(stdscr,FALSE);
        !           155:        }
        !           156:        else
        !           157:                signal(SIGINT,die);
        !           158: loop:
        !           159:        head = 4;
        !           160:        end_i = 0;
        !           161:        hd=0;
        !           162:        lseek(mf, (long)nli[X_DK_BUSY].n_value, 0);
        !           163:        read(mf, &s.dk_busy, sizeof s.dk_busy);
        !           164:        lseek(mf, (long)nli[X_DK_TIME].n_value, 0);
        !           165:        read(mf, s.dk_time, sizeof s.dk_time);
        !           166:        lseek(mf, (long)nli[X_DK_XFER].n_value, 0);
        !           167:        read(mf, s.dk_xfer, sizeof s.dk_xfer);
        !           168:        lseek(mf, (long)nli[X_DK_WDS].n_value, 0);
        !           169:        read(mf, s.dk_wds, sizeof s.dk_wds);
        !           170:        lseek(mf, (long)nli[X_TK_NIN].n_value, 0);
        !           171:        read(mf, &s.tk_nin, sizeof s.tk_nin);
        !           172:        lseek(mf, (long)nli[X_TK_NOUT].n_value, 0);
        !           173:        read(mf, &s.tk_nout, sizeof s.tk_nout);
        !           174:        lseek(mf, (long)nli[X_DK_SEEK].n_value, 0);
        !           175:        read(mf, s.dk_seek, sizeof s.dk_seek);
        !           176:        lseek(mf, (long)nli[X_CP_TIME].n_value, 0);
        !           177:        read(mf, s.cp_time, sizeof s.cp_time);
        !           178:        lseek(mf, (long)nli[X_DK_MSPW].n_value, 0);
        !           179:        read(mf, s.dk_mspw, sizeof s.dk_mspw);
        !           180:        lseek(mf, (long)nli[X_HZ].n_value, 0);
        !           181:        read(mf, &hz, sizeof hz);
        !           182:        for (i = 0; i < DK_NDRIVE; i++) {
        !           183: #define X(fld) t = s.fld[i]; s.fld[i] -= s1.fld[i]; s1.fld[i] = t
        !           184:                X(dk_xfer); X(dk_seek); X(dk_wds); X(dk_time);
        !           185:        }
        !           186:        t = s.tk_nin; s.tk_nin -= s1.tk_nin; s1.tk_nin = t;
        !           187:        t = s.tk_nout; s.tk_nout -= s1.tk_nout; s1.tk_nout = t;
        !           188:        etime = 0;
        !           189:        for(i=0; i<CPUSTATES; i++) {
        !           190:                X(cp_time);
        !           191:                etime += s.cp_time[i];
        !           192:        }
        !           193:        if (etime == 0.0)
        !           194:                etime = 1.0;
        !           195:        etime /= (float) hz;
        !           196:        rec[iter].tin = s.tk_nin/etime;
        !           197:        rec[iter].tout = s.tk_nout/etime;
        !           198:        for (i=0; i<DK_NDRIVE; i++){
        !           199:                if(dr_name[i][0] != '?'){
        !           200:                        stats(i,iter);
        !           201:                }
        !           202:        }
        !           203:        for (i=0; i<CPUSTATES; i++)
        !           204:                stat1(i,iter);
        !           205:        count++;
        !           206: prt_loop:
        !           207:        beg_i = hd;
        !           208:        if (TERM) {
        !           209:                if (head == 4)
        !           210:                        printw(" tty  tin tout     cpu    us ni sy id     "); 
        !           211:                for (i = hd; i < DK_NDRIVE; i++){ 
        !           212:                        if (dr_name[i][0] != '?'){
        !           213:                                printw("          %3.3s ",dr_name[i]); 
        !           214:                                head++;
        !           215:                                if ((head % 5 )== 0)
        !           216:                                        break;
        !           217:                        }
        !           218:                }
        !           219:                if (head !=5 )
        !           220:                        printw ("\n");
        !           221:                if (i == DK_NDRIVE)
        !           222:                        i--;
        !           223:                end_i = i;
        !           224:                for (i = beg_i; i <= end_i; i++)
        !           225:                        if(dr_name[i][0] != '?')
        !           226:                                printw(" bps tps  msps");
        !           227:                printw ("\n");
        !           228:                for(i = 0; i < (iter+1); i++){
        !           229:                        if (head == 5){
        !           230:                                printw("     %4.0f%5.0f           ",rec[i].tin,rec[i].tout);
        !           231:                                for (j = 0; j < CPUSTE; j++)
        !           232:                                        printw("%3.0f",rec[i].syste[j]);
        !           233:                                printw("                   ");
        !           234:                        }       
        !           235:                        for (j = beg_i; j <= end_i; j++)
        !           236:                                if (dr_name[j][0] != '?')
        !           237:                                printw("%4.0f%4.0f %5.1f",
        !           238:                                  rec[i].bps[j], rec[i].tps[j],
        !           239:                                  rec[i].msps[j]);
        !           240:                        printw ("\n");
        !           241:                }
        !           242:                for(i=(iter+1); i<repcnt; i++)
        !           243:                        printw("\n");
        !           244:                if (end_i < (DK_NDRIVE-1) ){
        !           245:                        hd = end_i+1;
        !           246:                        goto prt_loop;
        !           247:                }
        !           248:                refresh();
        !           249:                move(0,0);     
        !           250:        }
        !           251:        else
        !           252:             if ((count >= MAXRPT) &&( (count % MAXRPT ) == 0))
        !           253:                        ptoutput(iter+1);
        !           254: 
        !           255:        if (totrep > 0 )
        !           256:                totrep--;
        !           257:        iter++;
        !           258: 
        !           259:        if (count >=  MAXRPT ){
        !           260:                for(i=0; i < (MAXRPT -1); i++){
        !           261:                        shiftarray(i,1);
        !           262:                }
        !           263:                iter = MAXRPT-1;
        !           264:        }
        !           265: /*
        !           266: 
        !           267:        if (count >= MAXRPT) {
        !           268:                for(i = 0; i < (MAXRPT-1); i ++){
        !           269:                        rec[i].tin = rec[i+1].tin;
        !           270:                        rec[i].tout = rec[i+1].tout;
        !           271:                        for(j=0; j < CPUSTATES; j++)
        !           272:                                rec[i].syste[j] = rec[i+1].syste[j];
        !           273:                        for(j=0; j< DK_NDRIVE; j++){
        !           274:                                rec[i].bps[j] =rec[i+1].bps[j];
        !           275:                                rec[i].tps[j] =rec[i+1].tps[j];
        !           276:                                rec[i].msps[j] =rec[i+1].msps[j];
        !           277:                        }
        !           278:                }
        !           279:        iter = MAXRPT -1;
        !           280:        }
        !           281: */
        !           282: 
        !           283:        if (totrep != 0 ){
        !           284:                if(argc > 1) {
        !           285:                        sleep(atoi(argv[1]));     
        !           286:                        goto loop;
        !           287:                }
        !           288:        }
        !           289:        if(TERM)
        !           290:                dietty();
        !           291:        else
        !           292:                die();
        !           293: }
        !           294: 
        !           295: stats(dn,cnt)
        !           296: {
        !           297:        register i;
        !           298:        double atime, words, xtime, itime;
        !           299: /*
        !           300:        if (s.dk_mspw[dn] == 0.0) {
        !           301:                rec[cnt].bps[dn] = 0.0;
        !           302:                rec[cnt].tps[dn] = 0.0; 
        !           303:                rec[cnt].msps[dn] = 0.0;
        !           304:                return;
        !           305:        }
        !           306: */
        !           307:        atime = s.dk_time[dn];
        !           308:        atime /= (float) hz;
        !           309:        words = s.dk_wds[dn]*32.0;      /* number of words transferred */
        !           310:        xtime = s.dk_mspw[dn]*words;    /* transfer time */
        !           311:        itime = atime - xtime;          /* time not transferring */
        !           312:        if (xtime < 0)
        !           313:                itime += xtime, xtime = 0;
        !           314:        if (itime < 0)
        !           315:                xtime += itime, itime = 0;
        !           316:        rec[cnt].bps[dn] = words/512/etime;
        !           317:        rec[cnt].tps[dn] = s.dk_xfer[dn]/etime; 
        !           318:        rec[cnt].msps[dn] = s.dk_seek[dn] ? itime*1000./s.dk_seek[dn] : 0.0;
        !           319: }
        !           320: 
        !           321: stat1(o,ict)
        !           322: {
        !           323:        register i;
        !           324:        double time;
        !           325: 
        !           326:        time = 0;
        !           327:        for(i=0; i<CPUSTATES; i++)
        !           328:                time += s.cp_time[i];
        !           329:        if (time == 0.0)
        !           330:                time = 1.0;
        !           331:        rec[ict].syste[o] = 100*s.cp_time[o]/time;
        !           332: }
        !           333: 
        !           334: #define steal(where, var) lseek(mf, where, 0); read(mf, &var, sizeof var);
        !           335: 
        !           336: read_names()
        !           337: {
        !           338:        struct vba_device udev, *up;
        !           339:        struct vba_driver udrv;
        !           340:        int     unit, i;
        !           341: 
        !           342:        up = (struct vba_device *) nli[X_VBDINIT].n_value;
        !           343:        if (up == 0)
        !           344:        {
        !           345:                fprintf(stderr, "iostat: Disk init info not in namelist\n");
        !           346:                exit(1);
        !           347:        }
        !           348:        vdinfo_save = vdinfo;
        !           349:        for (;;) {
        !           350:                steal(up++, udev);
        !           351:                 if (udev.ui_driver == 0)
        !           352:                        break;
        !           353:                if (udev.ui_dk <= 0 || udev.ui_alive == 0)
        !           354:                        continue;
        !           355:                unit = (udev.ui_ctlr * 4) + udev.ui_slave;
        !           356:                if(udev.ui_type >= nodktyp){
        !           357:                        fprintf(stderr,"iostat : disk type in unit %d not supported \n",unit);
        !           358:                        exit(1);
        !           359:                }
        !           360:                vdinfo = vdinfo_save;
        !           361:                for(i=0; i < udev.ui_type; i++)
        !           362:                        vdinfo++;
        !           363:                dr_name[unit][0] = vdinfo->type_name[0];
        !           364:                dr_name[unit][1] = vdinfo->type_name[1];
        !           365:        }
        !           366: }
        !           367: die()
        !           368: {
        !           369:        int     i,j,k;
        !           370:        iter--;
        !           371:        signal(SIGINT,SIG_IGN);
        !           372:        i = count % MAXRPT;
        !           373:        if (count >= MAXRPT){
        !           374:                k = MAXRPT - i;
        !           375:                for (j=0; j <i; j++)
        !           376:                        shiftarray(0,k);
        !           377:        }
        !           378:        ptoutput(i);
        !           379:        exit(0);
        !           380: }
        !           381: dietty()
        !           382: {
        !           383:        signal(SIGINT, SIG_IGN);
        !           384:        mvcur(0,COLS-1, LINES-1,0);
        !           385:        endwin();
        !           386:        exit(0);
        !           387: }
        !           388: ptoutput(reptot)
        !           389:        int reptot;
        !           390: {
        !           391: register       i,j;
        !           392: int    doneflg,head,end_i,beg_i;
        !           393:        head = 4;
        !           394:        beg_i = 0;
        !           395:        doneflg=0;
        !           396:        printf(" tty  tin tout     cpu    us ni sy id     "); 
        !           397:        while (!doneflg){
        !           398:          for (i = beg_i; i < DK_NDRIVE; i++){ 
        !           399:                if (dr_name[i][0] != '?'){
        !           400:                        printf("          %3.3s ",dr_name[i]); 
        !           401:                        head++;
        !           402:                        if ((head % 5 )== 0)
        !           403:                                break;
        !           404:                }
        !           405:          }
        !           406:          if (head !=5 )
        !           407:                        printf ("\n");
        !           408:          if (i == DK_NDRIVE){
        !           409:                i--;
        !           410:                doneflg++;
        !           411:                }
        !           412:          end_i = i;
        !           413:          for (i = beg_i; i <= end_i; i++)
        !           414:                if(dr_name[i][0] != '?')
        !           415:                        printf(" bps tps  msps");
        !           416:          printf ("\n");
        !           417:          for(i = 0; i < reptot; i++){
        !           418:                if (head == 5){
        !           419:                        printf("     %4.0f%5.0f           ",
        !           420:                               rec[i].tin,rec[i].tout);
        !           421:                        for (j = 0; j < CPUSTE; j++)
        !           422:                                printf("%3.0f",rec[i].syste[j]);
        !           423:                        printf("                   ");
        !           424:                }
        !           425:                for (j = beg_i; j <= end_i; j++)
        !           426:                        if (dr_name[j][0] != '?'){
        !           427:                              printf("%4.0f%4.0f %5.1f", rec[i].bps[j],
        !           428:                              rec[i].tps[j],rec[i].msps[j]);
        !           429:                        }
        !           430:                printf ("\n");
        !           431:          }
        !           432:          for(i=reptot; i<repcnt; i++)
        !           433:                        printf("\n");
        !           434:        beg_i = end_i;
        !           435:        }
        !           436: }
        !           437: shiftarray(srtary,offset)
        !           438:        int     srtary; /* starting array to be shifted */
        !           439:        int     offset; /* offset to be skip in shifting array  */ 
        !           440: {
        !           441: register       j;
        !           442:        rec[srtary].tin = rec[srtary+offset].tin;
        !           443:        rec[srtary].tout = rec[srtary+offset].tout;
        !           444:        for(j=0; j < CPUSTATES; j++)
        !           445:                rec[srtary].syste[j] = rec[srtary+offset].syste[j];
        !           446:        for(j=0; j< DK_NDRIVE; j++){
        !           447:                rec[srtary].bps[j] =rec[srtary+offset].bps[j];
        !           448:                rec[srtary].tps[j] =rec[srtary+offset].tps[j];
        !           449:                rec[srtary].msps[j] =rec[srtary+offset].msps[j];
        !           450:        }
        !           451: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.