u.c

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

#ifndef lint
static char *sccsid = "@(#)u.c	4.5	(ULTRIX)	4/11/91";
#endif

/************************************************************************
 *									*
 *			Copyright (c) 1988 by				*
 *		Digital Equipment Corporation, Maynard, MA		*
 *			All rights reserved.				*
 *									*
 *   This software is furnished under a license and may be used and	*
 *   copied  only  in accordance with the terms of such license and	*
 *   with the  inclusion  of  the  above  copyright  notice.   This	*
 *   software  or  any  other copies thereof may not be provided or	*
 *   otherwise made available to any other person.  No title to and	*
 *   ownership of the software is hereby transferred.			*
 *									*
 *   This software is  derived  from  software  received  from  the	*
 *   University    of   California,   Berkeley,   and   from   Bell	*
 *   Laboratories.  Use, duplication, or disclosure is  subject  to	*
 *   restrictions  under  license  agreements  with  University  of	*
 *   California and with AT&T.						*
 *									*
 *   The information in this software is subject to change  without	*
 *   notice  and should not be construed as a commitment by Digital	*
 *   Equipment Corporation.						*
 *									*
 *   Digital assumes no responsibility for the use  or  reliability	*
 *   of its software on equipment which is not supplied by Digital.	*
 *									*
 ************************************************************************/

#include	"crash.h"
#include	<sys/proc.h>
#include	<machine/pte.h>
#include	<sys/cpudata.h>
#include	<sys/vm.h>
#include	<frame.h>
#include	<stdio.h>

#ifdef vax
#define KERNELSTACK	(0x7fffffff)
#endif vax

struct uarea u;			/* external uarea buffer */

char cmdbuf[CLSIZE*NBPG];	/* global command string buffer */
int argaddr;			/* global vaddr of command space */

prcpudata(option)
	int option;
{
	struct cpudata cpudata;
	int maxcpu;
	int i;

printf("CPU  ID State   Proc      PCB      Swtch    Syscall     Ints  Locks\n");
/*      DDD DDD SSSSSSS  Shhhh 0x88888888 ddddddddd ddddddddd ddddddddd */
	for(i=0;i<MAXCPU;i++) {
		if (get_cpudata(&cpudata, i) == -1) 
			continue;
		printf("%3d %3d %s%s%s%s%s%s",cpudata.cpu_num,
		       i,
		       cpudata.cpu_state & CPU_RUN ? "R":" ",
		       cpudata.cpu_state & CPU_TBI ? "T":" ",
		       cpudata.cpu_state & CPU_PANIC ? "P":" ",
		       cpudata.cpu_state & CPU_SOFT_DISABLE ? "D":" ",
		       cpudata.cpu_state & CPU_BOOT ? "B":" ",
		       cpudata.cpu_state & CPU_STOP ? "S":" ");
#ifdef mips
		printf("%s", cpudata.cpu_inisr == 1 ? "I":" ");
#else
		printf(" ");
#endif
		printf("  %s",cpudata.cpu_noproc ? "*" : " ");
#ifdef mips
		if (cpudata.cpu_noproc)
			printf("%4d ",getindex((char *)cpudata.cpu_idleproc, procbuckets,
					       PROCBUCKETS));
		else
		printf("%4d ",getindex((char *)cpudata.cpu_proc, procbuckets,
		    PROCBUCKETS));

#else
		printf("%4d ",getindex((char *)cpudata.cpu_proc, procbuckets,
		    PROCBUCKETS));
#endif

		printf("0x%8x ", cpudata.cpu_paddr);
		printf("%9d %9d %9d ", cpudata.cpu_switch,
		    cpudata.cpu_syscall,cpudata.cpu_intr);
		if (cpudata.cpu_hlock) {
			praddr(cpudata.cpu_hlock);
			printf("\n");
		} else
			printf("None\n");


		if (cpudata.cpu_panicstr) {
			printf("panicstr: ");
			prod(cpudata.cpu_panicstr, 1, "s");
		}
#ifdef DEBUG
		printf(" stack 0x%x istack 0x%x\n",
		       cpudata.cpu_stack, cpudata.cpu_istack);
#endif

		
				}

}
prlockhead() {
printf("State   Lost       Spin      Won      avg spin  pcnt lost   Cost  Name\n");
/*      SSS dddddddddd dddddddddd dddddddddd   xxx.xxx   xxx.xxx  xxx.xxx */
}
prlock(lp,mflg)
struct lock_t *lp;
int mflg; /* if =0, lock pointer is in local memory, =1 -> kernel memory */
{
	struct lock_t lock;
	struct lock_trace trace;
	float avg_spin, percent_lost;

	if (mflg == 1) {
		if (readmem((char *)&lock, (char *)lp, sizeof(struct lock_t))
		    != sizeof(struct lock_t)) {
			printf("couldn't find lock at 0x%x\n",lp);
			return(1);
		}
	} else 
		bcopy(lp, &lock, sizeof(struct lock_t));
	if (lock.l_lock)
		printf("*L*");
	else
		printf("   ");

	printf(" %10d %10d %10d ",lock.l_lost, lock.l_spin, lock.l_won);
	if (lock.l_lost != 0)
		avg_spin = (float) lock.l_spin/(float)lock.l_lost;
	else
		avg_spin = 0;
			
	if ((lock.l_lost+lock.l_won) != 0)
		percent_lost = 100.0 * (float) lock.l_lost/
			(float) (lock.l_lost + lock.l_won);
	else
		percent_lost = 0;
	printf(" %6.1f %7.2f %7.1f ", avg_spin, percent_lost, 
	       avg_spin*percent_lost);


	if (mflg == 1)
		praddr(lp);
	printf("\n");

}

