file.c

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

	for (i = 0; i < NIADDR; i++) {
		printf("%8d", G_TO_I(gp)->di_ib[i]);
		if (i % 6 == 5)
			printf("\n            ");
	}
	printf("\n");
}

int get_file_slot(s)
	register char *s;
{
	int index;
	int addr;
	
	if((*s == '@') || (*s == '*')){
		sscanf(++s, "%x", &addr);
		index =	 getindex((char *)addr, filebuckets, FILEBUCKETS);
		if(index == -1)
			printf("addr 0x%x is not a file\n", addr);
	} else
		if(isdigit(*s)) {
			index = atoi(s);
		} else
			index = -1;
	return(index);
}

int get_gnode_slot(s)
	register char *s;
{
	int index;
	int addr;
	
	switch(*s) {
		case '@' :
		case '*' :
			sscanf(++s, "%x", &addr);
			index =	 getindex((char *)addr, gnodebuckets,
			    GNODEBUCKETS);
			if(index == -1)
				printf("addr 0x%x is not a gnode\n", addr);
			break;
		case '#' :
			sscanf(++s, "%d", &addr);
			index = gnum_to_slot(addr);
			if(index == -1)
				printf("cannot find slot %d\n", addr);
			break;
		default:
			if(isdigit(*s))
				index = atoi(s);
			else {
				printf("%s is an invalid token\n", s);
				index = -1;
			}
	}
	return(index);
}

int
gnum_to_slot(gnum)
	int gnum;
{
	int slot;

	for (slot = 0; slot < tab[GNODE_T].ents; slot++) {
		if ((int)gnodetab[slot].g_number == gnum)
			return (slot);
	}
	return (-1);
}



void
printrnodehd() 
{
	printf("          FHANDLE            EFFECTIVE       REAL   ");
	printf(" AS WR      \n");
	printf("SLOT FSID    NO  GEN   REF   UID   GID    UID    GID");
	printf(" ERROR FLAGS\n");
}

void
printgnodehd() {
	printf("SLOT MAJ  MIN FS  GNUMB REF LINK  UID  ");
	printf("GID    SIZE FORW BACK    MODE  FLAGS\n");
}


prgnode_long(gp)
	struct gnode *gp;
{
	printf("g_chain[2] - 0x%x 0x%x (",gp->g_chain[0],gp->g_chain[1]);
	if (gp->g_chain[0] != NULL) {
		praddr(gp->g_chain[0]);
		printf("  ");
	}
	if (gp->g_chain[1] != NULL) {
		praddr(gp->g_chain[1]);
		printf("  ");
	}
	printf(")\n\n");

	printf("rdev %d %d (0x%x) ", (gp->g_rdev>>8),(gp->g_rdev&0377),
	       gp->g_rdev);
	printf("g_shlockc %d g_exlockc %d\n", gp->g_shlockc, gp->g_exlockc);
	printf("g_mp -");
	praddr(gp->g_mp);
	printf(" g_ops - ");
	praddr(gp->g_ops);
	printf(" g_altops -");
	praddr(gp->g_altops);
	printf("\n");

	printf("g_dquot 0x%x g_blocks %d g_gennum %d\n",
	       gp->g_dquot, gp->g_blocks, gp->g_gennum);

	printf("\n Initialization state: - ");
	switch (gp->g_init) {
		default:
			printf (" *Unknown*\n");
			break;
		case READY_GNODE:
			printf (" Ready\n");
			break;
		case RECLAIM_GNODE:
			printf (" Reclaim\n");
			break;
		case NEW_GNODE:
			printf (" New\n");
			break; 
	}
	
	prlock_long(&gp->g_lk);

	printf("\nRead-ahead %d\n",gp->g_lastr);

	if (gp->g_flag & GTEXT) {
		printf(" Text branch:\n");
		printf("g_text ");
		praddr(gp->g_textp);
		printf(" Cmap entry ");
		praddr(gp->g_hcmap_struct);
		printf("\n");
		printf(" xcount %d  hcount %d hcmap 0x%x\n",
		       gp->g_xcount, gp->g_hcount, gp->g_hcmap);
	}
	if ((gp->g_mode & GFMT) == GFSOCK) {
		printf(" Socket: \n");
		praddr(gp->g_socket);
		printf(" (0x%x)\n",gp->g_socket);
	}

	if (gp->g_count == 0) {
		printf("Free list: 0x%x 0x%x (",gp->g_forw,gp->g_back);
		if (gp->g_forw != NULL) {
			praddr(gp->g_forw);
			printf("  ");
		}
		if (gp->g_back != NULL) {
			praddr(gp->g_back);
			printf("  ");
		}
		printf(")\n");
	}
	printf("\n");
}
#define EX_RDONLY 0x01 

