pfstat.c

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

	    printf ("Xdrops:\t\t%-8d\tRdrops:\t\t%-8d\n",
		    enXdrops, enRdrops);
	    printf ("Rmissed:\t%-8d\tRunwanted:\t%-8d\n",
	    		enRmissed, enRunwanted);
	    printf ("AllowPromisc:\t");
	    if (enStatep->ens_AllowPromisc) {
		printf("yes (%d)", enStatep->ens_PromiscCount);
	    }
	    else {
		printf("no     ");
	    }
	    printf ("\t\tAllowCopyAll:\t");
	    if (enStatep->ens_AllowCopyAll) {
		printf("yes (%d)", enStatep->ens_CopyAllCount);
	    }
	    else {
		printf("no     ");
	    }
	    printf ("\n");
	    printf("UserMaxWaiting:\t%d\n", enStatep->ens_UserMaxWaiting);
	    printf ("\n");
	}
	if (Parameters) {
	    struct endevp *devp = &enDevParams;
	    printf ("Device type: ");
	    switch (devp->end_dev_type) {
		case ENDT_3MB:
		     printf("3Mb");
		     break;
		case ENDT_BS3MB:
		     printf("byte-swapping 3Mb");
		     break;
		case ENDT_10MB:
		     printf("10Mb");
		     break;
		default:
		     printf("unknown (%d)", devp->end_dev_type);
		     break;
	    }
	    PrintIFP(enet_info[unit].ifp);
	    printf("\n");
	    printf("Address Length: %d\tHeader Length: %d\tMTU: %d\n",
    		devp->end_addr_len, devp->end_hdr_len, devp->end_MTU);
	    printf("Interface Address: ");
	    PrintAddress(devp->end_addr, devp->end_addr_len);
	    printf("\nBroadcast Address: ");
	    PrintAddress(devp->end_broadaddr, devp->end_addr_len);
	    printf("\n\n");
	}

	if (Descriptors) {
	    printf ("Desq(%x): %d/%d open files [%x,%x]:\n",
		     (((caddr_t)&enDesq
			- (caddr_t)enStatep + (caddr_t)enStatePs[unit])),
		    enDesq.enQ_NumQueued, enMaxMinors,
		     (enDesq.enQ_F),  (enDesq.enQ_B));
	    printf ("AllDescriptors:\n");
	    printf (" #    LOC   LINK-QUEUE  STATE WAIT-QUEUE  NQ'D    TOUT MODE  SIG   PROC(PID)");
	    printf ("\n");
	    op = &ThisDescriptor;
	    for (i = 0; i < enMaxMinors; i++) {
 		if ((enAllocMap[i] == 0) && !Verbose)
			continue;
		if (enUnitMap[i] != unit)
			continue;
		loc = (long)enAllDescriptors[i];
		if (loc == 0)
			continue;
		klseek(fc, loc, 0);
		read(fc, &ThisDescriptor, sizeof(ThisDescriptor));
#ifdef	vax
		printf ("%2d %8.1x", i, loc | 0x80000000);
#else
		printf ("%2d %8.1x", i, loc);
#endif	vax
		popdes (op);
	    }
	}

	if (Filters) {
	    printf ("\nFilters:\n");
	    printf (" #    COUNT  DROPS PRI LEN FILTER");
	    printf ("\n");
	    op = &ThisDescriptor;
	    for (i = 0; i < enMaxMinors; i++) {
	    loc = nl[SENDESCRIPTORS].n_value;
 		if ((enAllocMap[i] == 0) && !Verbose)
			continue;
		if (enUnitMap[i] != unit)
			continue;
		loc = (long)enAllDescriptors[i];
		if (loc == 0)
			continue;
		klseek(fc, loc, 0);
		read(fc, &ThisDescriptor, sizeof(ThisDescriptor));
		printf ("%2d ", i);
		printf("%8d ", op->enOD_RecvCount);
		printf("%6d ", op->enOD_Drops);
		pfilt (&op -> enOD_OpenFilter);
	    }
	}
    }
    if (QueueElements) {
	printf ("\n");
	printf ("QueueElts:\n");
	printf (
"   LOC        LINK-QUEUE     COUNT   REF FLAGS DROP    TIME");
	printf ("\n");
	loc = nl[SENQELTS].n_value;
	for (p = enQueueElts; p < &enQueueElts[ENPACKETS];
				p++, loc += sizeof (enQueueElts[0])) {
	    if ((Verbose == 0) && (p->enP_RefCount == 0))
		continue;
#ifdef	vax
	    printf ("%8.1x ", loc | 0x80000000);
#else
	    printf ("%8.1x ", loc);
#endif	vax
	    pqelt (p);
	}
    }
}

