misc.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

			}
			if(pp->pr_sw == CHAR)
				putchar(ch);
			else
				printf(" %4.4o", ch & 0377);
		}
		break;
	case HEX:
		if(addr & 03) {
			printf("warning: address not word aligned\n");
		}
		for(i = 0; i < units; i++) {
			if(i % 4 == 0) {
				if(i != 0)
					printf("\n");
				printf(FMT, (int)addr + i * NBPW);
				printf(":");
			}
			if(read(mem, (char *)&lword, sizeof (long)) !=
			    sizeof (long)) {
				printf("  read error");
				break;
			}
			printf(" %08x", lword);
		}
		break;

	case STRING: {
		char string[1024];
		if(read(mem, string, sizeof (string)) != sizeof (string)) {
			printf("  read error");
			break;
		}
		if(units == 0)
			printf(" %s", string);
		else {
			char format[10];
			sprintf(format, " %%%ds", units);
			printf(format, string);
		}
		break;
	}
	}
	putc('\n', stdout);
}

struct gnode *gnodetab=NULL;

initgnode() {
	struct buckets 	*bucketaddr=NULL;
	struct Symbol Glist, Gnode;
	struct Symbol *symsrch();
	
	Gnode = *symsrch("_gnode");
	Gfree = *symsrch("_gfreeh");
	readsym (&Gnode, (char *)&tab[GNODE_T].first, sizeof(unsigned));
	readsym (symsrch("_ngnode"), (char *)&tab[GNODE_T].ents, sizeof(int));
	tab[GNODE_T].name = "gnode";
	tab[GNODE_T].size = sizeof(struct gnode);
	tab[GNODE_T].last = (unsigned) 0;
	
	if (gnodetab == NULL)
	gnodetab = (struct gnode *) malloc((unsigned)(sizeof(struct gnode) *
	    tab[GNODE_T].ents));

	if (bucketaddr == NULL)
	bucketaddr = (struct buckets *) malloc((unsigned)
	    (sizeof(struct buckets) * tab[GNODE_T].ents));

	if((bucketaddr == NULL) || (gnodetab == NULL)) 
		fatal("cannot allocate space for gnode temp tables");
	else {	/* get us the gnodes */
		register int i;
		register int max = tab[GNODE_T].ents;
		char *gnodeaddr;
		
		bzero((char *)gnodetab, sizeof(struct gnode) * max);
		bzero((char *)bucketaddr, sizeof(struct buckets) * max);
		bzero((char *)gnodebuckets, sizeof gnodebuckets);
		Glist = *symsrch("_gnode");		
		readmem((char *)&gnodeaddr, (int)Glist.s_value,
		    sizeof(struct gnode *));
		
		for(i = 0; i < max; i++)  {
			readmem((char *)&gnodetab[i], (int)gnodeaddr,
			    sizeof(struct gnode));
			bucketaddr->index = i;
			bucketaddr->addr = (char *) gnodeaddr;
			bucketaddr->next = gnodebuckets[HASH(gnodeaddr,
			    GNODEBUCKETS)];
			gnodebuckets[HASH(gnodeaddr, GNODEBUCKETS)] =
			    bucketaddr++;
			gnodeaddr = (char *) ((int)gnodeaddr + sizeof(struct
			    gnode));
		}
	}
}

#ifdef notdef
/*MJK*/printgnodecache(hash)
	int hash;
{
	struct buckets *bp;
	int i;
	for(i = 0; i < GNODEBUCKETS; i++) {
		if(hash != -1) i = hash;
		printf("bucket %d 0x%x\n", i, &gnodebuckets[i]);
		bp = gnodebuckets[i];
		do {
			printf("bucketaddr 0x%x addr 0x%x, index %d next 0x%x\n",
			bp, bp->addr, bp->index, bp->next);
			bp = bp->next;
		} while(bp->next);
		if(hash != -1) break;
	}
}
#endif

struct file *filetab=NULL;

