usr/src/lib/sun_fc/common/FCHBAPort.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 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26
  27
  28 #include <FCHBAPort.h>
  29 #include <Exceptions.h>
  30 #include <Trace.h>
  31 #include <sun_fc.h>
  32 #include <iostream>
  33 #include <iomanip>
  34 #include <sys/types.h>
  35 #include <sys/mkdev.h>
  36 #include <sys/stat.h>
  37 #include <fcntl.h>
  38 #include <unistd.h>
  39 #include <stropts.h>
  40 #include <dirent.h>
  41 #include <sys/fibre-channel/fc.h>
  42 #include <sys/fibre-channel/fcio.h>
  43 #include <sys/fibre-channel/ulp/fcp_util.h>
  44 #include <sys/fibre-channel/ulp/fcsm.h>
  45 #include <sys/fibre-channel/impl/fc_error.h>
  46 #include <sys/fibre-channel/fc_appif.h>
  47 #include <sys/scsi/generic/commands.h>
  48 #include <sys/scsi/impl/commands.h>
  49 #include <sys/scsi/impl/sense.h>
  50 #include <sys/scsi/generic/inquiry.h>
  51 #include <sys/scsi/generic/status.h>
  52 #include <errno.h>
  53 #include <FCHBANPIVPort.h>
  54
  55
  56 using namespace std;
  57
  58 const int FCHBAPort::MAX_FCIO_MSG_LEN = 256;
  59 const string FCHBAPort::FCSM_DRIVER_PATH = "/devices/pseudo/fcsm@0:fcsm";
  60 const string FCHBAPort::FCP_DRIVER_PATH = "/devices/pseudo/fcp@0:fcp";
  61
  62 /*
  63  * Interpret the error code in the fcio_t structure
  64  *
  65  * message must be at least MAX_FCIO_MSG_LEN in length.
  66  */
  67 void
  68 FCHBAPort::transportError(uint32_t fcio_errno, char *message) {
  69         Trace log("transportError");
  70         string fcioErrorString;
  71         if (message == NULL) {
  72             log.internalError("NULL routine argument");
  73             return;
  74         }
  75         switch (fcio_errno) {
  76         case (uint32_t)FC_FAILURE:
  77             fcioErrorString = "general failure";
  78             break;
  79         case (uint32_t)FC_FAILURE_SILENT:
  80             fcioErrorString = "general failure but fail silently";
  81             break;
  82         case FC_SUCCESS:
  83             fcioErrorString = "successful completion";
  84             break;
  85         case FC_CAP_ERROR:
  86             fcioErrorString = "FCA capability error";
  87             break;
  88         case FC_CAP_FOUND:
  89             fcioErrorString = "FCA capability unsettable";
  90             break;
  91         case FC_CAP_SETTABLE:
  92             fcioErrorString = "FCA capability settable";
  93             break;
  94         case FC_UNBOUND:
  95             fcioErrorString = "unbound stuff";
  96             break;
  97         case FC_NOMEM:
  98             fcioErrorString = "allocation error";
  99             break;
 100         case FC_BADPACKET:
 101             fcioErrorString = "invalid packet specified/supplied";
 102             break;
 103         case FC_OFFLINE:
 104             fcioErrorString = "I/O resource unavailable";
 105             break;
 106         case FC_OLDPORT:
 107             fcioErrorString = "operation on non-loop port";
 108             break;
 109         case FC_NO_MAP:
 110             fcioErrorString = "requested map unavailable";
 111             break;
 112         case FC_TRANSPORT_ERROR:
 113             fcioErrorString = "unable to transport I/O";
 114             break;
 115         case FC_ELS_FREJECT:
 116             fcioErrorString = "ELS rejected by a Fabric";
 117             break;
 118         case FC_ELS_PREJECT:
 119             fcioErrorString = "ELS rejected by an N_port";
 120             break;
 121         case FC_ELS_BAD:
 122             fcioErrorString = "ELS rejected by FCA/fctl";
 123             break;
 124         case FC_ELS_MALFORMED:
 125             fcioErrorString = "poorly formed ELS request";
 126             break;
 127         case FC_TOOMANY:
 128                 fcioErrorString = "resource request too large";
 129             break;
 130         case FC_UB_BADTOKEN:
 131             fcioErrorString = "invalid unsolicited buffer token";
 132             break;
 133         case FC_UB_ERROR:
 134             fcioErrorString = "invalid unsol buf request";
 135             break;
 136         case FC_UB_BUSY:
 137             fcioErrorString = "buffer already in use";
 138             break;
 139         case FC_BADULP:
 140             fcioErrorString = "Unknown ulp";
 141             break;
 142         case FC_BADTYPE:
 143             fcioErrorString = "ULP not registered to handle this FC4 type";
 144             break;
 145         case FC_UNCLAIMED:
 146             fcioErrorString = "request or data not claimed";
 147             break;
 148         case FC_ULP_SAMEMODULE:
 149             fcioErrorString = "module already in use";
 150             break;
 151         case FC_ULP_SAMETYPE:
 152             fcioErrorString = "FC4 module already in use";
 153             break;
 154         case FC_ABORTED:
 155             fcioErrorString = "request aborted";
 156             break;
 157         case FC_ABORT_FAILED:
 158             fcioErrorString = "abort request failed";
 159             break;
 160         case FC_BADEXCHANGE:
 161             fcioErrorString = "exchange doesnÕt exist";
 162             break;
 163         case FC_BADWWN:
 164             fcioErrorString = "WWN not recognized";
 165             break;
 166         case FC_BADDEV:
 167             fcioErrorString = "device unrecognized";
 168             break;
 169         case FC_BADCMD:
 170             fcioErrorString = "invalid command issued";
 171             break;
 172         case FC_BADOBJECT:
 173             fcioErrorString = "invalid object requested";
 174             break;
 175         case FC_BADPORT:
 176             fcioErrorString = "invalid port specified";
 177             break;
 178         case FC_NOTTHISPORT:
 179             fcioErrorString = "resource not at this port";
 180             break;
 181         case FC_PREJECT:
 182             fcioErrorString = "reject at remote N_Port";
 183             break;
 184         case FC_FREJECT:
 185             fcioErrorString = "reject at remote Fabric";
 186             break;
 187         case FC_PBUSY:
 188             fcioErrorString = "remote N_Port busy";
 189             break;
 190         case FC_FBUSY:
 191             fcioErrorString = "remote Fabric busy";
 192             break;
 193         case FC_ALREADY:
 194             fcioErrorString = "already logged in";
 195             break;
 196         case FC_LOGINREQ:
 197             fcioErrorString = "login required";
 198             break;
 199         case FC_RESETFAIL:
 200             fcioErrorString = "reset failed";
 201             break;
 202         case FC_INVALID_REQUEST:
 203             fcioErrorString = "request is invalid";
 204             break;
 205         case FC_OUTOFBOUNDS:
 206             fcioErrorString = "port number is out of bounds";
 207             break;
 208         case FC_TRAN_BUSY:
 209             fcioErrorString = "command transport busy";
 210             break;
 211         case FC_STATEC_BUSY:
 212             fcioErrorString = "port driver currently busy";
 213             break;
 214         case FC_DEVICE_BUSY:
 215             fcioErrorString = "transport working on this device";
 216             break;
 217         case FC_DEVICE_NOT_TGT:
 218             fcioErrorString = "device is not a SCSI target";
 219             break;
 220         default:
 221             snprintf(message, MAX_FCIO_MSG_LEN, "Unknown error code 0x%x",
 222                 fcio_errno);
 223             return;
 224         }
 225         snprintf(message, MAX_FCIO_MSG_LEN, "%s", fcioErrorString.c_str());
 226 }
 227
 228 static void
 229 reportSense(struct scsi_extended_sense *sense, const char *routine) {
 230         Trace log("reportSense");
 231         string msg;
 232         if (!sense) {
 233             log.internalError("NULL sense argument passed.");
 234             return;
 235         }
 236         if (!routine) {
 237             log.internalError("NULL routine argument passed.");
 238             return;
 239         }
 240         log.genericIOError("SCSI FAILURE");
 241         switch (sense->es_key) {
 242         case KEY_NO_SENSE:
 243             msg = "No sense";
 244             break;
 245         case KEY_RECOVERABLE_ERROR:
 246             msg = "Recoverable error";
 247             break;
 248         case KEY_NOT_READY:
 249             msg = "Not ready";
 250             break;
 251         case KEY_MEDIUM_ERROR:
 252             msg = "Medium error";
 253             break;
 254         case KEY_HARDWARE_ERROR:
 255             msg = "Hardware error";
 256             break;
 257         case KEY_ILLEGAL_REQUEST:
 258             msg = "Illegal request";
 259             break;
 260         case KEY_UNIT_ATTENTION:
 261             msg = "Unit attention";
 262             break;
 263         case KEY_DATA_PROTECT:
 264             msg = "Data protect";
 265             break;
 266         case KEY_BLANK_CHECK:
 267             msg = "Blank check";
 268             break;
 269         case KEY_VENDOR_UNIQUE:
 270             msg = "Vendor Unique";
 271             break;
 272         case KEY_COPY_ABORTED:
 273             msg = "Copy aborted";
 274             break;
 275         case KEY_ABORTED_COMMAND:
 276             msg = "Aborted command";
 277             break;
 278         case KEY_EQUAL:
 279             msg = "Equal";
 280             break;
 281         case KEY_VOLUME_OVERFLOW:
 282             msg = "Volume overflow";
 283             break;
 284         case KEY_MISCOMPARE:
 285             msg = "Miscompare";
 286             break;
 287         case KEY_RESERVED:
 288             msg = "Reserved";
 289             break;
 290         default:
 291             msg = "unknown sense key";
 292         }
 293         log.genericIOError("\tSense key: %s", msg.c_str());
 294         log.genericIOError("\tASC  = 0x%x", sense->es_add_code);
 295         log.genericIOError("\tASCQ = 0x%x", sense->es_qual_code);
 296 }
 297
 298 /*
 299  * Issue a SCSI pass thru command.
 300  * Returns a scsi status value.
 301  */
 302 void FCHBAPort::sendSCSIPassThru(struct fcp_scsi_cmd *fscsi,
 303             HBA_UINT32 *responseSize, HBA_UINT32 *senseSize,
 304             HBA_UINT8 *scsiStatus) {
 305         Trace log("FCHBAPort::sendSCSIPassThru");
 306         int                 fd;
 307         HBA_STATUS          ret;
 308         int                 count;
 309         char                fcioErrorString[MAX_FCIO_MSG_LEN] = "";
 310         hrtime_t            start;
 311         hrtime_t            end;
 312         int                 ioctl_errno;
 313         double              duration;
 314         la_wwn_t            wwn;
 315
 316         if (fscsi == NULL ||
 317                 responseSize == NULL ||
 318                 senseSize == NULL ||
 319                 scsiStatus == NULL) {
 320             throw BadArgumentException();
 321         }
 322
 323         memcpy(&wwn, fscsi->scsi_fc_pwwn.raw_wwn, sizeof (la_wwn_t));
 324         start = gethrtime();
 325         fscsi->scsi_fc_port_num = instanceNumber;
 326
 327         fd = HBA::_open(FCP_DRIVER_PATH, O_RDONLY | O_NDELAY);
 328         count = 0;
 329         ioctl_errno = 0;
 330
 331         if (ioctl(fd, FCP_TGT_SEND_SCSI, fscsi) != 0) {
 332             /* save off errno */
 333             ioctl_errno = errno;
 334             close(fd);
 335             /*
 336              * collect SCSI status first regrardless of the value.
 337              * 0 is a good status so this should be okay
 338              */
 339             *scsiStatus = fscsi->scsi_bufstatus & STATUS_MASK;
 340             transportError(fscsi->scsi_fc_status, fcioErrorString);
 341
 342             /* Did we get a check condition? */
 343             if ((fscsi->scsi_bufstatus & STATUS_MASK) == STATUS_CHECK) {
 344                 *senseSize = fscsi->scsi_rqlen;
 345                 throw CheckConditionException();
 346             } else if (fscsi->scsi_fc_status == FC_DEVICE_NOT_TGT) {
 347                 /*
 348                  * fcp driver returns FC_DEVICE_NOT_TGT when the node is not
 349                  * scsi-capable like remote hba nodes.
 350                  */
 351                 throw NotATargetException();
 352             } else if (fscsi->scsi_fc_status == FC_INVALID_LUN) {
 353                 throw InvalidLUNException();
 354             } else if (ioctl_errno == EBUSY) {
 355                 throw BusyException();
 356             } else if (ioctl_errno == EAGAIN) {
 357                 throw TryAgainException();
 358             } else if (ioctl_errno == ENOTSUP) {
 359                 throw NotSupportedException();
 360             } else if (ioctl_errno == ENOENT) {
 361                 throw UnavailableException();
 362             } else {
 363                 throw IOError(this, wwnConversion(wwn.raw_wwn),
 364                         fscsi->scsi_lun);
 365             }
 366         } else {
 367                 close(fd);
 368             /* Just in case, check for a check-condition state */
 369             if ((fscsi->scsi_bufstatus & STATUS_MASK) == STATUS_CHECK) {
 370                 *scsiStatus = fscsi->scsi_bufstatus & STATUS_MASK;
 371                 *senseSize = fscsi->scsi_rqlen;
 372                 throw CheckConditionException();
 373             }
 374         }
 375
 376         /* Record the response data */
 377         *scsiStatus = fscsi->scsi_bufstatus & STATUS_MASK;
 378         *responseSize = fscsi->scsi_buflen;
 379         *senseSize = fscsi->scsi_rqlen;
 380
 381         /* Do some quick duration calcuations */
 382         end = gethrtime();
 383         duration = end - start;
 384         duration /= HR_SECOND;
 385         log.debug("Total SCSI IO time for HBA %s "
 386             "target %016llx was %.4f seconds", getPath().c_str(),
 387             wwnConversion(wwn.raw_wwn), duration);
 388
 389 #ifdef DEBUG
 390         /* Did we have any failure */
 391         if (ret != HBA_STATUS_OK) {
 392             log.genericIOError(
 393                 "Ioctl failed for device \"%s\" target %016llx."
 394                 "  Errno: \"%s\"(%d), "
 395                 "Transport: \"%s\", SCSI Status: 0x%x"
 396                 "responseSize = %d, senseSize = %d",
 397                 getPath().c_str(), wwnConversion(fscsi->scsi_fc_pwwn.raw_wwn),
 398                 strerror(ioctl_errno), ioctl_errno, fcioErrorString,
 399                 *scsiStatus, *responseSize, *senseSize);
 400             /* We may or may not have sense data */
 401             reportSense((struct scsi_extended_sense *)fscsi->scsi_rqbufaddr,
 402                 ROUTINE);
 403         }
 404 #endif
 405
 406 }
 407
 408 /*
 409  * constructs the fcp_scsi_cmd struct for SCSI_Inquiry, SendReadCapacity, or
 410  * SendReportLUNs
 411  */
 412 /*#include <fcio.h>
 413 #include <fcp_util.h>*/
 414 inline void
 415 scsi_cmd_init(struct fcp_scsi_cmd *fscsi, const char *portname, void *reqbuf,
 416             size_t req_len, void *responseBuffer, size_t resp_len,
 417             void *senseBuffer, size_t sense_len) {
 418         Trace log("scsi_cmd_init");
 419         fscsi->scsi_fc_rspcode  = 0;
 420         fscsi->scsi_flags       = FCP_SCSI_READ;
 421         fscsi->scsi_timeout     = 10 /* sec */;
 422         fscsi->scsi_cdbbufaddr  = (char *)reqbuf;
 423         fscsi->scsi_cdblen      = (uint32_t) req_len;
 424         fscsi->scsi_bufaddr     = (char *)responseBuffer;
 425         fscsi->scsi_buflen      = (uint32_t) resp_len;
 426         fscsi->scsi_bufresid    = 0;
 427         fscsi->scsi_bufstatus   = 0;
 428         fscsi->scsi_rqbufaddr   = (char *)senseBuffer;
 429         fscsi->scsi_rqlen       = (uint32_t) sense_len;
 430         fscsi->scsi_rqresid     = 0;
 431 }
 432
 433
 434 FCHBAPort::FCHBAPort(string thePath) : HBAPort() {
 435         Trace log("FCHBAPort::FCHBAPort");
 436         log.debug("Initializing HBA port %s", thePath.c_str());
 437         fcio_t          fcio;
 438         int             size = 200;
 439         fc_hba_npiv_port_list_t *pathList;
 440         bool            retry = false;
 441         int             bufSize;
 442
 443         try {
 444             path = lookupControllerPath(thePath);
 445             sscanf(path.c_str(), "/dev/cfg/c%d", &controllerNumber);
 446         } catch (...) {
 447             log.debug("Unable to lookup controller path and number for %s",
 448                     thePath.c_str());
 449             path = "/devices";
 450             path += thePath;
 451             path += ":fc";
 452             controllerNumber = -1;
 453         }
 454
 455         // Fetch the minor number for later use
 456         struct stat sbuf;
 457         if (stat(path.c_str(), &sbuf) == -1) {
 458             throw IOError("Unable to stat device path: " + path);
 459         }
 460         instanceNumber = minor(sbuf.st_rdev);
 461
 462         // This routine is not index based, so we can discard stateChange
 463         uint64_t tmp;
 464         HBA_PORTATTRIBUTES attrs = getPortAttributes(tmp);
 465         memcpy(&tmp, &attrs.PortWWN, 8);
 466         portWWN = ntohll(tmp);
 467         memcpy(&tmp, &attrs.NodeWWN, 8);
 468         nodeWWN = ntohll(tmp);
 469
 470         // For reference, here's how to dump WWN's through C++ streams.
 471         // cout << "\tPort WWN: " << hex << setfill('0') << setw(16) << portWWN
 472         // << endl;
 473         // cout << "\tNode WWN: " << hex << setfill('0') << setw(16) << nodeWWN
 474         // << endl;
 475
 476         // we should add code here to build NPIVPORT instance
 477         // Get Port's NPIV port list ( include nwwn and pwwn and path)
 478         memset((caddr_t)&fcio, 0, sizeof (fcio));
 479         fcio.fcio_cmd = FCIO_GET_NPIV_PORT_LIST;
 480         fcio.fcio_xfer = FCIO_XFER_READ;
 481         do {
 482                 retry = false;
 483                 bufSize = MAXPATHLEN * (size - 1) + (int) sizeof (fc_hba_npiv_port_list_t);
 484                 pathList = (fc_hba_npiv_port_list_t *) new uchar_t[bufSize];
 485                 pathList->numAdapters = size;
 486                 fcio.fcio_olen = bufSize;
 487                 fcio.fcio_obuf = (char *)pathList;
 488                 fp_ioctl(getPath(), FCIO_CMD, &fcio);
 489                 if (pathList->numAdapters > size) {
 490                         log.debug("Buffer too small for number of NPIV Port.Retry.");
 491                         size = pathList->numAdapters;
 492                         retry = true;
 493                         delete (pathList);
 494                 }
 495         } while (retry);
 496         log.debug("Get %d npiv ports", pathList->numAdapters);
 497         // Make instance for each NPIV Port
 498         for ( int i = 0; i < pathList->numAdapters; i++) {
 499                 try {
 500                         addPort(new FCHBANPIVPort(pathList->hbaPaths[i]));
 501                 } catch (...) {
 502                         log.debug("Ignoring partial failure");
 503                 }
 504         }
 505         delete (pathList);
 506 }
 507
 508 uint32_t FCHBAPort::deleteNPIVPort(uint64_t vportwwn) {
 509         Trace log("FCHBAPort::deleteNPIVPort");
 510         fcio_t  fcio;
 511         la_wwn_t        lawwn[1];
 512         int ret = 0;
 513
 514         memset(&fcio, 0, sizeof(fcio));
 515         uint64_t en_wwn = htonll(vportwwn);
 516         memcpy(&lawwn[0], &en_wwn, sizeof (en_wwn));
 517
 518         fcio.fcio_cmd = FCIO_DELETE_NPIV_PORT;
 519         fcio.fcio_xfer = FCIO_XFER_WRITE;
 520         fcio.fcio_ilen = sizeof (la_wwn_t) * 2;
 521         fcio.fcio_ibuf = (caddr_t)&lawwn;
 522
 523         fp_ioctl(getPath(), FCIO_CMD, &fcio);
 524
 525         return (ret);
 526 }
 527
 528 uint32_t FCHBAPort::createNPIVPort(uint64_t vnodewwn, uint64_t vportwwn, uint32_t vindex) {
 529         Trace log("FCHBAPort::createNPIVPort");
 530         fcio_t  fcio;
 531         la_wwn_t        lawwn[2];
 532         uint32_t vportindex = 0;
 533         HBA_NPIVCREATEENTRY     entrybuf;
 534
 535         memset(&fcio, 0, sizeof(fcio));
 536         uint64_t en_wwn = htonll(vnodewwn);
 537         memcpy(&entrybuf.VNodeWWN, &en_wwn, sizeof (en_wwn));
 538         en_wwn = htonll(vportwwn);
 539         memcpy(&entrybuf.VPortWWN, &en_wwn, sizeof (en_wwn));
 540         entrybuf.vindex = vindex;
 541
 542         fcio.fcio_cmd = FCIO_CREATE_NPIV_PORT;
 543         fcio.fcio_xfer = FCIO_XFER_READ;
 544         fcio.fcio_olen = sizeof (uint32_t);
 545         fcio.fcio_obuf = (caddr_t)&vportindex;
 546         fcio.fcio_ilen = sizeof (HBA_NPIVCREATEENTRY);
 547         fcio.fcio_ibuf = (caddr_t)&entrybuf;
 548
 549         fp_ioctl(getPath(), FCIO_CMD, &fcio);
 550
 551         return (vportindex);
 552 }
 553
 554 HBA_PORTNPIVATTRIBUTES FCHBAPort::getPortNPIVAttributes(uint64_t &stateChange) {
 555         Trace log("FCHBAPort::getPortNPIVAttributes");
 556
 557         HBA_PORTNPIVATTRIBUTES  attributes;
 558         fc_hba_port_npiv_attributes_t   attrs;
 559         fcio_t  fcio;
 560
 561         memset(&fcio, 0, sizeof(fcio));
 562         memset(&attributes, 0, sizeof(attributes));
 563
 564         fcio.fcio_cmd = FCIO_GET_ADAPTER_PORT_NPIV_ATTRIBUTES;
 565         fcio.fcio_olen = sizeof(attrs);
 566         fcio.fcio_xfer = FCIO_XFER_READ;
 567         fcio.fcio_obuf = (caddr_t)&attrs;
 568
 569         fp_ioctl(getPath(), FCIO_CMD, &fcio);
 570
 571         stateChange = attrs.lastChange;
 572         attributes.npivflag = attrs.npivflag;
 573         memcpy(&attributes.NodeWWN, &attrs.NodeWWN, 8);
 574         memcpy(&attributes.PortWWN, &attrs.PortWWN, 8);
 575         attributes.MaxNumberOfNPIVPorts = attrs.MaxNumberOfNPIVPorts;
 576         attributes.NumberOfNPIVPorts = attrs.NumberOfNPIVPorts;
 577
 578         return (attributes);
 579 }
 580
 581 HBA_PORTATTRIBUTES FCHBAPort::getPortAttributes(uint64_t &stateChange) {
 582         Trace log("FCHBAPort::getPortAttributes");
 583
 584         HBA_PORTATTRIBUTES              attributes;
 585         fcio_t                  fcio;
 586         fc_hba_port_attributes_t    attrs;
 587
 588         memset(&fcio, 0, sizeof (fcio));
 589         memset(&attributes, 0, sizeof (attributes));
 590
 591         fcio.fcio_cmd = FCIO_GET_ADAPTER_PORT_ATTRIBUTES;
 592         fcio.fcio_olen = sizeof (attrs);
 593         fcio.fcio_xfer = FCIO_XFER_READ;
 594         fcio.fcio_obuf = (caddr_t)&attrs;
 595
 596         fp_ioctl(getPath(), FCIO_CMD, &fcio);
 597
 598         stateChange = attrs.lastChange;
 599
 600         attributes.PortFcId = attrs.PortFcId;
 601         attributes.PortType = attrs.PortType;
 602         attributes.PortState = attrs.PortState;
 603         attributes.PortSupportedClassofService = attrs.PortSupportedClassofService;
 604         attributes.PortSupportedSpeed = attrs.PortSupportedSpeed;
 605         attributes.PortSpeed = attrs.PortSpeed;
 606         attributes.PortMaxFrameSize = attrs.PortMaxFrameSize;
 607         attributes.NumberofDiscoveredPorts = attrs.NumberofDiscoveredPorts;
 608         memcpy(&attributes.NodeWWN, &attrs.NodeWWN, 8);
 609         memcpy(&attributes.PortWWN, &attrs.PortWWN, 8);
 610         memcpy(&attributes.FabricName, &attrs.FabricName, 8);
 611         memcpy(&attributes.PortSupportedFc4Types, &attrs.PortSupportedFc4Types, 32);
 612         memcpy(&attributes.PortActiveFc4Types, &attrs.PortActiveFc4Types, 32);
 613         memcpy(&attributes.PortSymbolicName, &attrs.PortSymbolicName, 256);
 614
 615         strncpy((char *)attributes.OSDeviceName, getPath().c_str(), 256);
 616         return (attributes);
 617 }
 618
 619 HBA_PORTATTRIBUTES FCHBAPort::getDiscoveredAttributes(
 620             HBA_UINT32 discoveredport, uint64_t &stateChange) {
 621         Trace log("FCHBAPort::getDiscoverdAttributes(i)");
 622
 623         HBA_PORTATTRIBUTES              attributes;
 624         fcio_t                  fcio;
 625         fc_hba_port_attributes_t    attrs;
 626
 627         memset(&fcio, 0, sizeof (fcio));
 628         memset(&attributes, 0, sizeof (attributes));
 629
 630         fcio.fcio_cmd = FCIO_GET_DISCOVERED_PORT_ATTRIBUTES;
 631         fcio.fcio_olen = sizeof (attrs);
 632         fcio.fcio_xfer = FCIO_XFER_READ;
 633         fcio.fcio_obuf = (caddr_t)&attrs;
 634         fcio.fcio_ilen = sizeof (discoveredport);
 635         fcio.fcio_ibuf = (caddr_t)&discoveredport;
 636
 637         fp_ioctl(getPath(), FCIO_CMD, &fcio);
 638
 639         stateChange = attrs.lastChange;
 640
 641         attributes.PortFcId = attrs.PortFcId;
 642         attributes.PortType = attrs.PortType;
 643         attributes.PortState = attrs.PortState;
 644         attributes.PortSupportedClassofService = attrs.PortSupportedClassofService;
 645         attributes.PortSupportedSpeed = attrs.PortSupportedSpeed;
 646         attributes.PortSpeed = attrs.PortSpeed;
 647         attributes.PortMaxFrameSize = attrs.PortMaxFrameSize;
 648         attributes.NumberofDiscoveredPorts = attrs.NumberofDiscoveredPorts;
 649         memcpy(&attributes.NodeWWN, &attrs.NodeWWN, 8);
 650         memcpy(&attributes.PortWWN, &attrs.PortWWN, 8);
 651         memcpy(&attributes.FabricName, &attrs.FabricName, 8);
 652         memcpy(&attributes.PortSupportedFc4Types, &attrs.PortSupportedFc4Types, 32);
 653         memcpy(&attributes.PortActiveFc4Types, &attrs.PortActiveFc4Types, 32);
 654         memcpy(&attributes.PortSymbolicName, &attrs.PortSymbolicName, 256);
 655
 656
 657         return (attributes);
 658 }
 659
 660 HBA_PORTATTRIBUTES FCHBAPort::getDiscoveredAttributes(
 661             uint64_t wwn, uint64_t &stateChange) {
 662         Trace log("FCHBAPort::getDiscoverdAttributes(p)");
 663
 664         HBA_PORTATTRIBUTES attributes;
 665         fcio_t                  fcio;
 666         fc_hba_port_attributes_t    attrs;
 667         la_wwn_t        lawwn;
 668
 669         memset(&fcio, 0, sizeof (fcio));
 670         memset(&attributes, 0, sizeof (attributes));
 671
 672         uint64_t en_wwn = htonll(wwn);
 673         memcpy(&lawwn, &en_wwn, sizeof (en_wwn));
 674
 675         fcio.fcio_cmd = FCIO_GET_PORT_ATTRIBUTES;
 676         fcio.fcio_olen = sizeof (attrs);
 677         fcio.fcio_xfer = FCIO_XFER_READ;
 678         fcio.fcio_obuf = (caddr_t)&attrs;
 679         fcio.fcio_ilen = sizeof (wwn);
 680         fcio.fcio_ibuf = (caddr_t)&lawwn;
 681
 682         fp_ioctl(getPath(), FCIO_CMD, &fcio);
 683
 684         stateChange = attrs.lastChange;
 685
 686         attributes.PortFcId = attrs.PortFcId;
 687         attributes.PortType = attrs.PortType;
 688         attributes.PortState = attrs.PortState;
 689         attributes.PortSupportedClassofService = attrs.PortSupportedClassofService;
 690         attributes.PortSupportedSpeed = attrs.PortSupportedSpeed;
 691         attributes.PortSpeed = attrs.PortSpeed;
 692         attributes.PortMaxFrameSize = attrs.PortMaxFrameSize;
 693         attributes.NumberofDiscoveredPorts = attrs.NumberofDiscoveredPorts;
 694         memcpy(&attributes.NodeWWN, &attrs.NodeWWN, 8);
 695         memcpy(&attributes.PortWWN, &attrs.PortWWN, 8);
 696         memcpy(&attributes.FabricName, &attrs.FabricName, 8);
 697         memcpy(&attributes.PortSupportedFc4Types, &attrs.PortSupportedFc4Types, 32);
 698         memcpy(&attributes.PortActiveFc4Types, &attrs.PortActiveFc4Types, 32);
 699         memcpy(&attributes.PortSymbolicName, &attrs.PortSymbolicName, 256);
 700
 701
 702         return (attributes);
 703 }
 704
 705
 706 void FCHBAPort::getTargetMappings(PHBA_FCPTARGETMAPPINGV2 userMappings) {
 707         Trace log("FCHBAPort::getTargetMappings");
 708         int                             i, index;
 709         uint_t                  total_entries = 0;
 710
 711         struct fcp_ioctl                fioctl;
 712         fc_hba_target_mappings_t    *mappings;
 713         int                             fd;
 714         bool                    zeroLength = false;
 715
 716
 717         if (userMappings == NULL) {
 718             log.userError("Null mapping argument ");
 719             throw BadArgumentException();
 720         }
 721
 722         /* It's possible they didn't give any space */
 723         if (userMappings->NumberOfEntries == 0) {
 724             zeroLength = true;
 725             userMappings->NumberOfEntries = 1;
 726                 /* We have to give the driver at least one space */
 727         }
 728
 729         mappings = (fc_hba_target_mappings_t *)new uchar_t[
 730                 (sizeof (fc_hba_mapping_entry_t)) *
 731                 (userMappings->NumberOfEntries - 1) +
 732                 sizeof (fc_hba_target_mappings_t)];
 733         if (mappings == NULL) {
 734             log.noMemory();
 735             throw InternalError();
 736         }
 737
 738
 739         fioctl.fp_minor = instanceNumber;
 740         fioctl.listlen = ((uint32_t) (sizeof (fc_hba_mapping_entry_t))) *
 741                 (userMappings->NumberOfEntries - 1) +
 742                 (uint32_t) sizeof (fc_hba_target_mappings_t);
 743         fioctl.list = (caddr_t)mappings;
 744
 745         fd = HBA::_open(FCP_DRIVER_PATH, O_RDONLY | O_NDELAY);
 746
 747         log.debug("Performing IOCTL to fetch mappings");
 748
 749         if (ioctl(fd, FCP_GET_TARGET_MAPPINGS, &fioctl) != 0) {
 750             delete (mappings);
 751             close(fd);
 752             if (errno == EBUSY) {
 753                 throw BusyException();
 754             } else if (errno == EAGAIN) {
 755                 throw TryAgainException();
 756             } else if (errno == ENOTSUP) {
 757                 throw NotSupportedException();
 758             } else if (errno == ENOENT) {
 759                 throw UnavailableException();
 760             } else {
 761                 throw IOError("Unable to fetch target mappings");
 762             }
 763         }
 764
 765         close(fd);
 766         // Quickly iterate through and copy the data over to the client
 767         for (i = 0; i < userMappings->NumberOfEntries && !zeroLength &&
 768                     i < mappings->numLuns; i++) {
 769             string raw = mappings->entries[i].targetDriver;
 770
 771
 772             if (raw.length() <= 0) {
 773                 log.internalError("Bad target mapping without path, truncating.");
 774                 break;
 775             }
 776             /*
 777              * Ideally, we'd like to ask some standard Solaris interface
 778              * "What is the prefered minor node for this target?"
 779              * but no such interface exists today.  So, for now,
 780              * we just hard-code ":n" for tapes, ":c,raw" for disks,
 781              * and ":0" for enclosures.
 782              * Devices with other generic names will be presented through
 783              * first matching /dev path.
 784              */
 785             if ((raw.find("/st@") != raw.npos) ||
 786                 (raw.find("/tape@") != raw.npos)) {
 787                 raw += ":n";
 788             } else if ((raw.find("/ssd@") != raw.npos) ||
 789                 (raw.find("/sd@") != raw.npos) ||
 790                 (raw.find("/disk@") != raw.npos)) {
 791                 raw += ":c,raw";
 792             } else if ((raw.find("/ses@") != raw.npos) ||
 793                 (raw.find("/enclosure@") != raw.npos)) {
 794                 raw += ":0";
 795             } else {
 796                 log.debug(
 797             "Unrecognized target driver (%s), using first matching /dev path",
 798                     raw.c_str());
 799             }
 800             snprintf(userMappings->entry[i].ScsiId.OSDeviceName,
 801                 sizeof (userMappings->entry[i].ScsiId.OSDeviceName),
 802                 "/devices%s", raw.c_str());
 803             userMappings->entry[i].ScsiId.ScsiBusNumber =
 804                     controllerNumber;
 805             userMappings->entry[i].ScsiId.ScsiTargetNumber =
 806                     mappings->entries[i].targetNumber;
 807             userMappings->entry[i].ScsiId.ScsiOSLun =
 808                     mappings->entries[i].osLUN;
 809             userMappings->entry[i].FcpId.FcId =
 810                     mappings->entries[i].d_id;
 811             memcpy(userMappings->entry[i].FcpId.NodeWWN.wwn,
 812                     mappings->entries[i].NodeWWN.raw_wwn,
 813                     sizeof (la_wwn_t));
 814             memcpy(userMappings->entry[i].FcpId.PortWWN.wwn,
 815                     mappings->entries[i].PortWWN.raw_wwn,
 816                     sizeof (la_wwn_t));
 817
 818             userMappings->entry[i].FcpId.FcpLun =
 819                 mappings->entries[i].samLUN;
 820
 821             memcpy(userMappings->entry[i].LUID.buffer,
 822                     mappings->entries[i].guid,
 823                     sizeof (userMappings->entry[i].LUID.buffer));
 824         }
 825
 826         log.debug("Total mappings: %d %08x %08x",
 827             mappings->numLuns, mappings->entries[i].osLUN, mappings->entries[i].samLUN);
 828
 829         // If everything is good, convert paths to sym-links
 830         if (mappings->numLuns > 0 && !zeroLength) {
 831             if (userMappings->NumberOfEntries >= mappings->numLuns) {
 832                 // User buffer is larger than needed. (All is good)
 833                 userMappings->NumberOfEntries = mappings->numLuns;
 834                 convertToShortNames(userMappings);
 835             } else {
 836                 // User buffer is non zero, but too small.  Don't bother with links
 837                 userMappings->NumberOfEntries = mappings->numLuns;
 838                 delete (mappings);
 839                 throw MoreDataException();
 840             }
 841         } else if (mappings->numLuns > 0) {
 842             // Zero length buffer, but we've got mappings
 843             userMappings->NumberOfEntries = mappings->numLuns;
 844             delete (mappings);
 845             throw MoreDataException();
 846         } else {
 847             // No mappings, no worries
 848             userMappings->NumberOfEntries = 0;
 849             delete (mappings);
 850             return;
 851         }
 852         delete (mappings);
 853 }
 854
 855 void FCHBAPort::getRNIDMgmtInfo(PHBA_MGMTINFO info) {
 856         Trace log("FCHBAPort::getRNIDMgmtInfo");
 857         HBA_STATUS              status = HBA_STATUS_OK;
 858         fc_rnid_t               rnid;
 859         fcio_t                  fcio;
 860
 861
 862         if (info == NULL) {
 863             log.userError("NULL port management info");
 864             throw BadArgumentException();
 865         }
 866
 867         // Get the RNID information from the first port
 868         memset(&rnid, 0, sizeof (fc_rnid_t));
 869         memset((caddr_t)&fcio, 0, sizeof (fcio));
 870
 871         fcio.fcio_cmd = FCIO_GET_NODE_ID;
 872         fcio.fcio_olen = sizeof (fc_rnid_t);
 873         fcio.fcio_xfer = FCIO_XFER_READ;
 874         fcio.fcio_obuf = (caddr_t)&rnid;
 875         fp_ioctl(getPath(), FCIO_CMD, &fcio);
 876
 877         // Copy out the struct members of rnid into PHBA_MGMTINFO struct
 878         memcpy(&info->wwn, &(rnid.global_id), sizeof (info->wwn));
 879         memcpy(&info->unittype, &(rnid.unit_type), sizeof (info->unittype));
 880         memcpy(&info->PortId, &(rnid.port_id), sizeof (info->PortId));
 881         memcpy(&info->NumberOfAttachedNodes, &(rnid.num_attached),
 882                 sizeof (info->NumberOfAttachedNodes));
 883         memcpy(&info->IPVersion, &(rnid.ip_version), sizeof (info->IPVersion));
 884         memcpy(&info->UDPPort, &(rnid.udp_port), sizeof (info->UDPPort));
 885         memcpy(&info->IPAddress, &(rnid.ip_addr), sizeof (info->IPAddress));
 886         memcpy(&info->TopologyDiscoveryFlags, &(rnid.topo_flags),
 887                 sizeof (info->TopologyDiscoveryFlags));
 888 }
 889
 890 void FCHBAPort::sendCTPassThru(void *requestBuffer, HBA_UINT32 requestSize,
 891             void *responseBuffer, HBA_UINT32 *responseSize) {
 892         Trace log("FCHBAPort::sendCTPassThru");
 893         fcio_t                  fcio;
 894         struct stat             sbuf;
 895         minor_t                 minor_node;
 896         hrtime_t                start, end;
 897         double                  duration;
 898
 899         // Validate the arguments
 900         if (requestBuffer == NULL) {
 901             log.userError("NULL request buffer");
 902             throw BadArgumentException();
 903         }
 904         if (responseBuffer == NULL) {
 905             log.userError("NULL response buffer");
 906             throw BadArgumentException();
 907         }
 908
 909         minor_node = instanceNumber;
 910
 911         // construct fcio struct
 912         memset(&fcio, 0, sizeof (fcio_t));
 913         fcio.fcio_cmd   = FCSMIO_CT_CMD;
 914         fcio.fcio_xfer  = FCIO_XFER_RW;
 915
 916         fcio.fcio_ilen  = requestSize;
 917         fcio.fcio_ibuf  = (char *)requestBuffer;
 918         fcio.fcio_olen  = *responseSize;
 919         fcio.fcio_obuf  = (char *)responseBuffer;
 920
 921         fcio.fcio_alen  = sizeof (minor_t);
 922         fcio.fcio_abuf  = (char *)&minor_node;
 923
 924
 925         start = gethrtime();
 926         fcsm_ioctl(FCSMIO_CMD, &fcio);
 927
 928         // Do some calculations on the duration of the ioctl.
 929         end = gethrtime();
 930         duration = end - start;
 931         duration /= HR_SECOND;
 932         log.debug(
 933             "Total CTPASS ioctl call for HBA %s was %.4f seconds",
 934             getPath().c_str(), duration);
 935 }
 936
 937 void FCHBAPort::sendRLS(uint64_t destWWN,
 938             void                *pRspBuffer,
 939             HBA_UINT32          *pRspBufferSize) {
 940         Trace log("FCHBAPort::sendRLS");
 941
 942         fcio_t          fcio;
 943         fc_portid_t             rls_req;
 944
 945
 946         // Validate the arguments
 947         if (pRspBuffer == NULL ||
 948                 pRspBufferSize == NULL) {
 949             log.userError("NULL hba");
 950             throw BadArgumentException();
 951         }
 952
 953         // check to see if we are sending RLS to the HBA
 954         HBA_PORTATTRIBUTES attrs;
 955         uint64_t tmp;
 956         if (getPortWWN() == destWWN) {
 957             attrs = getPortAttributes(tmp);
 958         } else {
 959             attrs = getDiscoveredAttributes(destWWN, tmp);
 960         }
 961
 962         memcpy(&rls_req, &attrs.PortFcId,
 963             sizeof (attrs.PortFcId));
 964
 965         memset((caddr_t)&fcio, 0, sizeof (fcio));
 966         fcio.fcio_cmd = FCIO_LINK_STATUS;
 967         fcio.fcio_ibuf = (caddr_t)&rls_req;
 968         fcio.fcio_ilen = sizeof (rls_req);
 969         fcio.fcio_xfer = FCIO_XFER_RW;
 970         fcio.fcio_flags = 0;
 971         fcio.fcio_cmd_flags = FCIO_CFLAGS_RLS_DEST_NPORT;
 972         fcio.fcio_obuf = (char *)new uchar_t[*pRspBufferSize];
 973         fcio.fcio_olen = *pRspBufferSize;
 974
 975         if (fcio.fcio_obuf == NULL) {
 976             log.noMemory();
 977             throw InternalError();
 978         }
 979
 980         fp_ioctl(getPath(), FCIO_CMD, &fcio);
 981         memcpy(pRspBuffer, fcio.fcio_obuf, *pRspBufferSize);
 982         if (fcio.fcio_obuf != NULL) {
 983             delete(fcio.fcio_obuf);
 984         }
 985 }
 986
 987 void FCHBAPort::sendReportLUNs(uint64_t wwn,
 988             void *responseBuffer, HBA_UINT32 *responseSize,
 989             HBA_UINT8 *scsiStatus,
 990             void *senseBuffer, HBA_UINT32 *senseSize) {
 991         Trace log("FCHBAPort::sendReportLUNs");
 992         struct  fcp_scsi_cmd        fscsi;
 993         union   scsi_cdb            scsi_rl_req;
 994         uint64_t                    targetWwn = htonll(wwn);
 995
 996         // Validate the arguments
 997         if (responseBuffer == NULL ||
 998                 senseBuffer == NULL ||
 999                 responseSize == NULL ||
1000                 senseSize == NULL) {
1001             throw BadArgumentException();
1002         }
1003
1004         memset(&fscsi, 0, sizeof (fscsi));
1005         memset(&scsi_rl_req, 0, sizeof (scsi_rl_req));
1006         memcpy(fscsi.scsi_fc_pwwn.raw_wwn, &targetWwn, sizeof (la_wwn_t));
1007
1008         scsi_cmd_init(&fscsi, getPath().c_str(), &scsi_rl_req,
1009                     sizeof (scsi_rl_req), responseBuffer, *responseSize,
1010                     senseBuffer, *senseSize);
1011
1012         fscsi.scsi_lun = 0;
1013         scsi_rl_req.scc_cmd = SCMD_REPORT_LUNS;
1014         FORMG5COUNT(&scsi_rl_req, *responseSize);
1015         sendSCSIPassThru(&fscsi, responseSize, senseSize, scsiStatus);
1016 }
1017
1018 /*
1019  * arguments:
1020  *      wwn - remote target WWN where the SCSI Inquiry shall be sent
1021  *      fcLun - the SCSI LUN to which the SCSI Inquiry shall be sent
1022  *      cdb1 - the second byte of the CDB for the SCSI Inquiry
1023  *      cdb2 - the third byte of teh CDB for the SCSI Inquiry
1024  *      responseBuffer - shall be a pointer to a buffer to receive the SCSI
1025  *              Inquiry command response
1026  *      responseSize - a pointer to the size of the buffer to receive
1027  *              the SCSI Inquiry.
1028  *      scsiStatus - a pointer to a buffer to receive SCSI status
1029  *      senseBuffer - pointer to a buffer to receive SCSI sense data
1030  *      seneseSize - pointer to the size of the buffer to receive SCSI sense
1031  *              data
1032  */
1033 void FCHBAPort::sendScsiInquiry(uint64_t wwn, HBA_UINT64 fcLun,
1034             HBA_UINT8 cdb1, HBA_UINT8 cdb2, void *responseBuffer,
1035             HBA_UINT32 *responseSize, HBA_UINT8 *scsiStatus, void *senseBuffer,
1036             HBA_UINT32 *senseSize) {
1037         Trace log("FCHBAPort::sendScsiInquiry");
1038
1039         struct  fcp_scsi_cmd        fscsi;
1040         union   scsi_cdb            scsi_inq_req;
1041         uint64_t                    targetWwn = htonll(wwn);
1042
1043         // Validate the arguments
1044         if (responseBuffer == NULL ||
1045                 senseBuffer == NULL ||
1046                 responseSize == NULL ||
1047                 senseSize == NULL) {
1048             throw BadArgumentException();
1049         }
1050
1051         memset(&fscsi, 0, sizeof (fscsi));
1052         memset(&scsi_inq_req, 0, sizeof (scsi_inq_req));
1053         memcpy(fscsi.scsi_fc_pwwn.raw_wwn, &targetWwn, sizeof (la_wwn_t));
1054
1055
1056         scsi_cmd_init(&fscsi, getPath().c_str(), &scsi_inq_req,
1057             sizeof (scsi_inq_req), responseBuffer, *responseSize,
1058             senseBuffer, *senseSize);
1059         fscsi.scsi_lun = fcLun;
1060
1061         scsi_inq_req.scc_cmd = SCMD_INQUIRY;
1062         scsi_inq_req.g0_addr1 = cdb2;
1063         scsi_inq_req.g0_addr2 = cdb1;
1064         scsi_inq_req.g0_count0 = *responseSize;
1065
1066
1067         sendSCSIPassThru(&fscsi, responseSize, senseSize, scsiStatus);
1068 }
1069
1070
1071 void FCHBAPort::sendReadCapacity(uint64_t pwwn,
1072                 HBA_UINT64 fcLun, void *responseBuffer,
1073                 HBA_UINT32 *responseSize, HBA_UINT8 *scsiStatus,
1074                 void *senseBuffer, HBA_UINT32 *senseSize) {
1075         Trace log("FCHBAPort::sendReadCapacity");
1076
1077         struct fcp_scsi_cmd         fscsi;
1078         union scsi_cdb      scsi_rc_req;
1079         uint64_t                    targetWwn = htonll(pwwn);
1080
1081         // Validate the arguments
1082         if (responseBuffer == NULL ||
1083                 senseBuffer == NULL ||
1084                 responseSize == NULL ||
1085                 senseSize == NULL ||
1086                 scsiStatus == NULL) {
1087             throw BadArgumentException();
1088         }
1089
1090         memset(&fscsi, 0, sizeof (fscsi));
1091         memset(&scsi_rc_req, 0, sizeof (scsi_rc_req));
1092
1093         scsi_cmd_init(&fscsi, getPath().c_str(), &scsi_rc_req,
1094             sizeof (scsi_rc_req), responseBuffer, *responseSize,
1095             senseBuffer, *senseSize);
1096
1097         memcpy(fscsi.scsi_fc_pwwn.raw_wwn, &targetWwn, sizeof (la_wwn_t));
1098         fscsi.scsi_lun = fcLun;
1099
1100         scsi_rc_req.scc_cmd = SCMD_READ_CAPACITY;
1101         scsi_rc_req.g1_reladdr = 0;
1102
1103         scsi_rc_req.g1_addr3 = 0;
1104         scsi_rc_req.g1_count0   = 0;
1105
1106         sendSCSIPassThru(&fscsi, responseSize, senseSize, scsiStatus);
1107 }
1108
1109 void FCHBAPort::sendRNID(uint64_t destwwn, HBA_UINT32 destfcid,
1110                             HBA_UINT32 nodeIdDataFormat, void *pRspBuffer,
1111                             HBA_UINT32 *RspBufferSize) {
1112         Trace log("FCHBAPort::sendRNID");
1113         int                     localportfound, remoteportfound, send;
1114         fcio_t                  fcio;
1115
1116         // Validate the arguments
1117         if (pRspBuffer == NULL ||
1118                 RspBufferSize == NULL) {
1119             throw BadArgumentException();
1120         }
1121         // NodeIdDataFormat must be within the range of 0x00 and 0xff
1122         if (nodeIdDataFormat > 0xff) {
1123             log.userError(
1124                     "NodeIdDataFormat must be within the range of 0x00 "
1125                     "and 0xFF");
1126             throw BadArgumentException();
1127         }
1128
1129
1130         remoteportfound = 0;
1131         if (destfcid != 0) {
1132             try {
1133                 uint64_t tmp;
1134                 HBA_PORTATTRIBUTES attrs = getDiscoveredAttributes(destwwn,
1135                         tmp);
1136                 if (attrs.PortFcId == destfcid) {
1137                     send = 1;
1138                     remoteportfound = 1;
1139                 } else {
1140                     send = 0;
1141                     remoteportfound = 1;
1142                 }
1143             } catch (HBAException &e) {
1144                 /*
1145                  * Send RNID if destination port not
1146                  * present in the discovered ports table
1147                  */
1148             }
1149             if (remoteportfound == 0) {
1150                 send = 1;
1151             }
1152         } else {
1153             send = 1;
1154         }
1155
1156         if (!send) {
1157             // Can we log something so we can figure out why?
1158             throw BadArgumentException();
1159         }
1160
1161         memset((caddr_t)&fcio, 0, sizeof (fcio));
1162         uint64_t netdestwwn = htonll(destwwn);
1163         fcio.fcio_cmd = FCIO_SEND_NODE_ID;
1164         fcio.fcio_xfer = FCIO_XFER_READ;
1165         fcio.fcio_cmd_flags = nodeIdDataFormat;
1166         fcio.fcio_ilen = sizeof (la_wwn_t);
1167         fcio.fcio_ibuf = (caddr_t)&netdestwwn;
1168         fcio.fcio_olen  = *RspBufferSize;
1169         fcio.fcio_obuf  = (char *)new uchar_t[*RspBufferSize];
1170
1171
1172         if (fcio.fcio_obuf == NULL) {
1173             log.noMemory();
1174             throw InternalError();
1175         }
1176
1177         fp_ioctl(getPath(), FCIO_CMD, &fcio);
1178
1179         memcpy(pRspBuffer, fcio.fcio_obuf, *RspBufferSize);
1180
1181         if (fcio.fcio_obuf != NULL) {
1182             delete(fcio.fcio_obuf);
1183         }
1184 }
1185
1186 void FCHBAPort::setRNID(HBA_MGMTINFO info) {
1187         Trace log("FCHBAPort::setRNID");
1188         fc_rnid_t               rnid;
1189         fcio_t                  fcio;
1190
1191         memset(&rnid, 0, sizeof (fc_rnid_t));
1192         memset((caddr_t)&fcio, 0, sizeof (fcio));
1193
1194
1195         fcio.fcio_cmd = FCIO_SET_NODE_ID;
1196         fcio.fcio_ilen = sizeof (fc_rnid_t);
1197         fcio.fcio_xfer = FCIO_XFER_WRITE;
1198         fcio.fcio_ibuf = (caddr_t)&rnid;
1199
1200
1201         // Copy the HBA_MGMTINFO into fc_rnid_t struct
1202         memcpy(&(rnid.unit_type), &(info.unittype), sizeof (rnid.unit_type));
1203         memcpy(&(rnid.port_id), &(info.PortId), sizeof (rnid.port_id));
1204         memcpy(&(rnid.global_id), &(info.wwn), sizeof (info.wwn));
1205         memcpy(&(rnid.num_attached), &(info.NumberOfAttachedNodes),
1206                 sizeof (rnid.num_attached));
1207         memcpy(&(rnid.ip_version), &(info.IPVersion), sizeof (rnid.ip_version));
1208         memcpy(&(rnid.udp_port), &(info.UDPPort), sizeof (rnid.udp_port));
1209         memcpy(&(rnid.ip_addr), &info.IPAddress, sizeof (rnid.ip_addr));
1210         memcpy(&(rnid.topo_flags), &(info.TopologyDiscoveryFlags),
1211                 sizeof (rnid.topo_flags));
1212
1213         fp_ioctl(getPath(), FCIO_CMD, &fcio, O_NDELAY | O_RDONLY | O_EXCL);
1214 }
1215
1216 void FCHBAPort::fp_ioctl(string path, int cmd, fcio_t *fcio, int openflag) {
1217         Trace log("FCHBAPort::fp_ioctl with openflag");
1218         char fcioErrorString[MAX_FCIO_MSG_LEN] = "";
1219         int fd = HBA::_open(path, openflag);
1220         try {
1221             int times = 0;
1222             HBA::_ioctl(fd, cmd, (uchar_t *)fcio);
1223             while (fcio->fcio_errno == FC_STATEC_BUSY) {
1224                 sleep(1);
1225                 HBA::_ioctl(fd, cmd, (uchar_t *)fcio);
1226                 if (times++ > 10) {
1227                         break;
1228                 }
1229             }
1230             close(fd);
1231             if (fcio->fcio_errno) {
1232                 throw IOError("IOCTL transport failure");
1233             }
1234         } catch (...) {
1235             close(fd);
1236             transportError(fcio->fcio_errno, fcioErrorString);
1237             log.genericIOError("ioctl (0x%x) failed. Transport: \"%s\"", cmd,
1238                     fcioErrorString);
1239             switch (fcio->fcio_errno) {
1240             case FC_BADWWN:
1241                 throw IllegalWWNException();
1242             case FC_BADPORT:
1243                 throw IllegalWWNException();
1244             case FC_OUTOFBOUNDS:
1245                 throw IllegalIndexException();
1246             case FC_PBUSY:
1247             case FC_FBUSY:
1248             case FC_TRAN_BUSY:
1249             case FC_STATEC_BUSY:
1250             case FC_DEVICE_BUSY:
1251                 throw BusyException();
1252             case FC_SUCCESS:
1253             default:
1254                 throw;
1255             }
1256         }
1257 }
1258
1259 void FCHBAPort::fp_ioctl(string path, int cmd, fcio_t *fcio) {
1260         Trace log("FCHBAPort::fp_ioctl");
1261         fp_ioctl(path, cmd, fcio, O_NDELAY | O_RDONLY);
1262 }
1263
1264 void FCHBAPort::fcsm_ioctl(int cmd, fcio_t *fcio) {
1265         // We use the same error handling as fp, so just re-use
1266         fp_ioctl(FCSM_DRIVER_PATH, cmd, fcio);
1267 }