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