scs.c

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

	offset = (int)(&pib_st.pd) - (int)(&pib_st.lport_name);
	printscs_pd((char *) ((char *)pib_ptr + offset), printmode, 
		pib_st.type.hwtype);
    }
}

/*
 *
 *   Name:	printscs_cbq	- Print contents of a connection block queue 
 *				head.
 *
 *   Abstract:	Disect and display a connection block queue head.  Follow the 
 *		queue and print out the associated connection blocks.
 *
 *   Inputs:    cbq_ptr	 	- Pointer to a connection block queue head.
 *		printmode	- Controlls output level.
 *
 *   Return	NONE
 *   Values:
 */
int 
printscs_cbq(cbq_ptr, printmode, cbq_type)
    cbq		*cbq_ptr;
    int		printmode;
    int		cbq_type;

{
	cbq cbq_st;
	char *printstring;

	switch (cbq_type) {
		case X_CBS: printstring = "connection block"; break;
		case X_SCS_CB: printstring = "waiting connection block"; break;
		default: printstring = "UNKNOWN"; 
	}
        if (cbq_ptr == 0) {
	    printf("\tNULL %s queue head.\n",printstring);
	    return;
        }
	if(readmem((char *) &cbq_st, (int)cbq_ptr, sizeof(cbq)) !=
	    sizeof(cbq)) {
		printf("could not read %s queue head at 0x%x.\n", printstring,
			cbq_ptr);
		return;
	}

    printscs_follow_cbq(cbq_ptr, printmode); 
}

/*
 *
 *   Name:	printscs_follow_cbq	- Follow links in a connection block 
 *					 queue.
 *
 *   Abstract:	Get to connection blocks in a list.
 *
 *   Inputs:    cbq_ptr	 	- Pointer to a connection block queue head.
 *		printmode	- Controlls output level.
 *
 *   Return	NONE
 *   Values:
 */
int 
printscs_follow_cbq(cbq_ptr, printmode)
    cbq		*cbq_ptr;
    int		printmode;

{
	cbq cbq_st;
	CB  cb_st;
	CB  *cb_ptr;

	if(readmem((char *) &cbq_st, (int)cbq_ptr, sizeof(cbq)) !=
	    sizeof(cbq)) {
		printf("could not connection block queue head at 0x%x.\n",
			cbq_ptr);
		return;
	}

    if (cbq_ptr == 0) {
	printf("\tNULL connection block queue head.\n");
	return;
    }
    if ((cbq_st.flink == cbq_st.blink) && (cbq_st.flink == cbq_ptr)) {
	printf("EMPTY connection block queue.\n");
	return;
    }
    cb_ptr = (CB *)cbq_st.flink;
    do {
	printscs_cb(cb_ptr, printmode);
	if(readmem((char *) &cb_st, (int)cb_ptr, sizeof(CB)) !=
	    sizeof(CB)) {
	    	printf("could not read connection block at 0x%x\n",cb_ptr);
		return;
	}
	cb_ptr = (CB *)cb_st.flink;
    } while (cb_ptr != (CB *)cbq_ptr);
}

/*
 *
 *   Name:	printscs_cb	- Print contents of a connection block.
 *
 *   Abstract:	Disect and display a connection block. 
 *
 *   Inputs:    cb_ptr	 	- Pointer to a connection block. 
 *		printmode	- Controlls output level.
 *
 *   Return	NONE
 *   Values:
 */
int 
printscs_cb(cb_ptr, printmode)
    CB		*cb_ptr;
    int		printmode;

