1940d71d2Seschrock /* 2940d71d2Seschrock * CDDL HEADER START 3940d71d2Seschrock * 4940d71d2Seschrock * The contents of this file are subject to the terms of the 5940d71d2Seschrock * Common Development and Distribution License (the "License"). 6940d71d2Seschrock * You may not use this file except in compliance with the License. 7940d71d2Seschrock * 8940d71d2Seschrock * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9940d71d2Seschrock * or http://www.opensolaris.org/os/licensing. 10940d71d2Seschrock * See the License for the specific language governing permissions 11940d71d2Seschrock * and limitations under the License. 12940d71d2Seschrock * 13940d71d2Seschrock * When distributing Covered Code, include this CDDL HEADER in each 14940d71d2Seschrock * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15940d71d2Seschrock * If applicable, add the following below this CDDL HEADER, with the 16940d71d2Seschrock * fields enclosed by brackets "[]" replaced with your own identifying 17940d71d2Seschrock * information: Portions Copyright [yyyy] [name of copyright owner] 18940d71d2Seschrock * 19940d71d2Seschrock * CDDL HEADER END 20940d71d2Seschrock */ 21940d71d2Seschrock 22940d71d2Seschrock /* 2344ed9dbbSStephen Hanson * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24940d71d2Seschrock */ 25940d71d2Seschrock 266efb64caSEric Schrock #include <alloca.h> 27940d71d2Seschrock #include <dirent.h> 28940d71d2Seschrock #include <devid.h> 29940d71d2Seschrock #include <fm/libdiskstatus.h> 30940d71d2Seschrock #include <inttypes.h> 31940d71d2Seschrock #include <pthread.h> 32940d71d2Seschrock #include <strings.h> 33ac88567aSHyon Kim #include <string.h> 34940d71d2Seschrock #include <unistd.h> 35940d71d2Seschrock #include <sys/dkio.h> 36940d71d2Seschrock #include <sys/fm/protocol.h> 3744ed9dbbSStephen Hanson #include <sys/libdevid.h> 38940d71d2Seschrock #include <sys/scsi/scsi_types.h> 39ac88567aSHyon Kim #include <sys/byteorder.h> 40f76de749SStephen Hanson #include <pthread.h> 41f76de749SStephen Hanson #include <signal.h> 42f76de749SStephen Hanson #include <fcntl.h> 43f76de749SStephen Hanson #include <sys/ctfs.h> 44f76de749SStephen Hanson #include <libcontract.h> 45f76de749SStephen Hanson #include <poll.h> 46f76de749SStephen Hanson #include <sys/contract/device.h> 47f76de749SStephen Hanson #include <libsysevent.h> 48f76de749SStephen Hanson #include <sys/sysevent/eventdefs.h> 49d91236feSeschrock 50940d71d2Seschrock #include "disk.h" 51d91236feSeschrock #include "ses.h" 52940d71d2Seschrock 53940d71d2Seschrock #define SES_VERSION 1 54940d71d2Seschrock 55ac88567aSHyon Kim #define SES_STARTING_SUBCHASSIS 256 /* valid subchassis IDs are uint8_t */ 56ac88567aSHyon Kim #define NO_SUBCHASSIS ((uint64_t)-1) 57ac88567aSHyon Kim 58525b85dbSEric Schrock static int ses_snap_freq = 250; /* in milliseconds */ 59940d71d2Seschrock 60d91236feSeschrock #define SES_STATUS_UNAVAIL(s) \ 610b32bb8bSEric Schrock ((s) == SES_ESC_UNSUPPORTED || (s) >= SES_ESC_NOT_INSTALLED) 62940d71d2Seschrock 63940d71d2Seschrock /* 64940d71d2Seschrock * Because multiple SES targets can be part of a single chassis, we construct 65940d71d2Seschrock * our own hierarchy that takes this into account. These SES targets may refer 66940d71d2Seschrock * to the same devices (multiple paths) or to different devices (managing 67940d71d2Seschrock * different portions of the space). We arrange things into a 68940d71d2Seschrock * ses_enum_enclosure_t, which contains a set of ses targets, and a list of all 69940d71d2Seschrock * nodes found so far. 70940d71d2Seschrock */ 710b32bb8bSEric Schrock typedef struct ses_alt_node { 720b32bb8bSEric Schrock topo_list_t san_link; 730b32bb8bSEric Schrock ses_node_t *san_node; 740b32bb8bSEric Schrock } ses_alt_node_t; 75940d71d2Seschrock 76940d71d2Seschrock typedef struct ses_enum_node { 77940d71d2Seschrock topo_list_t sen_link; 78940d71d2Seschrock ses_node_t *sen_node; 790b32bb8bSEric Schrock topo_list_t sen_alt_nodes; 80940d71d2Seschrock uint64_t sen_type; 81940d71d2Seschrock uint64_t sen_instance; 82940d71d2Seschrock ses_enum_target_t *sen_target; 83940d71d2Seschrock } ses_enum_node_t; 84940d71d2Seschrock 85940d71d2Seschrock typedef struct ses_enum_chassis { 86940d71d2Seschrock topo_list_t sec_link; 8753dbcc59SSundeep Panicker topo_list_t sec_subchassis; 88940d71d2Seschrock topo_list_t sec_nodes; 89940d71d2Seschrock topo_list_t sec_targets; 90940d71d2Seschrock const char *sec_csn; 91940d71d2Seschrock ses_node_t *sec_enclosure; 92940d71d2Seschrock ses_enum_target_t *sec_target; 93940d71d2Seschrock topo_instance_t sec_instance; 9453dbcc59SSundeep Panicker topo_instance_t sec_scinstance; 95ac88567aSHyon Kim topo_instance_t sec_maxinstance; 96940d71d2Seschrock boolean_t sec_hasdev; 97d91236feSeschrock boolean_t sec_internal; 98940d71d2Seschrock } ses_enum_chassis_t; 99940d71d2Seschrock 100940d71d2Seschrock typedef struct ses_enum_data { 101ac88567aSHyon Kim topo_list_t sed_devs; 102940d71d2Seschrock topo_list_t sed_chassis; 103940d71d2Seschrock ses_enum_chassis_t *sed_current; 104940d71d2Seschrock ses_enum_target_t *sed_target; 105940d71d2Seschrock int sed_errno; 106940d71d2Seschrock char *sed_name; 107940d71d2Seschrock topo_mod_t *sed_mod; 108940d71d2Seschrock topo_instance_t sed_instance; 109940d71d2Seschrock } ses_enum_data_t; 110940d71d2Seschrock 111ac88567aSHyon Kim typedef struct sas_connector_phy_data { 112ac88567aSHyon Kim uint64_t index; 113ac88567aSHyon Kim uint64_t phy_mask; 114ac88567aSHyon Kim } sas_connector_phy_data_t; 115ac88567aSHyon Kim 116ac88567aSHyon Kim typedef struct sas_connector_type { 117ac88567aSHyon Kim uint64_t type; 118ac88567aSHyon Kim char *name; 119ac88567aSHyon Kim } sas_connector_type_t; 120ac88567aSHyon Kim 121ac88567aSHyon Kim static const sas_connector_type_t sas_connector_type_list[] = { 122ac88567aSHyon Kim { 0x0, "Information unknown" }, 123ac88567aSHyon Kim { 0x1, "External SAS 4x receptacle (see SAS-2 and SFF-8470)" }, 124ac88567aSHyon Kim { 0x2, "Exteranl Mini SAS 4x receptacle (see SAS-2 and SFF-8088)" }, 125ac88567aSHyon Kim { 0xF, "Vendor-specific external connector" }, 126ac88567aSHyon Kim { 0x10, "Internal wide SAS 4i plug (see SAS-2 and SFF-8484)" }, 127ac88567aSHyon Kim { 0x11, 128ac88567aSHyon Kim "Internal wide Mini SAS 4i receptacle (see SAS-2 and SFF-8087)" }, 129ac88567aSHyon Kim { 0x20, "Internal SAS Drive receptacle (see SAS-2 and SFF-8482)" }, 130ac88567aSHyon Kim { 0x21, "Internal SATA host plug (see SAS-2 and SATA-2)" }, 131ac88567aSHyon Kim { 0x22, "Internal SAS Drive plug (see SAS-2 and SFF-8482)" }, 132ac88567aSHyon Kim { 0x23, "Internal SATA device plug (see SAS-2 and SATA-2)" }, 133ac88567aSHyon Kim { 0x2F, "Internal SAS virtual connector" }, 134ac88567aSHyon Kim { 0x3F, "Vendor-specific internal connector" }, 135ac88567aSHyon Kim { 0x70, "Other Vendor-specific connector" }, 136ac88567aSHyon Kim { 0x71, "Other Vendor-specific connector" }, 137ac88567aSHyon Kim { 0x72, "Other Vendor-specific connector" }, 138ac88567aSHyon Kim { 0x73, "Other Vendor-specific connector" }, 139ac88567aSHyon Kim { 0x74, "Other Vendor-specific connector" }, 140ac88567aSHyon Kim { 0x75, "Other Vendor-specific connector" }, 141ac88567aSHyon Kim { 0x76, "Other Vendor-specific connector" }, 142ac88567aSHyon Kim { 0x77, "Other Vendor-specific connector" }, 143ac88567aSHyon Kim { 0x78, "Other Vendor-specific connector" }, 144ac88567aSHyon Kim { 0x79, "Other Vendor-specific connector" }, 145ac88567aSHyon Kim { 0x7A, "Other Vendor-specific connector" }, 146ac88567aSHyon Kim { 0x7B, "Other Vendor-specific connector" }, 147ac88567aSHyon Kim { 0x7C, "Other Vendor-specific connector" }, 148ac88567aSHyon Kim { 0x7D, "Other Vendor-specific connector" }, 149ac88567aSHyon Kim { 0x7E, "Other Vendor-specific connector" }, 150ac88567aSHyon Kim { 0x7F, "Other Vendor-specific connector" }, 151ac88567aSHyon Kim { 0x80, "Not Defined" } 152ac88567aSHyon Kim }; 153ac88567aSHyon Kim 154ac88567aSHyon Kim #define SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED 0x80 155ac88567aSHyon Kim #define SAS_CONNECTOR_TYPE_NOT_DEFINED \ 156ac88567aSHyon Kim "Connector type not definedi by SES-2 standard" 157ac88567aSHyon Kim #define SAS_CONNECTOR_TYPE_RESERVED \ 158ac88567aSHyon Kim "Connector type reserved by SES-2 standard" 159ac88567aSHyon Kim 16053dbcc59SSundeep Panicker typedef enum { 16153dbcc59SSundeep Panicker SES_NEW_CHASSIS = 0x1, 16253dbcc59SSundeep Panicker SES_NEW_SUBCHASSIS = 0x2, 16353dbcc59SSundeep Panicker SES_DUP_CHASSIS = 0x4, 16453dbcc59SSundeep Panicker SES_DUP_SUBCHASSIS = 0x8 16553dbcc59SSundeep Panicker } ses_chassis_type_e; 16653dbcc59SSundeep Panicker 167b4879163SHyon Kim static const topo_pgroup_info_t storage_pgroup = { 168b4879163SHyon Kim TOPO_PGROUP_STORAGE, 169ac88567aSHyon Kim TOPO_STABILITY_PRIVATE, 170ac88567aSHyon Kim TOPO_STABILITY_PRIVATE, 171ac88567aSHyon Kim 1 172ac88567aSHyon Kim }; 173ac88567aSHyon Kim 174b4879163SHyon Kim static const topo_pgroup_info_t smp_pgroup = { 175b4879163SHyon Kim TOPO_PGROUP_SMP, 176ac88567aSHyon Kim TOPO_STABILITY_PRIVATE, 177ac88567aSHyon Kim TOPO_STABILITY_PRIVATE, 178ac88567aSHyon Kim 1 179ac88567aSHyon Kim }; 180ac88567aSHyon Kim 181940d71d2Seschrock static int ses_present(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *, 182940d71d2Seschrock nvlist_t **); 183940d71d2Seschrock static int ses_contains(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *, 184940d71d2Seschrock nvlist_t **); 185940d71d2Seschrock 186940d71d2Seschrock static const topo_method_t ses_component_methods[] = { 187940d71d2Seschrock { TOPO_METH_PRESENT, TOPO_METH_PRESENT_DESC, 188940d71d2Seschrock TOPO_METH_PRESENT_VERSION0, TOPO_STABILITY_INTERNAL, ses_present }, 189d91236feSeschrock { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0, 190d91236feSeschrock TOPO_STABILITY_INTERNAL, ses_node_enum_facility }, 19188045cffSRobert Johnston { TOPO_METH_SENSOR_FAILURE, TOPO_METH_SENSOR_FAILURE_DESC, 19288045cffSRobert Johnston TOPO_METH_SENSOR_FAILURE_VERSION, TOPO_STABILITY_INTERNAL, 19388045cffSRobert Johnston topo_method_sensor_failure }, 194d91236feSeschrock { NULL } 195d91236feSeschrock }; 196d91236feSeschrock 197d91236feSeschrock static const topo_method_t ses_bay_methods[] = { 198d91236feSeschrock { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0, 199d91236feSeschrock TOPO_STABILITY_INTERNAL, ses_node_enum_facility }, 200940d71d2Seschrock { NULL } 201940d71d2Seschrock }; 202940d71d2Seschrock 203940d71d2Seschrock static const topo_method_t ses_enclosure_methods[] = { 204940d71d2Seschrock { TOPO_METH_CONTAINS, TOPO_METH_CONTAINS_DESC, 205940d71d2Seschrock TOPO_METH_CONTAINS_VERSION, TOPO_STABILITY_INTERNAL, ses_contains }, 206d91236feSeschrock { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0, 207d91236feSeschrock TOPO_STABILITY_INTERNAL, ses_enc_enum_facility }, 208940d71d2Seschrock { NULL } 209940d71d2Seschrock }; 210940d71d2Seschrock 211f76de749SStephen Hanson /* 212f76de749SStephen Hanson * Functions for tracking ses devices which we were unable to open. We retry 213f76de749SStephen Hanson * these at regular intervals using ses_recheck_dir() and if we find that we 214f76de749SStephen Hanson * can now open any of them then we send a sysevent to indicate that a new topo 215f76de749SStephen Hanson * snapshot should be taken. 216f76de749SStephen Hanson */ 217f76de749SStephen Hanson typedef struct ses_open_fail_list { 218f76de749SStephen Hanson struct ses_open_fail_list *sof_next; 219f76de749SStephen Hanson char *sof_path; 220f76de749SStephen Hanson } ses_open_fail_list_t; 221f76de749SStephen Hanson 222f76de749SStephen Hanson static ses_open_fail_list_t *ses_sofh; 223f76de749SStephen Hanson static pthread_mutex_t ses_sofmt; 224*05b58617SStephen Hanson static void ses_ct_print(char *ptr); 225f76de749SStephen Hanson 226f76de749SStephen Hanson static void 227*05b58617SStephen Hanson ses_recheck_dir() 228f76de749SStephen Hanson { 229f76de749SStephen Hanson ses_target_t *target; 230f76de749SStephen Hanson sysevent_id_t eid; 231*05b58617SStephen Hanson char buf[80]; 232f76de749SStephen Hanson ses_open_fail_list_t *sof; 233f76de749SStephen Hanson 234f76de749SStephen Hanson /* 235f76de749SStephen Hanson * check list of "unable to open" devices 236f76de749SStephen Hanson */ 237f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sofmt); 238f76de749SStephen Hanson for (sof = ses_sofh; sof != NULL; sof = sof->sof_next) { 239f76de749SStephen Hanson /* 240f76de749SStephen Hanson * see if we can open it now 241f76de749SStephen Hanson */ 242f76de749SStephen Hanson if ((target = ses_open(LIBSES_VERSION, 243f76de749SStephen Hanson sof->sof_path)) == NULL) { 244*05b58617SStephen Hanson (void) snprintf(buf, sizeof (buf), 245f76de749SStephen Hanson "recheck_dir - still can't open %s", sof->sof_path); 246*05b58617SStephen Hanson ses_ct_print(buf); 247f76de749SStephen Hanson continue; 248f76de749SStephen Hanson } 249f76de749SStephen Hanson 250f76de749SStephen Hanson /* 251f76de749SStephen Hanson * ok - better force a new snapshot 252f76de749SStephen Hanson */ 253*05b58617SStephen Hanson (void) snprintf(buf, sizeof (buf), 254f76de749SStephen Hanson "recheck_dir - can now open %s", sof->sof_path); 255*05b58617SStephen Hanson ses_ct_print(buf); 256f76de749SStephen Hanson (void) sysevent_post_event(EC_PLATFORM, ESC_PLATFORM_SP_RESET, 257f76de749SStephen Hanson SUNW_VENDOR, "fmd", NULL, &eid); 258f76de749SStephen Hanson ses_close(target); 259f76de749SStephen Hanson break; 260f76de749SStephen Hanson } 261f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sofmt); 262f76de749SStephen Hanson } 263f76de749SStephen Hanson 264f76de749SStephen Hanson static void 265f76de749SStephen Hanson ses_sof_alloc(topo_mod_t *mod, char *path) 266f76de749SStephen Hanson { 267f76de749SStephen Hanson ses_open_fail_list_t *sof; 268f76de749SStephen Hanson 269f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sofmt); 270f76de749SStephen Hanson sof = topo_mod_zalloc(mod, sizeof (*sof)); 271f76de749SStephen Hanson topo_mod_dprintf(mod, "sof_alloc %s", path); 272f76de749SStephen Hanson sof->sof_path = path; 273f76de749SStephen Hanson sof->sof_next = ses_sofh; 274f76de749SStephen Hanson ses_sofh = sof; 275f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sofmt); 276f76de749SStephen Hanson } 277f76de749SStephen Hanson 278f76de749SStephen Hanson static void 279f76de749SStephen Hanson ses_sof_freeall(topo_mod_t *mod) 280f76de749SStephen Hanson { 281f76de749SStephen Hanson ses_open_fail_list_t *sof, *next_sof; 282f76de749SStephen Hanson 283f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sofmt); 284f76de749SStephen Hanson for (sof = ses_sofh; sof != NULL; sof = next_sof) { 285f76de749SStephen Hanson next_sof = sof->sof_next; 286f76de749SStephen Hanson topo_mod_dprintf(mod, "sof_freeall %s", sof->sof_path); 287f76de749SStephen Hanson topo_mod_strfree(mod, sof->sof_path); 288f76de749SStephen Hanson topo_mod_free(mod, sof, sizeof (*sof)); 289f76de749SStephen Hanson } 290f76de749SStephen Hanson ses_sofh = NULL; 291f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sofmt); 292f76de749SStephen Hanson } 293f76de749SStephen Hanson 294f76de749SStephen Hanson /* 295f76de749SStephen Hanson * functions for verifying that the ses_enum_target_t held in a device 296f76de749SStephen Hanson * contract's cookie field is still valid (it may have been freed by 297f76de749SStephen Hanson * ses_release()). 298f76de749SStephen Hanson */ 299f76de749SStephen Hanson typedef struct ses_stp_list { 300f76de749SStephen Hanson struct ses_stp_list *ssl_next; 301f76de749SStephen Hanson ses_enum_target_t *ssl_tgt; 302f76de749SStephen Hanson } ses_stp_list_t; 303f76de749SStephen Hanson 304f76de749SStephen Hanson static ses_stp_list_t *ses_sslh; 305f76de749SStephen Hanson static pthread_mutex_t ses_sslmt; 306f76de749SStephen Hanson 307f76de749SStephen Hanson static void 308f76de749SStephen Hanson ses_ssl_alloc(topo_mod_t *mod, ses_enum_target_t *stp) 309f76de749SStephen Hanson { 310f76de749SStephen Hanson ses_stp_list_t *ssl; 311f76de749SStephen Hanson 312f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sslmt); 313f76de749SStephen Hanson ssl = topo_mod_zalloc(mod, sizeof (*ssl)); 314f76de749SStephen Hanson topo_mod_dprintf(mod, "ssl_alloc %p", stp); 315f76de749SStephen Hanson ssl->ssl_tgt = stp; 316f76de749SStephen Hanson ssl->ssl_next = ses_sslh; 317f76de749SStephen Hanson ses_sslh = ssl; 318f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 319f76de749SStephen Hanson } 320f76de749SStephen Hanson 321f76de749SStephen Hanson static void 322f76de749SStephen Hanson ses_ssl_free(topo_mod_t *mod, ses_enum_target_t *stp) 323f76de749SStephen Hanson { 324f76de749SStephen Hanson ses_stp_list_t *ssl, *prev_ssl; 325f76de749SStephen Hanson 326f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sslmt); 327f76de749SStephen Hanson prev_ssl = NULL; 328f76de749SStephen Hanson for (ssl = ses_sslh; ssl != NULL; ssl = ssl->ssl_next) { 329f76de749SStephen Hanson if (ssl->ssl_tgt == stp) { 330f76de749SStephen Hanson topo_mod_dprintf(mod, "ssl_free %p", ssl->ssl_tgt); 331f76de749SStephen Hanson if (prev_ssl == NULL) 332f76de749SStephen Hanson ses_sslh = ssl->ssl_next; 333f76de749SStephen Hanson else 334f76de749SStephen Hanson prev_ssl->ssl_next = ssl->ssl_next; 335f76de749SStephen Hanson topo_mod_free(mod, ssl, sizeof (*ssl)); 336f76de749SStephen Hanson break; 337f76de749SStephen Hanson } 338f76de749SStephen Hanson prev_ssl = ssl; 339f76de749SStephen Hanson } 340f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 341f76de749SStephen Hanson } 342f76de749SStephen Hanson 343f76de749SStephen Hanson static int 344f76de749SStephen Hanson ses_ssl_valid(ses_enum_target_t *stp) 345f76de749SStephen Hanson { 346f76de749SStephen Hanson ses_stp_list_t *ssl; 347f76de749SStephen Hanson 348f76de749SStephen Hanson for (ssl = ses_sslh; ssl != NULL; ssl = ssl->ssl_next) 349f76de749SStephen Hanson if (ssl->ssl_tgt == stp) 350f76de749SStephen Hanson return (1); 351f76de749SStephen Hanson return (0); 352f76de749SStephen Hanson } 353f76de749SStephen Hanson 354f76de749SStephen Hanson /* 355f76de749SStephen Hanson * Functions for creating and destroying a background thread 356f76de749SStephen Hanson * (ses_contract_thread) used for detecting when ses devices have been 357f76de749SStephen Hanson * retired/unretired. 358f76de749SStephen Hanson */ 359f76de749SStephen Hanson static struct ses_thread_s { 360f76de749SStephen Hanson pthread_mutex_t mt; 361f76de749SStephen Hanson pthread_t tid; 362f76de749SStephen Hanson int thr_sig; 363f76de749SStephen Hanson int doexit; 364f76de749SStephen Hanson int count; 365f76de749SStephen Hanson } sesthread = { 366f76de749SStephen Hanson PTHREAD_MUTEX_INITIALIZER, 367f76de749SStephen Hanson 0, 368f76de749SStephen Hanson SIGTERM, 369f76de749SStephen Hanson 0, 370f76de749SStephen Hanson 0 371f76de749SStephen Hanson }; 372f76de749SStephen Hanson 373*05b58617SStephen Hanson typedef struct ses_mod_list { 374*05b58617SStephen Hanson struct ses_mod_list *smod_next; 375*05b58617SStephen Hanson topo_mod_t *smod_mod; 376*05b58617SStephen Hanson } ses_mod_list_t; 377*05b58617SStephen Hanson 378*05b58617SStephen Hanson static ses_mod_list_t *ses_smod; 379*05b58617SStephen Hanson 380*05b58617SStephen Hanson static void 381*05b58617SStephen Hanson ses_ct_print(char *ptr) 382*05b58617SStephen Hanson { 383*05b58617SStephen Hanson (void) pthread_mutex_lock(&sesthread.mt); 384*05b58617SStephen Hanson if (ses_smod->smod_mod) 385*05b58617SStephen Hanson topo_mod_dprintf(ses_smod->smod_mod, ptr); 386*05b58617SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 387*05b58617SStephen Hanson } 388*05b58617SStephen Hanson 389*05b58617SStephen Hanson /*ARGSUSED*/ 390f76de749SStephen Hanson static void * 391f76de749SStephen Hanson ses_contract_thread(void *arg) 392f76de749SStephen Hanson { 393f76de749SStephen Hanson int efd, ctlfd, statfd; 394f76de749SStephen Hanson ct_evthdl_t ev; 395f76de749SStephen Hanson ctevid_t evid; 396f76de749SStephen Hanson uint_t event; 397f76de749SStephen Hanson char path[PATH_MAX]; 398*05b58617SStephen Hanson char buf[80]; 399f76de749SStephen Hanson ses_enum_target_t *stp; 400f76de749SStephen Hanson ct_stathdl_t stathdl; 401f76de749SStephen Hanson ctid_t ctid; 402f76de749SStephen Hanson struct pollfd fds; 403f76de749SStephen Hanson int pollret; 404f76de749SStephen Hanson 405*05b58617SStephen Hanson ses_ct_print("start contract event thread"); 406f76de749SStephen Hanson efd = open64(CTFS_ROOT "/device/pbundle", O_RDONLY); 407f76de749SStephen Hanson fds.fd = efd; 408f76de749SStephen Hanson fds.events = POLLIN; 409f76de749SStephen Hanson fds.revents = 0; 410f76de749SStephen Hanson for (;;) { 411f76de749SStephen Hanson /* check if we've been asked to exit */ 412f76de749SStephen Hanson (void) pthread_mutex_lock(&sesthread.mt); 413f76de749SStephen Hanson if (sesthread.doexit) { 414f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 415f76de749SStephen Hanson break; 416f76de749SStephen Hanson } 417f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 418f76de749SStephen Hanson 419f76de749SStephen Hanson /* poll until an event arrives */ 420f76de749SStephen Hanson if ((pollret = poll(&fds, 1, 10000)) <= 0) { 421f76de749SStephen Hanson if (pollret == 0) 422*05b58617SStephen Hanson ses_recheck_dir(); 423f76de749SStephen Hanson continue; 424f76de749SStephen Hanson } 425f76de749SStephen Hanson 426f76de749SStephen Hanson /* read the event */ 427f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sslmt); 428*05b58617SStephen Hanson ses_ct_print("read contract event"); 429f76de749SStephen Hanson if (ct_event_read(efd, &ev) != 0) { 430f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 431f76de749SStephen Hanson continue; 432f76de749SStephen Hanson } 433f76de749SStephen Hanson 434f76de749SStephen Hanson /* see if it is an event we are expecting */ 435f76de749SStephen Hanson ctid = ct_event_get_ctid(ev); 436*05b58617SStephen Hanson (void) snprintf(buf, sizeof (buf), 437*05b58617SStephen Hanson "got contract event ctid=%d", ctid); 438*05b58617SStephen Hanson ses_ct_print(buf); 439f76de749SStephen Hanson event = ct_event_get_type(ev); 440f76de749SStephen Hanson if (event != CT_DEV_EV_OFFLINE && event != CT_EV_NEGEND) { 441*05b58617SStephen Hanson snprintf(buf, sizeof (buf), 442*05b58617SStephen Hanson "bad contract event %x", event); 443*05b58617SStephen Hanson ses_ct_print(buf); 444f76de749SStephen Hanson ct_event_free(ev); 445f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 446f76de749SStephen Hanson continue; 447f76de749SStephen Hanson } 448f76de749SStephen Hanson 449f76de749SStephen Hanson /* find target pointer saved in cookie */ 450f76de749SStephen Hanson evid = ct_event_get_evid(ev); 451f76de749SStephen Hanson (void) snprintf(path, PATH_MAX, CTFS_ROOT "/device/%ld/status", 452f76de749SStephen Hanson ctid); 453f76de749SStephen Hanson statfd = open64(path, O_RDONLY); 454f76de749SStephen Hanson ct_status_read(statfd, CTD_COMMON, &stathdl); 455f76de749SStephen Hanson stp = (ses_enum_target_t *)(uintptr_t) 456f76de749SStephen Hanson ct_status_get_cookie(stathdl); 457f76de749SStephen Hanson ct_status_free(stathdl); 458f76de749SStephen Hanson close(statfd); 459f76de749SStephen Hanson 460f76de749SStephen Hanson /* check if target pointer is still valid */ 461f76de749SStephen Hanson if (ses_ssl_valid(stp) == 0) { 462*05b58617SStephen Hanson snprintf(buf, sizeof (buf), 463*05b58617SStephen Hanson "contract already abandoned %x", event); 464*05b58617SStephen Hanson ses_ct_print(buf); 465f76de749SStephen Hanson (void) snprintf(path, PATH_MAX, 466f76de749SStephen Hanson CTFS_ROOT "/device/%ld/ctl", ctid); 467f76de749SStephen Hanson ctlfd = open64(path, O_WRONLY); 468f76de749SStephen Hanson if (event != CT_EV_NEGEND) 469f76de749SStephen Hanson ct_ctl_ack(ctlfd, evid); 470f76de749SStephen Hanson else 471f76de749SStephen Hanson ct_ctl_abandon(ctlfd); 472f76de749SStephen Hanson close(ctlfd); 473f76de749SStephen Hanson ct_event_free(ev); 474f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 475f76de749SStephen Hanson continue; 476f76de749SStephen Hanson } 477f76de749SStephen Hanson 478f76de749SStephen Hanson /* find control device for ack/abandon */ 479f76de749SStephen Hanson (void) pthread_mutex_lock(&stp->set_lock); 480f76de749SStephen Hanson (void) snprintf(path, PATH_MAX, CTFS_ROOT "/device/%ld/ctl", 481f76de749SStephen Hanson ctid); 482f76de749SStephen Hanson ctlfd = open64(path, O_WRONLY); 483f76de749SStephen Hanson if (event != CT_EV_NEGEND) { 484f76de749SStephen Hanson /* if this is an offline event, do the offline */ 485*05b58617SStephen Hanson ses_ct_print("got contract offline event"); 486f76de749SStephen Hanson if (stp->set_target) { 487*05b58617SStephen Hanson ses_ct_print("contract thread rele"); 488f76de749SStephen Hanson ses_snap_rele(stp->set_snap); 489f76de749SStephen Hanson ses_close(stp->set_target); 490f76de749SStephen Hanson stp->set_target = NULL; 491f76de749SStephen Hanson } 492f76de749SStephen Hanson ct_ctl_ack(ctlfd, evid); 493f76de749SStephen Hanson } else { 494f76de749SStephen Hanson /* if this is the negend, then abandon the contract */ 495*05b58617SStephen Hanson ses_ct_print("got contract negend"); 496f76de749SStephen Hanson if (stp->set_ctid) { 497*05b58617SStephen Hanson snprintf(buf, sizeof (buf), 498*05b58617SStephen Hanson "abandon old contract %d", stp->set_ctid); 499*05b58617SStephen Hanson ses_ct_print(buf); 500f76de749SStephen Hanson stp->set_ctid = NULL; 501f76de749SStephen Hanson } 502f76de749SStephen Hanson ct_ctl_abandon(ctlfd); 503f76de749SStephen Hanson } 504f76de749SStephen Hanson close(ctlfd); 505f76de749SStephen Hanson (void) pthread_mutex_unlock(&stp->set_lock); 506f76de749SStephen Hanson ct_event_free(ev); 507f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 508f76de749SStephen Hanson } 509f76de749SStephen Hanson close(efd); 510f76de749SStephen Hanson return (NULL); 511f76de749SStephen Hanson } 512f76de749SStephen Hanson 513f76de749SStephen Hanson int 514f76de749SStephen Hanson find_thr_sig(void) 515f76de749SStephen Hanson { 516f76de749SStephen Hanson int i; 517f76de749SStephen Hanson sigset_t oset, rset; 518f76de749SStephen Hanson int sig[] = {SIGTERM, SIGUSR1, SIGUSR2}; 519f76de749SStephen Hanson int sig_sz = sizeof (sig) / sizeof (int); 520f76de749SStephen Hanson int rc = SIGTERM; 521f76de749SStephen Hanson 522f76de749SStephen Hanson /* prefered set of signals that are likely used to terminate threads */ 523f76de749SStephen Hanson (void) sigemptyset(&oset); 524f76de749SStephen Hanson (void) pthread_sigmask(SIG_SETMASK, NULL, &oset); 525f76de749SStephen Hanson for (i = 0; i < sig_sz; i++) { 526f76de749SStephen Hanson if (sigismember(&oset, sig[i]) == 0) { 527f76de749SStephen Hanson return (sig[i]); 528f76de749SStephen Hanson } 529f76de749SStephen Hanson } 530f76de749SStephen Hanson 531f76de749SStephen Hanson /* reserved set of signals that are not allowed to terminate thread */ 532f76de749SStephen Hanson (void) sigemptyset(&rset); 533f76de749SStephen Hanson (void) sigaddset(&rset, SIGABRT); 534f76de749SStephen Hanson (void) sigaddset(&rset, SIGKILL); 535f76de749SStephen Hanson (void) sigaddset(&rset, SIGSTOP); 536f76de749SStephen Hanson (void) sigaddset(&rset, SIGCANCEL); 537f76de749SStephen Hanson 538f76de749SStephen Hanson /* Find signal that is not masked and not in the reserved list. */ 539f76de749SStephen Hanson for (i = 1; i < MAXSIG; i++) { 540f76de749SStephen Hanson if (sigismember(&rset, i) == 1) { 541f76de749SStephen Hanson continue; 542f76de749SStephen Hanson } 543f76de749SStephen Hanson if (sigismember(&oset, i) == 0) { 544f76de749SStephen Hanson return (i); 545f76de749SStephen Hanson } 546f76de749SStephen Hanson } 547f76de749SStephen Hanson 548f76de749SStephen Hanson return (rc); 549f76de749SStephen Hanson } 550f76de749SStephen Hanson 551f76de749SStephen Hanson /*ARGSUSED*/ 552f76de749SStephen Hanson static void 553f76de749SStephen Hanson ses_handler(int sig) 554f76de749SStephen Hanson { 555f76de749SStephen Hanson } 556f76de749SStephen Hanson 557f76de749SStephen Hanson static void 558*05b58617SStephen Hanson ses_thread_init(topo_mod_t *mod) 559f76de749SStephen Hanson { 560f76de749SStephen Hanson pthread_attr_t *attr = NULL; 561f76de749SStephen Hanson struct sigaction act; 562*05b58617SStephen Hanson ses_mod_list_t *smod; 563f76de749SStephen Hanson 564f76de749SStephen Hanson (void) pthread_mutex_lock(&sesthread.mt); 565f76de749SStephen Hanson sesthread.count++; 566*05b58617SStephen Hanson smod = topo_mod_zalloc(mod, sizeof (*smod)); 567*05b58617SStephen Hanson smod->smod_mod = mod; 568*05b58617SStephen Hanson smod->smod_next = ses_smod; 569*05b58617SStephen Hanson ses_smod = smod; 570f76de749SStephen Hanson if (sesthread.tid == 0) { 571f76de749SStephen Hanson /* find a suitable signal to use for killing the thread below */ 572f76de749SStephen Hanson sesthread.thr_sig = find_thr_sig(); 573f76de749SStephen Hanson 574f76de749SStephen Hanson /* if don't have a handler for this signal, create one */ 575f76de749SStephen Hanson (void) sigaction(sesthread.thr_sig, NULL, &act); 576f76de749SStephen Hanson if (act.sa_handler == SIG_DFL || act.sa_handler == SIG_IGN) 577f76de749SStephen Hanson act.sa_handler = ses_handler; 578f76de749SStephen Hanson (void) sigaction(sesthread.thr_sig, &act, NULL); 579f76de749SStephen Hanson 580f76de749SStephen Hanson /* create a thread to listen for offline events */ 581f76de749SStephen Hanson (void) pthread_create(&sesthread.tid, 582*05b58617SStephen Hanson attr, ses_contract_thread, NULL); 583f76de749SStephen Hanson } 584f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 585f76de749SStephen Hanson } 586f76de749SStephen Hanson 587f76de749SStephen Hanson static void 588*05b58617SStephen Hanson ses_thread_fini(topo_mod_t *mod) 589f76de749SStephen Hanson { 590*05b58617SStephen Hanson ses_mod_list_t *smod, *prev_smod; 591*05b58617SStephen Hanson 592f76de749SStephen Hanson (void) pthread_mutex_lock(&sesthread.mt); 593*05b58617SStephen Hanson prev_smod = NULL; 594*05b58617SStephen Hanson for (smod = ses_smod; smod != NULL; smod = smod->smod_next) { 595*05b58617SStephen Hanson if (smod->smod_mod == mod) { 596*05b58617SStephen Hanson if (prev_smod == NULL) 597*05b58617SStephen Hanson ses_smod = smod->smod_next; 598*05b58617SStephen Hanson else 599*05b58617SStephen Hanson prev_smod->smod_next = smod->smod_next; 600*05b58617SStephen Hanson topo_mod_free(mod, smod, sizeof (*smod)); 601*05b58617SStephen Hanson break; 602*05b58617SStephen Hanson } 603*05b58617SStephen Hanson prev_smod = smod; 604*05b58617SStephen Hanson } 605f76de749SStephen Hanson if (--sesthread.count > 0) { 606f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 607f76de749SStephen Hanson return; 608f76de749SStephen Hanson } 609f76de749SStephen Hanson sesthread.doexit = 1; 610f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 611f76de749SStephen Hanson (void) pthread_kill(sesthread.tid, sesthread.thr_sig); 612f76de749SStephen Hanson (void) pthread_join(sesthread.tid, NULL); 613f76de749SStephen Hanson sesthread.tid = 0; 614f76de749SStephen Hanson } 615f76de749SStephen Hanson 616f76de749SStephen Hanson static void 617f76de749SStephen Hanson ses_create_contract(topo_mod_t *mod, ses_enum_target_t *stp) 618f76de749SStephen Hanson { 619f76de749SStephen Hanson int tfd, len, rval; 620f76de749SStephen Hanson char link_path[PATH_MAX]; 621f76de749SStephen Hanson 622f76de749SStephen Hanson stp->set_ctid = NULL; 623f76de749SStephen Hanson 624f76de749SStephen Hanson /* convert "/dev" path into "/devices" path */ 625f76de749SStephen Hanson if ((len = readlink(stp->set_devpath, link_path, PATH_MAX)) < 0) { 626f76de749SStephen Hanson topo_mod_dprintf(mod, "readlink failed"); 627f76de749SStephen Hanson return; 628f76de749SStephen Hanson } 629f76de749SStephen Hanson link_path[len] = '\0'; 630f76de749SStephen Hanson 631f76de749SStephen Hanson /* set up template to create new contract */ 632f76de749SStephen Hanson tfd = open64(CTFS_ROOT "/device/template", O_RDWR); 633f76de749SStephen Hanson ct_tmpl_set_critical(tfd, CT_DEV_EV_OFFLINE); 634f76de749SStephen Hanson ct_tmpl_set_cookie(tfd, (uint64_t)(uintptr_t)stp); 635f76de749SStephen Hanson 636f76de749SStephen Hanson /* strip "../../devices" off the front and create the contract */ 637f76de749SStephen Hanson if ((rval = ct_dev_tmpl_set_minor(tfd, &link_path[13])) != 0) 638f76de749SStephen Hanson topo_mod_dprintf(mod, "failed to set minor %s rval = %d", 639f76de749SStephen Hanson &link_path[13], rval); 640f76de749SStephen Hanson else if ((rval = ct_tmpl_create(tfd, &stp->set_ctid)) != 0) 641f76de749SStephen Hanson topo_mod_dprintf(mod, "failed to create ctid rval = %d", rval); 642f76de749SStephen Hanson else 643f76de749SStephen Hanson topo_mod_dprintf(mod, "created ctid=%d", stp->set_ctid); 644f76de749SStephen Hanson close(tfd); 645f76de749SStephen Hanson } 646f76de749SStephen Hanson 647940d71d2Seschrock static void 648940d71d2Seschrock ses_target_free(topo_mod_t *mod, ses_enum_target_t *stp) 649940d71d2Seschrock { 650940d71d2Seschrock if (--stp->set_refcount == 0) { 651f76de749SStephen Hanson /* check if already closed due to contract offline request */ 652f76de749SStephen Hanson (void) pthread_mutex_lock(&stp->set_lock); 653f76de749SStephen Hanson if (stp->set_target) { 654f76de749SStephen Hanson ses_snap_rele(stp->set_snap); 655f76de749SStephen Hanson ses_close(stp->set_target); 656f76de749SStephen Hanson stp->set_target = NULL; 657f76de749SStephen Hanson } 658f76de749SStephen Hanson if (stp->set_ctid) { 659f76de749SStephen Hanson int ctlfd; 660f76de749SStephen Hanson char path[PATH_MAX]; 661f76de749SStephen Hanson 662f76de749SStephen Hanson topo_mod_dprintf(mod, "abandon old contract %d", 663f76de749SStephen Hanson stp->set_ctid); 664f76de749SStephen Hanson (void) snprintf(path, PATH_MAX, 665f76de749SStephen Hanson CTFS_ROOT "/device/%ld/ctl", stp->set_ctid); 666f76de749SStephen Hanson ctlfd = open64(path, O_WRONLY); 667f76de749SStephen Hanson ct_ctl_abandon(ctlfd); 668f76de749SStephen Hanson close(ctlfd); 669f76de749SStephen Hanson stp->set_ctid = NULL; 670f76de749SStephen Hanson } 671f76de749SStephen Hanson (void) pthread_mutex_unlock(&stp->set_lock); 672f76de749SStephen Hanson ses_ssl_free(mod, stp); 673940d71d2Seschrock topo_mod_strfree(mod, stp->set_devpath); 674940d71d2Seschrock topo_mod_free(mod, stp, sizeof (ses_enum_target_t)); 675940d71d2Seschrock } 676940d71d2Seschrock } 677940d71d2Seschrock 678940d71d2Seschrock static void 67953dbcc59SSundeep Panicker ses_data_free(ses_enum_data_t *sdp, ses_enum_chassis_t *pcp) 680940d71d2Seschrock { 681940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 682940d71d2Seschrock ses_enum_chassis_t *cp; 683940d71d2Seschrock ses_enum_node_t *np; 684940d71d2Seschrock ses_enum_target_t *tp; 6850b32bb8bSEric Schrock ses_alt_node_t *ap; 68653dbcc59SSundeep Panicker topo_list_t *cpl; 68753dbcc59SSundeep Panicker 68853dbcc59SSundeep Panicker 68953dbcc59SSundeep Panicker if (pcp != NULL) 69053dbcc59SSundeep Panicker cpl = &pcp->sec_subchassis; 69153dbcc59SSundeep Panicker else 69253dbcc59SSundeep Panicker cpl = &sdp->sed_chassis; 693940d71d2Seschrock 69453dbcc59SSundeep Panicker while ((cp = topo_list_next(cpl)) != NULL) { 69553dbcc59SSundeep Panicker topo_list_delete(cpl, cp); 696940d71d2Seschrock 697940d71d2Seschrock while ((np = topo_list_next(&cp->sec_nodes)) != NULL) { 6980b32bb8bSEric Schrock while ((ap = topo_list_next(&np->sen_alt_nodes)) != 6990b32bb8bSEric Schrock NULL) { 7000b32bb8bSEric Schrock topo_list_delete(&np->sen_alt_nodes, ap); 7010b32bb8bSEric Schrock topo_mod_free(mod, ap, sizeof (ses_alt_node_t)); 7020b32bb8bSEric Schrock } 703940d71d2Seschrock topo_list_delete(&cp->sec_nodes, np); 704940d71d2Seschrock topo_mod_free(mod, np, sizeof (ses_enum_node_t)); 705940d71d2Seschrock } 706940d71d2Seschrock 707940d71d2Seschrock while ((tp = topo_list_next(&cp->sec_targets)) != NULL) { 708940d71d2Seschrock topo_list_delete(&cp->sec_targets, tp); 709940d71d2Seschrock ses_target_free(mod, tp); 710940d71d2Seschrock } 711940d71d2Seschrock 712940d71d2Seschrock topo_mod_free(mod, cp, sizeof (ses_enum_chassis_t)); 713940d71d2Seschrock } 714940d71d2Seschrock 71553dbcc59SSundeep Panicker if (pcp == NULL) { 716ac88567aSHyon Kim dev_list_free(mod, &sdp->sed_devs); 71753dbcc59SSundeep Panicker topo_mod_free(mod, sdp, sizeof (ses_enum_data_t)); 71853dbcc59SSundeep Panicker } 719940d71d2Seschrock } 720940d71d2Seschrock 721940d71d2Seschrock /* 722940d71d2Seschrock * For enclosure nodes, we have a special contains method. By default, the hc 723940d71d2Seschrock * walker will compare the node name and instance number to determine if an 724940d71d2Seschrock * FMRI matches. For enclosures where the enumeration order is impossible to 725940d71d2Seschrock * predict, we instead use the chassis-id as a unique identifier, and ignore 726940d71d2Seschrock * the instance number. 727940d71d2Seschrock */ 728940d71d2Seschrock static int 729940d71d2Seschrock fmri_contains(topo_mod_t *mod, nvlist_t *nv1, nvlist_t *nv2) 730940d71d2Seschrock { 731940d71d2Seschrock uint8_t v1, v2; 732940d71d2Seschrock nvlist_t **hcp1, **hcp2; 733940d71d2Seschrock int err, i; 734940d71d2Seschrock uint_t nhcp1, nhcp2; 735940d71d2Seschrock nvlist_t *a1, *a2; 736940d71d2Seschrock char *c1, *c2; 737940d71d2Seschrock int mindepth; 738940d71d2Seschrock 739940d71d2Seschrock if (nvlist_lookup_uint8(nv1, FM_VERSION, &v1) != 0 || 740940d71d2Seschrock nvlist_lookup_uint8(nv2, FM_VERSION, &v2) != 0 || 741940d71d2Seschrock v1 > FM_HC_SCHEME_VERSION || v2 > FM_HC_SCHEME_VERSION) 742940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_VERSION)); 743940d71d2Seschrock 744940d71d2Seschrock err = nvlist_lookup_nvlist_array(nv1, FM_FMRI_HC_LIST, &hcp1, &nhcp1); 745940d71d2Seschrock err |= nvlist_lookup_nvlist_array(nv2, FM_FMRI_HC_LIST, &hcp2, &nhcp2); 746940d71d2Seschrock if (err != 0) 747940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 748940d71d2Seschrock 749940d71d2Seschrock /* 750940d71d2Seschrock * If the chassis-id doesn't match, then these FMRIs are not 751940d71d2Seschrock * equivalent. If one of the FMRIs doesn't have a chassis ID, then we 752940d71d2Seschrock * have no choice but to fall back to the instance ID. 753940d71d2Seschrock */ 754940d71d2Seschrock if (nvlist_lookup_nvlist(nv1, FM_FMRI_AUTHORITY, &a1) == 0 && 755940d71d2Seschrock nvlist_lookup_nvlist(nv2, FM_FMRI_AUTHORITY, &a2) == 0 && 756940d71d2Seschrock nvlist_lookup_string(a1, FM_FMRI_AUTH_CHASSIS, &c1) == 0 && 757940d71d2Seschrock nvlist_lookup_string(a2, FM_FMRI_AUTH_CHASSIS, &c2) == 0) { 758940d71d2Seschrock if (strcmp(c1, c2) != 0) 759940d71d2Seschrock return (0); 760940d71d2Seschrock 761940d71d2Seschrock mindepth = 1; 762940d71d2Seschrock } else { 763940d71d2Seschrock mindepth = 0; 764940d71d2Seschrock } 765940d71d2Seschrock 766940d71d2Seschrock if (nhcp2 < nhcp1) 767940d71d2Seschrock return (0); 768940d71d2Seschrock 769940d71d2Seschrock for (i = 0; i < nhcp1; i++) { 770940d71d2Seschrock char *nm1 = NULL; 771940d71d2Seschrock char *nm2 = NULL; 772940d71d2Seschrock char *id1 = NULL; 773940d71d2Seschrock char *id2 = NULL; 774940d71d2Seschrock 775940d71d2Seschrock (void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_NAME, &nm1); 776940d71d2Seschrock (void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_NAME, &nm2); 777940d71d2Seschrock (void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_ID, &id1); 778940d71d2Seschrock (void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_ID, &id2); 779940d71d2Seschrock if (nm1 == NULL || nm2 == NULL || id1 == NULL || id2 == NULL) 780940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 781940d71d2Seschrock 782940d71d2Seschrock if (strcmp(nm1, nm2) == 0 && 783940d71d2Seschrock (i < mindepth || strcmp(id1, id2) == 0)) 784940d71d2Seschrock continue; 785940d71d2Seschrock 786940d71d2Seschrock return (0); 787940d71d2Seschrock } 788940d71d2Seschrock 789940d71d2Seschrock return (1); 790940d71d2Seschrock } 791940d71d2Seschrock 792940d71d2Seschrock /*ARGSUSED*/ 793940d71d2Seschrock static int 794940d71d2Seschrock ses_contains(topo_mod_t *mod, tnode_t *tn, topo_version_t version, 795940d71d2Seschrock nvlist_t *in, nvlist_t **out) 796940d71d2Seschrock { 797940d71d2Seschrock int ret; 798940d71d2Seschrock nvlist_t *nv1, *nv2; 799940d71d2Seschrock 800940d71d2Seschrock if (version > TOPO_METH_CONTAINS_VERSION) 801940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_VER_NEW)); 802940d71d2Seschrock 803940d71d2Seschrock if (nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_FMRI, &nv1) != 0 || 804940d71d2Seschrock nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_SUBFMRI, &nv2) != 0) 805940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL)); 806940d71d2Seschrock 807940d71d2Seschrock ret = fmri_contains(mod, nv1, nv2); 808940d71d2Seschrock if (ret < 0) 809940d71d2Seschrock return (-1); 810940d71d2Seschrock 811940d71d2Seschrock if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) == 0) { 81273e32a37SRobert Johnston if (nvlist_add_uint32(*out, TOPO_METH_CONTAINS_RET, 813940d71d2Seschrock ret) == 0) 814940d71d2Seschrock return (0); 815940d71d2Seschrock else 816940d71d2Seschrock nvlist_free(*out); 817940d71d2Seschrock } 818940d71d2Seschrock 819940d71d2Seschrock return (-1); 820940d71d2Seschrock 821940d71d2Seschrock } 822940d71d2Seschrock 823940d71d2Seschrock /* 824d91236feSeschrock * Return a current instance of the node. This is somewhat complicated because 825d91236feSeschrock * we need to take a new snapshot in order to get the new data, but we don't 826940d71d2Seschrock * want to be constantly taking SES snapshots if the consumer is going to do a 827940d71d2Seschrock * series of queries. So we adopt the strategy of assuming that the SES state 828d91236feSeschrock * is not going to be rapidly changing, and limit our snapshot frequency to 829d91236feSeschrock * some defined bounds. 830940d71d2Seschrock */ 831d91236feSeschrock ses_node_t * 8320b32bb8bSEric Schrock ses_node_lock(topo_mod_t *mod, tnode_t *tn) 833940d71d2Seschrock { 834940d71d2Seschrock ses_enum_target_t *tp = topo_node_getspecific(tn); 835525b85dbSEric Schrock hrtime_t now; 836940d71d2Seschrock ses_snap_t *snap; 837940d71d2Seschrock int err; 838d91236feSeschrock uint64_t nodeid; 839940d71d2Seschrock ses_node_t *np; 840940d71d2Seschrock 841d91236feSeschrock if (tp == NULL) { 842d91236feSeschrock (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 843d91236feSeschrock return (NULL); 844d91236feSeschrock } 845940d71d2Seschrock 8460b32bb8bSEric Schrock (void) pthread_mutex_lock(&tp->set_lock); 8470b32bb8bSEric Schrock 848940d71d2Seschrock /* 849940d71d2Seschrock * Determine if we need to take a new snapshot. 850940d71d2Seschrock */ 851525b85dbSEric Schrock now = gethrtime(); 852940d71d2Seschrock 853f76de749SStephen Hanson if (tp->set_target == NULL) { 854f76de749SStephen Hanson /* 855f76de749SStephen Hanson * We may have closed the device but not yet abandoned the 856f76de749SStephen Hanson * contract (ie we've had the offline event but not yet the 857f76de749SStephen Hanson * negend). If so, just return failure. 858f76de749SStephen Hanson */ 859f76de749SStephen Hanson if (tp->set_ctid != NULL) { 860f76de749SStephen Hanson (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 861f76de749SStephen Hanson (void) pthread_mutex_unlock(&tp->set_lock); 862f76de749SStephen Hanson return (NULL); 863f76de749SStephen Hanson } 864f76de749SStephen Hanson 865f76de749SStephen Hanson /* 866f76de749SStephen Hanson * The device has been closed due to a contract offline 867f76de749SStephen Hanson * request, then we need to reopen it and create a new contract. 868f76de749SStephen Hanson */ 869f76de749SStephen Hanson if ((tp->set_target = 870f76de749SStephen Hanson ses_open(LIBSES_VERSION, tp->set_devpath)) == NULL) { 871f76de749SStephen Hanson sysevent_id_t eid; 872f76de749SStephen Hanson 873f76de749SStephen Hanson (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 874f76de749SStephen Hanson (void) pthread_mutex_unlock(&tp->set_lock); 875f76de749SStephen Hanson topo_mod_dprintf(mod, "recheck_dir - " 876f76de749SStephen Hanson "can no longer open %s", tp->set_devpath); 877f76de749SStephen Hanson (void) sysevent_post_event(EC_PLATFORM, 878f76de749SStephen Hanson ESC_PLATFORM_SP_RESET, SUNW_VENDOR, "fmd", NULL, 879f76de749SStephen Hanson &eid); 880f76de749SStephen Hanson return (NULL); 881f76de749SStephen Hanson } 882f76de749SStephen Hanson topo_mod_dprintf(mod, "reopen contract"); 883f76de749SStephen Hanson ses_create_contract(mod, tp); 884f76de749SStephen Hanson tp->set_snap = ses_snap_hold(tp->set_target); 885f76de749SStephen Hanson tp->set_snaptime = gethrtime(); 886f76de749SStephen Hanson } else if (now - tp->set_snaptime > (ses_snap_freq * 1000 * 1000) && 887940d71d2Seschrock (snap = ses_snap_new(tp->set_target)) != NULL) { 888940d71d2Seschrock if (ses_snap_generation(snap) != 889940d71d2Seschrock ses_snap_generation(tp->set_snap)) { 890940d71d2Seschrock /* 891940d71d2Seschrock * If we find ourselves in this situation, we're in 892940d71d2Seschrock * trouble. The generation count has changed, which 893940d71d2Seschrock * indicates that our current topology is out of date. 894940d71d2Seschrock * But we need to consult the new topology in order to 895940d71d2Seschrock * determine presence at this moment in time. We can't 896940d71d2Seschrock * go back and change the topo snapshot in situ, so 897d91236feSeschrock * we'll just have to fail the call in this unlikely 898d91236feSeschrock * scenario. 899940d71d2Seschrock */ 900940d71d2Seschrock ses_snap_rele(snap); 901d91236feSeschrock (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 9020b32bb8bSEric Schrock (void) pthread_mutex_unlock(&tp->set_lock); 903d91236feSeschrock return (NULL); 904940d71d2Seschrock } else { 905940d71d2Seschrock ses_snap_rele(tp->set_snap); 906940d71d2Seschrock tp->set_snap = snap; 907940d71d2Seschrock } 908525b85dbSEric Schrock tp->set_snaptime = gethrtime(); 909940d71d2Seschrock } 910940d71d2Seschrock 911940d71d2Seschrock snap = tp->set_snap; 912940d71d2Seschrock 913940d71d2Seschrock verify(topo_prop_get_uint64(tn, TOPO_PGROUP_SES, 914940d71d2Seschrock TOPO_PROP_NODE_ID, &nodeid, &err) == 0); 915940d71d2Seschrock verify((np = ses_node_lookup(snap, nodeid)) != NULL); 916d91236feSeschrock 917d91236feSeschrock return (np); 918d91236feSeschrock } 919d91236feSeschrock 9200b32bb8bSEric Schrock /*ARGSUSED*/ 9210b32bb8bSEric Schrock void 9220b32bb8bSEric Schrock ses_node_unlock(topo_mod_t *mod, tnode_t *tn) 9230b32bb8bSEric Schrock { 9240b32bb8bSEric Schrock ses_enum_target_t *tp = topo_node_getspecific(tn); 9250b32bb8bSEric Schrock 9260b32bb8bSEric Schrock verify(tp != NULL); 9270b32bb8bSEric Schrock 9280b32bb8bSEric Schrock (void) pthread_mutex_unlock(&tp->set_lock); 9290b32bb8bSEric Schrock } 9300b32bb8bSEric Schrock 931d91236feSeschrock /* 932d91236feSeschrock * Determine if the element is present. 933d91236feSeschrock */ 934d91236feSeschrock /*ARGSUSED*/ 935d91236feSeschrock static int 936d91236feSeschrock ses_present(topo_mod_t *mod, tnode_t *tn, topo_version_t version, 937d91236feSeschrock nvlist_t *in, nvlist_t **out) 938d91236feSeschrock { 939d91236feSeschrock boolean_t present; 940d91236feSeschrock ses_node_t *np; 941d91236feSeschrock nvlist_t *props, *nvl; 942d91236feSeschrock uint64_t status; 943d91236feSeschrock 9440b32bb8bSEric Schrock if ((np = ses_node_lock(mod, tn)) == NULL) 945d91236feSeschrock return (-1); 946d91236feSeschrock 947940d71d2Seschrock verify((props = ses_node_props(np)) != NULL); 948940d71d2Seschrock verify(nvlist_lookup_uint64(props, 949940d71d2Seschrock SES_PROP_STATUS_CODE, &status) == 0); 950940d71d2Seschrock 9510b32bb8bSEric Schrock ses_node_unlock(mod, tn); 9520b32bb8bSEric Schrock 953940d71d2Seschrock present = (status != SES_ESC_NOT_INSTALLED); 954940d71d2Seschrock 955940d71d2Seschrock if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0) 956940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 957940d71d2Seschrock 958940d71d2Seschrock if (nvlist_add_uint32(nvl, TOPO_METH_PRESENT_RET, 959940d71d2Seschrock present) != 0) { 960940d71d2Seschrock nvlist_free(nvl); 961940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 962940d71d2Seschrock } 963940d71d2Seschrock 964940d71d2Seschrock *out = nvl; 965940d71d2Seschrock 966940d71d2Seschrock return (0); 967940d71d2Seschrock } 968940d71d2Seschrock 969940d71d2Seschrock /* 970ac88567aSHyon Kim * Sets standard properties for a ses node (enclosure, bay, controller 971ac88567aSHyon Kim * or expander). 972ac88567aSHyon Kim * This includes setting the FRU, as well as setting the 973ac88567aSHyon Kim * authority information. When the fru topo node(frutn) is not NULL 974ac88567aSHyon Kim * its resouce should be used as FRU. 975940d71d2Seschrock */ 976940d71d2Seschrock static int 977ac88567aSHyon Kim ses_set_standard_props(topo_mod_t *mod, tnode_t *frutn, tnode_t *tn, 978ac88567aSHyon Kim nvlist_t *auth, uint64_t nodeid, const char *path) 979940d71d2Seschrock { 980940d71d2Seschrock int err; 981940d71d2Seschrock char *product, *chassis; 982940d71d2Seschrock nvlist_t *fmri; 983940d71d2Seschrock topo_pgroup_info_t pgi; 984940d71d2Seschrock 985940d71d2Seschrock /* 986940d71d2Seschrock * Set the authority explicitly if specified. 987940d71d2Seschrock */ 988940d71d2Seschrock if (auth) { 989940d71d2Seschrock verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT, 990940d71d2Seschrock &product) == 0); 991940d71d2Seschrock verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_CHASSIS, 992940d71d2Seschrock &chassis) == 0); 993940d71d2Seschrock if (topo_prop_set_string(tn, FM_FMRI_AUTHORITY, 994940d71d2Seschrock FM_FMRI_AUTH_PRODUCT, TOPO_PROP_IMMUTABLE, product, 995940d71d2Seschrock &err) != 0 || 996940d71d2Seschrock topo_prop_set_string(tn, FM_FMRI_AUTHORITY, 997940d71d2Seschrock FM_FMRI_AUTH_CHASSIS, TOPO_PROP_IMMUTABLE, chassis, 998940d71d2Seschrock &err) != 0 || 999940d71d2Seschrock topo_prop_set_string(tn, FM_FMRI_AUTHORITY, 1000940d71d2Seschrock FM_FMRI_AUTH_SERVER, TOPO_PROP_IMMUTABLE, "", 1001940d71d2Seschrock &err) != 0) { 1002940d71d2Seschrock topo_mod_dprintf(mod, "failed to add authority " 1003d91236feSeschrock "properties: %s\n", topo_strerror(err)); 1004940d71d2Seschrock return (topo_mod_seterrno(mod, err)); 1005940d71d2Seschrock } 1006940d71d2Seschrock } 1007940d71d2Seschrock 1008940d71d2Seschrock /* 1009940d71d2Seschrock * Copy the resource and set that as the FRU. 1010940d71d2Seschrock */ 1011ac88567aSHyon Kim if (frutn != NULL) { 1012ac88567aSHyon Kim if (topo_node_resource(frutn, &fmri, &err) != 0) { 1013ac88567aSHyon Kim topo_mod_dprintf(mod, 1014ac88567aSHyon Kim "topo_node_resource() failed : %s\n", 1015ac88567aSHyon Kim topo_strerror(err)); 1016ac88567aSHyon Kim return (topo_mod_seterrno(mod, err)); 1017ac88567aSHyon Kim } 1018ac88567aSHyon Kim } else { 1019ac88567aSHyon Kim if (topo_node_resource(tn, &fmri, &err) != 0) { 1020ac88567aSHyon Kim topo_mod_dprintf(mod, 1021ac88567aSHyon Kim "topo_node_resource() failed : %s\n", 1022ac88567aSHyon Kim topo_strerror(err)); 1023ac88567aSHyon Kim return (topo_mod_seterrno(mod, err)); 1024ac88567aSHyon Kim } 1025940d71d2Seschrock } 1026940d71d2Seschrock 1027940d71d2Seschrock if (topo_node_fru_set(tn, fmri, 0, &err) != 0) { 1028940d71d2Seschrock topo_mod_dprintf(mod, 1029940d71d2Seschrock "topo_node_fru_set() failed : %s\n", 1030940d71d2Seschrock topo_strerror(err)); 1031940d71d2Seschrock nvlist_free(fmri); 1032940d71d2Seschrock return (topo_mod_seterrno(mod, err)); 1033940d71d2Seschrock } 1034940d71d2Seschrock 1035940d71d2Seschrock nvlist_free(fmri); 1036940d71d2Seschrock 1037940d71d2Seschrock /* 1038940d71d2Seschrock * Set the SES-specific properties so that consumers can query 1039940d71d2Seschrock * additional information about the particular SES element. 1040940d71d2Seschrock */ 1041940d71d2Seschrock pgi.tpi_name = TOPO_PGROUP_SES; 1042940d71d2Seschrock pgi.tpi_namestab = TOPO_STABILITY_PRIVATE; 1043940d71d2Seschrock pgi.tpi_datastab = TOPO_STABILITY_PRIVATE; 1044940d71d2Seschrock pgi.tpi_version = TOPO_VERSION; 1045940d71d2Seschrock if (topo_pgroup_create(tn, &pgi, &err) != 0) { 1046940d71d2Seschrock topo_mod_dprintf(mod, "failed to create propgroup " 1047940d71d2Seschrock "%s: %s\n", TOPO_PGROUP_SES, topo_strerror(err)); 1048940d71d2Seschrock return (-1); 1049940d71d2Seschrock } 1050940d71d2Seschrock 1051940d71d2Seschrock if (topo_prop_set_uint64(tn, TOPO_PGROUP_SES, 1052940d71d2Seschrock TOPO_PROP_NODE_ID, TOPO_PROP_IMMUTABLE, 1053940d71d2Seschrock nodeid, &err) != 0) { 1054940d71d2Seschrock topo_mod_dprintf(mod, 1055940d71d2Seschrock "failed to create property %s: %s\n", 1056940d71d2Seschrock TOPO_PROP_NODE_ID, topo_strerror(err)); 1057940d71d2Seschrock return (-1); 1058940d71d2Seschrock } 1059940d71d2Seschrock 1060940d71d2Seschrock if (topo_prop_set_string(tn, TOPO_PGROUP_SES, 1061940d71d2Seschrock TOPO_PROP_TARGET_PATH, TOPO_PROP_IMMUTABLE, 1062940d71d2Seschrock path, &err) != 0) { 1063940d71d2Seschrock topo_mod_dprintf(mod, 1064940d71d2Seschrock "failed to create property %s: %s\n", 1065940d71d2Seschrock TOPO_PROP_TARGET_PATH, topo_strerror(err)); 1066940d71d2Seschrock return (-1); 1067940d71d2Seschrock } 1068940d71d2Seschrock 1069940d71d2Seschrock return (0); 1070940d71d2Seschrock } 1071940d71d2Seschrock 1072940d71d2Seschrock /* 1073940d71d2Seschrock * Callback to add a disk to a given bay. We first check the status-code to 1074940d71d2Seschrock * determine if a disk is present, ignoring those that aren't in an appropriate 10750b32bb8bSEric Schrock * state. We then scan the parent bay node's SAS address array to determine 10760b32bb8bSEric Schrock * possible attached SAS addresses. We create a disk node if the disk is not 10770b32bb8bSEric Schrock * SAS or the SES target does not support the necessary pages for this; if we 10780b32bb8bSEric Schrock * find the SAS address, we create a disk node and also correlate it with 10790b32bb8bSEric Schrock * the corresponding Solaris device node to fill in the rest of the data. 1080940d71d2Seschrock */ 1081940d71d2Seschrock static int 1082940d71d2Seschrock ses_create_disk(ses_enum_data_t *sdp, tnode_t *pnode, nvlist_t *props) 1083940d71d2Seschrock { 1084940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 1085940d71d2Seschrock uint64_t status; 1086940d71d2Seschrock nvlist_t **sas; 1087940d71d2Seschrock uint_t s, nsas; 10880b32bb8bSEric Schrock char **paths; 108944ed9dbbSStephen Hanson int err, ret; 109044ed9dbbSStephen Hanson tnode_t *child = NULL; 1091940d71d2Seschrock 1092940d71d2Seschrock /* 1093940d71d2Seschrock * Skip devices that are not in a present (and possibly damaged) state. 1094940d71d2Seschrock */ 1095940d71d2Seschrock if (nvlist_lookup_uint64(props, SES_PROP_STATUS_CODE, &status) != 0) 1096940d71d2Seschrock return (0); 1097940d71d2Seschrock 1098ac88567aSHyon Kim if (status != SES_ESC_UNSUPPORTED && 1099ac88567aSHyon Kim status != SES_ESC_OK && 1100940d71d2Seschrock status != SES_ESC_CRITICAL && 1101940d71d2Seschrock status != SES_ESC_NONCRITICAL && 1102940d71d2Seschrock status != SES_ESC_UNRECOVERABLE && 1103940d71d2Seschrock status != SES_ESC_NO_ACCESS) 1104940d71d2Seschrock return (0); 1105940d71d2Seschrock 1106940d71d2Seschrock topo_mod_dprintf(mod, "found attached disk"); 1107940d71d2Seschrock 1108940d71d2Seschrock /* 1109940d71d2Seschrock * Create the disk range. 1110940d71d2Seschrock */ 11110b32bb8bSEric Schrock if (topo_node_range_create(mod, pnode, DISK, 0, 0) != 0) { 1112940d71d2Seschrock topo_mod_dprintf(mod, 1113940d71d2Seschrock "topo_node_create_range() failed: %s", 1114940d71d2Seschrock topo_mod_errmsg(mod)); 1115940d71d2Seschrock return (-1); 1116940d71d2Seschrock } 1117940d71d2Seschrock 1118940d71d2Seschrock /* 1119940d71d2Seschrock * Look through all SAS addresses and attempt to correlate them to a 1120940d71d2Seschrock * known Solaris device. If we don't find a matching node, then we 1121940d71d2Seschrock * don't enumerate the disk node. 1122940d71d2Seschrock */ 1123940d71d2Seschrock if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 1124940d71d2Seschrock &sas, &nsas) != 0) 1125940d71d2Seschrock return (0); 1126940d71d2Seschrock 11270b32bb8bSEric Schrock if (topo_prop_get_string_array(pnode, TOPO_PGROUP_SES, 11280b32bb8bSEric Schrock TOPO_PROP_SAS_ADDR, &paths, &nsas, &err) != 0) 11290b32bb8bSEric Schrock return (0); 11300b32bb8bSEric Schrock 11310b32bb8bSEric Schrock err = 0; 11320b32bb8bSEric Schrock 1133940d71d2Seschrock for (s = 0; s < nsas; s++) { 1134ac88567aSHyon Kim ret = disk_declare_addr(mod, pnode, &sdp->sed_devs, paths[s], 113544ed9dbbSStephen Hanson &child); 113644ed9dbbSStephen Hanson if (ret == 0) { 113744ed9dbbSStephen Hanson break; 113844ed9dbbSStephen Hanson } else if (ret < 0) { 11390b32bb8bSEric Schrock err = -1; 11400b32bb8bSEric Schrock break; 11410b32bb8bSEric Schrock } 11420b32bb8bSEric Schrock } 11430b32bb8bSEric Schrock 114444ed9dbbSStephen Hanson if (s == nsas) 114544ed9dbbSStephen Hanson disk_declare_non_enumerated(mod, pnode, &child); 114644ed9dbbSStephen Hanson 114744ed9dbbSStephen Hanson /* copy sas_addresses (target-ports) from parent (with 'w'added) */ 114844ed9dbbSStephen Hanson if (child != NULL) { 114944ed9dbbSStephen Hanson int i; 115044ed9dbbSStephen Hanson char **tports; 115144ed9dbbSStephen Hanson uint64_t wwn; 115244ed9dbbSStephen Hanson 115344ed9dbbSStephen Hanson tports = topo_mod_zalloc(mod, sizeof (char *) * nsas); 115444ed9dbbSStephen Hanson if (tports != NULL) { 115544ed9dbbSStephen Hanson for (i = 0; i < nsas; i++) { 115644ed9dbbSStephen Hanson if (scsi_wwnstr_to_wwn(paths[i], &wwn) != 115744ed9dbbSStephen Hanson DDI_SUCCESS) 115844ed9dbbSStephen Hanson break; 115944ed9dbbSStephen Hanson tports[i] = scsi_wwn_to_wwnstr(wwn, 1, NULL); 116044ed9dbbSStephen Hanson if (tports[i] == NULL) 116144ed9dbbSStephen Hanson break; 116244ed9dbbSStephen Hanson } 116344ed9dbbSStephen Hanson /* if they all worked then create the property */ 116444ed9dbbSStephen Hanson if (i == nsas) 116544ed9dbbSStephen Hanson (void) topo_prop_set_string_array(child, 116644ed9dbbSStephen Hanson TOPO_PGROUP_STORAGE, 116744ed9dbbSStephen Hanson TOPO_STORAGE_TARGET_PORT_L0IDS, 116844ed9dbbSStephen Hanson TOPO_PROP_IMMUTABLE, (const char **)tports, 116944ed9dbbSStephen Hanson nsas, &err); 117044ed9dbbSStephen Hanson 117144ed9dbbSStephen Hanson for (i = 0; i < nsas; i++) 117244ed9dbbSStephen Hanson if (tports[i] != NULL) 117344ed9dbbSStephen Hanson scsi_free_wwnstr(tports[i]); 117444ed9dbbSStephen Hanson topo_mod_free(mod, tports, sizeof (char *) * nsas); 117544ed9dbbSStephen Hanson } 117644ed9dbbSStephen Hanson } 117744ed9dbbSStephen Hanson 11780b32bb8bSEric Schrock for (s = 0; s < nsas; s++) 11790b32bb8bSEric Schrock topo_mod_free(mod, paths[s], strlen(paths[s]) + 1); 11800b32bb8bSEric Schrock topo_mod_free(mod, paths, nsas * sizeof (char *)); 11810b32bb8bSEric Schrock 11820b32bb8bSEric Schrock return (err); 11830b32bb8bSEric Schrock } 11840b32bb8bSEric Schrock 11850b32bb8bSEric Schrock static int 11860b32bb8bSEric Schrock ses_add_bay_props(topo_mod_t *mod, tnode_t *tn, ses_enum_node_t *snp) 11870b32bb8bSEric Schrock { 11880b32bb8bSEric Schrock ses_alt_node_t *ap; 11890b32bb8bSEric Schrock ses_node_t *np; 11900b32bb8bSEric Schrock nvlist_t *props; 11910b32bb8bSEric Schrock 11920b32bb8bSEric Schrock nvlist_t **phys; 11930b32bb8bSEric Schrock uint_t i, j, n_phys, all_phys = 0; 11940b32bb8bSEric Schrock char **paths; 11950b32bb8bSEric Schrock uint64_t addr; 11960b32bb8bSEric Schrock size_t len; 11970b32bb8bSEric Schrock int terr, err = -1; 11980b32bb8bSEric Schrock 11990b32bb8bSEric Schrock for (ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL; 12000b32bb8bSEric Schrock ap = topo_list_next(ap)) { 12010b32bb8bSEric Schrock np = ap->san_node; 12020b32bb8bSEric Schrock props = ses_node_props(np); 12030b32bb8bSEric Schrock 12040b32bb8bSEric Schrock if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 12050b32bb8bSEric Schrock &phys, &n_phys) != 0) 12060b32bb8bSEric Schrock continue; 12070b32bb8bSEric Schrock 12080b32bb8bSEric Schrock all_phys += n_phys; 12090b32bb8bSEric Schrock } 12100b32bb8bSEric Schrock 12110b32bb8bSEric Schrock if (all_phys == 0) 12120b32bb8bSEric Schrock return (0); 12130b32bb8bSEric Schrock 12140b32bb8bSEric Schrock if ((paths = topo_mod_zalloc(mod, all_phys * sizeof (char *))) == NULL) 12150b32bb8bSEric Schrock return (-1); 12160b32bb8bSEric Schrock 12170b32bb8bSEric Schrock for (i = 0, ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL; 12180b32bb8bSEric Schrock ap = topo_list_next(ap)) { 12190b32bb8bSEric Schrock np = ap->san_node; 12200b32bb8bSEric Schrock props = ses_node_props(np); 12210b32bb8bSEric Schrock 12220b32bb8bSEric Schrock if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 12230b32bb8bSEric Schrock &phys, &n_phys) != 0) 1224940d71d2Seschrock continue; 1225940d71d2Seschrock 12260b32bb8bSEric Schrock for (j = 0; j < n_phys; j++) { 12270b32bb8bSEric Schrock if (nvlist_lookup_uint64(phys[j], SES_SAS_PROP_ADDR, 12280b32bb8bSEric Schrock &addr) != 0) 12290b32bb8bSEric Schrock continue; 1230940d71d2Seschrock 12310b32bb8bSEric Schrock len = snprintf(NULL, 0, "%016llx", addr) + 1; 12320b32bb8bSEric Schrock if ((paths[i] = topo_mod_alloc(mod, len)) == NULL) 12330b32bb8bSEric Schrock goto error; 12340b32bb8bSEric Schrock 12350b32bb8bSEric Schrock (void) snprintf(paths[i], len, "%016llx", addr); 12360b32bb8bSEric Schrock 12370b32bb8bSEric Schrock ++i; 12380b32bb8bSEric Schrock } 1239940d71d2Seschrock } 1240940d71d2Seschrock 12410b32bb8bSEric Schrock err = topo_prop_set_string_array(tn, TOPO_PGROUP_SES, 12420b32bb8bSEric Schrock TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE, 12430b32bb8bSEric Schrock (const char **)paths, i, &terr); 12440b32bb8bSEric Schrock if (err != 0) 12450b32bb8bSEric Schrock err = topo_mod_seterrno(mod, terr); 12460b32bb8bSEric Schrock 12470b32bb8bSEric Schrock error: 12480b32bb8bSEric Schrock for (i = 0; i < all_phys && paths[i] != NULL; i++) 12490b32bb8bSEric Schrock topo_mod_free(mod, paths[i], strlen(paths[i]) + 1); 12500b32bb8bSEric Schrock topo_mod_free(mod, paths, all_phys * sizeof (char *)); 12510b32bb8bSEric Schrock 12520b32bb8bSEric Schrock return (err); 1253940d71d2Seschrock } 1254940d71d2Seschrock 1255940d71d2Seschrock /* 1256ac88567aSHyon Kim * Callback to create a basic node (bay, psu, fan, or controller and expander). 1257940d71d2Seschrock */ 1258940d71d2Seschrock static int 1259940d71d2Seschrock ses_create_generic(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1260ac88567aSHyon Kim tnode_t *pnode, const char *nodename, const char *labelname, tnode_t **node) 1261940d71d2Seschrock { 1262940d71d2Seschrock ses_node_t *np = snp->sen_node; 1263d91236feSeschrock ses_node_t *parent; 1264940d71d2Seschrock uint64_t instance = snp->sen_instance; 1265940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 1266940d71d2Seschrock nvlist_t *props, *aprops; 1267940d71d2Seschrock nvlist_t *auth = NULL, *fmri = NULL; 1268ac88567aSHyon Kim tnode_t *tn = NULL, *frutn = NULL; 1269940d71d2Seschrock char label[128]; 1270940d71d2Seschrock int err; 1271d91236feSeschrock char *part = NULL, *serial = NULL, *revision = NULL; 1272d91236feSeschrock char *desc; 1273d91236feSeschrock boolean_t report; 1274940d71d2Seschrock 1275940d71d2Seschrock props = ses_node_props(np); 1276940d71d2Seschrock 1277940d71d2Seschrock (void) nvlist_lookup_string(props, LIBSES_PROP_PART, &part); 1278940d71d2Seschrock (void) nvlist_lookup_string(props, LIBSES_PROP_SERIAL, &serial); 1279940d71d2Seschrock 1280940d71d2Seschrock topo_mod_dprintf(mod, "adding %s %llu", nodename, instance); 1281940d71d2Seschrock 1282940d71d2Seschrock /* 1283940d71d2Seschrock * Create the node. The interesting information is all copied from the 1284940d71d2Seschrock * parent enclosure node, so there is not much to do. 1285940d71d2Seschrock */ 1286940d71d2Seschrock if ((auth = topo_mod_auth(mod, pnode)) == NULL) 1287940d71d2Seschrock goto error; 1288940d71d2Seschrock 1289d91236feSeschrock /* 1290d91236feSeschrock * We want to report revision information for the controller nodes, but 1291d91236feSeschrock * we do not get per-element revision information. However, we do have 1292d91236feSeschrock * revision information for the entire enclosure, and we can use the 1293d91236feSeschrock * 'reported-via' property to know that this controller corresponds to 1294d91236feSeschrock * the given revision information. This means we cannot get revision 1295d91236feSeschrock * information for targets we are not explicitly connected to, but 1296d91236feSeschrock * there is little we can do about the situation. 1297d91236feSeschrock */ 1298d91236feSeschrock if (strcmp(nodename, CONTROLLER) == 0 && 1299d91236feSeschrock nvlist_lookup_boolean_value(props, SES_PROP_REPORT, &report) == 0 && 1300d91236feSeschrock report) { 1301d91236feSeschrock for (parent = ses_node_parent(np); parent != NULL; 1302d91236feSeschrock parent = ses_node_parent(parent)) { 1303d91236feSeschrock if (ses_node_type(parent) == SES_NODE_ENCLOSURE) { 1304d91236feSeschrock (void) nvlist_lookup_string( 1305d91236feSeschrock ses_node_props(parent), 1306d91236feSeschrock SES_EN_PROP_REV, &revision); 1307d91236feSeschrock break; 1308d91236feSeschrock } 1309d91236feSeschrock } 1310d91236feSeschrock } 1311d91236feSeschrock 1312940d71d2Seschrock if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION, 1313d91236feSeschrock nodename, (topo_instance_t)instance, NULL, auth, part, revision, 1314940d71d2Seschrock serial)) == NULL) { 1315940d71d2Seschrock topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s", 1316940d71d2Seschrock topo_mod_errmsg(mod)); 1317940d71d2Seschrock goto error; 1318940d71d2Seschrock } 1319940d71d2Seschrock 1320940d71d2Seschrock if ((tn = topo_node_bind(mod, pnode, nodename, 1321940d71d2Seschrock instance, fmri)) == NULL) { 1322940d71d2Seschrock topo_mod_dprintf(mod, "topo_node_bind() failed: %s", 1323940d71d2Seschrock topo_mod_errmsg(mod)); 1324940d71d2Seschrock goto error; 1325940d71d2Seschrock } 1326940d71d2Seschrock 1327940d71d2Seschrock /* 1328d91236feSeschrock * For the node label, we look for the following in order: 1329d91236feSeschrock * 1330d91236feSeschrock * <ses-description> 1331d91236feSeschrock * <ses-class-description> <instance> 1332d91236feSeschrock * <default-type-label> <instance> 1333940d71d2Seschrock */ 1334d91236feSeschrock if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 || 1335d91236feSeschrock desc[0] == '\0') { 1336d91236feSeschrock parent = ses_node_parent(np); 1337d91236feSeschrock aprops = ses_node_props(parent); 1338d91236feSeschrock if (nvlist_lookup_string(aprops, SES_PROP_CLASS_DESCRIPTION, 1339ac88567aSHyon Kim &desc) != 0 || desc[0] == '\0') 1340ac88567aSHyon Kim desc = (char *)labelname; 1341d91236feSeschrock (void) snprintf(label, sizeof (label), "%s %llu", desc, 1342d91236feSeschrock instance); 1343d91236feSeschrock desc = label; 1344d91236feSeschrock } 1345d91236feSeschrock 1346d91236feSeschrock if (topo_node_label_set(tn, desc, &err) != 0) 1347940d71d2Seschrock goto error; 1348940d71d2Seschrock 1349ac88567aSHyon Kim /* 1350ac88567aSHyon Kim * For an expander node, set the FRU to its parent(controller). 1351ac88567aSHyon Kim * For a connector node, set the FRU to its grand parent(controller). 1352ac88567aSHyon Kim */ 1353ac88567aSHyon Kim if (strcmp(nodename, SASEXPANDER) == 0) { 1354ac88567aSHyon Kim frutn = pnode; 1355ac88567aSHyon Kim } else if (strcmp(nodename, RECEPTACLE) == 0) { 1356ac88567aSHyon Kim frutn = topo_node_parent(pnode); 1357ac88567aSHyon Kim } 1358ac88567aSHyon Kim 1359ac88567aSHyon Kim if (ses_set_standard_props(mod, frutn, tn, NULL, ses_node_id(np), 1360940d71d2Seschrock snp->sen_target->set_devpath) != 0) 1361940d71d2Seschrock goto error; 1362940d71d2Seschrock 1363ac88567aSHyon Kim if (strcmp(nodename, BAY) == 0) { 13640b32bb8bSEric Schrock if (ses_add_bay_props(mod, tn, snp) != 0) 13650b32bb8bSEric Schrock goto error; 13660b32bb8bSEric Schrock 1367940d71d2Seschrock if (ses_create_disk(sdp, tn, props) != 0) 1368940d71d2Seschrock goto error; 1369d91236feSeschrock 1370d91236feSeschrock if (topo_method_register(mod, tn, ses_bay_methods) != 0) { 1371d91236feSeschrock topo_mod_dprintf(mod, 1372d91236feSeschrock "topo_method_register() failed: %s", 1373d91236feSeschrock topo_mod_errmsg(mod)); 1374d91236feSeschrock goto error; 1375d91236feSeschrock } 1376ac88567aSHyon Kim } else if ((strcmp(nodename, FAN) == 0) || 1377ac88567aSHyon Kim (strcmp(nodename, PSU) == 0) || 1378ac88567aSHyon Kim (strcmp(nodename, CONTROLLER) == 0)) { 1379940d71d2Seschrock /* 1380d91236feSeschrock * Only fan, psu, and controller nodes have a 'present' method. 1381d91236feSeschrock * Bay nodes are always present, and disk nodes are present by 1382ac88567aSHyon Kim * virtue of being enumerated and SAS expander nodes and 1383ac88567aSHyon Kim * SAS connector nodes are also always present once 1384ac88567aSHyon Kim * the parent controller is found. 1385940d71d2Seschrock */ 1386940d71d2Seschrock if (topo_method_register(mod, tn, ses_component_methods) != 0) { 1387940d71d2Seschrock topo_mod_dprintf(mod, 1388940d71d2Seschrock "topo_method_register() failed: %s", 1389940d71d2Seschrock topo_mod_errmsg(mod)); 1390940d71d2Seschrock goto error; 1391940d71d2Seschrock } 1392940d71d2Seschrock 1393940d71d2Seschrock } 1394940d71d2Seschrock 1395d91236feSeschrock snp->sen_target->set_refcount++; 1396d91236feSeschrock topo_node_setspecific(tn, snp->sen_target); 1397d91236feSeschrock 1398940d71d2Seschrock nvlist_free(auth); 1399940d71d2Seschrock nvlist_free(fmri); 1400ac88567aSHyon Kim if (node != NULL) *node = tn; 1401ac88567aSHyon Kim return (0); 1402ac88567aSHyon Kim 1403ac88567aSHyon Kim error: 1404ac88567aSHyon Kim nvlist_free(auth); 1405ac88567aSHyon Kim nvlist_free(fmri); 1406ac88567aSHyon Kim return (-1); 1407ac88567aSHyon Kim } 1408ac88567aSHyon Kim 1409ac88567aSHyon Kim /* 1410ac88567aSHyon Kim * Create SAS expander specific props. 1411ac88567aSHyon Kim */ 1412ac88567aSHyon Kim /*ARGSUSED*/ 1413ac88567aSHyon Kim static int 1414ac88567aSHyon Kim ses_set_expander_props(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1415ac88567aSHyon Kim tnode_t *ptnode, tnode_t *tnode, int *phycount, int64_t *connlist) 1416ac88567aSHyon Kim { 1417ac88567aSHyon Kim ses_node_t *np = snp->sen_node; 1418ac88567aSHyon Kim topo_mod_t *mod = sdp->sed_mod; 1419ac88567aSHyon Kim nvlist_t *auth = NULL, *fmri = NULL; 1420ac88567aSHyon Kim nvlist_t *props, **phylist; 1421ac88567aSHyon Kim int err, i; 1422ac88567aSHyon Kim uint_t pcount; 1423ac88567aSHyon Kim uint64_t sasaddr, connidx; 1424ac88567aSHyon Kim char sasaddr_str[17]; 1425b4879163SHyon Kim boolean_t found = B_FALSE, ses_found = B_FALSE; 1426b4879163SHyon Kim dev_di_node_t *dnode, *sesdnode; 1427ac88567aSHyon Kim 1428ac88567aSHyon Kim props = ses_node_props(np); 1429ac88567aSHyon Kim 1430ac88567aSHyon Kim /* 1431ac88567aSHyon Kim * the uninstalled expander is not enumerated by checking 1432ac88567aSHyon Kim * the element status code. No present present' method provided. 1433ac88567aSHyon Kim */ 1434ac88567aSHyon Kim /* 1435ac88567aSHyon Kim * Get the Expander SAS address. It should exist. 1436ac88567aSHyon Kim */ 1437ac88567aSHyon Kim if (nvlist_lookup_uint64(props, SES_EXP_PROP_SAS_ADDR, 1438ac88567aSHyon Kim &sasaddr) != 0) { 1439ac88567aSHyon Kim topo_mod_dprintf(mod, 1440ac88567aSHyon Kim "Failed to get prop %s.", SES_EXP_PROP_SAS_ADDR); 1441ac88567aSHyon Kim goto error; 1442ac88567aSHyon Kim } 1443ac88567aSHyon Kim 1444ac88567aSHyon Kim (void) sprintf(sasaddr_str, "%llx", sasaddr); 1445ac88567aSHyon Kim 1446ac88567aSHyon Kim /* search matching dev_di_node. */ 1447ac88567aSHyon Kim for (dnode = topo_list_next(&sdp->sed_devs); dnode != NULL; 1448ac88567aSHyon Kim dnode = topo_list_next(dnode)) { 1449b4879163SHyon Kim for (i = 0; i < dnode->ddn_ppath_count; i++) { 1450b4879163SHyon Kim if ((dnode->ddn_target_port[i] != NULL) && 1451b4879163SHyon Kim (strstr(dnode->ddn_target_port[i], 1452b4879163SHyon Kim sasaddr_str) != NULL)) { 1453b4879163SHyon Kim found = B_TRUE; 1454b4879163SHyon Kim break; 1455b4879163SHyon Kim } 1456ac88567aSHyon Kim } 1457b4879163SHyon Kim if (found) 1458b4879163SHyon Kim break; 1459ac88567aSHyon Kim } 1460ac88567aSHyon Kim 1461ac88567aSHyon Kim if (!found) { 1462ac88567aSHyon Kim topo_mod_dprintf(mod, 1463ac88567aSHyon Kim "ses_set_expander_props: Failed to find matching " 1464ac88567aSHyon Kim "devinfo node for Exapnder SAS address %s", 1465ac88567aSHyon Kim SES_EXP_PROP_SAS_ADDR); 1466ac88567aSHyon Kim /* continue on to get storage group props. */ 1467ac88567aSHyon Kim } else { 1468b4879163SHyon Kim /* create/set the devfs-path and devid in the smp group */ 1469b4879163SHyon Kim if (topo_pgroup_create(tnode, &smp_pgroup, &err) != 0) { 1470ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1471b4879163SHyon Kim "failed to create smp property group %s\n", 1472b4879163SHyon Kim topo_strerror(err)); 1473ac88567aSHyon Kim goto error; 1474ac88567aSHyon Kim } else { 1475b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP, 1476b4879163SHyon Kim TOPO_PROP_SMP_TARGET_PORT, TOPO_PROP_IMMUTABLE, 1477b4879163SHyon Kim dnode->ddn_target_port[i], &err) != 0) { 1478b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1479b4879163SHyon Kim "set %S error %s\n", TOPO_PROP_SAS_ADDR, 1480b4879163SHyon Kim topo_strerror(err)); 1481b4879163SHyon Kim } 1482b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP, 1483b4879163SHyon Kim TOPO_PROP_SMP_DEV_PATH, TOPO_PROP_IMMUTABLE, 1484ac88567aSHyon Kim dnode->ddn_dpath, &err) != 0) { 1485ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1486ac88567aSHyon Kim "set dev error %s\n", topo_strerror(err)); 1487ac88567aSHyon Kim } 1488b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP, 1489b4879163SHyon Kim TOPO_PROP_SMP_DEVID, TOPO_PROP_IMMUTABLE, 1490ac88567aSHyon Kim dnode->ddn_devid, &err) != 0) { 1491ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1492ac88567aSHyon Kim "set devid error %s\n", topo_strerror(err)); 1493ac88567aSHyon Kim } 1494ac88567aSHyon Kim if (dnode->ddn_ppath_count != 0 && 1495b4879163SHyon Kim topo_prop_set_string_array(tnode, TOPO_PGROUP_SMP, 1496b4879163SHyon Kim TOPO_PROP_SMP_PHYS_PATH, TOPO_PROP_IMMUTABLE, 1497ac88567aSHyon Kim (const char **)dnode->ddn_ppath, 1498ac88567aSHyon Kim dnode->ddn_ppath_count, &err) != 0) { 1499ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1500ac88567aSHyon Kim "set phys-path error %s\n", 1501ac88567aSHyon Kim topo_strerror(err)); 1502ac88567aSHyon Kim } 1503ac88567aSHyon Kim } 1504ac88567aSHyon Kim } 1505ac88567aSHyon Kim 1506b4879163SHyon Kim /* update the ses property group with SES target info */ 1507b4879163SHyon Kim if (topo_pgroup_info(tnode, TOPO_PGROUP_SES, &err) == NULL) { 1508b4879163SHyon Kim /* the SES property group should exist. */ 1509b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1510b4879163SHyon Kim "ses pgroup info error %s\n", topo_strerror(err)); 1511b4879163SHyon Kim goto error; 1512b4879163SHyon Kim } else { 1513b4879163SHyon Kim /* locate assciated enclosure dev_di_node. */ 1514b4879163SHyon Kim for (sesdnode = topo_list_next(&sdp->sed_devs); 1515b4879163SHyon Kim sesdnode != NULL; sesdnode = topo_list_next(sesdnode)) { 1516b4879163SHyon Kim for (i = 0; i < sesdnode->ddn_ppath_count; i++) { 1517b4879163SHyon Kim /* 1518b4879163SHyon Kim * check if attached port exists and 1519b4879163SHyon Kim * its node type is enclosure and 1520b4879163SHyon Kim * attached port is same as sas address of 1521b4879163SHyon Kim * the expander and 1522b4879163SHyon Kim * bridge port for virtual phy indication 1523b4879163SHyon Kim * exist. 1524b4879163SHyon Kim */ 1525b4879163SHyon Kim if ((sesdnode->ddn_attached_port[i] != NULL) && 1526b4879163SHyon Kim (sesdnode->ddn_dtype == DTYPE_ESI) && 1527b4879163SHyon Kim (strstr(sesdnode->ddn_attached_port[i], 1528b4879163SHyon Kim sasaddr_str) != NULL) && 1529b4879163SHyon Kim (sesdnode->ddn_bridge_port[i] != NULL)) { 1530b4879163SHyon Kim ses_found = B_TRUE; 1531b4879163SHyon Kim break; 1532b4879163SHyon Kim } 1533b4879163SHyon Kim } 1534b4879163SHyon Kim if (ses_found) break; 1535b4879163SHyon Kim } 1536b4879163SHyon Kim 1537b4879163SHyon Kim if (ses_found) { 1538b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SES, 1539b4879163SHyon Kim TOPO_PROP_SES_TARGET_PORT, TOPO_PROP_IMMUTABLE, 1540b4879163SHyon Kim sesdnode->ddn_target_port[i], &err) != 0) { 1541b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1542b4879163SHyon Kim "set ses %S error %s\n", TOPO_PROP_SAS_ADDR, 1543b4879163SHyon Kim topo_strerror(err)); 1544b4879163SHyon Kim } 1545b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SES, 1546b4879163SHyon Kim TOPO_PROP_SES_DEV_PATH, TOPO_PROP_IMMUTABLE, 1547b4879163SHyon Kim sesdnode->ddn_dpath, &err) != 0) { 1548b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1549b4879163SHyon Kim "set ses dev error %s\n", 1550b4879163SHyon Kim topo_strerror(err)); 1551b4879163SHyon Kim } 1552b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SES, 1553b4879163SHyon Kim TOPO_PROP_SES_DEVID, TOPO_PROP_IMMUTABLE, 1554b4879163SHyon Kim sesdnode->ddn_devid, &err) != 0) { 1555b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1556b4879163SHyon Kim "set ses devid error %s\n", 1557b4879163SHyon Kim topo_strerror(err)); 1558b4879163SHyon Kim } 1559b4879163SHyon Kim if (sesdnode->ddn_ppath_count != 0 && 1560b4879163SHyon Kim topo_prop_set_string_array(tnode, TOPO_PGROUP_SES, 1561b4879163SHyon Kim TOPO_PROP_SES_PHYS_PATH, TOPO_PROP_IMMUTABLE, 1562b4879163SHyon Kim (const char **)sesdnode->ddn_ppath, 1563b4879163SHyon Kim sesdnode->ddn_ppath_count, &err) != 0) { 1564b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1565b4879163SHyon Kim "set ses phys-path error %s\n", 1566b4879163SHyon Kim topo_strerror(err)); 1567b4879163SHyon Kim } 1568b4879163SHyon Kim 1569b4879163SHyon Kim } 1570b4879163SHyon Kim } 1571b4879163SHyon Kim 1572ac88567aSHyon Kim /* create the storage group */ 1573ac88567aSHyon Kim if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) { 1574ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1575ac88567aSHyon Kim "create storage error %s\n", topo_strerror(err)); 1576ac88567aSHyon Kim goto error; 1577ac88567aSHyon Kim } else { 1578b4879163SHyon Kim /* set the SAS address prop out of expander element status. */ 1579ac88567aSHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE, 1580ac88567aSHyon Kim TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE, sasaddr_str, 1581ac88567aSHyon Kim &err) != 0) { 1582ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1583ac88567aSHyon Kim "set %S error %s\n", TOPO_PROP_SAS_ADDR, 1584ac88567aSHyon Kim topo_strerror(err)); 1585ac88567aSHyon Kim } 1586ac88567aSHyon Kim 1587ac88567aSHyon Kim /* Get the phy information for the expander */ 1588ac88567aSHyon Kim if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 1589ac88567aSHyon Kim &phylist, &pcount) != 0) { 1590ac88567aSHyon Kim topo_mod_dprintf(mod, 1591ac88567aSHyon Kim "Failed to get prop %s.", SES_SAS_PROP_PHYS); 1592ac88567aSHyon Kim } else { 1593ac88567aSHyon Kim /* 1594ac88567aSHyon Kim * For each phy, get the connector element index and 1595ac88567aSHyon Kim * stores into connector element index array. 1596ac88567aSHyon Kim */ 1597ac88567aSHyon Kim *phycount = pcount; 1598ac88567aSHyon Kim for (i = 0; i < pcount; i++) { 1599ac88567aSHyon Kim if (nvlist_lookup_uint64(phylist[i], 1600ac88567aSHyon Kim SES_PROP_CE_IDX, &connidx) == 0) { 1601ac88567aSHyon Kim if (connidx != 0xff) { 1602ac88567aSHyon Kim connlist[i] = connidx; 1603ac88567aSHyon Kim } else { 1604ac88567aSHyon Kim connlist[i] = -1; 1605ac88567aSHyon Kim } 1606ac88567aSHyon Kim } else { 1607ac88567aSHyon Kim /* Fail to get the index. set to -1. */ 1608ac88567aSHyon Kim connlist[i] = -1; 1609ac88567aSHyon Kim } 1610ac88567aSHyon Kim } 1611ac88567aSHyon Kim 1612ac88567aSHyon Kim /* set the phy count prop of the expander. */ 1613ac88567aSHyon Kim if (topo_prop_set_uint64(tnode, TOPO_PGROUP_STORAGE, 1614ac88567aSHyon Kim TOPO_PROP_PHY_COUNT, TOPO_PROP_IMMUTABLE, pcount, 1615ac88567aSHyon Kim &err) != 0) { 1616ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1617ac88567aSHyon Kim "set %S error %s\n", TOPO_PROP_PHY_COUNT, 1618ac88567aSHyon Kim topo_strerror(err)); 1619ac88567aSHyon Kim } 1620ac88567aSHyon Kim 1621ac88567aSHyon Kim /* 1622ac88567aSHyon Kim * set the connector element index of 1623ac88567aSHyon Kim * the expander phys. 1624ac88567aSHyon Kim */ 1625ac88567aSHyon Kim } 1626ac88567aSHyon Kim 1627ac88567aSHyon Kim /* populate other misc storage group properties */ 1628ac88567aSHyon Kim if (found) { 1629ac88567aSHyon Kim if (dnode->ddn_mfg && (topo_prop_set_string(tnode, 1630ac88567aSHyon Kim TOPO_PGROUP_STORAGE, TOPO_STORAGE_MANUFACTURER, 1631ac88567aSHyon Kim TOPO_PROP_IMMUTABLE, dnode->ddn_mfg, &err) != 0)) { 1632ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1633ac88567aSHyon Kim "set mfg error %s\n", topo_strerror(err)); 1634ac88567aSHyon Kim } 1635ac88567aSHyon Kim 1636ac88567aSHyon Kim if (dnode->ddn_model && (topo_prop_set_string(tnode, 1637ac88567aSHyon Kim TOPO_PGROUP_STORAGE, TOPO_STORAGE_MODEL, 1638ac88567aSHyon Kim TOPO_PROP_IMMUTABLE, 1639ac88567aSHyon Kim dnode->ddn_model, &err) != 0)) { 1640ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1641ac88567aSHyon Kim "set model error %s\n", topo_strerror(err)); 1642ac88567aSHyon Kim } 1643ac88567aSHyon Kim 1644ac88567aSHyon Kim if (dnode->ddn_serial && (topo_prop_set_string(tnode, 1645ac88567aSHyon Kim TOPO_PGROUP_STORAGE, TOPO_STORAGE_SERIAL_NUM, 1646ac88567aSHyon Kim TOPO_PROP_IMMUTABLE, 1647ac88567aSHyon Kim dnode->ddn_serial, &err) != 0)) { 1648ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1649ac88567aSHyon Kim "set serial error %s\n", 1650ac88567aSHyon Kim topo_strerror(err)); 1651ac88567aSHyon Kim } 1652ac88567aSHyon Kim 1653ac88567aSHyon Kim if (dnode->ddn_firm && (topo_prop_set_string(tnode, 1654ac88567aSHyon Kim TOPO_PGROUP_STORAGE, 1655ac88567aSHyon Kim TOPO_STORAGE_FIRMWARE_REV, TOPO_PROP_IMMUTABLE, 1656ac88567aSHyon Kim dnode->ddn_firm, &err) != 0)) { 1657ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1658ac88567aSHyon Kim "set firm error %s\n", topo_strerror(err)); 1659ac88567aSHyon Kim } 1660ac88567aSHyon Kim } 1661ac88567aSHyon Kim } 1662ac88567aSHyon Kim 1663940d71d2Seschrock return (0); 1664940d71d2Seschrock 1665940d71d2Seschrock error: 1666940d71d2Seschrock nvlist_free(auth); 1667940d71d2Seschrock nvlist_free(fmri); 1668940d71d2Seschrock return (-1); 1669940d71d2Seschrock } 1670940d71d2Seschrock 1671ac88567aSHyon Kim /* 1672ac88567aSHyon Kim * Create SAS expander specific props. 1673ac88567aSHyon Kim */ 1674ac88567aSHyon Kim /*ARGSUSED*/ 1675ac88567aSHyon Kim static int 1676ac88567aSHyon Kim ses_set_connector_props(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1677ac88567aSHyon Kim tnode_t *tnode, int64_t phy_mask) 1678ac88567aSHyon Kim { 1679ac88567aSHyon Kim ses_node_t *np = snp->sen_node; 1680ac88567aSHyon Kim topo_mod_t *mod = sdp->sed_mod; 1681ac88567aSHyon Kim nvlist_t *props; 1682ac88567aSHyon Kim int err, i; 1683ac88567aSHyon Kim uint64_t conntype; 1684ac88567aSHyon Kim char phymask_str[17], *conntype_str; 1685ac88567aSHyon Kim boolean_t found; 1686ac88567aSHyon Kim 1687ac88567aSHyon Kim props = ses_node_props(np); 1688ac88567aSHyon Kim 1689ac88567aSHyon Kim /* 1690ac88567aSHyon Kim * convert phy mask to string. 1691ac88567aSHyon Kim */ 1692ac88567aSHyon Kim (void) snprintf(phymask_str, 17, "%llx", phy_mask); 1693ac88567aSHyon Kim 1694ac88567aSHyon Kim /* create the storage group */ 1695ac88567aSHyon Kim if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) { 1696ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1697ac88567aSHyon Kim "create storage error %s\n", topo_strerror(err)); 1698ac88567aSHyon Kim return (-1); 1699ac88567aSHyon Kim } else { 1700ac88567aSHyon Kim /* set the SAS address prop of the expander. */ 1701ac88567aSHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE, 1702ac88567aSHyon Kim TOPO_STORAGE_SAS_PHY_MASK, TOPO_PROP_IMMUTABLE, 1703ac88567aSHyon Kim phymask_str, &err) != 0) { 1704ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1705ac88567aSHyon Kim "set %S error %s\n", TOPO_STORAGE_SAS_PHY_MASK, 1706ac88567aSHyon Kim topo_strerror(err)); 1707ac88567aSHyon Kim } 1708ac88567aSHyon Kim 1709ac88567aSHyon Kim /* Get the connector type information for the expander */ 1710ac88567aSHyon Kim if (nvlist_lookup_uint64(props, 1711ac88567aSHyon Kim SES_SC_PROP_CONNECTOR_TYPE, &conntype) != 0) { 1712ac88567aSHyon Kim topo_mod_dprintf(mod, "Failed to get prop %s.", 1713ac88567aSHyon Kim TOPO_STORAGE_SAS_PHY_MASK); 1714ac88567aSHyon Kim } else { 1715ac88567aSHyon Kim found = B_FALSE; 1716ac88567aSHyon Kim for (i = 0; ; i++) { 1717ac88567aSHyon Kim if (sas_connector_type_list[i].type == 1718ac88567aSHyon Kim SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) { 1719ac88567aSHyon Kim break; 1720ac88567aSHyon Kim } 1721ac88567aSHyon Kim if (sas_connector_type_list[i].type == 1722ac88567aSHyon Kim conntype) { 1723ac88567aSHyon Kim conntype_str = 1724ac88567aSHyon Kim sas_connector_type_list[i].name; 1725ac88567aSHyon Kim found = B_TRUE; 1726ac88567aSHyon Kim break; 1727ac88567aSHyon Kim } 1728ac88567aSHyon Kim } 1729ac88567aSHyon Kim 1730ac88567aSHyon Kim if (!found) { 1731ac88567aSHyon Kim if (conntype < 1732ac88567aSHyon Kim SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) { 1733ac88567aSHyon Kim conntype_str = 1734ac88567aSHyon Kim SAS_CONNECTOR_TYPE_RESERVED; 1735ac88567aSHyon Kim } else { 1736ac88567aSHyon Kim conntype_str = 1737ac88567aSHyon Kim SAS_CONNECTOR_TYPE_NOT_DEFINED; 1738ac88567aSHyon Kim } 1739ac88567aSHyon Kim } 1740ac88567aSHyon Kim 1741ac88567aSHyon Kim /* set the phy count prop of the expander. */ 1742ac88567aSHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE, 1743ac88567aSHyon Kim TOPO_STORAGE_SAS_CONNECTOR_TYPE, 1744ac88567aSHyon Kim TOPO_PROP_IMMUTABLE, conntype_str, &err) != 0) { 1745ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1746ac88567aSHyon Kim "set %S error %s\n", TOPO_PROP_PHY_COUNT, 1747ac88567aSHyon Kim topo_strerror(err)); 1748ac88567aSHyon Kim } 1749ac88567aSHyon Kim } 1750ac88567aSHyon Kim } 1751ac88567aSHyon Kim 1752ac88567aSHyon Kim return (0); 1753ac88567aSHyon Kim } 1754ac88567aSHyon Kim 1755ac88567aSHyon Kim /* 1756ac88567aSHyon Kim * Instantiate SAS expander nodes for a given ESC Electronics node(controller) 1757ac88567aSHyon Kim * nodes. 1758ac88567aSHyon Kim */ 1759ac88567aSHyon Kim /*ARGSUSED*/ 1760ac88567aSHyon Kim static int 1761ac88567aSHyon Kim ses_create_esc_sasspecific(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1762ac88567aSHyon Kim tnode_t *pnode, ses_enum_chassis_t *cp, 1763ac88567aSHyon Kim boolean_t dorange) 1764ac88567aSHyon Kim { 1765ac88567aSHyon Kim topo_mod_t *mod = sdp->sed_mod; 1766ac88567aSHyon Kim tnode_t *exptn, *contn; 1767ac88567aSHyon Kim boolean_t found; 1768ac88567aSHyon Kim sas_connector_phy_data_t connectors[64] = {NULL}; 1769ac88567aSHyon Kim uint64_t max; 1770ac88567aSHyon Kim ses_enum_node_t *ctlsnp, *xsnp, *consnp; 1771ac88567aSHyon Kim ses_node_t *np = snp->sen_node; 1772ac88567aSHyon Kim nvlist_t *props, *psprops; 1773ac88567aSHyon Kim uint64_t index, psindex, conindex, psstatus, i, j, count; 1774ac88567aSHyon Kim int64_t cidxlist[256] = {NULL}; 1775ac88567aSHyon Kim int phycount; 1776ac88567aSHyon Kim 1777ac88567aSHyon Kim props = ses_node_props(np); 1778ac88567aSHyon Kim 1779ac88567aSHyon Kim if (nvlist_lookup_uint64(props, SES_PROP_ELEMENT_ONLY_INDEX, 1780ac88567aSHyon Kim &index) != 0) 1781ac88567aSHyon Kim return (-1); 1782ac88567aSHyon Kim 1783ac88567aSHyon Kim /* 1784ac88567aSHyon Kim * For SES constroller node, check to see if there are 1785ac88567aSHyon Kim * associated SAS expanders. 1786ac88567aSHyon Kim */ 1787ac88567aSHyon Kim found = B_FALSE; 1788ac88567aSHyon Kim max = 0; 1789ac88567aSHyon Kim for (ctlsnp = topo_list_next(&cp->sec_nodes); ctlsnp != NULL; 1790ac88567aSHyon Kim ctlsnp = topo_list_next(ctlsnp)) { 1791ac88567aSHyon Kim if (ctlsnp->sen_type == SES_ET_SAS_EXPANDER) { 1792ac88567aSHyon Kim found = B_TRUE; 1793ac88567aSHyon Kim if (ctlsnp->sen_instance > max) 1794ac88567aSHyon Kim max = ctlsnp->sen_instance; 1795ac88567aSHyon Kim } 1796ac88567aSHyon Kim } 1797ac88567aSHyon Kim 1798ac88567aSHyon Kim /* 1799ac88567aSHyon Kim * No SAS expander found notthing to process. 1800ac88567aSHyon Kim */ 1801ac88567aSHyon Kim if (!found) 1802ac88567aSHyon Kim return (0); 1803ac88567aSHyon Kim 1804ac88567aSHyon Kim topo_mod_dprintf(mod, "%s Controller %d: creating " 1805ac88567aSHyon Kim "%llu %s nodes", cp->sec_csn, index, max + 1, SASEXPANDER); 1806ac88567aSHyon Kim 1807ac88567aSHyon Kim /* 1808ac88567aSHyon Kim * The max number represent the number of elements 1809ac88567aSHyon Kim * deducted from the highest SES_PROP_ELEMENT_CLASS_INDEX 1810ac88567aSHyon Kim * of SET_ET_SAS_EXPANDER type element. 1811ac88567aSHyon Kim * 1812ac88567aSHyon Kim * There may be multiple ESC Electronics element(controllers) 1813ac88567aSHyon Kim * within JBOD(typicall two for redundancy) and SAS expander 1814ac88567aSHyon Kim * elements are associated with only one of them. We are 1815ac88567aSHyon Kim * still creating the range based max number here. 1816ac88567aSHyon Kim * That will cover the case that all expanders are associated 1817ac88567aSHyon Kim * with one SES controller. 1818ac88567aSHyon Kim */ 1819ac88567aSHyon Kim if (dorange && topo_node_range_create(mod, pnode, 1820ac88567aSHyon Kim SASEXPANDER, 0, max) != 0) { 1821ac88567aSHyon Kim topo_mod_dprintf(mod, 1822ac88567aSHyon Kim "topo_node_create_range() failed: %s", 1823ac88567aSHyon Kim topo_mod_errmsg(mod)); 1824ac88567aSHyon Kim return (-1); 1825ac88567aSHyon Kim } 1826ac88567aSHyon Kim 1827ac88567aSHyon Kim /* 1828ac88567aSHyon Kim * Search exapnders with the parent index matching with 1829ac88567aSHyon Kim * ESC Electronics element index. 1830ac88567aSHyon Kim * Note the index used here is a global index across 1831ac88567aSHyon Kim * SES elements. 1832ac88567aSHyon Kim */ 1833ac88567aSHyon Kim for (xsnp = topo_list_next(&cp->sec_nodes); xsnp != NULL; 1834ac88567aSHyon Kim xsnp = topo_list_next(xsnp)) { 1835ac88567aSHyon Kim if (xsnp->sen_type == SES_ET_SAS_EXPANDER) { 1836ac88567aSHyon Kim /* 1837ac88567aSHyon Kim * get the parent ESC controller. 1838ac88567aSHyon Kim */ 1839ac88567aSHyon Kim psprops = ses_node_props(xsnp->sen_node); 1840ac88567aSHyon Kim if (nvlist_lookup_uint64(psprops, 1841ac88567aSHyon Kim SES_PROP_STATUS_CODE, &psstatus) == 0) { 1842ac88567aSHyon Kim if (psstatus == SES_ESC_NOT_INSTALLED) { 1843ac88567aSHyon Kim /* 1844ac88567aSHyon Kim * Not installed. 1845ac88567aSHyon Kim * Don't create a ndoe. 1846ac88567aSHyon Kim */ 1847ac88567aSHyon Kim continue; 1848ac88567aSHyon Kim } 1849ac88567aSHyon Kim } else { 1850ac88567aSHyon Kim /* 1851ac88567aSHyon Kim * The element should have status code. 1852ac88567aSHyon Kim * If not there is no way to find 1853ac88567aSHyon Kim * out if the expander element exist or 1854ac88567aSHyon Kim * not. 1855ac88567aSHyon Kim */ 1856ac88567aSHyon Kim continue; 1857ac88567aSHyon Kim } 1858ac88567aSHyon Kim 1859ac88567aSHyon Kim /* Get the physical parent index to compare. */ 1860ac88567aSHyon Kim if (nvlist_lookup_uint64(psprops, 1861ac88567aSHyon Kim LIBSES_PROP_PHYS_PARENT, &psindex) == 0) { 1862ac88567aSHyon Kim if (index == psindex) { 1863ac88567aSHyon Kim /* indentation moved forward */ 1864ac88567aSHyon Kim /* 1865ac88567aSHyon Kim * Handle basic node information of SAS expander 1866ac88567aSHyon Kim * element - binding to parent node and 1867ac88567aSHyon Kim * allocating FMRI... 1868ac88567aSHyon Kim */ 1869ac88567aSHyon Kim if (ses_create_generic(sdp, xsnp, pnode, SASEXPANDER, 1870ac88567aSHyon Kim "SAS-EXPANDER", &exptn) != 0) 1871ac88567aSHyon Kim continue; 1872ac88567aSHyon Kim /* 1873ac88567aSHyon Kim * Now handle SAS expander unique portion of node creation. 1874ac88567aSHyon Kim * The max nubmer of the phy count is 256 since SES-2 1875ac88567aSHyon Kim * defines as 1 byte field. The cidxlist has the same 1876ac88567aSHyon Kim * number of elements. 1877ac88567aSHyon Kim * 1878ac88567aSHyon Kim * We use size 64 array to store the connectors. 1879ac88567aSHyon Kim * Typically a connectors associated with 4 phys so that 1880ac88567aSHyon Kim * matches with the max number of connecters associated 1881ac88567aSHyon Kim * with an expander. 1882ac88567aSHyon Kim * The phy count goes up to 38 for Sun supported 1883ac88567aSHyon Kim * JBOD. 1884ac88567aSHyon Kim */ 1885ac88567aSHyon Kim memset(cidxlist, 0, sizeof (int64_t) * 64); 1886ac88567aSHyon Kim if (ses_set_expander_props(sdp, xsnp, pnode, exptn, &phycount, 1887ac88567aSHyon Kim cidxlist) != 0) { 1888ac88567aSHyon Kim /* 1889ac88567aSHyon Kim * error on getting specific prop failed. 1890ac88567aSHyon Kim * continue on. Note that the node is 1891ac88567aSHyon Kim * left bound. 1892ac88567aSHyon Kim */ 1893ac88567aSHyon Kim continue; 1894ac88567aSHyon Kim } 1895ac88567aSHyon Kim 1896ac88567aSHyon Kim /* 1897ac88567aSHyon Kim * count represetns the number of connectors discovered so far. 1898ac88567aSHyon Kim */ 1899ac88567aSHyon Kim count = 0; 1900ac88567aSHyon Kim memset(connectors, 0, sizeof (sas_connector_phy_data_t) * 64); 1901ac88567aSHyon Kim for (i = 0; i < phycount; i++) { 1902ac88567aSHyon Kim if (cidxlist[i] != -1) { 1903ac88567aSHyon Kim /* connector index is valid. */ 1904ac88567aSHyon Kim for (j = 0; j < count; j++) { 1905ac88567aSHyon Kim if (connectors[j].index == 1906ac88567aSHyon Kim cidxlist[i]) { 1907ac88567aSHyon Kim /* 1908ac88567aSHyon Kim * Just update phy mask. 1909ac88567aSHyon Kim * The postion for connector 1910ac88567aSHyon Kim * index lists(cidxlist index) 1911ac88567aSHyon Kim * is set. 1912ac88567aSHyon Kim */ 1913ac88567aSHyon Kim connectors[j].phy_mask = 1914ac88567aSHyon Kim connectors[j].phy_mask | 1915ac88567aSHyon Kim (1ULL << i); 1916ac88567aSHyon Kim break; 1917ac88567aSHyon Kim } 1918ac88567aSHyon Kim } 1919ac88567aSHyon Kim /* 1920ac88567aSHyon Kim * If j and count matche a new connector 1921ac88567aSHyon Kim * index is found. 1922ac88567aSHyon Kim */ 1923ac88567aSHyon Kim if (j == count) { 1924ac88567aSHyon Kim /* add a new index and phy mask. */ 1925ac88567aSHyon Kim connectors[count].index = cidxlist[i]; 1926ac88567aSHyon Kim connectors[count].phy_mask = 1927ac88567aSHyon Kim connectors[count].phy_mask | 1928ac88567aSHyon Kim (1ULL << i); 1929ac88567aSHyon Kim count++; 1930ac88567aSHyon Kim } 1931ac88567aSHyon Kim } 1932ac88567aSHyon Kim } 1933ac88567aSHyon Kim 1934ac88567aSHyon Kim /* 1935ac88567aSHyon Kim * create range for the connector nodes. 1936ac88567aSHyon Kim * The class index of the ses connector element 1937ac88567aSHyon Kim * is set as the instance nubmer for the node. 1938ac88567aSHyon Kim * Even though one expander may not have all connectors 1939ac88567aSHyon Kim * are associated with we are creating the range with 1940ac88567aSHyon Kim * max possible instance number. 1941ac88567aSHyon Kim */ 1942ac88567aSHyon Kim found = B_FALSE; 1943ac88567aSHyon Kim max = 0; 1944ac88567aSHyon Kim for (consnp = topo_list_next(&cp->sec_nodes); 1945ac88567aSHyon Kim consnp != NULL; consnp = topo_list_next(consnp)) { 1946ac88567aSHyon Kim if (consnp->sen_type == SES_ET_SAS_CONNECTOR) { 1947ac88567aSHyon Kim psprops = ses_node_props(consnp->sen_node); 1948ac88567aSHyon Kim found = B_TRUE; 1949ac88567aSHyon Kim if (consnp->sen_instance > max) 1950ac88567aSHyon Kim max = consnp->sen_instance; 1951ac88567aSHyon Kim } 1952ac88567aSHyon Kim } 1953ac88567aSHyon Kim 1954ac88567aSHyon Kim /* 1955ac88567aSHyon Kim * No SAS connector found nothing to process. 1956ac88567aSHyon Kim */ 1957ac88567aSHyon Kim if (!found) 1958ac88567aSHyon Kim return (0); 1959ac88567aSHyon Kim 1960ac88567aSHyon Kim if (dorange && topo_node_range_create(mod, exptn, 1961ac88567aSHyon Kim RECEPTACLE, 0, max) != 0) { 1962ac88567aSHyon Kim topo_mod_dprintf(mod, 1963ac88567aSHyon Kim "topo_node_create_range() failed: %s", 1964ac88567aSHyon Kim topo_mod_errmsg(mod)); 1965ac88567aSHyon Kim return (-1); 1966ac88567aSHyon Kim } 1967ac88567aSHyon Kim 1968ac88567aSHyon Kim /* search matching connector element using the index. */ 1969ac88567aSHyon Kim for (i = 0; i < count; i++) { 1970ac88567aSHyon Kim found = B_FALSE; 1971ac88567aSHyon Kim for (consnp = topo_list_next(&cp->sec_nodes); 1972ac88567aSHyon Kim consnp != NULL; consnp = topo_list_next(consnp)) { 1973ac88567aSHyon Kim if (consnp->sen_type == SES_ET_SAS_CONNECTOR) { 1974ac88567aSHyon Kim psprops = ses_node_props( 1975ac88567aSHyon Kim consnp->sen_node); 1976ac88567aSHyon Kim /* 1977ac88567aSHyon Kim * Get the physical parent index to 1978ac88567aSHyon Kim * compare. 1979ac88567aSHyon Kim * The connector elements are children 1980ac88567aSHyon Kim * of ESC Electronics element even 1981ac88567aSHyon Kim * though we enumerate them under 1982ac88567aSHyon Kim * an expander in libtopo. 1983ac88567aSHyon Kim */ 1984ac88567aSHyon Kim if (nvlist_lookup_uint64(psprops, 1985ac88567aSHyon Kim SES_PROP_ELEMENT_ONLY_INDEX, 1986ac88567aSHyon Kim &conindex) == 0) { 1987ac88567aSHyon Kim if (conindex == 1988ac88567aSHyon Kim connectors[i].index) { 1989ac88567aSHyon Kim found = B_TRUE; 1990ac88567aSHyon Kim break; 1991ac88567aSHyon Kim } 1992ac88567aSHyon Kim } 1993ac88567aSHyon Kim } 1994ac88567aSHyon Kim } 1995ac88567aSHyon Kim 1996ac88567aSHyon Kim /* now create a libtopo node. */ 1997ac88567aSHyon Kim if (found) { 1998ac88567aSHyon Kim /* Create generic props. */ 1999ac88567aSHyon Kim if (ses_create_generic(sdp, consnp, exptn, 2000ac88567aSHyon Kim RECEPTACLE, "RECEPTACLE", &contn) != 2001ac88567aSHyon Kim 0) { 2002ac88567aSHyon Kim continue; 2003ac88567aSHyon Kim } 2004ac88567aSHyon Kim /* Create connector specific props. */ 2005ac88567aSHyon Kim if (ses_set_connector_props(sdp, consnp, 2006ac88567aSHyon Kim contn, connectors[i].phy_mask) != 0) { 2007ac88567aSHyon Kim continue; 2008ac88567aSHyon Kim } 2009ac88567aSHyon Kim } 2010ac88567aSHyon Kim } 2011ac88567aSHyon Kim /* end indentation change */ 2012ac88567aSHyon Kim } 2013ac88567aSHyon Kim } 2014ac88567aSHyon Kim } 2015ac88567aSHyon Kim } 2016ac88567aSHyon Kim 2017ac88567aSHyon Kim return (0); 2018ac88567aSHyon Kim } 2019ac88567aSHyon Kim 2020ac88567aSHyon Kim /* 2021ac88567aSHyon Kim * Instantiate any protocol specific portion of a node. 2022ac88567aSHyon Kim */ 2023ac88567aSHyon Kim /*ARGSUSED*/ 2024ac88567aSHyon Kim static int 2025ac88567aSHyon Kim ses_create_protocol_specific(ses_enum_data_t *sdp, ses_enum_node_t *snp, 2026ac88567aSHyon Kim tnode_t *pnode, uint64_t type, ses_enum_chassis_t *cp, 2027ac88567aSHyon Kim boolean_t dorange) 2028ac88567aSHyon Kim { 2029ac88567aSHyon Kim 2030ac88567aSHyon Kim if (type == SES_ET_ESC_ELECTRONICS) { 2031ac88567aSHyon Kim /* create SAS specific children(expanders and connectors. */ 2032ac88567aSHyon Kim return (ses_create_esc_sasspecific(sdp, snp, pnode, cp, 2033ac88567aSHyon Kim dorange)); 2034ac88567aSHyon Kim } 2035ac88567aSHyon Kim 2036ac88567aSHyon Kim return (0); 2037ac88567aSHyon Kim } 2038ac88567aSHyon Kim 2039940d71d2Seschrock /* 2040940d71d2Seschrock * Instantiate any children of a given type. 2041940d71d2Seschrock */ 2042940d71d2Seschrock static int 2043940d71d2Seschrock ses_create_children(ses_enum_data_t *sdp, tnode_t *pnode, uint64_t type, 2044d91236feSeschrock const char *nodename, const char *defaultlabel, ses_enum_chassis_t *cp, 2045d91236feSeschrock boolean_t dorange) 2046940d71d2Seschrock { 2047940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 2048940d71d2Seschrock boolean_t found; 2049940d71d2Seschrock uint64_t max; 2050940d71d2Seschrock ses_enum_node_t *snp; 2051ac88567aSHyon Kim tnode_t *tn; 2052940d71d2Seschrock 2053940d71d2Seschrock /* 2054940d71d2Seschrock * First go through and count how many matching nodes we have. 2055940d71d2Seschrock */ 2056940d71d2Seschrock max = 0; 2057940d71d2Seschrock found = B_FALSE; 2058940d71d2Seschrock for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2059940d71d2Seschrock snp = topo_list_next(snp)) { 2060940d71d2Seschrock if (snp->sen_type == type) { 2061940d71d2Seschrock found = B_TRUE; 2062940d71d2Seschrock if (snp->sen_instance > max) 2063940d71d2Seschrock max = snp->sen_instance; 2064940d71d2Seschrock } 2065940d71d2Seschrock } 2066940d71d2Seschrock 2067940d71d2Seschrock /* 2068940d71d2Seschrock * No enclosure should export both DEVICE and ARRAY_DEVICE elements. 2069940d71d2Seschrock * Since we map both of these to 'disk', if an enclosure does this, we 2070940d71d2Seschrock * just ignore the array elements. 2071940d71d2Seschrock */ 2072940d71d2Seschrock if (!found || 2073940d71d2Seschrock (type == SES_ET_ARRAY_DEVICE && cp->sec_hasdev)) 2074940d71d2Seschrock return (0); 2075940d71d2Seschrock 2076940d71d2Seschrock topo_mod_dprintf(mod, "%s: creating %llu %s nodes", 207753dbcc59SSundeep Panicker cp->sec_csn, max + 1, nodename); 2078940d71d2Seschrock 2079d91236feSeschrock if (dorange && topo_node_range_create(mod, pnode, 2080940d71d2Seschrock nodename, 0, max) != 0) { 2081940d71d2Seschrock topo_mod_dprintf(mod, 2082940d71d2Seschrock "topo_node_create_range() failed: %s", 2083940d71d2Seschrock topo_mod_errmsg(mod)); 2084940d71d2Seschrock return (-1); 2085940d71d2Seschrock } 2086940d71d2Seschrock 2087940d71d2Seschrock for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2088940d71d2Seschrock snp = topo_list_next(snp)) { 2089940d71d2Seschrock if (snp->sen_type == type) { 2090940d71d2Seschrock if (ses_create_generic(sdp, snp, pnode, 2091ac88567aSHyon Kim nodename, defaultlabel, &tn) != 0) 2092940d71d2Seschrock return (-1); 2093ac88567aSHyon Kim /* 2094ac88567aSHyon Kim * For some SES element there may be protocol specific 2095ac88567aSHyon Kim * information to process. Here we are processing 2096ac88567aSHyon Kim * the association between enclosure controller and 2097ac88567aSHyon Kim * SAS expanders. 2098ac88567aSHyon Kim */ 2099ac88567aSHyon Kim if (type == SES_ET_ESC_ELECTRONICS) { 2100ac88567aSHyon Kim /* create SAS expander node */ 2101ac88567aSHyon Kim if (ses_create_protocol_specific(sdp, snp, 2102ac88567aSHyon Kim tn, type, cp, dorange) != 0) { 2103ac88567aSHyon Kim return (-1); 2104ac88567aSHyon Kim } 2105ac88567aSHyon Kim } 2106ac88567aSHyon Kim 2107940d71d2Seschrock } 2108940d71d2Seschrock } 2109940d71d2Seschrock 2110940d71d2Seschrock return (0); 2111940d71d2Seschrock } 2112940d71d2Seschrock 211353dbcc59SSundeep Panicker /* 211453dbcc59SSundeep Panicker * Instantiate a new subchassis instance in the topology. 211553dbcc59SSundeep Panicker */ 211653dbcc59SSundeep Panicker static int 211753dbcc59SSundeep Panicker ses_create_subchassis(ses_enum_data_t *sdp, tnode_t *pnode, 211853dbcc59SSundeep Panicker ses_enum_chassis_t *scp) 211953dbcc59SSundeep Panicker { 212053dbcc59SSundeep Panicker topo_mod_t *mod = sdp->sed_mod; 212153dbcc59SSundeep Panicker tnode_t *tn; 212253dbcc59SSundeep Panicker nvlist_t *props; 212353dbcc59SSundeep Panicker nvlist_t *auth = NULL, *fmri = NULL; 212453dbcc59SSundeep Panicker uint64_t instance = scp->sec_instance; 212553dbcc59SSundeep Panicker char *desc; 212653dbcc59SSundeep Panicker char label[128]; 212753dbcc59SSundeep Panicker char **paths; 212853dbcc59SSundeep Panicker int i, err; 212953dbcc59SSundeep Panicker ses_enum_target_t *stp; 213053dbcc59SSundeep Panicker int ret = -1; 213153dbcc59SSundeep Panicker 213253dbcc59SSundeep Panicker /* 213353dbcc59SSundeep Panicker * Copy authority information from parent enclosure node 213453dbcc59SSundeep Panicker */ 213553dbcc59SSundeep Panicker if ((auth = topo_mod_auth(mod, pnode)) == NULL) 213653dbcc59SSundeep Panicker goto error; 213753dbcc59SSundeep Panicker 213853dbcc59SSundeep Panicker /* 213953dbcc59SSundeep Panicker * Record the subchassis serial number in the FMRI. 214053dbcc59SSundeep Panicker * For now, we assume that logical id is the subchassis serial number. 214153dbcc59SSundeep Panicker * If this assumption changes in future, then the following 214253dbcc59SSundeep Panicker * piece of code will need to be updated via an RFE. 214353dbcc59SSundeep Panicker */ 214453dbcc59SSundeep Panicker if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION, 2145ac88567aSHyon Kim SUBCHASSIS, (topo_instance_t)instance, NULL, auth, NULL, NULL, 2146ac88567aSHyon Kim NULL)) == NULL) { 214753dbcc59SSundeep Panicker topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s", 214853dbcc59SSundeep Panicker topo_mod_errmsg(mod)); 214953dbcc59SSundeep Panicker goto error; 215053dbcc59SSundeep Panicker } 215153dbcc59SSundeep Panicker 215253dbcc59SSundeep Panicker if ((tn = topo_node_bind(mod, pnode, SUBCHASSIS, 215353dbcc59SSundeep Panicker instance, fmri)) == NULL) { 215453dbcc59SSundeep Panicker topo_mod_dprintf(mod, "topo_node_bind() failed: %s", 215553dbcc59SSundeep Panicker topo_mod_errmsg(mod)); 215653dbcc59SSundeep Panicker goto error; 215753dbcc59SSundeep Panicker } 215853dbcc59SSundeep Panicker 215953dbcc59SSundeep Panicker props = ses_node_props(scp->sec_enclosure); 216053dbcc59SSundeep Panicker 216153dbcc59SSundeep Panicker /* 216253dbcc59SSundeep Panicker * Look for the subchassis label in the following order: 216353dbcc59SSundeep Panicker * <ses-description> 216453dbcc59SSundeep Panicker * <ses-class-description> <instance> 216553dbcc59SSundeep Panicker * <default-type-label> <instance> 216653dbcc59SSundeep Panicker * 216753dbcc59SSundeep Panicker * For subchassis, the default label is "SUBCHASSIS" 216853dbcc59SSundeep Panicker */ 216953dbcc59SSundeep Panicker if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 || 217053dbcc59SSundeep Panicker desc[0] == '\0') { 217153dbcc59SSundeep Panicker if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION, 217253dbcc59SSundeep Panicker &desc) == 0 && desc[0] != '\0') 217353dbcc59SSundeep Panicker (void) snprintf(label, sizeof (label), "%s %llu", desc, 217453dbcc59SSundeep Panicker instance); 217553dbcc59SSundeep Panicker else 217653dbcc59SSundeep Panicker (void) snprintf(label, sizeof (label), 217753dbcc59SSundeep Panicker "SUBCHASSIS %llu", instance); 217853dbcc59SSundeep Panicker desc = label; 217953dbcc59SSundeep Panicker } 218053dbcc59SSundeep Panicker 218153dbcc59SSundeep Panicker if (topo_node_label_set(tn, desc, &err) != 0) 218253dbcc59SSundeep Panicker goto error; 218353dbcc59SSundeep Panicker 2184ac88567aSHyon Kim if (ses_set_standard_props(mod, NULL, tn, NULL, 218553dbcc59SSundeep Panicker ses_node_id(scp->sec_enclosure), scp->sec_target->set_devpath) != 0) 218653dbcc59SSundeep Panicker goto error; 218753dbcc59SSundeep Panicker 2188ac88567aSHyon Kim /* 2189ac88567aSHyon Kim * Set the 'chassis-type' property for this subchassis. This is either 2190ac88567aSHyon Kim * 'ses-class-description' or 'subchassis'. 2191ac88567aSHyon Kim */ 2192ac88567aSHyon Kim if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION, &desc) != 0) 2193ac88567aSHyon Kim desc = "subchassis"; 2194ac88567aSHyon Kim 2195ac88567aSHyon Kim if (topo_prop_set_string(tn, TOPO_PGROUP_SES, 2196ac88567aSHyon Kim TOPO_PROP_CHASSIS_TYPE, TOPO_PROP_IMMUTABLE, desc, &err) != 0) { 2197ac88567aSHyon Kim topo_mod_dprintf(mod, "failed to create property %s: %s\n", 2198ac88567aSHyon Kim TOPO_PROP_CHASSIS_TYPE, topo_strerror(err)); 2199ac88567aSHyon Kim goto error; 2200ac88567aSHyon Kim } 2201ac88567aSHyon Kim 220253dbcc59SSundeep Panicker /* 220353dbcc59SSundeep Panicker * For enclosures, we want to include all possible targets (for upgrade 220453dbcc59SSundeep Panicker * purposes). 220553dbcc59SSundeep Panicker */ 220653dbcc59SSundeep Panicker for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL; 220753dbcc59SSundeep Panicker stp = topo_list_next(stp), i++) 220853dbcc59SSundeep Panicker ; 220953dbcc59SSundeep Panicker 221053dbcc59SSundeep Panicker verify(i != 0); 221153dbcc59SSundeep Panicker paths = alloca(i * sizeof (char *)); 221253dbcc59SSundeep Panicker 221353dbcc59SSundeep Panicker for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL; 221453dbcc59SSundeep Panicker stp = topo_list_next(stp), i++) 221553dbcc59SSundeep Panicker paths[i] = stp->set_devpath; 221653dbcc59SSundeep Panicker 221753dbcc59SSundeep Panicker if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES, 221853dbcc59SSundeep Panicker TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths, 221953dbcc59SSundeep Panicker i, &err) != 0) { 222053dbcc59SSundeep Panicker topo_mod_dprintf(mod, "failed to create property %s: %s\n", 222153dbcc59SSundeep Panicker TOPO_PROP_PATHS, topo_strerror(err)); 222253dbcc59SSundeep Panicker goto error; 222353dbcc59SSundeep Panicker } 222453dbcc59SSundeep Panicker 222553dbcc59SSundeep Panicker if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) { 222653dbcc59SSundeep Panicker topo_mod_dprintf(mod, "topo_method_register() failed: %s", 222753dbcc59SSundeep Panicker topo_mod_errmsg(mod)); 222853dbcc59SSundeep Panicker goto error; 222953dbcc59SSundeep Panicker } 223053dbcc59SSundeep Panicker 223153dbcc59SSundeep Panicker /* 223253dbcc59SSundeep Panicker * Create the nodes for controllers and bays. 223353dbcc59SSundeep Panicker */ 223453dbcc59SSundeep Panicker if (ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS, 223553dbcc59SSundeep Panicker CONTROLLER, "CONTROLLER", scp, B_TRUE) != 0 || 223653dbcc59SSundeep Panicker ses_create_children(sdp, tn, SES_ET_DEVICE, 223753dbcc59SSundeep Panicker BAY, "BAY", scp, B_TRUE) != 0 || 223853dbcc59SSundeep Panicker ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE, 223953dbcc59SSundeep Panicker BAY, "BAY", scp, B_TRUE) != 0) 224053dbcc59SSundeep Panicker goto error; 224153dbcc59SSundeep Panicker 224253dbcc59SSundeep Panicker ret = 0; 224353dbcc59SSundeep Panicker 224453dbcc59SSundeep Panicker error: 224553dbcc59SSundeep Panicker nvlist_free(auth); 224653dbcc59SSundeep Panicker nvlist_free(fmri); 224753dbcc59SSundeep Panicker return (ret); 224853dbcc59SSundeep Panicker } 224953dbcc59SSundeep Panicker 2250940d71d2Seschrock /* 2251940d71d2Seschrock * Instantiate a new chassis instance in the topology. 2252940d71d2Seschrock */ 2253940d71d2Seschrock static int 2254940d71d2Seschrock ses_create_chassis(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp) 2255940d71d2Seschrock { 2256940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 2257940d71d2Seschrock nvlist_t *props; 2258940d71d2Seschrock char *raw_manufacturer, *raw_model, *raw_revision; 2259940d71d2Seschrock char *manufacturer = NULL, *model = NULL, *product = NULL; 2260940d71d2Seschrock char *revision = NULL; 2261940d71d2Seschrock char *serial; 22626efb64caSEric Schrock char **paths; 2263940d71d2Seschrock size_t prodlen; 2264940d71d2Seschrock tnode_t *tn; 2265940d71d2Seschrock nvlist_t *fmri = NULL, *auth = NULL; 2266940d71d2Seschrock int ret = -1; 2267940d71d2Seschrock ses_enum_node_t *snp; 22686efb64caSEric Schrock ses_enum_target_t *stp; 226953dbcc59SSundeep Panicker ses_enum_chassis_t *scp; 22706efb64caSEric Schrock int i, err; 227153dbcc59SSundeep Panicker uint64_t sc_count = 0; 2272940d71d2Seschrock 2273d91236feSeschrock /* 2274d91236feSeschrock * Ignore any internal enclosures. 2275d91236feSeschrock */ 2276d91236feSeschrock if (cp->sec_internal) 2277d91236feSeschrock return (0); 2278d91236feSeschrock 2279940d71d2Seschrock /* 2280940d71d2Seschrock * Check to see if there are any devices presennt in the chassis. If 2281940d71d2Seschrock * not, ignore the chassis alltogether. This is most useful for 2282940d71d2Seschrock * ignoring internal HBAs that present a SES target but don't actually 2283940d71d2Seschrock * manage any of the devices. 2284940d71d2Seschrock */ 2285940d71d2Seschrock for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2286940d71d2Seschrock snp = topo_list_next(snp)) { 2287940d71d2Seschrock if (snp->sen_type == SES_ET_DEVICE || 2288940d71d2Seschrock snp->sen_type == SES_ET_ARRAY_DEVICE) 2289940d71d2Seschrock break; 2290940d71d2Seschrock } 2291940d71d2Seschrock 2292940d71d2Seschrock if (snp == NULL) 2293940d71d2Seschrock return (0); 2294940d71d2Seschrock 2295940d71d2Seschrock props = ses_node_props(cp->sec_enclosure); 2296940d71d2Seschrock 2297940d71d2Seschrock /* 2298940d71d2Seschrock * We use the following property mappings: 2299940d71d2Seschrock * 2300940d71d2Seschrock * manufacturer vendor-id 2301940d71d2Seschrock * model product-id 2302940d71d2Seschrock * serial-number libses-chassis-serial 2303940d71d2Seschrock */ 2304940d71d2Seschrock verify(nvlist_lookup_string(props, SES_EN_PROP_VID, 2305940d71d2Seschrock &raw_manufacturer) == 0); 2306940d71d2Seschrock verify(nvlist_lookup_string(props, SES_EN_PROP_PID, &raw_model) == 0); 2307940d71d2Seschrock verify(nvlist_lookup_string(props, SES_EN_PROP_REV, 2308940d71d2Seschrock &raw_revision) == 0); 2309940d71d2Seschrock verify(nvlist_lookup_string(props, LIBSES_EN_PROP_CSN, &serial) == 0); 2310940d71d2Seschrock 2311940d71d2Seschrock /* 2312940d71d2Seschrock * To construct the authority information, we 'clean' each string by 2313940d71d2Seschrock * removing any offensive characters and trimmming whitespace. For the 2314940d71d2Seschrock * 'product-id', we use a concatenation of 'manufacturer-model'. We 2315940d71d2Seschrock * also take the numerical serial number and convert it to a string. 2316940d71d2Seschrock */ 2317940d71d2Seschrock if ((manufacturer = disk_auth_clean(mod, raw_manufacturer)) == NULL || 2318940d71d2Seschrock (model = disk_auth_clean(mod, raw_model)) == NULL || 2319940d71d2Seschrock (revision = disk_auth_clean(mod, raw_revision)) == NULL) { 2320940d71d2Seschrock goto error; 2321940d71d2Seschrock } 2322940d71d2Seschrock 2323940d71d2Seschrock prodlen = strlen(manufacturer) + strlen(model) + 2; 2324940d71d2Seschrock if ((product = topo_mod_alloc(mod, prodlen)) == NULL) 2325940d71d2Seschrock goto error; 2326940d71d2Seschrock 2327940d71d2Seschrock (void) snprintf(product, prodlen, "%s-%s", manufacturer, model); 2328940d71d2Seschrock 2329940d71d2Seschrock /* 2330940d71d2Seschrock * Construct the topo node and bind it to our parent. 2331940d71d2Seschrock */ 2332940d71d2Seschrock if (topo_mod_nvalloc(mod, &auth, NV_UNIQUE_NAME) != 0) 2333940d71d2Seschrock goto error; 2334940d71d2Seschrock 2335940d71d2Seschrock if (nvlist_add_string(auth, FM_FMRI_AUTH_PRODUCT, product) != 0 || 2336940d71d2Seschrock nvlist_add_string(auth, FM_FMRI_AUTH_CHASSIS, serial) != 0) { 2337940d71d2Seschrock (void) topo_mod_seterrno(mod, EMOD_NVL_INVAL); 2338940d71d2Seschrock goto error; 2339940d71d2Seschrock } 2340940d71d2Seschrock 2341940d71d2Seschrock /* 2342940d71d2Seschrock * We pass NULL for the parent FMRI because there is no resource 2343940d71d2Seschrock * associated with it. For the toplevel enclosure, we leave the 2344940d71d2Seschrock * serial/part/revision portions empty, which are reserved for 2345940d71d2Seschrock * individual components within the chassis. 2346940d71d2Seschrock */ 2347940d71d2Seschrock if ((fmri = topo_mod_hcfmri(mod, NULL, FM_HC_SCHEME_VERSION, 2348940d71d2Seschrock SES_ENCLOSURE, cp->sec_instance, NULL, auth, 2349940d71d2Seschrock model, revision, serial)) == NULL) { 2350940d71d2Seschrock topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s", 2351940d71d2Seschrock topo_mod_errmsg(mod)); 2352940d71d2Seschrock goto error; 2353940d71d2Seschrock } 2354940d71d2Seschrock 2355940d71d2Seschrock if ((tn = topo_node_bind(mod, pnode, SES_ENCLOSURE, 2356940d71d2Seschrock cp->sec_instance, fmri)) == NULL) { 2357940d71d2Seschrock topo_mod_dprintf(mod, "topo_node_bind() failed: %s", 2358940d71d2Seschrock topo_mod_errmsg(mod)); 2359940d71d2Seschrock goto error; 2360940d71d2Seschrock } 2361940d71d2Seschrock 2362940d71d2Seschrock if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) { 2363940d71d2Seschrock topo_mod_dprintf(mod, 2364940d71d2Seschrock "topo_method_register() failed: %s", 2365940d71d2Seschrock topo_mod_errmsg(mod)); 2366940d71d2Seschrock goto error; 2367940d71d2Seschrock } 2368940d71d2Seschrock 2369ac88567aSHyon Kim if (ses_set_standard_props(mod, NULL, tn, auth, 2370940d71d2Seschrock ses_node_id(cp->sec_enclosure), cp->sec_target->set_devpath) != 0) 2371940d71d2Seschrock goto error; 2372940d71d2Seschrock 23736efb64caSEric Schrock /* 23746efb64caSEric Schrock * For enclosures, we want to include all possible targets (for upgrade 23756efb64caSEric Schrock * purposes). 23766efb64caSEric Schrock */ 23776efb64caSEric Schrock for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL; 23786efb64caSEric Schrock stp = topo_list_next(stp), i++) 23796efb64caSEric Schrock ; 23806efb64caSEric Schrock 23816efb64caSEric Schrock verify(i != 0); 23826efb64caSEric Schrock paths = alloca(i * sizeof (char *)); 23836efb64caSEric Schrock 23846efb64caSEric Schrock for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL; 23856efb64caSEric Schrock stp = topo_list_next(stp), i++) 23866efb64caSEric Schrock paths[i] = stp->set_devpath; 23876efb64caSEric Schrock 23886efb64caSEric Schrock 23896efb64caSEric Schrock if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES, 23906efb64caSEric Schrock TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths, 23916efb64caSEric Schrock i, &err) != 0) { 23926efb64caSEric Schrock topo_mod_dprintf(mod, 23936efb64caSEric Schrock "failed to create property %s: %s\n", 23946efb64caSEric Schrock TOPO_PROP_PATHS, topo_strerror(err)); 23956efb64caSEric Schrock goto error; 23966efb64caSEric Schrock } 23976efb64caSEric Schrock 2398940d71d2Seschrock /* 2399ac88567aSHyon Kim * Create the nodes for power supplies, fans, controllers and devices. 2400ac88567aSHyon Kim * Note that SAS exopander nodes and connector nodes are handled 2401ac88567aSHyon Kim * through protocol specific processing of controllers. 2402940d71d2Seschrock */ 2403940d71d2Seschrock if (ses_create_children(sdp, tn, SES_ET_POWER_SUPPLY, 2404d91236feSeschrock PSU, "PSU", cp, B_TRUE) != 0 || 2405940d71d2Seschrock ses_create_children(sdp, tn, SES_ET_COOLING, 2406d91236feSeschrock FAN, "FAN", cp, B_TRUE) != 0 || 2407940d71d2Seschrock ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS, 2408d91236feSeschrock CONTROLLER, "CONTROLLER", cp, B_TRUE) != 0 || 2409940d71d2Seschrock ses_create_children(sdp, tn, SES_ET_DEVICE, 2410d91236feSeschrock BAY, "BAY", cp, B_TRUE) != 0 || 2411940d71d2Seschrock ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE, 2412d91236feSeschrock BAY, "BAY", cp, B_TRUE) != 0) 2413940d71d2Seschrock goto error; 2414940d71d2Seschrock 2415ac88567aSHyon Kim if (cp->sec_maxinstance >= 0 && 2416ac88567aSHyon Kim (topo_node_range_create(mod, tn, SUBCHASSIS, 0, 2417ac88567aSHyon Kim cp->sec_maxinstance) != 0)) { 241853dbcc59SSundeep Panicker topo_mod_dprintf(mod, "topo_node_create_range() failed: %s", 241953dbcc59SSundeep Panicker topo_mod_errmsg(mod)); 242053dbcc59SSundeep Panicker goto error; 242153dbcc59SSundeep Panicker } 242253dbcc59SSundeep Panicker 242353dbcc59SSundeep Panicker for (scp = topo_list_next(&cp->sec_subchassis); scp != NULL; 242453dbcc59SSundeep Panicker scp = topo_list_next(scp)) { 242553dbcc59SSundeep Panicker 242653dbcc59SSundeep Panicker if (ses_create_subchassis(sdp, tn, scp) != 0) 242753dbcc59SSundeep Panicker goto error; 242853dbcc59SSundeep Panicker 242953dbcc59SSundeep Panicker topo_mod_dprintf(mod, "created Subchassis node with " 2430ac88567aSHyon Kim "instance %u\nand target (%s) under Chassis with CSN %s", 2431ac88567aSHyon Kim scp->sec_instance, scp->sec_target->set_devpath, 2432ac88567aSHyon Kim cp->sec_csn); 243353dbcc59SSundeep Panicker 243453dbcc59SSundeep Panicker sc_count++; 243553dbcc59SSundeep Panicker } 243653dbcc59SSundeep Panicker 243753dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: created %llu %s nodes", 243853dbcc59SSundeep Panicker cp->sec_csn, sc_count, SUBCHASSIS); 243953dbcc59SSundeep Panicker 24406efb64caSEric Schrock cp->sec_target->set_refcount++; 24416efb64caSEric Schrock topo_node_setspecific(tn, cp->sec_target); 2442d91236feSeschrock 2443940d71d2Seschrock ret = 0; 2444940d71d2Seschrock error: 2445940d71d2Seschrock topo_mod_strfree(mod, manufacturer); 2446940d71d2Seschrock topo_mod_strfree(mod, model); 2447940d71d2Seschrock topo_mod_strfree(mod, revision); 2448940d71d2Seschrock topo_mod_strfree(mod, product); 2449940d71d2Seschrock 2450940d71d2Seschrock nvlist_free(fmri); 2451940d71d2Seschrock nvlist_free(auth); 2452940d71d2Seschrock return (ret); 2453940d71d2Seschrock } 2454940d71d2Seschrock 2455d91236feSeschrock /* 2456d91236feSeschrock * Create a bay node explicitly enumerated via XML. 2457d91236feSeschrock */ 2458d91236feSeschrock static int 2459d91236feSeschrock ses_create_bays(ses_enum_data_t *sdp, tnode_t *pnode) 2460d91236feSeschrock { 2461d91236feSeschrock topo_mod_t *mod = sdp->sed_mod; 2462d91236feSeschrock ses_enum_chassis_t *cp; 2463d91236feSeschrock 2464d91236feSeschrock /* 2465d91236feSeschrock * Iterate over chassis looking for an internal enclosure. This 2466d91236feSeschrock * property is set via a vendor-specific plugin, and there should only 2467d91236feSeschrock * ever be a single internal chassis in a system. 2468d91236feSeschrock */ 2469d91236feSeschrock for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL; 2470d91236feSeschrock cp = topo_list_next(cp)) { 2471d91236feSeschrock if (cp->sec_internal) 2472d91236feSeschrock break; 2473d91236feSeschrock } 2474d91236feSeschrock 2475d91236feSeschrock if (cp == NULL) { 2476d91236feSeschrock topo_mod_dprintf(mod, "failed to find internal chassis\n"); 2477d91236feSeschrock return (-1); 2478d91236feSeschrock } 2479d91236feSeschrock 2480d91236feSeschrock if (ses_create_children(sdp, pnode, SES_ET_DEVICE, 2481d91236feSeschrock BAY, "BAY", cp, B_FALSE) != 0 || 2482d91236feSeschrock ses_create_children(sdp, pnode, SES_ET_ARRAY_DEVICE, 2483d91236feSeschrock BAY, "BAY", cp, B_FALSE) != 0) 2484d91236feSeschrock return (-1); 2485d91236feSeschrock 2486d91236feSeschrock return (0); 2487d91236feSeschrock } 248853dbcc59SSundeep Panicker 248953dbcc59SSundeep Panicker /* 249053dbcc59SSundeep Panicker * Initialize chassis or subchassis. 249153dbcc59SSundeep Panicker */ 249253dbcc59SSundeep Panicker static int 249353dbcc59SSundeep Panicker ses_init_chassis(topo_mod_t *mod, ses_enum_data_t *sdp, ses_enum_chassis_t *pcp, 249453dbcc59SSundeep Panicker ses_enum_chassis_t *cp, ses_node_t *np, nvlist_t *props, 2495ac88567aSHyon Kim uint64_t subchassis, ses_chassis_type_e flags) 249653dbcc59SSundeep Panicker { 249753dbcc59SSundeep Panicker boolean_t internal, ident; 249853dbcc59SSundeep Panicker 249953dbcc59SSundeep Panicker assert((flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS | 250053dbcc59SSundeep Panicker SES_DUP_CHASSIS | SES_DUP_SUBCHASSIS)) != 0); 250153dbcc59SSundeep Panicker 2502ac88567aSHyon Kim assert(cp != NULL); 2503ac88567aSHyon Kim assert(np != NULL); 2504ac88567aSHyon Kim assert(props != NULL); 250553dbcc59SSundeep Panicker 250653dbcc59SSundeep Panicker if (flags & (SES_NEW_SUBCHASSIS | SES_DUP_SUBCHASSIS)) 250753dbcc59SSundeep Panicker assert(pcp != NULL); 250853dbcc59SSundeep Panicker 2509ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_init_chassis: %s: index %llu, flags (%d)", 2510ac88567aSHyon Kim sdp->sed_name, subchassis, flags); 251153dbcc59SSundeep Panicker 251253dbcc59SSundeep Panicker if (flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS)) { 251353dbcc59SSundeep Panicker 251453dbcc59SSundeep Panicker topo_mod_dprintf(mod, "new chassis/subchassis"); 251553dbcc59SSundeep Panicker if (nvlist_lookup_boolean_value(props, 251653dbcc59SSundeep Panicker LIBSES_EN_PROP_INTERNAL, &internal) == 0) 251753dbcc59SSundeep Panicker cp->sec_internal = internal; 251853dbcc59SSundeep Panicker 251953dbcc59SSundeep Panicker cp->sec_enclosure = np; 252053dbcc59SSundeep Panicker cp->sec_target = sdp->sed_target; 252153dbcc59SSundeep Panicker 252253dbcc59SSundeep Panicker if (flags & SES_NEW_CHASSIS) { 2523ac88567aSHyon Kim if (!cp->sec_internal) 2524ac88567aSHyon Kim cp->sec_instance = sdp->sed_instance++; 252553dbcc59SSundeep Panicker topo_list_append(&sdp->sed_chassis, cp); 252653dbcc59SSundeep Panicker } else { 2527ac88567aSHyon Kim if (subchassis != NO_SUBCHASSIS) 2528ac88567aSHyon Kim cp->sec_instance = subchassis; 2529ac88567aSHyon Kim else 2530ac88567aSHyon Kim cp->sec_instance = pcp->sec_scinstance++; 2531ac88567aSHyon Kim 2532ac88567aSHyon Kim if (cp->sec_instance > pcp->sec_maxinstance) 2533ac88567aSHyon Kim pcp->sec_maxinstance = cp->sec_instance; 2534ac88567aSHyon Kim 253553dbcc59SSundeep Panicker topo_list_append(&pcp->sec_subchassis, cp); 253653dbcc59SSundeep Panicker } 253753dbcc59SSundeep Panicker 253853dbcc59SSundeep Panicker } else { 253953dbcc59SSundeep Panicker topo_mod_dprintf(mod, "dup chassis/subchassis"); 254053dbcc59SSundeep Panicker if (nvlist_lookup_boolean_value(props, 254153dbcc59SSundeep Panicker SES_PROP_IDENT, &ident) == 0) { 254253dbcc59SSundeep Panicker topo_mod_dprintf(mod, "overriding enclosure node"); 254353dbcc59SSundeep Panicker 254453dbcc59SSundeep Panicker cp->sec_enclosure = np; 254553dbcc59SSundeep Panicker cp->sec_target = sdp->sed_target; 254653dbcc59SSundeep Panicker } 254753dbcc59SSundeep Panicker } 254853dbcc59SSundeep Panicker 254953dbcc59SSundeep Panicker topo_list_append(&cp->sec_targets, sdp->sed_target); 255053dbcc59SSundeep Panicker sdp->sed_current = cp; 255153dbcc59SSundeep Panicker 255253dbcc59SSundeep Panicker return (0); 255353dbcc59SSundeep Panicker } 255453dbcc59SSundeep Panicker 2555940d71d2Seschrock /* 2556940d71d2Seschrock * Gather nodes from the current SES target into our chassis list, merging the 2557940d71d2Seschrock * results if necessary. 2558940d71d2Seschrock */ 2559940d71d2Seschrock static ses_walk_action_t 2560940d71d2Seschrock ses_enum_gather(ses_node_t *np, void *data) 2561940d71d2Seschrock { 2562940d71d2Seschrock nvlist_t *props = ses_node_props(np); 2563940d71d2Seschrock ses_enum_data_t *sdp = data; 2564940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 256553dbcc59SSundeep Panicker ses_enum_chassis_t *cp, *scp; 2566940d71d2Seschrock ses_enum_node_t *snp; 25670b32bb8bSEric Schrock ses_alt_node_t *sap; 2568940d71d2Seschrock char *csn; 2569940d71d2Seschrock uint64_t instance, type; 2570d91236feSeschrock uint64_t prevstatus, status; 257153dbcc59SSundeep Panicker boolean_t report; 2572ac88567aSHyon Kim uint64_t subchassis = NO_SUBCHASSIS; 2573940d71d2Seschrock 2574940d71d2Seschrock if (ses_node_type(np) == SES_NODE_ENCLOSURE) { 2575940d71d2Seschrock /* 2576940d71d2Seschrock * If we have already identified the chassis for this target, 2577940d71d2Seschrock * then this is a secondary enclosure and we should ignore it, 2578940d71d2Seschrock * along with the rest of the tree (since this is depth-first). 2579940d71d2Seschrock */ 2580940d71d2Seschrock if (sdp->sed_current != NULL) 2581940d71d2Seschrock return (SES_WALK_ACTION_TERMINATE); 2582940d71d2Seschrock 2583940d71d2Seschrock /* 2584940d71d2Seschrock * Go through the list of chassis we have seen so far and see 2585940d71d2Seschrock * if this serial number matches one of the known values. 258653dbcc59SSundeep Panicker * If so, check whether this enclosure is a subchassis. 2587940d71d2Seschrock */ 2588940d71d2Seschrock if (nvlist_lookup_string(props, LIBSES_EN_PROP_CSN, 2589940d71d2Seschrock &csn) != 0) 2590940d71d2Seschrock return (SES_WALK_ACTION_TERMINATE); 2591940d71d2Seschrock 2592ac88567aSHyon Kim (void) nvlist_lookup_uint64(props, LIBSES_EN_PROP_SUBCHASSIS_ID, 2593ac88567aSHyon Kim &subchassis); 259453dbcc59SSundeep Panicker 259553dbcc59SSundeep Panicker topo_mod_dprintf(mod, "ses_enum_gather: Enclosure Node (%s) " 2596ac88567aSHyon Kim "CSN (%s), subchassis (%llu)", sdp->sed_name, csn, 2597ac88567aSHyon Kim subchassis); 259853dbcc59SSundeep Panicker 259953dbcc59SSundeep Panicker /* 260053dbcc59SSundeep Panicker * We need to determine whether this enclosure node 260153dbcc59SSundeep Panicker * represents a chassis or a subchassis. Since we may 260253dbcc59SSundeep Panicker * receive the enclosure nodes in a non-deterministic 260353dbcc59SSundeep Panicker * manner, we need to account for all possible combinations: 260453dbcc59SSundeep Panicker * 1. Chassis for the current CSN has not yet been 260553dbcc59SSundeep Panicker * allocated 260653dbcc59SSundeep Panicker * 1.1 This is a new chassis: 260753dbcc59SSundeep Panicker * allocate and instantiate the chassis 260853dbcc59SSundeep Panicker * 1.2 This is a new subchassis: 260953dbcc59SSundeep Panicker * allocate a placeholder chassis 261053dbcc59SSundeep Panicker * allocate and instantiate the subchassis 261153dbcc59SSundeep Panicker * link the subchassis to the chassis 261253dbcc59SSundeep Panicker * 2. Chassis for the current CSN has been allocated 261353dbcc59SSundeep Panicker * 2.1 This is a duplicate chassis enclosure 261453dbcc59SSundeep Panicker * check whether to override old chassis 261553dbcc59SSundeep Panicker * append to chassis' target list 261653dbcc59SSundeep Panicker * 2.2 Only placeholder chassis exists 261753dbcc59SSundeep Panicker * fill in the chassis fields 261853dbcc59SSundeep Panicker * 2.3 This is a new subchassis 261953dbcc59SSundeep Panicker * allocate and instantiate the subchassis 262053dbcc59SSundeep Panicker * link the subchassis to the chassis 262153dbcc59SSundeep Panicker * 2.4 This is a duplicate subchassis enclosure 262253dbcc59SSundeep Panicker * check whether to override old chassis 262353dbcc59SSundeep Panicker * append to chassis' target list 262453dbcc59SSundeep Panicker */ 262553dbcc59SSundeep Panicker 2626940d71d2Seschrock for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL; 262753dbcc59SSundeep Panicker cp = topo_list_next(cp)) 262853dbcc59SSundeep Panicker if (strcmp(cp->sec_csn, csn) == 0) 2629940d71d2Seschrock break; 2630940d71d2Seschrock 2631940d71d2Seschrock if (cp == NULL) { 263253dbcc59SSundeep Panicker /* 1. Haven't seen a chassis with this CSN before */ 2633940d71d2Seschrock 2634940d71d2Seschrock if ((cp = topo_mod_zalloc(mod, 2635940d71d2Seschrock sizeof (ses_enum_chassis_t))) == NULL) 2636940d71d2Seschrock goto error; 2637940d71d2Seschrock 2638ac88567aSHyon Kim cp->sec_scinstance = SES_STARTING_SUBCHASSIS; 2639ac88567aSHyon Kim cp->sec_maxinstance = -1; 2640940d71d2Seschrock cp->sec_csn = csn; 264153dbcc59SSundeep Panicker 2642ac88567aSHyon Kim if (subchassis == NO_SUBCHASSIS) { 264353dbcc59SSundeep Panicker /* 1.1 This is a new chassis */ 264453dbcc59SSundeep Panicker 264553dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Initialize new " 2646ac88567aSHyon Kim "chassis with CSN %s", sdp->sed_name, csn); 264753dbcc59SSundeep Panicker 264853dbcc59SSundeep Panicker if (ses_init_chassis(mod, sdp, NULL, cp, 2649ac88567aSHyon Kim np, props, NO_SUBCHASSIS, 2650ac88567aSHyon Kim SES_NEW_CHASSIS) < 0) 265153dbcc59SSundeep Panicker goto error; 265253dbcc59SSundeep Panicker } else { 265353dbcc59SSundeep Panicker /* 1.2 This is a new subchassis */ 265453dbcc59SSundeep Panicker 265553dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Initialize new " 2656ac88567aSHyon Kim "subchassis with CSN %s and index %llu", 2657ac88567aSHyon Kim sdp->sed_name, csn, subchassis); 265853dbcc59SSundeep Panicker 265953dbcc59SSundeep Panicker if ((scp = topo_mod_zalloc(mod, 266053dbcc59SSundeep Panicker sizeof (ses_enum_chassis_t))) == NULL) 266153dbcc59SSundeep Panicker goto error; 266253dbcc59SSundeep Panicker 266353dbcc59SSundeep Panicker scp->sec_csn = csn; 266453dbcc59SSundeep Panicker 2665ac88567aSHyon Kim if (ses_init_chassis(mod, sdp, cp, scp, np, 2666ac88567aSHyon Kim props, subchassis, SES_NEW_SUBCHASSIS) < 0) 266753dbcc59SSundeep Panicker goto error; 266853dbcc59SSundeep Panicker } 26696efb64caSEric Schrock } else { 2670ac88567aSHyon Kim /* 2671ac88567aSHyon Kim * We have a chassis or subchassis with this CSN. If 2672ac88567aSHyon Kim * it's a chassis, we must check to see whether it is 2673ac88567aSHyon Kim * a placeholder previously created because we found a 2674ac88567aSHyon Kim * subchassis with this CSN. We will know that because 2675ac88567aSHyon Kim * the sec_target value will not be set; it is set only 2676ac88567aSHyon Kim * in ses_init_chassis(). In that case, initialise it 2677ac88567aSHyon Kim * as a new chassis; otherwise, it's a duplicate and we 2678ac88567aSHyon Kim * need to append only. 2679ac88567aSHyon Kim */ 2680ac88567aSHyon Kim if (subchassis == NO_SUBCHASSIS) { 2681ac88567aSHyon Kim if (cp->sec_target != NULL) { 268253dbcc59SSundeep Panicker /* 2.1 This is a duplicate chassis */ 268353dbcc59SSundeep Panicker 268453dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Append " 2685ac88567aSHyon Kim "duplicate chassis with CSN (%s)", 2686ac88567aSHyon Kim sdp->sed_name, csn); 268753dbcc59SSundeep Panicker 268853dbcc59SSundeep Panicker if (ses_init_chassis(mod, sdp, NULL, cp, 2689ac88567aSHyon Kim np, props, NO_SUBCHASSIS, 269053dbcc59SSundeep Panicker SES_DUP_CHASSIS) < 0) 269153dbcc59SSundeep Panicker goto error; 269253dbcc59SSundeep Panicker } else { 2693ac88567aSHyon Kim /* Placeholder chassis - init it up */ 269453dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Initialize" 2695ac88567aSHyon Kim "placeholder chassis with CSN %s", 2696ac88567aSHyon Kim sdp->sed_name, csn); 269753dbcc59SSundeep Panicker 2698ac88567aSHyon Kim if (ses_init_chassis(mod, sdp, NULL, 2699ac88567aSHyon Kim cp, np, props, NO_SUBCHASSIS, 270053dbcc59SSundeep Panicker SES_NEW_CHASSIS) < 0) 270153dbcc59SSundeep Panicker goto error; 270253dbcc59SSundeep Panicker 270353dbcc59SSundeep Panicker } 270453dbcc59SSundeep Panicker } else { 270553dbcc59SSundeep Panicker /* This is a subchassis */ 270653dbcc59SSundeep Panicker 270753dbcc59SSundeep Panicker for (scp = topo_list_next(&cp->sec_subchassis); 270853dbcc59SSundeep Panicker scp != NULL; scp = topo_list_next(scp)) 2709ac88567aSHyon Kim if (scp->sec_instance == subchassis) 271053dbcc59SSundeep Panicker break; 271153dbcc59SSundeep Panicker 271253dbcc59SSundeep Panicker if (scp == NULL) { 271353dbcc59SSundeep Panicker /* 2.3 This is a new subchassis */ 271453dbcc59SSundeep Panicker 271553dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Initialize " 271653dbcc59SSundeep Panicker "new subchassis with CSN (%s) " 271753dbcc59SSundeep Panicker "and LID (%s)", 2718ac88567aSHyon Kim sdp->sed_name, csn); 271953dbcc59SSundeep Panicker 272053dbcc59SSundeep Panicker if ((scp = topo_mod_zalloc(mod, 272153dbcc59SSundeep Panicker sizeof (ses_enum_chassis_t))) 272253dbcc59SSundeep Panicker == NULL) 272353dbcc59SSundeep Panicker goto error; 272453dbcc59SSundeep Panicker 272553dbcc59SSundeep Panicker scp->sec_csn = csn; 272653dbcc59SSundeep Panicker 272753dbcc59SSundeep Panicker if (ses_init_chassis(mod, sdp, cp, scp, 2728ac88567aSHyon Kim np, props, subchassis, 272953dbcc59SSundeep Panicker SES_NEW_SUBCHASSIS) < 0) 273053dbcc59SSundeep Panicker goto error; 273153dbcc59SSundeep Panicker } else { 273253dbcc59SSundeep Panicker /* 2.4 This is a duplicate subchassis */ 273353dbcc59SSundeep Panicker 273453dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Append " 273553dbcc59SSundeep Panicker "duplicate subchassis with " 2736ac88567aSHyon Kim "CSN (%s)", sdp->sed_name, csn); 273753dbcc59SSundeep Panicker 273853dbcc59SSundeep Panicker if (ses_init_chassis(mod, sdp, cp, scp, 2739ac88567aSHyon Kim np, props, subchassis, 274053dbcc59SSundeep Panicker SES_DUP_SUBCHASSIS) < 0) 274153dbcc59SSundeep Panicker goto error; 274253dbcc59SSundeep Panicker } 27436efb64caSEric Schrock } 2744940d71d2Seschrock } 2745940d71d2Seschrock } else if (ses_node_type(np) == SES_NODE_ELEMENT) { 2746940d71d2Seschrock /* 2747940d71d2Seschrock * If we haven't yet seen an enclosure node and identified the 2748940d71d2Seschrock * current chassis, something is very wrong; bail out. 2749940d71d2Seschrock */ 2750940d71d2Seschrock if (sdp->sed_current == NULL) 2751940d71d2Seschrock return (SES_WALK_ACTION_TERMINATE); 2752940d71d2Seschrock 2753940d71d2Seschrock /* 2754940d71d2Seschrock * If this isn't one of the element types we care about, then 2755940d71d2Seschrock * ignore it. 2756940d71d2Seschrock */ 2757940d71d2Seschrock verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_TYPE, 2758940d71d2Seschrock &type) == 0); 2759940d71d2Seschrock if (type != SES_ET_DEVICE && 2760940d71d2Seschrock type != SES_ET_ARRAY_DEVICE && 2761940d71d2Seschrock type != SES_ET_COOLING && 2762940d71d2Seschrock type != SES_ET_POWER_SUPPLY && 2763ac88567aSHyon Kim type != SES_ET_ESC_ELECTRONICS && 2764ac88567aSHyon Kim type != SES_ET_SAS_EXPANDER && 2765ac88567aSHyon Kim type != SES_ET_SAS_CONNECTOR) 2766940d71d2Seschrock return (SES_WALK_ACTION_CONTINUE); 2767940d71d2Seschrock 2768940d71d2Seschrock /* 2769940d71d2Seschrock * Get the current instance number and see if we already know 2770940d71d2Seschrock * about this element. If so, it means we have multiple paths 2771940d71d2Seschrock * to the same elements, and we should ignore the current path. 2772940d71d2Seschrock */ 2773940d71d2Seschrock verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_CLASS_INDEX, 2774940d71d2Seschrock &instance) == 0); 2775940d71d2Seschrock if (type == SES_ET_DEVICE || type == SES_ET_ARRAY_DEVICE) 2776940d71d2Seschrock (void) nvlist_lookup_uint64(props, SES_PROP_BAY_NUMBER, 2777940d71d2Seschrock &instance); 2778940d71d2Seschrock 2779940d71d2Seschrock cp = sdp->sed_current; 2780940d71d2Seschrock 2781940d71d2Seschrock for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2782940d71d2Seschrock snp = topo_list_next(snp)) { 2783940d71d2Seschrock if (snp->sen_type == type && 2784940d71d2Seschrock snp->sen_instance == instance) 2785d91236feSeschrock break; 2786d91236feSeschrock } 2787d91236feSeschrock 2788d91236feSeschrock /* 2789d91236feSeschrock * We prefer the new element under the following circumstances: 2790d91236feSeschrock * 2791d91236feSeschrock * - The currently known element's status is unknown or not 2792d91236feSeschrock * available, but the new element has a known status. This 2793d91236feSeschrock * occurs if a given element is only available through a 2794d91236feSeschrock * particular target. 2795d91236feSeschrock * 2796d91236feSeschrock * - This is an ESC_ELECTRONICS element, and the 'reported-via' 2797d91236feSeschrock * property is set. This allows us to get reliable firmware 2798d91236feSeschrock * revision information from the enclosure node. 2799d91236feSeschrock */ 2800d91236feSeschrock if (snp != NULL) { 2801d91236feSeschrock if (nvlist_lookup_uint64( 2802d91236feSeschrock ses_node_props(snp->sen_node), 2803d91236feSeschrock SES_PROP_STATUS_CODE, &prevstatus) != 0) 2804d91236feSeschrock prevstatus = SES_ESC_UNSUPPORTED; 2805d91236feSeschrock if (nvlist_lookup_uint64( 2806d91236feSeschrock props, SES_PROP_STATUS_CODE, &status) != 0) 2807d91236feSeschrock status = SES_ESC_UNSUPPORTED; 2808d91236feSeschrock if (nvlist_lookup_boolean_value( 2809d91236feSeschrock props, SES_PROP_REPORT, &report) != 0) 2810d91236feSeschrock report = B_FALSE; 2811d91236feSeschrock 2812d91236feSeschrock if ((SES_STATUS_UNAVAIL(prevstatus) && 2813d91236feSeschrock !SES_STATUS_UNAVAIL(status)) || 2814d91236feSeschrock (type == SES_ET_ESC_ELECTRONICS && 2815d91236feSeschrock report)) { 2816d91236feSeschrock snp->sen_node = np; 2817d91236feSeschrock snp->sen_target = sdp->sed_target; 2818d91236feSeschrock } 2819d91236feSeschrock 28200b32bb8bSEric Schrock if ((sap = topo_mod_zalloc(mod, 28210b32bb8bSEric Schrock sizeof (ses_alt_node_t))) == NULL) 28220b32bb8bSEric Schrock goto error; 28230b32bb8bSEric Schrock 28240b32bb8bSEric Schrock sap->san_node = np; 28250b32bb8bSEric Schrock topo_list_append(&snp->sen_alt_nodes, sap); 28260b32bb8bSEric Schrock 2827d91236feSeschrock return (SES_WALK_ACTION_CONTINUE); 2828940d71d2Seschrock } 2829940d71d2Seschrock 2830940d71d2Seschrock if ((snp = topo_mod_zalloc(mod, 2831940d71d2Seschrock sizeof (ses_enum_node_t))) == NULL) 2832940d71d2Seschrock goto error; 2833940d71d2Seschrock 28340b32bb8bSEric Schrock if ((sap = topo_mod_zalloc(mod, 28350b32bb8bSEric Schrock sizeof (ses_alt_node_t))) == NULL) { 28360b32bb8bSEric Schrock topo_mod_free(mod, snp, sizeof (ses_enum_node_t)); 28370b32bb8bSEric Schrock goto error; 28380b32bb8bSEric Schrock } 28390b32bb8bSEric Schrock 2840940d71d2Seschrock topo_mod_dprintf(mod, "%s: adding node (%llu, %llu)", 2841940d71d2Seschrock sdp->sed_name, type, instance); 2842940d71d2Seschrock snp->sen_node = np; 2843940d71d2Seschrock snp->sen_type = type; 2844940d71d2Seschrock snp->sen_instance = instance; 2845940d71d2Seschrock snp->sen_target = sdp->sed_target; 28460b32bb8bSEric Schrock sap->san_node = np; 28470b32bb8bSEric Schrock topo_list_append(&snp->sen_alt_nodes, sap); 2848940d71d2Seschrock topo_list_append(&cp->sec_nodes, snp); 2849940d71d2Seschrock 2850940d71d2Seschrock if (type == SES_ET_DEVICE) 2851940d71d2Seschrock cp->sec_hasdev = B_TRUE; 2852940d71d2Seschrock } 2853940d71d2Seschrock 2854940d71d2Seschrock return (SES_WALK_ACTION_CONTINUE); 2855940d71d2Seschrock 2856940d71d2Seschrock error: 2857940d71d2Seschrock sdp->sed_errno = -1; 2858940d71d2Seschrock return (SES_WALK_ACTION_TERMINATE); 2859940d71d2Seschrock } 2860940d71d2Seschrock 2861940d71d2Seschrock static int 2862940d71d2Seschrock ses_process_dir(const char *dirpath, ses_enum_data_t *sdp) 2863940d71d2Seschrock { 2864940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 2865940d71d2Seschrock DIR *dir; 2866940d71d2Seschrock struct dirent *dp; 2867940d71d2Seschrock char path[PATH_MAX]; 2868940d71d2Seschrock ses_enum_target_t *stp; 2869940d71d2Seschrock int err = -1; 2870940d71d2Seschrock 2871940d71d2Seschrock /* 2872940d71d2Seschrock * Open the SES target directory and iterate over any available 2873940d71d2Seschrock * targets. 2874940d71d2Seschrock */ 2875940d71d2Seschrock if ((dir = opendir(dirpath)) == NULL) { 2876940d71d2Seschrock /* 2877940d71d2Seschrock * If the SES target directory does not exist, then return as if 2878940d71d2Seschrock * there are no active targets. 2879940d71d2Seschrock */ 2880940d71d2Seschrock topo_mod_dprintf(mod, "failed to open ses " 2881940d71d2Seschrock "directory '%s'", dirpath); 2882940d71d2Seschrock return (0); 2883940d71d2Seschrock } 2884940d71d2Seschrock 2885940d71d2Seschrock while ((dp = readdir(dir)) != NULL) { 2886940d71d2Seschrock if (strcmp(dp->d_name, ".") == 0 || 2887940d71d2Seschrock strcmp(dp->d_name, "..") == 0) 2888940d71d2Seschrock continue; 2889940d71d2Seschrock 2890940d71d2Seschrock /* 2891940d71d2Seschrock * Create a new target instance and take a snapshot. 2892940d71d2Seschrock */ 2893940d71d2Seschrock if ((stp = topo_mod_zalloc(mod, 2894940d71d2Seschrock sizeof (ses_enum_target_t))) == NULL) 2895940d71d2Seschrock goto error; 2896940d71d2Seschrock 28970b32bb8bSEric Schrock (void) pthread_mutex_init(&stp->set_lock, NULL); 28980b32bb8bSEric Schrock 2899940d71d2Seschrock (void) snprintf(path, sizeof (path), "%s/%s", dirpath, 2900940d71d2Seschrock dp->d_name); 2901940d71d2Seschrock 2902940d71d2Seschrock /* 2903940d71d2Seschrock * We keep track of the SES device path and export it on a 2904940d71d2Seschrock * per-node basis to allow higher level software to get to the 2905940d71d2Seschrock * corresponding SES state. 2906940d71d2Seschrock */ 2907940d71d2Seschrock if ((stp->set_devpath = topo_mod_strdup(mod, path)) == NULL) { 2908940d71d2Seschrock topo_mod_free(mod, stp, sizeof (ses_enum_target_t)); 2909940d71d2Seschrock goto error; 2910940d71d2Seschrock } 2911940d71d2Seschrock 2912940d71d2Seschrock if ((stp->set_target = 2913940d71d2Seschrock ses_open(LIBSES_VERSION, path)) == NULL) { 2914940d71d2Seschrock topo_mod_dprintf(mod, "failed to open ses target " 2915940d71d2Seschrock "'%s': %s", dp->d_name, ses_errmsg()); 2916f76de749SStephen Hanson ses_sof_alloc(mod, stp->set_devpath); 2917940d71d2Seschrock topo_mod_free(mod, stp, sizeof (ses_enum_target_t)); 2918940d71d2Seschrock continue; 2919940d71d2Seschrock } 2920f76de749SStephen Hanson topo_mod_dprintf(mod, "open contract"); 2921f76de749SStephen Hanson ses_ssl_alloc(mod, stp); 2922f76de749SStephen Hanson ses_create_contract(mod, stp); 2923940d71d2Seschrock 2924940d71d2Seschrock stp->set_refcount = 1; 2925940d71d2Seschrock sdp->sed_target = stp; 2926940d71d2Seschrock stp->set_snap = ses_snap_hold(stp->set_target); 2927525b85dbSEric Schrock stp->set_snaptime = gethrtime(); 2928940d71d2Seschrock 2929940d71d2Seschrock /* 2930940d71d2Seschrock * Enumerate over all SES elements and merge them into the 2931940d71d2Seschrock * correct ses_enum_chassis_t. 2932940d71d2Seschrock */ 2933940d71d2Seschrock sdp->sed_current = NULL; 2934940d71d2Seschrock sdp->sed_errno = 0; 2935940d71d2Seschrock sdp->sed_name = dp->d_name; 2936940d71d2Seschrock (void) ses_walk(stp->set_snap, ses_enum_gather, sdp); 2937940d71d2Seschrock 2938940d71d2Seschrock if (sdp->sed_errno != 0) 2939940d71d2Seschrock goto error; 2940940d71d2Seschrock } 2941940d71d2Seschrock 2942940d71d2Seschrock err = 0; 2943940d71d2Seschrock error: 2944940d71d2Seschrock closedir(dir); 2945940d71d2Seschrock return (err); 2946940d71d2Seschrock } 2947940d71d2Seschrock 2948940d71d2Seschrock static void 2949940d71d2Seschrock ses_release(topo_mod_t *mod, tnode_t *tn) 2950940d71d2Seschrock { 2951940d71d2Seschrock ses_enum_target_t *stp; 2952940d71d2Seschrock 2953f76de749SStephen Hanson if ((stp = topo_node_getspecific(tn)) != NULL) { 2954f76de749SStephen Hanson topo_node_setspecific(tn, NULL); 2955940d71d2Seschrock ses_target_free(mod, stp); 2956f76de749SStephen Hanson } 2957940d71d2Seschrock } 2958940d71d2Seschrock 2959940d71d2Seschrock /*ARGSUSED*/ 2960940d71d2Seschrock static int 2961940d71d2Seschrock ses_enum(topo_mod_t *mod, tnode_t *rnode, const char *name, 2962940d71d2Seschrock topo_instance_t min, topo_instance_t max, void *arg, void *notused) 2963940d71d2Seschrock { 2964940d71d2Seschrock ses_enum_chassis_t *cp; 2965d91236feSeschrock ses_enum_data_t *data; 2966940d71d2Seschrock 2967940d71d2Seschrock /* 2968940d71d2Seschrock * Check to make sure we're being invoked sensibly, and that we're not 2969940d71d2Seschrock * being invoked as part of a post-processing step. 2970940d71d2Seschrock */ 2971d91236feSeschrock if (strcmp(name, SES_ENCLOSURE) != 0 && strcmp(name, BAY) != 0) 2972940d71d2Seschrock return (0); 2973940d71d2Seschrock 2974940d71d2Seschrock /* 2975d91236feSeschrock * If this is the first time we've called our enumeration method, then 2976d91236feSeschrock * gather information about any available enclosures. 2977940d71d2Seschrock */ 2978d91236feSeschrock if ((data = topo_mod_getspecific(mod)) == NULL) { 2979f76de749SStephen Hanson ses_sof_freeall(mod); 2980d91236feSeschrock if ((data = topo_mod_zalloc(mod, sizeof (ses_enum_data_t))) == 2981d91236feSeschrock NULL) 2982d91236feSeschrock return (-1); 2983940d71d2Seschrock 2984d91236feSeschrock data->sed_mod = mod; 2985d91236feSeschrock topo_mod_setspecific(mod, data); 2986d91236feSeschrock 2987ac88567aSHyon Kim if (dev_list_gather(mod, &data->sed_devs) != 0) 2988d91236feSeschrock goto error; 2989d91236feSeschrock 2990d91236feSeschrock /* 2991d91236feSeschrock * We search both the ses(7D) and sgen(7D) locations, so we are 2992d91236feSeschrock * independent of any particular driver class bindings. 2993d91236feSeschrock */ 2994d91236feSeschrock if (ses_process_dir("/dev/es", data) != 0 || 2995d91236feSeschrock ses_process_dir("/dev/scsi/ses", data) != 0) 2996d91236feSeschrock goto error; 2997d91236feSeschrock } 2998d91236feSeschrock 2999d91236feSeschrock if (strcmp(name, SES_ENCLOSURE) == 0) { 3000d91236feSeschrock /* 3001d91236feSeschrock * This is a request to enumerate external enclosures. Go 3002d91236feSeschrock * through all the targets and create chassis nodes where 3003d91236feSeschrock * necessary. 3004d91236feSeschrock */ 3005d91236feSeschrock for (cp = topo_list_next(&data->sed_chassis); cp != NULL; 3006d91236feSeschrock cp = topo_list_next(cp)) { 3007d91236feSeschrock if (ses_create_chassis(data, rnode, cp) != 0) 3008d91236feSeschrock goto error; 3009d91236feSeschrock } 3010d91236feSeschrock } else { 3011d91236feSeschrock /* 3012d91236feSeschrock * This is a request to enumerate a specific bay underneath the 3013d91236feSeschrock * root chassis (for internal disks). 3014d91236feSeschrock */ 3015d91236feSeschrock if (ses_create_bays(data, rnode) != 0) 3016940d71d2Seschrock goto error; 3017940d71d2Seschrock } 3018940d71d2Seschrock 3019d91236feSeschrock /* 3020d91236feSeschrock * This is a bit of a kludge. In order to allow internal disks to be 3021d91236feSeschrock * enumerated and share snapshot-specific information with the external 3022d91236feSeschrock * enclosure enumeration, we rely on the fact that we will be invoked 3023d91236feSeschrock * for the 'ses-enclosure' node last. 3024d91236feSeschrock */ 3025d91236feSeschrock if (strcmp(name, SES_ENCLOSURE) == 0) { 302653dbcc59SSundeep Panicker for (cp = topo_list_next(&data->sed_chassis); cp != NULL; 302753dbcc59SSundeep Panicker cp = topo_list_next(cp)) 302853dbcc59SSundeep Panicker ses_data_free(data, cp); 302953dbcc59SSundeep Panicker ses_data_free(data, NULL); 3030d91236feSeschrock topo_mod_setspecific(mod, NULL); 3031d91236feSeschrock } 3032940d71d2Seschrock return (0); 3033940d71d2Seschrock 3034940d71d2Seschrock error: 303553dbcc59SSundeep Panicker for (cp = topo_list_next(&data->sed_chassis); cp != NULL; 303653dbcc59SSundeep Panicker cp = topo_list_next(cp)) 303753dbcc59SSundeep Panicker ses_data_free(data, cp); 303853dbcc59SSundeep Panicker ses_data_free(data, NULL); 3039d91236feSeschrock topo_mod_setspecific(mod, NULL); 3040940d71d2Seschrock return (-1); 3041940d71d2Seschrock } 3042940d71d2Seschrock 3043940d71d2Seschrock static const topo_modops_t ses_ops = 3044940d71d2Seschrock { ses_enum, ses_release }; 3045940d71d2Seschrock 3046940d71d2Seschrock static topo_modinfo_t ses_info = 3047940d71d2Seschrock { SES_ENCLOSURE, FM_FMRI_SCHEME_HC, SES_VERSION, &ses_ops }; 3048940d71d2Seschrock 3049940d71d2Seschrock /*ARGSUSED*/ 3050940d71d2Seschrock int 3051940d71d2Seschrock _topo_init(topo_mod_t *mod, topo_version_t version) 3052940d71d2Seschrock { 3053f76de749SStephen Hanson int rval; 3054f76de749SStephen Hanson 3055940d71d2Seschrock if (getenv("TOPOSESDEBUG") != NULL) 3056940d71d2Seschrock topo_mod_setdebug(mod); 3057940d71d2Seschrock 3058940d71d2Seschrock topo_mod_dprintf(mod, "initializing %s enumerator\n", 3059940d71d2Seschrock SES_ENCLOSURE); 3060940d71d2Seschrock 3061f76de749SStephen Hanson if ((rval = topo_mod_register(mod, &ses_info, TOPO_VERSION)) == 0) 3062f76de749SStephen Hanson ses_thread_init(mod); 3063f76de749SStephen Hanson 3064f76de749SStephen Hanson return (rval); 3065940d71d2Seschrock } 3066940d71d2Seschrock 3067940d71d2Seschrock void 3068940d71d2Seschrock _topo_fini(topo_mod_t *mod) 3069940d71d2Seschrock { 3070*05b58617SStephen Hanson ses_thread_fini(mod); 3071f76de749SStephen Hanson ses_sof_freeall(mod); 3072940d71d2Seschrock topo_mod_unregister(mod); 3073940d71d2Seschrock } 3074