OpenSolaris_b135/common/devid/devid_scsi.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* These functions are used to encode SCSI INQUIRY data into
* Solaris devid / guid values.
*/
#ifndef _KERNEL
#include <stdio.h>
#endif /* _KERNEL */
#include <sys/inttypes.h>
#include <sys/types.h>
#include <sys/stropts.h>
#include <sys/debug.h>
#include <sys/isa_defs.h>
#include <sys/dditypes.h>
#include <sys/ddi_impldefs.h>
#include <sys/scsi/scsi.h>
#ifndef _KERNEL
#include <sys/libdevid.h>
#endif /* !_KERNEL */
#include "devid_impl.h"
#define SCSI_INQUIRY_VID_POS 9
#define SCSI_INQUIRY_VID_SUN "SUN"
#define SCSI_INQUIRY_VID_SUN_LEN 3
#define SCSI_INQUIRY_VID_HITACHI "HITACHI"
#define SCSI_INQUIRY_VID_HITACHI_LEN 7
#define SCSI_INQUIRY_PID_HITACHI_OPEN "OPEN-"
#define SCSI_INQUIRY_PID_HITACHI_OPEN_LEN 5
#define SCSI_INQUIRY_VID_EMC "EMC "
#define SCSI_INQUIRY_VID_EMC_LEN 8
#define SCSI_INQUIRY_PID_EMC_SYMMETRIX "SYMMETRIX "
#define SCSI_INQUIRY_PID_EMC_SYMMETRIX_LEN 16
#define MSG_NOT_STANDARDS_COMPLIANT "!Page83 data not standards compliant "
#define MSG_NOT_STANDARDS_COMPLIANT_SIZE ( \
sizeof (MSG_NOT_STANDARDS_COMPLIANT) + \
sizeof (((struct scsi_inquiry *)NULL)->inq_vid) + \
sizeof (((struct scsi_inquiry *)NULL)->inq_pid) + \
sizeof (((struct scsi_inquiry *)NULL)->inq_revision) + 4)
#define IS_DEVID_GUID_TYPE(type) ((type == DEVID_SCSI3_WWN) || \
(IS_DEVID_SCSI3_VPD_TYPE(type)))
#define IS_DEVID_SCSI_TYPE(type) ((IS_DEVID_GUID_TYPE(type)) || \
(type == DEVID_SCSI_SERIAL))
/*
* The max inquiry page 83 size as expected in the code today
* is 0xf0 bytes. Defining a constant to make it easy incase
* this needs to be changed at a later time.
*/
#define SCMD_MAX_INQUIRY_PAGE83_SIZE 0xFF
#define SCMD_MIN_INQUIRY_PAGE83_SIZE 0x08
#define SCMD_INQUIRY_PAGE83_HDR_SIZE 4
#define SCSI_INQUIRY_PAGE83_EMC_SYMMETRIX_ID_LEN 16
#define SCMD_MAX_INQUIRY_PAGE80_SIZE 0xFF
#define SCMD_MIN_INQUIRY_PAGE80_SIZE 0x04
#define SCMD_MIN_STANDARD_INQUIRY_SIZE 0x04
#define SCMD_INQUIRY_PAGE83_IDENT_DESC_HDR_SIZE 4
#define SCMD_INQUIRY_VPD_TYPE_T10 0x01
#define SCMD_INQUIRY_VPD_TYPE_EUI 0x02
#define SCMD_INQUIRY_VPD_TYPE_NAA 0x03
#define SCMD_INQUIRY_VPD_TYPE_RTP 0x04
#define SCMD_INQUIRY_VPD_TYPE_TPG 0x05
#define SCMD_INQUIRY_VPD_TYPE_LUG 0x06
#define SCMD_INQUIRY_VPD_TYPE_MD5 0x07
#define SCMD_INQUIRY_VPD_TYPE_SSN 0x08
static int is_page83_data_valid(uchar_t *inq83, size_t inq83_len);
static int is_page80_data_valid(uchar_t *inq80, size_t inq80_len);
static int is_initialized_id(uchar_t *id, size_t id_len);
static void encode_scsi3_page83(int version, uchar_t *inq83,
size_t inq83_len, uchar_t **id, size_t *id_len, ushort_t *id_type);
static void encode_scsi3_page83_emc(int version, uchar_t *inq83,
size_t inq83_len, uchar_t **id, size_t *id_len, ushort_t *id_type);
static void encode_serialnum(int version, uchar_t *inq, uchar_t *inq80,
size_t inq80_len, uchar_t **id, size_t *id_len, ushort_t *id_type);
static void encode_sun_serialnum(int version, uchar_t *inq,
size_t inq_len, uchar_t **id, size_t *id_len, ushort_t *id_type);
static int devid_scsi_init(char *driver_name,
uchar_t *raw_id, size_t raw_id_len, ushort_t raw_id_type,
ddi_devid_t *ret_devid);
static char ctoi(char c);
/*
* Function: ddi_/devid_scsi_encode
*
* Description: This routine finds and encodes a unique devid
*
* Arguments: version - id encode algorithm version
* driver_name - binding driver name (if ! known use NULL)
* inq - standard inquiry buffer
* inq_len - standard inquiry buffer length
* inq80 - serial number inquiry buffer
* inq80_len - serial number inquiry buffer length
* inq83 - vpd inquiry buffer
* inq83_len - vpd inquiry buffer length
* devid - id returned
*
* Return Code: DEVID_SUCCESS - success
* DEVID_FAILURE - failure
* DEVID_RETRY - LUN is in a transitional state. A delay should
* occur and then this inquiry data should be re-acquired and
* this function should be called again.
*/
int
#ifdef _KERNEL
ddi_devid_scsi_encode(
#else /* ! _KERNEL */
devid_scsi_encode(
#endif /* _KERNEL */
int version, /* IN */
char *driver_name, /* IN */
uchar_t *inq, /* IN */
size_t inq_len, /* IN */
uchar_t *inq80, /* IN */
size_t inq80_len, /* IN */
uchar_t *inq83, /* IN */
size_t inq83_len, /* IN */
ddi_devid_t *devid) /* OUT */
{
int rval = DEVID_FAILURE;
uchar_t *id = NULL;
size_t id_len = 0;
ushort_t id_type = DEVID_NONE;
struct scsi_inquiry *inq_std = (struct scsi_inquiry *)inq;
#ifdef _KERNEL
char *msg = NULL;
#endif /* _KERNEL */
DEVID_ASSERT(devid != NULL);
/* verify valid version */
if (version > DEVID_SCSI_ENCODE_VERSION_LATEST) {
return (rval);
}
/* make sure minimum inquiry bytes are available */
if (inq_len < SCMD_MIN_STANDARD_INQUIRY_SIZE) {
return (rval);
}
/*
* If 0x83 is availible, that is the best choice. Our next choice is
* 0x80. If neither are availible, we leave it to the caller to
* determine possible alternate ID, although discouraged. In the
* case of the target drivers they create a fabricated id which is
* stored in the acyl. The HBA drivers should avoid using an
* alternate id. Although has already created a hack of using the
* node wwn in some cases. Which needs to be carried forward for
* legacy reasons.
*/
if (inq83 != NULL) {
/*
* Perform page 83 validation tests and report offenders.
* We cannot enforce the page 83 specification because
* many Sun partners (ex. HDS) do not conform to the
* standards yet.
*/
if (is_page83_data_valid(inq83, inq83_len) ==
DEVID_RET_INVALID) {
/*
* invalid page 83 data. bug 4939576 introduced
* handling for EMC non-standard data.
*/
if ((bcmp(inq_std->inq_vid, SCSI_INQUIRY_VID_EMC,
SCSI_INQUIRY_VID_EMC_LEN) == 0) &&
(bcmp(inq_std->inq_pid,
SCSI_INQUIRY_PID_EMC_SYMMETRIX,
SCSI_INQUIRY_PID_EMC_SYMMETRIX_LEN) == 0)) {
encode_scsi3_page83_emc(version, inq83,
inq83_len, &id, &id_len, &id_type);
}
#ifdef _KERNEL
/*
* invalid page 83 data. Special hack for HDS
* specific device, to suppress the warning msg.
*/
if ((bcmp(inq_std->inq_vid, SCSI_INQUIRY_VID_HITACHI,
SCSI_INQUIRY_VID_HITACHI_LEN) != 0) ||
(bcmp(inq_std->inq_pid,
SCSI_INQUIRY_PID_HITACHI_OPEN,
SCSI_INQUIRY_PID_HITACHI_OPEN_LEN) != 0)) {
/*
* report the page 0x83 standards violation.
*/
msg = kmem_alloc(
MSG_NOT_STANDARDS_COMPLIANT_SIZE,
KM_SLEEP);
(void) strcpy(msg, MSG_NOT_STANDARDS_COMPLIANT);
(void) strncat(msg, inq_std->inq_vid,
sizeof (inq_std->inq_vid));
(void) strcat(msg, " ");
(void) strncat(msg, inq_std->inq_pid,
sizeof (inq_std->inq_pid));
(void) strcat(msg, " ");
(void) strncat(msg, inq_std->inq_revision,
sizeof (inq_std->inq_revision));
(void) strcat(msg, "\n");
cmn_err(CE_WARN, msg);
kmem_free(msg,
MSG_NOT_STANDARDS_COMPLIANT_SIZE);
}
#endif /* _KERNEL */
}
if (id_type == DEVID_NONE) {
encode_scsi3_page83(version, inq83,
inq83_len, &id, &id_len, &id_type);
}
}
/*
* If no vpd page is available at this point then we
* attempt to use a SCSI serial number from page 0x80.
*/
if ((id_type == DEVID_NONE) &&
(inq != NULL) &&
(inq80 != NULL)) {
if (is_page80_data_valid(inq80, inq80_len) == DEVID_RET_VALID) {
encode_serialnum(version, inq, inq80,
inq80_len, &id, &id_len, &id_type);
}
}
/*
* If no vpd page or serial is available at this point and
* it's a SUN disk it conforms to the disk qual. 850 specifications
* and we can fabricate a serial number id based on the standard
* inquiry page.
*/
if ((id_type == DEVID_NONE) &&
(inq != NULL)) {
encode_sun_serialnum(version, inq, inq_len,
&id, &id_len, &id_type);
}
if (id_type != DEVID_NONE) {
if (is_initialized_id(id, id_len) == DEVID_RET_VALID) {
rval = devid_scsi_init(driver_name,
id, id_len, id_type, devid);
} else {
rval = DEVID_RETRY;
}
DEVID_FREE(id, id_len);
}
return (rval);
}
/*
* Function: is_page83_data_valid
*
* Description: This routine is used to validate the page 0x83 data
* passed in valid based on the standards specification.
*
* Arguments: inq83 -
* inq83_len -
*
* Return Code: DEVID_RET_VALID
* DEVID_RET_INVALID
*
*/
static int
is_page83_data_valid(uchar_t *inq83, size_t inq83_len)
{
int covered_desc_len = 0;
int dlen = 0;
uchar_t *dblk = NULL;
DEVID_ASSERT(inq83 != NULL);
/* if not large enough fail */
if (inq83_len < SCMD_MIN_INQUIRY_PAGE83_SIZE)
return (DEVID_RET_INVALID);
/*
* Ensuring that the Peripheral device type(bits 0 - 4) has
* the valid settings - the value 0x1f indicates no device type.
* Only this value can be validated since all other fields are
* either used or reserved.
*/
if ((inq83[0] & DTYPE_MASK) == DTYPE_UNKNOWN) {
/* failed-peripheral devtype */
return (DEVID_RET_INVALID);
}
/*
* Ensure that the page length field - third and 4th bytes
* contain a non zero length value. Our implementation
* does not seem to expect more that 255 bytes of data...
* what is to be done if the reported size is > 255 bytes?
* Yes the device will return only 255 bytes as we provide
* buffer to house only that much data but the standards
* prevent the targets from reporting the truncated size
* in this field.
*
* Currently reporting sizes more than 255 as failure.
*
*/
if ((inq83[2] == 0) && (inq83[3] == 0)) {
/* length field is 0! */
return (DEVID_RET_INVALID);
}
if (inq83[3] > (SCMD_MAX_INQUIRY_PAGE83_SIZE - 3)) {
/* length field exceeds expected size of 255 bytes */
return (DEVID_RET_INVALID);
}
/*
* Validation of individual descriptor blocks are done in the
* following while loop. It is possible to have multiple
* descriptor blocks.
* the 'dblk' pointer will be pointing to the start of
* each entry of the descriptor block.
*/
covered_desc_len = 0;
dblk = &inq83[4]; /* start of first decriptor blk */
while (covered_desc_len < inq83[3]) {
/*
* Ensure that the length field is non zero
* Further length validations will be done
* along with the 'identifier type' as some of
* the lengths are dependent on it.
*/
dlen = dblk[3];
if (dlen == 0) {
/* descr length is 0 */
return (DEVID_RET_INVALID);
}
/*
* ensure that the size of the descriptor block does
* not claim to be larger than the entire page83
* data that has been received.
*/
if ((covered_desc_len + dlen) > inq83[3]) {
/* failed-descr length */
return (DEVID_RET_INVALID);
}
/*
* The spec says that if the PIV field is 0 OR the
* association field contains value other than 1 and 2,
* then the protocol identifier field should be ignored.
* If association field contains a value of 1 or 2
* and the PIV field is set, then the protocol identifier
* field has to be validated.
* The protocol identifier values 0 - f are either assigned
* or reserved. Nothing to validate here, hence skipping
* over to the next check.
*/
/*
* Check for valid code set values.
* All possible values are reserved or assigned. Nothing
* to validate - skipping over.
*/
/*
* Identifier Type validation
* All SPC3rev22 identified types and the expected lengths
* are validated.
*/
switch (dblk[1] & 0x0f) {
case SCMD_INQUIRY_VPD_TYPE_T10: /* T10 vendor Id */
/* No specific length validation required */
break;
case SCMD_INQUIRY_VPD_TYPE_EUI: /* EUI 64 ID */
/* EUI-64: size is expected to be 8, 12, or 16 bytes */
if ((dlen != 8) && (dlen != 12) && (dlen != 16)) {
/* page83 validation failed-EIU64 */
return (DEVID_RET_INVALID);
}
break;
case SCMD_INQUIRY_VPD_TYPE_NAA: /* NAA Id type */
/*
* the size for this varies -
* IEEE extended/registered is 8 bytes
* IEEE Registered extended is 16 bytes
*/
switch (dblk[4] & 0xf0) {
case 0x20: /* IEEE Ext */
case 0x50: /* IEEE Reg */
if (dlen != 8) {
/* failed-IEE E/R len */
return (DEVID_RET_INVALID);
}
/*
* the codeSet for this MUST
* be set to 1
*/
if ((dblk[0] & 0x0f) != 1) {
/*
* failed-IEEE E/R
* codeSet != 1.
*/
return (DEVID_RET_INVALID);
}
break;
case 0x60: /* IEEE EXT REG */
if (dlen != 16) {
/* failed-IEEE ER len */
return (DEVID_RET_INVALID);
}
/*
* the codeSet for this MUST
* be set to 1
*/
if ((dblk[0] & 0x0f) != 1) {
/*
* failed-IEEE ER
* codeSet != 1.
*/
return (DEVID_RET_INVALID);
}
break;
default:
/* reserved values */
break;
}
break;
case SCMD_INQUIRY_VPD_TYPE_RTP: /* Relative Target port */
if (dlen != 4) {
/* failed-Rel target Port length */
return (DEVID_RET_INVALID);
}
break;
case SCMD_INQUIRY_VPD_TYPE_TPG: /* Target port group */
if (dlen != 4) {
/* failed-target Port group length */
return (DEVID_RET_INVALID);
}
break;
case SCMD_INQUIRY_VPD_TYPE_LUG: /* Logical unit group */
if (dlen != 4) {
/* failed-Logical Unit group length */
return (DEVID_RET_INVALID);
}
break;
case SCMD_INQUIRY_VPD_TYPE_MD5: /* MD5 unit group */
if (dlen != 16) {
/* failed-MD5 Unit grp */
return (DEVID_RET_INVALID);
}
break;
default:
break;
}
/*
* Now lets advance to the next descriptor block
* and validate it.
* the descriptor block size is <descr Header> + <descr Data>
* <descr Header> is equal to 4 bytes
* <descr Data> is available in dlen or dblk[3].
*/
dblk = &dblk[4 + dlen];
/*
* update the covered_desc_len so that we can ensure that
* the 'while' loop terminates.
*/
covered_desc_len += (dlen + 4);
}
return (DEVID_RET_VALID);
}
/*
* Function: is_initialized_id
*
* Description: Routine to ensure that the ID calculated is not a
* space or zero filled ID. Returning a space / zero
* filled ID when the luns on the target are not fully
* initialized is a valid response from the target as
* per the T10 spec. When a space/zero filled ID is
* found its information needs to be polled again
* after sometime time to see if the luns are fully
* initialized to return a valid guid information.
*
* Arguments: id - raw id
* id_len - raw id len
*
* Return Code: DEVID_VALID - indicates a non space/zero filled id
* DEVID_INVALID - indicates id contains uninitialized data
* and suggests retry of the collection commands.
*/
static int
is_initialized_id(uchar_t *id, size_t id_len)
{
int idx;
if ((id == NULL) ||
(id_len == 0)) {
/* got id length as 0 fetch info again */
return (DEVID_RET_INVALID);
}
/* First lets check if the guid is filled with spaces */
for (idx = 0; idx < id_len; idx++) {
if (id[idx] != ' ') {
break;
}
}
/*
* Lets exit if we find that it contains ALL spaces
* saying that it has an uninitialized guid
*/
if (idx >= id_len) {
/* guid filled with spaces found */
return (DEVID_RET_INVALID);
}
/*
* Since we have found that it is not filled with spaces
* now lets ensure that the guid is not filled with only
* zeros.
*/
for (idx = 0; idx < id_len; idx ++) {
if (id[idx] != 0) {
return (DEVID_RET_VALID);
}
}
/* guid filled with zeros found */
return (DEVID_RET_INVALID);
}
/*
* Function: is_page80_data_valid
*
* Description: This routine is used to validate the page 0x80 data
* passed in valid based on the standards specification.
*
* Arguments: inq80 -
* inq80_len -
*
* Return Code: DEVID_RET_VALID
* DEVID_RET_INVALID
*
*/
/* ARGSUSED */
static int
is_page80_data_valid(uchar_t *inq80, size_t inq80_len)
{
DEVID_ASSERT(inq80);
/* if not large enough fail */
if (inq80_len < SCMD_MIN_INQUIRY_PAGE80_SIZE) {
return (DEVID_RET_INVALID);
}
/*
* (inq80_len - 4) is the size of the buffer space available
* for the product serial number. So inq80[3] (ie. product
* serial number) should be <= (inq80_len -4).
*/
if (inq80[3] > (inq80_len - 4)) {
return (DEVID_RET_INVALID);
}
return (DEVID_RET_VALID);
}
/*
* Function: encode_devid_page
*
* Description: This routine finds the unique devid if available and
* fills the devid and length parameters.
*
* Arguments: version - encode version
* inq83 - driver soft state (unit) structure
* inq83_len - length of raw inq83 data
* id - raw id
* id_len - len of raw id
* id_type - type of id
*
* Note: DEVID_NONE is returned in the id_type field
* if no supported page 83 id is found.
*/
static void
encode_scsi3_page83(int version, uchar_t *inq83, size_t inq83_len,
uchar_t **id, size_t *id_len, ushort_t *id_type)
{
size_t descriptor_bytes_left = 0;
size_t offset = 0;
int idx = 0;
size_t offset_id_type[4];
DEVID_ASSERT(inq83 != NULL);
/* inq83 length was already validate in is_page83_valid */
DEVID_ASSERT(id != NULL);
DEVID_ASSERT(id_len != NULL);
DEVID_ASSERT(id_type != NULL);
/* preset defaults */
*id = NULL;
*id_len = 0;
*id_type = DEVID_NONE;
/* verify we have enough memory for a ident header */
if (inq83_len < SCMD_INQUIRY_PAGE83_HDR_SIZE) {
return;
}
/*
* Attempt to validate the page data. Once validated, we'll walk
* the descriptors, looking for certain identifier types that will
* mark this device with a unique id/wwn. Note the comment below
* for what we really want to receive.
*/
/*
* The format of the inq83 data (Device Identification VPD page) is
* a header (containing the total length of the page, from which
* descriptor_bytes_left is calculated), followed by a list of
* identification descriptors. Each identifcation descriptor has a
* header which includes the length of the individual identification
* descriptor).
*
* Set the offset to the beginning byte of the first identification
* descriptor. We'll index everything from there.
*/
offset = SCMD_INQUIRY_PAGE83_HDR_SIZE;
descriptor_bytes_left = (size_t)((inq83[2] << 8) | inq83[3]);
/*
* If the raw data states that the data is larger
* than what is actually received abort encode.
* Otherwise we will run off into unknown memory
* on the decode.
*/
if ((descriptor_bytes_left + offset) > inq83_len) {
return;
}
/* Zero out our offset array */
bzero(offset_id_type, sizeof (offset_id_type));
/*
* According to the scsi spec 8.4.3 SPC-2, there could be several
* descriptors associated with each lun. Some we care about and some
* we don't. This loop is set up to iterate through the descriptors.
* We want the 0x03 case which represents an FC-PH, FC-PH3 or FC-FS
* Name_Identifier. The spec mentions nothing about ordering, so we
* don't assume any.
*
* We need to check if we've finished walking the list of descriptors,
* we also perform additional checks to be sure the newly calculated
* offset is within the bounds of the buffer, and the identifier length
* (as calculated by the length field in the header) is valid. This is
* done to protect against devices which return bad page83 data.
*/
while ((descriptor_bytes_left > 0) && (offset_id_type[3] == 0) &&
(offset + SCMD_INQUIRY_PAGE83_IDENT_DESC_HDR_SIZE <= inq83_len) &&
(offset + SCMD_INQUIRY_PAGE83_IDENT_DESC_HDR_SIZE +
(size_t)inq83[offset + 3] <= inq83_len)) {
/*
* Inspect the Identification descriptor list. Store the
* offsets in the devid page separately for 0x03, 0x01 and
* 0x02. Identifiers 0x00 and 0x04 are not useful as they
* don't represent unique identifiers for a lun. We also
* check the association by masking with 0x3f because we want
* an association of 0x0 - indicating the identifier field is
* associated with the addressed physical or logical device
* and not the port.
*/
switch ((inq83[offset + 1] & 0x3f)) {
case SCMD_INQUIRY_VPD_TYPE_T10:
offset_id_type[SCMD_INQUIRY_VPD_TYPE_T10] = offset;
break;
case SCMD_INQUIRY_VPD_TYPE_EUI:
offset_id_type[SCMD_INQUIRY_VPD_TYPE_EUI] = offset;
break;
case SCMD_INQUIRY_VPD_TYPE_NAA:
offset_id_type[SCMD_INQUIRY_VPD_TYPE_NAA] = offset;
break;
default:
/* Devid page undesired id type */
break;
}
/*
* Calculate the descriptor bytes left and move to
* the beginning byte of the next id descriptor.
*/
descriptor_bytes_left -= (size_t)(inq83[offset + 3] +
SCMD_INQUIRY_PAGE83_IDENT_DESC_HDR_SIZE);
offset += (SCMD_INQUIRY_PAGE83_IDENT_DESC_HDR_SIZE +
(size_t)inq83[offset + 3]);
}
offset = 0;
/*
* We can't depend on an order from a device by identifier type, but
* once we have them, we'll walk them in the same order to prevent a
* firmware upgrade from breaking our algorithm. Start with the one
* we want the most: id_offset_type[3].
*/
for (idx = 3; idx > 0; idx--) {
if (offset_id_type[idx] > 0) {
offset = offset_id_type[idx];
break;
}
}
/*
* We have a valid Device ID page, set the length of the
* identifier and copy the value into the wwn.
*/
if (offset > 0) {
*id_len = (size_t)inq83[offset + 3];
if ((*id = DEVID_MALLOC(*id_len)) == NULL) {
*id_len = 0;
return;
}
bcopy(&inq83[offset + SCMD_INQUIRY_PAGE83_IDENT_DESC_HDR_SIZE],
*id, *id_len);
/* set devid type */
switch (version) {
/* In version 1 all page 83 types were grouped */
case DEVID_SCSI_ENCODE_VERSION1:
*id_type = DEVID_SCSI3_WWN;
break;
/* In version 2 we break page 83 apart to be unique */
case DEVID_SCSI_ENCODE_VERSION2:
switch (idx) {
case 3:
*id_type = DEVID_SCSI3_VPD_NAA;
break;
case 2:
*id_type = DEVID_SCSI3_VPD_EUI;
break;
case 1:
*id_type = DEVID_SCSI3_VPD_T10;
break;
default:
DEVID_FREE(*id, *id_len);
*id_len = 0;
break;
}
break;
default:
DEVID_FREE(*id, *id_len);
*id_len = 0;
break;
}
}
}
/*
* Function: encode_scsi3_page83_emc
*
* Description: Routine to handle proprietary page 83 of EMC Symmetrix
* device. Called by ssfcp_handle_page83()
*
* Arguments: version - encode version
* inq83 - scsi page 83 buffer
* inq83_len - scsi page 83 buffer size
* id - raw emc id
* id_len - len of raw emc id
* id_type - type of emc id
*/
static void
encode_scsi3_page83_emc(int version, uchar_t *inq83,
size_t inq83_len, uchar_t **id, size_t *id_len, ushort_t *id_type)
{
uchar_t *guidp = NULL;
DEVID_ASSERT(inq83 != NULL);
DEVID_ASSERT(id != NULL);
DEVID_ASSERT(id_len != NULL);
DEVID_ASSERT(id_type != NULL);
/* preset defaults */
*id = NULL;
*id_len = 0;
*id_type = DEVID_NONE;
/* The initial devid algorithm didn't use EMC page 83 data */
if (version == DEVID_SCSI_ENCODE_VERSION1) {
return;
}
/* EMC page 83 requires atleast 20 bytes */
if (inq83_len < (SCMD_INQUIRY_PAGE83_HDR_SIZE +
SCSI_INQUIRY_PAGE83_EMC_SYMMETRIX_ID_LEN)) {
return;
}
/*
* The 4th byte in the page 83 info returned is most likely
* indicating the length of the id - which 0x10(16 bytes)
* and the 5th byte is indicating that the id is of
* IEEE Registered Extended Name format(6). Validate
* these code prints before proceeding further as the
* following proprietary approach is tied to the specific
* device type and incase the EMC firmware changes, we will
* have to validate for the changed device before we start
* supporting such a device.
*/
if ((inq83[3] != 0x10) || (inq83[4] != 0x60)) {
/* unsupported emc symtx device type */
return;
} else {
guidp = &inq83[SCMD_INQUIRY_PAGE83_HDR_SIZE];
/*
* The GUID returned by the EMC device is
* in the IEEE Registered Extended Name format(6)
* as a result it is of 16 bytes in length.
* An IEEE Registered Name format(5) will be of
* 8 bytes which is NOT what is being returned
* by the device type for which we are providing
* the support.
*/
*id_len = SCSI_INQUIRY_PAGE83_EMC_SYMMETRIX_ID_LEN;
if ((*id = DEVID_MALLOC(*id_len)) == NULL) {
*id_len = 0;
return;
}
bcopy(guidp, *id, *id_len);
/* emc id matches type 3 */
*id_type = DEVID_SCSI3_VPD_NAA;
}
}
/*
* Function: encode_serialnum
*
* Description: This routine finds the unique devid from the inquiry page
* 0x80, serial number page. If available and fills the wwn
* and length parameters.
*
* Arguments: version - encode version
* inq - standard inquiry data
* inq80 - serial inquiry data
* inq80_len - serial inquiry data len
* id - raw id
* id_len - raw id len
* id_type - raw id type
*/
/* ARGSUSED */
static void
encode_serialnum(int version, uchar_t *inq, uchar_t *inq80,
size_t inq80_len, uchar_t **id, size_t *id_len, ushort_t *id_type)
{
struct scsi_inquiry *inq_std = (struct scsi_inquiry *)inq;
int idx = 0;
DEVID_ASSERT(inq != NULL);
DEVID_ASSERT(inq80 != NULL);
DEVID_ASSERT(id != NULL);
DEVID_ASSERT(id_len != NULL);
DEVID_ASSERT(id_type != NULL);
/* preset defaults */
*id = NULL;
*id_len = 0;
*id_type = DEVID_NONE;
/* verify inq80 buffer is large enough for a header */
if (inq80_len < SCMD_MIN_INQUIRY_PAGE80_SIZE) {
return;
}
/*
* Attempt to validate the page data. Once validated, we'll check
* the serial number.
*/
*id_len = (size_t)inq80[3]; /* Store Product Serial Number length */
/* verify buffer is large enough for serial number */
if (inq80_len < (*id_len + SCMD_MIN_INQUIRY_PAGE80_SIZE)) {
return;
}
/*
* Device returns ASCII space (20h) in all the bytes of successful data
* transfer, if the product serial number is not available. So we end
* up having to check all the bytes for a space until we reach
* something else.
*/
for (idx = 0; idx < *id_len; idx++) {
if (inq80[4 + idx] == ' ') {
continue;
}
/*
* The serial number is valid, but since this is only vendor
* unique, we'll combine the inquiry vid and pid with the
* serial number.
*/
*id_len += sizeof (inq_std->inq_vid);
*id_len += sizeof (inq_std->inq_pid);
if ((*id = DEVID_MALLOC(*id_len)) == NULL) {
*id_len = 0;
return;
}
bcopy(&inq_std->inq_vid, *id, sizeof (inq_std->inq_vid));
bcopy(&inq_std->inq_pid, &(*id)[sizeof (inq_std->inq_vid)],
sizeof (inq_std->inq_pid));
bcopy(&inq80[4], &(*id)[sizeof (inq_std->inq_vid) +
sizeof (inq_std->inq_pid)], inq80[3]);
*id_type = DEVID_SCSI_SERIAL;
break;
}
/*
* The spec suggests that the command could succeed but return all
* spaces if the product serial number is not available. In this case
* we need to fail this routine. To accomplish this, we compare our
* length to the serial number length. If they are the same, then we
* never copied in the vid and updated the length. That being the case,
* we must not have found a valid serial number.
*/
if (*id_len == (size_t)inq80[3]) {
/* empty unit serial number */
if (*id != NULL) {
DEVID_FREE(*id, *id_len);
}
*id = NULL;
*id_len = 0;
}
}
/*
* Function: encode_sun_serialnum
*
* Description: This routine finds the unique devid from the inquiry page
* 0x80, serial number page. If available and fills the wwn
* and length parameters.
*
* Arguments: version - encode version
* inq - standard inquiry data
* inq_len - standard inquiry data len
* id - raw id
* id_len - raw id len
* id_type - raw id type
*
* Return Code: DEVID_SUCCESS
* DEVID_FAILURE
*/
/* ARGSUSED */
static void
encode_sun_serialnum(int version, uchar_t *inq,
size_t inq_len, uchar_t **id, size_t *id_len, ushort_t *id_type)
{
struct scsi_inquiry *inq_std = (struct scsi_inquiry *)inq;
DEVID_ASSERT(inq != NULL);
DEVID_ASSERT(id != NULL);
DEVID_ASSERT(id_len != NULL);
DEVID_ASSERT(id_type != NULL);
/* verify enough buffer is available */
if (inq_len < SCMD_MIN_STANDARD_INQUIRY_SIZE) {
return;
}
/* sun qual drive */
if ((inq_std != NULL) &&
(bcmp(&inq_std->inq_pid[SCSI_INQUIRY_VID_POS],
SCSI_INQUIRY_VID_SUN, SCSI_INQUIRY_VID_SUN_LEN) == 0)) {
/*
* VPD pages 0x83 and 0x80 are unavailable. This
* is a Sun qualified disk as indicated by
* "SUN" in bytes 25-27 of the inquiry data
* (bytes 9-11 of the pid). Devid's are created
* for Sun qualified disks by combining the
* vendor id with the product id with the serial
* number located in bytes 36-47 of the inquiry data.
*/
/* get data size */
*id_len = sizeof (inq_std->inq_vid) +
sizeof (inq_std->inq_pid) +
sizeof (inq_std->inq_serial);
if ((*id = DEVID_MALLOC(*id_len)) == NULL) {
*id_len = 0;
return;
}
/* copy the vid at the beginning */
bcopy(&inq_std->inq_vid, *id,
sizeof (inq_std->inq_vid));
/* copy the pid after the vid */
bcopy(&inq_std->inq_pid,
&(*id)[sizeof (inq_std->inq_vid)],
sizeof (inq_std->inq_pid));
/* copy the serial number after the vid and pid */
bcopy(&inq_std->inq_serial,
&(*id)[sizeof (inq_std->inq_vid) +
sizeof (inq_std->inq_pid)],
sizeof (inq_std->inq_serial));
/* devid formed from inquiry data */
*id_type = DEVID_SCSI_SERIAL;
}
}
/*
* Function: devid_scsi_init
*
* Description: This routine is used to create a devid for a scsi
* devid type.
*
* Arguments: hint - driver soft state (unit) structure
* raw_id - pass by reference variable to hold wwn
* raw_id_len - wwn length
* raw_id_type -
* ret_devid -
*
* Return Code: DEVID_SUCCESS
* DEVID_FAILURE
*
*/
static int
devid_scsi_init(
char *driver_name,
uchar_t *raw_id,
size_t raw_id_len,
ushort_t raw_id_type,
ddi_devid_t *ret_devid)
{
impl_devid_t *i_devid = NULL;
int i_devid_len = 0;
int driver_name_len = 0;
ushort_t u_raw_id_len = 0;
DEVID_ASSERT(raw_id != NULL);
DEVID_ASSERT(ret_devid != NULL);
if (!IS_DEVID_SCSI_TYPE(raw_id_type)) {
*ret_devid = NULL;
return (DEVID_FAILURE);
}
i_devid_len = sizeof (*i_devid) + raw_id_len - sizeof (i_devid->did_id);
if ((i_devid = DEVID_MALLOC(i_devid_len)) == NULL) {
*ret_devid = NULL;
return (DEVID_FAILURE);
}
i_devid->did_magic_hi = DEVID_MAGIC_MSB;
i_devid->did_magic_lo = DEVID_MAGIC_LSB;
i_devid->did_rev_hi = DEVID_REV_MSB;
i_devid->did_rev_lo = DEVID_REV_LSB;
DEVID_FORMTYPE(i_devid, raw_id_type);
u_raw_id_len = raw_id_len;
DEVID_FORMLEN(i_devid, u_raw_id_len);
/* Fill in driver name hint */
bzero(i_devid->did_driver, DEVID_HINT_SIZE);
if (driver_name != NULL) {
driver_name_len = strlen(driver_name);
if (driver_name_len > DEVID_HINT_SIZE) {
/* Pick up last four characters of driver name */
driver_name += driver_name_len - DEVID_HINT_SIZE;
driver_name_len = DEVID_HINT_SIZE;
}
bcopy(driver_name, i_devid->did_driver, driver_name_len);
}
bcopy(raw_id, i_devid->did_id, raw_id_len);
/* return device id */
*ret_devid = (ddi_devid_t)i_devid;
return (DEVID_SUCCESS);
}
/*
* Function: devid_to_guid
*
* Description: This routine extracts a guid string form a devid.
* The common use of this guid is for a HBA driver
* to pass into mdi_pi_alloc().
*
* Arguments: devid - devid to extract guid from
*
* Return Code: guid string - success
* NULL - failure
*/
char *
#ifdef _KERNEL
ddi_devid_to_guid(ddi_devid_t devid)
#else /* !_KERNEL */
devid_to_guid(ddi_devid_t devid)
#endif /* _KERNEL */
{
impl_devid_t *id = (impl_devid_t *)devid;
int len = 0;
int idx = 0;
int num = 0;
char *guid = NULL;
char *ptr = NULL;
char *dp = NULL;
DEVID_ASSERT(devid != NULL);
/* NULL devid -> NULL guid */
if (devid == NULL)
return (NULL);
if (!IS_DEVID_GUID_TYPE(DEVID_GETTYPE(id)))
return (NULL);
/* guid is always converted to ascii, append NULL */
len = DEVID_GETLEN(id);
/* allocate guid string */
if ((guid = DEVID_MALLOC((len * 2) + 1)) == NULL)
return (NULL);
/* perform encode of id to hex string */
ptr = guid;
for (idx = 0, dp = &id->did_id[0]; idx < len; idx++, dp++) {
num = ((*dp) >> 4) & 0xF;
*ptr++ = (num < 10) ? (num + '0') : (num + ('a' - 10));
num = (*dp) & 0xF;
*ptr++ = (num < 10) ? (num + '0') : (num + ('a' - 10));
}
*ptr = 0;
return (guid);
}
/*
* Function: devid_free_guid
*
* Description: This routine frees a guid allocated by
* devid_to_guid().
*
* Arguments: guid - guid to free
*/
void
#ifdef _KERNEL
ddi_devid_free_guid(char *guid)
#else /* !_KERNEL */
devid_free_guid(char *guid)
#endif /* _KERNEL */
{
if (guid != NULL) {
DEVID_FREE(guid, strlen(guid) + 1);
}
}
static char
ctoi(char c)
{
if ((c >= '0') && (c <= '9'))
c -= '0';
else if ((c >= 'A') && (c <= 'F'))
c = c - 'A' + 10;
else if ((c >= 'a') && (c <= 'f'))
c = c - 'a' + 10;
else
c = -1;
return (c);
}
/* ====NOTE: The scsi_* interfaces are not related to devids :NOTE==== */
/*
* Function: scsi_wwnstr_to_wwn
*
* Description: This routine translates wwn from wwnstr string to uint64 wwn.
*
* Arguments: wwnstr - the string wwn to be transformed
* wwnp - the pointer to 64 bit wwn
*/
int
scsi_wwnstr_to_wwn(const char *wwnstr, uint64_t *wwnp)
{
int i;
char cl, ch;
uint64_t tmp;
if (wwnp == NULL)
return (DDI_FAILURE);
*wwnp = 0;
if (wwnstr == NULL)
return (DDI_FAILURE);
/* Skip leading 'w' if wwnstr is in unit-address form */
wwnstr = scsi_wwnstr_skip_ua_prefix(wwnstr);
if (strlen(wwnstr) != 16)
return (DDI_FAILURE);
for (i = 0; i < 8; i++) {
ch = ctoi(*wwnstr++);
cl = ctoi(*wwnstr++);
if (cl == -1 || ch == -1) {
return (DDI_FAILURE);
}
tmp = (ch << 4) + cl;
*wwnp = (*wwnp << 8) | tmp;
}
return (DDI_SUCCESS);
}
/*
* Function: scsi_wwn_to_wwnstr
*
* Description: This routine translates from a uint64 wwn to a wwnstr
*
* Arguments:
* wwn - the 64 bit wwn
* unit_address_form - do we want a leading 'w'?
* wwnstr - allow caller to perform wwnstr allocation.
* If non-NULL, don't use scsi_free_wwnstr(),
* and make sure you provide 18/17 bytes of space.
*/
char *
scsi_wwn_to_wwnstr(uint64_t wwn, int unit_address_form, char *wwnstr)
{
int len;
/* make space for leading 'w' */
if (unit_address_form)
len = 1 + 16 + 1; /* "w0123456789abcdef\0" */
else
len = 16 + 1; /* "0123456789abcdef\0" */
if (wwnstr == NULL) {
/* We allocate, caller uses scsi_free_wwnstr(). */
if ((wwnstr = DEVID_MALLOC(len)) == NULL)
return (NULL);
}
if (unit_address_form)
(void) snprintf(wwnstr, len, "w%016" PRIx64, wwn);
else
(void) snprintf(wwnstr, len, "%016" PRIx64, wwn);
return (wwnstr);
}
/*
* Function: scsi_wwnstr_hexcase
*
* Description: This routine switches a wwnstr to upper/lower case hex
* (a wwnstr uses lower-case hex by default).
*
* Arguments:
* wwnstr - the pointer to the wwnstr string.
* upper_case_hex - non-zero will convert to upper_case hex
* zero will convert to lower case hex.
*/
void
scsi_wwnstr_hexcase(char *wwnstr, int upper_case_hex)
{
char *s;
char c;
for (s = wwnstr; *s; s++) {
c = *s;
if ((upper_case_hex != 0) &&
((c >= 'a') && (c <= 'f')))
c -= ('a' - 'A'); /* lower to upper */
else if ((upper_case_hex == 0) &&
((c >= 'A') && (c <= 'F')))
c += ('a' - 'A'); /* upper to lower */
*s = c;
}
}
/*
* Function: scsi_wwnstr_skip_ua_prefix
*
* Description: This routine removes the leading 'w' in wwnstr,
* if its in unit-address form.
*
* Arguments: wwnstr - the string wwn to be transformed
*
*/
const char *
scsi_wwnstr_skip_ua_prefix(const char *wwnstr)
{
if (*wwnstr == 'w')
wwnstr++;
return (wwnstr);
}
/*
* Function: scsi_wwnstr_free
*
* Description: This routine frees a wwnstr returned by a call
* to scsi_wwn_to_strwwn with a NULL wwnstr argument.
*
* Arguments:
* wwnstr - the pointer to the wwnstr string to free.
*/
void
scsi_free_wwnstr(char *wwnstr)
{
#ifdef _KERNEL
kmem_free(wwnstr, strlen(wwnstr) + 1);
#else /* _KERNEL */
free(wwnstr);
#endif /* _KERNEL */
}
/*
* Function: scsi_lun_to_lun64/scsi_lun64_to_lun
*
* Description: Convert between normalized (SCSI-3) LUN format, as
* described by scsi_lun_t, and a normalized lun64_t
* representation (used by Solaris SCSI_ADDR_PROP_LUN64
* "lun64" property). The normalized representation maps
* in a compatible way to SCSI-2 LUNs. See scsi_address.h
*
* SCSI-3 LUNs are 64 bits. SCSI-2 LUNs are 3 bits (up to
* 5 bits in non-compliant implementations). SCSI-3 will
* pass a (64-bit) scsi_lun_t, but we need a
* representation from which we can for example, make
* device names. For unit-address compatibility, we represent
* 64-bit LUN numbers in such a way that they appear like they
* would have under SCSI-2. This means that the single level
* LUN number is in the lowest byte with the second,
* third, and fourth level LUNs represented in
* successively higher bytes. In particular, if (and only
* if) the first byte of a 64 bit LUN is zero, denoting
* "Peripheral Device Addressing Method" and "Bus
* Identifier" zero, then the target implements LUNs
* compatible in spirit with SCSI-2 LUNs (although under
* SCSI-3 there may be up to 256 of them). Under SCSI-3
* rules, a target is *required* to use this format if it
* contains 256 or fewer Logical Units, none of which are
* dependent logical units. These routines have knowledge
* of the structure and size of a scsi_lun_t.
*
* NOTE: We tolerate vendors that use "Single level LUN structure using
* peripheral device addressing method" with a non-zero bus identifier
* (spec says bus identifier must be zero). Described another way, we let
* the non-'addressing method' bits of sl_lun1_msb contribute to our lun64
* value).
*/
scsi_lun64_t
scsi_lun_to_lun64(scsi_lun_t lun)
{
scsi_lun64_t lun64;
/*
* Check to see if we have a single level lun that uses the
* "Peripheral Device" addressing method. If so, the lun64 value is
* kept in Solaris 'unit-address compatibility' form.
*/
if (((lun.sl_lun2_msb == 0) && (lun.sl_lun2_lsb == 0) &&
(lun.sl_lun3_msb == 0) && (lun.sl_lun3_lsb == 0) &&
(lun.sl_lun4_msb == 0) && (lun.sl_lun4_lsb == 0)) &&
((lun.sl_lun1_msb & SCSI_LUN_AM_MASK) == SCSI_LUN_AM_PDEV)) {
/*
* LUN has Solaris 'unit-address compatibility' form, construct
* lun64 value from non-'addressing method' bits of msb and lsb.
*/
lun64 = ((lun.sl_lun1_msb & ~SCSI_LUN_AM_MASK) << 8) |
lun.sl_lun1_lsb;
} else {
/*
* LUN does not have a Solaris 'unit-address compatibility'
* form, construct lun64 value in full 64 bit LUN format.
*/
lun64 =
((scsi_lun64_t)lun.sl_lun1_msb << 56) |
((scsi_lun64_t)lun.sl_lun1_lsb << 48) |
((scsi_lun64_t)lun.sl_lun2_msb << 40) |
((scsi_lun64_t)lun.sl_lun2_lsb << 32) |
((scsi_lun64_t)lun.sl_lun3_msb << 24) |
((scsi_lun64_t)lun.sl_lun3_lsb << 16) |
((scsi_lun64_t)lun.sl_lun4_msb << 8) |
(scsi_lun64_t)lun.sl_lun4_lsb;
}
return (lun64);
}
scsi_lun_t
scsi_lun64_to_lun(scsi_lun64_t lun64)
{
scsi_lun_t lun;
if (lun64 <= (((0xFF & ~SCSI_LUN_AM_MASK) << 8) | 0xFF)) {
/*
* lun64 is in Solaris 'unit-address compatibility' form.
*/
lun.sl_lun1_msb = SCSI_LUN_AM_PDEV | (lun64 >> 8);
lun.sl_lun1_lsb = (uchar_t)lun64;
lun.sl_lun2_msb = 0;
lun.sl_lun2_lsb = 0;
lun.sl_lun3_msb = 0;
lun.sl_lun3_lsb = 0;
lun.sl_lun4_msb = 0;
lun.sl_lun4_lsb = 0;
} else {
/* lun64 is in full 64 bit LUN format. */
lun.sl_lun1_msb = (uchar_t)(lun64 >> 56);
lun.sl_lun1_lsb = (uchar_t)(lun64 >> 48);
lun.sl_lun2_msb = (uchar_t)(lun64 >> 40);
lun.sl_lun2_lsb = (uchar_t)(lun64 >> 32);
lun.sl_lun3_msb = (uchar_t)(lun64 >> 24);
lun.sl_lun3_lsb = (uchar_t)(lun64 >> 16);
lun.sl_lun4_msb = (uchar_t)(lun64 >> 8);
lun.sl_lun4_lsb = (uchar_t)(lun64);
}
return (lun);
}
/*
* This routine returns the true length of the ascii inquiry fields that are to
* be created by removing the padded spaces at the end of the inquiry data.
* This routine was designed for trimming spaces from the vid, pid and revision
* which are defined as being left aligned. In addition, we return 0 length
* if the field is full of all 0's or spaces, indicating to the caller that
* the device was not ready to return the inquiry data as per note 65 in
* the scsi-2 spec.
*/
int
scsi_ascii_inquiry_len(char *field, size_t length)
{
int retval;
int trailer;
char *p;
retval = length;
/*
* The vid, pid and revision are left-aligned ascii fields within the
* inquiry data. Here we trim the end of these fields by discounting
* length associated with trailing spaces or NULL bytes. The remaining
* bytes shall be only graphics codes - 0x20 through 0x7e as per the
* scsi spec definition. If we have all 0's or spaces, we return 0
* length. For devices that store inquiry data on the device, they
* can return 0's or spaces in these fields until the data is avail-
* able from the device (See NOTE 65 in the scsi-2 specification
* around the inquiry command.) We don't want to create a field in
* the case of a device not able to return valid data.
*/
trailer = 1;
for (p = field + length - 1; p >= field; p--) {
if (trailer) {
if ((*p == ' ') || (*p == '\0')) {
retval--;
continue;
}
trailer = 0;
}
/* each char must be within 0x20 - 0x7e */
if (*p < 0x20 || *p > 0x7e) {
retval = -1;
break;
}
}
return (retval);
}