prlock_long(lp,mflg)
struct lock_t *lp;
int mflg; /* if =0, lock pointer is in local memory, =1 -> kernel memory */
{
	struct lock_t lock;
	struct lock_trace trace;
	struct Symbol *search();
	int i;

	if (mflg == 1) {
		if (readmem((char *)&lock, (char *)lp, sizeof(struct lock_t))
		    != sizeof(struct lock_t)) {
			printf("couldn't find lock at 0x%x\n",lp);
			return(1);
		}
	} else 
		bcopy(lp, &lock, sizeof(struct lock_t));

	printf("Lock - ");
	if (mflg == 1)
		praddr(lp);
	else
		printf("None");
	printf("\n");

	printf("\t Lock State: %s%s Type: %s  Pos %4d IPL: %4d\n",
	       lock.l_wanted ? "W":" ",
	       lock.l_lock ? "L" : " ",
	       lock.l_type == LK_SPIN ? "spin" : lock.l_type == LK_WAIT ? "wait" : "UNKN",
	       lock.l_hierpos, lock.l_ipl);
	printf("\tplock: ");
	if (lock.l_plock == NULL)
		printf(" Null ");
	else
		printf("0x%8x",lock.l_plock);
	printf(" lost %d spin %d won %d\n",
	       lock.l_lost, lock.l_spin, lock.l_won);

}

prlcktrace(tp)
	struct lock_trace *tp;
{
	struct Symbol *search();

	printf("pid %6d  pc 0x%8x (", tp->tr_pid,tp->tr_pc);
	prsym(search(tp->tr_pc), tp->tr_pc);
	printf(") psl 0x%x lock 0x%8x ",tp->tr_psl,tp->tr_lock);
	if (tp->tr_lock)
		praddr(tp->tr_lock);
	else
		printf("None");
	printf("\n");
}
prpcb (p)
	int p;			/* proc slot number */
{
	struct pcb *pcb;
	int i;

	if (p < 0) return;
	if (getuarea(p) == -1) {
		printf ("process %d (slot %d): uarea not in core.\n", 
		proctab[p].p_pid,p);
		return;
	}
	pcb = &U.u_pcb;
	printf("\n");
	printf ("process %d (slot %d)\n",proctab[p].p_pid,p);
	printf("\n");
#ifdef vax
	printf ("ksp:   %8x    ",pcb->pcb_ksp);
	printf ("usp:   %8x    ",pcb->pcb_usp);
	printf ("r0:    %8x\n",  pcb->pcb_r0);
	printf ("r1:    %8x    ",pcb->pcb_r1);
	printf ("r2:    %8x    ",pcb->pcb_r2);
	printf ("r3:    %8x\n",  pcb->pcb_r3);
	printf ("r4:    %8x    ",pcb->pcb_r4);
	printf ("r5:    %8x    ",pcb->pcb_r5);
	printf ("r6:    %8x\n",  pcb->pcb_r6);
	printf ("r7:    %8x    ",pcb->pcb_r7);
	printf ("r8:    %8x    ",pcb->pcb_r8);
	printf ("r9:    %8x\n",  pcb->pcb_r9);
	printf ("r10:   %8x    ",pcb->pcb_r10);
	printf ("r11:   %8x    ",pcb->pcb_r11);
	printf ("ap:    %8x\n",  pcb->pcb_r12);
	printf ("fp:    %8x    ",pcb->pcb_r13);
	printf ("pc:    %8x    ",pcb->pcb_pc);
	printf ("psl:   %8x\n",  pcb->pcb_psl);
	printf ("p0br:  %8x    ",(unsigned)pcb->pcb_p0br);
	printf ("p0lr:  %8x    ",pcb->pcb_p0lr & 0x3fffff);
	printf ("p1br:  %8x\n",  (unsigned)pcb->pcb_p1br);
	printf ("p1lr:  %8x\n",  pcb->pcb_p1lr & 0x3fffff);
#endif vax
#ifdef mips
	printf ("pc:    %8x    ",pcb->pcb_regs[10]);
	printf ("sp:    %8x    ",pcb->pcb_regs[8]);
	printf ("sr:    %8x\n",pcb->pcb_regs[11]);
	for(i=0; i<12; i+=4) {
		printf("r%2d  %8x r%2d  %8x r%2d  %8x r%2d  %8x \n",
		       i,pcb->pcb_regs[i],i+1,pcb->pcb_regs[i+1],
		       i+2,pcb->pcb_regs[i+2],i+3,pcb->pcb_regs[i+3]);
	}
#endif mips
}