{
	CB cb_st;
	int offset;

        if (cb_ptr == 0) {
	    printf("\tNULL connection block pointer.\n");
	    return;
        }
	printf("\t\t\t------------- CONNECTION BLOCK ------------------\n");
	if(readmem((char *) &cb_st, (int)cb_ptr, sizeof(CB)) !=
	    sizeof(CB)) {
		printf("could not read connection block at 0x%x.\n",cb_ptr);
		return;
	}

    if (printmode & SCS_PRINTFULL) {
	printf("\t\t\tConnection block address is 0x%x\n",cb_ptr);
	printf("\t\t\tflink: 0x%x, blink: 0x%x\n",cb_st.flink, cb_st.blink);
	printf("\t\t\tsize: %d, type: %d\n",cb_st.size, cb_st.type);
	printf("\t\t\tSCS waiting CB queue: fiink 0x%x, blink 0x%x\n",
		cb_st.scs_cb.flink, cb_st.scs_cb.blink);
	printf("\t\t\tSYSAP control 0x%x ",cb_st.control);
	if (cb_st.control != 0) {
		printf(" \(");
		praddr(cb_st.control);
		printf("\)");
	}
	printf("\n");
	printf("\t\t\tMessage event 0x%x ",cb_st.msg_event);
	if (cb_st.msg_event != 0) {
		printf(" \(");
		praddr(cb_st.msg_event);
		printf("\)");
	}
	printf("\n");
	printf("\t\t\tDatagram event 0x%x ",cb_st.dg_event);
	if (cb_st.dg_event != 0) {
		printf(" \(");
		praddr(cb_st.dg_event);
		printf("\)");
	}
	printf("\n");
	printf("\t\t\tPB: 0x%x, PDT: 0x%x, PCCB: 0x%x\n", cb_st.pb, 
		cb_st.pdt, cb_st.pccb);
	printf("\t\t\tSYSAP auxiliary pointer: 0x%x\n",cb_st.aux);
	offset = (int)(&cb_st.forkb) - (int)(&cb_st.flink);
	printscs_kschedblk((char *) ((char *)cb_ptr + offset), printmode);
	printf("\t\t\tConnection rejection reason: 0x%x\n",
		cb_st.errlogopt.rreason);
	offset = (int)(&cb_st.cinfo) - (int)(&cb_st.flink);
	printscs_cib((char *) ((char *)cb_ptr + offset), printmode);
    }
}

/*
 *
 *   Name:	printscs_cib	- Print contents of a connection information 
 *				  block.
 *
 *   Abstract:	Disect and display a connection information block. 
 *
 *   Inputs:    cib_ptr	 	- Pointer to a connection information block. 
 *		printmode	- Controlls output level.
 *
 *   Return	NONE
 *   Values:
 */
int 
printscs_cib(cib_ptr, printmode)
    CIB		*cib_ptr;
    int		printmode;

{
	CIB cib_st;
	int offset;
	int i;
	u_char c;

        if (cib_ptr == 0) {
	    printf("\tNULL connection information block pointer.\n");
	    return;
        }
	printf("\t\t\t\t-------- CONNECTION INFORMATION BLOCK ------\n");
	if(readmem((char *) &cib_st, (int)cib_ptr, sizeof(CIB)) !=
	    sizeof(CIB)) {
		printf("could not read connection information block at 0x%x.\n",
			cib_ptr);
		return;
	}

    if (printmode & SCS_PRINTFULL) {
	printf("\t\t\t\tConnection information block address 0x%x\n",
		cib_ptr);
	printf("\t\t\t\tlconnid: index %d, seq_num %d\n",
		cib_st.lconnid.index, cib_st.lconnid.seq_num);
	printf("\t\t\t\trconnid: index %d, seq_num %d\n",
		cib_st.rconnid.index, cib_st.rconnid.seq_num);
	printf("\t\t\t\tcstate: %d, cbstate: %d\n",cib_st.cstate,
		cib_st.cbstate);
	printf("\t\t\t\tstatus: ");
		if (cib_st.status.cwait)
			printf("cwait ");
		if (cib_st.status.abort_fork)
			printf("abort_fork ");
		if (cib_st.status.disconnect)
			printf("disconnect ");
	printf("\n");
	printf("\t\t\t\tntransfers: %d, reason: %d\n",cib_st.ntransfers,
		cib_st.reason);
	printf("\t\t\t\trproc_name: ");
	for (i=0; i< NAME_SIZE; i++) {
		c = (u_char)cib_st.rproc_name[i];
		if (isprint(c))
			printf("%c",c);
	}
	printf("\n");
	printf("\t\t\t\tlproc_name: ");
	for (i=0; i< NAME_SIZE; i++) {
		c = (u_char)cib_st.lproc_name[i];
		if (isprint(c))
			printf("%c",c);
	}
	printf("\n");
	printf("\t\t\t\tlconn_data: ");
	for (i=0; i< NAME_SIZE; i++) {
		c = (u_char)cib_st.lconn_data[i];
		if (isprint(c))
			printf("%c",c);
	}
	printf("\n");
	printf("\t\t\t\trconn_data: ");
	for (i=0; i< NAME_SIZE; i++) {
		c = (u_char)cib_st.rconn_data[i];
		if (isprint(c))
			printf("%c",c);
	}
	printf("\n");
	printf("\t\t\t\treserved_credit: %d, snd_credit: %d\n",
		cib_st.reserved_credit, cib_st.snd_credit);
	printf("\t\t\t\tmin_snd_credit: %d, rec_credit: %d\n",
		cib_st.min_snd_credit, cib_st.rec_credit);
	printf("\t\t\t\tinit_rec_credit: %d, min_rec_credit: %d\n",
		cib_st.init_rec_credit, cib_st.min_rec_credit);
	printf("\t\t\t\tpend_rec_credit: %d, dg_credit: %d\n",
		cib_st.pend_rec_credit, cib_st.dg_credit);
	printf("\t\t\t\tdgs_snt: %d, dgs_rec: %d\n",
		cib_st.dgs_snt, cib_st.dgs_rec);
	printf("\t\t\t\tdgs_discard: %d, msgs_snt: %d\n",
		cib_st.dgs_discard, cib_st.msgs_snt);
	printf("\t\t\t\tmsgs_rec: %d, sdatas_snt: %d\n",
		cib_st.msgs_rec, cib_st.sdatas_snt);
	printf("\t\t\t\tbytes_snt: %d, rdatas_snt: %d\n",
		cib_st.bytes_snt, cib_st.rdatas_snt);
	printf("\t\t\t\tbytes_req: %d, bytes_mapped: %d\n",
		cib_st.bytes_req, cib_st.bytes_mapped);
    }
}

