X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=extras%2Fscsi_id%2Fscsi_serial.c;h=cbacf379fee8cff055b9d44d01792837eb222159;hp=e0074b662d3a9692b1c17f253c753eebfbc825b8;hb=fdcd1f4666a4cceb0de7935a72567f30f1905c08;hpb=062db23d5eb303ef49d2ff805381229932f44246 diff --git a/extras/scsi_id/scsi_serial.c b/extras/scsi_id/scsi_serial.c index e0074b662..cbacf379f 100644 --- a/extras/scsi_id/scsi_serial.c +++ b/extras/scsi_id/scsi_serial.c @@ -5,24 +5,17 @@ * * Copyright (C) IBM Corp. 2003 * - * This library is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation; either version 2.1 of the - * License, or (at your option) any later version. + * Author: + * Patrick Mansfield * - * This library 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 - * USA + * 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 version 2 of the License. */ #include #include +#include #include #include #include @@ -30,11 +23,16 @@ #include #include #include -#include /* need __user when built via klibc */ +#include +#include #include -#include -#include "scsi_id.h" +#include +/* #include */ +#include "bsg.h" + +#include "../../udev/udev.h" #include "scsi.h" +#include "scsi_id.h" /* * A priority based list of id, naa, and binary/ascii for the identifier @@ -75,24 +73,24 @@ static const char hex_str[]="0123456789abcdef"; * are used here. */ -#define DID_NO_CONNECT 0x01 /* Unable to connect before timeout */ - -#define DID_BUS_BUSY 0x02 /* Bus remain busy until timeout */ -#define DID_TIME_OUT 0x03 /* Timed out for some other reason */ - -#define DRIVER_TIMEOUT 0x06 -#define DRIVER_SENSE 0x08 /* Sense_buffer has been set */ +#define DID_NO_CONNECT 0x01 /* Unable to connect before timeout */ +#define DID_BUS_BUSY 0x02 /* Bus remain busy until timeout */ +#define DID_TIME_OUT 0x03 /* Timed out for some other reason */ +#define DRIVER_TIMEOUT 0x06 +#define DRIVER_SENSE 0x08 /* Sense_buffer has been set */ /* The following "category" function returns one of the following */ -#define SG_ERR_CAT_CLEAN 0 /* No errors or other information */ -#define SG_ERR_CAT_MEDIA_CHANGED 1 /* interpreted from sense buffer */ -#define SG_ERR_CAT_RESET 2 /* interpreted from sense buffer */ -#define SG_ERR_CAT_TIMEOUT 3 -#define SG_ERR_CAT_RECOVERED 4 /* Successful command after recovered err */ -#define SG_ERR_CAT_SENSE 98 /* Something else in the sense buffer */ -#define SG_ERR_CAT_OTHER 99 /* Some other error/warning */ - -static int sg_err_category_new(int scsi_status, int msg_status, int +#define SG_ERR_CAT_CLEAN 0 /* No errors or other information */ +#define SG_ERR_CAT_MEDIA_CHANGED 1 /* interpreted from sense buffer */ +#define SG_ERR_CAT_RESET 2 /* interpreted from sense buffer */ +#define SG_ERR_CAT_TIMEOUT 3 +#define SG_ERR_CAT_RECOVERED 4 /* Successful command after recovered err */ +#define SG_ERR_CAT_NOTSUPPORTED 5 /* Illegal / unsupported command */ +#define SG_ERR_CAT_SENSE 98 /* Something else in the sense buffer */ +#define SG_ERR_CAT_OTHER 99 /* Some other error/warning */ + +static int sg_err_category_new(struct udev *udev, + int scsi_status, int msg_status, int host_status, int driver_status, const unsigned char *sense_buffer, int sb_len) { @@ -102,10 +100,7 @@ static int sg_err_category_new(int scsi_status, int msg_status, int * XXX change to return only two values - failed or OK. */ - /* - * checks msg_status - */ - if (!scsi_status && !msg_status && !host_status && !driver_status) + if (!scsi_status && !host_status && !driver_status) return SG_ERR_CAT_CLEAN; if ((scsi_status == SCSI_CHECK_CONDITION) || @@ -130,6 +125,8 @@ static int sg_err_category_new(int scsi_status, int msg_status, int return SG_ERR_CAT_MEDIA_CHANGED; if (0x29 == asc) return SG_ERR_CAT_RESET; + } else if (sense_key == ILLEGAL_REQUEST) { + return SG_ERR_CAT_NOTSUPPORTED; } } return SG_ERR_CAT_SENSE; @@ -147,18 +144,27 @@ static int sg_err_category_new(int scsi_status, int msg_status, int return SG_ERR_CAT_OTHER; } -static int sg_err_category3(struct sg_io_hdr *hp) +static int sg_err_category3(struct udev *udev, struct sg_io_hdr *hp) { - return sg_err_category_new(hp->status, hp->msg_status, + return sg_err_category_new(udev, + hp->status, hp->msg_status, hp->host_status, hp->driver_status, hp->sbp, hp->sb_len_wr); } -static int scsi_dump_sense(struct sysfs_device *scsi_dev, struct sg_io_hdr *io) +static int sg_err_category4(struct udev *udev, struct sg_io_v4 *hp) +{ + return sg_err_category_new(udev, hp->device_status, 0, + hp->transport_status, hp->driver_status, + (unsigned char *)(uintptr_t)hp->response, + hp->response_len); +} + +static int scsi_dump_sense(struct udev *udev, + struct scsi_id_device *dev_scsi, + unsigned char *sense_buffer, int sb_len) { - unsigned char *sense_buffer; int s; - int sb_len; int code; int sense_class; int sense_key; @@ -181,16 +187,13 @@ static int scsi_dump_sense(struct sysfs_device *scsi_dev, struct sg_io_hdr *io) * we'll retry the command. */ - dprintf("got check condition\n"); + dbg(udev, "got check condition\n"); - sb_len = io->sb_len_wr; if (sb_len < 1) { - log_message(LOG_WARNING, "%s: sense buffer empty\n", - scsi_dev->name); + info(udev, "%s: sense buffer empty\n", dev_scsi->kernel); return -1; } - sense_buffer = io->sbp; sense_class = (sense_buffer[0] >> 4) & 0x07; code = sense_buffer[0] & 0xf; @@ -200,10 +203,8 @@ static int scsi_dump_sense(struct sysfs_device *scsi_dev, struct sg_io_hdr *io) */ s = sense_buffer[7] + 8; if (sb_len < s) { - log_message(LOG_WARNING, - "%s: sense buffer too small %d bytes," - " %d bytes too short\n", scsi_dev->name, - sb_len, s - sb_len); + info(udev, "%s: sense buffer too small %d bytes, %d bytes too short\n", + dev_scsi->kernel, sb_len, s - sb_len); return -1; } if ((code == 0x0) || (code == 0x1)) { @@ -213,9 +214,8 @@ static int scsi_dump_sense(struct sysfs_device *scsi_dev, struct sg_io_hdr *io) /* * Possible? */ - log_message(LOG_WARNING, "%s: sense result too" - " small %d bytes\n", - scsi_dev->name, s); + info(udev, "%s: sense result too" " small %d bytes\n", + dev_scsi->kernel, s); return -1; } asc = sense_buffer[12]; @@ -226,163 +226,203 @@ static int scsi_dump_sense(struct sysfs_device *scsi_dev, struct sg_io_hdr *io) asc = sense_buffer[2]; ascq = sense_buffer[3]; } else { - log_message(LOG_WARNING, - "%s: invalid sense code 0x%x\n", - scsi_dev->name, code); + info(udev, "%s: invalid sense code 0x%x\n", + dev_scsi->kernel, code); return -1; } - log_message(LOG_WARNING, - "%s: sense key 0x%x ASC 0x%x ASCQ 0x%x\n", - scsi_dev->name, sense_key, asc, ascq); + info(udev, "%s: sense key 0x%x ASC 0x%x ASCQ 0x%x\n", + dev_scsi->kernel, sense_key, asc, ascq); } else { if (sb_len < 4) { - log_message(LOG_WARNING, - "%s: sense buffer too small %d bytes, %d bytes too short\n", - scsi_dev->name, sb_len, 4 - sb_len); + info(udev, "%s: sense buffer too small %d bytes, %d bytes too short\n", + dev_scsi->kernel, sb_len, 4 - sb_len); return -1; } if (sense_buffer[0] < 15) - log_message(LOG_WARNING, "%s: old sense key: 0x%x\n", - scsi_dev->name, sense_buffer[0] & 0x0f); + info(udev, "%s: old sense key: 0x%x\n", dev_scsi->kernel, sense_buffer[0] & 0x0f); else - log_message(LOG_WARNING, "%s: sense = %2x %2x\n", - scsi_dev->name, sense_buffer[0], - sense_buffer[2]); - log_message(LOG_WARNING, - "%s: non-extended sense class %d code 0x%0x\n", - scsi_dev->name, sense_class, code); + info(udev, "%s: sense = %2x %2x\n", + dev_scsi->kernel, sense_buffer[0], sense_buffer[2]); + info(udev, "%s: non-extended sense class %d code 0x%0x\n", + dev_scsi->kernel, sense_class, code); } #ifdef DUMP_SENSE for (i = 0, j = 0; (i < s) && (j < 254); i++) { - dprintf("i %d, j %d\n", i, j); + dbg(udev, "i %d, j %d\n", i, j); out_buffer[j++] = hex_str[(sense_buffer[i] & 0xf0) >> 4]; out_buffer[j++] = hex_str[sense_buffer[i] & 0x0f]; out_buffer[j++] = ' '; } out_buffer[j] = '\0'; - log_message(LOG_WARNING, "%s: sense dump:\n", scsi_dev->name); - log_message(LOG_WARNING, "%s: %s\n", scsi_dev->name, out_buffer); + info(udev, "%s: sense dump:\n", dev_scsi->kernel); + info(udev, "%s: %s\n", dev_scsi->kernel, out_buffer); #endif return -1; } -static int scsi_dump(struct sysfs_device *scsi_dev, struct sg_io_hdr *io) +static int scsi_dump(struct udev *udev, + struct scsi_id_device *dev_scsi, struct sg_io_hdr *io) { if (!io->status && !io->host_status && !io->msg_status && !io->driver_status) { /* * Impossible, should not be called. */ - log_message(LOG_WARNING, "%s: called with no error\n", - __FUNCTION__); + info(udev, "%s: called with no error\n", __FUNCTION__); return -1; } - log_message(LOG_WARNING, "%s: sg_io failed status 0x%x 0x%x 0x%x 0x%x\n", - scsi_dev->name, io->driver_status, io->host_status, - io->msg_status, io->status); + info(udev, "%s: sg_io failed status 0x%x 0x%x 0x%x 0x%x\n", + dev_scsi->kernel, io->driver_status, io->host_status, io->msg_status, io->status); if (io->status == SCSI_CHECK_CONDITION) - return scsi_dump_sense(scsi_dev, io); + return scsi_dump_sense(udev, dev_scsi, io->sbp, io->sb_len_wr); + else + return -1; +} + +static int scsi_dump_v4(struct udev *udev, + struct scsi_id_device *dev_scsi, struct sg_io_v4 *io) +{ + if (!io->device_status && !io->transport_status && + !io->driver_status) { + /* + * Impossible, should not be called. + */ + info(udev, "%s: called with no error\n", __FUNCTION__); + return -1; + } + + info(udev, "%s: sg_io failed status 0x%x 0x%x 0x%x\n", + dev_scsi->kernel, io->driver_status, io->transport_status, + io->device_status); + if (io->device_status == SCSI_CHECK_CONDITION) + return scsi_dump_sense(udev, dev_scsi, (unsigned char *)(uintptr_t)io->response, + io->response_len); else return -1; } -static int scsi_inquiry(struct sysfs_device *scsi_dev, int fd, unsigned - char evpd, unsigned char page, unsigned char *buf, - unsigned int buflen) +static int scsi_inquiry(struct udev *udev, + struct scsi_id_device *dev_scsi, int fd, + unsigned char evpd, unsigned char page, + unsigned char *buf, unsigned int buflen) { unsigned char inq_cmd[INQUIRY_CMDLEN] = { INQUIRY_CMD, evpd, page, 0, buflen, 0 }; unsigned char sense[SENSE_BUFF_LEN]; - struct sg_io_hdr io_hdr; + void *io_buf; int retval; - unsigned char *inq; - unsigned char *buffer; int retry = 3; /* rather random */ - if (buflen > 255) { - log_message(LOG_WARNING, "buflen %d too long\n", buflen); + if (buflen > SCSI_INQ_BUFF_LEN) { + info(udev, "buflen %d too long\n", buflen); return -1; } - inq = malloc(OFFSET + sizeof (inq_cmd) + 512); - memset(inq, 0, OFFSET + sizeof (inq_cmd) + 512); - buffer = inq + OFFSET; resend: - dprintf("%s evpd %d, page 0x%x\n", scsi_dev->name, evpd, page); - - memset(&io_hdr, 0, sizeof(struct sg_io_hdr)); - io_hdr.interface_id = 'S'; - io_hdr.cmd_len = sizeof(inq_cmd); - io_hdr.mx_sb_len = sizeof(sense); - io_hdr.dxfer_direction = SG_DXFER_FROM_DEV; - io_hdr.dxfer_len = buflen; - io_hdr.dxferp = buffer; - io_hdr.cmdp = inq_cmd; - io_hdr.sbp = sense; - io_hdr.timeout = DEF_TIMEOUT; - - if (ioctl(fd, SG_IO, &io_hdr) < 0) { - log_message(LOG_WARNING, "%s: ioctl failed: %s\n", - scsi_dev->name, strerror(errno)); - return -1; + dbg(udev, "%s evpd %d, page 0x%x\n", dev_scsi->kernel, evpd, page); + + if (dev_scsi->use_sg == 4) { + struct sg_io_v4 io_v4; + + memset(&io_v4, 0, sizeof(struct sg_io_v4)); + io_v4.guard = 'Q'; + io_v4.protocol = BSG_PROTOCOL_SCSI; + io_v4.subprotocol = BSG_SUB_PROTOCOL_SCSI_CMD; + io_v4.request_len = sizeof(inq_cmd); + io_v4.request = (uintptr_t)inq_cmd; + io_v4.max_response_len = sizeof(sense); + io_v4.response = (uintptr_t)sense; + io_v4.din_xfer_len = buflen; + io_v4.din_xferp = (uintptr_t)buf; + io_buf = (void *)&io_v4; + } else { + struct sg_io_hdr io_hdr; + + memset(&io_hdr, 0, sizeof(struct sg_io_hdr)); + io_hdr.interface_id = 'S'; + io_hdr.cmd_len = sizeof(inq_cmd); + io_hdr.mx_sb_len = sizeof(sense); + io_hdr.dxfer_direction = SG_DXFER_FROM_DEV; + io_hdr.dxfer_len = buflen; + io_hdr.dxferp = buf; + io_hdr.cmdp = inq_cmd; + io_hdr.sbp = sense; + io_hdr.timeout = DEF_TIMEOUT; + io_buf = (void *)&io_hdr; } - retval = sg_err_category3(&io_hdr); + retval = ioctl(fd, SG_IO, io_buf); + if (retval < 0) { + if ((errno == EINVAL || errno == ENOSYS) && dev_scsi->use_sg == 4) { + dev_scsi->use_sg = 3; + goto resend; + } + info(udev, "%s: ioctl failed: %s\n", dev_scsi->kernel, strerror(errno)); + goto error; + } + + if (dev_scsi->use_sg == 4) + retval = sg_err_category4(udev, io_buf); + else + retval = sg_err_category3(udev, io_buf); switch (retval) { + case SG_ERR_CAT_NOTSUPPORTED: + buf[1] = 0; + /* Fallthrough */ case SG_ERR_CAT_CLEAN: case SG_ERR_CAT_RECOVERED: retval = 0; break; default: - retval = scsi_dump(scsi_dev, &io_hdr); + if (dev_scsi->use_sg == 4) + retval = scsi_dump_v4(udev, dev_scsi, io_buf); + else + retval = scsi_dump(udev, dev_scsi, io_buf); } if (!retval) { retval = buflen; - memcpy(buf, buffer, retval); } else if (retval > 0) { if (--retry > 0) { - dprintf("%s: Retrying ...\n", scsi_dev->name); + dbg(udev, "%s: Retrying ...\n", dev_scsi->kernel); goto resend; } retval = -1; } +error: if (retval < 0) - log_message(LOG_WARNING, - "%s: Unable to get INQUIRY vpd %d page 0x%x.\n", - scsi_dev->name, evpd, page); + info(udev, "%s: Unable to get INQUIRY vpd %d page 0x%x.\n", + dev_scsi->kernel, evpd, page); - free(inq); return retval; } -static int do_scsi_page0_inquiry(struct sysfs_device *scsi_dev, int fd, - char *buffer, int len) +/* Get list of supported EVPD pages */ +static int do_scsi_page0_inquiry(struct udev *udev, + struct scsi_id_device *dev_scsi, int fd, + unsigned char *buffer, unsigned int len) { int retval; - char vendor[MAX_ATTR_LEN]; memset(buffer, 0, len); - retval = scsi_inquiry(scsi_dev, fd, 1, 0x0, buffer, len); + retval = scsi_inquiry(udev, dev_scsi, fd, 1, 0x0, buffer, len); if (retval < 0) return 1; if (buffer[1] != 0) { - log_message(LOG_WARNING, "%s: page 0 not available.\n", - scsi_dev->name); + info(udev, "%s: page 0 not available.\n", dev_scsi->kernel); return 1; } if (buffer[3] > len) { - log_message(LOG_WARNING, "%s: page 0 buffer too long %d\n", - scsi_dev->name, buffer[3]); + info(udev, "%s: page 0 buffer too long %d\n", dev_scsi->kernel, buffer[3]); return 1; } @@ -398,16 +438,8 @@ static int do_scsi_page0_inquiry(struct sysfs_device *scsi_dev, int fd, * If the vendor id appears in the page assume the page is * invalid. */ - if (sysfs_get_attr(scsi_dev->path, "vendor", vendor, - MAX_ATTR_LEN)) { - log_message(LOG_WARNING, - "%s: cannot get model attribute\n", - scsi_dev->name); - return 1; - } - if (!strncmp(&buffer[VENDOR_LENGTH], vendor, VENDOR_LENGTH)) { - log_message(LOG_WARNING, "%s: invalid page0 data\n", - scsi_dev->name); + if (!strncmp((char *)&buffer[VENDOR_LENGTH], dev_scsi->vendor, VENDOR_LENGTH)) { + info(udev, "%s: invalid page0 data\n", dev_scsi->kernel); return 1; } } @@ -418,44 +450,25 @@ static int do_scsi_page0_inquiry(struct sysfs_device *scsi_dev, int fd, * The caller checks that serial is long enough to include the vendor + * model. */ -static int prepend_vendor_model(struct sysfs_device *scsi_dev, char *serial) +static int prepend_vendor_model(struct udev *udev, + struct scsi_id_device *dev_scsi, char *serial) { - char attr[MAX_ATTR_LEN]; int ind; - if (sysfs_get_attr(scsi_dev->path, "vendor", attr, MAX_ATTR_LEN)) { - log_message(LOG_WARNING, "%s: cannot get vendor attribute\n", - scsi_dev->name); - return 1; - } - strncpy(serial, attr, VENDOR_LENGTH); + strncpy(serial, dev_scsi->vendor, VENDOR_LENGTH); ind = strlen(serial) - 1; - /* - * Remove sysfs added newlines. - */ - if (serial[ind] == '\n') - serial[ind] = '\0'; - if (sysfs_get_attr(scsi_dev->path, "model", attr, MAX_ATTR_LEN)) { - log_message(LOG_WARNING, "%s: cannot get model attribute\n", - scsi_dev->name); - return 1; - } - strncat(serial, attr, MODEL_LENGTH); + strncat(serial, dev_scsi->model, MODEL_LENGTH); ind = strlen(serial) - 1; - if (serial[ind] == '\n') - serial[ind] = '\0'; - else - ind++; + ind++; /* * This is not a complete check, since we are using strncat/cpy * above, ind will never be too large. */ if (ind != (VENDOR_LENGTH + MODEL_LENGTH)) { - log_message(LOG_WARNING, "%s: expected length %d, got length %d\n", - scsi_dev->name, (VENDOR_LENGTH + MODEL_LENGTH), - ind); + info(udev, "%s: expected length %d, got length %d\n", + dev_scsi->kernel, (VENDOR_LENGTH + MODEL_LENGTH), ind); return 1; } return ind; @@ -465,11 +478,13 @@ static int prepend_vendor_model(struct sysfs_device *scsi_dev, char *serial) * check_fill_0x83_id - check the page 0x83 id, if OK allocate and fill * serial number. **/ -static int check_fill_0x83_id(struct sysfs_device *scsi_dev, char - *page_83, const struct scsi_id_search_values - *id_search, char *serial, int max_len) +static int check_fill_0x83_id(struct udev *udev, + struct scsi_id_device *dev_scsi, + unsigned char *page_83, + const struct scsi_id_search_values + *id_search, char *serial, char *serial_short, int max_len) { - int i, j, len; + int i, j, s, len; /* * ASSOCIATION must be with the device (value 0) @@ -503,7 +518,7 @@ static int check_fill_0x83_id(struct sysfs_device *scsi_dev, char */ len *= 2; - /* + /* * Add one byte for the NUL termination, and one for the id_type. */ len += 2; @@ -511,8 +526,8 @@ static int check_fill_0x83_id(struct sysfs_device *scsi_dev, char len += VENDOR_LENGTH + MODEL_LENGTH; if (max_len < len) { - log_message(LOG_WARNING, "%s: length %d too short - need %d\n", - scsi_dev->name, max_len, len); + info(udev, "%s: length %d too short - need %d\n", + dev_scsi->kernel, max_len, len); return 1; } @@ -525,13 +540,13 @@ static int check_fill_0x83_id(struct sysfs_device *scsi_dev, char * included in the identifier. */ if (id_search->id_type == SCSI_ID_VENDOR_SPECIFIC) - if (prepend_vendor_model(scsi_dev, &serial[1]) < 0) { - dprintf("prepend failed\n"); + if (prepend_vendor_model(udev, dev_scsi, &serial[1]) < 0) { + dbg(udev, "prepend failed\n"); return 1; } i = 4; /* offset to the start of the identifier */ - j = strlen(serial); + s = j = strlen(serial); if ((page_83[0] & 0x0f) == SCSI_ID_ASCII) { /* * ASCII descriptor. @@ -549,24 +564,51 @@ static int check_fill_0x83_id(struct sysfs_device *scsi_dev, char i++; } } + + strcpy(serial_short, &serial[s]); return 0; } -static int do_scsi_page83_inquiry(struct sysfs_device *scsi_dev, int fd, - char *serial, int len) +/* Extract the raw binary from VPD 0x83 pre-SPC devices */ +static int check_fill_0x83_prespc3(struct udev *udev, + struct scsi_id_device *dev_scsi, + unsigned char *page_83, + const struct scsi_id_search_values + *id_search, char *serial, char *serial_short, int max_len) +{ + int i, j; + + dbg(udev, "using pre-spc3-83 for %s\n", dev_scsi->kernel); + serial[0] = hex_str[id_search->id_type]; + /* serial has been memset to zero before */ + j = strlen(serial); /* j = 1; */ + + for (i = 0; i < page_83[3]; ++i) { + serial[j++] = hex_str[(page_83[4+i] & 0xf0) >> 4]; + serial[j++] = hex_str[ page_83[4+i] & 0x0f]; + } + strcpy(serial_short, serial); + return 0; +} + + +/* Get device identification VPD page */ +static int do_scsi_page83_inquiry(struct udev *udev, + struct scsi_id_device *dev_scsi, int fd, + char *serial, char *serial_short, int len) { int retval; - int id_ind, j; - unsigned char page_83[256]; + unsigned int id_ind, j; + unsigned char page_83[SCSI_INQ_BUFF_LEN]; - memset(page_83, 0, 256); - retval = scsi_inquiry(scsi_dev, fd, 1, 0x83, page_83, 255); + memset(page_83, 0, SCSI_INQ_BUFF_LEN); + retval = scsi_inquiry(udev, dev_scsi, fd, 1, PAGE_83, page_83, + SCSI_INQ_BUFF_LEN); if (retval < 0) return 1; - if (page_83[1] != 0x83) { - log_message(LOG_WARNING, "%s: Invalid page 0x83\n", - scsi_dev->name); + if (page_83[1] != PAGE_83) { + info(udev, "%s: Invalid page 0x83\n", dev_scsi->kernel); return 1; } @@ -576,6 +618,34 @@ static int do_scsi_page83_inquiry(struct sysfs_device *scsi_dev, int fd, * the form: "1 ". */ + /* + * Model 4, 5, and (some) model 6 EMC Symmetrix devices return + * a page 83 reply according to SCSI-2 format instead of SPC-2/3. + * + * The SCSI-2 page 83 format returns an IEEE WWN in binary + * encoded hexi-decimal in the 16 bytes following the initial + * 4-byte page 83 reply header. + * + * Both the SPC-2 and SPC-3 formats return an IEEE WWN as part + * of an Identification descriptor. The 3rd byte of the first + * Identification descriptor is a reserved (BSZ) byte field. + * + * Reference the 7th byte of the page 83 reply to determine + * whether the reply is compliant with SCSI-2 or SPC-2/3 + * specifications. A zero value in the 7th byte indicates + * an SPC-2/3 conformant reply, (i.e., the reserved field of the + * first Identification descriptor). This byte will be non-zero + * for a SCSI-2 conformant page 83 reply from these EMC + * Symmetrix models since the 7th byte of the reply corresponds + * to the 4th and 5th nibbles of the 6-byte OUI for EMC, that is, + * 0x006048. + */ + + if (page_83[6] != 0) + return check_fill_0x83_prespc3(udev, + dev_scsi, page_83, id_search_list, + serial, serial_short, len); + /* * Search for a match in the prioritized id_search_list. */ @@ -586,53 +656,123 @@ static int do_scsi_page83_inquiry(struct sysfs_device *scsi_dev, int fd, * Examine each descriptor returned. There is normally only * one or a small number of descriptors. */ - for (j = 4; j <= page_83[3] + 3; - j += page_83[j + 3] + 4) { - retval = check_fill_0x83_id(scsi_dev, &page_83[j], + for (j = 4; j <= (unsigned int)page_83[3] + 3; j += page_83[j + 3] + 4) { + retval = check_fill_0x83_id(udev, + dev_scsi, &page_83[j], &id_search_list[id_ind], - serial, len); - dprintf("%s id desc %d/%d/%d\n", scsi_dev->name, + serial, serial_short, len); + dbg(udev, "%s id desc %d/%d/%d\n", dev_scsi->kernel, id_search_list[id_ind].id_type, id_search_list[id_ind].naa_type, id_search_list[id_ind].code_set); if (!retval) { - dprintf(" used\n"); + dbg(udev, " used\n"); return retval; } else if (retval < 0) { - dprintf(" failed\n"); + dbg(udev, " failed\n"); return retval; } else { - dprintf(" not used\n"); + dbg(udev, " not used\n"); } } } return 1; } -static int do_scsi_page80_inquiry(struct sysfs_device *scsi_dev, int fd, - char *serial, int max_len) +/* + * Get device identification VPD page for older SCSI-2 device which is not + * compliant with either SPC-2 or SPC-3 format. + * + * Return the hard coded error code value 2 if the page 83 reply is not + * conformant to the SCSI-2 format. + */ +static int do_scsi_page83_prespc3_inquiry(struct udev *udev, + struct scsi_id_device *dev_scsi, int fd, + char *serial, char *serial_short, int len) +{ + int retval; + int i, j; + unsigned char page_83[SCSI_INQ_BUFF_LEN]; + + memset(page_83, 0, SCSI_INQ_BUFF_LEN); + retval = scsi_inquiry(udev, dev_scsi, fd, 1, PAGE_83, page_83, SCSI_INQ_BUFF_LEN); + if (retval < 0) + return 1; + + if (page_83[1] != PAGE_83) { + info(udev, "%s: Invalid page 0x83\n", dev_scsi->kernel); + return 1; + } + /* + * Model 4, 5, and (some) model 6 EMC Symmetrix devices return + * a page 83 reply according to SCSI-2 format instead of SPC-2/3. + * + * The SCSI-2 page 83 format returns an IEEE WWN in binary + * encoded hexi-decimal in the 16 bytes following the initial + * 4-byte page 83 reply header. + * + * Both the SPC-2 and SPC-3 formats return an IEEE WWN as part + * of an Identification descriptor. The 3rd byte of the first + * Identification descriptor is a reserved (BSZ) byte field. + * + * Reference the 7th byte of the page 83 reply to determine + * whether the reply is compliant with SCSI-2 or SPC-2/3 + * specifications. A zero value in the 7th byte indicates + * an SPC-2/3 conformant reply, (i.e., the reserved field of the + * first Identification descriptor). This byte will be non-zero + * for a SCSI-2 conformant page 83 reply from these EMC + * Symmetrix models since the 7th byte of the reply corresponds + * to the 4th and 5th nibbles of the 6-byte OUI for EMC, that is, + * 0x006048. + */ + if (page_83[6] == 0) + return 2; + + serial[0] = hex_str[id_search_list[0].id_type]; + /* + * The first four bytes contain data, not a descriptor. + */ + i = 4; + j = strlen(serial); + /* + * Binary descriptor, convert to ASCII, + * using two bytes of ASCII for each byte + * in the page_83. + */ + while (i < (page_83[3]+4)) { + serial[j++] = hex_str[(page_83[i] & 0xf0) >> 4]; + serial[j++] = hex_str[page_83[i] & 0x0f]; + i++; + } + dbg(udev, "using pre-spc3-83 for %s\n", dev_scsi->kernel); + return 0; +} + +/* Get unit serial number VPD page */ +static int do_scsi_page80_inquiry(struct udev *udev, + struct scsi_id_device *dev_scsi, int fd, + char *serial, char *serial_short, int max_len) { int retval; int ser_ind; int i; int len; - unsigned char buf[256]; + unsigned char buf[SCSI_INQ_BUFF_LEN]; - memset(buf, 0, 256); - retval = scsi_inquiry(scsi_dev, fd, 1, 0x80, buf, 255); + memset(buf, 0, SCSI_INQ_BUFF_LEN); + retval = scsi_inquiry(udev, dev_scsi, fd, 1, PAGE_80, buf, SCSI_INQ_BUFF_LEN); if (retval < 0) return retval; - if (buf[1] != 0x80) { - log_message(LOG_WARNING, "%s: Invalid page 0x80\n", - scsi_dev->name); + if (buf[1] != PAGE_80) { + info(udev, "%s: Invalid page 0x80\n", dev_scsi->kernel); return 1; } len = 1 + VENDOR_LENGTH + MODEL_LENGTH + buf[3]; if (max_len < len) { - log_message(LOG_WARNING, "%s: length %d too short - need %d\n", - scsi_dev->name, max_len, len); + info(udev, "%s: length %d too short - need %d\n", + dev_scsi->kernel, max_len, len); return 1; } /* @@ -640,53 +780,128 @@ static int do_scsi_page80_inquiry(struct sysfs_device *scsi_dev, int fd, * specific type where we prepend '0' + vendor + model. */ serial[0] = 'S'; - ser_ind = prepend_vendor_model(scsi_dev, &serial[1]); + ser_ind = prepend_vendor_model(udev, dev_scsi, &serial[1]); if (ser_ind < 0) return 1; len = buf[3]; for (i = 4; i < len + 4; i++, ser_ind++) serial[ser_ind] = buf[i]; + memcpy(serial_short, &buf[4], len); + serial_short[len] = '\0'; return 0; } -int scsi_get_serial (struct sysfs_device *scsi_dev, const char *devname, - int page_code, char *serial, int len) +int scsi_std_inquiry(struct udev *udev, + struct scsi_id_device *dev_scsi, const char *devname) { - unsigned char page0[256]; int fd; - int ind; - int retval; + unsigned char buf[SCSI_INQ_BUFF_LEN]; + struct stat statbuf; + int err = 0; - if (len > 255) { - } - memset(serial, 0, len); - dprintf("opening %s\n", devname); + dbg(udev, "opening %s\n", devname); fd = open(devname, O_RDONLY | O_NONBLOCK); if (fd < 0) { - log_message(LOG_WARNING, "%s: cannot open %s: %s\n", - scsi_dev->name, devname, strerror(errno)); + info(udev, "scsi_id: cannot open %s: %s\n", + devname, strerror(errno)); return 1; } - if (page_code == 0x80) { - if (do_scsi_page80_inquiry(scsi_dev, fd, serial, len)) { + if (fstat(fd, &statbuf) < 0) { + info(udev, "scsi_id: cannot stat %s: %s\n", + devname, strerror(errno)); + err = 2; + goto out; + } + sprintf(dev_scsi->kernel,"%d:%d", major(statbuf.st_rdev), + minor(statbuf.st_rdev)); + + memset(buf, 0, SCSI_INQ_BUFF_LEN); + err = scsi_inquiry(udev, dev_scsi, fd, 0, 0, buf, SCSI_INQ_BUFF_LEN); + if (err < 0) + goto out; + + err = 0; + memcpy(dev_scsi->vendor, buf + 8, 8); + dev_scsi->vendor[8] = '\0'; + memcpy(dev_scsi->model, buf + 16, 16); + dev_scsi->model[16] = '\0'; + memcpy(dev_scsi->revision, buf + 32, 4); + dev_scsi->revision[4] = '\0'; + sprintf(dev_scsi->type,"%x", buf[0] & 0x1f); + +out: + close(fd); + return err; +} + +int scsi_get_serial(struct udev *udev, + struct scsi_id_device *dev_scsi, const char *devname, + int page_code, int len) +{ + unsigned char page0[SCSI_INQ_BUFF_LEN]; + int fd = -1; + int cnt = 10; + int ind; + int retval; + + memset(dev_scsi->serial, 0, len); + dbg(udev, "opening %s\n", devname); + while (--cnt) { + fd = open(devname, O_RDONLY | O_NONBLOCK); + if (fd >= 0) + break; + info(udev, "%s: cannot open %s: %s\n", dev_scsi->kernel, devname, strerror(errno)); + if (errno != EBUSY) + break; + usleep(500000 + (rand() % 100000) ); + } + if (fd < 0) + return 1; + + if (page_code == PAGE_80) { + if (do_scsi_page80_inquiry(udev, dev_scsi, fd, dev_scsi->serial, dev_scsi->serial_short, len)) { retval = 1; goto completed; } else { retval = 0; goto completed; } - } else if (page_code == 0x83) { - if (do_scsi_page83_inquiry(scsi_dev, fd, serial, len)) { + } else if (page_code == PAGE_83) { + if (do_scsi_page83_inquiry(udev, dev_scsi, fd, dev_scsi->serial, dev_scsi->serial_short, len)) { retval = 1; goto completed; } else { retval = 0; goto completed; } + } else if (page_code == PAGE_83_PRE_SPC3) { + retval = do_scsi_page83_prespc3_inquiry(udev, dev_scsi, fd, dev_scsi->serial, dev_scsi->serial_short, len); + if (retval) { + /* + * Fallback to servicing a SPC-2/3 compliant page 83 + * inquiry if the page 83 reply format does not + * conform to pre-SPC3 expectations. + */ + if (retval == 2) { + if (do_scsi_page83_inquiry(udev, dev_scsi, fd, dev_scsi->serial, dev_scsi->serial_short, len)) { + retval = 1; + goto completed; + } else { + retval = 0; + goto completed; + } + } + else { + retval = 1; + goto completed; + } + } else { + retval = 0; + goto completed; + } } else if (page_code != 0x00) { - log_message(LOG_WARNING, "%s: unsupported page code 0x%d\n", - scsi_dev->name, page_code); + info(udev, "%s: unsupported page code 0x%d\n", dev_scsi->kernel, page_code); return 1; } @@ -694,7 +909,7 @@ int scsi_get_serial (struct sysfs_device *scsi_dev, const char *devname, * Get page 0, the page of the pages. By default, try from best to * worst of supported pages: 0x83 then 0x80. */ - if (do_scsi_page0_inquiry(scsi_dev, fd, page0, 255)) { + if (do_scsi_page0_inquiry(udev, dev_scsi, fd, page0, SCSI_INQ_BUFF_LEN)) { /* * Don't try anything else. Black list if a specific page * should be used for this vendor+model, or maybe have an @@ -704,12 +919,12 @@ int scsi_get_serial (struct sysfs_device *scsi_dev, const char *devname, goto completed; } - dprintf("%s: Checking page0\n", scsi_dev->name); + dbg(udev, "%s: Checking page0\n", dev_scsi->kernel); for (ind = 4; ind <= page0[3] + 3; ind++) - if (page0[ind] == 0x83) - if (!do_scsi_page83_inquiry(scsi_dev, fd, serial, - len)) { + if (page0[ind] == PAGE_83) + if (!do_scsi_page83_inquiry(udev, dev_scsi, fd, + dev_scsi->serial, dev_scsi->serial_short, len)) { /* * Success */ @@ -718,9 +933,9 @@ int scsi_get_serial (struct sysfs_device *scsi_dev, const char *devname, } for (ind = 4; ind <= page0[3] + 3; ind++) - if (page0[ind] == 0x80) - if (!do_scsi_page80_inquiry(scsi_dev, fd, serial, - len)) { + if (page0[ind] == PAGE_80) + if (!do_scsi_page80_inquiry(udev, dev_scsi, fd, + dev_scsi->serial, dev_scsi->serial_short, len)) { /* * Success */ @@ -728,9 +943,8 @@ int scsi_get_serial (struct sysfs_device *scsi_dev, const char *devname, goto completed; } retval = 1; + completed: - if (close(fd) < 0) - log_message(LOG_WARNING, "%s: close failed: %s\n", - scsi_dev->name, strerror(errno)); + close(fd); return retval; }