iscsi_common.c

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

/*	common/iscsi_common.c
 *
 * 	Contains functions common for both iscsi initiator and iscsi target
 *
 *	vi: set autoindent tabstop=8 shiftwidth=4 :
 *
 *	This file contains auxilliary functions for iscsi initiator
 *	code that are responsible for dealing with error recovery.
 *
 *	Copyright (C) 2001-2003 InterOperability Lab (IOL)
 *	University of New Hampshier (UNH)
 *	Durham, NH 03824
 *
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation; either version 2, or (at your option)
 *	any later version.
 *
 *	This program is distributed in the hope that it will be useful,
 *	but WITHOUT ANY WARRANTY; without even the implied warranty of
 *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *	GNU General Public License for more details.
 *
 *	You should have received a copy of the GNU General Public License
 *	along with this program; if not, write to the Free Software
 *	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 *	USA.
 *
 *	The name of IOL and/or UNH may not be used to endorse or promote
 *	products derived from this software without specific prior
 * 	written permission.
*/
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/net.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <scsi/scsi.h>

#include "iscsi_common.h"
#include "debug.h"

#ifdef __KERNEL__

/*	routine to convert a 64-bit value in network byte order
	into a printable string
*/
char *
string_llx(__u64 x, char *str)
{
	int i;
	static char convert[] = "0123456789abcdef";
	char *ptr;
	__u32 c;
	union {
		__u64 x;
		__u8 c[8];
	} tmp;

	tmp.x = x;
	ptr = str;
	*ptr++ = '0';
	*ptr++ = 'x';
	for (i = 0; i < 8; i++) {
		c = tmp.c[i];
		*ptr++ = convert[c >> 4];
		*ptr++ = convert[c & 0xf];
	}
	*ptr = '\0';
	return str;
}

static void
print_rsvd_u8(int n, __u8 rsvd)
{
	if (rsvd != 0)
		printk("    rsvd%d: 0x%.2x\n", n, rsvd);
}

static void
print_rsvd_u16(int n, __u16 rsvd)
{
	if (rsvd != 0)
		printk("    rsvd%d: 0x%.4x\n", n, rsvd);
}

static void
print_rsvd_u32(int n, __u32 rsvd)
{
	if (rsvd != 0)
		printk("    rsvd%d: 0x%.8x\n", n, rsvd);
}

static void
print_rsvd_u64(int n, __u64 rsvd)
{
	char string[8];

	if (rsvd != 0ll)
		printk("    rsvd%d: %s\n", n, string_llx(rsvd, string));
}

static void
print_opcode(__u8 opcode)
{
	printk("    Opcode: 0x%.2x,  I: %d\n", opcode & ISCSI_OPCODE,
	       (opcode & I_BIT) != 0);
}

static void
print_flags(__u8 flags)
{
	printk("    flags: 0x%.2x\n", flags);
}

static void
print_version(char *which, __u8 version)
{
	printk("    Version%s: 0x%.2x\n", which, version);
}

static void
print_response(__u8 response)
{
	if (response != 0)
		printk("    Response: 0x%.2x\n", response);
}

static void
print_status(__u8 status)
{
	if (status != 0)
		printk("    Status: 0x%.2x\n", status);
}

static void
print_lun(__u64 lun)
{
	char string[20];

	if (lun != 0ll)
		printk("    LUN: %s\n", string_llx(lun, string));
}

static void
print_isid_tsih(__u8 isid[6], __u16 tsih)
{
	printk("    ISID: 0x%.2x %.2x %.2x %.2x %.2x %.2x\n",
	       isid[0], isid[1], isid[2], isid[3], isid[4], isid[5]);
	printk("    TSIH: %u\n", be16_to_cpu(tsih));
}

static void
print_dsl(__u32 length)
{
	if (length != 0)
		printk("    DSL: %u\n", be32_to_cpu(length));
}

static void
print_itt(__u32 init_task_tag)
{
	if (init_task_tag == ALL_ONES)
		printk("    ITT: 0x%08x\n", init_task_tag);
	else
		printk("    ITT: %u\n", be32_to_cpu(init_task_tag));
}

static void
print_ttt(__u32 target_xfer_tag)
{
	if (target_xfer_tag == ALL_ONES)
		printk("    TTT: 0x%08x\n", target_xfer_tag);
	else
		printk("    TTT: %u\n", be32_to_cpu(target_xfer_tag));
}

static void
print_cid(__u16 cid)
{
	printk("    CID: %u\n", be16_to_cpu(cid));
}

static void
print_expstatsn(__u32 exp_stat_sn)
{
	if (exp_stat_sn != 0)
		printk("    ExpStatSN: %u\n", be32_to_cpu(exp_stat_sn));
}

static void
print_cmdsn_expstatsn(__u32 cmd_sn, __u32 exp_stat_sn)
{
	printk("    CmdSN: %u\n", be32_to_cpu(cmd_sn));
	print_expstatsn(exp_stat_sn);
}

static void
print_statsn_exp_max(__u32 stat_sn, __u32 exp_cmd_sn, __u32 max_cmd_sn)
{
	if (stat_sn != 0)
		printk("    StatSN: %u\n", be32_to_cpu(stat_sn));
	printk("    ExpCmdSN: %u\n", be32_to_cpu(exp_cmd_sn));
	printk("    MaxCmdSN: %u\n", be32_to_cpu(max_cmd_sn));
}