/*
 *
 *   Name:	printscs_pd	- Print contents of a port data block.
 *
 *   Abstract:	The "pd" field of the PIB data structure is a union of two
 *		possible types (gvp and msi).  For the case of CI the gvp
 *		field is interpreted.  For msi devices the msi structure is
 *		displayed.  For other hardware types (such as uq) this
 *		structure is not used and consequently is not interpreted.
 *
 *   Inputs:    pd_ptr	 	- Pointer to a port data block.
 *		printmode	- Controlls output level.
 *		hwtype		- Port hardware type.
 *
 *   Return	NONE
 *   Values:
 */
int 
printscs_pd(pd_ptr, printmode, hwtype)
    char	*pd_ptr;
    int		printmode;
    u_long	hwtype;

{
	switch (hwtype) {
		case HPT_SII: 	    printscs_msipib(pd_ptr, printmode); break;
		case HPT_CI780:
		case HPT_CI750:
		case HPT_CIBCI:
		case HPT_CIBCA_BA:
		case HPT_CIBCA_AA:
		case HPT_CIXCD:
		case HPT_HSC:
				    printscs_gvppib(pd_ptr, printmode); break;
		default: 	    printf("\t\t\tpd field not used.\n");
	}
}

/*
 *
 *   Name:	printscs_gvppib	- Print contents of a generic vaxport path
 *				  information block.
 *
 *   Abstract:	Disect and display a _gvppib. This structure is itself a 
 *		union of only 1 element (_cipib), so this routine reads in
 *		a struct of that type and displays the contents.
 *
 *   Inputs:    cipib_ptr	- Pointer to a CI path info block.
 *		printmode	- Controlls output level.
 *
 *   Return	NONE
 *   Values:
 */
int 
printscs_gvppib(cipib_ptr, printmode)
    CIPIB		*cipib_ptr;
    int		printmode;