prexport()
{
	unsigned ep, enxt;
	struct export e;
	char path[MAXPATHLEN];

	readsym(symsrch("_exported"), &ep, sizeof(ep));

	if (ep == NULL) {
		printf("Empty List\n");
		return;
	} 
	printf(" fsid     inum       gen    map flags path\n");
/*              dddddd ddddddddd dddddddddd ddd ss    ppppppppppppppp */
	do {
		get_export(ep, &e);

		if (readmem((char *)path, (int)e.e_path, e.e_pathlen) 
		    != e.e_pathlen) {
			perror("export path read");
			printf("read error on export path at 0x%x\n", e.e_path);
			return(0);
		}

		printf("%5d %10d %10d %3d %2s    %s\n",
		       e.e_fsid, e.e_gnum, e.e_gen, e.e_rootmap,
		       e.e_flags & EX_RDONLY ? "ro" : "  ",
		       path);


		ep = (unsigned)e.e_next;

	} while (ep != NULL);
}

int
get_export(addr, ep)
	unsigned addr;
	struct export *ep;
{

	if (readmem((char *)ep, (int)addr, sizeof(*ep)) 
	    != sizeof(*ep)) {
		perror("export read");
		printf("read error on export at 0x%x\n", addr);
		return(0);
	}
	return(1);
}

pr_dnlc()
{
	struct ncache nc;
	struct ucred cred;
	unsigned addr, size;
	char name[50];
	int i;

	readsym(symsrch("_ncache"), &addr, sizeof(addr));
	readsym(symsrch("_ncsize"), &size, sizeof(size));
	printf("ncache: 0x%x, cache size %d entries\n", addr, size);
	printf("Entry       Name        uid      cred  gnode parent\n");
/*              ddddd nnnnnnnnnnnnnnn ddddd 0xhhhhhhhh xxxxx xxxxx */
	for (i=0; i<size; i++) {
		if (readmem((char *)&nc, (int) addr, sizeof(nc))
				    != sizeof(nc)) {
			printf("read error on dnlc at 0x%x\n", addr);
			perror("dnlc entry read");
			return(0);
		}
		if (nc.vp != NULL) {
			readmem((char *)&cred, (int) nc.cred, sizeof(cred));
			strncpy(name, nc.name, nc.namlen);
			name[nc.namlen]='\0';
			printf("%5d %15s %5d 0x%x %5d %5d\n",
			       i, name,cred.cr_uid, nc.cred,
			       getindex((char *)nc.vp, 
					gnodebuckets, GNODEBUCKETS),
			       getindex((char *)nc.dp,
					gnodebuckets, GNODEBUCKETS));
		}
		addr += sizeof(struct ncache);
	}

}


prnamei(index)
	int index;
{
	int	nchsize,i;
	struct nch *np, nch;
	char name[NCHNAMLEN];
	unsigned addr;
	
	readsym(symsrch("_nch"), &addr, sizeof(addr));
	readsym(symsrch("_nchsize"), &nchsize, sizeof(nchsize));

	printf("ncache: 0x%x, cache size %d entries\n", addr, nchsize);
	printf("Entry       Name        dev   inode    idev    id     gnode\n");
/*              ddddd nnnnnnnnnnnnnnn ddd ddd dddddd ddd ddd dddddd  dddddd*/

	if (index == -1) {
		for (i=0; i<nchsize; i++) {
			if (readmem((char *)&nch, (int) addr, sizeof(nch))
			    != sizeof(nch)) {
				printf("read error on namei cache at 0x%x\n", addr);
				perror("namei cache entry read");
				return(0);
			}
			if ((nch.nc_ip != NULL) && (nch.nc_ino != 0)) {
				strncpy(name, nch.nc_name, nch.nc_nlen);
				name[nch.nc_nlen]='\0';
				printf("%5d %15s %3d %3d %6d %3d %3d %6d %6d\n",
				       i, name, 
				       major(nch.nc_dev),minor(nch.nc_dev), 
				       nch.nc_ino,
				       major(nch.nc_idev),minor(nch.nc_idev), 
				       nch.nc_id,
				       getindex((char *)nch.nc_ip, 
						gnodebuckets, GNODEBUCKETS));
			}
			addr += sizeof(struct nch);
		}
	} else {
		if ((index < 0) || (index > nchsize)) {
			printf("bad index (%d) in namei cache\n", index);
			perror("bad namei cache index");
			return(0);
		}
		if (readmem((char *)&nch, (int) addr+index*sizeof(nch), 
			    sizeof(nch)) != sizeof(nch)) {
			printf("read error on namei cache at 0x%x\n", addr);
			perror("namei cache entry read");
			return(0);
		}
		if ((nch.nc_ip != NULL) && (nch.nc_ino != 0)) {
			strncpy(name, nch.nc_name, nch.nc_nlen);
			name[nch.nc_nlen]='\0';
			printf("%5d %15s %3d %3d %6d %3d %3d %6d %6d\n",
			       index, name, 
			       major(nch.nc_dev),minor(nch.nc_dev), 
			       nch.nc_ino,
			       major(nch.nc_idev),minor(nch.nc_idev), 
			       nch.nc_id,
			       getindex((char *)nch.nc_ip, 
					gnodebuckets, GNODEBUCKETS));
		}
	}
}

