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. 25057c620aSHans Rosenfeld * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 26*317c37f3SRob Johnston * Copyright (c) 2020, Joyent, Inc. 27940d71d2Seschrock */ 28940d71d2Seschrock 296efb64caSEric Schrock #include <alloca.h> 30940d71d2Seschrock #include <dirent.h> 31940d71d2Seschrock #include <devid.h> 32940d71d2Seschrock #include <fm/libdiskstatus.h> 33940d71d2Seschrock #include <inttypes.h> 34940d71d2Seschrock #include <pthread.h> 35940d71d2Seschrock #include <strings.h> 36ac88567aSHyon Kim #include <string.h> 37940d71d2Seschrock #include <unistd.h> 38940d71d2Seschrock #include <sys/dkio.h> 39940d71d2Seschrock #include <sys/fm/protocol.h> 4044ed9dbbSStephen Hanson #include <sys/libdevid.h> 41940d71d2Seschrock #include <sys/scsi/scsi_types.h> 42ac88567aSHyon Kim #include <sys/byteorder.h> 43f76de749SStephen Hanson #include <pthread.h> 44f76de749SStephen Hanson #include <signal.h> 45f76de749SStephen Hanson #include <fcntl.h> 46f76de749SStephen Hanson #include <sys/ctfs.h> 47f76de749SStephen Hanson #include <libcontract.h> 48f76de749SStephen Hanson #include <poll.h> 49f76de749SStephen Hanson #include <sys/contract/device.h> 50f76de749SStephen Hanson #include <libsysevent.h> 51f76de749SStephen Hanson #include <sys/sysevent/eventdefs.h> 52ded93414SHyon Kim #include <scsi/plugins/ses/vendor/sun.h> 53d91236feSeschrock 54940d71d2Seschrock #include "disk.h" 55d91236feSeschrock #include "ses.h" 56940d71d2Seschrock 57940d71d2Seschrock #define SES_VERSION 1 58940d71d2Seschrock 59ac88567aSHyon Kim #define SES_STARTING_SUBCHASSIS 256 /* valid subchassis IDs are uint8_t */ 60ac88567aSHyon Kim #define NO_SUBCHASSIS ((uint64_t)-1) 61ac88567aSHyon Kim 62525b85dbSEric Schrock static int ses_snap_freq = 250; /* in milliseconds */ 63940d71d2Seschrock 64d91236feSeschrock #define SES_STATUS_UNAVAIL(s) \ 650b32bb8bSEric Schrock ((s) == SES_ESC_UNSUPPORTED || (s) >= SES_ESC_NOT_INSTALLED) 66940d71d2Seschrock 67ded93414SHyon Kim #define HR_SECOND 1000000000 68ded93414SHyon Kim 69940d71d2Seschrock /* 70940d71d2Seschrock * Because multiple SES targets can be part of a single chassis, we construct 71940d71d2Seschrock * our own hierarchy that takes this into account. These SES targets may refer 72940d71d2Seschrock * to the same devices (multiple paths) or to different devices (managing 73940d71d2Seschrock * different portions of the space). We arrange things into a 74940d71d2Seschrock * ses_enum_enclosure_t, which contains a set of ses targets, and a list of all 75940d71d2Seschrock * nodes found so far. 76940d71d2Seschrock */ 770b32bb8bSEric Schrock typedef struct ses_alt_node { 780b32bb8bSEric Schrock topo_list_t san_link; 790b32bb8bSEric Schrock ses_node_t *san_node; 800b32bb8bSEric Schrock } ses_alt_node_t; 81940d71d2Seschrock 82940d71d2Seschrock typedef struct ses_enum_node { 83940d71d2Seschrock topo_list_t sen_link; 84940d71d2Seschrock ses_node_t *sen_node; 850b32bb8bSEric Schrock topo_list_t sen_alt_nodes; 86940d71d2Seschrock uint64_t sen_type; 87940d71d2Seschrock uint64_t sen_instance; 88940d71d2Seschrock ses_enum_target_t *sen_target; 89940d71d2Seschrock } ses_enum_node_t; 90940d71d2Seschrock 91940d71d2Seschrock typedef struct ses_enum_chassis { 92940d71d2Seschrock topo_list_t sec_link; 9353dbcc59SSundeep Panicker topo_list_t sec_subchassis; 94940d71d2Seschrock topo_list_t sec_nodes; 95940d71d2Seschrock topo_list_t sec_targets; 96940d71d2Seschrock const char *sec_csn; 97940d71d2Seschrock ses_node_t *sec_enclosure; 98940d71d2Seschrock ses_enum_target_t *sec_target; 99940d71d2Seschrock topo_instance_t sec_instance; 10053dbcc59SSundeep Panicker topo_instance_t sec_scinstance; 101ac88567aSHyon Kim topo_instance_t sec_maxinstance; 102940d71d2Seschrock boolean_t sec_hasdev; 103d91236feSeschrock boolean_t sec_internal; 104940d71d2Seschrock } ses_enum_chassis_t; 105940d71d2Seschrock 106940d71d2Seschrock typedef struct ses_enum_data { 107ac88567aSHyon Kim topo_list_t sed_devs; 108940d71d2Seschrock topo_list_t sed_chassis; 109940d71d2Seschrock ses_enum_chassis_t *sed_current; 110940d71d2Seschrock ses_enum_target_t *sed_target; 111940d71d2Seschrock int sed_errno; 112940d71d2Seschrock char *sed_name; 113940d71d2Seschrock topo_mod_t *sed_mod; 114940d71d2Seschrock topo_instance_t sed_instance; 115940d71d2Seschrock } ses_enum_data_t; 116940d71d2Seschrock 117ac88567aSHyon Kim typedef struct sas_connector_phy_data { 118ded93414SHyon Kim uint64_t scpd_index; 119ded93414SHyon Kim uint64_t scpd_pm; 120ac88567aSHyon Kim } sas_connector_phy_data_t; 121ac88567aSHyon Kim 122ac88567aSHyon Kim typedef struct sas_connector_type { 123ded93414SHyon Kim uint64_t sct_type; 124ded93414SHyon Kim char *sct_name; 125ac88567aSHyon Kim } sas_connector_type_t; 126ac88567aSHyon Kim 127ac88567aSHyon Kim static const sas_connector_type_t sas_connector_type_list[] = { 128ac88567aSHyon Kim { 0x0, "Information unknown" }, 129ac88567aSHyon Kim { 0x1, "External SAS 4x receptacle (see SAS-2 and SFF-8470)" }, 130ac88567aSHyon Kim { 0x2, "Exteranl Mini SAS 4x receptacle (see SAS-2 and SFF-8088)" }, 13147d6cd81SRobert Mustacchi { 0x3, "QSFP+ receptacle (see SAS-2.1 and SFF-8436)" }, 13247d6cd81SRobert Mustacchi { 0x4, "Mini SAS 4x active receptacle (see SAS-2.1 and SFF-8088)" }, 13347d6cd81SRobert Mustacchi { 0x5, "Mini SAS HD 4x receptacle (see SAS-2.1 and SFF-8644)" }, 13447d6cd81SRobert Mustacchi { 0x6, "Mini SAS HD 8x receptacle (see SAS-2.1 and SFF-8644)" }, 13547d6cd81SRobert Mustacchi { 0x7, "Mini SAS HD 16x receptacle (see SAS-2.1 and SFF-8644)" }, 136ac88567aSHyon Kim { 0xF, "Vendor-specific external connector" }, 137ac88567aSHyon Kim { 0x10, "Internal wide SAS 4i plug (see SAS-2 and SFF-8484)" }, 138ac88567aSHyon Kim { 0x11, 139ac88567aSHyon Kim "Internal wide Mini SAS 4i receptacle (see SAS-2 and SFF-8087)" }, 14047d6cd81SRobert Mustacchi { 0x12, "Mini SAS HD 4i receptacle (see SAS-2.1 and SFF-8643)" }, 14147d6cd81SRobert Mustacchi { 0x20, "Internal SAS Drive receptacle (see SAS-2 and SFF-8482)" }, 14247d6cd81SRobert Mustacchi { 0x21, "Internal SATA host plug (see SAS-2 and SATA-2)" }, 143ac88567aSHyon Kim { 0x22, "Internal SAS Drive plug (see SAS-2 and SFF-8482)" }, 144ac88567aSHyon Kim { 0x23, "Internal SATA device plug (see SAS-2 and SATA-2)" }, 14547d6cd81SRobert Mustacchi { 0x24, "Micro SAS receptacle (see SAS-2.14)" }, 14647d6cd81SRobert Mustacchi { 0x25, "Micro SATA device plug (see SAS-2.1 and SATA)" }, 14747d6cd81SRobert Mustacchi { 0x26, "Micro SAS plug (see SAS-2.1 and SFF-8486)" }, 14847d6cd81SRobert Mustacchi { 0x27, "Micro SAS/SATA plug (see SAS-2.1 and SFF-8486)" }, 14947d6cd81SRobert Mustacchi { 0x28, 15047d6cd81SRobert Mustacchi "12 Gb/s SAS Drive backplane receptacle (see SAS-34 and SFF-8680)" }, 15147d6cd81SRobert Mustacchi { 0x29, "12Gb/s SAS Drive Plug (see SAS-3 and SFF-8680)" }, 15247d6cd81SRobert Mustacchi { 0x2A, "Multifunction 12 Gb/s 6x Unshielded receptacle connector " 15347d6cd81SRobert Mustacchi "receptacle (see SAS-3 and SFF-8639)" }, 15447d6cd81SRobert Mustacchi { 0x2B, "Multifunction 12 Gb/s 6x Unshielded receptable connector " 15547d6cd81SRobert Mustacchi "plug (see SAS-3 and SFF-8639)" }, 156ac88567aSHyon Kim { 0x2F, "Internal SAS virtual connector" }, 157ac88567aSHyon Kim { 0x3F, "Vendor-specific internal connector" }, 158ac88567aSHyon Kim { 0x70, "Other Vendor-specific connector" }, 159ac88567aSHyon Kim { 0x71, "Other Vendor-specific connector" }, 160ac88567aSHyon Kim { 0x72, "Other Vendor-specific connector" }, 161ac88567aSHyon Kim { 0x73, "Other Vendor-specific connector" }, 162ac88567aSHyon Kim { 0x74, "Other Vendor-specific connector" }, 163ac88567aSHyon Kim { 0x75, "Other Vendor-specific connector" }, 164ac88567aSHyon Kim { 0x76, "Other Vendor-specific connector" }, 165ac88567aSHyon Kim { 0x77, "Other Vendor-specific connector" }, 166ac88567aSHyon Kim { 0x78, "Other Vendor-specific connector" }, 167ac88567aSHyon Kim { 0x79, "Other Vendor-specific connector" }, 168ac88567aSHyon Kim { 0x7A, "Other Vendor-specific connector" }, 169ac88567aSHyon Kim { 0x7B, "Other Vendor-specific connector" }, 170ac88567aSHyon Kim { 0x7C, "Other Vendor-specific connector" }, 171ac88567aSHyon Kim { 0x7D, "Other Vendor-specific connector" }, 172ac88567aSHyon Kim { 0x7E, "Other Vendor-specific connector" }, 173ac88567aSHyon Kim { 0x7F, "Other Vendor-specific connector" }, 174ac88567aSHyon Kim { 0x80, "Not Defined" } 175ac88567aSHyon Kim }; 176ac88567aSHyon Kim 177ac88567aSHyon Kim #define SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED 0x80 178ac88567aSHyon Kim #define SAS_CONNECTOR_TYPE_NOT_DEFINED \ 17947d6cd81SRobert Mustacchi "Connector type not defined by SES-2 standard" 180ac88567aSHyon Kim #define SAS_CONNECTOR_TYPE_RESERVED \ 181ac88567aSHyon Kim "Connector type reserved by SES-2 standard" 182ac88567aSHyon Kim 183ded93414SHyon Kim typedef struct phys_enum_type { 184ded93414SHyon Kim uint64_t pet_type; 185ded93414SHyon Kim char *pet_nodename; 186ded93414SHyon Kim char *pet_defaultlabel; 187ded93414SHyon Kim boolean_t pet_dorange; 188ded93414SHyon Kim } phys_enum_type_t; 189ded93414SHyon Kim 190ded93414SHyon Kim static const phys_enum_type_t phys_enum_type_list[] = { 191ded93414SHyon Kim { SES_ET_ARRAY_DEVICE, BAY, "BAY", B_TRUE }, 192ded93414SHyon Kim { SES_ET_COOLING, FAN, "FAN", B_TRUE }, 193ded93414SHyon Kim { SES_ET_DEVICE, BAY, "BAY", B_TRUE }, 194ded93414SHyon Kim { SES_ET_ESC_ELECTRONICS, CONTROLLER, "CONTROLLER", B_TRUE }, 195ded93414SHyon Kim { SES_ET_POWER_SUPPLY, PSU, "PSU", B_TRUE }, 196ded93414SHyon Kim { SES_ET_SUNW_FANBOARD, FANBOARD, "FANBOARD", B_TRUE }, 197ded93414SHyon Kim { SES_ET_SUNW_FANMODULE, FANMODULE, "FANMODULE", B_TRUE }, 198ded93414SHyon Kim { SES_ET_SUNW_POWERBOARD, POWERBOARD, "POWERBOARD", B_TRUE }, 199ded93414SHyon Kim { SES_ET_SUNW_POWERMODULE, POWERMODULE, "POWERMODULE", B_TRUE } 200ded93414SHyon Kim }; 201ded93414SHyon Kim 202ded93414SHyon Kim #define N_PHYS_ENUM_TYPES (sizeof (phys_enum_type_list) / \ 203ded93414SHyon Kim sizeof (phys_enum_type_list[0])) 204ded93414SHyon Kim 205ded93414SHyon Kim /* 206ded93414SHyon Kim * Structure for the hierarchical tree for element nodes. 207ded93414SHyon Kim */ 208ded93414SHyon Kim typedef struct ses_phys_tree { 209ded93414SHyon Kim ses_node_t *spt_snode; 210ded93414SHyon Kim ses_enum_node_t *spt_senumnode; 211ded93414SHyon Kim boolean_t spt_isfru; 212ded93414SHyon Kim uint64_t spt_eonlyindex; 213ded93414SHyon Kim uint64_t spt_cindex; 214ded93414SHyon Kim uint64_t spt_pindex; 215ded93414SHyon Kim uint64_t spt_maxinst; 216ded93414SHyon Kim struct ses_phys_tree *spt_parent; 217ded93414SHyon Kim struct ses_phys_tree *spt_child; 218ded93414SHyon Kim struct ses_phys_tree *spt_sibling; 219ded93414SHyon Kim tnode_t *spt_tnode; 220ded93414SHyon Kim } ses_phys_tree_t; 221ded93414SHyon Kim 22253dbcc59SSundeep Panicker typedef enum { 22353dbcc59SSundeep Panicker SES_NEW_CHASSIS = 0x1, 22453dbcc59SSundeep Panicker SES_NEW_SUBCHASSIS = 0x2, 22553dbcc59SSundeep Panicker SES_DUP_CHASSIS = 0x4, 22653dbcc59SSundeep Panicker SES_DUP_SUBCHASSIS = 0x8 22753dbcc59SSundeep Panicker } ses_chassis_type_e; 22853dbcc59SSundeep Panicker 229ded93414SHyon Kim 230b4879163SHyon Kim static const topo_pgroup_info_t storage_pgroup = { 231b4879163SHyon Kim TOPO_PGROUP_STORAGE, 232ac88567aSHyon Kim TOPO_STABILITY_PRIVATE, 233ac88567aSHyon Kim TOPO_STABILITY_PRIVATE, 234ac88567aSHyon Kim 1 235ac88567aSHyon Kim }; 236ac88567aSHyon Kim 237b4879163SHyon Kim static const topo_pgroup_info_t smp_pgroup = { 238b4879163SHyon Kim TOPO_PGROUP_SMP, 239ac88567aSHyon Kim TOPO_STABILITY_PRIVATE, 240ac88567aSHyon Kim TOPO_STABILITY_PRIVATE, 241ac88567aSHyon Kim 1 242ac88567aSHyon Kim }; 243ac88567aSHyon Kim 244a961ec00SHyon Kim static const topo_pgroup_info_t ses_pgroup = { 245a961ec00SHyon Kim TOPO_PGROUP_SES, 246a961ec00SHyon Kim TOPO_STABILITY_PRIVATE, 247a961ec00SHyon Kim TOPO_STABILITY_PRIVATE, 248a961ec00SHyon Kim 1 249a961ec00SHyon Kim }; 250a961ec00SHyon Kim 251940d71d2Seschrock static int ses_present(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *, 252940d71d2Seschrock nvlist_t **); 253940d71d2Seschrock static int ses_contains(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *, 254940d71d2Seschrock nvlist_t **); 255940d71d2Seschrock 256940d71d2Seschrock static const topo_method_t ses_component_methods[] = { 257940d71d2Seschrock { TOPO_METH_PRESENT, TOPO_METH_PRESENT_DESC, 258940d71d2Seschrock TOPO_METH_PRESENT_VERSION0, TOPO_STABILITY_INTERNAL, ses_present }, 259d91236feSeschrock { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0, 260d91236feSeschrock TOPO_STABILITY_INTERNAL, ses_node_enum_facility }, 26188045cffSRobert Johnston { TOPO_METH_SENSOR_FAILURE, TOPO_METH_SENSOR_FAILURE_DESC, 26288045cffSRobert Johnston TOPO_METH_SENSOR_FAILURE_VERSION, TOPO_STABILITY_INTERNAL, 26388045cffSRobert Johnston topo_method_sensor_failure }, 264d91236feSeschrock { NULL } 265d91236feSeschrock }; 266d91236feSeschrock 267*317c37f3SRob Johnston #define TOPO_METH_SMCI_4U36_LABEL "smci_4u36_bay_label" 268*317c37f3SRob Johnston #define TOPO_METH_SMCI_4U36_LABEL_DESC \ 269*317c37f3SRob Johnston "compute bay labels on SMCI 4U36 storage platform variants" 270*317c37f3SRob Johnston #define TOPO_METH_SMCI_4U36_LABEL_VERSION 0 271*317c37f3SRob Johnston static int smci_4u36_bay_label(topo_mod_t *, tnode_t *, topo_version_t, 272*317c37f3SRob Johnston nvlist_t *, nvlist_t **); 273*317c37f3SRob Johnston 274d91236feSeschrock static const topo_method_t ses_bay_methods[] = { 275d91236feSeschrock { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0, 276d91236feSeschrock TOPO_STABILITY_INTERNAL, ses_node_enum_facility }, 2778abca89fSRob Johnston { TOPO_METH_OCCUPIED, TOPO_METH_OCCUPIED_DESC, 2788abca89fSRob Johnston TOPO_METH_OCCUPIED_VERSION, TOPO_STABILITY_INTERNAL, 2798abca89fSRob Johnston topo_mod_hc_occupied }, 280*317c37f3SRob Johnston { TOPO_METH_SMCI_4U36_LABEL, TOPO_METH_SMCI_4U36_LABEL_DESC, 281*317c37f3SRob Johnston TOPO_METH_SMCI_4U36_LABEL_VERSION, TOPO_STABILITY_INTERNAL, 282*317c37f3SRob Johnston smci_4u36_bay_label }, 2838abca89fSRob Johnston { NULL } 2848abca89fSRob Johnston }; 2858abca89fSRob Johnston 2868abca89fSRob Johnston static const topo_method_t ses_recep_methods[] = { 2878abca89fSRob Johnston { TOPO_METH_OCCUPIED, TOPO_METH_OCCUPIED_DESC, 2888abca89fSRob Johnston TOPO_METH_OCCUPIED_VERSION, TOPO_STABILITY_INTERNAL, 2898abca89fSRob Johnston topo_mod_hc_occupied }, 290940d71d2Seschrock { NULL } 291940d71d2Seschrock }; 292940d71d2Seschrock 293940d71d2Seschrock static const topo_method_t ses_enclosure_methods[] = { 294940d71d2Seschrock { TOPO_METH_CONTAINS, TOPO_METH_CONTAINS_DESC, 295940d71d2Seschrock TOPO_METH_CONTAINS_VERSION, TOPO_STABILITY_INTERNAL, ses_contains }, 296d91236feSeschrock { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0, 297d91236feSeschrock TOPO_STABILITY_INTERNAL, ses_enc_enum_facility }, 298940d71d2Seschrock { NULL } 299940d71d2Seschrock }; 300940d71d2Seschrock 301*317c37f3SRob Johnston /* 302*317c37f3SRob Johnston * The bay_label_overrides table can be used to map a server product ID to a 303*317c37f3SRob Johnston * topo method that will be invoked to override the value of the label property 304*317c37f3SRob Johnston * for all bay nodes. By default the property value is static, derived from 305*317c37f3SRob Johnston * the corresponding SES array device element's descriptor string. 306*317c37f3SRob Johnston */ 307*317c37f3SRob Johnston typedef struct ses_label_overrides { 308*317c37f3SRob Johnston const char *slbl_product; 309*317c37f3SRob Johnston const char *slbl_mname; 310*317c37f3SRob Johnston } ses_label_overrides_t; 311*317c37f3SRob Johnston 312*317c37f3SRob Johnston /* 313*317c37f3SRob Johnston * This table covers three generations of SMCI's 4U 36-bay storage server 314*317c37f3SRob Johnston * (and the Joyent-branded versions). There was also an Ivy Bridge variant 315*317c37f3SRob Johnston * which has been omitted due to an inability to find one to test on. 316*317c37f3SRob Johnston */ 317*317c37f3SRob Johnston static const ses_label_overrides_t bay_label_overrides[] = { 318*317c37f3SRob Johnston /* Sandy Bridge variant */ 319*317c37f3SRob Johnston { "SSG-6047R-E1R36L", TOPO_METH_SMCI_4U36_LABEL }, 320*317c37f3SRob Johnston { "Joyent-Storage-Platform-5001", TOPO_METH_SMCI_4U36_LABEL }, 321*317c37f3SRob Johnston 322*317c37f3SRob Johnston /* Broadwell variant */ 323*317c37f3SRob Johnston { "SSG-6048R-E1CR36L", TOPO_METH_SMCI_4U36_LABEL }, 324*317c37f3SRob Johnston { "Joyent-Storage-Platform-7001", TOPO_METH_SMCI_4U36_LABEL }, 325*317c37f3SRob Johnston 326*317c37f3SRob Johnston /* Skylake variant */ 327*317c37f3SRob Johnston { "SSG-6049P-E1CR36L", TOPO_METH_SMCI_4U36_LABEL }, 328*317c37f3SRob Johnston { "Joyent-S10G5", TOPO_METH_SMCI_4U36_LABEL } 329*317c37f3SRob Johnston }; 330*317c37f3SRob Johnston 331*317c37f3SRob Johnston #define N_BAY_LBL_OVERRIDES (sizeof (bay_label_overrides) / \ 332*317c37f3SRob Johnston sizeof (bay_label_overrides[0])) 333*317c37f3SRob Johnston 334f76de749SStephen Hanson /* 335f76de749SStephen Hanson * Functions for tracking ses devices which we were unable to open. We retry 336f76de749SStephen Hanson * these at regular intervals using ses_recheck_dir() and if we find that we 337f76de749SStephen Hanson * can now open any of them then we send a sysevent to indicate that a new topo 338f76de749SStephen Hanson * snapshot should be taken. 339f76de749SStephen Hanson */ 340f76de749SStephen Hanson typedef struct ses_open_fail_list { 341f76de749SStephen Hanson struct ses_open_fail_list *sof_next; 342f76de749SStephen Hanson char *sof_path; 343f76de749SStephen Hanson } ses_open_fail_list_t; 344f76de749SStephen Hanson 345f76de749SStephen Hanson static ses_open_fail_list_t *ses_sofh; 346f76de749SStephen Hanson static pthread_mutex_t ses_sofmt; 34705b58617SStephen Hanson static void ses_ct_print(char *ptr); 348f76de749SStephen Hanson 349f76de749SStephen Hanson static void 35005b58617SStephen Hanson ses_recheck_dir() 351f76de749SStephen Hanson { 352f76de749SStephen Hanson ses_target_t *target; 353f76de749SStephen Hanson sysevent_id_t eid; 35405b58617SStephen Hanson char buf[80]; 355f76de749SStephen Hanson ses_open_fail_list_t *sof; 356f76de749SStephen Hanson 357f76de749SStephen Hanson /* 358f76de749SStephen Hanson * check list of "unable to open" devices 359f76de749SStephen Hanson */ 360f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sofmt); 361f76de749SStephen Hanson for (sof = ses_sofh; sof != NULL; sof = sof->sof_next) { 362f76de749SStephen Hanson /* 363f76de749SStephen Hanson * see if we can open it now 364f76de749SStephen Hanson */ 365f76de749SStephen Hanson if ((target = ses_open(LIBSES_VERSION, 366f76de749SStephen Hanson sof->sof_path)) == NULL) { 36705b58617SStephen Hanson (void) snprintf(buf, sizeof (buf), 368f76de749SStephen Hanson "recheck_dir - still can't open %s", sof->sof_path); 36905b58617SStephen Hanson ses_ct_print(buf); 370f76de749SStephen Hanson continue; 371f76de749SStephen Hanson } 372f76de749SStephen Hanson 373f76de749SStephen Hanson /* 374f76de749SStephen Hanson * ok - better force a new snapshot 375f76de749SStephen Hanson */ 37605b58617SStephen Hanson (void) snprintf(buf, sizeof (buf), 377f76de749SStephen Hanson "recheck_dir - can now open %s", sof->sof_path); 37805b58617SStephen Hanson ses_ct_print(buf); 379f76de749SStephen Hanson (void) sysevent_post_event(EC_PLATFORM, ESC_PLATFORM_SP_RESET, 380f76de749SStephen Hanson SUNW_VENDOR, "fmd", NULL, &eid); 381f76de749SStephen Hanson ses_close(target); 382f76de749SStephen Hanson break; 383f76de749SStephen Hanson } 384f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sofmt); 385f76de749SStephen Hanson } 386f76de749SStephen Hanson 387f76de749SStephen Hanson static void 388f76de749SStephen Hanson ses_sof_alloc(topo_mod_t *mod, char *path) 389f76de749SStephen Hanson { 390f76de749SStephen Hanson ses_open_fail_list_t *sof; 391f76de749SStephen Hanson 392f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sofmt); 393f76de749SStephen Hanson sof = topo_mod_zalloc(mod, sizeof (*sof)); 394f76de749SStephen Hanson topo_mod_dprintf(mod, "sof_alloc %s", path); 395f76de749SStephen Hanson sof->sof_path = path; 396f76de749SStephen Hanson sof->sof_next = ses_sofh; 397f76de749SStephen Hanson ses_sofh = sof; 398f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sofmt); 399f76de749SStephen Hanson } 400f76de749SStephen Hanson 401f76de749SStephen Hanson static void 402f76de749SStephen Hanson ses_sof_freeall(topo_mod_t *mod) 403f76de749SStephen Hanson { 404f76de749SStephen Hanson ses_open_fail_list_t *sof, *next_sof; 405f76de749SStephen Hanson 406f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sofmt); 407f76de749SStephen Hanson for (sof = ses_sofh; sof != NULL; sof = next_sof) { 408f76de749SStephen Hanson next_sof = sof->sof_next; 409f76de749SStephen Hanson topo_mod_dprintf(mod, "sof_freeall %s", sof->sof_path); 410f76de749SStephen Hanson topo_mod_strfree(mod, sof->sof_path); 411f76de749SStephen Hanson topo_mod_free(mod, sof, sizeof (*sof)); 412f76de749SStephen Hanson } 413f76de749SStephen Hanson ses_sofh = NULL; 414f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sofmt); 415f76de749SStephen Hanson } 416f76de749SStephen Hanson 417f76de749SStephen Hanson /* 418f76de749SStephen Hanson * functions for verifying that the ses_enum_target_t held in a device 419f76de749SStephen Hanson * contract's cookie field is still valid (it may have been freed by 420f76de749SStephen Hanson * ses_release()). 421f76de749SStephen Hanson */ 422f76de749SStephen Hanson typedef struct ses_stp_list { 423f76de749SStephen Hanson struct ses_stp_list *ssl_next; 424f76de749SStephen Hanson ses_enum_target_t *ssl_tgt; 425f76de749SStephen Hanson } ses_stp_list_t; 426f76de749SStephen Hanson 427f76de749SStephen Hanson static ses_stp_list_t *ses_sslh; 428f76de749SStephen Hanson static pthread_mutex_t ses_sslmt; 429f76de749SStephen Hanson 430f76de749SStephen Hanson static void 431f76de749SStephen Hanson ses_ssl_alloc(topo_mod_t *mod, ses_enum_target_t *stp) 432f76de749SStephen Hanson { 433f76de749SStephen Hanson ses_stp_list_t *ssl; 434f76de749SStephen Hanson 435f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sslmt); 436f76de749SStephen Hanson ssl = topo_mod_zalloc(mod, sizeof (*ssl)); 437f76de749SStephen Hanson topo_mod_dprintf(mod, "ssl_alloc %p", stp); 438f76de749SStephen Hanson ssl->ssl_tgt = stp; 439f76de749SStephen Hanson ssl->ssl_next = ses_sslh; 440f76de749SStephen Hanson ses_sslh = ssl; 441f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 442f76de749SStephen Hanson } 443f76de749SStephen Hanson 444f76de749SStephen Hanson static void 445f76de749SStephen Hanson ses_ssl_free(topo_mod_t *mod, ses_enum_target_t *stp) 446f76de749SStephen Hanson { 447f76de749SStephen Hanson ses_stp_list_t *ssl, *prev_ssl; 448f76de749SStephen Hanson 449f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sslmt); 450f76de749SStephen Hanson prev_ssl = NULL; 451f76de749SStephen Hanson for (ssl = ses_sslh; ssl != NULL; ssl = ssl->ssl_next) { 452f76de749SStephen Hanson if (ssl->ssl_tgt == stp) { 453f76de749SStephen Hanson topo_mod_dprintf(mod, "ssl_free %p", ssl->ssl_tgt); 454f76de749SStephen Hanson if (prev_ssl == NULL) 455f76de749SStephen Hanson ses_sslh = ssl->ssl_next; 456f76de749SStephen Hanson else 457f76de749SStephen Hanson prev_ssl->ssl_next = ssl->ssl_next; 458f76de749SStephen Hanson topo_mod_free(mod, ssl, sizeof (*ssl)); 459f76de749SStephen Hanson break; 460f76de749SStephen Hanson } 461f76de749SStephen Hanson prev_ssl = ssl; 462f76de749SStephen Hanson } 463f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 464f76de749SStephen Hanson } 465f76de749SStephen Hanson 466f76de749SStephen Hanson static int 467f76de749SStephen Hanson ses_ssl_valid(ses_enum_target_t *stp) 468f76de749SStephen Hanson { 469f76de749SStephen Hanson ses_stp_list_t *ssl; 470f76de749SStephen Hanson 471f76de749SStephen Hanson for (ssl = ses_sslh; ssl != NULL; ssl = ssl->ssl_next) 472f76de749SStephen Hanson if (ssl->ssl_tgt == stp) 473f76de749SStephen Hanson return (1); 474f76de749SStephen Hanson return (0); 475f76de749SStephen Hanson } 476f76de749SStephen Hanson 477f76de749SStephen Hanson /* 478f76de749SStephen Hanson * Functions for creating and destroying a background thread 479f76de749SStephen Hanson * (ses_contract_thread) used for detecting when ses devices have been 480f76de749SStephen Hanson * retired/unretired. 481f76de749SStephen Hanson */ 482f76de749SStephen Hanson static struct ses_thread_s { 483f76de749SStephen Hanson pthread_mutex_t mt; 484f76de749SStephen Hanson pthread_t tid; 485f76de749SStephen Hanson int thr_sig; 486f76de749SStephen Hanson int doexit; 487f76de749SStephen Hanson int count; 488f76de749SStephen Hanson } sesthread = { 489f76de749SStephen Hanson PTHREAD_MUTEX_INITIALIZER, 490f76de749SStephen Hanson 0, 491f76de749SStephen Hanson SIGTERM, 492f76de749SStephen Hanson 0, 493f76de749SStephen Hanson 0 494f76de749SStephen Hanson }; 495f76de749SStephen Hanson 49605b58617SStephen Hanson typedef struct ses_mod_list { 49705b58617SStephen Hanson struct ses_mod_list *smod_next; 49805b58617SStephen Hanson topo_mod_t *smod_mod; 49905b58617SStephen Hanson } ses_mod_list_t; 50005b58617SStephen Hanson 50105b58617SStephen Hanson static ses_mod_list_t *ses_smod; 50205b58617SStephen Hanson 50305b58617SStephen Hanson static void 50405b58617SStephen Hanson ses_ct_print(char *ptr) 50505b58617SStephen Hanson { 50605b58617SStephen Hanson (void) pthread_mutex_lock(&sesthread.mt); 5072eb07f5eSStephen Hanson if (ses_smod != NULL && ses_smod->smod_mod != NULL) 50805b58617SStephen Hanson topo_mod_dprintf(ses_smod->smod_mod, ptr); 50905b58617SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 51005b58617SStephen Hanson } 51105b58617SStephen Hanson 51205b58617SStephen Hanson /*ARGSUSED*/ 513f76de749SStephen Hanson static void * 514f76de749SStephen Hanson ses_contract_thread(void *arg) 515f76de749SStephen Hanson { 516f76de749SStephen Hanson int efd, ctlfd, statfd; 517f76de749SStephen Hanson ct_evthdl_t ev; 518f76de749SStephen Hanson ctevid_t evid; 519f76de749SStephen Hanson uint_t event; 520f76de749SStephen Hanson char path[PATH_MAX]; 52105b58617SStephen Hanson char buf[80]; 522f76de749SStephen Hanson ses_enum_target_t *stp; 523f76de749SStephen Hanson ct_stathdl_t stathdl; 524f76de749SStephen Hanson ctid_t ctid; 525f76de749SStephen Hanson struct pollfd fds; 526f76de749SStephen Hanson int pollret; 527057c620aSHans Rosenfeld sigset_t sigset; 528f76de749SStephen Hanson 52905b58617SStephen Hanson ses_ct_print("start contract event thread"); 530f76de749SStephen Hanson efd = open64(CTFS_ROOT "/device/pbundle", O_RDONLY); 531f76de749SStephen Hanson fds.fd = efd; 532f76de749SStephen Hanson fds.events = POLLIN; 533f76de749SStephen Hanson fds.revents = 0; 5348e4148b0SJohn Levon (void) sigaddset(&sigset, sesthread.thr_sig); 5358e4148b0SJohn Levon (void) pthread_sigmask(SIG_UNBLOCK, &sigset, NULL); 536f76de749SStephen Hanson for (;;) { 537f76de749SStephen Hanson /* check if we've been asked to exit */ 538f76de749SStephen Hanson (void) pthread_mutex_lock(&sesthread.mt); 539f76de749SStephen Hanson if (sesthread.doexit) { 540f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 541f76de749SStephen Hanson break; 542f76de749SStephen Hanson } 543f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 544f76de749SStephen Hanson 545f76de749SStephen Hanson /* poll until an event arrives */ 546f76de749SStephen Hanson if ((pollret = poll(&fds, 1, 10000)) <= 0) { 547f76de749SStephen Hanson if (pollret == 0) 54805b58617SStephen Hanson ses_recheck_dir(); 549f76de749SStephen Hanson continue; 550f76de749SStephen Hanson } 551f76de749SStephen Hanson 552f76de749SStephen Hanson /* read the event */ 553f76de749SStephen Hanson (void) pthread_mutex_lock(&ses_sslmt); 55405b58617SStephen Hanson ses_ct_print("read contract event"); 555f76de749SStephen Hanson if (ct_event_read(efd, &ev) != 0) { 556f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 557f76de749SStephen Hanson continue; 558f76de749SStephen Hanson } 559f76de749SStephen Hanson 560f76de749SStephen Hanson /* see if it is an event we are expecting */ 561f76de749SStephen Hanson ctid = ct_event_get_ctid(ev); 56205b58617SStephen Hanson (void) snprintf(buf, sizeof (buf), 56305b58617SStephen Hanson "got contract event ctid=%d", ctid); 56405b58617SStephen Hanson ses_ct_print(buf); 565f76de749SStephen Hanson event = ct_event_get_type(ev); 566f76de749SStephen Hanson if (event != CT_DEV_EV_OFFLINE && event != CT_EV_NEGEND) { 567edb433b6SMilan Jurik (void) snprintf(buf, sizeof (buf), 56805b58617SStephen Hanson "bad contract event %x", event); 56905b58617SStephen Hanson ses_ct_print(buf); 570f76de749SStephen Hanson ct_event_free(ev); 571f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 572f76de749SStephen Hanson continue; 573f76de749SStephen Hanson } 574f76de749SStephen Hanson 575f76de749SStephen Hanson /* find target pointer saved in cookie */ 576f76de749SStephen Hanson evid = ct_event_get_evid(ev); 577f76de749SStephen Hanson (void) snprintf(path, PATH_MAX, CTFS_ROOT "/device/%ld/status", 578f76de749SStephen Hanson ctid); 579f76de749SStephen Hanson statfd = open64(path, O_RDONLY); 580edb433b6SMilan Jurik (void) ct_status_read(statfd, CTD_COMMON, &stathdl); 581f76de749SStephen Hanson stp = (ses_enum_target_t *)(uintptr_t) 582f76de749SStephen Hanson ct_status_get_cookie(stathdl); 583f76de749SStephen Hanson ct_status_free(stathdl); 584edb433b6SMilan Jurik (void) close(statfd); 585f76de749SStephen Hanson 586f76de749SStephen Hanson /* check if target pointer is still valid */ 587f76de749SStephen Hanson if (ses_ssl_valid(stp) == 0) { 588edb433b6SMilan Jurik (void) snprintf(buf, sizeof (buf), 58905b58617SStephen Hanson "contract already abandoned %x", event); 59005b58617SStephen Hanson ses_ct_print(buf); 591f76de749SStephen Hanson (void) snprintf(path, PATH_MAX, 592f76de749SStephen Hanson CTFS_ROOT "/device/%ld/ctl", ctid); 593f76de749SStephen Hanson ctlfd = open64(path, O_WRONLY); 594f76de749SStephen Hanson if (event != CT_EV_NEGEND) 595edb433b6SMilan Jurik (void) ct_ctl_ack(ctlfd, evid); 596f76de749SStephen Hanson else 597edb433b6SMilan Jurik (void) ct_ctl_abandon(ctlfd); 598edb433b6SMilan Jurik (void) close(ctlfd); 599f76de749SStephen Hanson ct_event_free(ev); 600f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 601f76de749SStephen Hanson continue; 602f76de749SStephen Hanson } 603f76de749SStephen Hanson 604f76de749SStephen Hanson /* find control device for ack/abandon */ 605f76de749SStephen Hanson (void) pthread_mutex_lock(&stp->set_lock); 606f76de749SStephen Hanson (void) snprintf(path, PATH_MAX, CTFS_ROOT "/device/%ld/ctl", 607f76de749SStephen Hanson ctid); 608f76de749SStephen Hanson ctlfd = open64(path, O_WRONLY); 609f76de749SStephen Hanson if (event != CT_EV_NEGEND) { 610f76de749SStephen Hanson /* if this is an offline event, do the offline */ 61105b58617SStephen Hanson ses_ct_print("got contract offline event"); 612f76de749SStephen Hanson if (stp->set_target) { 61305b58617SStephen Hanson ses_ct_print("contract thread rele"); 614f76de749SStephen Hanson ses_snap_rele(stp->set_snap); 615f76de749SStephen Hanson ses_close(stp->set_target); 616f76de749SStephen Hanson stp->set_target = NULL; 617f76de749SStephen Hanson } 618edb433b6SMilan Jurik (void) ct_ctl_ack(ctlfd, evid); 619f76de749SStephen Hanson } else { 620f76de749SStephen Hanson /* if this is the negend, then abandon the contract */ 62105b58617SStephen Hanson ses_ct_print("got contract negend"); 622f76de749SStephen Hanson if (stp->set_ctid) { 623ad8ef92aSMilan Jurik (void) snprintf(buf, sizeof (buf), 62405b58617SStephen Hanson "abandon old contract %d", stp->set_ctid); 62505b58617SStephen Hanson ses_ct_print(buf); 6265cc5d5ceSToomas Soome stp->set_ctid = 0; 627f76de749SStephen Hanson } 628edb433b6SMilan Jurik (void) ct_ctl_abandon(ctlfd); 629f76de749SStephen Hanson } 630ad8ef92aSMilan Jurik (void) close(ctlfd); 631f76de749SStephen Hanson (void) pthread_mutex_unlock(&stp->set_lock); 632f76de749SStephen Hanson ct_event_free(ev); 633f76de749SStephen Hanson (void) pthread_mutex_unlock(&ses_sslmt); 634f76de749SStephen Hanson } 635ad8ef92aSMilan Jurik (void) close(efd); 636f76de749SStephen Hanson return (NULL); 637f76de749SStephen Hanson } 638f76de749SStephen Hanson 639f76de749SStephen Hanson int 640f76de749SStephen Hanson find_thr_sig(void) 641f76de749SStephen Hanson { 642f76de749SStephen Hanson int i; 643f76de749SStephen Hanson sigset_t oset, rset; 644f76de749SStephen Hanson int sig[] = {SIGTERM, SIGUSR1, SIGUSR2}; 645f76de749SStephen Hanson int sig_sz = sizeof (sig) / sizeof (int); 646f76de749SStephen Hanson int rc = SIGTERM; 647f76de749SStephen Hanson 648f76de749SStephen Hanson /* prefered set of signals that are likely used to terminate threads */ 649f76de749SStephen Hanson (void) sigemptyset(&oset); 650f76de749SStephen Hanson (void) pthread_sigmask(SIG_SETMASK, NULL, &oset); 651f76de749SStephen Hanson for (i = 0; i < sig_sz; i++) { 652f76de749SStephen Hanson if (sigismember(&oset, sig[i]) == 0) { 653f76de749SStephen Hanson return (sig[i]); 654f76de749SStephen Hanson } 655f76de749SStephen Hanson } 656f76de749SStephen Hanson 657f76de749SStephen Hanson /* reserved set of signals that are not allowed to terminate thread */ 658f76de749SStephen Hanson (void) sigemptyset(&rset); 659f76de749SStephen Hanson (void) sigaddset(&rset, SIGABRT); 660f76de749SStephen Hanson (void) sigaddset(&rset, SIGKILL); 661f76de749SStephen Hanson (void) sigaddset(&rset, SIGSTOP); 662f76de749SStephen Hanson (void) sigaddset(&rset, SIGCANCEL); 663f76de749SStephen Hanson 664f76de749SStephen Hanson /* Find signal that is not masked and not in the reserved list. */ 665f76de749SStephen Hanson for (i = 1; i < MAXSIG; i++) { 666f76de749SStephen Hanson if (sigismember(&rset, i) == 1) { 667f76de749SStephen Hanson continue; 668f76de749SStephen Hanson } 669f76de749SStephen Hanson if (sigismember(&oset, i) == 0) { 670f76de749SStephen Hanson return (i); 671f76de749SStephen Hanson } 672f76de749SStephen Hanson } 673f76de749SStephen Hanson 674f76de749SStephen Hanson return (rc); 675f76de749SStephen Hanson } 676f76de749SStephen Hanson 677f76de749SStephen Hanson /*ARGSUSED*/ 678f76de749SStephen Hanson static void 679f76de749SStephen Hanson ses_handler(int sig) 680f76de749SStephen Hanson { 681f76de749SStephen Hanson } 682f76de749SStephen Hanson 683f76de749SStephen Hanson static void 68405b58617SStephen Hanson ses_thread_init(topo_mod_t *mod) 685f76de749SStephen Hanson { 686f76de749SStephen Hanson pthread_attr_t *attr = NULL; 687f76de749SStephen Hanson struct sigaction act; 68805b58617SStephen Hanson ses_mod_list_t *smod; 689f76de749SStephen Hanson 690f76de749SStephen Hanson (void) pthread_mutex_lock(&sesthread.mt); 691f76de749SStephen Hanson sesthread.count++; 69205b58617SStephen Hanson smod = topo_mod_zalloc(mod, sizeof (*smod)); 69305b58617SStephen Hanson smod->smod_mod = mod; 69405b58617SStephen Hanson smod->smod_next = ses_smod; 69505b58617SStephen Hanson ses_smod = smod; 696f76de749SStephen Hanson if (sesthread.tid == 0) { 697f76de749SStephen Hanson /* find a suitable signal to use for killing the thread below */ 698f76de749SStephen Hanson sesthread.thr_sig = find_thr_sig(); 699f76de749SStephen Hanson 700f76de749SStephen Hanson /* if don't have a handler for this signal, create one */ 701f76de749SStephen Hanson (void) sigaction(sesthread.thr_sig, NULL, &act); 702f76de749SStephen Hanson if (act.sa_handler == SIG_DFL || act.sa_handler == SIG_IGN) 703f76de749SStephen Hanson act.sa_handler = ses_handler; 704f76de749SStephen Hanson (void) sigaction(sesthread.thr_sig, &act, NULL); 705f76de749SStephen Hanson 706f76de749SStephen Hanson /* create a thread to listen for offline events */ 707f76de749SStephen Hanson (void) pthread_create(&sesthread.tid, 70805b58617SStephen Hanson attr, ses_contract_thread, NULL); 709f76de749SStephen Hanson } 710f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 711f76de749SStephen Hanson } 712f76de749SStephen Hanson 713f76de749SStephen Hanson static void 71405b58617SStephen Hanson ses_thread_fini(topo_mod_t *mod) 715f76de749SStephen Hanson { 71605b58617SStephen Hanson ses_mod_list_t *smod, *prev_smod; 71705b58617SStephen Hanson 718f76de749SStephen Hanson (void) pthread_mutex_lock(&sesthread.mt); 71905b58617SStephen Hanson prev_smod = NULL; 72005b58617SStephen Hanson for (smod = ses_smod; smod != NULL; smod = smod->smod_next) { 72105b58617SStephen Hanson if (smod->smod_mod == mod) { 72205b58617SStephen Hanson if (prev_smod == NULL) 72305b58617SStephen Hanson ses_smod = smod->smod_next; 72405b58617SStephen Hanson else 72505b58617SStephen Hanson prev_smod->smod_next = smod->smod_next; 72605b58617SStephen Hanson topo_mod_free(mod, smod, sizeof (*smod)); 72705b58617SStephen Hanson break; 72805b58617SStephen Hanson } 72905b58617SStephen Hanson prev_smod = smod; 73005b58617SStephen Hanson } 731f76de749SStephen Hanson if (--sesthread.count > 0) { 732f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 733f76de749SStephen Hanson return; 734f76de749SStephen Hanson } 735f76de749SStephen Hanson sesthread.doexit = 1; 736f76de749SStephen Hanson (void) pthread_mutex_unlock(&sesthread.mt); 737f76de749SStephen Hanson (void) pthread_kill(sesthread.tid, sesthread.thr_sig); 738f76de749SStephen Hanson (void) pthread_join(sesthread.tid, NULL); 739f76de749SStephen Hanson sesthread.tid = 0; 740f76de749SStephen Hanson } 741f76de749SStephen Hanson 742f76de749SStephen Hanson static void 743f76de749SStephen Hanson ses_create_contract(topo_mod_t *mod, ses_enum_target_t *stp) 744f76de749SStephen Hanson { 745f76de749SStephen Hanson int tfd, len, rval; 746f76de749SStephen Hanson char link_path[PATH_MAX]; 747f76de749SStephen Hanson 7485cc5d5ceSToomas Soome stp->set_ctid = 0; 749f76de749SStephen Hanson 750f76de749SStephen Hanson /* convert "/dev" path into "/devices" path */ 751f76de749SStephen Hanson if ((len = readlink(stp->set_devpath, link_path, PATH_MAX)) < 0) { 752f76de749SStephen Hanson topo_mod_dprintf(mod, "readlink failed"); 753f76de749SStephen Hanson return; 754f76de749SStephen Hanson } 755f76de749SStephen Hanson link_path[len] = '\0'; 756f76de749SStephen Hanson 757f76de749SStephen Hanson /* set up template to create new contract */ 758f76de749SStephen Hanson tfd = open64(CTFS_ROOT "/device/template", O_RDWR); 759edb433b6SMilan Jurik (void) ct_tmpl_set_critical(tfd, CT_DEV_EV_OFFLINE); 760edb433b6SMilan Jurik (void) ct_tmpl_set_cookie(tfd, (uint64_t)(uintptr_t)stp); 761f76de749SStephen Hanson 762f76de749SStephen Hanson /* strip "../../devices" off the front and create the contract */ 763f76de749SStephen Hanson if ((rval = ct_dev_tmpl_set_minor(tfd, &link_path[13])) != 0) 764f76de749SStephen Hanson topo_mod_dprintf(mod, "failed to set minor %s rval = %d", 765f76de749SStephen Hanson &link_path[13], rval); 766f76de749SStephen Hanson else if ((rval = ct_tmpl_create(tfd, &stp->set_ctid)) != 0) 767f76de749SStephen Hanson topo_mod_dprintf(mod, "failed to create ctid rval = %d", rval); 768f76de749SStephen Hanson else 769f76de749SStephen Hanson topo_mod_dprintf(mod, "created ctid=%d", stp->set_ctid); 770ad8ef92aSMilan Jurik (void) close(tfd); 771f76de749SStephen Hanson } 772f76de749SStephen Hanson 773940d71d2Seschrock static void 774940d71d2Seschrock ses_target_free(topo_mod_t *mod, ses_enum_target_t *stp) 775940d71d2Seschrock { 776940d71d2Seschrock if (--stp->set_refcount == 0) { 777f76de749SStephen Hanson /* check if already closed due to contract offline request */ 778f76de749SStephen Hanson (void) pthread_mutex_lock(&stp->set_lock); 779f76de749SStephen Hanson if (stp->set_target) { 780f76de749SStephen Hanson ses_snap_rele(stp->set_snap); 781f76de749SStephen Hanson ses_close(stp->set_target); 782f76de749SStephen Hanson stp->set_target = NULL; 783f76de749SStephen Hanson } 784f76de749SStephen Hanson if (stp->set_ctid) { 785f76de749SStephen Hanson int ctlfd; 786f76de749SStephen Hanson char path[PATH_MAX]; 787f76de749SStephen Hanson 788f76de749SStephen Hanson topo_mod_dprintf(mod, "abandon old contract %d", 789f76de749SStephen Hanson stp->set_ctid); 790f76de749SStephen Hanson (void) snprintf(path, PATH_MAX, 791f76de749SStephen Hanson CTFS_ROOT "/device/%ld/ctl", stp->set_ctid); 792f76de749SStephen Hanson ctlfd = open64(path, O_WRONLY); 793ad8ef92aSMilan Jurik (void) ct_ctl_abandon(ctlfd); 794ad8ef92aSMilan Jurik (void) close(ctlfd); 7955cc5d5ceSToomas Soome stp->set_ctid = 0; 796f76de749SStephen Hanson } 797f76de749SStephen Hanson (void) pthread_mutex_unlock(&stp->set_lock); 798f76de749SStephen Hanson ses_ssl_free(mod, stp); 799940d71d2Seschrock topo_mod_strfree(mod, stp->set_devpath); 800940d71d2Seschrock topo_mod_free(mod, stp, sizeof (ses_enum_target_t)); 801940d71d2Seschrock } 802940d71d2Seschrock } 803940d71d2Seschrock 804940d71d2Seschrock static void 80553dbcc59SSundeep Panicker ses_data_free(ses_enum_data_t *sdp, ses_enum_chassis_t *pcp) 806940d71d2Seschrock { 807940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 808940d71d2Seschrock ses_enum_chassis_t *cp; 809940d71d2Seschrock ses_enum_node_t *np; 810940d71d2Seschrock ses_enum_target_t *tp; 8110b32bb8bSEric Schrock ses_alt_node_t *ap; 81253dbcc59SSundeep Panicker topo_list_t *cpl; 81353dbcc59SSundeep Panicker 81453dbcc59SSundeep Panicker 81553dbcc59SSundeep Panicker if (pcp != NULL) 81653dbcc59SSundeep Panicker cpl = &pcp->sec_subchassis; 81753dbcc59SSundeep Panicker else 81853dbcc59SSundeep Panicker cpl = &sdp->sed_chassis; 819940d71d2Seschrock 82053dbcc59SSundeep Panicker while ((cp = topo_list_next(cpl)) != NULL) { 82153dbcc59SSundeep Panicker topo_list_delete(cpl, cp); 822940d71d2Seschrock 823940d71d2Seschrock while ((np = topo_list_next(&cp->sec_nodes)) != NULL) { 8240b32bb8bSEric Schrock while ((ap = topo_list_next(&np->sen_alt_nodes)) != 8250b32bb8bSEric Schrock NULL) { 8260b32bb8bSEric Schrock topo_list_delete(&np->sen_alt_nodes, ap); 8270b32bb8bSEric Schrock topo_mod_free(mod, ap, sizeof (ses_alt_node_t)); 8280b32bb8bSEric Schrock } 829940d71d2Seschrock topo_list_delete(&cp->sec_nodes, np); 830940d71d2Seschrock topo_mod_free(mod, np, sizeof (ses_enum_node_t)); 831940d71d2Seschrock } 832940d71d2Seschrock 833940d71d2Seschrock while ((tp = topo_list_next(&cp->sec_targets)) != NULL) { 834940d71d2Seschrock topo_list_delete(&cp->sec_targets, tp); 835940d71d2Seschrock ses_target_free(mod, tp); 836940d71d2Seschrock } 837940d71d2Seschrock 838940d71d2Seschrock topo_mod_free(mod, cp, sizeof (ses_enum_chassis_t)); 839940d71d2Seschrock } 840940d71d2Seschrock 84153dbcc59SSundeep Panicker if (pcp == NULL) { 842ac88567aSHyon Kim dev_list_free(mod, &sdp->sed_devs); 84353dbcc59SSundeep Panicker topo_mod_free(mod, sdp, sizeof (ses_enum_data_t)); 84453dbcc59SSundeep Panicker } 845940d71d2Seschrock } 846940d71d2Seschrock 847940d71d2Seschrock /* 848940d71d2Seschrock * For enclosure nodes, we have a special contains method. By default, the hc 849940d71d2Seschrock * walker will compare the node name and instance number to determine if an 850940d71d2Seschrock * FMRI matches. For enclosures where the enumeration order is impossible to 851940d71d2Seschrock * predict, we instead use the chassis-id as a unique identifier, and ignore 852940d71d2Seschrock * the instance number. 853940d71d2Seschrock */ 854940d71d2Seschrock static int 855940d71d2Seschrock fmri_contains(topo_mod_t *mod, nvlist_t *nv1, nvlist_t *nv2) 856940d71d2Seschrock { 857940d71d2Seschrock uint8_t v1, v2; 858940d71d2Seschrock nvlist_t **hcp1, **hcp2; 859940d71d2Seschrock int err, i; 860940d71d2Seschrock uint_t nhcp1, nhcp2; 861940d71d2Seschrock nvlist_t *a1, *a2; 862940d71d2Seschrock char *c1, *c2; 863940d71d2Seschrock int mindepth; 864940d71d2Seschrock 865940d71d2Seschrock if (nvlist_lookup_uint8(nv1, FM_VERSION, &v1) != 0 || 866940d71d2Seschrock nvlist_lookup_uint8(nv2, FM_VERSION, &v2) != 0 || 867940d71d2Seschrock v1 > FM_HC_SCHEME_VERSION || v2 > FM_HC_SCHEME_VERSION) 868940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_VERSION)); 869940d71d2Seschrock 870940d71d2Seschrock err = nvlist_lookup_nvlist_array(nv1, FM_FMRI_HC_LIST, &hcp1, &nhcp1); 871940d71d2Seschrock err |= nvlist_lookup_nvlist_array(nv2, FM_FMRI_HC_LIST, &hcp2, &nhcp2); 872940d71d2Seschrock if (err != 0) 873940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 874940d71d2Seschrock 875940d71d2Seschrock /* 876940d71d2Seschrock * If the chassis-id doesn't match, then these FMRIs are not 877940d71d2Seschrock * equivalent. If one of the FMRIs doesn't have a chassis ID, then we 878940d71d2Seschrock * have no choice but to fall back to the instance ID. 879940d71d2Seschrock */ 880940d71d2Seschrock if (nvlist_lookup_nvlist(nv1, FM_FMRI_AUTHORITY, &a1) == 0 && 881940d71d2Seschrock nvlist_lookup_nvlist(nv2, FM_FMRI_AUTHORITY, &a2) == 0 && 882940d71d2Seschrock nvlist_lookup_string(a1, FM_FMRI_AUTH_CHASSIS, &c1) == 0 && 883940d71d2Seschrock nvlist_lookup_string(a2, FM_FMRI_AUTH_CHASSIS, &c2) == 0) { 884940d71d2Seschrock if (strcmp(c1, c2) != 0) 885940d71d2Seschrock return (0); 886940d71d2Seschrock 887940d71d2Seschrock mindepth = 1; 888940d71d2Seschrock } else { 889940d71d2Seschrock mindepth = 0; 890940d71d2Seschrock } 891940d71d2Seschrock 892940d71d2Seschrock if (nhcp2 < nhcp1) 893940d71d2Seschrock return (0); 894940d71d2Seschrock 895940d71d2Seschrock for (i = 0; i < nhcp1; i++) { 896940d71d2Seschrock char *nm1 = NULL; 897940d71d2Seschrock char *nm2 = NULL; 898940d71d2Seschrock char *id1 = NULL; 899940d71d2Seschrock char *id2 = NULL; 900940d71d2Seschrock 901940d71d2Seschrock (void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_NAME, &nm1); 902940d71d2Seschrock (void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_NAME, &nm2); 903940d71d2Seschrock (void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_ID, &id1); 904940d71d2Seschrock (void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_ID, &id2); 905940d71d2Seschrock if (nm1 == NULL || nm2 == NULL || id1 == NULL || id2 == NULL) 906940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 907940d71d2Seschrock 908940d71d2Seschrock if (strcmp(nm1, nm2) == 0 && 909940d71d2Seschrock (i < mindepth || strcmp(id1, id2) == 0)) 910940d71d2Seschrock continue; 911940d71d2Seschrock 912940d71d2Seschrock return (0); 913940d71d2Seschrock } 914940d71d2Seschrock 915940d71d2Seschrock return (1); 916940d71d2Seschrock } 917940d71d2Seschrock 918940d71d2Seschrock /*ARGSUSED*/ 919940d71d2Seschrock static int 920940d71d2Seschrock ses_contains(topo_mod_t *mod, tnode_t *tn, topo_version_t version, 921940d71d2Seschrock nvlist_t *in, nvlist_t **out) 922940d71d2Seschrock { 923940d71d2Seschrock int ret; 924940d71d2Seschrock nvlist_t *nv1, *nv2; 925940d71d2Seschrock 926940d71d2Seschrock if (version > TOPO_METH_CONTAINS_VERSION) 927940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_VER_NEW)); 928940d71d2Seschrock 929940d71d2Seschrock if (nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_FMRI, &nv1) != 0 || 930940d71d2Seschrock nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_SUBFMRI, &nv2) != 0) 931940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL)); 932940d71d2Seschrock 933940d71d2Seschrock ret = fmri_contains(mod, nv1, nv2); 934940d71d2Seschrock if (ret < 0) 935940d71d2Seschrock return (-1); 936940d71d2Seschrock 937940d71d2Seschrock if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) == 0) { 93873e32a37SRobert Johnston if (nvlist_add_uint32(*out, TOPO_METH_CONTAINS_RET, 939940d71d2Seschrock ret) == 0) 940940d71d2Seschrock return (0); 941940d71d2Seschrock else 942940d71d2Seschrock nvlist_free(*out); 943940d71d2Seschrock } 944940d71d2Seschrock 945940d71d2Seschrock return (-1); 946940d71d2Seschrock 947940d71d2Seschrock } 948940d71d2Seschrock 949940d71d2Seschrock /* 950d91236feSeschrock * Return a current instance of the node. This is somewhat complicated because 951d91236feSeschrock * we need to take a new snapshot in order to get the new data, but we don't 952940d71d2Seschrock * want to be constantly taking SES snapshots if the consumer is going to do a 953940d71d2Seschrock * series of queries. So we adopt the strategy of assuming that the SES state 954d91236feSeschrock * is not going to be rapidly changing, and limit our snapshot frequency to 955d91236feSeschrock * some defined bounds. 956940d71d2Seschrock */ 957d91236feSeschrock ses_node_t * 9580b32bb8bSEric Schrock ses_node_lock(topo_mod_t *mod, tnode_t *tn) 959940d71d2Seschrock { 960940d71d2Seschrock ses_enum_target_t *tp = topo_node_getspecific(tn); 961525b85dbSEric Schrock hrtime_t now; 962940d71d2Seschrock ses_snap_t *snap; 963940d71d2Seschrock int err; 964d91236feSeschrock uint64_t nodeid; 965940d71d2Seschrock ses_node_t *np; 966940d71d2Seschrock 967d91236feSeschrock if (tp == NULL) { 968d91236feSeschrock (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 969d91236feSeschrock return (NULL); 970d91236feSeschrock } 971940d71d2Seschrock 9720b32bb8bSEric Schrock (void) pthread_mutex_lock(&tp->set_lock); 9730b32bb8bSEric Schrock 974940d71d2Seschrock /* 975940d71d2Seschrock * Determine if we need to take a new snapshot. 976940d71d2Seschrock */ 977525b85dbSEric Schrock now = gethrtime(); 978940d71d2Seschrock 979f76de749SStephen Hanson if (tp->set_target == NULL) { 980f76de749SStephen Hanson /* 981f76de749SStephen Hanson * We may have closed the device but not yet abandoned the 982f76de749SStephen Hanson * contract (ie we've had the offline event but not yet the 983f76de749SStephen Hanson * negend). If so, just return failure. 984f76de749SStephen Hanson */ 9855cc5d5ceSToomas Soome if (tp->set_ctid != 0) { 986f76de749SStephen Hanson (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 987f76de749SStephen Hanson (void) pthread_mutex_unlock(&tp->set_lock); 988f76de749SStephen Hanson return (NULL); 989f76de749SStephen Hanson } 990f76de749SStephen Hanson 991f76de749SStephen Hanson /* 992f76de749SStephen Hanson * The device has been closed due to a contract offline 993f76de749SStephen Hanson * request, then we need to reopen it and create a new contract. 994f76de749SStephen Hanson */ 995f76de749SStephen Hanson if ((tp->set_target = 996f76de749SStephen Hanson ses_open(LIBSES_VERSION, tp->set_devpath)) == NULL) { 997f76de749SStephen Hanson sysevent_id_t eid; 998f76de749SStephen Hanson 999f76de749SStephen Hanson (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 1000f76de749SStephen Hanson (void) pthread_mutex_unlock(&tp->set_lock); 1001f76de749SStephen Hanson topo_mod_dprintf(mod, "recheck_dir - " 1002f76de749SStephen Hanson "can no longer open %s", tp->set_devpath); 1003f76de749SStephen Hanson (void) sysevent_post_event(EC_PLATFORM, 1004f76de749SStephen Hanson ESC_PLATFORM_SP_RESET, SUNW_VENDOR, "fmd", NULL, 1005f76de749SStephen Hanson &eid); 1006f76de749SStephen Hanson return (NULL); 1007f76de749SStephen Hanson } 1008f76de749SStephen Hanson topo_mod_dprintf(mod, "reopen contract"); 1009f76de749SStephen Hanson ses_create_contract(mod, tp); 1010f76de749SStephen Hanson tp->set_snap = ses_snap_hold(tp->set_target); 1011f76de749SStephen Hanson tp->set_snaptime = gethrtime(); 1012f76de749SStephen Hanson } else if (now - tp->set_snaptime > (ses_snap_freq * 1000 * 1000) && 1013940d71d2Seschrock (snap = ses_snap_new(tp->set_target)) != NULL) { 1014940d71d2Seschrock if (ses_snap_generation(snap) != 1015940d71d2Seschrock ses_snap_generation(tp->set_snap)) { 1016940d71d2Seschrock /* 1017940d71d2Seschrock * If we find ourselves in this situation, we're in 1018940d71d2Seschrock * trouble. The generation count has changed, which 1019940d71d2Seschrock * indicates that our current topology is out of date. 1020940d71d2Seschrock * But we need to consult the new topology in order to 1021940d71d2Seschrock * determine presence at this moment in time. We can't 1022940d71d2Seschrock * go back and change the topo snapshot in situ, so 1023d91236feSeschrock * we'll just have to fail the call in this unlikely 1024d91236feSeschrock * scenario. 1025940d71d2Seschrock */ 1026940d71d2Seschrock ses_snap_rele(snap); 1027d91236feSeschrock (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP); 10280b32bb8bSEric Schrock (void) pthread_mutex_unlock(&tp->set_lock); 1029d91236feSeschrock return (NULL); 1030940d71d2Seschrock } else { 1031940d71d2Seschrock ses_snap_rele(tp->set_snap); 1032940d71d2Seschrock tp->set_snap = snap; 1033940d71d2Seschrock } 1034525b85dbSEric Schrock tp->set_snaptime = gethrtime(); 1035940d71d2Seschrock } 1036940d71d2Seschrock 1037940d71d2Seschrock snap = tp->set_snap; 1038940d71d2Seschrock 1039940d71d2Seschrock verify(topo_prop_get_uint64(tn, TOPO_PGROUP_SES, 1040940d71d2Seschrock TOPO_PROP_NODE_ID, &nodeid, &err) == 0); 1041940d71d2Seschrock verify((np = ses_node_lookup(snap, nodeid)) != NULL); 1042d91236feSeschrock 1043d91236feSeschrock return (np); 1044d91236feSeschrock } 1045d91236feSeschrock 10460b32bb8bSEric Schrock /*ARGSUSED*/ 10470b32bb8bSEric Schrock void 10480b32bb8bSEric Schrock ses_node_unlock(topo_mod_t *mod, tnode_t *tn) 10490b32bb8bSEric Schrock { 10500b32bb8bSEric Schrock ses_enum_target_t *tp = topo_node_getspecific(tn); 10510b32bb8bSEric Schrock 10520b32bb8bSEric Schrock verify(tp != NULL); 10530b32bb8bSEric Schrock 10540b32bb8bSEric Schrock (void) pthread_mutex_unlock(&tp->set_lock); 10550b32bb8bSEric Schrock } 10560b32bb8bSEric Schrock 1057d91236feSeschrock /* 1058d91236feSeschrock * Determine if the element is present. 1059d91236feSeschrock */ 1060d91236feSeschrock /*ARGSUSED*/ 1061d91236feSeschrock static int 1062d91236feSeschrock ses_present(topo_mod_t *mod, tnode_t *tn, topo_version_t version, 1063d91236feSeschrock nvlist_t *in, nvlist_t **out) 1064d91236feSeschrock { 1065d91236feSeschrock boolean_t present; 1066d91236feSeschrock ses_node_t *np; 1067d91236feSeschrock nvlist_t *props, *nvl; 1068d91236feSeschrock uint64_t status; 1069d91236feSeschrock 10700b32bb8bSEric Schrock if ((np = ses_node_lock(mod, tn)) == NULL) 1071d91236feSeschrock return (-1); 1072d91236feSeschrock 1073940d71d2Seschrock verify((props = ses_node_props(np)) != NULL); 1074940d71d2Seschrock verify(nvlist_lookup_uint64(props, 1075940d71d2Seschrock SES_PROP_STATUS_CODE, &status) == 0); 1076940d71d2Seschrock 10770b32bb8bSEric Schrock ses_node_unlock(mod, tn); 10780b32bb8bSEric Schrock 1079940d71d2Seschrock present = (status != SES_ESC_NOT_INSTALLED); 1080940d71d2Seschrock 1081940d71d2Seschrock if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0) 1082940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 1083940d71d2Seschrock 1084940d71d2Seschrock if (nvlist_add_uint32(nvl, TOPO_METH_PRESENT_RET, 1085940d71d2Seschrock present) != 0) { 1086940d71d2Seschrock nvlist_free(nvl); 1087940d71d2Seschrock return (topo_mod_seterrno(mod, EMOD_FMRI_NVL)); 1088940d71d2Seschrock } 1089940d71d2Seschrock 1090940d71d2Seschrock *out = nvl; 1091940d71d2Seschrock 1092940d71d2Seschrock return (0); 1093940d71d2Seschrock } 1094940d71d2Seschrock 1095940d71d2Seschrock /* 1096ac88567aSHyon Kim * Sets standard properties for a ses node (enclosure, bay, controller 1097ac88567aSHyon Kim * or expander). 1098ac88567aSHyon Kim * This includes setting the FRU, as well as setting the 1099ac88567aSHyon Kim * authority information. When the fru topo node(frutn) is not NULL 1100ac88567aSHyon Kim * its resouce should be used as FRU. 1101940d71d2Seschrock */ 1102940d71d2Seschrock static int 1103ac88567aSHyon Kim ses_set_standard_props(topo_mod_t *mod, tnode_t *frutn, tnode_t *tn, 1104ac88567aSHyon Kim nvlist_t *auth, uint64_t nodeid, const char *path) 1105940d71d2Seschrock { 1106940d71d2Seschrock int err; 1107940d71d2Seschrock char *product, *chassis; 1108940d71d2Seschrock nvlist_t *fmri; 1109940d71d2Seschrock 1110940d71d2Seschrock /* 1111940d71d2Seschrock * Set the authority explicitly if specified. 1112940d71d2Seschrock */ 1113940d71d2Seschrock if (auth) { 1114940d71d2Seschrock verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT, 1115940d71d2Seschrock &product) == 0); 1116940d71d2Seschrock verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_CHASSIS, 1117940d71d2Seschrock &chassis) == 0); 1118940d71d2Seschrock if (topo_prop_set_string(tn, FM_FMRI_AUTHORITY, 1119940d71d2Seschrock FM_FMRI_AUTH_PRODUCT, TOPO_PROP_IMMUTABLE, product, 1120940d71d2Seschrock &err) != 0 || 1121940d71d2Seschrock topo_prop_set_string(tn, FM_FMRI_AUTHORITY, 1122940d71d2Seschrock FM_FMRI_AUTH_CHASSIS, TOPO_PROP_IMMUTABLE, chassis, 1123940d71d2Seschrock &err) != 0 || 1124940d71d2Seschrock topo_prop_set_string(tn, FM_FMRI_AUTHORITY, 1125940d71d2Seschrock FM_FMRI_AUTH_SERVER, TOPO_PROP_IMMUTABLE, "", 1126940d71d2Seschrock &err) != 0) { 1127940d71d2Seschrock topo_mod_dprintf(mod, "failed to add authority " 1128d91236feSeschrock "properties: %s\n", topo_strerror(err)); 1129940d71d2Seschrock return (topo_mod_seterrno(mod, err)); 1130940d71d2Seschrock } 1131940d71d2Seschrock } 1132940d71d2Seschrock 1133940d71d2Seschrock /* 1134940d71d2Seschrock * Copy the resource and set that as the FRU. 1135940d71d2Seschrock */ 1136ac88567aSHyon Kim if (frutn != NULL) { 1137ac88567aSHyon Kim if (topo_node_resource(frutn, &fmri, &err) != 0) { 1138ac88567aSHyon Kim topo_mod_dprintf(mod, 1139ac88567aSHyon Kim "topo_node_resource() failed : %s\n", 1140ac88567aSHyon Kim topo_strerror(err)); 1141ac88567aSHyon Kim return (topo_mod_seterrno(mod, err)); 1142ac88567aSHyon Kim } 1143ac88567aSHyon Kim } else { 1144ac88567aSHyon Kim if (topo_node_resource(tn, &fmri, &err) != 0) { 1145ac88567aSHyon Kim topo_mod_dprintf(mod, 1146ac88567aSHyon Kim "topo_node_resource() failed : %s\n", 1147ac88567aSHyon Kim topo_strerror(err)); 1148ac88567aSHyon Kim return (topo_mod_seterrno(mod, err)); 1149ac88567aSHyon Kim } 1150940d71d2Seschrock } 1151940d71d2Seschrock 1152940d71d2Seschrock if (topo_node_fru_set(tn, fmri, 0, &err) != 0) { 1153940d71d2Seschrock topo_mod_dprintf(mod, 1154940d71d2Seschrock "topo_node_fru_set() failed : %s\n", 1155940d71d2Seschrock topo_strerror(err)); 1156940d71d2Seschrock nvlist_free(fmri); 1157940d71d2Seschrock return (topo_mod_seterrno(mod, err)); 1158940d71d2Seschrock } 1159940d71d2Seschrock 1160940d71d2Seschrock nvlist_free(fmri); 1161940d71d2Seschrock 1162940d71d2Seschrock /* 1163940d71d2Seschrock * Set the SES-specific properties so that consumers can query 1164940d71d2Seschrock * additional information about the particular SES element. 1165940d71d2Seschrock */ 1166a961ec00SHyon Kim if (topo_pgroup_create(tn, &ses_pgroup, &err) != 0) { 1167940d71d2Seschrock topo_mod_dprintf(mod, "failed to create propgroup " 1168940d71d2Seschrock "%s: %s\n", TOPO_PGROUP_SES, topo_strerror(err)); 1169940d71d2Seschrock return (-1); 1170940d71d2Seschrock } 1171940d71d2Seschrock 1172940d71d2Seschrock if (topo_prop_set_uint64(tn, TOPO_PGROUP_SES, 1173940d71d2Seschrock TOPO_PROP_NODE_ID, TOPO_PROP_IMMUTABLE, 1174940d71d2Seschrock nodeid, &err) != 0) { 1175940d71d2Seschrock topo_mod_dprintf(mod, 1176940d71d2Seschrock "failed to create property %s: %s\n", 1177940d71d2Seschrock TOPO_PROP_NODE_ID, topo_strerror(err)); 1178940d71d2Seschrock return (-1); 1179940d71d2Seschrock } 1180940d71d2Seschrock 1181940d71d2Seschrock if (topo_prop_set_string(tn, TOPO_PGROUP_SES, 1182940d71d2Seschrock TOPO_PROP_TARGET_PATH, TOPO_PROP_IMMUTABLE, 1183940d71d2Seschrock path, &err) != 0) { 1184940d71d2Seschrock topo_mod_dprintf(mod, 1185940d71d2Seschrock "failed to create property %s: %s\n", 1186940d71d2Seschrock TOPO_PROP_TARGET_PATH, topo_strerror(err)); 1187940d71d2Seschrock return (-1); 1188940d71d2Seschrock } 1189940d71d2Seschrock 1190940d71d2Seschrock return (0); 1191940d71d2Seschrock } 1192940d71d2Seschrock 11938221efecSRobert Mustacchi /* 11948221efecSRobert Mustacchi * Iterate over the SES phy information. If any of the ports indicates that it's 11958221efecSRobert Mustacchi * a SATA device and we haven't matched any disk devices yet, that means 11968221efecSRobert Mustacchi * that the HBA was able to create a WWN for the SATA device based on its GUID, 11978221efecSRobert Mustacchi * which is good. However, SES includes the WWN for the device's STP bridge. In 11988221efecSRobert Mustacchi * theory, if the driver includes the WWN based on the SATA guid then it should 11998221efecSRobert Mustacchi * also set the bridge-port property indicating the WWN that should match the 12008221efecSRobert Mustacchi * SATA device. 12018221efecSRobert Mustacchi */ 12028221efecSRobert Mustacchi static int 12038221efecSRobert Mustacchi ses_create_disk_bridge(ses_enum_data_t *sdp, tnode_t *pnode, nvlist_t *props, 12048221efecSRobert Mustacchi tnode_t **child) 12058221efecSRobert Mustacchi { 12068221efecSRobert Mustacchi nvlist_t **phys; 12078221efecSRobert Mustacchi uint_t i, n_phys; 12088221efecSRobert Mustacchi topo_mod_t *mod = sdp->sed_mod; 12098221efecSRobert Mustacchi 12108221efecSRobert Mustacchi if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, &phys, 12118221efecSRobert Mustacchi &n_phys) != 0) 12128221efecSRobert Mustacchi return (1); 12138221efecSRobert Mustacchi 12148221efecSRobert Mustacchi for (i = 0; i < n_phys; i++) { 12158221efecSRobert Mustacchi uint64_t wwn; 12168221efecSRobert Mustacchi boolean_t sata; 12178221efecSRobert Mustacchi char wwnstr[64]; 12188221efecSRobert Mustacchi 12198221efecSRobert Mustacchi if (nvlist_lookup_uint64(phys[i], SES_SAS_PROP_ADDR, 12208221efecSRobert Mustacchi &wwn) != 0 || wwn == 0) { 12218221efecSRobert Mustacchi continue; 12228221efecSRobert Mustacchi } 12238221efecSRobert Mustacchi 12248221efecSRobert Mustacchi if (nvlist_lookup_boolean_value(phys[i], 12258221efecSRobert Mustacchi SES_SAS_PROP_SATA_DEVICE, &sata) != 0 || !sata) { 12268221efecSRobert Mustacchi continue; 12278221efecSRobert Mustacchi } 12288221efecSRobert Mustacchi 12298221efecSRobert Mustacchi if (scsi_wwn_to_wwnstr(wwn, 0, wwnstr) == NULL) 12308221efecSRobert Mustacchi continue; 12318221efecSRobert Mustacchi 12328221efecSRobert Mustacchi if (disk_declare_bridge(mod, pnode, &sdp->sed_devs, 12338221efecSRobert Mustacchi wwnstr, child) == 0) { 12348221efecSRobert Mustacchi return (0); 12358221efecSRobert Mustacchi } 12368221efecSRobert Mustacchi 12378221efecSRobert Mustacchi } 12388221efecSRobert Mustacchi 12398221efecSRobert Mustacchi return (1); 12408221efecSRobert Mustacchi } 12418221efecSRobert Mustacchi 1242940d71d2Seschrock /* 1243940d71d2Seschrock * Callback to add a disk to a given bay. We first check the status-code to 1244940d71d2Seschrock * determine if a disk is present, ignoring those that aren't in an appropriate 12450b32bb8bSEric Schrock * state. We then scan the parent bay node's SAS address array to determine 12460b32bb8bSEric Schrock * possible attached SAS addresses. We create a disk node if the disk is not 12470b32bb8bSEric Schrock * SAS or the SES target does not support the necessary pages for this; if we 12480b32bb8bSEric Schrock * find the SAS address, we create a disk node and also correlate it with 12490b32bb8bSEric Schrock * the corresponding Solaris device node to fill in the rest of the data. 1250940d71d2Seschrock */ 1251940d71d2Seschrock static int 1252940d71d2Seschrock ses_create_disk(ses_enum_data_t *sdp, tnode_t *pnode, nvlist_t *props) 1253940d71d2Seschrock { 1254940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 1255940d71d2Seschrock uint64_t status; 1256940d71d2Seschrock uint_t s, nsas; 12570b32bb8bSEric Schrock char **paths; 125844ed9dbbSStephen Hanson int err, ret; 125944ed9dbbSStephen Hanson tnode_t *child = NULL; 1260940d71d2Seschrock 1261940d71d2Seschrock /* 1262940d71d2Seschrock * Skip devices that are not in a present (and possibly damaged) state. 1263db8547feSRob Johnston * Also, skip devices that this expander is either not fully wired to, 1264db8547feSRob Johnston * or are hidden due to SAS zoning, as indicated by the 1265db8547feSRob Johnston * SES_ESC_NO_ACCESS state. 1266940d71d2Seschrock */ 1267940d71d2Seschrock if (nvlist_lookup_uint64(props, SES_PROP_STATUS_CODE, &status) != 0) 1268940d71d2Seschrock return (0); 1269940d71d2Seschrock 1270ac88567aSHyon Kim if (status != SES_ESC_UNSUPPORTED && 1271ac88567aSHyon Kim status != SES_ESC_OK && 1272940d71d2Seschrock status != SES_ESC_CRITICAL && 1273940d71d2Seschrock status != SES_ESC_NONCRITICAL && 1274940d71d2Seschrock status != SES_ESC_UNRECOVERABLE && 12759bd90b91SRobert Mustacchi status != SES_ESC_UNKNOWN) 1276940d71d2Seschrock return (0); 1277940d71d2Seschrock 1278940d71d2Seschrock topo_mod_dprintf(mod, "found attached disk"); 1279940d71d2Seschrock 1280940d71d2Seschrock /* 1281940d71d2Seschrock * Create the disk range. 1282940d71d2Seschrock */ 12830b32bb8bSEric Schrock if (topo_node_range_create(mod, pnode, DISK, 0, 0) != 0) { 1284940d71d2Seschrock topo_mod_dprintf(mod, 1285940d71d2Seschrock "topo_node_create_range() failed: %s", 1286940d71d2Seschrock topo_mod_errmsg(mod)); 1287940d71d2Seschrock return (-1); 1288940d71d2Seschrock } 1289940d71d2Seschrock 1290940d71d2Seschrock /* 1291940d71d2Seschrock * Look through all SAS addresses and attempt to correlate them to a 1292940d71d2Seschrock * known Solaris device. If we don't find a matching node, then we 1293940d71d2Seschrock * don't enumerate the disk node. 129423a5d44cSHyon Kim * Note that TOPO_PROP_SAS_ADDR prop includes SAS address from 129523a5d44cSHyon Kim * alternate elements that represent the same device. 1296940d71d2Seschrock */ 12970b32bb8bSEric Schrock if (topo_prop_get_string_array(pnode, TOPO_PGROUP_SES, 12980b32bb8bSEric Schrock TOPO_PROP_SAS_ADDR, &paths, &nsas, &err) != 0) 12990b32bb8bSEric Schrock return (0); 13000b32bb8bSEric Schrock 13010b32bb8bSEric Schrock err = 0; 13020b32bb8bSEric Schrock 1303940d71d2Seschrock for (s = 0; s < nsas; s++) { 1304ac88567aSHyon Kim ret = disk_declare_addr(mod, pnode, &sdp->sed_devs, paths[s], 130544ed9dbbSStephen Hanson &child); 130644ed9dbbSStephen Hanson if (ret == 0) { 130744ed9dbbSStephen Hanson break; 130844ed9dbbSStephen Hanson } else if (ret < 0) { 13090b32bb8bSEric Schrock err = -1; 13100b32bb8bSEric Schrock break; 13110b32bb8bSEric Schrock } 13120b32bb8bSEric Schrock } 13130b32bb8bSEric Schrock 13148221efecSRobert Mustacchi /* 13158221efecSRobert Mustacchi * We need to take another pass through the properties for this bay by 13168221efecSRobert Mustacchi * iterating over the phys and noting if any of these are SATA. Note, 13178221efecSRobert Mustacchi * this information isn't commonly part of the topo tree at this time, 13188221efecSRobert Mustacchi * hence why we end up going back and iterating over the properties 13198221efecSRobert Mustacchi * ourselves. 13208221efecSRobert Mustacchi */ 13218221efecSRobert Mustacchi if (s == nsas) { 13228221efecSRobert Mustacchi if (ses_create_disk_bridge(sdp, pnode, props, &child) != 0) 13238221efecSRobert Mustacchi (void) disk_declare_non_enumerated(mod, pnode, &child); 13248221efecSRobert Mustacchi } 132544ed9dbbSStephen Hanson 132644ed9dbbSStephen Hanson /* copy sas_addresses (target-ports) from parent (with 'w'added) */ 132744ed9dbbSStephen Hanson if (child != NULL) { 132844ed9dbbSStephen Hanson int i; 132944ed9dbbSStephen Hanson char **tports; 133044ed9dbbSStephen Hanson uint64_t wwn; 133144ed9dbbSStephen Hanson 133244ed9dbbSStephen Hanson tports = topo_mod_zalloc(mod, sizeof (char *) * nsas); 133344ed9dbbSStephen Hanson if (tports != NULL) { 133444ed9dbbSStephen Hanson for (i = 0; i < nsas; i++) { 133544ed9dbbSStephen Hanson if (scsi_wwnstr_to_wwn(paths[i], &wwn) != 133644ed9dbbSStephen Hanson DDI_SUCCESS) 133744ed9dbbSStephen Hanson break; 133844ed9dbbSStephen Hanson tports[i] = scsi_wwn_to_wwnstr(wwn, 1, NULL); 133944ed9dbbSStephen Hanson if (tports[i] == NULL) 134044ed9dbbSStephen Hanson break; 134144ed9dbbSStephen Hanson } 134244ed9dbbSStephen Hanson /* if they all worked then create the property */ 134344ed9dbbSStephen Hanson if (i == nsas) 134444ed9dbbSStephen Hanson (void) topo_prop_set_string_array(child, 134544ed9dbbSStephen Hanson TOPO_PGROUP_STORAGE, 134644ed9dbbSStephen Hanson TOPO_STORAGE_TARGET_PORT_L0IDS, 134744ed9dbbSStephen Hanson TOPO_PROP_IMMUTABLE, (const char **)tports, 134844ed9dbbSStephen Hanson nsas, &err); 134944ed9dbbSStephen Hanson 135044ed9dbbSStephen Hanson for (i = 0; i < nsas; i++) 135144ed9dbbSStephen Hanson if (tports[i] != NULL) 135244ed9dbbSStephen Hanson scsi_free_wwnstr(tports[i]); 135344ed9dbbSStephen Hanson topo_mod_free(mod, tports, sizeof (char *) * nsas); 135444ed9dbbSStephen Hanson } 135544ed9dbbSStephen Hanson } 135644ed9dbbSStephen Hanson 13570b32bb8bSEric Schrock for (s = 0; s < nsas; s++) 13580b32bb8bSEric Schrock topo_mod_free(mod, paths[s], strlen(paths[s]) + 1); 13590b32bb8bSEric Schrock topo_mod_free(mod, paths, nsas * sizeof (char *)); 13600b32bb8bSEric Schrock 13610b32bb8bSEric Schrock return (err); 13620b32bb8bSEric Schrock } 13630b32bb8bSEric Schrock 13640b32bb8bSEric Schrock static int 13650b32bb8bSEric Schrock ses_add_bay_props(topo_mod_t *mod, tnode_t *tn, ses_enum_node_t *snp) 13660b32bb8bSEric Schrock { 13670b32bb8bSEric Schrock ses_alt_node_t *ap; 13680b32bb8bSEric Schrock ses_node_t *np; 13690b32bb8bSEric Schrock nvlist_t *props; 13700b32bb8bSEric Schrock 13710b32bb8bSEric Schrock nvlist_t **phys; 13720b32bb8bSEric Schrock uint_t i, j, n_phys, all_phys = 0; 13730b32bb8bSEric Schrock char **paths; 13740b32bb8bSEric Schrock uint64_t addr; 13750b32bb8bSEric Schrock size_t len; 13760b32bb8bSEric Schrock int terr, err = -1; 13770b32bb8bSEric Schrock 13780b32bb8bSEric Schrock for (ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL; 13790b32bb8bSEric Schrock ap = topo_list_next(ap)) { 13800b32bb8bSEric Schrock np = ap->san_node; 13810b32bb8bSEric Schrock props = ses_node_props(np); 13820b32bb8bSEric Schrock 13830b32bb8bSEric Schrock if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 13840b32bb8bSEric Schrock &phys, &n_phys) != 0) 13850b32bb8bSEric Schrock continue; 13860b32bb8bSEric Schrock 13870b32bb8bSEric Schrock all_phys += n_phys; 13880b32bb8bSEric Schrock } 13890b32bb8bSEric Schrock 13900b32bb8bSEric Schrock if (all_phys == 0) 13910b32bb8bSEric Schrock return (0); 13920b32bb8bSEric Schrock 13930b32bb8bSEric Schrock if ((paths = topo_mod_zalloc(mod, all_phys * sizeof (char *))) == NULL) 13940b32bb8bSEric Schrock return (-1); 13950b32bb8bSEric Schrock 13960b32bb8bSEric Schrock for (i = 0, ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL; 13970b32bb8bSEric Schrock ap = topo_list_next(ap)) { 13980b32bb8bSEric Schrock np = ap->san_node; 13990b32bb8bSEric Schrock props = ses_node_props(np); 14000b32bb8bSEric Schrock 14010b32bb8bSEric Schrock if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 14020b32bb8bSEric Schrock &phys, &n_phys) != 0) 1403940d71d2Seschrock continue; 1404940d71d2Seschrock 14050b32bb8bSEric Schrock for (j = 0; j < n_phys; j++) { 14060b32bb8bSEric Schrock if (nvlist_lookup_uint64(phys[j], SES_SAS_PROP_ADDR, 14070b32bb8bSEric Schrock &addr) != 0) 14080b32bb8bSEric Schrock continue; 1409940d71d2Seschrock 14100b32bb8bSEric Schrock len = snprintf(NULL, 0, "%016llx", addr) + 1; 14110b32bb8bSEric Schrock if ((paths[i] = topo_mod_alloc(mod, len)) == NULL) 14120b32bb8bSEric Schrock goto error; 14130b32bb8bSEric Schrock 14140b32bb8bSEric Schrock (void) snprintf(paths[i], len, "%016llx", addr); 14150b32bb8bSEric Schrock 14160b32bb8bSEric Schrock ++i; 14170b32bb8bSEric Schrock } 1418940d71d2Seschrock } 1419940d71d2Seschrock 14200b32bb8bSEric Schrock err = topo_prop_set_string_array(tn, TOPO_PGROUP_SES, 14210b32bb8bSEric Schrock TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE, 14220b32bb8bSEric Schrock (const char **)paths, i, &terr); 14230b32bb8bSEric Schrock if (err != 0) 14240b32bb8bSEric Schrock err = topo_mod_seterrno(mod, terr); 14250b32bb8bSEric Schrock 14260b32bb8bSEric Schrock error: 14270b32bb8bSEric Schrock for (i = 0; i < all_phys && paths[i] != NULL; i++) 14280b32bb8bSEric Schrock topo_mod_free(mod, paths[i], strlen(paths[i]) + 1); 14290b32bb8bSEric Schrock topo_mod_free(mod, paths, all_phys * sizeof (char *)); 14300b32bb8bSEric Schrock 14310b32bb8bSEric Schrock return (err); 1432940d71d2Seschrock } 1433940d71d2Seschrock 1434*317c37f3SRob Johnston static const char * 1435*317c37f3SRob Johnston lookup_bay_override(const char *product_id) 1436*317c37f3SRob Johnston { 1437*317c37f3SRob Johnston for (uint_t i = 0; i < N_BAY_LBL_OVERRIDES; i++) { 1438*317c37f3SRob Johnston if (strcmp(product_id, 1439*317c37f3SRob Johnston bay_label_overrides[i].slbl_product) == 0) { 1440*317c37f3SRob Johnston return (bay_label_overrides[i].slbl_mname); 1441*317c37f3SRob Johnston } 1442*317c37f3SRob Johnston } 1443*317c37f3SRob Johnston return (NULL); 1444*317c37f3SRob Johnston } 1445*317c37f3SRob Johnston 1446940d71d2Seschrock /* 1447ac88567aSHyon Kim * Callback to create a basic node (bay, psu, fan, or controller and expander). 1448940d71d2Seschrock */ 1449940d71d2Seschrock static int 1450ded93414SHyon Kim ses_create_generic(ses_enum_data_t *sdp, ses_enum_node_t *snp, tnode_t *pnode, 1451ded93414SHyon Kim tnode_t *frutn, const char *nodename, const char *labelname, 1452ded93414SHyon Kim tnode_t **node) 1453940d71d2Seschrock { 1454940d71d2Seschrock ses_node_t *np = snp->sen_node; 1455d91236feSeschrock ses_node_t *parent; 1456940d71d2Seschrock uint64_t instance = snp->sen_instance; 1457940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 1458940d71d2Seschrock nvlist_t *props, *aprops; 1459940d71d2Seschrock nvlist_t *auth = NULL, *fmri = NULL; 1460ded93414SHyon Kim tnode_t *tn = NULL; 1461469735ecSRob Johnston char *clean_label = NULL, label[128]; 1462940d71d2Seschrock int err; 1463d91236feSeschrock char *part = NULL, *serial = NULL, *revision = NULL; 1464d91236feSeschrock char *desc; 1465d91236feSeschrock boolean_t report; 1466940d71d2Seschrock 1467940d71d2Seschrock props = ses_node_props(np); 1468940d71d2Seschrock 1469940d71d2Seschrock (void) nvlist_lookup_string(props, LIBSES_PROP_PART, &part); 1470940d71d2Seschrock (void) nvlist_lookup_string(props, LIBSES_PROP_SERIAL, &serial); 1471940d71d2Seschrock 1472940d71d2Seschrock topo_mod_dprintf(mod, "adding %s %llu", nodename, instance); 1473940d71d2Seschrock 1474940d71d2Seschrock /* 1475940d71d2Seschrock * Create the node. The interesting information is all copied from the 1476940d71d2Seschrock * parent enclosure node, so there is not much to do. 1477940d71d2Seschrock */ 1478940d71d2Seschrock if ((auth = topo_mod_auth(mod, pnode)) == NULL) 1479940d71d2Seschrock goto error; 1480940d71d2Seschrock 1481d91236feSeschrock /* 1482d91236feSeschrock * We want to report revision information for the controller nodes, but 1483d91236feSeschrock * we do not get per-element revision information. However, we do have 1484d91236feSeschrock * revision information for the entire enclosure, and we can use the 1485d91236feSeschrock * 'reported-via' property to know that this controller corresponds to 1486d91236feSeschrock * the given revision information. This means we cannot get revision 1487d91236feSeschrock * information for targets we are not explicitly connected to, but 1488d91236feSeschrock * there is little we can do about the situation. 1489d91236feSeschrock */ 1490d91236feSeschrock if (strcmp(nodename, CONTROLLER) == 0 && 1491d91236feSeschrock nvlist_lookup_boolean_value(props, SES_PROP_REPORT, &report) == 0 && 1492d91236feSeschrock report) { 1493d91236feSeschrock for (parent = ses_node_parent(np); parent != NULL; 1494d91236feSeschrock parent = ses_node_parent(parent)) { 1495d91236feSeschrock if (ses_node_type(parent) == SES_NODE_ENCLOSURE) { 1496d91236feSeschrock (void) nvlist_lookup_string( 1497d91236feSeschrock ses_node_props(parent), 1498d91236feSeschrock SES_EN_PROP_REV, &revision); 1499d91236feSeschrock break; 1500d91236feSeschrock } 1501d91236feSeschrock } 1502d91236feSeschrock } 1503d91236feSeschrock 1504940d71d2Seschrock if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION, 1505d91236feSeschrock nodename, (topo_instance_t)instance, NULL, auth, part, revision, 1506940d71d2Seschrock serial)) == NULL) { 1507940d71d2Seschrock topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s", 1508940d71d2Seschrock topo_mod_errmsg(mod)); 1509940d71d2Seschrock goto error; 1510940d71d2Seschrock } 1511940d71d2Seschrock 1512940d71d2Seschrock if ((tn = topo_node_bind(mod, pnode, nodename, 1513940d71d2Seschrock instance, fmri)) == NULL) { 1514940d71d2Seschrock topo_mod_dprintf(mod, "topo_node_bind() failed: %s", 1515940d71d2Seschrock topo_mod_errmsg(mod)); 1516940d71d2Seschrock goto error; 1517940d71d2Seschrock } 1518940d71d2Seschrock 1519940d71d2Seschrock /* 1520d91236feSeschrock * For the node label, we look for the following in order: 1521d91236feSeschrock * 1522cbb9248eSRob Johnston * <ses-description> 1523cbb9248eSRob Johnston * <ses-class-description> <instance> 1524cbb9248eSRob Johnston * <default-type-label> <instance> 1525940d71d2Seschrock */ 1526d91236feSeschrock if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 || 1527d91236feSeschrock desc[0] == '\0') { 1528d91236feSeschrock parent = ses_node_parent(np); 1529d91236feSeschrock aprops = ses_node_props(parent); 1530d91236feSeschrock if (nvlist_lookup_string(aprops, SES_PROP_CLASS_DESCRIPTION, 1531ac88567aSHyon Kim &desc) != 0 || desc[0] == '\0') 1532ac88567aSHyon Kim desc = (char *)labelname; 1533d91236feSeschrock (void) snprintf(label, sizeof (label), "%s %llu", desc, 1534d91236feSeschrock instance); 1535d91236feSeschrock desc = label; 1536d91236feSeschrock } 1537d91236feSeschrock 1538469735ecSRob Johnston if ((clean_label = topo_mod_clean_str(mod, desc)) == NULL) 1539469735ecSRob Johnston goto error; 1540469735ecSRob Johnston 1541469735ecSRob Johnston if (topo_prop_set_string(tn, TOPO_PGROUP_PROTOCOL, TOPO_PROP_LABEL, 1542469735ecSRob Johnston TOPO_PROP_MUTABLE, clean_label, &err) < 0) 1543940d71d2Seschrock goto error; 1544940d71d2Seschrock 1545ac88567aSHyon Kim if (ses_set_standard_props(mod, frutn, tn, NULL, ses_node_id(np), 1546940d71d2Seschrock snp->sen_target->set_devpath) != 0) 1547940d71d2Seschrock goto error; 1548940d71d2Seschrock 1549ac88567aSHyon Kim if (strcmp(nodename, BAY) == 0) { 1550*317c37f3SRob Johnston const char *label_method; 1551*317c37f3SRob Johnston char *product; 1552*317c37f3SRob Johnston nvlist_t *args = NULL; 15530b32bb8bSEric Schrock 1554*317c37f3SRob Johnston if (ses_add_bay_props(mod, tn, snp) != 0) 1555940d71d2Seschrock goto error; 1556d91236feSeschrock 1557d91236feSeschrock if (topo_method_register(mod, tn, ses_bay_methods) != 0) { 1558d91236feSeschrock topo_mod_dprintf(mod, 1559d91236feSeschrock "topo_method_register() failed: %s", 1560d91236feSeschrock topo_mod_errmsg(mod)); 1561d91236feSeschrock goto error; 1562d91236feSeschrock } 1563*317c37f3SRob Johnston 1564*317c37f3SRob Johnston /* 1565*317c37f3SRob Johnston * Ideally we'd perform this sort of override with a platform 1566*317c37f3SRob Johnston * specific XML map file, and that would work here if we only 1567*317c37f3SRob Johnston * wanted to override the bay node label. However, we'd also 1568*317c37f3SRob Johnston * like the disk node label (if the bay is occupied) to inherit 1569*317c37f3SRob Johnston * the overriden bay label. So we need to ensure the 1570*317c37f3SRob Johnston * propmethod is registered before we create the child disk 1571*317c37f3SRob Johnston * node. 1572*317c37f3SRob Johnston */ 1573*317c37f3SRob Johnston if ((product = topo_mod_product(mod)) == NULL) { 1574*317c37f3SRob Johnston (void) topo_mod_seterrno(mod, EMOD_NOMEM); 1575*317c37f3SRob Johnston goto error; 1576*317c37f3SRob Johnston } 1577*317c37f3SRob Johnston if ((label_method = lookup_bay_override(product)) != NULL) { 1578*317c37f3SRob Johnston if (topo_mod_nvalloc(mod, &args, NV_UNIQUE_NAME) != 0 || 1579*317c37f3SRob Johnston topo_prop_method_register(tn, TOPO_PGROUP_PROTOCOL, 1580*317c37f3SRob Johnston TOPO_PROP_LABEL, TOPO_TYPE_STRING, label_method, 1581*317c37f3SRob Johnston args, &err)) { 1582*317c37f3SRob Johnston topo_mod_dprintf(mod, 1583*317c37f3SRob Johnston "Failed to register method: %s on %s=%" 1584*317c37f3SRob Johnston PRIu64, label_method, BAY, 1585*317c37f3SRob Johnston topo_node_instance(tn)); 1586*317c37f3SRob Johnston topo_mod_strfree(mod, product); 1587*317c37f3SRob Johnston nvlist_free(args); 1588*317c37f3SRob Johnston goto error; 1589*317c37f3SRob Johnston } 1590*317c37f3SRob Johnston nvlist_free(args); 1591*317c37f3SRob Johnston } 1592*317c37f3SRob Johnston topo_mod_strfree(mod, product); 1593*317c37f3SRob Johnston 1594*317c37f3SRob Johnston if (ses_create_disk(sdp, tn, props) != 0) 1595*317c37f3SRob Johnston goto error; 1596ac88567aSHyon Kim } else if ((strcmp(nodename, FAN) == 0) || 1597ac88567aSHyon Kim (strcmp(nodename, PSU) == 0) || 1598ac88567aSHyon Kim (strcmp(nodename, CONTROLLER) == 0)) { 1599940d71d2Seschrock /* 1600d91236feSeschrock * Only fan, psu, and controller nodes have a 'present' method. 1601d91236feSeschrock * Bay nodes are always present, and disk nodes are present by 1602ac88567aSHyon Kim * virtue of being enumerated and SAS expander nodes and 1603ac88567aSHyon Kim * SAS connector nodes are also always present once 1604ac88567aSHyon Kim * the parent controller is found. 1605940d71d2Seschrock */ 1606940d71d2Seschrock if (topo_method_register(mod, tn, ses_component_methods) != 0) { 1607940d71d2Seschrock topo_mod_dprintf(mod, 1608940d71d2Seschrock "topo_method_register() failed: %s", 1609940d71d2Seschrock topo_mod_errmsg(mod)); 1610940d71d2Seschrock goto error; 1611940d71d2Seschrock } 1612940d71d2Seschrock 1613940d71d2Seschrock } 1614940d71d2Seschrock 1615d91236feSeschrock snp->sen_target->set_refcount++; 1616d91236feSeschrock topo_node_setspecific(tn, snp->sen_target); 1617d91236feSeschrock 1618940d71d2Seschrock nvlist_free(auth); 1619940d71d2Seschrock nvlist_free(fmri); 1620469735ecSRob Johnston topo_mod_strfree(mod, clean_label); 1621ac88567aSHyon Kim if (node != NULL) *node = tn; 1622ac88567aSHyon Kim return (0); 1623ac88567aSHyon Kim 1624ac88567aSHyon Kim error: 1625ac88567aSHyon Kim nvlist_free(auth); 1626ac88567aSHyon Kim nvlist_free(fmri); 1627469735ecSRob Johnston topo_mod_strfree(mod, clean_label); 1628ac88567aSHyon Kim return (-1); 1629ac88567aSHyon Kim } 1630ac88567aSHyon Kim 1631ac88567aSHyon Kim /* 1632ac88567aSHyon Kim * Create SAS expander specific props. 1633ac88567aSHyon Kim */ 1634ac88567aSHyon Kim /*ARGSUSED*/ 1635ac88567aSHyon Kim static int 1636ac88567aSHyon Kim ses_set_expander_props(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1637ac88567aSHyon Kim tnode_t *ptnode, tnode_t *tnode, int *phycount, int64_t *connlist) 1638ac88567aSHyon Kim { 1639ac88567aSHyon Kim ses_node_t *np = snp->sen_node; 1640ac88567aSHyon Kim topo_mod_t *mod = sdp->sed_mod; 1641ac88567aSHyon Kim nvlist_t *auth = NULL, *fmri = NULL; 1642ac88567aSHyon Kim nvlist_t *props, **phylist; 1643ac88567aSHyon Kim int err, i; 1644ac88567aSHyon Kim uint_t pcount; 1645ac88567aSHyon Kim uint64_t sasaddr, connidx; 1646ac88567aSHyon Kim char sasaddr_str[17]; 1647b4879163SHyon Kim boolean_t found = B_FALSE, ses_found = B_FALSE; 1648b4879163SHyon Kim dev_di_node_t *dnode, *sesdnode; 1649ac88567aSHyon Kim 1650ac88567aSHyon Kim props = ses_node_props(np); 1651ac88567aSHyon Kim 1652ac88567aSHyon Kim /* 1653ac88567aSHyon Kim * the uninstalled expander is not enumerated by checking 1654ac88567aSHyon Kim * the element status code. No present present' method provided. 1655ac88567aSHyon Kim */ 1656ac88567aSHyon Kim /* 1657ac88567aSHyon Kim * Get the Expander SAS address. It should exist. 1658ac88567aSHyon Kim */ 1659ac88567aSHyon Kim if (nvlist_lookup_uint64(props, SES_EXP_PROP_SAS_ADDR, 1660ac88567aSHyon Kim &sasaddr) != 0) { 1661ac88567aSHyon Kim topo_mod_dprintf(mod, 1662ac88567aSHyon Kim "Failed to get prop %s.", SES_EXP_PROP_SAS_ADDR); 1663ac88567aSHyon Kim goto error; 1664ac88567aSHyon Kim } 1665ac88567aSHyon Kim 1666ac88567aSHyon Kim (void) sprintf(sasaddr_str, "%llx", sasaddr); 1667ac88567aSHyon Kim 1668ac88567aSHyon Kim /* search matching dev_di_node. */ 1669ac88567aSHyon Kim for (dnode = topo_list_next(&sdp->sed_devs); dnode != NULL; 1670ac88567aSHyon Kim dnode = topo_list_next(dnode)) { 1671b4879163SHyon Kim for (i = 0; i < dnode->ddn_ppath_count; i++) { 1672b4879163SHyon Kim if ((dnode->ddn_target_port[i] != NULL) && 1673b4879163SHyon Kim (strstr(dnode->ddn_target_port[i], 1674b4879163SHyon Kim sasaddr_str) != NULL)) { 1675b4879163SHyon Kim found = B_TRUE; 1676b4879163SHyon Kim break; 1677b4879163SHyon Kim } 1678ac88567aSHyon Kim } 1679b4879163SHyon Kim if (found) 1680b4879163SHyon Kim break; 1681ac88567aSHyon Kim } 1682ac88567aSHyon Kim 1683ac88567aSHyon Kim if (!found) { 1684ac88567aSHyon Kim topo_mod_dprintf(mod, 1685ac88567aSHyon Kim "ses_set_expander_props: Failed to find matching " 1686ac88567aSHyon Kim "devinfo node for Exapnder SAS address %s", 1687ac88567aSHyon Kim SES_EXP_PROP_SAS_ADDR); 1688ac88567aSHyon Kim /* continue on to get storage group props. */ 1689ac88567aSHyon Kim } else { 1690b4879163SHyon Kim /* create/set the devfs-path and devid in the smp group */ 1691b4879163SHyon Kim if (topo_pgroup_create(tnode, &smp_pgroup, &err) != 0) { 1692ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1693b4879163SHyon Kim "failed to create smp property group %s\n", 1694b4879163SHyon Kim topo_strerror(err)); 1695ac88567aSHyon Kim goto error; 1696ac88567aSHyon Kim } else { 1697b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP, 1698b4879163SHyon Kim TOPO_PROP_SMP_TARGET_PORT, TOPO_PROP_IMMUTABLE, 1699b4879163SHyon Kim dnode->ddn_target_port[i], &err) != 0) { 1700b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1701b4879163SHyon Kim "set %S error %s\n", TOPO_PROP_SAS_ADDR, 1702b4879163SHyon Kim topo_strerror(err)); 1703b4879163SHyon Kim } 1704b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP, 1705b4879163SHyon Kim TOPO_PROP_SMP_DEV_PATH, TOPO_PROP_IMMUTABLE, 1706ac88567aSHyon Kim dnode->ddn_dpath, &err) != 0) { 1707ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1708ac88567aSHyon Kim "set dev error %s\n", topo_strerror(err)); 1709ac88567aSHyon Kim } 1710b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP, 1711b4879163SHyon Kim TOPO_PROP_SMP_DEVID, TOPO_PROP_IMMUTABLE, 1712ac88567aSHyon Kim dnode->ddn_devid, &err) != 0) { 1713ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1714ac88567aSHyon Kim "set devid error %s\n", topo_strerror(err)); 1715ac88567aSHyon Kim } 1716ac88567aSHyon Kim if (dnode->ddn_ppath_count != 0 && 1717b4879163SHyon Kim topo_prop_set_string_array(tnode, TOPO_PGROUP_SMP, 1718b4879163SHyon Kim TOPO_PROP_SMP_PHYS_PATH, TOPO_PROP_IMMUTABLE, 1719ac88567aSHyon Kim (const char **)dnode->ddn_ppath, 1720ac88567aSHyon Kim dnode->ddn_ppath_count, &err) != 0) { 1721ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1722ac88567aSHyon Kim "set phys-path error %s\n", 1723ac88567aSHyon Kim topo_strerror(err)); 1724ac88567aSHyon Kim } 1725ac88567aSHyon Kim } 1726ac88567aSHyon Kim } 1727ac88567aSHyon Kim 1728b4879163SHyon Kim /* update the ses property group with SES target info */ 1729ded93414SHyon Kim if ((topo_pgroup_create(tnode, &ses_pgroup, &err) != 0) && 1730a961ec00SHyon Kim (err != ETOPO_PROP_DEFD)) { 1731a961ec00SHyon Kim /* SES prop group doesn't exist but failed to be created. */ 1732b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1733a961ec00SHyon Kim "ses pgroup create error %s\n", topo_strerror(err)); 1734b4879163SHyon Kim goto error; 1735b4879163SHyon Kim } else { 1736b4879163SHyon Kim /* locate assciated enclosure dev_di_node. */ 1737b4879163SHyon Kim for (sesdnode = topo_list_next(&sdp->sed_devs); 1738b4879163SHyon Kim sesdnode != NULL; sesdnode = topo_list_next(sesdnode)) { 1739b4879163SHyon Kim for (i = 0; i < sesdnode->ddn_ppath_count; i++) { 1740b4879163SHyon Kim /* 1741b4879163SHyon Kim * check if attached port exists and 1742b4879163SHyon Kim * its node type is enclosure and 1743b4879163SHyon Kim * attached port is same as sas address of 1744b4879163SHyon Kim * the expander and 1745b4879163SHyon Kim * bridge port for virtual phy indication 1746b4879163SHyon Kim * exist. 1747b4879163SHyon Kim */ 1748b4879163SHyon Kim if ((sesdnode->ddn_attached_port[i] != NULL) && 1749b4879163SHyon Kim (sesdnode->ddn_dtype == DTYPE_ESI) && 1750b4879163SHyon Kim (strstr(sesdnode->ddn_attached_port[i], 1751b4879163SHyon Kim sasaddr_str) != NULL) && 1752b4879163SHyon Kim (sesdnode->ddn_bridge_port[i] != NULL)) { 1753b4879163SHyon Kim ses_found = B_TRUE; 1754b4879163SHyon Kim break; 1755b4879163SHyon Kim } 1756b4879163SHyon Kim } 1757b4879163SHyon Kim if (ses_found) break; 1758b4879163SHyon Kim } 1759b4879163SHyon Kim 1760b4879163SHyon Kim if (ses_found) { 1761b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SES, 1762b4879163SHyon Kim TOPO_PROP_SES_TARGET_PORT, TOPO_PROP_IMMUTABLE, 1763b4879163SHyon Kim sesdnode->ddn_target_port[i], &err) != 0) { 1764b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1765b4879163SHyon Kim "set ses %S error %s\n", TOPO_PROP_SAS_ADDR, 1766b4879163SHyon Kim topo_strerror(err)); 1767b4879163SHyon Kim } 1768b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SES, 1769b4879163SHyon Kim TOPO_PROP_SES_DEV_PATH, TOPO_PROP_IMMUTABLE, 1770b4879163SHyon Kim sesdnode->ddn_dpath, &err) != 0) { 1771b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1772b4879163SHyon Kim "set ses dev error %s\n", 1773b4879163SHyon Kim topo_strerror(err)); 1774b4879163SHyon Kim } 1775b4879163SHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_SES, 1776b4879163SHyon Kim TOPO_PROP_SES_DEVID, TOPO_PROP_IMMUTABLE, 1777b4879163SHyon Kim sesdnode->ddn_devid, &err) != 0) { 1778b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1779b4879163SHyon Kim "set ses devid error %s\n", 1780b4879163SHyon Kim topo_strerror(err)); 1781b4879163SHyon Kim } 1782b4879163SHyon Kim if (sesdnode->ddn_ppath_count != 0 && 1783b4879163SHyon Kim topo_prop_set_string_array(tnode, TOPO_PGROUP_SES, 1784b4879163SHyon Kim TOPO_PROP_SES_PHYS_PATH, TOPO_PROP_IMMUTABLE, 1785b4879163SHyon Kim (const char **)sesdnode->ddn_ppath, 1786b4879163SHyon Kim sesdnode->ddn_ppath_count, &err) != 0) { 1787b4879163SHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1788b4879163SHyon Kim "set ses phys-path error %s\n", 1789b4879163SHyon Kim topo_strerror(err)); 1790b4879163SHyon Kim } 1791b4879163SHyon Kim 1792b4879163SHyon Kim } 1793b4879163SHyon Kim } 1794b4879163SHyon Kim 1795ac88567aSHyon Kim /* create the storage group */ 1796ac88567aSHyon Kim if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) { 1797ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1798ac88567aSHyon Kim "create storage error %s\n", topo_strerror(err)); 1799ac88567aSHyon Kim goto error; 1800ac88567aSHyon Kim } else { 1801b4879163SHyon Kim /* set the SAS address prop out of expander element status. */ 1802ac88567aSHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE, 1803ac88567aSHyon Kim TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE, sasaddr_str, 1804ac88567aSHyon Kim &err) != 0) { 1805ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1806ac88567aSHyon Kim "set %S error %s\n", TOPO_PROP_SAS_ADDR, 1807ac88567aSHyon Kim topo_strerror(err)); 1808ac88567aSHyon Kim } 1809ac88567aSHyon Kim 1810ac88567aSHyon Kim /* Get the phy information for the expander */ 1811ac88567aSHyon Kim if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, 1812ac88567aSHyon Kim &phylist, &pcount) != 0) { 1813ac88567aSHyon Kim topo_mod_dprintf(mod, 1814ac88567aSHyon Kim "Failed to get prop %s.", SES_SAS_PROP_PHYS); 1815ac88567aSHyon Kim } else { 1816ac88567aSHyon Kim /* 1817ac88567aSHyon Kim * For each phy, get the connector element index and 1818ac88567aSHyon Kim * stores into connector element index array. 1819ac88567aSHyon Kim */ 1820ac88567aSHyon Kim *phycount = pcount; 1821ac88567aSHyon Kim for (i = 0; i < pcount; i++) { 1822ac88567aSHyon Kim if (nvlist_lookup_uint64(phylist[i], 1823ac88567aSHyon Kim SES_PROP_CE_IDX, &connidx) == 0) { 1824ac88567aSHyon Kim if (connidx != 0xff) { 1825ac88567aSHyon Kim connlist[i] = connidx; 1826ac88567aSHyon Kim } else { 1827ac88567aSHyon Kim connlist[i] = -1; 1828ac88567aSHyon Kim } 1829ac88567aSHyon Kim } else { 1830ac88567aSHyon Kim /* Fail to get the index. set to -1. */ 1831ac88567aSHyon Kim connlist[i] = -1; 1832ac88567aSHyon Kim } 1833ac88567aSHyon Kim } 1834ac88567aSHyon Kim 1835ac88567aSHyon Kim /* set the phy count prop of the expander. */ 1836ac88567aSHyon Kim if (topo_prop_set_uint64(tnode, TOPO_PGROUP_STORAGE, 1837ac88567aSHyon Kim TOPO_PROP_PHY_COUNT, TOPO_PROP_IMMUTABLE, pcount, 1838ac88567aSHyon Kim &err) != 0) { 1839ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1840ac88567aSHyon Kim "set %S error %s\n", TOPO_PROP_PHY_COUNT, 1841ac88567aSHyon Kim topo_strerror(err)); 1842ac88567aSHyon Kim } 1843ac88567aSHyon Kim 1844ac88567aSHyon Kim /* 1845ac88567aSHyon Kim * set the connector element index of 1846ac88567aSHyon Kim * the expander phys. 1847ac88567aSHyon Kim */ 1848ac88567aSHyon Kim } 1849ac88567aSHyon Kim 1850ac88567aSHyon Kim /* populate other misc storage group properties */ 1851ac88567aSHyon Kim if (found) { 1852ac88567aSHyon Kim if (dnode->ddn_mfg && (topo_prop_set_string(tnode, 1853ac88567aSHyon Kim TOPO_PGROUP_STORAGE, TOPO_STORAGE_MANUFACTURER, 1854ac88567aSHyon Kim TOPO_PROP_IMMUTABLE, dnode->ddn_mfg, &err) != 0)) { 1855ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1856ac88567aSHyon Kim "set mfg error %s\n", topo_strerror(err)); 1857ac88567aSHyon Kim } 1858ac88567aSHyon Kim 1859ac88567aSHyon Kim if (dnode->ddn_model && (topo_prop_set_string(tnode, 1860ac88567aSHyon Kim TOPO_PGROUP_STORAGE, TOPO_STORAGE_MODEL, 1861ac88567aSHyon Kim TOPO_PROP_IMMUTABLE, 1862ac88567aSHyon Kim dnode->ddn_model, &err) != 0)) { 1863ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1864ac88567aSHyon Kim "set model error %s\n", topo_strerror(err)); 1865ac88567aSHyon Kim } 1866ac88567aSHyon Kim 1867ac88567aSHyon Kim if (dnode->ddn_serial && (topo_prop_set_string(tnode, 1868ac88567aSHyon Kim TOPO_PGROUP_STORAGE, TOPO_STORAGE_SERIAL_NUM, 1869ac88567aSHyon Kim TOPO_PROP_IMMUTABLE, 1870ac88567aSHyon Kim dnode->ddn_serial, &err) != 0)) { 1871ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1872ac88567aSHyon Kim "set serial error %s\n", 1873ac88567aSHyon Kim topo_strerror(err)); 1874ac88567aSHyon Kim } 1875ac88567aSHyon Kim 1876ac88567aSHyon Kim if (dnode->ddn_firm && (topo_prop_set_string(tnode, 1877ac88567aSHyon Kim TOPO_PGROUP_STORAGE, 1878ac88567aSHyon Kim TOPO_STORAGE_FIRMWARE_REV, TOPO_PROP_IMMUTABLE, 1879ac88567aSHyon Kim dnode->ddn_firm, &err) != 0)) { 1880ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1881ac88567aSHyon Kim "set firm error %s\n", topo_strerror(err)); 1882ac88567aSHyon Kim } 1883ac88567aSHyon Kim } 1884ac88567aSHyon Kim } 1885ac88567aSHyon Kim 1886940d71d2Seschrock return (0); 1887940d71d2Seschrock 1888940d71d2Seschrock error: 1889940d71d2Seschrock nvlist_free(auth); 1890940d71d2Seschrock nvlist_free(fmri); 1891940d71d2Seschrock return (-1); 1892940d71d2Seschrock } 1893940d71d2Seschrock 1894ac88567aSHyon Kim /* 1895ac88567aSHyon Kim * Create SAS expander specific props. 1896ac88567aSHyon Kim */ 1897ac88567aSHyon Kim /*ARGSUSED*/ 1898ac88567aSHyon Kim static int 1899ac88567aSHyon Kim ses_set_connector_props(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1900ac88567aSHyon Kim tnode_t *tnode, int64_t phy_mask) 1901ac88567aSHyon Kim { 1902ac88567aSHyon Kim ses_node_t *np = snp->sen_node; 1903ac88567aSHyon Kim topo_mod_t *mod = sdp->sed_mod; 1904ac88567aSHyon Kim nvlist_t *props; 1905ac88567aSHyon Kim int err, i; 1906ac88567aSHyon Kim uint64_t conntype; 1907ac88567aSHyon Kim char phymask_str[17], *conntype_str; 1908ac88567aSHyon Kim boolean_t found; 1909ac88567aSHyon Kim 1910ac88567aSHyon Kim props = ses_node_props(np); 1911ac88567aSHyon Kim 1912ac88567aSHyon Kim /* 1913ac88567aSHyon Kim * convert phy mask to string. 1914ac88567aSHyon Kim */ 1915ac88567aSHyon Kim (void) snprintf(phymask_str, 17, "%llx", phy_mask); 1916ac88567aSHyon Kim 1917ac88567aSHyon Kim /* create the storage group */ 1918ac88567aSHyon Kim if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) { 1919ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1920ac88567aSHyon Kim "create storage error %s\n", topo_strerror(err)); 1921ac88567aSHyon Kim return (-1); 1922ac88567aSHyon Kim } else { 1923ac88567aSHyon Kim /* set the SAS address prop of the expander. */ 1924ac88567aSHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE, 1925ac88567aSHyon Kim TOPO_STORAGE_SAS_PHY_MASK, TOPO_PROP_IMMUTABLE, 1926ac88567aSHyon Kim phymask_str, &err) != 0) { 1927ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1928ac88567aSHyon Kim "set %S error %s\n", TOPO_STORAGE_SAS_PHY_MASK, 1929ac88567aSHyon Kim topo_strerror(err)); 1930ac88567aSHyon Kim } 1931ac88567aSHyon Kim 1932ac88567aSHyon Kim /* Get the connector type information for the expander */ 1933ac88567aSHyon Kim if (nvlist_lookup_uint64(props, 1934ac88567aSHyon Kim SES_SC_PROP_CONNECTOR_TYPE, &conntype) != 0) { 1935ac88567aSHyon Kim topo_mod_dprintf(mod, "Failed to get prop %s.", 1936ac88567aSHyon Kim TOPO_STORAGE_SAS_PHY_MASK); 1937ac88567aSHyon Kim } else { 1938ac88567aSHyon Kim found = B_FALSE; 1939ac88567aSHyon Kim for (i = 0; ; i++) { 1940ded93414SHyon Kim if (sas_connector_type_list[i].sct_type == 1941ac88567aSHyon Kim SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) { 1942ac88567aSHyon Kim break; 1943ac88567aSHyon Kim } 1944ded93414SHyon Kim if (sas_connector_type_list[i].sct_type == 1945ac88567aSHyon Kim conntype) { 1946ac88567aSHyon Kim conntype_str = 1947ded93414SHyon Kim sas_connector_type_list[i].sct_name; 1948ac88567aSHyon Kim found = B_TRUE; 1949ac88567aSHyon Kim break; 1950ac88567aSHyon Kim } 1951ac88567aSHyon Kim } 1952ac88567aSHyon Kim 1953ac88567aSHyon Kim if (!found) { 1954ac88567aSHyon Kim if (conntype < 1955ac88567aSHyon Kim SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) { 1956ac88567aSHyon Kim conntype_str = 1957ac88567aSHyon Kim SAS_CONNECTOR_TYPE_RESERVED; 1958ac88567aSHyon Kim } else { 1959ac88567aSHyon Kim conntype_str = 1960ac88567aSHyon Kim SAS_CONNECTOR_TYPE_NOT_DEFINED; 1961ac88567aSHyon Kim } 1962ac88567aSHyon Kim } 1963ac88567aSHyon Kim 1964ac88567aSHyon Kim /* set the phy count prop of the expander. */ 1965ac88567aSHyon Kim if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE, 1966ac88567aSHyon Kim TOPO_STORAGE_SAS_CONNECTOR_TYPE, 1967ac88567aSHyon Kim TOPO_PROP_IMMUTABLE, conntype_str, &err) != 0) { 1968ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_set_expander_props: " 1969ac88567aSHyon Kim "set %S error %s\n", TOPO_PROP_PHY_COUNT, 1970ac88567aSHyon Kim topo_strerror(err)); 1971ac88567aSHyon Kim } 1972ac88567aSHyon Kim } 1973ac88567aSHyon Kim } 1974ac88567aSHyon Kim 1975ac88567aSHyon Kim return (0); 1976ac88567aSHyon Kim } 1977ac88567aSHyon Kim 1978ac88567aSHyon Kim /* 1979ac88567aSHyon Kim * Instantiate SAS expander nodes for a given ESC Electronics node(controller) 1980ac88567aSHyon Kim * nodes. 1981ac88567aSHyon Kim */ 1982ac88567aSHyon Kim /*ARGSUSED*/ 1983ac88567aSHyon Kim static int 1984ac88567aSHyon Kim ses_create_esc_sasspecific(ses_enum_data_t *sdp, ses_enum_node_t *snp, 1985ac88567aSHyon Kim tnode_t *pnode, ses_enum_chassis_t *cp, 1986ac88567aSHyon Kim boolean_t dorange) 1987ac88567aSHyon Kim { 1988ac88567aSHyon Kim topo_mod_t *mod = sdp->sed_mod; 1989ac88567aSHyon Kim tnode_t *exptn, *contn; 1990ac88567aSHyon Kim boolean_t found; 19915cc5d5ceSToomas Soome sas_connector_phy_data_t connectors[64] = {0}; 1992ac88567aSHyon Kim uint64_t max; 1993ac88567aSHyon Kim ses_enum_node_t *ctlsnp, *xsnp, *consnp; 1994ac88567aSHyon Kim ses_node_t *np = snp->sen_node; 1995ac88567aSHyon Kim nvlist_t *props, *psprops; 1996ac88567aSHyon Kim uint64_t index, psindex, conindex, psstatus, i, j, count; 19975cc5d5ceSToomas Soome int64_t cidxlist[256] = {0}; 1998ac88567aSHyon Kim int phycount; 1999ac88567aSHyon Kim 2000ac88567aSHyon Kim props = ses_node_props(np); 2001ac88567aSHyon Kim 2002ac88567aSHyon Kim if (nvlist_lookup_uint64(props, SES_PROP_ELEMENT_ONLY_INDEX, 2003ac88567aSHyon Kim &index) != 0) 2004ac88567aSHyon Kim return (-1); 2005ac88567aSHyon Kim 2006ac88567aSHyon Kim /* 2007ac88567aSHyon Kim * For SES constroller node, check to see if there are 2008ac88567aSHyon Kim * associated SAS expanders. 2009ac88567aSHyon Kim */ 2010ac88567aSHyon Kim found = B_FALSE; 2011ac88567aSHyon Kim max = 0; 2012ac88567aSHyon Kim for (ctlsnp = topo_list_next(&cp->sec_nodes); ctlsnp != NULL; 2013ac88567aSHyon Kim ctlsnp = topo_list_next(ctlsnp)) { 2014ac88567aSHyon Kim if (ctlsnp->sen_type == SES_ET_SAS_EXPANDER) { 2015ac88567aSHyon Kim found = B_TRUE; 2016ac88567aSHyon Kim if (ctlsnp->sen_instance > max) 2017ac88567aSHyon Kim max = ctlsnp->sen_instance; 2018ac88567aSHyon Kim } 2019ac88567aSHyon Kim } 2020ac88567aSHyon Kim 2021ac88567aSHyon Kim /* 2022ac88567aSHyon Kim * No SAS expander found notthing to process. 2023ac88567aSHyon Kim */ 2024ac88567aSHyon Kim if (!found) 2025ac88567aSHyon Kim return (0); 2026ac88567aSHyon Kim 2027ac88567aSHyon Kim topo_mod_dprintf(mod, "%s Controller %d: creating " 2028ac88567aSHyon Kim "%llu %s nodes", cp->sec_csn, index, max + 1, SASEXPANDER); 2029ac88567aSHyon Kim 2030ac88567aSHyon Kim /* 2031ac88567aSHyon Kim * The max number represent the number of elements 2032ac88567aSHyon Kim * deducted from the highest SES_PROP_ELEMENT_CLASS_INDEX 2033ac88567aSHyon Kim * of SET_ET_SAS_EXPANDER type element. 2034ac88567aSHyon Kim * 2035ac88567aSHyon Kim * There may be multiple ESC Electronics element(controllers) 2036ac88567aSHyon Kim * within JBOD(typicall two for redundancy) and SAS expander 2037ac88567aSHyon Kim * elements are associated with only one of them. We are 2038ac88567aSHyon Kim * still creating the range based max number here. 2039ac88567aSHyon Kim * That will cover the case that all expanders are associated 2040ac88567aSHyon Kim * with one SES controller. 2041ac88567aSHyon Kim */ 2042ac88567aSHyon Kim if (dorange && topo_node_range_create(mod, pnode, 2043ac88567aSHyon Kim SASEXPANDER, 0, max) != 0) { 2044ac88567aSHyon Kim topo_mod_dprintf(mod, 2045ac88567aSHyon Kim "topo_node_create_range() failed: %s", 2046ac88567aSHyon Kim topo_mod_errmsg(mod)); 2047ac88567aSHyon Kim return (-1); 2048ac88567aSHyon Kim } 2049ac88567aSHyon Kim 2050ac88567aSHyon Kim /* 2051ac88567aSHyon Kim * Search exapnders with the parent index matching with 2052ac88567aSHyon Kim * ESC Electronics element index. 2053ac88567aSHyon Kim * Note the index used here is a global index across 2054ac88567aSHyon Kim * SES elements. 2055ac88567aSHyon Kim */ 2056ac88567aSHyon Kim for (xsnp = topo_list_next(&cp->sec_nodes); xsnp != NULL; 2057ac88567aSHyon Kim xsnp = topo_list_next(xsnp)) { 2058ac88567aSHyon Kim if (xsnp->sen_type == SES_ET_SAS_EXPANDER) { 2059ac88567aSHyon Kim /* 2060ac88567aSHyon Kim * get the parent ESC controller. 2061ac88567aSHyon Kim */ 2062ac88567aSHyon Kim psprops = ses_node_props(xsnp->sen_node); 2063ac88567aSHyon Kim if (nvlist_lookup_uint64(psprops, 2064ac88567aSHyon Kim SES_PROP_STATUS_CODE, &psstatus) == 0) { 2065ac88567aSHyon Kim if (psstatus == SES_ESC_NOT_INSTALLED) { 2066ac88567aSHyon Kim /* 2067ac88567aSHyon Kim * Not installed. 2068ac88567aSHyon Kim * Don't create a ndoe. 2069ac88567aSHyon Kim */ 2070ac88567aSHyon Kim continue; 2071ac88567aSHyon Kim } 2072ac88567aSHyon Kim } else { 2073ac88567aSHyon Kim /* 2074ac88567aSHyon Kim * The element should have status code. 2075ac88567aSHyon Kim * If not there is no way to find 2076ac88567aSHyon Kim * out if the expander element exist or 2077ac88567aSHyon Kim * not. 2078ac88567aSHyon Kim */ 2079ac88567aSHyon Kim continue; 2080ac88567aSHyon Kim } 2081ac88567aSHyon Kim 2082ac88567aSHyon Kim /* Get the physical parent index to compare. */ 2083ac88567aSHyon Kim if (nvlist_lookup_uint64(psprops, 2084ac88567aSHyon Kim LIBSES_PROP_PHYS_PARENT, &psindex) == 0) { 2085ac88567aSHyon Kim if (index == psindex) { 2086ac88567aSHyon Kim /* indentation moved forward */ 2087ac88567aSHyon Kim /* 2088ac88567aSHyon Kim * Handle basic node information of SAS expander 2089ac88567aSHyon Kim * element - binding to parent node and 2090ac88567aSHyon Kim * allocating FMRI... 2091ac88567aSHyon Kim */ 2092ded93414SHyon Kim if (ses_create_generic(sdp, xsnp, pnode, pnode, SASEXPANDER, 2093ac88567aSHyon Kim "SAS-EXPANDER", &exptn) != 0) 2094ac88567aSHyon Kim continue; 2095ac88567aSHyon Kim /* 2096ac88567aSHyon Kim * Now handle SAS expander unique portion of node creation. 2097ac88567aSHyon Kim * The max nubmer of the phy count is 256 since SES-2 2098ac88567aSHyon Kim * defines as 1 byte field. The cidxlist has the same 2099ac88567aSHyon Kim * number of elements. 2100ac88567aSHyon Kim * 2101ac88567aSHyon Kim * We use size 64 array to store the connectors. 2102ac88567aSHyon Kim * Typically a connectors associated with 4 phys so that 2103ac88567aSHyon Kim * matches with the max number of connecters associated 2104ac88567aSHyon Kim * with an expander. 2105ac88567aSHyon Kim * The phy count goes up to 38 for Sun supported 2106ac88567aSHyon Kim * JBOD. 2107ac88567aSHyon Kim */ 2108edb433b6SMilan Jurik (void) memset(cidxlist, 0, sizeof (int64_t) * 64); 2109ac88567aSHyon Kim if (ses_set_expander_props(sdp, xsnp, pnode, exptn, &phycount, 2110ac88567aSHyon Kim cidxlist) != 0) { 2111ac88567aSHyon Kim /* 2112ac88567aSHyon Kim * error on getting specific prop failed. 2113ac88567aSHyon Kim * continue on. Note that the node is 2114ac88567aSHyon Kim * left bound. 2115ac88567aSHyon Kim */ 2116ac88567aSHyon Kim continue; 2117ac88567aSHyon Kim } 2118ac88567aSHyon Kim 2119ac88567aSHyon Kim /* 2120ac88567aSHyon Kim * count represetns the number of connectors discovered so far. 2121ac88567aSHyon Kim */ 2122ac88567aSHyon Kim count = 0; 2123edb433b6SMilan Jurik (void) memset(connectors, 0, 2124edb433b6SMilan Jurik sizeof (sas_connector_phy_data_t) * 64); 2125ac88567aSHyon Kim for (i = 0; i < phycount; i++) { 2126ac88567aSHyon Kim if (cidxlist[i] != -1) { 2127ac88567aSHyon Kim /* connector index is valid. */ 2128ac88567aSHyon Kim for (j = 0; j < count; j++) { 2129ded93414SHyon Kim if (connectors[j].scpd_index == 2130ac88567aSHyon Kim cidxlist[i]) { 2131ac88567aSHyon Kim /* 2132ac88567aSHyon Kim * Just update phy mask. 2133ac88567aSHyon Kim * The postion for connector 2134ac88567aSHyon Kim * index lists(cidxlist index) 2135ac88567aSHyon Kim * is set. 2136ac88567aSHyon Kim */ 2137ded93414SHyon Kim connectors[j].scpd_pm = 2138ded93414SHyon Kim connectors[j].scpd_pm | 2139ac88567aSHyon Kim (1ULL << i); 2140ac88567aSHyon Kim break; 2141ac88567aSHyon Kim } 2142ac88567aSHyon Kim } 2143ac88567aSHyon Kim /* 2144ac88567aSHyon Kim * If j and count matche a new connector 2145ac88567aSHyon Kim * index is found. 2146ac88567aSHyon Kim */ 2147ac88567aSHyon Kim if (j == count) { 2148ac88567aSHyon Kim /* add a new index and phy mask. */ 2149ded93414SHyon Kim connectors[count].scpd_index = 2150ded93414SHyon Kim cidxlist[i]; 2151ded93414SHyon Kim connectors[count].scpd_pm = 2152ded93414SHyon Kim connectors[count].scpd_pm | 2153ac88567aSHyon Kim (1ULL << i); 2154ac88567aSHyon Kim count++; 2155ac88567aSHyon Kim } 2156ac88567aSHyon Kim } 2157ac88567aSHyon Kim } 2158ac88567aSHyon Kim 2159ac88567aSHyon Kim /* 2160ac88567aSHyon Kim * create range for the connector nodes. 2161ac88567aSHyon Kim * The class index of the ses connector element 2162ac88567aSHyon Kim * is set as the instance nubmer for the node. 2163ac88567aSHyon Kim * Even though one expander may not have all connectors 2164ac88567aSHyon Kim * are associated with we are creating the range with 2165ac88567aSHyon Kim * max possible instance number. 2166ac88567aSHyon Kim */ 2167ac88567aSHyon Kim found = B_FALSE; 2168ac88567aSHyon Kim max = 0; 2169ac88567aSHyon Kim for (consnp = topo_list_next(&cp->sec_nodes); 2170ac88567aSHyon Kim consnp != NULL; consnp = topo_list_next(consnp)) { 2171ac88567aSHyon Kim if (consnp->sen_type == SES_ET_SAS_CONNECTOR) { 2172ac88567aSHyon Kim psprops = ses_node_props(consnp->sen_node); 2173ac88567aSHyon Kim found = B_TRUE; 2174ac88567aSHyon Kim if (consnp->sen_instance > max) 2175ac88567aSHyon Kim max = consnp->sen_instance; 2176ac88567aSHyon Kim } 2177ac88567aSHyon Kim } 2178ac88567aSHyon Kim 2179ac88567aSHyon Kim /* 2180ac88567aSHyon Kim * No SAS connector found nothing to process. 2181ac88567aSHyon Kim */ 2182ac88567aSHyon Kim if (!found) 2183ac88567aSHyon Kim return (0); 2184ac88567aSHyon Kim 2185ac88567aSHyon Kim if (dorange && topo_node_range_create(mod, exptn, 2186ac88567aSHyon Kim RECEPTACLE, 0, max) != 0) { 2187ac88567aSHyon Kim topo_mod_dprintf(mod, 2188ac88567aSHyon Kim "topo_node_create_range() failed: %s", 2189ac88567aSHyon Kim topo_mod_errmsg(mod)); 2190ac88567aSHyon Kim return (-1); 2191ac88567aSHyon Kim } 2192ac88567aSHyon Kim 2193ac88567aSHyon Kim /* search matching connector element using the index. */ 2194ac88567aSHyon Kim for (i = 0; i < count; i++) { 2195ac88567aSHyon Kim found = B_FALSE; 2196ac88567aSHyon Kim for (consnp = topo_list_next(&cp->sec_nodes); 2197ac88567aSHyon Kim consnp != NULL; consnp = topo_list_next(consnp)) { 2198ac88567aSHyon Kim if (consnp->sen_type == SES_ET_SAS_CONNECTOR) { 2199ac88567aSHyon Kim psprops = ses_node_props( 2200ac88567aSHyon Kim consnp->sen_node); 2201ac88567aSHyon Kim /* 2202ac88567aSHyon Kim * Get the physical parent index to 2203ac88567aSHyon Kim * compare. 2204ac88567aSHyon Kim * The connector elements are children 2205ac88567aSHyon Kim * of ESC Electronics element even 2206ac88567aSHyon Kim * though we enumerate them under 2207ac88567aSHyon Kim * an expander in libtopo. 2208ac88567aSHyon Kim */ 2209ac88567aSHyon Kim if (nvlist_lookup_uint64(psprops, 2210ac88567aSHyon Kim SES_PROP_ELEMENT_ONLY_INDEX, 2211ac88567aSHyon Kim &conindex) == 0) { 2212ac88567aSHyon Kim if (conindex == 2213ded93414SHyon Kim connectors[i].scpd_index) { 2214ac88567aSHyon Kim found = B_TRUE; 2215ac88567aSHyon Kim break; 2216ac88567aSHyon Kim } 2217ac88567aSHyon Kim } 2218ac88567aSHyon Kim } 2219ac88567aSHyon Kim } 2220ac88567aSHyon Kim 2221ac88567aSHyon Kim /* now create a libtopo node. */ 2222ac88567aSHyon Kim if (found) { 2223ac88567aSHyon Kim /* Create generic props. */ 2224ac88567aSHyon Kim if (ses_create_generic(sdp, consnp, exptn, 2225ded93414SHyon Kim topo_node_parent(exptn), 2226ac88567aSHyon Kim RECEPTACLE, "RECEPTACLE", &contn) != 2227ac88567aSHyon Kim 0) { 2228ac88567aSHyon Kim continue; 2229ac88567aSHyon Kim } 2230ac88567aSHyon Kim /* Create connector specific props. */ 2231ac88567aSHyon Kim if (ses_set_connector_props(sdp, consnp, 2232ded93414SHyon Kim contn, connectors[i].scpd_pm) != 0) { 2233ac88567aSHyon Kim continue; 2234ac88567aSHyon Kim } 22358abca89fSRob Johnston if (topo_method_register(mod, contn, 22368abca89fSRob Johnston ses_recep_methods) != 0) { 22378abca89fSRob Johnston topo_mod_dprintf(mod, 22388abca89fSRob Johnston "topo_method_register() failed: " 22398abca89fSRob Johnston "%s", 22408abca89fSRob Johnston topo_mod_errmsg(mod)); 22418abca89fSRob Johnston continue; 22428abca89fSRob Johnston } 22438abca89fSRob Johnston 2244ac88567aSHyon Kim } 2245ac88567aSHyon Kim } 2246ac88567aSHyon Kim /* end indentation change */ 2247ac88567aSHyon Kim } 2248ac88567aSHyon Kim } 2249ac88567aSHyon Kim } 2250ac88567aSHyon Kim } 2251ac88567aSHyon Kim 2252ac88567aSHyon Kim return (0); 2253ac88567aSHyon Kim } 2254ac88567aSHyon Kim 2255ac88567aSHyon Kim /* 2256ac88567aSHyon Kim * Instantiate any protocol specific portion of a node. 2257ac88567aSHyon Kim */ 2258ac88567aSHyon Kim /*ARGSUSED*/ 2259ac88567aSHyon Kim static int 2260ac88567aSHyon Kim ses_create_protocol_specific(ses_enum_data_t *sdp, ses_enum_node_t *snp, 2261ac88567aSHyon Kim tnode_t *pnode, uint64_t type, ses_enum_chassis_t *cp, 2262ac88567aSHyon Kim boolean_t dorange) 2263ac88567aSHyon Kim { 2264ac88567aSHyon Kim 2265ac88567aSHyon Kim if (type == SES_ET_ESC_ELECTRONICS) { 2266ac88567aSHyon Kim /* create SAS specific children(expanders and connectors. */ 2267ac88567aSHyon Kim return (ses_create_esc_sasspecific(sdp, snp, pnode, cp, 2268ac88567aSHyon Kim dorange)); 2269ac88567aSHyon Kim } 2270ac88567aSHyon Kim 2271ac88567aSHyon Kim return (0); 2272ac88567aSHyon Kim } 2273ac88567aSHyon Kim 2274940d71d2Seschrock /* 2275940d71d2Seschrock * Instantiate any children of a given type. 2276940d71d2Seschrock */ 2277940d71d2Seschrock static int 2278940d71d2Seschrock ses_create_children(ses_enum_data_t *sdp, tnode_t *pnode, uint64_t type, 2279d91236feSeschrock const char *nodename, const char *defaultlabel, ses_enum_chassis_t *cp, 2280d91236feSeschrock boolean_t dorange) 2281940d71d2Seschrock { 2282940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 2283940d71d2Seschrock boolean_t found; 2284940d71d2Seschrock uint64_t max; 2285940d71d2Seschrock ses_enum_node_t *snp; 2286ac88567aSHyon Kim tnode_t *tn; 2287940d71d2Seschrock 2288940d71d2Seschrock /* 2289940d71d2Seschrock * First go through and count how many matching nodes we have. 2290940d71d2Seschrock */ 2291940d71d2Seschrock max = 0; 2292940d71d2Seschrock found = B_FALSE; 2293940d71d2Seschrock for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2294940d71d2Seschrock snp = topo_list_next(snp)) { 2295940d71d2Seschrock if (snp->sen_type == type) { 2296940d71d2Seschrock found = B_TRUE; 2297940d71d2Seschrock if (snp->sen_instance > max) 2298940d71d2Seschrock max = snp->sen_instance; 2299940d71d2Seschrock } 2300940d71d2Seschrock } 2301940d71d2Seschrock 2302940d71d2Seschrock /* 2303940d71d2Seschrock * No enclosure should export both DEVICE and ARRAY_DEVICE elements. 2304940d71d2Seschrock * Since we map both of these to 'disk', if an enclosure does this, we 2305940d71d2Seschrock * just ignore the array elements. 2306940d71d2Seschrock */ 2307940d71d2Seschrock if (!found || 2308940d71d2Seschrock (type == SES_ET_ARRAY_DEVICE && cp->sec_hasdev)) 2309940d71d2Seschrock return (0); 2310940d71d2Seschrock 2311940d71d2Seschrock topo_mod_dprintf(mod, "%s: creating %llu %s nodes", 231253dbcc59SSundeep Panicker cp->sec_csn, max + 1, nodename); 2313940d71d2Seschrock 2314d91236feSeschrock if (dorange && topo_node_range_create(mod, pnode, 2315940d71d2Seschrock nodename, 0, max) != 0) { 2316940d71d2Seschrock topo_mod_dprintf(mod, 2317940d71d2Seschrock "topo_node_create_range() failed: %s", 2318940d71d2Seschrock topo_mod_errmsg(mod)); 2319940d71d2Seschrock return (-1); 2320940d71d2Seschrock } 2321940d71d2Seschrock 2322940d71d2Seschrock for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2323940d71d2Seschrock snp = topo_list_next(snp)) { 2324940d71d2Seschrock if (snp->sen_type == type) { 2325ded93414SHyon Kim /* 2326ded93414SHyon Kim * With flat layout of ses nodes there is no 2327ded93414SHyon Kim * way to find out the direct FRU for a node. 2328ded93414SHyon Kim * Passing NULL for fru topo node. Note that 2329ded93414SHyon Kim * ses_create_children_from_phys_tree() provides 2330ded93414SHyon Kim * the actual direct FRU for a node. 2331ded93414SHyon Kim */ 2332ded93414SHyon Kim if (ses_create_generic(sdp, snp, pnode, NULL, 2333ac88567aSHyon Kim nodename, defaultlabel, &tn) != 0) 2334940d71d2Seschrock return (-1); 2335ac88567aSHyon Kim /* 2336ac88567aSHyon Kim * For some SES element there may be protocol specific 2337ac88567aSHyon Kim * information to process. Here we are processing 2338ac88567aSHyon Kim * the association between enclosure controller and 2339ac88567aSHyon Kim * SAS expanders. 2340ac88567aSHyon Kim */ 2341ac88567aSHyon Kim if (type == SES_ET_ESC_ELECTRONICS) { 2342ac88567aSHyon Kim /* create SAS expander node */ 2343ac88567aSHyon Kim if (ses_create_protocol_specific(sdp, snp, 2344ac88567aSHyon Kim tn, type, cp, dorange) != 0) { 2345ac88567aSHyon Kim return (-1); 2346ac88567aSHyon Kim } 2347ac88567aSHyon Kim } 2348ac88567aSHyon Kim 2349940d71d2Seschrock } 2350940d71d2Seschrock } 2351940d71d2Seschrock 2352940d71d2Seschrock return (0); 2353940d71d2Seschrock } 2354940d71d2Seschrock 235553dbcc59SSundeep Panicker /* 235653dbcc59SSundeep Panicker * Instantiate a new subchassis instance in the topology. 235753dbcc59SSundeep Panicker */ 235853dbcc59SSundeep Panicker static int 235953dbcc59SSundeep Panicker ses_create_subchassis(ses_enum_data_t *sdp, tnode_t *pnode, 236053dbcc59SSundeep Panicker ses_enum_chassis_t *scp) 236153dbcc59SSundeep Panicker { 236253dbcc59SSundeep Panicker topo_mod_t *mod = sdp->sed_mod; 236353dbcc59SSundeep Panicker tnode_t *tn; 236453dbcc59SSundeep Panicker nvlist_t *props; 236553dbcc59SSundeep Panicker nvlist_t *auth = NULL, *fmri = NULL; 236653dbcc59SSundeep Panicker uint64_t instance = scp->sec_instance; 236753dbcc59SSundeep Panicker char *desc; 2368469735ecSRob Johnston char *clean_label = NULL, label[128]; 236953dbcc59SSundeep Panicker char **paths; 237053dbcc59SSundeep Panicker int i, err; 237153dbcc59SSundeep Panicker ses_enum_target_t *stp; 237253dbcc59SSundeep Panicker int ret = -1; 237353dbcc59SSundeep Panicker 237453dbcc59SSundeep Panicker /* 237553dbcc59SSundeep Panicker * Copy authority information from parent enclosure node 237653dbcc59SSundeep Panicker */ 237753dbcc59SSundeep Panicker if ((auth = topo_mod_auth(mod, pnode)) == NULL) 237853dbcc59SSundeep Panicker goto error; 237953dbcc59SSundeep Panicker 238053dbcc59SSundeep Panicker /* 238153dbcc59SSundeep Panicker * Record the subchassis serial number in the FMRI. 238253dbcc59SSundeep Panicker * For now, we assume that logical id is the subchassis serial number. 238353dbcc59SSundeep Panicker * If this assumption changes in future, then the following 238453dbcc59SSundeep Panicker * piece of code will need to be updated via an RFE. 238553dbcc59SSundeep Panicker */ 238653dbcc59SSundeep Panicker if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION, 2387ac88567aSHyon Kim SUBCHASSIS, (topo_instance_t)instance, NULL, auth, NULL, NULL, 2388ac88567aSHyon Kim NULL)) == NULL) { 238953dbcc59SSundeep Panicker topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s", 239053dbcc59SSundeep Panicker topo_mod_errmsg(mod)); 239153dbcc59SSundeep Panicker goto error; 239253dbcc59SSundeep Panicker } 239353dbcc59SSundeep Panicker 239453dbcc59SSundeep Panicker if ((tn = topo_node_bind(mod, pnode, SUBCHASSIS, 239553dbcc59SSundeep Panicker instance, fmri)) == NULL) { 239653dbcc59SSundeep Panicker topo_mod_dprintf(mod, "topo_node_bind() failed: %s", 239753dbcc59SSundeep Panicker topo_mod_errmsg(mod)); 239853dbcc59SSundeep Panicker goto error; 239953dbcc59SSundeep Panicker } 240053dbcc59SSundeep Panicker 240153dbcc59SSundeep Panicker props = ses_node_props(scp->sec_enclosure); 240253dbcc59SSundeep Panicker 240353dbcc59SSundeep Panicker /* 240453dbcc59SSundeep Panicker * Look for the subchassis label in the following order: 240553dbcc59SSundeep Panicker * <ses-description> 240653dbcc59SSundeep Panicker * <ses-class-description> <instance> 240753dbcc59SSundeep Panicker * <default-type-label> <instance> 240853dbcc59SSundeep Panicker * 240953dbcc59SSundeep Panicker * For subchassis, the default label is "SUBCHASSIS" 241053dbcc59SSundeep Panicker */ 241153dbcc59SSundeep Panicker if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 || 241253dbcc59SSundeep Panicker desc[0] == '\0') { 241353dbcc59SSundeep Panicker if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION, 241453dbcc59SSundeep Panicker &desc) == 0 && desc[0] != '\0') 241553dbcc59SSundeep Panicker (void) snprintf(label, sizeof (label), "%s %llu", desc, 241653dbcc59SSundeep Panicker instance); 241753dbcc59SSundeep Panicker else 241853dbcc59SSundeep Panicker (void) snprintf(label, sizeof (label), 241953dbcc59SSundeep Panicker "SUBCHASSIS %llu", instance); 242053dbcc59SSundeep Panicker desc = label; 242153dbcc59SSundeep Panicker } 242253dbcc59SSundeep Panicker 2423469735ecSRob Johnston if ((clean_label = topo_mod_clean_str(mod, desc)) == NULL) 2424469735ecSRob Johnston goto error; 2425469735ecSRob Johnston 2426469735ecSRob Johnston if (topo_prop_set_string(tn, TOPO_PGROUP_PROTOCOL, TOPO_PROP_LABEL, 2427469735ecSRob Johnston TOPO_PROP_MUTABLE, clean_label, &err) < 0) 242853dbcc59SSundeep Panicker goto error; 242953dbcc59SSundeep Panicker 2430ac88567aSHyon Kim if (ses_set_standard_props(mod, NULL, tn, NULL, 243153dbcc59SSundeep Panicker ses_node_id(scp->sec_enclosure), scp->sec_target->set_devpath) != 0) 243253dbcc59SSundeep Panicker goto error; 243353dbcc59SSundeep Panicker 2434ac88567aSHyon Kim /* 2435ac88567aSHyon Kim * Set the 'chassis-type' property for this subchassis. This is either 2436ac88567aSHyon Kim * 'ses-class-description' or 'subchassis'. 2437ac88567aSHyon Kim */ 2438ac88567aSHyon Kim if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION, &desc) != 0) 2439ac88567aSHyon Kim desc = "subchassis"; 2440ac88567aSHyon Kim 2441ac88567aSHyon Kim if (topo_prop_set_string(tn, TOPO_PGROUP_SES, 2442ac88567aSHyon Kim TOPO_PROP_CHASSIS_TYPE, TOPO_PROP_IMMUTABLE, desc, &err) != 0) { 2443ac88567aSHyon Kim topo_mod_dprintf(mod, "failed to create property %s: %s\n", 2444ac88567aSHyon Kim TOPO_PROP_CHASSIS_TYPE, topo_strerror(err)); 2445ac88567aSHyon Kim goto error; 2446ac88567aSHyon Kim } 2447ac88567aSHyon Kim 244853dbcc59SSundeep Panicker /* 244953dbcc59SSundeep Panicker * For enclosures, we want to include all possible targets (for upgrade 245053dbcc59SSundeep Panicker * purposes). 245153dbcc59SSundeep Panicker */ 245253dbcc59SSundeep Panicker for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL; 245353dbcc59SSundeep Panicker stp = topo_list_next(stp), i++) 245453dbcc59SSundeep Panicker ; 245553dbcc59SSundeep Panicker 245653dbcc59SSundeep Panicker verify(i != 0); 245753dbcc59SSundeep Panicker paths = alloca(i * sizeof (char *)); 245853dbcc59SSundeep Panicker 245953dbcc59SSundeep Panicker for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL; 246053dbcc59SSundeep Panicker stp = topo_list_next(stp), i++) 246153dbcc59SSundeep Panicker paths[i] = stp->set_devpath; 246253dbcc59SSundeep Panicker 246353dbcc59SSundeep Panicker if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES, 246453dbcc59SSundeep Panicker TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths, 246553dbcc59SSundeep Panicker i, &err) != 0) { 246653dbcc59SSundeep Panicker topo_mod_dprintf(mod, "failed to create property %s: %s\n", 246753dbcc59SSundeep Panicker TOPO_PROP_PATHS, topo_strerror(err)); 246853dbcc59SSundeep Panicker goto error; 246953dbcc59SSundeep Panicker } 247053dbcc59SSundeep Panicker 247153dbcc59SSundeep Panicker if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) { 247253dbcc59SSundeep Panicker topo_mod_dprintf(mod, "topo_method_register() failed: %s", 247353dbcc59SSundeep Panicker topo_mod_errmsg(mod)); 247453dbcc59SSundeep Panicker goto error; 247553dbcc59SSundeep Panicker } 247653dbcc59SSundeep Panicker 247753dbcc59SSundeep Panicker /* 247853dbcc59SSundeep Panicker * Create the nodes for controllers and bays. 247953dbcc59SSundeep Panicker */ 248053dbcc59SSundeep Panicker if (ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS, 248153dbcc59SSundeep Panicker CONTROLLER, "CONTROLLER", scp, B_TRUE) != 0 || 248253dbcc59SSundeep Panicker ses_create_children(sdp, tn, SES_ET_DEVICE, 248353dbcc59SSundeep Panicker BAY, "BAY", scp, B_TRUE) != 0 || 248453dbcc59SSundeep Panicker ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE, 248553dbcc59SSundeep Panicker BAY, "BAY", scp, B_TRUE) != 0) 248653dbcc59SSundeep Panicker goto error; 248753dbcc59SSundeep Panicker 248853dbcc59SSundeep Panicker ret = 0; 248953dbcc59SSundeep Panicker 249053dbcc59SSundeep Panicker error: 249153dbcc59SSundeep Panicker nvlist_free(auth); 249253dbcc59SSundeep Panicker nvlist_free(fmri); 2493469735ecSRob Johnston topo_mod_strfree(mod, clean_label); 249453dbcc59SSundeep Panicker return (ret); 249553dbcc59SSundeep Panicker } 249653dbcc59SSundeep Panicker 2497ded93414SHyon Kim /* 2498ded93414SHyon Kim * Function we use to insert a node. 2499ded93414SHyon Kim */ 2500ded93414SHyon Kim static int 2501ded93414SHyon Kim ses_phys_tree_insert(topo_mod_t *mod, ses_phys_tree_t **sproot, 2502ded93414SHyon Kim ses_phys_tree_t *child) 2503ded93414SHyon Kim { 2504ded93414SHyon Kim uint64_t ppindex, eindex, pindex; 2505ded93414SHyon Kim ses_phys_tree_t *node_ptr; 2506ded93414SHyon Kim int ret = 0; 2507ded93414SHyon Kim 2508ded93414SHyon Kim assert(sproot != NULL); 2509ded93414SHyon Kim assert(child != NULL); 2510ded93414SHyon Kim 2511ded93414SHyon Kim if (*sproot == NULL) { 2512ded93414SHyon Kim *sproot = child; 2513ded93414SHyon Kim return (0); 2514ded93414SHyon Kim } 2515ded93414SHyon Kim 2516ded93414SHyon Kim pindex = child->spt_pindex; 2517ded93414SHyon Kim ppindex = (*sproot)->spt_pindex; 2518ded93414SHyon Kim eindex = (*sproot)->spt_eonlyindex; 2519ded93414SHyon Kim 2520ded93414SHyon Kim /* 2521ded93414SHyon Kim * If the element only index of the root is same as the physical 2522ded93414SHyon Kim * parent index of a node to be added, add the node as a child of 2523ded93414SHyon Kim * the current root. 2524ded93414SHyon Kim */ 2525ded93414SHyon Kim if (eindex == pindex) { 2526ded93414SHyon Kim (void) ses_phys_tree_insert(mod, &(*sproot)->spt_child, child); 2527ded93414SHyon Kim child->spt_parent = *sproot; 2528ded93414SHyon Kim } else if (ppindex == pindex) { 2529ded93414SHyon Kim /* 2530ded93414SHyon Kim * if the physical parent of the current root and the child 2531ded93414SHyon Kim * is same, then this should be a sibling node. 2532ded93414SHyon Kim * Siblings can be different element types and arrange 2533ded93414SHyon Kim * them by group. 2534ded93414SHyon Kim */ 2535ded93414SHyon Kim if ((*sproot)->spt_senumnode->sen_type == 2536ded93414SHyon Kim child->spt_senumnode->sen_type) { 2537ded93414SHyon Kim child->spt_sibling = *sproot; 2538ded93414SHyon Kim *sproot = child; 2539ded93414SHyon Kim } else { 2540ded93414SHyon Kim /* add a node in front of matching element type. */ 2541ded93414SHyon Kim node_ptr = *sproot; 2542ded93414SHyon Kim while (node_ptr->spt_sibling != NULL) { 2543ded93414SHyon Kim if (node_ptr->spt_sibling-> 2544ded93414SHyon Kim spt_senumnode->sen_type == 2545ded93414SHyon Kim child->spt_senumnode->sen_type) { 2546ded93414SHyon Kim child->spt_sibling = 2547ded93414SHyon Kim node_ptr->spt_sibling; 2548ded93414SHyon Kim node_ptr->spt_sibling = child; 2549ded93414SHyon Kim break; 2550ded93414SHyon Kim } 2551ded93414SHyon Kim node_ptr = node_ptr->spt_sibling; 2552ded93414SHyon Kim } 2553ded93414SHyon Kim /* no matching. Add the child at the end. */ 2554ded93414SHyon Kim if (node_ptr->spt_sibling == NULL) { 2555ded93414SHyon Kim node_ptr->spt_sibling = child; 2556ded93414SHyon Kim } 2557ded93414SHyon Kim } 2558ded93414SHyon Kim child->spt_parent = (*sproot)->spt_parent; 2559ded93414SHyon Kim } else { 2560ded93414SHyon Kim /* 2561ded93414SHyon Kim * The root and the node is not directly related. 2562ded93414SHyon Kim * Try to insert to the child sub-tree first and then try to 2563ded93414SHyon Kim * insert to the sibling sub-trees. If fails for both 2564ded93414SHyon Kim * the caller will retry insertion later. 2565ded93414SHyon Kim */ 2566ded93414SHyon Kim if ((*sproot)->spt_child) { 2567ded93414SHyon Kim ret = ses_phys_tree_insert(mod, &(*sproot)->spt_child, 2568ded93414SHyon Kim child); 2569ded93414SHyon Kim } 2570ded93414SHyon Kim if ((*sproot)->spt_child == NULL || ret != 0) { 2571ded93414SHyon Kim if ((*sproot)->spt_sibling) { 2572ded93414SHyon Kim ret = ses_phys_tree_insert(mod, 2573ded93414SHyon Kim &(*sproot)->spt_sibling, child); 2574ded93414SHyon Kim } else { 2575ded93414SHyon Kim ret = 1; 2576ded93414SHyon Kim } 2577ded93414SHyon Kim } 2578ded93414SHyon Kim return (ret); 2579ded93414SHyon Kim } 2580ded93414SHyon Kim return (0); 2581ded93414SHyon Kim } 2582ded93414SHyon Kim 2583ded93414SHyon Kim /* 2584ded93414SHyon Kim * Construct tree view of ses elements through parent phyiscal element index. 2585ded93414SHyon Kim * The root of tree is already constructed using the enclosure element. 2586ded93414SHyon Kim */ 2587ded93414SHyon Kim static int 2588ded93414SHyon Kim ses_construct_phys_tree(ses_enum_data_t *sdp, ses_enum_chassis_t *cp, 2589ded93414SHyon Kim ses_phys_tree_t *sproot) 2590ded93414SHyon Kim { 2591ded93414SHyon Kim ses_enum_node_t *snp; 2592ded93414SHyon Kim ses_phys_tree_t *child; 2593ded93414SHyon Kim ses_phys_tree_t *u_watch = NULL; 2594ded93414SHyon Kim ses_phys_tree_t *u_head = NULL; 2595ded93414SHyon Kim ses_phys_tree_t *u_tail = NULL; 2596ded93414SHyon Kim int u_inserted = 0, u_left = 0; 2597ded93414SHyon Kim nvlist_t *props; 2598ded93414SHyon Kim topo_mod_t *mod = sdp->sed_mod; 2599ded93414SHyon Kim 2600ded93414SHyon Kim for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2601ded93414SHyon Kim snp = topo_list_next(snp)) { 2602ded93414SHyon Kim if ((child = topo_mod_zalloc(mod, 2603ded93414SHyon Kim sizeof (ses_phys_tree_t))) == NULL) { 2604ded93414SHyon Kim topo_mod_dprintf(mod, 2605ded93414SHyon Kim "failed to allocate root."); 2606ded93414SHyon Kim return (-1); 2607ded93414SHyon Kim } 2608ded93414SHyon Kim child->spt_snode = snp->sen_node; 2609ded93414SHyon Kim props = ses_node_props(snp->sen_node); 2610ded93414SHyon Kim if (nvlist_lookup_uint64(props, 2611ded93414SHyon Kim LIBSES_PROP_PHYS_PARENT, &child->spt_pindex) != 0) { 2612ded93414SHyon Kim /* 2613ded93414SHyon Kim * the prop should exist. continue to see if 2614ded93414SHyon Kim * we can build a partial tree with other elements. 2615ded93414SHyon Kim */ 2616ded93414SHyon Kim topo_mod_dprintf(mod, 2617ded93414SHyon Kim "ses_construct_phys_tree(): Failed to find prop %s " 2618ded93414SHyon Kim "on ses element type %d and instance %d " 2619ded93414SHyon Kim "(CSN %s).", LIBSES_PROP_PHYS_PARENT, 2620ded93414SHyon Kim snp->sen_type, snp->sen_instance, cp->sec_csn); 2621ded93414SHyon Kim topo_mod_free(mod, child, sizeof (ses_phys_tree_t)); 2622ded93414SHyon Kim continue; 2623ded93414SHyon Kim } else { 2624ded93414SHyon Kim if (nvlist_lookup_boolean_value(props, 2625ded93414SHyon Kim LIBSES_PROP_FRU, &child->spt_isfru) != 0) { 2626ded93414SHyon Kim topo_mod_dprintf(mod, 2627ded93414SHyon Kim "ses_construct_phys_tree(): Failed to " 2628ded93414SHyon Kim "find prop %s on ses element type %d " 2629ded93414SHyon Kim "and instance %d (CSN %s).", 2630ded93414SHyon Kim LIBSES_PROP_FRU, 2631ded93414SHyon Kim snp->sen_type, snp->sen_instance, 2632ded93414SHyon Kim cp->sec_csn); 2633ded93414SHyon Kim /* 2634ded93414SHyon Kim * Ignore if the prop doesn't exist. 2635ded93414SHyon Kim * Note that the enclosure itself should be 2636ded93414SHyon Kim * a FRU so if no FRU found the enclosure FRU 2637ded93414SHyon Kim * can be a direct FRU. 2638ded93414SHyon Kim */ 2639ded93414SHyon Kim } 2640ded93414SHyon Kim verify(nvlist_lookup_uint64(props, 2641ded93414SHyon Kim SES_PROP_ELEMENT_ONLY_INDEX, 2642ded93414SHyon Kim &child->spt_eonlyindex) == 0); 2643ded93414SHyon Kim verify(nvlist_lookup_uint64(props, 2644ded93414SHyon Kim SES_PROP_ELEMENT_CLASS_INDEX, 2645ded93414SHyon Kim &child->spt_cindex) == 0); 2646ded93414SHyon Kim } 2647ded93414SHyon Kim child->spt_senumnode = snp; 2648ded93414SHyon Kim if (ses_phys_tree_insert(mod, &sproot, child) != 0) { 2649ded93414SHyon Kim /* collect unresolved element to process later. */ 2650ded93414SHyon Kim if (u_head == NULL) { 2651ded93414SHyon Kim u_head = child; 2652ded93414SHyon Kim u_tail = child; 2653ded93414SHyon Kim } else { 2654ded93414SHyon Kim child->spt_sibling = u_head; 2655ded93414SHyon Kim u_head = child; 2656ded93414SHyon Kim } 2657ded93414SHyon Kim } 2658ded93414SHyon Kim } 2659ded93414SHyon Kim 2660ded93414SHyon Kim /* 2661ded93414SHyon Kim * The parent of a child node may not be inserted yet. 2662ded93414SHyon Kim * Trying to insert the child until no child is left or 2663ded93414SHyon Kim * no child is not added further. For the latter 2664ded93414SHyon Kim * the hierarchical relationship between elements 2665ded93414SHyon Kim * should be checked through SUNW,FRUID page. 2666ded93414SHyon Kim * u_watch is a watch dog to check the prgress of unresolved 2667ded93414SHyon Kim * node. 2668ded93414SHyon Kim */ 2669ded93414SHyon Kim u_watch = u_tail; 2670ded93414SHyon Kim while (u_head) { 2671ded93414SHyon Kim child = u_head; 2672ded93414SHyon Kim u_head = u_head->spt_sibling; 2673ded93414SHyon Kim if (u_head == NULL) 2674ded93414SHyon Kim u_tail = NULL; 2675ded93414SHyon Kim child->spt_sibling = NULL; 2676ded93414SHyon Kim if (ses_phys_tree_insert(mod, &sproot, child) != 0) { 2677ded93414SHyon Kim u_tail->spt_sibling = child; 2678ded93414SHyon Kim u_tail = child; 2679ded93414SHyon Kim if (child == u_watch) { 2680ded93414SHyon Kim /* 2681ded93414SHyon Kim * We just scanned one round for the 2682ded93414SHyon Kim * unresolved list. Check to see whether we 2683ded93414SHyon Kim * have nodes inserted, if none, we should 2684ded93414SHyon Kim * break in case of an indefinite loop. 2685ded93414SHyon Kim */ 2686ded93414SHyon Kim if (u_inserted == 0) { 2687ded93414SHyon Kim /* 2688ded93414SHyon Kim * Indicate there is unhandled node. 2689ded93414SHyon Kim * Chain free the whole unsolved 2690ded93414SHyon Kim * list here. 2691ded93414SHyon Kim */ 2692ded93414SHyon Kim u_left++; 2693ded93414SHyon Kim break; 2694ded93414SHyon Kim } else { 2695ded93414SHyon Kim u_inserted = 0; 2696ded93414SHyon Kim u_watch = u_tail; 2697ded93414SHyon Kim } 2698ded93414SHyon Kim } 2699ded93414SHyon Kim } else { 2700ded93414SHyon Kim /* 2701ded93414SHyon Kim * We just inserted one rpnode, increment the 2702ded93414SHyon Kim * unsolved_inserted counter. We will utilize this 2703ded93414SHyon Kim * counter to detect an indefinite insertion loop. 2704ded93414SHyon Kim */ 2705ded93414SHyon Kim u_inserted++; 27067f188cd7SHyon Kim if (child == u_watch) { 27077f188cd7SHyon Kim /* 27087f188cd7SHyon Kim * watch dog node itself is inserted. 27097f188cd7SHyon Kim * Set it to the tail and refresh the watching. 27107f188cd7SHyon Kim */ 27117f188cd7SHyon Kim u_watch = u_tail; 27127f188cd7SHyon Kim u_inserted = 0; 27137f188cd7SHyon Kim u_left = 0; 27147f188cd7SHyon Kim } 2715ded93414SHyon Kim } 2716ded93414SHyon Kim } 2717ded93414SHyon Kim 2718ded93414SHyon Kim /* check if there is left out unresolved nodes. */ 2719ded93414SHyon Kim if (u_left) { 2720ded93414SHyon Kim topo_mod_dprintf(mod, "ses_construct_phys_tree(): " 2721ded93414SHyon Kim "Failed to construct physical view of the following " 2722ded93414SHyon Kim "ses elements of Chassis CSN %s.", cp->sec_csn); 2723ded93414SHyon Kim while (u_head) { 2724ded93414SHyon Kim u_tail = u_head->spt_sibling; 2725ded93414SHyon Kim topo_mod_dprintf(mod, 2726ded93414SHyon Kim "\telement type (%d) and instance (%d)", 2727ded93414SHyon Kim u_head->spt_senumnode->sen_type, 2728ded93414SHyon Kim u_head->spt_senumnode->sen_instance); 2729ded93414SHyon Kim topo_mod_free(mod, u_head, sizeof (ses_phys_tree_t)); 2730ded93414SHyon Kim u_head = u_tail; 2731ded93414SHyon Kim } 2732ded93414SHyon Kim return (-1); 2733ded93414SHyon Kim } 2734ded93414SHyon Kim 2735ded93414SHyon Kim return (0); 2736ded93414SHyon Kim } 2737ded93414SHyon Kim 2738ded93414SHyon Kim /* 2739ded93414SHyon Kim * Free the whole phys tree. 2740ded93414SHyon Kim */ 2741ded93414SHyon Kim static void ses_phys_tree_free(topo_mod_t *mod, ses_phys_tree_t *sproot) 2742ded93414SHyon Kim { 2743ded93414SHyon Kim if (sproot == NULL) 2744ded93414SHyon Kim return; 2745ded93414SHyon Kim 2746ded93414SHyon Kim /* Free child tree. */ 2747ded93414SHyon Kim if (sproot->spt_child) { 2748ded93414SHyon Kim ses_phys_tree_free(mod, sproot->spt_child); 2749ded93414SHyon Kim } 2750ded93414SHyon Kim 2751ded93414SHyon Kim /* Free sibling trees. */ 2752ded93414SHyon Kim if (sproot->spt_sibling) { 2753ded93414SHyon Kim ses_phys_tree_free(mod, sproot->spt_sibling); 2754ded93414SHyon Kim } 2755ded93414SHyon Kim 2756ded93414SHyon Kim /* Free root node itself. */ 2757ded93414SHyon Kim topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t)); 2758ded93414SHyon Kim } 2759ded93414SHyon Kim 2760ded93414SHyon Kim /* 2761ded93414SHyon Kim * Parses phys_enum_type table to get the index of the given type. 2762ded93414SHyon Kim */ 2763ded93414SHyon Kim static boolean_t 2764ded93414SHyon Kim is_type_enumerated(ses_phys_tree_t *node, int *index) 2765ded93414SHyon Kim { 2766ded93414SHyon Kim int i; 2767ded93414SHyon Kim 2768ded93414SHyon Kim for (i = 0; i < N_PHYS_ENUM_TYPES; i++) { 2769ded93414SHyon Kim if (node->spt_senumnode->sen_type == 2770ded93414SHyon Kim phys_enum_type_list[i].pet_type) { 2771ded93414SHyon Kim *index = i; 2772ded93414SHyon Kim return (B_TRUE); 2773ded93414SHyon Kim } 2774ded93414SHyon Kim } 2775ded93414SHyon Kim return (B_FALSE); 2776ded93414SHyon Kim } 2777ded93414SHyon Kim 2778ded93414SHyon Kim /* 2779ded93414SHyon Kim * Recusrive routine for top-down enumeration of the tree. 2780ded93414SHyon Kim */ 2781ded93414SHyon Kim static int 2782ded93414SHyon Kim ses_enumerate_node(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp, 2783ded93414SHyon Kim ses_phys_tree_t *parent, int mrange[]) 2784ded93414SHyon Kim { 2785ded93414SHyon Kim topo_mod_t *mod = sdp->sed_mod; 2786ded93414SHyon Kim ses_phys_tree_t *child = NULL; 2787ded93414SHyon Kim int i, ret = 0, ret_ch; 2788ded93414SHyon Kim uint64_t prevtype = SES_ET_UNSPECIFIED; 2789ded93414SHyon Kim ses_phys_tree_t *dirfru = NULL; 2790ded93414SHyon Kim tnode_t *tn = NULL, *frutn = NULL; 2791ded93414SHyon Kim 2792ded93414SHyon Kim if (parent == NULL) { 2793ded93414SHyon Kim return (0); 2794ded93414SHyon Kim } 2795ded93414SHyon Kim 2796ded93414SHyon Kim for (child = parent->spt_child; child != NULL; 2797ded93414SHyon Kim child = child->spt_sibling) { 2798ded93414SHyon Kim if (is_type_enumerated(child, &i)) { 2799ded93414SHyon Kim if (prevtype != phys_enum_type_list[i].pet_type) { 2800ded93414SHyon Kim /* check if range needs to be created. */ 2801ded93414SHyon Kim if (phys_enum_type_list[i].pet_dorange && 2802ded93414SHyon Kim topo_node_range_create(mod, pnode, 2803ded93414SHyon Kim phys_enum_type_list[i].pet_nodename, 0, 2804ded93414SHyon Kim mrange[i]) != 0) { 2805ded93414SHyon Kim topo_mod_dprintf(mod, 2806ded93414SHyon Kim "topo_node_create_range() failed: " 2807ded93414SHyon Kim "%s", topo_mod_errmsg(mod)); 2808ded93414SHyon Kim return (-1); 2809ded93414SHyon Kim } 2810ded93414SHyon Kim prevtype = phys_enum_type_list[i].pet_type; 2811ded93414SHyon Kim } 2812ded93414SHyon Kim 2813ded93414SHyon Kim if (!(child->spt_isfru)) { 2814ded93414SHyon Kim for (dirfru = parent; dirfru != NULL; 2815ded93414SHyon Kim dirfru = dirfru->spt_parent) { 2816ded93414SHyon Kim if (dirfru->spt_isfru) { 2817ded93414SHyon Kim break; 2818ded93414SHyon Kim } 2819ded93414SHyon Kim } 2820ded93414SHyon Kim /* found direct FRU node. */ 2821ded93414SHyon Kim if (dirfru) { 2822ded93414SHyon Kim frutn = dirfru->spt_tnode; 2823ded93414SHyon Kim } else { 2824ded93414SHyon Kim frutn = NULL; 2825ded93414SHyon Kim } 2826ded93414SHyon Kim } else { 2827ded93414SHyon Kim frutn = NULL; 2828ded93414SHyon Kim } 2829ded93414SHyon Kim 2830ded93414SHyon Kim if (ses_create_generic(sdp, child->spt_senumnode, 2831ded93414SHyon Kim pnode, frutn, phys_enum_type_list[i].pet_nodename, 2832ded93414SHyon Kim phys_enum_type_list[i].pet_defaultlabel, &tn) != 0) 2833ded93414SHyon Kim return (-1); 2834ded93414SHyon Kim 2835ded93414SHyon Kim child->spt_tnode = tn; 2836ded93414SHyon Kim /* 2837ded93414SHyon Kim * For some SES element there may be protocol specific 2838ded93414SHyon Kim * information to process. Here we are processing 2839ded93414SHyon Kim * the association between enclosure controller and 2840ded93414SHyon Kim * SAS expanders. 2841ded93414SHyon Kim */ 2842ded93414SHyon Kim if (phys_enum_type_list[i].pet_type == 2843ded93414SHyon Kim SES_ET_ESC_ELECTRONICS) { 2844ded93414SHyon Kim /* create SAS expander node */ 2845ded93414SHyon Kim if (ses_create_protocol_specific(sdp, 2846ded93414SHyon Kim child->spt_senumnode, tn, 2847ded93414SHyon Kim phys_enum_type_list[i].pet_type, 2848ded93414SHyon Kim cp, phys_enum_type_list[i].pet_dorange) != 2849ded93414SHyon Kim 0) { 2850ded93414SHyon Kim return (-1); 2851ded93414SHyon Kim } 2852ded93414SHyon Kim } 2853ded93414SHyon Kim } else { 2854ded93414SHyon Kim continue; 2855ded93414SHyon Kim } 2856ded93414SHyon Kim ret_ch = ses_enumerate_node(sdp, tn, cp, child, mrange); 2857ded93414SHyon Kim if (ret_ch) 2858ded93414SHyon Kim ret = ret_ch; /* there was an error and set the ret. */ 2859ded93414SHyon Kim } 2860ded93414SHyon Kim 2861ded93414SHyon Kim return (ret); 2862ded93414SHyon Kim } 2863ded93414SHyon Kim 2864ded93414SHyon Kim /* 2865ded93414SHyon Kim * Instantiate types of nodes that are specified in the hierarchy 2866ded93414SHyon Kim * element type list. 2867ded93414SHyon Kim */ 2868ded93414SHyon Kim static int 2869ded93414SHyon Kim ses_create_children_from_phys_tree(ses_enum_data_t *sdp, tnode_t *pnode, 2870ded93414SHyon Kim ses_enum_chassis_t *cp, ses_phys_tree_t *phys_tree) 2871ded93414SHyon Kim { 2872ded93414SHyon Kim topo_mod_t *mod = sdp->sed_mod; 2873ded93414SHyon Kim int mrange[N_PHYS_ENUM_TYPES] = { 0 }; 2874ded93414SHyon Kim ses_enum_node_t *snp; 2875ded93414SHyon Kim int i, ret; 2876ded93414SHyon Kim 2877ded93414SHyon Kim /* 2878ded93414SHyon Kim * First get max range for each type of element to be enumerated. 2879ded93414SHyon Kim */ 2880ded93414SHyon Kim for (i = 0; i < N_PHYS_ENUM_TYPES; i++) { 2881ded93414SHyon Kim if (phys_enum_type_list[i].pet_dorange) { 2882ded93414SHyon Kim for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2883ded93414SHyon Kim snp = topo_list_next(snp)) { 2884ded93414SHyon Kim if (snp->sen_type == 2885ded93414SHyon Kim phys_enum_type_list[i].pet_type) { 2886ded93414SHyon Kim if (snp->sen_instance > mrange[i]) 2887ded93414SHyon Kim mrange[i] = 2888ded93414SHyon Kim snp->sen_instance; 2889ded93414SHyon Kim } 2890ded93414SHyon Kim } 2891ded93414SHyon Kim } 2892ded93414SHyon Kim } 2893ded93414SHyon Kim 2894ded93414SHyon Kim topo_mod_dprintf(mod, "%s: creating nodes from FRU hierarchy tree.", 2895ded93414SHyon Kim cp->sec_csn); 2896ded93414SHyon Kim 2897ded93414SHyon Kim if ((ret = ses_enumerate_node(sdp, pnode, cp, phys_tree, mrange)) != 2898ded93414SHyon Kim 0) { 2899ded93414SHyon Kim topo_mod_dprintf(mod, 2900ded93414SHyon Kim "ses_create_children_from_phys_tree() failed: "); 2901ded93414SHyon Kim return (ret); 2902ded93414SHyon Kim } 2903ded93414SHyon Kim 2904ded93414SHyon Kim return (0); 2905ded93414SHyon Kim } 2906ded93414SHyon Kim 2907940d71d2Seschrock /* 2908940d71d2Seschrock * Instantiate a new chassis instance in the topology. 2909940d71d2Seschrock */ 2910940d71d2Seschrock static int 2911940d71d2Seschrock ses_create_chassis(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp) 2912940d71d2Seschrock { 2913940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 2914940d71d2Seschrock nvlist_t *props; 2915940d71d2Seschrock char *raw_manufacturer, *raw_model, *raw_revision; 2916940d71d2Seschrock char *manufacturer = NULL, *model = NULL, *product = NULL; 2917940d71d2Seschrock char *revision = NULL; 2918940d71d2Seschrock char *serial; 29196efb64caSEric Schrock char **paths; 2920940d71d2Seschrock size_t prodlen; 2921940d71d2Seschrock tnode_t *tn; 2922940d71d2Seschrock nvlist_t *fmri = NULL, *auth = NULL; 2923940d71d2Seschrock int ret = -1; 2924940d71d2Seschrock ses_enum_node_t *snp; 29256efb64caSEric Schrock ses_enum_target_t *stp; 292653dbcc59SSundeep Panicker ses_enum_chassis_t *scp; 29276efb64caSEric Schrock int i, err; 2928ded93414SHyon Kim uint64_t sc_count = 0, pindex; 2929ded93414SHyon Kim ses_phys_tree_t *sproot = NULL; 2930ded93414SHyon Kim hrtime_t start; 2931ded93414SHyon Kim hrtime_t end; 2932ded93414SHyon Kim double duration; 2933940d71d2Seschrock 2934d91236feSeschrock /* 2935d91236feSeschrock * Ignore any internal enclosures. 2936d91236feSeschrock */ 2937d91236feSeschrock if (cp->sec_internal) 2938d91236feSeschrock return (0); 2939d91236feSeschrock 2940940d71d2Seschrock /* 2941940d71d2Seschrock * Check to see if there are any devices presennt in the chassis. If 2942940d71d2Seschrock * not, ignore the chassis alltogether. This is most useful for 2943940d71d2Seschrock * ignoring internal HBAs that present a SES target but don't actually 2944940d71d2Seschrock * manage any of the devices. 2945940d71d2Seschrock */ 2946940d71d2Seschrock for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 2947940d71d2Seschrock snp = topo_list_next(snp)) { 2948940d71d2Seschrock if (snp->sen_type == SES_ET_DEVICE || 2949940d71d2Seschrock snp->sen_type == SES_ET_ARRAY_DEVICE) 2950940d71d2Seschrock break; 2951940d71d2Seschrock } 2952940d71d2Seschrock 2953940d71d2Seschrock if (snp == NULL) 2954940d71d2Seschrock return (0); 2955940d71d2Seschrock 2956940d71d2Seschrock props = ses_node_props(cp->sec_enclosure); 2957940d71d2Seschrock 2958940d71d2Seschrock /* 2959940d71d2Seschrock * We use the following property mappings: 2960940d71d2Seschrock * 2961cbb9248eSRob Johnston * manufacturer vendor-id 2962cbb9248eSRob Johnston * model product-id 2963cbb9248eSRob Johnston * serial-number libses-chassis-serial 2964940d71d2Seschrock */ 2965940d71d2Seschrock verify(nvlist_lookup_string(props, SES_EN_PROP_VID, 2966940d71d2Seschrock &raw_manufacturer) == 0); 2967940d71d2Seschrock verify(nvlist_lookup_string(props, SES_EN_PROP_PID, &raw_model) == 0); 2968940d71d2Seschrock verify(nvlist_lookup_string(props, SES_EN_PROP_REV, 2969940d71d2Seschrock &raw_revision) == 0); 2970940d71d2Seschrock verify(nvlist_lookup_string(props, LIBSES_EN_PROP_CSN, &serial) == 0); 2971940d71d2Seschrock 2972940d71d2Seschrock /* 2973940d71d2Seschrock * To construct the authority information, we 'clean' each string by 2974940d71d2Seschrock * removing any offensive characters and trimmming whitespace. For the 2975940d71d2Seschrock * 'product-id', we use a concatenation of 'manufacturer-model'. We 2976940d71d2Seschrock * also take the numerical serial number and convert it to a string. 2977940d71d2Seschrock */ 2978cbb9248eSRob Johnston if ((manufacturer = topo_mod_clean_str(mod, raw_manufacturer)) == 2979cbb9248eSRob Johnston NULL || (model = topo_mod_clean_str(mod, raw_model)) == NULL || 2980cbb9248eSRob Johnston (revision = topo_mod_clean_str(mod, raw_revision)) == NULL) { 2981940d71d2Seschrock goto error; 2982940d71d2Seschrock } 2983940d71d2Seschrock 2984940d71d2Seschrock prodlen = strlen(manufacturer) + strlen(model) + 2; 2985940d71d2Seschrock if ((product = topo_mod_alloc(mod, prodlen)) == NULL) 2986940d71d2Seschrock goto error; 2987940d71d2Seschrock 2988940d71d2Seschrock (void) snprintf(product, prodlen, "%s-%s", manufacturer, model); 2989940d71d2Seschrock 2990940d71d2Seschrock /* 2991940d71d2Seschrock * Construct the topo node and bind it to our parent. 2992940d71d2Seschrock */ 2993940d71d2Seschrock if (topo_mod_nvalloc(mod, &auth, NV_UNIQUE_NAME) != 0) 2994940d71d2Seschrock goto error; 2995940d71d2Seschrock 2996940d71d2Seschrock if (nvlist_add_string(auth, FM_FMRI_AUTH_PRODUCT, product) != 0 || 2997940d71d2Seschrock nvlist_add_string(auth, FM_FMRI_AUTH_CHASSIS, serial) != 0) { 2998940d71d2Seschrock (void) topo_mod_seterrno(mod, EMOD_NVL_INVAL); 2999940d71d2Seschrock goto error; 3000940d71d2Seschrock } 3001940d71d2Seschrock 3002940d71d2Seschrock /* 3003940d71d2Seschrock * We pass NULL for the parent FMRI because there is no resource 3004940d71d2Seschrock * associated with it. For the toplevel enclosure, we leave the 3005940d71d2Seschrock * serial/part/revision portions empty, which are reserved for 3006940d71d2Seschrock * individual components within the chassis. 3007940d71d2Seschrock */ 3008940d71d2Seschrock if ((fmri = topo_mod_hcfmri(mod, NULL, FM_HC_SCHEME_VERSION, 3009940d71d2Seschrock SES_ENCLOSURE, cp->sec_instance, NULL, auth, 3010940d71d2Seschrock model, revision, serial)) == NULL) { 3011940d71d2Seschrock topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s", 3012940d71d2Seschrock topo_mod_errmsg(mod)); 3013940d71d2Seschrock goto error; 3014940d71d2Seschrock } 3015940d71d2Seschrock 3016940d71d2Seschrock if ((tn = topo_node_bind(mod, pnode, SES_ENCLOSURE, 3017940d71d2Seschrock cp->sec_instance, fmri)) == NULL) { 3018940d71d2Seschrock topo_mod_dprintf(mod, "topo_node_bind() failed: %s", 3019940d71d2Seschrock topo_mod_errmsg(mod)); 3020940d71d2Seschrock goto error; 3021940d71d2Seschrock } 3022940d71d2Seschrock 3023940d71d2Seschrock if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) { 3024940d71d2Seschrock topo_mod_dprintf(mod, 3025940d71d2Seschrock "topo_method_register() failed: %s", 3026940d71d2Seschrock topo_mod_errmsg(mod)); 3027940d71d2Seschrock goto error; 3028940d71d2Seschrock } 3029940d71d2Seschrock 3030ac88567aSHyon Kim if (ses_set_standard_props(mod, NULL, tn, auth, 3031940d71d2Seschrock ses_node_id(cp->sec_enclosure), cp->sec_target->set_devpath) != 0) 3032940d71d2Seschrock goto error; 3033940d71d2Seschrock 30346efb64caSEric Schrock /* 30356efb64caSEric Schrock * For enclosures, we want to include all possible targets (for upgrade 30366efb64caSEric Schrock * purposes). 30376efb64caSEric Schrock */ 30386efb64caSEric Schrock for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL; 30396efb64caSEric Schrock stp = topo_list_next(stp), i++) 30406efb64caSEric Schrock ; 30416efb64caSEric Schrock 30426efb64caSEric Schrock verify(i != 0); 30436efb64caSEric Schrock paths = alloca(i * sizeof (char *)); 30446efb64caSEric Schrock 30456efb64caSEric Schrock for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL; 30466efb64caSEric Schrock stp = topo_list_next(stp), i++) 30476efb64caSEric Schrock paths[i] = stp->set_devpath; 30486efb64caSEric Schrock 30496efb64caSEric Schrock 30506efb64caSEric Schrock if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES, 30516efb64caSEric Schrock TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths, 30526efb64caSEric Schrock i, &err) != 0) { 30536efb64caSEric Schrock topo_mod_dprintf(mod, 30546efb64caSEric Schrock "failed to create property %s: %s\n", 30556efb64caSEric Schrock TOPO_PROP_PATHS, topo_strerror(err)); 30566efb64caSEric Schrock goto error; 30576efb64caSEric Schrock } 30586efb64caSEric Schrock 3059ded93414SHyon Kim if (nvlist_lookup_uint64(props, 3060ded93414SHyon Kim LIBSES_PROP_PHYS_PARENT, &pindex) == 0) { 3061ded93414SHyon Kim start = gethrtime(); /* to mearusre performance */ 3062ded93414SHyon Kim /* 3063ded93414SHyon Kim * The enclosure is supported through SUNW,FRUID. 3064ded93414SHyon Kim * Need to enumerate the nodes through hierarchical order. 3065ded93414SHyon Kim */ 3066ded93414SHyon Kim if ((sproot = topo_mod_zalloc(mod, 3067ded93414SHyon Kim sizeof (ses_phys_tree_t))) == NULL) { 3068ded93414SHyon Kim topo_mod_dprintf(mod, 3069ded93414SHyon Kim "failed to allocate root: %s\n", 3070ded93414SHyon Kim topo_strerror(err)); 3071ded93414SHyon Kim goto error; 3072ded93414SHyon Kim } 3073ded93414SHyon Kim sproot->spt_pindex = pindex; 3074ded93414SHyon Kim if (nvlist_lookup_boolean_value(props, 3075ded93414SHyon Kim LIBSES_PROP_FRU, &sproot->spt_isfru) != 0) { 3076ded93414SHyon Kim topo_mod_dprintf(mod, 3077ded93414SHyon Kim "ses_create_chassis(): Failed to find prop %s " 3078ded93414SHyon Kim "on enclosure element (CSN %s).", 3079ded93414SHyon Kim LIBSES_PROP_FRU, cp->sec_csn); 3080ded93414SHyon Kim /* an enclosure should be a FRU. continue to process. */ 3081ded93414SHyon Kim sproot->spt_isfru = B_TRUE; 3082ded93414SHyon Kim } 3083ded93414SHyon Kim if (nvlist_lookup_uint64(props, 3084ded93414SHyon Kim SES_PROP_ELEMENT_ONLY_INDEX, 3085ded93414SHyon Kim &sproot->spt_eonlyindex) != 0) { 3086ded93414SHyon Kim topo_mod_dprintf(mod, 3087ded93414SHyon Kim "ses_create_chassis(): Failed to find prop %s " 3088ded93414SHyon Kim "on enclosure element (CSN %s).", 3089ded93414SHyon Kim LIBSES_PROP_PHYS_PARENT, cp->sec_csn); 3090ded93414SHyon Kim topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t)); 3091ded93414SHyon Kim goto error; 3092ded93414SHyon Kim } 3093ded93414SHyon Kim if (sproot->spt_pindex != sproot->spt_eonlyindex) { 3094ded93414SHyon Kim topo_mod_dprintf(mod, "ses_create_chassis(): " 3095ded93414SHyon Kim "Enclosure element(CSN %s) should have " 3096ded93414SHyon Kim "itself as the parent to be the root node " 3097ded93414SHyon Kim "of FRU hierarchical tree.)", cp->sec_csn); 3098ded93414SHyon Kim topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t)); 3099ded93414SHyon Kim goto error; 3100ded93414SHyon Kim } else { 3101ded93414SHyon Kim sproot->spt_snode = cp->sec_enclosure; 3102ded93414SHyon Kim sproot->spt_tnode = tn; 3103ded93414SHyon Kim /* construct a tree. */ 3104ded93414SHyon Kim if (ses_construct_phys_tree(sdp, cp, sproot) != 0) { 3105ded93414SHyon Kim topo_mod_dprintf(mod, "ses_create_chassis(): " 3106ded93414SHyon Kim "Failed to construct FRU hierarchical " 3107ded93414SHyon Kim "tree on enclosure (CSN %s.)", 3108ded93414SHyon Kim cp->sec_csn); 3109ded93414SHyon Kim } 3110ded93414SHyon Kim 3111ded93414SHyon Kim /* enumerate elements from the tree. */ 3112ded93414SHyon Kim if (ses_create_children_from_phys_tree(sdp, tn, cp, 3113ded93414SHyon Kim sproot) != 0) { 3114ded93414SHyon Kim topo_mod_dprintf(mod, "ses_create_chassis(): " 3115ded93414SHyon Kim "Failed to create children topo nodes out " 3116ded93414SHyon Kim "of FRU hierarchical tree on enclosure " 3117ded93414SHyon Kim "(CSN %s).", cp->sec_csn); 3118ded93414SHyon Kim } 3119ded93414SHyon Kim /* destroy the phys tree. */ 3120ded93414SHyon Kim ses_phys_tree_free(mod, sproot); 3121ded93414SHyon Kim } 3122ded93414SHyon Kim 3123ded93414SHyon Kim end = gethrtime(); 3124ded93414SHyon Kim duration = end - start; 3125ded93414SHyon Kim duration /= HR_SECOND; 3126ded93414SHyon Kim topo_mod_dprintf(mod, 3127ded93414SHyon Kim "FRU boundary tree based enumeration: %.6f seconds", 3128ded93414SHyon Kim duration); 3129ded93414SHyon Kim } else { 3130ded93414SHyon Kim /* 3131ded93414SHyon Kim * Create the nodes for power supplies, fans, controllers and 3132ded93414SHyon Kim * devices. Note that SAS exopander nodes and connector nodes 3133ded93414SHyon Kim * are handled through protocol specific processing of 3134ded93414SHyon Kim * controllers. 3135ded93414SHyon Kim */ 3136ded93414SHyon Kim if (ses_create_children(sdp, tn, SES_ET_POWER_SUPPLY, 3137ded93414SHyon Kim PSU, "PSU", cp, B_TRUE) != 0 || 3138ded93414SHyon Kim ses_create_children(sdp, tn, SES_ET_COOLING, 3139ded93414SHyon Kim FAN, "FAN", cp, B_TRUE) != 0 || 3140ded93414SHyon Kim ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS, 3141ded93414SHyon Kim CONTROLLER, "CONTROLLER", cp, B_TRUE) != 0 || 3142ded93414SHyon Kim ses_create_children(sdp, tn, SES_ET_DEVICE, 3143ded93414SHyon Kim BAY, "BAY", cp, B_TRUE) != 0 || 3144ded93414SHyon Kim ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE, 3145ded93414SHyon Kim BAY, "BAY", cp, B_TRUE) != 0) 3146ded93414SHyon Kim goto error; 3147ded93414SHyon Kim } 3148940d71d2Seschrock 3149ac88567aSHyon Kim if (cp->sec_maxinstance >= 0 && 3150ac88567aSHyon Kim (topo_node_range_create(mod, tn, SUBCHASSIS, 0, 3151ac88567aSHyon Kim cp->sec_maxinstance) != 0)) { 315253dbcc59SSundeep Panicker topo_mod_dprintf(mod, "topo_node_create_range() failed: %s", 315353dbcc59SSundeep Panicker topo_mod_errmsg(mod)); 315453dbcc59SSundeep Panicker goto error; 315553dbcc59SSundeep Panicker } 315653dbcc59SSundeep Panicker 315753dbcc59SSundeep Panicker for (scp = topo_list_next(&cp->sec_subchassis); scp != NULL; 315853dbcc59SSundeep Panicker scp = topo_list_next(scp)) { 315953dbcc59SSundeep Panicker 316053dbcc59SSundeep Panicker if (ses_create_subchassis(sdp, tn, scp) != 0) 316153dbcc59SSundeep Panicker goto error; 316253dbcc59SSundeep Panicker 316353dbcc59SSundeep Panicker topo_mod_dprintf(mod, "created Subchassis node with " 3164ac88567aSHyon Kim "instance %u\nand target (%s) under Chassis with CSN %s", 3165ac88567aSHyon Kim scp->sec_instance, scp->sec_target->set_devpath, 3166ac88567aSHyon Kim cp->sec_csn); 316753dbcc59SSundeep Panicker 316853dbcc59SSundeep Panicker sc_count++; 316953dbcc59SSundeep Panicker } 317053dbcc59SSundeep Panicker 317153dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: created %llu %s nodes", 317253dbcc59SSundeep Panicker cp->sec_csn, sc_count, SUBCHASSIS); 317353dbcc59SSundeep Panicker 31746efb64caSEric Schrock cp->sec_target->set_refcount++; 31756efb64caSEric Schrock topo_node_setspecific(tn, cp->sec_target); 3176d91236feSeschrock 3177940d71d2Seschrock ret = 0; 3178940d71d2Seschrock error: 3179940d71d2Seschrock topo_mod_strfree(mod, manufacturer); 3180940d71d2Seschrock topo_mod_strfree(mod, model); 3181940d71d2Seschrock topo_mod_strfree(mod, revision); 3182940d71d2Seschrock topo_mod_strfree(mod, product); 3183940d71d2Seschrock 3184940d71d2Seschrock nvlist_free(fmri); 3185940d71d2Seschrock nvlist_free(auth); 3186940d71d2Seschrock return (ret); 3187940d71d2Seschrock } 3188940d71d2Seschrock 3189d91236feSeschrock /* 3190d91236feSeschrock * Create a bay node explicitly enumerated via XML. 3191d91236feSeschrock */ 3192d91236feSeschrock static int 3193d91236feSeschrock ses_create_bays(ses_enum_data_t *sdp, tnode_t *pnode) 3194d91236feSeschrock { 3195d91236feSeschrock topo_mod_t *mod = sdp->sed_mod; 3196d91236feSeschrock ses_enum_chassis_t *cp; 3197d91236feSeschrock 3198d91236feSeschrock /* 3199d91236feSeschrock * Iterate over chassis looking for an internal enclosure. This 3200d91236feSeschrock * property is set via a vendor-specific plugin, and there should only 3201d91236feSeschrock * ever be a single internal chassis in a system. 3202d91236feSeschrock */ 3203d91236feSeschrock for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL; 3204d91236feSeschrock cp = topo_list_next(cp)) { 3205d91236feSeschrock if (cp->sec_internal) 3206d91236feSeschrock break; 3207d91236feSeschrock } 3208d91236feSeschrock 3209d91236feSeschrock if (cp == NULL) { 3210d91236feSeschrock topo_mod_dprintf(mod, "failed to find internal chassis\n"); 3211d91236feSeschrock return (-1); 3212d91236feSeschrock } 3213d91236feSeschrock 3214d91236feSeschrock if (ses_create_children(sdp, pnode, SES_ET_DEVICE, 3215d91236feSeschrock BAY, "BAY", cp, B_FALSE) != 0 || 3216d91236feSeschrock ses_create_children(sdp, pnode, SES_ET_ARRAY_DEVICE, 3217d91236feSeschrock BAY, "BAY", cp, B_FALSE) != 0) 3218d91236feSeschrock return (-1); 3219d91236feSeschrock 3220d91236feSeschrock return (0); 3221d91236feSeschrock } 322253dbcc59SSundeep Panicker 322353dbcc59SSundeep Panicker /* 322453dbcc59SSundeep Panicker * Initialize chassis or subchassis. 322553dbcc59SSundeep Panicker */ 322653dbcc59SSundeep Panicker static int 322753dbcc59SSundeep Panicker ses_init_chassis(topo_mod_t *mod, ses_enum_data_t *sdp, ses_enum_chassis_t *pcp, 322853dbcc59SSundeep Panicker ses_enum_chassis_t *cp, ses_node_t *np, nvlist_t *props, 3229ac88567aSHyon Kim uint64_t subchassis, ses_chassis_type_e flags) 323053dbcc59SSundeep Panicker { 323153dbcc59SSundeep Panicker boolean_t internal, ident; 323253dbcc59SSundeep Panicker 323353dbcc59SSundeep Panicker assert((flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS | 323453dbcc59SSundeep Panicker SES_DUP_CHASSIS | SES_DUP_SUBCHASSIS)) != 0); 323553dbcc59SSundeep Panicker 3236ac88567aSHyon Kim assert(cp != NULL); 3237ac88567aSHyon Kim assert(np != NULL); 3238ac88567aSHyon Kim assert(props != NULL); 323953dbcc59SSundeep Panicker 324053dbcc59SSundeep Panicker if (flags & (SES_NEW_SUBCHASSIS | SES_DUP_SUBCHASSIS)) 324153dbcc59SSundeep Panicker assert(pcp != NULL); 324253dbcc59SSundeep Panicker 3243ac88567aSHyon Kim topo_mod_dprintf(mod, "ses_init_chassis: %s: index %llu, flags (%d)", 3244ac88567aSHyon Kim sdp->sed_name, subchassis, flags); 324553dbcc59SSundeep Panicker 324653dbcc59SSundeep Panicker if (flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS)) { 324753dbcc59SSundeep Panicker 324853dbcc59SSundeep Panicker topo_mod_dprintf(mod, "new chassis/subchassis"); 324953dbcc59SSundeep Panicker if (nvlist_lookup_boolean_value(props, 325053dbcc59SSundeep Panicker LIBSES_EN_PROP_INTERNAL, &internal) == 0) 325153dbcc59SSundeep Panicker cp->sec_internal = internal; 325253dbcc59SSundeep Panicker 325353dbcc59SSundeep Panicker cp->sec_enclosure = np; 325453dbcc59SSundeep Panicker cp->sec_target = sdp->sed_target; 325553dbcc59SSundeep Panicker 325653dbcc59SSundeep Panicker if (flags & SES_NEW_CHASSIS) { 3257ac88567aSHyon Kim if (!cp->sec_internal) 3258ac88567aSHyon Kim cp->sec_instance = sdp->sed_instance++; 325953dbcc59SSundeep Panicker topo_list_append(&sdp->sed_chassis, cp); 326053dbcc59SSundeep Panicker } else { 3261ac88567aSHyon Kim if (subchassis != NO_SUBCHASSIS) 3262ac88567aSHyon Kim cp->sec_instance = subchassis; 3263ac88567aSHyon Kim else 3264ac88567aSHyon Kim cp->sec_instance = pcp->sec_scinstance++; 3265ac88567aSHyon Kim 3266ac88567aSHyon Kim if (cp->sec_instance > pcp->sec_maxinstance) 3267ac88567aSHyon Kim pcp->sec_maxinstance = cp->sec_instance; 3268ac88567aSHyon Kim 326953dbcc59SSundeep Panicker topo_list_append(&pcp->sec_subchassis, cp); 327053dbcc59SSundeep Panicker } 327153dbcc59SSundeep Panicker 327253dbcc59SSundeep Panicker } else { 327353dbcc59SSundeep Panicker topo_mod_dprintf(mod, "dup chassis/subchassis"); 327453dbcc59SSundeep Panicker if (nvlist_lookup_boolean_value(props, 327553dbcc59SSundeep Panicker SES_PROP_IDENT, &ident) == 0) { 327653dbcc59SSundeep Panicker topo_mod_dprintf(mod, "overriding enclosure node"); 327753dbcc59SSundeep Panicker 327853dbcc59SSundeep Panicker cp->sec_enclosure = np; 327953dbcc59SSundeep Panicker cp->sec_target = sdp->sed_target; 328053dbcc59SSundeep Panicker } 328153dbcc59SSundeep Panicker } 328253dbcc59SSundeep Panicker 328353dbcc59SSundeep Panicker topo_list_append(&cp->sec_targets, sdp->sed_target); 328453dbcc59SSundeep Panicker sdp->sed_current = cp; 328553dbcc59SSundeep Panicker 328653dbcc59SSundeep Panicker return (0); 328753dbcc59SSundeep Panicker } 328853dbcc59SSundeep Panicker 3289940d71d2Seschrock /* 3290940d71d2Seschrock * Gather nodes from the current SES target into our chassis list, merging the 3291940d71d2Seschrock * results if necessary. 3292940d71d2Seschrock */ 3293940d71d2Seschrock static ses_walk_action_t 3294940d71d2Seschrock ses_enum_gather(ses_node_t *np, void *data) 3295940d71d2Seschrock { 3296940d71d2Seschrock nvlist_t *props = ses_node_props(np); 3297940d71d2Seschrock ses_enum_data_t *sdp = data; 3298940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 329953dbcc59SSundeep Panicker ses_enum_chassis_t *cp, *scp; 3300940d71d2Seschrock ses_enum_node_t *snp; 33010b32bb8bSEric Schrock ses_alt_node_t *sap; 3302940d71d2Seschrock char *csn; 3303940d71d2Seschrock uint64_t instance, type; 3304d91236feSeschrock uint64_t prevstatus, status; 330553dbcc59SSundeep Panicker boolean_t report; 3306ac88567aSHyon Kim uint64_t subchassis = NO_SUBCHASSIS; 3307940d71d2Seschrock 3308940d71d2Seschrock if (ses_node_type(np) == SES_NODE_ENCLOSURE) { 3309940d71d2Seschrock /* 3310940d71d2Seschrock * If we have already identified the chassis for this target, 3311940d71d2Seschrock * then this is a secondary enclosure and we should ignore it, 3312940d71d2Seschrock * along with the rest of the tree (since this is depth-first). 3313940d71d2Seschrock */ 3314940d71d2Seschrock if (sdp->sed_current != NULL) 3315940d71d2Seschrock return (SES_WALK_ACTION_TERMINATE); 3316940d71d2Seschrock 3317940d71d2Seschrock /* 3318940d71d2Seschrock * Go through the list of chassis we have seen so far and see 3319940d71d2Seschrock * if this serial number matches one of the known values. 332053dbcc59SSundeep Panicker * If so, check whether this enclosure is a subchassis. 3321940d71d2Seschrock */ 3322940d71d2Seschrock if (nvlist_lookup_string(props, LIBSES_EN_PROP_CSN, 3323940d71d2Seschrock &csn) != 0) 3324940d71d2Seschrock return (SES_WALK_ACTION_TERMINATE); 3325940d71d2Seschrock 3326ac88567aSHyon Kim (void) nvlist_lookup_uint64(props, LIBSES_EN_PROP_SUBCHASSIS_ID, 3327ac88567aSHyon Kim &subchassis); 332853dbcc59SSundeep Panicker 332953dbcc59SSundeep Panicker topo_mod_dprintf(mod, "ses_enum_gather: Enclosure Node (%s) " 3330ac88567aSHyon Kim "CSN (%s), subchassis (%llu)", sdp->sed_name, csn, 3331ac88567aSHyon Kim subchassis); 333253dbcc59SSundeep Panicker 333353dbcc59SSundeep Panicker /* 333453dbcc59SSundeep Panicker * We need to determine whether this enclosure node 333553dbcc59SSundeep Panicker * represents a chassis or a subchassis. Since we may 333653dbcc59SSundeep Panicker * receive the enclosure nodes in a non-deterministic 333753dbcc59SSundeep Panicker * manner, we need to account for all possible combinations: 333853dbcc59SSundeep Panicker * 1. Chassis for the current CSN has not yet been 333953dbcc59SSundeep Panicker * allocated 334053dbcc59SSundeep Panicker * 1.1 This is a new chassis: 334153dbcc59SSundeep Panicker * allocate and instantiate the chassis 334253dbcc59SSundeep Panicker * 1.2 This is a new subchassis: 334353dbcc59SSundeep Panicker * allocate a placeholder chassis 334453dbcc59SSundeep Panicker * allocate and instantiate the subchassis 334553dbcc59SSundeep Panicker * link the subchassis to the chassis 334653dbcc59SSundeep Panicker * 2. Chassis for the current CSN has been allocated 334753dbcc59SSundeep Panicker * 2.1 This is a duplicate chassis enclosure 334853dbcc59SSundeep Panicker * check whether to override old chassis 334953dbcc59SSundeep Panicker * append to chassis' target list 335053dbcc59SSundeep Panicker * 2.2 Only placeholder chassis exists 335153dbcc59SSundeep Panicker * fill in the chassis fields 335253dbcc59SSundeep Panicker * 2.3 This is a new subchassis 335353dbcc59SSundeep Panicker * allocate and instantiate the subchassis 335453dbcc59SSundeep Panicker * link the subchassis to the chassis 335553dbcc59SSundeep Panicker * 2.4 This is a duplicate subchassis enclosure 335653dbcc59SSundeep Panicker * check whether to override old chassis 335753dbcc59SSundeep Panicker * append to chassis' target list 335853dbcc59SSundeep Panicker */ 335953dbcc59SSundeep Panicker 3360940d71d2Seschrock for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL; 336153dbcc59SSundeep Panicker cp = topo_list_next(cp)) 336253dbcc59SSundeep Panicker if (strcmp(cp->sec_csn, csn) == 0) 3363940d71d2Seschrock break; 3364940d71d2Seschrock 3365940d71d2Seschrock if (cp == NULL) { 336653dbcc59SSundeep Panicker /* 1. Haven't seen a chassis with this CSN before */ 3367940d71d2Seschrock 3368940d71d2Seschrock if ((cp = topo_mod_zalloc(mod, 3369940d71d2Seschrock sizeof (ses_enum_chassis_t))) == NULL) 3370940d71d2Seschrock goto error; 3371940d71d2Seschrock 3372ac88567aSHyon Kim cp->sec_scinstance = SES_STARTING_SUBCHASSIS; 3373ac88567aSHyon Kim cp->sec_maxinstance = -1; 3374940d71d2Seschrock cp->sec_csn = csn; 337553dbcc59SSundeep Panicker 3376ac88567aSHyon Kim if (subchassis == NO_SUBCHASSIS) { 337753dbcc59SSundeep Panicker /* 1.1 This is a new chassis */ 337853dbcc59SSundeep Panicker 337953dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Initialize new " 3380ac88567aSHyon Kim "chassis with CSN %s", sdp->sed_name, csn); 338153dbcc59SSundeep Panicker 338253dbcc59SSundeep Panicker if (ses_init_chassis(mod, sdp, NULL, cp, 3383ac88567aSHyon Kim np, props, NO_SUBCHASSIS, 3384ac88567aSHyon Kim SES_NEW_CHASSIS) < 0) 338553dbcc59SSundeep Panicker goto error; 338653dbcc59SSundeep Panicker } else { 338753dbcc59SSundeep Panicker /* 1.2 This is a new subchassis */ 338853dbcc59SSundeep Panicker 338953dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Initialize new " 3390ac88567aSHyon Kim "subchassis with CSN %s and index %llu", 3391ac88567aSHyon Kim sdp->sed_name, csn, subchassis); 339253dbcc59SSundeep Panicker 339353dbcc59SSundeep Panicker if ((scp = topo_mod_zalloc(mod, 339453dbcc59SSundeep Panicker sizeof (ses_enum_chassis_t))) == NULL) 339553dbcc59SSundeep Panicker goto error; 339653dbcc59SSundeep Panicker 339753dbcc59SSundeep Panicker scp->sec_csn = csn; 339853dbcc59SSundeep Panicker 3399ac88567aSHyon Kim if (ses_init_chassis(mod, sdp, cp, scp, np, 3400ac88567aSHyon Kim props, subchassis, SES_NEW_SUBCHASSIS) < 0) 340153dbcc59SSundeep Panicker goto error; 340253dbcc59SSundeep Panicker } 34036efb64caSEric Schrock } else { 3404ac88567aSHyon Kim /* 3405ac88567aSHyon Kim * We have a chassis or subchassis with this CSN. If 3406ac88567aSHyon Kim * it's a chassis, we must check to see whether it is 3407ac88567aSHyon Kim * a placeholder previously created because we found a 3408ac88567aSHyon Kim * subchassis with this CSN. We will know that because 3409ac88567aSHyon Kim * the sec_target value will not be set; it is set only 3410ac88567aSHyon Kim * in ses_init_chassis(). In that case, initialise it 3411ac88567aSHyon Kim * as a new chassis; otherwise, it's a duplicate and we 3412ac88567aSHyon Kim * need to append only. 3413ac88567aSHyon Kim */ 3414ac88567aSHyon Kim if (subchassis == NO_SUBCHASSIS) { 3415ac88567aSHyon Kim if (cp->sec_target != NULL) { 341653dbcc59SSundeep Panicker /* 2.1 This is a duplicate chassis */ 341753dbcc59SSundeep Panicker 341853dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Append " 3419ac88567aSHyon Kim "duplicate chassis with CSN (%s)", 3420ac88567aSHyon Kim sdp->sed_name, csn); 342153dbcc59SSundeep Panicker 342253dbcc59SSundeep Panicker if (ses_init_chassis(mod, sdp, NULL, cp, 3423ac88567aSHyon Kim np, props, NO_SUBCHASSIS, 342453dbcc59SSundeep Panicker SES_DUP_CHASSIS) < 0) 342553dbcc59SSundeep Panicker goto error; 342653dbcc59SSundeep Panicker } else { 3427ac88567aSHyon Kim /* Placeholder chassis - init it up */ 342853dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Initialize" 3429ac88567aSHyon Kim "placeholder chassis with CSN %s", 3430ac88567aSHyon Kim sdp->sed_name, csn); 343153dbcc59SSundeep Panicker 3432ac88567aSHyon Kim if (ses_init_chassis(mod, sdp, NULL, 3433ac88567aSHyon Kim cp, np, props, NO_SUBCHASSIS, 343453dbcc59SSundeep Panicker SES_NEW_CHASSIS) < 0) 343553dbcc59SSundeep Panicker goto error; 343653dbcc59SSundeep Panicker 343753dbcc59SSundeep Panicker } 343853dbcc59SSundeep Panicker } else { 343953dbcc59SSundeep Panicker /* This is a subchassis */ 344053dbcc59SSundeep Panicker 344153dbcc59SSundeep Panicker for (scp = topo_list_next(&cp->sec_subchassis); 344253dbcc59SSundeep Panicker scp != NULL; scp = topo_list_next(scp)) 3443ac88567aSHyon Kim if (scp->sec_instance == subchassis) 344453dbcc59SSundeep Panicker break; 344553dbcc59SSundeep Panicker 344653dbcc59SSundeep Panicker if (scp == NULL) { 344753dbcc59SSundeep Panicker /* 2.3 This is a new subchassis */ 344853dbcc59SSundeep Panicker 344953dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Initialize " 345053dbcc59SSundeep Panicker "new subchassis with CSN (%s) " 345153dbcc59SSundeep Panicker "and LID (%s)", 3452ac88567aSHyon Kim sdp->sed_name, csn); 345353dbcc59SSundeep Panicker 345453dbcc59SSundeep Panicker if ((scp = topo_mod_zalloc(mod, 345553dbcc59SSundeep Panicker sizeof (ses_enum_chassis_t))) 345653dbcc59SSundeep Panicker == NULL) 345753dbcc59SSundeep Panicker goto error; 345853dbcc59SSundeep Panicker 345953dbcc59SSundeep Panicker scp->sec_csn = csn; 346053dbcc59SSundeep Panicker 346153dbcc59SSundeep Panicker if (ses_init_chassis(mod, sdp, cp, scp, 3462ac88567aSHyon Kim np, props, subchassis, 346353dbcc59SSundeep Panicker SES_NEW_SUBCHASSIS) < 0) 346453dbcc59SSundeep Panicker goto error; 346553dbcc59SSundeep Panicker } else { 346653dbcc59SSundeep Panicker /* 2.4 This is a duplicate subchassis */ 346753dbcc59SSundeep Panicker 346853dbcc59SSundeep Panicker topo_mod_dprintf(mod, "%s: Append " 346953dbcc59SSundeep Panicker "duplicate subchassis with " 3470ac88567aSHyon Kim "CSN (%s)", sdp->sed_name, csn); 347153dbcc59SSundeep Panicker 347253dbcc59SSundeep Panicker if (ses_init_chassis(mod, sdp, cp, scp, 3473ac88567aSHyon Kim np, props, subchassis, 347453dbcc59SSundeep Panicker SES_DUP_SUBCHASSIS) < 0) 347553dbcc59SSundeep Panicker goto error; 347653dbcc59SSundeep Panicker } 34776efb64caSEric Schrock } 3478940d71d2Seschrock } 3479940d71d2Seschrock } else if (ses_node_type(np) == SES_NODE_ELEMENT) { 3480940d71d2Seschrock /* 3481940d71d2Seschrock * If we haven't yet seen an enclosure node and identified the 3482940d71d2Seschrock * current chassis, something is very wrong; bail out. 3483940d71d2Seschrock */ 3484940d71d2Seschrock if (sdp->sed_current == NULL) 3485940d71d2Seschrock return (SES_WALK_ACTION_TERMINATE); 3486940d71d2Seschrock 3487940d71d2Seschrock /* 3488940d71d2Seschrock * If this isn't one of the element types we care about, then 3489940d71d2Seschrock * ignore it. 3490940d71d2Seschrock */ 3491940d71d2Seschrock verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_TYPE, 3492940d71d2Seschrock &type) == 0); 3493940d71d2Seschrock if (type != SES_ET_DEVICE && 3494940d71d2Seschrock type != SES_ET_ARRAY_DEVICE && 3495ded93414SHyon Kim type != SES_ET_SUNW_FANBOARD && 3496ded93414SHyon Kim type != SES_ET_SUNW_FANMODULE && 3497940d71d2Seschrock type != SES_ET_COOLING && 3498ded93414SHyon Kim type != SES_ET_SUNW_POWERBOARD && 3499ded93414SHyon Kim type != SES_ET_SUNW_POWERMODULE && 3500940d71d2Seschrock type != SES_ET_POWER_SUPPLY && 3501ac88567aSHyon Kim type != SES_ET_ESC_ELECTRONICS && 3502ac88567aSHyon Kim type != SES_ET_SAS_EXPANDER && 3503ac88567aSHyon Kim type != SES_ET_SAS_CONNECTOR) 3504940d71d2Seschrock return (SES_WALK_ACTION_CONTINUE); 3505940d71d2Seschrock 3506940d71d2Seschrock /* 3507940d71d2Seschrock * Get the current instance number and see if we already know 3508940d71d2Seschrock * about this element. If so, it means we have multiple paths 3509940d71d2Seschrock * to the same elements, and we should ignore the current path. 3510940d71d2Seschrock */ 3511940d71d2Seschrock verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_CLASS_INDEX, 3512940d71d2Seschrock &instance) == 0); 3513940d71d2Seschrock if (type == SES_ET_DEVICE || type == SES_ET_ARRAY_DEVICE) 3514940d71d2Seschrock (void) nvlist_lookup_uint64(props, SES_PROP_BAY_NUMBER, 3515940d71d2Seschrock &instance); 3516940d71d2Seschrock 3517940d71d2Seschrock cp = sdp->sed_current; 3518940d71d2Seschrock 3519940d71d2Seschrock for (snp = topo_list_next(&cp->sec_nodes); snp != NULL; 3520940d71d2Seschrock snp = topo_list_next(snp)) { 3521940d71d2Seschrock if (snp->sen_type == type && 3522940d71d2Seschrock snp->sen_instance == instance) 3523d91236feSeschrock break; 3524d91236feSeschrock } 3525d91236feSeschrock 3526d91236feSeschrock /* 3527d91236feSeschrock * We prefer the new element under the following circumstances: 3528d91236feSeschrock * 3529d91236feSeschrock * - The currently known element's status is unknown or not 3530d91236feSeschrock * available, but the new element has a known status. This 3531d91236feSeschrock * occurs if a given element is only available through a 3532d91236feSeschrock * particular target. 3533d91236feSeschrock * 3534d91236feSeschrock * - This is an ESC_ELECTRONICS element, and the 'reported-via' 3535d91236feSeschrock * property is set. This allows us to get reliable firmware 3536d91236feSeschrock * revision information from the enclosure node. 3537d91236feSeschrock */ 3538d91236feSeschrock if (snp != NULL) { 3539d91236feSeschrock if (nvlist_lookup_uint64( 3540d91236feSeschrock ses_node_props(snp->sen_node), 3541d91236feSeschrock SES_PROP_STATUS_CODE, &prevstatus) != 0) 3542d91236feSeschrock prevstatus = SES_ESC_UNSUPPORTED; 3543d91236feSeschrock if (nvlist_lookup_uint64( 3544d91236feSeschrock props, SES_PROP_STATUS_CODE, &status) != 0) 3545d91236feSeschrock status = SES_ESC_UNSUPPORTED; 3546d91236feSeschrock if (nvlist_lookup_boolean_value( 3547d91236feSeschrock props, SES_PROP_REPORT, &report) != 0) 3548d91236feSeschrock report = B_FALSE; 3549d91236feSeschrock 3550d91236feSeschrock if ((SES_STATUS_UNAVAIL(prevstatus) && 3551d91236feSeschrock !SES_STATUS_UNAVAIL(status)) || 3552d91236feSeschrock (type == SES_ET_ESC_ELECTRONICS && 3553d91236feSeschrock report)) { 3554d91236feSeschrock snp->sen_node = np; 3555d91236feSeschrock snp->sen_target = sdp->sed_target; 3556d91236feSeschrock } 3557d91236feSeschrock 35580b32bb8bSEric Schrock if ((sap = topo_mod_zalloc(mod, 35590b32bb8bSEric Schrock sizeof (ses_alt_node_t))) == NULL) 35600b32bb8bSEric Schrock goto error; 35610b32bb8bSEric Schrock 35620b32bb8bSEric Schrock sap->san_node = np; 35630b32bb8bSEric Schrock topo_list_append(&snp->sen_alt_nodes, sap); 35640b32bb8bSEric Schrock 3565d91236feSeschrock return (SES_WALK_ACTION_CONTINUE); 3566940d71d2Seschrock } 3567940d71d2Seschrock 3568940d71d2Seschrock if ((snp = topo_mod_zalloc(mod, 3569940d71d2Seschrock sizeof (ses_enum_node_t))) == NULL) 3570940d71d2Seschrock goto error; 3571940d71d2Seschrock 35720b32bb8bSEric Schrock if ((sap = topo_mod_zalloc(mod, 35730b32bb8bSEric Schrock sizeof (ses_alt_node_t))) == NULL) { 35740b32bb8bSEric Schrock topo_mod_free(mod, snp, sizeof (ses_enum_node_t)); 35750b32bb8bSEric Schrock goto error; 35760b32bb8bSEric Schrock } 35770b32bb8bSEric Schrock 3578940d71d2Seschrock topo_mod_dprintf(mod, "%s: adding node (%llu, %llu)", 3579940d71d2Seschrock sdp->sed_name, type, instance); 3580940d71d2Seschrock snp->sen_node = np; 3581940d71d2Seschrock snp->sen_type = type; 3582940d71d2Seschrock snp->sen_instance = instance; 3583940d71d2Seschrock snp->sen_target = sdp->sed_target; 35840b32bb8bSEric Schrock sap->san_node = np; 35850b32bb8bSEric Schrock topo_list_append(&snp->sen_alt_nodes, sap); 3586940d71d2Seschrock topo_list_append(&cp->sec_nodes, snp); 3587940d71d2Seschrock 3588940d71d2Seschrock if (type == SES_ET_DEVICE) 3589940d71d2Seschrock cp->sec_hasdev = B_TRUE; 3590940d71d2Seschrock } 3591940d71d2Seschrock 3592940d71d2Seschrock return (SES_WALK_ACTION_CONTINUE); 3593940d71d2Seschrock 3594940d71d2Seschrock error: 3595940d71d2Seschrock sdp->sed_errno = -1; 3596940d71d2Seschrock return (SES_WALK_ACTION_TERMINATE); 3597940d71d2Seschrock } 3598940d71d2Seschrock 3599940d71d2Seschrock static int 3600940d71d2Seschrock ses_process_dir(const char *dirpath, ses_enum_data_t *sdp) 3601940d71d2Seschrock { 3602940d71d2Seschrock topo_mod_t *mod = sdp->sed_mod; 3603940d71d2Seschrock DIR *dir; 3604940d71d2Seschrock struct dirent *dp; 3605940d71d2Seschrock char path[PATH_MAX]; 3606940d71d2Seschrock ses_enum_target_t *stp; 3607940d71d2Seschrock int err = -1; 3608940d71d2Seschrock 3609940d71d2Seschrock /* 3610940d71d2Seschrock * Open the SES target directory and iterate over any available 3611940d71d2Seschrock * targets. 3612940d71d2Seschrock */ 3613940d71d2Seschrock if ((dir = opendir(dirpath)) == NULL) { 3614940d71d2Seschrock /* 3615940d71d2Seschrock * If the SES target directory does not exist, then return as if 3616940d71d2Seschrock * there are no active targets. 3617940d71d2Seschrock */ 3618940d71d2Seschrock topo_mod_dprintf(mod, "failed to open ses " 3619940d71d2Seschrock "directory '%s'", dirpath); 3620940d71d2Seschrock return (0); 3621940d71d2Seschrock } 3622940d71d2Seschrock 3623940d71d2Seschrock while ((dp = readdir(dir)) != NULL) { 3624940d71d2Seschrock if (strcmp(dp->d_name, ".") == 0 || 3625940d71d2Seschrock strcmp(dp->d_name, "..") == 0) 3626940d71d2Seschrock continue; 3627940d71d2Seschrock 3628940d71d2Seschrock /* 3629940d71d2Seschrock * Create a new target instance and take a snapshot. 3630940d71d2Seschrock */ 3631940d71d2Seschrock if ((stp = topo_mod_zalloc(mod, 3632940d71d2Seschrock sizeof (ses_enum_target_t))) == NULL) 3633940d71d2Seschrock goto error; 3634940d71d2Seschrock 36350b32bb8bSEric Schrock (void) pthread_mutex_init(&stp->set_lock, NULL); 36360b32bb8bSEric Schrock 3637940d71d2Seschrock (void) snprintf(path, sizeof (path), "%s/%s", dirpath, 3638940d71d2Seschrock dp->d_name); 3639940d71d2Seschrock 3640940d71d2Seschrock /* 3641940d71d2Seschrock * We keep track of the SES device path and export it on a 3642940d71d2Seschrock * per-node basis to allow higher level software to get to the 3643940d71d2Seschrock * corresponding SES state. 3644940d71d2Seschrock */ 3645940d71d2Seschrock if ((stp->set_devpath = topo_mod_strdup(mod, path)) == NULL) { 3646940d71d2Seschrock topo_mod_free(mod, stp, sizeof (ses_enum_target_t)); 3647940d71d2Seschrock goto error; 3648940d71d2Seschrock } 3649940d71d2Seschrock 3650940d71d2Seschrock if ((stp->set_target = 3651940d71d2Seschrock ses_open(LIBSES_VERSION, path)) == NULL) { 3652940d71d2Seschrock topo_mod_dprintf(mod, "failed to open ses target " 3653940d71d2Seschrock "'%s': %s", dp->d_name, ses_errmsg()); 3654f76de749SStephen Hanson ses_sof_alloc(mod, stp->set_devpath); 3655940d71d2Seschrock topo_mod_free(mod, stp, sizeof (ses_enum_target_t)); 3656940d71d2Seschrock continue; 3657940d71d2Seschrock } 3658f76de749SStephen Hanson topo_mod_dprintf(mod, "open contract"); 3659f76de749SStephen Hanson ses_ssl_alloc(mod, stp); 3660f76de749SStephen Hanson ses_create_contract(mod, stp); 3661940d71d2Seschrock 3662940d71d2Seschrock stp->set_refcount = 1; 3663940d71d2Seschrock sdp->sed_target = stp; 3664940d71d2Seschrock stp->set_snap = ses_snap_hold(stp->set_target); 3665525b85dbSEric Schrock stp->set_snaptime = gethrtime(); 3666940d71d2Seschrock 3667940d71d2Seschrock /* 3668940d71d2Seschrock * Enumerate over all SES elements and merge them into the 3669940d71d2Seschrock * correct ses_enum_chassis_t. 3670940d71d2Seschrock */ 3671940d71d2Seschrock sdp->sed_current = NULL; 3672940d71d2Seschrock sdp->sed_errno = 0; 3673940d71d2Seschrock sdp->sed_name = dp->d_name; 3674940d71d2Seschrock (void) ses_walk(stp->set_snap, ses_enum_gather, sdp); 3675940d71d2Seschrock 3676940d71d2Seschrock if (sdp->sed_errno != 0) 3677940d71d2Seschrock goto error; 3678940d71d2Seschrock } 3679940d71d2Seschrock 3680940d71d2Seschrock err = 0; 3681940d71d2Seschrock error: 3682edb433b6SMilan Jurik (void) closedir(dir); 3683940d71d2Seschrock return (err); 3684940d71d2Seschrock } 3685940d71d2Seschrock 3686*317c37f3SRob Johnston /* 3687*317c37f3SRob Johnston * Different generations of SMCI's 4U36 storage servers used different models 3688*317c37f3SRob Johnston * of front and rear SAS expanders. 3689*317c37f3SRob Johnston */ 3690*317c37f3SRob Johnston #define SMCI4U36_FRONT_EXPANDER_PID1 "LSI-SAS2X36" 3691*317c37f3SRob Johnston #define SMCI4U36_FRONT_EXPANDER_PID2 "LSI-SAS3x40" 3692*317c37f3SRob Johnston #define SMCI4U36_FRONT_EXPANDER_PID3 "SMC-SC846P" 3693*317c37f3SRob Johnston 3694*317c37f3SRob Johnston #define SMCI4U36_REAR_EXPANDER_PID1 "LSI-CORP-SAS2X28" 3695*317c37f3SRob Johnston #define SMCI4U36_REAR_EXPANDER_PID2 "LSI-SAS3x28" 3696*317c37f3SRob Johnston 3697*317c37f3SRob Johnston static int 3698*317c37f3SRob Johnston smci_4u36_bay_label(topo_mod_t *mod, tnode_t *node, topo_version_t version, 3699*317c37f3SRob Johnston nvlist_t *in, nvlist_t **out) 3700*317c37f3SRob Johnston { 3701*317c37f3SRob Johnston int err, ret = -1; 3702*317c37f3SRob Johnston nvlist_t *pargs, *auth, *nvl = NULL, *fmri; 3703*317c37f3SRob Johnston char *label = NULL, *product_id; 3704*317c37f3SRob Johnston 3705*317c37f3SRob Johnston /* 3706*317c37f3SRob Johnston * Now look for a private argument list to determine if the invoker is 3707*317c37f3SRob Johnston * trying to do a set operation and if so, return an error as this 3708*317c37f3SRob Johnston * method only supports get operations. 3709*317c37f3SRob Johnston */ 3710*317c37f3SRob Johnston if ((nvlist_lookup_nvlist(in, TOPO_PROP_PARGS, &pargs) == 0) && 3711*317c37f3SRob Johnston nvlist_exists(pargs, TOPO_PROP_VAL_VAL)) { 3712*317c37f3SRob Johnston topo_mod_dprintf(mod, "%s: set operation not suppported", 3713*317c37f3SRob Johnston __func__); 3714*317c37f3SRob Johnston return (topo_mod_seterrno(mod, EMOD_NVL_INVAL)); 3715*317c37f3SRob Johnston } 3716*317c37f3SRob Johnston 3717*317c37f3SRob Johnston if (topo_node_resource(node, &fmri, &err) != 0) { 3718*317c37f3SRob Johnston (void) topo_mod_seterrno(mod, err); 3719*317c37f3SRob Johnston goto err; 3720*317c37f3SRob Johnston } 3721*317c37f3SRob Johnston 3722*317c37f3SRob Johnston if (nvlist_lookup_nvlist(fmri, FM_FMRI_AUTHORITY, &auth) != 0 || 3723*317c37f3SRob Johnston nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT, &product_id) != 3724*317c37f3SRob Johnston 0) { 3725*317c37f3SRob Johnston topo_mod_dprintf(mod, "%s: malformed FMRI", __func__); 3726*317c37f3SRob Johnston (void) topo_mod_seterrno(mod, EMOD_UNKNOWN); 3727*317c37f3SRob Johnston nvlist_free(fmri); 3728*317c37f3SRob Johnston goto err; 3729*317c37f3SRob Johnston } 3730*317c37f3SRob Johnston nvlist_free(fmri); 3731*317c37f3SRob Johnston 3732*317c37f3SRob Johnston if (strcmp(product_id, SMCI4U36_FRONT_EXPANDER_PID1) == 0 || 3733*317c37f3SRob Johnston strcmp(product_id, SMCI4U36_FRONT_EXPANDER_PID2) == 0 || 3734*317c37f3SRob Johnston strcmp(product_id, SMCI4U36_FRONT_EXPANDER_PID3) == 0) { 3735*317c37f3SRob Johnston err = asprintf(&label, "Front Slot %" PRIu64, 3736*317c37f3SRob Johnston topo_node_instance(node)); 3737*317c37f3SRob Johnston } else if (strcmp(product_id, SMCI4U36_REAR_EXPANDER_PID1) == 0 || 3738*317c37f3SRob Johnston strcmp(product_id, SMCI4U36_REAR_EXPANDER_PID2) == 0) { 3739*317c37f3SRob Johnston err = asprintf(&label, "Rear Slot %" PRIu64, 3740*317c37f3SRob Johnston topo_node_instance(node)); 3741*317c37f3SRob Johnston } else { 3742*317c37f3SRob Johnston topo_mod_dprintf(mod, "%s: unexpected expander product id: %s", 3743*317c37f3SRob Johnston __func__, product_id); 3744*317c37f3SRob Johnston (void) topo_mod_seterrno(mod, EMOD_UNKNOWN); 3745*317c37f3SRob Johnston goto err; 3746*317c37f3SRob Johnston } 3747*317c37f3SRob Johnston 3748*317c37f3SRob Johnston if (err < 0) { 3749*317c37f3SRob Johnston (void) topo_mod_seterrno(mod, EMOD_NOMEM); 3750*317c37f3SRob Johnston goto err; 3751*317c37f3SRob Johnston } 3752*317c37f3SRob Johnston 3753*317c37f3SRob Johnston if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 || 3754*317c37f3SRob Johnston nvlist_add_string(nvl, TOPO_PROP_VAL_NAME, TOPO_PROP_LABEL) != 0 || 3755*317c37f3SRob Johnston nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, TOPO_TYPE_STRING) 3756*317c37f3SRob Johnston != 0 || 3757*317c37f3SRob Johnston nvlist_add_string(nvl, TOPO_PROP_VAL_VAL, label) 3758*317c37f3SRob Johnston != 0) { 3759*317c37f3SRob Johnston topo_mod_dprintf(mod, "Failed to allocate 'out' nvlist"); 3760*317c37f3SRob Johnston nvlist_free(nvl); 3761*317c37f3SRob Johnston (void) topo_mod_seterrno(mod, EMOD_NOMEM); 3762*317c37f3SRob Johnston goto err; 3763*317c37f3SRob Johnston } 3764*317c37f3SRob Johnston *out = nvl; 3765*317c37f3SRob Johnston ret = 0; 3766*317c37f3SRob Johnston err: 3767*317c37f3SRob Johnston free(label); 3768*317c37f3SRob Johnston return (ret); 3769*317c37f3SRob Johnston 3770*317c37f3SRob Johnston } 3771*317c37f3SRob Johnston 3772940d71d2Seschrock static void 3773940d71d2Seschrock ses_release(topo_mod_t *mod, tnode_t *tn) 3774940d71d2Seschrock { 3775940d71d2Seschrock ses_enum_target_t *stp; 3776940d71d2Seschrock 3777f76de749SStephen Hanson if ((stp = topo_node_getspecific(tn)) != NULL) { 3778f76de749SStephen Hanson topo_node_setspecific(tn, NULL); 3779940d71d2Seschrock ses_target_free(mod, stp); 3780f76de749SStephen Hanson } 3781940d71d2Seschrock } 3782940d71d2Seschrock 3783940d71d2Seschrock /*ARGSUSED*/ 3784940d71d2Seschrock static int 3785940d71d2Seschrock ses_enum(topo_mod_t *mod, tnode_t *rnode, const char *name, 3786940d71d2Seschrock topo_instance_t min, topo_instance_t max, void *arg, void *notused) 3787940d71d2Seschrock { 3788940d71d2Seschrock ses_enum_chassis_t *cp; 3789d91236feSeschrock ses_enum_data_t *data; 3790940d71d2Seschrock 3791940d71d2Seschrock /* 3792940d71d2Seschrock * Check to make sure we're being invoked sensibly, and that we're not 3793940d71d2Seschrock * being invoked as part of a post-processing step. 3794940d71d2Seschrock */ 3795d91236feSeschrock if (strcmp(name, SES_ENCLOSURE) != 0 && strcmp(name, BAY) != 0) 3796940d71d2Seschrock return (0); 3797940d71d2Seschrock 3798940d71d2Seschrock /* 3799d91236feSeschrock * If this is the first time we've called our enumeration method, then 3800d91236feSeschrock * gather information about any available enclosures. 3801940d71d2Seschrock */ 3802d91236feSeschrock if ((data = topo_mod_getspecific(mod)) == NULL) { 3803f76de749SStephen Hanson ses_sof_freeall(mod); 3804d91236feSeschrock if ((data = topo_mod_zalloc(mod, sizeof (ses_enum_data_t))) == 3805d91236feSeschrock NULL) 3806d91236feSeschrock return (-1); 3807940d71d2Seschrock 3808d91236feSeschrock data->sed_mod = mod; 3809d91236feSeschrock topo_mod_setspecific(mod, data); 3810d91236feSeschrock 3811ac88567aSHyon Kim if (dev_list_gather(mod, &data->sed_devs) != 0) 3812d91236feSeschrock goto error; 3813d91236feSeschrock 3814d91236feSeschrock /* 3815d91236feSeschrock * We search both the ses(7D) and sgen(7D) locations, so we are 3816d91236feSeschrock * independent of any particular driver class bindings. 3817d91236feSeschrock */ 3818d91236feSeschrock if (ses_process_dir("/dev/es", data) != 0 || 3819d91236feSeschrock ses_process_dir("/dev/scsi/ses", data) != 0) 3820d91236feSeschrock goto error; 3821d91236feSeschrock } 3822d91236feSeschrock 3823d91236feSeschrock if (strcmp(name, SES_ENCLOSURE) == 0) { 3824d91236feSeschrock /* 3825d91236feSeschrock * This is a request to enumerate external enclosures. Go 3826d91236feSeschrock * through all the targets and create chassis nodes where 3827d91236feSeschrock * necessary. 3828d91236feSeschrock */ 3829d91236feSeschrock for (cp = topo_list_next(&data->sed_chassis); cp != NULL; 3830d91236feSeschrock cp = topo_list_next(cp)) { 3831d91236feSeschrock if (ses_create_chassis(data, rnode, cp) != 0) 3832d91236feSeschrock goto error; 3833d91236feSeschrock } 3834d91236feSeschrock } else { 3835d91236feSeschrock /* 3836d91236feSeschrock * This is a request to enumerate a specific bay underneath the 3837d91236feSeschrock * root chassis (for internal disks). 3838d91236feSeschrock */ 3839d91236feSeschrock if (ses_create_bays(data, rnode) != 0) 3840940d71d2Seschrock goto error; 3841940d71d2Seschrock } 3842940d71d2Seschrock 3843d91236feSeschrock /* 3844d91236feSeschrock * This is a bit of a kludge. In order to allow internal disks to be 3845d91236feSeschrock * enumerated and share snapshot-specific information with the external 3846d91236feSeschrock * enclosure enumeration, we rely on the fact that we will be invoked 3847d91236feSeschrock * for the 'ses-enclosure' node last. 3848d91236feSeschrock */ 3849d91236feSeschrock if (strcmp(name, SES_ENCLOSURE) == 0) { 385053dbcc59SSundeep Panicker for (cp = topo_list_next(&data->sed_chassis); cp != NULL; 385153dbcc59SSundeep Panicker cp = topo_list_next(cp)) 385253dbcc59SSundeep Panicker ses_data_free(data, cp); 385353dbcc59SSundeep Panicker ses_data_free(data, NULL); 3854d91236feSeschrock topo_mod_setspecific(mod, NULL); 3855d91236feSeschrock } 3856940d71d2Seschrock return (0); 3857940d71d2Seschrock 3858940d71d2Seschrock error: 385953dbcc59SSundeep Panicker for (cp = topo_list_next(&data->sed_chassis); cp != NULL; 386053dbcc59SSundeep Panicker cp = topo_list_next(cp)) 386153dbcc59SSundeep Panicker ses_data_free(data, cp); 386253dbcc59SSundeep Panicker ses_data_free(data, NULL); 3863d91236feSeschrock topo_mod_setspecific(mod, NULL); 3864940d71d2Seschrock return (-1); 3865940d71d2Seschrock } 3866940d71d2Seschrock 3867940d71d2Seschrock static const topo_modops_t ses_ops = 3868940d71d2Seschrock { ses_enum, ses_release }; 3869940d71d2Seschrock 3870940d71d2Seschrock static topo_modinfo_t ses_info = 3871940d71d2Seschrock { SES_ENCLOSURE, FM_FMRI_SCHEME_HC, SES_VERSION, &ses_ops }; 3872940d71d2Seschrock 3873940d71d2Seschrock /*ARGSUSED*/ 3874940d71d2Seschrock int 3875940d71d2Seschrock _topo_init(topo_mod_t *mod, topo_version_t version) 3876940d71d2Seschrock { 3877f76de749SStephen Hanson int rval; 3878f76de749SStephen Hanson 3879940d71d2Seschrock if (getenv("TOPOSESDEBUG") != NULL) 3880940d71d2Seschrock topo_mod_setdebug(mod); 3881940d71d2Seschrock 3882940d71d2Seschrock topo_mod_dprintf(mod, "initializing %s enumerator\n", 3883940d71d2Seschrock SES_ENCLOSURE); 3884940d71d2Seschrock 3885f76de749SStephen Hanson if ((rval = topo_mod_register(mod, &ses_info, TOPO_VERSION)) == 0) 3886f76de749SStephen Hanson ses_thread_init(mod); 3887f76de749SStephen Hanson 3888f76de749SStephen Hanson return (rval); 3889940d71d2Seschrock } 3890940d71d2Seschrock 3891940d71d2Seschrock void 3892940d71d2Seschrock _topo_fini(topo_mod_t *mod) 3893940d71d2Seschrock { 389405b58617SStephen Hanson ses_thread_fini(mod); 3895f76de749SStephen Hanson ses_sof_freeall(mod); 3896940d71d2Seschrock topo_mod_unregister(mod); 3897940d71d2Seschrock } 3898