extras/scsi_id/scsi_serial.c

   1 /*
   2  * scsi_serial.c
   3  *
   4  * Code related to requesting and getting an id from a scsi device
   5  *
   6  * Copyright (C) IBM Corp. 2003
   7  *
   8  * Author:
   9  *      Patrick Mansfield<patmans@us.ibm.com>
  10  *
  11  *      This program is free software; you can redistribute it and/or modify it
  12  *      under the terms of the GNU General Public License as published by the
  13  *      Free Software Foundation version 2 of the License.
  14  */
  15
  16 #include <sys/types.h>
  17 #include <sys/ioctl.h>
  18 #include <sys/stat.h>
  19 #include <stdio.h>
  20 #include <errno.h>
  21 #include <string.h>
  22 #include <fcntl.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <syslog.h>
  26 #include <inttypes.h>
  27 #include <scsi/scsi.h>
  28 #include <scsi/sg.h>
  29 #include <linux/types.h>
  30 /* #include <linux/bsg.h> */
  31 #include "bsg.h"
  32
  33 #include "../../udev/udev.h"
  34 #include "scsi.h"
  35 #include "scsi_id.h"
  36
  37 /*
  38  * A priority based list of id, naa, and binary/ascii for the identifier
  39  * descriptor in VPD page 0x83.
  40  *
  41  * Brute force search for a match starting with the first value in the
  42  * following id_search_list. This is not a performance issue, since there
  43  * is normally one or some small number of descriptors.
  44  */
  45 static const struct scsi_id_search_values id_search_list[] = {
  46         { SCSI_ID_NAA,  SCSI_ID_NAA_IEEE_REG_EXTENDED,  SCSI_ID_BINARY },
  47         { SCSI_ID_NAA,  SCSI_ID_NAA_IEEE_REG_EXTENDED,  SCSI_ID_ASCII },
  48         { SCSI_ID_NAA,  SCSI_ID_NAA_IEEE_REG,   SCSI_ID_BINARY },
  49         { SCSI_ID_NAA,  SCSI_ID_NAA_IEEE_REG,   SCSI_ID_ASCII },
  50         /*
  51          * Devices already exist using NAA values that are now marked
  52          * reserved. These should not conflict with other values, or it is
  53          * a bug in the device. As long as we find the IEEE extended one
  54          * first, we really don't care what other ones are used. Using
  55          * don't care here means that a device that returns multiple
  56          * non-IEEE descriptors in a random order will get different
  57          * names.
  58          */
  59         { SCSI_ID_NAA,  SCSI_ID_NAA_DONT_CARE,  SCSI_ID_BINARY },
  60         { SCSI_ID_NAA,  SCSI_ID_NAA_DONT_CARE,  SCSI_ID_ASCII },
  61         { SCSI_ID_EUI_64,       SCSI_ID_NAA_DONT_CARE,  SCSI_ID_BINARY },
  62         { SCSI_ID_EUI_64,       SCSI_ID_NAA_DONT_CARE,  SCSI_ID_ASCII },
  63         { SCSI_ID_T10_VENDOR,   SCSI_ID_NAA_DONT_CARE,  SCSI_ID_BINARY },
  64         { SCSI_ID_T10_VENDOR,   SCSI_ID_NAA_DONT_CARE,  SCSI_ID_ASCII },
  65         { SCSI_ID_VENDOR_SPECIFIC,      SCSI_ID_NAA_DONT_CARE,  SCSI_ID_BINARY },
  66         { SCSI_ID_VENDOR_SPECIFIC,      SCSI_ID_NAA_DONT_CARE,  SCSI_ID_ASCII },
  67 };
  68
  69 static const char hex_str[]="0123456789abcdef";
  70
  71 /*
  72  * Values returned in the result/status, only the ones used by the code
  73  * are used here.
  74  */
  75
  76 #define DID_NO_CONNECT                  0x01    /* Unable to connect before timeout */
  77 #define DID_BUS_BUSY                    0x02    /* Bus remain busy until timeout */
  78 #define DID_TIME_OUT                    0x03    /* Timed out for some other reason */
  79 #define DRIVER_TIMEOUT                  0x06
  80 #define DRIVER_SENSE                    0x08    /* Sense_buffer has been set */
  81
  82 /* The following "category" function returns one of the following */
  83 #define SG_ERR_CAT_CLEAN                0       /* No errors or other information */
  84 #define SG_ERR_CAT_MEDIA_CHANGED        1       /* interpreted from sense buffer */
  85 #define SG_ERR_CAT_RESET                2       /* interpreted from sense buffer */
  86 #define SG_ERR_CAT_TIMEOUT              3
  87 #define SG_ERR_CAT_RECOVERED            4       /* Successful command after recovered err */
  88 #define SG_ERR_CAT_NOTSUPPORTED         5       /* Illegal / unsupported command */
  89 #define SG_ERR_CAT_SENSE                98      /* Something else in the sense buffer */
  90 #define SG_ERR_CAT_OTHER                99      /* Some other error/warning */
  91
  92 static int sg_err_category_new(int scsi_status, int msg_status, int
  93                                host_status, int driver_status, const
  94                                unsigned char *sense_buffer, int sb_len)
  95 {
  96         scsi_status &= 0x7e;
  97
  98         /*
  99          * XXX change to return only two values - failed or OK.
 100          */
 101
 102         if (!scsi_status && !host_status && !driver_status)
 103                 return SG_ERR_CAT_CLEAN;
 104
 105         if ((scsi_status == SCSI_CHECK_CONDITION) ||
 106             (scsi_status == SCSI_COMMAND_TERMINATED) ||
 107             ((driver_status & 0xf) == DRIVER_SENSE)) {
 108                 if (sense_buffer && (sb_len > 2)) {
 109                         int sense_key;
 110                         unsigned char asc;
 111
 112                         if (sense_buffer[0] & 0x2) {
 113                                 sense_key = sense_buffer[1] & 0xf;
 114                                 asc = sense_buffer[2];
 115                         } else {
 116                                 sense_key = sense_buffer[2] & 0xf;
 117                                 asc = (sb_len > 12) ? sense_buffer[12] : 0;
 118                         }
 119
 120                         if (sense_key == RECOVERED_ERROR)
 121                                 return SG_ERR_CAT_RECOVERED;
 122                         else if (sense_key == UNIT_ATTENTION) {
 123                                 if (0x28 == asc)
 124                                         return SG_ERR_CAT_MEDIA_CHANGED;
 125                                 if (0x29 == asc)
 126                                         return SG_ERR_CAT_RESET;
 127                         } else if (sense_key == ILLEGAL_REQUEST) {
 128                                 return SG_ERR_CAT_NOTSUPPORTED;
 129                         }
 130                 }
 131                 return SG_ERR_CAT_SENSE;
 132         }
 133         if (!host_status) {
 134                 if ((host_status == DID_NO_CONNECT) ||
 135                     (host_status == DID_BUS_BUSY) ||
 136                     (host_status == DID_TIME_OUT))
 137                         return SG_ERR_CAT_TIMEOUT;
 138         }
 139         if (!driver_status) {
 140                 if (driver_status == DRIVER_TIMEOUT)
 141                         return SG_ERR_CAT_TIMEOUT;
 142         }
 143         return SG_ERR_CAT_OTHER;
 144 }
 145
 146 static int sg_err_category3(struct sg_io_hdr *hp)
 147 {
 148         return sg_err_category_new(hp->status, hp->msg_status,
 149                                    hp->host_status, hp->driver_status,
 150                                    hp->sbp, hp->sb_len_wr);
 151 }
 152
 153 static int sg_err_category4(struct sg_io_v4 *hp)
 154 {
 155         return sg_err_category_new(hp->device_status, 0,
 156                                    hp->transport_status, hp->driver_status,
 157                                    (unsigned char *)hp->response,
 158                                    hp->response_len);
 159 }
 160
 161 static int scsi_dump_sense(struct scsi_id_device *dev_scsi,
 162                            unsigned char *sense_buffer, int sb_len)
 163 {
 164         int s;
 165         int code;
 166         int sense_class;
 167         int sense_key;
 168         int descriptor_format;
 169         int asc, ascq;
 170 #ifdef DUMP_SENSE
 171         char out_buffer[256];
 172         int i, j;
 173 #endif
 174
 175         /*
 176          * Figure out and print the sense key, asc and ascq.
 177          *
 178          * If you want to suppress these for a particular drive model, add
 179          * a black list entry in the scsi_id config file.
 180          *
 181          * XXX We probably need to: lookup the sense/asc/ascq in a retry
 182          * table, and if found return 1 (after dumping the sense, asc, and
 183          * ascq). So, if/when we get something like a power on/reset,
 184          * we'll retry the command.
 185          */
 186
 187         dbg("got check condition\n");
 188
 189         if (sb_len < 1) {
 190                 info("%s: sense buffer empty\n", dev_scsi->kernel);
 191                 return -1;
 192         }
 193
 194         sense_class = (sense_buffer[0] >> 4) & 0x07;
 195         code = sense_buffer[0] & 0xf;
 196
 197         if (sense_class == 7) {
 198                 /*
 199                  * extended sense data.
 200                  */
 201                 s = sense_buffer[7] + 8;
 202                 if (sb_len < s) {
 203                         info("%s: sense buffer too small %d bytes, %d bytes too short\n",
 204                             dev_scsi->kernel, sb_len, s - sb_len);
 205                         return -1;
 206                 }
 207                 if ((code == 0x0) || (code == 0x1)) {
 208                         descriptor_format = 0;
 209                         sense_key = sense_buffer[2] & 0xf;
 210                         if (s < 14) {
 211                                 /*
 212                                  * Possible?
 213                                  */
 214                                 info("%s: sense result too" " small %d bytes\n",
 215                                     dev_scsi->kernel, s);
 216                                 return -1;
 217                         }
 218                         asc = sense_buffer[12];
 219                         ascq = sense_buffer[13];
 220                 } else if ((code == 0x2) || (code == 0x3)) {
 221                         descriptor_format = 1;
 222                         sense_key = sense_buffer[1] & 0xf;
 223                         asc = sense_buffer[2];
 224                         ascq = sense_buffer[3];
 225                 } else {
 226                         info("%s: invalid sense code 0x%x\n",
 227                             dev_scsi->kernel, code);
 228                         return -1;
 229                 }
 230                 info("%s: sense key 0x%x ASC 0x%x ASCQ 0x%x\n",
 231                     dev_scsi->kernel, sense_key, asc, ascq);
 232         } else {
 233                 if (sb_len < 4) {
 234                         info("%s: sense buffer too small %d bytes, %d bytes too short\n",
 235                             dev_scsi->kernel, sb_len, 4 - sb_len);
 236                         return -1;
 237                 }
 238
 239                 if (sense_buffer[0] < 15)
 240                         info("%s: old sense key: 0x%x\n", dev_scsi->kernel, sense_buffer[0] & 0x0f);
 241                 else
 242                         info("%s: sense = %2x %2x\n",
 243                             dev_scsi->kernel, sense_buffer[0], sense_buffer[2]);
 244                 info("%s: non-extended sense class %d code 0x%0x\n",
 245                     dev_scsi->kernel, sense_class, code);
 246
 247         }
 248
 249 #ifdef DUMP_SENSE
 250         for (i = 0, j = 0; (i < s) && (j < 254); i++) {
 251                 dbg("i %d, j %d\n", i, j);
 252                 out_buffer[j++] = hex_str[(sense_buffer[i] & 0xf0) >> 4];
 253                 out_buffer[j++] = hex_str[sense_buffer[i] & 0x0f];
 254                 out_buffer[j++] = ' ';
 255         }
 256         out_buffer[j] = '\0';
 257         info("%s: sense dump:\n", dev_scsi->kernel);
 258         info("%s: %s\n", dev_scsi->kernel, out_buffer);
 259
 260 #endif
 261         return -1;
 262 }
 263
 264 static int scsi_dump(struct scsi_id_device *dev_scsi, struct sg_io_hdr *io)
 265 {
 266         if (!io->status && !io->host_status && !io->msg_status &&
 267             !io->driver_status) {
 268                 /*
 269                  * Impossible, should not be called.
 270                  */
 271                 info("%s: called with no error\n", __FUNCTION__);
 272                 return -1;
 273         }
 274
 275         info("%s: sg_io failed status 0x%x 0x%x 0x%x 0x%x\n",
 276             dev_scsi->kernel, io->driver_status, io->host_status, io->msg_status, io->status);
 277         if (io->status == SCSI_CHECK_CONDITION)
 278                 return scsi_dump_sense(dev_scsi, io->sbp, io->sb_len_wr);
 279         else
 280                 return -1;
 281 }
 282
 283 static int scsi_dump_v4(struct scsi_id_device *dev_scsi, struct sg_io_v4 *io)
 284 {
 285         if (!io->device_status && !io->transport_status &&
 286             !io->driver_status) {
 287                 /*
 288                  * Impossible, should not be called.
 289                  */
 290                 info("%s: called with no error\n", __FUNCTION__);
 291                 return -1;
 292         }
 293
 294         info("%s: sg_io failed status 0x%x 0x%x 0x%x\n",
 295             dev_scsi->kernel, io->driver_status, io->transport_status,
 296              io->device_status);
 297         if (io->device_status == SCSI_CHECK_CONDITION)
 298                 return scsi_dump_sense(dev_scsi, (unsigned char *)io->response,
 299                                        io->response_len);
 300         else
 301                 return -1;
 302 }
 303
 304 static int scsi_inquiry(struct scsi_id_device *dev_scsi, int fd,
 305                         unsigned char evpd, unsigned char page,
 306                         unsigned char *buf, unsigned int buflen)
 307 {
 308         unsigned char inq_cmd[INQUIRY_CMDLEN] =
 309                 { INQUIRY_CMD, evpd, page, 0, buflen, 0 };
 310         unsigned char sense[SENSE_BUFF_LEN];
 311         void *io_buf;
 312         int retval;
 313         int retry = 3; /* rather random */
 314
 315         if (buflen > SCSI_INQ_BUFF_LEN) {
 316                 info("buflen %d too long\n", buflen);
 317                 return -1;
 318         }
 319
 320 resend:
 321         dbg("%s evpd %d, page 0x%x\n", dev_scsi->kernel, evpd, page);
 322
 323         if (dev_scsi->use_sg == 4) {
 324                 struct sg_io_v4 io_v4;
 325
 326                 memset(&io_v4, 0, sizeof(struct sg_io_v4));
 327                 io_v4.guard = 'Q';
 328                 io_v4.protocol = BSG_PROTOCOL_SCSI;
 329                 io_v4.subprotocol = BSG_SUB_PROTOCOL_SCSI_CMD;
 330                 io_v4.request_len = sizeof(inq_cmd);
 331                 io_v4.request = (uintptr_t)inq_cmd;
 332                 io_v4.max_response_len = sizeof(sense);
 333                 io_v4.response = (uintptr_t)sense;
 334                 io_v4.din_xfer_len = buflen;
 335                 io_v4.din_xferp = (uintptr_t)buf;
 336                 io_buf = (void *)&io_v4;
 337         } else {
 338                 struct sg_io_hdr io_hdr;
 339
 340                 memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
 341                 io_hdr.interface_id = 'S';
 342                 io_hdr.cmd_len = sizeof(inq_cmd);
 343                 io_hdr.mx_sb_len = sizeof(sense);
 344                 io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
 345                 io_hdr.dxfer_len = buflen;
 346                 io_hdr.dxferp = buf;
 347                 io_hdr.cmdp = inq_cmd;
 348                 io_hdr.sbp = sense;
 349                 io_hdr.timeout = DEF_TIMEOUT;
 350                 io_buf = (void *)&io_hdr;
 351         }
 352
 353         retval = ioctl(fd, SG_IO, io_buf);
 354         if (retval < 0) {
 355                 if ((errno == EINVAL || errno == ENOSYS) && dev_scsi->use_sg == 4) {
 356                         dev_scsi->use_sg = 3;
 357                         goto resend;
 358                 }
 359                 info("%s: ioctl failed: %s\n", dev_scsi->kernel, strerror(errno));
 360                 goto error;
 361         }
 362
 363         if (dev_scsi->use_sg == 4)
 364                 retval = sg_err_category4(io_buf);
 365         else
 366                 retval = sg_err_category3(io_buf);
 367
 368         switch (retval) {
 369                 case SG_ERR_CAT_NOTSUPPORTED:
 370                         buf[1] = 0;
 371                         /* Fallthrough */
 372                 case SG_ERR_CAT_CLEAN:
 373                 case SG_ERR_CAT_RECOVERED:
 374                         retval = 0;
 375                         break;
 376
 377                 default:
 378                         if (dev_scsi->use_sg == 4)
 379                                 retval = scsi_dump_v4(dev_scsi, io_buf);
 380                         else
 381                                 retval = scsi_dump(dev_scsi, io_buf);
 382         }
 383
 384         if (!retval) {
 385                 retval = buflen;
 386         } else if (retval > 0) {
 387                 if (--retry > 0) {
 388                         dbg("%s: Retrying ...\n", dev_scsi->kernel);
 389                         goto resend;
 390                 }
 391                 retval = -1;
 392         }
 393
 394 error:
 395         if (retval < 0)
 396                 info("%s: Unable to get INQUIRY vpd %d page 0x%x.\n",
 397                     dev_scsi->kernel, evpd, page);
 398
 399         return retval;
 400 }
 401
 402 /* Get list of supported EVPD pages */
 403 static int do_scsi_page0_inquiry(struct scsi_id_device *dev_scsi, int fd,
 404                                  unsigned char *buffer, unsigned int len)
 405 {
 406         int retval;
 407
 408         memset(buffer, 0, len);
 409         retval = scsi_inquiry(dev_scsi, fd, 1, 0x0, buffer, len);
 410         if (retval < 0)
 411                 return 1;
 412
 413         if (buffer[1] != 0) {
 414                 info("%s: page 0 not available.\n", dev_scsi->kernel);
 415                 return 1;
 416         }
 417         if (buffer[3] > len) {
 418                 info("%s: page 0 buffer too long %d\n", dev_scsi->kernel,  buffer[3]);
 419                 return 1;
 420         }
 421
 422         /*
 423          * Following check is based on code once included in the 2.5.x
 424          * kernel.
 425          *
 426          * Some ill behaved devices return the standard inquiry here
 427          * rather than the evpd data, snoop the data to verify.
 428          */
 429         if (buffer[3] > MODEL_LENGTH) {
 430                 /*
 431                  * If the vendor id appears in the page assume the page is
 432                  * invalid.
 433                  */
 434                 if (!strncmp((char *)&buffer[VENDOR_LENGTH], dev_scsi->vendor, VENDOR_LENGTH)) {
 435                         info("%s: invalid page0 data\n", dev_scsi->kernel);
 436                         return 1;
 437                 }
 438         }
 439         return 0;
 440 }
 441
 442 /*
 443  * The caller checks that serial is long enough to include the vendor +
 444  * model.
 445  */
 446 static int prepend_vendor_model(struct scsi_id_device *dev_scsi, char *serial)
 447 {
 448         int ind;
 449
 450         strncpy(serial, dev_scsi->vendor, VENDOR_LENGTH);
 451         ind = strlen(serial) - 1;
 452
 453         strncat(serial, dev_scsi->model, MODEL_LENGTH);
 454         ind = strlen(serial) - 1;
 455         ind++;
 456
 457         /*
 458          * This is not a complete check, since we are using strncat/cpy
 459          * above, ind will never be too large.
 460          */
 461         if (ind != (VENDOR_LENGTH + MODEL_LENGTH)) {
 462                 info("%s: expected length %d, got length %d\n",
 463                      dev_scsi->kernel, (VENDOR_LENGTH + MODEL_LENGTH), ind);
 464                 return 1;
 465         }
 466         return ind;
 467 }
 468
 469 /**
 470  * check_fill_0x83_id - check the page 0x83 id, if OK allocate and fill
 471  * serial number.
 472  **/
 473 static int check_fill_0x83_id(struct scsi_id_device *dev_scsi,
 474                               unsigned char *page_83,
 475                               const struct scsi_id_search_values
 476                               *id_search, char *serial, char *serial_short, int max_len)
 477 {
 478         int i, j, s, len;
 479
 480         /*
 481          * ASSOCIATION must be with the device (value 0)
 482          */
 483         if ((page_83[1] & 0x30) != 0)
 484                 return 1;
 485
 486         if ((page_83[1] & 0x0f) != id_search->id_type)
 487                 return 1;
 488
 489         /*
 490          * Possibly check NAA sub-type.
 491          */
 492         if ((id_search->naa_type != SCSI_ID_NAA_DONT_CARE) &&
 493             (id_search->naa_type != (page_83[4] & 0xf0) >> 4))
 494                 return 1;
 495
 496         /*
 497          * Check for matching code set - ASCII or BINARY.
 498          */
 499         if ((page_83[0] & 0x0f) != id_search->code_set)
 500                 return 1;
 501
 502         /*
 503          * page_83[3]: identifier length
 504          */
 505         len = page_83[3];
 506         if ((page_83[0] & 0x0f) != SCSI_ID_ASCII)
 507                 /*
 508                  * If not ASCII, use two bytes for each binary value.
 509                  */
 510                 len *= 2;
 511
 512         /*
 513          * Add one byte for the NUL termination, and one for the id_type.
 514          */
 515         len += 2;
 516         if (id_search->id_type == SCSI_ID_VENDOR_SPECIFIC)
 517                 len += VENDOR_LENGTH + MODEL_LENGTH;
 518
 519         if (max_len < len) {
 520                 info("%s: length %d too short - need %d\n",
 521                     dev_scsi->kernel, max_len, len);
 522                 return 1;
 523         }
 524
 525         serial[0] = hex_str[id_search->id_type];
 526
 527         /*
 528          * For SCSI_ID_VENDOR_SPECIFIC prepend the vendor and model before
 529          * the id since it is not unique across all vendors and models,
 530          * this differs from SCSI_ID_T10_VENDOR, where the vendor is
 531          * included in the identifier.
 532          */
 533         if (id_search->id_type == SCSI_ID_VENDOR_SPECIFIC)
 534                 if (prepend_vendor_model(dev_scsi, &serial[1]) < 0) {
 535                         dbg("prepend failed\n");
 536                         return 1;
 537                 }
 538
 539         i = 4; /* offset to the start of the identifier */
 540         s = j = strlen(serial);
 541         if ((page_83[0] & 0x0f) == SCSI_ID_ASCII) {
 542                 /*
 543                  * ASCII descriptor.
 544                  */
 545                 while (i < (4 + page_83[3]))
 546                         serial[j++] = page_83[i++];
 547         } else {
 548                 /*
 549                  * Binary descriptor, convert to ASCII, using two bytes of
 550                  * ASCII for each byte in the page_83.
 551                  */
 552                 while (i < (4 + page_83[3])) {
 553                         serial[j++] = hex_str[(page_83[i] & 0xf0) >> 4];
 554                         serial[j++] = hex_str[page_83[i] & 0x0f];
 555                         i++;
 556                 }
 557         }
 558
 559         strcpy(serial_short, &serial[s]);
 560         return 0;
 561 }
 562
 563 /* Extract the raw binary from VPD 0x83 pre-SPC devices */
 564 static int check_fill_0x83_prespc3(struct scsi_id_device *dev_scsi,
 565                                    unsigned char *page_83,
 566                                    const struct scsi_id_search_values
 567                                    *id_search, char *serial, char *serial_short, int max_len)
 568 {
 569         int i, j;
 570
 571         dbg("using pre-spc3-83 for %s\n", dev_scsi->kernel);
 572         serial[0] = hex_str[id_search->id_type];
 573         /* serial has been memset to zero before */
 574         j = strlen(serial);     /* j = 1; */
 575
 576         for (i = 0; i < page_83[3]; ++i) {
 577                 serial[j++] = hex_str[(page_83[4+i] & 0xf0) >> 4];
 578                 serial[j++] = hex_str[ page_83[4+i] & 0x0f];
 579         }
 580         strcpy(serial_short, serial);
 581         return 0;
 582 }
 583
 584
 585 /* Get device identification VPD page */
 586 static int do_scsi_page83_inquiry(struct scsi_id_device *dev_scsi, int fd,
 587                                   char *serial, char *serial_short, int len)
 588 {
 589         int retval;
 590         unsigned int id_ind, j;
 591         unsigned char page_83[SCSI_INQ_BUFF_LEN];
 592
 593         memset(page_83, 0, SCSI_INQ_BUFF_LEN);
 594         retval = scsi_inquiry(dev_scsi, fd, 1, PAGE_83, page_83,
 595                               SCSI_INQ_BUFF_LEN);
 596         if (retval < 0)
 597                 return 1;
 598
 599         if (page_83[1] != PAGE_83) {
 600                 info("%s: Invalid page 0x83\n", dev_scsi->kernel);
 601                 return 1;
 602         }
 603
 604         /*
 605          * XXX Some devices (IBM 3542) return all spaces for an identifier if
 606          * the LUN is not actually configured. This leads to identifers of
 607          * the form: "1            ".
 608          */
 609
 610         /*
 611          * Model 4, 5, and (some) model 6 EMC Symmetrix devices return
 612          * a page 83 reply according to SCSI-2 format instead of SPC-2/3.
 613          *
 614          * The SCSI-2 page 83 format returns an IEEE WWN in binary
 615          * encoded hexi-decimal in the 16 bytes following the initial
 616          * 4-byte page 83 reply header.
 617          *
 618          * Both the SPC-2 and SPC-3 formats return an IEEE WWN as part
 619          * of an Identification descriptor.  The 3rd byte of the first
 620          * Identification descriptor is a reserved (BSZ) byte field.
 621          *
 622          * Reference the 7th byte of the page 83 reply to determine
 623          * whether the reply is compliant with SCSI-2 or SPC-2/3
 624          * specifications.  A zero value in the 7th byte indicates
 625          * an SPC-2/3 conformant reply, (i.e., the reserved field of the
 626          * first Identification descriptor).  This byte will be non-zero
 627          * for a SCSI-2 conformant page 83 reply from these EMC
 628          * Symmetrix models since the 7th byte of the reply corresponds
 629          * to the 4th and 5th nibbles of the 6-byte OUI for EMC, that is,
 630          * 0x006048.
 631          */
 632
 633         if (page_83[6] != 0)
 634                 return check_fill_0x83_prespc3(dev_scsi, page_83, id_search_list,
 635                                                serial, serial_short, len);
 636
 637         /*
 638          * Search for a match in the prioritized id_search_list.
 639          */
 640         for (id_ind = 0;
 641              id_ind < sizeof(id_search_list)/sizeof(id_search_list[0]);
 642              id_ind++) {
 643                 /*
 644                  * Examine each descriptor returned. There is normally only
 645                  * one or a small number of descriptors.
 646                  */
 647                 for (j = 4; j <= (unsigned int)page_83[3] + 3; j += page_83[j + 3] + 4) {
 648                         retval = check_fill_0x83_id(dev_scsi, &page_83[j],
 649                                                     &id_search_list[id_ind],
 650                                                     serial, serial_short, len);
 651                         dbg("%s id desc %d/%d/%d\n", dev_scsi->kernel,
 652                                 id_search_list[id_ind].id_type,
 653                                 id_search_list[id_ind].naa_type,
 654                                 id_search_list[id_ind].code_set);
 655                         if (!retval) {
 656                                 dbg("  used\n");
 657                                 return retval;
 658                         } else if (retval < 0) {
 659                                 dbg("  failed\n");
 660                                 return retval;
 661                         } else {
 662                                 dbg("  not used\n");
 663                         }
 664                 }
 665         }
 666         return 1;
 667 }
 668
 669 /*
 670  * Get device identification VPD page for older SCSI-2 device which is not
 671  * compliant with either SPC-2 or SPC-3 format.
 672  *
 673  * Return the hard coded error code value 2 if the page 83 reply is not
 674  * conformant to the SCSI-2 format.
 675  */
 676 static int do_scsi_page83_prespc3_inquiry(struct scsi_id_device *dev_scsi, int fd,
 677                                           char *serial, char *serial_short, int len)
 678 {
 679         int retval;
 680         int i, j;
 681         unsigned char page_83[SCSI_INQ_BUFF_LEN];
 682
 683         memset(page_83, 0, SCSI_INQ_BUFF_LEN);
 684         retval = scsi_inquiry(dev_scsi, fd, 1, PAGE_83, page_83, SCSI_INQ_BUFF_LEN);
 685         if (retval < 0)
 686                 return 1;
 687
 688         if (page_83[1] != PAGE_83) {
 689                 info("%s: Invalid page 0x83\n", dev_scsi->kernel);
 690                 return 1;
 691         }
 692         /*
 693          * Model 4, 5, and (some) model 6 EMC Symmetrix devices return
 694          * a page 83 reply according to SCSI-2 format instead of SPC-2/3.
 695          *
 696          * The SCSI-2 page 83 format returns an IEEE WWN in binary
 697          * encoded hexi-decimal in the 16 bytes following the initial
 698          * 4-byte page 83 reply header.
 699          *
 700          * Both the SPC-2 and SPC-3 formats return an IEEE WWN as part
 701          * of an Identification descriptor.  The 3rd byte of the first
 702          * Identification descriptor is a reserved (BSZ) byte field.
 703          *
 704          * Reference the 7th byte of the page 83 reply to determine
 705          * whether the reply is compliant with SCSI-2 or SPC-2/3
 706          * specifications.  A zero value in the 7th byte indicates
 707          * an SPC-2/3 conformant reply, (i.e., the reserved field of the
 708          * first Identification descriptor).  This byte will be non-zero
 709          * for a SCSI-2 conformant page 83 reply from these EMC
 710          * Symmetrix models since the 7th byte of the reply corresponds
 711          * to the 4th and 5th nibbles of the 6-byte OUI for EMC, that is,
 712          * 0x006048.
 713          */
 714         if (page_83[6] == 0)
 715                 return 2;
 716
 717         serial[0] = hex_str[id_search_list[0].id_type];
 718         /*
 719          * The first four bytes contain data, not a descriptor.
 720          */
 721         i = 4;
 722         j = strlen(serial);
 723         /*
 724          * Binary descriptor, convert to ASCII,
 725          * using two bytes of ASCII for each byte
 726          * in the page_83.
 727          */
 728         while (i < (page_83[3]+4)) {
 729                 serial[j++] = hex_str[(page_83[i] & 0xf0) >> 4];
 730                 serial[j++] = hex_str[page_83[i] & 0x0f];
 731                 i++;
 732         }
 733         dbg("using pre-spc3-83 for %s\n", dev_scsi->kernel);
 734         return 0;
 735 }
 736
 737 /* Get unit serial number VPD page */
 738 static int do_scsi_page80_inquiry(struct scsi_id_device *dev_scsi, int fd,
 739                                   char *serial, char *serial_short, int max_len)
 740 {
 741         int retval;
 742         int ser_ind;
 743         int i;
 744         int len;
 745         unsigned char buf[SCSI_INQ_BUFF_LEN];
 746
 747         memset(buf, 0, SCSI_INQ_BUFF_LEN);
 748         retval = scsi_inquiry(dev_scsi, fd, 1, PAGE_80, buf, SCSI_INQ_BUFF_LEN);
 749         if (retval < 0)
 750                 return retval;
 751
 752         if (buf[1] != PAGE_80) {
 753                 info("%s: Invalid page 0x80\n", dev_scsi->kernel);
 754                 return 1;
 755         }
 756
 757         len = 1 + VENDOR_LENGTH + MODEL_LENGTH + buf[3];
 758         if (max_len < len) {
 759                 info("%s: length %d too short - need %d\n",
 760                     dev_scsi->kernel, max_len, len);
 761                 return 1;
 762         }
 763         /*
 764          * Prepend 'S' to avoid unlikely collision with page 0x83 vendor
 765          * specific type where we prepend '0' + vendor + model.
 766          */
 767         serial[0] = 'S';
 768         ser_ind = prepend_vendor_model(dev_scsi, &serial[1]);
 769         if (ser_ind < 0)
 770                 return 1;
 771         len = buf[3];
 772         for (i = 4; i < len + 4; i++, ser_ind++)
 773                 serial[ser_ind] = buf[i];
 774         memcpy(serial_short, &buf[4], len);
 775         serial_short[len] = '\0';
 776         return 0;
 777 }
 778
 779 int scsi_std_inquiry(struct scsi_id_device *dev_scsi, const char *devname)
 780 {
 781         int fd;
 782         unsigned char buf[SCSI_INQ_BUFF_LEN];
 783         struct stat statbuf;
 784         int err = 0;
 785
 786         dbg("opening %s\n", devname);
 787         fd = open(devname, O_RDONLY | O_NONBLOCK);
 788         if (fd < 0) {
 789                 info("scsi_id: cannot open %s: %s\n",
 790                      devname, strerror(errno));
 791                 return 1;
 792         }
 793
 794         if (fstat(fd, &statbuf) < 0) {
 795                 info("scsi_id: cannot stat %s: %s\n",
 796                      devname, strerror(errno));
 797                 err = 2;
 798                 goto out;
 799         }
 800         sprintf(dev_scsi->kernel,"%d:%d", major(statbuf.st_rdev),
 801                 minor(statbuf.st_rdev));
 802
 803         memset(buf, 0, SCSI_INQ_BUFF_LEN);
 804         err = scsi_inquiry(dev_scsi, fd, 0, 0, buf, SCSI_INQ_BUFF_LEN);
 805         if (err < 0)
 806                 goto out;
 807
 808         err = 0;
 809         memcpy(dev_scsi->vendor, buf + 8, 8);
 810         dev_scsi->vendor[8] = '\0';
 811         memcpy(dev_scsi->model, buf + 16, 16);
 812         dev_scsi->model[16] = '\0';
 813         memcpy(dev_scsi->revision, buf + 32, 4);
 814         dev_scsi->revision[4] = '\0';
 815         sprintf(dev_scsi->type,"%x", buf[0] & 0x1f);
 816
 817 out:
 818         close(fd);
 819         return err;
 820 }
 821
 822 int scsi_get_serial (struct scsi_id_device *dev_scsi, const char *devname,
 823                      int page_code, char *serial_short, int len)
 824 {
 825         unsigned char page0[SCSI_INQ_BUFF_LEN];
 826         int fd = -1;
 827         int cnt = 10;
 828         int ind;
 829         int retval;
 830
 831         memset(dev_scsi->serial, 0, len);
 832         dbg("opening %s\n", devname);
 833         while (--cnt) {
 834                 fd = open(devname, O_RDONLY | O_NONBLOCK);
 835                 if (fd >= 0)
 836                         break;
 837                 info("%s: cannot open %s: %s\n", dev_scsi->kernel, devname, strerror(errno));
 838                 if (errno != EBUSY)
 839                         break;
 840                 usleep(500000 + (rand() % 100000) );
 841         }
 842         if (fd < 0)
 843                 return 1;
 844
 845         if (page_code == PAGE_80) {
 846                 if (do_scsi_page80_inquiry(dev_scsi, fd, dev_scsi->serial, serial_short, len)) {
 847                         retval = 1;
 848                         goto completed;
 849                 } else  {
 850                         retval = 0;
 851                         goto completed;
 852                 }
 853         } else if (page_code == PAGE_83) {
 854                 if (do_scsi_page83_inquiry(dev_scsi, fd, dev_scsi->serial, serial_short, len)) {
 855                         retval = 1;
 856                         goto completed;
 857                 } else  {
 858                         retval = 0;
 859                         goto completed;
 860                 }
 861         } else if (page_code == PAGE_83_PRE_SPC3) {
 862                 retval = do_scsi_page83_prespc3_inquiry(dev_scsi, fd, dev_scsi->serial, serial_short, len);
 863                 if (retval) {
 864                         /*
 865                          * Fallback to servicing a SPC-2/3 compliant page 83
 866                          * inquiry if the page 83 reply format does not
 867                          * conform to pre-SPC3 expectations.
 868                          */
 869                         if (retval == 2) {
 870                                 if (do_scsi_page83_inquiry(dev_scsi, fd, dev_scsi->serial, serial_short, len)) {
 871                                         retval = 1;
 872                                         goto completed;
 873                                 } else  {
 874                                         retval = 0;
 875                                         goto completed;
 876                                 }
 877                         }
 878                         else {
 879                                 retval = 1;
 880                                 goto completed;
 881                         }
 882                 } else  {
 883                         retval = 0;
 884                         goto completed;
 885                 }
 886         } else if (page_code != 0x00) {
 887                 info("%s: unsupported page code 0x%d\n", dev_scsi->kernel, page_code);
 888                 return 1;
 889         }
 890
 891         /*
 892          * Get page 0, the page of the pages. By default, try from best to
 893          * worst of supported pages: 0x83 then 0x80.
 894          */
 895         if (do_scsi_page0_inquiry(dev_scsi, fd, page0, SCSI_INQ_BUFF_LEN)) {
 896                 /*
 897                  * Don't try anything else. Black list if a specific page
 898                  * should be used for this vendor+model, or maybe have an
 899                  * optional fall-back to page 0x80 or page 0x83.
 900                  */
 901                 retval = 1;
 902                 goto completed;
 903         }
 904
 905         dbg("%s: Checking page0\n", dev_scsi->kernel);
 906
 907         for (ind = 4; ind <= page0[3] + 3; ind++)
 908                 if (page0[ind] == PAGE_83)
 909                         if (!do_scsi_page83_inquiry(dev_scsi, fd,
 910                                                     dev_scsi->serial, serial_short, len)) {
 911                                 /*
 912                                  * Success
 913                                  */
 914                                 retval = 0;
 915                                 goto completed;
 916                         }
 917
 918         for (ind = 4; ind <= page0[3] + 3; ind++)
 919                 if (page0[ind] == PAGE_80)
 920                         if (!do_scsi_page80_inquiry(dev_scsi, fd,
 921                                                     dev_scsi->serial, serial_short, len)) {
 922                                 /*
 923                                  * Success
 924                                  */
 925                                 retval = 0;
 926                                 goto completed;
 927                         }
 928         retval = 1;
 929
 930 completed:
 931         close(fd);
 932         return retval;
 933 }