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 <stdio.h>
  19 #include <errno.h>
  20 #include <string.h>
  21 #include <fcntl.h>
  22 #include <stdlib.h>
  23 #include <unistd.h>
  24 #include <syslog.h>
  25 #include <inttypes.h>
  26 #include <scsi/scsi.h>
  27 #include <scsi/sg.h>
  28 #include <linux/types.h>
  29 /* #include <linux/bsg.h> */
  30 #include "bsg.h"
  31
  32 #include "../../udev.h"
  33 #include "scsi.h"
  34 #include "scsi_id.h"
  35 #include "scsi_id_version.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         struct sg_io_hdr io_hdr;
 312         struct sg_io_v4 io_v4;
 313         void *io_buf;
 314         int retval;
 315         int retry = 3; /* rather random */
 316
 317         if (buflen > SCSI_INQ_BUFF_LEN) {
 318                 info("buflen %d too long\n", buflen);
 319                 return -1;
 320         }
 321
 322 resend:
 323         dbg("%s evpd %d, page 0x%x\n", dev_scsi->kernel, evpd, page);
 324
 325         if (dev_scsi->use_sg == 4) {
 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                 memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
 339                 io_hdr.interface_id = 'S';
 340                 io_hdr.cmd_len = sizeof(inq_cmd);
 341                 io_hdr.mx_sb_len = sizeof(sense);
 342                 io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
 343                 io_hdr.dxfer_len = buflen;
 344                 io_hdr.dxferp = buf;
 345                 io_hdr.cmdp = inq_cmd;
 346                 io_hdr.sbp = sense;
 347                 io_hdr.timeout = DEF_TIMEOUT;
 348                 io_buf = (void *)&io_hdr;
 349         }
 350
 351         if (ioctl(fd, SG_IO, io_buf) < 0) {
 352                 if (errno == EINVAL && dev_scsi->use_sg == 4) {
 353                         dev_scsi->use_sg = 3;
 354                         goto resend;
 355                 }
 356                 info("%s: ioctl failed: %s\n", dev_scsi->kernel, strerror(errno));
 357                 retval = -1;
 358                 goto error;
 359         }
 360
 361         if (dev_scsi->use_sg == 4)
 362                 retval = sg_err_category4(io_buf);
 363         else
 364                 retval = sg_err_category3(io_buf);
 365
 366         switch (retval) {
 367                 case SG_ERR_CAT_NOTSUPPORTED:
 368                         buf[1] = 0;
 369                         /* Fallthrough */
 370                 case SG_ERR_CAT_CLEAN:
 371                 case SG_ERR_CAT_RECOVERED:
 372                         retval = 0;
 373                         break;
 374
 375                 default:
 376                         if (dev_scsi->use_sg == 4)
 377                                 retval = scsi_dump_v4(dev_scsi, io_buf);
 378                         else
 379                                 retval = scsi_dump(dev_scsi, io_buf);
 380         }
 381
 382         if (!retval) {
 383                 retval = buflen;
 384         } else if (retval > 0) {
 385                 if (--retry > 0) {
 386                         dbg("%s: Retrying ...\n", dev_scsi->kernel);
 387                         goto resend;
 388                 }
 389                 retval = -1;
 390         }
 391
 392 error:
 393         if (retval < 0)
 394                 info("%s: Unable to get INQUIRY vpd %d page 0x%x.\n",
 395                     dev_scsi->kernel, evpd, page);
 396
 397         return retval;
 398 }
 399
 400 /* Get list of supported EVPD pages */
 401 static int do_scsi_page0_inquiry(struct scsi_id_device *dev_scsi, int fd,
 402                                  unsigned char *buffer, unsigned int len)
 403 {
 404         int retval;
 405
 406         memset(buffer, 0, len);
 407         retval = scsi_inquiry(dev_scsi, fd, 1, 0x0, buffer, len);
 408         if (retval < 0)
 409                 return 1;
 410
 411         if (buffer[1] != 0) {
 412                 info("%s: page 0 not available.\n", dev_scsi->kernel);
 413                 return 1;
 414         }
 415         if (buffer[3] > len) {
 416                 info("%s: page 0 buffer too long %d\n", dev_scsi->kernel,  buffer[3]);
 417                 return 1;
 418         }
 419
 420         /*
 421          * Following check is based on code once included in the 2.5.x
 422          * kernel.
 423          *
 424          * Some ill behaved devices return the standard inquiry here
 425          * rather than the evpd data, snoop the data to verify.
 426          */
 427         if (buffer[3] > MODEL_LENGTH) {
 428                 /*
 429                  * If the vendor id appears in the page assume the page is
 430                  * invalid.
 431                  */
 432                 if (!strncmp((char *)&buffer[VENDOR_LENGTH], dev_scsi->vendor, VENDOR_LENGTH)) {
 433                         info("%s: invalid page0 data\n", dev_scsi->kernel);
 434                         return 1;
 435                 }
 436         }
 437         return 0;
 438 }
 439
 440 /*
 441  * The caller checks that serial is long enough to include the vendor +
 442  * model.
 443  */
 444 static int prepend_vendor_model(struct scsi_id_device *dev_scsi, char *serial)
 445 {
 446         int ind;
 447
 448         strncpy(serial, dev_scsi->vendor, VENDOR_LENGTH);
 449         ind = strlen(serial) - 1;
 450
 451         strncat(serial, dev_scsi->model, MODEL_LENGTH);
 452         ind = strlen(serial) - 1;
 453         ind++;
 454
 455         /*
 456          * This is not a complete check, since we are using strncat/cpy
 457          * above, ind will never be too large.
 458          */
 459         if (ind != (VENDOR_LENGTH + MODEL_LENGTH)) {
 460                 info("%s: expected length %d, got length %d\n",
 461                      dev_scsi->kernel, (VENDOR_LENGTH + MODEL_LENGTH), ind);
 462                 return 1;
 463         }
 464         return ind;
 465 }
 466
 467 /**
 468  * check_fill_0x83_id - check the page 0x83 id, if OK allocate and fill
 469  * serial number.
 470  **/
 471 static int check_fill_0x83_id(struct scsi_id_device *dev_scsi,
 472                               unsigned char *page_83,
 473                               const struct scsi_id_search_values
 474                               *id_search, char *serial, char *serial_short, int max_len)
 475 {
 476         int i, j, s, len;
 477
 478         /*
 479          * ASSOCIATION must be with the device (value 0)
 480          */
 481         if ((page_83[1] & 0x30) != 0)
 482                 return 1;
 483
 484         if ((page_83[1] & 0x0f) != id_search->id_type)
 485                 return 1;
 486
 487         /*
 488          * Possibly check NAA sub-type.
 489          */
 490         if ((id_search->naa_type != SCSI_ID_NAA_DONT_CARE) &&
 491             (id_search->naa_type != (page_83[4] & 0xf0) >> 4))
 492                 return 1;
 493
 494         /*
 495          * Check for matching code set - ASCII or BINARY.
 496          */
 497         if ((page_83[0] & 0x0f) != id_search->code_set)
 498                 return 1;
 499
 500         /*
 501          * page_83[3]: identifier length
 502          */
 503         len = page_83[3];
 504         if ((page_83[0] & 0x0f) != SCSI_ID_ASCII)
 505                 /*
 506                  * If not ASCII, use two bytes for each binary value.
 507                  */
 508                 len *= 2;
 509
 510         /*
 511          * Add one byte for the NUL termination, and one for the id_type.
 512          */
 513         len += 2;
 514         if (id_search->id_type == SCSI_ID_VENDOR_SPECIFIC)
 515                 len += VENDOR_LENGTH + MODEL_LENGTH;
 516
 517         if (max_len < len) {
 518                 info("%s: length %d too short - need %d\n",
 519                     dev_scsi->kernel, max_len, len);
 520                 return 1;
 521         }
 522
 523         serial[0] = hex_str[id_search->id_type];
 524
 525         /*
 526          * For SCSI_ID_VENDOR_SPECIFIC prepend the vendor and model before
 527          * the id since it is not unique across all vendors and models,
 528          * this differs from SCSI_ID_T10_VENDOR, where the vendor is
 529          * included in the identifier.
 530          */
 531         if (id_search->id_type == SCSI_ID_VENDOR_SPECIFIC)
 532                 if (prepend_vendor_model(dev_scsi, &serial[1]) < 0) {
 533                         dbg("prepend failed\n");
 534                         return 1;
 535                 }
 536
 537         i = 4; /* offset to the start of the identifier */
 538         s = j = strlen(serial);
 539         if ((page_83[0] & 0x0f) == SCSI_ID_ASCII) {
 540                 /*
 541                  * ASCII descriptor.
 542                  */
 543                 while (i < (4 + page_83[3]))
 544                         serial[j++] = page_83[i++];
 545         } else {
 546                 /*
 547                  * Binary descriptor, convert to ASCII, using two bytes of
 548                  * ASCII for each byte in the page_83.
 549                  */
 550                 while (i < (4 + page_83[3])) {
 551                         serial[j++] = hex_str[(page_83[i] & 0xf0) >> 4];
 552                         serial[j++] = hex_str[page_83[i] & 0x0f];
 553                         i++;
 554                 }
 555         }
 556
 557         strcpy(serial_short, &serial[s]);
 558         return 0;
 559 }
 560
 561 /* Extract the raw binary from VPD 0x83 pre-SPC devices */
 562 static int check_fill_0x83_prespc3(struct scsi_id_device *dev_scsi,
 563                                    unsigned char *page_83,
 564                                    const struct scsi_id_search_values
 565                                    *id_search, char *serial, char *serial_short, int max_len)
 566 {
 567         int i, j;
 568
 569         dbg("using pre-spc3-83 for %s\n", dev_scsi->kernel);
 570         serial[0] = hex_str[id_search->id_type];
 571         /* serial has been memset to zero before */
 572         j = strlen(serial);     /* j = 1; */
 573
 574         for (i = 0; i < page_83[3]; ++i) {
 575                 serial[j++] = hex_str[(page_83[4+i] & 0xf0) >> 4];
 576                 serial[j++] = hex_str[ page_83[4+i] & 0x0f];
 577         }
 578         strcpy(serial_short, serial);
 579         return 0;
 580 }
 581
 582
 583 /* Get device identification VPD page */
 584 static int do_scsi_page83_inquiry(struct scsi_id_device *dev_scsi, int fd,
 585                                   char *serial, char *serial_short, int len)
 586 {
 587         int retval;
 588         unsigned int id_ind, j;
 589         unsigned char page_83[SCSI_INQ_BUFF_LEN];
 590
 591         memset(page_83, 0, SCSI_INQ_BUFF_LEN);
 592         retval = scsi_inquiry(dev_scsi, fd, 1, PAGE_83, page_83,
 593                               SCSI_INQ_BUFF_LEN);
 594         if (retval < 0)
 595                 return 1;
 596
 597         if (page_83[1] != PAGE_83) {
 598                 info("%s: Invalid page 0x83\n", dev_scsi->kernel);
 599                 return 1;
 600         }
 601
 602         /*
 603          * XXX Some devices (IBM 3542) return all spaces for an identifier if
 604          * the LUN is not actually configured. This leads to identifers of
 605          * the form: "1            ".
 606          */
 607
 608         /*
 609          * Model 4, 5, and (some) model 6 EMC Symmetrix devices return
 610          * a page 83 reply according to SCSI-2 format instead of SPC-2/3.
 611          *
 612          * The SCSI-2 page 83 format returns an IEEE WWN in binary
 613          * encoded hexi-decimal in the 16 bytes following the initial
 614          * 4-byte page 83 reply header.
 615          *
 616          * Both the SPC-2 and SPC-3 formats return an IEEE WWN as part
 617          * of an Identification descriptor.  The 3rd byte of the first
 618          * Identification descriptor is a reserved (BSZ) byte field.
 619          *
 620          * Reference the 7th byte of the page 83 reply to determine
 621          * whether the reply is compliant with SCSI-2 or SPC-2/3
 622          * specifications.  A zero value in the 7th byte indicates
 623          * an SPC-2/3 conformant reply, (i.e., the reserved field of the
 624          * first Identification descriptor).  This byte will be non-zero
 625          * for a SCSI-2 conformant page 83 reply from these EMC
 626          * Symmetrix models since the 7th byte of the reply corresponds
 627          * to the 4th and 5th nibbles of the 6-byte OUI for EMC, that is,
 628          * 0x006048.
 629          */
 630
 631         if (page_83[6] != 0)
 632                 return check_fill_0x83_prespc3(dev_scsi, page_83, id_search_list,
 633                                                serial, serial_short, len);
 634
 635         /*
 636          * Search for a match in the prioritized id_search_list.
 637          */
 638         for (id_ind = 0;
 639              id_ind < sizeof(id_search_list)/sizeof(id_search_list[0]);
 640              id_ind++) {
 641                 /*
 642                  * Examine each descriptor returned. There is normally only
 643                  * one or a small number of descriptors.
 644                  */
 645                 for (j = 4; j <= (unsigned int)page_83[3] + 3; j += page_83[j + 3] + 4) {
 646                         retval = check_fill_0x83_id(dev_scsi, &page_83[j],
 647                                                     &id_search_list[id_ind],
 648                                                     serial, serial_short, len);
 649                         dbg("%s id desc %d/%d/%d\n", dev_scsi->kernel,
 650                                 id_search_list[id_ind].id_type,
 651                                 id_search_list[id_ind].naa_type,
 652                                 id_search_list[id_ind].code_set);
 653                         if (!retval) {
 654                                 dbg("  used\n");
 655                                 return retval;
 656                         } else if (retval < 0) {
 657                                 dbg("  failed\n");
 658                                 return retval;
 659                         } else {
 660                                 dbg("  not used\n");
 661                         }
 662                 }
 663         }
 664         return 1;
 665 }
 666
 667 /*
 668  * Get device identification VPD page for older SCSI-2 device which is not
 669  * compliant with either SPC-2 or SPC-3 format.
 670  *
 671  * Return the hard coded error code value 2 if the page 83 reply is not
 672  * conformant to the SCSI-2 format.
 673  */
 674 static int do_scsi_page83_prespc3_inquiry(struct scsi_id_device *dev_scsi, int fd,
 675                                           char *serial, char *serial_short, int len)
 676 {
 677         int retval;
 678         int i, j;
 679         unsigned char page_83[SCSI_INQ_BUFF_LEN];
 680
 681         memset(page_83, 0, SCSI_INQ_BUFF_LEN);
 682         retval = scsi_inquiry(dev_scsi, fd, 1, PAGE_83, page_83, SCSI_INQ_BUFF_LEN);
 683         if (retval < 0)
 684                 return 1;
 685
 686         if (page_83[1] != PAGE_83) {
 687                 info("%s: Invalid page 0x83\n", dev_scsi->kernel);
 688                 return 1;
 689         }
 690         /*
 691          * Model 4, 5, and (some) model 6 EMC Symmetrix devices return
 692          * a page 83 reply according to SCSI-2 format instead of SPC-2/3.
 693          *
 694          * The SCSI-2 page 83 format returns an IEEE WWN in binary
 695          * encoded hexi-decimal in the 16 bytes following the initial
 696          * 4-byte page 83 reply header.
 697          *
 698          * Both the SPC-2 and SPC-3 formats return an IEEE WWN as part
 699          * of an Identification descriptor.  The 3rd byte of the first
 700          * Identification descriptor is a reserved (BSZ) byte field.
 701          *
 702          * Reference the 7th byte of the page 83 reply to determine
 703          * whether the reply is compliant with SCSI-2 or SPC-2/3
 704          * specifications.  A zero value in the 7th byte indicates
 705          * an SPC-2/3 conformant reply, (i.e., the reserved field of the
 706          * first Identification descriptor).  This byte will be non-zero
 707          * for a SCSI-2 conformant page 83 reply from these EMC
 708          * Symmetrix models since the 7th byte of the reply corresponds
 709          * to the 4th and 5th nibbles of the 6-byte OUI for EMC, that is,
 710          * 0x006048.
 711          */
 712         if (page_83[6] == 0)
 713                 return 2;
 714
 715         serial[0] = hex_str[id_search_list[0].id_type];
 716         /*
 717          * The first four bytes contain data, not a descriptor.
 718          */
 719         i = 4;
 720         j = strlen(serial);
 721         /*
 722          * Binary descriptor, convert to ASCII,
 723          * using two bytes of ASCII for each byte
 724          * in the page_83.
 725          */
 726         while (i < (page_83[3]+4)) {
 727                 serial[j++] = hex_str[(page_83[i] & 0xf0) >> 4];
 728                 serial[j++] = hex_str[page_83[i] & 0x0f];
 729                 i++;
 730         }
 731         dbg("using pre-spc3-83 for %s\n", dev_scsi->kernel);
 732         return 0;
 733 }
 734
 735 /* Get unit serial number VPD page */
 736 static int do_scsi_page80_inquiry(struct scsi_id_device *dev_scsi, int fd,
 737                                   char *serial, char *serial_short, int max_len)
 738 {
 739         int retval;
 740         int ser_ind;
 741         int i;
 742         int len;
 743         unsigned char buf[SCSI_INQ_BUFF_LEN];
 744
 745         memset(buf, 0, SCSI_INQ_BUFF_LEN);
 746         retval = scsi_inquiry(dev_scsi, fd, 1, PAGE_80, buf, SCSI_INQ_BUFF_LEN);
 747         if (retval < 0)
 748                 return retval;
 749
 750         if (buf[1] != PAGE_80) {
 751                 info("%s: Invalid page 0x80\n", dev_scsi->kernel);
 752                 return 1;
 753         }
 754
 755         len = 1 + VENDOR_LENGTH + MODEL_LENGTH + buf[3];
 756         if (max_len < len) {
 757                 info("%s: length %d too short - need %d\n",
 758                     dev_scsi->kernel, max_len, len);
 759                 return 1;
 760         }
 761         /*
 762          * Prepend 'S' to avoid unlikely collision with page 0x83 vendor
 763          * specific type where we prepend '0' + vendor + model.
 764          */
 765         serial[0] = 'S';
 766         ser_ind = prepend_vendor_model(dev_scsi, &serial[1]);
 767         if (ser_ind < 0)
 768                 return 1;
 769         len = buf[3];
 770         for (i = 4; i < len + 4; i++, ser_ind++)
 771                 serial[ser_ind] = buf[i];
 772         memcpy(serial_short, &buf[4], len);
 773         serial_short[len] = '\0';
 774         return 0;
 775 }
 776
 777 int scsi_std_inquiry(struct scsi_id_device *dev_scsi, const char *devname)
 778 {
 779         int retval;
 780         int fd;
 781         unsigned char buf[SCSI_INQ_BUFF_LEN];
 782         struct stat statbuf;
 783
 784         dbg("opening %s\n", devname);
 785         fd = open(devname, O_RDONLY | O_NONBLOCK);
 786         if (fd < 0) {
 787                 info("scsi_id: cannot open %s: %s\n",
 788                      devname, strerror(errno));
 789                 return 1;
 790         }
 791
 792         if (fstat(fd, &statbuf) < 0) {
 793                 info("scsi_id: cannot stat %s: %s\n",
 794                      devname, strerror(errno));
 795                 return 2;
 796         }
 797         sprintf(dev_scsi->kernel,"%d:%d", major(statbuf.st_rdev),
 798                 minor(statbuf.st_rdev));
 799
 800         memset(buf, 0, SCSI_INQ_BUFF_LEN);
 801         retval = scsi_inquiry(dev_scsi, fd, 0, 0, buf, SCSI_INQ_BUFF_LEN);
 802         if (retval < 0)
 803                 return retval;
 804
 805         memcpy(dev_scsi->vendor, buf + 8, 8);
 806         dev_scsi->vendor[8] = '\0';
 807         memcpy(dev_scsi->model, buf + 16, 16);
 808         dev_scsi->model[16] = '\0';
 809         memcpy(dev_scsi->revision, buf + 32, 4);
 810         dev_scsi->revision[4] = '\0';
 811         sprintf(dev_scsi->type,"%x", buf[0] & 0x1f);
 812
 813         close(fd);
 814
 815         return 0;
 816 }
 817
 818 int scsi_get_serial (struct scsi_id_device *dev_scsi, const char *devname,
 819                      int page_code, char *serial_short, int len)
 820 {
 821         unsigned char page0[SCSI_INQ_BUFF_LEN];
 822         int fd;
 823         int ind;
 824         int retval;
 825
 826         memset(dev_scsi->serial, 0, len);
 827         dbg("opening %s\n", devname);
 828         fd = open(devname, O_RDONLY | O_NONBLOCK);
 829         if (fd < 0) {
 830                 info("%s: cannot open %s: %s\n",
 831                     dev_scsi->kernel, devname, strerror(errno));
 832                 return 1;
 833         }
 834
 835         if (page_code == PAGE_80) {
 836                 if (do_scsi_page80_inquiry(dev_scsi, fd, dev_scsi->serial, serial_short, len)) {
 837                         retval = 1;
 838                         goto completed;
 839                 } else  {
 840                         retval = 0;
 841                         goto completed;
 842                 }
 843         } else if (page_code == PAGE_83) {
 844                 if (do_scsi_page83_inquiry(dev_scsi, fd, dev_scsi->serial, serial_short, len)) {
 845                         retval = 1;
 846                         goto completed;
 847                 } else  {
 848                         retval = 0;
 849                         goto completed;
 850                 }
 851         } else if (page_code == PAGE_83_PRE_SPC3) {
 852                 retval = do_scsi_page83_prespc3_inquiry(dev_scsi, fd, dev_scsi->serial, serial_short, len);
 853                 if (retval) {
 854                         /*
 855                          * Fallback to servicing a SPC-2/3 compliant page 83
 856                          * inquiry if the page 83 reply format does not
 857                          * conform to pre-SPC3 expectations.
 858                          */
 859                         if (retval == 2) {
 860                                 if (do_scsi_page83_inquiry(dev_scsi, fd, dev_scsi->serial, serial_short, len)) {
 861                                         retval = 1;
 862                                         goto completed;
 863                                 } else  {
 864                                         retval = 0;
 865                                         goto completed;
 866                                 }
 867                         }
 868                         else {
 869                                 retval = 1;
 870                                 goto completed;
 871                         }
 872                 } else  {
 873                         retval = 0;
 874                         goto completed;
 875                 }
 876         } else if (page_code != 0x00) {
 877                 info("%s: unsupported page code 0x%d\n", dev_scsi->kernel, page_code);
 878                 return 1;
 879         }
 880
 881         /*
 882          * Get page 0, the page of the pages. By default, try from best to
 883          * worst of supported pages: 0x83 then 0x80.
 884          */
 885         if (do_scsi_page0_inquiry(dev_scsi, fd, page0, SCSI_INQ_BUFF_LEN)) {
 886                 /*
 887                  * Don't try anything else. Black list if a specific page
 888                  * should be used for this vendor+model, or maybe have an
 889                  * optional fall-back to page 0x80 or page 0x83.
 890                  */
 891                 retval = 1;
 892                 goto completed;
 893         }
 894
 895         dbg("%s: Checking page0\n", dev_scsi->kernel);
 896
 897         for (ind = 4; ind <= page0[3] + 3; ind++)
 898                 if (page0[ind] == PAGE_83)
 899                         if (!do_scsi_page83_inquiry(dev_scsi, fd,
 900                                                     dev_scsi->serial, serial_short, len)) {
 901                                 /*
 902                                  * Success
 903                                  */
 904                                 retval = 0;
 905                                 goto completed;
 906                         }
 907
 908         for (ind = 4; ind <= page0[3] + 3; ind++)
 909                 if (page0[ind] == PAGE_80)
 910                         if (!do_scsi_page80_inquiry(dev_scsi, fd,
 911                                                     dev_scsi->serial, serial_short, len)) {
 912                                 /*
 913                                  * Success
 914                                  */
 915                                 retval = 0;
 916                                 goto completed;
 917                         }
 918         retval = 1;
 919 completed:
 920         if (close(fd) < 0)
 921                 info("%s: close failed: %s\n", dev_scsi->kernel, strerror(errno));
 922         return retval;
 923 }