Return to showq.c CVS log

Up to [Research Unix] / researchv10no / cmd

researchv10 Norman

#include <nlist.h>
#include <sys/param.h>
#include <ctype.h>
#include <sys/stream.h>
#include <sys/inode.h>
#include <sys/conf.h>
#include <sys/dkp.h>
#include <sys/dz.h>

struct nlist nl[] ={
#define	QNL	0
	{"_queue"},
#define	BLNL	1
	{"_cblock"},
#define	STNL	2
	{"_streams"},
#define	QFNL	3
	{"_qfreelist"},
#define DKPNL	4
	{ "_dkpstream" },
#define	NBLOCK	5
	{ "_blkcnt"},
#define	NQUEUE	6
	{ "_queuecnt"},
#define	NSTREAM	7
	{ "_streamcnt"},
#define	DZNL	8
	{"_dzinfo"},
#define CDKPNL	9
	{ "_cdkpstream" },
#define	BLKALL	10
	{ "_blkall" },
#define	BLKMAX	11
	{ "_blkmax" },
#define	BLKFREE	12
	{ "_blkfree" },
#define	STWNL	13
	{ "_stwdata" },
#define	BLKOWN	14
	{ "_blkowner" },
#define	STRDATA	15
	{ "_strdata" },
#define	STREAMSTART	16
	{ "_bufldstream" },
	{ "_rdkstream" },
	{ "_connstream" },
	{ "_connginfo" },
	{ "_kcinfo" },
	{ "_rcureinfo" },
	{ "_qesinfo" },
	{ "_dhvinfo" },
	{ "_dkinfo" },
	{ "_dkpstream" },
	{ "_cdkpstream" },
	{ "_dzinfo" },
	{ "_kbinfo" },
	{ "_kdiinfo" },
	{ "_msgstream" },
	{ "_rmsgstream" },
	{ "_mginfo" },
	{ "_ilsinfo" },
	{ "_nttystream" },
	{ "_spinfo" },
	{ "_ttystream" },
	{ "_xpstream" },
	{ "_ipdinfo" },
	{ "_ipstream" },
	{ "_tcpdinfo" },
	{ "_tcpstream" },
	{ "_udpdinfo" },
	{ "_udpstream" },
	{ "_nilinfo" },
	{ "_cnstream" },
	{ "" },
};

struct	infoinfo {
	char	*name;
	struct	streamtab inf;
} inf[50];

struct	qinit **qall;
char	*ball;
char	*strall;
char	*core = "/dev/mem";
char	*sys  = "/unix";
int	mem;
int	blkcnt;
int	queuecnt;
int	streamcnt;
short	blkall[6];
short	blkmax[6];
short	blkfree[6];

#define	DK_OPEN	01
#define	DK_LCLOSE	02
#define	DK_RCLOSE	04
#define	DK_XCHARMODE	010
#define	DK_RCHARMODE	0200
#define	DK_OPENING	020

#define	getme(s, kind, off, type)  _get(kind, off, sizeof(type), &s)

struct flags {
	int	flag;
	char	*name;
};

struct flags stflags[] = {
	IOCWAIT,	"IOC",
	RSLEEP,		"RSLEEP",
	WSLEEP,		"WSLEEP",
	HUNGUP,		"HUNGUP",
	RSEL,		"RSEL",
	WSEL,		"WSEL",
	EXCL,		"EXCL",
	STWOPEN,	"WOPEN",
	0
};

struct flags qflags[] = {
	QUSE,		"use",
	QREADR,		"read",
	QNOENB,		"noenb",
	QENAB,		"enab",
	QWANTR,		"wantr",
	QWANTW,		"wantw",
	QFULL,		"full",
	QDELIM,		"delim",
	QBIGB,		"bigb",
	0
};

struct	flags dkpflags[] = {
	DK_OPEN,	"open",
	DK_LCLOSE,	"lclose",
	DK_RCLOSE,	"rclose",
	DK_XCHARMODE,	"xcharmode",
	DK_RCHARMODE,	"rcharmode",
	DK_OPENING,	"opening",
	0
};

#define	DZEXIST	01
#define	DZISOPEN 02
#define	DZWOPEN	04
#define	DZTIME	010
#define	DZCARR	020
#define	DZSTOP	040
#define	DZHUPCL	0100

