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