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