/* find all the ref's to a gnode */
pr_gref(index) 
	int index;
{
	struct gnode *gp;
	int i, j, gref, f;
	struct	file	*fp;
	struct	text	tbuf;
	struct	proc	*p;
	struct 	ncache 	n;
	struct	mount	*m;
	struct 	fs_data	fsd;

	gp = &gnodetab[index];
	gref=0;

	printf("\n");
	printf("Reference summary for gnode[%d]\n", index);
	printf("gnode has %d refs\n",gp->g_count);
	printf("\nfile:  ");
	for(i = 0; i < tab[FILE_T].ents; i++) {
		fp = &filetab[i];
		if (fp->f_count == 0)
			continue;
		if (getindex(fp->f_data, gnodebuckets, GNODEBUCKETS) != index)
			continue;
		printf("%8d", i);
	}
	printf("\nuarea: ");
	for(i = 0; i < tab[PROC_T].ents; i++) {
		p = &proctab[i];
		if (p->p_stat == 0)
			continue;
		get_uarea(&proctab[i]);
		if (getindex(U.u_cdir, gnodebuckets, GNODEBUCKETS) == index) {
			printf("%d - cdir ",i);
			gref++;
		}
		if (getindex(U.u_rdir, gnodebuckets, GNODEBUCKETS) == index) {
			printf("%i - rdir ",i);
			gref++;
		}
		for(j = 0; j < NOFILE; j++) {
			if (U.u_ofile[j] == NULL)
				continue;
			f = getindex((char *)U.u_ofile[j], filebuckets, FILEBUCKETS);
			if (filetab[f].f_type != DTYPE_INODE)
				continue;

			if (getindex(filetab[f].f_data, gnodebuckets, GNODEBUCKETS) == index) {
				printf("%d - ofile[%d] ",i, j);
				gref++;
			}
		}
	}
	printf("\ntext: ");
	
	for(i = 0; i < tab[TEXT_T].ents; i++) {
		if(readmem((char *)&tbuf,(int)(tab[TEXT_T].first + i*sizeof tbuf),
			   sizeof tbuf) != sizeof tbuf) {
			printf("%4d  read error on text table\n", i);
			return;
		}
		if (tbuf.x_gptr == NULL)
			continue;
		if (getindex((char *)tbuf.x_gptr,gnodebuckets, GNODEBUCKETS) == index) {
			printf(" %d",i);
			gref++;
		}

	}

	printf("\ndnlc:  ");

	for(i = 0; i < tab[DNLC_T].ents; i++) {
		if (!get_dnlc(i, &n))
			continue;

		if (getindex((char *)n.vp,gnodebuckets, GNODEBUCKETS) == index) {
			printf("%d - vp ", i);
			gref++;
		}
		if (getindex((char *)n.dp,gnodebuckets, GNODEBUCKETS) == index) {
			printf("%d - dp ", i);
			gref++;
		}
	}
	printf("\nmount:  ");
	for(i = 0; i < tab[MOUNT_T].ents; i++) {
		m = &mounttab[i];
		if ((m->m_flgs & MTE_DONE) ==0)
			continue;
		if (getindex((char *)m->m_gnodp,gnodebuckets, GNODEBUCKETS) == index) {
			printf("%d - gnodp ", i);
			gref++;
		}
		if (getindex((char *)m->m_rootgp,gnodebuckets, GNODEBUCKETS) == index) {
			printf("%d - root ", i);
			gref++;
		}
		if (getindex((char *)m->m_qinod,gnodebuckets, GNODEBUCKETS) == index) {
			printf("%d - quota ", i);
			gref++;
		}
	}

	
	printf("\n Found %d refs, %d still unaccounted\n",
	       gref, gp->g_count-gref);
}