iscsi_common.c

iscsi源代码 UNH的progect 有initiator端和target端的源码

	print_statsn_exp_max(cmd->stat_sn, cmd->exp_cmd_sn, cmd->max_cmd_sn);
	print_rsvd_u32(4, cmd->rsvd4);
	printk("    Time2Wait: 0x%.8x\n", be16_to_cpu(cmd->time2wait));
	printk("    Tm2Retain: 0x%.8x\n", be16_to_cpu(cmd->time2retain));
	print_rsvd_u32(5, cmd->rsvd5);
}

void
print_init_scsi_data_out(struct iscsi_init_scsi_data_out *cmd)
{
	print_opcode(cmd->opcode);
	print_flags(cmd->flags);
	print_rsvd_u16(2, cmd->rsvd2);
	print_dsl(cmd->length);
	print_lun(cmd->lun);
	print_itt(cmd->init_task_tag);
	print_ttt(cmd->target_xfer_tag);
	print_rsvd_u32(3, cmd->rsvd3);
	print_expstatsn(cmd->exp_stat_sn);
	print_rsvd_u32(4, cmd->rsvd4);
	print_datasn(cmd->data_sn);
	print_offset(cmd->offset);
	print_rsvd_u32(5, cmd->rsvd5);
}

void
print_targ_scsi_data_in(struct iscsi_targ_scsi_data_in *cmd)
{
	print_opcode(cmd->opcode);
	print_flags(cmd->flags);
	print_rsvd_u8(1, cmd->rsvd1);
	print_status(cmd->status);
	print_dsl(cmd->length);
	print_lun(cmd->lun);
	print_itt(cmd->init_task_tag);
	print_ttt(cmd->target_xfer_tag);
	print_statsn_exp_max(cmd->stat_sn, cmd->exp_cmd_sn, cmd->max_cmd_sn);
	print_datasn(cmd->data_sn);
	print_offset(cmd->offset);
	print_residual(cmd->resid);
}

void
print_targ_rjt(struct iscsi_targ_rjt *cmd)
{
	print_opcode(cmd->opcode);
	print_flags(cmd->flags);
	if (cmd->reason != 0)
		printk("    Reason: 0x%.2x\n", cmd->reason);
	print_rsvd_u8(2, cmd->rsvd2);
	print_dsl(cmd->length);
	print_lun(cmd->lun);
	print_itt(cmd->init_task_tag);
	print_rsvd_u32(4, cmd->rsvd4);
	print_statsn_exp_max(cmd->stat_sn, cmd->exp_cmd_sn, cmd->max_cmd_sn);
	print_datasn(cmd->data_sn);
	print_rsvd_u64(4, cmd->rsvd4);
	print_rsvd_u64(5, cmd->rsvd5);
}

void
print_init_nopout(struct iscsi_init_nopout *cmd)
{
	print_opcode(cmd->opcode);
	print_flags(cmd->flags);
	print_rsvd_u16(1, cmd->rsvd1);
	print_dsl(cmd->length);
	print_lun(cmd->lun);
	print_itt(cmd->init_task_tag);
	print_ttt(cmd->target_xfer_tag);
	print_cmdsn_expstatsn(cmd->cmd_sn, cmd->exp_stat_sn);
	print_rsvd_u64(2, cmd->rsvd2);
	print_rsvd_u64(3, cmd->rsvd3);
}

void
print_targ_nopin(struct iscsi_targ_nopin *cmd)
{
	print_opcode(cmd->opcode);
	print_flags(cmd->flags);
	print_rsvd_u16(1, cmd->rsvd1);
	print_dsl(cmd->length);
	print_lun(cmd->lun);
	print_itt(cmd->init_task_tag);
	print_ttt(cmd->target_xfer_tag);
	print_statsn_exp_max(cmd->stat_sn, cmd->exp_cmd_sn, cmd->max_cmd_sn);
	print_rsvd_u32(2, cmd->rsvd2);
	print_rsvd_u64(3, cmd->rsvd3);
}

void
print_targ_r2t(struct iscsi_targ_r2t *cmd)
{
	print_opcode(cmd->opcode);
	print_flags(cmd->flags);
	print_rsvd_u16(2, cmd->rsvd2);
	print_dsl(cmd->length);
	print_lun(cmd->lun);
	print_itt(cmd->init_task_tag);
	print_ttt(cmd->target_xfer_tag);
	print_statsn_exp_max(cmd->stat_sn, cmd->exp_cmd_sn, cmd->max_cmd_sn);
	printk("    R2TSN: %u\n", be32_to_cpu(cmd->r2t_sn));
	print_offset(cmd->offset);
	printk("    DDTL: %u\n", be32_to_cpu(cmd->xfer_len));
}

