![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to showq.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / showq|
Return to showq.c CVS log | Up to [Research Unix] / researchv8dc / cmd / showq |
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.