libmultipath/discovery.c

   1 /*
   2  * Copyright (c) 2004, 2005, 2006 Christophe Varoqui
   3  * Copyright (c) 2005 Stefan Bader, IBM
   4  * Copyright (c) 2005 Mike Anderson
   5  */
   6 #include <stdio.h>
   7 #include <unistd.h>
   8 #include <fcntl.h>
   9 #include <sys/ioctl.h>
  10 #include <sys/stat.h>
  11 #include <dirent.h>
  12 #include <errno.h>
  13 #include <libgen.h>
  14 #include <libudev.h>
  15
  16 #include "checkers.h"
  17 #include "vector.h"
  18 #include "memory.h"
  19 #include "util.h"
  20 #include "structs.h"
  21 #include "config.h"
  22 #include "blacklist.h"
  23 #include "callout.h"
  24 #include "debug.h"
  25 #include "propsel.h"
  26 #include "sg_include.h"
  27 #include "sysfs.h"
  28 #include "discovery.h"
  29 #include "prio.h"
  30 #include "defaults.h"
  31
  32 int
  33 store_pathinfo (vector pathvec, vector hwtable, struct udev_device *udevice,
  34                 int flag, struct path **pp_ptr)
  35 {
  36         int err = 1;
  37         struct path * pp;
  38         const char * devname;
  39
  40         if (pp_ptr)
  41                 *pp_ptr = NULL;
  42
  43         devname = udev_device_get_sysname(udevice);
  44         if (!devname)
  45                 return 1;
  46
  47         pp = alloc_path();
  48
  49         if (!pp)
  50                 return 1;
  51
  52         if(safe_sprintf(pp->dev, "%s", devname)) {
  53                 condlog(0, "pp->dev too small");
  54                 goto out;
  55         }
  56         pp->udev = udev_device_ref(udevice);
  57         err = pathinfo(pp, hwtable,
  58                        (conf->dry_run == 3)? flag : (flag | DI_BLACKLIST));
  59         if (err)
  60                 goto out;
  61
  62         err = store_path(pathvec, pp);
  63         if (err)
  64                 goto out;
  65
  66 out:
  67         if (err)
  68                 free_path(pp);
  69         else if (pp_ptr)
  70                 *pp_ptr = pp;
  71         return err;
  72 }
  73
  74 static int
  75 path_discover (vector pathvec, struct config * conf,
  76                struct udev_device *udevice, int flag)
  77 {
  78         struct path * pp;
  79         const char * devname;
  80
  81         devname = udev_device_get_sysname(udevice);
  82         if (!devname)
  83                 return 0;
  84
  85         if (filter_property(conf, udevice) > 0)
  86                 return 0;
  87
  88         if (filter_devnode(conf->blist_devnode, conf->elist_devnode,
  89                            (char *)devname) > 0)
  90                 return 0;
  91
  92         pp = find_path_by_dev(pathvec, (char *)devname);
  93         if (!pp) {
  94                 if (store_pathinfo(pathvec, conf->hwtable,
  95                                    udevice, flag, NULL) != 1)
  96                         return 0;
  97                 else
  98                         return 1;
  99         }
 100         return pathinfo(pp, conf->hwtable, flag);
 101 }
 102
 103 int
 104 path_discovery (vector pathvec, struct config * conf, int flag)
 105 {
 106         struct udev_enumerate *udev_iter;
 107         struct udev_list_entry *entry;
 108         struct udev_device *udevice;
 109         const char *devpath;
 110         int r = 0;
 111
 112         udev_iter = udev_enumerate_new(conf->udev);
 113         if (!udev_iter)
 114                 return 1;
 115
 116         udev_enumerate_add_match_subsystem(udev_iter, "block");
 117         udev_enumerate_scan_devices(udev_iter);
 118
 119         udev_list_entry_foreach(entry,
 120                                 udev_enumerate_get_list_entry(udev_iter)) {
 121                 const char *devtype;
 122                 devpath = udev_list_entry_get_name(entry);
 123                 condlog(4, "Discover device %s", devpath);
 124                 udevice = udev_device_new_from_syspath(conf->udev, devpath);
 125                 if (!udevice) {
 126                         condlog(4, "%s: no udev information", devpath);
 127                         r++;
 128                         continue;
 129                 }
 130                 devtype = udev_device_get_devtype(udevice);
 131                 if(devtype && !strncmp(devtype, "disk", 4)) {
 132                         r += path_discover(pathvec, conf,
 133                                                    udevice, flag);
 134                 }
 135                 udev_device_unref(udevice);
 136         }
 137         udev_enumerate_unref(udev_iter);
 138         condlog(4, "Discovery status %d", r);
 139         return r;
 140 }
 141
 142 #define declare_sysfs_get_str(fname)                                    \
 143 extern int                                                              \
 144 sysfs_get_##fname (struct udev_device * udev, char * buff, size_t len)  \
 145 {                                                                       \
 146         const char * attr;                                              \
 147         const char * devname;                                           \
 148                                                                         \
 149         devname = udev_device_get_sysname(udev);                        \
 150                                                                         \
 151         attr = udev_device_get_sysattr_value(udev, #fname);             \
 152         if (!attr) {                                                    \
 153                 condlog(3, "%s: attribute %s not found in sysfs",       \
 154                         devname, #fname);                               \
 155                 return 1;                                               \
 156         }                                                               \
 157         if (strlen(attr) > len) {                                       \
 158                 condlog(3, "%s: overflow in attribute %s",              \
 159                         devname, #fname);                               \
 160                 return 2;                                               \
 161         }                                                               \
 162         strlcpy(buff, attr, len);                                       \
 163         return 0;                                                       \
 164 }
 165
 166 declare_sysfs_get_str(devtype);
 167 declare_sysfs_get_str(cutype);
 168 declare_sysfs_get_str(vendor);
 169 declare_sysfs_get_str(model);
 170 declare_sysfs_get_str(rev);
 171 declare_sysfs_get_str(dev);
 172
 173 int
 174 sysfs_get_timeout(struct path *pp, unsigned int *timeout)
 175 {
 176         const char *attr = NULL;
 177         const char *subsys;
 178         struct udev_device *parent;
 179         int r;
 180         unsigned int t;
 181
 182         if (!pp->udev || pp->bus != SYSFS_BUS_SCSI)
 183                 return 1;
 184
 185         parent = pp->udev;
 186         while (parent) {
 187                 subsys = udev_device_get_subsystem(parent);
 188                 attr = udev_device_get_sysattr_value(parent, "timeout");
 189                 if (subsys && attr)
 190                         break;
 191                 parent = udev_device_get_parent(parent);
 192         }
 193         if (!attr) {
 194                 condlog(3, "%s: No timeout value in sysfs", pp->dev);
 195                 return 1;
 196         }
 197
 198         r = sscanf(attr, "%u\n", &t);
 199
 200         if (r != 1) {
 201                 condlog(3, "%s: Cannot parse timeout attribute '%s'",
 202                         pp->dev, attr);
 203                 return 1;
 204         }
 205
 206         *timeout = t * 1000;
 207
 208         return 0;
 209 }
 210
 211 int
 212 sysfs_get_tgt_nodename (struct path *pp, char * node)
 213 {
 214         const char *tgtname, *value;
 215         struct udev_device *parent, *tgtdev;
 216         int host, channel, tgtid = -1;
 217
 218         parent = udev_device_get_parent_with_subsystem_devtype(pp->udev, "scsi", "scsi_device");
 219         if (!parent)
 220                 return 1;
 221         /* Check for SAS */
 222         value = udev_device_get_sysattr_value(parent, "sas_address");
 223         if (value) {
 224                 tgtdev = udev_device_get_parent(parent);
 225                 while (tgtdev) {
 226                         tgtname = udev_device_get_sysname(tgtdev);
 227                         if (sscanf(tgtname, "end_device-%d:%d",
 228                                    &host, &tgtid) == 2)
 229                                 break;
 230                         tgtdev = udev_device_get_parent(tgtdev);
 231                         tgtid = -1;
 232                 }
 233                 if (tgtid >= 0) {
 234                         pp->sg_id.proto_id = SCSI_PROTOCOL_SAS;
 235                         pp->sg_id.transport_id = tgtid;
 236                         strncpy(node, value, NODE_NAME_SIZE);
 237                         return 0;
 238                 }
 239         }
 240
 241         parent = udev_device_get_parent_with_subsystem_devtype(pp->udev, "scsi", "scsi_target");
 242         if (!parent)
 243                 return 1;
 244         /* Check for FibreChannel */
 245         tgtdev = udev_device_get_parent(parent);
 246         value = udev_device_get_sysname(tgtdev);
 247         if (sscanf(value, "rport-%d:%d-%d",
 248                    &host, &channel, &tgtid) == 3) {
 249                 tgtdev = udev_device_new_from_subsystem_sysname(conf->udev,
 250                                 "fc_remote_ports", value);
 251                 if (tgtdev) {
 252                         condlog(3, "SCSI target %d:%d:%d -> "
 253                                 "FC rport %d:%d-%d",
 254                                 pp->sg_id.host_no, pp->sg_id.channel,
 255                                 pp->sg_id.scsi_id, host, channel,
 256                                 tgtid);
 257                         value = udev_device_get_sysattr_value(tgtdev,
 258                                                               "node_name");
 259                         if (value) {
 260                                 pp->sg_id.proto_id = SCSI_PROTOCOL_FCP;
 261                                 pp->sg_id.transport_id = tgtid;
 262                                 strncpy(node, value, NODE_NAME_SIZE);
 263                                 udev_device_unref(tgtdev);
 264                                 return 0;
 265                         } else
 266                                 udev_device_unref(tgtdev);
 267                 }
 268         }
 269
 270         /* Check for iSCSI */
 271         parent = pp->udev;
 272         tgtname = NULL;
 273         while (parent) {
 274                 tgtname = udev_device_get_sysname(parent);
 275                 if (tgtname && sscanf(tgtname , "session%d", &tgtid) == 1)
 276                         break;
 277                 parent = udev_device_get_parent(parent);
 278                 tgtname = NULL;
 279                 tgtid = -1;
 280         }
 281         if (parent && tgtname) {
 282                 tgtdev = udev_device_new_from_subsystem_sysname(conf->udev,
 283                                 "iscsi_session", tgtname);
 284                 if (tgtdev) {
 285                         const char *value;
 286
 287                         value = udev_device_get_sysattr_value(tgtdev, "tgtname");
 288                         if (value) {
 289                                 pp->sg_id.proto_id = SCSI_PROTOCOL_ISCSI;
 290                                 pp->sg_id.transport_id = tgtid;
 291                                 strncpy(node, value, NODE_NAME_SIZE);
 292                                 udev_device_unref(tgtdev);
 293                                 return 0;
 294                         }
 295                         else
 296                                 udev_device_unref(tgtdev);
 297                 }
 298         }
 299         /* Check for libata */
 300         parent = pp->udev;
 301         tgtname = NULL;
 302         while (parent) {
 303                 tgtname = udev_device_get_sysname(parent);
 304                 if (tgtname && sscanf(tgtname, "ata%d", &tgtid) == 1)
 305                         break;
 306                 parent = udev_device_get_parent(parent);
 307                 tgtname = NULL;
 308         }
 309         if (tgtname) {
 310                 pp->sg_id.proto_id = SCSI_PROTOCOL_ATA;
 311                 pp->sg_id.transport_id = tgtid;
 312                 snprintf(node, NODE_NAME_SIZE, "ata-%d.00", tgtid);
 313                 return 0;
 314         }
 315         pp->sg_id.proto_id = SCSI_PROTOCOL_UNSPEC;
 316         return 1;
 317 }
 318
 319 static void
 320 sysfs_set_rport_tmo(struct multipath *mpp, struct path *pp)
 321 {
 322         struct udev_device *rport_dev = NULL;
 323         char value[11];
 324         char rport_id[32];
 325         unsigned long long tmo = 0;
 326         int ret;
 327
 328         sprintf(rport_id, "rport-%d:%d-%d",
 329                 pp->sg_id.host_no, pp->sg_id.channel, pp->sg_id.transport_id);
 330         rport_dev = udev_device_new_from_subsystem_sysname(conf->udev,
 331                                 "fc_remote_ports", rport_id);
 332         if (!rport_dev) {
 333                 condlog(1, "%s: No fc_remote_port device for '%s'", pp->dev,
 334                         rport_id);
 335                 return;
 336         }
 337         condlog(4, "target%d:%d:%d -> %s", pp->sg_id.host_no,
 338                 pp->sg_id.channel, pp->sg_id.scsi_id, rport_id);
 339
 340         /*
 341          * This is tricky.
 342          * dev_loss_tmo will be limited to 600 if fast_io_fail
 343          * is _not_ set.
 344          * fast_io_fail will be limited by the current dev_loss_tmo
 345          * setting.
 346          * So to get everything right we first need to increase
 347          * dev_loss_tmo to the fast_io_fail setting (if present),
 348          * then set fast_io_fail, and _then_ set dev_loss_tmo
 349          * to the correct value.
 350          */
 351         value[0] = '\0';
 352         if (mpp->fast_io_fail != MP_FAST_IO_FAIL_UNSET &&
 353             mpp->fast_io_fail != MP_FAST_IO_FAIL_ZERO &&
 354             mpp->fast_io_fail != MP_FAST_IO_FAIL_OFF) {
 355                 /* Check if we need to temporarily increase dev_loss_tmo */
 356                 ret = sysfs_attr_get_value(rport_dev, "dev_loss_tmo",
 357                                            value, 16);
 358                 if (ret <= 0) {
 359                         condlog(0, "%s: failed to read dev_loss_tmo value, "
 360                                 "error %d", rport_id, -ret);
 361                         goto out;
 362                 }
 363                 if (sscanf(value, "%llu\n", &tmo) != 1) {
 364                         condlog(0, "%s: Cannot parse dev_loss_tmo "
 365                                 "attribute '%s'", rport_id, value);
 366                         goto out;
 367                 }
 368                 if (mpp->fast_io_fail >= tmo) {
 369                         snprintf(value, 11, "%u", mpp->fast_io_fail);
 370                 }
 371         } else if (mpp->dev_loss > 600) {
 372                 condlog(3, "%s: limiting dev_loss_tmo to 600, since "
 373                         "fast_io_fail is not set", rport_id);
 374                 snprintf(value, 11, "%u", 600);
 375         } else {
 376                 snprintf(value, 11, "%u", mpp->dev_loss);
 377         }
 378         if (strlen(value)) {
 379                 ret = sysfs_attr_set_value(rport_dev, "dev_loss_tmo", value, 11);
 380                 if (ret <= 0) {
 381                         if (ret == -EBUSY)
 382                                 condlog(3, "%s: rport blocked", rport_id);
 383                         else
 384                                 condlog(0, "%s: failed to set dev_loss_tmo to %s, error %d",
 385                                         rport_id, value, -ret);
 386                         goto out;
 387                 }
 388         }
 389         if (mpp->fast_io_fail != MP_FAST_IO_FAIL_UNSET) {
 390                 if (mpp->fast_io_fail == MP_FAST_IO_FAIL_OFF)
 391                         sprintf(value, "off");
 392                 else if (mpp->fast_io_fail == MP_FAST_IO_FAIL_ZERO)
 393                         sprintf(value, "0");
 394                 else
 395                         snprintf(value, 11, "%u", mpp->fast_io_fail);
 396                 ret = sysfs_attr_set_value(rport_dev, "fast_io_fail_tmo",
 397                                            value, 11);
 398                 if (ret <= 0) {
 399                         if (ret == -EBUSY)
 400                                 condlog(3, "%s: rport blocked", rport_id);
 401                         else
 402                                 condlog(0, "%s: failed to set fast_io_fail_tmo to %s, error %d",
 403                                         rport_id, value, -ret);
 404                 }
 405         }
 406         if (tmo > 0) {
 407                 snprintf(value, 11, "%u", mpp->dev_loss);
 408                 ret = sysfs_attr_set_value(rport_dev, "dev_loss_tmo",
 409                                            value, 11);
 410                 if (ret <= 0) {
 411                         if (ret == -EBUSY)
 412                                 condlog(3, "%s: rport blocked", rport_id);
 413                         else
 414                                 condlog(0, "%s: failed to set dev_loss_tmo to %s, error %d",
 415                                         rport_id, value, -ret);
 416                 }
 417         }
 418 out:
 419         udev_device_unref(rport_dev);
 420 }
 421
 422 static void
 423 sysfs_set_session_tmo(struct multipath *mpp, struct path *pp)
 424 {
 425         struct udev_device *session_dev = NULL;
 426         char session_id[64];
 427         char value[11];
 428
 429         sprintf(session_id, "session%d", pp->sg_id.transport_id);
 430         session_dev = udev_device_new_from_subsystem_sysname(conf->udev,
 431                                 "iscsi_session", session_id);
 432         if (!session_dev) {
 433                 condlog(1, "%s: No iscsi session for '%s'", pp->dev,
 434                         session_id);
 435                 return;
 436         }
 437         condlog(4, "target%d:%d:%d -> %s", pp->sg_id.host_no,
 438                 pp->sg_id.channel, pp->sg_id.scsi_id, session_id);
 439
 440         if (mpp->dev_loss) {
 441                 condlog(3, "%s: ignoring dev_loss_tmo on iSCSI", pp->dev);
 442         }
 443         if (mpp->fast_io_fail != MP_FAST_IO_FAIL_UNSET) {
 444                 if (mpp->fast_io_fail == MP_FAST_IO_FAIL_OFF) {
 445                         condlog(3, "%s: can't switch off fast_io_fail_tmo "
 446                                 "on iSCSI", pp->dev);
 447                 } else if (mpp->fast_io_fail == MP_FAST_IO_FAIL_ZERO) {
 448                         condlog(3, "%s: can't set fast_io_fail_tmo to '0'"
 449                                 "on iSCSI", pp->dev);
 450                 } else {
 451                         snprintf(value, 11, "%u", mpp->fast_io_fail);
 452                         if (sysfs_attr_set_value(session_dev, "recovery_tmo",
 453                                                  value, 11) <= 0) {
 454                                 condlog(3, "%s: Failed to set recovery_tmo, "
 455                                         " error %d", pp->dev, errno);
 456                         }
 457                 }
 458         }
 459         udev_device_unref(session_dev);
 460         return;
 461 }
 462
 463 static void
 464 sysfs_set_nexus_loss_tmo(struct multipath *mpp, struct path *pp)
 465 {
 466         struct udev_device *sas_dev = NULL;
 467         char end_dev_id[64];
 468         char value[11];
 469
 470         sprintf(end_dev_id, "end_device-%d:%d",
 471                 pp->sg_id.host_no, pp->sg_id.transport_id);
 472         sas_dev = udev_device_new_from_subsystem_sysname(conf->udev,
 473                                 "sas_end_device", end_dev_id);
 474         if (!sas_dev) {
 475                 condlog(1, "%s: No SAS end device for '%s'", pp->dev,
 476                         end_dev_id);
 477                 return;
 478         }
 479         condlog(4, "target%d:%d:%d -> %s", pp->sg_id.host_no,
 480                 pp->sg_id.channel, pp->sg_id.scsi_id, end_dev_id);
 481
 482         if (mpp->dev_loss) {
 483                 snprintf(value, 11, "%u", mpp->dev_loss);
 484                 if (sysfs_attr_set_value(sas_dev, "I_T_nexus_loss_timeout",
 485                                          value, 11) <= 0)
 486                         condlog(3, "%s: failed to update "
 487                                 "I_T Nexus loss timeout, error %d",
 488                                 pp->dev, errno);
 489         }
 490         udev_device_unref(sas_dev);
 491         return;
 492 }
 493
 494 int
 495 sysfs_set_scsi_tmo (struct multipath *mpp)
 496 {
 497         struct path *pp;
 498         int i;
 499         int dev_loss_tmo = mpp->dev_loss;
 500
 501         if (mpp->no_path_retry > 0) {
 502                 int no_path_retry_tmo = mpp->no_path_retry * conf->checkint;
 503
 504                 if (no_path_retry_tmo > MAX_DEV_LOSS_TMO)
 505                         no_path_retry_tmo = MAX_DEV_LOSS_TMO;
 506                 if (no_path_retry_tmo > dev_loss_tmo)
 507                         dev_loss_tmo = no_path_retry_tmo;
 508                 condlog(3, "%s: update dev_loss_tmo to %d",
 509                         mpp->alias, dev_loss_tmo);
 510         } else if (mpp->no_path_retry == NO_PATH_RETRY_QUEUE) {
 511                 dev_loss_tmo = MAX_DEV_LOSS_TMO;
 512                 condlog(3, "%s: update dev_loss_tmo to %d",
 513                         mpp->alias, dev_loss_tmo);
 514         }
 515         mpp->dev_loss = dev_loss_tmo;
 516         if (mpp->dev_loss && mpp->fast_io_fail >= (int)mpp->dev_loss) {
 517                 condlog(3, "%s: turning off fast_io_fail (%d is not smaller than dev_loss_tmo)",
 518                         mpp->alias, mpp->fast_io_fail);
 519                 mpp->fast_io_fail = MP_FAST_IO_FAIL_OFF;
 520         }
 521         if (!mpp->dev_loss && mpp->fast_io_fail == MP_FAST_IO_FAIL_UNSET)
 522                 return 0;
 523
 524         vector_foreach_slot(mpp->paths, pp, i) {
 525                 if (pp->sg_id.proto_id == SCSI_PROTOCOL_FCP)
 526                         sysfs_set_rport_tmo(mpp, pp);
 527                 if (pp->sg_id.proto_id == SCSI_PROTOCOL_ISCSI)
 528                         sysfs_set_session_tmo(mpp, pp);
 529                 if (pp->sg_id.proto_id == SCSI_PROTOCOL_SAS)
 530                         sysfs_set_nexus_loss_tmo(mpp, pp);
 531         }
 532         return 0;
 533 }
 534
 535 int
 536 do_inq(int sg_fd, int cmddt, int evpd, unsigned int pg_op,
 537        void *resp, int mx_resp_len)
 538 {
 539         unsigned char inqCmdBlk[INQUIRY_CMDLEN] =
 540                 { INQUIRY_CMD, 0, 0, 0, 0, 0 };
 541         unsigned char sense_b[SENSE_BUFF_LEN];
 542         struct sg_io_hdr io_hdr;
 543
 544         if (cmddt)
 545                 inqCmdBlk[1] |= 2;
 546         if (evpd)
 547                 inqCmdBlk[1] |= 1;
 548         inqCmdBlk[2] = (unsigned char) pg_op;
 549         inqCmdBlk[3] = (unsigned char)((mx_resp_len >> 8) & 0xff);
 550         inqCmdBlk[4] = (unsigned char) (mx_resp_len & 0xff);
 551         memset(&io_hdr, 0, sizeof (struct sg_io_hdr));
 552         memset(sense_b, 0, SENSE_BUFF_LEN);
 553         io_hdr.interface_id = 'S';
 554         io_hdr.cmd_len = sizeof (inqCmdBlk);
 555         io_hdr.mx_sb_len = sizeof (sense_b);
 556         io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
 557         io_hdr.dxfer_len = mx_resp_len;
 558         io_hdr.dxferp = resp;
 559         io_hdr.cmdp = inqCmdBlk;
 560         io_hdr.sbp = sense_b;
 561         io_hdr.timeout = DEF_TIMEOUT;
 562
 563         if (ioctl(sg_fd, SG_IO, &io_hdr) < 0)
 564                 return -1;
 565
 566         /* treat SG_ERR here to get rid of sg_err.[ch] */
 567         io_hdr.status &= 0x7e;
 568         if ((0 == io_hdr.status) && (0 == io_hdr.host_status) &&
 569             (0 == io_hdr.driver_status))
 570                 return 0;
 571         if ((SCSI_CHECK_CONDITION == io_hdr.status) ||
 572             (SCSI_COMMAND_TERMINATED == io_hdr.status) ||
 573             (SG_ERR_DRIVER_SENSE == (0xf & io_hdr.driver_status))) {
 574                 if (io_hdr.sbp && (io_hdr.sb_len_wr > 2)) {
 575                         int sense_key;
 576                         unsigned char * sense_buffer = io_hdr.sbp;
 577                         if (sense_buffer[0] & 0x2)
 578                                 sense_key = sense_buffer[1] & 0xf;
 579                         else
 580                                 sense_key = sense_buffer[2] & 0xf;
 581                         if(RECOVERED_ERROR == sense_key)
 582                                 return 0;
 583                 }
 584         }
 585         return -1;
 586 }
 587
 588 static int
 589 get_serial (char * str, int maxlen, int fd)
 590 {
 591         int len = 0;
 592         char buff[MX_ALLOC_LEN + 1] = {0};
 593
 594         if (fd < 0)
 595                 return 1;
 596
 597         if (0 == do_inq(fd, 0, 1, 0x80, buff, MX_ALLOC_LEN)) {
 598                 len = buff[3];
 599                 if (len >= maxlen)
 600                         return 1;
 601                 if (len > 0) {
 602                         memcpy(str, buff + 4, len);
 603                         str[len] = '\0';
 604                 }
 605                 return 0;
 606         }
 607         return 1;
 608 }
 609
 610 static int
 611 get_geometry(struct path *pp)
 612 {
 613         if (pp->fd < 0)
 614                 return 1;
 615
 616         if (ioctl(pp->fd, HDIO_GETGEO, &pp->geom)) {
 617                 condlog(2, "%s: HDIO_GETGEO failed with %d", pp->dev, errno);
 618                 memset(&pp->geom, 0, sizeof(pp->geom));
 619                 return 1;
 620         }
 621         condlog(3, "%s: %u cyl, %u heads, %u sectors/track, start at %lu",
 622                 pp->dev, pp->geom.cylinders, pp->geom.heads,
 623                 pp->geom.sectors, pp->geom.start);
 624         return 0;
 625 }
 626
 627 static int
 628 scsi_sysfs_pathinfo (struct path * pp)
 629 {
 630         struct udev_device *parent;
 631         const char *attr_path = NULL;
 632
 633         parent = pp->udev;
 634         while (parent) {
 635                 const char *subsys = udev_device_get_subsystem(parent);
 636                 if (subsys && !strncmp(subsys, "scsi", 4)) {
 637                         attr_path = udev_device_get_sysname(parent);
 638                         if (!attr_path)
 639                                 break;
 640                         if (sscanf(attr_path, "%i:%i:%i:%i",
 641                                    &pp->sg_id.host_no,
 642                                    &pp->sg_id.channel,
 643                                    &pp->sg_id.scsi_id,
 644                                    &pp->sg_id.lun) == 4)
 645                                 break;
 646                 }
 647                 parent = udev_device_get_parent(parent);
 648         }
 649         if (!attr_path || pp->sg_id.host_no == -1)
 650                 return 1;
 651
 652         if (sysfs_get_vendor(parent, pp->vendor_id, SCSI_VENDOR_SIZE))
 653                 return 1;
 654
 655         condlog(3, "%s: vendor = %s", pp->dev, pp->vendor_id);
 656
 657         if (sysfs_get_model(parent, pp->product_id, SCSI_PRODUCT_SIZE))
 658                 return 1;
 659
 660         condlog(3, "%s: product = %s", pp->dev, pp->product_id);
 661
 662         if (sysfs_get_rev(parent, pp->rev, SCSI_REV_SIZE))
 663                 return 1;
 664
 665         condlog(3, "%s: rev = %s", pp->dev, pp->rev);
 666
 667         /*
 668          * set the hwe configlet pointer
 669          */
 670         pp->hwe = find_hwe(conf->hwtable, pp->vendor_id, pp->product_id, pp->rev);
 671
 672         /*
 673          * host / bus / target / lun
 674          */
 675         condlog(3, "%s: h:b:t:l = %i:%i:%i:%i",
 676                         pp->dev,
 677                         pp->sg_id.host_no,
 678                         pp->sg_id.channel,
 679                         pp->sg_id.scsi_id,
 680                         pp->sg_id.lun);
 681
 682         /*
 683          * target node name
 684          */
 685         if(!sysfs_get_tgt_nodename(pp, pp->tgt_node_name)) {
 686                 condlog(3, "%s: tgt_node_name = %s",
 687                         pp->dev, pp->tgt_node_name);
 688         }
 689
 690         return 0;
 691 }
 692
 693 static int
 694 ccw_sysfs_pathinfo (struct path * pp)
 695 {
 696         struct udev_device *parent;
 697         char attr_buff[NAME_SIZE];
 698         const char *attr_path;
 699
 700         parent = pp->udev;
 701         while (parent) {
 702                 const char *subsys = udev_device_get_subsystem(parent);
 703                 if (subsys && !strncmp(subsys, "ccw", 3))
 704                         break;
 705                 parent = udev_device_get_parent(parent);
 706         }
 707         if (!parent)
 708                 return 1;
 709
 710         sprintf(pp->vendor_id, "IBM");
 711
 712         condlog(3, "%s: vendor = %s", pp->dev, pp->vendor_id);
 713
 714         if (sysfs_get_devtype(parent, attr_buff, FILE_NAME_SIZE))
 715                 return 1;
 716
 717         if (!strncmp(attr_buff, "3370", 4)) {
 718                 sprintf(pp->product_id,"S/390 DASD FBA");
 719         } else if (!strncmp(attr_buff, "9336", 4)) {
 720                 sprintf(pp->product_id,"S/390 DASD FBA");
 721         } else {
 722                 sprintf(pp->product_id,"S/390 DASD ECKD");
 723         }
 724
 725         condlog(3, "%s: product = %s", pp->dev, pp->product_id);
 726
 727         /*
 728          * set the hwe configlet pointer
 729          */
 730         pp->hwe = find_hwe(conf->hwtable, pp->vendor_id, pp->product_id, NULL);
 731
 732         /*
 733          * host / bus / target / lun
 734          */
 735         attr_path = udev_device_get_sysname(parent);
 736         pp->sg_id.lun = 0;
 737         sscanf(attr_path, "%i.%i.%x",
 738                         &pp->sg_id.host_no,
 739                         &pp->sg_id.channel,
 740                         &pp->sg_id.scsi_id);
 741         condlog(3, "%s: h:b:t:l = %i:%i:%i:%i",
 742                         pp->dev,
 743                         pp->sg_id.host_no,
 744                         pp->sg_id.channel,
 745                         pp->sg_id.scsi_id,
 746                         pp->sg_id.lun);
 747
 748         return 0;
 749 }
 750
 751 static int
 752 cciss_sysfs_pathinfo (struct path * pp)
 753 {
 754         const char * attr_path = NULL;
 755         struct udev_device *parent;
 756
 757         parent = pp->udev;
 758         while (parent) {
 759                 const char *subsys = udev_device_get_subsystem(parent);
 760                 if (subsys && !strncmp(subsys, "cciss", 5)) {
 761                         attr_path = udev_device_get_sysname(parent);
 762                         if (!attr_path)
 763                                 break;
 764                         if (sscanf(attr_path, "c%id%i",
 765                                    &pp->sg_id.host_no,
 766                                    &pp->sg_id.scsi_id) == 2)
 767                                 break;
 768                 }
 769                 parent = udev_device_get_parent(parent);
 770         }
 771         if (!attr_path || pp->sg_id.host_no == -1)
 772                 return 1;
 773
 774         if (sysfs_get_vendor(parent, pp->vendor_id, SCSI_VENDOR_SIZE))
 775                 return 1;
 776
 777         condlog(3, "%s: vendor = %s", pp->dev, pp->vendor_id);
 778
 779         if (sysfs_get_model(parent, pp->product_id, SCSI_PRODUCT_SIZE))
 780                 return 1;
 781
 782         condlog(3, "%s: product = %s", pp->dev, pp->product_id);
 783
 784         if (sysfs_get_rev(parent, pp->rev, SCSI_REV_SIZE))
 785                 return 1;
 786
 787         condlog(3, "%s: rev = %s", pp->dev, pp->rev);
 788
 789         /*
 790          * set the hwe configlet pointer
 791          */
 792         pp->hwe = find_hwe(conf->hwtable, pp->vendor_id, pp->product_id, pp->rev);
 793
 794         /*
 795          * host / bus / target / lun
 796          */
 797         pp->sg_id.lun = 0;
 798         pp->sg_id.channel = 0;
 799         condlog(3, "%s: h:b:t:l = %i:%i:%i:%i",
 800                 pp->dev,
 801                 pp->sg_id.host_no,
 802                 pp->sg_id.channel,
 803                 pp->sg_id.scsi_id,
 804                 pp->sg_id.lun);
 805         return 0;
 806 }
 807
 808 static int
 809 common_sysfs_pathinfo (struct path * pp)
 810 {
 811         if (!pp->udev) {
 812                 condlog(4, "%s: udev not initialised", pp->dev);
 813                 return 1;
 814         }
 815         if (sysfs_get_dev(pp->udev, pp->dev_t, BLK_DEV_SIZE)) {
 816                 condlog(3, "%s: no 'dev' attribute in sysfs", pp->dev);
 817                 return 1;
 818         }
 819
 820         condlog(3, "%s: dev_t = %s", pp->dev, pp->dev_t);
 821
 822         if (sysfs_get_size(pp, &pp->size))
 823                 return 1;
 824
 825         condlog(3, "%s: size = %llu", pp->dev, pp->size);
 826
 827         return 0;
 828 }
 829
 830 int
 831 path_offline (struct path * pp)
 832 {
 833         struct udev_device * parent;
 834         char buff[SCSI_STATE_SIZE];
 835
 836         if (pp->bus != SYSFS_BUS_SCSI)
 837                 return PATH_UP;
 838
 839         parent = pp->udev;
 840         while (parent) {
 841                 const char *subsys = udev_device_get_subsystem(parent);
 842                 if (subsys && !strncmp(subsys, "scsi", 4))
 843                         break;
 844                 parent = udev_device_get_parent(parent);
 845         }
 846
 847         if (!parent) {
 848                 condlog(1, "%s: failed to get sysfs information", pp->dev);
 849                 return PATH_DOWN;
 850         }
 851
 852         memset(buff, 0x0, SCSI_STATE_SIZE);
 853         if (sysfs_attr_get_value(parent, "state", buff, SCSI_STATE_SIZE) <= 0)
 854                 return PATH_DOWN;
 855
 856         condlog(3, "%s: path state = %s", pp->dev, buff);
 857
 858         if (!strncmp(buff, "offline", 7) ||
 859             !strncmp(buff, "quiesce", 7) ||
 860             !strncmp(buff, "transport-offline", 17)) {
 861                 pp->offline = 1;
 862                 return PATH_DOWN;
 863         }
 864         pp->offline = 0;
 865         if (!strncmp(buff, "blocked", 7) || !strncmp(buff, "quiesce", 7))
 866                 return PATH_PENDING;
 867         else if (!strncmp(buff, "running", 7))
 868                 return PATH_UP;
 869
 870         return PATH_DOWN;
 871 }
 872
 873 int
 874 sysfs_pathinfo(struct path * pp)
 875 {
 876         if (common_sysfs_pathinfo(pp))
 877                 return 1;
 878
 879         pp->bus = SYSFS_BUS_UNDEF;
 880         if (!strncmp(pp->dev,"cciss",5))
 881                 pp->bus = SYSFS_BUS_CCISS;
 882         if (!strncmp(pp->dev,"dasd", 4))
 883                 pp->bus = SYSFS_BUS_CCW;
 884         if (!strncmp(pp->dev,"sd", 2))
 885                 pp->bus = SYSFS_BUS_SCSI;
 886
 887         if (pp->bus == SYSFS_BUS_UNDEF)
 888                 return 0;
 889         else if (pp->bus == SYSFS_BUS_SCSI) {
 890                 if (scsi_sysfs_pathinfo(pp))
 891                         return 1;
 892         } else if (pp->bus == SYSFS_BUS_CCW) {
 893                 if (ccw_sysfs_pathinfo(pp))
 894                         return 1;
 895         } else if (pp->bus == SYSFS_BUS_CCISS) {
 896                 if (cciss_sysfs_pathinfo(pp))
 897                         return 1;
 898         }
 899         return 0;
 900 }
 901
 902 static int
 903 scsi_ioctl_pathinfo (struct path * pp, int mask)
 904 {
 905         if (mask & DI_SERIAL) {
 906                 get_serial(pp->serial, SERIAL_SIZE, pp->fd);
 907                 condlog(3, "%s: serial = %s", pp->dev, pp->serial);
 908         }
 909
 910         return 0;
 911 }
 912
 913 static int
 914 cciss_ioctl_pathinfo (struct path * pp, int mask)
 915 {
 916         if (mask & DI_SERIAL) {
 917                 get_serial(pp->serial, SERIAL_SIZE, pp->fd);
 918                 condlog(3, "%s: serial = %s", pp->dev, pp->serial);
 919         }
 920         return 0;
 921 }
 922
 923 int
 924 get_state (struct path * pp, int daemon)
 925 {
 926         struct checker * c = &pp->checker;
 927         int state;
 928
 929         condlog(3, "%s: get_state", pp->dev);
 930
 931         if (!checker_selected(c)) {
 932                 if (daemon) {
 933                         if (pathinfo(pp, conf->hwtable, DI_SYSFS) != 0) {
 934                                 condlog(3, "%s: couldn't get sysfs pathinfo",
 935                                         pp->dev);
 936                                 return PATH_UNCHECKED;
 937                         }
 938                 }
 939                 select_checker(pp);
 940                 if (!checker_selected(c)) {
 941                         condlog(3, "%s: No checker selected", pp->dev);
 942                         return PATH_UNCHECKED;
 943                 }
 944                 checker_set_fd(c, pp->fd);
 945                 if (checker_init(c, pp->mpp?&pp->mpp->mpcontext:NULL)) {
 946                         memset(c, 0x0, sizeof(struct checker));
 947                         condlog(3, "%s: checker init failed", pp->dev);
 948                         return PATH_UNCHECKED;
 949                 }
 950         }
 951         checker_clear_message(c);
 952         if (daemon)
 953                 checker_set_async(c);
 954         if (!conf->checker_timeout &&
 955             (pp->bus != SYSFS_BUS_SCSI ||
 956              sysfs_get_timeout(pp, &(c->timeout))))
 957                 c->timeout = DEF_TIMEOUT;
 958         state = checker_check(c);
 959         condlog(3, "%s: state = %s", pp->dev, checker_state_name(state));
 960         if (state != PATH_UP && state != PATH_GHOST &&
 961             strlen(checker_message(c)))
 962                 condlog(3, "%s: checker msg is \"%s\"",
 963                         pp->dev, checker_message(c));
 964         return state;
 965 }
 966
 967 static int
 968 get_prio (struct path * pp)
 969 {
 970         if (!pp)
 971                 return 0;
 972
 973         struct prio * p = &pp->prio;
 974
 975         if (!prio_selected(p)) {
 976                 select_detect_prio(pp);
 977                 select_prio(pp);
 978                 if (!prio_selected(p)) {
 979                         condlog(3, "%s: no prio selected", pp->dev);
 980                         pp->priority = PRIO_UNDEF;
 981                         return 1;
 982                 }
 983         }
 984         pp->priority = prio_getprio(p, pp);
 985         if (pp->priority < 0) {
 986                 condlog(3, "%s: %s prio error", pp->dev, prio_name(p));
 987                 pp->priority = PRIO_UNDEF;
 988                 return 1;
 989         }
 990         condlog(3, "%s: %s prio = %u",
 991                 pp->dev, prio_name(p), pp->priority);
 992         return 0;
 993 }
 994
 995 static int
 996 get_uid (struct path * pp)
 997 {
 998         char *c;
 999         const char *origin;
1000
1001         if (!pp->uid_attribute && !pp->getuid)
1002                 select_getuid(pp);
1003
1004         if (!pp->udev) {
1005                 condlog(1, "%s: no udev information", pp->dev);
1006                 return 1;
1007         }
1008
1009         memset(pp->wwid, 0, WWID_SIZE);
1010         if (pp->getuid) {
1011                 char buff[CALLOUT_MAX_SIZE];
1012
1013                 /* Use 'getuid' callout, deprecated */
1014                 condlog(1, "%s: using deprecated getuid callout", pp->dev);
1015                 if (apply_format(pp->getuid, &buff[0], pp)) {
1016                         condlog(0, "error formatting uid callout command");
1017                         memset(pp->wwid, 0, WWID_SIZE);
1018                 } else if (execute_program(buff, pp->wwid, WWID_SIZE)) {
1019                         condlog(3, "error calling out %s", buff);
1020                         memset(pp->wwid, 0, WWID_SIZE);
1021                 }
1022                 origin = "callout";
1023         } else {
1024                 const char *value;
1025
1026                 value = udev_device_get_property_value(pp->udev,
1027                                                        pp->uid_attribute);
1028                 if ((!value || strlen(value) == 0) && conf->dry_run == 2)
1029                         value = getenv(pp->uid_attribute);
1030                 if (value && strlen(value)) {
1031                         size_t len = WWID_SIZE;
1032
1033                         if (strlen(value) + 1 > WWID_SIZE) {
1034                                 condlog(0, "%s: wwid overflow", pp->dev);
1035                         } else {
1036                                 len = strlen(value);
1037                         }
1038                         strncpy(pp->wwid, value, len);
1039                 } else {
1040                         condlog(3, "%s: no %s attribute", pp->dev,
1041                                 pp->uid_attribute);
1042                 }
1043                 origin = "udev";
1044         }
1045         /* Strip any trailing blanks */
1046         c = strchr(pp->wwid, '\0');
1047         c--;
1048         while (c && c >= pp->wwid && *c == ' ') {
1049                 *c = '\0';
1050                 c--;
1051         }
1052         condlog(3, "%s: uid = %s (%s)", pp->dev,
1053                 *pp->wwid == '\0' ? "<empty>" : pp->wwid, origin);
1054         return 0;
1055 }
1056
1057 extern int
1058 pathinfo (struct path *pp, vector hwtable, int mask)
1059 {
1060         int path_state;
1061
1062         condlog(3, "%s: mask = 0x%x", pp->dev, mask);
1063
1064         /*
1065          * fetch info available in sysfs
1066          */
1067         if (mask & DI_SYSFS && sysfs_pathinfo(pp))
1068                 return 1;
1069
1070         if (mask & DI_BLACKLIST && mask & DI_SYSFS) {
1071                 if (filter_device(conf->blist_device, conf->elist_device,
1072                                   pp->vendor_id, pp->product_id) > 0) {
1073                         return 2;
1074                 }
1075         }
1076
1077         path_state = path_offline(pp);
1078
1079         /*
1080          * fetch info not available through sysfs
1081          */
1082         if (pp->fd < 0)
1083                 pp->fd = open(udev_device_get_devnode(pp->udev), O_RDONLY);
1084
1085         if (pp->fd < 0) {
1086                 condlog(4, "Couldn't open node for %s: %s",
1087                         pp->dev, strerror(errno));
1088                 goto blank;
1089         }
1090
1091         if (mask & DI_SERIAL)
1092                 get_geometry(pp);
1093
1094         if (path_state == PATH_UP && pp->bus == SYSFS_BUS_SCSI &&
1095             scsi_ioctl_pathinfo(pp, mask))
1096                 goto blank;
1097
1098         if (pp->bus == SYSFS_BUS_CCISS &&
1099             cciss_ioctl_pathinfo(pp, mask))
1100                 goto blank;
1101
1102         if (mask & DI_CHECKER) {
1103                 if (path_state == PATH_UP) {
1104                         pp->chkrstate = pp->state = get_state(pp, 0);
1105                         if (pp->state == PATH_UNCHECKED ||
1106                             pp->state == PATH_WILD)
1107                                 goto blank;
1108                         if (pp->state == PATH_TIMEOUT)
1109                                 pp->state = PATH_DOWN;
1110                 } else {
1111                         condlog(3, "%s: path inaccessible", pp->dev);
1112                         pp->chkrstate = pp->state = path_state;
1113                 }
1114         }
1115
1116         if ((mask & DI_WWID) && !strlen(pp->wwid))
1117                 get_uid(pp);
1118         if (mask & DI_BLACKLIST && mask & DI_WWID) {
1119                 if (filter_wwid(conf->blist_wwid, conf->elist_wwid,
1120                                 pp->wwid) > 0) {
1121                         return 2;
1122                 }
1123         }
1124
1125          /*
1126           * Retrieve path priority, even for PATH_DOWN paths if it has never
1127           * been successfully obtained before.
1128           */
1129         if ((mask & DI_PRIO) && path_state == PATH_UP) {
1130                 if (pp->state != PATH_DOWN || pp->priority == PRIO_UNDEF) {
1131                         if (!strlen(pp->wwid))
1132                                 get_uid(pp);
1133                         get_prio(pp);
1134                 } else {
1135                         pp->priority = PRIO_UNDEF;
1136                 }
1137         }
1138
1139         return 0;
1140
1141 blank:
1142         /*
1143          * Recoverable error, for example faulty or offline path
1144          */
1145         memset(pp->wwid, 0, WWID_SIZE);
1146         pp->chkrstate = pp->state = PATH_DOWN;
1147
1148         return 0;
1149 }