{
	CIPIB cipib_st;
	int offset;

        if (cipib_ptr == 0) {
	    printf("\tNULL CI path information block pointer.\n");
	    return;
        }
	printf("\t\t\t\t------------ CIPIB BLOCK ----------\n");
	if(readmem((char *) &cipib_st, (int)cipib_ptr, sizeof(CIPIB)) !=
	    sizeof(CIPIB)) {
		printf("could not read CI path information block at 0x%x.\n",
			cipib_ptr);
		return;
	}

    if (printmode & SCS_PRINTFULL) {
	printf("\t\t\t\tCI path information block address 0x%x\n",
		cipib_ptr);
	printf("\t\t\t\trom_level: %d, fn_level: %d\n",
		cipib_st.ucode_rev.rom_level, cipib_st.ucode_rev.fn_level);
	printf("\t\t\t\tport_fcn: 0x%x, port_fcn_ext: 0x%x\n",
		cipib_st.port_fcn, cipib_st.port_fcn_ext);
	printf("\t\t\t\tport_fcn_ext2: 0x%x, reset_port: 0x%x\n",
		cipib_st.port_fcn_ext2, cipib_st.reset_port);
	printf("\t\t\t\trport_state: %d \(", cipib_st.rport_state);
		switch (cipib_st.rport_state) {
			case PS_UNINIT: printf("PS_UNINIT"); break;
			case PS_UNINIT_MAINT: printf("PS_UNINIT_MAINT"); break;
			case PS_DISAB: printf("PS_DISAB"); break;
			case PS_DISAB_MAINT: printf("PS_DISAB_MAINT"); break;
			case PS_ENAB: printf("PS_ENAB"); break;
			case PS_ENAB_MAINT: printf("PS_ENAB_MAINT"); break;
			default: printf("UNKNOWN");
		}
		printf("\)\n");
    }
}

/*
 *
 *   Name:	printscs_msipib	- Print contents of a MSI path
 *				  information block.
 *
 *   Abstract:	Disect and display a _msipib. This structure is itself a 
 *		union of only 1 element (_msirpi), so this routine reads in
 *		a struct of that type and displays the contents.
 *
 *   Inputs:    msirpi_ptr	- Pointer to a MSI path info block.
 *		printmode	- Controlls output level.
 *
 *   Return	NONE
 *   Values:
 */
int 
printscs_msipib(msirpi_ptr, printmode)
    MSIRPI	*msirpi_ptr;
    int		printmode;

{
	MSIRPI msirpi_st;
	int offset;

        if (msirpi_ptr == 0) {
	    printf("\tNULL MSI path information block pointer.\n");
	    return;
        }
	printf("\t\t\t\t------------ MSIRPI BLOCK ----------\n");
	if(readmem((char *) &msirpi_st, (int)msirpi_ptr, sizeof(MSIRPI)) !=
	    sizeof(MSIRPI)) {
		printf("could not read MSI path information block at 0x%x.\n",
			msirpi_ptr);
		return;
	}

    if (printmode & SCS_PRINTFULL) {
	printf("\t\t\t\tMSI path information block address 0x%x\n",
		msirpi_ptr);
	printf("\t\t\t\tst_level: %d, fn_level: %d\n",
		msirpi_st.ucode_rev.st_level, msirpi_st.ucode_rev.fn_level);
	printf("\t\t\t\tport_fcn: 0x%x, 0x%x\n",
		msirpi_st.port_fcn[0], msirpi_st.port_fcn[1]);
	printf("\t\t\t\treset_port: %d, port_state: %d \(",
		msirpi_st.sys_state.reset_port, msirpi_st.sys_state.port_state);
		switch (msirpi_st.sys_state.port_state) {
			case PS_UNINIT: printf("PS_UNINIT"); break;
			case PS_UNINIT_MAINT: printf("PS_UNINIT_MAINT"); break;
			case PS_DISAB: printf("PS_DISAB"); break;
			case PS_DISAB_MAINT: printf("PS_DISAB_MAINT"); break;
			case PS_ENAB: printf("PS_ENAB"); break;
			case PS_ENAB_MAINT: printf("PS_ENAB_MAINT"); break;
			default: printf("UNKNOWN");
		}
		printf("\)\n");
	printf("\t\t\t\tsys_state1: %d, sys_state2: %d \n",
		msirpi_st.sys_state.sys_state1, msirpi_st.sys_state.sys_state2);
	printf("\t\t\t\tport_fcn_ext.maxbodylen: %d\n",
		msirpi_st.port_fcn_ext.maxbodylen);
    }
}