usr/src/lib/sun_fc/common/FCHBA.cc

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26
  27 #include <unistd.h>
  28
  29 #include <FCHBA.h>
  30 #include <Exceptions.h>
  31 #include <Trace.h>
  32 #include <iostream>
  33 #include <iomanip>
  34 #include <cerrno>
  35 #include <cstring>
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38 #include <fcntl.h>
  39 #include <unistd.h>
  40 #include <stropts.h>
  41 #include <sys/fibre-channel/fcio.h>
  42 #include <sys/fibre-channel/ulp/fcsm.h>
  43 #include <FCHBAPort.h>
  44 #include <HBAList.h>
  45
  46 #define EXCPT_RETRY_COUNT    10
  47
  48 using namespace std;
  49 const string FCHBA::FCSM_DRIVER_PATH = "/devices/pseudo/fcsm@0:fcsm";
  50 const string FCHBA::FCSM_DRIVER_PKG     = "SUNWfcsm";
  51 const int FCHBA::MAX_FCIO_MSG_LEN = 256;
  52
  53 FCHBA::FCHBA(string path) : HBA() {
  54     Trace log("FCHBA::FCHBA");
  55     log.debug("Constructing new HBA (%s)", path.c_str());
  56
  57     // Add first port
  58     addPort(new FCHBAPort(path));
  59
  60     name = "INTERNAL-FAILURE"; // Just in case things go wrong
  61     try {
  62         HBA_ADAPTERATTRIBUTES attrs = getHBAAttributes();
  63         name = attrs.Manufacturer;
  64         name += "-";
  65         name += attrs.Model;
  66
  67         // Grab any other ports on this adapter
  68         for (int i = 1; i < attrs.NumberOfPorts; i++) {
  69             fcio_t                      fcio;
  70             int                 fd;
  71             char                nextPath[MAXPATHLEN];
  72
  73             log.debug("Fetching other port %d", i);
  74
  75             // construct fcio struct
  76             memset(&fcio, 0, sizeof (fcio_t));
  77             memset(nextPath, 0, sizeof (nextPath));
  78             fcio.fcio_cmd       = FCIO_GET_OTHER_ADAPTER_PORTS;
  79             fcio.fcio_xfer      = FCIO_XFER_RW;
  80
  81             fcio.fcio_olen      = MAXPATHLEN;
  82             fcio.fcio_obuf      = (char *)nextPath;
  83             fcio.fcio_ilen      = sizeof (i);
  84             fcio.fcio_ibuf      = (char *)&i;
  85
  86             // open the fcsm node so we can send the ioctl to
  87             errno = 0;
  88             HBAPort *port = getPortByIndex(0);
  89             if ((fd = open(port->getPath().c_str(), O_NDELAY | O_RDONLY)) ==
  90                     -1) {
  91                 log.debug("Unable to open %d opened (%s)", i,
  92                 port->getPath().c_str());
  93                 if (errno == EBUSY) {
  94                     throw BusyException();
  95                 } else if (errno == EAGAIN) {
  96                     throw TryAgainException();
  97                 } else if (errno == ENOTSUP) {
  98                     throw NotSupportedException();
  99                 } else if (errno == ENOENT) {
 100                     throw UnavailableException();
 101                 } else {
 102                     throw IOError("Unable to open FCSM driver");
 103                 }
 104             }
 105             log.debug("Other port %d opened", i);
 106
 107             errno = 0;
 108             if (ioctl(fd, FCIO_CMD, &fcio) != 0) {
 109                 // Interpret the fcio error code
 110                 char fcioErrorString[MAX_FCIO_MSG_LEN] = "";
 111
 112                 log.genericIOError(
 113                     "ADAPTER_LIST failed: "
 114                     "Errno: \"%s\"",
 115                     strerror(errno));
 116                 close(fd);
 117                 if (errno == EBUSY) {
 118                     throw BusyException();
 119                 } else if (errno == EAGAIN) {
 120                     throw TryAgainException();
 121                 } else if (errno == ENOTSUP) {
 122                     throw NotSupportedException();
 123                 } else if (errno == ENOENT) {
 124                     throw UnavailableException();
 125                 } else {
 126                     throw IOError("Unable to build HBA list");
 127                 }
 128             }
 129             close(fd);
 130             log.debug("About to add port %d (%s)", i, nextPath);
 131             addPort(new FCHBAPort(nextPath));
 132         }
 133     } catch (BusyException &e) {
 134         throw e;
 135     } catch (TryAgainException &e) {
 136         throw e;
 137     } catch (UnavailableException &e) {
 138         throw e;
 139     } catch (HBAException &e) {
 140         log.internalError(
 141                 "Unable to construct HBA.");
 142         throw e;
 143     }
 144 }
 145
 146 std::string FCHBA::getName() {
 147     Trace log("FCHBA::getName");
 148     return (name);
 149 }
 150
 151 HBA_ADAPTERATTRIBUTES FCHBA::getHBAAttributes() {
 152     Trace log("FCHBA::getHBAAttributes");
 153     int fd;
 154
 155     errno = 0;
 156     HBAPort *port = getPortByIndex(0);
 157     if ((fd = open(port->getPath().c_str(), O_NDELAY | O_RDONLY)) == -1) {
 158         // Why did we fail?
 159         if (errno == EBUSY) {
 160             throw BusyException();
 161         } else if (errno == EAGAIN) {
 162             throw TryAgainException();
 163         } else if (errno == ENOTSUP) {
 164             throw NotSupportedException();
 165         } else {
 166             throw IOError(port);
 167         }
 168     }
 169
 170     HBA_ADAPTERATTRIBUTES attributes;
 171     fcio_t                          fcio;
 172     fc_hba_adapter_attributes_t     attrs;
 173
 174     memset(&fcio, 0, sizeof (fcio));
 175
 176     fcio.fcio_cmd = FCIO_GET_ADAPTER_ATTRIBUTES;
 177     fcio.fcio_olen = sizeof (attrs);
 178     fcio.fcio_xfer = FCIO_XFER_READ;
 179     fcio.fcio_obuf = (caddr_t)&attrs;
 180
 181
 182     errno = 0;
 183     if (ioctl(fd, FCIO_CMD, &fcio) != 0) {
 184         close(fd);
 185         if (errno == EBUSY) {
 186             throw BusyException();
 187         } else if (errno == EAGAIN) {
 188             throw TryAgainException();
 189         } else if (errno == ENOTSUP) {
 190             throw NotSupportedException();
 191         } else {
 192             throw IOError("Unable to fetch adapter attributes");
 193         }
 194     }
 195     close(fd);
 196
 197     /* Now copy over the payload */
 198     attributes.NumberOfPorts = attrs.NumberOfPorts;
 199     attributes.VendorSpecificID = attrs.VendorSpecificID;
 200     memcpy(attributes.Manufacturer, attrs.Manufacturer, 64);
 201     memcpy(attributes.SerialNumber, attrs.SerialNumber, 64);
 202     memcpy(attributes.Model, attrs.Model, 256);
 203     memcpy(attributes.ModelDescription, attrs.ModelDescription, 256);
 204     memcpy(attributes.NodeSymbolicName, attrs.NodeSymbolicName, 256);
 205     memcpy(attributes.HardwareVersion, attrs.HardwareVersion, 256);
 206     memcpy(attributes.DriverVersion, attrs.DriverVersion, 256);
 207     memcpy(attributes.OptionROMVersion, attrs.OptionROMVersion, 256);
 208     memcpy(attributes.FirmwareVersion, attrs.FirmwareVersion, 256);
 209     memcpy(attributes.DriverName, attrs.DriverName, 256);
 210     memcpy(&attributes.NodeWWN, &attrs.NodeWWN, 8);
 211
 212     return (attributes);
 213 }
 214
 215 int FCHBA::doForceLip() {
 216     Trace        log("FCHBA::doForceLip");
 217     int          fd;
 218     fcio_t       fcio;
 219     uint64_t     wwn  = 0;
 220     HBAPort     *port = getPortByIndex(0);
 221
 222     errno = 0;
 223     if ((fd = open(port->getPath().c_str(), O_RDONLY | O_EXCL)) == -1) {
 224         if (errno == EBUSY) {
 225             throw BusyException();
 226         } else if (errno == EAGAIN) {
 227             throw TryAgainException();
 228         } else if (errno == ENOTSUP) {
 229             throw NotSupportedException();
 230         } else {
 231             throw IOError(port);
 232         }
 233     }
 234
 235     memset(&fcio, 0, sizeof (fcio));
 236     fcio.fcio_cmd = FCIO_RESET_LINK;
 237     fcio.fcio_xfer = FCIO_XFER_WRITE;
 238     fcio.fcio_ilen = sizeof (wwn);
 239     fcio.fcio_ibuf = (caddr_t)&wwn;
 240
 241     errno = 0;
 242     if (ioctl(fd, FCIO_CMD, &fcio) != 0) {
 243         close(fd);
 244
 245         if (errno == EBUSY) {
 246             throw BusyException();
 247         } else if (errno == EAGAIN) {
 248             throw TryAgainException();
 249         } else if (errno == ENOTSUP) {
 250             throw NotSupportedException();
 251         } else {
 252             throw IOError("Unable to reinitialize the link");
 253         }
 254     } else {
 255         close(fd);
 256         return (fcio.fcio_errno);
 257     }
 258 }
 259
 260 HBA_ADAPTERATTRIBUTES FCHBA::npivGetHBAAttributes() {
 261         Trace log("FCHBA::npivGetHBAAttributes");
 262         int fd;
 263
 264         errno = 0;
 265         HBAPort *port = getPortByIndex(0);
 266         if ((fd = open(port->getPath().c_str(), O_NDELAY | O_RDONLY)) == -1) {
 267                 // Why did we fail?
 268                 if (errno == EBUSY) {
 269                         throw BusyException();
 270                 } else if (errno == EAGAIN) {
 271                         throw TryAgainException();
 272                 } else if (errno == ENOTSUP) {
 273                         throw NotSupportedException();
 274                 } else {
 275                         throw IOError(port);
 276                 }
 277         }
 278
 279         HBA_ADAPTERATTRIBUTES attributes;
 280         fcio_t fcio;
 281         fc_hba_adapter_attributes_t attrs;
 282
 283         memset(&fcio, 0, sizeof (fcio));
 284         fcio.fcio_cmd = FCIO_NPIV_GET_ADAPTER_ATTRIBUTES;
 285         fcio.fcio_olen = sizeof (attrs);
 286         fcio.fcio_xfer = FCIO_XFER_READ;
 287         fcio.fcio_obuf = (caddr_t)&attrs;
 288         errno = 0;
 289
 290         if (ioctl(fd, FCIO_CMD, &fcio) != 0) {
 291                 close(fd);
 292                 if (errno == EBUSY) {
 293                         throw BusyException();
 294                 } else if (errno == EAGAIN) {
 295                         throw TryAgainException();
 296                 } else if (errno == ENOTSUP) {
 297                         throw NotSupportedException();
 298                 } else {
 299                         throw IOError("Unable to fetch adapter attributes");
 300                 }
 301         }
 302         close(fd);
 303
 304         /* Now copy over the payload */
 305         attributes.NumberOfPorts = attrs.NumberOfPorts;
 306         attributes.VendorSpecificID = attrs.VendorSpecificID;
 307         memcpy(attributes.Manufacturer, attrs.Manufacturer, 64);
 308         memcpy(attributes.SerialNumber, attrs.SerialNumber, 64);
 309         memcpy(attributes.Model, attrs.Model, 256);
 310         memcpy(attributes.ModelDescription, attrs.ModelDescription, 256);
 311         memcpy(attributes.NodeSymbolicName, attrs.NodeSymbolicName, 256);
 312         memcpy(attributes.HardwareVersion, attrs.HardwareVersion, 256);
 313         memcpy(attributes.DriverVersion, attrs.DriverVersion, 256);
 314         memcpy(attributes.OptionROMVersion, attrs.OptionROMVersion, 256);
 315         memcpy(attributes.FirmwareVersion, attrs.FirmwareVersion, 256);
 316         memcpy(attributes.DriverName, attrs.DriverName, 256);
 317         memcpy(&attributes.NodeWWN, &attrs.NodeWWN, 8);
 318
 319         return (attributes);
 320 }
 321
 322 void FCHBA::loadAdapters(vector<HBA*> &list) {
 323     Trace log("FCHBA::loadAdapters");
 324     fcio_t                      fcio;
 325     fc_hba_list_t               *pathList;
 326     int                 fd;
 327     int                 size = 64; // default first attempt
 328     bool                retry = false;
 329     struct stat         sb;
 330     int bufSize;
 331
 332     /* Before we do anything, let's see if FCSM is on the system */
 333     errno = 0;
 334     if (stat(FCSM_DRIVER_PATH.c_str(), &sb) != 0) {
 335         if (errno == ENOENT) {
 336             log.genericIOError(
 337                 "The %s driver is not present. Unable to issue "
 338                 "CT commands. Please install the %s package.",
 339                 FCSM_DRIVER_PATH.c_str(), FCSM_DRIVER_PKG.c_str());
 340             throw NotSupportedException();
 341         } else {
 342             log.genericIOError(
 343                 "Can not stat the %s driver for reason \"%s\" "
 344                 "Unable to issue CT commands.",
 345                 FCSM_DRIVER_PATH.c_str(), strerror(errno));
 346             throw IOError("Unable to stat FCSM driver");
 347         }
 348     }
 349
 350
 351     /* construct fcio struct */
 352     memset(&fcio, 0, sizeof (fcio_t));
 353     fcio.fcio_cmd       = FCSMIO_ADAPTER_LIST;
 354     fcio.fcio_xfer      = FCIO_XFER_RW;
 355
 356
 357     /* open the fcsm node so we can send the ioctl to */
 358     errno = 0;
 359     if ((fd = open(FCSM_DRIVER_PATH.c_str(), O_RDONLY)) < 0) {
 360         if (errno == EBUSY) {
 361             throw BusyException();
 362         } else if (errno == EAGAIN) {
 363             throw TryAgainException();
 364         } else if (errno == ENOTSUP) {
 365             throw NotSupportedException();
 366         } else if (errno == ENOENT) {
 367             throw UnavailableException();
 368         } else {
 369             throw IOError("Unable to open FCSM driver");
 370         }
 371     }
 372
 373     do {
 374         retry = false;
 375         errno = 0;
 376         bufSize = MAXPATHLEN * size + (int) sizeof (fc_hba_list_t) - 1;
 377         pathList = (fc_hba_list_t *)new uchar_t[bufSize];
 378         pathList->numAdapters = size;
 379         fcio.fcio_olen  = bufSize;
 380         fcio.fcio_obuf  = (char *)pathList;
 381         if (ioctl(fd, FCSMIO_CMD, &fcio) != 0) {
 382             /* Interpret the fcio error code */
 383             char fcioErrorString[MAX_FCIO_MSG_LEN] = "";
 384
 385             log.genericIOError(
 386                 "ADAPTER_LIST failed: "
 387                 "Errno: \"%s\"",
 388                 strerror(errno));
 389             delete (pathList);
 390             close(fd);
 391             if (errno == EBUSY) {
 392                 throw BusyException();
 393             } else if (errno == EAGAIN) {
 394                 throw TryAgainException();
 395             } else if (errno == ENOTSUP) {
 396                 throw NotSupportedException();
 397             } else if (errno == ENOENT) {
 398                 throw UnavailableException();
 399             } else {
 400                 throw IOError("Unable to build HBA list");
 401             }
 402         }
 403         if (pathList->numAdapters > size) {
 404             log.debug(
 405                 "Buffer too small for number of HBAs. Retrying.");
 406             size = pathList->numAdapters;
 407             retry = true;
 408             delete (pathList);
 409         }
 410     } while (retry);
 411
 412     close(fd);
 413     log.debug("Detected %d adapters", pathList->numAdapters);
 414     for (int i = 0, times =0; i < pathList->numAdapters;) {
 415         try {
 416             HBA *hba = new FCHBA(pathList->hbaPaths[i]);
 417             list.insert(list.begin(), hba);
 418             i++;
 419         } catch (BusyException &e) {
 420             sleep(1);
 421             if (times++ > EXCPT_RETRY_COUNT) {
 422                 i++;
 423                 times = 0;
 424             }
 425             continue;
 426         } catch (TryAgainException &e) {
 427             sleep(1);
 428             if (times++ > EXCPT_RETRY_COUNT) {
 429                 i++;
 430                 times = 0;
 431             }
 432             continue;
 433         } catch (UnavailableException &e) {
 434             sleep(1);
 435             if (times++ > EXCPT_RETRY_COUNT) {
 436                 i++;
 437                 times = 0;
 438             }
 439             continue;
 440         } catch (HBAException &e) {
 441             i++;
 442             times = 0;
 443             log.debug(
 444                 "Ignoring partial failure while loading an HBA");
 445         }
 446     }
 447     if (pathList->numAdapters > HBAList::HBA_MAX_PER_LIST) {
 448         delete(pathList);
 449         throw InternalError(
 450             "Exceeds max number of adapters that VSL supports.");
 451     }
 452     delete (pathList);
 453 }