struct flags dzflags[] = {
	DZEXIST,	"exists",
	DZISOPEN,	"open",
	DZWOPEN,	"wopen",
	DZTIME,		"time",
	DZCARR,		"carrier",
	DZSTOP,		"stop",
	DZHUPCL,	"hupcl",
	0
};

int	vflag;
int	sflag;
int	mflag;
char	*infstr();

main(argc, argv)
char **argv;
{
	struct queue q;
	struct block b;
	struct stdata s;
	int i;
	int nq = 0;

	for (;;argc--, argv++) {
		if (argc>1 && strcmp(argv[1], "-v")==0) {
			vflag++;
			continue;
		}
		if (argc>1 && strcmp(argv[1], "-m")==0) {
			mflag++;
			continue;
		}
		if (argc>1 && strcmp(argv[1], "-V")==0) {
			vflag = 2;
			continue;
		}
		if (argc>1 && strcmp(argv[1], "-s")==0) {
			sflag++;
			continue;
		}
		break;
	}
	if (argc>1)
		sys = argv[1];
	if (argc>2)
		core = argv[2];
	nlist(sys, nl);
	mem = open(core, 0);
	if (mem<0) {
		printf("can't open %s\n", core);
		exit(1);
	}
	getme(queuecnt, NQUEUE, 0, int);
	getme(streamcnt, NSTREAM, 0, int);
	getme(blkcnt, NBLOCK, 0, int);
	getme(blkmax[0], BLKMAX, 0, blkmax);
	getme(blkall[0], BLKALL, 0, blkall);
	getme(blkfree[0], BLKFREE, 0, blkfree);
	printf("blocks max: (%d,%d,%d,%d,%d,%d)\n",
		blkmax[0], blkmax[1], blkmax[2], blkmax[3], blkmax[4], blkmax[5]);
	printf("blocks cur: (%d,%d,%d,%d,%d,%d)\n",
		blkall[0], blkall[1], blkall[2], blkall[3], blkall[4], blkall[5]);
	printf("blocks free: (%d,%d,%d,%d,%d,%d)\n",
		blkfree[0], blkfree[1], blkfree[2], blkfree[3], blkfree[4], blkfree[5]);
	initinfo();
	ball = (char *)malloc(blkcnt*sizeof(char));
	strall = (char *)malloc(streamcnt*sizeof(char));
	qall = (struct qinit **)malloc(queuecnt*sizeof(struct queue *));
	for (i=0; i<blkcnt; i++)
		ball[i] = 0;
	for (i=0; i<streamcnt; i++)
		strall[i] = 0;
	for (i=0; i<queuecnt; i++) {
		getme(q, QNL, i, struct queue);
		if (q.flag==0)
			qall[i] = 0;
		else {
			qall[i] = q.qinfo;
			nq++;
		}
	}
	for (i=0; i<streamcnt; i++)
		pstream(i);
	for (i=0; i<queuecnt; i++) {
		if (qall[i])
			printf("Loose queue %d, info #%x\n", i, qall[i]);
	}
	printf("%d queues in use\n", nq);
	bfreecount();
	nq = 0;
	for (i=0; i<blkcnt; i++)
		if (ball[i]==0) {
			struct block b;
			long owner;

			if (mflag) {
				getme(b, BLNL, i, struct block);
#if BLKOWNER
				getme(owner, BLKOWN, i, long);
				printf("   owner=##%x\n", owner);
#endif
				pblock(&b);
			}
			nq++;
		}
	if (!sflag)
		printf("%d blocks missing\n", nq);
	nq = 0;
	for (i=0; i<blkcnt; i++) {
		if (ball[i])
			continue;
		if (nq >= 5 && vflag < 2)
			continue;
		printf("#%x\n", (struct block *)nl[BLNL].n_value+i);
		nq++;
	}
	exit(0);
}