static void
print_residual(__u32 resid)
{
	if (resid != 0)
		printk("    ResidualCount: %u\n", be32_to_cpu(resid));
}

static void
print_datasn(__u32 data_sn)
{
	if (data_sn != 0)
		printk("    DataSN: %u\n", be32_to_cpu(data_sn));
}

static void
print_offset(__u32 offset)
{
	if (offset != 0)
		printk("    BufferOffset: %u\n", be32_to_cpu(offset));
}

static void
print_rtt(__u32 ref_task_tag)
{
	if (ref_task_tag != 0)
		printk("    RTT: %u\n", be32_to_cpu(ref_task_tag));
}

static void
print_exp_data_sn(__u32 exp_data_sn)
{
	if (exp_data_sn != 0)
		printk("    ExpDataSN: %u\n", be32_to_cpu(exp_data_sn));
}

static void
print_begrun(__u32 begrun)
{
	printk("    BegRun: %u\n", be32_to_cpu(begrun));
}

static void
print_runlen(__u32 runlen)
{
	printk("    RunLength: %u\n", be32_to_cpu(runlen));
}

void
print_init_scsi_cmnd(struct iscsi_init_scsi_cmnd *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);
	printk("    EDTL: %u\n", be32_to_cpu(cmd->xfer_len));
	print_cmdsn_expstatsn(cmd->cmd_sn, cmd->exp_stat_sn);
	printk
	    ("    CDB: 0x%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x "
	     "%.2x %.2x %.2x %.2x %.2x\n", cmd->cdb[0], cmd->cdb[1],
	     cmd->cdb[2], cmd->cdb[3], cmd->cdb[4], cmd->cdb[5], cmd->cdb[6],
	     cmd->cdb[7], cmd->cdb[8], cmd->cdb[9], cmd->cdb[10], cmd->cdb[11],
	     cmd->cdb[12], cmd->cdb[13], cmd->cdb[14], cmd->cdb[15]);
}

void
print_targ_scsi_rsp(struct iscsi_targ_scsi_rsp *cmd)
{
	print_opcode(cmd->opcode);
	print_flags(cmd->flags);
	print_response(cmd->response);
	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_exp_data_sn(cmd->exp_data_sn);
	if (cmd->bidi_resid != 0)
		printk("    BidiResidualCount: %u\n",
		       be32_to_cpu(cmd->bidi_resid));
	print_residual(cmd->resid);
}

void
print_init_text_cmnd(struct iscsi_init_text_cmnd *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_cmdsn_expstatsn(cmd->cmd_sn, cmd->exp_stat_sn);
	print_rsvd_u64(4, cmd->rsvd4);
	print_rsvd_u64(5, cmd->rsvd5);
}

void
print_targ_text_rsp(struct iscsi_targ_text_rsp *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);
	print_rsvd_u32(4, cmd->rsvd4);
	print_rsvd_u64(5, cmd->rsvd5);
}

void
print_init_login_cmnd(struct iscsi_init_login_cmnd *cmd)
{
	print_opcode(cmd->opcode);
	print_flags(cmd->flags);
	print_version("Max", cmd->version_max);
	print_version("Min", cmd->version_min);
	print_dsl(cmd->length);
	print_isid_tsih(cmd->isid, cmd->tsih);
	print_itt(cmd->init_task_tag);
	print_cid(cmd->cid);
	print_rsvd_u16(1, cmd->rsvd1);
	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_login_rsp(struct iscsi_targ_login_rsp *cmd)
{
	print_opcode(cmd->opcode);
	print_flags(cmd->flags);
	print_version("Max", cmd->version_max);
	print_version("Active", cmd->version_active);
	print_dsl(cmd->length);
	print_isid_tsih(cmd->isid, cmd->tsih);
	print_itt(cmd->init_task_tag);
	print_rsvd_u32(1, cmd->rsvd1);
	print_statsn_exp_max(cmd->stat_sn, cmd->exp_cmd_sn, cmd->max_cmd_sn);
	if (cmd->status_class != 0)
		printk("    StatusClass: 0x%.2x\n", cmd->status_class);
	if (cmd->status_detail != 0)
		printk("    StatusDetail: 0x%.2x\n", cmd->status_detail);
	print_rsvd_u16(2, cmd->rsvd2);
	print_rsvd_u64(3, cmd->rsvd3);
}

void
print_init_logout_cmnd(struct iscsi_init_logout_cmnd *cmd)
{
	print_opcode(cmd->opcode);
	printk("reasoncod: 0x%.2x\n", cmd->flags);
	print_rsvd_u16(1, cmd->rsvd1);
	print_dsl(cmd->length);
	print_lun(cmd->lun);
	print_itt(cmd->init_task_tag);
	print_cid(cmd->cid);
	print_rsvd_u16(2, cmd->rsvd2);
	print_cmdsn_expstatsn(cmd->cmd_sn, cmd->exp_stat_sn);
	print_rsvd_u64(4, cmd->rsvd4);
	print_rsvd_u64(5, cmd->rsvd5);
}

void
print_targ_logout_rsp(struct iscsi_targ_logout_rsp *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(3, cmd->rsvd3);