Return to showq.c CVS log

Up to [Research Unix] / researchv8dc / cmd / showq

Annotation of researchv8dc/cmd/showq/showq.c, revision 1.1

1.1     ! root        1: 
        !             2: #include <nlist.h>
        !             3: #include "/usr/sys/h/param.h"
        !             4: #include <ctype.h>
        !             5: #include "/usr/sys/h/stream.h"
        !             6: #include "/usr/sys/h/inode.h"
        !             7: #include "/usr/sys/h/conf.h"
        !             8: 
        !             9: struct nlist nl[] ={
        !            10: #define        QNL     0
        !            11:        {"_queue"},
        !            12: #define        BLNL    1
        !            13:        {"_cblock"},
        !            14: #define        STNL    2
        !            15:        {"_streams"},
        !            16: #define        QFNL    3
        !            17:        {"_qfreelist"},
        !            18: #define        DTNL    4
        !            19:        {"_dtlinfo"},
        !            20: #define DKPNL  5
        !            21:        { "_dkpinfo" },
        !            22: #define        NBLOCK  6
        !            23:        { "_Nblock"},
        !            24: #define        NQUEUE  7
        !            25:        { "_Nqueue"},
        !            26: #define        NSTREAM 8
        !            27:        { "_Nstream"},
        !            28: #define        C       9
        !            29:        {"_cblockC"},
        !            30: #define        M       10
        !            31:        {"_cblockM"},
        !            32: #define        N4      11
        !            33:        {"_Nblk4"},
        !            34: #define        N16     12
        !            35:        {"_Nblk16"},
        !            36: #define        N64     13
        !            37:        {"_Nblk64"},
        !            38: #define        NBIG    14
        !            39:        {"_Nblkbig"},
        !            40: #define        DZNL    15
        !            41:        {"_dzinfo"},
        !            42: #define CDKPNL 16
        !            43:        { "_cdkpinfo" },
        !            44:        { "" },
        !            45: };
        !            46: 
        !            47: struct qinit **qall;
        !            48: char   *ball;
        !            49: char   *core = "/dev/mem";
        !            50: char   *sys  = "/unix";
        !            51: int    mem;
        !            52: int    Nblock;
        !            53: int    Nqueue;
        !            54: int    Nstream;
        !            55: 
        !            56: struct dt {
        !            57:        char    nack;
        !            58:        char    cack;
        !            59:        char    nchar;
        !            60:        char    state;
        !            61:        short   lastecho;
        !            62:        struct  queue *queue;
        !            63: };
        !            64: 
        !            65: 
        !            66: struct dkp {
        !            67:        struct  queue   *rdq;   /* associated read queue */
        !            68:        struct  block   *inp;   /* msg being collected */
        !            69:        struct  block   *inpe;  /*  end of msg */
        !            70:        short   state;          /* flags */
        !            71:        short   trx;            /* # bytes in trailer being collected */
        !            72:        short   indata;         /* # bytes in message being collected */
        !            73:        u_char  iseq;           /* last good input sequence number */
        !            74:        u_char  lastecho;       /* last echo/rej sent */
        !            75:        u_char  WS;             /* first non-accepted message */
        !            76:        u_char  WACK;           /* first non-received message */
        !            77:        u_char  WNX;            /* next message to be sent */
        !            78:        u_char  XW;             /* size of xmit window */
        !            79:        u_char  timer;          /* timeout for xmit */
        !            80:        u_char  outcnt;         /* count output chars cor char mode */
        !            81:        u_char  trbuf[3];       /* trailer being collected */
        !            82:        struct  block *xb[8];   /* the xmit window buffer */
        !            83: };
        !            84: #define        DK_OPEN 01
        !            85: #define        DK_LCLOSE       02
        !            86: #define        DK_RCLOSE       04
        !            87: #define        DK_XCHARMODE    010
        !            88: #define        DK_RCHARMODE    0200
        !            89: #define        DK_OPENING      020
        !            90: 
        !            91: struct dz {
        !            92:        short   state;
        !            93:        short   flags;
        !            94:        struct  block   *oblock;
        !            95:        struct  queue   *rdq;
        !            96:        char    board;
        !            97:        char    line;
        !            98:        char    speed;
        !            99: };
        !           100: 
        !           101: #define        getme(s, kind, off, type)  _get(kind, off, sizeof(type), &s)
        !           102: 
        !           103: struct flags {
        !           104:        int     flag;
        !           105:        char    *name;
        !           106: };
        !           107: 
        !           108: struct flags stflags[] = {
        !           109:        IOCWAIT,        "IOC",
        !           110:        RSLEEP,         "RSLEEP",
        !           111:        WSLEEP,         "WSLEEP",
        !           112:        HUNGUP,         "HUNGUP",
        !           113:        RSEL,           "RSEL",
        !           114:        WSEL,           "WSEL",
        !           115:        EXCL,           "EXCL",
        !           116:        STWOPEN,        "WOPEN",
        !           117:        0
        !           118: };
        !           119: 
        !           120: struct flags qflags[] = {
        !           121:        QUSE,           "use",
        !           122:        QREADR,         "read",
        !           123:        QNOENB,         "noenb",
        !           124:        QENAB,          "enab",
        !           125:        QWANTR,         "wantr",
        !           126:        QWANTW,         "wantw",
        !           127:        QFULL,          "full",
        !           128:        QDELIM,         "delim",
        !           129:        QBIGB,          "bigb",
        !           130:        0
        !           131: };
        !           132: 
        !           133: #define        CLOG1   01
        !           134: #define        CLOG2   02
        !           135: #define        STOPDT  04
        !           136: #define        USEDT   010
        !           137: struct flags dtflags[] = {
        !           138:        CLOG1,  "clog1",
        !           139:        CLOG2,  "clog2",
        !           140:        STOPDT, "stop",
        !           141:        USEDT,  "use",
        !           142:        0
        !           143: };
        !           144: 
        !           145: struct flags dkpflags[] = {
        !           146:        DK_OPEN,        "open",
        !           147:        DK_LCLOSE,      "lclose",
        !           148:        DK_RCLOSE,      "rclose",
        !           149:        DK_XCHARMODE,   "xcharmode",
        !           150:        DK_RCHARMODE,   "rcharmode",
        !           151:        DK_OPENING,     "opening",
        !           152:        0
        !           153: };
        !           154: 
        !           155: #define        DZEXIST 01
        !           156: #define        DZISOPEN 02
        !           157: #define        DZWOPEN 04
        !           158: #define        DZTIME  010
        !           159: #define        DZCARR  020
        !           160: #define        DZSTOP  040
        !           161: #define        DZHUPCL 0100
        !           162: 
        !           163: struct flags dzflags[] = {
        !           164:        DZEXIST,        "exists",
        !           165:        DZISOPEN,       "open",
        !           166:        DZWOPEN,        "wopen",
        !           167:        DZTIME,         "time",
        !           168:        DZCARR,         "carrier",
        !           169:        DZSTOP,         "stop",
        !           170:        DZHUPCL,        "hupcl",
        !           171:        0
        !           172: };
        !           173: 
        !           174: int    vflag;
        !           175: int    sflag;
        !           176: int    mflag;
        !           177: 
        !           178: main(argc, argv)
        !           179: char **argv;
        !           180: {
        !           181:        struct queue q;
        !           182:        struct block b;
        !           183:        struct stdata s;
        !           184:        int i;
        !           185:        int nq = 0;
        !           186:        int blkcur[4],blkmin[4];
        !           187:        int b4, b16, b64, bBIG;
        !           188: 
        !           189:        for (;;argc--, argv++) {
        !           190:                if (argc>1 && strcmp(argv[1], "-v")==0) {
        !           191:                        vflag++;
        !           192:                        continue;
        !           193:                }
        !           194:                if (argc>1 && strcmp(argv[1], "-m")==0) {
        !           195:                        mflag++;
        !           196:                        continue;
        !           197:                }
        !           198:                if (argc>1 && strcmp(argv[1], "-V")==0) {
        !           199:                        vflag = 2;
        !           200:                        continue;
        !           201:                }
        !           202:                if (argc>1 && strcmp(argv[1], "-s")==0) {
        !           203:                        sflag++;
        !           204:                        continue;
        !           205:                }
        !           206:                break;
        !           207:        }
        !           208:        if (argc>1)
        !           209:                sys = argv[1];
        !           210:        if (argc>2)
        !           211:                core = argv[2];
        !           212:        nlist(sys, nl);
        !           213:        mem = open(core, 0);
        !           214:        if (mem<0) {
        !           215:                printf("can't open %s\n", core);
        !           216:                exit(1);
        !           217:        }
        !           218:        getme(blkcur[0], C, 0, blkcur);
        !           219:        getme(blkmin[0], M, 0, blkmin);
        !           220:        getme(b4, N4, 0, b4);
        !           221:        getme(b16, N16, 0, b16);
        !           222:        getme(b64, N64, 0, b64);
        !           223:        getme(bBIG, NBIG, 0, int);
        !           224:        getme(Nqueue, NQUEUE, 0, int);
        !           225:        getme(Nstream, NSTREAM, 0, int);
        !           226:        getme(Nblock, NBLOCK, 0, int);
        !           227:        printf("blocks max: %.0f%% (%d,%d,%d,%d)\n",
        !           228:                100.*(Nblock-blkmin[0]-blkmin[1]-blkmin[2])/Nblock,
        !           229:                b4-blkmin[0], b16-blkmin[1], b64-blkmin[2], bBIG-blkmin[3]);
        !           230:        ball = (char *)malloc(Nblock*sizeof(char));
        !           231:        qall = (struct qinit **)malloc(Nqueue*sizeof(struct queue *));
        !           232:        for (i=0; i<Nblock; i++)
        !           233:                ball[i] = 0;
        !           234:        for (i=0; i<Nqueue; i++) {
        !           235:                getme(q, QNL, i, struct queue);
        !           236:                if (q.flag==0)
        !           237:                        qall[i] = 0;
        !           238:                else {
        !           239:                        qall[i] = q.qinfo;
        !           240:                        nq++;
        !           241:                }
        !           242:        }
        !           243:        for (i=0; i<Nstream; i++) {
        !           244:                pstream(i);
        !           245:        }
        !           246:        for (i=0; i<Nqueue; i++) {
        !           247:                if (qall[i])
        !           248:                        printf("Loose queue %d, info %x\n", i, qall[i]);
        !           249:        }
        !           250:        printf("%d queues in use\n", nq);
        !           251:        bfreecount();
        !           252:        nq = 0;
        !           253:        for (i=0; i<Nblock; i++)
        !           254:                if (ball[i]==0) {
        !           255:                        struct block b;
        !           256:                        if (mflag) {
        !           257:                                getme(b, BLNL, i, struct block);
        !           258:                                pblock(&b);
        !           259:                        }
        !           260:                        nq++;
        !           261:                }
        !           262:        if (!sflag)
        !           263:                printf("%d blocks missing\n", nq);
        !           264:        nq = 0;
        !           265:        for (i=0; i<Nblock; i++) {
        !           266:                if (ball[i]==0 && nq < 5) {
        !           267:                        printf("%x\n", (struct block *)nl[BLNL].n_value+i);
        !           268:                        nq++;
        !           269:                }
        !           270:        }
        !           271: }
        !           272: 
        !           273: pstream(i)
        !           274: {
        !           275:        struct stdata s;
        !           276:        struct queue rq, wq;
        !           277:        struct inode ino;
        !           278:        struct queue *rqp, *wqp;
        !           279:        struct stdata *sp;
        !           280:        struct streamtab st, st1, st2, st3;
        !           281:        int d;
        !           282:        int forward = 1;
        !           283: 
        !           284:        sp = (struct stdata *)getme(s, STNL, i, struct stdata);
        !           285:        if (s.wrq==NULL)
        !           286:                return;
        !           287:        if (!sflag)
        !           288:                printf("\nstream %d: ", i);
        !           289:        getme(ino, s.inode, 0, struct inode);
        !           290:        d = ino.i_un.i_rdev;
        !           291:        if (!sflag) {
        !           292:                printf("dev %d,%d  ", major(d), minor(d));
        !           293:                printf("count %d ", s.count);
        !           294:                flags(stflags, s.flag);
        !           295:                if (vflag)
        !           296:                        printf(" pgrp %d", s.pgrp);
        !           297:                printf("\n");
        !           298:        }
        !           299:        wqp = (struct queue *)getme(wq, s.wrq, 0, struct queue);
        !           300:        rqp = (struct queue *)getme(rq, RD(s.wrq), 0, struct queue);
        !           301:        if ((struct stdata *)rq.ptr != sp)
        !           302:                printf("rq ptr? = %x\n", rq.ptr);
        !           303:        getme(st, DTNL, 0, struct streamtab);
        !           304:        getme(st1, DKPNL, 0, struct streamtab);
        !           305:        getme(st3, CDKPNL, 0, struct streamtab);
        !           306:        getme(st2, DZNL, 0, struct streamtab);
        !           307:        for (;;) {
        !           308:                d = rqp - (struct queue *)nl[QNL].n_value;
        !           309:                if (d<0 || d>=Nqueue)
        !           310:                        printf("?");
        !           311:                else
        !           312:                        qall[d] = 0;
        !           313:                d = wqp - (struct queue *)nl[QNL].n_value;
        !           314:                if (d<0 || d>=Nqueue)
        !           315:                        printf("?");
        !           316:                else
        !           317:                        qall[d] = 0;
        !           318:                if (!sflag) {
        !           319:                        printf("   RQ %x: ", rqp);
        !           320:                        flags(qflags, rq.flag);
        !           321:                        if (vflag)
        !           322:                                printf(" ptr %x, inf %x", rq.ptr, rq.qinfo);
        !           323:                        printf("\n");
        !           324:                        pblocks(&rq);
        !           325:                        printf("   WQ %x: ", wqp);
        !           326:                        flags(qflags, wq.flag);
        !           327:                        if (vflag)
        !           328:                                printf(" ptr %x, inf %x", wq.ptr, wq.qinfo);
        !           329:                        printf("\n");
        !           330:                        pblocks(&wq);
        !           331:                        if (wq.qinfo == st.wrinit)
        !           332:                                pdtline(&wq);
        !           333:                        if (wq.qinfo == st1.wrinit || wq.qinfo == st3.wrinit)
        !           334:                                dkpline(&wq);
        !           335:                        if (wq.qinfo == st2.wrinit)
        !           336:                                dzfacts(&wq);
        !           337:                }
        !           338:                if (forward) {
        !           339:                        if (wq.next == NULL)
        !           340:                                break;
        !           341:                        wqp = (struct queue *)
        !           342:                             getme(wq, wq.next, 0, struct queue);
        !           343:                        if (wq.flag&QREADR) {
        !           344:                                printf("   <>\n");
        !           345:                                forward = 0;
        !           346:                                rqp = wqp;
        !           347:                                rq = wq;
        !           348:                                wqp = (struct queue *)
        !           349:                                     getme(wq, WR(rqp), 0, struct queue);
        !           350:                        } else
        !           351:                                rqp = (struct queue *)
        !           352:                                     getme(rq, RD(wqp), 0, struct queue);
        !           353:                } else {
        !           354:                        if (rq.next == NULL)
        !           355:                                break;
        !           356:                        rqp = (struct queue *)
        !           357:                             getme(rq, rq.next, 0, struct queue);
        !           358:                        if ((rq.flag&QREADR) == 0) {
        !           359:                                printf("   <>\n");
        !           360:                                forward = 1;
        !           361:                                wqp = rqp;
        !           362:                                wq = rq;
        !           363:                                rqp = (struct queue *)
        !           364:                                     getme(rq, RD(wqp), 0, struct queue);
        !           365:                        } else
        !           366:                                wqp = (struct queue *)
        !           367:                                     getme(wq, WR(rqp), 0, struct queue);
        !           368:                }
        !           369:        }
        !           370: }
        !           371: 
        !           372: pdtline(q)
        !           373: register struct queue *q;
        !           374: {
        !           375:        struct dt dt;
        !           376: 
        !           377:        getme(dt, q->ptr, 0, struct dt);
        !           378:        printf("        nack %o cack %o nchar %d lastecho %o q %lx  ", dt.nack,dt.cack,
        !           379:          dt.nchar, dt.lastecho, dt.queue);
        !           380:        flags(dtflags, dt.state);
        !           381:        printf("\n");
        !           382: }
        !           383: 
        !           384: dzfacts(q)
        !           385: register struct queue *q;
        !           386: {
        !           387:        struct dz dz;
        !           388: 
        !           389:        getme(dz, q->ptr, 0, struct dz);
        !           390:        printf("     DZ: ");
        !           391:        flags(dzflags, dz.state);
        !           392:        printf("\n");
        !           393: }
        !           394: 
        !           395: dkpline(q)
        !           396: register struct queue *q;
        !           397: {
        !           398:        struct dkp dkp;
        !           399:        register i;
        !           400: 
        !           401:        getme(dkp, q->ptr, 0, struct dkp);
        !           402:        printf("        WS %o WACK %o WNX %o iseq %o; ", dkp.WS, dkp.WACK,
        !           403:            dkp.WNX, dkp.iseq);
        !           404:        flags(dkpflags, dkp.state);
        !           405:        printf("\n      ");
        !           406:        for (i=0; i<8; i++)
        !           407:                printf(" %x", dkp.xb[i]);
        !           408:        printf("\n");
        !           409: }
        !           410: 
        !           411: pblocks(q)
        !           412: register struct queue *q;
        !           413: {
        !           414:        struct block b, *bp;
        !           415:        int nb = 0;
        !           416:        u_char buf[512];
        !           417:        register i, bno;
        !           418: 
        !           419:        bp = q->first;
        !           420:        for (i = 0; i < 1000; i++) {
        !           421:                if (bp==NULL)
        !           422:                        break;
        !           423:                bno = bp - (struct block *)nl[BLNL].n_value;
        !           424:                nb++;
        !           425:                baccount(bno);
        !           426:                getme(b, bp, 0, struct block);
        !           427:                if (vflag && (i<10 || vflag>1))
        !           428:                        pblock(&b);
        !           429:                bp = b.next;
        !           430:        }
        !           431:        if (i>=10)
        !           432:                printf("(gave up) ");
        !           433:        if (nb > 0)
        !           434:                printf("       %d blocks\n", nb);
        !           435: }
        !           436: 
        !           437: pblock(bp)
        !           438: register struct block *bp;
        !           439: {
        !           440:        register u_char *cp;
        !           441:        register i = 0;
        !           442:        u_char buf[1024];
        !           443: 
        !           444:        printf("        %.3o:", bp->type);
        !           445:        cp = buf;
        !           446:        getme(buf[0], bp->rptr, 0, buf);
        !           447:        while (bp->rptr < bp->wptr) {
        !           448:                if (i >= 16) {
        !           449:                        printf("\n          ");
        !           450:                        i = 0;
        !           451:                }
        !           452:                if (*cp<040 || *cp>=0177)
        !           453:                        printf(" %.3o ", *cp);
        !           454:                else
        !           455:                        printf("%c", *cp);
        !           456:                cp++;
        !           457:                bp->rptr++;
        !           458:                i++;
        !           459:        }
        !           460:        printf("\n");
        !           461: }
        !           462: 
        !           463: flags(fp, w)
        !           464: register struct flags *fp;
        !           465: {
        !           466:        int any = 0;
        !           467:        while (fp->name) {
        !           468:                if (fp->flag&w) {
        !           469:                        if (any)
        !           470:                                printf(", ");
        !           471:                        any++;
        !           472:                        printf("%s", fp->name);
        !           473:                }
        !           474:                fp++;
        !           475:        }
        !           476: }
        !           477: 
        !           478: _get(addr, off, size, loc)
        !           479: unsigned long addr;
        !           480: char *loc;
        !           481: {
        !           482: 
        !           483:        if (addr < 20)
        !           484:                addr = nl[addr].n_value;
        !           485:        addr += off*size;
        !           486:        lseek(mem, addr&0x7fffffff, 0);
        !           487:        read(mem, loc, size);
        !           488:        return(addr);
        !           489: }
        !           490: 
        !           491: bfreecount()
        !           492: {
        !           493:        struct block b;
        !           494:        struct block *bp;
        !           495:        register i;
        !           496: 
        !           497:        for (i=0; i<3; i++) {
        !           498:                getme(bp, QFNL, i, struct block *);
        !           499:                while (bp) {
        !           500:                        baccount(bp - (struct block *)nl[BLNL].n_value);
        !           501:                        getme(b, bp, 0, struct block);
        !           502:                        bp = b.next;
        !           503:                }
        !           504:        }
        !           505: }
        !           506: 
        !           507: baccount(bno)
        !           508: {
        !           509:        if (bno < 0 || bno >= Nblock)
        !           510:                printf("funny block %d\n", bno);
        !           511:        else if (ball[bno])
        !           512:                printf("dup block %d\n", bno);
        !           513:        else
        !           514:                ball[bno]++;
        !           515: }

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