osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

SCSI dissector, and changes to make the iSCSI dissector use it, from 

Dinesh Dutt.

svn path=/trunk/; revision=4508
This commit is contained in:
Guy Harris 2002-01-10 01:28:45 +00:00
parent 573f3fb04a
commit aa36cec9df
7 changed files with 3651 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
AUTHORS
View File

@ -982,6 +982,11 @@ Irfan Khan <ikhan[AT]qualcomm.com> {
Jayaram V.R <vjayar[AT]cisco.com> {
PPP multiplexing support
}
Dinesh Dutt <ddutt[AT]cisco.com> {
SCSI dissector, for use by iSCSI and other protocols that
transport SCSI operations
}
Alain Magloire <alainm[AT]rcsm.ece.mcgill.ca> was kind enough to
give his permission to use his version of snprintf.c.

6
Makefile.am
View File

@ -1,7 +1,7 @@
# Makefile.am
# Automake file for Ethereal
#
# $Id: Makefile.am,v 1.403 2002/01/09 02:51:46 itojun Exp $
# $Id: Makefile.am,v 1.404 2002/01/10 01:28:43 guy Exp $
#
# Ethereal - Network traffic analyzer
# By Gerald Combs <gerald@ethereal.com>
@ -239,7 +239,8 @@ DISSECTOR_SRC = \
packet-rwall.c \
packet-rx.c \
packet-sap.c \
packet-sctp.c \
packet-scsi.c \
packet-sctp.c \
packet-sdp.c \
packet-sip.c \
packet-skinny.c \
@ -407,6 +408,7 @@ noinst_HEADERS = \
packet-rtp.h \
packet-rwall.h \
packet-rx.h \
packet-scsi.h \
packet-sll.h \
packet-smb-browse.h \
packet-smb-common.h \

5
Makefile.nmake
View File

@ -1,7 +1,7 @@
## Makefile for building ethereal.exe with Microsoft C and nmake
## Use: $(MAKE) /$(MAKEFLAGS) -f makefile.nmake
#
# $Id: Makefile.nmake,v 1.163 2002/01/09 02:55:38 guy Exp $
# $Id: Makefile.nmake,v 1.164 2002/01/10 01:28:43 guy Exp $
include config.nmake
include <win32.mak>
@ -190,7 +190,8 @@ DISSECTOR_SRC = \
packet-rwall.c \
packet-rx.c \
packet-sap.c \
packet-sctp.c \
packet-scsi.c \
packet-sctp.c \
packet-sdp.c \
packet-sip.c \
packet-skinny.c \

1
doc/ethereal.pod.template
View File

@ -1277,6 +1277,7 @@ B<http://www.ethereal.com>.
Heinz Prantner <Heinz.Prantner[AT]radisys.com>
Irfan Khan <ikhan[AT]qualcomm.com>
Jayaram V.R <vjayar[AT]cisco.com>
Dinesh Dutt <ddutt[AT]cisco.com>
Alain Magloire <alainm[AT]rcsm.ece.mcgill.ca> was kind enough to give his
permission to use his version of snprintf.c.

362
packet-iscsi.c
View File

@ -4,7 +4,7 @@
*
* Conforms to the protocol described in: draft-ietf-ips-iscsi-08.txt
*
* $Id: packet-iscsi.c,v 1.18 2001/12/10 00:25:29 guy Exp $
* $Id: packet-iscsi.c,v 1.19 2002/01/10 01:28:43 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -55,6 +55,8 @@
#include "packet.h"
#include "prefs.h"
#include "conversation.h"
#include "packet-scsi.h"
static gboolean iscsi_desegment = TRUE;
@ -79,7 +81,6 @@ static int hf_iscsi_AHS = -1;
static int hf_iscsi_Padding = -1;
static int hf_iscsi_ping_data = -1;
static int hf_iscsi_immediate_data = -1;
static int hf_iscsi_sense_data = -1;
static int hf_iscsi_write_data = -1;
static int hf_iscsi_read_data = -1;
static int hf_iscsi_error_pdu_data = -1;
@ -104,8 +105,6 @@ static int hf_iscsi_InitiatorTaskTag = -1;
static int hf_iscsi_ExpectedDataTransferLength = -1;
static int hf_iscsi_CmdSN = -1;
static int hf_iscsi_ExpStatSN = -1;
static int hf_iscsi_SCSICommand_CDB = -1;
static int hf_iscsi_SCSICommand_CDB0 = -1;
static int hf_iscsi_StatSN = -1;
static int hf_iscsi_ExpCmdSN = -1;
static int hf_iscsi_MaxCmdSN = -1;
@ -166,6 +165,22 @@ static gint ett_iscsi_KeyValues = -1;
static gint ett_iscsi_CDB = -1;
static gint ett_iscsi_Flags = -1;
typedef struct _iscsi_conv_key {
guint32 conv_idx;
guint32 itt;
} iscsi_conv_key_t;
typedef struct _iscsi_conv_data {
guint32 iscsi_dl;
guint32 abs_secs;
guint32 abs_usecs;
} iscsi_conv_data_t;
static GHashTable *iscsi_req_hash = NULL;
static GMemChunk *iscsi_req_keys = NULL;
static GMemChunk *iscsi_req_vals = NULL;
static guint32 iscsi_init_count = 25;
#define X_BIT 0x80
#define I_BIT 0x40
@ -204,7 +219,7 @@ static const value_string iscsi_opcodes[] = {
{ ISCSI_OPCODE_TASK_MANAGEMENT_FUNCTION, "Task Management Function" },
{ ISCSI_OPCODE_LOGIN_COMMAND, "Login Command" },
{ ISCSI_OPCODE_TEXT_COMMAND, "Text Command" },
{ ISCSI_OPCODE_SCSI_DATA_OUT, "SCSI Write Data" },
{ ISCSI_OPCODE_SCSI_DATA_OUT, "SCSI Data Out" },
{ ISCSI_OPCODE_LOGOUT_COMMAND, "Logout Command" },
{ ISCSI_OPCODE_SNACK_REQUEST, "SNACK Request" },
@ -213,7 +228,7 @@ static const value_string iscsi_opcodes[] = {
{ ISCSI_OPCODE_TASK_MANAGEMENT_FUNCTION_RESPONSE, "Task Management Function Response" },
{ ISCSI_OPCODE_LOGIN_RESPONSE, "Login Response" },
{ ISCSI_OPCODE_TEXT_RESPONSE, "Text Response" },
{ ISCSI_OPCODE_SCSI_DATA_IN, "SCSI Read Data" },
{ ISCSI_OPCODE_SCSI_DATA_IN, "SCSI Data In" },
{ ISCSI_OPCODE_LOGOUT_RESPONSE, "Logout Response" },
{ ISCSI_OPCODE_R2T, "Ready To Transfer" },
{ ISCSI_OPCODE_ASYNC_MESSAGE, "Asynchronous Message" },
@ -291,88 +306,6 @@ static const value_string iscsi_scsicommand_taskattrs[] = {
{0, NULL},
};
static const value_string iscsi_scsi_cdb0[] = {
{0x00, "TEST_UNIT_READY"},
{0x01, "REZERO_UNIT"},
{0x03, "REQUEST_SENSE"},
{0x04, "FORMAT_UNIT"},
{0x05, "READ_BLOCK_LIMITS"},
{0x07, "REASSIGN_BLOCKS"},
{0x08, "READ_6"},
{0x0a, "WRITE_6"},
{0x0b, "SEEK_6"},
{0x0f, "READ_REVERSE"},
{0x10, "WRITE_FILEMARKS"},
{0x11, "SPACE"},
{0x12, "INQUIRY"},
{0x14, "RECOVER_BUFFERED_DATA"},
{0x15, "MODE_SELECT"},
{0x16, "RESERVE"},
{0x17, "RELEASE"},
{0x18, "COPY"},
{0x19, "ERASE"},
{0x1a, "MODE_SENSE"},
{0x1b, "START_STOP"},
{0x1c, "RECEIVE_DIAGNOSTIC"},
{0x1d, "SEND_DIAGNOSTIC"},
{0x1e, "ALLOW_MEDIUM_REMOVAL"},
{0x24, "SET_WINDOW"},
{0x25, "READ_CAPACITY"},
{0x28, "READ_10"},
{0x2a, "WRITE_10"},
{0x2b, "SEEK_10"},
{0x2e, "WRITE_VERIFY"},
{0x2f, "VERIFY"},
{0x30, "SEARCH_HIGH"},
{0x31, "SEARCH_EQUAL"},
{0x32, "SEARCH_LOW"},
{0x33, "SET_LIMITS"},
{0x34, "PRE_FETCH"},
{0x34, "READ_POSITION"},
{0x35, "SYNCHRONIZE_CACHE"},
{0x36, "LOCK_UNLOCK_CACHE"},
{0x37, "READ_DEFECT_DATA"},
{0x38, "MEDIUM_SCAN"},
{0x39, "COMPARE"},
{0x3a, "COPY_VERIFY"},
{0x3b, "WRITE_BUFFER"},
{0x3c, "READ_BUFFER"},
{0x3d, "UPDATE_BLOCK"},
{0x3e, "READ_LONG"},
{0x3f, "WRITE_LONG"},
{0x40, "CHANGE_DEFINITION"},
{0x41, "WRITE_SAME"},
{0x43, "READ_TOC"},
{0x4c, "LOG_SELECT"},
{0x4d, "LOG_SENSE"},
{0x55, "MODE_SELECT_10"},
{0x5a, "MODE_SENSE_10"},
{0xa5, "MOVE_MEDIUM"},
{0xa8, "READ_12"},
{0xaa, "WRITE_12"},
{0xae, "WRITE_VERIFY_12"},
{0xb0, "SEARCH_HIGH_12"},
{0xb1, "SEARCH_EQUAL_12"},
{0xb2, "SEARCH_LOW_12"},
{0xb8, "READ_ELEMENT_STATUS"},
{0xb6, "SEND_VOLUME_TAG"},
{0xea, "WRITE_LONG_2"},
{0, NULL},
};
static const value_string iscsi_scsi_statuses[] = {
{0x00, "Good"},
{0x02, "Check condition"},
{0x04, "Condition good"},
{0x08, "Busy"},
{0x10, "Intermediate good"},
{0x14, "Intermediate c good"},
{0x18, "Reservation conflict"},
{0x22, "Command terminated"},
{0x28, "Queue full"},
{0, NULL},
};
static const value_string iscsi_task_responses[] = {
{0, "Function complete"},
{1, "Task not in task set"},
@ -555,6 +488,53 @@ static guint32 crc32Table[256] = {
#define CRC32C_PRELOAD 0xffffffff
/*
* Hash Functions
*/
static gint
iscsi_equal(gconstpointer v, gconstpointer w)
{
iscsi_conv_key_t *v1 = (iscsi_conv_key_t *)v;
iscsi_conv_key_t *v2 = (iscsi_conv_key_t *)w;
return (v1->conv_idx == v2->conv_idx);
}
static guint
iscsi_hash (gconstpointer v)
{
iscsi_conv_key_t *key = (iscsi_conv_key_t *)v;
guint val;
val = key->conv_idx;
return val;
}
/*
* Protocol initialization
*/
static void
iscsi_init_protocol(void)
{
if (iscsi_req_keys)
g_mem_chunk_destroy(iscsi_req_keys);
if (iscsi_req_vals)
g_mem_chunk_destroy(iscsi_req_vals);
if (iscsi_req_hash)
g_hash_table_destroy(iscsi_req_hash);
iscsi_req_hash = g_hash_table_new(iscsi_hash, iscsi_equal);
iscsi_req_keys = g_mem_chunk_new("iscsi_req_keys",
sizeof(iscsi_conv_key_t),
iscsi_init_count * sizeof(iscsi_conv_key_t),
G_ALLOC_AND_FREE);
iscsi_req_vals = g_mem_chunk_new("iscsi_req_vals",
sizeof(iscsi_conv_data_t),
iscsi_init_count * sizeof(iscsi_conv_data_t),
G_ALLOC_AND_FREE);
}
static guint32
calculateCRC32(const void *buf, int len, guint32 crc) {
guint8 *p = (guint8 *)buf;
@ -678,52 +658,99 @@ handleDataSegmentAsTextKeys(proto_item *ti, tvbuff_t *tvb, guint offset, guint d
/* Code to actually dissect the packets */
static void
dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint offset, guint8 opcode, const char *opcode_str, guint32 data_segment_len) {
guint original_offset = offset;
proto_item *ti;
char *scsi_command_name = NULL;
guint8 scsi_status = 0;
guint cdb_offset = offset + 32; /* offset of CDB from start of PDU */
guint end_offset = offset + tvb_length_remaining(tvb, offset);
guint32 del_usecs = 0;
conversation_t *conversation = NULL;
iscsi_conv_data_t *cdata = NULL;
iscsi_conv_key_t ckey, *req_key;
/* Make entries in Protocol column and Info column on summary display */
if (check_col(pinfo->cinfo, COL_PROTOCOL))
col_set_str(pinfo->cinfo, COL_PROTOCOL, "iSCSI");
if (opcode == ISCSI_OPCODE_SCSI_RESPONSE) {
scsi_status = tvb_get_guint8 (tvb, offset+3);
}
if ((opcode == ISCSI_OPCODE_SCSI_RESPONSE) ||
(opcode == ISCSI_OPCODE_SCSI_DATA_IN) ||
(opcode == ISCSI_OPCODE_SCSI_DATA_OUT)) {
conversation = find_conversation (&pinfo->src, &pinfo->dst,
pinfo->ptype, pinfo->srcport,
pinfo->destport, 0);
if (conversation) {
ckey.conv_idx = conversation->index;
ckey.itt = tvb_get_ntohl (tvb, offset+16);
cdata = (iscsi_conv_data_t *)g_hash_table_lookup (iscsi_req_hash,
&ckey);
}
pinfo->private_data = cdata;
if (cdata) {
del_usecs = (pinfo->fd->abs_secs - cdata->abs_secs)* 1000000 +
(pinfo->fd->abs_usecs - cdata->abs_usecs);
}
}
else if (opcode == ISCSI_OPCODE_SCSI_COMMAND) {
conversation = find_conversation (&pinfo->src, &pinfo->dst,
pinfo->ptype, pinfo->srcport,
pinfo->destport, 0);
if (!conversation) {
conversation = conversation_new (&pinfo->src, &pinfo->dst,
pinfo->ptype, pinfo->srcport,
pinfo->destport, 0);
}
ckey.conv_idx = conversation->index;
ckey.itt = tvb_get_ntohl (tvb, offset+16);
cdata = (iscsi_conv_data_t *)g_hash_table_lookup (iscsi_req_hash,
&ckey);
if (cdata) {
/* Since we never free the memory used by an exchange, this maybe a
* case of another request using the same exchange as a previous
* req.
*/
cdata->abs_usecs = pinfo->fd->abs_usecs;
cdata->abs_secs = pinfo->fd->abs_secs;
/* The SCSI protocol uses this as the key to detect a
* SCSI-level conversation. */
}
else {
req_key = g_mem_chunk_alloc (iscsi_req_keys);
req_key->conv_idx = conversation->index;
req_key->itt = tvb_get_ntohl (tvb, offset+16);
cdata = g_mem_chunk_alloc (iscsi_req_vals);
cdata->abs_usecs = pinfo->fd->abs_usecs;
cdata->abs_secs = pinfo->fd->abs_secs;
g_hash_table_insert (iscsi_req_hash, req_key, cdata);
/* The SCSI protocol uses this as the key to detect a
* SCSI-level conversation. */
}
pinfo->private_data = cdata;
}
else {
pinfo->private_data = NULL;
}
if (check_col(pinfo->cinfo, COL_INFO)) {
col_append_str(pinfo->cinfo, COL_INFO, (char *)opcode_str);
if((opcode & ~(X_BIT | I_BIT)) == ISCSI_OPCODE_SCSI_COMMAND) {
/* SCSI Command */
guint8 cdb0 = tvb_get_guint8(tvb, cdb_offset);
scsi_command_name = match_strval(cdb0, iscsi_scsi_cdb0);
if(cdb0 == 0x08 || cdb0 == 0x0a) {
/* READ_6 and WRITE_6 */
guint lba = tvb_get_ntohl(tvb, cdb_offset) & 0x1fffff;
guint len = tvb_get_guint8(tvb, cdb_offset + 4);
col_append_fstr(pinfo->cinfo, COL_INFO, " (%s LBA 0x%06x len 0x%02x)", scsi_command_name, lba, len);
}
else if(cdb0 == 0x28 || cdb0 == 0x2a) {
/* READ_10 and WRITE_10 */
guint lba = tvb_get_ntohl(tvb, cdb_offset + 2);
guint len = tvb_get_ntohs(tvb, cdb_offset + 7);
col_append_fstr(pinfo->cinfo, COL_INFO, " (%s LBA 0x%08x len 0x%04x)", scsi_command_name, lba, len);
}
else if(scsi_command_name != NULL)
col_append_fstr(pinfo->cinfo, COL_INFO, " (%s)", scsi_command_name);
}
else if(opcode == ISCSI_OPCODE_SCSI_RESPONSE) {
/* SCSI Command Response */
const char *blurb = NULL;
/* look at response byte */
if(tvb_get_guint8(tvb, offset + 2) == 0) {
/* command completed at target */
blurb = match_strval(tvb_get_guint8(tvb, offset + 3), iscsi_scsi_statuses);
}
else
blurb = "Target Failure";
if(blurb != NULL)
col_append_fstr(pinfo->cinfo, COL_INFO, " (%s)", blurb);
}
if (opcode != ISCSI_OPCODE_SCSI_COMMAND) {
col_append_str(pinfo->cinfo, COL_INFO, (char *)opcode_str);
}
if (opcode == ISCSI_OPCODE_SCSI_RESPONSE) {
col_append_fstr (pinfo->cinfo, COL_INFO, " %s",
val_to_str (scsi_status, scsi_status_val, "0x%x"));
}
}
/* In the interest of speed, if "tree" is NULL, don't do any
@ -774,7 +801,7 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off
else if(opcode == ISCSI_OPCODE_SCSI_COMMAND) {
/* SCSI Command */
guint32 ahsLen = tvb_get_guint8(tvb, offset + 4) * 4;
{
{
gint b = tvb_get_guint8(tvb, offset + 1);
proto_item *tf = proto_tree_add_uint(ti, hf_iscsi_Flags, tvb, offset + 1, 1, b);
proto_tree *tt = proto_item_add_subtree(tf, ett_iscsi_Flags);
@ -793,32 +820,6 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off
proto_tree_add_item(ti, hf_iscsi_CmdSN, tvb, offset + 24, 4, FALSE);
proto_tree_add_item(ti, hf_iscsi_ExpStatSN, tvb, offset + 28, 4, FALSE);
{
/* dissect a little of the CDB for the most common
* commands */
guint8 cdb0 = tvb_get_guint8(tvb, cdb_offset);
gint cdb_len = 16;
proto_item *tf;
/* FIXME - extended CDB */
if(scsi_command_name == NULL)
scsi_command_name = match_strval(cdb0, iscsi_scsi_cdb0);
if(cdb0 == 0x08 || cdb0 == 0x0a) {
/* READ_6 and WRITE_6 */
guint lba = tvb_get_ntohl(tvb, cdb_offset) & 0x1fffff;
guint len = tvb_get_guint8(tvb, cdb_offset + 4);
tf = proto_tree_add_uint_format(ti, hf_iscsi_SCSICommand_CDB0, tvb, cdb_offset, cdb_len, cdb0, "CDB: %s LBA 0x%06x len 0x%02x", scsi_command_name, lba, len);
}
else if(cdb0 == 0x28 || cdb0 == 0x2a) {
/* READ_10 and WRITE_10 */
guint lba = tvb_get_ntohl(tvb, cdb_offset + 2);
guint len = tvb_get_ntohs(tvb, cdb_offset + 7);
tf = proto_tree_add_uint_format(ti, hf_iscsi_SCSICommand_CDB0, tvb, cdb_offset, cdb_len, cdb0, "CDB: %s LBA 0x%08x len 0x%04x", scsi_command_name, lba, len);
}
else
tf = proto_tree_add_uint(ti, hf_iscsi_SCSICommand_CDB0, tvb, cdb_offset, cdb_len, cdb0);
{
proto_tree *tt = proto_item_add_subtree(tf, ett_iscsi_CDB);
proto_tree_add_item(tt, hf_iscsi_SCSICommand_CDB, tvb, cdb_offset, cdb_len, FALSE);
}
if(ahsLen > 0) {
/* FIXME - disssect AHS? */
proto_tree_add_item(ti, hf_iscsi_AHS, tvb, offset + 48, ahsLen, FALSE);
@ -829,6 +830,16 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off
}
else if(opcode == ISCSI_OPCODE_SCSI_RESPONSE) {
/* SCSI Response */
if (del_usecs) {
if (del_usecs > 1000)
proto_tree_add_text (ti, tvb, offset, 0,
"Cmd Response Time: %d msecs",
del_usecs/1000);
else
proto_tree_add_text (ti, tvb, offset, 0,
"Cmd Response Time: %d usecs",
del_usecs);
}
{
gint b = tvb_get_guint8(tvb, offset + 1);
proto_item *tf = proto_tree_add_uint(ti, hf_iscsi_Flags, tvb, offset + 1, 1, b);
@ -850,7 +861,6 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off
proto_tree_add_item(ti, hf_iscsi_ExpDataSN, tvb, offset + 36, 4, FALSE);
proto_tree_add_item(ti, hf_iscsi_SCSIResponse_BidiReadResidualCount, tvb, offset + 44, 4, FALSE);
offset = handleHeaderDigest(ti, tvb, offset, 48);
offset = handleDataSegment(ti, tvb, offset, data_segment_len, end_offset, hf_iscsi_sense_data);
}
else if(opcode == ISCSI_OPCODE_TASK_MANAGEMENT_FUNCTION) {
/* Task Management Function */
@ -993,7 +1003,6 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off
proto_tree_add_item(ti, hf_iscsi_DataSN, tvb, offset + 36, 4, FALSE);
proto_tree_add_item(ti, hf_iscsi_BufferOffset, tvb, offset + 40, 4, FALSE);
offset = handleHeaderDigest(ti, tvb, offset, 48);
offset = handleDataSegment(ti, tvb, offset, data_segment_len, end_offset, hf_iscsi_write_data);
}
else if(opcode == ISCSI_OPCODE_SCSI_DATA_IN) {
/* SCSI Data In (read) */
@ -1017,7 +1026,6 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off
proto_tree_add_item(ti, hf_iscsi_DataSN, tvb, offset + 36, 4, FALSE);
proto_tree_add_item(ti, hf_iscsi_BufferOffset, tvb, offset + 40, 4, FALSE);
offset = handleHeaderDigest(ti, tvb, offset, 48);
offset = handleDataSegment(ti, tvb, offset, data_segment_len, end_offset, hf_iscsi_read_data);
}
else if(opcode == ISCSI_OPCODE_LOGOUT_COMMAND) {
/* Logout Command */
@ -1095,6 +1103,36 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off
proto_item_set_len(ti, offset - original_offset);
}
if((opcode & ~(X_BIT | I_BIT)) == ISCSI_OPCODE_SCSI_COMMAND) {
/* SCSI Command */
dissect_scsi_cdb (tvb, pinfo, tree, cdb_offset, 16);
}
else if (opcode == ISCSI_OPCODE_SCSI_RESPONSE) {
if (scsi_status == 0x2) {
/* A SCSI response with Check Condition contains sense data */
/* offset is setup correctly by the iscsi code for response above */
dissect_scsi_snsinfo (tvb, pinfo, tree, offset,
iscsi_min (data_segment_len,
end_offset-offset));
}
else {
dissect_scsi_rsp (tvb, pinfo, tree);
}
if (cdata && tree) {
/* destroy the data structures for this SCSI task */
#if 0
g_mem_chunk_free (iscsi_req_vals, cdata);
g_hash_table_remove (iscsi_req_hash, &ckey);
pinfo->private_data = NULL;
#endif
}
}
else if ((opcode == ISCSI_OPCODE_SCSI_DATA_IN) ||
(opcode == ISCSI_OPCODE_SCSI_DATA_OUT)) {
/* offset is setup correctly by the iscsi code for response above */
dissect_scsi_payload (tvb, pinfo, tree, offset, FALSE,
iscsi_min (data_segment_len, end_offset-offset));
}
}
static gboolean
@ -1281,11 +1319,6 @@ proto_register_iscsi(void)
FT_BYTES, BASE_HEX, NULL, 0,
"Immediate Data", HFILL }
},
{ &hf_iscsi_sense_data,
{ "SenseData", "iscsi.sensedata",
FT_BYTES, BASE_HEX, NULL, 0,
"Sense Data", HFILL }
},
{ &hf_iscsi_write_data,
{ "WriteData", "iscsi.writedata",
FT_BYTES, BASE_HEX, NULL, 0,
@ -1406,16 +1439,6 @@ proto_register_iscsi(void)
FT_UINT32, BASE_HEX, NULL, 0,
"Next expected status sequence number", HFILL }
},
{ &hf_iscsi_SCSICommand_CDB,
{ "CDB", "iscsi.scsicommand.cdb",
FT_BYTES, BASE_HEX, NULL, 0,
"SCSI CDB", HFILL }
},
{ &hf_iscsi_SCSICommand_CDB0,
{ "CDB", "iscsi.scsicommand.cdb0",
FT_UINT8, BASE_HEX, VALS(iscsi_scsi_cdb0), 0,
"SCSI CDB[0]", HFILL }
},
{ &hf_iscsi_SCSIResponse_ResidualCount,
{ "ResidualCount", "iscsi.scsiresponse.residualcount",
FT_UINT32, BASE_HEX, NULL, 0,
@ -1458,7 +1481,7 @@ proto_register_iscsi(void)
},
{ &hf_iscsi_SCSIResponse_Status,
{ "Status", "iscsi.scsiresponse.status",
FT_UINT8, BASE_HEX, VALS(iscsi_scsi_statuses), 0,
FT_UINT8, BASE_HEX, VALS(scsi_status_val), 0,
"SCSI command status value", HFILL }
},
{ &hf_iscsi_SCSIResponse_Response,
@ -1697,7 +1720,8 @@ proto_register_iscsi(void)
* subtrees used */
proto_register_field_array(proto_iscsi, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_init_routine (&iscsi_init_protocol);
{
module_t *iscsi_module = prefs_register_protocol(proto_iscsi, NULL);

2485
packet-scsi.c Normal file
View File

File diff suppressed because it is too large Load Diff

960
packet-scsi.h Normal file
View File

@ -0,0 +1,960 @@
/* packet-scsi.h
* Author: Dinesh G Dutt (ddutt@cisco.com)
*
* $Id: packet-scsi.h,v 1.1 2002/01/10 01:28:43 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
* Copyright 2002 Gerald Combs
*
* 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
* of the License, 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.
*/
#ifndef __PACKET_SCSI_H_
#define __PACKET_SCSI_H_
typedef guint32 scsi_cmnd_type;
typedef guint32 scsi_device_type;
/* Valid SCSI Device Types */
#define SCSI_CMND_SPC2 1
#define SCSI_CMND_SBC2 2
#define SCSI_CMND_SSC2 3
/* SPC-2 Commands */
#define SCSI_SPC2_INQUIRY 0x12
#define SCSI_SPC2_EXTCOPY 0x83
#define SCSI_SPC2_LOGSELECT 0x4C
#define SCSI_SPC2_LOGSENSE 0x4D
#define SCSI_SPC2_MODESELECT6 0x15
#define SCSI_SPC2_MODESELECT10 0x55
#define SCSI_SPC2_MODESENSE6 0x1A
#define SCSI_SPC2_MODESENSE10 0x5A
#define SCSI_SPC2_PERSRESVIN 0x5E
#define SCSI_SPC2_PERSRESVOUT 0x5F
#define SCSI_SPC2_PREVMEDREMOVAL 0x1E
#define SCSI_SPC2_READBUFFER 0x3C
#define SCSI_SPC2_RCVCOPYRESULTS 0x84
#define SCSI_SPC2_RCVDIAGRESULTS 0x1C
#define SCSI_SPC2_RELEASE6 0x17
#define SCSI_SPC2_RELEASE10 0x57
#define SCSI_SPC2_REPORTDEVICEID 0xA3
#define SCSI_SPC2_REPORTLUNS 0xA0
#define SCSI_SPC2_REQSENSE 0x03
#define SCSI_SPC2_RESERVE6 0x16
#define SCSI_SPC2_RESERVE10 0x56
#define SCSI_SPC2_SENDDIAG 0x1D
#define SCSI_SPC2_SETDEVICEID 0xA4
#define SCSI_SPC2_TESTUNITRDY 0x00
#define SCSI_SPC2_WRITEBUFFER 0x3B
static const value_string scsi_spc2_val[] = {
{SCSI_SPC2_EXTCOPY , "Extended Copy"},
{SCSI_SPC2_INQUIRY , "Inquiry"},
{SCSI_SPC2_LOGSELECT , "Log Select"},
{SCSI_SPC2_LOGSENSE , "Log Sense"},
{SCSI_SPC2_MODESELECT6 , "Mode Select (6)"},
{SCSI_SPC2_MODESELECT10 , "Mode Select (10)"},
{SCSI_SPC2_MODESENSE6 , "Mode Sense (6)"},
{SCSI_SPC2_MODESENSE10 , "Mode Sense (10)"},
{SCSI_SPC2_PERSRESVIN , "Persistent Reserve In"},
{SCSI_SPC2_PERSRESVOUT , "Persistent Reserve Out"},
{SCSI_SPC2_PREVMEDREMOVAL , "Prevent Allow Medium Removal"},
{SCSI_SPC2_RCVCOPYRESULTS , "Receive Copy Results"},
{SCSI_SPC2_RCVDIAGRESULTS , "Receive Diagnostics Results"},
{SCSI_SPC2_READBUFFER , "Read Buffer"},
{SCSI_SPC2_RELEASE6 , "Release (6)"},
{SCSI_SPC2_RELEASE10 , "Release (10)"},
{SCSI_SPC2_REPORTDEVICEID , "Report Device ID"},
{SCSI_SPC2_REPORTLUNS , "Report LUNs"},
{SCSI_SPC2_REQSENSE , "Request Sense"},
{SCSI_SPC2_RESERVE6 , "Reserve (6)"},
{SCSI_SPC2_RESERVE10 , "Reserve (10)"},
{SCSI_SPC2_TESTUNITRDY , "Test Unit Ready"},
{SCSI_SPC2_WRITEBUFFER , "Write Buffer"},
{0, NULL},
};
/* SBC-2 Commands */
#define SCSI_SBC2_FORMATUNIT 0x04
#define SCSI_SBC2_LOCKUNLKCACHE10 0x36
#define SCSI_SPC2_LOCKUNLKCACHE16 0x92
#define SCSI_SBC2_PREFETCH10 0x34
#define SCSI_SBC2_PREFETCH16 0x90
#define SCSI_SBC2_READ6 0x08
#define SCSI_SBC2_READ10 0x28
#define SCSI_SBC2_READ12 0xA8
#define SCSI_SBC2_READ16 0x88
#define SCSI_SBC2_READCAPACITY 0x25
#define SCSI_SBC2_READDEFDATA10 0x37
#define SCSI_SBC2_READDEFDATA12 0xB7
#define SCSI_SBC2_READLONG 0x3E
#define SCSI_SBC2_REASSIGNBLKS 0x07
#define SCSI_SBC2_REBUILD16 0x81
#define SCSI_SBC2_REBUILD32 0x7F
#define SCSI_SBC2_REGENERATE16 0x82
#define SCSI_SBC2_REGENERATE32 0x7F
#define SCSI_SBC2_SEEK10 0x2B
#define SCSI_SBC2_SETLIMITS10 0x33
#define SCSI_SBC2_SETLIMITS12 0xB3
#define SCSI_SBC2_STARTSTOPUNIT 0x1B
#define SCSI_SBC2_SYNCCACHE10 0x35
#define SCSI_SBC2_SYNCCACHE16 0x91
#define SCSI_SBC2_VERIFY10 0x2F
#define SCSI_SBC2_VERIFY12 0xAF
#define SCSI_SBC2_VERIFY16 0x8F
#define SCSI_SBC2_WRITE6 0x0A
#define SCSI_SBC2_WRITE10 0x2A
#define SCSI_SBC2_WRITE12 0xAA
#define SCSI_SBC2_WRITE16 0x8A
#define SCSI_SBC2_WRITENVERIFY10 0x2E
#define SCSI_SBC2_WRITENVERIFY12 0xAE
#define SCSI_SBC2_WRITENVERIFY16 0x8E
#define SCSI_SBC2_WRITELONG 0x3F
#define SCSI_SBC2_WRITESAME10 0x41
#define SCSI_SBC2_WRITESAME16 0x93
#define SCSI_SBC2_XDREAD10 0x52
#define SCSI_SBC2_XDREAD32 0x7F
#define SCSI_SBC2_XDWRITE10 0x50
#define SCSI_SBC2_XDWRITE32 0x7F
#define SCSI_SBC2_XDWRITEREAD10 0x53
#define SCSI_SBC2_XDWRITEREAD32 0x7F
#define SCSI_SBC2_XDWRITEEXTD16 0x80
#define SCSI_SBC2_XDWRITEEXTD32 0x7F
#define SCSI_SBC2_XPWRITE10 0x51
#define SCSI_SBC2_XPWRITE32 0x7F
static const value_string scsi_sbc2_val[] = {
{SCSI_SBC2_FORMATUNIT , "Format Unit"},
{SCSI_SBC2_LOCKUNLKCACHE10, "Lock Unlock Cache (10)"},
{SCSI_SPC2_LOCKUNLKCACHE16, "Lock Unlock Cache (16)"},
{SCSI_SBC2_PREFETCH10, "Pre-Fetch (10)"},
{SCSI_SBC2_PREFETCH16, "Pre-Fetch (16)"},
{SCSI_SBC2_READ6 , "Read (6)"},
{SCSI_SBC2_READ10 , "Read (10)"},
{SCSI_SBC2_READ12 , "Read (12)"},
{SCSI_SBC2_READ16 , "Read (16)"},
{SCSI_SBC2_READCAPACITY , "Read Capacity"},
{SCSI_SBC2_READDEFDATA10 , "Read Defect Data (10)"},
{SCSI_SBC2_READDEFDATA12 , "Read Defect Data (12)"},
{SCSI_SBC2_READLONG, "Read Long"},
{SCSI_SBC2_REASSIGNBLKS , "Reassign Blocks"},
{SCSI_SBC2_REBUILD16, "Rebuild (16)"},
{SCSI_SBC2_REBUILD32, "Rebuild (32)"},
{SCSI_SBC2_REGENERATE16, "Regenerate (16)"},
{SCSI_SBC2_REGENERATE32, "Regenerate (32)"},
{SCSI_SBC2_SEEK10, "Seek (10)"},
{SCSI_SBC2_SETLIMITS10, "Set Limits (10)"},
{SCSI_SBC2_SETLIMITS12, "Set Limits (12)"},
{SCSI_SBC2_STARTSTOPUNIT, "Start Stop Unit"},
{SCSI_SBC2_SYNCCACHE10, "Synchronize Cache (10)"},
{SCSI_SBC2_SYNCCACHE16, "Synchronize Cache (16)"},
{SCSI_SBC2_VERIFY10, "Verify (10)"},
{SCSI_SBC2_VERIFY12, "Verify (12)"},
{SCSI_SBC2_VERIFY16, "Verify (16)"},
{SCSI_SBC2_WRITE6 , "Write (6)"},
{SCSI_SBC2_WRITE10 , "Write (10)"},
{SCSI_SBC2_WRITE12 , "Write (12)"},
{SCSI_SBC2_WRITE16 , "Write (16)"},
{SCSI_SBC2_WRITENVERIFY10, "Write & Verify (10)"},
{SCSI_SBC2_WRITENVERIFY12, "Write & Verify (12)"},
{SCSI_SBC2_WRITENVERIFY16, "Write & Verify (16)"},
{SCSI_SBC2_WRITELONG, "Write Long"},
{SCSI_SBC2_WRITESAME10, "Write Same (10)"},
{SCSI_SBC2_WRITESAME16, "Write Same (16)"},
{SCSI_SBC2_XDREAD10, "XdRead (10)"},
{SCSI_SBC2_XDREAD32, "XdRead (32)"},
{SCSI_SBC2_XDWRITE10, "XdWrite (10)"},
{SCSI_SBC2_XDWRITE32, "XdWrite(32)"},
{SCSI_SBC2_XDWRITEREAD10, "XdWriteRead (10)"},
{SCSI_SBC2_XDWRITEREAD32, "XdWriteRead (32)"},
{SCSI_SBC2_XDWRITEEXTD16, "XdWrite Extended (16)"},
{SCSI_SBC2_XDWRITEEXTD32, "XdWrite Extended (32)"},
{SCSI_SBC2_XPWRITE10, "XpWrite (10)"},
{SCSI_SBC2_XPWRITE32, "XpWrite (32)"},
{0, NULL},
};
/* SSC2 Commands */
#define SCSI_SSC2_ERASE_16 0x93
#define SCSI_SSC2_FORMAT_MEDIUM 0x04
#define SCSI_SSC2_LOAD_UNLOAD 0x1B
#define SCSI_SSC2_LOCATE_16 0x92
#define SCSI_SSC2_MOVE_MEDIUM 0xA5
#define SCSI_SSC2_MOVE_MEDIUM_ATTACHED 0xA7
#define SCSI_SSC2_READ_16 0x88
#define SCSI_SSC2_READ_BLOCK_LIMITS 0x05
#define SCSI_SSC2_READ_ELEMENT_STATUS 0xB8
#define SCSI_SSC2_READ_ELEMENT_STATUS_ATTACHED 0xB4
#define SCSI_SSC2_READ_POSITION 0x34
#define SCSI_SSC2_READ_REVERSE_16 0x81
#define SCSI_SSC2_RECOVER_BUFFERED_DATA 0x14
#define SCSI_SSC2_REPORT_DENSITY_SUPPORT 0x44
#define SCSI_SSC2_REWIND 0x01
#define SCSI_SSC2_SET_CAPACITY 0x0B
#define SCSI_SSC2_SPACE_16 0x91
#define SCSI_SSC2_VERIFY_16 0x8F
#define SCSI_SSC2_WRITE_16 0x8A
#define SCSI_SSC2_WRITE_FILEMARKS_16 0x80
#define SCSI_SSC2_ERASE_6 0x19
#define SCSI_SSC2_LOCATE_10 0x2B
#define SCSI_SSC2_LOCATE_16 0x92
#define SCSI_SSC2_READ_6 0x08
#define SCSI_SSC2_READ_REVERSE_6 0x0F
#define SCSI_SSC2_SPACE_6 0x11
#define SCSI_SSC2_VERIFY_6 0x13
#define SCSI_SSC2_WRITE_6 0x0A
#define SCSI_SSC2_WRITE_FILEMARKS_6 0x10
static const value_string scsi_ssc2_val[] = {
{SCSI_SSC2_ERASE_16 , "Erase(16)"},
{SCSI_SSC2_FORMAT_MEDIUM , "Format Medium"},
{SCSI_SSC2_LOAD_UNLOAD , "Load Unload"},
{SCSI_SSC2_LOCATE_16 , "Locate(16)"},
{SCSI_SSC2_MOVE_MEDIUM , "Move Medium"},
{SCSI_SSC2_MOVE_MEDIUM_ATTACHED , "Move Medium Attached"},
{SCSI_SSC2_READ_16 , "Read(16)"},
{SCSI_SSC2_READ_BLOCK_LIMITS , "Read Block Limits"},
{SCSI_SSC2_READ_ELEMENT_STATUS , "Read Element Status"},
{SCSI_SSC2_READ_ELEMENT_STATUS_ATTACHED, "Read Element Status Attached"},
{SCSI_SSC2_READ_POSITION , "Read Position"},
{SCSI_SSC2_READ_REVERSE_16 , "Read Reverse(16)"},
{SCSI_SSC2_RECOVER_BUFFERED_DATA , "Recover Buffered Data"},
{SCSI_SSC2_REPORT_DENSITY_SUPPORT , "Report Density Support"},
{SCSI_SSC2_REWIND , "Rewind"},
{SCSI_SSC2_SET_CAPACITY , "Set Capacity"},
{SCSI_SSC2_SPACE_16 , "Space(16)"},
{SCSI_SSC2_VERIFY_16 , "Verify(16)"},
{SCSI_SSC2_WRITE_16 , "Write(16)"},
{SCSI_SSC2_WRITE_FILEMARKS_16 , "Write Filemarks(16)"},
{SCSI_SSC2_ERASE_6 , "Erase(6)"},
{SCSI_SSC2_LOCATE_10 , "Locate(10)"},
{SCSI_SSC2_LOCATE_16 , "Locate(16)"},
{SCSI_SSC2_READ_6 , "Read(6)"},
{SCSI_SSC2_READ_REVERSE_6 , "Read Reverse(6)"},
{SCSI_SSC2_SPACE_6 , "Space(6)"},
{SCSI_SSC2_VERIFY_6 , "Verify(6)"},
{SCSI_SSC2_WRITE_6 , "Write(6)"},
{SCSI_SSC2_WRITE_FILEMARKS_6 , "Write Filemarks(6)"},
};
static const value_string scsi_evpd_pagecode_val[] = {
{0x00, "Supported Vital Data Product Pages"},
{0x80, "Unit Serial Number Page"},
{0x82, "ASCII Implemented Operating Definition Page"},
{0x01, "ASCII Information Page"},
{0x02, "ASCII Information Page"},
{0x03, "ASCII Information Page"},
{0x04, "ASCII Information Page"},
{0x05, "ASCII Information Page"},
{0x06, "ASCII Information Page"},
{0x07, "ASCII Information Page"},
{0x83, "Device Identification Page"},
{0, NULL},
};
static const value_string scsi_logsel_pc_val[] = {
{0, "Current Threshold Values"},
{1, "Current Cumulative Values"},
{2, "Default Threshold Values"},
{3, "Default Cumulative Values"},
{0, NULL},
};
static const value_string scsi_logsns_pc_val[] = {
{0, "Threshold Values"},
{1, "Cumulative Values"},
{2, "Default Threshold Values"},
{3, "Default Cumulative Values"},
{0, NULL},
};
static const value_string scsi_logsns_page_val[] = {
{0xF, "Application Client Page"},
{0x1, "Buffer Overrun/Underrun Page"},
{0x3, "Error Counter (read) Page"},
{0x4, "Error Counter (read reverse) Page"},
{0x5, "Error Counter (verify) Page"},
{0x1, "Error Counter (write) Page"},
{0xB, "Last n Deferred Errors or Async Events Page"},
{0x7, "Last n Error Events Page"},
{0x6, "Non-medium Error Page"},
{0x10, "Self-test Results Page"},
{0xE, "Start-Stop Cycle Counter Page"},
{0x0, "Supported Log Pages"},
{0xD, "Temperature Page"},
{0, NULL},
};
static const value_string scsi_modesns_pc_val[] = {
{0, "Current Values"},
{1, "Changeable Values"},
{2, "Default Values"},
{3, "Saved Values"},
{0, NULL},
};
#define SCSI_MODEPAGE_VEND 0x0
#define SCSI_MODEPAGE_CTL 0x0A
#define SCSI_MODEPAGE_DISCON 0x02
#define SCSI_MODEPAGE_INFOEXCP 0x1C
#define SCSI_MODEPAGE_PWR 0x1A
#define SCSI_MODEPAGE_LUN 0x18
#define SCSI_MODEPAGE_PORT 0x19
#define SCSI_MODEPAGE_RDWRERR 0x01
#define SCSI_MODEPAGE_FMTDEV 0x03
#define SCSI_MODEPAGE_DISKGEOM 0x04
#define SCSI_MODEPAGE_FLEXDISK 0x05
#define SCSI_MODEPAGE_VERERR 0x07
#define SCSI_MODEPAGE_CACHE 0x08
#define SCSI_MODEPAGE_PERDEV 0x09
#define SCSI_MODEPAGE_MEDTYPE 0x0B
#define SCSI_MODEPAGE_NOTPART 0x0C
#define SCSI_MODEPAGE_XORCTL 0x10
static const value_string scsi_modesns_page_val[] = {
{0, "Vendor Specific Page"},
{0x0A, "Control"},
{0x02, "Disconnect-Reconnect"},
{0x1C, "Informational Exceptions Control"},
{0x1A, "Power Condition"},
{0x18, "Protocol Specific LUN"},
{0x19, "Protocol-Specific Port"},
{0x01, "Read/Write Error Recovery"},
{0x03, "Format Device"},
{0x04, "Rigid Disk Geometry"},
{0x05, "Flexible Disk"},
{0x07, "Verify Error Recovery"},
{0x08, "Caching"},
{0x09, "Peripheral Device"},
{0x0B, "Medium Types Supported"},
{0x0C, "Notch & Partition"},
{0x10, "XOR Control"},
{0x3F, "Return All Mode Pages"},
{0, NULL},
};
#define SCSI_SPC2_RESVIN_SVCA_RDKEYS 0
#define SCSI_SPC2_RESVIN_SVCA_RDRESV 1
static const value_string scsi_persresvin_svcaction_val[] = {
{SCSI_SPC2_RESVIN_SVCA_RDKEYS, "Read Keys"},
{SCSI_SPC2_RESVIN_SVCA_RDRESV, "Read Reservation"},
{0, NULL},
};
static const value_string scsi_persresvout_svcaction_val[] = {
{0, "Register"},
{1, "Reserve"},
{2, "Release"},
{3, "Clear"},
{4, "Preempt"},
{5, "Preempt & Abort"},
{6, "Register & Ignore Existing Key"},
{0, NULL},
};
static const value_string scsi_persresv_scope_val[] = {
{0, "LU Scope"},
{1, "Obsolete"},
{2, "Element Scope"},
{0, NULL},
};
static const value_string scsi_persresv_type_val[] = {
{1, "Write Excl"},
{3, "Excl Access"},
{5, "Write Excl, Registrants Only"},
{7, "Excl Access, Registrants Only"},
{0, NULL},
};
/* SCSI Device Types */
#define SCSI_DEV_SBC 0x0
#define SCSI_DEV_SSC 0x1
#define SCSI_DEV_PRNT 0x2
#define SCSI_DEV_PROC 0x3
#define SCSI_DEV_WORM 0x4
#define SCSI_DEV_CDROM 0x5
#define SCSI_DEV_SCAN 0x6
#define SCSI_DEV_OPTMEM 0x7
#define SCSI_DEV_SMC 0x8
#define SCSI_DEV_COMM 0x9
#define SCSI_DEV_RAID 0xC
#define SCSI_DEV_SES 0xD
#define SCSI_DEV_RBC 0xE
#define SCSI_DEV_OCRW 0xF
#define SCSI_DEV_OSD 0x11
static const value_string scsi_devtype_val[] = {
{SCSI_DEV_SBC , "Direct Access Device"},
{SCSI_DEV_SSC , "Sequential Access Device"},
{SCSI_DEV_PRNT , "Printer"},
{SCSI_DEV_PROC , "Processor"},
{SCSI_DEV_WORM , "WORM"},
{SCSI_DEV_CDROM , "CD ROM"},
{SCSI_DEV_SCAN , "Scanner"},
{SCSI_DEV_OPTMEM, "Optical Memory"},
{SCSI_DEV_SMC , "Medium Changer"},
{SCSI_DEV_COMM , "Communication"},
{SCSI_DEV_RAID , "Storage Array"},
{SCSI_DEV_SES , "Enclosure Services"},
{SCSI_DEV_RBC , "Simplified Block Device"},
{SCSI_DEV_OCRW , "OCRW"},
{SCSI_DEV_OSD , "OSD"},
{0, NULL},
};
static const enum_val_t scsi_devtype_options[] = {
{"Block Device", SCSI_DEV_SBC},
{"Sequential Device", SCSI_DEV_SSC},
{NULL, -1},
};
static const value_string scsi_inquiry_vers_val[] = {
{0, "No Compliance to any Standard"},
{2, "Compliance to ANSI X3.131:1994"},
{3, "Compliance to ANSI X3.301:1997"},
{4, "Compliance to SPC-2"},
{0x80, "Compliance to ISO/IEC 9316:1995"},
{0x82, "Compliance to ISO/IEC 9316:1995 and to ANSI X3.131:1994"},
{0x83, "Compliance to ISO/IEC 9316:1995 and to ANSI X3.301:1997"},
{0x84, "Compliance to ISO/IEC 9316:1995 and SPC-2"},
{0, NULL},
};
static const value_string scsi_modesense_medtype_val[] = {
{0, "Default"},
{1, "Flexible Disk, Single-sided"},
{2, "Flexible Disk, Double-sided"},
{0, NULL},
};
static const value_string scsi_verdesc_val[] = {
{0x0d40, "FC-AL (No Version)"},
{0x0d5c, "FC-AL ANSI X3.272:1996"},
{0x0d60, "FC-AL-2 (no version claimed)"},
{0x0d7c, "FC-AL-2 ANSI NCITS.332:1999"},
{0x0d61, "FC-AL-2 T11/1133 revision 7.0"},
{0x1320, "FC-FLA (no version claimed)"},
{0x133c, "FC-FLA ANSI NCITS TR-20:1998"},
{0x133b, "FC-FLA T11/1235 revision 7"},
{0x0da0, "FC-FS (no version claimed)"},
{0x0db7, "FC-FS T11/1331 revision 1.2"},
{0x08c0, "FCP (no version claimed)"},
{0x08dc, "FCP ANSI X3.269:1996"},
{0x08db, "FCP T10/0993 revision 12"},
{0x1340, "FC-PLDA (no version claimed)"},
{0x135c, "FC-PLDA ANSI NCITS TR-19:1998"},
{0x135b, "FC-PLDA T11/1162 revision 2.1"},
{0x0900, "FCP-2 (no version claimed)"},
{0x0901, "FCP-2 T10/1144 revision 4"},
{0x003c, "SAM ANSI X3.270:1996"},
{0x003b, "SAM T10/0994 revision 18"},
{0x0040, "SAM-2 (no version claimed)"},
{0x0020, "SAM (no version claimed)"},
{0x0180, "SBC (no version claimed)"},
{0x019c, "SBC ANSI NCITS.306:1998"},
{0x019b, "SBC T10/0996 revision 08c"},
{0x0320, "SBC-2 (no version claimed)"},
{0x01c0, "SES (no version claimed)"},
{0x01dc, "SES ANSI NCITS.305:1998"},
{0x01db, "SES T10/1212 revision 08b"},
{0x01de, "SES ANSI NCITS.305:1998 w/ Amendment ANSI NCITS.305/AM1:2000"},
{0x01dd, "SES T10/1212 revision 08b w/ Amendment ANSI NCITS.305/AM1:2000"},
{0x0120, "SPC (no version claimed)"},
{0x013c, "SPC ANSI X3.301:1997"},
{0x013b, "SPC T10/0995 revision 11a"},
{0x0260, "SPC-2 (no version claimed)"},
{0x0267, "SPC-2 T10/1236 revision 12"},
{0x0269, "SPC-2 T10/1236 revision 18"},
{0x0300, "SPC-3 (no version claimed)"},
{0x0960, "iSCSI (no version claimed)"},
{0x0d80, "FC-PH-3 (no version claimed)"},
{0x0d9c, "FC-PH-3 ANSI X3.303-1998"},
{0x0d20, "FC-PH (no version claimed)"},
{0, NULL},
};
#define SCSI_EVPD_SUPPPG 0
#define SCSI_EVPD_ASCIIOPER 0x82
#define SCSI_EVPD_DEVID 0x83
#define SCSI_EVPD_DEVSERNUM 0x80
static const value_string scsi_inq_evpd_val[] = {
{SCSI_EVPD_SUPPPG, "Supported Vital Product Data Page"},
{SCSI_EVPD_ASCIIOPER, "ASCII Implemented Operating Definition Page"},
{SCSI_EVPD_DEVID, "Device ID Page"},
{SCSI_EVPD_DEVSERNUM, "Unit Serial Number Page"},
{0x0, NULL},
};
/* Command Support Data "Support" field definitions */
static const value_string scsi_cmdt_supp_val[] = {
{0, "Data not currently available"},
{1, "SCSI Command not supported"},
{2, "Reserved"},
{3, "SCSI Command supported in conformance with a SCSI standard"},
{4, "Vendor Specific"},
{5, "SCSI Command supported in a vendor specific manner"},
{6, "Vendor Specific"},
{7, "Reserved"},
{0, NULL},
};
static const value_string scsi_devid_codeset_val[] = {
{0, "Reserved"},
{1, "Identifier field contains binary values"},
{2, "Identifier field contains ASCII graphic codes"},
{0, NULL},
};
static const value_string scsi_devid_assoc_val[] = {
{0, "Identifier is associated with addressed logical/physical device"},
{1, "Identifier is associated with the port that received the request"},
{0, NULL},
};
static const value_string scsi_devid_idtype_val[] = {
{0, "Vendor-specific ID (non-globally unique)"},
{1, "Vendor-ID + vendor-specific ID (globally unique)"},
{2, "EUI-64 ID"},
{3, "WWN"},
{4, "4-byte Binary Number/Reserved"},
{0, NULL},
};
static const value_string scsi_modesns_mrie_val[] = {
{0, "No Reporting of Informational Exception Condition"},
{1, "Asynchronous Error Reporting"},
{2, "Generate Unit Attention"},
{3, "Conditionally Generate Recovered Error"},
{4, "Unconditionally Generate Recovered Error"},
{5, "Generate No Sense"},
{6, "Only Report Informational Exception Condition on Request"},
{0, NULL},
};
static const value_string scsi_modesns_tst_val[] = {
{0, "Task Set Per LU For All Initiators"},
{1, "Task Set Per Initiator Per LU"},
{0, NULL},
};
static const value_string scsi_modesns_qmod_val[] = {
{0, "Restricted reordering"},
{1, "Unrestricted reordering"},
{0, NULL},
};
static const true_false_string scsi_modesns_qerr_val = {
"All blocked tasks shall be aborted on CHECK CONDITION",
"Blocked tasks shall resume after ACA/CA is cleared",
};
static const true_false_string scsi_modesns_tas_val = {
"Terminated tasks aborted without informing initiators",
"Tasks aborted by another initiator terminated with TASK ABORTED",
};
static const true_false_string scsi_modesns_rac_val = {
"Report a CHECK CONDITION Instead of Long Busy Condition",
"Long Busy Conditions Maybe Reported",
};
/* SCSI Transport Protocols */
#define SCSI_PROTO_FCP 0
#define SCSI_PROTO_iSCSI 5
static const value_string scsi_proto_val[] = {
{0, "FCP"},
{5, "iSCSI"},
{0, NULL},
};
static const value_string scsi_fcp_rrtov_val[] = {
{0, "No Timer Specified"},
{1, "0.001 secs"},
{3, "0.1 secs"},
{5, "10 secs"},
{0, NULL},
};
static const value_string scsi_sensekey_val[] = {
{0x0, "No Sense"},
{0x1, "Recovered Error"},
{0x2, "Not Ready"},
{0x3, "Medium Error"},
{0x4, "Hardware Error"},
{0x5, "Illegal Request"},
{0x6, "Unit Attention"},
{0x7, "Data Protection"},
{0x8, "Blank Check"},
{0x9, "Vendor Specific"},
{0xA, "Copy Aborted"},
{0xB, "Command Aborted"},
{0xC, "Obsolete Error Code"},
{0xD, "Overflow Command"},
{0xE, "Miscompare"},
{0xF, "Reserved"},
{0, NULL},
};
static const value_string scsi_sns_errtype_val[] = {
{0x70, "Current Error"},
{0x71, "Deferred Error"},
{0x7F, "Vendor Specific"},
{0, NULL},
};
static const value_string scsi_asc_val[] = {
{0x0000, "No Additional Sense Information"},
{0x0006, "I/O Process Terminated"},
{0x0016, "Operation In Progress"},
{0x0017, "Cleaning Requested"},
{0x0100, "No Index/Sector Signal"},
{0x0200, "No Seek Complete"},
{0x0300, "Peripheral Device Write Fault"},
{0x0400, "Logical Unit Not Ready, Cause Not Reportable"},
{0x0401, "Logical Unit Is In Process Of Becoming Ready"},
{0x0402, "Logical Unit Not Ready, Initializing Cmd. Required"},
{0x0403, "Logical Unit Not Ready, Manual Intervention Required"},
{0x0404, "Logical Unit Not Ready, Format In Progress"},
{0x0405, "Logical Unit Not Ready, Rebuild In Progress"},
{0x0406, "Logical Unit Not Ready, Recalculation In Progress"},
{0x0407, "Logical Unit Not Ready, Operation In Progress"},
{0x0409, "Logical Unit Not Ready, Self-Test In Progress"},
{0x0500, "Logical Unit Does Not Respond To Selection"},
{0x0600, "No Reference Position Found"},
{0x0700, "Multiple Peripheral Devices Selected"},
{0x0800, "Logical Unit Communication Failure"},
{0x0801, "Logical Unit Communication Time-Out"},
{0x0802, "Logical Unit Communication Parity Error"},
{0x0803, "Logical Unit Communication Crc Error (Ultra-Dma/32)"},
{0x0804, "Unreachable Copy Target"},
{0x0900, "Track Following Error"},
{0x0904, "Head Select Fault"},
{0x0A00, "Error Log Overflow"},
{0x0B00, "Warning"},
{0x0B01, "Warning - Specified Temperature Exceeded"},
{0x0B02, "Warning - Enclosure Degraded"},
{0x0C02, "Write Error - Auto Reallocation Failed"},
{0x0C03, "Write Error - Recommend Reassignment"},
{0x0C04, "Compression Check Miscompare Error"},
{0x0C05, "Data Expansion Occurred During Compression"},
{0x0C06, "Block Not Compressible"},
{0x0D00, "Error Detected By Third Party Temporary Initiator"},
{0x0D01, "Third Party Device Failure"},
{0x0D02, "Copy Target Device Not Reachable"},
{0x0D03, "Incorrect Copy Target Device Type"},
{0x0D04, "Copy Target Device Data Underrun"},
{0x0D05, "Copy Target Device Data Overrun"},
{0x1000, "Id Crc Or Ecc Error"},
{0x1100, "Unrecovered Read Error"},
{0x1101, "Read Retries Exhausted"},
{0x1102, "Error Too Long To Correct"},
{0x1103, "Multiple Read Errors"},
{0x1104, "Unrecovered Read Error - Auto Reallocate Failed"},
{0x110A, "Miscorrected Error"},
{0x110B, "Unrecovered Read Error - Recommend Reassignment"},
{0x110C, "Unrecovered Read Error - Recommend Rewrite The Data"},
{0x110D, "De-Compression Crc Error"},
{0x110E, "Cannot Decompress Using Declared Algorithm"},
{0x1200, "Address Mark Not Found For Id Field"},
{0x1300, "Address Mark Not Found For Data Field"},
{0x1400, "Recorded Entity Not Found"},
{0x1401, "Record Not Found"},
{0x1405, "Record Not Found - Recommend Reassignment"},
{0x1406, "Record Not Found - Data Auto-Reallocated"},
{0x1500, "Random Positioning Error"},
{0x1501, "Mechanical Positioning Error"},
{0x1502, "Positioning Error Detected By Read Of Medium"},
{0x1600, "Data Synchronization Mark Error"},
{0x1601, "Data Sync Error - Data Rewritten"},
{0x1602, "Data Sync Error - Recommend Rewrite"},
{0x1603, "Data Sync Error - Data Auto-Reallocated"},
{0x1604, "Data Sync Error - Recommend Reassignment"},
{0x1700, "Recovered Data With No Error Correction Applied"},
{0x1701, "Recovered Data With Retries"},
{0x1702, "Recovered Data With Positive Head Offset"},
{0x1703, "Recovered Data With Negative Head Offset"},
{0x1705, "Recovered Data Using Previous Sector Id"},
{0x1706, "Recovered Data Without Ecc - Data Auto-Reallocated"},
{0x1707, "Recovered Data Without Ecc - Recommend Reassignment"},
{0x1708, "Recovered Data Without Ecc - Recommend Rewrite"},
{0x1709, "Recovered Data Without Ecc - Data Rewritten"},
{0x1800, "Recovered Data With Error Correction Applied"},
{0x1801, "Recovered Data With Error Corr. & Retries Applied"},
{0x1802, "Recovered Data - Data Auto-Reallocated"},
{0x1805, "Recovered Data - Recommend Reassignment"},
{0x1806, "Recovered Data - Recommend Rewrite"},
{0x1807, "Recovered Data With Ecc - Data Rewritten"},
{0x1900, "List Error"},
{0x1901, "List Not Available"},
{0x1902, "List Error In Primary List"},
{0x1903, "List Error In Grown List"},
{0x1A00, "Parameter List Length Error"},
{0x1B00, "Synchronous Data Transfer Error"},
{0x1C00, "Defect List Not Found"},
{0x1C01, "Primary Defect List Not Found"},
{0x1C02, "Grown Defect List Not Found"},
{0x1D00, "Miscompare During Verify Operation"},
{0x1E00, "Recovered Id With Ecc Correction"},
{0x1F00, "Defect List Transfer"},
{0x2000, "Invalid Command Operation Code"},
{0x2100, "Logical Block Address Out Of Range"},
{0x2101, "Invalid Element Address"},
{0x2400, "Invalid Field In Cdb"},
{0x2401, "Cdb Decryption Error"},
{0x2500, "Logical Unit Not Supported"},
{0x2600, "Invalid Field In Parameter List"},
{0x2601, "Parameter Not Supported"},
{0x2602, "Parameter Value Invalid"},
{0x2603, "Threshold Parameters Not Supported"},
{0x2604, "Invalid Release Of Persistent Reservation"},
{0x2605, "Data Decryption Error"},
{0x2606, "Too Many Target Descriptors"},
{0x2607, "Unsupported Target Descriptor Type Code"},
{0x2608, "Too Many Segment Descriptors"},
{0x2609, "Unsupported Segment Descriptor Type Code"},
{0x260A, "Unexpected Inexact Segment"},
{0x260B, "Inline Data Length Exceeded"},
{0x260C, "Invalid Operation For Copy Source Or Destination"},
{0x260D, "Copy Segment Granularity Violation"},
{0x2700, "Write Protected"},
{0x2701, "Hardware Write Protected"},
{0x2702, "Logical Unit Software Write Protected"},
{0x2800, "Not Ready To Ready Change, Medium May Have Changed"},
{0x2801, "Import Or Export Element Accessed"},
{0x2900, "Power On, Reset, Or Bus Device Reset Occurred"},
{0x2901, "Power On Occurred"},
{0x2902, "Scsi Bus Reset Occurred"},
{0x2903, "Bus Device Reset Function Occurred"},
{0x2904, "Device Internal Reset"},
{0x2905, "Transceiver Mode Changed To Single-Ended"},
{0x2906, "Transceiver Mode Changed To Lvd"},
{0x2A00, "Parameters Changed"},
{0x2A01, "Mode Parameters Changed"},
{0x2A02, "Log Parameters Changed"},
{0x2A03, "Reservations Preempted"},
{0x2A04, "Reservations Released"},
{0x2A05, "Registrations Preempted"},
{0x2B00, "Copy Cannot Execute Since Host Cannot Disconnect"},
{0x2C00, "Command Sequence Error"},
{0x2F00, "Commands Cleared By Another Initiator"},
{0x3000, "Incompatible Medium Installed"},
{0x3001, "Cannot Read Medium - Unknown Format"},
{0x3002, "Cannot Read Medium - Incompatible Format"},
{0x3003, "Cleaning Cartridge Installed"},
{0x3004, "Cannot Write Medium - Unknown Format"},
{0x3005, "Cannot Write Medium - Incompatible Format"},
{0x3006, "Cannot Format Medium - Incompatible Medium"},
{0x3007, "Cleaning Failure"},
{0x3100, "Medium Format Corrupted"},
{0x3101, "Format Command Failed"},
{0x3200, "No Defect Spare Location Available"},
{0x3201, "Defect List Update Failure"},
{0x3400, "Enclosure Failure"},
{0x3500, "Enclosure Services Failure"},
{0x3501, "Unsupported Enclosure Function"},
{0x3502, "Enclosure Services Unavailable"},
{0x3503, "Enclosure Services Transfer Failure"},
{0x3504, "Enclosure Services Transfer Refused"},
{0x3700, "Rounded Parameter"},
{0x3900, "Saving Parameters Not Supported"},
{0x3A00, "Medium Not Present"},
{0x3A01, "Medium Not Present - Tray Closed"},
{0x3A02, "Medium Not Present - Tray Open"},
{0x3A03, "Medium Not Present - Loadable"},
{0x3A04, "Medium Not Present - Medium Auxiliary Memory Accessible"},
{0x3B0D, "Medium Destination Element Full"},
{0x3B0E, "Medium Source Element Empty"},
{0x3B11, "Medium Magazine Not Accessible"},
{0x3B12, "Medium Magazine Removed"},
{0x3B13, "Medium Magazine Inserted"},
{0x3B14, "Medium Magazine Locked"},
{0x3B15, "Medium Magazine Unlocked"},
{0x3D00, "Invalid Bits In Identify Message"},
{0x3E00, "Logical Unit Has Not Self-Configured Yet"},
{0x3E01, "Logical Unit Failure"},
{0x3E02, "Timeout On Logical Unit"},
{0x3E03, "Logical Unit Failed Self-Test"},
{0x3E04, "Logical Unit Unable To Update Self-Test Log"},
{0x3F00, "Target Operating Conditions Have Changed"},
{0x3F01, "Microcode Has Been Changed"},
{0x3F02, "Changed Operating Definition"},
{0x3F03, "Inquiry Data Has Changed"},
{0x3F04, "Component Device Attached"},
{0x3F05, "Device Identifier Changed"},
{0x3F06, "Redundancy Group Created Or Modified"},
{0x3F07, "Redundancy Group Deleted"},
{0x3F08, "Spare Created Or Modified"},
{0x3F09, "Spare Deleted"},
{0x3F0A, "Volume Set Created Or Modified"},
{0x3F0B, "Volume Set Deleted"},
{0x3F0C, "Volume Set Deassigned"},
{0x3F0D, "Volume Set Reassigned"},
{0x3F0E, "Reported Luns Data Has Changed"},
{0x3F0F, "Echo Buffer Overwritten"},
{0x3F10, "Medium Loadable"},
{0x3F11, "Medium Auxiliary Memory Accessible"},
{0x4200, "Self-Test Failure (Should Use 40 Nn)"},
{0x4300, "Message Error"},
{0x4400, "Internal Target Failure"},
{0x4500, "Select Or Reselect Failure"},
{0x4600, "Unsuccessful Soft Reset"},
{0x4700, "Scsi Parity Error"},
{0x4701, "Data Phase Crc Error Detected"},
{0x4702, "Scsi Parity Error Detected During St Data Phase"},
{0x4703, "Information Unit Crc Error Detected"},
{0x4704, "Asynchronous Information Protection Error Detected"},
{0x4800, "Initiator Detected Error Message Received"},
{0x4900, "Invalid Message Error"},
{0x4A00, "Command Phase Error"},
{0x4B00, "Data Phase Error"},
{0x4C00, "Logical Unit Failed Self-Configuration"},
{0x4D00, "Tagged Overlapped Commands (Nn = Queue Tag)"},
{0x4E00, "Overlapped Commands Attempted"},
{0x5300, "Media Load Or Eject Failed"},
{0x5302, "Medium Removal Prevented"},
{0x5501, "System Buffer Full"},
{0x5502, "Insufficient Reservation Resources"},
{0x5503, "Insufficient Resources"},
{0x5504, "Insufficient Registration Resources"},
{0x5A00, "Operator Request Or State Change Input"},
{0x5A01, "Operator Medium Removal Request"},
{0x5A02, "Operator Selected Write Protect"},
{0x5A03, "Operator Selected Write Permit"},
{0x5B00, "Log Exception"},
{0x5B01, "Threshold Condition Met"},
{0x5B02, "Log Counter At Maximum"},
{0x5B03, "Log List Codes Exhausted"},
{0x5C00, "Change"},
{0x5C02, "Synchronized"},
{0x5D00, "Failure Prediction Threshold Exceeded"},
{0x5D10, "Failure General Hard Drive Failure"},
{0x5D11, "Failure Drive Error Rate Too High"},
{0x5D12, "Failure Data Error Rate Too High"},
{0x5D13, "Failure Seek Error Rate Too High"},
{0x5D14, "Failure Too Many Block Reassigns"},
{0x5D15, "Failure Access Times Too High"},
{0x5D16, "Failure Start Unit Times Too High"},
{0x5D17, "Failure Channel Parametrics"},
{0x5D18, "Failure Controller Detected"},
{0x5D19, "Failure Throughput Performance"},
{0x5D1A, "Failure Seek Time Performance"},
{0x5D1B, "Failure Spin-Up Retry Count"},
{0x5D1C, "Failure Drive Calibration Retry"},
{0x5D20, "Failure General Hard Drive Failure"},
{0x5D21, "Failure Drive Error Rate Too High"},
{0x5D22, "Failure Data Error Rate Too High"},
{0x5D23, "Failure Seek Error Rate Too High"},
{0x5D24, "Failure Too Many Block Reassigns"},
{0x5D25, "Failure Access Times Too High"},
{0x5D26, "Failure Start Unit Times Too High"},
{0x5D27, "Failure Channel Parametrics"},
{0x5D28, "Failure Controller Detected"},
{0x5D29, "Failure Throughput Performance"},
{0x5D2A, "Failure Seek Time Performance"},
{0x5D2B, "Failure Spin-Up Retry Count"},
{0x5D2C, "Failure Drive Calibration Retry"},
{0x5D30, "Impending Failure General Hard Drive"},
{0x5D31, "Impending Failure Drive Error Rate Too High"},
{0x5D32, "Impending Failure Data Error Rate Too High"},
{0x5D33, "Impending Failure Seek Error Rate Too High"},
{0x5D34, "Impending Failure Too Many Block Reassigns"},
{0x5D35, "Impending Failure Access Times Too High"},
{0x5D36, "Impending Failure Start Unit Times Too High"},
{0x5D37, "Impending Failure Channel Parametrics"},
{0x5D38, "Impending Failure Controller Detected"},
{0x5D39, "Impending Failure Throughput Performance"},
{0x5D3A, "Impending Failure Seek Time Performance"},
{0x5D3B, "Impending Failure Spin-Up Retry Count"},
{0x5D3C, "Impending Failure Drive Calibration Retry"},
{0x5D40, "Failure General Hard Drive Failure"},
{0x5D41, "Failure Drive Error Rate Too High"},
{0x5D42, "Failure Data Error Rate Too High"},
{0x5D43, "Failure Seek Error Rate Too High"},
{0x5D44, "Failure Too Many Block Reassigns"},
{0x5D45, "Failure Access Times Too High"},
{0x5D46, "Failure Start Unit Times Too High"},
{0x5D47, "Failure Channel Parametrics"},
{0x5D48, "Failure Controller Detected"},
{0x5D49, "Failure Throughput Performance"},
{0x5D4A, "Failure Seek Time Performance"},
{0x5D4B, "Failure Spin-Up Retry Count"},
{0x5D4C, "Failure Drive Calibration Retry Count"},
{0x5D50, "Failure General Hard Drive Failure"},
{0x5D51, "Failure Drive Error Rate Too High"},
{0x5D52, "Failure Data Error Rate Too High"},
{0x5D53, "Failure Seek Error Rate Too High"},
{0x5D54, "Failure Too Many Block Reassigns"},
{0x5D55, "Failure Access Times Too High"},
{0x5D56, "Failure Start Unit Times Too High"},
{0x5D57, "Failure Channel Parametrics"},
{0x5D58, "Failure Controller Detected"},
{0x5D59, "Failure Throughput Performance"},
{0x5D5A, "Failure Seek Time Performance"},
{0x5D5B, "Failure Spin-Up Retry Count"},
{0x5D5C, "Failure Drive Calibration Retry Count"},
{0x5D60, "Failure General Hard Drive Failure"},
{0x5D61, "Failure Drive Error Rate Too High"},
{0x5D62, "Failure Data Error Rate Too High"},
{0x5D63, "Failure Seek Error Rate Too High"},
{0x5D64, "Failure Too Many Block Reassigns"},
{0x5D65, "Failure Access Times Too High"},
{0x5D66, "Failure Start Unit Times Too High"},
{0x5D67, "Failure Channel Parametrics"},
{0x5D68, "Failure Controller Detected"},
{0x5D69, "Failure Throughput Performance"},
{0x5D6A, "Failure Seek Time Performance"},
{0x5D6B, "Failure Spin-Up Retry Count"},
{0x5D6C, "Failure Drive Calibration Retry Count"},
{0x5DFF, "Failure Prediction Threshold Exceeded (False)"},
{0x5E00, "Low Power Condition On"},
{0x5E01, "Idle Condition Activated By Timer"},
{0x5E02, "Standby Condition Activated By Timer"},
{0x5E03, "Idle Condition Activated By Command"},
{0x5E04, "Standby Condition Activated By Command"},
{0x6500, "Voltage Fault"},
{0, NULL},
};
/* SCSI Status Codes */
static const value_string scsi_status_val[] = {
{0x00, "Good"},
{0x02, "Check Condition"},
{0x04, "Condition Met"},
{0x08, "Busy"},
{0x10, "Intermediate"},
{0x14, "Intermediate Condition Met"},
{0x18, "Reservation Conflict"},
{0x28, "Task Set Full"},
{0x30, "ACA Active"},
{0x40, "Task Aborted"},
{0, NULL},
};
/* Function Decls; functions invoked by SAM-2 transport protocols such as
* FCP/iSCSI
*/
void dissect_scsi_cdb (tvbuff_t *, packet_info *, proto_tree *, guint, guint);
void dissect_scsi_rsp (tvbuff_t *, packet_info *, proto_tree *);
void dissect_scsi_payload (tvbuff_t *, packet_info *, proto_tree *, guint,
gboolean, guint32);
void dissect_scsi_snsinfo (tvbuff_t *, packet_info *, proto_tree *, guint, guint);
#endif