pstream(i)
{
	struct stdata s;
	struct queue rq, wq;
	struct inode ino;
	struct queue *rqp, *wqp;
	struct stdata *sp;
	static struct streamtab dkpinfo, dzinfo, cdkpinfo;
	static int stread = 0;
	int d;
	int forward = 1;

	if (strall[i])
		return;
	strall[i]++;
	sp = (struct stdata *)getme(s, STNL, i, struct stdata);
	if (s.wrq==NULL)
		return;
	if (!sflag)
		printf("\nstream %d: ", i);
	getme(ino, s.inode, 0, struct inode);
	d = ino.i_un.i_rdev;
	if (!sflag) {
		printf("dev %d,%d  ", major(d), minor(d));
		printf("ino %d  ", ino.i_number);
		printf("count %d ", s.count);
		flags(stflags, s.flag);
		if (vflag)
			printf(" pgrp %d", s.pgrp);
		printf("\n");
	}
	wqp = (struct queue *)getme(wq, s.wrq, 0, struct queue);
	rqp = (struct queue *)getme(rq, RD(s.wrq), 0, struct queue);
	if ((struct stdata *)rq.ptr != sp)
		printf("rq ptr? = #%x\n", rq.ptr);
	if (stread == 0) {
		getme(dkpinfo, DKPNL, 0, struct streamtab);
		getme(cdkpinfo, CDKPNL, 0, struct streamtab);
		getme(dzinfo, DZNL, 0, struct streamtab);
		stread++;
	}
	for (;;) {
		d = rqp - (struct queue *)nl[QNL].n_value;
		if (d<0 || d>=queuecnt)
			printf("?");
		else
			qall[d] = 0;
		d = wqp - (struct queue *)nl[QNL].n_value;
		if (d<0 || d>=queuecnt)
			printf("?");
		else
			qall[d] = 0;
		if (!sflag) {
			printf("   RQ #%x: ", rqp);
			printf("%s; ", infstr(rq.qinfo));
			flags(qflags, rq.flag);
			printf(". ptr #%x", rq.ptr);
			printf("\n");
			pblocks(&rq);
			printf("   WQ #%x:   ", wqp);
			flags(qflags, wq.flag);
			printf(". ptr #%x", wq.ptr);
			printf("\n");
			pblocks(&wq);
			if ((long)wq.qinfo == nl[STWNL].n_value)
				strfacts(&wq);
			if (wq.qinfo == dkpinfo.wrinit || wq.qinfo == cdkpinfo.wrinit)
				dkpline(&wq);
			if (wq.qinfo == dzinfo.wrinit)
				dzfacts(&wq);
		}
		if (forward) {
			if (wq.next == NULL)
				break;
			wqp = (struct queue *)
			     getme(wq, wq.next, 0, struct queue);
			if (wq.flag&QREADR) {
				printf("   <>\n");
				forward = 0;
				rqp = wqp;
				rq = wq;
				wqp = (struct queue *)
				     getme(wq, WR(rqp), 0, struct queue);
			} else
				rqp = (struct queue *)
				     getme(rq, RD(wqp), 0, struct queue);
		} else {
			if (rq.next == NULL)
				break;
			rqp = (struct queue *)
			     getme(rq, rq.next, 0, struct queue);
			if ((rq.flag&QREADR) == 0) {
				printf("   <>\n");
				forward = 1;
				wqp = rqp;
				wq = rq;
				rqp = (struct queue *)
				     getme(rq, RD(wqp), 0, struct queue);
			} else
				wqp = (struct queue *)
				     getme(wq, WR(rqp), 0, struct queue);
		}
	}
}

strfacts(q)
register struct queue *q;
{
	register int i;
	struct stdata s;
	dev_t d;
	struct inode ino;

	i = (struct stdata *)q->ptr - (struct stdata *)nl[STNL].n_value;
	if (i < 0 || i > streamcnt)
		return;
	if (strall[i])
		return;
	strall[i]++;
	getme(s, STNL, i, struct stdata);
	if (s.wrq==NULL)
		return;
	if (!sflag)
		printf("stream %d: ", i);
	getme(ino, s.inode, 0, struct inode);
	d = ino.i_un.i_rdev;
	if (!sflag) {
		printf("dev %d,%d  ", major(d), minor(d));
		printf("ino %d  ", ino.i_number);
		printf("count %d ", s.count);
		flags(stflags, s.flag);
		if (vflag)
			printf(" pgrp %d", s.pgrp);
		printf("\n");
	}
}

