utils/blkmapd/device-inq.c

   1 /*
   2  * device-inq.c: inquire SCSI device information.
   3  *
   4  * Copyright (c) 2010 EMC Corporation, Haiying Tang <Tang_Haiying@emc.com>
   5  * All rights reserved.
   6  *
   7  * This program refers to "SCSI Primary Commands - 3 (SPC-3)
   8  * at http://www.t10.org and sg_inq.c in sg3_utils-1.26 for
   9  * Linux OS SCSI subsystem, by D. Gilbert.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <sys/ioctl.h>
  34 #include <sys/mount.h>
  35 #include <sys/select.h>
  36 #include <scsi/scsi.h>
  37 #include <scsi/scsi_ioctl.h>
  38 #include <scsi/sg.h>
  39
  40 #include <stdlib.h>
  41 #include <stdio.h>
  42 #include <unistd.h>
  43 #include <string.h>
  44 #include <syslog.h>
  45 #include <dirent.h>
  46 #include <ctype.h>
  47 #include <fcntl.h>
  48 #include <libgen.h>
  49 #include <errno.h>
  50
  51 #include "device-discovery.h"
  52
  53 #define DEF_ALLOC_LEN   255
  54 #define MX_ALLOC_LEN    (0xc000 + 0x80)
  55
  56 static struct bl_serial *bl_create_scsi_string(int len, const char *bytes)
  57 {
  58         struct bl_serial *s;
  59
  60         s = malloc(sizeof(*s) + len);
  61         if (s) {
  62                 s->data = (char *)&s[1];
  63                 s->len = len;
  64                 memcpy(s->data, bytes, len);
  65         }
  66         return s;
  67 }
  68
  69 static void bl_free_scsi_string(struct bl_serial *str)
  70 {
  71         if (str)
  72                 free(str);
  73 }
  74
  75 #define sg_io_ok(io_hdr) \
  76         ((((io_hdr).status & 0x7e) == 0) && \
  77         ((io_hdr).host_status == 0) && \
  78         (((io_hdr).driver_status & 0x0f) == 0))
  79
  80 static int sg_timeout = 1 * 1000;
  81
  82 static int bldev_inquire_page(int fd, int page, char *buffer, int len)
  83 {
  84         unsigned char cmd[] = { INQUIRY, 0, 0, 0, 0, 0 };
  85         unsigned char sense_b[28];
  86         struct sg_io_hdr io_hdr;
  87         if (page >= 0) {
  88                 cmd[1] = 1;
  89                 cmd[2] = page;
  90         }
  91         cmd[3] = (unsigned char)((len >> 8) & 0xff);
  92         cmd[4] = (unsigned char)(len & 0xff);
  93
  94         memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
  95         io_hdr.interface_id = 'S';
  96         io_hdr.cmd_len = sizeof(cmd);
  97         io_hdr.mx_sb_len = sizeof(sense_b);
  98         io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
  99         io_hdr.dxfer_len = len;
 100         io_hdr.dxferp = buffer;
 101         io_hdr.cmdp = cmd;
 102         io_hdr.sbp = sense_b;
 103         io_hdr.timeout = sg_timeout;
 104         if (ioctl(fd, SG_IO, &io_hdr) < 0)
 105                 return -1;
 106
 107         if (sg_io_ok(io_hdr))
 108                 return 0;
 109         return -1;
 110 }
 111
 112 static int bldev_inquire_pages(int fd, int page, char **buffer)
 113 {
 114         int status = 0;
 115         char *tmp;
 116         int len;
 117
 118         *buffer = calloc(DEF_ALLOC_LEN, sizeof(char));
 119         if (!*buffer) {
 120                 BL_LOG_ERR("%s: Out of memory!\n", __func__);
 121                 return -ENOMEM;
 122         }
 123
 124         status = bldev_inquire_page(fd, page, *buffer, DEF_ALLOC_LEN);
 125         if (status)
 126                 goto out;
 127
 128         status = -1;
 129         if ((*(*buffer + 1) & 0xff) != page)
 130                 goto out;
 131
 132         len = (*(*buffer + 2) << 8) + *(*buffer + 3) + 4;
 133         if (len > MX_ALLOC_LEN) {
 134                 BL_LOG_ERR("SCSI response length too long: %d\n", len);
 135                 goto out;
 136         }
 137         if (len > DEF_ALLOC_LEN) {
 138                 tmp = realloc(*buffer, len);
 139                 if (!tmp) {
 140                         BL_LOG_ERR("%s: Out of memory!\n", __func__);
 141                         status = -ENOMEM;
 142                         goto out;
 143                 }
 144                 *buffer = tmp;
 145                 status = bldev_inquire_page(fd, page, *buffer, len);
 146                 if (status)
 147                         goto out;
 148         }
 149         status = 0;
 150  out:
 151         return status;
 152 }
 153
 154 /* For EMC multipath devices, use VPD page (0xc0) to get status.
 155  * For other devices, return ACTIVE for now
 156  */
 157 extern enum bl_path_state_e bldev_read_ap_state(int fd)
 158 {
 159         int status = 0;
 160         char *buffer = NULL;
 161         enum bl_path_state_e ap_state = BL_PATH_STATE_ACTIVE;
 162
 163         status = bldev_inquire_pages(fd, 0xc0, &buffer);
 164         if (status)
 165                 goto out;
 166
 167         if (buffer[4] < 0x02)
 168                 ap_state = BL_PATH_STATE_PASSIVE;
 169  out:
 170         if (buffer)
 171                 free(buffer);
 172         return ap_state;
 173 }
 174
 175 struct bl_serial *bldev_read_serial(int fd, const char *filename)
 176 {
 177         struct bl_serial *serial_out = NULL;
 178         int status = 0;
 179         char *buffer;
 180         struct bl_dev_id *dev_root, *dev_id;
 181         unsigned int pos, len, current_id = 0;
 182
 183         status = bldev_inquire_pages(fd, 0x83, &buffer);
 184         if (status)
 185                 goto out;
 186
 187         dev_root = (struct bl_dev_id *)buffer;
 188
 189         pos = 0;
 190         current_id = 0;
 191         len = dev_root->len;
 192         while (pos < (len - sizeof(struct bl_dev_id) + sizeof(unsigned char))) {
 193                 dev_id = (struct bl_dev_id *)&(dev_root->data[pos]);
 194                 if ((dev_id->ids & 0xf) < current_id)
 195                         continue;
 196                 switch (dev_id->ids & 0xf) {
 197                         /* We process SCSI ID with four ID cases: 0, 1, 2 and 3.
 198                          * When more than one ID is available, priority is
 199                          * 3>2>1>0.
 200                          */
 201                 case 2: /* EUI-64 based */
 202                         if ((dev_id->len != 8) && (dev_id->len != 12) &&
 203                             (dev_id->len != 16))
 204                                 break;
 205                 case 3: /* NAA */
 206                         /* TODO: NAA validity judgement too complicated,
 207                          * so just ingore it here.
 208                          */
 209                         if ((dev_id->type & 0xf) != 1) {
 210                                 BL_LOG_ERR("Binary code_set expected\n");
 211                                 break;
 212                         }
 213                 case 0: /* vendor specific */
 214                 case 1: /* T10 vendor identification */
 215                         current_id = dev_id->ids & 0xf;
 216                         if (serial_out)
 217                                 bl_free_scsi_string(serial_out);
 218                         serial_out = bl_create_scsi_string(dev_id->len,
 219                                                            dev_id->data);
 220                         break;
 221                 }
 222                 if (current_id == 3)
 223                         break;
 224                 pos += (dev_id->len + sizeof(struct bl_dev_id) -
 225                         sizeof(unsigned char));
 226         }
 227  out:
 228         if (!serial_out)
 229                 serial_out = bl_create_scsi_string(strlen(filename), filename);
 230         if (buffer)
 231                 free(buffer);
 232         return serial_out;
 233 }