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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 #include <alloca.h> 27 #include <dirent.h> 28 #include <devid.h> 29 #include <fm/libdiskstatus.h> 30 #include <inttypes.h> 31 #include <pthread.h> 32 #include <strings.h> 33 #include <string.h> 34 #include <unistd.h> 35 #include <sys/dkio.h> 36 #include <sys/fm/protocol.h> 37 #include <sys/libdevid.h> 38 #include <sys/scsi/scsi_types.h> 39 #include <sys/byteorder.h> 40 #include <pthread.h> 41 #include <signal.h> 42 #include <fcntl.h> 43 #include <sys/ctfs.h> 44 #include <libcontract.h> 45 #include <poll.h> 46 #include <sys/contract/device.h> 47 #include <libsysevent.h> 48 #include <sys/sysevent/eventdefs.h> 49 #include <scsi/plugins/ses/vendor/sun.h> 50 51 #include "disk.h" 52 #include "ses.h" 53 54 #define SES_VERSION 1 55 56 #define SES_STARTING_SUBCHASSIS 256 /* valid subchassis IDs are uint8_t */ 57 #define NO_SUBCHASSIS ((uint64_t)-1) 58 59 static int ses_snap_freq = 250; /* in milliseconds */ 60 61 #define SES_STATUS_UNAVAIL(s) \ 62 ((s) == SES_ESC_UNSUPPORTED || (s) >= SES_ESC_NOT_INSTALLED) 63 64 #define HR_SECOND 1000000000 65 66 /* 67 * Because multiple SES targets can be part of a single chassis, we construct 68 * our own hierarchy that takes this into account. These SES targets may refer 69 * to the same devices (multiple paths) or to different devices (managing 70 * different portions of the space). We arrange things into a 71 * ses_enum_enclosure_t, which contains a set of ses targets, and a list of all 72 * nodes found so far. 73 */ 74 typedef struct ses_alt_node { 75 topo_list_t san_link; 76 ses_node_t *san_node; 77 } ses_alt_node_t; 78 79 typedef struct ses_enum_node { 80 topo_list_t sen_link; 81 ses_node_t *sen_node; 82 topo_list_t sen_alt_nodes; 83 uint64_t sen_type; 84 uint64_t sen_instance; 85 ses_enum_target_t *sen_target; 86 } ses_enum_node_t; 87 88 typedef struct ses_enum_chassis { 89 topo_list_t sec_link; 90 topo_list_t sec_subchassis; 91 topo_list_t sec_nodes; 92 topo_list_t sec_targets; 93 const char *sec_csn; 94 ses_node_t *sec_enclosure; 95 ses_enum_target_t *sec_target; 96 topo_instance_t sec_instance; 97 topo_instance_t sec_scinstance; 98 topo_instance_t sec_maxinstance; 99 boolean_t sec_hasdev; 100 boolean_t sec_internal; 101 } ses_enum_chassis_t; 102 103 typedef struct ses_enum_data { 104 topo_list_t sed_devs; 105 topo_list_t sed_chassis; 106 ses_enum_chassis_t *sed_current; 107 ses_enum_target_t *sed_target; 108 int sed_errno; 109 char *sed_name; 110 topo_mod_t *sed_mod; 111 topo_instance_t sed_instance; 112 } ses_enum_data_t; 113 114 typedef struct sas_connector_phy_data { 115 uint64_t scpd_index; 116 uint64_t scpd_pm; 117 } sas_connector_phy_data_t; 118 119 typedef struct sas_connector_type { 120 uint64_t sct_type; 121 char *sct_name; 122 } sas_connector_type_t; 123 124 static const sas_connector_type_t sas_connector_type_list[] = { 125 { 0x0, "Information unknown" }, 126 { 0x1, "External SAS 4x receptacle (see SAS-2 and SFF-8470)" }, 127 { 0x2, "Exteranl Mini SAS 4x receptacle (see SAS-2 and SFF-8088)" }, 128 { 0xF, "Vendor-specific external connector" }, 129 { 0x10, "Internal wide SAS 4i plug (see SAS-2 and SFF-8484)" }, 130 { 0x11, 131 "Internal wide Mini SAS 4i receptacle (see SAS-2 and SFF-8087)" }, 132 { 0x20, "Internal SAS Drive receptacle (see SAS-2 and SFF-8482)" }, 133 { 0x21, "Internal SATA host plug (see SAS-2 and SATA-2)" }, 134 { 0x22, "Internal SAS Drive plug (see SAS-2 and SFF-8482)" }, 135 { 0x23, "Internal SATA device plug (see SAS-2 and SATA-2)" }, 136 { 0x2F, "Internal SAS virtual connector" }, 137 { 0x3F, "Vendor-specific internal connector" }, 138 { 0x70, "Other Vendor-specific connector" }, 139 { 0x71, "Other Vendor-specific connector" }, 140 { 0x72, "Other Vendor-specific connector" }, 141 { 0x73, "Other Vendor-specific connector" }, 142 { 0x74, "Other Vendor-specific connector" }, 143 { 0x75, "Other Vendor-specific connector" }, 144 { 0x76, "Other Vendor-specific connector" }, 145 { 0x77, "Other Vendor-specific connector" }, 146 { 0x78, "Other Vendor-specific connector" }, 147 { 0x79, "Other Vendor-specific connector" }, 148 { 0x7A, "Other Vendor-specific connector" }, 149 { 0x7B, "Other Vendor-specific connector" }, 150 { 0x7C, "Other Vendor-specific connector" }, 151 { 0x7D, "Other Vendor-specific connector" }, 152 { 0x7E, "Other Vendor-specific connector" }, 153 { 0x7F, "Other Vendor-specific connector" }, 154 { 0x80, "Not Defined" } 155 }; 156 157 #define SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED 0x80 158 #define SAS_CONNECTOR_TYPE_NOT_DEFINED \ 159 "Connector type not definedi by SES-2 standard" 160 #define SAS_CONNECTOR_TYPE_RESERVED \ 161 "Connector type reserved by SES-2 standard" 162 163 typedef struct phys_enum_type { 164 uint64_t pet_type; 165 char *pet_nodename; 166 char *pet_defaultlabel; 167 boolean_t pet_dorange; 168 } phys_enum_type_t; 169 170 static const phys_enum_type_t phys_enum_type_list[] = { 171 { SES_ET_ARRAY_DEVICE, BAY, "BAY", B_TRUE }, 172 { SES_ET_COOLING, FAN, "FAN", B_TRUE }, 173 { SES_ET_DEVICE, BAY, "BAY", B_TRUE }, 174 { SES_ET_ESC_ELECTRONICS, CONTROLLER, "CONTROLLER", B_TRUE }, 175 { SES_ET_POWER_SUPPLY, PSU, "PSU", B_TRUE }, 176 { SES_ET_SUNW_FANBOARD, FANBOARD, "FANBOARD", B_TRUE }, 177 { SES_ET_SUNW_FANMODULE, FANMODULE, "FANMODULE", B_TRUE }, 178 { SES_ET_SUNW_POWERBOARD, POWERBOARD, "POWERBOARD", B_TRUE }, 179 { SES_ET_SUNW_POWERMODULE, POWERMODULE, "POWERMODULE", B_TRUE } 180 }; 181 182 #define N_PHYS_ENUM_TYPES (sizeof (phys_enum_type_list) / \ 183 sizeof (phys_enum_type_list[0])) 184 185 /* 186 * Structure for the hierarchical tree for element nodes. 187 */ 188 typedef struct ses_phys_tree { 189 ses_node_t *spt_snode; 190 ses_enum_node_t *spt_senumnode; 191 boolean_t spt_isfru; 192 uint64_t spt_eonlyindex; 193 uint64_t spt_cindex; 194 uint64_t spt_pindex; 195 uint64_t spt_maxinst; 196 struct ses_phys_tree *spt_parent; 197 struct ses_phys_tree *spt_child; 198 struct ses_phys_tree *spt_sibling; 199 tnode_t *spt_tnode; 200 } ses_phys_tree_t; 201 202 typedef enum { 203 SES_NEW_CHASSIS = 0x1, 204 SES_NEW_SUBCHASSIS = 0x2, 205 SES_DUP_CHASSIS = 0x4, 206 SES_DUP_SUBCHASSIS = 0x8 207 } ses_chassis_type_e; 208 209 210 static const topo_pgroup_info_t storage_pgroup = { 211 TOPO_PGROUP_STORAGE, 212 TOPO_STABILITY_PRIVATE, 213 TOPO_STABILITY_PRIVATE, 214 1 215 }; 216 217 static const topo_pgroup_info_t smp_pgroup = { 218 TOPO_PGROUP_SMP, 219 TOPO_STABILITY_PRIVATE, 220 TOPO_STABILITY_PRIVATE, 221 1 222 }; 223 224 static const topo_pgroup_info_t ses_pgroup = { 225 TOPO_PGROUP_SES, 226 TOPO_STABILITY_PRIVATE, 227 TOPO_STABILITY_PRIVATE, 228 1 229 }; 230 231 static int ses_present(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *, 232 nvlist_t **); 233 static int ses_contains(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *, 234 nvlist_t **); 235 236 static const topo_method_t ses_component_methods[] = { 237 { TOPO_METH_PRESENT, TOPO_METH_PRESENT_DESC, 238 TOPO_METH_PRESENT_VERSION0, TOPO_STABILITY_INTERNAL, ses_present }, 239 { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0, 240 TOPO_STABILITY_INTERNAL, ses_node_enum_facility }, 241 { TOPO_METH_SENSOR_FAILURE, TOPO_METH_SENSOR_FAILURE_DESC, 242 TOPO_METH_SENSOR_FAILURE_VERSION, TOPO_STABILITY_INTERNAL, 243 topo_method_sensor_failure }, 244 { NULL } 245 }; 246 247 static const topo_method_t ses_bay_methods[] = { 248 { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0, 249 TOPO_STABILITY_INTERNAL, ses_node_enum_facility }, 250 { NULL } 251 }; 252 253 static const topo_method_t ses_enclosure_methods[] = { 254 { TOPO_METH_CONTAINS, TOPO_METH_CONTAINS_DESC, 255 TOPO_METH_CONTAINS_VERSION, TOPO_STABILITY_INTERNAL, ses_contains }, 256 { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0, 257 TOPO_STABILITY_INTERNAL, ses_enc_enum_facility }, 258 { NULL } 259 }; 260 261 /* 262 * Functions for tracking ses devices which we were unable to open. We retry 263 * these at regular intervals using ses_recheck_dir() and if we find that we 264 * can now open any of them then we send a sysevent to indicate that a new topo 265 * snapshot should be taken. 266 */ 267 typedef struct ses_open_fail_list { 268 struct ses_open_fail_list *sof_next; 269 char *sof_path; 270 } ses_open_fail_list_t; 271 272 static ses_open_fail_list_t *ses_sofh; 273 static pthread_mutex_t ses_sofmt; 274 static void ses_ct_print(char *ptr); 275 276 static void 277 ses_recheck_dir() 278 { 279 ses_target_t *target; 280 sysevent_id_t eid; 281 char buf[80]; 282 ses_open_fail_list_t *sof; 283 284 /* 285 * check list of "unable to open" devices 286 */ 287 (void) pthread_mutex_lock(&ses_sofmt); 288 for (sof = ses_sofh; sof != NULL; sof = sof->sof_next) { 289 /* 290 * see if we can open it now 291 */ 292 if ((target = ses_open(LIBSES_VERSION, 293 sof->sof_path)) == NULL) { 294 (void) snprintf(buf, sizeof (buf), 295 "recheck_dir - still can't open %s", sof->sof_path); 296 ses_ct_print(buf); 297 continue; 298 } 299 300 /* 301 * ok - better force a new snapshot 302 */ 303 (void) snprintf(buf, sizeof (buf), 304 "recheck_dir - can now open %s", sof->sof_path); 305 ses_ct_print(buf); 306 (void) sysevent_post_event(EC_PLATFORM, ESC_PLATFORM_SP_RESET, 307 SUNW_VENDOR, "fmd", NULL, &eid); 308 ses_close(target); 309 break; 310 } 311 (void) pthread_mutex_unlock(&ses_sofmt); 312 } 313 314 static void 315 ses_sof_alloc(topo_mod_t *mod, char *path) 316 { 317 ses_open_fail_list_t *sof; 318 319 (void) pthread_mutex_lock(&ses_sofmt); 320 sof = topo_mod_zalloc(mod, sizeof (*sof)); 321 topo_mod_dprintf(mod, "sof_alloc %s", path); 322 sof->sof_path = path; 323 sof->sof_next = ses_sofh; 324 ses_sofh = sof; 325 (void) pthread_mutex_unlock(&ses_sofmt); 326 } 327 328 static void 329 ses_sof_freeall(topo_mod_t *mod) 330 { 331 ses_open_fail_list_t *sof, *next_sof; 332 333 (void) pthread_mutex_lock(&ses_sofmt); 334 for (sof = ses_sofh; sof != NULL; sof = next_sof) { 335 next_sof = sof->sof_next; 336 topo_mod_dprintf(mod, "sof_freeall %s", sof->sof_path); 337 topo_mod_strfree(mod, sof->sof_path); 338 topo_mod_free(mod, sof, sizeof (*sof)); 339 } 340 ses_sofh = NULL; 341 (void) pthread_mutex_unlock(&ses_sofmt); 342 } 343 344 /* 345 * functions for verifying that the ses_enum_target_t held in a device 346 * contract's cookie field is still valid (it may have been freed by 347 * ses_release()). 348 */ 349 typedef struct ses_stp_list { 350 struct ses_stp_list *ssl_next; 351 ses_enum_target_t *ssl_tgt; 352 } ses_stp_list_t; 353 354 static ses_stp_list_t *ses_sslh; 355 static pthread_mutex_t ses_sslmt; 356 357 static void 358 ses_ssl_alloc(topo_mod_t *mod, ses_enum_target_t *stp) 359 { 360 ses_stp_list_t *ssl; 361 362 (void) pthread_mutex_lock(&ses_sslmt); 363 ssl = topo_mod_zalloc(mod, sizeof (*ssl)); 364 topo_mod_dprintf(mod, "ssl_alloc %p", stp); 365 ssl->ssl_tgt = stp; 366 ssl->ssl_next = ses_sslh; 367 ses_sslh = ssl; 368 (void) pthread_mutex_unlock(&ses_sslmt); 369 } 370 371 static void 372 ses_ssl_free(topo_mod_t *mod, ses_enum_target_t *stp) 373 { 374 ses_stp_list_t *ssl, *prev_ssl; 375 376 (void) pthread_mutex_lock(&ses_sslmt); 377 prev_ssl = NULL; 378 for (ssl = ses_sslh; ssl != NULL; ssl = ssl->ssl_next) { 379 if (ssl->ssl_tgt == stp) { 380 topo_mod_dprintf(mod, "ssl_free %p", ssl->ssl_tgt); 381 if (prev_ssl == NULL) 382 ses_sslh = ssl->ssl_next; 383 else 384 prev_ssl->ssl_next = ssl->ssl_next; 385 topo_mod_free(mod, ssl, sizeof (*ssl)); 386 break; 387 } 388 prev_ssl = ssl; 389 } 390 (void) pthread_mutex_unlock(&ses_sslmt); 391 } 392 393 static int 394 ses_ssl_valid(ses_enum_target_t *stp) 395 { 396 ses_stp_list_t *ssl; 397 398 for (ssl = ses_sslh; ssl != NULL; ssl = ssl->ssl_next) 399 if (ssl->ssl_tgt == stp) 400 return (1); 401 return (0); 402 } 403 404 /* 405 * Functions for creating and destroying a background thread 406 * (ses_contract_thread) used for detecting when ses devices have been 407 * retired/unretired. 408 */ 409 static struct ses_thread_s { 410 pthread_mutex_t mt; 411 pthread_t tid; 412 int thr_sig; 413 int doexit; 414 int count; 415 } sesthread = { 416 PTHREAD_MUTEX_INITIALIZER, 417 0, 418 SIGTERM, 419 0, 420 0 421 }; 422 423 typedef struct ses_mod_list { 424 struct ses_mod_list *smod_next; 425 topo_mod_t *smod_mod; 426 } ses_mod_list_t; 427 428 static ses_mod_list_t *ses_smod; 429 430 static void 431 ses_ct_print(char *ptr) 432 { 433 (void) pthread_mutex_lock(&sesthread.mt); 434 if (ses_smod->smod_mod) 435 topo_mod_dprintf(ses_smod->smod_mod, ptr); 436 (void) pthread_mutex_unlock(&sesthread.mt); 437 } 438 439 /*ARGSUSED*/ 440 static void * 441 ses_contract_thread(void *arg) 442 { 443 int efd, ctlfd, statfd; 444 ct_evthdl_t ev; 445 ctevid_t evid; 446 uint_t event; 447 char path[PATH_MAX]; 448 char buf[80]; 449 ses_enum_target_t *stp; 450 ct_stathdl_t stathdl; 451 ctid_t ctid; 452 struct pollfd fds; 453 int pollret; 454 455 ses_ct_print("start contract event thread"); 456 efd = open64(CTFS_ROOT "/device/pbundle", O_RDONLY); 457 fds.fd = efd; 458 fds.events = POLLIN; 459 fds.revents = 0; 460 for (;;) { 461 /* check if we've been asked to exit */ 462 (void) pthread_mutex_lock(&sesthread.mt); 463 if (sesthread.doexit) { 464 (void) pthread_mutex_unlock(&sesthread.mt); 465 break; 466 } 467 (void) pthread_mutex_unlock(&sesthread.mt); 468 469 /* poll until an event arrives */ 470 if ((pollret = poll(&fds, 1, 10000)) <= 0) { 471 if (pollret == 0) 472 ses_recheck_dir(); 473 continue; 474 } 475 476 /* read the event */ 477 (void) pthread_mutex_lock(&ses_sslmt); 478 ses_ct_print("read contract event"); 479 if (ct_event_read(efd, &ev) != 0) { 480 (void) pthread_mutex_unlock(&ses_sslmt); 481 continue; 482 } 483 484 /* see if it is an event we are expecting */ 485 ctid = ct_event_get_ctid(ev); 486 (void) snprintf(buf, sizeof (buf), 487 "got contract event ctid=%d", ctid); 488 ses_ct_print(buf); 489 event = ct_event_get_type(ev); 490 if (event != CT_DEV_EV_OFFLINE && event != CT_EV_NEGEND) { 491 snprintf(buf, sizeof (buf), 492 "bad contract event %x", event); 493 ses_ct_print(buf); 494 ct_event_free(ev); 495 (void) pthread_mutex_unlock(&ses_sslmt); 496 continue; 497 } 498 499 /* find target pointer saved in cookie */ 500 evid = ct_event_get_evid(ev); 501 (void) snprintf(path, PATH_MAX, CTFS_ROOT "/device/%ld/status", 502 ctid); 503 statfd = open64(path, O_RDONLY); 504 ct_status_read(statfd, CTD_COMMON, &stathdl); 505 stp = (ses_enum_target_t *)(uintptr_t) 506 ct_status_get_cookie(stathdl); 507 ct_status_free(stathdl); 508 close(statfd); 509 510 /* check if target pointer is still valid */ 511 if (ses_ssl_valid(stp) == 0) { 512 snprintf(buf, sizeof (buf), 513 "contract already abandoned %x", event); 514 ses_ct_print(buf); 515 (void) snprintf(path, PATH_MAX, 516 CTFS_ROOT "/device/%ld/ctl", ctid); 517 ctlfd = open64(path, O_WRONLY); 518 if (event != CT_EV_NEGEND) 519 ct_ctl_ack(ctlfd, evid); 520 else 521 ct_ctl_abandon(ctlfd); 522 close(ctlfd); 523 ct_event_free(ev); 524 (void) pthread_mutex_unlock(&ses_sslmt); 525 continue; 526 } 527 528 /* find control device for ack/abandon */ 529 (void) pthread_mutex_lock(&stp->set_lock); 530 (void) snprintf(path, PATH_MAX, CTFS_ROOT "/device/%ld/ctl", 531 ctid); 532 ctlfd = open64(path, O_WRONLY); 533 if (event != CT_EV_NEGEND) { 534 /* if this is an offline event, do the offline */ 535 ses_ct_print("got contract offline event"); 536 if (stp->set_target) { 537 ses_ct_print("contract thread rele"); 538 ses_snap_rele(stp->set_snap); 539 ses_close(stp->set_target); 540 stp->set_target = NULL; 541 } 542 ct_ctl_ack(ctlfd, evid); 543 } else { 544 /* if this is the negend, then abandon the contract */ 545 ses_ct_print("got contract negend"); 546 if (stp->set_ctid) { 547 snprintf(buf, sizeof (buf), 548 "abandon old contract %d", stp->set_ctid); 549 ses_ct_print(buf); 550 stp->set_ctid = NULL; 551 } 552 ct_ctl_abandon(ctlfd); 553 } 554 close(ctlfd); 555 (void) pthread_mutex_unlock(&stp->set_lock); 556 ct_event_free(ev); 557 (void) pthread_mutex_unlock(&ses_sslmt); 558 } 559 close(efd); 560 return (NULL); 561 } 562 563 int 564 find_thr_sig(void) 565 { 566 int i; 567 sigset_t oset, rset; 568 int sig[] = {SIGTERM, SIGUSR1, SIGUSR2}; 569 int sig_sz = sizeof (sig) / sizeof (int); 570 int rc = SIGTERM; 571 572 /* prefered set of signals that are likely used to terminate threads */ 573 (void) sigemptyset(&oset); 574 (void) pthread_sigmask(SIG_SETMASK, NULL, &oset); 575 for (i = 0; i < sig_sz; i++) { 576 if (sigismember(&oset, sig[i]) == 0) { 577 return (sig[i]); 578 } 579 } 580 581 /* reserved set of signals that are not allowed to terminate thread */ 582 (void) sigemptyset(&rset); 583 (void) sigaddset(&rset, SIGABRT); 584 (void) sigaddset(&rset, SIGKILL); 585 (void) sigaddset(&rset, SIGSTOP); 586 (void) sigaddset(&rset, SIGCANCEL); 587 588 /* Find signal that is not masked and not in the reserved list. */ 589 for (i = 1; i < MAXSIG; i++) { 590 if (sigismember(&rset, i) == 1) { 591 continue; 592 } 593 if (sigismember(&oset, i) == 0) { 594 return (i); 595 } 596 } 597 598 return (rc); 599 } 600 601 /*ARGSUSED*/ 602 static void 603 ses_handler(int sig) 604 { 605 } 606 607 static void 608 ses_thread_init(topo_mod_t *mod) 609 { 610 pthread_attr_t *attr = NULL; 611 struct sigaction act; 612 ses_mod_list_t *smod; 613 614 (void) pthread_mutex_lock(&sesthread.mt); 615 sesthread.count++; 616 smod = topo_mod_zalloc(mod, sizeof (*smod)); 617 smod->smod_mod = mod; 618 smod->smod_next = ses_smod; 619 ses_smod = smod; 620 if (sesthread.tid == 0) { 621 /* find a suitable signal to use for killing the thread below */ 622 sesthread.thr_sig = find_thr_sig(); 623 624 /* if don't have a handler for this signal, create one */ 625 (void) sigaction(sesthread.thr_sig, NULL, &act); 626 if (act.sa_handler == SIG_DFL || act.sa_handler == SIG_IGN) 627 act.sa_handler = ses_handler; 628 (void) sigaction(sesthread.thr_sig, &act, NULL); 629 630 /* create a thread to listen for offline events */ 631 (void) pthread_create(&sesthread.tid, 632 attr, ses_contract_thread, NULL); 633 } 634 (void) pthread_mutex_unlock(&sesthread.mt); 635 } 636 637 static void 638 ses_thread_fini(topo_mod_t *mod) 639 { 640 ses_mod_list_t *smod, *prev_smod; 641 642 (void) pthread_mutex_lock(&sesthread.mt); 643 prev_smod = NULL; 644 for (smod = ses_smod; smod != NULL; smod = smod->smod_next) { 645 if (smod->smod_mod == mod) { 646 if (prev_smod == NULL) 647 ses_smod = smod->smod_next; 648 else 649 prev_smod->smod_next = smod->smod_next; 650 topo_mod_free(mod, smod, sizeof (*smod)); 651 break; 652 } 653 prev_smod = smod; 654 } 655 if (--sesthread.count > 0) { 656 (void) pthread_mutex_unlock(&sesthread.mt); 657 return; 658 } 659 sesthread.doexit = 1; 660 (void) pthread_mutex_unlock(&sesthread.mt); 661 (void) pthread_kill(sesthread.tid, sesthread.thr_sig); 662 (void) pthread_join(sesthread.tid, NULL); 663 sesthread.tid = 0; 664 } 665 666 static void 667 ses_create_contract(topo_mod_t *mod, ses_enum_target_t *stp) 668 { 669 int tfd, len, rval; 670 char link_path[PATH_MAX]; 671 672 stp->set_ctid = NULL; 673 674 /* convert "/dev" path into "/devices" path */ 675 if ((len = readlink(stp->set_devpath, link_path, PATH_MAX)) < 0) { 676 topo_mod_dprintf(mod, "readlink failed"); 677 return; 678 } 679 link_path[len] = '\0'; 680 681 /* set up template to create new contract */ 682 tfd = open64(CTFS_ROOT "/device/template", O_RDWR); 683 ct_tmpl_set_critical(tfd, CT_DEV_EV_OFFLINE); 684 ct_tmpl_set_cookie(tfd, (uint64_t)(uintptr_t)stp); 685 686 /* strip "../../devices" off the front and create the contract */ 687 if ((rval = ct_dev_tmpl_set_minor(tfd, &link_path[13])) != 0) 688 topo_mod_dprintf(mod, "failed to set minor %s rval = %d", 689 &link_path[13], rval); 690 else if ((rval = ct_tmpl_create(tfd, &stp->set_ctid)) != 0) 691 topo_mod_dprintf(mod, "failed to create ctid rval = %d", rval); 692 else 693 topo_mod_dprintf(mod, "created ctid=%d", stp->set_ctid); 694 close(tfd); 695 } 696 697 static void 698 ses_target_free(topo_mod_t *mod, ses_enum_target_t *stp) 699 { 700 if (--stp->set_refcount == 0) { 701 /* check if already closed due to contract offline request */ 702 (void) pthread_mutex_lock(&stp->set_lock); 703 if (stp->set_target) { 704 ses_snap_rele(stp->set_snap); 705 ses_close(stp->set_target); 706 stp->set_target = NULL; 707 } 708 if (stp->set_ctid) { 709 int ctlfd; 710 char path[PATH_MAX]; 711 712 topo_mod_dprintf(mod, "abandon old contract %d", 713 stp->set_ctid); 714 (void) snprintf(path, PATH_MAX, 715 CTFS_ROOT "/device/%ld/ctl", stp->set_ctid); 716 ctlfd = open64(path, O_WRONLY); 717 ct_ctl_abandon(ctlfd); 718 close(ctlfd); 719 stp->set_ctid = NULL; 720 } 721 (void) pthread_mutex_unlock(&stp->set_lock); 722 ses_ssl_free(mod, stp); 723 topo_mod_strfree(mod, stp->set_devpath); 724 topo_mod_free(mod, stp, sizeof (ses_enum_target_t)); 725 } 726 } 727 728 static void 729 ses_data_free(ses_enum_data_t *sdp, ses_enum_chassis_t *pcp) 730 { 731 topo_mod_t *mod = sdp->sed_mod; 732 ses_enum_chassis_t *cp; 733 ses_enum_node_t *np; 734 ses_enum_target_t *tp; 735 ses_alt_node_t *ap; 736 topo_list_t *cpl; 737 738 739 if (pcp != NULL) 740 cpl = &pcp->sec_subchassis; 741 else 742 cpl = &sdp->sed_chassis; 743 744 while ((cp = topo_list_next(cpl)) != NULL) { 745 topo_list_delete(cpl, cp); 746 747 while ((np = topo_list_next(&cp->sec_nodes)) != NULL) { 748 while ((ap = topo_list_next(&np->sen_alt_nodes)) != 749 NULL) { 750 topo_list_delete(&np->sen_alt_nodes, ap); 751 topo_mod_free(mod, ap, sizeof (ses_alt_node_t)); 752 } 753 topo_list_delete(&cp->sec_nodes, np); 754 topo_mod_free(mod, np, sizeof (ses_enum_node_t)); 755 } 756 757 while ((tp = topo_list_next(&cp->sec_targets)) != NULL) { 758 topo_list_delete(&cp->sec_targets, tp); 759 ses_target_free(mod, tp); 760 } 761 762 topo_mod_free(mod, cp, sizeof (ses_enum_chassis_t)); 763 } 764 765 if (pcp == NULL) { 766 dev_list_free(mod, &sdp->sed_devs); 767 topo_mod_free(mod, sdp, sizeof (ses_enum_data_t)); 768 } 769 } 770 771 /* 772 * For enclosure nodes, we have a special contains method. By default, the hc 773 * walker will compare the node name and instance number to determine if an 774 * FMRI matches. For enclosures where the enumeration order is impossible to 775 * predict, we instead use the chassis-id as a unique identifier, and ignore 776 * the instance number. 777 */ 778 static int 779 fmri_contains(topo_mod_t *mod, nvlist_t *nv1, nvlist_t *nv2) 780 { 781 uint8_t v1, v2; 782 nvlist_t **hcp1, **hcp2; 783 int err, i; 784 uint_t nhcp1, nhcp2; 785 nvlist_t *a1, *a2; 786 char *c1, *c2; 787 int mindepth; 788 789 if (nvlist_lookup_uint8(nv1, FM_VERSION, &v1) != 0 || 790 nvlist_lookup_uint8(nv2, FM_VERSION, &v2) != 0 || 791 v1 > FM_HC_SCHEME_VERSION || v2 > FM_HC_SCHEME_VERSION) 792 return (topo_mod_seterrno(mod, EMOD_FMRI_VERSION)); 793 794 err = nvlist_lookup_nvlist_array(nv1, FM_FMRI_HC_LIST, &hcp1, &nhcp1); 795 err |= nvlist_lookup_nvlist_array(nv2, FM_FMRI_HC_LIST, &hcp2, &nhcp2); 796 if (err != 0) 797 return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 798 799 /* 800 * If the chassis-id doesn't match, then these FMRIs are not 801 * equivalent. If one of the FMRIs doesn't have a chassis ID, then we 802 * have no choice but to fall back to the instance ID. 803 */ 804 if (nvlist_lookup_nvlist(nv1, FM_FMRI_AUTHORITY, &a1) == 0 && 805 nvlist_lookup_nvlist(nv2, FM_FMRI_AUTHORITY, &a2) == 0 && 806 nvlist_lookup_string(a1, FM_FMRI_AUTH_CHASSIS, &c1) == 0 && 807 nvlist_lookup_string(a2, FM_FMRI_AUTH_CHASSIS, &c2) == 0) { 808 if (strcmp(c1, c2) != 0) 809 return (0); 810 811 mindepth = 1; 812 } else { 813 mindepth = 0; 814 } 815 816 if (nhcp2 < nhcp1) 817 return (0); 818 819 for (i = 0; i < nhcp1; i++) { 820 char *nm1 = NULL; 821 char *nm2 = NULL; 822 char *id1 = NULL; 823 char *id2 = NULL; 824 825 (void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_NAME, &nm1); 826 (void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_NAME, &nm2); 827 (void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_ID, &id1); 828 (void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_ID, &id2); 829 if (nm1 == NULL || nm2 == NULL || id1 == NULL || id2 == NULL) 830 return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 831 832 if (strcmp(nm1, nm2) == 0 && 833 (i < mindepth || strcmp(id1, id2) == 0)) 834 continue; 835 836 return (0); 837 } 838 839 return (1); 840 } 841 842 /*ARGSUSED*/ 843 static int 844 ses_contains(topo_mod_t *mod, tnode_t *tn, topo_version_t version, 845 nvlist_t *in, nvlist_t **out) 846 { 847 int ret; 848 nvlist_t *nv1, *nv2; 849 850 if (version > TOPO_METH_CONTAINS_VERSION) 851 return (topo_mod_seterrno(mod, EMOD_VER_NEW)); 852 853 if (nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_FMRI, &nv1) != 0 || 854 nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_SUBFMRI, &nv2) != 0) 855 return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL)); 856 857 ret = fmri_contains(mod, nv1, nv2); 858 if (ret < 0) 859 return (-1); 860 861 if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) == 0) { 862 if (nvlist_add_uint32(*out, TOPO_METH_CONTAINS_RET, 863 ret) == 0) 864 return (0); 865 else 866 nvlist_free(*out); 867 } 868 869 return (-1); 870 871 } 872 873 /* 874 * Return a current instance of the node. This is somewhat complicated because 875 * we need to take a new snapshot in order to get the new data, but we don't 876 * want to be constantly taking SES snapshots if the consumer is going to do a 877 * series of queries. So we adopt the strategy of assuming that the SES state 878 * is not going to be rapidly changing, and limit our snapshot frequency to 879 * some defined bounds. 880 */ 881 ses_node_t * 882 ses_node_lock(topo_mod_t *mod, tnode_t *tn) 883 { 884 ses_enum_target_t *tp = topo_node_getspecific(tn); 885 hrtime_t now; 886 ses_snap_t *snap; 887 int err; 888 uint64_t nodeid; 889 ses_node_t *np; 890 891 if (tp == NULL) { 892 (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 893 return (NULL); 894 } 895 896 (void) pthread_mutex_lock(&tp->set_lock); 897 898 /* 899 * Determine if we need to take a new snapshot. 900 */ 901 now = gethrtime(); 902 903 if (tp->set_target == NULL) { 904 /* 905 * We may have closed the device but not yet abandoned the 906 * contract (ie we've had the offline event but not yet the 907 * negend). If so, just return failure. 908 */ 909 if (tp->set_ctid != NULL) { 910 (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 911 (void) pthread_mutex_unlock(&tp->set_lock); 912 return (NULL); 913 } 914 915 /* 916 * The device has been closed due to a contract offline 917 * request, then we need to reopen it and create a new contract. 918 */ 919 if ((tp->set_target = 920 ses_open(LIBSES_VERSION, tp->set_devpath)) == NULL) { 921 sysevent_id_t eid; 922 923 (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 924 (void) pthread_mutex_unlock(&tp->set_lock); 925 topo_mod_dprintf(mod, "recheck_dir - " 926 "can no longer open %s", tp->set_devpath); 927 (void) sysevent_post_event(EC_PLATFORM, 928 ESC_PLATFORM_SP_RESET, SUNW_VENDOR, "fmd", NULL, 929 &eid); 930 return (NULL); 931 } 932 topo_mod_dprintf(mod, "reopen contract"); 933 ses_create_contract(mod, tp); 934 tp->set_snap = ses_snap_hold(tp->set_target); 935 tp->set_snaptime = gethrtime(); 936 } else if (now - tp->set_snaptime > (ses_snap_freq * 1000 * 1000) && 937 (snap = ses_snap_new(tp->set_target)) != NULL) { 938 if (ses_snap_generation(snap) != 939 ses_snap_generation(tp->set_snap)) { 940 /* 941 * If we find ourselves in this situation, we're in 942 * trouble. The generation count has changed, which 943 * indicates that our current topology is out of date. 944 * But we need to consult the new topology in order to 945 * determine presence at this moment in time. We can't 946 * go back and change the topo snapshot in situ, so 947 * we'll just have to fail the call in this unlikely 948 * scenario. 949 */ 950 ses_snap_rele(snap); 951 (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 952 (void) pthread_mutex_unlock(&tp->set_lock); 953 return (NULL); 954 } else { 955 ses_snap_rele(tp->set_snap); 956 tp->set_snap = snap; 957 } 958 tp->set_snaptime = gethrtime(); 959 } 960 961 snap = tp->set_snap; 962 963 verify(topo_prop_get_uint64(tn, TOPO_PGROUP_SES, 964 TOPO_PROP_NODE_ID, &nodeid, &err) == 0); 965 verify((np = ses_node_lookup(snap, nodeid)) != NULL); 966 967 return (np); 968 } 969 970 /*ARGSUSED*/ 971 void 972 ses_node_unlock(topo_mod_t *mod, tnode_t *tn) 973 { 974 ses_enum_target_t *tp = topo_node_getspecific(tn); 975 976 verify(tp != NULL); 977 978 (void) pthread_mutex_unlock(&tp->set_lock); 979 } 980 981 /* 982 * Determine if the element is present. 983 */ 984 /*ARGSUSED*/ 985 static int 986 ses_present(topo_mod_t *mod, tnode_t *tn, topo_version_t version, 987 nvlist_t *in, nvlist_t **out) 988 { 989 boolean_t present; 990 ses_node_t *np; 991 nvlist_t *props, *nvl; 992 uint64_t status; 993 994 if ((np = ses_node_lock(mod, tn)) == NULL) 995 return (-1); 996 997 verify((props = ses_node_props(np)) != NULL); 998 verify(nvlist_lookup_uint64(props, 999 SES_PROP_STATUS_CODE, &status) == 0); 1000 1001 ses_node_unlock(mod, tn); 1002 1003 present = (status != SES_ESC_NOT_INSTALLED); 1004 1005 if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0) 1006 return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 1007 1008 if (nvlist_add_uint32(nvl, TOPO_METH_PRESENT_RET, 1009 present) != 0) { 1010 nvlist_free(nvl); 1011 return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 1012 } 1013 1014 *out = nvl; 1015 1016 return (0); 1017 } 1018 1019 /* 1020 * Sets standard properties for a ses node (enclosure, bay, controller 1021 * or expander). 1022 * This includes setting the FRU, as well as setting the 1023 * authority information. When the fru topo node(frutn) is not NULL 1024 * its resouce should be used as FRU. 1025 */ 1026 static int 1027 ses_set_standard_props(topo_mod_t *mod, tnode_t *frutn, tnode_t *tn, 1028 nvlist_t *auth, uint64_t nodeid, const char *path) 1029 { 1030 int err; 1031 char *product, *chassis; 1032 nvlist_t *fmri; 1033 1034 /* 1035 * Set the authority explicitly if specified. 1036 */ 1037 if (auth) { 1038 verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT, 1039 &product) == 0); 1040 verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_CHASSIS, 1041 &chassis) == 0); 1042 if (topo_prop_set_string(tn, FM_FMRI_AUTHORITY, 1043 FM_FMRI_AUTH_PRODUCT, TOPO_PROP_IMMUTABLE, product, 1044 &err) != 0 || 1045 topo_prop_set_string(tn, FM_FMRI_AUTHORITY, 1046 FM_FMRI_AUTH_CHASSIS, TOPO_PROP_IMMUTABLE, chassis, 1047 &err) != 0 || 1048 topo_prop_set_string(tn, FM_FMRI_AUTHORITY, 1049 FM_FMRI_AUTH_SERVER, TOPO_PROP_IMMUTABLE, "", 1050 &err) != 0) { 1051 topo_mod_dprintf(mod, "failed to add authority " 1052 "properties: %s\n", topo_strerror(err)); 1053 return (topo_mod_seterrno(mod, err)); 1054 } 1055 } 1056 1057 /* 1058 * Copy the resource and set that as the FRU. 1059 */ 1060 if (frutn != NULL) { 1061 if (topo_node_resource(frutn, &fmri, &err) != 0) { 1062 topo_mod_dprintf(mod, 1063 "topo_node_resource() failed : %s\n", 1064 topo_strerror(err)); 1065 return (topo_mod_seterrno(mod, err)); 1066 } 1067 } else { 1068 if (topo_node_resource(tn, &fmri, &err) != 0) { 1069 topo_mod_dprintf(mod, 1070 "topo_node_resource() failed : %s\n", 1071 topo_strerror(err)); 1072 return (topo_mod_seterrno(mod, err)); 1073 } 1074 } 1075 1076 if (topo_node_fru_set(tn, fmri, 0, &err) != 0) { 1077 topo_mod_dprintf(mod, 1078 "topo_node_fru_set() failed : %s\n", 1079 topo_strerror(err)); 1080 nvlist_free(fmri); 1081 return (topo_mod_seterrno(mod, err)); 1082 } 1083 1084 nvlist_free(fmri); 1085 1086 /* 1087 * Set the SES-specific properties so that consumers can query 1088 * additional information about the particular SES element. 1089 */ 1090 if (topo_pgroup_create(tn, &ses_pgroup, &err) != 0) { 1091 topo_mod_dprintf(mod, "failed to create propgroup " 1092 "%s: %s\n", TOPO_PGROUP_SES, topo_strerror(err)); 1093 return (-1); 1094 } 1095 1096 if (topo_prop_set_uint64(tn, TOPO_PGROUP_SES, 1097 TOPO_PROP_NODE_ID, TOPO_PROP_IMMUTABLE, 1098 nodeid, &err) != 0) { 1099 topo_mod_dprintf(mod, 1100 "failed to create property %s: %s\n", 1101 TOPO_PROP_NODE_ID, topo_strerror(err)); 1102 return (-1); 1103 } 1104 1105 if (topo_prop_set_string(tn, TOPO_PGROUP_SES, 1106 TOPO_PROP_TARGET_PATH, TOPO_PROP_IMMUTABLE, 1107 path, &err) != 0) { 1108 topo_mod_dprintf(mod, 1109 "failed to create property %s: %s\n", 1110 TOPO_PROP_TARGET_PATH, topo_strerror(err)); 1111 return (-1); 1112 } 1113 1114 return (0); 1115 } 1116 1117 /* 1118 * Callback to add a disk to a given bay. We first check the status-code to 1119 * determine if a disk is present, ignoring those that aren't in an appropriate 1120 * state. We then scan the parent bay node's SAS address array to determine 1121 * possible attached SAS addresses. We create a disk node if the disk is not 1122 * SAS or the SES target does not support the necessary pages for this; if we 1123 * find the SAS address, we create a disk node and also correlate it with 1124 * the corresponding Solaris device node to fill in the rest of the data. 1125 */ 1126 static int 1127 ses_create_disk(ses_enum_data_t *sdp, tnode_t *pnode, nvlist_t *props) 1128 { 1129 topo_mod_t *mod = sdp->sed_mod; 1130 uint64_t status; 1131 uint_t s, nsas; 1132 char **paths; 1133 int err, ret; 1134 tnode_t *child = NULL; 1135 1136 /* 1137 * Skip devices that are not in a present (and possibly damaged) state. 1138 */ 1139 if (nvlist_lookup_uint64(props, SES_PROP_STATUS_CODE, &status) != 0) 1140 return (0); 1141 1142 if (status != SES_ESC_UNSUPPORTED && 1143 status != SES_ESC_OK && 1144 status != SES_ESC_CRITICAL && 1145 status != SES_ESC_NONCRITICAL && 1146 status != SES_ESC_UNRECOVERABLE && 1147 status != SES_ESC_NO_ACCESS) 1148 return (0); 1149 1150 topo_mod_dprintf(mod, "found attached disk"); 1151 1152 /* 1153 * Create the disk range. 1154 */ 1155 if (topo_node_range_create(mod, pnode, DISK, 0, 0) != 0) { 1156 topo_mod_dprintf(mod, 1157 "topo_node_create_range() failed: %s", 1158 topo_mod_errmsg(mod)); 1159 return (-1); 1160 } 1161 1162 /* 1163 * Look through all SAS addresses and attempt to correlate them to a 1164 * known Solaris device. If we don't find a matching node, then we 1165 * don't enumerate the disk node. 1166 * Note that TOPO_PROP_SAS_ADDR prop includes SAS address from 1167 * alternate elements that represent the same device. 1168 */ 1169 if (topo_prop_get_string_array(pnode, TOPO_PGROUP_SES, 1170 TOPO_PROP_SAS_ADDR, &paths, &nsas, &err) != 0) 1171 return (0); 1172 1173 err = 0; 1174 1175 for (s = 0; s < nsas; s++) { 1176 ret = disk_declare_addr(mod, pnode, &sdp->sed_devs, paths[s], 1177 &child); 1178 if (ret == 0) { 1179 break; 1180 } else if (ret < 0) { 1181 err = -1; 1182 break; 1183 } 1184 } 1185 1186 if (s == nsas) 1187 disk_declare_non_enumerated(mod, pnode, &child); 1188 1189 /* copy sas_addresses (target-ports) from parent (with 'w'added) */ 1190 if (child != NULL) { 1191 int i; 1192 char **tports; 1193 uint64_t wwn; 1194 1195 tports = topo_mod_zalloc(mod, sizeof (char *) * nsas); 1196 if (tports != NULL) { 1197 for (i = 0; i < nsas; i++) { 1198 if (scsi_wwnstr_to_wwn(paths[i], &wwn) != 1199 DDI_SUCCESS) 1200 break; 1201 tports[i] = scsi_wwn_to_wwnstr(wwn, 1, NULL); 1202 if (tports[i] == NULL) 1203 break; 1204 } 1205 /* if they all worked then create the property */ 1206 if (i == nsas) 1207 (void) topo_prop_set_string_array(child, 1208 TOPO_PGROUP_STORAGE, 1209 TOPO_STORAGE_TARGET_PORT_L0IDS, 1210 TOPO_PROP_IMMUTABLE, (const char **)tports, 1211 nsas, &err); 1212 1213 for (i = 0; i < nsas; i++) 1214 if (tports[i] != NULL) 1215 scsi_free_wwnstr(tports[i]); 1216 topo_mod_free(mod, tports, sizeof (char *) * nsas); 1217 } 1218 } 1219 1220 for (s = 0; s < nsas; s++) 1221 topo_mod_free(mod, paths[s], strlen(paths[s]) + 1); 1222 topo_mod_free(mod, paths, nsas * sizeof (char *)); 1223 1224 return (err); 1225 } 1226 1227 static int 1228 ses_add_bay_props(topo_mod_t *mod, tnode_t *tn, ses_enum_node_t *snp) 1229 { 1230 ses_alt_node_t *ap; 1231 ses_node_t *np; 1232 nvlist_t *props; 1233 1234 nvlist_t **phys; 1235 uint_t i, j, n_phys, all_phys = 0; 1236 char **paths; 1237 uint64_t addr; 1238 size_t len; 1239 int terr, err = -1; 1240 1241 for (ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL; 1242 ap = topo_list_next(ap)) { 1243 np = ap->san_node; 1244 props = ses_node_props(np); 1245 1246 if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 1247 &phys, &n_phys) != 0) 1248 continue; 1249 1250 all_phys += n_phys; 1251 } 1252 1253 if (all_phys == 0) 1254 return (0); 1255 1256 if ((paths = topo_mod_zalloc(mod, all_phys * sizeof (char *))) == NULL) 1257 return (-1); 1258 1259 for (i = 0, ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL; 1260 ap = topo_list_next(ap)) { 1261 np = ap->san_node; 1262 props = ses_node_props(np); 1263 1264 if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 1265 &phys, &n_phys) != 0) 1266 continue; 1267 1268 for (j = 0; j < n_phys; j++) { 1269 if (nvlist_lookup_uint64(phys[j], SES_SAS_PROP_ADDR, 1270 &addr) != 0) 1271 continue; 1272 1273 len = snprintf(NULL, 0, "%016llx", addr) + 1; 1274 if ((paths[i] = topo_mod_alloc(mod, len)) == NULL) 1275 goto error; 1276 1277 (void) snprintf(paths[i], len, "%016llx", addr); 1278 1279 ++i; 1280 } 1281 } 1282 1283 err = topo_prop_set_string_array(tn, TOPO_PGROUP_SES, 1284 TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE, 1285 (const char **)paths, i, &terr); 1286 if (err != 0) 1287 err = topo_mod_seterrno(mod, terr); 1288 1289 error: 1290 for (i = 0; i < all_phys && paths[i] != NULL; i++) 1291 topo_mod_free(mod, paths[i], strlen(paths[i]) + 1); 1292 topo_mod_free(mod, paths, all_phys * sizeof (char *)); 1293 1294 return (err); 1295 } 1296 1297 /* 1298 * Callback to create a basic node (bay, psu, fan, or controller and expander). 1299 */ 1300 static int 1301 ses_create_generic(ses_enum_data_t *sdp, ses_enum_node_t *snp, tnode_t *pnode, 1302 tnode_t *frutn, const char *nodename, const char *labelname, 1303 tnode_t **node) 1304 { 1305 ses_node_t *np = snp->sen_node; 1306 ses_node_t *parent; 1307 uint64_t instance = snp->sen_instance; 1308 topo_mod_t *mod = sdp->sed_mod; 1309 nvlist_t *props, *aprops; 1310 nvlist_t *auth = NULL, *fmri = NULL; 1311 tnode_t *tn = NULL; 1312 char label[128]; 1313 int err; 1314 char *part = NULL, *serial = NULL, *revision = NULL; 1315 char *desc; 1316 boolean_t report; 1317 1318 props = ses_node_props(np); 1319 1320 (void) nvlist_lookup_string(props, LIBSES_PROP_PART, &part); 1321 (void) nvlist_lookup_string(props, LIBSES_PROP_SERIAL, &serial); 1322 1323 topo_mod_dprintf(mod, "adding %s %llu", nodename, instance); 1324 1325 /* 1326 * Create the node. The interesting information is all copied from the 1327 * parent enclosure node, so there is not much to do. 1328 */ 1329 if ((auth = topo_mod_auth(mod, pnode)) == NULL) 1330 goto error; 1331 1332 /* 1333 * We want to report revision information for the controller nodes, but 1334 * we do not get per-element revision information. However, we do have 1335 * revision information for the entire enclosure, and we can use the 1336 * 'reported-via' property to know that this controller corresponds to 1337 * the given revision information. This means we cannot get revision 1338 * information for targets we are not explicitly connected to, but 1339 * there is little we can do about the situation. 1340 */ 1341 if (strcmp(nodename, CONTROLLER) == 0 && 1342 nvlist_lookup_boolean_value(props, SES_PROP_REPORT, &report) == 0 && 1343 report) { 1344 for (parent = ses_node_parent(np); parent != NULL; 1345 parent = ses_node_parent(parent)) { 1346 if (ses_node_type(parent) == SES_NODE_ENCLOSURE) { 1347 (void) nvlist_lookup_string( 1348 ses_node_props(parent), 1349 SES_EN_PROP_REV, &revision); 1350 break; 1351 } 1352 } 1353 } 1354 1355 if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION, 1356 nodename, (topo_instance_t)instance, NULL, auth, part, revision, 1357 serial)) == NULL) { 1358 topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s", 1359 topo_mod_errmsg(mod)); 1360 goto error; 1361 } 1362 1363 if ((tn = topo_node_bind(mod, pnode, nodename, 1364 instance, fmri)) == NULL) { 1365 topo_mod_dprintf(mod, "topo_node_bind() failed: %s", 1366 topo_mod_errmsg(mod)); 1367 goto error; 1368 } 1369 1370 /* 1371 * For the node label, we look for the following in order: 1372 * 1373 * <ses-description> 1374 * <ses-class-description> <instance> 1375 * <default-type-label> <instance> 1376 */ 1377 if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 || 1378 desc[0] == '\0') { 1379 parent = ses_node_parent(np); 1380 aprops = ses_node_props(parent); 1381 if (nvlist_lookup_string(aprops, SES_PROP_CLASS_DESCRIPTION, 1382 &desc) != 0 || desc[0] == '\0') 1383 desc = (char *)labelname; 1384 (void) snprintf(label, sizeof (label), "%s %llu", desc, 1385 instance); 1386 desc = label; 1387 } 1388 1389 if (topo_node_label_set(tn, desc, &err) != 0) 1390 goto error; 1391 1392 if (ses_set_standard_props(mod, frutn, tn, NULL, ses_node_id(np), 1393 snp->sen_target->set_devpath) != 0) 1394 goto error; 1395 1396 if (strcmp(nodename, BAY) == 0) { 1397 if (ses_add_bay_props(mod, tn, snp) != 0) 1398 goto error; 1399 1400 if (ses_create_disk(sdp, tn, props) != 0) 1401 goto error; 1402 1403 if (topo_method_register(mod, tn, ses_bay_methods) != 0) { 1404 topo_mod_dprintf(mod, 1405 "topo_method_register() failed: %s", 1406 topo_mod_errmsg(mod)); 1407 goto error; 1408 } 1409 } else if ((strcmp(nodename, FAN) == 0) || 1410 (strcmp(nodename, PSU) == 0) || 1411 (strcmp(nodename, CONTROLLER) == 0)) { 1412 /* 1413 * Only fan, psu, and controller nodes have a 'present' method. 1414 * Bay nodes are always present, and disk nodes are present by 1415 * virtue of being enumerated and SAS expander nodes and 1416 * SAS connector nodes are also always present once 1417 * the parent controller is found. 1418 */ 1419 if (topo_method_register(mod, tn, ses_component_methods) != 0) { 1420 topo_mod_dprintf(mod, 1421 "topo_method_register() failed: %s", 1422 topo_mod_errmsg(mod)); 1423 goto error; 1424 } 1425 1426 } 1427 1428 snp->sen_target->set_refcount++; 1429 topo_node_setspecific(tn, snp->sen_target); 1430 1431 nvlist_free(auth); 1432 nvlist_free(fmri); 1433 if (node != NULL) *node = tn; 1434 return (0); 1435 1436 error: 1437 nvlist_free(auth); 1438 nvlist_free(fmri); 1439 return (-1); 1440 } 1441 1442 /* 1443 * Create SAS expander specific props. 1444 */ 1445 /*ARGSUSED*/ 1446 static int 1447 ses_set_expander_props(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1448 tnode_t *ptnode, tnode_t *tnode, int *phycount, int64_t *connlist) 1449 { 1450 ses_node_t *np = snp->sen_node; 1451 topo_mod_t *mod = sdp->sed_mod; 1452 nvlist_t *auth = NULL, *fmri = NULL; 1453 nvlist_t *props, **phylist; 1454 int err, i; 1455 uint_t pcount; 1456 uint64_t sasaddr, connidx; 1457 char sasaddr_str[17]; 1458 boolean_t found = B_FALSE, ses_found = B_FALSE; 1459 dev_di_node_t *dnode, *sesdnode; 1460 1461 props = ses_node_props(np); 1462 1463 /* 1464 * the uninstalled expander is not enumerated by checking 1465 * the element status code. No present present' method provided. 1466 */ 1467 /* 1468 * Get the Expander SAS address. It should exist. 1469 */ 1470 if (nvlist_lookup_uint64(props, SES_EXP_PROP_SAS_ADDR, 1471 &sasaddr) != 0) { 1472 topo_mod_dprintf(mod, 1473 "Failed to get prop %s.", SES_EXP_PROP_SAS_ADDR); 1474 goto error; 1475 } 1476 1477 (void) sprintf(sasaddr_str, "%llx", sasaddr); 1478 1479 /* search matching dev_di_node. */ 1480 for (dnode = topo_list_next(&sdp->sed_devs); dnode != NULL; 1481 dnode = topo_list_next(dnode)) { 1482 for (i = 0; i < dnode->ddn_ppath_count; i++) { 1483 if ((dnode->ddn_target_port[i] != NULL) && 1484 (strstr(dnode->ddn_target_port[i], 1485 sasaddr_str) != NULL)) { 1486 found = B_TRUE; 1487 break; 1488 } 1489 } 1490 if (found) 1491 break; 1492 } 1493 1494 if (!found) { 1495 topo_mod_dprintf(mod, 1496 "ses_set_expander_props: Failed to find matching " 1497 "devinfo node for Exapnder SAS address %s", 1498 SES_EXP_PROP_SAS_ADDR); 1499 /* continue on to get storage group props. */ 1500 } else { 1501 /* create/set the devfs-path and devid in the smp group */ 1502 if (topo_pgroup_create(tnode, &smp_pgroup, &err) != 0) { 1503 topo_mod_dprintf(mod, "ses_set_expander_props: " 1504 "failed to create smp property group %s\n", 1505 topo_strerror(err)); 1506 goto error; 1507 } else { 1508 if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP, 1509 TOPO_PROP_SMP_TARGET_PORT, TOPO_PROP_IMMUTABLE, 1510 dnode->ddn_target_port[i], &err) != 0) { 1511 topo_mod_dprintf(mod, "ses_set_expander_props: " 1512 "set %S error %s\n", TOPO_PROP_SAS_ADDR, 1513 topo_strerror(err)); 1514 } 1515 if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP, 1516 TOPO_PROP_SMP_DEV_PATH, TOPO_PROP_IMMUTABLE, 1517 dnode->ddn_dpath, &err) != 0) { 1518 topo_mod_dprintf(mod, "ses_set_expander_props: " 1519 "set dev error %s\n", topo_strerror(err)); 1520 } 1521 if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP, 1522 TOPO_PROP_SMP_DEVID, TOPO_PROP_IMMUTABLE, 1523 dnode->ddn_devid, &err) != 0) { 1524 topo_mod_dprintf(mod, "ses_set_expander_props: " 1525 "set devid error %s\n", topo_strerror(err)); 1526 } 1527 if (dnode->ddn_ppath_count != 0 && 1528 topo_prop_set_string_array(tnode, TOPO_PGROUP_SMP, 1529 TOPO_PROP_SMP_PHYS_PATH, TOPO_PROP_IMMUTABLE, 1530 (const char **)dnode->ddn_ppath, 1531 dnode->ddn_ppath_count, &err) != 0) { 1532 topo_mod_dprintf(mod, "ses_set_expander_props: " 1533 "set phys-path error %s\n", 1534 topo_strerror(err)); 1535 } 1536 } 1537 } 1538 1539 /* update the ses property group with SES target info */ 1540 if ((topo_pgroup_create(tnode, &ses_pgroup, &err) != 0) && 1541 (err != ETOPO_PROP_DEFD)) { 1542 /* SES prop group doesn't exist but failed to be created. */ 1543 topo_mod_dprintf(mod, "ses_set_expander_props: " 1544 "ses pgroup create error %s\n", topo_strerror(err)); 1545 goto error; 1546 } else { 1547 /* locate assciated enclosure dev_di_node. */ 1548 for (sesdnode = topo_list_next(&sdp->sed_devs); 1549 sesdnode != NULL; sesdnode = topo_list_next(sesdnode)) { 1550 for (i = 0; i < sesdnode->ddn_ppath_count; i++) { 1551 /* 1552 * check if attached port exists and 1553 * its node type is enclosure and 1554 * attached port is same as sas address of 1555 * the expander and 1556 * bridge port for virtual phy indication 1557 * exist. 1558 */ 1559 if ((sesdnode->ddn_attached_port[i] != NULL) && 1560 (sesdnode->ddn_dtype == DTYPE_ESI) && 1561 (strstr(sesdnode->ddn_attached_port[i], 1562 sasaddr_str) != NULL) && 1563 (sesdnode->ddn_bridge_port[i] != NULL)) { 1564 ses_found = B_TRUE; 1565 break; 1566 } 1567 } 1568 if (ses_found) break; 1569 } 1570 1571 if (ses_found) { 1572 if (topo_prop_set_string(tnode, TOPO_PGROUP_SES, 1573 TOPO_PROP_SES_TARGET_PORT, TOPO_PROP_IMMUTABLE, 1574 sesdnode->ddn_target_port[i], &err) != 0) { 1575 topo_mod_dprintf(mod, "ses_set_expander_props: " 1576 "set ses %S error %s\n", TOPO_PROP_SAS_ADDR, 1577 topo_strerror(err)); 1578 } 1579 if (topo_prop_set_string(tnode, TOPO_PGROUP_SES, 1580 TOPO_PROP_SES_DEV_PATH, TOPO_PROP_IMMUTABLE, 1581 sesdnode->ddn_dpath, &err) != 0) { 1582 topo_mod_dprintf(mod, "ses_set_expander_props: " 1583 "set ses dev error %s\n", 1584 topo_strerror(err)); 1585 } 1586 if (topo_prop_set_string(tnode, TOPO_PGROUP_SES, 1587 TOPO_PROP_SES_DEVID, TOPO_PROP_IMMUTABLE, 1588 sesdnode->ddn_devid, &err) != 0) { 1589 topo_mod_dprintf(mod, "ses_set_expander_props: " 1590 "set ses devid error %s\n", 1591 topo_strerror(err)); 1592 } 1593 if (sesdnode->ddn_ppath_count != 0 && 1594 topo_prop_set_string_array(tnode, TOPO_PGROUP_SES, 1595 TOPO_PROP_SES_PHYS_PATH, TOPO_PROP_IMMUTABLE, 1596 (const char **)sesdnode->ddn_ppath, 1597 sesdnode->ddn_ppath_count, &err) != 0) { 1598 topo_mod_dprintf(mod, "ses_set_expander_props: " 1599 "set ses phys-path error %s\n", 1600 topo_strerror(err)); 1601 } 1602 1603 } 1604 } 1605 1606 /* create the storage group */ 1607 if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) { 1608 topo_mod_dprintf(mod, "ses_set_expander_props: " 1609 "create storage error %s\n", topo_strerror(err)); 1610 goto error; 1611 } else { 1612 /* set the SAS address prop out of expander element status. */ 1613 if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE, 1614 TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE, sasaddr_str, 1615 &err) != 0) { 1616 topo_mod_dprintf(mod, "ses_set_expander_props: " 1617 "set %S error %s\n", TOPO_PROP_SAS_ADDR, 1618 topo_strerror(err)); 1619 } 1620 1621 /* Get the phy information for the expander */ 1622 if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 1623 &phylist, &pcount) != 0) { 1624 topo_mod_dprintf(mod, 1625 "Failed to get prop %s.", SES_SAS_PROP_PHYS); 1626 } else { 1627 /* 1628 * For each phy, get the connector element index and 1629 * stores into connector element index array. 1630 */ 1631 *phycount = pcount; 1632 for (i = 0; i < pcount; i++) { 1633 if (nvlist_lookup_uint64(phylist[i], 1634 SES_PROP_CE_IDX, &connidx) == 0) { 1635 if (connidx != 0xff) { 1636 connlist[i] = connidx; 1637 } else { 1638 connlist[i] = -1; 1639 } 1640 } else { 1641 /* Fail to get the index. set to -1. */ 1642 connlist[i] = -1; 1643 } 1644 } 1645 1646 /* set the phy count prop of the expander. */ 1647 if (topo_prop_set_uint64(tnode, TOPO_PGROUP_STORAGE, 1648 TOPO_PROP_PHY_COUNT, TOPO_PROP_IMMUTABLE, pcount, 1649 &err) != 0) { 1650 topo_mod_dprintf(mod, "ses_set_expander_props: " 1651 "set %S error %s\n", TOPO_PROP_PHY_COUNT, 1652 topo_strerror(err)); 1653 } 1654 1655 /* 1656 * set the connector element index of 1657 * the expander phys. 1658 */ 1659 } 1660 1661 /* populate other misc storage group properties */ 1662 if (found) { 1663 if (dnode->ddn_mfg && (topo_prop_set_string(tnode, 1664 TOPO_PGROUP_STORAGE, TOPO_STORAGE_MANUFACTURER, 1665 TOPO_PROP_IMMUTABLE, dnode->ddn_mfg, &err) != 0)) { 1666 topo_mod_dprintf(mod, "ses_set_expander_props: " 1667 "set mfg error %s\n", topo_strerror(err)); 1668 } 1669 1670 if (dnode->ddn_model && (topo_prop_set_string(tnode, 1671 TOPO_PGROUP_STORAGE, TOPO_STORAGE_MODEL, 1672 TOPO_PROP_IMMUTABLE, 1673 dnode->ddn_model, &err) != 0)) { 1674 topo_mod_dprintf(mod, "ses_set_expander_props: " 1675 "set model error %s\n", topo_strerror(err)); 1676 } 1677 1678 if (dnode->ddn_serial && (topo_prop_set_string(tnode, 1679 TOPO_PGROUP_STORAGE, TOPO_STORAGE_SERIAL_NUM, 1680 TOPO_PROP_IMMUTABLE, 1681 dnode->ddn_serial, &err) != 0)) { 1682 topo_mod_dprintf(mod, "ses_set_expander_props: " 1683 "set serial error %s\n", 1684 topo_strerror(err)); 1685 } 1686 1687 if (dnode->ddn_firm && (topo_prop_set_string(tnode, 1688 TOPO_PGROUP_STORAGE, 1689 TOPO_STORAGE_FIRMWARE_REV, TOPO_PROP_IMMUTABLE, 1690 dnode->ddn_firm, &err) != 0)) { 1691 topo_mod_dprintf(mod, "ses_set_expander_props: " 1692 "set firm error %s\n", topo_strerror(err)); 1693 } 1694 } 1695 } 1696 1697 return (0); 1698 1699 error: 1700 nvlist_free(auth); 1701 nvlist_free(fmri); 1702 return (-1); 1703 } 1704 1705 /* 1706 * Create SAS expander specific props. 1707 */ 1708 /*ARGSUSED*/ 1709 static int 1710 ses_set_connector_props(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1711 tnode_t *tnode, int64_t phy_mask) 1712 { 1713 ses_node_t *np = snp->sen_node; 1714 topo_mod_t *mod = sdp->sed_mod; 1715 nvlist_t *props; 1716 int err, i; 1717 uint64_t conntype; 1718 char phymask_str[17], *conntype_str; 1719 boolean_t found; 1720 1721 props = ses_node_props(np); 1722 1723 /* 1724 * convert phy mask to string. 1725 */ 1726 (void) snprintf(phymask_str, 17, "%llx", phy_mask); 1727 1728 /* create the storage group */ 1729 if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) { 1730 topo_mod_dprintf(mod, "ses_set_expander_props: " 1731 "create storage error %s\n", topo_strerror(err)); 1732 return (-1); 1733 } else { 1734 /* set the SAS address prop of the expander. */ 1735 if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE, 1736 TOPO_STORAGE_SAS_PHY_MASK, TOPO_PROP_IMMUTABLE, 1737 phymask_str, &err) != 0) { 1738 topo_mod_dprintf(mod, "ses_set_expander_props: " 1739 "set %S error %s\n", TOPO_STORAGE_SAS_PHY_MASK, 1740 topo_strerror(err)); 1741 } 1742 1743 /* Get the connector type information for the expander */ 1744 if (nvlist_lookup_uint64(props, 1745 SES_SC_PROP_CONNECTOR_TYPE, &conntype) != 0) { 1746 topo_mod_dprintf(mod, "Failed to get prop %s.", 1747 TOPO_STORAGE_SAS_PHY_MASK); 1748 } else { 1749 found = B_FALSE; 1750 for (i = 0; ; i++) { 1751 if (sas_connector_type_list[i].sct_type == 1752 SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) { 1753 break; 1754 } 1755 if (sas_connector_type_list[i].sct_type == 1756 conntype) { 1757 conntype_str = 1758 sas_connector_type_list[i].sct_name; 1759 found = B_TRUE; 1760 break; 1761 } 1762 } 1763 1764 if (!found) { 1765 if (conntype < 1766 SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) { 1767 conntype_str = 1768 SAS_CONNECTOR_TYPE_RESERVED; 1769 } else { 1770 conntype_str = 1771 SAS_CONNECTOR_TYPE_NOT_DEFINED; 1772 } 1773 } 1774 1775 /* set the phy count prop of the expander. */ 1776 if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE, 1777 TOPO_STORAGE_SAS_CONNECTOR_TYPE, 1778 TOPO_PROP_IMMUTABLE, conntype_str, &err) != 0) { 1779 topo_mod_dprintf(mod, "ses_set_expander_props: " 1780 "set %S error %s\n", TOPO_PROP_PHY_COUNT, 1781 topo_strerror(err)); 1782 } 1783 } 1784 } 1785 1786 return (0); 1787 } 1788 1789 /* 1790 * Instantiate SAS expander nodes for a given ESC Electronics node(controller) 1791 * nodes. 1792 */ 1793 /*ARGSUSED*/ 1794 static int 1795 ses_create_esc_sasspecific(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1796 tnode_t *pnode, ses_enum_chassis_t *cp, 1797 boolean_t dorange) 1798 { 1799 topo_mod_t *mod = sdp->sed_mod; 1800 tnode_t *exptn, *contn; 1801 boolean_t found; 1802 sas_connector_phy_data_t connectors[64] = {NULL}; 1803 uint64_t max; 1804 ses_enum_node_t *ctlsnp, *xsnp, *consnp; 1805 ses_node_t *np = snp->sen_node; 1806 nvlist_t *props, *psprops; 1807 uint64_t index, psindex, conindex, psstatus, i, j, count; 1808 int64_t cidxlist[256] = {NULL}; 1809 int phycount; 1810 1811 props = ses_node_props(np); 1812 1813 if (nvlist_lookup_uint64(props, SES_PROP_ELEMENT_ONLY_INDEX, 1814 &index) != 0) 1815 return (-1); 1816 1817 /* 1818 * For SES constroller node, check to see if there are 1819 * associated SAS expanders. 1820 */ 1821 found = B_FALSE; 1822 max = 0; 1823 for (ctlsnp = topo_list_next(&cp->sec_nodes); ctlsnp != NULL; 1824 ctlsnp = topo_list_next(ctlsnp)) { 1825 if (ctlsnp->sen_type == SES_ET_SAS_EXPANDER) { 1826 found = B_TRUE; 1827 if (ctlsnp->sen_instance > max) 1828 max = ctlsnp->sen_instance; 1829 } 1830 } 1831 1832 /* 1833 * No SAS expander found notthing to process. 1834 */ 1835 if (!found) 1836 return (0); 1837 1838 topo_mod_dprintf(mod, "%s Controller %d: creating " 1839 "%llu %s nodes", cp->sec_csn, index, max + 1, SASEXPANDER); 1840 1841 /* 1842 * The max number represent the number of elements 1843 * deducted from the highest SES_PROP_ELEMENT_CLASS_INDEX 1844 * of SET_ET_SAS_EXPANDER type element. 1845 * 1846 * There may be multiple ESC Electronics element(controllers) 1847 * within JBOD(typicall two for redundancy) and SAS expander 1848 * elements are associated with only one of them. We are 1849 * still creating the range based max number here. 1850 * That will cover the case that all expanders are associated 1851 * with one SES controller. 1852 */ 1853 if (dorange && topo_node_range_create(mod, pnode, 1854 SASEXPANDER, 0, max) != 0) { 1855 topo_mod_dprintf(mod, 1856 "topo_node_create_range() failed: %s", 1857 topo_mod_errmsg(mod)); 1858 return (-1); 1859 } 1860 1861 /* 1862 * Search exapnders with the parent index matching with 1863 * ESC Electronics element index. 1864 * Note the index used here is a global index across 1865 * SES elements. 1866 */ 1867 for (xsnp = topo_list_next(&cp->sec_nodes); xsnp != NULL; 1868 xsnp = topo_list_next(xsnp)) { 1869 if (xsnp->sen_type == SES_ET_SAS_EXPANDER) { 1870 /* 1871 * get the parent ESC controller. 1872 */ 1873 psprops = ses_node_props(xsnp->sen_node); 1874 if (nvlist_lookup_uint64(psprops, 1875 SES_PROP_STATUS_CODE, &psstatus) == 0) { 1876 if (psstatus == SES_ESC_NOT_INSTALLED) { 1877 /* 1878 * Not installed. 1879 * Don't create a ndoe. 1880 */ 1881 continue; 1882 } 1883 } else { 1884 /* 1885 * The element should have status code. 1886 * If not there is no way to find 1887 * out if the expander element exist or 1888 * not. 1889 */ 1890 continue; 1891 } 1892 1893 /* Get the physical parent index to compare. */ 1894 if (nvlist_lookup_uint64(psprops, 1895 LIBSES_PROP_PHYS_PARENT, &psindex) == 0) { 1896 if (index == psindex) { 1897 /* indentation moved forward */ 1898 /* 1899 * Handle basic node information of SAS expander 1900 * element - binding to parent node and 1901 * allocating FMRI... 1902 */ 1903 if (ses_create_generic(sdp, xsnp, pnode, pnode, SASEXPANDER, 1904 "SAS-EXPANDER", &exptn) != 0) 1905 continue; 1906 /* 1907 * Now handle SAS expander unique portion of node creation. 1908 * The max nubmer of the phy count is 256 since SES-2 1909 * defines as 1 byte field. The cidxlist has the same 1910 * number of elements. 1911 * 1912 * We use size 64 array to store the connectors. 1913 * Typically a connectors associated with 4 phys so that 1914 * matches with the max number of connecters associated 1915 * with an expander. 1916 * The phy count goes up to 38 for Sun supported 1917 * JBOD. 1918 */ 1919 memset(cidxlist, 0, sizeof (int64_t) * 64); 1920 if (ses_set_expander_props(sdp, xsnp, pnode, exptn, &phycount, 1921 cidxlist) != 0) { 1922 /* 1923 * error on getting specific prop failed. 1924 * continue on. Note that the node is 1925 * left bound. 1926 */ 1927 continue; 1928 } 1929 1930 /* 1931 * count represetns the number of connectors discovered so far. 1932 */ 1933 count = 0; 1934 memset(connectors, 0, sizeof (sas_connector_phy_data_t) * 64); 1935 for (i = 0; i < phycount; i++) { 1936 if (cidxlist[i] != -1) { 1937 /* connector index is valid. */ 1938 for (j = 0; j < count; j++) { 1939 if (connectors[j].scpd_index == 1940 cidxlist[i]) { 1941 /* 1942 * Just update phy mask. 1943 * The postion for connector 1944 * index lists(cidxlist index) 1945 * is set. 1946 */ 1947 connectors[j].scpd_pm = 1948 connectors[j].scpd_pm | 1949 (1ULL << i); 1950 break; 1951 } 1952 } 1953 /* 1954 * If j and count matche a new connector 1955 * index is found. 1956 */ 1957 if (j == count) { 1958 /* add a new index and phy mask. */ 1959 connectors[count].scpd_index = 1960 cidxlist[i]; 1961 connectors[count].scpd_pm = 1962 connectors[count].scpd_pm | 1963 (1ULL << i); 1964 count++; 1965 } 1966 } 1967 } 1968 1969 /* 1970 * create range for the connector nodes. 1971 * The class index of the ses connector element 1972 * is set as the instance nubmer for the node. 1973 * Even though one expander may not have all connectors 1974 * are associated with we are creating the range with 1975 * max possible instance number. 1976 */ 1977 found = B_FALSE; 1978 max = 0; 1979 for (consnp = topo_list_next(&cp->sec_nodes); 1980 consnp != NULL; consnp = topo_list_next(consnp)) { 1981 if (consnp->sen_type == SES_ET_SAS_CONNECTOR) { 1982 psprops = ses_node_props(consnp->sen_node); 1983 found = B_TRUE; 1984 if (consnp->sen_instance > max) 1985 max = consnp->sen_instance; 1986 } 1987 } 1988 1989 /* 1990 * No SAS connector found nothing to process. 1991 */ 1992 if (!found) 1993 return (0); 1994 1995 if (dorange && topo_node_range_create(mod, exptn, 1996 RECEPTACLE, 0, max) != 0) { 1997 topo_mod_dprintf(mod, 1998 "topo_node_create_range() failed: %s", 1999 topo_mod_errmsg(mod)); 2000 return (-1); 2001 } 2002 2003 /* search matching connector element using the index. */ 2004 for (i = 0; i < count; i++) { 2005 found = B_FALSE; 2006 for (consnp = topo_list_next(&cp->sec_nodes); 2007 consnp != NULL; consnp = topo_list_next(consnp)) { 2008 if (consnp->sen_type == SES_ET_SAS_CONNECTOR) { 2009 psprops = ses_node_props( 2010 consnp->sen_node); 2011 /* 2012 * Get the physical parent index to 2013 * compare. 2014 * The connector elements are children 2015 * of ESC Electronics element even 2016 * though we enumerate them under 2017 * an expander in libtopo. 2018 */ 2019 if (nvlist_lookup_uint64(psprops, 2020 SES_PROP_ELEMENT_ONLY_INDEX, 2021 &conindex) == 0) { 2022 if (conindex == 2023 connectors[i].scpd_index) { 2024 found = B_TRUE; 2025 break; 2026 } 2027 } 2028 } 2029 } 2030 2031 /* now create a libtopo node. */ 2032 if (found) { 2033 /* Create generic props. */ 2034 if (ses_create_generic(sdp, consnp, exptn, 2035 topo_node_parent(exptn), 2036 RECEPTACLE, "RECEPTACLE", &contn) != 2037 0) { 2038 continue; 2039 } 2040 /* Create connector specific props. */ 2041 if (ses_set_connector_props(sdp, consnp, 2042 contn, connectors[i].scpd_pm) != 0) { 2043 continue; 2044 } 2045 } 2046 } 2047 /* end indentation change */ 2048 } 2049 } 2050 } 2051 } 2052 2053 return (0); 2054 } 2055 2056 /* 2057 * Instantiate any protocol specific portion of a node. 2058 */ 2059 /*ARGSUSED*/ 2060 static int 2061 ses_create_protocol_specific(ses_enum_data_t *sdp, ses_enum_node_t *snp, 2062 tnode_t *pnode, uint64_t type, ses_enum_chassis_t *cp, 2063 boolean_t dorange) 2064 { 2065 2066 if (type == SES_ET_ESC_ELECTRONICS) { 2067 /* create SAS specific children(expanders and connectors. */ 2068 return (ses_create_esc_sasspecific(sdp, snp, pnode, cp, 2069 dorange)); 2070 } 2071 2072 return (0); 2073 } 2074 2075 /* 2076 * Instantiate any children of a given type. 2077 */ 2078 static int 2079 ses_create_children(ses_enum_data_t *sdp, tnode_t *pnode, uint64_t type, 2080 const char *nodename, const char *defaultlabel, ses_enum_chassis_t *cp, 2081 boolean_t dorange) 2082 { 2083 topo_mod_t *mod = sdp->sed_mod; 2084 boolean_t found; 2085 uint64_t max; 2086 ses_enum_node_t *snp; 2087 tnode_t *tn; 2088 2089 /* 2090 * First go through and count how many matching nodes we have. 2091 */ 2092 max = 0; 2093 found = B_FALSE; 2094 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2095 snp = topo_list_next(snp)) { 2096 if (snp->sen_type == type) { 2097 found = B_TRUE; 2098 if (snp->sen_instance > max) 2099 max = snp->sen_instance; 2100 } 2101 } 2102 2103 /* 2104 * No enclosure should export both DEVICE and ARRAY_DEVICE elements. 2105 * Since we map both of these to 'disk', if an enclosure does this, we 2106 * just ignore the array elements. 2107 */ 2108 if (!found || 2109 (type == SES_ET_ARRAY_DEVICE && cp->sec_hasdev)) 2110 return (0); 2111 2112 topo_mod_dprintf(mod, "%s: creating %llu %s nodes", 2113 cp->sec_csn, max + 1, nodename); 2114 2115 if (dorange && topo_node_range_create(mod, pnode, 2116 nodename, 0, max) != 0) { 2117 topo_mod_dprintf(mod, 2118 "topo_node_create_range() failed: %s", 2119 topo_mod_errmsg(mod)); 2120 return (-1); 2121 } 2122 2123 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2124 snp = topo_list_next(snp)) { 2125 if (snp->sen_type == type) { 2126 /* 2127 * With flat layout of ses nodes there is no 2128 * way to find out the direct FRU for a node. 2129 * Passing NULL for fru topo node. Note that 2130 * ses_create_children_from_phys_tree() provides 2131 * the actual direct FRU for a node. 2132 */ 2133 if (ses_create_generic(sdp, snp, pnode, NULL, 2134 nodename, defaultlabel, &tn) != 0) 2135 return (-1); 2136 /* 2137 * For some SES element there may be protocol specific 2138 * information to process. Here we are processing 2139 * the association between enclosure controller and 2140 * SAS expanders. 2141 */ 2142 if (type == SES_ET_ESC_ELECTRONICS) { 2143 /* create SAS expander node */ 2144 if (ses_create_protocol_specific(sdp, snp, 2145 tn, type, cp, dorange) != 0) { 2146 return (-1); 2147 } 2148 } 2149 2150 } 2151 } 2152 2153 return (0); 2154 } 2155 2156 /* 2157 * Instantiate a new subchassis instance in the topology. 2158 */ 2159 static int 2160 ses_create_subchassis(ses_enum_data_t *sdp, tnode_t *pnode, 2161 ses_enum_chassis_t *scp) 2162 { 2163 topo_mod_t *mod = sdp->sed_mod; 2164 tnode_t *tn; 2165 nvlist_t *props; 2166 nvlist_t *auth = NULL, *fmri = NULL; 2167 uint64_t instance = scp->sec_instance; 2168 char *desc; 2169 char label[128]; 2170 char **paths; 2171 int i, err; 2172 ses_enum_target_t *stp; 2173 int ret = -1; 2174 2175 /* 2176 * Copy authority information from parent enclosure node 2177 */ 2178 if ((auth = topo_mod_auth(mod, pnode)) == NULL) 2179 goto error; 2180 2181 /* 2182 * Record the subchassis serial number in the FMRI. 2183 * For now, we assume that logical id is the subchassis serial number. 2184 * If this assumption changes in future, then the following 2185 * piece of code will need to be updated via an RFE. 2186 */ 2187 if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION, 2188 SUBCHASSIS, (topo_instance_t)instance, NULL, auth, NULL, NULL, 2189 NULL)) == NULL) { 2190 topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s", 2191 topo_mod_errmsg(mod)); 2192 goto error; 2193 } 2194 2195 if ((tn = topo_node_bind(mod, pnode, SUBCHASSIS, 2196 instance, fmri)) == NULL) { 2197 topo_mod_dprintf(mod, "topo_node_bind() failed: %s", 2198 topo_mod_errmsg(mod)); 2199 goto error; 2200 } 2201 2202 props = ses_node_props(scp->sec_enclosure); 2203 2204 /* 2205 * Look for the subchassis label in the following order: 2206 * <ses-description> 2207 * <ses-class-description> <instance> 2208 * <default-type-label> <instance> 2209 * 2210 * For subchassis, the default label is "SUBCHASSIS" 2211 */ 2212 if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 || 2213 desc[0] == '\0') { 2214 if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION, 2215 &desc) == 0 && desc[0] != '\0') 2216 (void) snprintf(label, sizeof (label), "%s %llu", desc, 2217 instance); 2218 else 2219 (void) snprintf(label, sizeof (label), 2220 "SUBCHASSIS %llu", instance); 2221 desc = label; 2222 } 2223 2224 if (topo_node_label_set(tn, desc, &err) != 0) 2225 goto error; 2226 2227 if (ses_set_standard_props(mod, NULL, tn, NULL, 2228 ses_node_id(scp->sec_enclosure), scp->sec_target->set_devpath) != 0) 2229 goto error; 2230 2231 /* 2232 * Set the 'chassis-type' property for this subchassis. This is either 2233 * 'ses-class-description' or 'subchassis'. 2234 */ 2235 if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION, &desc) != 0) 2236 desc = "subchassis"; 2237 2238 if (topo_prop_set_string(tn, TOPO_PGROUP_SES, 2239 TOPO_PROP_CHASSIS_TYPE, TOPO_PROP_IMMUTABLE, desc, &err) != 0) { 2240 topo_mod_dprintf(mod, "failed to create property %s: %s\n", 2241 TOPO_PROP_CHASSIS_TYPE, topo_strerror(err)); 2242 goto error; 2243 } 2244 2245 /* 2246 * For enclosures, we want to include all possible targets (for upgrade 2247 * purposes). 2248 */ 2249 for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL; 2250 stp = topo_list_next(stp), i++) 2251 ; 2252 2253 verify(i != 0); 2254 paths = alloca(i * sizeof (char *)); 2255 2256 for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL; 2257 stp = topo_list_next(stp), i++) 2258 paths[i] = stp->set_devpath; 2259 2260 if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES, 2261 TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths, 2262 i, &err) != 0) { 2263 topo_mod_dprintf(mod, "failed to create property %s: %s\n", 2264 TOPO_PROP_PATHS, topo_strerror(err)); 2265 goto error; 2266 } 2267 2268 if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) { 2269 topo_mod_dprintf(mod, "topo_method_register() failed: %s", 2270 topo_mod_errmsg(mod)); 2271 goto error; 2272 } 2273 2274 /* 2275 * Create the nodes for controllers and bays. 2276 */ 2277 if (ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS, 2278 CONTROLLER, "CONTROLLER", scp, B_TRUE) != 0 || 2279 ses_create_children(sdp, tn, SES_ET_DEVICE, 2280 BAY, "BAY", scp, B_TRUE) != 0 || 2281 ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE, 2282 BAY, "BAY", scp, B_TRUE) != 0) 2283 goto error; 2284 2285 ret = 0; 2286 2287 error: 2288 nvlist_free(auth); 2289 nvlist_free(fmri); 2290 return (ret); 2291 } 2292 2293 /* 2294 * Function we use to insert a node. 2295 */ 2296 static int 2297 ses_phys_tree_insert(topo_mod_t *mod, ses_phys_tree_t **sproot, 2298 ses_phys_tree_t *child) 2299 { 2300 uint64_t ppindex, eindex, pindex; 2301 ses_phys_tree_t *node_ptr; 2302 int ret = 0; 2303 2304 assert(sproot != NULL); 2305 assert(child != NULL); 2306 2307 if (*sproot == NULL) { 2308 *sproot = child; 2309 return (0); 2310 } 2311 2312 pindex = child->spt_pindex; 2313 ppindex = (*sproot)->spt_pindex; 2314 eindex = (*sproot)->spt_eonlyindex; 2315 2316 /* 2317 * If the element only index of the root is same as the physical 2318 * parent index of a node to be added, add the node as a child of 2319 * the current root. 2320 */ 2321 if (eindex == pindex) { 2322 (void) ses_phys_tree_insert(mod, &(*sproot)->spt_child, child); 2323 child->spt_parent = *sproot; 2324 } else if (ppindex == pindex) { 2325 /* 2326 * if the physical parent of the current root and the child 2327 * is same, then this should be a sibling node. 2328 * Siblings can be different element types and arrange 2329 * them by group. 2330 */ 2331 if ((*sproot)->spt_senumnode->sen_type == 2332 child->spt_senumnode->sen_type) { 2333 child->spt_sibling = *sproot; 2334 *sproot = child; 2335 } else { 2336 /* add a node in front of matching element type. */ 2337 node_ptr = *sproot; 2338 while (node_ptr->spt_sibling != NULL) { 2339 if (node_ptr->spt_sibling-> 2340 spt_senumnode->sen_type == 2341 child->spt_senumnode->sen_type) { 2342 child->spt_sibling = 2343 node_ptr->spt_sibling; 2344 node_ptr->spt_sibling = child; 2345 break; 2346 } 2347 node_ptr = node_ptr->spt_sibling; 2348 } 2349 /* no matching. Add the child at the end. */ 2350 if (node_ptr->spt_sibling == NULL) { 2351 node_ptr->spt_sibling = child; 2352 } 2353 } 2354 child->spt_parent = (*sproot)->spt_parent; 2355 } else { 2356 /* 2357 * The root and the node is not directly related. 2358 * Try to insert to the child sub-tree first and then try to 2359 * insert to the sibling sub-trees. If fails for both 2360 * the caller will retry insertion later. 2361 */ 2362 if ((*sproot)->spt_child) { 2363 ret = ses_phys_tree_insert(mod, &(*sproot)->spt_child, 2364 child); 2365 } 2366 if ((*sproot)->spt_child == NULL || ret != 0) { 2367 if ((*sproot)->spt_sibling) { 2368 ret = ses_phys_tree_insert(mod, 2369 &(*sproot)->spt_sibling, child); 2370 } else { 2371 ret = 1; 2372 } 2373 } 2374 return (ret); 2375 } 2376 return (0); 2377 } 2378 2379 /* 2380 * Construct tree view of ses elements through parent phyiscal element index. 2381 * The root of tree is already constructed using the enclosure element. 2382 */ 2383 static int 2384 ses_construct_phys_tree(ses_enum_data_t *sdp, ses_enum_chassis_t *cp, 2385 ses_phys_tree_t *sproot) 2386 { 2387 ses_enum_node_t *snp; 2388 ses_phys_tree_t *child; 2389 ses_phys_tree_t *u_watch = NULL; 2390 ses_phys_tree_t *u_head = NULL; 2391 ses_phys_tree_t *u_tail = NULL; 2392 int u_inserted = 0, u_left = 0; 2393 nvlist_t *props; 2394 topo_mod_t *mod = sdp->sed_mod; 2395 2396 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2397 snp = topo_list_next(snp)) { 2398 if ((child = topo_mod_zalloc(mod, 2399 sizeof (ses_phys_tree_t))) == NULL) { 2400 topo_mod_dprintf(mod, 2401 "failed to allocate root."); 2402 return (-1); 2403 } 2404 child->spt_snode = snp->sen_node; 2405 props = ses_node_props(snp->sen_node); 2406 if (nvlist_lookup_uint64(props, 2407 LIBSES_PROP_PHYS_PARENT, &child->spt_pindex) != 0) { 2408 /* 2409 * the prop should exist. continue to see if 2410 * we can build a partial tree with other elements. 2411 */ 2412 topo_mod_dprintf(mod, 2413 "ses_construct_phys_tree(): Failed to find prop %s " 2414 "on ses element type %d and instance %d " 2415 "(CSN %s).", LIBSES_PROP_PHYS_PARENT, 2416 snp->sen_type, snp->sen_instance, cp->sec_csn); 2417 topo_mod_free(mod, child, sizeof (ses_phys_tree_t)); 2418 continue; 2419 } else { 2420 if (nvlist_lookup_boolean_value(props, 2421 LIBSES_PROP_FRU, &child->spt_isfru) != 0) { 2422 topo_mod_dprintf(mod, 2423 "ses_construct_phys_tree(): Failed to " 2424 "find prop %s on ses element type %d " 2425 "and instance %d (CSN %s).", 2426 LIBSES_PROP_FRU, 2427 snp->sen_type, snp->sen_instance, 2428 cp->sec_csn); 2429 /* 2430 * Ignore if the prop doesn't exist. 2431 * Note that the enclosure itself should be 2432 * a FRU so if no FRU found the enclosure FRU 2433 * can be a direct FRU. 2434 */ 2435 } 2436 verify(nvlist_lookup_uint64(props, 2437 SES_PROP_ELEMENT_ONLY_INDEX, 2438 &child->spt_eonlyindex) == 0); 2439 verify(nvlist_lookup_uint64(props, 2440 SES_PROP_ELEMENT_CLASS_INDEX, 2441 &child->spt_cindex) == 0); 2442 } 2443 child->spt_senumnode = snp; 2444 if (ses_phys_tree_insert(mod, &sproot, child) != 0) { 2445 /* collect unresolved element to process later. */ 2446 if (u_head == NULL) { 2447 u_head = child; 2448 u_tail = child; 2449 } else { 2450 child->spt_sibling = u_head; 2451 u_head = child; 2452 } 2453 } 2454 } 2455 2456 /* 2457 * The parent of a child node may not be inserted yet. 2458 * Trying to insert the child until no child is left or 2459 * no child is not added further. For the latter 2460 * the hierarchical relationship between elements 2461 * should be checked through SUNW,FRUID page. 2462 * u_watch is a watch dog to check the prgress of unresolved 2463 * node. 2464 */ 2465 u_watch = u_tail; 2466 while (u_head) { 2467 child = u_head; 2468 u_head = u_head->spt_sibling; 2469 if (u_head == NULL) 2470 u_tail = NULL; 2471 child->spt_sibling = NULL; 2472 if (ses_phys_tree_insert(mod, &sproot, child) != 0) { 2473 u_tail->spt_sibling = child; 2474 u_tail = child; 2475 if (child == u_watch) { 2476 /* 2477 * We just scanned one round for the 2478 * unresolved list. Check to see whether we 2479 * have nodes inserted, if none, we should 2480 * break in case of an indefinite loop. 2481 */ 2482 if (u_inserted == 0) { 2483 /* 2484 * Indicate there is unhandled node. 2485 * Chain free the whole unsolved 2486 * list here. 2487 */ 2488 u_left++; 2489 break; 2490 } else { 2491 u_inserted = 0; 2492 u_watch = u_tail; 2493 } 2494 } 2495 } else { 2496 /* 2497 * We just inserted one rpnode, increment the 2498 * unsolved_inserted counter. We will utilize this 2499 * counter to detect an indefinite insertion loop. 2500 */ 2501 u_inserted++; 2502 } 2503 } 2504 2505 /* check if there is left out unresolved nodes. */ 2506 if (u_left) { 2507 topo_mod_dprintf(mod, "ses_construct_phys_tree(): " 2508 "Failed to construct physical view of the following " 2509 "ses elements of Chassis CSN %s.", cp->sec_csn); 2510 while (u_head) { 2511 u_tail = u_head->spt_sibling; 2512 topo_mod_dprintf(mod, 2513 "\telement type (%d) and instance (%d)", 2514 u_head->spt_senumnode->sen_type, 2515 u_head->spt_senumnode->sen_instance); 2516 topo_mod_free(mod, u_head, sizeof (ses_phys_tree_t)); 2517 u_head = u_tail; 2518 } 2519 return (-1); 2520 } 2521 2522 return (0); 2523 } 2524 2525 /* 2526 * Free the whole phys tree. 2527 */ 2528 static void ses_phys_tree_free(topo_mod_t *mod, ses_phys_tree_t *sproot) 2529 { 2530 if (sproot == NULL) 2531 return; 2532 2533 /* Free child tree. */ 2534 if (sproot->spt_child) { 2535 ses_phys_tree_free(mod, sproot->spt_child); 2536 } 2537 2538 /* Free sibling trees. */ 2539 if (sproot->spt_sibling) { 2540 ses_phys_tree_free(mod, sproot->spt_sibling); 2541 } 2542 2543 /* Free root node itself. */ 2544 topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t)); 2545 } 2546 2547 /* 2548 * Parses phys_enum_type table to get the index of the given type. 2549 */ 2550 static boolean_t 2551 is_type_enumerated(ses_phys_tree_t *node, int *index) 2552 { 2553 int i; 2554 2555 for (i = 0; i < N_PHYS_ENUM_TYPES; i++) { 2556 if (node->spt_senumnode->sen_type == 2557 phys_enum_type_list[i].pet_type) { 2558 *index = i; 2559 return (B_TRUE); 2560 } 2561 } 2562 return (B_FALSE); 2563 } 2564 2565 /* 2566 * Recusrive routine for top-down enumeration of the tree. 2567 */ 2568 static int 2569 ses_enumerate_node(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp, 2570 ses_phys_tree_t *parent, int mrange[]) 2571 { 2572 topo_mod_t *mod = sdp->sed_mod; 2573 ses_phys_tree_t *child = NULL; 2574 int i, ret = 0, ret_ch; 2575 uint64_t prevtype = SES_ET_UNSPECIFIED; 2576 ses_phys_tree_t *dirfru = NULL; 2577 tnode_t *tn = NULL, *frutn = NULL; 2578 2579 if (parent == NULL) { 2580 return (0); 2581 } 2582 2583 for (child = parent->spt_child; child != NULL; 2584 child = child->spt_sibling) { 2585 if (is_type_enumerated(child, &i)) { 2586 if (prevtype != phys_enum_type_list[i].pet_type) { 2587 /* check if range needs to be created. */ 2588 if (phys_enum_type_list[i].pet_dorange && 2589 topo_node_range_create(mod, pnode, 2590 phys_enum_type_list[i].pet_nodename, 0, 2591 mrange[i]) != 0) { 2592 topo_mod_dprintf(mod, 2593 "topo_node_create_range() failed: " 2594 "%s", topo_mod_errmsg(mod)); 2595 return (-1); 2596 } 2597 prevtype = phys_enum_type_list[i].pet_type; 2598 } 2599 2600 if (!(child->spt_isfru)) { 2601 for (dirfru = parent; dirfru != NULL; 2602 dirfru = dirfru->spt_parent) { 2603 if (dirfru->spt_isfru) { 2604 break; 2605 } 2606 } 2607 /* found direct FRU node. */ 2608 if (dirfru) { 2609 frutn = dirfru->spt_tnode; 2610 } else { 2611 frutn = NULL; 2612 } 2613 } else { 2614 frutn = NULL; 2615 } 2616 2617 if (ses_create_generic(sdp, child->spt_senumnode, 2618 pnode, frutn, phys_enum_type_list[i].pet_nodename, 2619 phys_enum_type_list[i].pet_defaultlabel, &tn) != 0) 2620 return (-1); 2621 2622 child->spt_tnode = tn; 2623 /* 2624 * For some SES element there may be protocol specific 2625 * information to process. Here we are processing 2626 * the association between enclosure controller and 2627 * SAS expanders. 2628 */ 2629 if (phys_enum_type_list[i].pet_type == 2630 SES_ET_ESC_ELECTRONICS) { 2631 /* create SAS expander node */ 2632 if (ses_create_protocol_specific(sdp, 2633 child->spt_senumnode, tn, 2634 phys_enum_type_list[i].pet_type, 2635 cp, phys_enum_type_list[i].pet_dorange) != 2636 0) { 2637 return (-1); 2638 } 2639 } 2640 } else { 2641 continue; 2642 } 2643 ret_ch = ses_enumerate_node(sdp, tn, cp, child, mrange); 2644 if (ret_ch) 2645 ret = ret_ch; /* there was an error and set the ret. */ 2646 } 2647 2648 return (ret); 2649 } 2650 2651 /* 2652 * Instantiate types of nodes that are specified in the hierarchy 2653 * element type list. 2654 */ 2655 static int 2656 ses_create_children_from_phys_tree(ses_enum_data_t *sdp, tnode_t *pnode, 2657 ses_enum_chassis_t *cp, ses_phys_tree_t *phys_tree) 2658 { 2659 topo_mod_t *mod = sdp->sed_mod; 2660 int mrange[N_PHYS_ENUM_TYPES] = { 0 }; 2661 ses_enum_node_t *snp; 2662 int i, ret; 2663 2664 /* 2665 * First get max range for each type of element to be enumerated. 2666 */ 2667 for (i = 0; i < N_PHYS_ENUM_TYPES; i++) { 2668 if (phys_enum_type_list[i].pet_dorange) { 2669 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2670 snp = topo_list_next(snp)) { 2671 if (snp->sen_type == 2672 phys_enum_type_list[i].pet_type) { 2673 if (snp->sen_instance > mrange[i]) 2674 mrange[i] = 2675 snp->sen_instance; 2676 } 2677 } 2678 } 2679 } 2680 2681 topo_mod_dprintf(mod, "%s: creating nodes from FRU hierarchy tree.", 2682 cp->sec_csn); 2683 2684 if ((ret = ses_enumerate_node(sdp, pnode, cp, phys_tree, mrange)) != 2685 0) { 2686 topo_mod_dprintf(mod, 2687 "ses_create_children_from_phys_tree() failed: "); 2688 return (ret); 2689 } 2690 2691 return (0); 2692 } 2693 2694 /* 2695 * Instantiate a new chassis instance in the topology. 2696 */ 2697 static int 2698 ses_create_chassis(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp) 2699 { 2700 topo_mod_t *mod = sdp->sed_mod; 2701 nvlist_t *props; 2702 char *raw_manufacturer, *raw_model, *raw_revision; 2703 char *manufacturer = NULL, *model = NULL, *product = NULL; 2704 char *revision = NULL; 2705 char *serial; 2706 char **paths; 2707 size_t prodlen; 2708 tnode_t *tn; 2709 nvlist_t *fmri = NULL, *auth = NULL; 2710 int ret = -1; 2711 ses_enum_node_t *snp; 2712 ses_enum_target_t *stp; 2713 ses_enum_chassis_t *scp; 2714 int i, err; 2715 uint64_t sc_count = 0, pindex; 2716 ses_phys_tree_t *sproot = NULL; 2717 hrtime_t start; 2718 hrtime_t end; 2719 double duration; 2720 2721 /* 2722 * Ignore any internal enclosures. 2723 */ 2724 if (cp->sec_internal) 2725 return (0); 2726 2727 /* 2728 * Check to see if there are any devices presennt in the chassis. If 2729 * not, ignore the chassis alltogether. This is most useful for 2730 * ignoring internal HBAs that present a SES target but don't actually 2731 * manage any of the devices. 2732 */ 2733 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2734 snp = topo_list_next(snp)) { 2735 if (snp->sen_type == SES_ET_DEVICE || 2736 snp->sen_type == SES_ET_ARRAY_DEVICE) 2737 break; 2738 } 2739 2740 if (snp == NULL) 2741 return (0); 2742 2743 props = ses_node_props(cp->sec_enclosure); 2744 2745 /* 2746 * We use the following property mappings: 2747 * 2748 * manufacturer vendor-id 2749 * model product-id 2750 * serial-number libses-chassis-serial 2751 */ 2752 verify(nvlist_lookup_string(props, SES_EN_PROP_VID, 2753 &raw_manufacturer) == 0); 2754 verify(nvlist_lookup_string(props, SES_EN_PROP_PID, &raw_model) == 0); 2755 verify(nvlist_lookup_string(props, SES_EN_PROP_REV, 2756 &raw_revision) == 0); 2757 verify(nvlist_lookup_string(props, LIBSES_EN_PROP_CSN, &serial) == 0); 2758 2759 /* 2760 * To construct the authority information, we 'clean' each string by 2761 * removing any offensive characters and trimmming whitespace. For the 2762 * 'product-id', we use a concatenation of 'manufacturer-model'. We 2763 * also take the numerical serial number and convert it to a string. 2764 */ 2765 if ((manufacturer = disk_auth_clean(mod, raw_manufacturer)) == NULL || 2766 (model = disk_auth_clean(mod, raw_model)) == NULL || 2767 (revision = disk_auth_clean(mod, raw_revision)) == NULL) { 2768 goto error; 2769 } 2770 2771 prodlen = strlen(manufacturer) + strlen(model) + 2; 2772 if ((product = topo_mod_alloc(mod, prodlen)) == NULL) 2773 goto error; 2774 2775 (void) snprintf(product, prodlen, "%s-%s", manufacturer, model); 2776 2777 /* 2778 * Construct the topo node and bind it to our parent. 2779 */ 2780 if (topo_mod_nvalloc(mod, &auth, NV_UNIQUE_NAME) != 0) 2781 goto error; 2782 2783 if (nvlist_add_string(auth, FM_FMRI_AUTH_PRODUCT, product) != 0 || 2784 nvlist_add_string(auth, FM_FMRI_AUTH_CHASSIS, serial) != 0) { 2785 (void) topo_mod_seterrno(mod, EMOD_NVL_INVAL); 2786 goto error; 2787 } 2788 2789 /* 2790 * We pass NULL for the parent FMRI because there is no resource 2791 * associated with it. For the toplevel enclosure, we leave the 2792 * serial/part/revision portions empty, which are reserved for 2793 * individual components within the chassis. 2794 */ 2795 if ((fmri = topo_mod_hcfmri(mod, NULL, FM_HC_SCHEME_VERSION, 2796 SES_ENCLOSURE, cp->sec_instance, NULL, auth, 2797 model, revision, serial)) == NULL) { 2798 topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s", 2799 topo_mod_errmsg(mod)); 2800 goto error; 2801 } 2802 2803 if ((tn = topo_node_bind(mod, pnode, SES_ENCLOSURE, 2804 cp->sec_instance, fmri)) == NULL) { 2805 topo_mod_dprintf(mod, "topo_node_bind() failed: %s", 2806 topo_mod_errmsg(mod)); 2807 goto error; 2808 } 2809 2810 if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) { 2811 topo_mod_dprintf(mod, 2812 "topo_method_register() failed: %s", 2813 topo_mod_errmsg(mod)); 2814 goto error; 2815 } 2816 2817 if (ses_set_standard_props(mod, NULL, tn, auth, 2818 ses_node_id(cp->sec_enclosure), cp->sec_target->set_devpath) != 0) 2819 goto error; 2820 2821 /* 2822 * For enclosures, we want to include all possible targets (for upgrade 2823 * purposes). 2824 */ 2825 for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL; 2826 stp = topo_list_next(stp), i++) 2827 ; 2828 2829 verify(i != 0); 2830 paths = alloca(i * sizeof (char *)); 2831 2832 for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL; 2833 stp = topo_list_next(stp), i++) 2834 paths[i] = stp->set_devpath; 2835 2836 2837 if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES, 2838 TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths, 2839 i, &err) != 0) { 2840 topo_mod_dprintf(mod, 2841 "failed to create property %s: %s\n", 2842 TOPO_PROP_PATHS, topo_strerror(err)); 2843 goto error; 2844 } 2845 2846 if (nvlist_lookup_uint64(props, 2847 LIBSES_PROP_PHYS_PARENT, &pindex) == 0) { 2848 start = gethrtime(); /* to mearusre performance */ 2849 /* 2850 * The enclosure is supported through SUNW,FRUID. 2851 * Need to enumerate the nodes through hierarchical order. 2852 */ 2853 if ((sproot = topo_mod_zalloc(mod, 2854 sizeof (ses_phys_tree_t))) == NULL) { 2855 topo_mod_dprintf(mod, 2856 "failed to allocate root: %s\n", 2857 topo_strerror(err)); 2858 goto error; 2859 } 2860 sproot->spt_pindex = pindex; 2861 if (nvlist_lookup_boolean_value(props, 2862 LIBSES_PROP_FRU, &sproot->spt_isfru) != 0) { 2863 topo_mod_dprintf(mod, 2864 "ses_create_chassis(): Failed to find prop %s " 2865 "on enclosure element (CSN %s).", 2866 LIBSES_PROP_FRU, cp->sec_csn); 2867 /* an enclosure should be a FRU. continue to process. */ 2868 sproot->spt_isfru = B_TRUE; 2869 } 2870 if (nvlist_lookup_uint64(props, 2871 SES_PROP_ELEMENT_ONLY_INDEX, 2872 &sproot->spt_eonlyindex) != 0) { 2873 topo_mod_dprintf(mod, 2874 "ses_create_chassis(): Failed to find prop %s " 2875 "on enclosure element (CSN %s).", 2876 LIBSES_PROP_PHYS_PARENT, cp->sec_csn); 2877 topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t)); 2878 goto error; 2879 } 2880 if (sproot->spt_pindex != sproot->spt_eonlyindex) { 2881 topo_mod_dprintf(mod, "ses_create_chassis(): " 2882 "Enclosure element(CSN %s) should have " 2883 "itself as the parent to be the root node " 2884 "of FRU hierarchical tree.)", cp->sec_csn); 2885 topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t)); 2886 goto error; 2887 } else { 2888 sproot->spt_snode = cp->sec_enclosure; 2889 sproot->spt_tnode = tn; 2890 /* construct a tree. */ 2891 if (ses_construct_phys_tree(sdp, cp, sproot) != 0) { 2892 topo_mod_dprintf(mod, "ses_create_chassis(): " 2893 "Failed to construct FRU hierarchical " 2894 "tree on enclosure (CSN %s.)", 2895 cp->sec_csn); 2896 } 2897 2898 /* enumerate elements from the tree. */ 2899 if (ses_create_children_from_phys_tree(sdp, tn, cp, 2900 sproot) != 0) { 2901 topo_mod_dprintf(mod, "ses_create_chassis(): " 2902 "Failed to create children topo nodes out " 2903 "of FRU hierarchical tree on enclosure " 2904 "(CSN %s).", cp->sec_csn); 2905 } 2906 /* destroy the phys tree. */ 2907 ses_phys_tree_free(mod, sproot); 2908 } 2909 2910 end = gethrtime(); 2911 duration = end - start; 2912 duration /= HR_SECOND; 2913 topo_mod_dprintf(mod, 2914 "FRU boundary tree based enumeration: %.6f seconds", 2915 duration); 2916 } else { 2917 /* 2918 * Create the nodes for power supplies, fans, controllers and 2919 * devices. Note that SAS exopander nodes and connector nodes 2920 * are handled through protocol specific processing of 2921 * controllers. 2922 */ 2923 if (ses_create_children(sdp, tn, SES_ET_POWER_SUPPLY, 2924 PSU, "PSU", cp, B_TRUE) != 0 || 2925 ses_create_children(sdp, tn, SES_ET_COOLING, 2926 FAN, "FAN", cp, B_TRUE) != 0 || 2927 ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS, 2928 CONTROLLER, "CONTROLLER", cp, B_TRUE) != 0 || 2929 ses_create_children(sdp, tn, SES_ET_DEVICE, 2930 BAY, "BAY", cp, B_TRUE) != 0 || 2931 ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE, 2932 BAY, "BAY", cp, B_TRUE) != 0) 2933 goto error; 2934 } 2935 2936 if (cp->sec_maxinstance >= 0 && 2937 (topo_node_range_create(mod, tn, SUBCHASSIS, 0, 2938 cp->sec_maxinstance) != 0)) { 2939 topo_mod_dprintf(mod, "topo_node_create_range() failed: %s", 2940 topo_mod_errmsg(mod)); 2941 goto error; 2942 } 2943 2944 for (scp = topo_list_next(&cp->sec_subchassis); scp != NULL; 2945 scp = topo_list_next(scp)) { 2946 2947 if (ses_create_subchassis(sdp, tn, scp) != 0) 2948 goto error; 2949 2950 topo_mod_dprintf(mod, "created Subchassis node with " 2951 "instance %u\nand target (%s) under Chassis with CSN %s", 2952 scp->sec_instance, scp->sec_target->set_devpath, 2953 cp->sec_csn); 2954 2955 sc_count++; 2956 } 2957 2958 topo_mod_dprintf(mod, "%s: created %llu %s nodes", 2959 cp->sec_csn, sc_count, SUBCHASSIS); 2960 2961 cp->sec_target->set_refcount++; 2962 topo_node_setspecific(tn, cp->sec_target); 2963 2964 ret = 0; 2965 error: 2966 topo_mod_strfree(mod, manufacturer); 2967 topo_mod_strfree(mod, model); 2968 topo_mod_strfree(mod, revision); 2969 topo_mod_strfree(mod, product); 2970 2971 nvlist_free(fmri); 2972 nvlist_free(auth); 2973 return (ret); 2974 } 2975 2976 /* 2977 * Create a bay node explicitly enumerated via XML. 2978 */ 2979 static int 2980 ses_create_bays(ses_enum_data_t *sdp, tnode_t *pnode) 2981 { 2982 topo_mod_t *mod = sdp->sed_mod; 2983 ses_enum_chassis_t *cp; 2984 2985 /* 2986 * Iterate over chassis looking for an internal enclosure. This 2987 * property is set via a vendor-specific plugin, and there should only 2988 * ever be a single internal chassis in a system. 2989 */ 2990 for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL; 2991 cp = topo_list_next(cp)) { 2992 if (cp->sec_internal) 2993 break; 2994 } 2995 2996 if (cp == NULL) { 2997 topo_mod_dprintf(mod, "failed to find internal chassis\n"); 2998 return (-1); 2999 } 3000 3001 if (ses_create_children(sdp, pnode, SES_ET_DEVICE, 3002 BAY, "BAY", cp, B_FALSE) != 0 || 3003 ses_create_children(sdp, pnode, SES_ET_ARRAY_DEVICE, 3004 BAY, "BAY", cp, B_FALSE) != 0) 3005 return (-1); 3006 3007 return (0); 3008 } 3009 3010 /* 3011 * Initialize chassis or subchassis. 3012 */ 3013 static int 3014 ses_init_chassis(topo_mod_t *mod, ses_enum_data_t *sdp, ses_enum_chassis_t *pcp, 3015 ses_enum_chassis_t *cp, ses_node_t *np, nvlist_t *props, 3016 uint64_t subchassis, ses_chassis_type_e flags) 3017 { 3018 boolean_t internal, ident; 3019 3020 assert((flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS | 3021 SES_DUP_CHASSIS | SES_DUP_SUBCHASSIS)) != 0); 3022 3023 assert(cp != NULL); 3024 assert(np != NULL); 3025 assert(props != NULL); 3026 3027 if (flags & (SES_NEW_SUBCHASSIS | SES_DUP_SUBCHASSIS)) 3028 assert(pcp != NULL); 3029 3030 topo_mod_dprintf(mod, "ses_init_chassis: %s: index %llu, flags (%d)", 3031 sdp->sed_name, subchassis, flags); 3032 3033 if (flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS)) { 3034 3035 topo_mod_dprintf(mod, "new chassis/subchassis"); 3036 if (nvlist_lookup_boolean_value(props, 3037 LIBSES_EN_PROP_INTERNAL, &internal) == 0) 3038 cp->sec_internal = internal; 3039 3040 cp->sec_enclosure = np; 3041 cp->sec_target = sdp->sed_target; 3042 3043 if (flags & SES_NEW_CHASSIS) { 3044 if (!cp->sec_internal) 3045 cp->sec_instance = sdp->sed_instance++; 3046 topo_list_append(&sdp->sed_chassis, cp); 3047 } else { 3048 if (subchassis != NO_SUBCHASSIS) 3049 cp->sec_instance = subchassis; 3050 else 3051 cp->sec_instance = pcp->sec_scinstance++; 3052 3053 if (cp->sec_instance > pcp->sec_maxinstance) 3054 pcp->sec_maxinstance = cp->sec_instance; 3055 3056 topo_list_append(&pcp->sec_subchassis, cp); 3057 } 3058 3059 } else { 3060 topo_mod_dprintf(mod, "dup chassis/subchassis"); 3061 if (nvlist_lookup_boolean_value(props, 3062 SES_PROP_IDENT, &ident) == 0) { 3063 topo_mod_dprintf(mod, "overriding enclosure node"); 3064 3065 cp->sec_enclosure = np; 3066 cp->sec_target = sdp->sed_target; 3067 } 3068 } 3069 3070 topo_list_append(&cp->sec_targets, sdp->sed_target); 3071 sdp->sed_current = cp; 3072 3073 return (0); 3074 } 3075 3076 /* 3077 * Gather nodes from the current SES target into our chassis list, merging the 3078 * results if necessary. 3079 */ 3080 static ses_walk_action_t 3081 ses_enum_gather(ses_node_t *np, void *data) 3082 { 3083 nvlist_t *props = ses_node_props(np); 3084 ses_enum_data_t *sdp = data; 3085 topo_mod_t *mod = sdp->sed_mod; 3086 ses_enum_chassis_t *cp, *scp; 3087 ses_enum_node_t *snp; 3088 ses_alt_node_t *sap; 3089 char *csn; 3090 uint64_t instance, type; 3091 uint64_t prevstatus, status; 3092 boolean_t report; 3093 uint64_t subchassis = NO_SUBCHASSIS; 3094 3095 if (ses_node_type(np) == SES_NODE_ENCLOSURE) { 3096 /* 3097 * If we have already identified the chassis for this target, 3098 * then this is a secondary enclosure and we should ignore it, 3099 * along with the rest of the tree (since this is depth-first). 3100 */ 3101 if (sdp->sed_current != NULL) 3102 return (SES_WALK_ACTION_TERMINATE); 3103 3104 /* 3105 * Go through the list of chassis we have seen so far and see 3106 * if this serial number matches one of the known values. 3107 * If so, check whether this enclosure is a subchassis. 3108 */ 3109 if (nvlist_lookup_string(props, LIBSES_EN_PROP_CSN, 3110 &csn) != 0) 3111 return (SES_WALK_ACTION_TERMINATE); 3112 3113 (void) nvlist_lookup_uint64(props, LIBSES_EN_PROP_SUBCHASSIS_ID, 3114 &subchassis); 3115 3116 topo_mod_dprintf(mod, "ses_enum_gather: Enclosure Node (%s) " 3117 "CSN (%s), subchassis (%llu)", sdp->sed_name, csn, 3118 subchassis); 3119 3120 /* 3121 * We need to determine whether this enclosure node 3122 * represents a chassis or a subchassis. Since we may 3123 * receive the enclosure nodes in a non-deterministic 3124 * manner, we need to account for all possible combinations: 3125 * 1. Chassis for the current CSN has not yet been 3126 * allocated 3127 * 1.1 This is a new chassis: 3128 * allocate and instantiate the chassis 3129 * 1.2 This is a new subchassis: 3130 * allocate a placeholder chassis 3131 * allocate and instantiate the subchassis 3132 * link the subchassis to the chassis 3133 * 2. Chassis for the current CSN has been allocated 3134 * 2.1 This is a duplicate chassis enclosure 3135 * check whether to override old chassis 3136 * append to chassis' target list 3137 * 2.2 Only placeholder chassis exists 3138 * fill in the chassis fields 3139 * 2.3 This is a new subchassis 3140 * allocate and instantiate the subchassis 3141 * link the subchassis to the chassis 3142 * 2.4 This is a duplicate subchassis enclosure 3143 * check whether to override old chassis 3144 * append to chassis' target list 3145 */ 3146 3147 for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL; 3148 cp = topo_list_next(cp)) 3149 if (strcmp(cp->sec_csn, csn) == 0) 3150 break; 3151 3152 if (cp == NULL) { 3153 /* 1. Haven't seen a chassis with this CSN before */ 3154 3155 if ((cp = topo_mod_zalloc(mod, 3156 sizeof (ses_enum_chassis_t))) == NULL) 3157 goto error; 3158 3159 cp->sec_scinstance = SES_STARTING_SUBCHASSIS; 3160 cp->sec_maxinstance = -1; 3161 cp->sec_csn = csn; 3162 3163 if (subchassis == NO_SUBCHASSIS) { 3164 /* 1.1 This is a new chassis */ 3165 3166 topo_mod_dprintf(mod, "%s: Initialize new " 3167 "chassis with CSN %s", sdp->sed_name, csn); 3168 3169 if (ses_init_chassis(mod, sdp, NULL, cp, 3170 np, props, NO_SUBCHASSIS, 3171 SES_NEW_CHASSIS) < 0) 3172 goto error; 3173 } else { 3174 /* 1.2 This is a new subchassis */ 3175 3176 topo_mod_dprintf(mod, "%s: Initialize new " 3177 "subchassis with CSN %s and index %llu", 3178 sdp->sed_name, csn, subchassis); 3179 3180 if ((scp = topo_mod_zalloc(mod, 3181 sizeof (ses_enum_chassis_t))) == NULL) 3182 goto error; 3183 3184 scp->sec_csn = csn; 3185 3186 if (ses_init_chassis(mod, sdp, cp, scp, np, 3187 props, subchassis, SES_NEW_SUBCHASSIS) < 0) 3188 goto error; 3189 } 3190 } else { 3191 /* 3192 * We have a chassis or subchassis with this CSN. If 3193 * it's a chassis, we must check to see whether it is 3194 * a placeholder previously created because we found a 3195 * subchassis with this CSN. We will know that because 3196 * the sec_target value will not be set; it is set only 3197 * in ses_init_chassis(). In that case, initialise it 3198 * as a new chassis; otherwise, it's a duplicate and we 3199 * need to append only. 3200 */ 3201 if (subchassis == NO_SUBCHASSIS) { 3202 if (cp->sec_target != NULL) { 3203 /* 2.1 This is a duplicate chassis */ 3204 3205 topo_mod_dprintf(mod, "%s: Append " 3206 "duplicate chassis with CSN (%s)", 3207 sdp->sed_name, csn); 3208 3209 if (ses_init_chassis(mod, sdp, NULL, cp, 3210 np, props, NO_SUBCHASSIS, 3211 SES_DUP_CHASSIS) < 0) 3212 goto error; 3213 } else { 3214 /* Placeholder chassis - init it up */ 3215 topo_mod_dprintf(mod, "%s: Initialize" 3216 "placeholder chassis with CSN %s", 3217 sdp->sed_name, csn); 3218 3219 if (ses_init_chassis(mod, sdp, NULL, 3220 cp, np, props, NO_SUBCHASSIS, 3221 SES_NEW_CHASSIS) < 0) 3222 goto error; 3223 3224 } 3225 } else { 3226 /* This is a subchassis */ 3227 3228 for (scp = topo_list_next(&cp->sec_subchassis); 3229 scp != NULL; scp = topo_list_next(scp)) 3230 if (scp->sec_instance == subchassis) 3231 break; 3232 3233 if (scp == NULL) { 3234 /* 2.3 This is a new subchassis */ 3235 3236 topo_mod_dprintf(mod, "%s: Initialize " 3237 "new subchassis with CSN (%s) " 3238 "and LID (%s)", 3239 sdp->sed_name, csn); 3240 3241 if ((scp = topo_mod_zalloc(mod, 3242 sizeof (ses_enum_chassis_t))) 3243 == NULL) 3244 goto error; 3245 3246 scp->sec_csn = csn; 3247 3248 if (ses_init_chassis(mod, sdp, cp, scp, 3249 np, props, subchassis, 3250 SES_NEW_SUBCHASSIS) < 0) 3251 goto error; 3252 } else { 3253 /* 2.4 This is a duplicate subchassis */ 3254 3255 topo_mod_dprintf(mod, "%s: Append " 3256 "duplicate subchassis with " 3257 "CSN (%s)", sdp->sed_name, csn); 3258 3259 if (ses_init_chassis(mod, sdp, cp, scp, 3260 np, props, subchassis, 3261 SES_DUP_SUBCHASSIS) < 0) 3262 goto error; 3263 } 3264 } 3265 } 3266 } else if (ses_node_type(np) == SES_NODE_ELEMENT) { 3267 /* 3268 * If we haven't yet seen an enclosure node and identified the 3269 * current chassis, something is very wrong; bail out. 3270 */ 3271 if (sdp->sed_current == NULL) 3272 return (SES_WALK_ACTION_TERMINATE); 3273 3274 /* 3275 * If this isn't one of the element types we care about, then 3276 * ignore it. 3277 */ 3278 verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_TYPE, 3279 &type) == 0); 3280 if (type != SES_ET_DEVICE && 3281 type != SES_ET_ARRAY_DEVICE && 3282 type != SES_ET_SUNW_FANBOARD && 3283 type != SES_ET_SUNW_FANMODULE && 3284 type != SES_ET_COOLING && 3285 type != SES_ET_SUNW_POWERBOARD && 3286 type != SES_ET_SUNW_POWERMODULE && 3287 type != SES_ET_POWER_SUPPLY && 3288 type != SES_ET_ESC_ELECTRONICS && 3289 type != SES_ET_SAS_EXPANDER && 3290 type != SES_ET_SAS_CONNECTOR) 3291 return (SES_WALK_ACTION_CONTINUE); 3292 3293 /* 3294 * Get the current instance number and see if we already know 3295 * about this element. If so, it means we have multiple paths 3296 * to the same elements, and we should ignore the current path. 3297 */ 3298 verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_CLASS_INDEX, 3299 &instance) == 0); 3300 if (type == SES_ET_DEVICE || type == SES_ET_ARRAY_DEVICE) 3301 (void) nvlist_lookup_uint64(props, SES_PROP_BAY_NUMBER, 3302 &instance); 3303 3304 cp = sdp->sed_current; 3305 3306 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 3307 snp = topo_list_next(snp)) { 3308 if (snp->sen_type == type && 3309 snp->sen_instance == instance) 3310 break; 3311 } 3312 3313 /* 3314 * We prefer the new element under the following circumstances: 3315 * 3316 * - The currently known element's status is unknown or not 3317 * available, but the new element has a known status. This 3318 * occurs if a given element is only available through a 3319 * particular target. 3320 * 3321 * - This is an ESC_ELECTRONICS element, and the 'reported-via' 3322 * property is set. This allows us to get reliable firmware 3323 * revision information from the enclosure node. 3324 */ 3325 if (snp != NULL) { 3326 if (nvlist_lookup_uint64( 3327 ses_node_props(snp->sen_node), 3328 SES_PROP_STATUS_CODE, &prevstatus) != 0) 3329 prevstatus = SES_ESC_UNSUPPORTED; 3330 if (nvlist_lookup_uint64( 3331 props, SES_PROP_STATUS_CODE, &status) != 0) 3332 status = SES_ESC_UNSUPPORTED; 3333 if (nvlist_lookup_boolean_value( 3334 props, SES_PROP_REPORT, &report) != 0) 3335 report = B_FALSE; 3336 3337 if ((SES_STATUS_UNAVAIL(prevstatus) && 3338 !SES_STATUS_UNAVAIL(status)) || 3339 (type == SES_ET_ESC_ELECTRONICS && 3340 report)) { 3341 snp->sen_node = np; 3342 snp->sen_target = sdp->sed_target; 3343 } 3344 3345 if ((sap = topo_mod_zalloc(mod, 3346 sizeof (ses_alt_node_t))) == NULL) 3347 goto error; 3348 3349 sap->san_node = np; 3350 topo_list_append(&snp->sen_alt_nodes, sap); 3351 3352 return (SES_WALK_ACTION_CONTINUE); 3353 } 3354 3355 if ((snp = topo_mod_zalloc(mod, 3356 sizeof (ses_enum_node_t))) == NULL) 3357 goto error; 3358 3359 if ((sap = topo_mod_zalloc(mod, 3360 sizeof (ses_alt_node_t))) == NULL) { 3361 topo_mod_free(mod, snp, sizeof (ses_enum_node_t)); 3362 goto error; 3363 } 3364 3365 topo_mod_dprintf(mod, "%s: adding node (%llu, %llu)", 3366 sdp->sed_name, type, instance); 3367 snp->sen_node = np; 3368 snp->sen_type = type; 3369 snp->sen_instance = instance; 3370 snp->sen_target = sdp->sed_target; 3371 sap->san_node = np; 3372 topo_list_append(&snp->sen_alt_nodes, sap); 3373 topo_list_append(&cp->sec_nodes, snp); 3374 3375 if (type == SES_ET_DEVICE) 3376 cp->sec_hasdev = B_TRUE; 3377 } 3378 3379 return (SES_WALK_ACTION_CONTINUE); 3380 3381 error: 3382 sdp->sed_errno = -1; 3383 return (SES_WALK_ACTION_TERMINATE); 3384 } 3385 3386 static int 3387 ses_process_dir(const char *dirpath, ses_enum_data_t *sdp) 3388 { 3389 topo_mod_t *mod = sdp->sed_mod; 3390 DIR *dir; 3391 struct dirent *dp; 3392 char path[PATH_MAX]; 3393 ses_enum_target_t *stp; 3394 int err = -1; 3395 3396 /* 3397 * Open the SES target directory and iterate over any available 3398 * targets. 3399 */ 3400 if ((dir = opendir(dirpath)) == NULL) { 3401 /* 3402 * If the SES target directory does not exist, then return as if 3403 * there are no active targets. 3404 */ 3405 topo_mod_dprintf(mod, "failed to open ses " 3406 "directory '%s'", dirpath); 3407 return (0); 3408 } 3409 3410 while ((dp = readdir(dir)) != NULL) { 3411 if (strcmp(dp->d_name, ".") == 0 || 3412 strcmp(dp->d_name, "..") == 0) 3413 continue; 3414 3415 /* 3416 * Create a new target instance and take a snapshot. 3417 */ 3418 if ((stp = topo_mod_zalloc(mod, 3419 sizeof (ses_enum_target_t))) == NULL) 3420 goto error; 3421 3422 (void) pthread_mutex_init(&stp->set_lock, NULL); 3423 3424 (void) snprintf(path, sizeof (path), "%s/%s", dirpath, 3425 dp->d_name); 3426 3427 /* 3428 * We keep track of the SES device path and export it on a 3429 * per-node basis to allow higher level software to get to the 3430 * corresponding SES state. 3431 */ 3432 if ((stp->set_devpath = topo_mod_strdup(mod, path)) == NULL) { 3433 topo_mod_free(mod, stp, sizeof (ses_enum_target_t)); 3434 goto error; 3435 } 3436 3437 if ((stp->set_target = 3438 ses_open(LIBSES_VERSION, path)) == NULL) { 3439 topo_mod_dprintf(mod, "failed to open ses target " 3440 "'%s': %s", dp->d_name, ses_errmsg()); 3441 ses_sof_alloc(mod, stp->set_devpath); 3442 topo_mod_free(mod, stp, sizeof (ses_enum_target_t)); 3443 continue; 3444 } 3445 topo_mod_dprintf(mod, "open contract"); 3446 ses_ssl_alloc(mod, stp); 3447 ses_create_contract(mod, stp); 3448 3449 stp->set_refcount = 1; 3450 sdp->sed_target = stp; 3451 stp->set_snap = ses_snap_hold(stp->set_target); 3452 stp->set_snaptime = gethrtime(); 3453 3454 /* 3455 * Enumerate over all SES elements and merge them into the 3456 * correct ses_enum_chassis_t. 3457 */ 3458 sdp->sed_current = NULL; 3459 sdp->sed_errno = 0; 3460 sdp->sed_name = dp->d_name; 3461 (void) ses_walk(stp->set_snap, ses_enum_gather, sdp); 3462 3463 if (sdp->sed_errno != 0) 3464 goto error; 3465 } 3466 3467 err = 0; 3468 error: 3469 closedir(dir); 3470 return (err); 3471 } 3472 3473 static void 3474 ses_release(topo_mod_t *mod, tnode_t *tn) 3475 { 3476 ses_enum_target_t *stp; 3477 3478 if ((stp = topo_node_getspecific(tn)) != NULL) { 3479 topo_node_setspecific(tn, NULL); 3480 ses_target_free(mod, stp); 3481 } 3482 } 3483 3484 /*ARGSUSED*/ 3485 static int 3486 ses_enum(topo_mod_t *mod, tnode_t *rnode, const char *name, 3487 topo_instance_t min, topo_instance_t max, void *arg, void *notused) 3488 { 3489 ses_enum_chassis_t *cp; 3490 ses_enum_data_t *data; 3491 3492 /* 3493 * Check to make sure we're being invoked sensibly, and that we're not 3494 * being invoked as part of a post-processing step. 3495 */ 3496 if (strcmp(name, SES_ENCLOSURE) != 0 && strcmp(name, BAY) != 0) 3497 return (0); 3498 3499 /* 3500 * If this is the first time we've called our enumeration method, then 3501 * gather information about any available enclosures. 3502 */ 3503 if ((data = topo_mod_getspecific(mod)) == NULL) { 3504 ses_sof_freeall(mod); 3505 if ((data = topo_mod_zalloc(mod, sizeof (ses_enum_data_t))) == 3506 NULL) 3507 return (-1); 3508 3509 data->sed_mod = mod; 3510 topo_mod_setspecific(mod, data); 3511 3512 if (dev_list_gather(mod, &data->sed_devs) != 0) 3513 goto error; 3514 3515 /* 3516 * We search both the ses(7D) and sgen(7D) locations, so we are 3517 * independent of any particular driver class bindings. 3518 */ 3519 if (ses_process_dir("/dev/es", data) != 0 || 3520 ses_process_dir("/dev/scsi/ses", data) != 0) 3521 goto error; 3522 } 3523 3524 if (strcmp(name, SES_ENCLOSURE) == 0) { 3525 /* 3526 * This is a request to enumerate external enclosures. Go 3527 * through all the targets and create chassis nodes where 3528 * necessary. 3529 */ 3530 for (cp = topo_list_next(&data->sed_chassis); cp != NULL; 3531 cp = topo_list_next(cp)) { 3532 if (ses_create_chassis(data, rnode, cp) != 0) 3533 goto error; 3534 } 3535 } else { 3536 /* 3537 * This is a request to enumerate a specific bay underneath the 3538 * root chassis (for internal disks). 3539 */ 3540 if (ses_create_bays(data, rnode) != 0) 3541 goto error; 3542 } 3543 3544 /* 3545 * This is a bit of a kludge. In order to allow internal disks to be 3546 * enumerated and share snapshot-specific information with the external 3547 * enclosure enumeration, we rely on the fact that we will be invoked 3548 * for the 'ses-enclosure' node last. 3549 */ 3550 if (strcmp(name, SES_ENCLOSURE) == 0) { 3551 for (cp = topo_list_next(&data->sed_chassis); cp != NULL; 3552 cp = topo_list_next(cp)) 3553 ses_data_free(data, cp); 3554 ses_data_free(data, NULL); 3555 topo_mod_setspecific(mod, NULL); 3556 } 3557 return (0); 3558 3559 error: 3560 for (cp = topo_list_next(&data->sed_chassis); cp != NULL; 3561 cp = topo_list_next(cp)) 3562 ses_data_free(data, cp); 3563 ses_data_free(data, NULL); 3564 topo_mod_setspecific(mod, NULL); 3565 return (-1); 3566 } 3567 3568 static const topo_modops_t ses_ops = 3569 { ses_enum, ses_release }; 3570 3571 static topo_modinfo_t ses_info = 3572 { SES_ENCLOSURE, FM_FMRI_SCHEME_HC, SES_VERSION, &ses_ops }; 3573 3574 /*ARGSUSED*/ 3575 int 3576 _topo_init(topo_mod_t *mod, topo_version_t version) 3577 { 3578 int rval; 3579 3580 if (getenv("TOPOSESDEBUG") != NULL) 3581 topo_mod_setdebug(mod); 3582 3583 topo_mod_dprintf(mod, "initializing %s enumerator\n", 3584 SES_ENCLOSURE); 3585 3586 if ((rval = topo_mod_register(mod, &ses_info, TOPO_VERSION)) == 0) 3587 ses_thread_init(mod); 3588 3589 return (rval); 3590 } 3591 3592 void 3593 _topo_fini(topo_mod_t *mod) 3594 { 3595 ses_thread_fini(mod); 3596 ses_sof_freeall(mod); 3597 topo_mod_unregister(mod); 3598 } 3599