initfile() {
	struct buckets 	*bucketaddr=NULL;
	struct Symbol Flist;
	struct Symbol *symsrch();

	readsym (symsrch("_nfile"), (char *)&tab[FILE_T].ents, sizeof(int));
	tab[FILE_T].name = "file";
	tab[FILE_T].size = sizeof(struct file);
	tab[FILE_T].last = (unsigned) 0;
	if (filetab == NULL)
	filetab = (struct file *) malloc((unsigned)(sizeof(struct file) *
	    tab[FILE_T].ents));
	if (bucketaddr == NULL)
	bucketaddr = (struct buckets *) malloc((unsigned)
	    (sizeof(struct buckets) * tab[FILE_T].ents));
	if((bucketaddr == NULL) || (filetab == NULL)) 
		fatal("cannot allocate space for file temp tables");
	else {	/* get us the file */
		register int i;
		register int max = tab[FILE_T].ents;
		char *fileaddr;
		
		bzero((char *)filetab, sizeof(struct file) * max);
		bzero((char *)bucketaddr, sizeof(struct buckets) * max);
		bzero((char *)filebuckets, sizeof filebuckets);
		Flist = *symsrch("_file");		
		readmem((char *)&fileaddr, Flist.s_value, sizeof(int));
		
		for(i = 0; i < max; i++)  {
			readmem((char *)&filetab[i], (int)fileaddr,
			    sizeof(struct file));
			bucketaddr->index = i;
			bucketaddr->addr = (char *) fileaddr;
			bucketaddr->next = filebuckets[HASH(fileaddr,
			    FILEBUCKETS)];
			filebuckets[HASH(fileaddr, FILEBUCKETS)] =
			    bucketaddr++;
			fileaddr = (char *) ((int)fileaddr + sizeof(struct
			    file));
		}
	}
}

struct mount *mounttab=NULL;

initmount() {
	struct buckets 	*bucketaddr=NULL;
	struct Symbol Mlist;
	struct Symbol *symsrch();
	
	readsym (symsrch("_nmount"), (char *)&tab[MOUNT_T].ents, sizeof(int));
	tab[MOUNT_T].name = "mount";
	tab[MOUNT_T].size = sizeof(struct mount);
	tab[MOUNT_T].last = (unsigned) 0;
	
	if (mounttab == NULL)
	mounttab = (struct mount *) malloc((unsigned)(sizeof(struct mount) *
	    tab[MOUNT_T].ents));
	if (bucketaddr == NULL)
	bucketaddr = (struct buckets *) malloc((unsigned)
	    (sizeof(struct buckets) * tab[MOUNT_T].ents));

	if((bucketaddr == NULL) || (mounttab == NULL)) 
		fatal("cannot allocate space for mount temp tables");
	else {	/* get us the file */
		register int i;
		register int max = tab[MOUNT_T].ents;
		char *mountaddr;
		
		bzero((char *)mounttab, sizeof(struct mount) * max);
		bzero((char *)bucketaddr, sizeof(struct buckets) * max);
		bzero((char *)mountbuckets, sizeof mountbuckets);
		Mlist = *symsrch("_mount");		
		mountaddr = (char *) Mlist.s_value;

		for(i = 0; i < max; i++)  {
			readmem((char *)&mounttab[i], (int)mountaddr,
			    sizeof(struct mount));
			bucketaddr->index = i;
			bucketaddr->addr = (char *) mountaddr;
			bucketaddr->next = mountbuckets[HASH(mountaddr,
			    MOUNTBUCKETS)];
			mountbuckets[HASH(mountaddr, MOUNTBUCKETS)] =
			    bucketaddr++;
			mountaddr = (char *) ((int)mountaddr + sizeof(struct
			    mount));
		}
	}
}

#ifdef notdef
/*MJK*/printmountcache(hash)
	int hash;
{
	struct buckets *bp;
	int i;
	for(i = 0; i < MOUNTBUCKETS; i++) {
		if(hash != -1) i = hash;
		printf("printmountcache: bucket %d 0x%x\n", i, &mountbuckets[i]);
		fflush(stdout);
		bp = mountbuckets[i];
		while(bp) {
			printf("bucketaddr 0x%x addr 0x%x, index %d next 0x%x\n",
			bp, bp->addr, bp->index, bp->next);
			fflush(stdout);			
			bp = bp->next;
		}
		if(hash != -1) break;
	}
}
#endif

struct buf *buftab=NULL;