popdes (op)
register struct enOpenDescriptor   *op;
{
    static char *states[] = {
	" wait", "timed", " tout"
    };
    int     num;
    int     head;
    int	    to;

    num = (Verbose) ? ENMAXWAITING : op -> enOD_Waiting.enWQ_NumQueued;
    head = (Verbose) ? 0 : op -> enOD_Waiting.enWQ_Head;

#ifdef	TOO_WIDE
    printf (" %5x", clear (op -> enOD_Link.F));
    printf (" %5x", clear (op -> enOD_Link.B));
#else
    printf (" %8x  ", clear (op -> enOD_Link.F));
#endif	TOO_WIDE
    if ((int) op -> enOD_RecvState <= 2)
	printf (" %-5.5s ", states[(int) op -> enOD_RecvState]);
    else
	printf (" %3d   ", op -> enOD_RecvState);
    if (num)
	pwq (&op -> enOD_Waiting, head);
    else
	printf (" %-10s", "");
    printf (" %3d", op -> enOD_Waiting.enWQ_NumQueued);
    printf ("/%-3d", op -> enOD_Waiting.enWQ_MaxWaiting);
    to = op->enOD_Timeout;
    if ((to > hz*60) && (Verbose == 0)) {
	to /= (hz * 60);
	if (to > 60) {
	    to /= 60;
	    if (to > 999)
	    	printf(" long");
	    else
	    	printf(" %3dh", to);
	}	
	else
    	    printf(" %3dm", to);
    }
    else
	printf (" %4d", op -> enOD_Timeout);
    pmode(op->enOD_Flag, 6);	/* 6 = # of columns after leading space */
    printf (" %2d ", op -> enOD_SigNumb);
    printf (" %6x", clear (op -> enOD_SigProc));
    printf ("(%d)", op -> enOD_SigPid);
    printf ("\n");
    while (--num > 0) {
	PfiltNextWaitQueueIndex (head);
	printf ("%-29s", "");
	pwq (&op -> enOD_Waiting, head);
	printf ("\n");
    }
}


pwq (wq, idx)
register struct enWaitQueue *wq;
{

    int     tail = wq -> enWQ_Tail;

    PfiltPrevWaitQueueIndex (tail);
    printf (" %1s", (idx == wq -> enWQ_Head) ? "^" : " ");
    printf ("%8x", clear (wq -> enWQ_Packets[idx]));
    printf ("%s", (idx == tail) ? "$" : " ");

}

pfilt (fp)
register struct enfilter   *fp;
{

    int     w,
            arg,
            op,
            i;
    unsigned short *wp;

    printf ("%3d ", fp -> enf_Priority);
    printf ("%3d ", fp -> enf_FilterLen);

    i = 0;
    for (wp = &fp -> enf_Filter[0];
    			wp < &fp -> enf_Filter[fp -> enf_FilterLen]; wp++) {
	w = *wp;
	arg = (w & (0xffff >> ((sizeof (short) * 8) - ENF_NBPO)));
	op = (w & (0xffff << ENF_NBPA));
	switch (arg) {
	    default: 
		if (arg < ENF_PUSHWORD)
		    printf ("BADPUSH%d", arg);
		else
		    printf ("PUSHWORD+%d", arg - ENF_PUSHWORD);
		break;
	    case ENF_PUSHLIT: 
		printf ("PUSHLIT");
		break;
	    case ENF_PUSHZERO: 
		printf ("PUSHZERO");
		break;
	    case ENF_PUSHONE: 
		printf ("PUSHONE");
		break;
	    case ENF_PUSHFFFF: 
		printf ("PUSHFFFF");
		break;
	    case ENF_PUSH00FF: 
		printf ("PUSH00FF");
		break;
	    case ENF_PUSHFF00: 
		printf ("PUSHFF00");
		break;
	    case ENF_NOPUSH: 
		if (op == ENF_NOP)
		    printf ("NOP");
		break;
	}
	if (arg != ENF_NOPUSH && op != ENF_NOP)
	    printf ("|");
	switch (op) {
	    case ENF_AND: 
		printf ("AND");
		break;
	    case ENF_OR: 
		printf ("OR");
		break;
	    case ENF_XOR: 
		printf ("XOR");
		break;
	    case ENF_EQ: 
		printf ("EQ");
		break;
	    case ENF_NEQ: 
		printf ("NEQ");
		break;
	    case ENF_LT: 
		printf ("LT");
		break;
	    case ENF_LE: 
		printf ("LE");
		break;
	    case ENF_GT: 
		printf ("GT");
		break;
	    case ENF_GE: 
		printf ("GE");
		break;
	    case ENF_NOP: 
		break;
	    case ENF_COR:
	    	printf("COR");
		break;
	    case ENF_CAND:
	    	printf("CAND");
		break;
	    case ENF_CNOR:
	    	printf("CNOR");
		break;
	    case ENF_CNAND:
	    	printf("CNAND");
		break;
	    default: 
		printf ("OP%d", op);
		break;
	}
	printf (",");
	if (arg == ENF_PUSHLIT) {
	    i++;
	    printf ("%.1o,", *++wp);
	}
	if (++i >= 4) {
	    i = 0;
	    if (&wp[1] < &fp -> enf_Filter[fp -> enf_FilterLen])
		printf ("\n\t\t\t    ");
	}
    }
    printf ("\n");

}

