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 2008 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 + (int) sizeof (fc_hba_npiv_port_list_t) - 1; 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 } 1268