void
print_targ_async_msg(struct iscsi_targ_async_msg *cmd)
{
	print_opcode(cmd->opcode);
	print_flags(cmd->flags);
	print_rsvd_u16(2, cmd->rsvd2);
	print_dsl(cmd->length);
	print_lun(cmd->lun);
	print_itt(cmd->init_task_tag);
	print_rsvd_u32(3, cmd->rsvd3);
	print_statsn_exp_max(cmd->stat_sn, cmd->exp_cmd_sn, cmd->max_cmd_sn);
	printk("AsyncEvnt: %u\n", cmd->async_event);
	printk("AsyncVCod: %u\n", cmd->async_vcode);
	if (cmd->parameter1 != 0)
		printk("   Param1: %u\n", be16_to_cpu(cmd->parameter1));
	if (cmd->parameter2 != 0)
		printk("   Param2: %u\n", be16_to_cpu(cmd->parameter2));
	if (cmd->parameter3 != 0)
		printk("   Param3: %u\n", be16_to_cpu(cmd->parameter3));
	print_rsvd_u32(5, cmd->rsvd5);
}

void
print_init_task_mgt_command(struct iscsi_init_task_mgt_command *cmd)
{
	print_opcode(cmd->opcode);
	printk("    Function: 0x%.2x\n", cmd->function);
	print_rsvd_u16(1, cmd->rsvd1);
	print_dsl(cmd->length);
	print_lun(cmd->lun);
	print_itt(cmd->init_task_tag);
	print_rtt(cmd->ref_task_tag);
	print_cmdsn_expstatsn(cmd->cmd_sn, cmd->exp_stat_sn);
	if (cmd->ref_cmd_sn != 0)
		printk("    RefCmdSN: %u\n", be32_to_cpu(cmd->ref_cmd_sn));
	print_exp_data_sn(cmd->exp_data_sn);
	print_rsvd_u64(4, cmd->rsvd4);
}

void
print_targ_task_mgt_response(struct iscsi_targ_task_mgt_response *cmd)
{
	print_opcode(cmd->opcode);
	print_flags(cmd->flags);
	print_response(cmd->response);
	print_rsvd_u8(1, cmd->rsvd1);
	print_dsl(cmd->length);
	print_lun(cmd->lun);
	print_itt(cmd->init_task_tag);
	print_rsvd_u32(2, cmd->rsvd2);
	print_statsn_exp_max(cmd->stat_sn, cmd->exp_cmd_sn, cmd->max_cmd_sn);
	print_rsvd_u32(4, cmd->rsvd4);
	print_rsvd_u64(5, cmd->rsvd5);
}

void
print_init_snack(struct iscsi_init_snack *cmd)
{
	print_opcode(cmd->opcode);
	print_flags(cmd->flags);
	print_rsvd_u16(1, cmd->rsvd1);
	print_dsl(cmd->length);
	print_lun(cmd->lun);
	print_itt(cmd->init_task_tag);
	print_ttt(cmd->target_xfer_tag);
	print_rsvd_u32(2, cmd->rsvd2);
	print_expstatsn(cmd->exp_stat_sn);
	print_rsvd_u64(3, cmd->rsvd3);
	print_begrun(cmd->begrun);
	print_runlen(cmd->runlen);
}

void
print_iscsi_command(void *cmd)
{
	struct generic_pdu *pdu = cmd;

	switch (pdu->opcode & ISCSI_OPCODE) {
	case ISCSI_INIT_NOP_OUT:
		print_init_nopout((struct iscsi_init_nopout *)cmd);
		break;
	case ISCSI_INIT_SCSI_CMND:
		print_init_scsi_cmnd((struct iscsi_init_scsi_cmnd *)cmd);
		break;
	case ISCSI_INIT_TASK_MGMT_CMND:
		print_init_task_mgt_command(
				(struct iscsi_init_task_mgt_command *)cmd);
		break;
	case ISCSI_INIT_LOGIN_CMND:
		print_init_login_cmnd((struct iscsi_init_login_cmnd *)cmd);
		break;
	case ISCSI_INIT_TEXT_CMND:
		print_init_text_cmnd((struct iscsi_init_text_cmnd *)cmd);
		break;
	case ISCSI_INIT_SCSI_DATA_OUT:
		print_init_scsi_data_out((struct iscsi_init_scsi_data_out*)cmd);
		break;
	case ISCSI_INIT_LOGOUT_CMND:
		print_init_logout_cmnd((struct iscsi_init_logout_cmnd *)cmd);
		break;
	case ISCSI_INIT_SNACK:
		print_init_snack((struct iscsi_init_snack *)cmd);
		break;
	case ISCSI_TARG_NOP_IN:
		print_targ_nopin((struct iscsi_targ_nopin *)cmd);
		break;
	case ISCSI_TARG_SCSI_RSP:
		print_targ_scsi_rsp((struct iscsi_targ_scsi_rsp *)cmd);
		break;
	case ISCSI_TARG_TASK_MGMT_RSP:
		print_targ_task_mgt_response(
				(struct iscsi_targ_task_mgt_response *)cmd);
		break;
	case ISCSI_TARG_LOGIN_RSP:
		print_targ_login_rsp((struct iscsi_targ_login_rsp *)cmd);
		break;
	case ISCSI_TARG_TEXT_RSP:
		print_targ_text_rsp((struct iscsi_targ_text_rsp *)cmd);
		break;
	case ISCSI_TARG_SCSI_DATA_IN:
		print_targ_scsi_data_in((struct iscsi_targ_scsi_data_in *)cmd);
		break;
	case ISCSI_TARG_LOGOUT_RSP:
		print_targ_logout_rsp((struct iscsi_targ_logout_rsp *)cmd);
		break;
	case ISCSI_TARG_R2T:
		print_targ_r2t((struct iscsi_targ_r2t *)cmd);
		break;
	case ISCSI_TARG_ASYNC_MSG:
		print_targ_async_msg((struct iscsi_targ_async_msg *)cmd);
		break;
	case ISCSI_TARG_RJT:
		print_targ_rjt((struct iscsi_targ_rjt *)cmd);
		break;
	default:	/* an illegal opcode! */
		print_opcode(pdu->opcode);
		print_flags(pdu->flags);
		print_dsl(pdu->length);
		print_itt(pdu->init_task_tag);
		break;
	}	/* switch */
}