pqelt (qp)
register struct enPacket   *qp;
{
    char *ctime();
    char *ctp;
    struct timeval *tvp = &(qp->enP_Stamp.ens_tstamp);

    printf (" %8x", clear (qp -> enP_Link.F));
    printf (" %8x", clear (qp -> enP_Link.B));
    printf (" %5d", qp -> enP_ByteCount);
    printf (" %5d", qp -> enP_RefCount);
    pflags( qp -> enP_Stamp.ens_flags, 6);
    printf (" %4d", qp -> enP_Stamp.ens_dropped);
    
    while (tvp->tv_usec >= 1000000) {
	tvp->tv_sec++;
	tvp->tv_usec -= 1000000;
    }
    ctp = ctime(&(tvp->tv_sec));
    ctp += 11;	/* skip day and date */
    ctp[8] = 0;	/* no timezone or year */
    printf (" %s.%06d", ctp, qp->enP_Stamp.ens_tstamp.tv_usec);
    
    printf ("\n");

}

PrintAddress(a, l)
unsigned char *a;
int l;
{
	if (l == 1) {	/* one-byte addresses in octal */
	    if (*a)
	    	printf("0");
	    printf("%o", *a);
	    return;
	}
	while (l-- > 0) {
	    printf("%02x", *a++);
	    if (l > 0)
	    	printf(":");
	}
}

PrintIFP(ifp)
struct ifnet *ifp;
{
	struct ifnet ifnet;
	char name[16];
	
	printf("\tInterface: ");

	if (ifp == 0) {
	    printf("[ifp == 0?]");
	    return;
	}
	
	klseek(fc, (long) ifp, 0);
	read(fc, &ifnet, sizeof(struct ifnet));
	
	klseek(fc, (long)ifnet.if_name, 0);
	read(fc, name, sizeof(name));
	name[15] = 0;
	
	printf("%s%d", name, ifnet.if_unit);
	
	if ((ifnet.if_flags&IFF_UP) == 0)
	    printf(" not up");
}

/*
 * Stolen from ps as is
 */
klseek(fd, loc, off)
	int fd;
	long loc;
	int off;
{

	/*
	 * If this is a dump, then the kernel isn't doing the page
	 * mapping for us.  Simulate it.
	 */
	if (kflg && (loc & 0x80000000) != 0) {
		long v;
		long addr;
		struct pte pte;

		loc &= 0x7fffffff;
		v = btop(loc);
 		if(v >= nl[X_SYSSIZE].n_value) {
 			printf("address botch %x\n", loc);
 			return;
 		}
 		addr = (long)((struct pte *)nl[X_SYSMAP].n_value + v);
 		lseek(fd, addr&0x7fffffff, 0);
 		if(read(fd, (char *)&pte, sizeof(pte)) != sizeof(pte)) {
 			printf("Error reading kmem for pte at %x\n", addr);
 			return;
 		}
 		if (pte.pg_v == 0 && (pte.pg_fod || pte.pg_pfnum == 0)) {
 			printf("pte bad for %x\n", addr);
 			return;
 		}
 		loc = (long)ptob(pte.pg_pfnum) + (loc & PGOFSET);
 	}
	(void) lseek(fd, (long)loc, off);
}

struct BSEnt {
	unsigned long Bit;
	char Char;
};

struct BSEnt ModeStrings[] = {
	{ ENHOLDSIG, 'H' },
	{ ENBATCH, 'B' },
	{ ENTSTAMP, 'T' },
	{ ENPROMISC, 'P' },
	{ ENNONEXCL, 'N' },
	{ ENCOPYALL, 'C' },
};

pmode(m, cols)
short m;
int cols;
{
	pbits(m, cols, ModeStrings,
		(sizeof(ModeStrings)/sizeof(struct BSEnt)));
}

struct BSEnt FlagStrings[] = {
	{ ENSF_PROMISC, 'P' },
	{ ENSF_BROADCAST, 'B' },
	{ ENSF_TRAILER, 'T' },
	{ ENSF_MULTICAST, 'M' },
};

pflags(f, cols)
u_short f;
int cols;
{
	pbits(f, cols, FlagStrings,
		(sizeof(FlagStrings)/sizeof(struct BSEnt)));
}

pbits(b, cols, table, nelts)
unsigned long b;
int cols;
struct BSEnt *table;
int nelts;
{
	char bstring[33];
	char *bsp = bstring;
	int i;
	int colsused = 0;
	int precols;
	
	for (i = 0; i < nelts; i++) {
	    if (b & table[i].Bit) {
		colsused++;
		*bsp++ = table[i].Char;
		b &= ~table[i].Bit;
	    }
	}
	if (b) {
	    colsused++;
	    *bsp++ = '?';
	}
	*bsp = 0;
	
	if (colsused > cols) {
	    printf(bstring);
	}
	else {
	    precols = (cols - colsused)/2;
	    cols = (cols - colsused) - precols;

	    printf(" %*s%s%*s", precols, "", bstring, cols, "");
	}
}