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 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 26 */ 27 28 #include <sun_sas.h> 29 #include <sys/types.h> 30 #include <netinet/in.h> 31 #include <inttypes.h> 32 #include <ctype.h> 33 #include <sys/scsi/scsi_address.h> 34 #include <libdevid.h> 35 36 /* 37 * Get the preferred minor node for the given path. 38 * ":n" for tapes, ":c,raw" for disks, 39 * and ":0" for enclosures. 40 */ 41 static void 42 get_minor(char *devpath, char *minor) 43 { 44 const char ROUTINE[] = "get_minor"; 45 char fullpath[MAXPATHLEN]; 46 int fd; 47 48 if ((strstr(devpath, "/st@")) || (strstr(devpath, "/tape@"))) { 49 (void) strcpy(minor, ":n"); 50 } else if (strstr(devpath, "/smp@")) { 51 (void) strcpy(minor, ":smp"); 52 } else if ((strstr(devpath, "/ssd@")) || (strstr(devpath, "/sd@")) || 53 (strstr(devpath, "/disk@"))) { 54 (void) strcpy(minor, ":c,raw"); 55 } else if ((strstr(devpath, "/ses@")) || (strstr(devpath, 56 "/enclosure@"))) { 57 (void) snprintf(fullpath, MAXPATHLEN, "%s%s%s", DEVICES_DIR, 58 devpath, ":0"); 59 /* reset errno to 0 */ 60 errno = 0; 61 if ((fd = open(fullpath, O_RDONLY)) == -1) { 62 /* 63 * :0 minor doesn't exist. assume bound to sgen driver 64 * and :ses minor exist. 65 */ 66 if (errno == ENOENT) { 67 (void) strcpy(minor, ":ses"); 68 } 69 } else { 70 (void) strcpy(minor, ":0"); 71 (void) close(fd); 72 } 73 } else { 74 log(LOG_DEBUG, ROUTINE, "Unrecognized target (%s)", 75 devpath); 76 minor[0] = '\0'; 77 } 78 79 } 80 81 /* 82 * Free the attached port allocation. 83 */ 84 static void 85 free_attached_port(struct sun_sas_port *port_ptr) 86 { 87 struct sun_sas_port *tgt_port, *last_tgt_port; 88 struct ScsiEntryList *scsi_info = NULL, *last_scsi_info = NULL; 89 90 tgt_port = port_ptr->first_attached_port; 91 while (tgt_port != NULL) { 92 /* Free target mapping data list first. */ 93 scsi_info = tgt_port->scsiInfo; 94 while (scsi_info != NULL) { 95 last_scsi_info = scsi_info; 96 scsi_info = scsi_info->next; 97 free(last_scsi_info); 98 } 99 last_tgt_port = tgt_port; 100 tgt_port = tgt_port->next; 101 free(last_tgt_port->port_attributes.\ 102 PortSpecificAttribute.SASPort); 103 free(last_tgt_port); 104 } 105 106 port_ptr->first_attached_port = NULL; 107 port_ptr->port_attributes.PortSpecificAttribute.\ 108 SASPort->NumberofDiscoveredPorts = 0; 109 } 110 111 /* 112 * Fill domainPortWWN. 113 * should be called after completing discovered port discovery. 114 */ 115 void 116 fillDomainPortWWN(struct sun_sas_port *port_ptr) 117 { 118 const char ROUTINE[] = "fillDomainPortWWN"; 119 struct sun_sas_port *disco_port_ptr; 120 struct phy_info *phy_ptr; 121 uint64_t domainPort = 0; 122 struct ScsiEntryList *mapping_ptr; 123 124 for (disco_port_ptr = port_ptr->first_attached_port; 125 disco_port_ptr != NULL; disco_port_ptr = disco_port_ptr->next) { 126 if (disco_port_ptr->port_attributes.PortType == 127 HBA_PORTTYPE_SASEXPANDER && 128 wwnConversion(disco_port_ptr->port_attributes. 129 PortSpecificAttribute.SASPort-> 130 AttachedSASAddress.wwn) == 131 wwnConversion(port_ptr->port_attributes. 132 PortSpecificAttribute.SASPort-> 133 LocalSASAddress.wwn)) { 134 (void) memcpy(&domainPort, 135 disco_port_ptr->port_attributes. 136 PortSpecificAttribute. 137 SASPort->LocalSASAddress.wwn, 8); 138 break; 139 } 140 } 141 142 if (domainPort == 0) { 143 if (port_ptr->first_attached_port) { 144 /* 145 * there is no expander device attached on an HBA port 146 * domainPortWWN should not stay to 0 since multiple 147 * hba ports can have the same LocalSASAddres within 148 * the same HBA. 149 * Set the SAS address of direct attached target. 150 */ 151 if (wwnConversion(port_ptr->port_attributes. 152 PortSpecificAttribute.SASPort-> 153 LocalSASAddress.wwn) == 154 wwnConversion(port_ptr->first_attached_port-> 155 port_attributes.PortSpecificAttribute. 156 SASPort->AttachedSASAddress.wwn)) { 157 (void) memcpy(&domainPort, 158 port_ptr->first_attached_port-> 159 port_attributes.PortSpecificAttribute. 160 SASPort->LocalSASAddress.wwn, 8); 161 } else { 162 /* 163 * SAS address is not upstream connected. 164 * domainPortWWN stays as 0. 165 */ 166 log(LOG_DEBUG, ROUTINE, 167 "DomainPortWWN is not set. " 168 "Device(s) are visible on the HBA port " 169 "but there is no expander or directly " 170 "attached port with matching upsteam " 171 "attached SAS address for " 172 "HBA port (Local SAS Address: %016llx).", 173 wwnConversion(port_ptr->port_attributes. 174 PortSpecificAttribute. 175 SASPort->LocalSASAddress.wwn)); 176 return; 177 } 178 } else { 179 /* 180 * There existss an iport without properly configured 181 * child smp ndoes or child node or pathinfo. 182 * domainPortWWN stays as 0. 183 */ 184 log(LOG_DEBUG, ROUTINE, 185 "DomainPortWWN is not set. No properly " 186 "configured smp or directly attached port " 187 "found on HBA port(Local SAS Address: %016llx).", 188 wwnConversion(port_ptr->port_attributes. 189 PortSpecificAttribute. 190 SASPort->LocalSASAddress.wwn)); 191 return; 192 } 193 } 194 195 /* fill up phy info */ 196 for (phy_ptr = port_ptr->first_phy; phy_ptr != NULL; 197 phy_ptr = phy_ptr->next) { 198 (void) memcpy(phy_ptr->phy.domainPortWWN.wwn, &domainPort, 8); 199 } 200 201 /* fill up target mapping */ 202 for (disco_port_ptr = port_ptr->first_attached_port; 203 disco_port_ptr != NULL; disco_port_ptr = disco_port_ptr->next) { 204 for (mapping_ptr = disco_port_ptr->scsiInfo; 205 mapping_ptr != NULL; 206 mapping_ptr = mapping_ptr->next) { 207 (void) memcpy(mapping_ptr->entry.PortLun. 208 domainPortWWN.wwn, &domainPort, 8); 209 } 210 } 211 } 212 213 /* 214 * Finds attached device(target) from devinfo node. 215 */ 216 static HBA_STATUS 217 get_attached_devices_info(di_node_t node, struct sun_sas_port *port_ptr) 218 { 219 const char ROUTINE[] = "get_attached_devices_info"; 220 char *propStringData = NULL; 221 int *propIntData = NULL; 222 int64_t *propInt64Data = NULL; 223 scsi_lun_t samLun; 224 ddi_devid_t devid; 225 char *guidStr; 226 char *unit_address; 227 char *charptr; 228 char *devpath, link[MAXNAMELEN]; 229 char fullpath[MAXPATHLEN+1]; 230 char minorname[MAXNAMELEN+1]; 231 struct ScsiEntryList *mapping_ptr; 232 HBA_WWN SASAddress, AttachedSASAddress; 233 struct sun_sas_port *disco_port_ptr; 234 uint_t state = 0; 235 int portfound, rval, size; 236 int port_state = HBA_PORTSTATE_ONLINE; 237 uint64_t tmpAddr; 238 239 if (port_ptr == NULL) { 240 log(LOG_DEBUG, ROUTINE, "NULL port_ptr argument"); 241 return (HBA_STATUS_ERROR); 242 } 243 244 if ((devpath = di_devfs_path(node)) == NULL) { 245 log(LOG_DEBUG, ROUTINE, 246 "Device in device tree has no path. Skipping."); 247 return (HBA_STATUS_ERROR); 248 } 249 250 if ((di_instance(node) == -1) || di_retired(node)) { 251 log(LOG_DEBUG, ROUTINE, 252 "dev node (%s) returned instance of -1 or is retired. " 253 " Skipping.", devpath); 254 di_devfs_path_free(devpath); 255 return (HBA_STATUS_OK); 256 } 257 state = di_state(node); 258 /* when node is not attached and online, set the state to offline. */ 259 if (((state & DI_DRIVER_DETACHED) == DI_DRIVER_DETACHED) || 260 ((state & DI_DEVICE_OFFLINE) == DI_DEVICE_OFFLINE)) { 261 log(LOG_DEBUG, ROUTINE, 262 "dev node (%s) is either OFFLINE or DETACHED", 263 devpath); 264 port_state = HBA_PORTSTATE_OFFLINE; 265 } 266 267 /* add the "/devices" in the begining at the end */ 268 (void) snprintf(fullpath, sizeof (fullpath), "%s%s", 269 DEVICES_DIR, devpath); 270 271 (void) memset(&SASAddress, 0, sizeof (SASAddress)); 272 if ((unit_address = di_bus_addr(node)) != NULL) { 273 if ((charptr = strchr(unit_address, ',')) != NULL) { 274 *charptr = '\0'; 275 } 276 for (charptr = unit_address; *charptr != '\0'; charptr++) { 277 if (isxdigit(*charptr)) { 278 break; 279 } 280 } 281 if (*charptr != '\0') { 282 tmpAddr = htonll(strtoll(charptr, NULL, 16)); 283 (void) memcpy(&SASAddress.wwn[0], &tmpAddr, 8); 284 } else { 285 log(LOG_DEBUG, ROUTINE, 286 "No proper target port info on unit address of %s", 287 fullpath); 288 di_devfs_path_free(devpath); 289 return (HBA_STATUS_ERROR); 290 } 291 } else { 292 log(LOG_DEBUG, ROUTINE, 293 "Fail to get unit address of %s.", 294 fullpath); 295 di_devfs_path_free(devpath); 296 return (HBA_STATUS_ERROR); 297 } 298 299 (void) memset(&AttachedSASAddress, 0, sizeof (AttachedSASAddress)); 300 if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, "attached-port", 301 &propStringData) != -1) { 302 for (charptr = propStringData; *charptr != '\0'; charptr++) { 303 if (isxdigit(*charptr)) { 304 break; 305 } 306 } 307 if (*charptr != '\0') { 308 tmpAddr = htonll(strtoll(charptr, NULL, 16)); 309 (void) memcpy(AttachedSASAddress.wwn, &tmpAddr, 8); 310 /* check the attached address of hba port. */ 311 if (memcmp(port_ptr->port_attributes. 312 PortSpecificAttribute.SASPort->LocalSASAddress.wwn, 313 &tmpAddr, 8) == 0) { 314 /* 315 * When attached-port is set from iport 316 * attached-port prop, we do the cross check 317 * with device's own SAS address. 318 * 319 * If not set, we store device's own SAS 320 * address to iport attached SAS address. 321 */ 322 if (wwnConversion(port_ptr->port_attributes. 323 PortSpecificAttribute.SASPort-> 324 AttachedSASAddress.wwn)) { 325 /* verify the Attaached SAS Addr. */ 326 if (memcmp(port_ptr->port_attributes. 327 PortSpecificAttribute.SASPort-> 328 AttachedSASAddress.wwn, 329 SASAddress.wwn, 8) != 0) { 330 /* indentation move begin. */ 331 log(LOG_DEBUG, ROUTINE, 332 "iport attached-port(%016llx) do not" 333 " match with level 1 Local" 334 " SAS address(%016llx).", 335 wwnConversion(port_ptr->port_attributes. 336 PortSpecificAttribute. 337 SASPort->AttachedSASAddress.wwn), 338 wwnConversion(SASAddress.wwn)); 339 di_devfs_path_free(devpath); 340 free_attached_port(port_ptr); 341 return (HBA_STATUS_ERROR); 342 /* indentation move ends. */ 343 } 344 } else { 345 (void) memcpy(port_ptr->port_attributes. 346 PortSpecificAttribute. 347 SASPort->AttachedSASAddress.wwn, 348 &SASAddress.wwn[0], 8); 349 } 350 } 351 } else { 352 log(LOG_DEBUG, ROUTINE, 353 "No proper attached SAS address value on device %s", 354 fullpath); 355 di_devfs_path_free(devpath); 356 free_attached_port(port_ptr); 357 return (HBA_STATUS_ERROR); 358 } 359 } else { 360 log(LOG_DEBUG, ROUTINE, 361 "Property AttachedSASAddress not found for device \"%s\"", 362 fullpath); 363 di_devfs_path_free(devpath); 364 free_attached_port(port_ptr); 365 return (HBA_STATUS_ERROR); 366 } 367 368 /* 369 * walk the disco list to make sure that there isn't a matching 370 * port and node wwn or a matching device path 371 */ 372 portfound = 0; 373 for (disco_port_ptr = port_ptr->first_attached_port; 374 disco_port_ptr != NULL; 375 disco_port_ptr = disco_port_ptr->next) { 376 if ((disco_port_ptr->port_attributes.PortState != 377 HBA_PORTSTATE_ERROR) && (memcmp(disco_port_ptr-> 378 port_attributes.PortSpecificAttribute. 379 SASPort->LocalSASAddress.wwn, SASAddress.wwn, 8) == 0)) { 380 /* 381 * found matching disco_port 382 * look for matching device path 383 */ 384 portfound = 1; 385 for (mapping_ptr = disco_port_ptr->scsiInfo; 386 mapping_ptr != NULL; 387 mapping_ptr = mapping_ptr->next) { 388 if (strstr(mapping_ptr-> entry.ScsiId. 389 OSDeviceName, devpath) != 0) { 390 log(LOG_DEBUG, ROUTINE, 391 "Found an already discovered " 392 "device %s.", fullpath); 393 di_devfs_path_free(devpath); 394 return (HBA_STATUS_OK); 395 } 396 } 397 if (portfound == 1) { 398 break; 399 } 400 } 401 } 402 403 if (portfound == 0) { 404 /* 405 * there are no matching SAS address. 406 * this must be a new device 407 */ 408 if ((disco_port_ptr = (struct sun_sas_port *)calloc(1, 409 sizeof (struct sun_sas_port))) == NULL) { 410 OUT_OF_MEMORY(ROUTINE); 411 di_devfs_path_free(devpath); 412 free_attached_port(port_ptr); 413 return (HBA_STATUS_ERROR); 414 } 415 416 if ((disco_port_ptr->port_attributes.PortSpecificAttribute.\ 417 SASPort = (struct SMHBA_SAS_Port *)calloc(1, 418 sizeof (struct SMHBA_SAS_Port))) == NULL) { 419 OUT_OF_MEMORY("add_hba_port_info"); 420 di_devfs_path_free(devpath); 421 free_attached_port(port_ptr); 422 return (HBA_STATUS_ERROR); 423 } 424 425 (void) memcpy(disco_port_ptr->port_attributes. 426 PortSpecificAttribute.SASPort->LocalSASAddress.wwn, 427 SASAddress.wwn, 8); 428 (void) memcpy(disco_port_ptr->port_attributes. 429 PortSpecificAttribute.SASPort->AttachedSASAddress.wwn, 430 AttachedSASAddress.wwn, 8); 431 432 /* Default to unknown until we figure out otherwise */ 433 rval = di_prop_lookup_strings(DDI_DEV_T_ANY, node, 434 "variant", &propStringData); 435 if (rval < 0) { 436 /* check if it is SMP target */ 437 charptr = di_driver_name(node); 438 if (charptr != NULL && (strncmp(charptr, "smp", 439 strlen(charptr)) == 0)) { 440 disco_port_ptr->port_attributes.PortType = 441 HBA_PORTTYPE_SASEXPANDER; 442 disco_port_ptr->port_attributes. 443 PortSpecificAttribute. 444 SASPort->PortProtocol = 445 HBA_SASPORTPROTOCOL_SMP; 446 if (lookupSMPLink(devpath, (char *)link) == 447 HBA_STATUS_OK) { 448 /* indentation changed here. */ 449 (void) strlcpy(disco_port_ptr->port_attributes. 450 OSDeviceName, link, 451 sizeof (disco_port_ptr->port_attributes.OSDeviceName)); 452 /* indentation change ends here. */ 453 } else { 454 /* indentation changed here. */ 455 get_minor(devpath, minorname); 456 (void) snprintf(fullpath, sizeof (fullpath), "%s%s%s", 457 DEVICES_DIR, devpath, minorname); 458 (void) strlcpy(disco_port_ptr->port_attributes. 459 OSDeviceName, fullpath, 460 sizeof (disco_port_ptr->port_attributes.OSDeviceName)); 461 /* indentation change ends here. */ 462 } 463 } else { 464 disco_port_ptr->port_attributes.PortType = 465 HBA_PORTTYPE_SASDEVICE; 466 disco_port_ptr->port_attributes.\ 467 PortSpecificAttribute.\ 468 SASPort->PortProtocol = 469 HBA_SASPORTPROTOCOL_SSP; 470 } 471 } else { 472 if ((strcmp(propStringData, "sata") == 0) || 473 (strcmp(propStringData, "atapi") == 0)) { 474 disco_port_ptr->port_attributes.PortType = 475 HBA_PORTTYPE_SATADEVICE; 476 disco_port_ptr->port_attributes.\ 477 PortSpecificAttribute.SASPort->PortProtocol 478 = HBA_SASPORTPROTOCOL_SATA; 479 } else { 480 log(LOG_DEBUG, ROUTINE, 481 "Unexpected variant prop value %s found on", 482 " device %s", propStringData, fullpath); 483 /* 484 * Port type will be 0 485 * which is not valid type. 486 */ 487 } 488 } 489 490 /* SMP device was handled already */ 491 if (disco_port_ptr->port_attributes.OSDeviceName[0] == '\0') { 492 /* indentation change due to ctysle check on sizeof. */ 493 size = sizeof (disco_port_ptr->port_attributes.OSDeviceName); 494 (void) strlcpy(disco_port_ptr->port_attributes. 495 OSDeviceName, fullpath, size); 496 } 497 498 /* add new discovered port into the list */ 499 500 if (port_ptr->first_attached_port == NULL) { 501 port_ptr->first_attached_port = disco_port_ptr; 502 disco_port_ptr->index = 0; 503 port_ptr->port_attributes.PortSpecificAttribute.\ 504 SASPort->NumberofDiscoveredPorts = 1; 505 } else { 506 disco_port_ptr->next = port_ptr->first_attached_port; 507 port_ptr->first_attached_port = disco_port_ptr; 508 disco_port_ptr->index = port_ptr->port_attributes.\ 509 PortSpecificAttribute.\ 510 SASPort->NumberofDiscoveredPorts; 511 port_ptr->port_attributes.PortSpecificAttribute.\ 512 SASPort->NumberofDiscoveredPorts++; 513 } 514 disco_port_ptr->port_attributes.PortState = port_state; 515 } 516 517 if (disco_port_ptr->port_attributes.PortType == 518 HBA_PORTTYPE_SASEXPANDER) { 519 /* No mapping data for expander device. return ok here. */ 520 di_devfs_path_free(devpath); 521 return (HBA_STATUS_OK); 522 } 523 524 if ((mapping_ptr = (struct ScsiEntryList *)calloc 525 (1, sizeof (struct ScsiEntryList))) == NULL) { 526 OUT_OF_MEMORY(ROUTINE); 527 di_devfs_path_free(devpath); 528 free_attached_port(port_ptr); 529 return (HBA_STATUS_ERROR); 530 } 531 532 if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "lun", 533 &propIntData) != -1) { 534 mapping_ptr->entry.ScsiId.ScsiOSLun = *propIntData; 535 } else { 536 if ((charptr = strchr(unit_address, ',')) != NULL) { 537 charptr++; 538 mapping_ptr->entry.ScsiId.ScsiOSLun = 539 strtoull(charptr, NULL, 10); 540 } else { 541 log(LOG_DEBUG, ROUTINE, 542 "Failed to get LUN from the unit address of device " 543 " %s.", fullpath); 544 di_devfs_path_free(devpath); 545 free_attached_port(port_ptr); 546 return (HBA_STATUS_ERROR); 547 } 548 } 549 550 /* get TargetLun(SAM-LUN). */ 551 if (di_prop_lookup_int64(DDI_DEV_T_ANY, node, "lun64", 552 &propInt64Data) != -1) { 553 samLun = scsi_lun64_to_lun(*propInt64Data); 554 (void) memcpy(&mapping_ptr->entry.PortLun.TargetLun, 555 &samLun, 8); 556 } else { 557 log(LOG_DEBUG, "get_attached_devices_info", 558 "No lun64 prop found on device %s.", fullpath); 559 di_devfs_path_free(devpath); 560 free_attached_port(port_ptr); 561 return (HBA_STATUS_ERROR); 562 } 563 564 if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, 565 "target", &propIntData) != -1) { 566 mapping_ptr->entry.ScsiId.ScsiTargetNumber = *propIntData; 567 } else { 568 mapping_ptr->entry.ScsiId.ScsiTargetNumber = di_instance(node); 569 } 570 571 /* get ScsiBusNumber */ 572 mapping_ptr->entry.ScsiId.ScsiBusNumber = port_ptr->cntlNumber; 573 574 (void) memcpy(mapping_ptr->entry.PortLun.PortWWN.wwn, 575 SASAddress.wwn, 8); 576 577 /* Store the devices path for now. We'll convert to /dev later */ 578 get_minor(devpath, minorname); 579 (void) snprintf(mapping_ptr->entry.ScsiId.OSDeviceName, 580 sizeof (mapping_ptr->entry.ScsiId.OSDeviceName), 581 "%s%s%s", DEVICES_DIR, devpath, minorname); 582 583 /* reset errno to 0 */ 584 errno = 0; 585 if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, "devid", 586 &propStringData) != -1) { 587 if (devid_str_decode(propStringData, &devid, NULL) != -1) { 588 guidStr = devid_to_guid(devid); 589 if (guidStr != NULL) { 590 (void) strlcpy(mapping_ptr->entry.LUID.buffer, 591 guidStr, 592 sizeof (mapping_ptr->entry.LUID.buffer)); 593 devid_free_guid(guidStr); 594 } else { 595 /* 596 * Note: 597 * if logical unit associated page 83 id 598 * descriptor is not avaialble for the device 599 * devid_to_guid returns NULL with errno 0. 600 */ 601 log(LOG_DEBUG, ROUTINE, 602 "failed to get devid guid on (%s) : %s", 603 devpath, strerror(errno)); 604 } 605 606 devid_free(devid); 607 } else { 608 /* 609 * device may not support proper page 83 id descriptor. 610 * leave LUID attribute to NULL and continue. 611 */ 612 log(LOG_DEBUG, ROUTINE, 613 "failed to decode devid prop on (%s) : %s", 614 devpath, strerror(errno)); 615 } 616 } else { 617 /* leave LUID attribute to NULL and continue. */ 618 log(LOG_DEBUG, ROUTINE, 619 "failed to get devid prop on (%s) : %s", 620 devpath, strerror(errno)); 621 } 622 623 if (disco_port_ptr->scsiInfo == NULL) { 624 disco_port_ptr->scsiInfo = mapping_ptr; 625 } else { 626 mapping_ptr->next = disco_port_ptr->scsiInfo; 627 disco_port_ptr->scsiInfo = mapping_ptr; 628 } 629 630 di_devfs_path_free(devpath); 631 632 return (HBA_STATUS_OK); 633 } 634 635 /* 636 * Finds attached device(target) from pathinfo node. 637 */ 638 static HBA_STATUS 639 get_attached_paths_info(di_path_t path, struct sun_sas_port *port_ptr) 640 { 641 char ROUTINE[] = "get_attached_paths_info"; 642 char *propStringData = NULL; 643 int *propIntData = NULL; 644 int64_t *propInt64Data = NULL; 645 scsi_lun_t samLun; 646 ddi_devid_t devid; 647 char *guidStr; 648 char *unit_address; 649 char *charptr; 650 char *clientdevpath = NULL; 651 char *pathdevpath = NULL; 652 char fullpath[MAXPATHLEN+1]; 653 char minorname[MAXNAMELEN+1]; 654 struct ScsiEntryList *mapping_ptr; 655 HBA_WWN SASAddress, AttachedSASAddress; 656 struct sun_sas_port *disco_port_ptr; 657 di_path_state_t state = 0; 658 di_node_t clientnode; 659 int portfound, size; 660 int port_state = HBA_PORTSTATE_ONLINE; 661 uint64_t tmpAddr; 662 663 if (port_ptr == NULL) { 664 log(LOG_DEBUG, ROUTINE, "NULL port_ptr argument"); 665 return (HBA_STATUS_ERROR); 666 } 667 668 /* if not null, free before return. */ 669 pathdevpath = di_path_devfs_path(path); 670 671 state = di_path_state(path); 672 /* when node is not attached and online, set the state to offline. */ 673 if ((state == DI_PATH_STATE_OFFLINE) || 674 (state == DI_PATH_STATE_FAULT)) { 675 log(LOG_DEBUG, ROUTINE, 676 "path node (%s) is either OFFLINE or FAULT state", 677 pathdevpath ? pathdevpath : "(missing device path)"); 678 port_state = HBA_PORTSTATE_OFFLINE; 679 } 680 681 if (clientnode = di_path_client_node(path)) { 682 if (di_retired(clientnode)) { 683 log(LOG_DEBUG, ROUTINE, 684 "client node of path (%s) is retired. Skipping.", 685 pathdevpath ? pathdevpath : 686 "(missing device path)"); 687 if (pathdevpath) di_devfs_path_free(pathdevpath); 688 return (HBA_STATUS_OK); 689 } 690 if ((clientdevpath = di_devfs_path(clientnode)) == NULL) { 691 log(LOG_DEBUG, ROUTINE, 692 "Client device of path (%s) has no path. Skipping.", 693 pathdevpath ? pathdevpath : 694 "(missing device path)"); 695 if (pathdevpath) di_devfs_path_free(pathdevpath); 696 return (HBA_STATUS_ERROR); 697 } 698 } else { 699 log(LOG_DEBUG, ROUTINE, 700 "Failed to get client device from a path (%s).", 701 pathdevpath ? pathdevpath : 702 "(missing device path)"); 703 if (pathdevpath) di_devfs_path_free(pathdevpath); 704 return (HBA_STATUS_ERROR); 705 } 706 707 /* add the "/devices" in the begining and the :devctl at the end */ 708 (void) snprintf(fullpath, sizeof (fullpath), "%s%s", DEVICES_DIR, 709 clientdevpath); 710 711 (void) memset(&SASAddress, 0, sizeof (SASAddress)); 712 if ((unit_address = di_path_bus_addr(path)) != NULL) { 713 if ((charptr = strchr(unit_address, ',')) != NULL) { 714 *charptr = '\0'; 715 } 716 for (charptr = unit_address; *charptr != '\0'; charptr++) { 717 if (isxdigit(*charptr)) { 718 break; 719 } 720 } 721 if (charptr != '\0') { 722 tmpAddr = htonll(strtoll(charptr, NULL, 16)); 723 (void) memcpy(&SASAddress.wwn[0], &tmpAddr, 8); 724 } else { 725 log(LOG_DEBUG, ROUTINE, 726 "No proper target port info on unit address of " 727 "path (%s).", pathdevpath ? pathdevpath : 728 "(missing device path)"); 729 if (pathdevpath) di_devfs_path_free(pathdevpath); 730 di_devfs_path_free(clientdevpath); 731 return (HBA_STATUS_ERROR); 732 } 733 } else { 734 log(LOG_DEBUG, ROUTINE, "Fail to get unit address of path(%s).", 735 "path (%s).", pathdevpath ? pathdevpath : 736 "(missing device path)"); 737 if (pathdevpath) di_devfs_path_free(pathdevpath); 738 di_devfs_path_free(clientdevpath); 739 return (HBA_STATUS_ERROR); 740 } 741 742 (void) memset(&AttachedSASAddress, 0, sizeof (AttachedSASAddress)); 743 if (di_path_prop_lookup_strings(path, "attached-port", 744 &propStringData) != -1) { 745 for (charptr = propStringData; *charptr != '\0'; charptr++) { 746 if (isxdigit(*charptr)) { 747 break; 748 } 749 } 750 if (*charptr != '\0') { 751 tmpAddr = htonll(strtoll(charptr, NULL, 16)); 752 (void) memcpy(AttachedSASAddress.wwn, &tmpAddr, 8); 753 /* check the attached address of hba port. */ 754 if (memcmp(port_ptr->port_attributes. 755 PortSpecificAttribute.SASPort-> 756 LocalSASAddress.wwn, &tmpAddr, 8) == 0) { 757 if (wwnConversion(port_ptr->port_attributes. 758 PortSpecificAttribute.SASPort-> 759 AttachedSASAddress.wwn)) { 760 /* verify the attaached SAS Addr. */ 761 if (memcmp(port_ptr->port_attributes. 762 PortSpecificAttribute.SASPort-> 763 AttachedSASAddress.wwn, 764 SASAddress.wwn, 8) != 0) { 765 /* indentation move begin. */ 766 log(LOG_DEBUG, ROUTINE, 767 "iport attached-port(%016llx) do not" 768 " match with level 1 Local" 769 " SAS address(%016llx).", 770 wwnConversion(port_ptr->port_attributes. 771 PortSpecificAttribute. 772 SASPort->AttachedSASAddress.wwn), 773 wwnConversion(SASAddress.wwn)); 774 if (pathdevpath) 775 di_devfs_path_free(pathdevpath); 776 di_devfs_path_free(clientdevpath); 777 free_attached_port(port_ptr); 778 return (HBA_STATUS_ERROR); 779 /* indentation move ends. */ 780 } 781 } else { 782 /* store the Attaached SAS Addr. */ 783 (void) memcpy(port_ptr->port_attributes. 784 PortSpecificAttribute. 785 SASPort->AttachedSASAddress.wwn, 786 &SASAddress.wwn[0], 8); 787 } 788 } 789 } else { 790 log(LOG_DEBUG, ROUTINE, 791 "No proper attached SAS address value of path (%s)", 792 pathdevpath ? pathdevpath : 793 "(missing device path)"); 794 if (pathdevpath) di_devfs_path_free(pathdevpath); 795 di_devfs_path_free(clientdevpath); 796 free_attached_port(port_ptr); 797 return (HBA_STATUS_ERROR); 798 } 799 } else { 800 log(LOG_DEBUG, ROUTINE, 801 "Property attached-port not found for path (%s)", 802 pathdevpath ? pathdevpath : 803 "(missing device path)"); 804 if (pathdevpath) di_devfs_path_free(pathdevpath); 805 di_devfs_path_free(clientdevpath); 806 free_attached_port(port_ptr); 807 return (HBA_STATUS_ERROR); 808 } 809 810 /* 811 * walk the disco list to make sure that there isn't a matching 812 * port and node wwn or a matching device path 813 */ 814 portfound = 0; 815 for (disco_port_ptr = port_ptr->first_attached_port; 816 disco_port_ptr != NULL; 817 disco_port_ptr = disco_port_ptr->next) { 818 if ((disco_port_ptr->port_attributes.PortState != 819 HBA_PORTSTATE_ERROR) && 820 (memcmp(disco_port_ptr->port_attributes. 821 PortSpecificAttribute.SASPort->LocalSASAddress.wwn, 822 SASAddress.wwn, 8) == 0)) { 823 /* 824 * found matching disco_port 825 * look for matching device path 826 */ 827 portfound = 1; 828 for (mapping_ptr = disco_port_ptr->scsiInfo; 829 mapping_ptr != NULL; 830 mapping_ptr = mapping_ptr->next) { 831 if (strstr(mapping_ptr-> entry.ScsiId. 832 OSDeviceName, clientdevpath) != 0) { 833 log(LOG_DEBUG, ROUTINE, 834 "Found an already discovered " 835 "device %s.", clientdevpath); 836 if (pathdevpath) 837 di_devfs_path_free(pathdevpath); 838 di_devfs_path_free(clientdevpath); 839 return (HBA_STATUS_OK); 840 } 841 } 842 if (portfound == 1) { 843 break; 844 } 845 } 846 } 847 848 if (portfound == 0) { 849 /* 850 * there are no matching SAS address. 851 * this must be a new device 852 */ 853 if ((disco_port_ptr = (struct sun_sas_port *)calloc(1, 854 sizeof (struct sun_sas_port))) == NULL) { 855 OUT_OF_MEMORY(ROUTINE); 856 if (pathdevpath) di_devfs_path_free(pathdevpath); 857 di_devfs_path_free(clientdevpath); 858 free_attached_port(port_ptr); 859 return (HBA_STATUS_ERROR); 860 } 861 862 if ((disco_port_ptr->port_attributes.PortSpecificAttribute.\ 863 SASPort = (struct SMHBA_SAS_Port *)calloc(1, 864 sizeof (struct SMHBA_SAS_Port))) == NULL) { 865 OUT_OF_MEMORY("add_hba_port_info"); 866 if (pathdevpath) di_devfs_path_free(pathdevpath); 867 di_devfs_path_free(clientdevpath); 868 free_attached_port(port_ptr); 869 return (HBA_STATUS_ERROR); 870 } 871 872 (void) memcpy(disco_port_ptr->port_attributes. 873 PortSpecificAttribute. 874 SASPort->LocalSASAddress.wwn, SASAddress.wwn, 8); 875 (void) memcpy(disco_port_ptr->port_attributes. 876 PortSpecificAttribute. 877 SASPort->AttachedSASAddress.wwn, AttachedSASAddress.wwn, 8); 878 879 /* Default to unknown until we figure out otherwise */ 880 if (di_path_prop_lookup_strings(path, "variant", 881 &propStringData) != -1) { 882 if ((strcmp(propStringData, "sata") == 0) || 883 (strcmp(propStringData, "atapi") == 0)) { 884 disco_port_ptr->port_attributes.PortType = 885 HBA_PORTTYPE_SATADEVICE; 886 disco_port_ptr->port_attributes.\ 887 PortSpecificAttribute.SASPort->PortProtocol 888 = HBA_SASPORTPROTOCOL_SATA; 889 } else { 890 log(LOG_DEBUG, ROUTINE, 891 "Unexpected variant prop value %s found on", 892 " path (%s)", propStringData, 893 pathdevpath ? pathdevpath : 894 "(missing device path)"); 895 /* 896 * Port type will be 0 897 * which is not valid type. 898 */ 899 } 900 } else { 901 disco_port_ptr->port_attributes.PortType = 902 HBA_PORTTYPE_SASDEVICE; 903 disco_port_ptr->port_attributes.PortSpecificAttribute.\ 904 SASPort->PortProtocol = HBA_SASPORTPROTOCOL_SSP; 905 } 906 907 if (disco_port_ptr->port_attributes.OSDeviceName[0] == '\0') { 908 /* indentation change due to ctysle check on sizeof. */ 909 size = sizeof (disco_port_ptr->port_attributes.OSDeviceName); 910 if (pathdevpath != NULL) { 911 (void) strlcpy(disco_port_ptr->port_attributes. 912 OSDeviceName, pathdevpath, size); 913 } 914 } 915 916 /* add new discovered port into the list */ 917 if (port_ptr->first_attached_port == NULL) { 918 port_ptr->first_attached_port = disco_port_ptr; 919 disco_port_ptr->index = 0; 920 port_ptr->port_attributes.PortSpecificAttribute.\ 921 SASPort->NumberofDiscoveredPorts = 1; 922 } else { 923 disco_port_ptr->next = port_ptr->first_attached_port; 924 port_ptr->first_attached_port = disco_port_ptr; 925 disco_port_ptr->index = port_ptr->port_attributes.\ 926 PortSpecificAttribute.\ 927 SASPort->NumberofDiscoveredPorts; 928 port_ptr->port_attributes.PortSpecificAttribute.\ 929 SASPort->NumberofDiscoveredPorts++; 930 } 931 disco_port_ptr->port_attributes.PortState = port_state; 932 } 933 934 if ((mapping_ptr = (struct ScsiEntryList *)calloc 935 (1, sizeof (struct ScsiEntryList))) == NULL) { 936 OUT_OF_MEMORY(ROUTINE); 937 if (pathdevpath) di_devfs_path_free(pathdevpath); 938 di_devfs_path_free(clientdevpath); 939 free_attached_port(port_ptr); 940 return (HBA_STATUS_ERROR); 941 } 942 943 if (di_path_prop_lookup_ints(path, "lun", &propIntData) != -1) { 944 mapping_ptr->entry.ScsiId.ScsiOSLun = *propIntData; 945 } else { 946 if ((charptr = strchr(unit_address, ',')) != NULL) { 947 charptr++; 948 mapping_ptr->entry.ScsiId.ScsiOSLun = 949 strtoull(charptr, NULL, 10); 950 } else { 951 log(LOG_DEBUG, ROUTINE, 952 "Failed to get LUN from unit address of path(%s).", 953 pathdevpath ? pathdevpath : 954 "(missing device path)"); 955 if (pathdevpath) di_devfs_path_free(pathdevpath); 956 di_devfs_path_free(clientdevpath); 957 free_attached_port(port_ptr); 958 return (HBA_STATUS_ERROR); 959 } 960 } 961 962 /* Get TargetLun(SAM LUN). */ 963 if (di_path_prop_lookup_int64s(path, "lun64", &propInt64Data) != -1) { 964 samLun = scsi_lun64_to_lun(*propInt64Data); 965 (void) memcpy(&mapping_ptr->entry.PortLun.TargetLun, 966 &samLun, 8); 967 } else { 968 log(LOG_DEBUG, ROUTINE, "No lun64 prop found on path (%s)", 969 pathdevpath ? pathdevpath : 970 "(missing device path)"); 971 if (pathdevpath) di_devfs_path_free(pathdevpath); 972 di_devfs_path_free(clientdevpath); 973 free_attached_port(port_ptr); 974 return (HBA_STATUS_ERROR); 975 } 976 977 if (di_path_prop_lookup_ints(path, "target", &propIntData) != -1) { 978 mapping_ptr->entry.ScsiId.ScsiTargetNumber = *propIntData; 979 } else { 980 mapping_ptr->entry.ScsiId.ScsiTargetNumber = 981 di_path_instance(path); 982 } 983 984 /* get ScsiBusNumber */ 985 mapping_ptr->entry.ScsiId.ScsiBusNumber = port_ptr->cntlNumber; 986 987 (void) memcpy(mapping_ptr->entry.PortLun.PortWWN.wwn, 988 SASAddress.wwn, 8); 989 990 /* Store the devices path for now. We'll convert to /dev later */ 991 get_minor(clientdevpath, minorname); 992 (void) snprintf(mapping_ptr->entry.ScsiId.OSDeviceName, 993 sizeof (mapping_ptr->entry.ScsiId.OSDeviceName), 994 "%s%s%s", DEVICES_DIR, clientdevpath, minorname); 995 996 /* get luid. */ 997 errno = 0; /* reset errno to 0 */ 998 if (di_prop_lookup_strings(DDI_DEV_T_ANY, clientnode, "devid", 999 &propStringData) != -1) { 1000 if (devid_str_decode(propStringData, &devid, NULL) != -1) { 1001 guidStr = devid_to_guid(devid); 1002 if (guidStr != NULL) { 1003 (void) strlcpy(mapping_ptr->entry.LUID.buffer, 1004 guidStr, 1005 sizeof (mapping_ptr->entry.LUID.buffer)); 1006 devid_free_guid(guidStr); 1007 } else { 1008 /* 1009 * Note: 1010 * if logical unit associated page 83 id 1011 * descriptor is not avaialble for the device 1012 * devid_to_guid returns NULL with errno 0. 1013 */ 1014 log(LOG_DEBUG, ROUTINE, 1015 "failed to get devid guid on (%s)", 1016 " associated with path(%s) : %s", 1017 clientdevpath, 1018 pathdevpath ? pathdevpath : 1019 "(missing device path)", 1020 strerror(errno)); 1021 } 1022 1023 devid_free(devid); 1024 } else { 1025 /* 1026 * device may not support proper page 83 id descriptor. 1027 * leave LUID attribute to NULL and continue. 1028 */ 1029 log(LOG_DEBUG, ROUTINE, 1030 "failed to decode devid prop on (%s)", 1031 " associated with path(%s) : %s", 1032 clientdevpath, 1033 pathdevpath ? pathdevpath : 1034 "(missing device path)", 1035 strerror(errno)); 1036 } 1037 } else { 1038 /* leave LUID attribute to NULL and continue. */ 1039 log(LOG_DEBUG, ROUTINE, "Failed to get devid on %s" 1040 " associated with path(%s) : %s", clientdevpath, 1041 pathdevpath ? pathdevpath : "(missing device path)", 1042 strerror(errno)); 1043 } 1044 1045 if (disco_port_ptr->scsiInfo == NULL) { 1046 disco_port_ptr->scsiInfo = mapping_ptr; 1047 } else { 1048 mapping_ptr->next = disco_port_ptr->scsiInfo; 1049 disco_port_ptr->scsiInfo = mapping_ptr; 1050 } 1051 1052 if (pathdevpath) di_devfs_path_free(pathdevpath); 1053 di_devfs_path_free(clientdevpath); 1054 1055 return (HBA_STATUS_OK); 1056 } 1057 1058 /* 1059 * walks the devinfo tree retrieving all hba information 1060 */ 1061 extern HBA_STATUS 1062 devtree_attached_devices(di_node_t node, struct sun_sas_port *port_ptr) 1063 { 1064 const char ROUTINE[] = "devtree_attached_devices"; 1065 di_node_t nodechild = DI_NODE_NIL; 1066 di_path_t path = DI_PATH_NIL; 1067 1068 /* child should be device */ 1069 if ((nodechild = di_child_node(node)) == DI_NODE_NIL) { 1070 log(LOG_DEBUG, ROUTINE, 1071 "No devinfo child on the HBA port node."); 1072 } 1073 1074 if ((path = di_path_phci_next_path(node, path)) == 1075 DI_PATH_NIL) { 1076 log(LOG_DEBUG, ROUTINE, 1077 "No pathinfo node on the HBA port node."); 1078 } 1079 1080 if ((nodechild == DI_NODE_NIL) && (path == DI_PATH_NIL)) { 1081 return (HBA_STATUS_OK); 1082 } 1083 1084 while (nodechild != DI_NODE_NIL) { 1085 if (get_attached_devices_info(nodechild, port_ptr) 1086 != HBA_STATUS_OK) { 1087 break; 1088 } 1089 nodechild = di_sibling_node(nodechild); 1090 } 1091 1092 1093 while (path != DI_PATH_NIL) { 1094 if (get_attached_paths_info(path, port_ptr) 1095 != HBA_STATUS_OK) { 1096 break; 1097 } 1098 path = di_path_phci_next_path(node, path); 1099 } 1100 1101 return (HBA_STATUS_OK); 1102 } 1103