dzfacts(q)
register struct queue *q;
{
	struct dz dz;

	getme(dz, q->ptr, 0, struct dz);
	printf("     DZ: ");
	flags(dzflags, dz.state);
	printf("\n");
}

dkpline(q)
register struct queue *q;
{
	struct dkp dkp;
	register i;

	getme(dkp, q->ptr, 0, struct dkp);
	printf("	WS %o WACK %o WNX %o iseq %o; ", dkp.WS, dkp.WACK,
	    dkp.WNX, dkp.iseq);
	printf("window %d x %d; ", dkp.XW, dkp.xsize);
	flags(dkpflags, dkp.state);
	printf("\n	");
	for (i=0; i<8; i++)
		printf(" #%x", dkp.xb[i]);
	printf("\n");
}

pblocks(q)
register struct queue *q;
{
	struct block b, *bp;
	int nb = 0;
	u_char buf[512];
	register i, bno;

	bp = q->first;
	for (i = 0; i < 1000; i++) {
		if (bp==NULL)
			break;
		bno = bp - (struct block *)nl[BLNL].n_value;
		nb++;
		baccount(bno);
		getme(b, bp, 0, struct block);
		if (vflag && (i<10 || vflag>1))
			pblock(&b);
		bp = b.next;
	}
	if (vflag && i>=10)
		printf("(gave up) ");
	if (nb > 0)
		printf("       %d blocks\n", nb);
}

pblock(bp)
register struct block *bp;
{
	register u_char *cp;
	register i = 0;
	u_char buf[4096];

	printf("       %c%.3o:", bp->class&0200?'D':' ', bp->type);
	cp = buf;
	getme(buf[0], bp->base, 0, buf);
	printf("%3d:", bp->wptr-bp->base);
	while (bp->base < bp->wptr) {
		if (i >= 16) {
			printf("\n	        ");
			i = 0;
		}
		if (*cp<040 || *cp>=0177)
			printf(" %.3o", *cp);
		else
			printf("  %c ", *cp);
		cp++;
		bp->base++;
		i++;
	}
	printf("\n");
}

flags(fp, w)
register struct flags *fp;
{
	int any = 0;
	while (fp->name) {
		if (fp->flag&w) {
			if (any)
				printf(", ");
			any++;
			printf("%s", fp->name);
		}
		fp++;
	}
}

_get(addr, off, size, loc)
unsigned long addr;
char *loc;
{

	if (addr < 20)
		addr = nl[addr].n_value;
	addr += off*size;
	lseek(mem, addr&0x7fffffff, 0);
	read(mem, loc, size);
	return(addr);
}

bfreecount()
{
	struct block b;
	struct block *bp;
	register i;

	for (i=0; i<6; i++) {
		getme(bp, QFNL, i, struct block *);
		while (bp) {
			baccount(bp - (struct block *)nl[BLNL].n_value);
			getme(b, bp, 0, struct block);
			bp = b.next;
		}
	}
}

baccount(bno)
{
	if (bno < 0 || bno >= blkcnt)
		printf("funny block %d\n", bno);
	else if (ball[bno])
		printf("dup block %d\n", bno);
	else
		ball[bno]++;
}

initinfo()
{
	register i, j;

	inf[0].name = "head";
	inf[0].inf.rdinit = (struct qinit *)nl[STRDATA].n_value;
	for (j=1, i=STREAMSTART; nl[i].n_name[0]; i++) {
		if (nl[i].n_type!=0) {
			getme(inf[j].inf, nl[i].n_value, 0, struct streamtab);
			inf[j].name = nl[i].n_name;
			if (inf[j].name[0]=='_')
				inf[j].name++;
			j++;
		}
	}
}

char *
infstr(s)
long s;
{
	register i;
	static char buf[64];

	for (i=0; inf[i].name; i++) {
		if (inf[i].inf.rdinit == (struct qinit *)s
		 || inf[i].inf.wrinit == (struct qinit *)s) {
			sprintf(buf, "%s", inf[i].name);
			break;
		}
	}
	if (inf[i].name == NULL)
		sprintf(buf, "qinfo #%x", s);
	return(buf);
}

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