pruarea (p)
	int p;			/* proc slot number */
{
	int uresult;
	struct ucred ucred;
	char fflg;
	char *pofile_of;
	int *ofile_of, fp;

	register i;
	register struct nameidata *nd;
	register int *ip;
	
	uresult = getuarea(p);

	if (uresult != -1) {
		printf ("process %d (slot %d):",
		    proctab[uresult].p_pid, uresult);		
		printf ("\n");
		printf ("\n");
	}
	else {
		printf (" uarea not in core.\n");
		return;
	}

/* uarea printing code below is stolen from pstat */
	nd  = &U.u_nd;
	printf("procp\t%9.1x\n", U.u_procp);
	printf("ar0\t%9.1x\n", U.u_ar0);
	printf("comm\t %s\n", U.u_comm);
	printf("arg");
	for (i=0; i<sizeof(U.u_arg)/sizeof(U.u_arg[0]); i++) {
		if (i%5==0) printf("\t");
		printf("%9.1x", U.u_arg[i]);
		if (i%5==4) printf("\n");
	}
	printf("\n");
	printf("ap\t%9.1x\n", U.u_ap);
	printf("qsave");
	for (i=0; i<sizeof(label_t)/sizeof(int); i++) {
		if (i%5==0) printf("\t");
		printf("%9.1x", U.u_qsave.val[i]);
		if (i%5==4) printf("\n");
	}
	printf("\n");
	printf("error\t%9.1x\n", U.u_error);
	printf("r_val?\t%9.1x %9.1x\n", U.u_r.r_val1, U.u_r.r_val2);
	printf("eosys\t%9.1x\n", U.u_eosys);
/* credentials is now km_alloc-ed -- have to go get them!!! - rr */
	lseek(mem,sysvad(U.u_cred),0);
	read(mem,(char *)&ucred,sizeof(struct ucred));
	printf("\tref %d\n",ucred.cr_ref);
	printf("\tuid\t%d\tgid\t%d\n",ucred.cr_uid,ucred.cr_gid);
	printf("\truid\t%d\trgid\t%d\n",ucred.cr_ruid,ucred.cr_rgid);
	printf("\tgroups\t");
	for (i=0;i<NGROUPS;i++) {
		if (ucred.cr_groups[i] == -1) continue;
		printf("%d",ucred.cr_groups[i]);
		if ((i==(NGROUPS/2 - 1))) printf("\n\t\t");
		else if (i<NGROUPS-1) putchar(',');
	}
	printf("\n");
/* end of new credentials code */
	printf("u_ofile: (u_lastfile: %d)\n",U.u_lastfile);
	if (U.u_of_count != 0) {
		printf("u_ofile_of: 0x%8x u_pofile_of: 0x%8x\n",
		       U.u_ofile_of,U.u_pofile_of);
		ofile_of = (int *) malloc(U.u_of_count*
					  sizeof(int));
		pofile_of = (char *) 
			malloc(U.u_of_count);
		
		if (readmem((char *)ofile_of, (int)U.u_ofile_of, 
			    U.u_of_count*sizeof(int)) !=
		    U.u_of_count*sizeof(int)) {
			printf(" read error on fd overflow area\n");
			return;
		}
		if (readmem((char *)pofile_of, (int)U.u_pofile_of, 
			    U.u_of_count) !=
		    U.u_of_count) {
			printf(" read error on fd overflow area\n");
			return;
		}
	}
	for (i = 0; i <= U.u_omax; ++i) {
		if (i > NOFILE_IN_U) {
			fp = (int) ofile_of [i - NOFILE_IN_U];
			fflg = pofile_of [i - NOFILE_IN_U];
		} else {
			fp = (int)U.u_ofile[i];