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.
24*edb433b6SMilan Jurik  * Copyright 2012 Milan Jurik. All rights reserved.
25940d71d2Seschrock  */
26940d71d2Seschrock 
276efb64caSEric Schrock #include <alloca.h>
28940d71d2Seschrock #include <dirent.h>
29940d71d2Seschrock #include <devid.h>
30940d71d2Seschrock #include <fm/libdiskstatus.h>
31940d71d2Seschrock #include <inttypes.h>
32940d71d2Seschrock #include <pthread.h>
33940d71d2Seschrock #include <strings.h>
34ac88567aSHyon Kim #include <string.h>
35940d71d2Seschrock #include <unistd.h>
36940d71d2Seschrock #include <sys/dkio.h>
37940d71d2Seschrock #include <sys/fm/protocol.h>
3844ed9dbbSStephen Hanson #include <sys/libdevid.h>
39940d71d2Seschrock #include <sys/scsi/scsi_types.h>
40ac88567aSHyon Kim #include <sys/byteorder.h>
41f76de749SStephen Hanson #include <pthread.h>
42f76de749SStephen Hanson #include <signal.h>
43f76de749SStephen Hanson #include <fcntl.h>
44f76de749SStephen Hanson #include <sys/ctfs.h>
45f76de749SStephen Hanson #include <libcontract.h>
46f76de749SStephen Hanson #include <poll.h>
47f76de749SStephen Hanson #include <sys/contract/device.h>
48f76de749SStephen Hanson #include <libsysevent.h>
49f76de749SStephen Hanson #include <sys/sysevent/eventdefs.h>
50ded93414SHyon Kim #include <scsi/plugins/ses/vendor/sun.h>
51d91236feSeschrock 
52940d71d2Seschrock #include "disk.h"
53d91236feSeschrock #include "ses.h"
54940d71d2Seschrock 
55940d71d2Seschrock #define	SES_VERSION	1
56940d71d2Seschrock 
57ac88567aSHyon Kim #define	SES_STARTING_SUBCHASSIS 256	/* valid subchassis IDs are uint8_t */
58ac88567aSHyon Kim #define	NO_SUBCHASSIS	((uint64_t)-1)
59ac88567aSHyon Kim 
60525b85dbSEric Schrock static int ses_snap_freq = 250;		/* in milliseconds */
61940d71d2Seschrock 
62d91236feSeschrock #define	SES_STATUS_UNAVAIL(s)	\
630b32bb8bSEric Schrock 	((s) == SES_ESC_UNSUPPORTED || (s) >= SES_ESC_NOT_INSTALLED)
64940d71d2Seschrock 
65ded93414SHyon Kim #define	HR_SECOND   1000000000
66ded93414SHyon Kim 
67940d71d2Seschrock /*
68940d71d2Seschrock  * Because multiple SES targets can be part of a single chassis, we construct
69940d71d2Seschrock  * our own hierarchy that takes this into account.  These SES targets may refer
70940d71d2Seschrock  * to the same devices (multiple paths) or to different devices (managing
71940d71d2Seschrock  * different portions of the space).  We arrange things into a
72940d71d2Seschrock  * ses_enum_enclosure_t, which contains a set of ses targets, and a list of all
73940d71d2Seschrock  * nodes found so far.
74940d71d2Seschrock  */
750b32bb8bSEric Schrock typedef struct ses_alt_node {
760b32bb8bSEric Schrock 	topo_list_t		san_link;
770b32bb8bSEric Schrock 	ses_node_t		*san_node;
780b32bb8bSEric Schrock } ses_alt_node_t;
79940d71d2Seschrock 
80940d71d2Seschrock typedef struct ses_enum_node {
81940d71d2Seschrock 	topo_list_t		sen_link;
82940d71d2Seschrock 	ses_node_t		*sen_node;
830b32bb8bSEric Schrock 	topo_list_t		sen_alt_nodes;
84940d71d2Seschrock 	uint64_t		sen_type;
85940d71d2Seschrock 	uint64_t		sen_instance;
86940d71d2Seschrock 	ses_enum_target_t	*sen_target;
87940d71d2Seschrock } ses_enum_node_t;
88940d71d2Seschrock 
89940d71d2Seschrock typedef struct ses_enum_chassis {
90940d71d2Seschrock 	topo_list_t		sec_link;
9153dbcc59SSundeep Panicker 	topo_list_t		sec_subchassis;
92940d71d2Seschrock 	topo_list_t		sec_nodes;
93940d71d2Seschrock 	topo_list_t		sec_targets;
94940d71d2Seschrock 	const char		*sec_csn;
95940d71d2Seschrock 	ses_node_t		*sec_enclosure;
96940d71d2Seschrock 	ses_enum_target_t	*sec_target;
97940d71d2Seschrock 	topo_instance_t		sec_instance;
9853dbcc59SSundeep Panicker 	topo_instance_t		sec_scinstance;
99ac88567aSHyon Kim 	topo_instance_t		sec_maxinstance;
100940d71d2Seschrock 	boolean_t		sec_hasdev;
101d91236feSeschrock 	boolean_t		sec_internal;
102940d71d2Seschrock } ses_enum_chassis_t;
103940d71d2Seschrock 
104940d71d2Seschrock typedef struct ses_enum_data {
105ac88567aSHyon Kim 	topo_list_t		sed_devs;
106940d71d2Seschrock 	topo_list_t		sed_chassis;
107940d71d2Seschrock 	ses_enum_chassis_t	*sed_current;
108940d71d2Seschrock 	ses_enum_target_t	*sed_target;
109940d71d2Seschrock 	int			sed_errno;
110940d71d2Seschrock 	char			*sed_name;
111940d71d2Seschrock 	topo_mod_t		*sed_mod;
112940d71d2Seschrock 	topo_instance_t		sed_instance;
113940d71d2Seschrock } ses_enum_data_t;
114940d71d2Seschrock 
115ac88567aSHyon Kim typedef struct sas_connector_phy_data {
116ded93414SHyon Kim 	uint64_t    scpd_index;
117ded93414SHyon Kim 	uint64_t    scpd_pm;
118ac88567aSHyon Kim } sas_connector_phy_data_t;
119ac88567aSHyon Kim 
120ac88567aSHyon Kim typedef struct sas_connector_type {
121ded93414SHyon Kim 	uint64_t    sct_type;
122ded93414SHyon Kim 	char	    *sct_name;
123ac88567aSHyon Kim } sas_connector_type_t;
124ac88567aSHyon Kim 
125ac88567aSHyon Kim static const sas_connector_type_t sas_connector_type_list[] = {
126ac88567aSHyon Kim 	{   0x0, "Information unknown"  },
127ac88567aSHyon Kim 	{   0x1, "External SAS 4x receptacle (see SAS-2 and SFF-8470)"	},
128ac88567aSHyon Kim 	{   0x2, "Exteranl Mini SAS 4x receptacle (see SAS-2 and SFF-8088)" },
129ac88567aSHyon Kim 	{   0xF, "Vendor-specific external connector"	},
130ac88567aSHyon Kim 	{   0x10, "Internal wide SAS 4i plug (see SAS-2 and SFF-8484)"	},
131ac88567aSHyon Kim 	{   0x11,
132ac88567aSHyon Kim 	"Internal wide Mini SAS 4i receptacle (see SAS-2 and SFF-8087)"	},
133ac88567aSHyon Kim 	{   0x20, "Internal SAS Drive receptacle (see SAS-2 and SFF-8482)"  },
134ac88567aSHyon Kim 	{   0x21, "Internal SATA host plug (see SAS-2 and SATA-2)"  },
135ac88567aSHyon Kim 	{   0x22, "Internal SAS Drive plug (see SAS-2 and SFF-8482)"	},
136ac88567aSHyon Kim 	{   0x23, "Internal SATA device plug (see SAS-2 and SATA-2)"	},
137ac88567aSHyon Kim 	{   0x2F, "Internal SAS virtual connector"  },
138ac88567aSHyon Kim 	{   0x3F, "Vendor-specific internal connector"	},
139ac88567aSHyon Kim 	{   0x70, "Other Vendor-specific connector"	},
140ac88567aSHyon Kim 	{   0x71, "Other Vendor-specific connector"	},
141ac88567aSHyon Kim 	{   0x72, "Other Vendor-specific connector"	},
142ac88567aSHyon Kim 	{   0x73, "Other Vendor-specific connector"	},
143ac88567aSHyon Kim 	{   0x74, "Other Vendor-specific connector"	},
144ac88567aSHyon Kim 	{   0x75, "Other Vendor-specific connector"	},
145ac88567aSHyon Kim 	{   0x76, "Other Vendor-specific connector"	},
146ac88567aSHyon Kim 	{   0x77, "Other Vendor-specific connector"	},
147ac88567aSHyon Kim 	{   0x78, "Other Vendor-specific connector"	},
148ac88567aSHyon Kim 	{   0x79, "Other Vendor-specific connector"	},
149ac88567aSHyon Kim 	{   0x7A, "Other Vendor-specific connector"	},
150ac88567aSHyon Kim 	{   0x7B, "Other Vendor-specific connector"	},
151ac88567aSHyon Kim 	{   0x7C, "Other Vendor-specific connector"	},
152ac88567aSHyon Kim 	{   0x7D, "Other Vendor-specific connector"	},
153ac88567aSHyon Kim 	{   0x7E, "Other Vendor-specific connector"	},
154ac88567aSHyon Kim 	{   0x7F, "Other Vendor-specific connector"	},
155ac88567aSHyon Kim 	{   0x80, "Not Defined"	}
156ac88567aSHyon Kim };
157ac88567aSHyon Kim 
158ac88567aSHyon Kim #define	SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED  0x80
159ac88567aSHyon Kim #define	SAS_CONNECTOR_TYPE_NOT_DEFINED \
160ac88567aSHyon Kim 	"Connector type not definedi by SES-2 standard"
161ac88567aSHyon Kim #define	SAS_CONNECTOR_TYPE_RESERVED \
162ac88567aSHyon Kim 	"Connector type reserved by SES-2 standard"
163ac88567aSHyon Kim 
164ded93414SHyon Kim typedef struct phys_enum_type {
165ded93414SHyon Kim 	uint64_t    pet_type;
166ded93414SHyon Kim 	char	    *pet_nodename;
167ded93414SHyon Kim 	char	    *pet_defaultlabel;
168ded93414SHyon Kim 	boolean_t   pet_dorange;
169ded93414SHyon Kim } phys_enum_type_t;
170ded93414SHyon Kim 
171ded93414SHyon Kim static const phys_enum_type_t phys_enum_type_list[] = {
172ded93414SHyon Kim 	{   SES_ET_ARRAY_DEVICE, BAY, "BAY", B_TRUE  },
173ded93414SHyon Kim 	{   SES_ET_COOLING, FAN, "FAN", B_TRUE  },
174ded93414SHyon Kim 	{   SES_ET_DEVICE, BAY, "BAY", B_TRUE  },
175ded93414SHyon Kim 	{   SES_ET_ESC_ELECTRONICS, CONTROLLER, "CONTROLLER", B_TRUE  },
176ded93414SHyon Kim 	{   SES_ET_POWER_SUPPLY, PSU, "PSU", B_TRUE  },
177ded93414SHyon Kim 	{   SES_ET_SUNW_FANBOARD, FANBOARD, "FANBOARD", B_TRUE  },
178ded93414SHyon Kim 	{   SES_ET_SUNW_FANMODULE, FANMODULE, "FANMODULE", B_TRUE  },
179ded93414SHyon Kim 	{   SES_ET_SUNW_POWERBOARD, POWERBOARD, "POWERBOARD", B_TRUE  },
180ded93414SHyon Kim 	{   SES_ET_SUNW_POWERMODULE, POWERMODULE, "POWERMODULE", B_TRUE  }
181ded93414SHyon Kim };
182ded93414SHyon Kim 
183ded93414SHyon Kim #define	N_PHYS_ENUM_TYPES (sizeof (phys_enum_type_list) / \
184ded93414SHyon Kim 	sizeof (phys_enum_type_list[0]))
185ded93414SHyon Kim 
186ded93414SHyon Kim /*
187ded93414SHyon Kim  * Structure for the hierarchical tree for element nodes.
188ded93414SHyon Kim  */
189ded93414SHyon Kim typedef struct ses_phys_tree {
190ded93414SHyon Kim     ses_node_t	*spt_snode;
191ded93414SHyon Kim     ses_enum_node_t	*spt_senumnode;
192ded93414SHyon Kim     boolean_t	spt_isfru;
193ded93414SHyon Kim     uint64_t	spt_eonlyindex;
194ded93414SHyon Kim     uint64_t	spt_cindex;
195ded93414SHyon Kim     uint64_t	spt_pindex;
196ded93414SHyon Kim     uint64_t	spt_maxinst;
197ded93414SHyon Kim     struct ses_phys_tree    *spt_parent;
198ded93414SHyon Kim     struct ses_phys_tree    *spt_child;
199ded93414SHyon Kim     struct ses_phys_tree    *spt_sibling;
200ded93414SHyon Kim     tnode_t	*spt_tnode;
201ded93414SHyon Kim } ses_phys_tree_t;
202ded93414SHyon Kim 
20353dbcc59SSundeep Panicker typedef enum {
20453dbcc59SSundeep Panicker 	SES_NEW_CHASSIS		= 0x1,
20553dbcc59SSundeep Panicker 	SES_NEW_SUBCHASSIS	= 0x2,
20653dbcc59SSundeep Panicker 	SES_DUP_CHASSIS		= 0x4,
20753dbcc59SSundeep Panicker 	SES_DUP_SUBCHASSIS	= 0x8
20853dbcc59SSundeep Panicker } ses_chassis_type_e;
20953dbcc59SSundeep Panicker 
210ded93414SHyon Kim 
211b4879163SHyon Kim static const topo_pgroup_info_t storage_pgroup = {
212b4879163SHyon Kim 	TOPO_PGROUP_STORAGE,
213ac88567aSHyon Kim 	TOPO_STABILITY_PRIVATE,
214ac88567aSHyon Kim 	TOPO_STABILITY_PRIVATE,
215ac88567aSHyon Kim 	1
216ac88567aSHyon Kim };
217ac88567aSHyon Kim 
218b4879163SHyon Kim static const topo_pgroup_info_t smp_pgroup = {
219b4879163SHyon Kim 	TOPO_PGROUP_SMP,
220ac88567aSHyon Kim 	TOPO_STABILITY_PRIVATE,
221ac88567aSHyon Kim 	TOPO_STABILITY_PRIVATE,
222ac88567aSHyon Kim 	1
223ac88567aSHyon Kim };
224ac88567aSHyon Kim 
225a961ec00SHyon Kim static const topo_pgroup_info_t ses_pgroup = {
226a961ec00SHyon Kim 	TOPO_PGROUP_SES,
227a961ec00SHyon Kim 	TOPO_STABILITY_PRIVATE,
228a961ec00SHyon Kim 	TOPO_STABILITY_PRIVATE,
229a961ec00SHyon Kim 	1
230a961ec00SHyon Kim };
231a961ec00SHyon Kim 
232940d71d2Seschrock static int ses_present(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
233940d71d2Seschrock     nvlist_t **);
234940d71d2Seschrock static int ses_contains(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
235940d71d2Seschrock     nvlist_t **);
236940d71d2Seschrock 
237940d71d2Seschrock static const topo_method_t ses_component_methods[] = {
238940d71d2Seschrock 	{ TOPO_METH_PRESENT, TOPO_METH_PRESENT_DESC,
239940d71d2Seschrock 	    TOPO_METH_PRESENT_VERSION0, TOPO_STABILITY_INTERNAL, ses_present },
240d91236feSeschrock 	{ TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0,
241d91236feSeschrock 	    TOPO_STABILITY_INTERNAL, ses_node_enum_facility },
24288045cffSRobert Johnston 	{ TOPO_METH_SENSOR_FAILURE, TOPO_METH_SENSOR_FAILURE_DESC,
24388045cffSRobert Johnston 	    TOPO_METH_SENSOR_FAILURE_VERSION, TOPO_STABILITY_INTERNAL,
24488045cffSRobert Johnston 	    topo_method_sensor_failure },
245d91236feSeschrock 	{ NULL }
246d91236feSeschrock };
247d91236feSeschrock 
248d91236feSeschrock static const topo_method_t ses_bay_methods[] = {
249d91236feSeschrock 	{ TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0,
250d91236feSeschrock 	    TOPO_STABILITY_INTERNAL, ses_node_enum_facility },
251940d71d2Seschrock 	{ NULL }
252940d71d2Seschrock };
253940d71d2Seschrock 
254940d71d2Seschrock static const topo_method_t ses_enclosure_methods[] = {
255940d71d2Seschrock 	{ TOPO_METH_CONTAINS, TOPO_METH_CONTAINS_DESC,
256940d71d2Seschrock 	    TOPO_METH_CONTAINS_VERSION, TOPO_STABILITY_INTERNAL, ses_contains },
257d91236feSeschrock 	{ TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0,
258d91236feSeschrock 	    TOPO_STABILITY_INTERNAL, ses_enc_enum_facility },
259940d71d2Seschrock 	{ NULL }
260940d71d2Seschrock };
261940d71d2Seschrock 
262f76de749SStephen Hanson /*
263f76de749SStephen Hanson  * Functions for tracking ses devices which we were unable to open. We retry
264f76de749SStephen Hanson  * these at regular intervals using ses_recheck_dir() and if we find that we
265f76de749SStephen Hanson  * can now open any of them then we send a sysevent to indicate that a new topo
266f76de749SStephen Hanson  * snapshot should be taken.
267f76de749SStephen Hanson  */
268f76de749SStephen Hanson typedef struct ses_open_fail_list {
269f76de749SStephen Hanson 	struct ses_open_fail_list	*sof_next;
270f76de749SStephen Hanson 	char				*sof_path;
271f76de749SStephen Hanson } ses_open_fail_list_t;
272f76de749SStephen Hanson 
273f76de749SStephen Hanson static ses_open_fail_list_t *ses_sofh;
274f76de749SStephen Hanson static pthread_mutex_t ses_sofmt;
27505b58617SStephen Hanson static void ses_ct_print(char *ptr);
276f76de749SStephen Hanson 
277f76de749SStephen Hanson static void
27805b58617SStephen Hanson ses_recheck_dir()
279f76de749SStephen Hanson {
280f76de749SStephen Hanson 	ses_target_t *target;
281f76de749SStephen Hanson 	sysevent_id_t eid;
28205b58617SStephen Hanson 	char buf[80];
283f76de749SStephen Hanson 	ses_open_fail_list_t *sof;
284f76de749SStephen Hanson 
285f76de749SStephen Hanson 	/*
286f76de749SStephen Hanson 	 * check list of "unable to open" devices
287f76de749SStephen Hanson 	 */
288f76de749SStephen Hanson 	(void) pthread_mutex_lock(&ses_sofmt);
289f76de749SStephen Hanson 	for (sof = ses_sofh; sof != NULL; sof = sof->sof_next) {
290f76de749SStephen Hanson 		/*
291f76de749SStephen Hanson 		 * see if we can open it now
292f76de749SStephen Hanson 		 */
293f76de749SStephen Hanson 		if ((target = ses_open(LIBSES_VERSION,
294f76de749SStephen Hanson 		    sof->sof_path)) == NULL) {
29505b58617SStephen Hanson 			(void) snprintf(buf, sizeof (buf),
296f76de749SStephen Hanson 			    "recheck_dir - still can't open %s", sof->sof_path);
29705b58617SStephen Hanson 			ses_ct_print(buf);
298f76de749SStephen Hanson 			continue;
299f76de749SStephen Hanson 		}
300f76de749SStephen Hanson 
301f76de749SStephen Hanson 		/*
302f76de749SStephen Hanson 		 * ok - better force a new snapshot
303f76de749SStephen Hanson 		 */
30405b58617SStephen Hanson 		(void) snprintf(buf, sizeof (buf),
305f76de749SStephen Hanson 		    "recheck_dir - can now open %s", sof->sof_path);
30605b58617SStephen Hanson 		ses_ct_print(buf);
307f76de749SStephen Hanson 		(void) sysevent_post_event(EC_PLATFORM, ESC_PLATFORM_SP_RESET,
308f76de749SStephen Hanson 		    SUNW_VENDOR, "fmd", NULL, &eid);
309f76de749SStephen Hanson 		ses_close(target);
310f76de749SStephen Hanson 		break;
311f76de749SStephen Hanson 	}
312f76de749SStephen Hanson 	(void) pthread_mutex_unlock(&ses_sofmt);
313f76de749SStephen Hanson }
314f76de749SStephen Hanson 
315f76de749SStephen Hanson static void
316f76de749SStephen Hanson ses_sof_alloc(topo_mod_t *mod, char *path)
317f76de749SStephen Hanson {
318f76de749SStephen Hanson 	ses_open_fail_list_t *sof;
319f76de749SStephen Hanson 
320f76de749SStephen Hanson 	(void) pthread_mutex_lock(&ses_sofmt);
321f76de749SStephen Hanson 	sof = topo_mod_zalloc(mod, sizeof (*sof));
322f76de749SStephen Hanson 	topo_mod_dprintf(mod, "sof_alloc %s", path);
323f76de749SStephen Hanson 	sof->sof_path = path;
324f76de749SStephen Hanson 	sof->sof_next = ses_sofh;
325f76de749SStephen Hanson 	ses_sofh = sof;
326f76de749SStephen Hanson 	(void) pthread_mutex_unlock(&ses_sofmt);
327f76de749SStephen Hanson }
328f76de749SStephen Hanson 
329f76de749SStephen Hanson static void
330f76de749SStephen Hanson ses_sof_freeall(topo_mod_t *mod)
331f76de749SStephen Hanson {
332f76de749SStephen Hanson 	ses_open_fail_list_t *sof, *next_sof;
333f76de749SStephen Hanson 
334f76de749SStephen Hanson 	(void) pthread_mutex_lock(&ses_sofmt);
335f76de749SStephen Hanson 	for (sof = ses_sofh; sof != NULL; sof = next_sof) {
336f76de749SStephen Hanson 		next_sof = sof->sof_next;
337f76de749SStephen Hanson 		topo_mod_dprintf(mod, "sof_freeall %s", sof->sof_path);
338f76de749SStephen Hanson 		topo_mod_strfree(mod, sof->sof_path);
339f76de749SStephen Hanson 		topo_mod_free(mod, sof, sizeof (*sof));
340f76de749SStephen Hanson 	}
341f76de749SStephen Hanson 	ses_sofh = NULL;
342f76de749SStephen Hanson 	(void) pthread_mutex_unlock(&ses_sofmt);
343f76de749SStephen Hanson }
344f76de749SStephen Hanson 
345f76de749SStephen Hanson /*
346f76de749SStephen Hanson  * functions for verifying that the ses_enum_target_t held in a device
347f76de749SStephen Hanson  * contract's cookie field is still valid (it may have been freed by
348f76de749SStephen Hanson  * ses_release()).
349f76de749SStephen Hanson  */
350f76de749SStephen Hanson typedef struct ses_stp_list {
351f76de749SStephen Hanson 	struct ses_stp_list	*ssl_next;
352f76de749SStephen Hanson 	ses_enum_target_t	*ssl_tgt;
353f76de749SStephen Hanson } ses_stp_list_t;
354f76de749SStephen Hanson 
355f76de749SStephen Hanson static ses_stp_list_t *ses_sslh;
356f76de749SStephen Hanson static pthread_mutex_t ses_sslmt;
357f76de749SStephen Hanson 
358f76de749SStephen Hanson static void
359f76de749SStephen Hanson ses_ssl_alloc(topo_mod_t *mod, ses_enum_target_t *stp)
360f76de749SStephen Hanson {
361f76de749SStephen Hanson 	ses_stp_list_t *ssl;
362f76de749SStephen Hanson 
363f76de749SStephen Hanson 	(void) pthread_mutex_lock(&ses_sslmt);
364f76de749SStephen Hanson 	ssl = topo_mod_zalloc(mod, sizeof (*ssl));
365f76de749SStephen Hanson 	topo_mod_dprintf(mod, "ssl_alloc %p", stp);
366f76de749SStephen Hanson 	ssl->ssl_tgt = stp;
367f76de749SStephen Hanson 	ssl->ssl_next = ses_sslh;
368f76de749SStephen Hanson 	ses_sslh = ssl;
369f76de749SStephen Hanson 	(void) pthread_mutex_unlock(&ses_sslmt);
370f76de749SStephen Hanson }
371f76de749SStephen Hanson 
372f76de749SStephen Hanson static void
373f76de749SStephen Hanson ses_ssl_free(topo_mod_t *mod, ses_enum_target_t *stp)
374f76de749SStephen Hanson {
375f76de749SStephen Hanson 	ses_stp_list_t *ssl, *prev_ssl;
376f76de749SStephen Hanson 
377f76de749SStephen Hanson 	(void) pthread_mutex_lock(&ses_sslmt);
378f76de749SStephen Hanson 	prev_ssl = NULL;
379f76de749SStephen Hanson 	for (ssl = ses_sslh; ssl != NULL; ssl = ssl->ssl_next) {
380f76de749SStephen Hanson 		if (ssl->ssl_tgt == stp) {
381f76de749SStephen Hanson 			topo_mod_dprintf(mod, "ssl_free %p", ssl->ssl_tgt);
382f76de749SStephen Hanson 			if (prev_ssl == NULL)
383f76de749SStephen Hanson 				ses_sslh = ssl->ssl_next;
384f76de749SStephen Hanson 			else
385f76de749SStephen Hanson 				prev_ssl->ssl_next = ssl->ssl_next;
386f76de749SStephen Hanson 			topo_mod_free(mod, ssl, sizeof (*ssl));
387f76de749SStephen Hanson 			break;
388f76de749SStephen Hanson 		}
389f76de749SStephen Hanson 		prev_ssl = ssl;
390f76de749SStephen Hanson 	}
391f76de749SStephen Hanson 	(void) pthread_mutex_unlock(&ses_sslmt);
392f76de749SStephen Hanson }
393f76de749SStephen Hanson 
394f76de749SStephen Hanson static int
395f76de749SStephen Hanson ses_ssl_valid(ses_enum_target_t *stp)
396f76de749SStephen Hanson {
397f76de749SStephen Hanson 	ses_stp_list_t *ssl;
398f76de749SStephen Hanson 
399f76de749SStephen Hanson 	for (ssl = ses_sslh; ssl != NULL; ssl = ssl->ssl_next)
400f76de749SStephen Hanson 		if (ssl->ssl_tgt == stp)
401f76de749SStephen Hanson 			return (1);
402f76de749SStephen Hanson 	return (0);
403f76de749SStephen Hanson }
404f76de749SStephen Hanson 
405f76de749SStephen Hanson /*
406f76de749SStephen Hanson  * Functions for creating and destroying a background thread
407f76de749SStephen Hanson  * (ses_contract_thread) used for detecting when ses devices have been
408f76de749SStephen Hanson  * retired/unretired.
409f76de749SStephen Hanson  */
410f76de749SStephen Hanson static struct ses_thread_s {
411f76de749SStephen Hanson 	pthread_mutex_t mt;
412f76de749SStephen Hanson 	pthread_t tid;
413f76de749SStephen Hanson 	int thr_sig;
414f76de749SStephen Hanson 	int doexit;
415f76de749SStephen Hanson 	int count;
416f76de749SStephen Hanson } sesthread = {
417f76de749SStephen Hanson 	PTHREAD_MUTEX_INITIALIZER,
418f76de749SStephen Hanson 	0,
419f76de749SStephen Hanson 	SIGTERM,
420f76de749SStephen Hanson 	0,
421f76de749SStephen Hanson 	0
422f76de749SStephen Hanson };
423f76de749SStephen Hanson 
42405b58617SStephen Hanson typedef struct ses_mod_list {
42505b58617SStephen Hanson 	struct ses_mod_list	*smod_next;
42605b58617SStephen Hanson 	topo_mod_t		*smod_mod;
42705b58617SStephen Hanson } ses_mod_list_t;
42805b58617SStephen Hanson 
42905b58617SStephen Hanson static ses_mod_list_t *ses_smod;
43005b58617SStephen Hanson 
43105b58617SStephen Hanson static void
43205b58617SStephen Hanson ses_ct_print(char *ptr)
43305b58617SStephen Hanson {
43405b58617SStephen Hanson 	(void) pthread_mutex_lock(&sesthread.mt);
4352eb07f5eSStephen Hanson 	if (ses_smod != NULL && ses_smod->smod_mod != NULL)
43605b58617SStephen Hanson 		topo_mod_dprintf(ses_smod->smod_mod, ptr);
43705b58617SStephen Hanson 	(void) pthread_mutex_unlock(&sesthread.mt);
43805b58617SStephen Hanson }
43905b58617SStephen Hanson 
44005b58617SStephen Hanson /*ARGSUSED*/
441f76de749SStephen Hanson static void *
442f76de749SStephen Hanson ses_contract_thread(void *arg)
443f76de749SStephen Hanson {
444f76de749SStephen Hanson 	int efd, ctlfd, statfd;
445f76de749SStephen Hanson 	ct_evthdl_t ev;
446f76de749SStephen Hanson 	ctevid_t evid;
447f76de749SStephen Hanson 	uint_t event;
448f76de749SStephen Hanson 	char path[PATH_MAX];
44905b58617SStephen Hanson 	char buf[80];
450f76de749SStephen Hanson 	ses_enum_target_t *stp;
451f76de749SStephen Hanson 	ct_stathdl_t stathdl;
452f76de749SStephen Hanson 	ctid_t ctid;
453f76de749SStephen Hanson 	struct pollfd fds;
454f76de749SStephen Hanson 	int pollret;
455f76de749SStephen Hanson 
45605b58617SStephen Hanson 	ses_ct_print("start contract event thread");
457f76de749SStephen Hanson 	efd = open64(CTFS_ROOT "/device/pbundle", O_RDONLY);
458f76de749SStephen Hanson 	fds.fd = efd;
459f76de749SStephen Hanson 	fds.events = POLLIN;
460f76de749SStephen Hanson 	fds.revents = 0;
461f76de749SStephen Hanson 	for (;;) {
462f76de749SStephen Hanson 		/* check if we've been asked to exit */
463f76de749SStephen Hanson 		(void) pthread_mutex_lock(&sesthread.mt);
464f76de749SStephen Hanson 		if (sesthread.doexit) {
465f76de749SStephen Hanson 			(void) pthread_mutex_unlock(&sesthread.mt);
466f76de749SStephen Hanson 			break;
467f76de749SStephen Hanson 		}
468f76de749SStephen Hanson 		(void) pthread_mutex_unlock(&sesthread.mt);
469f76de749SStephen Hanson 
470f76de749SStephen Hanson 		/* poll until an event arrives */
471f76de749SStephen Hanson 		if ((pollret = poll(&fds, 1, 10000)) <= 0) {
472f76de749SStephen Hanson 			if (pollret == 0)
47305b58617SStephen Hanson 				ses_recheck_dir();
474f76de749SStephen Hanson 			continue;
475f76de749SStephen Hanson 		}
476f76de749SStephen Hanson 
477f76de749SStephen Hanson 		/* read the event */
478f76de749SStephen Hanson 		(void) pthread_mutex_lock(&ses_sslmt);
47905b58617SStephen Hanson 		ses_ct_print("read contract event");
480f76de749SStephen Hanson 		if (ct_event_read(efd, &ev) != 0) {
481f76de749SStephen Hanson 			(void) pthread_mutex_unlock(&ses_sslmt);
482f76de749SStephen Hanson 			continue;
483f76de749SStephen Hanson 		}
484f76de749SStephen Hanson 
485f76de749SStephen Hanson 		/* see if it is an event we are expecting */
486f76de749SStephen Hanson 		ctid = ct_event_get_ctid(ev);
48705b58617SStephen Hanson 		(void) snprintf(buf, sizeof (buf),
48805b58617SStephen Hanson 		    "got contract event ctid=%d", ctid);
48905b58617SStephen Hanson 		ses_ct_print(buf);
490f76de749SStephen Hanson 		event = ct_event_get_type(ev);
491f76de749SStephen Hanson 		if (event != CT_DEV_EV_OFFLINE && event != CT_EV_NEGEND) {
492*edb433b6SMilan Jurik 			(void) snprintf(buf, sizeof (buf),
49305b58617SStephen Hanson 			    "bad contract event %x", event);
49405b58617SStephen Hanson 			ses_ct_print(buf);
495f76de749SStephen Hanson 			ct_event_free(ev);
496f76de749SStephen Hanson 			(void) pthread_mutex_unlock(&ses_sslmt);
497f76de749SStephen Hanson 			continue;
498f76de749SStephen Hanson 		}
499f76de749SStephen Hanson 
500f76de749SStephen Hanson 		/* find target pointer saved in cookie */
501f76de749SStephen Hanson 		evid = ct_event_get_evid(ev);
502f76de749SStephen Hanson 		(void) snprintf(path, PATH_MAX, CTFS_ROOT "/device/%ld/status",
503f76de749SStephen Hanson 		    ctid);
504f76de749SStephen Hanson 		statfd = open64(path, O_RDONLY);
505*edb433b6SMilan Jurik 		(void) ct_status_read(statfd, CTD_COMMON, &stathdl);
506f76de749SStephen Hanson 		stp = (ses_enum_target_t *)(uintptr_t)
507f76de749SStephen Hanson 		    ct_status_get_cookie(stathdl);
508f76de749SStephen Hanson 		ct_status_free(stathdl);
509*edb433b6SMilan Jurik 		(void) close(statfd);
510f76de749SStephen Hanson 
511f76de749SStephen Hanson 		/* check if target pointer is still valid */
512f76de749SStephen Hanson 		if (ses_ssl_valid(stp) == 0) {
513*edb433b6SMilan Jurik 			(void) snprintf(buf, sizeof (buf),
51405b58617SStephen Hanson 			    "contract already abandoned %x", event);
51505b58617SStephen Hanson 			ses_ct_print(buf);
516f76de749SStephen Hanson 			(void) snprintf(path, PATH_MAX,
517f76de749SStephen Hanson 			    CTFS_ROOT "/device/%ld/ctl", ctid);
518f76de749SStephen Hanson 			ctlfd = open64(path, O_WRONLY);
519f76de749SStephen Hanson 			if (event != CT_EV_NEGEND)
520*edb433b6SMilan Jurik 				(void) ct_ctl_ack(ctlfd, evid);
521f76de749SStephen Hanson 			else
522*edb433b6SMilan Jurik 				(void) ct_ctl_abandon(ctlfd);
523*edb433b6SMilan Jurik 			(void) close(ctlfd);
524f76de749SStephen Hanson 			ct_event_free(ev);
525f76de749SStephen Hanson 			(void) pthread_mutex_unlock(&ses_sslmt);
526f76de749SStephen Hanson 			continue;
527f76de749SStephen Hanson 		}
528f76de749SStephen Hanson 
529f76de749SStephen Hanson 		/* find control device for ack/abandon */
530f76de749SStephen Hanson 		(void) pthread_mutex_lock(&stp->set_lock);
531f76de749SStephen Hanson 		(void) snprintf(path, PATH_MAX, CTFS_ROOT "/device/%ld/ctl",
532f76de749SStephen Hanson 		    ctid);
533f76de749SStephen Hanson 		ctlfd = open64(path, O_WRONLY);
534f76de749SStephen Hanson 		if (event != CT_EV_NEGEND) {
535f76de749SStephen Hanson 			/* if this is an offline event, do the offline */
53605b58617SStephen Hanson 			ses_ct_print("got contract offline event");
537f76de749SStephen Hanson 			if (stp->set_target) {
53805b58617SStephen Hanson 				ses_ct_print("contract thread rele");
539f76de749SStephen Hanson 				ses_snap_rele(stp->set_snap);
540f76de749SStephen Hanson 				ses_close(stp->set_target);
541f76de749SStephen Hanson 				stp->set_target = NULL;
542f76de749SStephen Hanson 			}
543*edb433b6SMilan Jurik 			(void) ct_ctl_ack(ctlfd, evid);
544f76de749SStephen Hanson 		} else {
545f76de749SStephen Hanson 			/* if this is the negend, then abandon the contract */
54605b58617SStephen Hanson 			ses_ct_print("got contract negend");
547f76de749SStephen Hanson 			if (stp->set_ctid) {
54805b58617SStephen Hanson 				snprintf(buf, sizeof (buf),
54905b58617SStephen Hanson 				    "abandon old contract %d", stp->set_ctid);
55005b58617SStephen Hanson 				ses_ct_print(buf);
551f76de749SStephen Hanson 				stp->set_ctid = NULL;
552f76de749SStephen Hanson 			}
553*edb433b6SMilan Jurik 			(void) ct_ctl_abandon(ctlfd);
554f76de749SStephen Hanson 		}
555f76de749SStephen Hanson 		close(ctlfd);
556f76de749SStephen Hanson 		(void) pthread_mutex_unlock(&stp->set_lock);
557f76de749SStephen Hanson 		ct_event_free(ev);
558f76de749SStephen Hanson 		(void) pthread_mutex_unlock(&ses_sslmt);
559f76de749SStephen Hanson 	}
560f76de749SStephen Hanson 	close(efd);
561f76de749SStephen Hanson 	return (NULL);
562f76de749SStephen Hanson }
563f76de749SStephen Hanson 
564f76de749SStephen Hanson int
565f76de749SStephen Hanson find_thr_sig(void)
566f76de749SStephen Hanson {
567f76de749SStephen Hanson 	int i;
568f76de749SStephen Hanson 	sigset_t oset, rset;
569f76de749SStephen Hanson 	int sig[] = {SIGTERM, SIGUSR1, SIGUSR2};
570f76de749SStephen Hanson 	int sig_sz = sizeof (sig) / sizeof (int);
571f76de749SStephen Hanson 	int rc = SIGTERM;
572f76de749SStephen Hanson 
573f76de749SStephen Hanson 	/* prefered set of signals that are likely used to terminate threads */
574f76de749SStephen Hanson 	(void) sigemptyset(&oset);
575f76de749SStephen Hanson 	(void) pthread_sigmask(SIG_SETMASK, NULL, &oset);
576f76de749SStephen Hanson 	for (i = 0; i < sig_sz; i++) {
577f76de749SStephen Hanson 		if (sigismember(&oset, sig[i]) == 0) {
578f76de749SStephen Hanson 			return (sig[i]);
579f76de749SStephen Hanson 		}
580f76de749SStephen Hanson 	}
581f76de749SStephen Hanson 
582f76de749SStephen Hanson 	/* reserved set of signals that are not allowed to terminate thread */
583f76de749SStephen Hanson 	(void) sigemptyset(&rset);
584f76de749SStephen Hanson 	(void) sigaddset(&rset, SIGABRT);
585f76de749SStephen Hanson 	(void) sigaddset(&rset, SIGKILL);
586f76de749SStephen Hanson 	(void) sigaddset(&rset, SIGSTOP);
587f76de749SStephen Hanson 	(void) sigaddset(&rset, SIGCANCEL);
588f76de749SStephen Hanson 
589f76de749SStephen Hanson 	/* Find signal that is not masked and not in the reserved list. */
590f76de749SStephen Hanson 	for (i = 1; i < MAXSIG; i++) {
591f76de749SStephen Hanson 		if (sigismember(&rset, i) == 1) {
592f76de749SStephen Hanson 			continue;
593f76de749SStephen Hanson 		}
594f76de749SStephen Hanson 		if (sigismember(&oset, i) == 0) {
595f76de749SStephen Hanson 			return (i);
596f76de749SStephen Hanson 		}
597f76de749SStephen Hanson 	}
598f76de749SStephen Hanson 
599f76de749SStephen Hanson 	return (rc);
600f76de749SStephen Hanson }
601f76de749SStephen Hanson 
602f76de749SStephen Hanson /*ARGSUSED*/
603f76de749SStephen Hanson static void
604f76de749SStephen Hanson ses_handler(int sig)
605f76de749SStephen Hanson {
606f76de749SStephen Hanson }
607f76de749SStephen Hanson 
608f76de749SStephen Hanson static void
60905b58617SStephen Hanson ses_thread_init(topo_mod_t *mod)
610f76de749SStephen Hanson {
611f76de749SStephen Hanson 	pthread_attr_t *attr = NULL;
612f76de749SStephen Hanson 	struct sigaction act;
61305b58617SStephen Hanson 	ses_mod_list_t *smod;
614f76de749SStephen Hanson 
615f76de749SStephen Hanson 	(void) pthread_mutex_lock(&sesthread.mt);
616f76de749SStephen Hanson 	sesthread.count++;
61705b58617SStephen Hanson 	smod = topo_mod_zalloc(mod, sizeof (*smod));
61805b58617SStephen Hanson 	smod->smod_mod = mod;
61905b58617SStephen Hanson 	smod->smod_next = ses_smod;
62005b58617SStephen Hanson 	ses_smod = smod;
621f76de749SStephen Hanson 	if (sesthread.tid == 0) {
622f76de749SStephen Hanson 		/* find a suitable signal to use for killing the thread below */
623f76de749SStephen Hanson 		sesthread.thr_sig = find_thr_sig();
624f76de749SStephen Hanson 
625f76de749SStephen Hanson 		/* if don't have a handler for this signal, create one */
626f76de749SStephen Hanson 		(void) sigaction(sesthread.thr_sig, NULL, &act);
627f76de749SStephen Hanson 		if (act.sa_handler == SIG_DFL || act.sa_handler == SIG_IGN)
628f76de749SStephen Hanson 			act.sa_handler = ses_handler;
629f76de749SStephen Hanson 		(void) sigaction(sesthread.thr_sig, &act, NULL);
630f76de749SStephen Hanson 
631f76de749SStephen Hanson 		/* create a thread to listen for offline events */
632f76de749SStephen Hanson 		(void) pthread_create(&sesthread.tid,
63305b58617SStephen Hanson 		    attr, ses_contract_thread, NULL);
634f76de749SStephen Hanson 	}
635f76de749SStephen Hanson 	(void) pthread_mutex_unlock(&sesthread.mt);
636f76de749SStephen Hanson }
637f76de749SStephen Hanson 
638f76de749SStephen Hanson static void
63905b58617SStephen Hanson ses_thread_fini(topo_mod_t *mod)
640f76de749SStephen Hanson {
64105b58617SStephen Hanson 	ses_mod_list_t *smod, *prev_smod;
64205b58617SStephen Hanson 
643f76de749SStephen Hanson 	(void) pthread_mutex_lock(&sesthread.mt);
64405b58617SStephen Hanson 	prev_smod = NULL;
64505b58617SStephen Hanson 	for (smod = ses_smod; smod != NULL; smod = smod->smod_next) {
64605b58617SStephen Hanson 		if (smod->smod_mod == mod) {
64705b58617SStephen Hanson 			if (prev_smod == NULL)
64805b58617SStephen Hanson 				ses_smod = smod->smod_next;
64905b58617SStephen Hanson 			else
65005b58617SStephen Hanson 				prev_smod->smod_next = smod->smod_next;
65105b58617SStephen Hanson 			topo_mod_free(mod, smod, sizeof (*smod));
65205b58617SStephen Hanson 			break;
65305b58617SStephen Hanson 		}
65405b58617SStephen Hanson 		prev_smod = smod;
65505b58617SStephen Hanson 	}
656f76de749SStephen Hanson 	if (--sesthread.count > 0) {
657f76de749SStephen Hanson 		(void) pthread_mutex_unlock(&sesthread.mt);
658f76de749SStephen Hanson 		return;
659f76de749SStephen Hanson 	}
660f76de749SStephen Hanson 	sesthread.doexit = 1;
661f76de749SStephen Hanson 	(void) pthread_mutex_unlock(&sesthread.mt);
662f76de749SStephen Hanson 	(void) pthread_kill(sesthread.tid, sesthread.thr_sig);
663f76de749SStephen Hanson 	(void) pthread_join(sesthread.tid, NULL);
664f76de749SStephen Hanson 	sesthread.tid = 0;
665f76de749SStephen Hanson }
666f76de749SStephen Hanson 
667f76de749SStephen Hanson static void
668f76de749SStephen Hanson ses_create_contract(topo_mod_t *mod, ses_enum_target_t *stp)
669f76de749SStephen Hanson {
670f76de749SStephen Hanson 	int tfd, len, rval;
671f76de749SStephen Hanson 	char link_path[PATH_MAX];
672f76de749SStephen Hanson 
673f76de749SStephen Hanson 	stp->set_ctid = NULL;
674f76de749SStephen Hanson 
675f76de749SStephen Hanson 	/* convert "/dev" path into "/devices" path */
676f76de749SStephen Hanson 	if ((len = readlink(stp->set_devpath, link_path, PATH_MAX)) < 0) {
677f76de749SStephen Hanson 		topo_mod_dprintf(mod, "readlink failed");
678f76de749SStephen Hanson 		return;
679f76de749SStephen Hanson 	}
680f76de749SStephen Hanson 	link_path[len] = '\0';
681f76de749SStephen Hanson 
682f76de749SStephen Hanson 	/* set up template to create new contract */
683f76de749SStephen Hanson 	tfd = open64(CTFS_ROOT "/device/template", O_RDWR);
684*edb433b6SMilan Jurik 	(void) ct_tmpl_set_critical(tfd, CT_DEV_EV_OFFLINE);
685*edb433b6SMilan Jurik 	(void) ct_tmpl_set_cookie(tfd, (uint64_t)(uintptr_t)stp);
686f76de749SStephen Hanson 
687f76de749SStephen Hanson 	/* strip "../../devices" off the front and create the contract */
688f76de749SStephen Hanson 	if ((rval = ct_dev_tmpl_set_minor(tfd, &link_path[13])) != 0)
689f76de749SStephen Hanson 		topo_mod_dprintf(mod, "failed to set minor %s rval = %d",
690f76de749SStephen Hanson 		    &link_path[13], rval);
691f76de749SStephen Hanson 	else if ((rval = ct_tmpl_create(tfd, &stp->set_ctid)) != 0)
692f76de749SStephen Hanson 		topo_mod_dprintf(mod, "failed to create ctid rval = %d", rval);
693f76de749SStephen Hanson 	else
694f76de749SStephen Hanson 		topo_mod_dprintf(mod, "created ctid=%d", stp->set_ctid);
695f76de749SStephen Hanson 	close(tfd);
696f76de749SStephen Hanson }
697f76de749SStephen Hanson 
698940d71d2Seschrock static void
699940d71d2Seschrock ses_target_free(topo_mod_t *mod, ses_enum_target_t *stp)
700940d71d2Seschrock {
701940d71d2Seschrock 	if (--stp->set_refcount == 0) {
702f76de749SStephen Hanson 		/* check if already closed due to contract offline request */
703f76de749SStephen Hanson 		(void) pthread_mutex_lock(&stp->set_lock);
704f76de749SStephen Hanson 		if (stp->set_target) {
705f76de749SStephen Hanson 			ses_snap_rele(stp->set_snap);
706f76de749SStephen Hanson 			ses_close(stp->set_target);
707f76de749SStephen Hanson 			stp->set_target = NULL;
708f76de749SStephen Hanson 		}
709f76de749SStephen Hanson 		if (stp->set_ctid) {
710f76de749SStephen Hanson 			int ctlfd;
711f76de749SStephen Hanson 			char path[PATH_MAX];
712f76de749SStephen Hanson 
713f76de749SStephen Hanson 			topo_mod_dprintf(mod, "abandon old contract %d",
714f76de749SStephen Hanson 			    stp->set_ctid);
715f76de749SStephen Hanson 			(void) snprintf(path, PATH_MAX,
716f76de749SStephen Hanson 			    CTFS_ROOT "/device/%ld/ctl", stp->set_ctid);
717f76de749SStephen Hanson 			ctlfd = open64(path, O_WRONLY);
718f76de749SStephen Hanson 			ct_ctl_abandon(ctlfd);
719f76de749SStephen Hanson 			close(ctlfd);
720f76de749SStephen Hanson 			stp->set_ctid = NULL;
721f76de749SStephen Hanson 		}
722f76de749SStephen Hanson 		(void) pthread_mutex_unlock(&stp->set_lock);
723f76de749SStephen Hanson 		ses_ssl_free(mod, stp);
724940d71d2Seschrock 		topo_mod_strfree(mod, stp->set_devpath);
725940d71d2Seschrock 		topo_mod_free(mod, stp, sizeof (ses_enum_target_t));
726940d71d2Seschrock 	}
727940d71d2Seschrock }
728940d71d2Seschrock 
729940d71d2Seschrock static void
73053dbcc59SSundeep Panicker ses_data_free(ses_enum_data_t *sdp, ses_enum_chassis_t *pcp)
731940d71d2Seschrock {
732940d71d2Seschrock 	topo_mod_t *mod = sdp->sed_mod;
733940d71d2Seschrock 	ses_enum_chassis_t *cp;
734940d71d2Seschrock 	ses_enum_node_t *np;
735940d71d2Seschrock 	ses_enum_target_t *tp;
7360b32bb8bSEric Schrock 	ses_alt_node_t *ap;
73753dbcc59SSundeep Panicker 	topo_list_t *cpl;
73853dbcc59SSundeep Panicker 
73953dbcc59SSundeep Panicker 
74053dbcc59SSundeep Panicker 	if (pcp != NULL)
74153dbcc59SSundeep Panicker 		cpl = &pcp->sec_subchassis;
74253dbcc59SSundeep Panicker 	else
74353dbcc59SSundeep Panicker 		cpl = &sdp->sed_chassis;
744940d71d2Seschrock 
74553dbcc59SSundeep Panicker 	while ((cp = topo_list_next(cpl)) != NULL) {
74653dbcc59SSundeep Panicker 		topo_list_delete(cpl, cp);
747940d71d2Seschrock 
748940d71d2Seschrock 		while ((np = topo_list_next(&cp->sec_nodes)) != NULL) {
7490b32bb8bSEric Schrock 			while ((ap = topo_list_next(&np->sen_alt_nodes)) !=
7500b32bb8bSEric Schrock 			    NULL) {
7510b32bb8bSEric Schrock 				topo_list_delete(&np->sen_alt_nodes, ap);
7520b32bb8bSEric Schrock 				topo_mod_free(mod, ap, sizeof (ses_alt_node_t));
7530b32bb8bSEric Schrock 			}
754940d71d2Seschrock 			topo_list_delete(&cp->sec_nodes, np);
755940d71d2Seschrock 			topo_mod_free(mod, np, sizeof (ses_enum_node_t));
756940d71d2Seschrock 		}
757940d71d2Seschrock 
758940d71d2Seschrock 		while ((tp = topo_list_next(&cp->sec_targets)) != NULL) {
759940d71d2Seschrock 			topo_list_delete(&cp->sec_targets, tp);
760940d71d2Seschrock 			ses_target_free(mod, tp);
761940d71d2Seschrock 		}
762940d71d2Seschrock 
763940d71d2Seschrock 		topo_mod_free(mod, cp, sizeof (ses_enum_chassis_t));
764940d71d2Seschrock 	}
765940d71d2Seschrock 
76653dbcc59SSundeep Panicker 	if (pcp == NULL) {
767ac88567aSHyon Kim 		dev_list_free(mod, &sdp->sed_devs);
76853dbcc59SSundeep Panicker 		topo_mod_free(mod, sdp, sizeof (ses_enum_data_t));
76953dbcc59SSundeep Panicker 	}
770940d71d2Seschrock }
771940d71d2Seschrock 
772940d71d2Seschrock /*
773940d71d2Seschrock  * For enclosure nodes, we have a special contains method.  By default, the hc
774940d71d2Seschrock  * walker will compare the node name and instance number to determine if an
775940d71d2Seschrock  * FMRI matches.  For enclosures where the enumeration order is impossible to
776940d71d2Seschrock  * predict, we instead use the chassis-id as a unique identifier, and ignore
777940d71d2Seschrock  * the instance number.
778940d71d2Seschrock  */
779940d71d2Seschrock static int
780940d71d2Seschrock fmri_contains(topo_mod_t *mod, nvlist_t *nv1, nvlist_t *nv2)
781940d71d2Seschrock {
782940d71d2Seschrock 	uint8_t v1, v2;
783940d71d2Seschrock 	nvlist_t **hcp1, **hcp2;
784940d71d2Seschrock 	int err, i;
785940d71d2Seschrock 	uint_t nhcp1, nhcp2;
786940d71d2Seschrock 	nvlist_t *a1, *a2;
787940d71d2Seschrock 	char *c1, *c2;
788940d71d2Seschrock 	int mindepth;
789940d71d2Seschrock 
790940d71d2Seschrock 	if (nvlist_lookup_uint8(nv1, FM_VERSION, &v1) != 0 ||
791940d71d2Seschrock 	    nvlist_lookup_uint8(nv2, FM_VERSION, &v2) != 0 ||
792940d71d2Seschrock 	    v1 > FM_HC_SCHEME_VERSION || v2 > FM_HC_SCHEME_VERSION)
793940d71d2Seschrock 		return (topo_mod_seterrno(mod, EMOD_FMRI_VERSION));
794940d71d2Seschrock 
795940d71d2Seschrock 	err = nvlist_lookup_nvlist_array(nv1, FM_FMRI_HC_LIST, &hcp1, &nhcp1);
796940d71d2Seschrock 	err |= nvlist_lookup_nvlist_array(nv2, FM_FMRI_HC_LIST, &hcp2, &nhcp2);
797940d71d2Seschrock 	if (err != 0)
798940d71d2Seschrock 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
799940d71d2Seschrock 
800940d71d2Seschrock 	/*
801940d71d2Seschrock 	 * If the chassis-id doesn't match, then these FMRIs are not
802940d71d2Seschrock 	 * equivalent.  If one of the FMRIs doesn't have a chassis ID, then we
803940d71d2Seschrock 	 * have no choice but to fall back to the instance ID.
804940d71d2Seschrock 	 */
805940d71d2Seschrock 	if (nvlist_lookup_nvlist(nv1, FM_FMRI_AUTHORITY, &a1) == 0 &&
806940d71d2Seschrock 	    nvlist_lookup_nvlist(nv2, FM_FMRI_AUTHORITY, &a2) == 0 &&
807940d71d2Seschrock 	    nvlist_lookup_string(a1, FM_FMRI_AUTH_CHASSIS, &c1) == 0 &&
808940d71d2Seschrock 	    nvlist_lookup_string(a2, FM_FMRI_AUTH_CHASSIS, &c2) == 0) {
809940d71d2Seschrock 		if (strcmp(c1, c2) != 0)
810940d71d2Seschrock 			return (0);
811940d71d2Seschrock 
812940d71d2Seschrock 		mindepth = 1;
813940d71d2Seschrock 	} else {
814940d71d2Seschrock 		mindepth = 0;
815940d71d2Seschrock 	}
816940d71d2Seschrock 
817940d71d2Seschrock 	if (nhcp2 < nhcp1)
818940d71d2Seschrock 		return (0);
819940d71d2Seschrock 
820940d71d2Seschrock 	for (i = 0; i < nhcp1; i++) {
821940d71d2Seschrock 		char *nm1 = NULL;
822940d71d2Seschrock 		char *nm2 = NULL;
823940d71d2Seschrock 		char *id1 = NULL;
824940d71d2Seschrock 		char *id2 = NULL;
825940d71d2Seschrock 
826940d71d2Seschrock 		(void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_NAME, &nm1);
827940d71d2Seschrock 		(void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_NAME, &nm2);
828940d71d2Seschrock 		(void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_ID, &id1);
829940d71d2Seschrock 		(void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_ID, &id2);
830940d71d2Seschrock 		if (nm1 == NULL || nm2 == NULL || id1 == NULL || id2 == NULL)
831940d71d2Seschrock 			return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
832940d71d2Seschrock 
833940d71d2Seschrock 		if (strcmp(nm1, nm2) == 0 &&
834940d71d2Seschrock 		    (i < mindepth || strcmp(id1, id2) == 0))
835940d71d2Seschrock 			continue;
836940d71d2Seschrock 
837940d71d2Seschrock 		return (0);
838940d71d2Seschrock 	}
839940d71d2Seschrock 
840940d71d2Seschrock 	return (1);
841940d71d2Seschrock }
842940d71d2Seschrock 
843940d71d2Seschrock /*ARGSUSED*/
844940d71d2Seschrock static int
845940d71d2Seschrock ses_contains(topo_mod_t *mod, tnode_t *tn, topo_version_t version,
846940d71d2Seschrock     nvlist_t *in, nvlist_t **out)
847940d71d2Seschrock {
848940d71d2Seschrock 	int ret;
849940d71d2Seschrock 	nvlist_t *nv1, *nv2;
850940d71d2Seschrock 
851940d71d2Seschrock 	if (version > TOPO_METH_CONTAINS_VERSION)
852940d71d2Seschrock 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
853940d71d2Seschrock 
854940d71d2Seschrock 	if (nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_FMRI, &nv1) != 0 ||
855940d71d2Seschrock 	    nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_SUBFMRI, &nv2) != 0)
856940d71d2Seschrock 		return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
857940d71d2Seschrock 
858940d71d2Seschrock 	ret = fmri_contains(mod, nv1, nv2);
859940d71d2Seschrock 	if (ret < 0)
860940d71d2Seschrock 		return (-1);
861940d71d2Seschrock 
862940d71d2Seschrock 	if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) == 0) {
86373e32a37SRobert Johnston 		if (nvlist_add_uint32(*out, TOPO_METH_CONTAINS_RET,
864940d71d2Seschrock 		    ret) == 0)
865940d71d2Seschrock 			return (0);
866940d71d2Seschrock 		else
867940d71d2Seschrock 			nvlist_free(*out);
868940d71d2Seschrock 	}
869940d71d2Seschrock 
870940d71d2Seschrock 	return (-1);
871940d71d2Seschrock 
872940d71d2Seschrock }
873940d71d2Seschrock 
874940d71d2Seschrock /*
875d91236feSeschrock  * Return a current instance of the node.  This is somewhat complicated because
876d91236feSeschrock  * we need to take a new snapshot in order to get the new data, but we don't
877940d71d2Seschrock  * want to be constantly taking SES snapshots if the consumer is going to do a
878940d71d2Seschrock  * series of queries.  So we adopt the strategy of assuming that the SES state
879d91236feSeschrock  * is not going to be rapidly changing, and limit our snapshot frequency to
880d91236feSeschrock  * some defined bounds.
881940d71d2Seschrock  */
882d91236feSeschrock ses_node_t *
8830b32bb8bSEric Schrock ses_node_lock(topo_mod_t *mod, tnode_t *tn)
884940d71d2Seschrock {
885940d71d2Seschrock 	ses_enum_target_t *tp = topo_node_getspecific(tn);
886525b85dbSEric Schrock 	hrtime_t now;
887940d71d2Seschrock 	ses_snap_t *snap;
888940d71d2Seschrock 	int err;
889d91236feSeschrock 	uint64_t nodeid;
890940d71d2Seschrock 	ses_node_t *np;
891940d71d2Seschrock 
892d91236feSeschrock 	if (tp == NULL) {
893d91236feSeschrock 		(void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP);
894d91236feSeschrock 		return (NULL);
895d91236feSeschrock 	}
896940d71d2Seschrock 
8970b32bb8bSEric Schrock 	(void) pthread_mutex_lock(&tp->set_lock);
8980b32bb8bSEric Schrock 
899940d71d2Seschrock 	/*
900940d71d2Seschrock 	 * Determine if we need to take a new snapshot.
901940d71d2Seschrock 	 */
902525b85dbSEric Schrock 	now = gethrtime();
903940d71d2Seschrock 
904f76de749SStephen Hanson 	if (tp->set_target == NULL) {
905f76de749SStephen Hanson 		/*
906f76de749SStephen Hanson 		 * We may have closed the device but not yet abandoned the
907f76de749SStephen Hanson 		 * contract (ie we've had the offline event but not yet the
908f76de749SStephen Hanson 		 * negend). If so, just return failure.
909f76de749SStephen Hanson 		 */
910f76de749SStephen Hanson 		if (tp->set_ctid != NULL) {
911f76de749SStephen Hanson 			(void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP);
912f76de749SStephen Hanson 			(void) pthread_mutex_unlock(&tp->set_lock);
913f76de749SStephen Hanson 			return (NULL);
914f76de749SStephen Hanson 		}
915f76de749SStephen Hanson 
916f76de749SStephen Hanson 		/*
917f76de749SStephen Hanson 		 * The device has been closed due to a contract offline
918f76de749SStephen Hanson 		 * request, then we need to reopen it and create a new contract.
919f76de749SStephen Hanson 		 */
920f76de749SStephen Hanson 		if ((tp->set_target =
921f76de749SStephen Hanson 		    ses_open(LIBSES_VERSION, tp->set_devpath)) == NULL) {
922f76de749SStephen Hanson 			sysevent_id_t eid;
923f76de749SStephen Hanson 
924f76de749SStephen Hanson 			(void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP);
925f76de749SStephen Hanson 			(void) pthread_mutex_unlock(&tp->set_lock);
926f76de749SStephen Hanson 			topo_mod_dprintf(mod, "recheck_dir - "
927f76de749SStephen Hanson 			    "can no longer open %s", tp->set_devpath);
928f76de749SStephen Hanson 			(void) sysevent_post_event(EC_PLATFORM,
929f76de749SStephen Hanson 			    ESC_PLATFORM_SP_RESET, SUNW_VENDOR, "fmd", NULL,
930f76de749SStephen Hanson 			    &eid);
931f76de749SStephen Hanson 			return (NULL);
932f76de749SStephen Hanson 		}
933f76de749SStephen Hanson 		topo_mod_dprintf(mod, "reopen contract");
934f76de749SStephen Hanson 		ses_create_contract(mod, tp);
935f76de749SStephen Hanson 		tp->set_snap = ses_snap_hold(tp->set_target);
936f76de749SStephen Hanson 		tp->set_snaptime = gethrtime();
937f76de749SStephen Hanson 	} else if (now - tp->set_snaptime > (ses_snap_freq * 1000 * 1000) &&
938940d71d2Seschrock 	    (snap = ses_snap_new(tp->set_target)) != NULL) {
939940d71d2Seschrock 		if (ses_snap_generation(snap) !=
940940d71d2Seschrock 		    ses_snap_generation(tp->set_snap)) {
941940d71d2Seschrock 			/*
942940d71d2Seschrock 			 * If we find ourselves in this situation, we're in
943940d71d2Seschrock 			 * trouble.  The generation count has changed, which
944940d71d2Seschrock 			 * indicates that our current topology is out of date.
945940d71d2Seschrock 			 * But we need to consult the new topology in order to
946940d71d2Seschrock 			 * determine presence at this moment in time.  We can't
947940d71d2Seschrock 			 * go back and change the topo snapshot in situ, so
948d91236feSeschrock 			 * we'll just have to fail the call in this unlikely
949d91236feSeschrock 			 * scenario.
950940d71d2Seschrock 			 */
951940d71d2Seschrock 			ses_snap_rele(snap);
952d91236feSeschrock 			(void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP);
9530b32bb8bSEric Schrock 			(void) pthread_mutex_unlock(&tp->set_lock);
954d91236feSeschrock 			return (NULL);
955940d71d2Seschrock 		} else {
956940d71d2Seschrock 			ses_snap_rele(tp->set_snap);
957940d71d2Seschrock 			tp->set_snap = snap;
958940d71d2Seschrock 		}
959525b85dbSEric Schrock 		tp->set_snaptime = gethrtime();
960940d71d2Seschrock 	}
961940d71d2Seschrock 
962940d71d2Seschrock 	snap = tp->set_snap;
963940d71d2Seschrock 
964940d71d2Seschrock 	verify(topo_prop_get_uint64(tn, TOPO_PGROUP_SES,
965940d71d2Seschrock 	    TOPO_PROP_NODE_ID, &nodeid, &err) == 0);
966940d71d2Seschrock 	verify((np = ses_node_lookup(snap, nodeid)) != NULL);
967d91236feSeschrock 
968d91236feSeschrock 	return (np);
969d91236feSeschrock }
970d91236feSeschrock 
9710b32bb8bSEric Schrock /*ARGSUSED*/
9720b32bb8bSEric Schrock void
9730b32bb8bSEric Schrock ses_node_unlock(topo_mod_t *mod, tnode_t *tn)
9740b32bb8bSEric Schrock {
9750b32bb8bSEric Schrock 	ses_enum_target_t *tp = topo_node_getspecific(tn);
9760b32bb8bSEric Schrock 
9770b32bb8bSEric Schrock 	verify(tp != NULL);
9780b32bb8bSEric Schrock 
9790b32bb8bSEric Schrock 	(void) pthread_mutex_unlock(&tp->set_lock);
9800b32bb8bSEric Schrock }
9810b32bb8bSEric Schrock 
982d91236feSeschrock /*
983d91236feSeschrock  * Determine if the element is present.
984d91236feSeschrock  */
985d91236feSeschrock /*ARGSUSED*/
986d91236feSeschrock static int
987d91236feSeschrock ses_present(topo_mod_t *mod, tnode_t *tn, topo_version_t version,
988d91236feSeschrock     nvlist_t *in, nvlist_t **out)
989d91236feSeschrock {
990d91236feSeschrock 	boolean_t present;
991d91236feSeschrock 	ses_node_t *np;
992d91236feSeschrock 	nvlist_t *props, *nvl;
993d91236feSeschrock 	uint64_t status;
994d91236feSeschrock 
9950b32bb8bSEric Schrock 	if ((np = ses_node_lock(mod, tn)) == NULL)
996d91236feSeschrock 		return (-1);
997d91236feSeschrock 
998940d71d2Seschrock 	verify((props = ses_node_props(np)) != NULL);
999940d71d2Seschrock 	verify(nvlist_lookup_uint64(props,
1000940d71d2Seschrock 	    SES_PROP_STATUS_CODE, &status) == 0);
1001940d71d2Seschrock 
10020b32bb8bSEric Schrock 	ses_node_unlock(mod, tn);
10030b32bb8bSEric Schrock 
1004940d71d2Seschrock 	present = (status != SES_ESC_NOT_INSTALLED);
1005940d71d2Seschrock 
1006940d71d2Seschrock 	if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0)
1007940d71d2Seschrock 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
1008940d71d2Seschrock 
1009940d71d2Seschrock 	if (nvlist_add_uint32(nvl, TOPO_METH_PRESENT_RET,
1010940d71d2Seschrock 	    present) != 0) {
1011940d71d2Seschrock 		nvlist_free(nvl);
1012940d71d2Seschrock 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
1013940d71d2Seschrock 	}
1014940d71d2Seschrock 
1015940d71d2Seschrock 	*out = nvl;
1016940d71d2Seschrock 
1017940d71d2Seschrock 	return (0);
1018940d71d2Seschrock }
1019940d71d2Seschrock 
1020940d71d2Seschrock /*
1021ac88567aSHyon Kim  * Sets standard properties for a ses node (enclosure, bay, controller
1022ac88567aSHyon Kim  * or expander).
1023ac88567aSHyon Kim  * This includes setting the FRU, as well as setting the
1024ac88567aSHyon Kim  * authority information.  When  the fru topo node(frutn) is not NULL
1025ac88567aSHyon Kim  * its resouce should be used as FRU.
1026940d71d2Seschrock  */
1027940d71d2Seschrock static int
1028ac88567aSHyon Kim ses_set_standard_props(topo_mod_t *mod, tnode_t *frutn, tnode_t *tn,
1029ac88567aSHyon Kim     nvlist_t *auth, uint64_t nodeid, const char *path)
1030940d71d2Seschrock {
1031940d71d2Seschrock 	int err;
1032940d71d2Seschrock 	char *product, *chassis;
1033940d71d2Seschrock 	nvlist_t *fmri;
1034940d71d2Seschrock 
1035940d71d2Seschrock 	/*
1036940d71d2Seschrock 	 * Set the authority explicitly if specified.
1037940d71d2Seschrock 	 */
1038940d71d2Seschrock 	if (auth) {
1039940d71d2Seschrock 		verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT,
1040940d71d2Seschrock 		    &product) == 0);
1041940d71d2Seschrock 		verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_CHASSIS,
1042940d71d2Seschrock 		    &chassis) == 0);
1043940d71d2Seschrock 		if (topo_prop_set_string(tn, FM_FMRI_AUTHORITY,
1044940d71d2Seschrock 		    FM_FMRI_AUTH_PRODUCT, TOPO_PROP_IMMUTABLE, product,
1045940d71d2Seschrock 		    &err) != 0 ||
1046940d71d2Seschrock 		    topo_prop_set_string(tn, FM_FMRI_AUTHORITY,
1047940d71d2Seschrock 		    FM_FMRI_AUTH_CHASSIS, TOPO_PROP_IMMUTABLE, chassis,
1048940d71d2Seschrock 		    &err) != 0 ||
1049940d71d2Seschrock 		    topo_prop_set_string(tn, FM_FMRI_AUTHORITY,
1050940d71d2Seschrock 		    FM_FMRI_AUTH_SERVER, TOPO_PROP_IMMUTABLE, "",
1051940d71d2Seschrock 		    &err) != 0) {
1052940d71d2Seschrock 			topo_mod_dprintf(mod, "failed to add authority "
1053d91236feSeschrock 			    "properties: %s\n", topo_strerror(err));
1054940d71d2Seschrock 			return (topo_mod_seterrno(mod, err));
1055940d71d2Seschrock 		}
1056940d71d2Seschrock 	}
1057940d71d2Seschrock 
1058940d71d2Seschrock 	/*
1059940d71d2Seschrock 	 * Copy the resource and set that as the FRU.
1060940d71d2Seschrock 	 */
1061ac88567aSHyon Kim 	if (frutn != NULL) {
1062ac88567aSHyon Kim 		if (topo_node_resource(frutn, &fmri, &err) != 0) {
1063ac88567aSHyon Kim 			topo_mod_dprintf(mod,
1064ac88567aSHyon Kim 			    "topo_node_resource() failed : %s\n",
1065ac88567aSHyon Kim 			    topo_strerror(err));
1066ac88567aSHyon Kim 			return (topo_mod_seterrno(mod, err));
1067ac88567aSHyon Kim 		}
1068ac88567aSHyon Kim 	} else {
1069ac88567aSHyon Kim 		if (topo_node_resource(tn, &fmri, &err) != 0) {
1070ac88567aSHyon Kim 			topo_mod_dprintf(mod,
1071ac88567aSHyon Kim 			    "topo_node_resource() failed : %s\n",
1072ac88567aSHyon Kim 			    topo_strerror(err));
1073ac88567aSHyon Kim 			return (topo_mod_seterrno(mod, err));
1074ac88567aSHyon Kim 		}
1075940d71d2Seschrock 	}
1076940d71d2Seschrock 
1077940d71d2Seschrock 	if (topo_node_fru_set(tn, fmri, 0, &err) != 0) {
1078940d71d2Seschrock 		topo_mod_dprintf(mod,
1079940d71d2Seschrock 		    "topo_node_fru_set() failed : %s\n",
1080940d71d2Seschrock 		    topo_strerror(err));
1081940d71d2Seschrock 		nvlist_free(fmri);
1082940d71d2Seschrock 		return (topo_mod_seterrno(mod, err));
1083940d71d2Seschrock 	}
1084940d71d2Seschrock 
1085940d71d2Seschrock 	nvlist_free(fmri);
1086940d71d2Seschrock 
1087940d71d2Seschrock 	/*
1088940d71d2Seschrock 	 * Set the SES-specific properties so that consumers can query
1089940d71d2Seschrock 	 * additional information about the particular SES element.
1090940d71d2Seschrock 	 */
1091a961ec00SHyon Kim 	if (topo_pgroup_create(tn, &ses_pgroup, &err) != 0) {
1092940d71d2Seschrock 		topo_mod_dprintf(mod, "failed to create propgroup "
1093940d71d2Seschrock 		    "%s: %s\n", TOPO_PGROUP_SES, topo_strerror(err));
1094940d71d2Seschrock 		return (-1);
1095940d71d2Seschrock 	}
1096940d71d2Seschrock 
1097940d71d2Seschrock 	if (topo_prop_set_uint64(tn, TOPO_PGROUP_SES,
1098940d71d2Seschrock 	    TOPO_PROP_NODE_ID, TOPO_PROP_IMMUTABLE,
1099940d71d2Seschrock 	    nodeid, &err) != 0) {
1100940d71d2Seschrock 		topo_mod_dprintf(mod,
1101940d71d2Seschrock 		    "failed to create property %s: %s\n",
1102940d71d2Seschrock 		    TOPO_PROP_NODE_ID, topo_strerror(err));
1103940d71d2Seschrock 		return (-1);
1104940d71d2Seschrock 	}
1105940d71d2Seschrock 
1106940d71d2Seschrock 	if (topo_prop_set_string(tn, TOPO_PGROUP_SES,
1107940d71d2Seschrock 	    TOPO_PROP_TARGET_PATH, TOPO_PROP_IMMUTABLE,
1108940d71d2Seschrock 	    path, &err) != 0) {
1109940d71d2Seschrock 		topo_mod_dprintf(mod,
1110940d71d2Seschrock 		    "failed to create property %s: %s\n",
1111940d71d2Seschrock 		    TOPO_PROP_TARGET_PATH, topo_strerror(err));
1112940d71d2Seschrock 		return (-1);
1113940d71d2Seschrock 	}
1114940d71d2Seschrock 
1115940d71d2Seschrock 	return (0);
1116940d71d2Seschrock }
1117940d71d2Seschrock 
1118940d71d2Seschrock /*
1119940d71d2Seschrock  * Callback to add a disk to a given bay.  We first check the status-code to
1120940d71d2Seschrock  * determine if a disk is present, ignoring those that aren't in an appropriate
11210b32bb8bSEric Schrock  * state.  We then scan the parent bay node's SAS address array to determine
11220b32bb8bSEric Schrock  * possible attached SAS addresses.  We create a disk node if the disk is not
11230b32bb8bSEric Schrock  * SAS or the SES target does not support the necessary pages for this; if we
11240b32bb8bSEric Schrock  * find the SAS address, we create a disk node and also correlate it with
11250b32bb8bSEric Schrock  * the corresponding Solaris device node to fill in the rest of the data.
1126940d71d2Seschrock  */
1127940d71d2Seschrock static int
1128940d71d2Seschrock ses_create_disk(ses_enum_data_t *sdp, tnode_t *pnode, nvlist_t *props)
1129940d71d2Seschrock {
1130940d71d2Seschrock 	topo_mod_t *mod = sdp->sed_mod;
1131940d71d2Seschrock 	uint64_t status;
1132940d71d2Seschrock 	uint_t s, nsas;
11330b32bb8bSEric Schrock 	char **paths;
113444ed9dbbSStephen Hanson 	int err, ret;
113544ed9dbbSStephen Hanson 	tnode_t *child = NULL;
1136940d71d2Seschrock 
1137940d71d2Seschrock 	/*
1138940d71d2Seschrock 	 * Skip devices that are not in a present (and possibly damaged) state.
1139940d71d2Seschrock 	 */
1140940d71d2Seschrock 	if (nvlist_lookup_uint64(props, SES_PROP_STATUS_CODE, &status) != 0)
1141940d71d2Seschrock 		return (0);
1142940d71d2Seschrock 
1143ac88567aSHyon Kim 	if (status != SES_ESC_UNSUPPORTED &&
1144ac88567aSHyon Kim 	    status != SES_ESC_OK &&
1145940d71d2Seschrock 	    status != SES_ESC_CRITICAL &&
1146940d71d2Seschrock 	    status != SES_ESC_NONCRITICAL &&
1147940d71d2Seschrock 	    status != SES_ESC_UNRECOVERABLE &&
1148940d71d2Seschrock 	    status != SES_ESC_NO_ACCESS)
1149940d71d2Seschrock 		return (0);
1150940d71d2Seschrock 
1151940d71d2Seschrock 	topo_mod_dprintf(mod, "found attached disk");
1152940d71d2Seschrock 
1153940d71d2Seschrock 	/*
1154940d71d2Seschrock 	 * Create the disk range.
1155940d71d2Seschrock 	 */
11560b32bb8bSEric Schrock 	if (topo_node_range_create(mod, pnode, DISK, 0, 0) != 0) {
1157940d71d2Seschrock 		topo_mod_dprintf(mod,
1158940d71d2Seschrock 		    "topo_node_create_range() failed: %s",
1159940d71d2Seschrock 		    topo_mod_errmsg(mod));
1160940d71d2Seschrock 		return (-1);
1161940d71d2Seschrock 	}
1162940d71d2Seschrock 
1163940d71d2Seschrock 	/*
1164940d71d2Seschrock 	 * Look through all SAS addresses and attempt to correlate them to a
1165940d71d2Seschrock 	 * known Solaris device.  If we don't find a matching node, then we
1166940d71d2Seschrock 	 * don't enumerate the disk node.
116723a5d44cSHyon Kim 	 * Note that TOPO_PROP_SAS_ADDR prop includes SAS address from
116823a5d44cSHyon Kim 	 * alternate elements that represent the same device.
1169940d71d2Seschrock 	 */
11700b32bb8bSEric Schrock 	if (topo_prop_get_string_array(pnode, TOPO_PGROUP_SES,
11710b32bb8bSEric Schrock 	    TOPO_PROP_SAS_ADDR, &paths, &nsas, &err) != 0)
11720b32bb8bSEric Schrock 		return (0);
11730b32bb8bSEric Schrock 
11740b32bb8bSEric Schrock 	err = 0;
11750b32bb8bSEric Schrock 
1176940d71d2Seschrock 	for (s = 0; s < nsas; s++) {
1177ac88567aSHyon Kim 		ret = disk_declare_addr(mod, pnode, &sdp->sed_devs, paths[s],
117844ed9dbbSStephen Hanson 		    &child);
117944ed9dbbSStephen Hanson 		if (ret == 0) {
118044ed9dbbSStephen Hanson 			break;
118144ed9dbbSStephen Hanson 		} else if (ret < 0) {
11820b32bb8bSEric Schrock 			err = -1;
11830b32bb8bSEric Schrock 			break;
11840b32bb8bSEric Schrock 		}
11850b32bb8bSEric Schrock 	}
11860b32bb8bSEric Schrock 
118744ed9dbbSStephen Hanson 	if (s == nsas)
1188*edb433b6SMilan Jurik 		(void) disk_declare_non_enumerated(mod, pnode, &child);
118944ed9dbbSStephen Hanson 
119044ed9dbbSStephen Hanson 	/* copy sas_addresses (target-ports) from parent (with 'w'added) */
119144ed9dbbSStephen Hanson 	if (child != NULL) {
119244ed9dbbSStephen Hanson 		int i;
119344ed9dbbSStephen Hanson 		char **tports;
119444ed9dbbSStephen Hanson 		uint64_t wwn;
119544ed9dbbSStephen Hanson 
119644ed9dbbSStephen Hanson 		tports = topo_mod_zalloc(mod, sizeof (char *) * nsas);
119744ed9dbbSStephen Hanson 		if (tports != NULL) {
119844ed9dbbSStephen Hanson 			for (i = 0; i < nsas; i++) {
119944ed9dbbSStephen Hanson 				if (scsi_wwnstr_to_wwn(paths[i], &wwn) !=
120044ed9dbbSStephen Hanson 				    DDI_SUCCESS)
120144ed9dbbSStephen Hanson 					break;
120244ed9dbbSStephen Hanson 				tports[i] = scsi_wwn_to_wwnstr(wwn, 1, NULL);
120344ed9dbbSStephen Hanson 				if (tports[i] == NULL)
120444ed9dbbSStephen Hanson 					break;
120544ed9dbbSStephen Hanson 			}
120644ed9dbbSStephen Hanson 			/* if they all worked then create the property */
120744ed9dbbSStephen Hanson 			if (i == nsas)
120844ed9dbbSStephen Hanson 				(void) topo_prop_set_string_array(child,
120944ed9dbbSStephen Hanson 				    TOPO_PGROUP_STORAGE,
121044ed9dbbSStephen Hanson 				    TOPO_STORAGE_TARGET_PORT_L0IDS,
121144ed9dbbSStephen Hanson 				    TOPO_PROP_IMMUTABLE, (const char **)tports,
121244ed9dbbSStephen Hanson 				    nsas, &err);
121344ed9dbbSStephen Hanson 
121444ed9dbbSStephen Hanson 			for (i = 0; i < nsas; i++)
121544ed9dbbSStephen Hanson 				if (tports[i] != NULL)
121644ed9dbbSStephen Hanson 					scsi_free_wwnstr(tports[i]);
121744ed9dbbSStephen Hanson 			topo_mod_free(mod, tports, sizeof (char *) * nsas);
121844ed9dbbSStephen Hanson 		}
121944ed9dbbSStephen Hanson 	}
122044ed9dbbSStephen Hanson 
12210b32bb8bSEric Schrock 	for (s = 0; s < nsas; s++)
12220b32bb8bSEric Schrock 		topo_mod_free(mod, paths[s], strlen(paths[s]) + 1);
12230b32bb8bSEric Schrock 	topo_mod_free(mod, paths, nsas * sizeof (char *));
12240b32bb8bSEric Schrock 
12250b32bb8bSEric Schrock 	return (err);
12260b32bb8bSEric Schrock }
12270b32bb8bSEric Schrock 
12280b32bb8bSEric Schrock static int
12290b32bb8bSEric Schrock ses_add_bay_props(topo_mod_t *mod, tnode_t *tn, ses_enum_node_t *snp)
12300b32bb8bSEric Schrock {
12310b32bb8bSEric Schrock 	ses_alt_node_t *ap;
12320b32bb8bSEric Schrock 	ses_node_t *np;
12330b32bb8bSEric Schrock 	nvlist_t *props;
12340b32bb8bSEric Schrock 
12350b32bb8bSEric Schrock 	nvlist_t **phys;
12360b32bb8bSEric Schrock 	uint_t i, j, n_phys, all_phys = 0;
12370b32bb8bSEric Schrock 	char **paths;
12380b32bb8bSEric Schrock 	uint64_t addr;
12390b32bb8bSEric Schrock 	size_t len;
12400b32bb8bSEric Schrock 	int terr, err = -1;
12410b32bb8bSEric Schrock 
12420b32bb8bSEric Schrock 	for (ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL;
12430b32bb8bSEric Schrock 	    ap = topo_list_next(ap)) {
12440b32bb8bSEric Schrock 		np = ap->san_node;
12450b32bb8bSEric Schrock 		props = ses_node_props(np);
12460b32bb8bSEric Schrock 
12470b32bb8bSEric Schrock 		if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS,
12480b32bb8bSEric Schrock 		    &phys, &n_phys) != 0)
12490b32bb8bSEric Schrock 			continue;
12500b32bb8bSEric Schrock 
12510b32bb8bSEric Schrock 		all_phys += n_phys;
12520b32bb8bSEric Schrock 	}
12530b32bb8bSEric Schrock 
12540b32bb8bSEric Schrock 	if (all_phys == 0)
12550b32bb8bSEric Schrock 		return (0);
12560b32bb8bSEric Schrock 
12570b32bb8bSEric Schrock 	if ((paths = topo_mod_zalloc(mod, all_phys * sizeof (char *))) == NULL)
12580b32bb8bSEric Schrock 		return (-1);
12590b32bb8bSEric Schrock 
12600b32bb8bSEric Schrock 	for (i = 0, ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL;
12610b32bb8bSEric Schrock 	    ap = topo_list_next(ap)) {
12620b32bb8bSEric Schrock 		np = ap->san_node;
12630b32bb8bSEric Schrock 		props = ses_node_props(np);
12640b32bb8bSEric Schrock 
12650b32bb8bSEric Schrock 		if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS,
12660b32bb8bSEric Schrock 		    &phys, &n_phys) != 0)
1267940d71d2Seschrock 			continue;
1268940d71d2Seschrock 
12690b32bb8bSEric Schrock 		for (j = 0; j < n_phys; j++) {
12700b32bb8bSEric Schrock 			if (nvlist_lookup_uint64(phys[j], SES_SAS_PROP_ADDR,
12710b32bb8bSEric Schrock 			    &addr) != 0)
12720b32bb8bSEric Schrock 				continue;
1273940d71d2Seschrock 
12740b32bb8bSEric Schrock 			len = snprintf(NULL, 0, "%016llx", addr) + 1;
12750b32bb8bSEric Schrock 			if ((paths[i] = topo_mod_alloc(mod, len)) == NULL)
12760b32bb8bSEric Schrock 				goto error;
12770b32bb8bSEric Schrock 
12780b32bb8bSEric Schrock 			(void) snprintf(paths[i], len, "%016llx", addr);
12790b32bb8bSEric Schrock 
12800b32bb8bSEric Schrock 			++i;
12810b32bb8bSEric Schrock 		}
1282940d71d2Seschrock 	}
1283940d71d2Seschrock 
12840b32bb8bSEric Schrock 	err = topo_prop_set_string_array(tn, TOPO_PGROUP_SES,
12850b32bb8bSEric Schrock 	    TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE,
12860b32bb8bSEric Schrock 	    (const char **)paths, i, &terr);
12870b32bb8bSEric Schrock 	if (err != 0)
12880b32bb8bSEric Schrock 		err = topo_mod_seterrno(mod, terr);
12890b32bb8bSEric Schrock 
12900b32bb8bSEric Schrock error:
12910b32bb8bSEric Schrock 	for (i = 0; i < all_phys && paths[i] != NULL; i++)
12920b32bb8bSEric Schrock 		topo_mod_free(mod, paths[i], strlen(paths[i]) + 1);
12930b32bb8bSEric Schrock 	topo_mod_free(mod, paths, all_phys * sizeof (char *));
12940b32bb8bSEric Schrock 
12950b32bb8bSEric Schrock 	return (err);
1296940d71d2Seschrock }
1297940d71d2Seschrock 
1298940d71d2Seschrock /*
1299ac88567aSHyon Kim  * Callback to create a basic node (bay, psu, fan, or controller and expander).
1300940d71d2Seschrock  */
1301940d71d2Seschrock static int
1302ded93414SHyon Kim ses_create_generic(ses_enum_data_t *sdp, ses_enum_node_t *snp, tnode_t *pnode,
1303ded93414SHyon Kim     tnode_t *frutn, const char *nodename, const char *labelname,
1304ded93414SHyon Kim     tnode_t **node)
1305940d71d2Seschrock {
1306940d71d2Seschrock 	ses_node_t *np = snp->sen_node;
1307d91236feSeschrock 	ses_node_t *parent;
1308940d71d2Seschrock 	uint64_t instance = snp->sen_instance;
1309940d71d2Seschrock 	topo_mod_t *mod = sdp->sed_mod;
1310940d71d2Seschrock 	nvlist_t *props, *aprops;
1311940d71d2Seschrock 	nvlist_t *auth = NULL, *fmri = NULL;
1312ded93414SHyon Kim 	tnode_t *tn = NULL;
1313940d71d2Seschrock 	char label[128];
1314940d71d2Seschrock 	int err;
1315d91236feSeschrock 	char *part = NULL, *serial = NULL, *revision = NULL;
1316d91236feSeschrock 	char *desc;
1317d91236feSeschrock 	boolean_t report;
1318940d71d2Seschrock 
1319940d71d2Seschrock 	props = ses_node_props(np);
1320940d71d2Seschrock 
1321940d71d2Seschrock 	(void) nvlist_lookup_string(props, LIBSES_PROP_PART, &part);
1322940d71d2Seschrock 	(void) nvlist_lookup_string(props, LIBSES_PROP_SERIAL, &serial);
1323940d71d2Seschrock 
1324940d71d2Seschrock 	topo_mod_dprintf(mod, "adding %s %llu", nodename, instance);
1325940d71d2Seschrock 
1326940d71d2Seschrock 	/*
1327940d71d2Seschrock 	 * Create the node.  The interesting information is all copied from the
1328940d71d2Seschrock 	 * parent enclosure node, so there is not much to do.
1329940d71d2Seschrock 	 */
1330940d71d2Seschrock 	if ((auth = topo_mod_auth(mod, pnode)) == NULL)
1331940d71d2Seschrock 		goto error;
1332940d71d2Seschrock 
1333d91236feSeschrock 	/*
1334d91236feSeschrock 	 * We want to report revision information for the controller nodes, but
1335d91236feSeschrock 	 * we do not get per-element revision information.  However, we do have
1336d91236feSeschrock 	 * revision information for the entire enclosure, and we can use the
1337d91236feSeschrock 	 * 'reported-via' property to know that this controller corresponds to
1338d91236feSeschrock 	 * the given revision information.  This means we cannot get revision
1339d91236feSeschrock 	 * information for targets we are not explicitly connected to, but
1340d91236feSeschrock 	 * there is little we can do about the situation.
1341d91236feSeschrock 	 */
1342d91236feSeschrock 	if (strcmp(nodename, CONTROLLER) == 0 &&
1343d91236feSeschrock 	    nvlist_lookup_boolean_value(props, SES_PROP_REPORT, &report) == 0 &&
1344d91236feSeschrock 	    report) {
1345d91236feSeschrock 		for (parent = ses_node_parent(np); parent != NULL;
1346d91236feSeschrock 		    parent = ses_node_parent(parent)) {
1347d91236feSeschrock 			if (ses_node_type(parent) == SES_NODE_ENCLOSURE) {
1348d91236feSeschrock 				(void) nvlist_lookup_string(
1349d91236feSeschrock 				    ses_node_props(parent),
1350d91236feSeschrock 				    SES_EN_PROP_REV, &revision);
1351d91236feSeschrock 				break;
1352d91236feSeschrock 			}
1353d91236feSeschrock 		}
1354d91236feSeschrock 	}
1355d91236feSeschrock 
1356940d71d2Seschrock 	if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION,
1357d91236feSeschrock 	    nodename, (topo_instance_t)instance, NULL, auth, part, revision,
1358940d71d2Seschrock 	    serial)) == NULL) {
1359940d71d2Seschrock 		topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
1360940d71d2Seschrock 		    topo_mod_errmsg(mod));
1361940d71d2Seschrock 		goto error;
1362940d71d2Seschrock 	}
1363940d71d2Seschrock 
1364940d71d2Seschrock 	if ((tn = topo_node_bind(mod, pnode, nodename,
1365940d71d2Seschrock 	    instance, fmri)) == NULL) {
1366940d71d2Seschrock 		topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
1367940d71d2Seschrock 		    topo_mod_errmsg(mod));
1368940d71d2Seschrock 		goto error;
1369940d71d2Seschrock 	}
1370940d71d2Seschrock 
1371940d71d2Seschrock 	/*
1372d91236feSeschrock 	 * For the node label, we look for the following in order:
1373d91236feSeschrock 	 *
1374d91236feSeschrock 	 * 	<ses-description>
1375d91236feSeschrock 	 * 	<ses-class-description> <instance>
1376d91236feSeschrock 	 * 	<default-type-label> <instance>
1377940d71d2Seschrock 	 */
1378d91236feSeschrock 	if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 ||
1379d91236feSeschrock 	    desc[0] == '\0') {
1380d91236feSeschrock 		parent = ses_node_parent(np);
1381d91236feSeschrock 		aprops = ses_node_props(parent);
1382d91236feSeschrock 		if (nvlist_lookup_string(aprops, SES_PROP_CLASS_DESCRIPTION,
1383ac88567aSHyon Kim 		    &desc) != 0 || desc[0] == '\0')
1384ac88567aSHyon Kim 			desc = (char *)labelname;
1385d91236feSeschrock 		(void) snprintf(label, sizeof (label), "%s %llu", desc,
1386d91236feSeschrock 		    instance);
1387d91236feSeschrock 		desc = label;
1388d91236feSeschrock 	}
1389d91236feSeschrock 
1390d91236feSeschrock 	if (topo_node_label_set(tn, desc, &err) != 0)
1391940d71d2Seschrock 		goto error;
1392940d71d2Seschrock 
1393ac88567aSHyon Kim 	if (ses_set_standard_props(mod, frutn, tn, NULL, ses_node_id(np),
1394940d71d2Seschrock 	    snp->sen_target->set_devpath) != 0)
1395940d71d2Seschrock 		goto error;
1396940d71d2Seschrock 
1397ac88567aSHyon Kim 	if (strcmp(nodename, BAY) == 0) {
13980b32bb8bSEric Schrock 		if (ses_add_bay_props(mod, tn, snp) != 0)
13990b32bb8bSEric Schrock 			goto error;
14000b32bb8bSEric Schrock 
1401940d71d2Seschrock 		if (ses_create_disk(sdp, tn, props) != 0)
1402940d71d2Seschrock 			goto error;
1403d91236feSeschrock 
1404d91236feSeschrock 		if (topo_method_register(mod, tn, ses_bay_methods) != 0) {
1405d91236feSeschrock 			topo_mod_dprintf(mod,
1406d91236feSeschrock 			    "topo_method_register() failed: %s",
1407d91236feSeschrock 			    topo_mod_errmsg(mod));
1408d91236feSeschrock 			goto error;
1409d91236feSeschrock 		}
1410ac88567aSHyon Kim 	} else if ((strcmp(nodename, FAN) == 0) ||
1411ac88567aSHyon Kim 	    (strcmp(nodename, PSU) == 0) ||
1412ac88567aSHyon Kim 	    (strcmp(nodename, CONTROLLER) == 0)) {
1413940d71d2Seschrock 		/*
1414d91236feSeschrock 		 * Only fan, psu, and controller nodes have a 'present' method.
1415d91236feSeschrock 		 * Bay nodes are always present, and disk nodes are present by
1416ac88567aSHyon Kim 		 * virtue of being enumerated and SAS expander nodes and
1417ac88567aSHyon Kim 		 * SAS connector nodes are also always present once
1418ac88567aSHyon Kim 		 * the parent controller is found.
1419940d71d2Seschrock 		 */
1420940d71d2Seschrock 		if (topo_method_register(mod, tn, ses_component_methods) != 0) {
1421940d71d2Seschrock 			topo_mod_dprintf(mod,
1422940d71d2Seschrock 			    "topo_method_register() failed: %s",
1423940d71d2Seschrock 			    topo_mod_errmsg(mod));
1424940d71d2Seschrock 			goto error;
1425940d71d2Seschrock 		}
1426940d71d2Seschrock 
1427940d71d2Seschrock 	}
1428940d71d2Seschrock 
1429d91236feSeschrock 	snp->sen_target->set_refcount++;
1430d91236feSeschrock 	topo_node_setspecific(tn, snp->sen_target);
1431d91236feSeschrock 
1432940d71d2Seschrock 	nvlist_free(auth);
1433940d71d2Seschrock 	nvlist_free(fmri);
1434ac88567aSHyon Kim 	if (node != NULL) *node = tn;
1435ac88567aSHyon Kim 	return (0);
1436ac88567aSHyon Kim 
1437ac88567aSHyon Kim error:
1438ac88567aSHyon Kim 	nvlist_free(auth);
1439ac88567aSHyon Kim 	nvlist_free(fmri);
1440ac88567aSHyon Kim 	return (-1);
1441ac88567aSHyon Kim }
1442ac88567aSHyon Kim 
1443ac88567aSHyon Kim /*
1444ac88567aSHyon Kim  * Create SAS expander specific props.
1445ac88567aSHyon Kim  */
1446ac88567aSHyon Kim /*ARGSUSED*/
1447ac88567aSHyon Kim static int
1448ac88567aSHyon Kim ses_set_expander_props(ses_enum_data_t *sdp, ses_enum_node_t *snp,
1449ac88567aSHyon Kim     tnode_t *ptnode, tnode_t *tnode, int *phycount, int64_t *connlist)
1450ac88567aSHyon Kim {
1451ac88567aSHyon Kim 	ses_node_t *np = snp->sen_node;
1452ac88567aSHyon Kim 	topo_mod_t *mod = sdp->sed_mod;
1453ac88567aSHyon Kim 	nvlist_t *auth = NULL, *fmri = NULL;
1454ac88567aSHyon Kim 	nvlist_t *props, **phylist;
1455ac88567aSHyon Kim 	int err, i;
1456ac88567aSHyon Kim 	uint_t pcount;
1457ac88567aSHyon Kim 	uint64_t sasaddr, connidx;
1458ac88567aSHyon Kim 	char sasaddr_str[17];
1459b4879163SHyon Kim 	boolean_t found = B_FALSE, ses_found = B_FALSE;
1460b4879163SHyon Kim 	dev_di_node_t *dnode, *sesdnode;
1461ac88567aSHyon Kim 
1462ac88567aSHyon Kim 	props = ses_node_props(np);
1463ac88567aSHyon Kim 
1464ac88567aSHyon Kim 	/*
1465ac88567aSHyon Kim 	 * the uninstalled expander is not enumerated by checking
1466ac88567aSHyon Kim 	 * the element status code.  No present present' method provided.
1467ac88567aSHyon Kim 	 */
1468ac88567aSHyon Kim 	/*
1469ac88567aSHyon Kim 	 * Get the Expander SAS address.  It should exist.
1470ac88567aSHyon Kim 	 */
1471ac88567aSHyon Kim 	if (nvlist_lookup_uint64(props, SES_EXP_PROP_SAS_ADDR,
1472ac88567aSHyon Kim 	    &sasaddr) != 0) {
1473ac88567aSHyon Kim 		topo_mod_dprintf(mod,
1474ac88567aSHyon Kim 		    "Failed to get prop %s.", SES_EXP_PROP_SAS_ADDR);
1475ac88567aSHyon Kim 		goto error;
1476ac88567aSHyon Kim 	}
1477ac88567aSHyon Kim 
1478ac88567aSHyon Kim 	(void) sprintf(sasaddr_str, "%llx", sasaddr);
1479ac88567aSHyon Kim 
1480ac88567aSHyon Kim 	/* search matching dev_di_node. */
1481ac88567aSHyon Kim 	for (dnode = topo_list_next(&sdp->sed_devs); dnode != NULL;
1482ac88567aSHyon Kim 	    dnode = topo_list_next(dnode)) {
1483b4879163SHyon Kim 		for (i = 0; i < dnode->ddn_ppath_count; i++) {
1484b4879163SHyon Kim 			if ((dnode->ddn_target_port[i] != NULL) &&
1485b4879163SHyon Kim 			    (strstr(dnode->ddn_target_port[i],
1486b4879163SHyon Kim 			    sasaddr_str) != NULL)) {
1487b4879163SHyon Kim 				found = B_TRUE;
1488b4879163SHyon Kim 				break;
1489b4879163SHyon Kim 			}
1490ac88567aSHyon Kim 		}
1491b4879163SHyon Kim 		if (found)
1492b4879163SHyon Kim 			break;
1493ac88567aSHyon Kim 	}
1494ac88567aSHyon Kim 
1495ac88567aSHyon Kim 	if (!found) {
1496ac88567aSHyon Kim 		topo_mod_dprintf(mod,
1497ac88567aSHyon Kim 		    "ses_set_expander_props: Failed to find matching "
1498ac88567aSHyon Kim 		    "devinfo node for Exapnder SAS address %s",
1499ac88567aSHyon Kim 		    SES_EXP_PROP_SAS_ADDR);
1500ac88567aSHyon Kim 		/* continue on to get storage group props. */
1501ac88567aSHyon Kim 	} else {
1502b4879163SHyon Kim 		/* create/set the devfs-path and devid in the smp group */
1503b4879163SHyon Kim 		if (topo_pgroup_create(tnode, &smp_pgroup, &err) != 0) {
1504ac88567aSHyon Kim 			topo_mod_dprintf(mod, "ses_set_expander_props: "
1505b4879163SHyon Kim 			    "failed to create smp property group %s\n",
1506b4879163SHyon Kim 			    topo_strerror(err));
1507ac88567aSHyon Kim 			goto error;
1508ac88567aSHyon Kim 		} else {
1509b4879163SHyon Kim 			if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP,
1510b4879163SHyon Kim 			    TOPO_PROP_SMP_TARGET_PORT, TOPO_PROP_IMMUTABLE,
1511b4879163SHyon Kim 			    dnode->ddn_target_port[i], &err) != 0) {
1512b4879163SHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1513b4879163SHyon Kim 				    "set %S error %s\n", TOPO_PROP_SAS_ADDR,
1514b4879163SHyon Kim 				    topo_strerror(err));
1515b4879163SHyon Kim 			}
1516b4879163SHyon Kim 			if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP,
1517b4879163SHyon Kim 			    TOPO_PROP_SMP_DEV_PATH, TOPO_PROP_IMMUTABLE,
1518ac88567aSHyon Kim 			    dnode->ddn_dpath, &err) != 0) {
1519ac88567aSHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1520ac88567aSHyon Kim 				    "set dev error %s\n", topo_strerror(err));
1521ac88567aSHyon Kim 			}
1522b4879163SHyon Kim 			if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP,
1523b4879163SHyon Kim 			    TOPO_PROP_SMP_DEVID, TOPO_PROP_IMMUTABLE,
1524ac88567aSHyon Kim 			    dnode->ddn_devid, &err) != 0) {
1525ac88567aSHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1526ac88567aSHyon Kim 				    "set devid error %s\n", topo_strerror(err));
1527ac88567aSHyon Kim 			}
1528ac88567aSHyon Kim 			if (dnode->ddn_ppath_count != 0 &&
1529b4879163SHyon Kim 			    topo_prop_set_string_array(tnode, TOPO_PGROUP_SMP,
1530b4879163SHyon Kim 			    TOPO_PROP_SMP_PHYS_PATH, TOPO_PROP_IMMUTABLE,
1531ac88567aSHyon Kim 			    (const char **)dnode->ddn_ppath,
1532ac88567aSHyon Kim 			    dnode->ddn_ppath_count, &err) != 0) {
1533ac88567aSHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1534ac88567aSHyon Kim 				    "set phys-path error %s\n",
1535ac88567aSHyon Kim 				    topo_strerror(err));
1536ac88567aSHyon Kim 			}
1537ac88567aSHyon Kim 		}
1538ac88567aSHyon Kim 	}
1539ac88567aSHyon Kim 
1540b4879163SHyon Kim 	/* update the ses property group with SES target info */
1541ded93414SHyon Kim 	if ((topo_pgroup_create(tnode, &ses_pgroup, &err) != 0) &&
1542a961ec00SHyon Kim 	    (err != ETOPO_PROP_DEFD)) {
1543a961ec00SHyon Kim 		/* SES prop group doesn't exist but failed to be created. */
1544b4879163SHyon Kim 		topo_mod_dprintf(mod, "ses_set_expander_props: "
1545a961ec00SHyon Kim 		    "ses pgroup create error %s\n", topo_strerror(err));
1546b4879163SHyon Kim 		goto error;
1547b4879163SHyon Kim 	} else {
1548b4879163SHyon Kim 		/* locate assciated enclosure dev_di_node. */
1549b4879163SHyon Kim 		for (sesdnode = topo_list_next(&sdp->sed_devs);
1550b4879163SHyon Kim 		    sesdnode != NULL; sesdnode = topo_list_next(sesdnode)) {
1551b4879163SHyon Kim 			for (i = 0; i < sesdnode->ddn_ppath_count; i++) {
1552b4879163SHyon Kim 				/*
1553b4879163SHyon Kim 				 * check if attached port exists and
1554b4879163SHyon Kim 				 * its node type is enclosure and
1555b4879163SHyon Kim 				 * attached port is same as sas address of
1556b4879163SHyon Kim 				 * the expander and
1557b4879163SHyon Kim 				 * bridge port for virtual phy indication
1558b4879163SHyon Kim 				 * exist.
1559b4879163SHyon Kim 				 */
1560b4879163SHyon Kim 				if ((sesdnode->ddn_attached_port[i] != NULL) &&
1561b4879163SHyon Kim 				    (sesdnode->ddn_dtype == DTYPE_ESI) &&
1562b4879163SHyon Kim 				    (strstr(sesdnode->ddn_attached_port[i],
1563b4879163SHyon Kim 				    sasaddr_str) != NULL) &&
1564b4879163SHyon Kim 				    (sesdnode->ddn_bridge_port[i] != NULL)) {
1565b4879163SHyon Kim 					ses_found = B_TRUE;
1566b4879163SHyon Kim 					break;
1567b4879163SHyon Kim 				}
1568b4879163SHyon Kim 			}
1569b4879163SHyon Kim 			if (ses_found) break;
1570b4879163SHyon Kim 		}
1571b4879163SHyon Kim 
1572b4879163SHyon Kim 		if (ses_found) {
1573b4879163SHyon Kim 			if (topo_prop_set_string(tnode, TOPO_PGROUP_SES,
1574b4879163SHyon Kim 			    TOPO_PROP_SES_TARGET_PORT, TOPO_PROP_IMMUTABLE,
1575b4879163SHyon Kim 			    sesdnode->ddn_target_port[i], &err) != 0) {
1576b4879163SHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1577b4879163SHyon Kim 				    "set ses %S error %s\n", TOPO_PROP_SAS_ADDR,
1578b4879163SHyon Kim 				    topo_strerror(err));
1579b4879163SHyon Kim 			}
1580b4879163SHyon Kim 			if (topo_prop_set_string(tnode, TOPO_PGROUP_SES,
1581b4879163SHyon Kim 			    TOPO_PROP_SES_DEV_PATH, TOPO_PROP_IMMUTABLE,
1582b4879163SHyon Kim 			    sesdnode->ddn_dpath, &err) != 0) {
1583b4879163SHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1584b4879163SHyon Kim 				    "set ses dev error %s\n",
1585b4879163SHyon Kim 				    topo_strerror(err));
1586b4879163SHyon Kim 			}
1587b4879163SHyon Kim 			if (topo_prop_set_string(tnode, TOPO_PGROUP_SES,
1588b4879163SHyon Kim 			    TOPO_PROP_SES_DEVID, TOPO_PROP_IMMUTABLE,
1589b4879163SHyon Kim 			    sesdnode->ddn_devid, &err) != 0) {
1590b4879163SHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1591b4879163SHyon Kim 				    "set ses devid error %s\n",
1592b4879163SHyon Kim 				    topo_strerror(err));
1593b4879163SHyon Kim 			}
1594b4879163SHyon Kim 			if (sesdnode->ddn_ppath_count != 0 &&
1595b4879163SHyon Kim 			    topo_prop_set_string_array(tnode, TOPO_PGROUP_SES,
1596b4879163SHyon Kim 			    TOPO_PROP_SES_PHYS_PATH, TOPO_PROP_IMMUTABLE,
1597b4879163SHyon Kim 			    (const char **)sesdnode->ddn_ppath,
1598b4879163SHyon Kim 			    sesdnode->ddn_ppath_count, &err) != 0) {
1599b4879163SHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1600b4879163SHyon Kim 				    "set ses phys-path error %s\n",
1601b4879163SHyon Kim 				    topo_strerror(err));
1602b4879163SHyon Kim 			}
1603b4879163SHyon Kim 
1604b4879163SHyon Kim 		}
1605b4879163SHyon Kim 	}
1606b4879163SHyon Kim 
1607ac88567aSHyon Kim 	/* create the storage group */
1608ac88567aSHyon Kim 	if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) {
1609ac88567aSHyon Kim 		topo_mod_dprintf(mod, "ses_set_expander_props: "
1610ac88567aSHyon Kim 		    "create storage error %s\n", topo_strerror(err));
1611ac88567aSHyon Kim 		goto error;
1612ac88567aSHyon Kim 	} else {
1613b4879163SHyon Kim 		/* set the SAS address prop out of expander element status. */
1614ac88567aSHyon Kim 		if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE,
1615ac88567aSHyon Kim 		    TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE, sasaddr_str,
1616ac88567aSHyon Kim 		    &err) != 0) {
1617ac88567aSHyon Kim 			topo_mod_dprintf(mod, "ses_set_expander_props: "
1618ac88567aSHyon Kim 			    "set %S error %s\n", TOPO_PROP_SAS_ADDR,
1619ac88567aSHyon Kim 			    topo_strerror(err));
1620ac88567aSHyon Kim 		}
1621ac88567aSHyon Kim 
1622ac88567aSHyon Kim 		/* Get the phy information for the expander */
1623ac88567aSHyon Kim 		if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS,
1624ac88567aSHyon Kim 		    &phylist, &pcount) != 0) {
1625ac88567aSHyon Kim 			topo_mod_dprintf(mod,
1626ac88567aSHyon Kim 			    "Failed to get prop %s.", SES_SAS_PROP_PHYS);
1627ac88567aSHyon Kim 		} else {
1628ac88567aSHyon Kim 			/*
1629ac88567aSHyon Kim 			 * For each phy, get the connector element index and
1630ac88567aSHyon Kim 			 * stores into connector element index array.
1631ac88567aSHyon Kim 			 */
1632ac88567aSHyon Kim 			*phycount = pcount;
1633ac88567aSHyon Kim 			for (i = 0; i < pcount; i++) {
1634ac88567aSHyon Kim 				if (nvlist_lookup_uint64(phylist[i],
1635ac88567aSHyon Kim 				    SES_PROP_CE_IDX, &connidx) == 0) {
1636ac88567aSHyon Kim 					if (connidx != 0xff) {
1637ac88567aSHyon Kim 						connlist[i] = connidx;
1638ac88567aSHyon Kim 					} else {
1639ac88567aSHyon Kim 						connlist[i] = -1;
1640ac88567aSHyon Kim 					}
1641ac88567aSHyon Kim 				} else {
1642ac88567aSHyon Kim 					/* Fail to get the index. set to -1. */
1643ac88567aSHyon Kim 					connlist[i] = -1;
1644ac88567aSHyon Kim 				}
1645ac88567aSHyon Kim 			}
1646ac88567aSHyon Kim 
1647ac88567aSHyon Kim 			/* set the phy count prop of the expander. */
1648ac88567aSHyon Kim 			if (topo_prop_set_uint64(tnode, TOPO_PGROUP_STORAGE,
1649ac88567aSHyon Kim 			    TOPO_PROP_PHY_COUNT, TOPO_PROP_IMMUTABLE, pcount,
1650ac88567aSHyon Kim 			    &err) != 0) {
1651ac88567aSHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1652ac88567aSHyon Kim 				    "set %S error %s\n", TOPO_PROP_PHY_COUNT,
1653ac88567aSHyon Kim 				    topo_strerror(err));
1654ac88567aSHyon Kim 			}
1655ac88567aSHyon Kim 
1656ac88567aSHyon Kim 			/*
1657ac88567aSHyon Kim 			 * set the connector element index of
1658ac88567aSHyon Kim 			 * the expander phys.
1659ac88567aSHyon Kim 			 */
1660ac88567aSHyon Kim 		}
1661ac88567aSHyon Kim 
1662ac88567aSHyon Kim 		/* populate other misc storage group properties */
1663ac88567aSHyon Kim 		if (found) {
1664ac88567aSHyon Kim 			if (dnode->ddn_mfg && (topo_prop_set_string(tnode,
1665ac88567aSHyon Kim 			    TOPO_PGROUP_STORAGE, TOPO_STORAGE_MANUFACTURER,
1666ac88567aSHyon Kim 			    TOPO_PROP_IMMUTABLE, dnode->ddn_mfg, &err) != 0)) {
1667ac88567aSHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1668ac88567aSHyon Kim 				    "set mfg error %s\n", topo_strerror(err));
1669ac88567aSHyon Kim 			}
1670ac88567aSHyon Kim 
1671ac88567aSHyon Kim 			if (dnode->ddn_model && (topo_prop_set_string(tnode,
1672ac88567aSHyon Kim 			    TOPO_PGROUP_STORAGE, TOPO_STORAGE_MODEL,
1673ac88567aSHyon Kim 			    TOPO_PROP_IMMUTABLE,
1674ac88567aSHyon Kim 			    dnode->ddn_model, &err) != 0)) {
1675ac88567aSHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1676ac88567aSHyon Kim 				    "set model error %s\n", topo_strerror(err));
1677ac88567aSHyon Kim 			}
1678ac88567aSHyon Kim 
1679ac88567aSHyon Kim 			if (dnode->ddn_serial && (topo_prop_set_string(tnode,
1680ac88567aSHyon Kim 			    TOPO_PGROUP_STORAGE, TOPO_STORAGE_SERIAL_NUM,
1681ac88567aSHyon Kim 			    TOPO_PROP_IMMUTABLE,
1682ac88567aSHyon Kim 			    dnode->ddn_serial, &err) != 0)) {
1683ac88567aSHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1684ac88567aSHyon Kim 				    "set serial error %s\n",
1685ac88567aSHyon Kim 				    topo_strerror(err));
1686ac88567aSHyon Kim 			}
1687ac88567aSHyon Kim 
1688ac88567aSHyon Kim 			if (dnode->ddn_firm && (topo_prop_set_string(tnode,
1689ac88567aSHyon Kim 			    TOPO_PGROUP_STORAGE,
1690ac88567aSHyon Kim 			    TOPO_STORAGE_FIRMWARE_REV, TOPO_PROP_IMMUTABLE,
1691ac88567aSHyon Kim 			    dnode->ddn_firm, &err) != 0)) {
1692ac88567aSHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1693ac88567aSHyon Kim 				    "set firm error %s\n", topo_strerror(err));
1694ac88567aSHyon Kim 			}
1695ac88567aSHyon Kim 		}
1696ac88567aSHyon Kim 	}
1697ac88567aSHyon Kim 
1698940d71d2Seschrock 	return (0);
1699940d71d2Seschrock 
1700940d71d2Seschrock error:
1701940d71d2Seschrock 	nvlist_free(auth);
1702940d71d2Seschrock 	nvlist_free(fmri);
1703940d71d2Seschrock 	return (-1);
1704940d71d2Seschrock }
1705940d71d2Seschrock 
1706ac88567aSHyon Kim /*
1707ac88567aSHyon Kim  * Create SAS expander specific props.
1708ac88567aSHyon Kim  */
1709ac88567aSHyon Kim /*ARGSUSED*/
1710ac88567aSHyon Kim static int
1711ac88567aSHyon Kim ses_set_connector_props(ses_enum_data_t *sdp, ses_enum_node_t *snp,
1712ac88567aSHyon Kim     tnode_t *tnode, int64_t phy_mask)
1713ac88567aSHyon Kim {
1714ac88567aSHyon Kim 	ses_node_t *np = snp->sen_node;
1715ac88567aSHyon Kim 	topo_mod_t *mod = sdp->sed_mod;
1716ac88567aSHyon Kim 	nvlist_t *props;
1717ac88567aSHyon Kim 	int err, i;
1718ac88567aSHyon Kim 	uint64_t conntype;
1719ac88567aSHyon Kim 	char phymask_str[17], *conntype_str;
1720ac88567aSHyon Kim 	boolean_t   found;
1721ac88567aSHyon Kim 
1722ac88567aSHyon Kim 	props = ses_node_props(np);
1723ac88567aSHyon Kim 
1724ac88567aSHyon Kim 	/*
1725ac88567aSHyon Kim 	 * convert phy mask to string.
1726ac88567aSHyon Kim 	 */
1727ac88567aSHyon Kim 	(void) snprintf(phymask_str, 17, "%llx", phy_mask);
1728ac88567aSHyon Kim 
1729ac88567aSHyon Kim 	/* create the storage group */
1730ac88567aSHyon Kim 	if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) {
1731ac88567aSHyon Kim 		topo_mod_dprintf(mod, "ses_set_expander_props: "
1732ac88567aSHyon Kim 		    "create storage error %s\n", topo_strerror(err));
1733ac88567aSHyon Kim 		return (-1);
1734ac88567aSHyon Kim 	} else {
1735ac88567aSHyon Kim 		/* set the SAS address prop of the expander. */
1736ac88567aSHyon Kim 		if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE,
1737ac88567aSHyon Kim 		    TOPO_STORAGE_SAS_PHY_MASK, TOPO_PROP_IMMUTABLE,
1738ac88567aSHyon Kim 		    phymask_str, &err) != 0) {
1739ac88567aSHyon Kim 			topo_mod_dprintf(mod, "ses_set_expander_props: "
1740ac88567aSHyon Kim 			    "set %S error %s\n", TOPO_STORAGE_SAS_PHY_MASK,
1741ac88567aSHyon Kim 			    topo_strerror(err));
1742ac88567aSHyon Kim 		}
1743ac88567aSHyon Kim 
1744ac88567aSHyon Kim 		/* Get the connector type information for the expander */
1745ac88567aSHyon Kim 		if (nvlist_lookup_uint64(props,
1746ac88567aSHyon Kim 		    SES_SC_PROP_CONNECTOR_TYPE, &conntype) != 0) {
1747ac88567aSHyon Kim 			topo_mod_dprintf(mod, "Failed to get prop %s.",
1748ac88567aSHyon Kim 			    TOPO_STORAGE_SAS_PHY_MASK);
1749ac88567aSHyon Kim 		} else {
1750ac88567aSHyon Kim 			found = B_FALSE;
1751ac88567aSHyon Kim 			for (i = 0; ; i++) {
1752ded93414SHyon Kim 				if (sas_connector_type_list[i].sct_type ==
1753ac88567aSHyon Kim 				    SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) {
1754ac88567aSHyon Kim 					break;
1755ac88567aSHyon Kim 				}
1756ded93414SHyon Kim 				if (sas_connector_type_list[i].sct_type ==
1757ac88567aSHyon Kim 				    conntype) {
1758ac88567aSHyon Kim 					conntype_str =
1759ded93414SHyon Kim 					    sas_connector_type_list[i].sct_name;
1760ac88567aSHyon Kim 					found = B_TRUE;
1761ac88567aSHyon Kim 					break;
1762ac88567aSHyon Kim 				}
1763ac88567aSHyon Kim 			}
1764ac88567aSHyon Kim 
1765ac88567aSHyon Kim 			if (!found) {
1766ac88567aSHyon Kim 				if (conntype <
1767ac88567aSHyon Kim 				    SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) {
1768ac88567aSHyon Kim 					conntype_str =
1769ac88567aSHyon Kim 					    SAS_CONNECTOR_TYPE_RESERVED;
1770ac88567aSHyon Kim 				} else {
1771ac88567aSHyon Kim 					conntype_str =
1772ac88567aSHyon Kim 					    SAS_CONNECTOR_TYPE_NOT_DEFINED;
1773ac88567aSHyon Kim 				}
1774ac88567aSHyon Kim 			}
1775ac88567aSHyon Kim 
1776ac88567aSHyon Kim 			/* set the phy count prop of the expander. */
1777ac88567aSHyon Kim 			if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE,
1778ac88567aSHyon Kim 			    TOPO_STORAGE_SAS_CONNECTOR_TYPE,
1779ac88567aSHyon Kim 			    TOPO_PROP_IMMUTABLE, conntype_str, &err) != 0) {
1780ac88567aSHyon Kim 				topo_mod_dprintf(mod, "ses_set_expander_props: "
1781ac88567aSHyon Kim 				    "set %S error %s\n", TOPO_PROP_PHY_COUNT,
1782ac88567aSHyon Kim 				    topo_strerror(err));
1783ac88567aSHyon Kim 			}
1784ac88567aSHyon Kim 		}
1785ac88567aSHyon Kim 	}
1786ac88567aSHyon Kim 
1787ac88567aSHyon Kim 	return (0);
1788ac88567aSHyon Kim }
1789ac88567aSHyon Kim 
1790ac88567aSHyon Kim /*
1791ac88567aSHyon Kim  * Instantiate SAS expander nodes for a given ESC Electronics node(controller)
1792ac88567aSHyon Kim  * nodes.
1793ac88567aSHyon Kim  */
1794ac88567aSHyon Kim /*ARGSUSED*/
1795ac88567aSHyon Kim static int
1796ac88567aSHyon Kim ses_create_esc_sasspecific(ses_enum_data_t *sdp, ses_enum_node_t *snp,
1797ac88567aSHyon Kim     tnode_t *pnode, ses_enum_chassis_t *cp,
1798ac88567aSHyon Kim     boolean_t dorange)
1799ac88567aSHyon Kim {
1800ac88567aSHyon Kim 	topo_mod_t *mod = sdp->sed_mod;
1801ac88567aSHyon Kim 	tnode_t	*exptn, *contn;
1802ac88567aSHyon Kim 	boolean_t found;
1803ac88567aSHyon Kim 	sas_connector_phy_data_t connectors[64] = {NULL};
1804ac88567aSHyon Kim 	uint64_t max;
1805ac88567aSHyon Kim 	ses_enum_node_t *ctlsnp, *xsnp, *consnp;
1806ac88567aSHyon Kim 	ses_node_t *np = snp->sen_node;
1807ac88567aSHyon Kim 	nvlist_t *props, *psprops;
1808ac88567aSHyon Kim 	uint64_t index, psindex, conindex, psstatus, i, j, count;
1809ac88567aSHyon Kim 	int64_t cidxlist[256] = {NULL};
1810ac88567aSHyon Kim 	int phycount;
1811ac88567aSHyon Kim 
1812ac88567aSHyon Kim 	props = ses_node_props(np);
1813ac88567aSHyon Kim 
1814ac88567aSHyon Kim 	if (nvlist_lookup_uint64(props, SES_PROP_ELEMENT_ONLY_INDEX,
1815ac88567aSHyon Kim 	    &index) != 0)
1816ac88567aSHyon Kim 		return (-1);
1817ac88567aSHyon Kim 
1818ac88567aSHyon Kim 	/*
1819ac88567aSHyon Kim 	 * For SES constroller node, check to see if there are
1820ac88567aSHyon Kim 	 * associated SAS expanders.
1821ac88567aSHyon Kim 	 */
1822ac88567aSHyon Kim 	found = B_FALSE;
1823ac88567aSHyon Kim 	max = 0;
1824ac88567aSHyon Kim 	for (ctlsnp = topo_list_next(&cp->sec_nodes); ctlsnp != NULL;
1825ac88567aSHyon Kim 	    ctlsnp = topo_list_next(ctlsnp)) {
1826ac88567aSHyon Kim 		if (ctlsnp->sen_type == SES_ET_SAS_EXPANDER) {
1827ac88567aSHyon Kim 			found = B_TRUE;
1828ac88567aSHyon Kim 			if (ctlsnp->sen_instance > max)
1829ac88567aSHyon Kim 				max = ctlsnp->sen_instance;
1830ac88567aSHyon Kim 		}
1831ac88567aSHyon Kim 	}
1832ac88567aSHyon Kim 
1833ac88567aSHyon Kim 	/*
1834ac88567aSHyon Kim 	 * No SAS expander found notthing to process.
1835ac88567aSHyon Kim 	 */
1836ac88567aSHyon Kim 	if (!found)
1837ac88567aSHyon Kim 		return (0);
1838ac88567aSHyon Kim 
1839ac88567aSHyon Kim 	topo_mod_dprintf(mod, "%s Controller %d: creating "
1840ac88567aSHyon Kim 	    "%llu %s nodes", cp->sec_csn, index, max + 1, SASEXPANDER);
1841ac88567aSHyon Kim 
1842ac88567aSHyon Kim 	/*
1843ac88567aSHyon Kim 	 * The max number represent the number of elements
1844ac88567aSHyon Kim 	 * deducted from the highest SES_PROP_ELEMENT_CLASS_INDEX
1845ac88567aSHyon Kim 	 * of SET_ET_SAS_EXPANDER type element.
1846ac88567aSHyon Kim 	 *
1847ac88567aSHyon Kim 	 * There may be multiple ESC Electronics element(controllers)
1848ac88567aSHyon Kim 	 * within JBOD(typicall two for redundancy) and SAS expander
1849ac88567aSHyon Kim 	 * elements are associated with only one of them.  We are
1850ac88567aSHyon Kim 	 * still creating the range based max number here.
1851ac88567aSHyon Kim 	 * That will cover the case that all expanders are associated
1852ac88567aSHyon Kim 	 * with one SES controller.
1853ac88567aSHyon Kim 	 */
1854ac88567aSHyon Kim 	if (dorange && topo_node_range_create(mod, pnode,
1855ac88567aSHyon Kim 	    SASEXPANDER, 0, max) != 0) {
1856ac88567aSHyon Kim 		topo_mod_dprintf(mod,
1857ac88567aSHyon Kim 		    "topo_node_create_range() failed: %s",
1858ac88567aSHyon Kim 		    topo_mod_errmsg(mod));
1859ac88567aSHyon Kim 		return (-1);
1860ac88567aSHyon Kim 	}
1861ac88567aSHyon Kim 
1862ac88567aSHyon Kim 	/*
1863ac88567aSHyon Kim 	 * Search exapnders with the parent index matching with
1864ac88567aSHyon Kim 	 * ESC Electronics element index.
1865ac88567aSHyon Kim 	 * Note the index used here is a global index across
1866ac88567aSHyon Kim 	 * SES elements.
1867ac88567aSHyon Kim 	 */
1868ac88567aSHyon Kim 	for (xsnp = topo_list_next(&cp->sec_nodes); xsnp != NULL;
1869ac88567aSHyon Kim 	    xsnp = topo_list_next(xsnp)) {
1870ac88567aSHyon Kim 		if (xsnp->sen_type == SES_ET_SAS_EXPANDER) {
1871ac88567aSHyon Kim 			/*
1872ac88567aSHyon Kim 			 * get the parent ESC controller.
1873ac88567aSHyon Kim 			 */
1874ac88567aSHyon Kim 			psprops = ses_node_props(xsnp->sen_node);
1875ac88567aSHyon Kim 			if (nvlist_lookup_uint64(psprops,
1876ac88567aSHyon Kim 			    SES_PROP_STATUS_CODE, &psstatus) == 0) {
1877ac88567aSHyon Kim 				if (psstatus == SES_ESC_NOT_INSTALLED) {
1878ac88567aSHyon Kim 					/*
1879ac88567aSHyon Kim 					 * Not installed.
1880ac88567aSHyon Kim 					 * Don't create a ndoe.
1881ac88567aSHyon Kim 					 */
1882ac88567aSHyon Kim 					continue;
1883ac88567aSHyon Kim 				}
1884ac88567aSHyon Kim 			} else {
1885ac88567aSHyon Kim 				/*
1886ac88567aSHyon Kim 				 * The element should have status code.
1887ac88567aSHyon Kim 				 * If not there is no way to find
1888ac88567aSHyon Kim 				 * out if the expander element exist or
1889ac88567aSHyon Kim 				 * not.
1890ac88567aSHyon Kim 				 */
1891ac88567aSHyon Kim 				continue;
1892ac88567aSHyon Kim 			}
1893ac88567aSHyon Kim 
1894ac88567aSHyon Kim 			/* Get the physical parent index to compare. */
1895ac88567aSHyon Kim 			if (nvlist_lookup_uint64(psprops,
1896ac88567aSHyon Kim 			    LIBSES_PROP_PHYS_PARENT, &psindex) == 0) {
1897ac88567aSHyon Kim 				if (index == psindex) {
1898ac88567aSHyon Kim 		/* indentation moved forward */
1899ac88567aSHyon Kim 		/*
1900ac88567aSHyon Kim 		 * Handle basic node information of SAS expander
1901ac88567aSHyon Kim 		 * element - binding to parent node and
1902ac88567aSHyon Kim 		 * allocating FMRI...
1903ac88567aSHyon Kim 		 */
1904ded93414SHyon Kim 		if (ses_create_generic(sdp, xsnp, pnode, pnode, SASEXPANDER,
1905ac88567aSHyon Kim 		    "SAS-EXPANDER", &exptn) != 0)
1906ac88567aSHyon Kim 			continue;
1907ac88567aSHyon Kim 		/*
1908ac88567aSHyon Kim 		 * Now handle SAS expander unique portion of node creation.
1909ac88567aSHyon Kim 		 * The max nubmer of the phy count is 256 since SES-2
1910ac88567aSHyon Kim 		 * defines as 1 byte field.  The cidxlist has the same
1911ac88567aSHyon Kim 		 * number of elements.
1912ac88567aSHyon Kim 		 *
1913ac88567aSHyon Kim 		 * We use size 64 array to store the connectors.
1914ac88567aSHyon Kim 		 * Typically a connectors associated with 4 phys so that
1915ac88567aSHyon Kim 		 * matches with the max number of connecters associated
1916ac88567aSHyon Kim 		 * with an expander.
1917ac88567aSHyon Kim 		 * The phy count goes up to 38 for Sun supported
1918ac88567aSHyon Kim 		 * JBOD.
1919ac88567aSHyon Kim 		 */
1920*edb433b6SMilan Jurik 		(void) memset(cidxlist, 0, sizeof (int64_t) * 64);
1921ac88567aSHyon Kim 		if (ses_set_expander_props(sdp, xsnp, pnode, exptn, &phycount,
1922ac88567aSHyon Kim 		    cidxlist) != 0) {
1923ac88567aSHyon Kim 			/*
1924ac88567aSHyon Kim 			 * error on getting specific prop failed.
1925ac88567aSHyon Kim 			 * continue on.  Note that the node is
1926ac88567aSHyon Kim 			 * left bound.
1927ac88567aSHyon Kim 			 */
1928ac88567aSHyon Kim 			continue;
1929ac88567aSHyon Kim 		}
1930ac88567aSHyon Kim 
1931ac88567aSHyon Kim 		/*
1932ac88567aSHyon Kim 		 * count represetns the number of connectors discovered so far.
1933ac88567aSHyon Kim 		 */
1934ac88567aSHyon Kim 		count = 0;
1935*edb433b6SMilan Jurik 		(void) memset(connectors, 0,
1936*edb433b6SMilan Jurik 		    sizeof (sas_connector_phy_data_t) * 64);
1937ac88567aSHyon Kim 		for (i = 0; i < phycount; i++) {
1938ac88567aSHyon Kim 			if (cidxlist[i] != -1) {
1939ac88567aSHyon Kim 				/* connector index is valid. */
1940ac88567aSHyon Kim 				for (j = 0; j < count; j++) {
1941ded93414SHyon Kim 					if (connectors[j].scpd_index ==
1942ac88567aSHyon Kim 					    cidxlist[i]) {
1943ac88567aSHyon Kim 						/*
1944ac88567aSHyon Kim 						 * Just update phy mask.
1945ac88567aSHyon Kim 						 * The postion for connector
1946ac88567aSHyon Kim 						 * index lists(cidxlist index)
1947ac88567aSHyon Kim 						 * is set.
1948ac88567aSHyon Kim 						 */
1949ded93414SHyon Kim 						connectors[j].scpd_pm =
1950ded93414SHyon Kim 						    connectors[j].scpd_pm |
1951ac88567aSHyon Kim 						    (1ULL << i);
1952ac88567aSHyon Kim 						break;
1953ac88567aSHyon Kim 					}
1954ac88567aSHyon Kim 				}
1955ac88567aSHyon Kim 				/*
1956ac88567aSHyon Kim 				 * If j and count matche a  new connector
1957ac88567aSHyon Kim 				 * index is found.
1958ac88567aSHyon Kim 				 */
1959ac88567aSHyon Kim 				if (j == count) {
1960ac88567aSHyon Kim 					/* add a new index and phy mask. */
1961ded93414SHyon Kim 					connectors[count].scpd_index =
1962ded93414SHyon Kim 					    cidxlist[i];
1963ded93414SHyon Kim 					connectors[count].scpd_pm =
1964ded93414SHyon Kim 					    connectors[count].scpd_pm |
1965ac88567aSHyon Kim 					    (1ULL << i);
1966ac88567aSHyon Kim 					count++;
1967ac88567aSHyon Kim 				}
1968ac88567aSHyon Kim 			}
1969ac88567aSHyon Kim 		}
1970ac88567aSHyon Kim 
1971ac88567aSHyon Kim 		/*
1972ac88567aSHyon Kim 		 * create range for the connector nodes.
1973ac88567aSHyon Kim 		 * The class index of the ses connector element
1974ac88567aSHyon Kim 		 * is set as the instance nubmer for the node.
1975ac88567aSHyon Kim 		 * Even though one expander may not have all connectors
1976ac88567aSHyon Kim 		 * are associated with we are creating the range with
1977ac88567aSHyon Kim 		 * max possible instance number.
1978ac88567aSHyon Kim 		 */
1979ac88567aSHyon Kim 		found = B_FALSE;
1980ac88567aSHyon Kim 		max = 0;
1981ac88567aSHyon Kim 		for (consnp = topo_list_next(&cp->sec_nodes);
1982ac88567aSHyon Kim 		    consnp != NULL; consnp = topo_list_next(consnp)) {
1983ac88567aSHyon Kim 			if (consnp->sen_type == SES_ET_SAS_CONNECTOR) {
1984ac88567aSHyon Kim 				psprops = ses_node_props(consnp->sen_node);
1985ac88567aSHyon Kim 				found = B_TRUE;
1986ac88567aSHyon Kim 				if (consnp->sen_instance > max)
1987ac88567aSHyon Kim 					max = consnp->sen_instance;
1988ac88567aSHyon Kim 			}
1989ac88567aSHyon Kim 		}
1990ac88567aSHyon Kim 
1991ac88567aSHyon Kim 		/*
1992ac88567aSHyon Kim 		 * No SAS connector found nothing to process.
1993ac88567aSHyon Kim 		 */
1994ac88567aSHyon Kim 		if (!found)
1995ac88567aSHyon Kim 			return (0);
1996ac88567aSHyon Kim 
1997ac88567aSHyon Kim 		if (dorange && topo_node_range_create(mod, exptn,
1998ac88567aSHyon Kim 		    RECEPTACLE, 0, max) != 0) {
1999ac88567aSHyon Kim 			topo_mod_dprintf(mod,
2000ac88567aSHyon Kim 			    "topo_node_create_range() failed: %s",
2001ac88567aSHyon Kim 			    topo_mod_errmsg(mod));
2002ac88567aSHyon Kim 			return (-1);
2003ac88567aSHyon Kim 		}
2004ac88567aSHyon Kim 
2005ac88567aSHyon Kim 		/* search matching connector element using the index. */
2006ac88567aSHyon Kim 		for (i = 0; i < count; i++) {
2007ac88567aSHyon Kim 			found = B_FALSE;
2008ac88567aSHyon Kim 			for (consnp = topo_list_next(&cp->sec_nodes);
2009ac88567aSHyon Kim 			    consnp != NULL; consnp = topo_list_next(consnp)) {
2010ac88567aSHyon Kim 				if (consnp->sen_type == SES_ET_SAS_CONNECTOR) {
2011ac88567aSHyon Kim 					psprops = ses_node_props(
2012ac88567aSHyon Kim 					    consnp->sen_node);
2013ac88567aSHyon Kim 					/*
2014ac88567aSHyon Kim 					 * Get the physical parent index to
2015ac88567aSHyon Kim 					 * compare.
2016ac88567aSHyon Kim 					 * The connector elements are children
2017ac88567aSHyon Kim 					 * of ESC Electronics element even
2018ac88567aSHyon Kim 					 * though we enumerate them under
2019ac88567aSHyon Kim 					 * an expander in libtopo.
2020ac88567aSHyon Kim 					 */
2021ac88567aSHyon Kim 					if (nvlist_lookup_uint64(psprops,
2022ac88567aSHyon Kim 					    SES_PROP_ELEMENT_ONLY_INDEX,
2023ac88567aSHyon Kim 					    &conindex) == 0) {
2024ac88567aSHyon Kim 						if (conindex ==
2025ded93414SHyon Kim 						    connectors[i].scpd_index) {
2026ac88567aSHyon Kim 							found = B_TRUE;
2027ac88567aSHyon Kim 							break;
2028ac88567aSHyon Kim 						}
2029ac88567aSHyon Kim 					}
2030ac88567aSHyon Kim 				}
2031ac88567aSHyon Kim 			}
2032ac88567aSHyon Kim 
2033ac88567aSHyon Kim 			/* now create a libtopo node. */
2034ac88567aSHyon Kim 			if (found) {
2035ac88567aSHyon Kim 				/* Create generic props. */
2036ac88567aSHyon Kim 				if (ses_create_generic(sdp, consnp, exptn,
2037ded93414SHyon Kim 				    topo_node_parent(exptn),
2038ac88567aSHyon Kim 				    RECEPTACLE, "RECEPTACLE", &contn) !=
2039ac88567aSHyon Kim 				    0) {
2040ac88567aSHyon Kim 					continue;
2041ac88567aSHyon Kim 				}
2042ac88567aSHyon Kim 				/* Create connector specific props. */
2043ac88567aSHyon Kim 				if (ses_set_connector_props(sdp, consnp,
2044ded93414SHyon Kim 				    contn, connectors[i].scpd_pm) != 0) {
2045ac88567aSHyon Kim 					continue;
2046ac88567aSHyon Kim 				}
2047ac88567aSHyon Kim 			}
2048ac88567aSHyon Kim 		}
2049ac88567aSHyon Kim 		/* end indentation change */
2050ac88567aSHyon Kim 				}
2051ac88567aSHyon Kim 			}
2052ac88567aSHyon Kim 		}
2053ac88567aSHyon Kim 	}
2054ac88567aSHyon Kim 
2055ac88567aSHyon Kim 	return (0);
2056ac88567aSHyon Kim }
2057ac88567aSHyon Kim 
2058ac88567aSHyon Kim /*
2059ac88567aSHyon Kim  * Instantiate any protocol specific portion of a node.
2060ac88567aSHyon Kim  */
2061ac88567aSHyon Kim /*ARGSUSED*/
2062ac88567aSHyon Kim static int
2063ac88567aSHyon Kim ses_create_protocol_specific(ses_enum_data_t *sdp, ses_enum_node_t *snp,
2064ac88567aSHyon Kim     tnode_t *pnode, uint64_t type, ses_enum_chassis_t *cp,
2065ac88567aSHyon Kim     boolean_t dorange)
2066ac88567aSHyon Kim {
2067ac88567aSHyon Kim 
2068ac88567aSHyon Kim 	if (type == SES_ET_ESC_ELECTRONICS) {
2069ac88567aSHyon Kim 		/* create SAS specific children(expanders and connectors. */
2070ac88567aSHyon Kim 		return (ses_create_esc_sasspecific(sdp, snp, pnode, cp,
2071ac88567aSHyon Kim 		    dorange));
2072ac88567aSHyon Kim 	}
2073ac88567aSHyon Kim 
2074ac88567aSHyon Kim 	return (0);
2075ac88567aSHyon Kim }
2076ac88567aSHyon Kim 
2077940d71d2Seschrock /*
2078940d71d2Seschrock  * Instantiate any children of a given type.
2079940d71d2Seschrock  */
2080940d71d2Seschrock static int
2081940d71d2Seschrock ses_create_children(ses_enum_data_t *sdp, tnode_t *pnode, uint64_t type,
2082d91236feSeschrock     const char *nodename, const char *defaultlabel, ses_enum_chassis_t *cp,
2083d91236feSeschrock     boolean_t dorange)
2084940d71d2Seschrock {
2085940d71d2Seschrock 	topo_mod_t *mod = sdp->sed_mod;
2086940d71d2Seschrock 	boolean_t found;
2087940d71d2Seschrock 	uint64_t max;
2088940d71d2Seschrock 	ses_enum_node_t *snp;
2089ac88567aSHyon Kim 	tnode_t	*tn;
2090940d71d2Seschrock 
2091940d71d2Seschrock 	/*
2092940d71d2Seschrock 	 * First go through and count how many matching nodes we have.
2093940d71d2Seschrock 	 */
2094940d71d2Seschrock 	max = 0;
2095940d71d2Seschrock 	found = B_FALSE;
2096940d71d2Seschrock 	for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2097940d71d2Seschrock 	    snp = topo_list_next(snp)) {
2098940d71d2Seschrock 		if (snp->sen_type == type) {
2099940d71d2Seschrock 			found = B_TRUE;
2100940d71d2Seschrock 			if (snp->sen_instance > max)
2101940d71d2Seschrock 				max = snp->sen_instance;
2102940d71d2Seschrock 		}
2103940d71d2Seschrock 	}
2104940d71d2Seschrock 
2105940d71d2Seschrock 	/*
2106940d71d2Seschrock 	 * No enclosure should export both DEVICE and ARRAY_DEVICE elements.
2107940d71d2Seschrock 	 * Since we map both of these to 'disk', if an enclosure does this, we
2108940d71d2Seschrock 	 * just ignore the array elements.
2109940d71d2Seschrock 	 */
2110940d71d2Seschrock 	if (!found ||
2111940d71d2Seschrock 	    (type == SES_ET_ARRAY_DEVICE && cp->sec_hasdev))
2112940d71d2Seschrock 		return (0);
2113940d71d2Seschrock 
2114940d71d2Seschrock 	topo_mod_dprintf(mod, "%s: creating %llu %s nodes",
211553dbcc59SSundeep Panicker 	    cp->sec_csn, max + 1, nodename);
2116940d71d2Seschrock 
2117d91236feSeschrock 	if (dorange && topo_node_range_create(mod, pnode,
2118940d71d2Seschrock 	    nodename, 0, max) != 0) {
2119940d71d2Seschrock 		topo_mod_dprintf(mod,
2120940d71d2Seschrock 		    "topo_node_create_range() failed: %s",
2121940d71d2Seschrock 		    topo_mod_errmsg(mod));
2122940d71d2Seschrock 		return (-1);
2123940d71d2Seschrock 	}
2124940d71d2Seschrock 
2125940d71d2Seschrock 	for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2126940d71d2Seschrock 	    snp = topo_list_next(snp)) {
2127940d71d2Seschrock 		if (snp->sen_type == type) {
2128ded93414SHyon Kim 			/*
2129ded93414SHyon Kim 			 * With flat layout of ses nodes there is no
2130ded93414SHyon Kim 			 * way to find out the direct FRU for a node.
2131ded93414SHyon Kim 			 * Passing NULL for fru topo node.  Note that
2132ded93414SHyon Kim 			 * ses_create_children_from_phys_tree() provides
2133ded93414SHyon Kim 			 * the actual direct FRU for a node.
2134ded93414SHyon Kim 			 */
2135ded93414SHyon Kim 			if (ses_create_generic(sdp, snp, pnode, NULL,
2136ac88567aSHyon Kim 			    nodename, defaultlabel, &tn) != 0)
2137940d71d2Seschrock 				return (-1);
2138ac88567aSHyon Kim 			/*
2139ac88567aSHyon Kim 			 * For some SES element there may be protocol specific
2140ac88567aSHyon Kim 			 * information to process.   Here we are processing
2141ac88567aSHyon Kim 			 * the association between enclosure controller and
2142ac88567aSHyon Kim 			 * SAS expanders.
2143ac88567aSHyon Kim 			 */
2144ac88567aSHyon Kim 			if (type == SES_ET_ESC_ELECTRONICS) {
2145ac88567aSHyon Kim 				/* create SAS expander node */
2146ac88567aSHyon Kim 				if (ses_create_protocol_specific(sdp, snp,
2147ac88567aSHyon Kim 				    tn, type, cp, dorange) != 0) {
2148ac88567aSHyon Kim 					return (-1);
2149ac88567aSHyon Kim 				}
2150ac88567aSHyon Kim 			}
2151ac88567aSHyon Kim 
2152940d71d2Seschrock 		}
2153940d71d2Seschrock 	}
2154940d71d2Seschrock 
2155940d71d2Seschrock 	return (0);
2156940d71d2Seschrock }
2157940d71d2Seschrock 
215853dbcc59SSundeep Panicker /*
215953dbcc59SSundeep Panicker  * Instantiate a new subchassis instance in the topology.
216053dbcc59SSundeep Panicker  */
216153dbcc59SSundeep Panicker static int
216253dbcc59SSundeep Panicker ses_create_subchassis(ses_enum_data_t *sdp, tnode_t *pnode,
216353dbcc59SSundeep Panicker     ses_enum_chassis_t *scp)
216453dbcc59SSundeep Panicker {
216553dbcc59SSundeep Panicker 	topo_mod_t *mod = sdp->sed_mod;
216653dbcc59SSundeep Panicker 	tnode_t *tn;
216753dbcc59SSundeep Panicker 	nvlist_t *props;
216853dbcc59SSundeep Panicker 	nvlist_t *auth = NULL, *fmri = NULL;
216953dbcc59SSundeep Panicker 	uint64_t instance = scp->sec_instance;
217053dbcc59SSundeep Panicker 	char *desc;
217153dbcc59SSundeep Panicker 	char label[128];
217253dbcc59SSundeep Panicker 	char **paths;
217353dbcc59SSundeep Panicker 	int i, err;
217453dbcc59SSundeep Panicker 	ses_enum_target_t *stp;
217553dbcc59SSundeep Panicker 	int ret = -1;
217653dbcc59SSundeep Panicker 
217753dbcc59SSundeep Panicker 	/*
217853dbcc59SSundeep Panicker 	 * Copy authority information from parent enclosure node
217953dbcc59SSundeep Panicker 	 */
218053dbcc59SSundeep Panicker 	if ((auth = topo_mod_auth(mod, pnode)) == NULL)
218153dbcc59SSundeep Panicker 		goto error;
218253dbcc59SSundeep Panicker 
218353dbcc59SSundeep Panicker 	/*
218453dbcc59SSundeep Panicker 	 * Record the subchassis serial number in the FMRI.
218553dbcc59SSundeep Panicker 	 * For now, we assume that logical id is the subchassis serial number.
218653dbcc59SSundeep Panicker 	 * If this assumption changes in future, then the following
218753dbcc59SSundeep Panicker 	 * piece of code will need to be updated via an RFE.
218853dbcc59SSundeep Panicker 	 */
218953dbcc59SSundeep Panicker 	if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION,
2190ac88567aSHyon Kim 	    SUBCHASSIS, (topo_instance_t)instance, NULL, auth, NULL, NULL,
2191ac88567aSHyon Kim 	    NULL)) == NULL) {
219253dbcc59SSundeep Panicker 		topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
219353dbcc59SSundeep Panicker 		    topo_mod_errmsg(mod));
219453dbcc59SSundeep Panicker 		goto error;
219553dbcc59SSundeep Panicker 	}
219653dbcc59SSundeep Panicker 
219753dbcc59SSundeep Panicker 	if ((tn = topo_node_bind(mod, pnode, SUBCHASSIS,
219853dbcc59SSundeep Panicker 	    instance, fmri)) == NULL) {
219953dbcc59SSundeep Panicker 		topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
220053dbcc59SSundeep Panicker 		    topo_mod_errmsg(mod));
220153dbcc59SSundeep Panicker 		goto error;
220253dbcc59SSundeep Panicker 	}
220353dbcc59SSundeep Panicker 
220453dbcc59SSundeep Panicker 	props = ses_node_props(scp->sec_enclosure);
220553dbcc59SSundeep Panicker 
220653dbcc59SSundeep Panicker 	/*
220753dbcc59SSundeep Panicker 	 * Look for the subchassis label in the following order:
220853dbcc59SSundeep Panicker 	 *	<ses-description>
220953dbcc59SSundeep Panicker 	 *	<ses-class-description> <instance>
221053dbcc59SSundeep Panicker 	 *	<default-type-label> <instance>
221153dbcc59SSundeep Panicker 	 *
221253dbcc59SSundeep Panicker 	 * For subchassis, the default label is "SUBCHASSIS"
221353dbcc59SSundeep Panicker 	 */
221453dbcc59SSundeep Panicker 	if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 ||
221553dbcc59SSundeep Panicker 	    desc[0] == '\0') {
221653dbcc59SSundeep Panicker 		if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION,
221753dbcc59SSundeep Panicker 		    &desc) == 0 && desc[0] != '\0')
221853dbcc59SSundeep Panicker 			(void) snprintf(label, sizeof (label), "%s %llu", desc,
221953dbcc59SSundeep Panicker 			    instance);
222053dbcc59SSundeep Panicker 		else
222153dbcc59SSundeep Panicker 			(void) snprintf(label, sizeof (label),
222253dbcc59SSundeep Panicker 			    "SUBCHASSIS %llu", instance);
222353dbcc59SSundeep Panicker 		desc = label;
222453dbcc59SSundeep Panicker 	}
222553dbcc59SSundeep Panicker 
222653dbcc59SSundeep Panicker 	if (topo_node_label_set(tn, desc, &err) != 0)
222753dbcc59SSundeep Panicker 		goto error;
222853dbcc59SSundeep Panicker 
2229ac88567aSHyon Kim 	if (ses_set_standard_props(mod, NULL, tn, NULL,
223053dbcc59SSundeep Panicker 	    ses_node_id(scp->sec_enclosure), scp->sec_target->set_devpath) != 0)
223153dbcc59SSundeep Panicker 		goto error;
223253dbcc59SSundeep Panicker 
2233ac88567aSHyon Kim 	/*
2234ac88567aSHyon Kim 	 * Set the 'chassis-type' property for this subchassis.  This is either
2235ac88567aSHyon Kim 	 * 'ses-class-description' or 'subchassis'.
2236ac88567aSHyon Kim 	 */
2237ac88567aSHyon Kim 	if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION, &desc) != 0)
2238ac88567aSHyon Kim 		desc = "subchassis";
2239ac88567aSHyon Kim 
2240ac88567aSHyon Kim 	if (topo_prop_set_string(tn, TOPO_PGROUP_SES,
2241ac88567aSHyon Kim 	    TOPO_PROP_CHASSIS_TYPE, TOPO_PROP_IMMUTABLE, desc, &err) != 0) {
2242ac88567aSHyon Kim 		topo_mod_dprintf(mod, "failed to create property %s: %s\n",
2243ac88567aSHyon Kim 		    TOPO_PROP_CHASSIS_TYPE, topo_strerror(err));
2244ac88567aSHyon Kim 		goto error;
2245ac88567aSHyon Kim 	}
2246ac88567aSHyon Kim 
224753dbcc59SSundeep Panicker 	/*
224853dbcc59SSundeep Panicker 	 * For enclosures, we want to include all possible targets (for upgrade
224953dbcc59SSundeep Panicker 	 * purposes).
225053dbcc59SSundeep Panicker 	 */
225153dbcc59SSundeep Panicker 	for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL;
225253dbcc59SSundeep Panicker 	    stp = topo_list_next(stp), i++)
225353dbcc59SSundeep Panicker 		;
225453dbcc59SSundeep Panicker 
225553dbcc59SSundeep Panicker 	verify(i != 0);
225653dbcc59SSundeep Panicker 	paths = alloca(i * sizeof (char *));
225753dbcc59SSundeep Panicker 
225853dbcc59SSundeep Panicker 	for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL;
225953dbcc59SSundeep Panicker 	    stp = topo_list_next(stp), i++)
226053dbcc59SSundeep Panicker 		paths[i] = stp->set_devpath;
226153dbcc59SSundeep Panicker 
226253dbcc59SSundeep Panicker 	if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES,
226353dbcc59SSundeep Panicker 	    TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths,
226453dbcc59SSundeep Panicker 	    i, &err) != 0) {
226553dbcc59SSundeep Panicker 		topo_mod_dprintf(mod, "failed to create property %s: %s\n",
226653dbcc59SSundeep Panicker 		    TOPO_PROP_PATHS, topo_strerror(err));
226753dbcc59SSundeep Panicker 		goto error;
226853dbcc59SSundeep Panicker 	}
226953dbcc59SSundeep Panicker 
227053dbcc59SSundeep Panicker 	if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) {
227153dbcc59SSundeep Panicker 		topo_mod_dprintf(mod, "topo_method_register() failed: %s",
227253dbcc59SSundeep Panicker 		    topo_mod_errmsg(mod));
227353dbcc59SSundeep Panicker 		goto error;
227453dbcc59SSundeep Panicker 	}
227553dbcc59SSundeep Panicker 
227653dbcc59SSundeep Panicker 	/*
227753dbcc59SSundeep Panicker 	 * Create the nodes for controllers and bays.
227853dbcc59SSundeep Panicker 	 */
227953dbcc59SSundeep Panicker 	if (ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS,
228053dbcc59SSundeep Panicker 	    CONTROLLER, "CONTROLLER", scp, B_TRUE) != 0 ||
228153dbcc59SSundeep Panicker 	    ses_create_children(sdp, tn, SES_ET_DEVICE,
228253dbcc59SSundeep Panicker 	    BAY, "BAY", scp, B_TRUE) != 0 ||
228353dbcc59SSundeep Panicker 	    ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE,
228453dbcc59SSundeep Panicker 	    BAY, "BAY", scp, B_TRUE) != 0)
228553dbcc59SSundeep Panicker 		goto error;
228653dbcc59SSundeep Panicker 
228753dbcc59SSundeep Panicker 	ret = 0;
228853dbcc59SSundeep Panicker 
228953dbcc59SSundeep Panicker error:
229053dbcc59SSundeep Panicker 	nvlist_free(auth);
229153dbcc59SSundeep Panicker 	nvlist_free(fmri);
229253dbcc59SSundeep Panicker 	return (ret);
229353dbcc59SSundeep Panicker }
229453dbcc59SSundeep Panicker 
2295ded93414SHyon Kim /*
2296ded93414SHyon Kim  * Function we use to insert a node.
2297ded93414SHyon Kim  */
2298ded93414SHyon Kim static int
2299ded93414SHyon Kim ses_phys_tree_insert(topo_mod_t *mod, ses_phys_tree_t **sproot,
2300ded93414SHyon Kim     ses_phys_tree_t *child)
2301ded93414SHyon Kim {
2302ded93414SHyon Kim 	uint64_t ppindex, eindex, pindex;
2303ded93414SHyon Kim 	ses_phys_tree_t *node_ptr;
2304ded93414SHyon Kim 	int ret = 0;
2305ded93414SHyon Kim 
2306ded93414SHyon Kim 	assert(sproot != NULL);
2307ded93414SHyon Kim 	assert(child != NULL);
2308ded93414SHyon Kim 
2309ded93414SHyon Kim 	if (*sproot == NULL) {
2310ded93414SHyon Kim 		*sproot = child;
2311ded93414SHyon Kim 		return (0);
2312ded93414SHyon Kim 	}
2313ded93414SHyon Kim 
2314ded93414SHyon Kim 	pindex = child->spt_pindex;
2315ded93414SHyon Kim 	ppindex = (*sproot)->spt_pindex;
2316ded93414SHyon Kim 	eindex = (*sproot)->spt_eonlyindex;
2317ded93414SHyon Kim 
2318ded93414SHyon Kim 	/*
2319ded93414SHyon Kim 	 * If the element only index of the root is same as the physical
2320ded93414SHyon Kim 	 * parent index of a node to be added, add the node as a child of
2321ded93414SHyon Kim 	 * the current root.
2322ded93414SHyon Kim 	 */
2323ded93414SHyon Kim 	if (eindex == pindex) {
2324ded93414SHyon Kim 		(void) ses_phys_tree_insert(mod, &(*sproot)->spt_child, child);
2325ded93414SHyon Kim 		child->spt_parent = *sproot;
2326ded93414SHyon Kim 	} else if (ppindex == pindex) {
2327ded93414SHyon Kim 		/*
2328ded93414SHyon Kim 		 * if the physical parent of the current root and the child
2329ded93414SHyon Kim 		 * is same, then this should be a sibling node.
2330ded93414SHyon Kim 		 * Siblings can be different element types and arrange
2331ded93414SHyon Kim 		 * them by group.
2332ded93414SHyon Kim 		 */
2333ded93414SHyon Kim 		if ((*sproot)->spt_senumnode->sen_type ==
2334ded93414SHyon Kim 		    child->spt_senumnode->sen_type) {
2335ded93414SHyon Kim 			child->spt_sibling = *sproot;
2336ded93414SHyon Kim 			*sproot = child;
2337ded93414SHyon Kim 		} else {
2338ded93414SHyon Kim 			/* add a node in front of matching element type. */
2339ded93414SHyon Kim 			node_ptr = *sproot;
2340ded93414SHyon Kim 			while (node_ptr->spt_sibling != NULL) {
2341ded93414SHyon Kim 				if (node_ptr->spt_sibling->
2342ded93414SHyon Kim 				    spt_senumnode->sen_type ==
2343ded93414SHyon Kim 				    child->spt_senumnode->sen_type) {
2344ded93414SHyon Kim 					child->spt_sibling =
2345ded93414SHyon Kim 					    node_ptr->spt_sibling;
2346ded93414SHyon Kim 					node_ptr->spt_sibling = child;
2347ded93414SHyon Kim 					break;
2348ded93414SHyon Kim 				}
2349ded93414SHyon Kim 				node_ptr = node_ptr->spt_sibling;
2350ded93414SHyon Kim 			}
2351ded93414SHyon Kim 			/* no matching.  Add the child at the end. */
2352ded93414SHyon Kim 			if (node_ptr->spt_sibling == NULL) {
2353ded93414SHyon Kim 				node_ptr->spt_sibling = child;
2354ded93414SHyon Kim 			}
2355ded93414SHyon Kim 		}
2356ded93414SHyon Kim 		child->spt_parent = (*sproot)->spt_parent;
2357ded93414SHyon Kim 	} else {
2358ded93414SHyon Kim 		/*
2359ded93414SHyon Kim 		 * The root and the node is not directly related.
2360ded93414SHyon Kim 		 * Try to insert to the child sub-tree first and then try to
2361ded93414SHyon Kim 		 * insert to the sibling sub-trees.  If fails for both
2362ded93414SHyon Kim 		 * the caller will retry insertion later.
2363ded93414SHyon Kim 		 */
2364ded93414SHyon Kim 		if ((*sproot)->spt_child) {
2365ded93414SHyon Kim 			ret = ses_phys_tree_insert(mod, &(*sproot)->spt_child,
2366ded93414SHyon Kim 			    child);
2367ded93414SHyon Kim 		}
2368ded93414SHyon Kim 		if ((*sproot)->spt_child == NULL || ret != 0) {
2369ded93414SHyon Kim 			if ((*sproot)->spt_sibling) {
2370ded93414SHyon Kim 				ret = ses_phys_tree_insert(mod,
2371ded93414SHyon Kim 				    &(*sproot)->spt_sibling, child);
2372ded93414SHyon Kim 			} else {
2373ded93414SHyon Kim 				ret = 1;
2374ded93414SHyon Kim 			}
2375ded93414SHyon Kim 		}
2376ded93414SHyon Kim 		return (ret);
2377ded93414SHyon Kim 	}
2378ded93414SHyon Kim 	return (0);
2379ded93414SHyon Kim }
2380ded93414SHyon Kim 
2381ded93414SHyon Kim /*
2382ded93414SHyon Kim  * Construct tree view of ses elements through parent phyiscal element index.
2383ded93414SHyon Kim  * The root of tree is already constructed using the enclosure element.
2384ded93414SHyon Kim  */
2385ded93414SHyon Kim static int
2386ded93414SHyon Kim ses_construct_phys_tree(ses_enum_data_t *sdp, ses_enum_chassis_t *cp,
2387ded93414SHyon Kim     ses_phys_tree_t *sproot)
2388ded93414SHyon Kim {
2389ded93414SHyon Kim 	ses_enum_node_t *snp;
2390ded93414SHyon Kim 	ses_phys_tree_t	*child;
2391ded93414SHyon Kim 	ses_phys_tree_t	*u_watch = NULL;
2392ded93414SHyon Kim 	ses_phys_tree_t	*u_head = NULL;
2393ded93414SHyon Kim 	ses_phys_tree_t	*u_tail = NULL;
2394ded93414SHyon Kim 	int u_inserted = 0, u_left = 0;
2395ded93414SHyon Kim 	nvlist_t *props;
2396ded93414SHyon Kim 	topo_mod_t *mod = sdp->sed_mod;
2397ded93414SHyon Kim 
2398ded93414SHyon Kim 	for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2399ded93414SHyon Kim 	    snp = topo_list_next(snp)) {
2400ded93414SHyon Kim 		if ((child = topo_mod_zalloc(mod,
2401ded93414SHyon Kim 		    sizeof (ses_phys_tree_t))) == NULL) {
2402ded93414SHyon Kim 			topo_mod_dprintf(mod,
2403ded93414SHyon Kim 			    "failed to allocate root.");
2404ded93414SHyon Kim 			return (-1);
2405ded93414SHyon Kim 		}
2406ded93414SHyon Kim 		child->spt_snode = snp->sen_node;
2407ded93414SHyon Kim 		props = ses_node_props(snp->sen_node);
2408ded93414SHyon Kim 		if (nvlist_lookup_uint64(props,
2409ded93414SHyon Kim 		    LIBSES_PROP_PHYS_PARENT, &child->spt_pindex) != 0) {
2410ded93414SHyon Kim 			/*
2411ded93414SHyon Kim 			 * the prop should exist. continue to see if
2412ded93414SHyon Kim 			 * we can build a partial tree with other elements.
2413ded93414SHyon Kim 			 */
2414ded93414SHyon Kim 			topo_mod_dprintf(mod,
2415ded93414SHyon Kim 			    "ses_construct_phys_tree(): Failed to find prop %s "
2416ded93414SHyon Kim 			    "on ses element type %d and instance %d "
2417ded93414SHyon Kim 			    "(CSN %s).", LIBSES_PROP_PHYS_PARENT,
2418ded93414SHyon Kim 			    snp->sen_type, snp->sen_instance, cp->sec_csn);
2419ded93414SHyon Kim 			topo_mod_free(mod, child, sizeof (ses_phys_tree_t));
2420ded93414SHyon Kim 			continue;
2421ded93414SHyon Kim 		} else {
2422ded93414SHyon Kim 			if (nvlist_lookup_boolean_value(props,
2423ded93414SHyon Kim 			    LIBSES_PROP_FRU, &child->spt_isfru) != 0) {
2424ded93414SHyon Kim 				topo_mod_dprintf(mod,
2425ded93414SHyon Kim 				    "ses_construct_phys_tree(): Failed to "
2426ded93414SHyon Kim 				    "find prop %s on ses element type %d "
2427ded93414SHyon Kim 				    "and instance %d (CSN %s).",
2428ded93414SHyon Kim 				    LIBSES_PROP_FRU,
2429ded93414SHyon Kim 				    snp->sen_type, snp->sen_instance,
2430ded93414SHyon Kim 				    cp->sec_csn);
2431ded93414SHyon Kim 				/*
2432ded93414SHyon Kim 				 * Ignore if the prop doesn't exist.
2433ded93414SHyon Kim 				 * Note that the enclosure itself should be
2434ded93414SHyon Kim 				 * a FRU so if no FRU found the enclosure FRU
2435ded93414SHyon Kim 				 * can be a direct FRU.
2436ded93414SHyon Kim 				 */
2437ded93414SHyon Kim 			}
2438ded93414SHyon Kim 			verify(nvlist_lookup_uint64(props,
2439ded93414SHyon Kim 			    SES_PROP_ELEMENT_ONLY_INDEX,
2440ded93414SHyon Kim 			    &child->spt_eonlyindex) == 0);
2441ded93414SHyon Kim 			verify(nvlist_lookup_uint64(props,
2442ded93414SHyon Kim 			    SES_PROP_ELEMENT_CLASS_INDEX,
2443ded93414SHyon Kim 			    &child->spt_cindex) == 0);
2444ded93414SHyon Kim 		}
2445ded93414SHyon Kim 		child->spt_senumnode = snp;
2446ded93414SHyon Kim 		if (ses_phys_tree_insert(mod, &sproot, child) != 0) {
2447ded93414SHyon Kim 			/* collect unresolved element to process later. */
2448ded93414SHyon Kim 			if (u_head == NULL) {
2449ded93414SHyon Kim 				u_head = child;
2450ded93414SHyon Kim 				u_tail = child;
2451ded93414SHyon Kim 			} else {
2452ded93414SHyon Kim 				child->spt_sibling = u_head;
2453ded93414SHyon Kim 				u_head = child;
2454ded93414SHyon Kim 			}
2455ded93414SHyon Kim 		}
2456ded93414SHyon Kim 	}
2457ded93414SHyon Kim 
2458ded93414SHyon Kim 	/*
2459ded93414SHyon Kim 	 * The parent of a child node may not be inserted yet.
2460ded93414SHyon Kim 	 * Trying to insert the child until no child is left or
2461ded93414SHyon Kim 	 * no child is not added further.  For the latter
2462ded93414SHyon Kim 	 * the hierarchical relationship between elements
2463ded93414SHyon Kim 	 * should be checked through SUNW,FRUID page.
2464ded93414SHyon Kim 	 * u_watch is a watch dog to check the prgress of unresolved
2465ded93414SHyon Kim 	 * node.
2466ded93414SHyon Kim 	 */
2467ded93414SHyon Kim 	u_watch = u_tail;
2468ded93414SHyon Kim 	while (u_head) {
2469ded93414SHyon Kim 		child = u_head;
2470ded93414SHyon Kim 		u_head = u_head->spt_sibling;
2471ded93414SHyon Kim 		if (u_head == NULL)
2472ded93414SHyon Kim 			u_tail = NULL;
2473ded93414SHyon Kim 		child->spt_sibling = NULL;
2474ded93414SHyon Kim 		if (ses_phys_tree_insert(mod, &sproot, child) != 0) {
2475ded93414SHyon Kim 			u_tail->spt_sibling = child;
2476ded93414SHyon Kim 			u_tail = child;
2477ded93414SHyon Kim 			if (child == u_watch) {
2478ded93414SHyon Kim 				/*
2479ded93414SHyon Kim 				 * We just scanned one round for the
2480ded93414SHyon Kim 				 * unresolved list. Check to see whether we
2481ded93414SHyon Kim 				 * have nodes inserted, if none, we should
2482ded93414SHyon Kim 				 * break in case of an indefinite loop.
2483ded93414SHyon Kim 				 */
2484ded93414SHyon Kim 				if (u_inserted == 0) {
2485ded93414SHyon Kim 					/*
2486ded93414SHyon Kim 					 * Indicate there is unhandled node.
2487ded93414SHyon Kim 					 * Chain free the whole unsolved
2488ded93414SHyon Kim 					 * list here.
2489ded93414SHyon Kim 					 */
2490ded93414SHyon Kim 					u_left++;
2491ded93414SHyon Kim 					break;
2492ded93414SHyon Kim 				} else {
2493ded93414SHyon Kim 					u_inserted = 0;
2494ded93414SHyon Kim 					u_watch = u_tail;
2495ded93414SHyon Kim 				}
2496ded93414SHyon Kim 			}
2497ded93414SHyon Kim 		} else {
2498ded93414SHyon Kim 			/*
2499ded93414SHyon Kim 			 * We just inserted one rpnode, increment the
2500ded93414SHyon Kim 			 * unsolved_inserted counter. We will utilize this
2501ded93414SHyon Kim 			 * counter to detect an indefinite insertion loop.
2502ded93414SHyon Kim 			 */
2503ded93414SHyon Kim 			u_inserted++;
25047f188cd7SHyon Kim 			if (child == u_watch) {
25057f188cd7SHyon Kim 				/*
25067f188cd7SHyon Kim 				 * watch dog node itself is inserted.
25077f188cd7SHyon Kim 				 * Set it to the tail and refresh the watching.
25087f188cd7SHyon Kim 				 */
25097f188cd7SHyon Kim 				u_watch = u_tail;
25107f188cd7SHyon Kim 				u_inserted = 0;
25117f188cd7SHyon Kim 				u_left = 0;
25127f188cd7SHyon Kim 			}
2513ded93414SHyon Kim 		}
2514ded93414SHyon Kim 	}
2515ded93414SHyon Kim 
2516ded93414SHyon Kim 	/* check if there is left out unresolved nodes. */
2517ded93414SHyon Kim 	if (u_left) {
2518ded93414SHyon Kim 		topo_mod_dprintf(mod, "ses_construct_phys_tree(): "
2519ded93414SHyon Kim 		    "Failed to construct physical view of the following "
2520ded93414SHyon Kim 		    "ses elements of Chassis CSN %s.", cp->sec_csn);
2521ded93414SHyon Kim 		while (u_head) {
2522ded93414SHyon Kim 			u_tail = u_head->spt_sibling;
2523ded93414SHyon Kim 			topo_mod_dprintf(mod,
2524ded93414SHyon Kim 			    "\telement type (%d) and instance (%d)",
2525ded93414SHyon Kim 			    u_head->spt_senumnode->sen_type,
2526ded93414SHyon Kim 			    u_head->spt_senumnode->sen_instance);
2527ded93414SHyon Kim 			topo_mod_free(mod, u_head, sizeof (ses_phys_tree_t));
2528ded93414SHyon Kim 			u_head = u_tail;
2529ded93414SHyon Kim 		}
2530ded93414SHyon Kim 		return (-1);
2531ded93414SHyon Kim 	}
2532ded93414SHyon Kim 
2533ded93414SHyon Kim 	return (0);
2534ded93414SHyon Kim }
2535ded93414SHyon Kim 
2536ded93414SHyon Kim /*
2537ded93414SHyon Kim  * Free the whole phys tree.
2538ded93414SHyon Kim  */
2539ded93414SHyon Kim static void ses_phys_tree_free(topo_mod_t *mod, ses_phys_tree_t *sproot)
2540ded93414SHyon Kim {
2541ded93414SHyon Kim 	if (sproot == NULL)
2542ded93414SHyon Kim 		return;
2543ded93414SHyon Kim 
2544ded93414SHyon Kim 	/* Free child tree. */
2545ded93414SHyon Kim 	if (sproot->spt_child) {
2546ded93414SHyon Kim 		ses_phys_tree_free(mod, sproot->spt_child);
2547ded93414SHyon Kim 	}
2548ded93414SHyon Kim 
2549ded93414SHyon Kim 	/* Free sibling trees. */
2550ded93414SHyon Kim 	if (sproot->spt_sibling) {
2551ded93414SHyon Kim 		ses_phys_tree_free(mod, sproot->spt_sibling);
2552ded93414SHyon Kim 	}
2553ded93414SHyon Kim 
2554ded93414SHyon Kim 	/* Free root node itself. */
2555ded93414SHyon Kim 	topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t));
2556ded93414SHyon Kim }
2557ded93414SHyon Kim 
2558ded93414SHyon Kim /*
2559ded93414SHyon Kim  * Parses phys_enum_type table to get the index of the given type.
2560ded93414SHyon Kim  */
2561ded93414SHyon Kim static boolean_t
2562ded93414SHyon Kim is_type_enumerated(ses_phys_tree_t *node, int *index)
2563ded93414SHyon Kim {
2564ded93414SHyon Kim 	int i;
2565ded93414SHyon Kim 
2566ded93414SHyon Kim 	for (i = 0; i < N_PHYS_ENUM_TYPES; i++) {
2567ded93414SHyon Kim 		if (node->spt_senumnode->sen_type ==
2568ded93414SHyon Kim 		    phys_enum_type_list[i].pet_type) {
2569ded93414SHyon Kim 			*index = i;
2570ded93414SHyon Kim 			return (B_TRUE);
2571ded93414SHyon Kim 		}
2572ded93414SHyon Kim 	}
2573ded93414SHyon Kim 	return (B_FALSE);
2574ded93414SHyon Kim }
2575ded93414SHyon Kim 
2576ded93414SHyon Kim /*
2577ded93414SHyon Kim  * Recusrive routine for top-down enumeration of the tree.
2578ded93414SHyon Kim  */
2579ded93414SHyon Kim static int
2580ded93414SHyon Kim ses_enumerate_node(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp,
2581ded93414SHyon Kim     ses_phys_tree_t *parent, int mrange[])
2582ded93414SHyon Kim {
2583ded93414SHyon Kim 	topo_mod_t *mod = sdp->sed_mod;
2584ded93414SHyon Kim 	ses_phys_tree_t *child = NULL;
2585ded93414SHyon Kim 	int i, ret = 0, ret_ch;
2586ded93414SHyon Kim 	uint64_t prevtype = SES_ET_UNSPECIFIED;
2587ded93414SHyon Kim 	ses_phys_tree_t *dirfru = NULL;
2588ded93414SHyon Kim 	tnode_t *tn = NULL, *frutn = NULL;
2589ded93414SHyon Kim 
2590ded93414SHyon Kim 	if (parent == NULL) {
2591ded93414SHyon Kim 		return (0);
2592ded93414SHyon Kim 	}
2593ded93414SHyon Kim 
2594ded93414SHyon Kim 	for (child = parent->spt_child; child != NULL;
2595ded93414SHyon Kim 	    child = child->spt_sibling) {
2596ded93414SHyon Kim 		if (is_type_enumerated(child, &i)) {
2597ded93414SHyon Kim 			if (prevtype != phys_enum_type_list[i].pet_type) {
2598ded93414SHyon Kim 				/* check if range needs to be created. */
2599ded93414SHyon Kim 				if (phys_enum_type_list[i].pet_dorange &&
2600ded93414SHyon Kim 				    topo_node_range_create(mod, pnode,
2601ded93414SHyon Kim 				    phys_enum_type_list[i].pet_nodename, 0,
2602ded93414SHyon Kim 				    mrange[i]) != 0) {
2603ded93414SHyon Kim 					topo_mod_dprintf(mod,
2604ded93414SHyon Kim 					    "topo_node_create_range() failed: "
2605ded93414SHyon Kim 					    "%s", topo_mod_errmsg(mod));
2606ded93414SHyon Kim 					return (-1);
2607ded93414SHyon Kim 				}
2608ded93414SHyon Kim 				prevtype = phys_enum_type_list[i].pet_type;
2609ded93414SHyon Kim 			}
2610ded93414SHyon Kim 
2611ded93414SHyon Kim 			if (!(child->spt_isfru)) {
2612ded93414SHyon Kim 				for (dirfru = parent; dirfru != NULL;
2613ded93414SHyon Kim 				    dirfru = dirfru->spt_parent) {
2614ded93414SHyon Kim 					if (dirfru->spt_isfru) {
2615ded93414SHyon Kim 						break;
2616ded93414SHyon Kim 					}
2617ded93414SHyon Kim 				}
2618ded93414SHyon Kim 				/* found direct FRU node. */
2619ded93414SHyon Kim 				if (dirfru) {
2620ded93414SHyon Kim 					frutn = dirfru->spt_tnode;
2621ded93414SHyon Kim 				} else {
2622ded93414SHyon Kim 					frutn = NULL;
2623ded93414SHyon Kim 				}
2624ded93414SHyon Kim 			} else {
2625ded93414SHyon Kim 				frutn = NULL;
2626ded93414SHyon Kim 			}
2627ded93414SHyon Kim 
2628ded93414SHyon Kim 			if (ses_create_generic(sdp, child->spt_senumnode,
2629ded93414SHyon Kim 			    pnode, frutn, phys_enum_type_list[i].pet_nodename,
2630ded93414SHyon Kim 			    phys_enum_type_list[i].pet_defaultlabel, &tn) != 0)
2631ded93414SHyon Kim 				return (-1);
2632ded93414SHyon Kim 
2633ded93414SHyon Kim 			child->spt_tnode = tn;
2634ded93414SHyon Kim 			/*
2635ded93414SHyon Kim 			 * For some SES element there may be protocol specific
2636ded93414SHyon Kim 			 * information to process.   Here we are processing
2637ded93414SHyon Kim 			 * the association between enclosure controller and
2638ded93414SHyon Kim 			 * SAS expanders.
2639ded93414SHyon Kim 			 */
2640ded93414SHyon Kim 			if (phys_enum_type_list[i].pet_type ==
2641ded93414SHyon Kim 			    SES_ET_ESC_ELECTRONICS) {
2642ded93414SHyon Kim 				/* create SAS expander node */
2643ded93414SHyon Kim 				if (ses_create_protocol_specific(sdp,
2644ded93414SHyon Kim 				    child->spt_senumnode, tn,
2645ded93414SHyon Kim 				    phys_enum_type_list[i].pet_type,
2646ded93414SHyon Kim 				    cp, phys_enum_type_list[i].pet_dorange) !=
2647ded93414SHyon Kim 				    0) {
2648ded93414SHyon Kim 					return (-1);
2649ded93414SHyon Kim 				}
2650ded93414SHyon Kim 			}
2651ded93414SHyon Kim 		} else {
2652ded93414SHyon Kim 			continue;
2653ded93414SHyon Kim 		}
2654ded93414SHyon Kim 		ret_ch = ses_enumerate_node(sdp, tn, cp, child, mrange);
2655ded93414SHyon Kim 		if (ret_ch)
2656ded93414SHyon Kim 			ret = ret_ch; /* there was an error and set the ret. */
2657ded93414SHyon Kim 	}
2658ded93414SHyon Kim 
2659ded93414SHyon Kim 	return (ret);
2660ded93414SHyon Kim }
2661ded93414SHyon Kim 
2662ded93414SHyon Kim /*
2663ded93414SHyon Kim  * Instantiate types of nodes that are specified in the hierarchy
2664ded93414SHyon Kim  * element type list.
2665ded93414SHyon Kim  */
2666ded93414SHyon Kim static int
2667ded93414SHyon Kim ses_create_children_from_phys_tree(ses_enum_data_t *sdp, tnode_t *pnode,
2668ded93414SHyon Kim     ses_enum_chassis_t *cp, ses_phys_tree_t *phys_tree)
2669ded93414SHyon Kim {
2670ded93414SHyon Kim 	topo_mod_t *mod = sdp->sed_mod;
2671ded93414SHyon Kim 	int mrange[N_PHYS_ENUM_TYPES] = { 0 };
2672ded93414SHyon Kim 	ses_enum_node_t *snp;
2673ded93414SHyon Kim 	int i, ret;
2674ded93414SHyon Kim 
2675ded93414SHyon Kim 	/*
2676ded93414SHyon Kim 	 * First get max range for each type of element to be enumerated.
2677ded93414SHyon Kim 	 */
2678ded93414SHyon Kim 	for (i = 0; i < N_PHYS_ENUM_TYPES; i++) {
2679ded93414SHyon Kim 		if (phys_enum_type_list[i].pet_dorange) {
2680ded93414SHyon Kim 			for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2681ded93414SHyon Kim 			    snp = topo_list_next(snp)) {
2682ded93414SHyon Kim 				if (snp->sen_type ==
2683ded93414SHyon Kim 				    phys_enum_type_list[i].pet_type) {
2684ded93414SHyon Kim 					if (snp->sen_instance > mrange[i])
2685ded93414SHyon Kim 						mrange[i] =
2686ded93414SHyon Kim 						    snp->sen_instance;
2687ded93414SHyon Kim 				}
2688ded93414SHyon Kim 			}
2689ded93414SHyon Kim 		}
2690ded93414SHyon Kim 	}
2691ded93414SHyon Kim 
2692ded93414SHyon Kim 	topo_mod_dprintf(mod, "%s: creating nodes from FRU hierarchy tree.",
2693ded93414SHyon Kim 	    cp->sec_csn);
2694ded93414SHyon Kim 
2695ded93414SHyon Kim 	if ((ret = ses_enumerate_node(sdp, pnode, cp, phys_tree, mrange)) !=
2696ded93414SHyon Kim 	    0) {
2697ded93414SHyon Kim 		topo_mod_dprintf(mod,
2698ded93414SHyon Kim 		    "ses_create_children_from_phys_tree() failed: ");
2699ded93414SHyon Kim 		return (ret);
2700ded93414SHyon Kim 	}
2701ded93414SHyon Kim 
2702ded93414SHyon Kim 	return (0);
2703ded93414SHyon Kim }
2704ded93414SHyon Kim 
2705940d71d2Seschrock /*
2706940d71d2Seschrock  * Instantiate a new chassis instance in the topology.
2707940d71d2Seschrock  */
2708940d71d2Seschrock static int
2709940d71d2Seschrock ses_create_chassis(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp)
2710940d71d2Seschrock {
2711940d71d2Seschrock 	topo_mod_t *mod = sdp->sed_mod;
2712940d71d2Seschrock 	nvlist_t *props;
2713940d71d2Seschrock 	char *raw_manufacturer, *raw_model, *raw_revision;
2714940d71d2Seschrock 	char *manufacturer = NULL, *model = NULL, *product = NULL;
2715940d71d2Seschrock 	char *revision = NULL;
2716940d71d2Seschrock 	char *serial;
27176efb64caSEric Schrock 	char **paths;
2718940d71d2Seschrock 	size_t prodlen;
2719940d71d2Seschrock 	tnode_t *tn;
2720940d71d2Seschrock 	nvlist_t *fmri = NULL, *auth = NULL;
2721940d71d2Seschrock 	int ret = -1;
2722940d71d2Seschrock 	ses_enum_node_t *snp;
27236efb64caSEric Schrock 	ses_enum_target_t *stp;
272453dbcc59SSundeep Panicker 	ses_enum_chassis_t *scp;
27256efb64caSEric Schrock 	int i, err;
2726ded93414SHyon Kim 	uint64_t sc_count = 0, pindex;
2727ded93414SHyon Kim 	ses_phys_tree_t	*sproot = NULL;
2728ded93414SHyon Kim 	hrtime_t start;
2729ded93414SHyon Kim 	hrtime_t end;
2730ded93414SHyon Kim 	double duration;
2731940d71d2Seschrock 
2732d91236feSeschrock 	/*
2733d91236feSeschrock 	 * Ignore any internal enclosures.
2734d91236feSeschrock 	 */
2735d91236feSeschrock 	if (cp->sec_internal)
2736d91236feSeschrock 		return (0);
2737d91236feSeschrock 
2738940d71d2Seschrock 	/*
2739940d71d2Seschrock 	 * Check to see if there are any devices presennt in the chassis.  If
2740940d71d2Seschrock 	 * not, ignore the chassis alltogether.  This is most useful for
2741940d71d2Seschrock 	 * ignoring internal HBAs that present a SES target but don't actually
2742940d71d2Seschrock 	 * manage any of the devices.
2743940d71d2Seschrock 	 */
2744940d71d2Seschrock 	for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2745940d71d2Seschrock 	    snp = topo_list_next(snp)) {
2746940d71d2Seschrock 		if (snp->sen_type == SES_ET_DEVICE ||
2747940d71d2Seschrock 		    snp->sen_type == SES_ET_ARRAY_DEVICE)
2748940d71d2Seschrock 			break;
2749940d71d2Seschrock 	}
2750940d71d2Seschrock 
2751940d71d2Seschrock 	if (snp == NULL)
2752940d71d2Seschrock 		return (0);
2753940d71d2Seschrock 
2754940d71d2Seschrock 	props = ses_node_props(cp->sec_enclosure);
2755940d71d2Seschrock 
2756940d71d2Seschrock 	/*
2757940d71d2Seschrock 	 * We use the following property mappings:
2758940d71d2Seschrock 	 *
2759940d71d2Seschrock 	 * 	manufacturer		vendor-id
2760940d71d2Seschrock 	 * 	model			product-id
2761940d71d2Seschrock 	 * 	serial-number		libses-chassis-serial
2762940d71d2Seschrock 	 */
2763940d71d2Seschrock 	verify(nvlist_lookup_string(props, SES_EN_PROP_VID,
2764940d71d2Seschrock 	    &raw_manufacturer) == 0);
2765940d71d2Seschrock 	verify(nvlist_lookup_string(props, SES_EN_PROP_PID, &raw_model) == 0);
2766940d71d2Seschrock 	verify(nvlist_lookup_string(props, SES_EN_PROP_REV,
2767940d71d2Seschrock 	    &raw_revision) == 0);
2768940d71d2Seschrock 	verify(nvlist_lookup_string(props, LIBSES_EN_PROP_CSN, &serial) == 0);
2769940d71d2Seschrock 
2770940d71d2Seschrock 	/*
2771940d71d2Seschrock 	 * To construct the authority information, we 'clean' each string by
2772940d71d2Seschrock 	 * removing any offensive characters and trimmming whitespace.  For the
2773940d71d2Seschrock 	 * 'product-id', we use a concatenation of 'manufacturer-model'.  We
2774940d71d2Seschrock 	 * also take the numerical serial number and convert it to a string.
2775940d71d2Seschrock 	 */
2776940d71d2Seschrock 	if ((manufacturer = disk_auth_clean(mod, raw_manufacturer)) == NULL ||
2777940d71d2Seschrock 	    (model = disk_auth_clean(mod, raw_model)) == NULL ||
2778940d71d2Seschrock 	    (revision = disk_auth_clean(mod, raw_revision)) == NULL) {
2779940d71d2Seschrock 		goto error;
2780940d71d2Seschrock 	}
2781940d71d2Seschrock 
2782940d71d2Seschrock 	prodlen = strlen(manufacturer) + strlen(model) + 2;
2783940d71d2Seschrock 	if ((product = topo_mod_alloc(mod, prodlen)) == NULL)
2784940d71d2Seschrock 		goto error;
2785940d71d2Seschrock 
2786940d71d2Seschrock 	(void) snprintf(product, prodlen, "%s-%s", manufacturer, model);
2787940d71d2Seschrock 
2788940d71d2Seschrock 	/*
2789940d71d2Seschrock 	 * Construct the topo node and bind it to our parent.
2790940d71d2Seschrock 	 */
2791940d71d2Seschrock 	if (topo_mod_nvalloc(mod, &auth, NV_UNIQUE_NAME) != 0)
2792940d71d2Seschrock 		goto error;
2793940d71d2Seschrock 
2794940d71d2Seschrock 	if (nvlist_add_string(auth, FM_FMRI_AUTH_PRODUCT, product) != 0 ||
2795940d71d2Seschrock 	    nvlist_add_string(auth, FM_FMRI_AUTH_CHASSIS, serial) != 0) {
2796940d71d2Seschrock 		(void) topo_mod_seterrno(mod, EMOD_NVL_INVAL);
2797940d71d2Seschrock 		goto error;
2798940d71d2Seschrock 	}
2799940d71d2Seschrock 
2800940d71d2Seschrock 	/*
2801940d71d2Seschrock 	 * We pass NULL for the parent FMRI because there is no resource
2802940d71d2Seschrock 	 * associated with it.  For the toplevel enclosure, we leave the
2803940d71d2Seschrock 	 * serial/part/revision portions empty, which are reserved for
2804940d71d2Seschrock 	 * individual components within the chassis.
2805940d71d2Seschrock 	 */
2806940d71d2Seschrock 	if ((fmri = topo_mod_hcfmri(mod, NULL, FM_HC_SCHEME_VERSION,
2807940d71d2Seschrock 	    SES_ENCLOSURE, cp->sec_instance, NULL, auth,
2808940d71d2Seschrock 	    model, revision, serial)) == NULL) {
2809940d71d2Seschrock 		topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
2810940d71d2Seschrock 		    topo_mod_errmsg(mod));
2811940d71d2Seschrock 		goto error;
2812940d71d2Seschrock 	}
2813940d71d2Seschrock 
2814940d71d2Seschrock 	if ((tn = topo_node_bind(mod, pnode, SES_ENCLOSURE,
2815940d71d2Seschrock 	    cp->sec_instance, fmri)) == NULL) {
2816940d71d2Seschrock 		topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
2817940d71d2Seschrock 		    topo_mod_errmsg(mod));
2818940d71d2Seschrock 		goto error;
2819940d71d2Seschrock 	}
2820940d71d2Seschrock 
2821940d71d2Seschrock 	if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) {
2822940d71d2Seschrock 		topo_mod_dprintf(mod,
2823940d71d2Seschrock 		    "topo_method_register() failed: %s",
2824940d71d2Seschrock 		    topo_mod_errmsg(mod));
2825940d71d2Seschrock 		goto error;
2826940d71d2Seschrock 	}
2827940d71d2Seschrock 
2828ac88567aSHyon Kim 	if (ses_set_standard_props(mod, NULL, tn, auth,
2829940d71d2Seschrock 	    ses_node_id(cp->sec_enclosure), cp->sec_target->set_devpath) != 0)
2830940d71d2Seschrock 		goto error;
2831940d71d2Seschrock 
28326efb64caSEric Schrock 	/*
28336efb64caSEric Schrock 	 * For enclosures, we want to include all possible targets (for upgrade
28346efb64caSEric Schrock 	 * purposes).
28356efb64caSEric Schrock 	 */
28366efb64caSEric Schrock 	for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL;
28376efb64caSEric Schrock 	    stp = topo_list_next(stp), i++)
28386efb64caSEric Schrock 		;
28396efb64caSEric Schrock 
28406efb64caSEric Schrock 	verify(i != 0);
28416efb64caSEric Schrock 	paths = alloca(i * sizeof (char *));
28426efb64caSEric Schrock 
28436efb64caSEric Schrock 	for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL;
28446efb64caSEric Schrock 	    stp = topo_list_next(stp), i++)
28456efb64caSEric Schrock 		paths[i] = stp->set_devpath;
28466efb64caSEric Schrock 
28476efb64caSEric Schrock 
28486efb64caSEric Schrock 	if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES,
28496efb64caSEric Schrock 	    TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths,
28506efb64caSEric Schrock 	    i, &err) != 0) {
28516efb64caSEric Schrock 		topo_mod_dprintf(mod,
28526efb64caSEric Schrock 		    "failed to create property %s: %s\n",
28536efb64caSEric Schrock 		    TOPO_PROP_PATHS, topo_strerror(err));
28546efb64caSEric Schrock 		goto error;
28556efb64caSEric Schrock 	}
28566efb64caSEric Schrock 
2857ded93414SHyon Kim 	if (nvlist_lookup_uint64(props,
2858ded93414SHyon Kim 	    LIBSES_PROP_PHYS_PARENT, &pindex) == 0) {
2859ded93414SHyon Kim 		start = gethrtime(); /* to mearusre performance */
2860ded93414SHyon Kim 		/*
2861ded93414SHyon Kim 		 * The enclosure is supported through SUNW,FRUID.
2862ded93414SHyon Kim 		 * Need to enumerate the nodes through hierarchical order.
2863ded93414SHyon Kim 		 */
2864ded93414SHyon Kim 		if ((sproot = topo_mod_zalloc(mod,
2865ded93414SHyon Kim 		    sizeof (ses_phys_tree_t))) == NULL) {
2866ded93414SHyon Kim 			topo_mod_dprintf(mod,
2867ded93414SHyon Kim 			    "failed to allocate root: %s\n",
2868ded93414SHyon Kim 			    topo_strerror(err));
2869ded93414SHyon Kim 			goto error;
2870ded93414SHyon Kim 		}
2871ded93414SHyon Kim 		sproot->spt_pindex = pindex;
2872ded93414SHyon Kim 		if (nvlist_lookup_boolean_value(props,
2873ded93414SHyon Kim 		    LIBSES_PROP_FRU, &sproot->spt_isfru) != 0) {
2874ded93414SHyon Kim 			topo_mod_dprintf(mod,
2875ded93414SHyon Kim 			    "ses_create_chassis(): Failed to find prop %s "
2876ded93414SHyon Kim 			    "on enclosure element (CSN %s).",
2877ded93414SHyon Kim 			    LIBSES_PROP_FRU, cp->sec_csn);
2878ded93414SHyon Kim 			/* an enclosure should be a FRU. continue to process. */
2879ded93414SHyon Kim 			sproot->spt_isfru = B_TRUE;
2880ded93414SHyon Kim 		}
2881ded93414SHyon Kim 		if (nvlist_lookup_uint64(props,
2882ded93414SHyon Kim 		    SES_PROP_ELEMENT_ONLY_INDEX,
2883ded93414SHyon Kim 		    &sproot->spt_eonlyindex) != 0) {
2884ded93414SHyon Kim 			topo_mod_dprintf(mod,
2885ded93414SHyon Kim 			    "ses_create_chassis(): Failed to find prop %s "
2886ded93414SHyon Kim 			    "on enclosure element (CSN %s).",
2887ded93414SHyon Kim 			    LIBSES_PROP_PHYS_PARENT, cp->sec_csn);
2888ded93414SHyon Kim 			topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t));
2889ded93414SHyon Kim 			goto error;
2890ded93414SHyon Kim 		}
2891ded93414SHyon Kim 		if (sproot->spt_pindex != sproot->spt_eonlyindex) {
2892ded93414SHyon Kim 			topo_mod_dprintf(mod, "ses_create_chassis(): "
2893ded93414SHyon Kim 			    "Enclosure element(CSN %s) should have "
2894ded93414SHyon Kim 			    "itself as the parent to be the root node "
2895ded93414SHyon Kim 			    "of FRU hierarchical tree.)", cp->sec_csn);
2896ded93414SHyon Kim 			topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t));
2897ded93414SHyon Kim 			goto error;
2898ded93414SHyon Kim 		} else {
2899ded93414SHyon Kim 			sproot->spt_snode = cp->sec_enclosure;
2900ded93414SHyon Kim 			sproot->spt_tnode = tn;
2901ded93414SHyon Kim 			/* construct a tree. */
2902ded93414SHyon Kim 			if (ses_construct_phys_tree(sdp, cp, sproot) != 0) {
2903ded93414SHyon Kim 				topo_mod_dprintf(mod, "ses_create_chassis(): "
2904ded93414SHyon Kim 				    "Failed to construct FRU hierarchical "
2905ded93414SHyon Kim 				    "tree on enclosure (CSN %s.)",
2906ded93414SHyon Kim 				    cp->sec_csn);
2907ded93414SHyon Kim 			}
2908ded93414SHyon Kim 
2909ded93414SHyon Kim 			/* enumerate elements from the tree. */
2910ded93414SHyon Kim 			if (ses_create_children_from_phys_tree(sdp, tn, cp,
2911ded93414SHyon Kim 			    sproot) != 0) {
2912ded93414SHyon Kim 				topo_mod_dprintf(mod, "ses_create_chassis(): "
2913ded93414SHyon Kim 				    "Failed to create children topo nodes out "
2914ded93414SHyon Kim 				    "of FRU hierarchical tree on enclosure "
2915ded93414SHyon Kim 				    "(CSN %s).", cp->sec_csn);
2916ded93414SHyon Kim 			}
2917ded93414SHyon Kim 			/* destroy the phys tree. */
2918ded93414SHyon Kim 			ses_phys_tree_free(mod, sproot);
2919ded93414SHyon Kim 		}
2920ded93414SHyon Kim 
2921ded93414SHyon Kim 		end = gethrtime();
2922ded93414SHyon Kim 		duration = end - start;
2923ded93414SHyon Kim 		duration /= HR_SECOND;
2924ded93414SHyon Kim 		topo_mod_dprintf(mod,
2925ded93414SHyon Kim 		    "FRU boundary tree based enumeration: %.6f seconds",
2926ded93414SHyon Kim 		    duration);
2927ded93414SHyon Kim 	} else {
2928ded93414SHyon Kim 		/*
2929ded93414SHyon Kim 		 * Create the nodes for power supplies, fans, controllers and
2930ded93414SHyon Kim 		 * devices.  Note that SAS exopander nodes and connector nodes
2931ded93414SHyon Kim 		 * are handled through protocol specific processing of
2932ded93414SHyon Kim 		 * controllers.
2933ded93414SHyon Kim 		 */
2934ded93414SHyon Kim 		if (ses_create_children(sdp, tn, SES_ET_POWER_SUPPLY,
2935ded93414SHyon Kim 		    PSU, "PSU", cp, B_TRUE) != 0 ||
2936ded93414SHyon Kim 		    ses_create_children(sdp, tn, SES_ET_COOLING,
2937ded93414SHyon Kim 		    FAN, "FAN", cp, B_TRUE) != 0 ||
2938ded93414SHyon Kim 		    ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS,
2939ded93414SHyon Kim 		    CONTROLLER, "CONTROLLER", cp, B_TRUE) != 0 ||
2940ded93414SHyon Kim 		    ses_create_children(sdp, tn, SES_ET_DEVICE,
2941ded93414SHyon Kim 		    BAY, "BAY", cp, B_TRUE) != 0 ||
2942ded93414SHyon Kim 		    ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE,
2943ded93414SHyon Kim 		    BAY, "BAY", cp, B_TRUE) != 0)
2944ded93414SHyon Kim 			goto error;
2945ded93414SHyon Kim 	}
2946940d71d2Seschrock 
2947ac88567aSHyon Kim 	if (cp->sec_maxinstance >= 0 &&
2948ac88567aSHyon Kim 	    (topo_node_range_create(mod, tn, SUBCHASSIS, 0,
2949ac88567aSHyon Kim 	    cp->sec_maxinstance) != 0)) {
295053dbcc59SSundeep Panicker 		topo_mod_dprintf(mod, "topo_node_create_range() failed: %s",
295153dbcc59SSundeep Panicker 		    topo_mod_errmsg(mod));
295253dbcc59SSundeep Panicker 		goto error;
295353dbcc59SSundeep Panicker 	}
295453dbcc59SSundeep Panicker 
295553dbcc59SSundeep Panicker 	for (scp = topo_list_next(&cp->sec_subchassis); scp != NULL;
295653dbcc59SSundeep Panicker 	    scp = topo_list_next(scp)) {
295753dbcc59SSundeep Panicker 
295853dbcc59SSundeep Panicker 		if (ses_create_subchassis(sdp, tn, scp) != 0)
295953dbcc59SSundeep Panicker 			goto error;
296053dbcc59SSundeep Panicker 
296153dbcc59SSundeep Panicker 		topo_mod_dprintf(mod, "created Subchassis node with "
2962ac88567aSHyon Kim 		    "instance %u\nand target (%s) under Chassis with CSN %s",
2963ac88567aSHyon Kim 		    scp->sec_instance, scp->sec_target->set_devpath,
2964ac88567aSHyon Kim 		    cp->sec_csn);
296553dbcc59SSundeep Panicker 
296653dbcc59SSundeep Panicker 		sc_count++;
296753dbcc59SSundeep Panicker 	}
296853dbcc59SSundeep Panicker 
296953dbcc59SSundeep Panicker 	topo_mod_dprintf(mod, "%s: created %llu %s nodes",
297053dbcc59SSundeep Panicker 	    cp->sec_csn, sc_count, SUBCHASSIS);
297153dbcc59SSundeep Panicker 
29726efb64caSEric Schrock 	cp->sec_target->set_refcount++;
29736efb64caSEric Schrock 	topo_node_setspecific(tn, cp->sec_target);
2974d91236feSeschrock 
2975940d71d2Seschrock 	ret = 0;
2976940d71d2Seschrock error:
2977940d71d2Seschrock 	topo_mod_strfree(mod, manufacturer);
2978940d71d2Seschrock 	topo_mod_strfree(mod, model);
2979940d71d2Seschrock 	topo_mod_strfree(mod, revision);
2980940d71d2Seschrock 	topo_mod_strfree(mod, product);
2981940d71d2Seschrock 
2982940d71d2Seschrock 	nvlist_free(fmri);
2983940d71d2Seschrock 	nvlist_free(auth);
2984940d71d2Seschrock 	return (ret);
2985940d71d2Seschrock }
2986940d71d2Seschrock 
2987d91236feSeschrock /*
2988d91236feSeschrock  * Create a bay node explicitly enumerated via XML.
2989d91236feSeschrock  */
2990d91236feSeschrock static int
2991d91236feSeschrock ses_create_bays(ses_enum_data_t *sdp, tnode_t *pnode)
2992d91236feSeschrock {
2993d91236feSeschrock 	topo_mod_t *mod = sdp->sed_mod;
2994d91236feSeschrock 	ses_enum_chassis_t *cp;
2995d91236feSeschrock 
2996d91236feSeschrock 	/*
2997d91236feSeschrock 	 * Iterate over chassis looking for an internal enclosure.  This
2998d91236feSeschrock 	 * property is set via a vendor-specific plugin, and there should only
2999d91236feSeschrock 	 * ever be a single internal chassis in a system.
3000d91236feSeschrock 	 */
3001d91236feSeschrock 	for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL;
3002d91236feSeschrock 	    cp = topo_list_next(cp)) {
3003d91236feSeschrock 		if (cp->sec_internal)
3004d91236feSeschrock 			break;
3005d91236feSeschrock 	}
3006d91236feSeschrock 
3007d91236feSeschrock 	if (cp == NULL) {
3008d91236feSeschrock 		topo_mod_dprintf(mod, "failed to find internal chassis\n");
3009d91236feSeschrock 		return (-1);
3010d91236feSeschrock 	}
3011d91236feSeschrock 
3012d91236feSeschrock 	if (ses_create_children(sdp, pnode, SES_ET_DEVICE,
3013d91236feSeschrock 	    BAY, "BAY", cp, B_FALSE) != 0 ||
3014d91236feSeschrock 	    ses_create_children(sdp, pnode, SES_ET_ARRAY_DEVICE,
3015d91236feSeschrock 	    BAY, "BAY", cp, B_FALSE) != 0)
3016d91236feSeschrock 		return (-1);
3017d91236feSeschrock 
3018d91236feSeschrock 	return (0);
3019d91236feSeschrock }
302053dbcc59SSundeep Panicker 
302153dbcc59SSundeep Panicker /*
302253dbcc59SSundeep Panicker  * Initialize chassis or subchassis.
302353dbcc59SSundeep Panicker  */
302453dbcc59SSundeep Panicker static int
302553dbcc59SSundeep Panicker ses_init_chassis(topo_mod_t *mod, ses_enum_data_t *sdp, ses_enum_chassis_t *pcp,
302653dbcc59SSundeep Panicker     ses_enum_chassis_t *cp, ses_node_t *np, nvlist_t *props,
3027ac88567aSHyon Kim     uint64_t subchassis, ses_chassis_type_e flags)
302853dbcc59SSundeep Panicker {
302953dbcc59SSundeep Panicker 	boolean_t internal, ident;
303053dbcc59SSundeep Panicker 
303153dbcc59SSundeep Panicker 	assert((flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS |
303253dbcc59SSundeep Panicker 	    SES_DUP_CHASSIS | SES_DUP_SUBCHASSIS)) != 0);
303353dbcc59SSundeep Panicker 
3034ac88567aSHyon Kim 	assert(cp != NULL);
3035ac88567aSHyon Kim 	assert(np != NULL);
3036ac88567aSHyon Kim 	assert(props != NULL);
303753dbcc59SSundeep Panicker 
303853dbcc59SSundeep Panicker 	if (flags & (SES_NEW_SUBCHASSIS | SES_DUP_SUBCHASSIS))
303953dbcc59SSundeep Panicker 		assert(pcp != NULL);
304053dbcc59SSundeep Panicker 
3041ac88567aSHyon Kim 	topo_mod_dprintf(mod, "ses_init_chassis: %s: index %llu, flags (%d)",
3042ac88567aSHyon Kim 	    sdp->sed_name, subchassis, flags);
304353dbcc59SSundeep Panicker 
304453dbcc59SSundeep Panicker 	if (flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS)) {
304553dbcc59SSundeep Panicker 
304653dbcc59SSundeep Panicker 		topo_mod_dprintf(mod, "new chassis/subchassis");
304753dbcc59SSundeep Panicker 		if (nvlist_lookup_boolean_value(props,
304853dbcc59SSundeep Panicker 		    LIBSES_EN_PROP_INTERNAL, &internal) == 0)
304953dbcc59SSundeep Panicker 			cp->sec_internal = internal;
305053dbcc59SSundeep Panicker 
305153dbcc59SSundeep Panicker 		cp->sec_enclosure = np;
305253dbcc59SSundeep Panicker 		cp->sec_target = sdp->sed_target;
305353dbcc59SSundeep Panicker 
305453dbcc59SSundeep Panicker 		if (flags & SES_NEW_CHASSIS) {
3055ac88567aSHyon Kim 			if (!cp->sec_internal)
3056ac88567aSHyon Kim 				cp->sec_instance = sdp->sed_instance++;
305753dbcc59SSundeep Panicker 			topo_list_append(&sdp->sed_chassis, cp);
305853dbcc59SSundeep Panicker 		} else {
3059ac88567aSHyon Kim 			if (subchassis != NO_SUBCHASSIS)
3060ac88567aSHyon Kim 				cp->sec_instance = subchassis;
3061ac88567aSHyon Kim 			else
3062ac88567aSHyon Kim 				cp->sec_instance = pcp->sec_scinstance++;
3063ac88567aSHyon Kim 
3064ac88567aSHyon Kim 			if (cp->sec_instance > pcp->sec_maxinstance)
3065ac88567aSHyon Kim 				pcp->sec_maxinstance = cp->sec_instance;
3066ac88567aSHyon Kim 
306753dbcc59SSundeep Panicker 			topo_list_append(&pcp->sec_subchassis, cp);
306853dbcc59SSundeep Panicker 		}
306953dbcc59SSundeep Panicker 
307053dbcc59SSundeep Panicker 	} else {
307153dbcc59SSundeep Panicker 		topo_mod_dprintf(mod, "dup chassis/subchassis");
307253dbcc59SSundeep Panicker 		if (nvlist_lookup_boolean_value(props,
307353dbcc59SSundeep Panicker 		    SES_PROP_IDENT, &ident) == 0) {
307453dbcc59SSundeep Panicker 			topo_mod_dprintf(mod,  "overriding enclosure node");
307553dbcc59SSundeep Panicker 
307653dbcc59SSundeep Panicker 			cp->sec_enclosure = np;
307753dbcc59SSundeep Panicker 			cp->sec_target = sdp->sed_target;
307853dbcc59SSundeep Panicker 		}
307953dbcc59SSundeep Panicker 	}
308053dbcc59SSundeep Panicker 
308153dbcc59SSundeep Panicker 	topo_list_append(&cp->sec_targets, sdp->sed_target);
308253dbcc59SSundeep Panicker 	sdp->sed_current = cp;
308353dbcc59SSundeep Panicker 
308453dbcc59SSundeep Panicker 	return (0);
308553dbcc59SSundeep Panicker }
308653dbcc59SSundeep Panicker 
3087940d71d2Seschrock /*
3088940d71d2Seschrock  * Gather nodes from the current SES target into our chassis list, merging the
3089940d71d2Seschrock  * results if necessary.
3090940d71d2Seschrock  */
3091940d71d2Seschrock static ses_walk_action_t
3092940d71d2Seschrock ses_enum_gather(ses_node_t *np, void *data)
3093940d71d2Seschrock {
3094940d71d2Seschrock 	nvlist_t *props = ses_node_props(np);
3095940d71d2Seschrock 	ses_enum_data_t *sdp = data;
3096940d71d2Seschrock 	topo_mod_t *mod = sdp->sed_mod;
309753dbcc59SSundeep Panicker 	ses_enum_chassis_t *cp, *scp;
3098940d71d2Seschrock 	ses_enum_node_t *snp;
30990b32bb8bSEric Schrock 	ses_alt_node_t *sap;
3100940d71d2Seschrock 	char *csn;
3101940d71d2Seschrock 	uint64_t instance, type;
3102d91236feSeschrock 	uint64_t prevstatus, status;
310353dbcc59SSundeep Panicker 	boolean_t report;
3104ac88567aSHyon Kim 	uint64_t subchassis = NO_SUBCHASSIS;
3105940d71d2Seschrock 
3106940d71d2Seschrock 	if (ses_node_type(np) == SES_NODE_ENCLOSURE) {
3107940d71d2Seschrock 		/*
3108940d71d2Seschrock 		 * If we have already identified the chassis for this target,
3109940d71d2Seschrock 		 * then this is a secondary enclosure and we should ignore it,
3110940d71d2Seschrock 		 * along with the rest of the tree (since this is depth-first).
3111940d71d2Seschrock 		 */
3112940d71d2Seschrock 		if (sdp->sed_current != NULL)
3113940d71d2Seschrock 			return (SES_WALK_ACTION_TERMINATE);
3114940d71d2Seschrock 
3115940d71d2Seschrock 		/*
3116940d71d2Seschrock 		 * Go through the list of chassis we have seen so far and see
3117940d71d2Seschrock 		 * if this serial number matches one of the known values.
311853dbcc59SSundeep Panicker 		 * If so, check whether this enclosure is a subchassis.
3119940d71d2Seschrock 		 */
3120940d71d2Seschrock 		if (nvlist_lookup_string(props, LIBSES_EN_PROP_CSN,
3121940d71d2Seschrock 		    &csn) != 0)
3122940d71d2Seschrock 			return (SES_WALK_ACTION_TERMINATE);
3123940d71d2Seschrock 
3124ac88567aSHyon Kim 		(void) nvlist_lookup_uint64(props, LIBSES_EN_PROP_SUBCHASSIS_ID,
3125ac88567aSHyon Kim 		    &subchassis);
312653dbcc59SSundeep Panicker 
312753dbcc59SSundeep Panicker 		topo_mod_dprintf(mod, "ses_enum_gather: Enclosure Node (%s) "
3128ac88567aSHyon Kim 		    "CSN (%s), subchassis (%llu)", sdp->sed_name, csn,
3129ac88567aSHyon Kim 		    subchassis);
313053dbcc59SSundeep Panicker 
313153dbcc59SSundeep Panicker 		/*
313253dbcc59SSundeep Panicker 		 * We need to determine whether this enclosure node
313353dbcc59SSundeep Panicker 		 * represents a chassis or a subchassis. Since we may
313453dbcc59SSundeep Panicker 		 * receive the enclosure nodes in a non-deterministic
313553dbcc59SSundeep Panicker 		 * manner, we need to account for all possible combinations:
313653dbcc59SSundeep Panicker 		 *	1. Chassis for the current CSN has not yet been
313753dbcc59SSundeep Panicker 		 *	   allocated
313853dbcc59SSundeep Panicker 		 *		1.1 This is a new chassis:
313953dbcc59SSundeep Panicker 		 *			allocate and instantiate the chassis
314053dbcc59SSundeep Panicker 		 *		1.2 This is a new subchassis:
314153dbcc59SSundeep Panicker 		 *			allocate a placeholder chassis
314253dbcc59SSundeep Panicker 		 *			allocate and instantiate the subchassis
314353dbcc59SSundeep Panicker 		 *			link the subchassis to the chassis
314453dbcc59SSundeep Panicker 		 *	2. Chassis for the current CSN has been allocated
314553dbcc59SSundeep Panicker 		 *		2.1 This is a duplicate chassis enclosure
314653dbcc59SSundeep Panicker 		 *			check whether to override old chassis
314753dbcc59SSundeep Panicker 		 *			append to chassis' target list
314853dbcc59SSundeep Panicker 		 *		2.2 Only placeholder chassis exists
314953dbcc59SSundeep Panicker 		 *			fill in the chassis fields
315053dbcc59SSundeep Panicker 		 *		2.3 This is a new subchassis
315153dbcc59SSundeep Panicker 		 *			allocate and instantiate the subchassis
315253dbcc59SSundeep Panicker 		 *			link the subchassis to the chassis
315353dbcc59SSundeep Panicker 		 *		2.4 This is a duplicate subchassis enclosure
315453dbcc59SSundeep Panicker 		 *			 check whether to override old chassis
315553dbcc59SSundeep Panicker 		 *			 append to chassis' target list
315653dbcc59SSundeep Panicker 		 */
315753dbcc59SSundeep Panicker 
3158940d71d2Seschrock 		for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL;
315953dbcc59SSundeep Panicker 		    cp = topo_list_next(cp))
316053dbcc59SSundeep Panicker 			if (strcmp(cp->sec_csn, csn) == 0)
3161940d71d2Seschrock 				break;
3162940d71d2Seschrock 
3163940d71d2Seschrock 		if (cp == NULL) {
316453dbcc59SSundeep Panicker 			/* 1. Haven't seen a chassis with this CSN before */
3165940d71d2Seschrock 
3166940d71d2Seschrock 			if ((cp = topo_mod_zalloc(mod,
3167940d71d2Seschrock 			    sizeof (ses_enum_chassis_t))) == NULL)
3168940d71d2Seschrock 				goto error;
3169940d71d2Seschrock 
3170ac88567aSHyon Kim 			cp->sec_scinstance = SES_STARTING_SUBCHASSIS;
3171ac88567aSHyon Kim 			cp->sec_maxinstance = -1;
3172940d71d2Seschrock 			cp->sec_csn = csn;
317353dbcc59SSundeep Panicker 
3174ac88567aSHyon Kim 			if (subchassis == NO_SUBCHASSIS) {
317553dbcc59SSundeep Panicker 				/* 1.1 This is a new chassis */
317653dbcc59SSundeep Panicker 
317753dbcc59SSundeep Panicker 				topo_mod_dprintf(mod, "%s: Initialize new "
3178ac88567aSHyon Kim 				    "chassis with CSN %s", sdp->sed_name, csn);
317953dbcc59SSundeep Panicker 
318053dbcc59SSundeep Panicker 				if (ses_init_chassis(mod, sdp, NULL, cp,
3181ac88567aSHyon Kim 				    np, props, NO_SUBCHASSIS,
3182ac88567aSHyon Kim 				    SES_NEW_CHASSIS) < 0)
318353dbcc59SSundeep Panicker 					goto error;
318453dbcc59SSundeep Panicker 			} else {
318553dbcc59SSundeep Panicker 				/* 1.2 This is a new subchassis */
318653dbcc59SSundeep Panicker 
318753dbcc59SSundeep Panicker 				topo_mod_dprintf(mod, "%s: Initialize new "
3188ac88567aSHyon Kim 				    "subchassis with CSN %s and index %llu",
3189ac88567aSHyon Kim 				    sdp->sed_name, csn, subchassis);
319053dbcc59SSundeep Panicker 
319153dbcc59SSundeep Panicker 				if ((scp = topo_mod_zalloc(mod,
319253dbcc59SSundeep Panicker 				    sizeof (ses_enum_chassis_t))) == NULL)
319353dbcc59SSundeep Panicker 					goto error;
319453dbcc59SSundeep Panicker 
319553dbcc59SSundeep Panicker 				scp->sec_csn = csn;
319653dbcc59SSundeep Panicker 
3197ac88567aSHyon Kim 				if (ses_init_chassis(mod, sdp, cp, scp, np,
3198ac88567aSHyon Kim 				    props, subchassis, SES_NEW_SUBCHASSIS) < 0)
319953dbcc59SSundeep Panicker 					goto error;
320053dbcc59SSundeep Panicker 			}
32016efb64caSEric Schrock 		} else {
3202ac88567aSHyon Kim 			/*
3203ac88567aSHyon Kim 			 * We have a chassis or subchassis with this CSN.  If
3204ac88567aSHyon Kim 			 * it's a chassis, we must check to see whether it is
3205ac88567aSHyon Kim 			 * a placeholder previously created because we found a
3206ac88567aSHyon Kim 			 * subchassis with this CSN.  We will know that because
3207ac88567aSHyon Kim 			 * the sec_target value will not be set; it is set only
3208ac88567aSHyon Kim 			 * in ses_init_chassis().  In that case, initialise it
3209ac88567aSHyon Kim 			 * as a new chassis; otherwise, it's a duplicate and we
3210ac88567aSHyon Kim 			 * need to append only.
3211ac88567aSHyon Kim 			 */
3212ac88567aSHyon Kim 			if (subchassis == NO_SUBCHASSIS) {
3213ac88567aSHyon Kim 				if (cp->sec_target != NULL) {
321453dbcc59SSundeep Panicker 					/* 2.1 This is a duplicate chassis */
321553dbcc59SSundeep Panicker 
321653dbcc59SSundeep Panicker 					topo_mod_dprintf(mod, "%s: Append "
3217ac88567aSHyon Kim 					    "duplicate chassis with CSN (%s)",
3218ac88567aSHyon Kim 					    sdp->sed_name, csn);
321953dbcc59SSundeep Panicker 
322053dbcc59SSundeep Panicker 					if (ses_init_chassis(mod, sdp, NULL, cp,
3221ac88567aSHyon Kim 					    np, props, NO_SUBCHASSIS,
322253dbcc59SSundeep Panicker 					    SES_DUP_CHASSIS) < 0)
322353dbcc59SSundeep Panicker 						goto error;
322453dbcc59SSundeep Panicker 				} else {
3225ac88567aSHyon Kim 					/* Placeholder chassis - init it up */
322653dbcc59SSundeep Panicker 					topo_mod_dprintf(mod, "%s: Initialize"
3227ac88567aSHyon Kim 					    "placeholder chassis with CSN %s",
3228ac88567aSHyon Kim 					    sdp->sed_name, csn);
322953dbcc59SSundeep Panicker 
3230ac88567aSHyon Kim 					if (ses_init_chassis(mod, sdp, NULL,
3231ac88567aSHyon Kim 					    cp, np, props, NO_SUBCHASSIS,
323253dbcc59SSundeep Panicker 					    SES_NEW_CHASSIS) < 0)
323353dbcc59SSundeep Panicker 						goto error;
323453dbcc59SSundeep Panicker 
323553dbcc59SSundeep Panicker 				}
323653dbcc59SSundeep Panicker 			} else {
323753dbcc59SSundeep Panicker 				/* This is a subchassis */
323853dbcc59SSundeep Panicker 
323953dbcc59SSundeep Panicker 				for (scp = topo_list_next(&cp->sec_subchassis);
324053dbcc59SSundeep Panicker 				    scp != NULL; scp = topo_list_next(scp))
3241ac88567aSHyon Kim 					if (scp->sec_instance == subchassis)
324253dbcc59SSundeep Panicker 						break;
324353dbcc59SSundeep Panicker 
324453dbcc59SSundeep Panicker 				if (scp == NULL) {
324553dbcc59SSundeep Panicker 					/* 2.3 This is a new subchassis */
324653dbcc59SSundeep Panicker 
324753dbcc59SSundeep Panicker 					topo_mod_dprintf(mod, "%s: Initialize "
324853dbcc59SSundeep Panicker 					    "new subchassis with CSN (%s) "
324953dbcc59SSundeep Panicker 					    "and LID (%s)",
3250ac88567aSHyon Kim 					    sdp->sed_name, csn);
325153dbcc59SSundeep Panicker 
325253dbcc59SSundeep Panicker 					if ((scp = topo_mod_zalloc(mod,
325353dbcc59SSundeep Panicker 					    sizeof (ses_enum_chassis_t)))
325453dbcc59SSundeep Panicker 					    == NULL)
325553dbcc59SSundeep Panicker 						goto error;
325653dbcc59SSundeep Panicker 
325753dbcc59SSundeep Panicker 					scp->sec_csn = csn;
325853dbcc59SSundeep Panicker 
325953dbcc59SSundeep Panicker 					if (ses_init_chassis(mod, sdp, cp, scp,
3260ac88567aSHyon Kim 					    np, props, subchassis,
326153dbcc59SSundeep Panicker 					    SES_NEW_SUBCHASSIS) < 0)
326253dbcc59SSundeep Panicker 						goto error;
326353dbcc59SSundeep Panicker 				} else {
326453dbcc59SSundeep Panicker 					/* 2.4 This is a duplicate subchassis */
326553dbcc59SSundeep Panicker 
326653dbcc59SSundeep Panicker 					topo_mod_dprintf(mod, "%s: Append "
326753dbcc59SSundeep Panicker 					    "duplicate subchassis with "
3268ac88567aSHyon Kim 					    "CSN (%s)", sdp->sed_name, csn);
326953dbcc59SSundeep Panicker 
327053dbcc59SSundeep Panicker 					if (ses_init_chassis(mod, sdp, cp, scp,
3271ac88567aSHyon Kim 					    np, props, subchassis,
327253dbcc59SSundeep Panicker 					    SES_DUP_SUBCHASSIS) < 0)
327353dbcc59SSundeep Panicker 						goto error;
327453dbcc59SSundeep Panicker 				}
32756efb64caSEric Schrock 			}
3276940d71d2Seschrock 		}
3277940d71d2Seschrock 	} else if (ses_node_type(np) == SES_NODE_ELEMENT) {
3278940d71d2Seschrock 		/*
3279940d71d2Seschrock 		 * If we haven't yet seen an enclosure node and identified the
3280940d71d2Seschrock 		 * current chassis, something is very wrong; bail out.
3281940d71d2Seschrock 		 */
3282940d71d2Seschrock 		if (sdp->sed_current == NULL)
3283940d71d2Seschrock 			return (SES_WALK_ACTION_TERMINATE);
3284940d71d2Seschrock 
3285940d71d2Seschrock 		/*
3286940d71d2Seschrock 		 * If this isn't one of the element types we care about, then
3287940d71d2Seschrock 		 * ignore it.
3288940d71d2Seschrock 		 */
3289940d71d2Seschrock 		verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_TYPE,
3290940d71d2Seschrock 		    &type) == 0);
3291940d71d2Seschrock 		if (type != SES_ET_DEVICE &&
3292940d71d2Seschrock 		    type != SES_ET_ARRAY_DEVICE &&
3293ded93414SHyon Kim 		    type != SES_ET_SUNW_FANBOARD &&
3294ded93414SHyon Kim 		    type != SES_ET_SUNW_FANMODULE &&
3295940d71d2Seschrock 		    type != SES_ET_COOLING &&
3296ded93414SHyon Kim 		    type != SES_ET_SUNW_POWERBOARD &&
3297ded93414SHyon Kim 		    type != SES_ET_SUNW_POWERMODULE &&
3298940d71d2Seschrock 		    type != SES_ET_POWER_SUPPLY &&
3299ac88567aSHyon Kim 		    type != SES_ET_ESC_ELECTRONICS &&
3300ac88567aSHyon Kim 		    type != SES_ET_SAS_EXPANDER &&
3301ac88567aSHyon Kim 		    type != SES_ET_SAS_CONNECTOR)
3302940d71d2Seschrock 			return (SES_WALK_ACTION_CONTINUE);
3303940d71d2Seschrock 
3304940d71d2Seschrock 		/*
3305940d71d2Seschrock 		 * Get the current instance number and see if we already know
3306940d71d2Seschrock 		 * about this element.  If so, it means we have multiple paths
3307940d71d2Seschrock 		 * to the same elements, and we should ignore the current path.
3308940d71d2Seschrock 		 */
3309940d71d2Seschrock 		verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_CLASS_INDEX,
3310940d71d2Seschrock 		    &instance) == 0);
3311940d71d2Seschrock 		if (type == SES_ET_DEVICE || type == SES_ET_ARRAY_DEVICE)
3312940d71d2Seschrock 			(void) nvlist_lookup_uint64(props, SES_PROP_BAY_NUMBER,
3313940d71d2Seschrock 			    &instance);
3314940d71d2Seschrock 
3315940d71d2Seschrock 		cp = sdp->sed_current;
3316940d71d2Seschrock 
3317940d71d2Seschrock 		for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
3318940d71d2Seschrock 		    snp = topo_list_next(snp)) {
3319940d71d2Seschrock 			if (snp->sen_type == type &&
3320940d71d2Seschrock 			    snp->sen_instance == instance)
3321d91236feSeschrock 				break;
3322d91236feSeschrock 		}
3323d91236feSeschrock 
3324d91236feSeschrock 		/*
3325d91236feSeschrock 		 * We prefer the new element under the following circumstances:
3326d91236feSeschrock 		 *
3327d91236feSeschrock 		 * - The currently known element's status is unknown or not
3328d91236feSeschrock 		 *   available, but the new element has a known status.  This
3329d91236feSeschrock 		 *   occurs if a given element is only available through a
3330d91236feSeschrock 		 *   particular target.
3331d91236feSeschrock 		 *
3332d91236feSeschrock 		 * - This is an ESC_ELECTRONICS element, and the 'reported-via'
3333d91236feSeschrock 		 *   property is set.  This allows us to get reliable firmware
3334d91236feSeschrock 		 *   revision information from the enclosure node.
3335d91236feSeschrock 		 */
3336d91236feSeschrock 		if (snp != NULL) {
3337d91236feSeschrock 			if (nvlist_lookup_uint64(
3338d91236feSeschrock 			    ses_node_props(snp->sen_node),
3339d91236feSeschrock 			    SES_PROP_STATUS_CODE, &prevstatus) != 0)
3340d91236feSeschrock 				prevstatus = SES_ESC_UNSUPPORTED;
3341d91236feSeschrock 			if (nvlist_lookup_uint64(
3342d91236feSeschrock 			    props, SES_PROP_STATUS_CODE, &status) != 0)
3343d91236feSeschrock 				status = SES_ESC_UNSUPPORTED;
3344d91236feSeschrock 			if (nvlist_lookup_boolean_value(
3345d91236feSeschrock 			    props, SES_PROP_REPORT, &report) != 0)
3346d91236feSeschrock 				report = B_FALSE;
3347d91236feSeschrock 
3348d91236feSeschrock 			if ((SES_STATUS_UNAVAIL(prevstatus) &&
3349d91236feSeschrock 			    !SES_STATUS_UNAVAIL(status)) ||
3350d91236feSeschrock 			    (type == SES_ET_ESC_ELECTRONICS &&
3351d91236feSeschrock 			    report)) {
3352d91236feSeschrock 				snp->sen_node = np;
3353d91236feSeschrock 				snp->sen_target = sdp->sed_target;
3354d91236feSeschrock 			}
3355d91236feSeschrock 
33560b32bb8bSEric Schrock 			if ((sap = topo_mod_zalloc(mod,
33570b32bb8bSEric Schrock 			    sizeof (ses_alt_node_t))) == NULL)
33580b32bb8bSEric Schrock 				goto error;
33590b32bb8bSEric Schrock 
33600b32bb8bSEric Schrock 			sap->san_node = np;
33610b32bb8bSEric Schrock 			topo_list_append(&snp->sen_alt_nodes, sap);
33620b32bb8bSEric Schrock 
3363d91236feSeschrock 			return (SES_WALK_ACTION_CONTINUE);
3364940d71d2Seschrock 		}
3365940d71d2Seschrock 
3366940d71d2Seschrock 		if ((snp = topo_mod_zalloc(mod,
3367940d71d2Seschrock 		    sizeof (ses_enum_node_t))) == NULL)
3368940d71d2Seschrock 			goto error;
3369940d71d2Seschrock 
33700b32bb8bSEric Schrock 		if ((sap = topo_mod_zalloc(mod,
33710b32bb8bSEric Schrock 		    sizeof (ses_alt_node_t))) == NULL) {
33720b32bb8bSEric Schrock 			topo_mod_free(mod, snp, sizeof (ses_enum_node_t));
33730b32bb8bSEric Schrock 			goto error;
33740b32bb8bSEric Schrock 		}
33750b32bb8bSEric Schrock 
3376940d71d2Seschrock 		topo_mod_dprintf(mod, "%s: adding node (%llu, %llu)",
3377940d71d2Seschrock 		    sdp->sed_name, type, instance);
3378940d71d2Seschrock 		snp->sen_node = np;
3379940d71d2Seschrock 		snp->sen_type = type;
3380940d71d2Seschrock 		snp->sen_instance = instance;
3381940d71d2Seschrock 		snp->sen_target = sdp->sed_target;
33820b32bb8bSEric Schrock 		sap->san_node = np;
33830b32bb8bSEric Schrock 		topo_list_append(&snp->sen_alt_nodes, sap);
3384940d71d2Seschrock 		topo_list_append(&cp->sec_nodes, snp);
3385940d71d2Seschrock 
3386940d71d2Seschrock 		if (type == SES_ET_DEVICE)
3387940d71d2Seschrock 			cp->sec_hasdev = B_TRUE;
3388940d71d2Seschrock 	}
3389940d71d2Seschrock 
3390940d71d2Seschrock 	return (SES_WALK_ACTION_CONTINUE);
3391940d71d2Seschrock 
3392940d71d2Seschrock error:
3393940d71d2Seschrock 	sdp->sed_errno = -1;
3394940d71d2Seschrock 	return (SES_WALK_ACTION_TERMINATE);
3395940d71d2Seschrock }
3396940d71d2Seschrock 
3397940d71d2Seschrock static int
3398940d71d2Seschrock ses_process_dir(const char *dirpath, ses_enum_data_t *sdp)
3399940d71d2Seschrock {
3400940d71d2Seschrock 	topo_mod_t *mod = sdp->sed_mod;
3401940d71d2Seschrock 	DIR *dir;
3402940d71d2Seschrock 	struct dirent *dp;
3403940d71d2Seschrock 	char path[PATH_MAX];
3404940d71d2Seschrock 	ses_enum_target_t *stp;
3405940d71d2Seschrock 	int err = -1;
3406940d71d2Seschrock 
3407940d71d2Seschrock 	/*
3408940d71d2Seschrock 	 * Open the SES target directory and iterate over any available
3409940d71d2Seschrock 	 * targets.
3410940d71d2Seschrock 	 */
3411940d71d2Seschrock 	if ((dir = opendir(dirpath)) == NULL) {
3412940d71d2Seschrock 		/*
3413940d71d2Seschrock 		 * If the SES target directory does not exist, then return as if
3414940d71d2Seschrock 		 * there are no active targets.
3415940d71d2Seschrock 		 */
3416940d71d2Seschrock 		topo_mod_dprintf(mod, "failed to open ses "
3417940d71d2Seschrock 		    "directory '%s'", dirpath);
3418940d71d2Seschrock 		return (0);
3419940d71d2Seschrock 	}
3420940d71d2Seschrock 
3421940d71d2Seschrock 	while ((dp = readdir(dir)) != NULL) {
3422940d71d2Seschrock 		if (strcmp(dp->d_name, ".") == 0 ||
3423940d71d2Seschrock 		    strcmp(dp->d_name, "..") == 0)
3424940d71d2Seschrock 			continue;
3425940d71d2Seschrock 
3426940d71d2Seschrock 		/*
3427940d71d2Seschrock 		 * Create a new target instance and take a snapshot.
3428940d71d2Seschrock 		 */
3429940d71d2Seschrock 		if ((stp = topo_mod_zalloc(mod,
3430940d71d2Seschrock 		    sizeof (ses_enum_target_t))) == NULL)
3431940d71d2Seschrock 			goto error;
3432940d71d2Seschrock 
34330b32bb8bSEric Schrock 		(void) pthread_mutex_init(&stp->set_lock, NULL);
34340b32bb8bSEric Schrock 
3435940d71d2Seschrock 		(void) snprintf(path, sizeof (path), "%s/%s", dirpath,
3436940d71d2Seschrock 		    dp->d_name);
3437940d71d2Seschrock 
3438940d71d2Seschrock 		/*
3439940d71d2Seschrock 		 * We keep track of the SES device path and export it on a
3440940d71d2Seschrock 		 * per-node basis to allow higher level software to get to the
3441940d71d2Seschrock 		 * corresponding SES state.
3442940d71d2Seschrock 		 */
3443940d71d2Seschrock 		if ((stp->set_devpath = topo_mod_strdup(mod, path)) == NULL) {
3444940d71d2Seschrock 			topo_mod_free(mod, stp, sizeof (ses_enum_target_t));
3445940d71d2Seschrock 			goto error;
3446940d71d2Seschrock 		}
3447940d71d2Seschrock 
3448940d71d2Seschrock 		if ((stp->set_target =
3449940d71d2Seschrock 		    ses_open(LIBSES_VERSION, path)) == NULL) {
3450940d71d2Seschrock 			topo_mod_dprintf(mod, "failed to open ses target "
3451940d71d2Seschrock 			    "'%s': %s", dp->d_name, ses_errmsg());
3452f76de749SStephen Hanson 			ses_sof_alloc(mod, stp->set_devpath);
3453940d71d2Seschrock 			topo_mod_free(mod, stp, sizeof (ses_enum_target_t));
3454940d71d2Seschrock 			continue;
3455940d71d2Seschrock 		}
3456f76de749SStephen Hanson 		topo_mod_dprintf(mod, "open contract");
3457f76de749SStephen Hanson 		ses_ssl_alloc(mod, stp);
3458f76de749SStephen Hanson 		ses_create_contract(mod, stp);
3459940d71d2Seschrock 
3460940d71d2Seschrock 		stp->set_refcount = 1;
3461940d71d2Seschrock 		sdp->sed_target = stp;
3462940d71d2Seschrock 		stp->set_snap = ses_snap_hold(stp->set_target);
3463525b85dbSEric Schrock 		stp->set_snaptime = gethrtime();
3464940d71d2Seschrock 
3465940d71d2Seschrock 		/*
3466940d71d2Seschrock 		 * Enumerate over all SES elements and merge them into the
3467940d71d2Seschrock 		 * correct ses_enum_chassis_t.
3468940d71d2Seschrock 		 */
3469940d71d2Seschrock 		sdp->sed_current = NULL;
3470940d71d2Seschrock 		sdp->sed_errno = 0;
3471940d71d2Seschrock 		sdp->sed_name = dp->d_name;
3472940d71d2Seschrock 		(void) ses_walk(stp->set_snap, ses_enum_gather, sdp);
3473940d71d2Seschrock 
3474940d71d2Seschrock 		if (sdp->sed_errno != 0)
3475940d71d2Seschrock 			goto error;
3476940d71d2Seschrock 	}
3477940d71d2Seschrock 
3478940d71d2Seschrock 	err = 0;
3479940d71d2Seschrock error:
3480*edb433b6SMilan Jurik 	(void) closedir(dir);
3481940d71d2Seschrock 	return (err);
3482940d71d2Seschrock }
3483940d71d2Seschrock 
3484940d71d2Seschrock static void
3485940d71d2Seschrock ses_release(topo_mod_t *mod, tnode_t *tn)
3486940d71d2Seschrock {
3487940d71d2Seschrock 	ses_enum_target_t *stp;
3488940d71d2Seschrock 
3489f76de749SStephen Hanson 	if ((stp = topo_node_getspecific(tn)) != NULL) {
3490f76de749SStephen Hanson 		topo_node_setspecific(tn, NULL);
3491940d71d2Seschrock 		ses_target_free(mod, stp);
3492f76de749SStephen Hanson 	}
3493940d71d2Seschrock }
3494940d71d2Seschrock 
3495940d71d2Seschrock /*ARGSUSED*/
3496940d71d2Seschrock static int
3497940d71d2Seschrock ses_enum(topo_mod_t *mod, tnode_t *rnode, const char *name,
3498940d71d2Seschrock     topo_instance_t min, topo_instance_t max, void *arg, void *notused)
3499940d71d2Seschrock {
3500940d71d2Seschrock 	ses_enum_chassis_t *cp;
3501d91236feSeschrock 	ses_enum_data_t *data;
3502940d71d2Seschrock 
3503940d71d2Seschrock 	/*
3504940d71d2Seschrock 	 * Check to make sure we're being invoked sensibly, and that we're not
3505940d71d2Seschrock 	 * being invoked as part of a post-processing step.
3506940d71d2Seschrock 	 */
3507d91236feSeschrock 	if (strcmp(name, SES_ENCLOSURE) != 0 && strcmp(name, BAY) != 0)
3508940d71d2Seschrock 		return (0);
3509940d71d2Seschrock 
3510940d71d2Seschrock 	/*
3511d91236feSeschrock 	 * If this is the first time we've called our enumeration method, then
3512d91236feSeschrock 	 * gather information about any available enclosures.
3513940d71d2Seschrock 	 */
3514d91236feSeschrock 	if ((data = topo_mod_getspecific(mod)) == NULL) {
3515f76de749SStephen Hanson 		ses_sof_freeall(mod);
3516d91236feSeschrock 		if ((data = topo_mod_zalloc(mod, sizeof (ses_enum_data_t))) ==
3517d91236feSeschrock 		    NULL)
3518d91236feSeschrock 			return (-1);
3519940d71d2Seschrock 
3520d91236feSeschrock 		data->sed_mod = mod;
3521d91236feSeschrock 		topo_mod_setspecific(mod, data);
3522d91236feSeschrock 
3523ac88567aSHyon Kim 		if (dev_list_gather(mod, &data->sed_devs) != 0)
3524d91236feSeschrock 			goto error;
3525d91236feSeschrock 
3526d91236feSeschrock 		/*
3527d91236feSeschrock 		 * We search both the ses(7D) and sgen(7D) locations, so we are
3528d91236feSeschrock 		 * independent of any particular driver class bindings.
3529d91236feSeschrock 		 */
3530d91236feSeschrock 		if (ses_process_dir("/dev/es", data) != 0 ||
3531d91236feSeschrock 		    ses_process_dir("/dev/scsi/ses", data) != 0)
3532d91236feSeschrock 			goto error;
3533d91236feSeschrock 	}
3534d91236feSeschrock 
3535d91236feSeschrock 	if (strcmp(name, SES_ENCLOSURE) == 0) {
3536d91236feSeschrock 		/*
3537d91236feSeschrock 		 * This is a request to enumerate external enclosures.  Go
3538d91236feSeschrock 		 * through all the targets and create chassis nodes where
3539d91236feSeschrock 		 * necessary.
3540d91236feSeschrock 		 */
3541d91236feSeschrock 		for (cp = topo_list_next(&data->sed_chassis); cp != NULL;
3542d91236feSeschrock 		    cp = topo_list_next(cp)) {
3543d91236feSeschrock 			if (ses_create_chassis(data, rnode, cp) != 0)
3544d91236feSeschrock 				goto error;
3545d91236feSeschrock 		}
3546d91236feSeschrock 	} else {
3547d91236feSeschrock 		/*
3548d91236feSeschrock 		 * This is a request to enumerate a specific bay underneath the
3549d91236feSeschrock 		 * root chassis (for internal disks).
3550d91236feSeschrock 		 */
3551d91236feSeschrock 		if (ses_create_bays(data, rnode) != 0)
3552940d71d2Seschrock 			goto error;
3553940d71d2Seschrock 	}
3554940d71d2Seschrock 
3555d91236feSeschrock 	/*
3556d91236feSeschrock 	 * This is a bit of a kludge.  In order to allow internal disks to be
3557d91236feSeschrock 	 * enumerated and share snapshot-specific information with the external
3558d91236feSeschrock 	 * enclosure enumeration, we rely on the fact that we will be invoked
3559d91236feSeschrock 	 * for the 'ses-enclosure' node last.
3560d91236feSeschrock 	 */
3561d91236feSeschrock 	if (strcmp(name, SES_ENCLOSURE) == 0) {
356253dbcc59SSundeep Panicker 		for (cp = topo_list_next(&data->sed_chassis); cp != NULL;
356353dbcc59SSundeep Panicker 		    cp = topo_list_next(cp))
356453dbcc59SSundeep Panicker 			ses_data_free(data, cp);
356553dbcc59SSundeep Panicker 		ses_data_free(data, NULL);
3566d91236feSeschrock 		topo_mod_setspecific(mod, NULL);
3567d91236feSeschrock 	}
3568940d71d2Seschrock 	return (0);
3569940d71d2Seschrock 
3570940d71d2Seschrock error:
357153dbcc59SSundeep Panicker 	for (cp = topo_list_next(&data->sed_chassis); cp != NULL;
357253dbcc59SSundeep Panicker 	    cp = topo_list_next(cp))
357353dbcc59SSundeep Panicker 		ses_data_free(data, cp);
357453dbcc59SSundeep Panicker 	ses_data_free(data, NULL);
3575d91236feSeschrock 	topo_mod_setspecific(mod, NULL);
3576940d71d2Seschrock 	return (-1);
3577940d71d2Seschrock }
3578940d71d2Seschrock 
3579940d71d2Seschrock static const topo_modops_t ses_ops =
3580940d71d2Seschrock 	{ ses_enum, ses_release };
3581940d71d2Seschrock 
3582940d71d2Seschrock static topo_modinfo_t ses_info =
3583940d71d2Seschrock 	{ SES_ENCLOSURE, FM_FMRI_SCHEME_HC, SES_VERSION, &ses_ops };
3584940d71d2Seschrock 
3585940d71d2Seschrock /*ARGSUSED*/
3586940d71d2Seschrock int
3587940d71d2Seschrock _topo_init(topo_mod_t *mod, topo_version_t version)
3588940d71d2Seschrock {
3589f76de749SStephen Hanson 	int rval;
3590f76de749SStephen Hanson 
3591940d71d2Seschrock 	if (getenv("TOPOSESDEBUG") != NULL)
3592940d71d2Seschrock 		topo_mod_setdebug(mod);
3593940d71d2Seschrock 
3594940d71d2Seschrock 	topo_mod_dprintf(mod, "initializing %s enumerator\n",
3595940d71d2Seschrock 	    SES_ENCLOSURE);
3596940d71d2Seschrock 
3597f76de749SStephen Hanson 	if ((rval = topo_mod_register(mod, &ses_info, TOPO_VERSION)) == 0)
3598f76de749SStephen Hanson 		ses_thread_init(mod);
3599f76de749SStephen Hanson 
3600f76de749SStephen Hanson 	return (rval);
3601940d71d2Seschrock }
3602940d71d2Seschrock 
3603940d71d2Seschrock void
3604940d71d2Seschrock _topo_fini(topo_mod_t *mod)
3605940d71d2Seschrock {
360605b58617SStephen Hanson 	ses_thread_fini(mod);
3607f76de749SStephen Hanson 	ses_sof_freeall(mod);
3608940d71d2Seschrock 	topo_mod_unregister(mod);
3609940d71d2Seschrock }
3610