initbuf() {
	struct buckets 	*bucketaddr=NULL;
	struct Symbol *symsrch();
	struct Symbol Buf;
	int buf_headers;
	struct buf *buf;
	
	readsym (symsrch("_nbuf"), (char *)&tab[BUF_T].ents,sizeof(int));
	buf_headers = tab[BUF_T].ents;
	Buf = *symsrch("_buf");
	readsym (&Buf, (char *)&buf, sizeof(unsigned));
	tab[BUF_T].name = "buf";
	tab[BUF_T].size = sizeof(struct buf);
	tab[BUFH_T].first = Buffree.s_value;
	tab[BUFH_T].ents = BQUEUES;
	tab[BUFH_T].name = "bfreelist";
	tab[BUFH_T].size = sizeof(struct buf);
	tab[BUFH_T].last = (unsigned) 0;
	
	readmem((char *)bfreelist, symsrch("_bfreelist")->s_value,
	    sizeof(struct buf) * BQUEUES);
	if (buftab == NULL)
	buftab = (struct buf *) malloc((unsigned)
	    (sizeof(struct buf) * buf_headers));
	if (bucketaddr == NULL)
	bucketaddr = (struct buckets *) malloc((unsigned)
	    (sizeof(struct buckets) * buf_headers));
	if((bucketaddr == NULL) || (buftab == NULL)) {
		fatal("cannot allocate space for buf temp tables");
	} else {	/* get us the buffer headers */
		register int i;
		struct buf *bufaddr;
		
		bzero((char *)buftab, sizeof(struct buf) * buf_headers);
		bzero((char *)bucketaddr, sizeof(struct buckets) * buf_headers);
		bzero((char *)bufbuckets, sizeof bufbuckets);
		bufaddr = buf;		
#ifdef DEBUG
		printf("first buf at 0x%x buf_headers %d\n", buf, buf_headers);
#endif
		for(i = 0; i < buf_headers; i++) {		
			readmem((char *)&buftab[i], (int)bufaddr,
			    sizeof(struct buf));
			if(i < buf_headers) {
				bucketaddr->index = i;
				bucketaddr->addr = (char *) bufaddr;
				bucketaddr->next =
				    bufbuckets[HASH(bufaddr, BUFBUCKETS)];
				bufbuckets[HASH(bufaddr, BUFBUCKETS)] =
				    bucketaddr++;
			} else {
				prbadbuf(bufaddr, (struct buf *)
				    ((u_int) tab[BUFH_T].first + i));
				break;
			}
			bufaddr = (struct buf *)((int)bufaddr + sizeof(struct
				buf));
#ifdef DEBUG
			printf("buf %d at 0x%x\n", i + 1, bufaddr);
#endif
		}
	}
}

#ifdef notdef
/*MJK*/printbufcache(hash)
	int hash;
{
	struct buckets *bp;
	int i;
	for(i = 0; i < BUFBUCKETS; i++) {
		if(hash != -1) i = hash;
		bp = bufbuckets[i];
		printf("printbufcache: bucket %d 0x%x\n", i, &bufbuckets[i]);
		fflush(stdout);
		while(bp) {
			printf("bucketaddr 0x%x addr 0x%x, index %d next 0x%x\n",
			bp, bp->addr, bp->index, bp->next);
			fflush(stdout);			
			bp = bp->next;
		}
		if(hash != -1) break;
	}
}
#endif

prbadbuf(bp, stop)
	struct buf *bp;
	char *stop;
{
	while(bp != (struct buf *)stop) {
		printf("bad (non allocated buffer) at 0x%x\n", bp);
	}
}


struct proc *proctab=NULL;

initproc() {
	struct buckets 	*bucketaddr=NULL;
	struct Symbol Plist;
	struct Symbol *symsrch();
	
	Plist = *symsrch("_proc");
	tab[PROC_T].first = Plist.s_value;
	readsym (symsrch("_nproc"), (char *)&tab[PROC_T].ents, sizeof(int));
	tab[PROC_T].name = "proc";
	tab[PROC_T].size = sizeof(struct proc);
	tab[PROC_T].last = (unsigned) 0;
	
	if (proctab == NULL)
	proctab = (struct proc *) malloc((unsigned)(sizeof(struct proc) *
	    tab[PROC_T].ents));
	if (bucketaddr == NULL)	
	bucketaddr = (struct buckets *) malloc((unsigned)
	    (sizeof(struct buckets) * tab[PROC_T].ents));
	if((bucketaddr == NULL) || (proctab == NULL)) 
		fatal("cannot allocate space for proc temp tables");
	else {	/* get us the file */
		register int i;
		register int max = tab[PROC_T].ents;
		int procaddr;
		
		bzero((char *)proctab, sizeof(struct proc) * max);
		bzero((char *)bucketaddr, sizeof(struct buckets) * max);
		bzero((char *)procbuckets, sizeof procbuckets);
		readmem((char *)&procaddr, Plist.s_value, sizeof(int));

		for(i = 0; i < max; i++)  {
			readmem((char *)&proctab[i], procaddr,
			    sizeof(struct proc));
			bucketaddr->index = i;
			bucketaddr->addr = (char *) procaddr;
			bucketaddr->next = procbuckets[HASH(procaddr,
			    PROCBUCKETS)];
			procbuckets[HASH(procaddr, PROCBUCKETS)] =
			    bucketaddr++;
			procaddr = (procaddr + sizeof(struct proc));
		}
	}
}


getindex(addr, buckethead, bucket)
	char *addr;
	struct buckets *buckethead[];
	int bucket;
{
	struct buckets *bp = buckethead[HASH(addr, bucket)];
	while((bp != NULL) && (bp->addr != addr)) {
		bp = bp->next;
	}
	return(bp ? bp->index : -1);
}


resync()
{

	initfile();
	initgnode();
	initmount();
	initbuf();
	initproc();
	

}