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. 24edb433b6SMilan Jurik * Copyright 2012 Milan Jurik. All rights reserved. 25*057c620aSHans Rosenfeld * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 26940d71d2Seschrock */ 27940d71d2Seschrock 286efb64caSEric Schrock #include <alloca.h> 29940d71d2Seschrock #include <dirent.h> 30940d71d2Seschrock #include <devid.h> 31940d71d2Seschrock #include <fm/libdiskstatus.h> 32940d71d2Seschrock #include <inttypes.h> 33940d71d2Seschrock #include <pthread.h> 34940d71d2Seschrock #include <strings.h> 35ac88567aSHyon Kim #include <string.h> 36940d71d2Seschrock #include <unistd.h> 37940d71d2Seschrock #include <sys/dkio.h> 38940d71d2Seschrock #include <sys/fm/protocol.h> 3944ed9dbbSStephen Hanson #include <sys/libdevid.h> 40940d71d2Seschrock #include <sys/scsi/scsi_types.h> 41ac88567aSHyon Kim #include <sys/byteorder.h> 42f76de749SStephen Hanson #include <pthread.h> 43f76de749SStephen Hanson #include <signal.h> 44f76de749SStephen Hanson #include <fcntl.h> 45f76de749SStephen Hanson #include <sys/ctfs.h> 46f76de749SStephen Hanson #include <libcontract.h> 47f76de749SStephen Hanson #include <poll.h> 48f76de749SStephen Hanson #include <sys/contract/device.h> 49f76de749SStephen Hanson #include <libsysevent.h> 50f76de749SStephen Hanson #include <sys/sysevent/eventdefs.h> 51ded93414SHyon Kim #include <scsi/plugins/ses/vendor/sun.h> 52d91236feSeschrock 53940d71d2Seschrock #include "disk.h" 54d91236feSeschrock #include "ses.h" 55940d71d2Seschrock 56940d71d2Seschrock #define SES_VERSION 1 57940d71d2Seschrock 58ac88567aSHyon Kim #define SES_STARTING_SUBCHASSIS 256 /* valid subchassis IDs are uint8_t */ 59ac88567aSHyon Kim #define NO_SUBCHASSIS ((uint64_t)-1) 60ac88567aSHyon Kim 61525b85dbSEric Schrock static int ses_snap_freq = 250; /* in milliseconds */ 62940d71d2Seschrock 63d91236feSeschrock #define SES_STATUS_UNAVAIL(s) \ 640b32bb8bSEric Schrock ((s) == SES_ESC_UNSUPPORTED || (s) >= SES_ESC_NOT_INSTALLED) 65940d71d2Seschrock 66ded93414SHyon Kim #define HR_SECOND 1000000000 67ded93414SHyon Kim 68940d71d2Seschrock /* 69940d71d2Seschrock * Because multiple SES targets can be part of a single chassis, we construct 70940d71d2Seschrock * our own hierarchy that takes this into account. These SES targets may refer 71940d71d2Seschrock * to the same devices (multiple paths) or to different devices (managing 72940d71d2Seschrock * different portions of the space). We arrange things into a 73940d71d2Seschrock * ses_enum_enclosure_t, which contains a set of ses targets, and a list of all 74940d71d2Seschrock * nodes found so far. 75940d71d2Seschrock */ 760b32bb8bSEric Schrock typedef struct ses_alt_node { 770b32bb8bSEric Schrock topo_list_t san_link; 780b32bb8bSEric Schrock ses_node_t *san_node; 790b32bb8bSEric Schrock } ses_alt_node_t; 80940d71d2Seschrock 81940d71d2Seschrock typedef struct ses_enum_node { 82940d71d2Seschrock topo_list_t sen_link; 83940d71d2Seschrock ses_node_t *sen_node; 840b32bb8bSEric Schrock topo_list_t sen_alt_nodes; 85940d71d2Seschrock uint64_t sen_type; 86940d71d2Seschrock uint64_t sen_instance; 87940d71d2Seschrock ses_enum_target_t *sen_target; 88940d71d2Seschrock } ses_enum_node_t; 89940d71d2Seschrock 90940d71d2Seschrock typedef struct ses_enum_chassis { 91940d71d2Seschrock topo_list_t sec_link; 9253dbcc59SSundeep Panicker topo_list_t sec_subchassis; 93940d71d2Seschrock topo_list_t sec_nodes; 94940d71d2Seschrock topo_list_t sec_targets; 95940d71d2Seschrock const char *sec_csn; 96940d71d2Seschrock ses_node_t *sec_enclosure; 97940d71d2Seschrock ses_enum_target_t *sec_target; 98940d71d2Seschrock topo_instance_t sec_instance; 9953dbcc59SSundeep Panicker topo_instance_t sec_scinstance; 100ac88567aSHyon Kim topo_instance_t sec_maxinstance; 101940d71d2Seschrock boolean_t sec_hasdev; 102d91236feSeschrock boolean_t sec_internal; 103940d71d2Seschrock } ses_enum_chassis_t; 104940d71d2Seschrock 105940d71d2Seschrock typedef struct ses_enum_data { 106ac88567aSHyon Kim topo_list_t sed_devs; 107940d71d2Seschrock topo_list_t sed_chassis; 108940d71d2Seschrock ses_enum_chassis_t *sed_current; 109940d71d2Seschrock ses_enum_target_t *sed_target; 110940d71d2Seschrock int sed_errno; 111940d71d2Seschrock char *sed_name; 112940d71d2Seschrock topo_mod_t *sed_mod; 113940d71d2Seschrock topo_instance_t sed_instance; 114940d71d2Seschrock } ses_enum_data_t; 115940d71d2Seschrock 116ac88567aSHyon Kim typedef struct sas_connector_phy_data { 117ded93414SHyon Kim uint64_t scpd_index; 118ded93414SHyon Kim uint64_t scpd_pm; 119ac88567aSHyon Kim } sas_connector_phy_data_t; 120ac88567aSHyon Kim 121ac88567aSHyon Kim typedef struct sas_connector_type { 122ded93414SHyon Kim uint64_t sct_type; 123ded93414SHyon Kim char *sct_name; 124ac88567aSHyon Kim } sas_connector_type_t; 125ac88567aSHyon Kim 126ac88567aSHyon Kim static const sas_connector_type_t sas_connector_type_list[] = { 127ac88567aSHyon Kim { 0x0, "Information unknown" }, 128ac88567aSHyon Kim { 0x1, "External SAS 4x receptacle (see SAS-2 and SFF-8470)" }, 129ac88567aSHyon Kim { 0x2, "Exteranl Mini SAS 4x receptacle (see SAS-2 and SFF-8088)" }, 130ac88567aSHyon Kim { 0xF, "Vendor-specific external connector" }, 131ac88567aSHyon Kim { 0x10, "Internal wide SAS 4i plug (see SAS-2 and SFF-8484)" }, 132ac88567aSHyon Kim { 0x11, 133ac88567aSHyon Kim "Internal wide Mini SAS 4i receptacle (see SAS-2 and SFF-8087)" }, 134ac88567aSHyon Kim { 0x20, "Internal SAS Drive receptacle (see SAS-2 and SFF-8482)" }, 135ac88567aSHyon Kim { 0x21, "Internal SATA host plug (see SAS-2 and SATA-2)" }, 136ac88567aSHyon Kim { 0x22, "Internal SAS Drive plug (see SAS-2 and SFF-8482)" }, 137ac88567aSHyon Kim { 0x23, "Internal SATA device plug (see SAS-2 and SATA-2)" }, 138ac88567aSHyon Kim { 0x2F, "Internal SAS virtual connector" }, 139ac88567aSHyon Kim { 0x3F, "Vendor-specific internal connector" }, 140ac88567aSHyon Kim { 0x70, "Other Vendor-specific connector" }, 141ac88567aSHyon Kim { 0x71, "Other Vendor-specific connector" }, 142ac88567aSHyon Kim { 0x72, "Other Vendor-specific connector" }, 143ac88567aSHyon Kim { 0x73, "Other Vendor-specific connector" }, 144ac88567aSHyon Kim { 0x74, "Other Vendor-specific connector" }, 145ac88567aSHyon Kim { 0x75, "Other Vendor-specific connector" }, 146ac88567aSHyon Kim { 0x76, "Other Vendor-specific connector" }, 147ac88567aSHyon Kim { 0x77, "Other Vendor-specific connector" }, 148ac88567aSHyon Kim { 0x78, "Other Vendor-specific connector" }, 149ac88567aSHyon Kim { 0x79, "Other Vendor-specific connector" }, 150ac88567aSHyon Kim { 0x7A, "Other Vendor-specific connector" }, 151ac88567aSHyon Kim { 0x7B, "Other Vendor-specific connector" }, 152ac88567aSHyon Kim { 0x7C, "Other Vendor-specific connector" }, 153ac88567aSHyon Kim { 0x7D, "Other Vendor-specific connector" }, 154ac88567aSHyon Kim { 0x7E, "Other Vendor-specific connector" }, 155ac88567aSHyon Kim { 0x7F, "Other Vendor-specific connector" }, 156ac88567aSHyon Kim { 0x80, "Not Defined" } 157ac88567aSHyon Kim }; 158ac88567aSHyon Kim 159ac88567aSHyon Kim #define SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED 0x80 160ac88567aSHyon Kim #define SAS_CONNECTOR_TYPE_NOT_DEFINED \ 161ac88567aSHyon Kim "Connector type not definedi by SES-2 standard" 162ac88567aSHyon Kim #define SAS_CONNECTOR_TYPE_RESERVED \ 163ac88567aSHyon Kim "Connector type reserved by SES-2 standard" 164ac88567aSHyon Kim 165ded93414SHyon Kim typedef struct phys_enum_type { 166ded93414SHyon Kim uint64_t pet_type; 167ded93414SHyon Kim char *pet_nodename; 168ded93414SHyon Kim char *pet_defaultlabel; 169ded93414SHyon Kim boolean_t pet_dorange; 170ded93414SHyon Kim } phys_enum_type_t; 171ded93414SHyon Kim 172ded93414SHyon Kim static const phys_enum_type_t phys_enum_type_list[] = { 173ded93414SHyon Kim { SES_ET_ARRAY_DEVICE, BAY, "BAY", B_TRUE }, 174ded93414SHyon Kim { SES_ET_COOLING, FAN, "FAN", B_TRUE }, 175ded93414SHyon Kim { SES_ET_DEVICE, BAY, "BAY", B_TRUE }, 176ded93414SHyon Kim { SES_ET_ESC_ELECTRONICS, CONTROLLER, "CONTROLLER", B_TRUE }, 177ded93414SHyon Kim { SES_ET_POWER_SUPPLY, PSU, "PSU", B_TRUE }, 178ded93414SHyon Kim { SES_ET_SUNW_FANBOARD, FANBOARD, "FANBOARD", B_TRUE }, 179ded93414SHyon Kim { SES_ET_SUNW_FANMODULE, FANMODULE, "FANMODULE", B_TRUE }, 180ded93414SHyon Kim { SES_ET_SUNW_POWERBOARD, POWERBOARD, "POWERBOARD", B_TRUE }, 181ded93414SHyon Kim { SES_ET_SUNW_POWERMODULE, POWERMODULE, "POWERMODULE", B_TRUE } 182ded93414SHyon Kim }; 183ded93414SHyon Kim 184ded93414SHyon Kim #define N_PHYS_ENUM_TYPES (sizeof (phys_enum_type_list) / \ 185ded93414SHyon Kim sizeof (phys_enum_type_list[0])) 186ded93414SHyon Kim 187ded93414SHyon Kim /* 188ded93414SHyon Kim * Structure for the hierarchical tree for element nodes. 189ded93414SHyon Kim */ 190ded93414SHyon Kim typedef struct ses_phys_tree { 191ded93414SHyon Kim ses_node_t *spt_snode; 192ded93414SHyon Kim ses_enum_node_t *spt_senumnode; 193ded93414SHyon Kim boolean_t spt_isfru; 194ded93414SHyon Kim uint64_t spt_eonlyindex; 195ded93414SHyon Kim uint64_t spt_cindex; 196ded93414SHyon Kim uint64_t spt_pindex; 197ded93414SHyon Kim uint64_t spt_maxinst; 198ded93414SHyon Kim struct ses_phys_tree *spt_parent; 199ded93414SHyon Kim struct ses_phys_tree *spt_child; 200ded93414SHyon Kim struct ses_phys_tree *spt_sibling; 201ded93414SHyon Kim tnode_t *spt_tnode; 202ded93414SHyon Kim } ses_phys_tree_t; 203ded93414SHyon Kim 20453dbcc59SSundeep Panicker typedef enum { 20553dbcc59SSundeep Panicker SES_NEW_CHASSIS = 0x1, 20653dbcc59SSundeep Panicker SES_NEW_SUBCHASSIS = 0x2, 20753dbcc59SSundeep Panicker SES_DUP_CHASSIS = 0x4, 20853dbcc59SSundeep Panicker SES_DUP_SUBCHASSIS = 0x8 20953dbcc59SSundeep Panicker } ses_chassis_type_e; 21053dbcc59SSundeep Panicker 211ded93414SHyon Kim 212b4879163SHyon Kim static const topo_pgroup_info_t storage_pgroup = { 213b4879163SHyon Kim TOPO_PGROUP_STORAGE, 214ac88567aSHyon Kim TOPO_STABILITY_PRIVATE, 215ac88567aSHyon Kim TOPO_STABILITY_PRIVATE, 216ac88567aSHyon Kim 1 217ac88567aSHyon Kim }; 218ac88567aSHyon Kim 219b4879163SHyon Kim static const topo_pgroup_info_t smp_pgroup = { 220b4879163SHyon Kim TOPO_PGROUP_SMP, 221ac88567aSHyon Kim TOPO_STABILITY_PRIVATE, 222ac88567aSHyon Kim TOPO_STABILITY_PRIVATE, 223ac88567aSHyon Kim 1 224ac88567aSHyon Kim }; 225ac88567aSHyon Kim 226a961ec00SHyon Kim static const topo_pgroup_info_t ses_pgroup = { 227a961ec00SHyon Kim TOPO_PGROUP_SES, 228a961ec00SHyon Kim TOPO_STABILITY_PRIVATE, 229a961ec00SHyon Kim TOPO_STABILITY_PRIVATE, 230a961ec00SHyon Kim 1 231a961ec00SHyon Kim }; 232a961ec00SHyon Kim 233940d71d2Seschrock static int ses_present(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *, 234940d71d2Seschrock nvlist_t **); 235940d71d2Seschrock static int ses_contains(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *, 236940d71d2Seschrock nvlist_t **); 237940d71d2Seschrock 238940d71d2Seschrock static const topo_method_t ses_component_methods[] = { 239940d71d2Seschrock { TOPO_METH_PRESENT, TOPO_METH_PRESENT_DESC, 240940d71d2Seschrock TOPO_METH_PRESENT_VERSION0, TOPO_STABILITY_INTERNAL, ses_present }, 241d91236feSeschrock { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0, 242d91236feSeschrock TOPO_STABILITY_INTERNAL, ses_node_enum_facility }, 24388045cffSRobert Johnston { TOPO_METH_SENSOR_FAILURE, TOPO_METH_SENSOR_FAILURE_DESC, 24488045cffSRobert Johnston TOPO_METH_SENSOR_FAILURE_VERSION, TOPO_STABILITY_INTERNAL, 24588045cffSRobert Johnston topo_method_sensor_failure }, 246d91236feSeschrock { NULL } 247d91236feSeschrock }; 248d91236feSeschrock 249d91236feSeschrock static const topo_method_t ses_bay_methods[] = { 250d91236feSeschrock { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0, 251d91236feSeschrock TOPO_STABILITY_INTERNAL, ses_node_enum_facility }, 252940d71d2Seschrock { NULL } 253940d71d2Seschrock }; 254940d71d2Seschrock 255940d71d2Seschrock static const topo_method_t ses_enclosure_methods[] = { 256940d71d2Seschrock { TOPO_METH_CONTAINS, TOPO_METH_CONTAINS_DESC, 257940d71d2Seschrock TOPO_METH_CONTAINS_VERSION, TOPO_STABILITY_INTERNAL, ses_contains }, 258d91236feSeschrock { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0, 259d91236feSeschrock TOPO_STABILITY_INTERNAL, ses_enc_enum_facility }, 260940d71d2Seschrock { NULL } 261940d71d2Seschrock }; 262940d71d2Seschrock 263f76de749SStephen Hanson /* 264f76de749SStephen Hanson * Functions for tracking ses devices which we were unable to open. We retry 265f76de749SStephen Hanson * these at regular intervals using ses_recheck_dir() and if we find that we 266f76de749SStephen Hanson * can now open any of them then we send a sysevent to indicate that a new topo 267f76de749SStephen Hanson * snapshot should be taken. 268f76de749SStephen Hanson */ 269f76de749SStephen Hanson typedef struct ses_open_fail_list { 270f76de749SStephen Hanson struct ses_open_fail_list *sof_next; 271f76de749SStephen Hanson char *sof_path; 272f76de749SStephen Hanson } ses_open_fail_list_t; 273f76de749SStephen Hanson 274f76de749SStephen Hanson static ses_open_fail_list_t *ses_sofh; 275f76de749SStephen Hanson static pthread_mutex_t ses_sofmt; 27605b58617SStephen Hanson static void ses_ct_print(char *ptr); 277f76de749SStephen Hanson 278f76de749SStephen Hanson static void 27905b58617SStephen Hanson ses_recheck_dir() 280f76de749SStephen Hanson { 281f76de749SStephen Hanson ses_target_t *target; 282f76de749SStephen Hanson sysevent_id_t eid; 28305b58617SStephen Hanson char buf[80]; 284f76de749SStephen Hanson ses_open_fail_list_t *sof; 285f76de749SStephen Hanson 286f76de749SStephen Hanson /* 287f76de749SStephen Hanson * check list of "unable to open" devices 288f76de749SStephen Hanson */ 289f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sofmt); 290f76de749SStephen Hanson for (sof = ses_sofh; sof != NULL; sof = sof->sof_next) { 291f76de749SStephen Hanson /* 292f76de749SStephen Hanson * see if we can open it now 293f76de749SStephen Hanson */ 294f76de749SStephen Hanson if ((target = ses_open(LIBSES_VERSION, 295f76de749SStephen Hanson sof->sof_path)) == NULL) { 29605b58617SStephen Hanson (void) snprintf(buf, sizeof (buf), 297f76de749SStephen Hanson "recheck_dir - still can't open %s", sof->sof_path); 29805b58617SStephen Hanson ses_ct_print(buf); 299f76de749SStephen Hanson continue; 300f76de749SStephen Hanson } 301f76de749SStephen Hanson 302f76de749SStephen Hanson /* 303f76de749SStephen Hanson * ok - better force a new snapshot 304f76de749SStephen Hanson */ 30505b58617SStephen Hanson (void) snprintf(buf, sizeof (buf), 306f76de749SStephen Hanson "recheck_dir - can now open %s", sof->sof_path); 30705b58617SStephen Hanson ses_ct_print(buf); 308f76de749SStephen Hanson (void) sysevent_post_event(EC_PLATFORM, ESC_PLATFORM_SP_RESET, 309f76de749SStephen Hanson SUNW_VENDOR, "fmd", NULL, &eid); 310f76de749SStephen Hanson ses_close(target); 311f76de749SStephen Hanson break; 312f76de749SStephen Hanson } 313f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sofmt); 314f76de749SStephen Hanson } 315f76de749SStephen Hanson 316f76de749SStephen Hanson static void 317f76de749SStephen Hanson ses_sof_alloc(topo_mod_t *mod, char *path) 318f76de749SStephen Hanson { 319f76de749SStephen Hanson ses_open_fail_list_t *sof; 320f76de749SStephen Hanson 321f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sofmt); 322f76de749SStephen Hanson sof = topo_mod_zalloc(mod, sizeof (*sof)); 323f76de749SStephen Hanson topo_mod_dprintf(mod, "sof_alloc %s", path); 324f76de749SStephen Hanson sof->sof_path = path; 325f76de749SStephen Hanson sof->sof_next = ses_sofh; 326f76de749SStephen Hanson ses_sofh = sof; 327f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sofmt); 328f76de749SStephen Hanson } 329f76de749SStephen Hanson 330f76de749SStephen Hanson static void 331f76de749SStephen Hanson ses_sof_freeall(topo_mod_t *mod) 332f76de749SStephen Hanson { 333f76de749SStephen Hanson ses_open_fail_list_t *sof, *next_sof; 334f76de749SStephen Hanson 335f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sofmt); 336f76de749SStephen Hanson for (sof = ses_sofh; sof != NULL; sof = next_sof) { 337f76de749SStephen Hanson next_sof = sof->sof_next; 338f76de749SStephen Hanson topo_mod_dprintf(mod, "sof_freeall %s", sof->sof_path); 339f76de749SStephen Hanson topo_mod_strfree(mod, sof->sof_path); 340f76de749SStephen Hanson topo_mod_free(mod, sof, sizeof (*sof)); 341f76de749SStephen Hanson } 342f76de749SStephen Hanson ses_sofh = NULL; 343f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sofmt); 344f76de749SStephen Hanson } 345f76de749SStephen Hanson 346f76de749SStephen Hanson /* 347f76de749SStephen Hanson * functions for verifying that the ses_enum_target_t held in a device 348f76de749SStephen Hanson * contract's cookie field is still valid (it may have been freed by 349f76de749SStephen Hanson * ses_release()). 350f76de749SStephen Hanson */ 351f76de749SStephen Hanson typedef struct ses_stp_list { 352f76de749SStephen Hanson struct ses_stp_list *ssl_next; 353f76de749SStephen Hanson ses_enum_target_t *ssl_tgt; 354f76de749SStephen Hanson } ses_stp_list_t; 355f76de749SStephen Hanson 356f76de749SStephen Hanson static ses_stp_list_t *ses_sslh; 357f76de749SStephen Hanson static pthread_mutex_t ses_sslmt; 358f76de749SStephen Hanson 359f76de749SStephen Hanson static void 360f76de749SStephen Hanson ses_ssl_alloc(topo_mod_t *mod, ses_enum_target_t *stp) 361f76de749SStephen Hanson { 362f76de749SStephen Hanson ses_stp_list_t *ssl; 363f76de749SStephen Hanson 364f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sslmt); 365f76de749SStephen Hanson ssl = topo_mod_zalloc(mod, sizeof (*ssl)); 366f76de749SStephen Hanson topo_mod_dprintf(mod, "ssl_alloc %p", stp); 367f76de749SStephen Hanson ssl->ssl_tgt = stp; 368f76de749SStephen Hanson ssl->ssl_next = ses_sslh; 369f76de749SStephen Hanson ses_sslh = ssl; 370f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 371f76de749SStephen Hanson } 372f76de749SStephen Hanson 373f76de749SStephen Hanson static void 374f76de749SStephen Hanson ses_ssl_free(topo_mod_t *mod, ses_enum_target_t *stp) 375f76de749SStephen Hanson { 376f76de749SStephen Hanson ses_stp_list_t *ssl, *prev_ssl; 377f76de749SStephen Hanson 378f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sslmt); 379f76de749SStephen Hanson prev_ssl = NULL; 380f76de749SStephen Hanson for (ssl = ses_sslh; ssl != NULL; ssl = ssl->ssl_next) { 381f76de749SStephen Hanson if (ssl->ssl_tgt == stp) { 382f76de749SStephen Hanson topo_mod_dprintf(mod, "ssl_free %p", ssl->ssl_tgt); 383f76de749SStephen Hanson if (prev_ssl == NULL) 384f76de749SStephen Hanson ses_sslh = ssl->ssl_next; 385f76de749SStephen Hanson else 386f76de749SStephen Hanson prev_ssl->ssl_next = ssl->ssl_next; 387f76de749SStephen Hanson topo_mod_free(mod, ssl, sizeof (*ssl)); 388f76de749SStephen Hanson break; 389f76de749SStephen Hanson } 390f76de749SStephen Hanson prev_ssl = ssl; 391f76de749SStephen Hanson } 392f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 393f76de749SStephen Hanson } 394f76de749SStephen Hanson 395f76de749SStephen Hanson static int 396f76de749SStephen Hanson ses_ssl_valid(ses_enum_target_t *stp) 397f76de749SStephen Hanson { 398f76de749SStephen Hanson ses_stp_list_t *ssl; 399f76de749SStephen Hanson 400f76de749SStephen Hanson for (ssl = ses_sslh; ssl != NULL; ssl = ssl->ssl_next) 401f76de749SStephen Hanson if (ssl->ssl_tgt == stp) 402f76de749SStephen Hanson return (1); 403f76de749SStephen Hanson return (0); 404f76de749SStephen Hanson } 405f76de749SStephen Hanson 406f76de749SStephen Hanson /* 407f76de749SStephen Hanson * Functions for creating and destroying a background thread 408f76de749SStephen Hanson * (ses_contract_thread) used for detecting when ses devices have been 409f76de749SStephen Hanson * retired/unretired. 410f76de749SStephen Hanson */ 411f76de749SStephen Hanson static struct ses_thread_s { 412f76de749SStephen Hanson pthread_mutex_t mt; 413f76de749SStephen Hanson pthread_t tid; 414f76de749SStephen Hanson int thr_sig; 415f76de749SStephen Hanson int doexit; 416f76de749SStephen Hanson int count; 417f76de749SStephen Hanson } sesthread = { 418f76de749SStephen Hanson PTHREAD_MUTEX_INITIALIZER, 419f76de749SStephen Hanson 0, 420f76de749SStephen Hanson SIGTERM, 421f76de749SStephen Hanson 0, 422f76de749SStephen Hanson 0 423f76de749SStephen Hanson }; 424f76de749SStephen Hanson 42505b58617SStephen Hanson typedef struct ses_mod_list { 42605b58617SStephen Hanson struct ses_mod_list *smod_next; 42705b58617SStephen Hanson topo_mod_t *smod_mod; 42805b58617SStephen Hanson } ses_mod_list_t; 42905b58617SStephen Hanson 43005b58617SStephen Hanson static ses_mod_list_t *ses_smod; 43105b58617SStephen Hanson 43205b58617SStephen Hanson static void 43305b58617SStephen Hanson ses_ct_print(char *ptr) 43405b58617SStephen Hanson { 43505b58617SStephen Hanson (void) pthread_mutex_lock(&sesthread.mt); 4362eb07f5eSStephen Hanson if (ses_smod != NULL && ses_smod->smod_mod != NULL) 43705b58617SStephen Hanson topo_mod_dprintf(ses_smod->smod_mod, ptr); 43805b58617SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 43905b58617SStephen Hanson } 44005b58617SStephen Hanson 44105b58617SStephen Hanson /*ARGSUSED*/ 442f76de749SStephen Hanson static void * 443f76de749SStephen Hanson ses_contract_thread(void *arg) 444f76de749SStephen Hanson { 445f76de749SStephen Hanson int efd, ctlfd, statfd; 446f76de749SStephen Hanson ct_evthdl_t ev; 447f76de749SStephen Hanson ctevid_t evid; 448f76de749SStephen Hanson uint_t event; 449f76de749SStephen Hanson char path[PATH_MAX]; 45005b58617SStephen Hanson char buf[80]; 451f76de749SStephen Hanson ses_enum_target_t *stp; 452f76de749SStephen Hanson ct_stathdl_t stathdl; 453f76de749SStephen Hanson ctid_t ctid; 454f76de749SStephen Hanson struct pollfd fds; 455f76de749SStephen Hanson int pollret; 456*057c620aSHans Rosenfeld sigset_t sigset; 457f76de749SStephen Hanson 45805b58617SStephen Hanson ses_ct_print("start contract event thread"); 459f76de749SStephen Hanson efd = open64(CTFS_ROOT "/device/pbundle", O_RDONLY); 460f76de749SStephen Hanson fds.fd = efd; 461f76de749SStephen Hanson fds.events = POLLIN; 462f76de749SStephen Hanson fds.revents = 0; 463*057c620aSHans Rosenfeld sigaddset(&sigset, sesthread.thr_sig); 464*057c620aSHans Rosenfeld pthread_sigmask(SIG_UNBLOCK, &sigset, NULL); 465f76de749SStephen Hanson for (;;) { 466f76de749SStephen Hanson /* check if we've been asked to exit */ 467f76de749SStephen Hanson (void) pthread_mutex_lock(&sesthread.mt); 468f76de749SStephen Hanson if (sesthread.doexit) { 469f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 470f76de749SStephen Hanson break; 471f76de749SStephen Hanson } 472f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 473f76de749SStephen Hanson 474f76de749SStephen Hanson /* poll until an event arrives */ 475f76de749SStephen Hanson if ((pollret = poll(&fds, 1, 10000)) <= 0) { 476f76de749SStephen Hanson if (pollret == 0) 47705b58617SStephen Hanson ses_recheck_dir(); 478f76de749SStephen Hanson continue; 479f76de749SStephen Hanson } 480f76de749SStephen Hanson 481f76de749SStephen Hanson /* read the event */ 482f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sslmt); 48305b58617SStephen Hanson ses_ct_print("read contract event"); 484f76de749SStephen Hanson if (ct_event_read(efd, &ev) != 0) { 485f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 486f76de749SStephen Hanson continue; 487f76de749SStephen Hanson } 488f76de749SStephen Hanson 489f76de749SStephen Hanson /* see if it is an event we are expecting */ 490f76de749SStephen Hanson ctid = ct_event_get_ctid(ev); 49105b58617SStephen Hanson (void) snprintf(buf, sizeof (buf), 49205b58617SStephen Hanson "got contract event ctid=%d", ctid); 49305b58617SStephen Hanson ses_ct_print(buf); 494f76de749SStephen Hanson event = ct_event_get_type(ev); 495f76de749SStephen Hanson if (event != CT_DEV_EV_OFFLINE && event != CT_EV_NEGEND) { 496edb433b6SMilan Jurik (void) snprintf(buf, sizeof (buf), 49705b58617SStephen Hanson "bad contract event %x", event); 49805b58617SStephen Hanson ses_ct_print(buf); 499f76de749SStephen Hanson ct_event_free(ev); 500f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 501f76de749SStephen Hanson continue; 502f76de749SStephen Hanson } 503f76de749SStephen Hanson 504f76de749SStephen Hanson /* find target pointer saved in cookie */ 505f76de749SStephen Hanson evid = ct_event_get_evid(ev); 506f76de749SStephen Hanson (void) snprintf(path, PATH_MAX, CTFS_ROOT "/device/%ld/status", 507f76de749SStephen Hanson ctid); 508f76de749SStephen Hanson statfd = open64(path, O_RDONLY); 509edb433b6SMilan Jurik (void) ct_status_read(statfd, CTD_COMMON, &stathdl); 510f76de749SStephen Hanson stp = (ses_enum_target_t *)(uintptr_t) 511f76de749SStephen Hanson ct_status_get_cookie(stathdl); 512f76de749SStephen Hanson ct_status_free(stathdl); 513edb433b6SMilan Jurik (void) close(statfd); 514f76de749SStephen Hanson 515f76de749SStephen Hanson /* check if target pointer is still valid */ 516f76de749SStephen Hanson if (ses_ssl_valid(stp) == 0) { 517edb433b6SMilan Jurik (void) snprintf(buf, sizeof (buf), 51805b58617SStephen Hanson "contract already abandoned %x", event); 51905b58617SStephen Hanson ses_ct_print(buf); 520f76de749SStephen Hanson (void) snprintf(path, PATH_MAX, 521f76de749SStephen Hanson CTFS_ROOT "/device/%ld/ctl", ctid); 522f76de749SStephen Hanson ctlfd = open64(path, O_WRONLY); 523f76de749SStephen Hanson if (event != CT_EV_NEGEND) 524edb433b6SMilan Jurik (void) ct_ctl_ack(ctlfd, evid); 525f76de749SStephen Hanson else 526edb433b6SMilan Jurik (void) ct_ctl_abandon(ctlfd); 527edb433b6SMilan Jurik (void) close(ctlfd); 528f76de749SStephen Hanson ct_event_free(ev); 529f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 530f76de749SStephen Hanson continue; 531f76de749SStephen Hanson } 532f76de749SStephen Hanson 533f76de749SStephen Hanson /* find control device for ack/abandon */ 534f76de749SStephen Hanson (void) pthread_mutex_lock(&stp->set_lock); 535f76de749SStephen Hanson (void) snprintf(path, PATH_MAX, CTFS_ROOT "/device/%ld/ctl", 536f76de749SStephen Hanson ctid); 537f76de749SStephen Hanson ctlfd = open64(path, O_WRONLY); 538f76de749SStephen Hanson if (event != CT_EV_NEGEND) { 539f76de749SStephen Hanson /* if this is an offline event, do the offline */ 54005b58617SStephen Hanson ses_ct_print("got contract offline event"); 541f76de749SStephen Hanson if (stp->set_target) { 54205b58617SStephen Hanson ses_ct_print("contract thread rele"); 543f76de749SStephen Hanson ses_snap_rele(stp->set_snap); 544f76de749SStephen Hanson ses_close(stp->set_target); 545f76de749SStephen Hanson stp->set_target = NULL; 546f76de749SStephen Hanson } 547edb433b6SMilan Jurik (void) ct_ctl_ack(ctlfd, evid); 548f76de749SStephen Hanson } else { 549f76de749SStephen Hanson /* if this is the negend, then abandon the contract */ 55005b58617SStephen Hanson ses_ct_print("got contract negend"); 551f76de749SStephen Hanson if (stp->set_ctid) { 552ad8ef92aSMilan Jurik (void) snprintf(buf, sizeof (buf), 55305b58617SStephen Hanson "abandon old contract %d", stp->set_ctid); 55405b58617SStephen Hanson ses_ct_print(buf); 555f76de749SStephen Hanson stp->set_ctid = NULL; 556f76de749SStephen Hanson } 557edb433b6SMilan Jurik (void) ct_ctl_abandon(ctlfd); 558f76de749SStephen Hanson } 559ad8ef92aSMilan Jurik (void) close(ctlfd); 560f76de749SStephen Hanson (void) pthread_mutex_unlock(&stp->set_lock); 561f76de749SStephen Hanson ct_event_free(ev); 562f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 563f76de749SStephen Hanson } 564ad8ef92aSMilan Jurik (void) close(efd); 565f76de749SStephen Hanson return (NULL); 566f76de749SStephen Hanson } 567f76de749SStephen Hanson 568f76de749SStephen Hanson int 569f76de749SStephen Hanson find_thr_sig(void) 570f76de749SStephen Hanson { 571f76de749SStephen Hanson int i; 572f76de749SStephen Hanson sigset_t oset, rset; 573f76de749SStephen Hanson int sig[] = {SIGTERM, SIGUSR1, SIGUSR2}; 574f76de749SStephen Hanson int sig_sz = sizeof (sig) / sizeof (int); 575f76de749SStephen Hanson int rc = SIGTERM; 576f76de749SStephen Hanson 577f76de749SStephen Hanson /* prefered set of signals that are likely used to terminate threads */ 578f76de749SStephen Hanson (void) sigemptyset(&oset); 579f76de749SStephen Hanson (void) pthread_sigmask(SIG_SETMASK, NULL, &oset); 580f76de749SStephen Hanson for (i = 0; i < sig_sz; i++) { 581f76de749SStephen Hanson if (sigismember(&oset, sig[i]) == 0) { 582f76de749SStephen Hanson return (sig[i]); 583f76de749SStephen Hanson } 584f76de749SStephen Hanson } 585f76de749SStephen Hanson 586f76de749SStephen Hanson /* reserved set of signals that are not allowed to terminate thread */ 587f76de749SStephen Hanson (void) sigemptyset(&rset); 588f76de749SStephen Hanson (void) sigaddset(&rset, SIGABRT); 589f76de749SStephen Hanson (void) sigaddset(&rset, SIGKILL); 590f76de749SStephen Hanson (void) sigaddset(&rset, SIGSTOP); 591f76de749SStephen Hanson (void) sigaddset(&rset, SIGCANCEL); 592f76de749SStephen Hanson 593f76de749SStephen Hanson /* Find signal that is not masked and not in the reserved list. */ 594f76de749SStephen Hanson for (i = 1; i < MAXSIG; i++) { 595f76de749SStephen Hanson if (sigismember(&rset, i) == 1) { 596f76de749SStephen Hanson continue; 597f76de749SStephen Hanson } 598f76de749SStephen Hanson if (sigismember(&oset, i) == 0) { 599f76de749SStephen Hanson return (i); 600f76de749SStephen Hanson } 601f76de749SStephen Hanson } 602f76de749SStephen Hanson 603f76de749SStephen Hanson return (rc); 604f76de749SStephen Hanson } 605f76de749SStephen Hanson 606f76de749SStephen Hanson /*ARGSUSED*/ 607f76de749SStephen Hanson static void 608f76de749SStephen Hanson ses_handler(int sig) 609f76de749SStephen Hanson { 610f76de749SStephen Hanson } 611f76de749SStephen Hanson 612f76de749SStephen Hanson static void 61305b58617SStephen Hanson ses_thread_init(topo_mod_t *mod) 614f76de749SStephen Hanson { 615f76de749SStephen Hanson pthread_attr_t *attr = NULL; 616f76de749SStephen Hanson struct sigaction act; 61705b58617SStephen Hanson ses_mod_list_t *smod; 618f76de749SStephen Hanson 619f76de749SStephen Hanson (void) pthread_mutex_lock(&sesthread.mt); 620f76de749SStephen Hanson sesthread.count++; 62105b58617SStephen Hanson smod = topo_mod_zalloc(mod, sizeof (*smod)); 62205b58617SStephen Hanson smod->smod_mod = mod; 62305b58617SStephen Hanson smod->smod_next = ses_smod; 62405b58617SStephen Hanson ses_smod = smod; 625f76de749SStephen Hanson if (sesthread.tid == 0) { 626f76de749SStephen Hanson /* find a suitable signal to use for killing the thread below */ 627f76de749SStephen Hanson sesthread.thr_sig = find_thr_sig(); 628f76de749SStephen Hanson 629f76de749SStephen Hanson /* if don't have a handler for this signal, create one */ 630f76de749SStephen Hanson (void) sigaction(sesthread.thr_sig, NULL, &act); 631f76de749SStephen Hanson if (act.sa_handler == SIG_DFL || act.sa_handler == SIG_IGN) 632f76de749SStephen Hanson act.sa_handler = ses_handler; 633f76de749SStephen Hanson (void) sigaction(sesthread.thr_sig, &act, NULL); 634f76de749SStephen Hanson 635f76de749SStephen Hanson /* create a thread to listen for offline events */ 636f76de749SStephen Hanson (void) pthread_create(&sesthread.tid, 63705b58617SStephen Hanson attr, ses_contract_thread, NULL); 638f76de749SStephen Hanson } 639f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 640f76de749SStephen Hanson } 641f76de749SStephen Hanson 642f76de749SStephen Hanson static void 64305b58617SStephen Hanson ses_thread_fini(topo_mod_t *mod) 644f76de749SStephen Hanson { 64505b58617SStephen Hanson ses_mod_list_t *smod, *prev_smod; 64605b58617SStephen Hanson 647f76de749SStephen Hanson (void) pthread_mutex_lock(&sesthread.mt); 64805b58617SStephen Hanson prev_smod = NULL; 64905b58617SStephen Hanson for (smod = ses_smod; smod != NULL; smod = smod->smod_next) { 65005b58617SStephen Hanson if (smod->smod_mod == mod) { 65105b58617SStephen Hanson if (prev_smod == NULL) 65205b58617SStephen Hanson ses_smod = smod->smod_next; 65305b58617SStephen Hanson else 65405b58617SStephen Hanson prev_smod->smod_next = smod->smod_next; 65505b58617SStephen Hanson topo_mod_free(mod, smod, sizeof (*smod)); 65605b58617SStephen Hanson break; 65705b58617SStephen Hanson } 65805b58617SStephen Hanson prev_smod = smod; 65905b58617SStephen Hanson } 660f76de749SStephen Hanson if (--sesthread.count > 0) { 661f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 662f76de749SStephen Hanson return; 663f76de749SStephen Hanson } 664f76de749SStephen Hanson sesthread.doexit = 1; 665f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 666f76de749SStephen Hanson (void) pthread_kill(sesthread.tid, sesthread.thr_sig); 667f76de749SStephen Hanson (void) pthread_join(sesthread.tid, NULL); 668f76de749SStephen Hanson sesthread.tid = 0; 669f76de749SStephen Hanson } 670f76de749SStephen Hanson 671f76de749SStephen Hanson static void 672f76de749SStephen Hanson ses_create_contract(topo_mod_t *mod, ses_enum_target_t *stp) 673f76de749SStephen Hanson { 674f76de749SStephen Hanson int tfd, len, rval; 675f76de749SStephen Hanson char link_path[PATH_MAX]; 676f76de749SStephen Hanson 677f76de749SStephen Hanson stp->set_ctid = NULL; 678f76de749SStephen Hanson 679f76de749SStephen Hanson /* convert "/dev" path into "/devices" path */ 680f76de749SStephen Hanson if ((len = readlink(stp->set_devpath, link_path, PATH_MAX)) < 0) { 681f76de749SStephen Hanson topo_mod_dprintf(mod, "readlink failed"); 682f76de749SStephen Hanson return; 683f76de749SStephen Hanson } 684f76de749SStephen Hanson link_path[len] = '\0'; 685f76de749SStephen Hanson 686f76de749SStephen Hanson /* set up template to create new contract */ 687f76de749SStephen Hanson tfd = open64(CTFS_ROOT "/device/template", O_RDWR); 688edb433b6SMilan Jurik (void) ct_tmpl_set_critical(tfd, CT_DEV_EV_OFFLINE); 689edb433b6SMilan Jurik (void) ct_tmpl_set_cookie(tfd, (uint64_t)(uintptr_t)stp); 690f76de749SStephen Hanson 691f76de749SStephen Hanson /* strip "../../devices" off the front and create the contract */ 692f76de749SStephen Hanson if ((rval = ct_dev_tmpl_set_minor(tfd, &link_path[13])) != 0) 693f76de749SStephen Hanson topo_mod_dprintf(mod, "failed to set minor %s rval = %d", 694f76de749SStephen Hanson &link_path[13], rval); 695f76de749SStephen Hanson else if ((rval = ct_tmpl_create(tfd, &stp->set_ctid)) != 0) 696f76de749SStephen Hanson topo_mod_dprintf(mod, "failed to create ctid rval = %d", rval); 697f76de749SStephen Hanson else 698f76de749SStephen Hanson topo_mod_dprintf(mod, "created ctid=%d", stp->set_ctid); 699ad8ef92aSMilan Jurik (void) close(tfd); 700f76de749SStephen Hanson } 701f76de749SStephen Hanson 702940d71d2Seschrock static void 703940d71d2Seschrock ses_target_free(topo_mod_t *mod, ses_enum_target_t *stp) 704940d71d2Seschrock { 705940d71d2Seschrock if (--stp->set_refcount == 0) { 706f76de749SStephen Hanson /* check if already closed due to contract offline request */ 707f76de749SStephen Hanson (void) pthread_mutex_lock(&stp->set_lock); 708f76de749SStephen Hanson if (stp->set_target) { 709f76de749SStephen Hanson ses_snap_rele(stp->set_snap); 710f76de749SStephen Hanson ses_close(stp->set_target); 711f76de749SStephen Hanson stp->set_target = NULL; 712f76de749SStephen Hanson } 713f76de749SStephen Hanson if (stp->set_ctid) { 714f76de749SStephen Hanson int ctlfd; 715f76de749SStephen Hanson char path[PATH_MAX]; 716f76de749SStephen Hanson 717f76de749SStephen Hanson topo_mod_dprintf(mod, "abandon old contract %d", 718f76de749SStephen Hanson stp->set_ctid); 719f76de749SStephen Hanson (void) snprintf(path, PATH_MAX, 720f76de749SStephen Hanson CTFS_ROOT "/device/%ld/ctl", stp->set_ctid); 721f76de749SStephen Hanson ctlfd = open64(path, O_WRONLY); 722ad8ef92aSMilan Jurik (void) ct_ctl_abandon(ctlfd); 723ad8ef92aSMilan Jurik (void) close(ctlfd); 724f76de749SStephen Hanson stp->set_ctid = NULL; 725f76de749SStephen Hanson } 726f76de749SStephen Hanson (void) pthread_mutex_unlock(&stp->set_lock); 727f76de749SStephen Hanson ses_ssl_free(mod, stp); 728940d71d2Seschrock topo_mod_strfree(mod, stp->set_devpath); 729940d71d2Seschrock topo_mod_free(mod, stp, sizeof (ses_enum_target_t)); 730940d71d2Seschrock } 731940d71d2Seschrock } 732940d71d2Seschrock 733940d71d2Seschrock static void 73453dbcc59SSundeep Panicker ses_data_free(ses_enum_data_t *sdp, ses_enum_chassis_t *pcp) 735940d71d2Seschrock { 736940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 737940d71d2Seschrock ses_enum_chassis_t *cp; 738940d71d2Seschrock ses_enum_node_t *np; 739940d71d2Seschrock ses_enum_target_t *tp; 7400b32bb8bSEric Schrock ses_alt_node_t *ap; 74153dbcc59SSundeep Panicker topo_list_t *cpl; 74253dbcc59SSundeep Panicker 74353dbcc59SSundeep Panicker 74453dbcc59SSundeep Panicker if (pcp != NULL) 74553dbcc59SSundeep Panicker cpl = &pcp->sec_subchassis; 74653dbcc59SSundeep Panicker else 74753dbcc59SSundeep Panicker cpl = &sdp->sed_chassis; 748940d71d2Seschrock 74953dbcc59SSundeep Panicker while ((cp = topo_list_next(cpl)) != NULL) { 75053dbcc59SSundeep Panicker topo_list_delete(cpl, cp); 751940d71d2Seschrock 752940d71d2Seschrock while ((np = topo_list_next(&cp->sec_nodes)) != NULL) { 7530b32bb8bSEric Schrock while ((ap = topo_list_next(&np->sen_alt_nodes)) != 7540b32bb8bSEric Schrock NULL) { 7550b32bb8bSEric Schrock topo_list_delete(&np->sen_alt_nodes, ap); 7560b32bb8bSEric Schrock topo_mod_free(mod, ap, sizeof (ses_alt_node_t)); 7570b32bb8bSEric Schrock } 758940d71d2Seschrock topo_list_delete(&cp->sec_nodes, np); 759940d71d2Seschrock topo_mod_free(mod, np, sizeof (ses_enum_node_t)); 760940d71d2Seschrock } 761940d71d2Seschrock 762940d71d2Seschrock while ((tp = topo_list_next(&cp->sec_targets)) != NULL) { 763940d71d2Seschrock topo_list_delete(&cp->sec_targets, tp); 764940d71d2Seschrock ses_target_free(mod, tp); 765940d71d2Seschrock } 766940d71d2Seschrock 767940d71d2Seschrock topo_mod_free(mod, cp, sizeof (ses_enum_chassis_t)); 768940d71d2Seschrock } 769940d71d2Seschrock 77053dbcc59SSundeep Panicker if (pcp == NULL) { 771ac88567aSHyon Kim dev_list_free(mod, &sdp->sed_devs); 77253dbcc59SSundeep Panicker topo_mod_free(mod, sdp, sizeof (ses_enum_data_t)); 77353dbcc59SSundeep Panicker } 774940d71d2Seschrock } 775940d71d2Seschrock 776940d71d2Seschrock /* 777940d71d2Seschrock * For enclosure nodes, we have a special contains method. By default, the hc 778940d71d2Seschrock * walker will compare the node name and instance number to determine if an 779940d71d2Seschrock * FMRI matches. For enclosures where the enumeration order is impossible to 780940d71d2Seschrock * predict, we instead use the chassis-id as a unique identifier, and ignore 781940d71d2Seschrock * the instance number. 782940d71d2Seschrock */ 783940d71d2Seschrock static int 784940d71d2Seschrock fmri_contains(topo_mod_t *mod, nvlist_t *nv1, nvlist_t *nv2) 785940d71d2Seschrock { 786940d71d2Seschrock uint8_t v1, v2; 787940d71d2Seschrock nvlist_t **hcp1, **hcp2; 788940d71d2Seschrock int err, i; 789940d71d2Seschrock uint_t nhcp1, nhcp2; 790940d71d2Seschrock nvlist_t *a1, *a2; 791940d71d2Seschrock char *c1, *c2; 792940d71d2Seschrock int mindepth; 793940d71d2Seschrock 794940d71d2Seschrock if (nvlist_lookup_uint8(nv1, FM_VERSION, &v1) != 0 || 795940d71d2Seschrock nvlist_lookup_uint8(nv2, FM_VERSION, &v2) != 0 || 796940d71d2Seschrock v1 > FM_HC_SCHEME_VERSION || v2 > FM_HC_SCHEME_VERSION) 797940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_VERSION)); 798940d71d2Seschrock 799940d71d2Seschrock err = nvlist_lookup_nvlist_array(nv1, FM_FMRI_HC_LIST, &hcp1, &nhcp1); 800940d71d2Seschrock err |= nvlist_lookup_nvlist_array(nv2, FM_FMRI_HC_LIST, &hcp2, &nhcp2); 801940d71d2Seschrock if (err != 0) 802940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 803940d71d2Seschrock 804940d71d2Seschrock /* 805940d71d2Seschrock * If the chassis-id doesn't match, then these FMRIs are not 806940d71d2Seschrock * equivalent. If one of the FMRIs doesn't have a chassis ID, then we 807940d71d2Seschrock * have no choice but to fall back to the instance ID. 808940d71d2Seschrock */ 809940d71d2Seschrock if (nvlist_lookup_nvlist(nv1, FM_FMRI_AUTHORITY, &a1) == 0 && 810940d71d2Seschrock nvlist_lookup_nvlist(nv2, FM_FMRI_AUTHORITY, &a2) == 0 && 811940d71d2Seschrock nvlist_lookup_string(a1, FM_FMRI_AUTH_CHASSIS, &c1) == 0 && 812940d71d2Seschrock nvlist_lookup_string(a2, FM_FMRI_AUTH_CHASSIS, &c2) == 0) { 813940d71d2Seschrock if (strcmp(c1, c2) != 0) 814940d71d2Seschrock return (0); 815940d71d2Seschrock 816940d71d2Seschrock mindepth = 1; 817940d71d2Seschrock } else { 818940d71d2Seschrock mindepth = 0; 819940d71d2Seschrock } 820940d71d2Seschrock 821940d71d2Seschrock if (nhcp2 < nhcp1) 822940d71d2Seschrock return (0); 823940d71d2Seschrock 824940d71d2Seschrock for (i = 0; i < nhcp1; i++) { 825940d71d2Seschrock char *nm1 = NULL; 826940d71d2Seschrock char *nm2 = NULL; 827940d71d2Seschrock char *id1 = NULL; 828940d71d2Seschrock char *id2 = NULL; 829940d71d2Seschrock 830940d71d2Seschrock (void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_NAME, &nm1); 831940d71d2Seschrock (void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_NAME, &nm2); 832940d71d2Seschrock (void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_ID, &id1); 833940d71d2Seschrock (void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_ID, &id2); 834940d71d2Seschrock if (nm1 == NULL || nm2 == NULL || id1 == NULL || id2 == NULL) 835940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 836940d71d2Seschrock 837940d71d2Seschrock if (strcmp(nm1, nm2) == 0 && 838940d71d2Seschrock (i < mindepth || strcmp(id1, id2) == 0)) 839940d71d2Seschrock continue; 840940d71d2Seschrock 841940d71d2Seschrock return (0); 842940d71d2Seschrock } 843940d71d2Seschrock 844940d71d2Seschrock return (1); 845940d71d2Seschrock } 846940d71d2Seschrock 847940d71d2Seschrock /*ARGSUSED*/ 848940d71d2Seschrock static int 849940d71d2Seschrock ses_contains(topo_mod_t *mod, tnode_t *tn, topo_version_t version, 850940d71d2Seschrock nvlist_t *in, nvlist_t **out) 851940d71d2Seschrock { 852940d71d2Seschrock int ret; 853940d71d2Seschrock nvlist_t *nv1, *nv2; 854940d71d2Seschrock 855940d71d2Seschrock if (version > TOPO_METH_CONTAINS_VERSION) 856940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_VER_NEW)); 857940d71d2Seschrock 858940d71d2Seschrock if (nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_FMRI, &nv1) != 0 || 859940d71d2Seschrock nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_SUBFMRI, &nv2) != 0) 860940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL)); 861940d71d2Seschrock 862940d71d2Seschrock ret = fmri_contains(mod, nv1, nv2); 863940d71d2Seschrock if (ret < 0) 864940d71d2Seschrock return (-1); 865940d71d2Seschrock 866940d71d2Seschrock if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) == 0) { 86773e32a37SRobert Johnston if (nvlist_add_uint32(*out, TOPO_METH_CONTAINS_RET, 868940d71d2Seschrock ret) == 0) 869940d71d2Seschrock return (0); 870940d71d2Seschrock else 871940d71d2Seschrock nvlist_free(*out); 872940d71d2Seschrock } 873940d71d2Seschrock 874940d71d2Seschrock return (-1); 875940d71d2Seschrock 876940d71d2Seschrock } 877940d71d2Seschrock 878940d71d2Seschrock /* 879d91236feSeschrock * Return a current instance of the node. This is somewhat complicated because 880d91236feSeschrock * we need to take a new snapshot in order to get the new data, but we don't 881940d71d2Seschrock * want to be constantly taking SES snapshots if the consumer is going to do a 882940d71d2Seschrock * series of queries. So we adopt the strategy of assuming that the SES state 883d91236feSeschrock * is not going to be rapidly changing, and limit our snapshot frequency to 884d91236feSeschrock * some defined bounds. 885940d71d2Seschrock */ 886d91236feSeschrock ses_node_t * 8870b32bb8bSEric Schrock ses_node_lock(topo_mod_t *mod, tnode_t *tn) 888940d71d2Seschrock { 889940d71d2Seschrock ses_enum_target_t *tp = topo_node_getspecific(tn); 890525b85dbSEric Schrock hrtime_t now; 891940d71d2Seschrock ses_snap_t *snap; 892940d71d2Seschrock int err; 893d91236feSeschrock uint64_t nodeid; 894940d71d2Seschrock ses_node_t *np; 895940d71d2Seschrock 896d91236feSeschrock if (tp == NULL) { 897d91236feSeschrock (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 898d91236feSeschrock return (NULL); 899d91236feSeschrock } 900940d71d2Seschrock 9010b32bb8bSEric Schrock (void) pthread_mutex_lock(&tp->set_lock); 9020b32bb8bSEric Schrock 903940d71d2Seschrock /* 904940d71d2Seschrock * Determine if we need to take a new snapshot. 905940d71d2Seschrock */ 906525b85dbSEric Schrock now = gethrtime(); 907940d71d2Seschrock 908f76de749SStephen Hanson if (tp->set_target == NULL) { 909f76de749SStephen Hanson /* 910f76de749SStephen Hanson * We may have closed the device but not yet abandoned the 911f76de749SStephen Hanson * contract (ie we've had the offline event but not yet the 912f76de749SStephen Hanson * negend). If so, just return failure. 913f76de749SStephen Hanson */ 914f76de749SStephen Hanson if (tp->set_ctid != NULL) { 915f76de749SStephen Hanson (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 916f76de749SStephen Hanson (void) pthread_mutex_unlock(&tp->set_lock); 917f76de749SStephen Hanson return (NULL); 918f76de749SStephen Hanson } 919f76de749SStephen Hanson 920f76de749SStephen Hanson /* 921f76de749SStephen Hanson * The device has been closed due to a contract offline 922f76de749SStephen Hanson * request, then we need to reopen it and create a new contract. 923f76de749SStephen Hanson */ 924f76de749SStephen Hanson if ((tp->set_target = 925f76de749SStephen Hanson ses_open(LIBSES_VERSION, tp->set_devpath)) == NULL) { 926f76de749SStephen Hanson sysevent_id_t eid; 927f76de749SStephen Hanson 928f76de749SStephen Hanson (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 929f76de749SStephen Hanson (void) pthread_mutex_unlock(&tp->set_lock); 930f76de749SStephen Hanson topo_mod_dprintf(mod, "recheck_dir - " 931f76de749SStephen Hanson "can no longer open %s", tp->set_devpath); 932f76de749SStephen Hanson (void) sysevent_post_event(EC_PLATFORM, 933f76de749SStephen Hanson ESC_PLATFORM_SP_RESET, SUNW_VENDOR, "fmd", NULL, 934f76de749SStephen Hanson &eid); 935f76de749SStephen Hanson return (NULL); 936f76de749SStephen Hanson } 937f76de749SStephen Hanson topo_mod_dprintf(mod, "reopen contract"); 938f76de749SStephen Hanson ses_create_contract(mod, tp); 939f76de749SStephen Hanson tp->set_snap = ses_snap_hold(tp->set_target); 940f76de749SStephen Hanson tp->set_snaptime = gethrtime(); 941f76de749SStephen Hanson } else if (now - tp->set_snaptime > (ses_snap_freq * 1000 * 1000) && 942940d71d2Seschrock (snap = ses_snap_new(tp->set_target)) != NULL) { 943940d71d2Seschrock if (ses_snap_generation(snap) != 944940d71d2Seschrock ses_snap_generation(tp->set_snap)) { 945940d71d2Seschrock /* 946940d71d2Seschrock * If we find ourselves in this situation, we're in 947940d71d2Seschrock * trouble. The generation count has changed, which 948940d71d2Seschrock * indicates that our current topology is out of date. 949940d71d2Seschrock * But we need to consult the new topology in order to 950940d71d2Seschrock * determine presence at this moment in time. We can't 951940d71d2Seschrock * go back and change the topo snapshot in situ, so 952d91236feSeschrock * we'll just have to fail the call in this unlikely 953d91236feSeschrock * scenario. 954940d71d2Seschrock */ 955940d71d2Seschrock ses_snap_rele(snap); 956d91236feSeschrock (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 9570b32bb8bSEric Schrock (void) pthread_mutex_unlock(&tp->set_lock); 958d91236feSeschrock return (NULL); 959940d71d2Seschrock } else { 960940d71d2Seschrock ses_snap_rele(tp->set_snap); 961940d71d2Seschrock tp->set_snap = snap; 962940d71d2Seschrock } 963525b85dbSEric Schrock tp->set_snaptime = gethrtime(); 964940d71d2Seschrock } 965940d71d2Seschrock 966940d71d2Seschrock snap = tp->set_snap; 967940d71d2Seschrock 968940d71d2Seschrock verify(topo_prop_get_uint64(tn, TOPO_PGROUP_SES, 969940d71d2Seschrock TOPO_PROP_NODE_ID, &nodeid, &err) == 0); 970940d71d2Seschrock verify((np = ses_node_lookup(snap, nodeid)) != NULL); 971d91236feSeschrock 972d91236feSeschrock return (np); 973d91236feSeschrock } 974d91236feSeschrock 9750b32bb8bSEric Schrock /*ARGSUSED*/ 9760b32bb8bSEric Schrock void 9770b32bb8bSEric Schrock ses_node_unlock(topo_mod_t *mod, tnode_t *tn) 9780b32bb8bSEric Schrock { 9790b32bb8bSEric Schrock ses_enum_target_t *tp = topo_node_getspecific(tn); 9800b32bb8bSEric Schrock 9810b32bb8bSEric Schrock verify(tp != NULL); 9820b32bb8bSEric Schrock 9830b32bb8bSEric Schrock (void) pthread_mutex_unlock(&tp->set_lock); 9840b32bb8bSEric Schrock } 9850b32bb8bSEric Schrock 986d91236feSeschrock /* 987d91236feSeschrock * Determine if the element is present. 988d91236feSeschrock */ 989d91236feSeschrock /*ARGSUSED*/ 990d91236feSeschrock static int 991d91236feSeschrock ses_present(topo_mod_t *mod, tnode_t *tn, topo_version_t version, 992d91236feSeschrock nvlist_t *in, nvlist_t **out) 993d91236feSeschrock { 994d91236feSeschrock boolean_t present; 995d91236feSeschrock ses_node_t *np; 996d91236feSeschrock nvlist_t *props, *nvl; 997d91236feSeschrock uint64_t status; 998d91236feSeschrock 9990b32bb8bSEric Schrock if ((np = ses_node_lock(mod, tn)) == NULL) 1000d91236feSeschrock return (-1); 1001d91236feSeschrock 1002940d71d2Seschrock verify((props = ses_node_props(np)) != NULL); 1003940d71d2Seschrock verify(nvlist_lookup_uint64(props, 1004940d71d2Seschrock SES_PROP_STATUS_CODE, &status) == 0); 1005940d71d2Seschrock 10060b32bb8bSEric Schrock ses_node_unlock(mod, tn); 10070b32bb8bSEric Schrock 1008940d71d2Seschrock present = (status != SES_ESC_NOT_INSTALLED); 1009940d71d2Seschrock 1010940d71d2Seschrock if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0) 1011940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 1012940d71d2Seschrock 1013940d71d2Seschrock if (nvlist_add_uint32(nvl, TOPO_METH_PRESENT_RET, 1014940d71d2Seschrock present) != 0) { 1015940d71d2Seschrock nvlist_free(nvl); 1016940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 1017940d71d2Seschrock } 1018940d71d2Seschrock 1019940d71d2Seschrock *out = nvl; 1020940d71d2Seschrock 1021940d71d2Seschrock return (0); 1022940d71d2Seschrock } 1023940d71d2Seschrock 1024940d71d2Seschrock /* 1025ac88567aSHyon Kim * Sets standard properties for a ses node (enclosure, bay, controller 1026ac88567aSHyon Kim * or expander). 1027ac88567aSHyon Kim * This includes setting the FRU, as well as setting the 1028ac88567aSHyon Kim * authority information. When the fru topo node(frutn) is not NULL 1029ac88567aSHyon Kim * its resouce should be used as FRU. 1030940d71d2Seschrock */ 1031940d71d2Seschrock static int 1032ac88567aSHyon Kim ses_set_standard_props(topo_mod_t *mod, tnode_t *frutn, tnode_t *tn, 1033ac88567aSHyon Kim nvlist_t *auth, uint64_t nodeid, const char *path) 1034940d71d2Seschrock { 1035940d71d2Seschrock int err; 1036940d71d2Seschrock char *product, *chassis; 1037940d71d2Seschrock nvlist_t *fmri; 1038940d71d2Seschrock 1039940d71d2Seschrock /* 1040940d71d2Seschrock * Set the authority explicitly if specified. 1041940d71d2Seschrock */ 1042940d71d2Seschrock if (auth) { 1043940d71d2Seschrock verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT, 1044940d71d2Seschrock &product) == 0); 1045940d71d2Seschrock verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_CHASSIS, 1046940d71d2Seschrock &chassis) == 0); 1047940d71d2Seschrock if (topo_prop_set_string(tn, FM_FMRI_AUTHORITY, 1048940d71d2Seschrock FM_FMRI_AUTH_PRODUCT, TOPO_PROP_IMMUTABLE, product, 1049940d71d2Seschrock &err) != 0 || 1050940d71d2Seschrock topo_prop_set_string(tn, FM_FMRI_AUTHORITY, 1051940d71d2Seschrock FM_FMRI_AUTH_CHASSIS, TOPO_PROP_IMMUTABLE, chassis, 1052940d71d2Seschrock &err) != 0 || 1053940d71d2Seschrock topo_prop_set_string(tn, FM_FMRI_AUTHORITY, 1054940d71d2Seschrock FM_FMRI_AUTH_SERVER, TOPO_PROP_IMMUTABLE, "", 1055940d71d2Seschrock &err) != 0) { 1056940d71d2Seschrock topo_mod_dprintf(mod, "failed to add authority " 1057d91236feSeschrock "properties: %s\n", topo_strerror(err)); 1058940d71d2Seschrock return (topo_mod_seterrno(mod, err)); 1059940d71d2Seschrock } 1060940d71d2Seschrock } 1061940d71d2Seschrock 1062940d71d2Seschrock /* 1063940d71d2Seschrock * Copy the resource and set that as the FRU. 1064940d71d2Seschrock */ 1065ac88567aSHyon Kim if (frutn != NULL) { 1066ac88567aSHyon Kim if (topo_node_resource(frutn, &fmri, &err) != 0) { 1067ac88567aSHyon Kim topo_mod_dprintf(mod, 1068ac88567aSHyon Kim "topo_node_resource() failed : %s\n", 1069ac88567aSHyon Kim topo_strerror(err)); 1070ac88567aSHyon Kim return (topo_mod_seterrno(mod, err)); 1071ac88567aSHyon Kim } 1072ac88567aSHyon Kim } else { 1073ac88567aSHyon Kim if (topo_node_resource(tn, &fmri, &err) != 0) { 1074ac88567aSHyon Kim topo_mod_dprintf(mod, 1075ac88567aSHyon Kim "topo_node_resource() failed : %s\n", 1076ac88567aSHyon Kim topo_strerror(err)); 1077ac88567aSHyon Kim return (topo_mod_seterrno(mod, err)); 1078ac88567aSHyon Kim } 1079940d71d2Seschrock } 1080940d71d2Seschrock 1081940d71d2Seschrock if (topo_node_fru_set(tn, fmri, 0, &err) != 0) { 1082940d71d2Seschrock topo_mod_dprintf(mod, 1083940d71d2Seschrock "topo_node_fru_set() failed : %s\n", 1084940d71d2Seschrock topo_strerror(err)); 1085940d71d2Seschrock nvlist_free(fmri); 1086940d71d2Seschrock return (topo_mod_seterrno(mod, err)); 1087940d71d2Seschrock } 1088940d71d2Seschrock 1089940d71d2Seschrock nvlist_free(fmri); 1090940d71d2Seschrock 1091940d71d2Seschrock /* 1092940d71d2Seschrock * Set the SES-specific properties so that consumers can query 1093940d71d2Seschrock * additional information about the particular SES element. 1094940d71d2Seschrock */ 1095a961ec00SHyon Kim if (topo_pgroup_create(tn, &ses_pgroup, &err) != 0) { 1096940d71d2Seschrock topo_mod_dprintf(mod, "failed to create propgroup " 1097940d71d2Seschrock "%s: %s\n", TOPO_PGROUP_SES, topo_strerror(err)); 1098940d71d2Seschrock return (-1); 1099940d71d2Seschrock } 1100940d71d2Seschrock 1101940d71d2Seschrock if (topo_prop_set_uint64(tn, TOPO_PGROUP_SES, 1102940d71d2Seschrock TOPO_PROP_NODE_ID, TOPO_PROP_IMMUTABLE, 1103940d71d2Seschrock nodeid, &err) != 0) { 1104940d71d2Seschrock topo_mod_dprintf(mod, 1105940d71d2Seschrock "failed to create property %s: %s\n", 1106940d71d2Seschrock TOPO_PROP_NODE_ID, topo_strerror(err)); 1107940d71d2Seschrock return (-1); 1108940d71d2Seschrock } 1109940d71d2Seschrock 1110940d71d2Seschrock if (topo_prop_set_string(tn, TOPO_PGROUP_SES, 1111940d71d2Seschrock TOPO_PROP_TARGET_PATH, TOPO_PROP_IMMUTABLE, 1112940d71d2Seschrock path, &err) != 0) { 1113940d71d2Seschrock topo_mod_dprintf(mod, 1114940d71d2Seschrock "failed to create property %s: %s\n", 1115940d71d2Seschrock TOPO_PROP_TARGET_PATH, topo_strerror(err)); 1116940d71d2Seschrock return (-1); 1117940d71d2Seschrock } 1118940d71d2Seschrock 1119940d71d2Seschrock return (0); 1120940d71d2Seschrock } 1121940d71d2Seschrock 1122940d71d2Seschrock /* 1123940d71d2Seschrock * Callback to add a disk to a given bay. We first check the status-code to 1124940d71d2Seschrock * determine if a disk is present, ignoring those that aren't in an appropriate 11250b32bb8bSEric Schrock * state. We then scan the parent bay node's SAS address array to determine 11260b32bb8bSEric Schrock * possible attached SAS addresses. We create a disk node if the disk is not 11270b32bb8bSEric Schrock * SAS or the SES target does not support the necessary pages for this; if we 11280b32bb8bSEric Schrock * find the SAS address, we create a disk node and also correlate it with 11290b32bb8bSEric Schrock * the corresponding Solaris device node to fill in the rest of the data. 1130940d71d2Seschrock */ 1131940d71d2Seschrock static int 1132940d71d2Seschrock ses_create_disk(ses_enum_data_t *sdp, tnode_t *pnode, nvlist_t *props) 1133940d71d2Seschrock { 1134940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 1135940d71d2Seschrock uint64_t status; 1136940d71d2Seschrock uint_t s, nsas; 11370b32bb8bSEric Schrock char **paths; 113844ed9dbbSStephen Hanson int err, ret; 113944ed9dbbSStephen Hanson tnode_t *child = NULL; 1140940d71d2Seschrock 1141940d71d2Seschrock /* 1142940d71d2Seschrock * Skip devices that are not in a present (and possibly damaged) state. 1143940d71d2Seschrock */ 1144940d71d2Seschrock if (nvlist_lookup_uint64(props, SES_PROP_STATUS_CODE, &status) != 0) 1145940d71d2Seschrock return (0); 1146940d71d2Seschrock 1147ac88567aSHyon Kim if (status != SES_ESC_UNSUPPORTED && 1148ac88567aSHyon Kim status != SES_ESC_OK && 1149940d71d2Seschrock status != SES_ESC_CRITICAL && 1150940d71d2Seschrock status != SES_ESC_NONCRITICAL && 1151940d71d2Seschrock status != SES_ESC_UNRECOVERABLE && 1152940d71d2Seschrock status != SES_ESC_NO_ACCESS) 1153940d71d2Seschrock return (0); 1154940d71d2Seschrock 1155940d71d2Seschrock topo_mod_dprintf(mod, "found attached disk"); 1156940d71d2Seschrock 1157940d71d2Seschrock /* 1158940d71d2Seschrock * Create the disk range. 1159940d71d2Seschrock */ 11600b32bb8bSEric Schrock if (topo_node_range_create(mod, pnode, DISK, 0, 0) != 0) { 1161940d71d2Seschrock topo_mod_dprintf(mod, 1162940d71d2Seschrock "topo_node_create_range() failed: %s", 1163940d71d2Seschrock topo_mod_errmsg(mod)); 1164940d71d2Seschrock return (-1); 1165940d71d2Seschrock } 1166940d71d2Seschrock 1167940d71d2Seschrock /* 1168940d71d2Seschrock * Look through all SAS addresses and attempt to correlate them to a 1169940d71d2Seschrock * known Solaris device. If we don't find a matching node, then we 1170940d71d2Seschrock * don't enumerate the disk node. 117123a5d44cSHyon Kim * Note that TOPO_PROP_SAS_ADDR prop includes SAS address from 117223a5d44cSHyon Kim * alternate elements that represent the same device. 1173940d71d2Seschrock */ 11740b32bb8bSEric Schrock if (topo_prop_get_string_array(pnode, TOPO_PGROUP_SES, 11750b32bb8bSEric Schrock TOPO_PROP_SAS_ADDR, &paths, &nsas, &err) != 0) 11760b32bb8bSEric Schrock return (0); 11770b32bb8bSEric Schrock 11780b32bb8bSEric Schrock err = 0; 11790b32bb8bSEric Schrock 1180940d71d2Seschrock for (s = 0; s < nsas; s++) { 1181ac88567aSHyon Kim ret = disk_declare_addr(mod, pnode, &sdp->sed_devs, paths[s], 118244ed9dbbSStephen Hanson &child); 118344ed9dbbSStephen Hanson if (ret == 0) { 118444ed9dbbSStephen Hanson break; 118544ed9dbbSStephen Hanson } else if (ret < 0) { 11860b32bb8bSEric Schrock err = -1; 11870b32bb8bSEric Schrock break; 11880b32bb8bSEric Schrock } 11890b32bb8bSEric Schrock } 11900b32bb8bSEric Schrock 119144ed9dbbSStephen Hanson if (s == nsas) 1192edb433b6SMilan Jurik (void) disk_declare_non_enumerated(mod, pnode, &child); 119344ed9dbbSStephen Hanson 119444ed9dbbSStephen Hanson /* copy sas_addresses (target-ports) from parent (with 'w'added) */ 119544ed9dbbSStephen Hanson if (child != NULL) { 119644ed9dbbSStephen Hanson int i; 119744ed9dbbSStephen Hanson char **tports; 119844ed9dbbSStephen Hanson uint64_t wwn; 119944ed9dbbSStephen Hanson 120044ed9dbbSStephen Hanson tports = topo_mod_zalloc(mod, sizeof (char *) * nsas); 120144ed9dbbSStephen Hanson if (tports != NULL) { 120244ed9dbbSStephen Hanson for (i = 0; i < nsas; i++) { 120344ed9dbbSStephen Hanson if (scsi_wwnstr_to_wwn(paths[i], &wwn) != 120444ed9dbbSStephen Hanson DDI_SUCCESS) 120544ed9dbbSStephen Hanson break; 120644ed9dbbSStephen Hanson tports[i] = scsi_wwn_to_wwnstr(wwn, 1, NULL); 120744ed9dbbSStephen Hanson if (tports[i] == NULL) 120844ed9dbbSStephen Hanson break; 120944ed9dbbSStephen Hanson } 121044ed9dbbSStephen Hanson /* if they all worked then create the property */ 121144ed9dbbSStephen Hanson if (i == nsas) 121244ed9dbbSStephen Hanson (void) topo_prop_set_string_array(child, 121344ed9dbbSStephen Hanson TOPO_PGROUP_STORAGE, 121444ed9dbbSStephen Hanson TOPO_STORAGE_TARGET_PORT_L0IDS, 121544ed9dbbSStephen Hanson TOPO_PROP_IMMUTABLE, (const char **)tports, 121644ed9dbbSStephen Hanson nsas, &err); 121744ed9dbbSStephen Hanson 121844ed9dbbSStephen Hanson for (i = 0; i < nsas; i++) 121944ed9dbbSStephen Hanson if (tports[i] != NULL) 122044ed9dbbSStephen Hanson scsi_free_wwnstr(tports[i]); 122144ed9dbbSStephen Hanson topo_mod_free(mod, tports, sizeof (char *) * nsas); 122244ed9dbbSStephen Hanson } 122344ed9dbbSStephen Hanson } 122444ed9dbbSStephen Hanson 12250b32bb8bSEric Schrock for (s = 0; s < nsas; s++) 12260b32bb8bSEric Schrock topo_mod_free(mod, paths[s], strlen(paths[s]) + 1); 12270b32bb8bSEric Schrock topo_mod_free(mod, paths, nsas * sizeof (char *)); 12280b32bb8bSEric Schrock 12290b32bb8bSEric Schrock return (err); 12300b32bb8bSEric Schrock } 12310b32bb8bSEric Schrock 12320b32bb8bSEric Schrock static int 12330b32bb8bSEric Schrock ses_add_bay_props(topo_mod_t *mod, tnode_t *tn, ses_enum_node_t *snp) 12340b32bb8bSEric Schrock { 12350b32bb8bSEric Schrock ses_alt_node_t *ap; 12360b32bb8bSEric Schrock ses_node_t *np; 12370b32bb8bSEric Schrock nvlist_t *props; 12380b32bb8bSEric Schrock 12390b32bb8bSEric Schrock nvlist_t **phys; 12400b32bb8bSEric Schrock uint_t i, j, n_phys, all_phys = 0; 12410b32bb8bSEric Schrock char **paths; 12420b32bb8bSEric Schrock uint64_t addr; 12430b32bb8bSEric Schrock size_t len; 12440b32bb8bSEric Schrock int terr, err = -1; 12450b32bb8bSEric Schrock 12460b32bb8bSEric Schrock for (ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL; 12470b32bb8bSEric Schrock ap = topo_list_next(ap)) { 12480b32bb8bSEric Schrock np = ap->san_node; 12490b32bb8bSEric Schrock props = ses_node_props(np); 12500b32bb8bSEric Schrock 12510b32bb8bSEric Schrock if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 12520b32bb8bSEric Schrock &phys, &n_phys) != 0) 12530b32bb8bSEric Schrock continue; 12540b32bb8bSEric Schrock 12550b32bb8bSEric Schrock all_phys += n_phys; 12560b32bb8bSEric Schrock } 12570b32bb8bSEric Schrock 12580b32bb8bSEric Schrock if (all_phys == 0) 12590b32bb8bSEric Schrock return (0); 12600b32bb8bSEric Schrock 12610b32bb8bSEric Schrock if ((paths = topo_mod_zalloc(mod, all_phys * sizeof (char *))) == NULL) 12620b32bb8bSEric Schrock return (-1); 12630b32bb8bSEric Schrock 12640b32bb8bSEric Schrock for (i = 0, ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL; 12650b32bb8bSEric Schrock ap = topo_list_next(ap)) { 12660b32bb8bSEric Schrock np = ap->san_node; 12670b32bb8bSEric Schrock props = ses_node_props(np); 12680b32bb8bSEric Schrock 12690b32bb8bSEric Schrock if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 12700b32bb8bSEric Schrock &phys, &n_phys) != 0) 1271940d71d2Seschrock continue; 1272940d71d2Seschrock 12730b32bb8bSEric Schrock for (j = 0; j < n_phys; j++) { 12740b32bb8bSEric Schrock if (nvlist_lookup_uint64(phys[j], SES_SAS_PROP_ADDR, 12750b32bb8bSEric Schrock &addr) != 0) 12760b32bb8bSEric Schrock continue; 1277940d71d2Seschrock 12780b32bb8bSEric Schrock len = snprintf(NULL, 0, "%016llx", addr) + 1; 12790b32bb8bSEric Schrock if ((paths[i] = topo_mod_alloc(mod, len)) == NULL) 12800b32bb8bSEric Schrock goto error; 12810b32bb8bSEric Schrock 12820b32bb8bSEric Schrock (void) snprintf(paths[i], len, "%016llx", addr); 12830b32bb8bSEric Schrock 12840b32bb8bSEric Schrock ++i; 12850b32bb8bSEric Schrock } 1286940d71d2Seschrock } 1287940d71d2Seschrock 12880b32bb8bSEric Schrock err = topo_prop_set_string_array(tn, TOPO_PGROUP_SES, 12890b32bb8bSEric Schrock TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE, 12900b32bb8bSEric Schrock (const char **)paths, i, &terr); 12910b32bb8bSEric Schrock if (err != 0) 12920b32bb8bSEric Schrock err = topo_mod_seterrno(mod, terr); 12930b32bb8bSEric Schrock 12940b32bb8bSEric Schrock error: 12950b32bb8bSEric Schrock for (i = 0; i < all_phys && paths[i] != NULL; i++) 12960b32bb8bSEric Schrock topo_mod_free(mod, paths[i], strlen(paths[i]) + 1); 12970b32bb8bSEric Schrock topo_mod_free(mod, paths, all_phys * sizeof (char *)); 12980b32bb8bSEric Schrock 12990b32bb8bSEric Schrock return (err); 1300940d71d2Seschrock } 1301940d71d2Seschrock 1302940d71d2Seschrock /* 1303ac88567aSHyon Kim * Callback to create a basic node (bay, psu, fan, or controller and expander). 1304940d71d2Seschrock */ 1305940d71d2Seschrock static int 1306ded93414SHyon Kim ses_create_generic(ses_enum_data_t *sdp, ses_enum_node_t *snp, tnode_t *pnode, 1307ded93414SHyon Kim tnode_t *frutn, const char *nodename, const char *labelname, 1308ded93414SHyon Kim tnode_t **node) 1309940d71d2Seschrock { 1310940d71d2Seschrock ses_node_t *np = snp->sen_node; 1311d91236feSeschrock ses_node_t *parent; 1312940d71d2Seschrock uint64_t instance = snp->sen_instance; 1313940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 1314940d71d2Seschrock nvlist_t *props, *aprops; 1315940d71d2Seschrock nvlist_t *auth = NULL, *fmri = NULL; 1316ded93414SHyon Kim tnode_t *tn = NULL; 1317940d71d2Seschrock char label[128]; 1318940d71d2Seschrock int err; 1319d91236feSeschrock char *part = NULL, *serial = NULL, *revision = NULL; 1320d91236feSeschrock char *desc; 1321d91236feSeschrock boolean_t report; 1322940d71d2Seschrock 1323940d71d2Seschrock props = ses_node_props(np); 1324940d71d2Seschrock 1325940d71d2Seschrock (void) nvlist_lookup_string(props, LIBSES_PROP_PART, &part); 1326940d71d2Seschrock (void) nvlist_lookup_string(props, LIBSES_PROP_SERIAL, &serial); 1327940d71d2Seschrock 1328940d71d2Seschrock topo_mod_dprintf(mod, "adding %s %llu", nodename, instance); 1329940d71d2Seschrock 1330940d71d2Seschrock /* 1331940d71d2Seschrock * Create the node. The interesting information is all copied from the 1332940d71d2Seschrock * parent enclosure node, so there is not much to do. 1333940d71d2Seschrock */ 1334940d71d2Seschrock if ((auth = topo_mod_auth(mod, pnode)) == NULL) 1335940d71d2Seschrock goto error; 1336940d71d2Seschrock 1337d91236feSeschrock /* 1338d91236feSeschrock * We want to report revision information for the controller nodes, but 1339d91236feSeschrock * we do not get per-element revision information. However, we do have 1340d91236feSeschrock * revision information for the entire enclosure, and we can use the 1341d91236feSeschrock * 'reported-via' property to know that this controller corresponds to 1342d91236feSeschrock * the given revision information. This means we cannot get revision 1343d91236feSeschrock * information for targets we are not explicitly connected to, but 1344d91236feSeschrock * there is little we can do about the situation. 1345d91236feSeschrock */ 1346d91236feSeschrock if (strcmp(nodename, CONTROLLER) == 0 && 1347d91236feSeschrock nvlist_lookup_boolean_value(props, SES_PROP_REPORT, &report) == 0 && 1348d91236feSeschrock report) { 1349d91236feSeschrock for (parent = ses_node_parent(np); parent != NULL; 1350d91236feSeschrock parent = ses_node_parent(parent)) { 1351d91236feSeschrock if (ses_node_type(parent) == SES_NODE_ENCLOSURE) { 1352d91236feSeschrock (void) nvlist_lookup_string( 1353d91236feSeschrock ses_node_props(parent), 1354d91236feSeschrock SES_EN_PROP_REV, &revision); 1355d91236feSeschrock break; 1356d91236feSeschrock } 1357d91236feSeschrock } 1358d91236feSeschrock } 1359d91236feSeschrock 1360940d71d2Seschrock if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION, 1361d91236feSeschrock nodename, (topo_instance_t)instance, NULL, auth, part, revision, 1362940d71d2Seschrock serial)) == NULL) { 1363940d71d2Seschrock topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s", 1364940d71d2Seschrock topo_mod_errmsg(mod)); 1365940d71d2Seschrock goto error; 1366940d71d2Seschrock } 1367940d71d2Seschrock 1368940d71d2Seschrock if ((tn = topo_node_bind(mod, pnode, nodename, 1369940d71d2Seschrock instance, fmri)) == NULL) { 1370940d71d2Seschrock topo_mod_dprintf(mod, "topo_node_bind() failed: %s", 1371940d71d2Seschrock topo_mod_errmsg(mod)); 1372940d71d2Seschrock goto error; 1373940d71d2Seschrock } 1374940d71d2Seschrock 1375940d71d2Seschrock /* 1376d91236feSeschrock * For the node label, we look for the following in order: 1377d91236feSeschrock * 1378d91236feSeschrock * <ses-description> 1379d91236feSeschrock * <ses-class-description> <instance> 1380d91236feSeschrock * <default-type-label> <instance> 1381940d71d2Seschrock */ 1382d91236feSeschrock if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 || 1383d91236feSeschrock desc[0] == '\0') { 1384d91236feSeschrock parent = ses_node_parent(np); 1385d91236feSeschrock aprops = ses_node_props(parent); 1386d91236feSeschrock if (nvlist_lookup_string(aprops, SES_PROP_CLASS_DESCRIPTION, 1387ac88567aSHyon Kim &desc) != 0 || desc[0] == '\0') 1388ac88567aSHyon Kim desc = (char *)labelname; 1389d91236feSeschrock (void) snprintf(label, sizeof (label), "%s %llu", desc, 1390d91236feSeschrock instance); 1391d91236feSeschrock desc = label; 1392d91236feSeschrock } 1393d91236feSeschrock 1394d91236feSeschrock if (topo_node_label_set(tn, desc, &err) != 0) 1395940d71d2Seschrock goto error; 1396940d71d2Seschrock 1397ac88567aSHyon Kim if (ses_set_standard_props(mod, frutn, tn, NULL, ses_node_id(np), 1398940d71d2Seschrock snp->sen_target->set_devpath) != 0) 1399940d71d2Seschrock goto error; 1400940d71d2Seschrock 1401ac88567aSHyon Kim if (strcmp(nodename, BAY) == 0) { 14020b32bb8bSEric Schrock if (ses_add_bay_props(mod, tn, snp) != 0) 14030b32bb8bSEric Schrock goto error; 14040b32bb8bSEric Schrock 1405940d71d2Seschrock if (ses_create_disk(sdp, tn, props) != 0) 1406940d71d2Seschrock goto error; 1407d91236feSeschrock 1408d91236feSeschrock if (topo_method_register(mod, tn, ses_bay_methods) != 0) { 1409d91236feSeschrock topo_mod_dprintf(mod, 1410d91236feSeschrock "topo_method_register() failed: %s", 1411d91236feSeschrock topo_mod_errmsg(mod)); 1412d91236feSeschrock goto error; 1413d91236feSeschrock } 1414ac88567aSHyon Kim } else if ((strcmp(nodename, FAN) == 0) || 1415ac88567aSHyon Kim (strcmp(nodename, PSU) == 0) || 1416ac88567aSHyon Kim (strcmp(nodename, CONTROLLER) == 0)) { 1417940d71d2Seschrock /* 1418d91236feSeschrock * Only fan, psu, and controller nodes have a 'present' method. 1419d91236feSeschrock * Bay nodes are always present, and disk nodes are present by 1420ac88567aSHyon Kim * virtue of being enumerated and SAS expander nodes and 1421ac88567aSHyon Kim * SAS connector nodes are also always present once 1422ac88567aSHyon Kim * the parent controller is found. 1423940d71d2Seschrock */ 1424940d71d2Seschrock if (topo_method_register(mod, tn, ses_component_methods) != 0) { 1425940d71d2Seschrock topo_mod_dprintf(mod, 1426940d71d2Seschrock "topo_method_register() failed: %s", 1427940d71d2Seschrock topo_mod_errmsg(mod)); 1428940d71d2Seschrock goto error; 1429940d71d2Seschrock } 1430940d71d2Seschrock 1431940d71d2Seschrock } 1432940d71d2Seschrock 1433d91236feSeschrock snp->sen_target->set_refcount++; 1434d91236feSeschrock topo_node_setspecific(tn, snp->sen_target); 1435d91236feSeschrock 1436940d71d2Seschrock nvlist_free(auth); 1437940d71d2Seschrock nvlist_free(fmri); 1438ac88567aSHyon Kim if (node != NULL) *node = tn; 1439ac88567aSHyon Kim return (0); 1440ac88567aSHyon Kim 1441ac88567aSHyon Kim error: 1442ac88567aSHyon Kim nvlist_free(auth); 1443ac88567aSHyon Kim nvlist_free(fmri); 1444ac88567aSHyon Kim return (-1); 1445ac88567aSHyon Kim } 1446ac88567aSHyon Kim 1447ac88567aSHyon Kim /* 1448ac88567aSHyon Kim * Create SAS expander specific props. 1449ac88567aSHyon Kim */ 1450ac88567aSHyon Kim /*ARGSUSED*/ 1451ac88567aSHyon Kim static int 1452ac88567aSHyon Kim ses_set_expander_props(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1453ac88567aSHyon Kim tnode_t *ptnode, tnode_t *tnode, int *phycount, int64_t *connlist) 1454ac88567aSHyon Kim { 1455ac88567aSHyon Kim ses_node_t *np = snp->sen_node; 1456ac88567aSHyon Kim topo_mod_t *mod = sdp->sed_mod; 1457ac88567aSHyon Kim nvlist_t *auth = NULL, *fmri = NULL; 1458ac88567aSHyon Kim nvlist_t *props, **phylist; 1459ac88567aSHyon Kim int err, i; 1460ac88567aSHyon Kim uint_t pcount; 1461ac88567aSHyon Kim uint64_t sasaddr, connidx; 1462ac88567aSHyon Kim char sasaddr_str[17]; 1463b4879163SHyon Kim boolean_t found = B_FALSE, ses_found = B_FALSE; 1464b4879163SHyon Kim dev_di_node_t *dnode, *sesdnode; 1465ac88567aSHyon Kim 1466ac88567aSHyon Kim props = ses_node_props(np); 1467ac88567aSHyon Kim 1468ac88567aSHyon Kim /* 1469ac88567aSHyon Kim * the uninstalled expander is not enumerated by checking 1470ac88567aSHyon Kim * the element status code. No present present' method provided. 1471ac88567aSHyon Kim */ 1472ac88567aSHyon Kim /* 1473ac88567aSHyon Kim * Get the Expander SAS address. It should exist. 1474ac88567aSHyon Kim */ 1475ac88567aSHyon Kim if (nvlist_lookup_uint64(props, SES_EXP_PROP_SAS_ADDR, 1476ac88567aSHyon Kim &sasaddr) != 0) { 1477ac88567aSHyon Kim topo_mod_dprintf(mod, 1478ac88567aSHyon Kim "Failed to get prop %s.", SES_EXP_PROP_SAS_ADDR); 1479ac88567aSHyon Kim goto error; 1480ac88567aSHyon Kim } 1481ac88567aSHyon Kim 1482ac88567aSHyon Kim (void) sprintf(sasaddr_str, "%llx", sasaddr); 1483ac88567aSHyon Kim 1484ac88567aSHyon Kim /* search matching dev_di_node. */ 1485ac88567aSHyon Kim for (dnode = topo_list_next(&sdp->sed_devs); dnode != NULL; 1486ac88567aSHyon Kim dnode = topo_list_next(dnode)) { 1487b4879163SHyon Kim for (i = 0; i < dnode->ddn_ppath_count; i++) { 1488b4879163SHyon Kim if ((dnode->ddn_target_port[i] != NULL) && 1489b4879163SHyon Kim (strstr(dnode->ddn_target_port[i], 1490b4879163SHyon Kim sasaddr_str) != NULL)) { 1491b4879163SHyon Kim found = B_TRUE; 1492b4879163SHyon Kim break; 1493b4879163SHyon Kim } 1494ac88567aSHyon Kim } 1495b4879163SHyon Kim if (found) 1496b4879163SHyon Kim break; 1497ac88567aSHyon Kim } 1498ac88567aSHyon Kim 1499ac88567aSHyon Kim if (!found) { 1500ac88567aSHyon Kim topo_mod_dprintf(mod, 1501ac88567aSHyon Kim "ses_set_expander_props: Failed to find matching " 1502ac88567aSHyon Kim "devinfo node for Exapnder SAS address %s", 1503ac88567aSHyon Kim SES_EXP_PROP_SAS_ADDR); 1504ac88567aSHyon Kim /* continue on to get storage group props. */ 1505ac88567aSHyon Kim } else { 1506b4879163SHyon Kim /* create/set the devfs-path and devid in the smp group */ 1507b4879163SHyon Kim if (topo_pgroup_create(tnode, &smp_pgroup, &err) != 0) { 1508ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1509b4879163SHyon Kim "failed to create smp property group %s\n", 1510b4879163SHyon Kim topo_strerror(err)); 1511ac88567aSHyon Kim goto error; 1512ac88567aSHyon Kim } else { 1513b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP, 1514b4879163SHyon Kim TOPO_PROP_SMP_TARGET_PORT, TOPO_PROP_IMMUTABLE, 1515b4879163SHyon Kim dnode->ddn_target_port[i], &err) != 0) { 1516b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1517b4879163SHyon Kim "set %S error %s\n", TOPO_PROP_SAS_ADDR, 1518b4879163SHyon Kim topo_strerror(err)); 1519b4879163SHyon Kim } 1520b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP, 1521b4879163SHyon Kim TOPO_PROP_SMP_DEV_PATH, TOPO_PROP_IMMUTABLE, 1522ac88567aSHyon Kim dnode->ddn_dpath, &err) != 0) { 1523ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1524ac88567aSHyon Kim "set dev error %s\n", topo_strerror(err)); 1525ac88567aSHyon Kim } 1526b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP, 1527b4879163SHyon Kim TOPO_PROP_SMP_DEVID, TOPO_PROP_IMMUTABLE, 1528ac88567aSHyon Kim dnode->ddn_devid, &err) != 0) { 1529ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1530ac88567aSHyon Kim "set devid error %s\n", topo_strerror(err)); 1531ac88567aSHyon Kim } 1532ac88567aSHyon Kim if (dnode->ddn_ppath_count != 0 && 1533b4879163SHyon Kim topo_prop_set_string_array(tnode, TOPO_PGROUP_SMP, 1534b4879163SHyon Kim TOPO_PROP_SMP_PHYS_PATH, TOPO_PROP_IMMUTABLE, 1535ac88567aSHyon Kim (const char **)dnode->ddn_ppath, 1536ac88567aSHyon Kim dnode->ddn_ppath_count, &err) != 0) { 1537ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1538ac88567aSHyon Kim "set phys-path error %s\n", 1539ac88567aSHyon Kim topo_strerror(err)); 1540ac88567aSHyon Kim } 1541ac88567aSHyon Kim } 1542ac88567aSHyon Kim } 1543ac88567aSHyon Kim 1544b4879163SHyon Kim /* update the ses property group with SES target info */ 1545ded93414SHyon Kim if ((topo_pgroup_create(tnode, &ses_pgroup, &err) != 0) && 1546a961ec00SHyon Kim (err != ETOPO_PROP_DEFD)) { 1547a961ec00SHyon Kim /* SES prop group doesn't exist but failed to be created. */ 1548b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1549a961ec00SHyon Kim "ses pgroup create error %s\n", topo_strerror(err)); 1550b4879163SHyon Kim goto error; 1551b4879163SHyon Kim } else { 1552b4879163SHyon Kim /* locate assciated enclosure dev_di_node. */ 1553b4879163SHyon Kim for (sesdnode = topo_list_next(&sdp->sed_devs); 1554b4879163SHyon Kim sesdnode != NULL; sesdnode = topo_list_next(sesdnode)) { 1555b4879163SHyon Kim for (i = 0; i < sesdnode->ddn_ppath_count; i++) { 1556b4879163SHyon Kim /* 1557b4879163SHyon Kim * check if attached port exists and 1558b4879163SHyon Kim * its node type is enclosure and 1559b4879163SHyon Kim * attached port is same as sas address of 1560b4879163SHyon Kim * the expander and 1561b4879163SHyon Kim * bridge port for virtual phy indication 1562b4879163SHyon Kim * exist. 1563b4879163SHyon Kim */ 1564b4879163SHyon Kim if ((sesdnode->ddn_attached_port[i] != NULL) && 1565b4879163SHyon Kim (sesdnode->ddn_dtype == DTYPE_ESI) && 1566b4879163SHyon Kim (strstr(sesdnode->ddn_attached_port[i], 1567b4879163SHyon Kim sasaddr_str) != NULL) && 1568b4879163SHyon Kim (sesdnode->ddn_bridge_port[i] != NULL)) { 1569b4879163SHyon Kim ses_found = B_TRUE; 1570b4879163SHyon Kim break; 1571b4879163SHyon Kim } 1572b4879163SHyon Kim } 1573b4879163SHyon Kim if (ses_found) break; 1574b4879163SHyon Kim } 1575b4879163SHyon Kim 1576b4879163SHyon Kim if (ses_found) { 1577b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SES, 1578b4879163SHyon Kim TOPO_PROP_SES_TARGET_PORT, TOPO_PROP_IMMUTABLE, 1579b4879163SHyon Kim sesdnode->ddn_target_port[i], &err) != 0) { 1580b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1581b4879163SHyon Kim "set ses %S error %s\n", TOPO_PROP_SAS_ADDR, 1582b4879163SHyon Kim topo_strerror(err)); 1583b4879163SHyon Kim } 1584b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SES, 1585b4879163SHyon Kim TOPO_PROP_SES_DEV_PATH, TOPO_PROP_IMMUTABLE, 1586b4879163SHyon Kim sesdnode->ddn_dpath, &err) != 0) { 1587b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1588b4879163SHyon Kim "set ses dev error %s\n", 1589b4879163SHyon Kim topo_strerror(err)); 1590b4879163SHyon Kim } 1591b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SES, 1592b4879163SHyon Kim TOPO_PROP_SES_DEVID, TOPO_PROP_IMMUTABLE, 1593b4879163SHyon Kim sesdnode->ddn_devid, &err) != 0) { 1594b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1595b4879163SHyon Kim "set ses devid error %s\n", 1596b4879163SHyon Kim topo_strerror(err)); 1597b4879163SHyon Kim } 1598b4879163SHyon Kim if (sesdnode->ddn_ppath_count != 0 && 1599b4879163SHyon Kim topo_prop_set_string_array(tnode, TOPO_PGROUP_SES, 1600b4879163SHyon Kim TOPO_PROP_SES_PHYS_PATH, TOPO_PROP_IMMUTABLE, 1601b4879163SHyon Kim (const char **)sesdnode->ddn_ppath, 1602b4879163SHyon Kim sesdnode->ddn_ppath_count, &err) != 0) { 1603b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1604b4879163SHyon Kim "set ses phys-path error %s\n", 1605b4879163SHyon Kim topo_strerror(err)); 1606b4879163SHyon Kim } 1607b4879163SHyon Kim 1608b4879163SHyon Kim } 1609b4879163SHyon Kim } 1610b4879163SHyon Kim 1611ac88567aSHyon Kim /* create the storage group */ 1612ac88567aSHyon Kim if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) { 1613ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1614ac88567aSHyon Kim "create storage error %s\n", topo_strerror(err)); 1615ac88567aSHyon Kim goto error; 1616ac88567aSHyon Kim } else { 1617b4879163SHyon Kim /* set the SAS address prop out of expander element status. */ 1618ac88567aSHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE, 1619ac88567aSHyon Kim TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE, sasaddr_str, 1620ac88567aSHyon Kim &err) != 0) { 1621ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1622ac88567aSHyon Kim "set %S error %s\n", TOPO_PROP_SAS_ADDR, 1623ac88567aSHyon Kim topo_strerror(err)); 1624ac88567aSHyon Kim } 1625ac88567aSHyon Kim 1626ac88567aSHyon Kim /* Get the phy information for the expander */ 1627ac88567aSHyon Kim if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 1628ac88567aSHyon Kim &phylist, &pcount) != 0) { 1629ac88567aSHyon Kim topo_mod_dprintf(mod, 1630ac88567aSHyon Kim "Failed to get prop %s.", SES_SAS_PROP_PHYS); 1631ac88567aSHyon Kim } else { 1632ac88567aSHyon Kim /* 1633ac88567aSHyon Kim * For each phy, get the connector element index and 1634ac88567aSHyon Kim * stores into connector element index array. 1635ac88567aSHyon Kim */ 1636ac88567aSHyon Kim *phycount = pcount; 1637ac88567aSHyon Kim for (i = 0; i < pcount; i++) { 1638ac88567aSHyon Kim if (nvlist_lookup_uint64(phylist[i], 1639ac88567aSHyon Kim SES_PROP_CE_IDX, &connidx) == 0) { 1640ac88567aSHyon Kim if (connidx != 0xff) { 1641ac88567aSHyon Kim connlist[i] = connidx; 1642ac88567aSHyon Kim } else { 1643ac88567aSHyon Kim connlist[i] = -1; 1644ac88567aSHyon Kim } 1645ac88567aSHyon Kim } else { 1646ac88567aSHyon Kim /* Fail to get the index. set to -1. */ 1647ac88567aSHyon Kim connlist[i] = -1; 1648ac88567aSHyon Kim } 1649ac88567aSHyon Kim } 1650ac88567aSHyon Kim 1651ac88567aSHyon Kim /* set the phy count prop of the expander. */ 1652ac88567aSHyon Kim if (topo_prop_set_uint64(tnode, TOPO_PGROUP_STORAGE, 1653ac88567aSHyon Kim TOPO_PROP_PHY_COUNT, TOPO_PROP_IMMUTABLE, pcount, 1654ac88567aSHyon Kim &err) != 0) { 1655ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1656ac88567aSHyon Kim "set %S error %s\n", TOPO_PROP_PHY_COUNT, 1657ac88567aSHyon Kim topo_strerror(err)); 1658ac88567aSHyon Kim } 1659ac88567aSHyon Kim 1660ac88567aSHyon Kim /* 1661ac88567aSHyon Kim * set the connector element index of 1662ac88567aSHyon Kim * the expander phys. 1663ac88567aSHyon Kim */ 1664ac88567aSHyon Kim } 1665ac88567aSHyon Kim 1666ac88567aSHyon Kim /* populate other misc storage group properties */ 1667ac88567aSHyon Kim if (found) { 1668ac88567aSHyon Kim if (dnode->ddn_mfg && (topo_prop_set_string(tnode, 1669ac88567aSHyon Kim TOPO_PGROUP_STORAGE, TOPO_STORAGE_MANUFACTURER, 1670ac88567aSHyon Kim TOPO_PROP_IMMUTABLE, dnode->ddn_mfg, &err) != 0)) { 1671ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1672ac88567aSHyon Kim "set mfg error %s\n", topo_strerror(err)); 1673ac88567aSHyon Kim } 1674ac88567aSHyon Kim 1675ac88567aSHyon Kim if (dnode->ddn_model && (topo_prop_set_string(tnode, 1676ac88567aSHyon Kim TOPO_PGROUP_STORAGE, TOPO_STORAGE_MODEL, 1677ac88567aSHyon Kim TOPO_PROP_IMMUTABLE, 1678ac88567aSHyon Kim dnode->ddn_model, &err) != 0)) { 1679ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1680ac88567aSHyon Kim "set model error %s\n", topo_strerror(err)); 1681ac88567aSHyon Kim } 1682ac88567aSHyon Kim 1683ac88567aSHyon Kim if (dnode->ddn_serial && (topo_prop_set_string(tnode, 1684ac88567aSHyon Kim TOPO_PGROUP_STORAGE, TOPO_STORAGE_SERIAL_NUM, 1685ac88567aSHyon Kim TOPO_PROP_IMMUTABLE, 1686ac88567aSHyon Kim dnode->ddn_serial, &err) != 0)) { 1687ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1688ac88567aSHyon Kim "set serial error %s\n", 1689ac88567aSHyon Kim topo_strerror(err)); 1690ac88567aSHyon Kim } 1691ac88567aSHyon Kim 1692ac88567aSHyon Kim if (dnode->ddn_firm && (topo_prop_set_string(tnode, 1693ac88567aSHyon Kim TOPO_PGROUP_STORAGE, 1694ac88567aSHyon Kim TOPO_STORAGE_FIRMWARE_REV, TOPO_PROP_IMMUTABLE, 1695ac88567aSHyon Kim dnode->ddn_firm, &err) != 0)) { 1696ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1697ac88567aSHyon Kim "set firm error %s\n", topo_strerror(err)); 1698ac88567aSHyon Kim } 1699ac88567aSHyon Kim } 1700ac88567aSHyon Kim } 1701ac88567aSHyon Kim 1702940d71d2Seschrock return (0); 1703940d71d2Seschrock 1704940d71d2Seschrock error: 1705940d71d2Seschrock nvlist_free(auth); 1706940d71d2Seschrock nvlist_free(fmri); 1707940d71d2Seschrock return (-1); 1708940d71d2Seschrock } 1709940d71d2Seschrock 1710ac88567aSHyon Kim /* 1711ac88567aSHyon Kim * Create SAS expander specific props. 1712ac88567aSHyon Kim */ 1713ac88567aSHyon Kim /*ARGSUSED*/ 1714ac88567aSHyon Kim static int 1715ac88567aSHyon Kim ses_set_connector_props(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1716ac88567aSHyon Kim tnode_t *tnode, int64_t phy_mask) 1717ac88567aSHyon Kim { 1718ac88567aSHyon Kim ses_node_t *np = snp->sen_node; 1719ac88567aSHyon Kim topo_mod_t *mod = sdp->sed_mod; 1720ac88567aSHyon Kim nvlist_t *props; 1721ac88567aSHyon Kim int err, i; 1722ac88567aSHyon Kim uint64_t conntype; 1723ac88567aSHyon Kim char phymask_str[17], *conntype_str; 1724ac88567aSHyon Kim boolean_t found; 1725ac88567aSHyon Kim 1726ac88567aSHyon Kim props = ses_node_props(np); 1727ac88567aSHyon Kim 1728ac88567aSHyon Kim /* 1729ac88567aSHyon Kim * convert phy mask to string. 1730ac88567aSHyon Kim */ 1731ac88567aSHyon Kim (void) snprintf(phymask_str, 17, "%llx", phy_mask); 1732ac88567aSHyon Kim 1733ac88567aSHyon Kim /* create the storage group */ 1734ac88567aSHyon Kim if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) { 1735ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1736ac88567aSHyon Kim "create storage error %s\n", topo_strerror(err)); 1737ac88567aSHyon Kim return (-1); 1738ac88567aSHyon Kim } else { 1739ac88567aSHyon Kim /* set the SAS address prop of the expander. */ 1740ac88567aSHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE, 1741ac88567aSHyon Kim TOPO_STORAGE_SAS_PHY_MASK, TOPO_PROP_IMMUTABLE, 1742ac88567aSHyon Kim phymask_str, &err) != 0) { 1743ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1744ac88567aSHyon Kim "set %S error %s\n", TOPO_STORAGE_SAS_PHY_MASK, 1745ac88567aSHyon Kim topo_strerror(err)); 1746ac88567aSHyon Kim } 1747ac88567aSHyon Kim 1748ac88567aSHyon Kim /* Get the connector type information for the expander */ 1749ac88567aSHyon Kim if (nvlist_lookup_uint64(props, 1750ac88567aSHyon Kim SES_SC_PROP_CONNECTOR_TYPE, &conntype) != 0) { 1751ac88567aSHyon Kim topo_mod_dprintf(mod, "Failed to get prop %s.", 1752ac88567aSHyon Kim TOPO_STORAGE_SAS_PHY_MASK); 1753ac88567aSHyon Kim } else { 1754ac88567aSHyon Kim found = B_FALSE; 1755ac88567aSHyon Kim for (i = 0; ; i++) { 1756ded93414SHyon Kim if (sas_connector_type_list[i].sct_type == 1757ac88567aSHyon Kim SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) { 1758ac88567aSHyon Kim break; 1759ac88567aSHyon Kim } 1760ded93414SHyon Kim if (sas_connector_type_list[i].sct_type == 1761ac88567aSHyon Kim conntype) { 1762ac88567aSHyon Kim conntype_str = 1763ded93414SHyon Kim sas_connector_type_list[i].sct_name; 1764ac88567aSHyon Kim found = B_TRUE; 1765ac88567aSHyon Kim break; 1766ac88567aSHyon Kim } 1767ac88567aSHyon Kim } 1768ac88567aSHyon Kim 1769ac88567aSHyon Kim if (!found) { 1770ac88567aSHyon Kim if (conntype < 1771ac88567aSHyon Kim SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) { 1772ac88567aSHyon Kim conntype_str = 1773ac88567aSHyon Kim SAS_CONNECTOR_TYPE_RESERVED; 1774ac88567aSHyon Kim } else { 1775ac88567aSHyon Kim conntype_str = 1776ac88567aSHyon Kim SAS_CONNECTOR_TYPE_NOT_DEFINED; 1777ac88567aSHyon Kim } 1778ac88567aSHyon Kim } 1779ac88567aSHyon Kim 1780ac88567aSHyon Kim /* set the phy count prop of the expander. */ 1781ac88567aSHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE, 1782ac88567aSHyon Kim TOPO_STORAGE_SAS_CONNECTOR_TYPE, 1783ac88567aSHyon Kim TOPO_PROP_IMMUTABLE, conntype_str, &err) != 0) { 1784ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1785ac88567aSHyon Kim "set %S error %s\n", TOPO_PROP_PHY_COUNT, 1786ac88567aSHyon Kim topo_strerror(err)); 1787ac88567aSHyon Kim } 1788ac88567aSHyon Kim } 1789ac88567aSHyon Kim } 1790ac88567aSHyon Kim 1791ac88567aSHyon Kim return (0); 1792ac88567aSHyon Kim } 1793ac88567aSHyon Kim 1794ac88567aSHyon Kim /* 1795ac88567aSHyon Kim * Instantiate SAS expander nodes for a given ESC Electronics node(controller) 1796ac88567aSHyon Kim * nodes. 1797ac88567aSHyon Kim */ 1798ac88567aSHyon Kim /*ARGSUSED*/ 1799ac88567aSHyon Kim static int 1800ac88567aSHyon Kim ses_create_esc_sasspecific(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1801ac88567aSHyon Kim tnode_t *pnode, ses_enum_chassis_t *cp, 1802ac88567aSHyon Kim boolean_t dorange) 1803ac88567aSHyon Kim { 1804ac88567aSHyon Kim topo_mod_t *mod = sdp->sed_mod; 1805ac88567aSHyon Kim tnode_t *exptn, *contn; 1806ac88567aSHyon Kim boolean_t found; 1807ac88567aSHyon Kim sas_connector_phy_data_t connectors[64] = {NULL}; 1808ac88567aSHyon Kim uint64_t max; 1809ac88567aSHyon Kim ses_enum_node_t *ctlsnp, *xsnp, *consnp; 1810ac88567aSHyon Kim ses_node_t *np = snp->sen_node; 1811ac88567aSHyon Kim nvlist_t *props, *psprops; 1812ac88567aSHyon Kim uint64_t index, psindex, conindex, psstatus, i, j, count; 1813ac88567aSHyon Kim int64_t cidxlist[256] = {NULL}; 1814ac88567aSHyon Kim int phycount; 1815ac88567aSHyon Kim 1816ac88567aSHyon Kim props = ses_node_props(np); 1817ac88567aSHyon Kim 1818ac88567aSHyon Kim if (nvlist_lookup_uint64(props, SES_PROP_ELEMENT_ONLY_INDEX, 1819ac88567aSHyon Kim &index) != 0) 1820ac88567aSHyon Kim return (-1); 1821ac88567aSHyon Kim 1822ac88567aSHyon Kim /* 1823ac88567aSHyon Kim * For SES constroller node, check to see if there are 1824ac88567aSHyon Kim * associated SAS expanders. 1825ac88567aSHyon Kim */ 1826ac88567aSHyon Kim found = B_FALSE; 1827ac88567aSHyon Kim max = 0; 1828ac88567aSHyon Kim for (ctlsnp = topo_list_next(&cp->sec_nodes); ctlsnp != NULL; 1829ac88567aSHyon Kim ctlsnp = topo_list_next(ctlsnp)) { 1830ac88567aSHyon Kim if (ctlsnp->sen_type == SES_ET_SAS_EXPANDER) { 1831ac88567aSHyon Kim found = B_TRUE; 1832ac88567aSHyon Kim if (ctlsnp->sen_instance > max) 1833ac88567aSHyon Kim max = ctlsnp->sen_instance; 1834ac88567aSHyon Kim } 1835ac88567aSHyon Kim } 1836ac88567aSHyon Kim 1837ac88567aSHyon Kim /* 1838ac88567aSHyon Kim * No SAS expander found notthing to process. 1839ac88567aSHyon Kim */ 1840ac88567aSHyon Kim if (!found) 1841ac88567aSHyon Kim return (0); 1842ac88567aSHyon Kim 1843ac88567aSHyon Kim topo_mod_dprintf(mod, "%s Controller %d: creating " 1844ac88567aSHyon Kim "%llu %s nodes", cp->sec_csn, index, max + 1, SASEXPANDER); 1845ac88567aSHyon Kim 1846ac88567aSHyon Kim /* 1847ac88567aSHyon Kim * The max number represent the number of elements 1848ac88567aSHyon Kim * deducted from the highest SES_PROP_ELEMENT_CLASS_INDEX 1849ac88567aSHyon Kim * of SET_ET_SAS_EXPANDER type element. 1850ac88567aSHyon Kim * 1851ac88567aSHyon Kim * There may be multiple ESC Electronics element(controllers) 1852ac88567aSHyon Kim * within JBOD(typicall two for redundancy) and SAS expander 1853ac88567aSHyon Kim * elements are associated with only one of them. We are 1854ac88567aSHyon Kim * still creating the range based max number here. 1855ac88567aSHyon Kim * That will cover the case that all expanders are associated 1856ac88567aSHyon Kim * with one SES controller. 1857ac88567aSHyon Kim */ 1858ac88567aSHyon Kim if (dorange && topo_node_range_create(mod, pnode, 1859ac88567aSHyon Kim SASEXPANDER, 0, max) != 0) { 1860ac88567aSHyon Kim topo_mod_dprintf(mod, 1861ac88567aSHyon Kim "topo_node_create_range() failed: %s", 1862ac88567aSHyon Kim topo_mod_errmsg(mod)); 1863ac88567aSHyon Kim return (-1); 1864ac88567aSHyon Kim } 1865ac88567aSHyon Kim 1866ac88567aSHyon Kim /* 1867ac88567aSHyon Kim * Search exapnders with the parent index matching with 1868ac88567aSHyon Kim * ESC Electronics element index. 1869ac88567aSHyon Kim * Note the index used here is a global index across 1870ac88567aSHyon Kim * SES elements. 1871ac88567aSHyon Kim */ 1872ac88567aSHyon Kim for (xsnp = topo_list_next(&cp->sec_nodes); xsnp != NULL; 1873ac88567aSHyon Kim xsnp = topo_list_next(xsnp)) { 1874ac88567aSHyon Kim if (xsnp->sen_type == SES_ET_SAS_EXPANDER) { 1875ac88567aSHyon Kim /* 1876ac88567aSHyon Kim * get the parent ESC controller. 1877ac88567aSHyon Kim */ 1878ac88567aSHyon Kim psprops = ses_node_props(xsnp->sen_node); 1879ac88567aSHyon Kim if (nvlist_lookup_uint64(psprops, 1880ac88567aSHyon Kim SES_PROP_STATUS_CODE, &psstatus) == 0) { 1881ac88567aSHyon Kim if (psstatus == SES_ESC_NOT_INSTALLED) { 1882ac88567aSHyon Kim /* 1883ac88567aSHyon Kim * Not installed. 1884ac88567aSHyon Kim * Don't create a ndoe. 1885ac88567aSHyon Kim */ 1886ac88567aSHyon Kim continue; 1887ac88567aSHyon Kim } 1888ac88567aSHyon Kim } else { 1889ac88567aSHyon Kim /* 1890ac88567aSHyon Kim * The element should have status code. 1891ac88567aSHyon Kim * If not there is no way to find 1892ac88567aSHyon Kim * out if the expander element exist or 1893ac88567aSHyon Kim * not. 1894ac88567aSHyon Kim */ 1895ac88567aSHyon Kim continue; 1896ac88567aSHyon Kim } 1897ac88567aSHyon Kim 1898ac88567aSHyon Kim /* Get the physical parent index to compare. */ 1899ac88567aSHyon Kim if (nvlist_lookup_uint64(psprops, 1900ac88567aSHyon Kim LIBSES_PROP_PHYS_PARENT, &psindex) == 0) { 1901ac88567aSHyon Kim if (index == psindex) { 1902ac88567aSHyon Kim /* indentation moved forward */ 1903ac88567aSHyon Kim /* 1904ac88567aSHyon Kim * Handle basic node information of SAS expander 1905ac88567aSHyon Kim * element - binding to parent node and 1906ac88567aSHyon Kim * allocating FMRI... 1907ac88567aSHyon Kim */ 1908ded93414SHyon Kim if (ses_create_generic(sdp, xsnp, pnode, pnode, SASEXPANDER, 1909ac88567aSHyon Kim "SAS-EXPANDER", &exptn) != 0) 1910ac88567aSHyon Kim continue; 1911ac88567aSHyon Kim /* 1912ac88567aSHyon Kim * Now handle SAS expander unique portion of node creation. 1913ac88567aSHyon Kim * The max nubmer of the phy count is 256 since SES-2 1914ac88567aSHyon Kim * defines as 1 byte field. The cidxlist has the same 1915ac88567aSHyon Kim * number of elements. 1916ac88567aSHyon Kim * 1917ac88567aSHyon Kim * We use size 64 array to store the connectors. 1918ac88567aSHyon Kim * Typically a connectors associated with 4 phys so that 1919ac88567aSHyon Kim * matches with the max number of connecters associated 1920ac88567aSHyon Kim * with an expander. 1921ac88567aSHyon Kim * The phy count goes up to 38 for Sun supported 1922ac88567aSHyon Kim * JBOD. 1923ac88567aSHyon Kim */ 1924edb433b6SMilan Jurik (void) memset(cidxlist, 0, sizeof (int64_t) * 64); 1925ac88567aSHyon Kim if (ses_set_expander_props(sdp, xsnp, pnode, exptn, &phycount, 1926ac88567aSHyon Kim cidxlist) != 0) { 1927ac88567aSHyon Kim /* 1928ac88567aSHyon Kim * error on getting specific prop failed. 1929ac88567aSHyon Kim * continue on. Note that the node is 1930ac88567aSHyon Kim * left bound. 1931ac88567aSHyon Kim */ 1932ac88567aSHyon Kim continue; 1933ac88567aSHyon Kim } 1934ac88567aSHyon Kim 1935ac88567aSHyon Kim /* 1936ac88567aSHyon Kim * count represetns the number of connectors discovered so far. 1937ac88567aSHyon Kim */ 1938ac88567aSHyon Kim count = 0; 1939edb433b6SMilan Jurik (void) memset(connectors, 0, 1940edb433b6SMilan Jurik sizeof (sas_connector_phy_data_t) * 64); 1941ac88567aSHyon Kim for (i = 0; i < phycount; i++) { 1942ac88567aSHyon Kim if (cidxlist[i] != -1) { 1943ac88567aSHyon Kim /* connector index is valid. */ 1944ac88567aSHyon Kim for (j = 0; j < count; j++) { 1945ded93414SHyon Kim if (connectors[j].scpd_index == 1946ac88567aSHyon Kim cidxlist[i]) { 1947ac88567aSHyon Kim /* 1948ac88567aSHyon Kim * Just update phy mask. 1949ac88567aSHyon Kim * The postion for connector 1950ac88567aSHyon Kim * index lists(cidxlist index) 1951ac88567aSHyon Kim * is set. 1952ac88567aSHyon Kim */ 1953ded93414SHyon Kim connectors[j].scpd_pm = 1954ded93414SHyon Kim connectors[j].scpd_pm | 1955ac88567aSHyon Kim (1ULL << i); 1956ac88567aSHyon Kim break; 1957ac88567aSHyon Kim } 1958ac88567aSHyon Kim } 1959ac88567aSHyon Kim /* 1960ac88567aSHyon Kim * If j and count matche a new connector 1961ac88567aSHyon Kim * index is found. 1962ac88567aSHyon Kim */ 1963ac88567aSHyon Kim if (j == count) { 1964ac88567aSHyon Kim /* add a new index and phy mask. */ 1965ded93414SHyon Kim connectors[count].scpd_index = 1966ded93414SHyon Kim cidxlist[i]; 1967ded93414SHyon Kim connectors[count].scpd_pm = 1968ded93414SHyon Kim connectors[count].scpd_pm | 1969ac88567aSHyon Kim (1ULL << i); 1970ac88567aSHyon Kim count++; 1971ac88567aSHyon Kim } 1972ac88567aSHyon Kim } 1973ac88567aSHyon Kim } 1974ac88567aSHyon Kim 1975ac88567aSHyon Kim /* 1976ac88567aSHyon Kim * create range for the connector nodes. 1977ac88567aSHyon Kim * The class index of the ses connector element 1978ac88567aSHyon Kim * is set as the instance nubmer for the node. 1979ac88567aSHyon Kim * Even though one expander may not have all connectors 1980ac88567aSHyon Kim * are associated with we are creating the range with 1981ac88567aSHyon Kim * max possible instance number. 1982ac88567aSHyon Kim */ 1983ac88567aSHyon Kim found = B_FALSE; 1984ac88567aSHyon Kim max = 0; 1985ac88567aSHyon Kim for (consnp = topo_list_next(&cp->sec_nodes); 1986ac88567aSHyon Kim consnp != NULL; consnp = topo_list_next(consnp)) { 1987ac88567aSHyon Kim if (consnp->sen_type == SES_ET_SAS_CONNECTOR) { 1988ac88567aSHyon Kim psprops = ses_node_props(consnp->sen_node); 1989ac88567aSHyon Kim found = B_TRUE; 1990ac88567aSHyon Kim if (consnp->sen_instance > max) 1991ac88567aSHyon Kim max = consnp->sen_instance; 1992ac88567aSHyon Kim } 1993ac88567aSHyon Kim } 1994ac88567aSHyon Kim 1995ac88567aSHyon Kim /* 1996ac88567aSHyon Kim * No SAS connector found nothing to process. 1997ac88567aSHyon Kim */ 1998ac88567aSHyon Kim if (!found) 1999ac88567aSHyon Kim return (0); 2000ac88567aSHyon Kim 2001ac88567aSHyon Kim if (dorange && topo_node_range_create(mod, exptn, 2002ac88567aSHyon Kim RECEPTACLE, 0, max) != 0) { 2003ac88567aSHyon Kim topo_mod_dprintf(mod, 2004ac88567aSHyon Kim "topo_node_create_range() failed: %s", 2005ac88567aSHyon Kim topo_mod_errmsg(mod)); 2006ac88567aSHyon Kim return (-1); 2007ac88567aSHyon Kim } 2008ac88567aSHyon Kim 2009ac88567aSHyon Kim /* search matching connector element using the index. */ 2010ac88567aSHyon Kim for (i = 0; i < count; i++) { 2011ac88567aSHyon Kim found = B_FALSE; 2012ac88567aSHyon Kim for (consnp = topo_list_next(&cp->sec_nodes); 2013ac88567aSHyon Kim consnp != NULL; consnp = topo_list_next(consnp)) { 2014ac88567aSHyon Kim if (consnp->sen_type == SES_ET_SAS_CONNECTOR) { 2015ac88567aSHyon Kim psprops = ses_node_props( 2016ac88567aSHyon Kim consnp->sen_node); 2017ac88567aSHyon Kim /* 2018ac88567aSHyon Kim * Get the physical parent index to 2019ac88567aSHyon Kim * compare. 2020ac88567aSHyon Kim * The connector elements are children 2021ac88567aSHyon Kim * of ESC Electronics element even 2022ac88567aSHyon Kim * though we enumerate them under 2023ac88567aSHyon Kim * an expander in libtopo. 2024ac88567aSHyon Kim */ 2025ac88567aSHyon Kim if (nvlist_lookup_uint64(psprops, 2026ac88567aSHyon Kim SES_PROP_ELEMENT_ONLY_INDEX, 2027ac88567aSHyon Kim &conindex) == 0) { 2028ac88567aSHyon Kim if (conindex == 2029ded93414SHyon Kim connectors[i].scpd_index) { 2030ac88567aSHyon Kim found = B_TRUE; 2031ac88567aSHyon Kim break; 2032ac88567aSHyon Kim } 2033ac88567aSHyon Kim } 2034ac88567aSHyon Kim } 2035ac88567aSHyon Kim } 2036ac88567aSHyon Kim 2037ac88567aSHyon Kim /* now create a libtopo node. */ 2038ac88567aSHyon Kim if (found) { 2039ac88567aSHyon Kim /* Create generic props. */ 2040ac88567aSHyon Kim if (ses_create_generic(sdp, consnp, exptn, 2041ded93414SHyon Kim topo_node_parent(exptn), 2042ac88567aSHyon Kim RECEPTACLE, "RECEPTACLE", &contn) != 2043ac88567aSHyon Kim 0) { 2044ac88567aSHyon Kim continue; 2045ac88567aSHyon Kim } 2046ac88567aSHyon Kim /* Create connector specific props. */ 2047ac88567aSHyon Kim if (ses_set_connector_props(sdp, consnp, 2048ded93414SHyon Kim contn, connectors[i].scpd_pm) != 0) { 2049ac88567aSHyon Kim continue; 2050ac88567aSHyon Kim } 2051ac88567aSHyon Kim } 2052ac88567aSHyon Kim } 2053ac88567aSHyon Kim /* end indentation change */ 2054ac88567aSHyon Kim } 2055ac88567aSHyon Kim } 2056ac88567aSHyon Kim } 2057ac88567aSHyon Kim } 2058ac88567aSHyon Kim 2059ac88567aSHyon Kim return (0); 2060ac88567aSHyon Kim } 2061ac88567aSHyon Kim 2062ac88567aSHyon Kim /* 2063ac88567aSHyon Kim * Instantiate any protocol specific portion of a node. 2064ac88567aSHyon Kim */ 2065ac88567aSHyon Kim /*ARGSUSED*/ 2066ac88567aSHyon Kim static int 2067ac88567aSHyon Kim ses_create_protocol_specific(ses_enum_data_t *sdp, ses_enum_node_t *snp, 2068ac88567aSHyon Kim tnode_t *pnode, uint64_t type, ses_enum_chassis_t *cp, 2069ac88567aSHyon Kim boolean_t dorange) 2070ac88567aSHyon Kim { 2071ac88567aSHyon Kim 2072ac88567aSHyon Kim if (type == SES_ET_ESC_ELECTRONICS) { 2073ac88567aSHyon Kim /* create SAS specific children(expanders and connectors. */ 2074ac88567aSHyon Kim return (ses_create_esc_sasspecific(sdp, snp, pnode, cp, 2075ac88567aSHyon Kim dorange)); 2076ac88567aSHyon Kim } 2077ac88567aSHyon Kim 2078ac88567aSHyon Kim return (0); 2079ac88567aSHyon Kim } 2080ac88567aSHyon Kim 2081940d71d2Seschrock /* 2082940d71d2Seschrock * Instantiate any children of a given type. 2083940d71d2Seschrock */ 2084940d71d2Seschrock static int 2085940d71d2Seschrock ses_create_children(ses_enum_data_t *sdp, tnode_t *pnode, uint64_t type, 2086d91236feSeschrock const char *nodename, const char *defaultlabel, ses_enum_chassis_t *cp, 2087d91236feSeschrock boolean_t dorange) 2088940d71d2Seschrock { 2089940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 2090940d71d2Seschrock boolean_t found; 2091940d71d2Seschrock uint64_t max; 2092940d71d2Seschrock ses_enum_node_t *snp; 2093ac88567aSHyon Kim tnode_t *tn; 2094940d71d2Seschrock 2095940d71d2Seschrock /* 2096940d71d2Seschrock * First go through and count how many matching nodes we have. 2097940d71d2Seschrock */ 2098940d71d2Seschrock max = 0; 2099940d71d2Seschrock found = B_FALSE; 2100940d71d2Seschrock for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2101940d71d2Seschrock snp = topo_list_next(snp)) { 2102940d71d2Seschrock if (snp->sen_type == type) { 2103940d71d2Seschrock found = B_TRUE; 2104940d71d2Seschrock if (snp->sen_instance > max) 2105940d71d2Seschrock max = snp->sen_instance; 2106940d71d2Seschrock } 2107940d71d2Seschrock } 2108940d71d2Seschrock 2109940d71d2Seschrock /* 2110940d71d2Seschrock * No enclosure should export both DEVICE and ARRAY_DEVICE elements. 2111940d71d2Seschrock * Since we map both of these to 'disk', if an enclosure does this, we 2112940d71d2Seschrock * just ignore the array elements. 2113940d71d2Seschrock */ 2114940d71d2Seschrock if (!found || 2115940d71d2Seschrock (type == SES_ET_ARRAY_DEVICE && cp->sec_hasdev)) 2116940d71d2Seschrock return (0); 2117940d71d2Seschrock 2118940d71d2Seschrock topo_mod_dprintf(mod, "%s: creating %llu %s nodes", 211953dbcc59SSundeep Panicker cp->sec_csn, max + 1, nodename); 2120940d71d2Seschrock 2121d91236feSeschrock if (dorange && topo_node_range_create(mod, pnode, 2122940d71d2Seschrock nodename, 0, max) != 0) { 2123940d71d2Seschrock topo_mod_dprintf(mod, 2124940d71d2Seschrock "topo_node_create_range() failed: %s", 2125940d71d2Seschrock topo_mod_errmsg(mod)); 2126940d71d2Seschrock return (-1); 2127940d71d2Seschrock } 2128940d71d2Seschrock 2129940d71d2Seschrock for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2130940d71d2Seschrock snp = topo_list_next(snp)) { 2131940d71d2Seschrock if (snp->sen_type == type) { 2132ded93414SHyon Kim /* 2133ded93414SHyon Kim * With flat layout of ses nodes there is no 2134ded93414SHyon Kim * way to find out the direct FRU for a node. 2135ded93414SHyon Kim * Passing NULL for fru topo node. Note that 2136ded93414SHyon Kim * ses_create_children_from_phys_tree() provides 2137ded93414SHyon Kim * the actual direct FRU for a node. 2138ded93414SHyon Kim */ 2139ded93414SHyon Kim if (ses_create_generic(sdp, snp, pnode, NULL, 2140ac88567aSHyon Kim nodename, defaultlabel, &tn) != 0) 2141940d71d2Seschrock return (-1); 2142ac88567aSHyon Kim /* 2143ac88567aSHyon Kim * For some SES element there may be protocol specific 2144ac88567aSHyon Kim * information to process. Here we are processing 2145ac88567aSHyon Kim * the association between enclosure controller and 2146ac88567aSHyon Kim * SAS expanders. 2147ac88567aSHyon Kim */ 2148ac88567aSHyon Kim if (type == SES_ET_ESC_ELECTRONICS) { 2149ac88567aSHyon Kim /* create SAS expander node */ 2150ac88567aSHyon Kim if (ses_create_protocol_specific(sdp, snp, 2151ac88567aSHyon Kim tn, type, cp, dorange) != 0) { 2152ac88567aSHyon Kim return (-1); 2153ac88567aSHyon Kim } 2154ac88567aSHyon Kim } 2155ac88567aSHyon Kim 2156940d71d2Seschrock } 2157940d71d2Seschrock } 2158940d71d2Seschrock 2159940d71d2Seschrock return (0); 2160940d71d2Seschrock } 2161940d71d2Seschrock 216253dbcc59SSundeep Panicker /* 216353dbcc59SSundeep Panicker * Instantiate a new subchassis instance in the topology. 216453dbcc59SSundeep Panicker */ 216553dbcc59SSundeep Panicker static int 216653dbcc59SSundeep Panicker ses_create_subchassis(ses_enum_data_t *sdp, tnode_t *pnode, 216753dbcc59SSundeep Panicker ses_enum_chassis_t *scp) 216853dbcc59SSundeep Panicker { 216953dbcc59SSundeep Panicker topo_mod_t *mod = sdp->sed_mod; 217053dbcc59SSundeep Panicker tnode_t *tn; 217153dbcc59SSundeep Panicker nvlist_t *props; 217253dbcc59SSundeep Panicker nvlist_t *auth = NULL, *fmri = NULL; 217353dbcc59SSundeep Panicker uint64_t instance = scp->sec_instance; 217453dbcc59SSundeep Panicker char *desc; 217553dbcc59SSundeep Panicker char label[128]; 217653dbcc59SSundeep Panicker char **paths; 217753dbcc59SSundeep Panicker int i, err; 217853dbcc59SSundeep Panicker ses_enum_target_t *stp; 217953dbcc59SSundeep Panicker int ret = -1; 218053dbcc59SSundeep Panicker 218153dbcc59SSundeep Panicker /* 218253dbcc59SSundeep Panicker * Copy authority information from parent enclosure node 218353dbcc59SSundeep Panicker */ 218453dbcc59SSundeep Panicker if ((auth = topo_mod_auth(mod, pnode)) == NULL) 218553dbcc59SSundeep Panicker goto error; 218653dbcc59SSundeep Panicker 218753dbcc59SSundeep Panicker /* 218853dbcc59SSundeep Panicker * Record the subchassis serial number in the FMRI. 218953dbcc59SSundeep Panicker * For now, we assume that logical id is the subchassis serial number. 219053dbcc59SSundeep Panicker * If this assumption changes in future, then the following 219153dbcc59SSundeep Panicker * piece of code will need to be updated via an RFE. 219253dbcc59SSundeep Panicker */ 219353dbcc59SSundeep Panicker if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION, 2194ac88567aSHyon Kim SUBCHASSIS, (topo_instance_t)instance, NULL, auth, NULL, NULL, 2195ac88567aSHyon Kim NULL)) == NULL) { 219653dbcc59SSundeep Panicker topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s", 219753dbcc59SSundeep Panicker topo_mod_errmsg(mod)); 219853dbcc59SSundeep Panicker goto error; 219953dbcc59SSundeep Panicker } 220053dbcc59SSundeep Panicker 220153dbcc59SSundeep Panicker if ((tn = topo_node_bind(mod, pnode, SUBCHASSIS, 220253dbcc59SSundeep Panicker instance, fmri)) == NULL) { 220353dbcc59SSundeep Panicker topo_mod_dprintf(mod, "topo_node_bind() failed: %s", 220453dbcc59SSundeep Panicker topo_mod_errmsg(mod)); 220553dbcc59SSundeep Panicker goto error; 220653dbcc59SSundeep Panicker } 220753dbcc59SSundeep Panicker 220853dbcc59SSundeep Panicker props = ses_node_props(scp->sec_enclosure); 220953dbcc59SSundeep Panicker 221053dbcc59SSundeep Panicker /* 221153dbcc59SSundeep Panicker * Look for the subchassis label in the following order: 221253dbcc59SSundeep Panicker * <ses-description> 221353dbcc59SSundeep Panicker * <ses-class-description> <instance> 221453dbcc59SSundeep Panicker * <default-type-label> <instance> 221553dbcc59SSundeep Panicker * 221653dbcc59SSundeep Panicker * For subchassis, the default label is "SUBCHASSIS" 221753dbcc59SSundeep Panicker */ 221853dbcc59SSundeep Panicker if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 || 221953dbcc59SSundeep Panicker desc[0] == '\0') { 222053dbcc59SSundeep Panicker if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION, 222153dbcc59SSundeep Panicker &desc) == 0 && desc[0] != '\0') 222253dbcc59SSundeep Panicker (void) snprintf(label, sizeof (label), "%s %llu", desc, 222353dbcc59SSundeep Panicker instance); 222453dbcc59SSundeep Panicker else 222553dbcc59SSundeep Panicker (void) snprintf(label, sizeof (label), 222653dbcc59SSundeep Panicker "SUBCHASSIS %llu", instance); 222753dbcc59SSundeep Panicker desc = label; 222853dbcc59SSundeep Panicker } 222953dbcc59SSundeep Panicker 223053dbcc59SSundeep Panicker if (topo_node_label_set(tn, desc, &err) != 0) 223153dbcc59SSundeep Panicker goto error; 223253dbcc59SSundeep Panicker 2233ac88567aSHyon Kim if (ses_set_standard_props(mod, NULL, tn, NULL, 223453dbcc59SSundeep Panicker ses_node_id(scp->sec_enclosure), scp->sec_target->set_devpath) != 0) 223553dbcc59SSundeep Panicker goto error; 223653dbcc59SSundeep Panicker 2237ac88567aSHyon Kim /* 2238ac88567aSHyon Kim * Set the 'chassis-type' property for this subchassis. This is either 2239ac88567aSHyon Kim * 'ses-class-description' or 'subchassis'. 2240ac88567aSHyon Kim */ 2241ac88567aSHyon Kim if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION, &desc) != 0) 2242ac88567aSHyon Kim desc = "subchassis"; 2243ac88567aSHyon Kim 2244ac88567aSHyon Kim if (topo_prop_set_string(tn, TOPO_PGROUP_SES, 2245ac88567aSHyon Kim TOPO_PROP_CHASSIS_TYPE, TOPO_PROP_IMMUTABLE, desc, &err) != 0) { 2246ac88567aSHyon Kim topo_mod_dprintf(mod, "failed to create property %s: %s\n", 2247ac88567aSHyon Kim TOPO_PROP_CHASSIS_TYPE, topo_strerror(err)); 2248ac88567aSHyon Kim goto error; 2249ac88567aSHyon Kim } 2250ac88567aSHyon Kim 225153dbcc59SSundeep Panicker /* 225253dbcc59SSundeep Panicker * For enclosures, we want to include all possible targets (for upgrade 225353dbcc59SSundeep Panicker * purposes). 225453dbcc59SSundeep Panicker */ 225553dbcc59SSundeep Panicker for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL; 225653dbcc59SSundeep Panicker stp = topo_list_next(stp), i++) 225753dbcc59SSundeep Panicker ; 225853dbcc59SSundeep Panicker 225953dbcc59SSundeep Panicker verify(i != 0); 226053dbcc59SSundeep Panicker paths = alloca(i * sizeof (char *)); 226153dbcc59SSundeep Panicker 226253dbcc59SSundeep Panicker for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL; 226353dbcc59SSundeep Panicker stp = topo_list_next(stp), i++) 226453dbcc59SSundeep Panicker paths[i] = stp->set_devpath; 226553dbcc59SSundeep Panicker 226653dbcc59SSundeep Panicker if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES, 226753dbcc59SSundeep Panicker TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths, 226853dbcc59SSundeep Panicker i, &err) != 0) { 226953dbcc59SSundeep Panicker topo_mod_dprintf(mod, "failed to create property %s: %s\n", 227053dbcc59SSundeep Panicker TOPO_PROP_PATHS, topo_strerror(err)); 227153dbcc59SSundeep Panicker goto error; 227253dbcc59SSundeep Panicker } 227353dbcc59SSundeep Panicker 227453dbcc59SSundeep Panicker if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) { 227553dbcc59SSundeep Panicker topo_mod_dprintf(mod, "topo_method_register() failed: %s", 227653dbcc59SSundeep Panicker topo_mod_errmsg(mod)); 227753dbcc59SSundeep Panicker goto error; 227853dbcc59SSundeep Panicker } 227953dbcc59SSundeep Panicker 228053dbcc59SSundeep Panicker /* 228153dbcc59SSundeep Panicker * Create the nodes for controllers and bays. 228253dbcc59SSundeep Panicker */ 228353dbcc59SSundeep Panicker if (ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS, 228453dbcc59SSundeep Panicker CONTROLLER, "CONTROLLER", scp, B_TRUE) != 0 || 228553dbcc59SSundeep Panicker ses_create_children(sdp, tn, SES_ET_DEVICE, 228653dbcc59SSundeep Panicker BAY, "BAY", scp, B_TRUE) != 0 || 228753dbcc59SSundeep Panicker ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE, 228853dbcc59SSundeep Panicker BAY, "BAY", scp, B_TRUE) != 0) 228953dbcc59SSundeep Panicker goto error; 229053dbcc59SSundeep Panicker 229153dbcc59SSundeep Panicker ret = 0; 229253dbcc59SSundeep Panicker 229353dbcc59SSundeep Panicker error: 229453dbcc59SSundeep Panicker nvlist_free(auth); 229553dbcc59SSundeep Panicker nvlist_free(fmri); 229653dbcc59SSundeep Panicker return (ret); 229753dbcc59SSundeep Panicker } 229853dbcc59SSundeep Panicker 2299ded93414SHyon Kim /* 2300ded93414SHyon Kim * Function we use to insert a node. 2301ded93414SHyon Kim */ 2302ded93414SHyon Kim static int 2303ded93414SHyon Kim ses_phys_tree_insert(topo_mod_t *mod, ses_phys_tree_t **sproot, 2304ded93414SHyon Kim ses_phys_tree_t *child) 2305ded93414SHyon Kim { 2306ded93414SHyon Kim uint64_t ppindex, eindex, pindex; 2307ded93414SHyon Kim ses_phys_tree_t *node_ptr; 2308ded93414SHyon Kim int ret = 0; 2309ded93414SHyon Kim 2310ded93414SHyon Kim assert(sproot != NULL); 2311ded93414SHyon Kim assert(child != NULL); 2312ded93414SHyon Kim 2313ded93414SHyon Kim if (*sproot == NULL) { 2314ded93414SHyon Kim *sproot = child; 2315ded93414SHyon Kim return (0); 2316ded93414SHyon Kim } 2317ded93414SHyon Kim 2318ded93414SHyon Kim pindex = child->spt_pindex; 2319ded93414SHyon Kim ppindex = (*sproot)->spt_pindex; 2320ded93414SHyon Kim eindex = (*sproot)->spt_eonlyindex; 2321ded93414SHyon Kim 2322ded93414SHyon Kim /* 2323ded93414SHyon Kim * If the element only index of the root is same as the physical 2324ded93414SHyon Kim * parent index of a node to be added, add the node as a child of 2325ded93414SHyon Kim * the current root. 2326ded93414SHyon Kim */ 2327ded93414SHyon Kim if (eindex == pindex) { 2328ded93414SHyon Kim (void) ses_phys_tree_insert(mod, &(*sproot)->spt_child, child); 2329ded93414SHyon Kim child->spt_parent = *sproot; 2330ded93414SHyon Kim } else if (ppindex == pindex) { 2331ded93414SHyon Kim /* 2332ded93414SHyon Kim * if the physical parent of the current root and the child 2333ded93414SHyon Kim * is same, then this should be a sibling node. 2334ded93414SHyon Kim * Siblings can be different element types and arrange 2335ded93414SHyon Kim * them by group. 2336ded93414SHyon Kim */ 2337ded93414SHyon Kim if ((*sproot)->spt_senumnode->sen_type == 2338ded93414SHyon Kim child->spt_senumnode->sen_type) { 2339ded93414SHyon Kim child->spt_sibling = *sproot; 2340ded93414SHyon Kim *sproot = child; 2341ded93414SHyon Kim } else { 2342ded93414SHyon Kim /* add a node in front of matching element type. */ 2343ded93414SHyon Kim node_ptr = *sproot; 2344ded93414SHyon Kim while (node_ptr->spt_sibling != NULL) { 2345ded93414SHyon Kim if (node_ptr->spt_sibling-> 2346ded93414SHyon Kim spt_senumnode->sen_type == 2347ded93414SHyon Kim child->spt_senumnode->sen_type) { 2348ded93414SHyon Kim child->spt_sibling = 2349ded93414SHyon Kim node_ptr->spt_sibling; 2350ded93414SHyon Kim node_ptr->spt_sibling = child; 2351ded93414SHyon Kim break; 2352ded93414SHyon Kim } 2353ded93414SHyon Kim node_ptr = node_ptr->spt_sibling; 2354ded93414SHyon Kim } 2355ded93414SHyon Kim /* no matching. Add the child at the end. */ 2356ded93414SHyon Kim if (node_ptr->spt_sibling == NULL) { 2357ded93414SHyon Kim node_ptr->spt_sibling = child; 2358ded93414SHyon Kim } 2359ded93414SHyon Kim } 2360ded93414SHyon Kim child->spt_parent = (*sproot)->spt_parent; 2361ded93414SHyon Kim } else { 2362ded93414SHyon Kim /* 2363ded93414SHyon Kim * The root and the node is not directly related. 2364ded93414SHyon Kim * Try to insert to the child sub-tree first and then try to 2365ded93414SHyon Kim * insert to the sibling sub-trees. If fails for both 2366ded93414SHyon Kim * the caller will retry insertion later. 2367ded93414SHyon Kim */ 2368ded93414SHyon Kim if ((*sproot)->spt_child) { 2369ded93414SHyon Kim ret = ses_phys_tree_insert(mod, &(*sproot)->spt_child, 2370ded93414SHyon Kim child); 2371ded93414SHyon Kim } 2372ded93414SHyon Kim if ((*sproot)->spt_child == NULL || ret != 0) { 2373ded93414SHyon Kim if ((*sproot)->spt_sibling) { 2374ded93414SHyon Kim ret = ses_phys_tree_insert(mod, 2375ded93414SHyon Kim &(*sproot)->spt_sibling, child); 2376ded93414SHyon Kim } else { 2377ded93414SHyon Kim ret = 1; 2378ded93414SHyon Kim } 2379ded93414SHyon Kim } 2380ded93414SHyon Kim return (ret); 2381ded93414SHyon Kim } 2382ded93414SHyon Kim return (0); 2383ded93414SHyon Kim } 2384ded93414SHyon Kim 2385ded93414SHyon Kim /* 2386ded93414SHyon Kim * Construct tree view of ses elements through parent phyiscal element index. 2387ded93414SHyon Kim * The root of tree is already constructed using the enclosure element. 2388ded93414SHyon Kim */ 2389ded93414SHyon Kim static int 2390ded93414SHyon Kim ses_construct_phys_tree(ses_enum_data_t *sdp, ses_enum_chassis_t *cp, 2391ded93414SHyon Kim ses_phys_tree_t *sproot) 2392ded93414SHyon Kim { 2393ded93414SHyon Kim ses_enum_node_t *snp; 2394ded93414SHyon Kim ses_phys_tree_t *child; 2395ded93414SHyon Kim ses_phys_tree_t *u_watch = NULL; 2396ded93414SHyon Kim ses_phys_tree_t *u_head = NULL; 2397ded93414SHyon Kim ses_phys_tree_t *u_tail = NULL; 2398ded93414SHyon Kim int u_inserted = 0, u_left = 0; 2399ded93414SHyon Kim nvlist_t *props; 2400ded93414SHyon Kim topo_mod_t *mod = sdp->sed_mod; 2401ded93414SHyon Kim 2402ded93414SHyon Kim for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2403ded93414SHyon Kim snp = topo_list_next(snp)) { 2404ded93414SHyon Kim if ((child = topo_mod_zalloc(mod, 2405ded93414SHyon Kim sizeof (ses_phys_tree_t))) == NULL) { 2406ded93414SHyon Kim topo_mod_dprintf(mod, 2407ded93414SHyon Kim "failed to allocate root."); 2408ded93414SHyon Kim return (-1); 2409ded93414SHyon Kim } 2410ded93414SHyon Kim child->spt_snode = snp->sen_node; 2411ded93414SHyon Kim props = ses_node_props(snp->sen_node); 2412ded93414SHyon Kim if (nvlist_lookup_uint64(props, 2413ded93414SHyon Kim LIBSES_PROP_PHYS_PARENT, &child->spt_pindex) != 0) { 2414ded93414SHyon Kim /* 2415ded93414SHyon Kim * the prop should exist. continue to see if 2416ded93414SHyon Kim * we can build a partial tree with other elements. 2417ded93414SHyon Kim */ 2418ded93414SHyon Kim topo_mod_dprintf(mod, 2419ded93414SHyon Kim "ses_construct_phys_tree(): Failed to find prop %s " 2420ded93414SHyon Kim "on ses element type %d and instance %d " 2421ded93414SHyon Kim "(CSN %s).", LIBSES_PROP_PHYS_PARENT, 2422ded93414SHyon Kim snp->sen_type, snp->sen_instance, cp->sec_csn); 2423ded93414SHyon Kim topo_mod_free(mod, child, sizeof (ses_phys_tree_t)); 2424ded93414SHyon Kim continue; 2425ded93414SHyon Kim } else { 2426ded93414SHyon Kim if (nvlist_lookup_boolean_value(props, 2427ded93414SHyon Kim LIBSES_PROP_FRU, &child->spt_isfru) != 0) { 2428ded93414SHyon Kim topo_mod_dprintf(mod, 2429ded93414SHyon Kim "ses_construct_phys_tree(): Failed to " 2430ded93414SHyon Kim "find prop %s on ses element type %d " 2431ded93414SHyon Kim "and instance %d (CSN %s).", 2432ded93414SHyon Kim LIBSES_PROP_FRU, 2433ded93414SHyon Kim snp->sen_type, snp->sen_instance, 2434ded93414SHyon Kim cp->sec_csn); 2435ded93414SHyon Kim /* 2436ded93414SHyon Kim * Ignore if the prop doesn't exist. 2437ded93414SHyon Kim * Note that the enclosure itself should be 2438ded93414SHyon Kim * a FRU so if no FRU found the enclosure FRU 2439ded93414SHyon Kim * can be a direct FRU. 2440ded93414SHyon Kim */ 2441ded93414SHyon Kim } 2442ded93414SHyon Kim verify(nvlist_lookup_uint64(props, 2443ded93414SHyon Kim SES_PROP_ELEMENT_ONLY_INDEX, 2444ded93414SHyon Kim &child->spt_eonlyindex) == 0); 2445ded93414SHyon Kim verify(nvlist_lookup_uint64(props, 2446ded93414SHyon Kim SES_PROP_ELEMENT_CLASS_INDEX, 2447ded93414SHyon Kim &child->spt_cindex) == 0); 2448ded93414SHyon Kim } 2449ded93414SHyon Kim child->spt_senumnode = snp; 2450ded93414SHyon Kim if (ses_phys_tree_insert(mod, &sproot, child) != 0) { 2451ded93414SHyon Kim /* collect unresolved element to process later. */ 2452ded93414SHyon Kim if (u_head == NULL) { 2453ded93414SHyon Kim u_head = child; 2454ded93414SHyon Kim u_tail = child; 2455ded93414SHyon Kim } else { 2456ded93414SHyon Kim child->spt_sibling = u_head; 2457ded93414SHyon Kim u_head = child; 2458ded93414SHyon Kim } 2459ded93414SHyon Kim } 2460ded93414SHyon Kim } 2461ded93414SHyon Kim 2462ded93414SHyon Kim /* 2463ded93414SHyon Kim * The parent of a child node may not be inserted yet. 2464ded93414SHyon Kim * Trying to insert the child until no child is left or 2465ded93414SHyon Kim * no child is not added further. For the latter 2466ded93414SHyon Kim * the hierarchical relationship between elements 2467ded93414SHyon Kim * should be checked through SUNW,FRUID page. 2468ded93414SHyon Kim * u_watch is a watch dog to check the prgress of unresolved 2469ded93414SHyon Kim * node. 2470ded93414SHyon Kim */ 2471ded93414SHyon Kim u_watch = u_tail; 2472ded93414SHyon Kim while (u_head) { 2473ded93414SHyon Kim child = u_head; 2474ded93414SHyon Kim u_head = u_head->spt_sibling; 2475ded93414SHyon Kim if (u_head == NULL) 2476ded93414SHyon Kim u_tail = NULL; 2477ded93414SHyon Kim child->spt_sibling = NULL; 2478ded93414SHyon Kim if (ses_phys_tree_insert(mod, &sproot, child) != 0) { 2479ded93414SHyon Kim u_tail->spt_sibling = child; 2480ded93414SHyon Kim u_tail = child; 2481ded93414SHyon Kim if (child == u_watch) { 2482ded93414SHyon Kim /* 2483ded93414SHyon Kim * We just scanned one round for the 2484ded93414SHyon Kim * unresolved list. Check to see whether we 2485ded93414SHyon Kim * have nodes inserted, if none, we should 2486ded93414SHyon Kim * break in case of an indefinite loop. 2487ded93414SHyon Kim */ 2488ded93414SHyon Kim if (u_inserted == 0) { 2489ded93414SHyon Kim /* 2490ded93414SHyon Kim * Indicate there is unhandled node. 2491ded93414SHyon Kim * Chain free the whole unsolved 2492ded93414SHyon Kim * list here. 2493ded93414SHyon Kim */ 2494ded93414SHyon Kim u_left++; 2495ded93414SHyon Kim break; 2496ded93414SHyon Kim } else { 2497ded93414SHyon Kim u_inserted = 0; 2498ded93414SHyon Kim u_watch = u_tail; 2499ded93414SHyon Kim } 2500ded93414SHyon Kim } 2501ded93414SHyon Kim } else { 2502ded93414SHyon Kim /* 2503ded93414SHyon Kim * We just inserted one rpnode, increment the 2504ded93414SHyon Kim * unsolved_inserted counter. We will utilize this 2505ded93414SHyon Kim * counter to detect an indefinite insertion loop. 2506ded93414SHyon Kim */ 2507ded93414SHyon Kim u_inserted++; 25087f188cd7SHyon Kim if (child == u_watch) { 25097f188cd7SHyon Kim /* 25107f188cd7SHyon Kim * watch dog node itself is inserted. 25117f188cd7SHyon Kim * Set it to the tail and refresh the watching. 25127f188cd7SHyon Kim */ 25137f188cd7SHyon Kim u_watch = u_tail; 25147f188cd7SHyon Kim u_inserted = 0; 25157f188cd7SHyon Kim u_left = 0; 25167f188cd7SHyon Kim } 2517ded93414SHyon Kim } 2518ded93414SHyon Kim } 2519ded93414SHyon Kim 2520ded93414SHyon Kim /* check if there is left out unresolved nodes. */ 2521ded93414SHyon Kim if (u_left) { 2522ded93414SHyon Kim topo_mod_dprintf(mod, "ses_construct_phys_tree(): " 2523ded93414SHyon Kim "Failed to construct physical view of the following " 2524ded93414SHyon Kim "ses elements of Chassis CSN %s.", cp->sec_csn); 2525ded93414SHyon Kim while (u_head) { 2526ded93414SHyon Kim u_tail = u_head->spt_sibling; 2527ded93414SHyon Kim topo_mod_dprintf(mod, 2528ded93414SHyon Kim "\telement type (%d) and instance (%d)", 2529ded93414SHyon Kim u_head->spt_senumnode->sen_type, 2530ded93414SHyon Kim u_head->spt_senumnode->sen_instance); 2531ded93414SHyon Kim topo_mod_free(mod, u_head, sizeof (ses_phys_tree_t)); 2532ded93414SHyon Kim u_head = u_tail; 2533ded93414SHyon Kim } 2534ded93414SHyon Kim return (-1); 2535ded93414SHyon Kim } 2536ded93414SHyon Kim 2537ded93414SHyon Kim return (0); 2538ded93414SHyon Kim } 2539ded93414SHyon Kim 2540ded93414SHyon Kim /* 2541ded93414SHyon Kim * Free the whole phys tree. 2542ded93414SHyon Kim */ 2543ded93414SHyon Kim static void ses_phys_tree_free(topo_mod_t *mod, ses_phys_tree_t *sproot) 2544ded93414SHyon Kim { 2545ded93414SHyon Kim if (sproot == NULL) 2546ded93414SHyon Kim return; 2547ded93414SHyon Kim 2548ded93414SHyon Kim /* Free child tree. */ 2549ded93414SHyon Kim if (sproot->spt_child) { 2550ded93414SHyon Kim ses_phys_tree_free(mod, sproot->spt_child); 2551ded93414SHyon Kim } 2552ded93414SHyon Kim 2553ded93414SHyon Kim /* Free sibling trees. */ 2554ded93414SHyon Kim if (sproot->spt_sibling) { 2555ded93414SHyon Kim ses_phys_tree_free(mod, sproot->spt_sibling); 2556ded93414SHyon Kim } 2557ded93414SHyon Kim 2558ded93414SHyon Kim /* Free root node itself. */ 2559ded93414SHyon Kim topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t)); 2560ded93414SHyon Kim } 2561ded93414SHyon Kim 2562ded93414SHyon Kim /* 2563ded93414SHyon Kim * Parses phys_enum_type table to get the index of the given type. 2564ded93414SHyon Kim */ 2565ded93414SHyon Kim static boolean_t 2566ded93414SHyon Kim is_type_enumerated(ses_phys_tree_t *node, int *index) 2567ded93414SHyon Kim { 2568ded93414SHyon Kim int i; 2569ded93414SHyon Kim 2570ded93414SHyon Kim for (i = 0; i < N_PHYS_ENUM_TYPES; i++) { 2571ded93414SHyon Kim if (node->spt_senumnode->sen_type == 2572ded93414SHyon Kim phys_enum_type_list[i].pet_type) { 2573ded93414SHyon Kim *index = i; 2574ded93414SHyon Kim return (B_TRUE); 2575ded93414SHyon Kim } 2576ded93414SHyon Kim } 2577ded93414SHyon Kim return (B_FALSE); 2578ded93414SHyon Kim } 2579ded93414SHyon Kim 2580ded93414SHyon Kim /* 2581ded93414SHyon Kim * Recusrive routine for top-down enumeration of the tree. 2582ded93414SHyon Kim */ 2583ded93414SHyon Kim static int 2584ded93414SHyon Kim ses_enumerate_node(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp, 2585ded93414SHyon Kim ses_phys_tree_t *parent, int mrange[]) 2586ded93414SHyon Kim { 2587ded93414SHyon Kim topo_mod_t *mod = sdp->sed_mod; 2588ded93414SHyon Kim ses_phys_tree_t *child = NULL; 2589ded93414SHyon Kim int i, ret = 0, ret_ch; 2590ded93414SHyon Kim uint64_t prevtype = SES_ET_UNSPECIFIED; 2591ded93414SHyon Kim ses_phys_tree_t *dirfru = NULL; 2592ded93414SHyon Kim tnode_t *tn = NULL, *frutn = NULL; 2593ded93414SHyon Kim 2594ded93414SHyon Kim if (parent == NULL) { 2595ded93414SHyon Kim return (0); 2596ded93414SHyon Kim } 2597ded93414SHyon Kim 2598ded93414SHyon Kim for (child = parent->spt_child; child != NULL; 2599ded93414SHyon Kim child = child->spt_sibling) { 2600ded93414SHyon Kim if (is_type_enumerated(child, &i)) { 2601ded93414SHyon Kim if (prevtype != phys_enum_type_list[i].pet_type) { 2602ded93414SHyon Kim /* check if range needs to be created. */ 2603ded93414SHyon Kim if (phys_enum_type_list[i].pet_dorange && 2604ded93414SHyon Kim topo_node_range_create(mod, pnode, 2605ded93414SHyon Kim phys_enum_type_list[i].pet_nodename, 0, 2606ded93414SHyon Kim mrange[i]) != 0) { 2607ded93414SHyon Kim topo_mod_dprintf(mod, 2608ded93414SHyon Kim "topo_node_create_range() failed: " 2609ded93414SHyon Kim "%s", topo_mod_errmsg(mod)); 2610ded93414SHyon Kim return (-1); 2611ded93414SHyon Kim } 2612ded93414SHyon Kim prevtype = phys_enum_type_list[i].pet_type; 2613ded93414SHyon Kim } 2614ded93414SHyon Kim 2615ded93414SHyon Kim if (!(child->spt_isfru)) { 2616ded93414SHyon Kim for (dirfru = parent; dirfru != NULL; 2617ded93414SHyon Kim dirfru = dirfru->spt_parent) { 2618ded93414SHyon Kim if (dirfru->spt_isfru) { 2619ded93414SHyon Kim break; 2620ded93414SHyon Kim } 2621ded93414SHyon Kim } 2622ded93414SHyon Kim /* found direct FRU node. */ 2623ded93414SHyon Kim if (dirfru) { 2624ded93414SHyon Kim frutn = dirfru->spt_tnode; 2625ded93414SHyon Kim } else { 2626ded93414SHyon Kim frutn = NULL; 2627ded93414SHyon Kim } 2628ded93414SHyon Kim } else { 2629ded93414SHyon Kim frutn = NULL; 2630ded93414SHyon Kim } 2631ded93414SHyon Kim 2632ded93414SHyon Kim if (ses_create_generic(sdp, child->spt_senumnode, 2633ded93414SHyon Kim pnode, frutn, phys_enum_type_list[i].pet_nodename, 2634ded93414SHyon Kim phys_enum_type_list[i].pet_defaultlabel, &tn) != 0) 2635ded93414SHyon Kim return (-1); 2636ded93414SHyon Kim 2637ded93414SHyon Kim child->spt_tnode = tn; 2638ded93414SHyon Kim /* 2639ded93414SHyon Kim * For some SES element there may be protocol specific 2640ded93414SHyon Kim * information to process. Here we are processing 2641ded93414SHyon Kim * the association between enclosure controller and 2642ded93414SHyon Kim * SAS expanders. 2643ded93414SHyon Kim */ 2644ded93414SHyon Kim if (phys_enum_type_list[i].pet_type == 2645ded93414SHyon Kim SES_ET_ESC_ELECTRONICS) { 2646ded93414SHyon Kim /* create SAS expander node */ 2647ded93414SHyon Kim if (ses_create_protocol_specific(sdp, 2648ded93414SHyon Kim child->spt_senumnode, tn, 2649ded93414SHyon Kim phys_enum_type_list[i].pet_type, 2650ded93414SHyon Kim cp, phys_enum_type_list[i].pet_dorange) != 2651ded93414SHyon Kim 0) { 2652ded93414SHyon Kim return (-1); 2653ded93414SHyon Kim } 2654ded93414SHyon Kim } 2655ded93414SHyon Kim } else { 2656ded93414SHyon Kim continue; 2657ded93414SHyon Kim } 2658ded93414SHyon Kim ret_ch = ses_enumerate_node(sdp, tn, cp, child, mrange); 2659ded93414SHyon Kim if (ret_ch) 2660ded93414SHyon Kim ret = ret_ch; /* there was an error and set the ret. */ 2661ded93414SHyon Kim } 2662ded93414SHyon Kim 2663ded93414SHyon Kim return (ret); 2664ded93414SHyon Kim } 2665ded93414SHyon Kim 2666ded93414SHyon Kim /* 2667ded93414SHyon Kim * Instantiate types of nodes that are specified in the hierarchy 2668ded93414SHyon Kim * element type list. 2669ded93414SHyon Kim */ 2670ded93414SHyon Kim static int 2671ded93414SHyon Kim ses_create_children_from_phys_tree(ses_enum_data_t *sdp, tnode_t *pnode, 2672ded93414SHyon Kim ses_enum_chassis_t *cp, ses_phys_tree_t *phys_tree) 2673ded93414SHyon Kim { 2674ded93414SHyon Kim topo_mod_t *mod = sdp->sed_mod; 2675ded93414SHyon Kim int mrange[N_PHYS_ENUM_TYPES] = { 0 }; 2676ded93414SHyon Kim ses_enum_node_t *snp; 2677ded93414SHyon Kim int i, ret; 2678ded93414SHyon Kim 2679ded93414SHyon Kim /* 2680ded93414SHyon Kim * First get max range for each type of element to be enumerated. 2681ded93414SHyon Kim */ 2682ded93414SHyon Kim for (i = 0; i < N_PHYS_ENUM_TYPES; i++) { 2683ded93414SHyon Kim if (phys_enum_type_list[i].pet_dorange) { 2684ded93414SHyon Kim for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2685ded93414SHyon Kim snp = topo_list_next(snp)) { 2686ded93414SHyon Kim if (snp->sen_type == 2687ded93414SHyon Kim phys_enum_type_list[i].pet_type) { 2688ded93414SHyon Kim if (snp->sen_instance > mrange[i]) 2689ded93414SHyon Kim mrange[i] = 2690ded93414SHyon Kim snp->sen_instance; 2691ded93414SHyon Kim } 2692ded93414SHyon Kim } 2693ded93414SHyon Kim } 2694ded93414SHyon Kim } 2695ded93414SHyon Kim 2696ded93414SHyon Kim topo_mod_dprintf(mod, "%s: creating nodes from FRU hierarchy tree.", 2697ded93414SHyon Kim cp->sec_csn); 2698ded93414SHyon Kim 2699ded93414SHyon Kim if ((ret = ses_enumerate_node(sdp, pnode, cp, phys_tree, mrange)) != 2700ded93414SHyon Kim 0) { 2701ded93414SHyon Kim topo_mod_dprintf(mod, 2702ded93414SHyon Kim "ses_create_children_from_phys_tree() failed: "); 2703ded93414SHyon Kim return (ret); 2704ded93414SHyon Kim } 2705ded93414SHyon Kim 2706ded93414SHyon Kim return (0); 2707ded93414SHyon Kim } 2708ded93414SHyon Kim 2709940d71d2Seschrock /* 2710940d71d2Seschrock * Instantiate a new chassis instance in the topology. 2711940d71d2Seschrock */ 2712940d71d2Seschrock static int 2713940d71d2Seschrock ses_create_chassis(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp) 2714940d71d2Seschrock { 2715940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 2716940d71d2Seschrock nvlist_t *props; 2717940d71d2Seschrock char *raw_manufacturer, *raw_model, *raw_revision; 2718940d71d2Seschrock char *manufacturer = NULL, *model = NULL, *product = NULL; 2719940d71d2Seschrock char *revision = NULL; 2720940d71d2Seschrock char *serial; 27216efb64caSEric Schrock char **paths; 2722940d71d2Seschrock size_t prodlen; 2723940d71d2Seschrock tnode_t *tn; 2724940d71d2Seschrock nvlist_t *fmri = NULL, *auth = NULL; 2725940d71d2Seschrock int ret = -1; 2726940d71d2Seschrock ses_enum_node_t *snp; 27276efb64caSEric Schrock ses_enum_target_t *stp; 272853dbcc59SSundeep Panicker ses_enum_chassis_t *scp; 27296efb64caSEric Schrock int i, err; 2730ded93414SHyon Kim uint64_t sc_count = 0, pindex; 2731ded93414SHyon Kim ses_phys_tree_t *sproot = NULL; 2732ded93414SHyon Kim hrtime_t start; 2733ded93414SHyon Kim hrtime_t end; 2734ded93414SHyon Kim double duration; 2735940d71d2Seschrock 2736d91236feSeschrock /* 2737d91236feSeschrock * Ignore any internal enclosures. 2738d91236feSeschrock */ 2739d91236feSeschrock if (cp->sec_internal) 2740d91236feSeschrock return (0); 2741d91236feSeschrock 2742940d71d2Seschrock /* 2743940d71d2Seschrock * Check to see if there are any devices presennt in the chassis. If 2744940d71d2Seschrock * not, ignore the chassis alltogether. This is most useful for 2745940d71d2Seschrock * ignoring internal HBAs that present a SES target but don't actually 2746940d71d2Seschrock * manage any of the devices. 2747940d71d2Seschrock */ 2748940d71d2Seschrock for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2749940d71d2Seschrock snp = topo_list_next(snp)) { 2750940d71d2Seschrock if (snp->sen_type == SES_ET_DEVICE || 2751940d71d2Seschrock snp->sen_type == SES_ET_ARRAY_DEVICE) 2752940d71d2Seschrock break; 2753940d71d2Seschrock } 2754940d71d2Seschrock 2755940d71d2Seschrock if (snp == NULL) 2756940d71d2Seschrock return (0); 2757940d71d2Seschrock 2758940d71d2Seschrock props = ses_node_props(cp->sec_enclosure); 2759940d71d2Seschrock 2760940d71d2Seschrock /* 2761940d71d2Seschrock * We use the following property mappings: 2762940d71d2Seschrock * 2763940d71d2Seschrock * manufacturer vendor-id 2764940d71d2Seschrock * model product-id 2765940d71d2Seschrock * serial-number libses-chassis-serial 2766940d71d2Seschrock */ 2767940d71d2Seschrock verify(nvlist_lookup_string(props, SES_EN_PROP_VID, 2768940d71d2Seschrock &raw_manufacturer) == 0); 2769940d71d2Seschrock verify(nvlist_lookup_string(props, SES_EN_PROP_PID, &raw_model) == 0); 2770940d71d2Seschrock verify(nvlist_lookup_string(props, SES_EN_PROP_REV, 2771940d71d2Seschrock &raw_revision) == 0); 2772940d71d2Seschrock verify(nvlist_lookup_string(props, LIBSES_EN_PROP_CSN, &serial) == 0); 2773940d71d2Seschrock 2774940d71d2Seschrock /* 2775940d71d2Seschrock * To construct the authority information, we 'clean' each string by 2776940d71d2Seschrock * removing any offensive characters and trimmming whitespace. For the 2777940d71d2Seschrock * 'product-id', we use a concatenation of 'manufacturer-model'. We 2778940d71d2Seschrock * also take the numerical serial number and convert it to a string. 2779940d71d2Seschrock */ 2780940d71d2Seschrock if ((manufacturer = disk_auth_clean(mod, raw_manufacturer)) == NULL || 2781940d71d2Seschrock (model = disk_auth_clean(mod, raw_model)) == NULL || 2782940d71d2Seschrock (revision = disk_auth_clean(mod, raw_revision)) == NULL) { 2783940d71d2Seschrock goto error; 2784940d71d2Seschrock } 2785940d71d2Seschrock 2786940d71d2Seschrock prodlen = strlen(manufacturer) + strlen(model) + 2; 2787940d71d2Seschrock if ((product = topo_mod_alloc(mod, prodlen)) == NULL) 2788940d71d2Seschrock goto error; 2789940d71d2Seschrock 2790940d71d2Seschrock (void) snprintf(product, prodlen, "%s-%s", manufacturer, model); 2791940d71d2Seschrock 2792940d71d2Seschrock /* 2793940d71d2Seschrock * Construct the topo node and bind it to our parent. 2794940d71d2Seschrock */ 2795940d71d2Seschrock if (topo_mod_nvalloc(mod, &auth, NV_UNIQUE_NAME) != 0) 2796940d71d2Seschrock goto error; 2797940d71d2Seschrock 2798940d71d2Seschrock if (nvlist_add_string(auth, FM_FMRI_AUTH_PRODUCT, product) != 0 || 2799940d71d2Seschrock nvlist_add_string(auth, FM_FMRI_AUTH_CHASSIS, serial) != 0) { 2800940d71d2Seschrock (void) topo_mod_seterrno(mod, EMOD_NVL_INVAL); 2801940d71d2Seschrock goto error; 2802940d71d2Seschrock } 2803940d71d2Seschrock 2804940d71d2Seschrock /* 2805940d71d2Seschrock * We pass NULL for the parent FMRI because there is no resource 2806940d71d2Seschrock * associated with it. For the toplevel enclosure, we leave the 2807940d71d2Seschrock * serial/part/revision portions empty, which are reserved for 2808940d71d2Seschrock * individual components within the chassis. 2809940d71d2Seschrock */ 2810940d71d2Seschrock if ((fmri = topo_mod_hcfmri(mod, NULL, FM_HC_SCHEME_VERSION, 2811940d71d2Seschrock SES_ENCLOSURE, cp->sec_instance, NULL, auth, 2812940d71d2Seschrock model, revision, serial)) == NULL) { 2813940d71d2Seschrock topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s", 2814940d71d2Seschrock topo_mod_errmsg(mod)); 2815940d71d2Seschrock goto error; 2816940d71d2Seschrock } 2817940d71d2Seschrock 2818940d71d2Seschrock if ((tn = topo_node_bind(mod, pnode, SES_ENCLOSURE, 2819940d71d2Seschrock cp->sec_instance, fmri)) == NULL) { 2820940d71d2Seschrock topo_mod_dprintf(mod, "topo_node_bind() failed: %s", 2821940d71d2Seschrock topo_mod_errmsg(mod)); 2822940d71d2Seschrock goto error; 2823940d71d2Seschrock } 2824940d71d2Seschrock 2825940d71d2Seschrock if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) { 2826940d71d2Seschrock topo_mod_dprintf(mod, 2827940d71d2Seschrock "topo_method_register() failed: %s", 2828940d71d2Seschrock topo_mod_errmsg(mod)); 2829940d71d2Seschrock goto error; 2830940d71d2Seschrock } 2831940d71d2Seschrock 2832ac88567aSHyon Kim if (ses_set_standard_props(mod, NULL, tn, auth, 2833940d71d2Seschrock ses_node_id(cp->sec_enclosure), cp->sec_target->set_devpath) != 0) 2834940d71d2Seschrock goto error; 2835940d71d2Seschrock 28366efb64caSEric Schrock /* 28376efb64caSEric Schrock * For enclosures, we want to include all possible targets (for upgrade 28386efb64caSEric Schrock * purposes). 28396efb64caSEric Schrock */ 28406efb64caSEric Schrock for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL; 28416efb64caSEric Schrock stp = topo_list_next(stp), i++) 28426efb64caSEric Schrock ; 28436efb64caSEric Schrock 28446efb64caSEric Schrock verify(i != 0); 28456efb64caSEric Schrock paths = alloca(i * sizeof (char *)); 28466efb64caSEric Schrock 28476efb64caSEric Schrock for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL; 28486efb64caSEric Schrock stp = topo_list_next(stp), i++) 28496efb64caSEric Schrock paths[i] = stp->set_devpath; 28506efb64caSEric Schrock 28516efb64caSEric Schrock 28526efb64caSEric Schrock if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES, 28536efb64caSEric Schrock TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths, 28546efb64caSEric Schrock i, &err) != 0) { 28556efb64caSEric Schrock topo_mod_dprintf(mod, 28566efb64caSEric Schrock "failed to create property %s: %s\n", 28576efb64caSEric Schrock TOPO_PROP_PATHS, topo_strerror(err)); 28586efb64caSEric Schrock goto error; 28596efb64caSEric Schrock } 28606efb64caSEric Schrock 2861ded93414SHyon Kim if (nvlist_lookup_uint64(props, 2862ded93414SHyon Kim LIBSES_PROP_PHYS_PARENT, &pindex) == 0) { 2863ded93414SHyon Kim start = gethrtime(); /* to mearusre performance */ 2864ded93414SHyon Kim /* 2865ded93414SHyon Kim * The enclosure is supported through SUNW,FRUID. 2866ded93414SHyon Kim * Need to enumerate the nodes through hierarchical order. 2867ded93414SHyon Kim */ 2868ded93414SHyon Kim if ((sproot = topo_mod_zalloc(mod, 2869ded93414SHyon Kim sizeof (ses_phys_tree_t))) == NULL) { 2870ded93414SHyon Kim topo_mod_dprintf(mod, 2871ded93414SHyon Kim "failed to allocate root: %s\n", 2872ded93414SHyon Kim topo_strerror(err)); 2873ded93414SHyon Kim goto error; 2874ded93414SHyon Kim } 2875ded93414SHyon Kim sproot->spt_pindex = pindex; 2876ded93414SHyon Kim if (nvlist_lookup_boolean_value(props, 2877ded93414SHyon Kim LIBSES_PROP_FRU, &sproot->spt_isfru) != 0) { 2878ded93414SHyon Kim topo_mod_dprintf(mod, 2879ded93414SHyon Kim "ses_create_chassis(): Failed to find prop %s " 2880ded93414SHyon Kim "on enclosure element (CSN %s).", 2881ded93414SHyon Kim LIBSES_PROP_FRU, cp->sec_csn); 2882ded93414SHyon Kim /* an enclosure should be a FRU. continue to process. */ 2883ded93414SHyon Kim sproot->spt_isfru = B_TRUE; 2884ded93414SHyon Kim } 2885ded93414SHyon Kim if (nvlist_lookup_uint64(props, 2886ded93414SHyon Kim SES_PROP_ELEMENT_ONLY_INDEX, 2887ded93414SHyon Kim &sproot->spt_eonlyindex) != 0) { 2888ded93414SHyon Kim topo_mod_dprintf(mod, 2889ded93414SHyon Kim "ses_create_chassis(): Failed to find prop %s " 2890ded93414SHyon Kim "on enclosure element (CSN %s).", 2891ded93414SHyon Kim LIBSES_PROP_PHYS_PARENT, cp->sec_csn); 2892ded93414SHyon Kim topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t)); 2893ded93414SHyon Kim goto error; 2894ded93414SHyon Kim } 2895ded93414SHyon Kim if (sproot->spt_pindex != sproot->spt_eonlyindex) { 2896ded93414SHyon Kim topo_mod_dprintf(mod, "ses_create_chassis(): " 2897ded93414SHyon Kim "Enclosure element(CSN %s) should have " 2898ded93414SHyon Kim "itself as the parent to be the root node " 2899ded93414SHyon Kim "of FRU hierarchical tree.)", cp->sec_csn); 2900ded93414SHyon Kim topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t)); 2901ded93414SHyon Kim goto error; 2902ded93414SHyon Kim } else { 2903ded93414SHyon Kim sproot->spt_snode = cp->sec_enclosure; 2904ded93414SHyon Kim sproot->spt_tnode = tn; 2905ded93414SHyon Kim /* construct a tree. */ 2906ded93414SHyon Kim if (ses_construct_phys_tree(sdp, cp, sproot) != 0) { 2907ded93414SHyon Kim topo_mod_dprintf(mod, "ses_create_chassis(): " 2908ded93414SHyon Kim "Failed to construct FRU hierarchical " 2909ded93414SHyon Kim "tree on enclosure (CSN %s.)", 2910ded93414SHyon Kim cp->sec_csn); 2911ded93414SHyon Kim } 2912ded93414SHyon Kim 2913ded93414SHyon Kim /* enumerate elements from the tree. */ 2914ded93414SHyon Kim if (ses_create_children_from_phys_tree(sdp, tn, cp, 2915ded93414SHyon Kim sproot) != 0) { 2916ded93414SHyon Kim topo_mod_dprintf(mod, "ses_create_chassis(): " 2917ded93414SHyon Kim "Failed to create children topo nodes out " 2918ded93414SHyon Kim "of FRU hierarchical tree on enclosure " 2919ded93414SHyon Kim "(CSN %s).", cp->sec_csn); 2920ded93414SHyon Kim } 2921ded93414SHyon Kim /* destroy the phys tree. */ 2922ded93414SHyon Kim ses_phys_tree_free(mod, sproot); 2923ded93414SHyon Kim } 2924ded93414SHyon Kim 2925ded93414SHyon Kim end = gethrtime(); 2926ded93414SHyon Kim duration = end - start; 2927ded93414SHyon Kim duration /= HR_SECOND; 2928ded93414SHyon Kim topo_mod_dprintf(mod, 2929ded93414SHyon Kim "FRU boundary tree based enumeration: %.6f seconds", 2930ded93414SHyon Kim duration); 2931ded93414SHyon Kim } else { 2932ded93414SHyon Kim /* 2933ded93414SHyon Kim * Create the nodes for power supplies, fans, controllers and 2934ded93414SHyon Kim * devices. Note that SAS exopander nodes and connector nodes 2935ded93414SHyon Kim * are handled through protocol specific processing of 2936ded93414SHyon Kim * controllers. 2937ded93414SHyon Kim */ 2938ded93414SHyon Kim if (ses_create_children(sdp, tn, SES_ET_POWER_SUPPLY, 2939ded93414SHyon Kim PSU, "PSU", cp, B_TRUE) != 0 || 2940ded93414SHyon Kim ses_create_children(sdp, tn, SES_ET_COOLING, 2941ded93414SHyon Kim FAN, "FAN", cp, B_TRUE) != 0 || 2942ded93414SHyon Kim ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS, 2943ded93414SHyon Kim CONTROLLER, "CONTROLLER", cp, B_TRUE) != 0 || 2944ded93414SHyon Kim ses_create_children(sdp, tn, SES_ET_DEVICE, 2945ded93414SHyon Kim BAY, "BAY", cp, B_TRUE) != 0 || 2946ded93414SHyon Kim ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE, 2947ded93414SHyon Kim BAY, "BAY", cp, B_TRUE) != 0) 2948ded93414SHyon Kim goto error; 2949ded93414SHyon Kim } 2950940d71d2Seschrock 2951ac88567aSHyon Kim if (cp->sec_maxinstance >= 0 && 2952ac88567aSHyon Kim (topo_node_range_create(mod, tn, SUBCHASSIS, 0, 2953ac88567aSHyon Kim cp->sec_maxinstance) != 0)) { 295453dbcc59SSundeep Panicker topo_mod_dprintf(mod, "topo_node_create_range() failed: %s", 295553dbcc59SSundeep Panicker topo_mod_errmsg(mod)); 295653dbcc59SSundeep Panicker goto error; 295753dbcc59SSundeep Panicker } 295853dbcc59SSundeep Panicker 295953dbcc59SSundeep Panicker for (scp = topo_list_next(&cp->sec_subchassis); scp != NULL; 296053dbcc59SSundeep Panicker scp = topo_list_next(scp)) { 296153dbcc59SSundeep Panicker 296253dbcc59SSundeep Panicker if (ses_create_subchassis(sdp, tn, scp) != 0) 296353dbcc59SSundeep Panicker goto error; 296453dbcc59SSundeep Panicker 296553dbcc59SSundeep Panicker topo_mod_dprintf(mod, "created Subchassis node with " 2966ac88567aSHyon Kim "instance %u\nand target (%s) under Chassis with CSN %s", 2967ac88567aSHyon Kim scp->sec_instance, scp->sec_target->set_devpath, 2968ac88567aSHyon Kim cp->sec_csn); 296953dbcc59SSundeep Panicker 297053dbcc59SSundeep Panicker sc_count++; 297153dbcc59SSundeep Panicker } 297253dbcc59SSundeep Panicker 297353dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: created %llu %s nodes", 297453dbcc59SSundeep Panicker cp->sec_csn, sc_count, SUBCHASSIS); 297553dbcc59SSundeep Panicker 29766efb64caSEric Schrock cp->sec_target->set_refcount++; 29776efb64caSEric Schrock topo_node_setspecific(tn, cp->sec_target); 2978d91236feSeschrock 2979940d71d2Seschrock ret = 0; 2980940d71d2Seschrock error: 2981940d71d2Seschrock topo_mod_strfree(mod, manufacturer); 2982940d71d2Seschrock topo_mod_strfree(mod, model); 2983940d71d2Seschrock topo_mod_strfree(mod, revision); 2984940d71d2Seschrock topo_mod_strfree(mod, product); 2985940d71d2Seschrock 2986940d71d2Seschrock nvlist_free(fmri); 2987940d71d2Seschrock nvlist_free(auth); 2988940d71d2Seschrock return (ret); 2989940d71d2Seschrock } 2990940d71d2Seschrock 2991d91236feSeschrock /* 2992d91236feSeschrock * Create a bay node explicitly enumerated via XML. 2993d91236feSeschrock */ 2994d91236feSeschrock static int 2995d91236feSeschrock ses_create_bays(ses_enum_data_t *sdp, tnode_t *pnode) 2996d91236feSeschrock { 2997d91236feSeschrock topo_mod_t *mod = sdp->sed_mod; 2998d91236feSeschrock ses_enum_chassis_t *cp; 2999d91236feSeschrock 3000d91236feSeschrock /* 3001d91236feSeschrock * Iterate over chassis looking for an internal enclosure. This 3002d91236feSeschrock * property is set via a vendor-specific plugin, and there should only 3003d91236feSeschrock * ever be a single internal chassis in a system. 3004d91236feSeschrock */ 3005d91236feSeschrock for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL; 3006d91236feSeschrock cp = topo_list_next(cp)) { 3007d91236feSeschrock if (cp->sec_internal) 3008d91236feSeschrock break; 3009d91236feSeschrock } 3010d91236feSeschrock 3011d91236feSeschrock if (cp == NULL) { 3012d91236feSeschrock topo_mod_dprintf(mod, "failed to find internal chassis\n"); 3013d91236feSeschrock return (-1); 3014d91236feSeschrock } 3015d91236feSeschrock 3016d91236feSeschrock if (ses_create_children(sdp, pnode, SES_ET_DEVICE, 3017d91236feSeschrock BAY, "BAY", cp, B_FALSE) != 0 || 3018d91236feSeschrock ses_create_children(sdp, pnode, SES_ET_ARRAY_DEVICE, 3019d91236feSeschrock BAY, "BAY", cp, B_FALSE) != 0) 3020d91236feSeschrock return (-1); 3021d91236feSeschrock 3022d91236feSeschrock return (0); 3023d91236feSeschrock } 302453dbcc59SSundeep Panicker 302553dbcc59SSundeep Panicker /* 302653dbcc59SSundeep Panicker * Initialize chassis or subchassis. 302753dbcc59SSundeep Panicker */ 302853dbcc59SSundeep Panicker static int 302953dbcc59SSundeep Panicker ses_init_chassis(topo_mod_t *mod, ses_enum_data_t *sdp, ses_enum_chassis_t *pcp, 303053dbcc59SSundeep Panicker ses_enum_chassis_t *cp, ses_node_t *np, nvlist_t *props, 3031ac88567aSHyon Kim uint64_t subchassis, ses_chassis_type_e flags) 303253dbcc59SSundeep Panicker { 303353dbcc59SSundeep Panicker boolean_t internal, ident; 303453dbcc59SSundeep Panicker 303553dbcc59SSundeep Panicker assert((flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS | 303653dbcc59SSundeep Panicker SES_DUP_CHASSIS | SES_DUP_SUBCHASSIS)) != 0); 303753dbcc59SSundeep Panicker 3038ac88567aSHyon Kim assert(cp != NULL); 3039ac88567aSHyon Kim assert(np != NULL); 3040ac88567aSHyon Kim assert(props != NULL); 304153dbcc59SSundeep Panicker 304253dbcc59SSundeep Panicker if (flags & (SES_NEW_SUBCHASSIS | SES_DUP_SUBCHASSIS)) 304353dbcc59SSundeep Panicker assert(pcp != NULL); 304453dbcc59SSundeep Panicker 3045ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_init_chassis: %s: index %llu, flags (%d)", 3046ac88567aSHyon Kim sdp->sed_name, subchassis, flags); 304753dbcc59SSundeep Panicker 304853dbcc59SSundeep Panicker if (flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS)) { 304953dbcc59SSundeep Panicker 305053dbcc59SSundeep Panicker topo_mod_dprintf(mod, "new chassis/subchassis"); 305153dbcc59SSundeep Panicker if (nvlist_lookup_boolean_value(props, 305253dbcc59SSundeep Panicker LIBSES_EN_PROP_INTERNAL, &internal) == 0) 305353dbcc59SSundeep Panicker cp->sec_internal = internal; 305453dbcc59SSundeep Panicker 305553dbcc59SSundeep Panicker cp->sec_enclosure = np; 305653dbcc59SSundeep Panicker cp->sec_target = sdp->sed_target; 305753dbcc59SSundeep Panicker 305853dbcc59SSundeep Panicker if (flags & SES_NEW_CHASSIS) { 3059ac88567aSHyon Kim if (!cp->sec_internal) 3060ac88567aSHyon Kim cp->sec_instance = sdp->sed_instance++; 306153dbcc59SSundeep Panicker topo_list_append(&sdp->sed_chassis, cp); 306253dbcc59SSundeep Panicker } else { 3063ac88567aSHyon Kim if (subchassis != NO_SUBCHASSIS) 3064ac88567aSHyon Kim cp->sec_instance = subchassis; 3065ac88567aSHyon Kim else 3066ac88567aSHyon Kim cp->sec_instance = pcp->sec_scinstance++; 3067ac88567aSHyon Kim 3068ac88567aSHyon Kim if (cp->sec_instance > pcp->sec_maxinstance) 3069ac88567aSHyon Kim pcp->sec_maxinstance = cp->sec_instance; 3070ac88567aSHyon Kim 307153dbcc59SSundeep Panicker topo_list_append(&pcp->sec_subchassis, cp); 307253dbcc59SSundeep Panicker } 307353dbcc59SSundeep Panicker 307453dbcc59SSundeep Panicker } else { 307553dbcc59SSundeep Panicker topo_mod_dprintf(mod, "dup chassis/subchassis"); 307653dbcc59SSundeep Panicker if (nvlist_lookup_boolean_value(props, 307753dbcc59SSundeep Panicker SES_PROP_IDENT, &ident) == 0) { 307853dbcc59SSundeep Panicker topo_mod_dprintf(mod, "overriding enclosure node"); 307953dbcc59SSundeep Panicker 308053dbcc59SSundeep Panicker cp->sec_enclosure = np; 308153dbcc59SSundeep Panicker cp->sec_target = sdp->sed_target; 308253dbcc59SSundeep Panicker } 308353dbcc59SSundeep Panicker } 308453dbcc59SSundeep Panicker 308553dbcc59SSundeep Panicker topo_list_append(&cp->sec_targets, sdp->sed_target); 308653dbcc59SSundeep Panicker sdp->sed_current = cp; 308753dbcc59SSundeep Panicker 308853dbcc59SSundeep Panicker return (0); 308953dbcc59SSundeep Panicker } 309053dbcc59SSundeep Panicker 3091940d71d2Seschrock /* 3092940d71d2Seschrock * Gather nodes from the current SES target into our chassis list, merging the 3093940d71d2Seschrock * results if necessary. 3094940d71d2Seschrock */ 3095940d71d2Seschrock static ses_walk_action_t 3096940d71d2Seschrock ses_enum_gather(ses_node_t *np, void *data) 3097940d71d2Seschrock { 3098940d71d2Seschrock nvlist_t *props = ses_node_props(np); 3099940d71d2Seschrock ses_enum_data_t *sdp = data; 3100940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 310153dbcc59SSundeep Panicker ses_enum_chassis_t *cp, *scp; 3102940d71d2Seschrock ses_enum_node_t *snp; 31030b32bb8bSEric Schrock ses_alt_node_t *sap; 3104940d71d2Seschrock char *csn; 3105940d71d2Seschrock uint64_t instance, type; 3106d91236feSeschrock uint64_t prevstatus, status; 310753dbcc59SSundeep Panicker boolean_t report; 3108ac88567aSHyon Kim uint64_t subchassis = NO_SUBCHASSIS; 3109940d71d2Seschrock 3110940d71d2Seschrock if (ses_node_type(np) == SES_NODE_ENCLOSURE) { 3111940d71d2Seschrock /* 3112940d71d2Seschrock * If we have already identified the chassis for this target, 3113940d71d2Seschrock * then this is a secondary enclosure and we should ignore it, 3114940d71d2Seschrock * along with the rest of the tree (since this is depth-first). 3115940d71d2Seschrock */ 3116940d71d2Seschrock if (sdp->sed_current != NULL) 3117940d71d2Seschrock return (SES_WALK_ACTION_TERMINATE); 3118940d71d2Seschrock 3119940d71d2Seschrock /* 3120940d71d2Seschrock * Go through the list of chassis we have seen so far and see 3121940d71d2Seschrock * if this serial number matches one of the known values. 312253dbcc59SSundeep Panicker * If so, check whether this enclosure is a subchassis. 3123940d71d2Seschrock */ 3124940d71d2Seschrock if (nvlist_lookup_string(props, LIBSES_EN_PROP_CSN, 3125940d71d2Seschrock &csn) != 0) 3126940d71d2Seschrock return (SES_WALK_ACTION_TERMINATE); 3127940d71d2Seschrock 3128ac88567aSHyon Kim (void) nvlist_lookup_uint64(props, LIBSES_EN_PROP_SUBCHASSIS_ID, 3129ac88567aSHyon Kim &subchassis); 313053dbcc59SSundeep Panicker 313153dbcc59SSundeep Panicker topo_mod_dprintf(mod, "ses_enum_gather: Enclosure Node (%s) " 3132ac88567aSHyon Kim "CSN (%s), subchassis (%llu)", sdp->sed_name, csn, 3133ac88567aSHyon Kim subchassis); 313453dbcc59SSundeep Panicker 313553dbcc59SSundeep Panicker /* 313653dbcc59SSundeep Panicker * We need to determine whether this enclosure node 313753dbcc59SSundeep Panicker * represents a chassis or a subchassis. Since we may 313853dbcc59SSundeep Panicker * receive the enclosure nodes in a non-deterministic 313953dbcc59SSundeep Panicker * manner, we need to account for all possible combinations: 314053dbcc59SSundeep Panicker * 1. Chassis for the current CSN has not yet been 314153dbcc59SSundeep Panicker * allocated 314253dbcc59SSundeep Panicker * 1.1 This is a new chassis: 314353dbcc59SSundeep Panicker * allocate and instantiate the chassis 314453dbcc59SSundeep Panicker * 1.2 This is a new subchassis: 314553dbcc59SSundeep Panicker * allocate a placeholder chassis 314653dbcc59SSundeep Panicker * allocate and instantiate the subchassis 314753dbcc59SSundeep Panicker * link the subchassis to the chassis 314853dbcc59SSundeep Panicker * 2. Chassis for the current CSN has been allocated 314953dbcc59SSundeep Panicker * 2.1 This is a duplicate chassis enclosure 315053dbcc59SSundeep Panicker * check whether to override old chassis 315153dbcc59SSundeep Panicker * append to chassis' target list 315253dbcc59SSundeep Panicker * 2.2 Only placeholder chassis exists 315353dbcc59SSundeep Panicker * fill in the chassis fields 315453dbcc59SSundeep Panicker * 2.3 This is a new subchassis 315553dbcc59SSundeep Panicker * allocate and instantiate the subchassis 315653dbcc59SSundeep Panicker * link the subchassis to the chassis 315753dbcc59SSundeep Panicker * 2.4 This is a duplicate subchassis enclosure 315853dbcc59SSundeep Panicker * check whether to override old chassis 315953dbcc59SSundeep Panicker * append to chassis' target list 316053dbcc59SSundeep Panicker */ 316153dbcc59SSundeep Panicker 3162940d71d2Seschrock for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL; 316353dbcc59SSundeep Panicker cp = topo_list_next(cp)) 316453dbcc59SSundeep Panicker if (strcmp(cp->sec_csn, csn) == 0) 3165940d71d2Seschrock break; 3166940d71d2Seschrock 3167940d71d2Seschrock if (cp == NULL) { 316853dbcc59SSundeep Panicker /* 1. Haven't seen a chassis with this CSN before */ 3169940d71d2Seschrock 3170940d71d2Seschrock if ((cp = topo_mod_zalloc(mod, 3171940d71d2Seschrock sizeof (ses_enum_chassis_t))) == NULL) 3172940d71d2Seschrock goto error; 3173940d71d2Seschrock 3174ac88567aSHyon Kim cp->sec_scinstance = SES_STARTING_SUBCHASSIS; 3175ac88567aSHyon Kim cp->sec_maxinstance = -1; 3176940d71d2Seschrock cp->sec_csn = csn; 317753dbcc59SSundeep Panicker 3178ac88567aSHyon Kim if (subchassis == NO_SUBCHASSIS) { 317953dbcc59SSundeep Panicker /* 1.1 This is a new chassis */ 318053dbcc59SSundeep Panicker 318153dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Initialize new " 3182ac88567aSHyon Kim "chassis with CSN %s", sdp->sed_name, csn); 318353dbcc59SSundeep Panicker 318453dbcc59SSundeep Panicker if (ses_init_chassis(mod, sdp, NULL, cp, 3185ac88567aSHyon Kim np, props, NO_SUBCHASSIS, 3186ac88567aSHyon Kim SES_NEW_CHASSIS) < 0) 318753dbcc59SSundeep Panicker goto error; 318853dbcc59SSundeep Panicker } else { 318953dbcc59SSundeep Panicker /* 1.2 This is a new subchassis */ 319053dbcc59SSundeep Panicker 319153dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Initialize new " 3192ac88567aSHyon Kim "subchassis with CSN %s and index %llu", 3193ac88567aSHyon Kim sdp->sed_name, csn, subchassis); 319453dbcc59SSundeep Panicker 319553dbcc59SSundeep Panicker if ((scp = topo_mod_zalloc(mod, 319653dbcc59SSundeep Panicker sizeof (ses_enum_chassis_t))) == NULL) 319753dbcc59SSundeep Panicker goto error; 319853dbcc59SSundeep Panicker 319953dbcc59SSundeep Panicker scp->sec_csn = csn; 320053dbcc59SSundeep Panicker 3201ac88567aSHyon Kim if (ses_init_chassis(mod, sdp, cp, scp, np, 3202ac88567aSHyon Kim props, subchassis, SES_NEW_SUBCHASSIS) < 0) 320353dbcc59SSundeep Panicker goto error; 320453dbcc59SSundeep Panicker } 32056efb64caSEric Schrock } else { 3206ac88567aSHyon Kim /* 3207ac88567aSHyon Kim * We have a chassis or subchassis with this CSN. If 3208ac88567aSHyon Kim * it's a chassis, we must check to see whether it is 3209ac88567aSHyon Kim * a placeholder previously created because we found a 3210ac88567aSHyon Kim * subchassis with this CSN. We will know that because 3211ac88567aSHyon Kim * the sec_target value will not be set; it is set only 3212ac88567aSHyon Kim * in ses_init_chassis(). In that case, initialise it 3213ac88567aSHyon Kim * as a new chassis; otherwise, it's a duplicate and we 3214ac88567aSHyon Kim * need to append only. 3215ac88567aSHyon Kim */ 3216ac88567aSHyon Kim if (subchassis == NO_SUBCHASSIS) { 3217ac88567aSHyon Kim if (cp->sec_target != NULL) { 321853dbcc59SSundeep Panicker /* 2.1 This is a duplicate chassis */ 321953dbcc59SSundeep Panicker 322053dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Append " 3221ac88567aSHyon Kim "duplicate chassis with CSN (%s)", 3222ac88567aSHyon Kim sdp->sed_name, csn); 322353dbcc59SSundeep Panicker 322453dbcc59SSundeep Panicker if (ses_init_chassis(mod, sdp, NULL, cp, 3225ac88567aSHyon Kim np, props, NO_SUBCHASSIS, 322653dbcc59SSundeep Panicker SES_DUP_CHASSIS) < 0) 322753dbcc59SSundeep Panicker goto error; 322853dbcc59SSundeep Panicker } else { 3229ac88567aSHyon Kim /* Placeholder chassis - init it up */ 323053dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Initialize" 3231ac88567aSHyon Kim "placeholder chassis with CSN %s", 3232ac88567aSHyon Kim sdp->sed_name, csn); 323353dbcc59SSundeep Panicker 3234ac88567aSHyon Kim if (ses_init_chassis(mod, sdp, NULL, 3235ac88567aSHyon Kim cp, np, props, NO_SUBCHASSIS, 323653dbcc59SSundeep Panicker SES_NEW_CHASSIS) < 0) 323753dbcc59SSundeep Panicker goto error; 323853dbcc59SSundeep Panicker 323953dbcc59SSundeep Panicker } 324053dbcc59SSundeep Panicker } else { 324153dbcc59SSundeep Panicker /* This is a subchassis */ 324253dbcc59SSundeep Panicker 324353dbcc59SSundeep Panicker for (scp = topo_list_next(&cp->sec_subchassis); 324453dbcc59SSundeep Panicker scp != NULL; scp = topo_list_next(scp)) 3245ac88567aSHyon Kim if (scp->sec_instance == subchassis) 324653dbcc59SSundeep Panicker break; 324753dbcc59SSundeep Panicker 324853dbcc59SSundeep Panicker if (scp == NULL) { 324953dbcc59SSundeep Panicker /* 2.3 This is a new subchassis */ 325053dbcc59SSundeep Panicker 325153dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Initialize " 325253dbcc59SSundeep Panicker "new subchassis with CSN (%s) " 325353dbcc59SSundeep Panicker "and LID (%s)", 3254ac88567aSHyon Kim sdp->sed_name, csn); 325553dbcc59SSundeep Panicker 325653dbcc59SSundeep Panicker if ((scp = topo_mod_zalloc(mod, 325753dbcc59SSundeep Panicker sizeof (ses_enum_chassis_t))) 325853dbcc59SSundeep Panicker == NULL) 325953dbcc59SSundeep Panicker goto error; 326053dbcc59SSundeep Panicker 326153dbcc59SSundeep Panicker scp->sec_csn = csn; 326253dbcc59SSundeep Panicker 326353dbcc59SSundeep Panicker if (ses_init_chassis(mod, sdp, cp, scp, 3264ac88567aSHyon Kim np, props, subchassis, 326553dbcc59SSundeep Panicker SES_NEW_SUBCHASSIS) < 0) 326653dbcc59SSundeep Panicker goto error; 326753dbcc59SSundeep Panicker } else { 326853dbcc59SSundeep Panicker /* 2.4 This is a duplicate subchassis */ 326953dbcc59SSundeep Panicker 327053dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Append " 327153dbcc59SSundeep Panicker "duplicate subchassis with " 3272ac88567aSHyon Kim "CSN (%s)", sdp->sed_name, csn); 327353dbcc59SSundeep Panicker 327453dbcc59SSundeep Panicker if (ses_init_chassis(mod, sdp, cp, scp, 3275ac88567aSHyon Kim np, props, subchassis, 327653dbcc59SSundeep Panicker SES_DUP_SUBCHASSIS) < 0) 327753dbcc59SSundeep Panicker goto error; 327853dbcc59SSundeep Panicker } 32796efb64caSEric Schrock } 3280940d71d2Seschrock } 3281940d71d2Seschrock } else if (ses_node_type(np) == SES_NODE_ELEMENT) { 3282940d71d2Seschrock /* 3283940d71d2Seschrock * If we haven't yet seen an enclosure node and identified the 3284940d71d2Seschrock * current chassis, something is very wrong; bail out. 3285940d71d2Seschrock */ 3286940d71d2Seschrock if (sdp->sed_current == NULL) 3287940d71d2Seschrock return (SES_WALK_ACTION_TERMINATE); 3288940d71d2Seschrock 3289940d71d2Seschrock /* 3290940d71d2Seschrock * If this isn't one of the element types we care about, then 3291940d71d2Seschrock * ignore it. 3292940d71d2Seschrock */ 3293940d71d2Seschrock verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_TYPE, 3294940d71d2Seschrock &type) == 0); 3295940d71d2Seschrock if (type != SES_ET_DEVICE && 3296940d71d2Seschrock type != SES_ET_ARRAY_DEVICE && 3297ded93414SHyon Kim type != SES_ET_SUNW_FANBOARD && 3298ded93414SHyon Kim type != SES_ET_SUNW_FANMODULE && 3299940d71d2Seschrock type != SES_ET_COOLING && 3300ded93414SHyon Kim type != SES_ET_SUNW_POWERBOARD && 3301ded93414SHyon Kim type != SES_ET_SUNW_POWERMODULE && 3302940d71d2Seschrock type != SES_ET_POWER_SUPPLY && 3303ac88567aSHyon Kim type != SES_ET_ESC_ELECTRONICS && 3304ac88567aSHyon Kim type != SES_ET_SAS_EXPANDER && 3305ac88567aSHyon Kim type != SES_ET_SAS_CONNECTOR) 3306940d71d2Seschrock return (SES_WALK_ACTION_CONTINUE); 3307940d71d2Seschrock 3308940d71d2Seschrock /* 3309940d71d2Seschrock * Get the current instance number and see if we already know 3310940d71d2Seschrock * about this element. If so, it means we have multiple paths 3311940d71d2Seschrock * to the same elements, and we should ignore the current path. 3312940d71d2Seschrock */ 3313940d71d2Seschrock verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_CLASS_INDEX, 3314940d71d2Seschrock &instance) == 0); 3315940d71d2Seschrock if (type == SES_ET_DEVICE || type == SES_ET_ARRAY_DEVICE) 3316940d71d2Seschrock (void) nvlist_lookup_uint64(props, SES_PROP_BAY_NUMBER, 3317940d71d2Seschrock &instance); 3318940d71d2Seschrock 3319940d71d2Seschrock cp = sdp->sed_current; 3320940d71d2Seschrock 3321940d71d2Seschrock for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 3322940d71d2Seschrock snp = topo_list_next(snp)) { 3323940d71d2Seschrock if (snp->sen_type == type && 3324940d71d2Seschrock snp->sen_instance == instance) 3325d91236feSeschrock break; 3326d91236feSeschrock } 3327d91236feSeschrock 3328d91236feSeschrock /* 3329d91236feSeschrock * We prefer the new element under the following circumstances: 3330d91236feSeschrock * 3331d91236feSeschrock * - The currently known element's status is unknown or not 3332d91236feSeschrock * available, but the new element has a known status. This 3333d91236feSeschrock * occurs if a given element is only available through a 3334d91236feSeschrock * particular target. 3335d91236feSeschrock * 3336d91236feSeschrock * - This is an ESC_ELECTRONICS element, and the 'reported-via' 3337d91236feSeschrock * property is set. This allows us to get reliable firmware 3338d91236feSeschrock * revision information from the enclosure node. 3339d91236feSeschrock */ 3340d91236feSeschrock if (snp != NULL) { 3341d91236feSeschrock if (nvlist_lookup_uint64( 3342d91236feSeschrock ses_node_props(snp->sen_node), 3343d91236feSeschrock SES_PROP_STATUS_CODE, &prevstatus) != 0) 3344d91236feSeschrock prevstatus = SES_ESC_UNSUPPORTED; 3345d91236feSeschrock if (nvlist_lookup_uint64( 3346d91236feSeschrock props, SES_PROP_STATUS_CODE, &status) != 0) 3347d91236feSeschrock status = SES_ESC_UNSUPPORTED; 3348d91236feSeschrock if (nvlist_lookup_boolean_value( 3349d91236feSeschrock props, SES_PROP_REPORT, &report) != 0) 3350d91236feSeschrock report = B_FALSE; 3351d91236feSeschrock 3352d91236feSeschrock if ((SES_STATUS_UNAVAIL(prevstatus) && 3353d91236feSeschrock !SES_STATUS_UNAVAIL(status)) || 3354d91236feSeschrock (type == SES_ET_ESC_ELECTRONICS && 3355d91236feSeschrock report)) { 3356d91236feSeschrock snp->sen_node = np; 3357d91236feSeschrock snp->sen_target = sdp->sed_target; 3358d91236feSeschrock } 3359d91236feSeschrock 33600b32bb8bSEric Schrock if ((sap = topo_mod_zalloc(mod, 33610b32bb8bSEric Schrock sizeof (ses_alt_node_t))) == NULL) 33620b32bb8bSEric Schrock goto error; 33630b32bb8bSEric Schrock 33640b32bb8bSEric Schrock sap->san_node = np; 33650b32bb8bSEric Schrock topo_list_append(&snp->sen_alt_nodes, sap); 33660b32bb8bSEric Schrock 3367d91236feSeschrock return (SES_WALK_ACTION_CONTINUE); 3368940d71d2Seschrock } 3369940d71d2Seschrock 3370940d71d2Seschrock if ((snp = topo_mod_zalloc(mod, 3371940d71d2Seschrock sizeof (ses_enum_node_t))) == NULL) 3372940d71d2Seschrock goto error; 3373940d71d2Seschrock 33740b32bb8bSEric Schrock if ((sap = topo_mod_zalloc(mod, 33750b32bb8bSEric Schrock sizeof (ses_alt_node_t))) == NULL) { 33760b32bb8bSEric Schrock topo_mod_free(mod, snp, sizeof (ses_enum_node_t)); 33770b32bb8bSEric Schrock goto error; 33780b32bb8bSEric Schrock } 33790b32bb8bSEric Schrock 3380940d71d2Seschrock topo_mod_dprintf(mod, "%s: adding node (%llu, %llu)", 3381940d71d2Seschrock sdp->sed_name, type, instance); 3382940d71d2Seschrock snp->sen_node = np; 3383940d71d2Seschrock snp->sen_type = type; 3384940d71d2Seschrock snp->sen_instance = instance; 3385940d71d2Seschrock snp->sen_target = sdp->sed_target; 33860b32bb8bSEric Schrock sap->san_node = np; 33870b32bb8bSEric Schrock topo_list_append(&snp->sen_alt_nodes, sap); 3388940d71d2Seschrock topo_list_append(&cp->sec_nodes, snp); 3389940d71d2Seschrock 3390940d71d2Seschrock if (type == SES_ET_DEVICE) 3391940d71d2Seschrock cp->sec_hasdev = B_TRUE; 3392940d71d2Seschrock } 3393940d71d2Seschrock 3394940d71d2Seschrock return (SES_WALK_ACTION_CONTINUE); 3395940d71d2Seschrock 3396940d71d2Seschrock error: 3397940d71d2Seschrock sdp->sed_errno = -1; 3398940d71d2Seschrock return (SES_WALK_ACTION_TERMINATE); 3399940d71d2Seschrock } 3400940d71d2Seschrock 3401940d71d2Seschrock static int 3402940d71d2Seschrock ses_process_dir(const char *dirpath, ses_enum_data_t *sdp) 3403940d71d2Seschrock { 3404940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 3405940d71d2Seschrock DIR *dir; 3406940d71d2Seschrock struct dirent *dp; 3407940d71d2Seschrock char path[PATH_MAX]; 3408940d71d2Seschrock ses_enum_target_t *stp; 3409940d71d2Seschrock int err = -1; 3410940d71d2Seschrock 3411940d71d2Seschrock /* 3412940d71d2Seschrock * Open the SES target directory and iterate over any available 3413940d71d2Seschrock * targets. 3414940d71d2Seschrock */ 3415940d71d2Seschrock if ((dir = opendir(dirpath)) == NULL) { 3416940d71d2Seschrock /* 3417940d71d2Seschrock * If the SES target directory does not exist, then return as if 3418940d71d2Seschrock * there are no active targets. 3419940d71d2Seschrock */ 3420940d71d2Seschrock topo_mod_dprintf(mod, "failed to open ses " 3421940d71d2Seschrock "directory '%s'", dirpath); 3422940d71d2Seschrock return (0); 3423940d71d2Seschrock } 3424940d71d2Seschrock 3425940d71d2Seschrock while ((dp = readdir(dir)) != NULL) { 3426940d71d2Seschrock if (strcmp(dp->d_name, ".") == 0 || 3427940d71d2Seschrock strcmp(dp->d_name, "..") == 0) 3428940d71d2Seschrock continue; 3429940d71d2Seschrock 3430940d71d2Seschrock /* 3431940d71d2Seschrock * Create a new target instance and take a snapshot. 3432940d71d2Seschrock */ 3433940d71d2Seschrock if ((stp = topo_mod_zalloc(mod, 3434940d71d2Seschrock sizeof (ses_enum_target_t))) == NULL) 3435940d71d2Seschrock goto error; 3436940d71d2Seschrock 34370b32bb8bSEric Schrock (void) pthread_mutex_init(&stp->set_lock, NULL); 34380b32bb8bSEric Schrock 3439940d71d2Seschrock (void) snprintf(path, sizeof (path), "%s/%s", dirpath, 3440940d71d2Seschrock dp->d_name); 3441940d71d2Seschrock 3442940d71d2Seschrock /* 3443940d71d2Seschrock * We keep track of the SES device path and export it on a 3444940d71d2Seschrock * per-node basis to allow higher level software to get to the 3445940d71d2Seschrock * corresponding SES state. 3446940d71d2Seschrock */ 3447940d71d2Seschrock if ((stp->set_devpath = topo_mod_strdup(mod, path)) == NULL) { 3448940d71d2Seschrock topo_mod_free(mod, stp, sizeof (ses_enum_target_t)); 3449940d71d2Seschrock goto error; 3450940d71d2Seschrock } 3451940d71d2Seschrock 3452940d71d2Seschrock if ((stp->set_target = 3453940d71d2Seschrock ses_open(LIBSES_VERSION, path)) == NULL) { 3454940d71d2Seschrock topo_mod_dprintf(mod, "failed to open ses target " 3455940d71d2Seschrock "'%s': %s", dp->d_name, ses_errmsg()); 3456f76de749SStephen Hanson ses_sof_alloc(mod, stp->set_devpath); 3457940d71d2Seschrock topo_mod_free(mod, stp, sizeof (ses_enum_target_t)); 3458940d71d2Seschrock continue; 3459940d71d2Seschrock } 3460f76de749SStephen Hanson topo_mod_dprintf(mod, "open contract"); 3461f76de749SStephen Hanson ses_ssl_alloc(mod, stp); 3462f76de749SStephen Hanson ses_create_contract(mod, stp); 3463940d71d2Seschrock 3464940d71d2Seschrock stp->set_refcount = 1; 3465940d71d2Seschrock sdp->sed_target = stp; 3466940d71d2Seschrock stp->set_snap = ses_snap_hold(stp->set_target); 3467525b85dbSEric Schrock stp->set_snaptime = gethrtime(); 3468940d71d2Seschrock 3469940d71d2Seschrock /* 3470940d71d2Seschrock * Enumerate over all SES elements and merge them into the 3471940d71d2Seschrock * correct ses_enum_chassis_t. 3472940d71d2Seschrock */ 3473940d71d2Seschrock sdp->sed_current = NULL; 3474940d71d2Seschrock sdp->sed_errno = 0; 3475940d71d2Seschrock sdp->sed_name = dp->d_name; 3476940d71d2Seschrock (void) ses_walk(stp->set_snap, ses_enum_gather, sdp); 3477940d71d2Seschrock 3478940d71d2Seschrock if (sdp->sed_errno != 0) 3479940d71d2Seschrock goto error; 3480940d71d2Seschrock } 3481940d71d2Seschrock 3482940d71d2Seschrock err = 0; 3483940d71d2Seschrock error: 3484edb433b6SMilan Jurik (void) closedir(dir); 3485940d71d2Seschrock return (err); 3486940d71d2Seschrock } 3487940d71d2Seschrock 3488940d71d2Seschrock static void 3489940d71d2Seschrock ses_release(topo_mod_t *mod, tnode_t *tn) 3490940d71d2Seschrock { 3491940d71d2Seschrock ses_enum_target_t *stp; 3492940d71d2Seschrock 3493f76de749SStephen Hanson if ((stp = topo_node_getspecific(tn)) != NULL) { 3494f76de749SStephen Hanson topo_node_setspecific(tn, NULL); 3495940d71d2Seschrock ses_target_free(mod, stp); 3496f76de749SStephen Hanson } 3497940d71d2Seschrock } 3498940d71d2Seschrock 3499940d71d2Seschrock /*ARGSUSED*/ 3500940d71d2Seschrock static int 3501940d71d2Seschrock ses_enum(topo_mod_t *mod, tnode_t *rnode, const char *name, 3502940d71d2Seschrock topo_instance_t min, topo_instance_t max, void *arg, void *notused) 3503940d71d2Seschrock { 3504940d71d2Seschrock ses_enum_chassis_t *cp; 3505d91236feSeschrock ses_enum_data_t *data; 3506940d71d2Seschrock 3507940d71d2Seschrock /* 3508940d71d2Seschrock * Check to make sure we're being invoked sensibly, and that we're not 3509940d71d2Seschrock * being invoked as part of a post-processing step. 3510940d71d2Seschrock */ 3511d91236feSeschrock if (strcmp(name, SES_ENCLOSURE) != 0 && strcmp(name, BAY) != 0) 3512940d71d2Seschrock return (0); 3513940d71d2Seschrock 3514940d71d2Seschrock /* 3515d91236feSeschrock * If this is the first time we've called our enumeration method, then 3516d91236feSeschrock * gather information about any available enclosures. 3517940d71d2Seschrock */ 3518d91236feSeschrock if ((data = topo_mod_getspecific(mod)) == NULL) { 3519f76de749SStephen Hanson ses_sof_freeall(mod); 3520d91236feSeschrock if ((data = topo_mod_zalloc(mod, sizeof (ses_enum_data_t))) == 3521d91236feSeschrock NULL) 3522d91236feSeschrock return (-1); 3523940d71d2Seschrock 3524d91236feSeschrock data->sed_mod = mod; 3525d91236feSeschrock topo_mod_setspecific(mod, data); 3526d91236feSeschrock 3527ac88567aSHyon Kim if (dev_list_gather(mod, &data->sed_devs) != 0) 3528d91236feSeschrock goto error; 3529d91236feSeschrock 3530d91236feSeschrock /* 3531d91236feSeschrock * We search both the ses(7D) and sgen(7D) locations, so we are 3532d91236feSeschrock * independent of any particular driver class bindings. 3533d91236feSeschrock */ 3534d91236feSeschrock if (ses_process_dir("/dev/es", data) != 0 || 3535d91236feSeschrock ses_process_dir("/dev/scsi/ses", data) != 0) 3536d91236feSeschrock goto error; 3537d91236feSeschrock } 3538d91236feSeschrock 3539d91236feSeschrock if (strcmp(name, SES_ENCLOSURE) == 0) { 3540d91236feSeschrock /* 3541d91236feSeschrock * This is a request to enumerate external enclosures. Go 3542d91236feSeschrock * through all the targets and create chassis nodes where 3543d91236feSeschrock * necessary. 3544d91236feSeschrock */ 3545d91236feSeschrock for (cp = topo_list_next(&data->sed_chassis); cp != NULL; 3546d91236feSeschrock cp = topo_list_next(cp)) { 3547d91236feSeschrock if (ses_create_chassis(data, rnode, cp) != 0) 3548d91236feSeschrock goto error; 3549d91236feSeschrock } 3550d91236feSeschrock } else { 3551d91236feSeschrock /* 3552d91236feSeschrock * This is a request to enumerate a specific bay underneath the 3553d91236feSeschrock * root chassis (for internal disks). 3554d91236feSeschrock */ 3555d91236feSeschrock if (ses_create_bays(data, rnode) != 0) 3556940d71d2Seschrock goto error; 3557940d71d2Seschrock } 3558940d71d2Seschrock 3559d91236feSeschrock /* 3560d91236feSeschrock * This is a bit of a kludge. In order to allow internal disks to be 3561d91236feSeschrock * enumerated and share snapshot-specific information with the external 3562d91236feSeschrock * enclosure enumeration, we rely on the fact that we will be invoked 3563d91236feSeschrock * for the 'ses-enclosure' node last. 3564d91236feSeschrock */ 3565d91236feSeschrock if (strcmp(name, SES_ENCLOSURE) == 0) { 356653dbcc59SSundeep Panicker for (cp = topo_list_next(&data->sed_chassis); cp != NULL; 356753dbcc59SSundeep Panicker cp = topo_list_next(cp)) 356853dbcc59SSundeep Panicker ses_data_free(data, cp); 356953dbcc59SSundeep Panicker ses_data_free(data, NULL); 3570d91236feSeschrock topo_mod_setspecific(mod, NULL); 3571d91236feSeschrock } 3572940d71d2Seschrock return (0); 3573940d71d2Seschrock 3574940d71d2Seschrock error: 357553dbcc59SSundeep Panicker for (cp = topo_list_next(&data->sed_chassis); cp != NULL; 357653dbcc59SSundeep Panicker cp = topo_list_next(cp)) 357753dbcc59SSundeep Panicker ses_data_free(data, cp); 357853dbcc59SSundeep Panicker ses_data_free(data, NULL); 3579d91236feSeschrock topo_mod_setspecific(mod, NULL); 3580940d71d2Seschrock return (-1); 3581940d71d2Seschrock } 3582940d71d2Seschrock 3583940d71d2Seschrock static const topo_modops_t ses_ops = 3584940d71d2Seschrock { ses_enum, ses_release }; 3585940d71d2Seschrock 3586940d71d2Seschrock static topo_modinfo_t ses_info = 3587940d71d2Seschrock { SES_ENCLOSURE, FM_FMRI_SCHEME_HC, SES_VERSION, &ses_ops }; 3588940d71d2Seschrock 3589940d71d2Seschrock /*ARGSUSED*/ 3590940d71d2Seschrock int 3591940d71d2Seschrock _topo_init(topo_mod_t *mod, topo_version_t version) 3592940d71d2Seschrock { 3593f76de749SStephen Hanson int rval; 3594f76de749SStephen Hanson 3595940d71d2Seschrock if (getenv("TOPOSESDEBUG") != NULL) 3596940d71d2Seschrock topo_mod_setdebug(mod); 3597940d71d2Seschrock 3598940d71d2Seschrock topo_mod_dprintf(mod, "initializing %s enumerator\n", 3599940d71d2Seschrock SES_ENCLOSURE); 3600940d71d2Seschrock 3601f76de749SStephen Hanson if ((rval = topo_mod_register(mod, &ses_info, TOPO_VERSION)) == 0) 3602f76de749SStephen Hanson ses_thread_init(mod); 3603f76de749SStephen Hanson 3604f76de749SStephen Hanson return (rval); 3605940d71d2Seschrock } 3606940d71d2Seschrock 3607940d71d2Seschrock void 3608940d71d2Seschrock _topo_fini(topo_mod_t *mod) 3609940d71d2Seschrock { 361005b58617SStephen Hanson ses_thread_fini(mod); 3611f76de749SStephen Hanson ses_sof_freeall(mod); 3612940d71d2Seschrock topo_mod_unregister(mod); 3613940d71d2Seschrock } 3614