u.c

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

			fflg = U.u_pofile[i];
		}
		if (fp == 0) continue;
		printf(" %d 0x%x ", i, fp);
			printf(" %s%s%s%s ",
		       (int) fflg & UF_EXCLOSE ? "Auto-close " : "",
		       (int) fflg & UF_MAPPED ? "Mapped " : "",
		       (int) fflg & UF_INUSE ? "In-Use " : "",
		       (int) fflg & UF_FDLOCK ? "SV Lock " : "");
		praddr(fp);
		printf("\n");
	}
	printf("sizes\t%d %d %d (clicks)\n", U.u_tsize, U.u_dsize, U.u_ssize);
/*	printf("dmap (%d bytes)\n\t%x\t%x\t%x\t%x\n",sizeof(struct dmap),
		U.u_dmap,U.u_smap,U.u_cdmap,U.u_csmap); moved to proc entry */
	printf("ssave");
	for (i=0; i<sizeof(label_t)/sizeof(int); i++) {
		if (i%5==0)
			printf("\t");
		printf("%9.1x", U.u_ssave.val[i]);
		if (i%5==4)
			printf("\n");
	}
	printf("\n");
	printf("u_odsize\t%d\n",U.u_odsize);
	printf("u_ossize\t%d\n",U.u_odsize);
	printf("u_outime\t%d\n",U.u_outime);
	printf("sigs");
	for (i=0; i<NSIG; i++) {
		if (i % 8 == 0)
			printf("\t");
		printf("%5.1x ", U.u_signal[i]);
		if (i % 8 == 7)
			printf("\n");
	}
	if (NSIG % 8 != 0) printf("\n");
	printf("sigmask");
	for (i=0; i<NSIG; i++) {
		if (i % 8 == 0)
			printf("\t");
		printf("%5.1x ", U.u_sigmask[i]);
		if (i % 8 == 7)
			printf("\n");
	}
	if (NSIG % 8 != 0) printf("\n");
	printf("sigonstack\t%9.1x\n",U.u_sigonstack);
	printf("oldmask   \t%9.1x\n",U.u_oldmask);
	printf("code      \t%9.1x\n", U.u_code);
	printf("sigstack  \t%9.1x\t%9.1x\n",
		U.u_sigstack.ss_sp,U.u_sigstack.ss_onstack);
	printf("cdir rdir\t%9.1x %9.1x\n", U.u_cdir, U.u_rdir);
	printf("cmask    \t0%o\n", U.u_cmask);
	printf("ru\t");
	ip = (int *)&U.u_ru;
	for (i = 0; i < sizeof(U.u_ru)/sizeof(int); i++) {
		if ( i % 10 == 0 && i ) printf("\n\t");
		printf("%d ", ip[i]);
	}
	if (sizeof(U.u_ru)/sizeof(int) % 10 != 0) printf("\n");
	ip = (int *)&U.u_cru;
	printf("cru\t");
	for (i = 0; i < sizeof(U.u_cru)/sizeof(int); i++) {
		if ( i % 10 == 0 && i ) printf("\n\t");
		printf("%d ", ip[i]);
	}
	if (sizeof(U.u_cru)/sizeof(int) % 10 != 0) printf("\n");
	printf("timers");
	for(i=0;i<sizeof(U.u_timer)/sizeof(struct itimerval);i++) {
		printf("\t%12d %12d %12d %12d\n",
			U.u_timer[i].it_interval.tv_sec,
			U.u_timer[i].it_interval.tv_usec,
			U.u_timer[i].it_value.tv_sec,
			U.u_timer[i].it_value.tv_usec);
	}