/*	returns pointer to printable name of SCSI op code */
/*	(Normally this is byte 1 of a SCSI CDB */
char *
printable_scsi_op(__u8 opcode, char *op_buf)
{
	char *result = "";

	/*      opcode symbols defined in <scsi/scsi.h> */
	/*      this table includes only those symbols we have actually seen
	   being sent to/from a vendor */
	switch (opcode) {
	case TEST_UNIT_READY:	/* 0x00 */
		result = "TEST_UNIT_READY";
		break;
	case REZERO_UNIT:	/* 0x01 */
		result = "REWIND";
		break;
	case REQUEST_SENSE:	/* 0x03 */
		result = "REQUEST_SENSE";
		break;
	case READ_BLOCK_LIMITS:	/* 0x05 */
		result = "READ_BLOCK_LIMITS";
		break;
	case READ_6:		/* 0x08 */
		result = "READ_6";
		break;
	case WRITE_6:		/* 0x0a */
		result = "WRITE_6";
		break;
	case WRITE_FILEMARKS:	/* 0x10 */
		result = "WRITE_FILEMARKS";
		break;
	case INQUIRY:		/* 0x12 */
		result = "INQUIRY";
		break;
	case MODE_SENSE:	/* 0x1a */
		result = "MODE_SENSE";
		break;
	case READ_CAPACITY:	/* 0x25 */
		result = "READ_CAPACITY";
		break;
	case READ_10:		/* 0x28 */
		result = "READ_10";
		break;
	case WRITE_10:		/* 0x2a */
		result = "WRITE_10";
		break;
	case READ_12:		/* 0xa8 */
		result = "READ_12";
		break;
	case WRITE_12:		/* 0xaa */
		result = "WRITE_12";
		break;
	default:
		sprintf(op_buf, "CDBop 0x%02x", opcode);
		result = op_buf;
		break;
	}			/* switch */
	return result;
}

/*	returns pointer to printable name of iSCSI op code, but if this is
 *	a SCSI Command, return the printable name of the SCSI op from the cdb
 */
char *
printable_iscsi_op(void *cmd, char *op_buf)
{
	struct generic_pdu *pdu = cmd;
	char *result = "";

	switch (pdu->opcode & ISCSI_OPCODE) {
	case ISCSI_INIT_NOP_OUT:
		result = "NopOut";
		break;
	case ISCSI_INIT_SCSI_CMND:
		result = printable_scsi_op(((struct iscsi_init_scsi_cmnd *)cmd)
							->cdb[0], op_buf);
		break;
	case ISCSI_INIT_TASK_MGMT_CMND:
		result = "Task MGMT Req";
		break;
	case ISCSI_INIT_LOGIN_CMND:
		result = "Login";
		break;
	case ISCSI_INIT_TEXT_CMND:
		result = "Text Req";
		break;
	case ISCSI_INIT_SCSI_DATA_OUT:
		result = "DataOut";
		break;
	case ISCSI_INIT_LOGOUT_CMND:
		result = "Logout";
		break;
	case ISCSI_INIT_SNACK:
		result = "SNACK";
		break;
	case ISCSI_TARG_NOP_IN:
		result = "NopIn";
		break;
	case ISCSI_TARG_SCSI_RSP:
		result = "SCSI Rsp";
		break;
	case ISCSI_TARG_TASK_MGMT_RSP:
		result = "Task MGMT Rsp";
		break;
	case ISCSI_TARG_LOGIN_RSP:
		result = "Login Rsp";
		break;
	case ISCSI_TARG_TEXT_RSP:
		result = "Text Rsp";
		break;
	case ISCSI_TARG_SCSI_DATA_IN:
		result = "DataIn";
		break;
	case ISCSI_TARG_LOGOUT_RSP:
		result = "Logout Rsp";
		break;
	case ISCSI_TARG_R2T:
		result = "R2T";
		break;
	case ISCSI_TARG_ASYNC_MSG:
		result = "ASYNC Message";
		break;
	case ISCSI_TARG_RJT:
		result = "Reject";
		break;
	default:	/* an illegal opcode! */
		sprintf(op_buf, "bad op 0x%02x", pdu->opcode & ISCSI_OPCODE);
		result = op_buf;
		break;
	}	/* switch */
	return result;
}

#endif