/*
 * Nothing now but will handle larger timer structure in the future!
 *	printf("u_XXX[3]\t%x %x %x\n",U.u_XXX[0],U.u_XXX[1],U.u_XXX[2]);
 */
	printf("start    \t%d\n", U.u_start);
	printf("acflag   \t%d\n", U.u_acflag);
	printf("limits   \t");
	for(i=0;i<RLIM_NLIMITS;i++) {
		printf("%d ",U.u_rlimit[i]);
	}
	printf("\n");
	printf("quota    \t%9.1x\n",U.u_quota);
	printf("quotaflag\t%9.1x\n",U.u_qflags);
	printf("smem     \t%9.1x %9.1x\n",
		U.u_smsize,U.u_lock);
	printf("prof     \t%9.1x %9.1x %9.1x %9.1x\n",
		U.u_prof.pr_base, U.u_prof.pr_size,
		U.u_prof.pr_off, U.u_prof.pr_scale);
	printf("u_nache  \toff %d ino %d dev %d tim %d\n",
		U.u_ncache.nc_prevoffset,U.u_ncache.nc_inumber,
		U.u_ncache.nc_dev,U.u_ncache.nc_time);
	printf("nameidata\n");
	printf("\tnameiop, error, endoff\t%8x %8d %8d\n",
		nd->ni_nameiop,nd->ni_error,nd->ni_endoff);
	printf("\t   base, count, offset\t%8x %8d %8d\n",
		nd->ni_base,nd->ni_count,nd->ni_offset);
	printf("\tdent ino %d name %.14s dirp %x\n",
		nd->ni_dent.d_ino,nd->ni_dent.d_name, nd->ni_dirp);
	printf("\tsegflg\t%8d\n", nd->ni_segflg);
	printf("u_stack  \t%9.1x\n",&U.u_stack[0]);
}
profile (p)
	int p;			/* proc slot number */
{
	do_ufile(p);
}
getcmd(i)
	int i;
{
	union {
		char	argc[CLSIZE*NBPG];
		int	argi[CLSIZE*NBPG/sizeof (int)];
	} argspac;
	register char *cp;
	register int *ip;
	char c;
	int nbad,flag;

	flag =  proctab[i].p_sched|proctab[i].p_vm|
		proctab[i].p_type|proctab[i].p_trace|
			proctab[i].p_file;

	if (flag & SSYS)
		goto retucomm;

	if (proctab[i].p_stat==SZOMB ||
	    flag&SWEXIT || !argaddr) {
		argspac.argc[0] = '\0';
		return(0);
	}
	if (lseek(mem, (int) argaddr,0) == -1) goto bad;
	if (read(mem, (char *)&argspac, sizeof (argspac))
		!= sizeof (argspac))
		goto bad;
#ifdef vax
	ip = &argspac.argi[CLSIZE*NBPG/sizeof (int)];
	ip -= 2;		/* last arg word and .long 0 */
#endif vax
#ifdef mips
	ip = &argspac.argi[(CLSIZE*NBPG-EA_SIZE)/sizeof (int)];
        while (*--ip == 0)
                if (ip == argspac.argi)
                        goto retucomm;

#endif mips
	while (*--ip)
		if (ip == argspac.argi)
			goto retucomm;
	*(char *)ip = ' ';
	ip++;
	nbad = 0;
#ifdef vax
	for (cp = (char *)ip; cp < &argspac.argc[CLSIZE*NBPG]; cp++) {
#endif vax
#ifdef mips
	for (cp = (char *)ip; cp < &argspac.argc[CLSIZE*NBPG-EA_SIZE]; cp++) {
#endif mips
		c = *cp & 0177;
		if (c == 0)
			*cp = ' ';
		else if (c < ' ' || c > 0176) {
			if (++nbad >= 5) {
				*cp++ = ' ';
				break;
			}
			*cp = '?';
		} else if (c == '=') {
			while (*--cp != ' ')
				if (cp <= (char *)ip)
					break;
			break;
		}
	}
	*cp = 0;
	while (*--cp == ' ')
		*cp = 0;
	cp = (char *)ip;
	(void) strncpy(cmdbuf, cp, &argspac.argc[CLSIZE*NBPG] - cp);
	if (cp[0] == '-' || cp[0] == '?' || cp[0] <= ' ') {
		(void) strcat(cmdbuf, " (");
		(void) strncat(cmdbuf, U.u_comm, sizeof(U.u_comm));
		(void) strcat(cmdbuf, ")");
	}
	return(1);

bad:
	printf("error locating command name for pid %d\n",proctab[i].p_pid);
	return(0);
retucomm:
	(void) strcpy(cmdbuf, " (");
	(void) strncat(cmdbuf, U.u_comm, sizeof (U.u_comm));
	(void) strcat(cmdbuf, ")");
	return(1);
}

ps_hdr()
{
	printf("SLOT   PID   UID   COMMAND\n");
}

do_ps(c)
	int c;			/* process slot number */
{
	if (c < 0) return;
	cmdbuf[0] = '\0';
	if(getuarea(c) == -1)
		return;
	if(getcmd(c))
		printf("%4d%6d%6d   %s\n", c, proctab[c].p_pid,
		    proctab[c].p_uid, cmdbuf);
}

void
prstack(procslot)
int	procslot;
{
	register  int	ret;
	int *afp;
	int *ksp;
	int *stack;
	int curproc;	
	int todo;
	unsigned where;
	
	if(procslot > (int)tab[PROC_T].ents) {
		printf("%d out of range, use Process Table Slot\n", procslot);
		return;
	}
	if(procslot == -1) {
		struct Symbol *scb;
		struct Symbol *symsrch();
		struct cpudata cpudata;
		
		scb = symsrch("_scb");
		if(readmem((char *)&afp, (int)scb->s_value - 4, sizeof afp) !=
		    sizeof afp) {
			printf("could not get locore\n");
			return;
		}
		if(afp == NULL) {
			printf("cannot dump stack of running process\n");
			return;
		}
		ksp = afp;
	
		get_cpudata(&cpudata, 0);
		curproc = getindex((char *)cpudata.cpu_proc, procbuckets,
		    PROCBUCKETS);
#ifdef DEBUG
		printf("proc addr 0x%x\n", cpudata.cpu_proc);
		printf("process slot %d\n", curproc);
#endif
		if((ret=getuarea(curproc)) == -1) {
			error("bad read of uarea");
			return;
		}
	} else {
		if((ret=getuarea(procslot)) == -1) {
			error("bad read of uarea");
			return;
		}
		else if(ret == SWAPPED) {
			error("process is swapped");
			return;
		}
#ifdef mips		
		ksp = (int *) U.u_pcb.pcb_regs[8];
#endif
#ifdef vax		
		afp = (int *) U.u_pcb.pcb_r13;
		ksp = (int *) U.u_pcb.pcb_ksp;
#endif
	}
	 /* make sure we are alligned */	
	ksp = (int *)(((unsigned) ksp + 0xf) & ~0xf);
	where = (int)ksp;
	todo = (int) (KERNELSTACK - (unsigned)ksp) / sizeof(int);	
	stack = (int *) ((char *)&U + (UPAGES * NBPG));
	/*
	 * we have the entire uarea in U. the actual displacement
	 * of fp (ap, and pc) is stack - (7fffffff - fp) (I think)
	 */
	printf ("ksp 0x%x, todo 0x%x stack 0x%x\n",ksp,todo,stack);
	ksp = (int *) (stack - ((int *)0xffffffff - ksp)) - 1;
	printf ("ksp 0x%x, todo 0x%x stack 0x%x\n",ksp,todo,stack);
	
	while (todo > 0) {
		printf("0x%x:  0x%08x 0x%08x 0x%08x 0x%08x\n", where,
		    *ksp, *(ksp + 1), *(ksp + 2), *(ksp + 3));
		ksp += 4;
		where += (4 * sizeof(int));
		todo -= 4;
	}
#ifdef vax
	printf("\n");
	printf("\n");
	printf("STACK FRAME:\n");
	printf("|- - - - - - - - - - ->|\tKFP == %x\n", afp);
	printf("________________________________________________________________________\n");
	printf("|  fp  |  pc  |  regs  |  cond  |   psl  |  ap  |  fp  |  pc  |  regs  |\n");
	printf("|______|______|________|________|________|______|______|______|________|\n");
#endif mips
}
#ifdef mips
prtrace(vars,procslot)
	int	procslot;
	int	vars;			/*  want vars */
{
	long stack_getwd();
	extern char *namelist;
	if (procslot < 0) return;
	if (getuarea(procslot) == -1) {
		printf ("process %d (slot %d): uarea not in core.\n", 
		proctab[procslot].p_pid,procslot);
		return;
	}
	U.u_pcb.pcb_regs[31] = U.u_pcb.pcb_regs[10];
	stacktrace(namelist,U.u_pcb.pcb_regs[10],U.u_pcb.pcb_regs[8],
		   U.u_pcb.pcb_regs,stack_getwd, vars);
}

long stack_getwd(p)
	unsigned int p;
{
	long data, *addr;
	if (p < 0xffffc000)
		return(0);
	addr = (int *) ((char *)&U + ((char *) p - (char *) 0xffffc000));
	data = (int) *addr;
	return(data);
}
#endif



biton(i)
	register unsigned int i;
{
	register int j = 0;

	while(i) {
		if(i & 0x1)
			j++;
		i >>= 1;
	}
	return(j);
}