1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2012 Milan Jurik. All rights reserved.
25 * Copyright 2017 Nexenta Systems, Inc. All rights reserved.
26 * Copyright (c) 2017, Joyent, Inc.
27 */
28
29 #include <alloca.h>
30 #include <dirent.h>
31 #include <devid.h>
32 #include <fm/libdiskstatus.h>
33 #include <inttypes.h>
34 #include <pthread.h>
35 #include <strings.h>
36 #include <string.h>
37 #include <unistd.h>
38 #include <sys/dkio.h>
39 #include <sys/fm/protocol.h>
40 #include <sys/libdevid.h>
41 #include <sys/scsi/scsi_types.h>
42 #include <sys/byteorder.h>
43 #include <pthread.h>
44 #include <signal.h>
45 #include <fcntl.h>
46 #include <sys/ctfs.h>
47 #include <libcontract.h>
48 #include <poll.h>
49 #include <sys/contract/device.h>
50 #include <libsysevent.h>
51 #include <sys/sysevent/eventdefs.h>
52 #include <scsi/plugins/ses/vendor/sun.h>
53
54 #include "disk.h"
55 #include "ses.h"
56
57 #define SES_VERSION 1
58
59 #define SES_STARTING_SUBCHASSIS 256 /* valid subchassis IDs are uint8_t */
60 #define NO_SUBCHASSIS ((uint64_t)-1)
61
62 static int ses_snap_freq = 250; /* in milliseconds */
63
64 #define SES_STATUS_UNAVAIL(s) \
65 ((s) == SES_ESC_UNSUPPORTED || (s) >= SES_ESC_NOT_INSTALLED)
66
67 #define HR_SECOND 1000000000
68
69 /*
70 * Because multiple SES targets can be part of a single chassis, we construct
71 * our own hierarchy that takes this into account. These SES targets may refer
72 * to the same devices (multiple paths) or to different devices (managing
73 * different portions of the space). We arrange things into a
74 * ses_enum_enclosure_t, which contains a set of ses targets, and a list of all
75 * nodes found so far.
76 */
77 typedef struct ses_alt_node {
78 topo_list_t san_link;
79 ses_node_t *san_node;
80 } ses_alt_node_t;
81
82 typedef struct ses_enum_node {
83 topo_list_t sen_link;
84 ses_node_t *sen_node;
85 topo_list_t sen_alt_nodes;
86 uint64_t sen_type;
87 uint64_t sen_instance;
88 ses_enum_target_t *sen_target;
89 } ses_enum_node_t;
90
91 typedef struct ses_enum_chassis {
92 topo_list_t sec_link;
93 topo_list_t sec_subchassis;
94 topo_list_t sec_nodes;
95 topo_list_t sec_targets;
96 const char *sec_csn;
97 ses_node_t *sec_enclosure;
98 ses_enum_target_t *sec_target;
99 topo_instance_t sec_instance;
100 topo_instance_t sec_scinstance;
101 topo_instance_t sec_maxinstance;
102 boolean_t sec_hasdev;
103 boolean_t sec_internal;
104 } ses_enum_chassis_t;
105
106 typedef struct ses_enum_data {
107 topo_list_t sed_devs;
108 topo_list_t sed_chassis;
109 ses_enum_chassis_t *sed_current;
110 ses_enum_target_t *sed_target;
111 int sed_errno;
112 char *sed_name;
113 topo_mod_t *sed_mod;
114 topo_instance_t sed_instance;
115 } ses_enum_data_t;
116
117 typedef struct sas_connector_phy_data {
118 uint64_t scpd_index;
119 uint64_t scpd_pm;
120 } sas_connector_phy_data_t;
121
122 typedef struct sas_connector_type {
123 uint64_t sct_type;
124 char *sct_name;
125 } sas_connector_type_t;
126
127 static const sas_connector_type_t sas_connector_type_list[] = {
128 { 0x0, "Information unknown" },
129 { 0x1, "External SAS 4x receptacle (see SAS-2 and SFF-8470)" },
130 { 0x2, "Exteranl Mini SAS 4x receptacle (see SAS-2 and SFF-8088)" },
131 { 0x3, "QSFP+ receptacle (see SAS-2.1 and SFF-8436)" },
132 { 0x4, "Mini SAS 4x active receptacle (see SAS-2.1 and SFF-8088)" },
133 { 0x5, "Mini SAS HD 4x receptacle (see SAS-2.1 and SFF-8644)" },
134 { 0x6, "Mini SAS HD 8x receptacle (see SAS-2.1 and SFF-8644)" },
135 { 0x7, "Mini SAS HD 16x receptacle (see SAS-2.1 and SFF-8644)" },
136 { 0xF, "Vendor-specific external connector" },
137 { 0x10, "Internal wide SAS 4i plug (see SAS-2 and SFF-8484)" },
138 { 0x11,
139 "Internal wide Mini SAS 4i receptacle (see SAS-2 and SFF-8087)" },
140 { 0x12, "Mini SAS HD 4i receptacle (see SAS-2.1 and SFF-8643)" },
141 { 0x20, "Internal SAS Drive receptacle (see SAS-2 and SFF-8482)" },
142 { 0x21, "Internal SATA host plug (see SAS-2 and SATA-2)" },
143 { 0x22, "Internal SAS Drive plug (see SAS-2 and SFF-8482)" },
144 { 0x23, "Internal SATA device plug (see SAS-2 and SATA-2)" },
145 { 0x24, "Micro SAS receptacle (see SAS-2.14)" },
146 { 0x25, "Micro SATA device plug (see SAS-2.1 and SATA)" },
147 { 0x26, "Micro SAS plug (see SAS-2.1 and SFF-8486)" },
148 { 0x27, "Micro SAS/SATA plug (see SAS-2.1 and SFF-8486)" },
149 { 0x28,
150 "12 Gb/s SAS Drive backplane receptacle (see SAS-34 and SFF-8680)" },
151 { 0x29, "12Gb/s SAS Drive Plug (see SAS-3 and SFF-8680)" },
152 { 0x2A, "Multifunction 12 Gb/s 6x Unshielded receptacle connector "
153 "receptacle (see SAS-3 and SFF-8639)" },
154 { 0x2B, "Multifunction 12 Gb/s 6x Unshielded receptable connector "
155 "plug (see SAS-3 and SFF-8639)" },
156 { 0x2F, "Internal SAS virtual connector" },
157 { 0x3F, "Vendor-specific internal connector" },
158 { 0x70, "Other Vendor-specific connector" },
159 { 0x71, "Other Vendor-specific connector" },
160 { 0x72, "Other Vendor-specific connector" },
161 { 0x73, "Other Vendor-specific connector" },
162 { 0x74, "Other Vendor-specific connector" },
163 { 0x75, "Other Vendor-specific connector" },
164 { 0x76, "Other Vendor-specific connector" },
165 { 0x77, "Other Vendor-specific connector" },
166 { 0x78, "Other Vendor-specific connector" },
167 { 0x79, "Other Vendor-specific connector" },
168 { 0x7A, "Other Vendor-specific connector" },
169 { 0x7B, "Other Vendor-specific connector" },
170 { 0x7C, "Other Vendor-specific connector" },
171 { 0x7D, "Other Vendor-specific connector" },
172 { 0x7E, "Other Vendor-specific connector" },
173 { 0x7F, "Other Vendor-specific connector" },
174 { 0x80, "Not Defined" }
175 };
176
177 #define SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED 0x80
178 #define SAS_CONNECTOR_TYPE_NOT_DEFINED \
179 "Connector type not defined by SES-2 standard"
180 #define SAS_CONNECTOR_TYPE_RESERVED \
181 "Connector type reserved by SES-2 standard"
182
183 typedef struct phys_enum_type {
184 uint64_t pet_type;
185 char *pet_nodename;
186 char *pet_defaultlabel;
187 boolean_t pet_dorange;
188 } phys_enum_type_t;
189
190 static const phys_enum_type_t phys_enum_type_list[] = {
191 { SES_ET_ARRAY_DEVICE, BAY, "BAY", B_TRUE },
192 { SES_ET_COOLING, FAN, "FAN", B_TRUE },
193 { SES_ET_DEVICE, BAY, "BAY", B_TRUE },
194 { SES_ET_ESC_ELECTRONICS, CONTROLLER, "CONTROLLER", B_TRUE },
195 { SES_ET_POWER_SUPPLY, PSU, "PSU", B_TRUE },
196 { SES_ET_SUNW_FANBOARD, FANBOARD, "FANBOARD", B_TRUE },
197 { SES_ET_SUNW_FANMODULE, FANMODULE, "FANMODULE", B_TRUE },
198 { SES_ET_SUNW_POWERBOARD, POWERBOARD, "POWERBOARD", B_TRUE },
199 { SES_ET_SUNW_POWERMODULE, POWERMODULE, "POWERMODULE", B_TRUE }
200 };
201
202 #define N_PHYS_ENUM_TYPES (sizeof (phys_enum_type_list) / \
203 sizeof (phys_enum_type_list[0]))
204
205 /*
206 * Structure for the hierarchical tree for element nodes.
207 */
208 typedef struct ses_phys_tree {
209 ses_node_t *spt_snode;
210 ses_enum_node_t *spt_senumnode;
211 boolean_t spt_isfru;
212 uint64_t spt_eonlyindex;
213 uint64_t spt_cindex;
214 uint64_t spt_pindex;
215 uint64_t spt_maxinst;
216 struct ses_phys_tree *spt_parent;
217 struct ses_phys_tree *spt_child;
218 struct ses_phys_tree *spt_sibling;
219 tnode_t *spt_tnode;
220 } ses_phys_tree_t;
221
222 typedef enum {
223 SES_NEW_CHASSIS = 0x1,
224 SES_NEW_SUBCHASSIS = 0x2,
225 SES_DUP_CHASSIS = 0x4,
226 SES_DUP_SUBCHASSIS = 0x8
227 } ses_chassis_type_e;
228
229
230 static const topo_pgroup_info_t storage_pgroup = {
231 TOPO_PGROUP_STORAGE,
232 TOPO_STABILITY_PRIVATE,
233 TOPO_STABILITY_PRIVATE,
234 1
235 };
236
237 static const topo_pgroup_info_t smp_pgroup = {
238 TOPO_PGROUP_SMP,
239 TOPO_STABILITY_PRIVATE,
240 TOPO_STABILITY_PRIVATE,
241 1
242 };
243
244 static const topo_pgroup_info_t ses_pgroup = {
245 TOPO_PGROUP_SES,
246 TOPO_STABILITY_PRIVATE,
247 TOPO_STABILITY_PRIVATE,
248 1
249 };
250
251 static int ses_present(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
252 nvlist_t **);
253 static int ses_contains(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
254 nvlist_t **);
255
256 static const topo_method_t ses_component_methods[] = {
257 { TOPO_METH_PRESENT, TOPO_METH_PRESENT_DESC,
258 TOPO_METH_PRESENT_VERSION0, TOPO_STABILITY_INTERNAL, ses_present },
259 { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0,
260 TOPO_STABILITY_INTERNAL, ses_node_enum_facility },
261 { TOPO_METH_SENSOR_FAILURE, TOPO_METH_SENSOR_FAILURE_DESC,
262 TOPO_METH_SENSOR_FAILURE_VERSION, TOPO_STABILITY_INTERNAL,
263 topo_method_sensor_failure },
264 { NULL }
265 };
266
267 static const topo_method_t ses_bay_methods[] = {
268 { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0,
269 TOPO_STABILITY_INTERNAL, ses_node_enum_facility },
270 { NULL }
271 };
272
273 static const topo_method_t ses_enclosure_methods[] = {
274 { TOPO_METH_CONTAINS, TOPO_METH_CONTAINS_DESC,
275 TOPO_METH_CONTAINS_VERSION, TOPO_STABILITY_INTERNAL, ses_contains },
276 { TOPO_METH_FAC_ENUM, TOPO_METH_FAC_ENUM_DESC, 0,
277 TOPO_STABILITY_INTERNAL, ses_enc_enum_facility },
278 { NULL }
279 };
280
281 /*
282 * Functions for tracking ses devices which we were unable to open. We retry
283 * these at regular intervals using ses_recheck_dir() and if we find that we
284 * can now open any of them then we send a sysevent to indicate that a new topo
285 * snapshot should be taken.
286 */
287 typedef struct ses_open_fail_list {
288 struct ses_open_fail_list *sof_next;
289 char *sof_path;
290 } ses_open_fail_list_t;
291
292 static ses_open_fail_list_t *ses_sofh;
293 static pthread_mutex_t ses_sofmt;
294 static void ses_ct_print(char *ptr);
295
296 static void
297 ses_recheck_dir()
298 {
299 ses_target_t *target;
300 sysevent_id_t eid;
301 char buf[80];
302 ses_open_fail_list_t *sof;
303
304 /*
305 * check list of "unable to open" devices
306 */
307 (void) pthread_mutex_lock(&ses_sofmt);
308 for (sof = ses_sofh; sof != NULL; sof = sof->sof_next) {
309 /*
310 * see if we can open it now
311 */
312 if ((target = ses_open(LIBSES_VERSION,
313 sof->sof_path)) == NULL) {
314 (void) snprintf(buf, sizeof (buf),
315 "recheck_dir - still can't open %s", sof->sof_path);
316 ses_ct_print(buf);
317 continue;
318 }
319
320 /*
321 * ok - better force a new snapshot
322 */
323 (void) snprintf(buf, sizeof (buf),
324 "recheck_dir - can now open %s", sof->sof_path);
325 ses_ct_print(buf);
326 (void) sysevent_post_event(EC_PLATFORM, ESC_PLATFORM_SP_RESET,
327 SUNW_VENDOR, "fmd", NULL, &eid);
328 ses_close(target);
329 break;
330 }
331 (void) pthread_mutex_unlock(&ses_sofmt);
332 }
333
334 static void
335 ses_sof_alloc(topo_mod_t *mod, char *path)
336 {
337 ses_open_fail_list_t *sof;
338
339 (void) pthread_mutex_lock(&ses_sofmt);
340 sof = topo_mod_zalloc(mod, sizeof (*sof));
341 topo_mod_dprintf(mod, "sof_alloc %s", path);
342 sof->sof_path = path;
343 sof->sof_next = ses_sofh;
344 ses_sofh = sof;
345 (void) pthread_mutex_unlock(&ses_sofmt);
346 }
347
348 static void
349 ses_sof_freeall(topo_mod_t *mod)
350 {
351 ses_open_fail_list_t *sof, *next_sof;
352
353 (void) pthread_mutex_lock(&ses_sofmt);
354 for (sof = ses_sofh; sof != NULL; sof = next_sof) {
355 next_sof = sof->sof_next;
356 topo_mod_dprintf(mod, "sof_freeall %s", sof->sof_path);
357 topo_mod_strfree(mod, sof->sof_path);
358 topo_mod_free(mod, sof, sizeof (*sof));
359 }
360 ses_sofh = NULL;
361 (void) pthread_mutex_unlock(&ses_sofmt);
362 }
363
364 /*
365 * functions for verifying that the ses_enum_target_t held in a device
366 * contract's cookie field is still valid (it may have been freed by
367 * ses_release()).
368 */
369 typedef struct ses_stp_list {
370 struct ses_stp_list *ssl_next;
371 ses_enum_target_t *ssl_tgt;
372 } ses_stp_list_t;
373
374 static ses_stp_list_t *ses_sslh;
375 static pthread_mutex_t ses_sslmt;
376
377 static void
378 ses_ssl_alloc(topo_mod_t *mod, ses_enum_target_t *stp)
379 {
380 ses_stp_list_t *ssl;
381
382 (void) pthread_mutex_lock(&ses_sslmt);
383 ssl = topo_mod_zalloc(mod, sizeof (*ssl));
384 topo_mod_dprintf(mod, "ssl_alloc %p", stp);
385 ssl->ssl_tgt = stp;
386 ssl->ssl_next = ses_sslh;
387 ses_sslh = ssl;
388 (void) pthread_mutex_unlock(&ses_sslmt);
389 }
390
391 static void
392 ses_ssl_free(topo_mod_t *mod, ses_enum_target_t *stp)
393 {
394 ses_stp_list_t *ssl, *prev_ssl;
395
396 (void) pthread_mutex_lock(&ses_sslmt);
397 prev_ssl = NULL;
398 for (ssl = ses_sslh; ssl != NULL; ssl = ssl->ssl_next) {
399 if (ssl->ssl_tgt == stp) {
400 topo_mod_dprintf(mod, "ssl_free %p", ssl->ssl_tgt);
401 if (prev_ssl == NULL)
402 ses_sslh = ssl->ssl_next;
403 else
404 prev_ssl->ssl_next = ssl->ssl_next;
405 topo_mod_free(mod, ssl, sizeof (*ssl));
406 break;
407 }
408 prev_ssl = ssl;
409 }
410 (void) pthread_mutex_unlock(&ses_sslmt);
411 }
412
413 static int
414 ses_ssl_valid(ses_enum_target_t *stp)
415 {
416 ses_stp_list_t *ssl;
417
418 for (ssl = ses_sslh; ssl != NULL; ssl = ssl->ssl_next)
419 if (ssl->ssl_tgt == stp)
420 return (1);
421 return (0);
422 }
423
424 /*
425 * Functions for creating and destroying a background thread
426 * (ses_contract_thread) used for detecting when ses devices have been
427 * retired/unretired.
428 */
429 static struct ses_thread_s {
430 pthread_mutex_t mt;
431 pthread_t tid;
432 int thr_sig;
433 int doexit;
434 int count;
435 } sesthread = {
436 PTHREAD_MUTEX_INITIALIZER,
437 0,
438 SIGTERM,
439 0,
440 0
441 };
442
443 typedef struct ses_mod_list {
444 struct ses_mod_list *smod_next;
445 topo_mod_t *smod_mod;
446 } ses_mod_list_t;
447
448 static ses_mod_list_t *ses_smod;
449
450 static void
451 ses_ct_print(char *ptr)
452 {
453 (void) pthread_mutex_lock(&sesthread.mt);
454 if (ses_smod != NULL && ses_smod->smod_mod != NULL)
455 topo_mod_dprintf(ses_smod->smod_mod, ptr);
456 (void) pthread_mutex_unlock(&sesthread.mt);
457 }
458
459 /*ARGSUSED*/
460 static void *
461 ses_contract_thread(void *arg)
462 {
463 int efd, ctlfd, statfd;
464 ct_evthdl_t ev;
465 ctevid_t evid;
466 uint_t event;
467 char path[PATH_MAX];
468 char buf[80];
469 ses_enum_target_t *stp;
470 ct_stathdl_t stathdl;
471 ctid_t ctid;
472 struct pollfd fds;
473 int pollret;
474 sigset_t sigset;
475
476 ses_ct_print("start contract event thread");
477 efd = open64(CTFS_ROOT "/device/pbundle", O_RDONLY);
478 fds.fd = efd;
479 fds.events = POLLIN;
480 fds.revents = 0;
481 sigaddset(&sigset, sesthread.thr_sig);
482 pthread_sigmask(SIG_UNBLOCK, &sigset, NULL);
483 for (;;) {
484 /* check if we've been asked to exit */
485 (void) pthread_mutex_lock(&sesthread.mt);
486 if (sesthread.doexit) {
487 (void) pthread_mutex_unlock(&sesthread.mt);
488 break;
489 }
490 (void) pthread_mutex_unlock(&sesthread.mt);
491
492 /* poll until an event arrives */
493 if ((pollret = poll(&fds, 1, 10000)) <= 0) {
494 if (pollret == 0)
495 ses_recheck_dir();
496 continue;
497 }
498
499 /* read the event */
500 (void) pthread_mutex_lock(&ses_sslmt);
501 ses_ct_print("read contract event");
502 if (ct_event_read(efd, &ev) != 0) {
503 (void) pthread_mutex_unlock(&ses_sslmt);
504 continue;
505 }
506
507 /* see if it is an event we are expecting */
508 ctid = ct_event_get_ctid(ev);
509 (void) snprintf(buf, sizeof (buf),
510 "got contract event ctid=%d", ctid);
511 ses_ct_print(buf);
512 event = ct_event_get_type(ev);
513 if (event != CT_DEV_EV_OFFLINE && event != CT_EV_NEGEND) {
514 (void) snprintf(buf, sizeof (buf),
515 "bad contract event %x", event);
516 ses_ct_print(buf);
517 ct_event_free(ev);
518 (void) pthread_mutex_unlock(&ses_sslmt);
519 continue;
520 }
521
522 /* find target pointer saved in cookie */
523 evid = ct_event_get_evid(ev);
524 (void) snprintf(path, PATH_MAX, CTFS_ROOT "/device/%ld/status",
525 ctid);
526 statfd = open64(path, O_RDONLY);
527 (void) ct_status_read(statfd, CTD_COMMON, &stathdl);
528 stp = (ses_enum_target_t *)(uintptr_t)
529 ct_status_get_cookie(stathdl);
530 ct_status_free(stathdl);
531 (void) close(statfd);
532
533 /* check if target pointer is still valid */
534 if (ses_ssl_valid(stp) == 0) {
535 (void) snprintf(buf, sizeof (buf),
536 "contract already abandoned %x", event);
537 ses_ct_print(buf);
538 (void) snprintf(path, PATH_MAX,
539 CTFS_ROOT "/device/%ld/ctl", ctid);
540 ctlfd = open64(path, O_WRONLY);
541 if (event != CT_EV_NEGEND)
542 (void) ct_ctl_ack(ctlfd, evid);
543 else
544 (void) ct_ctl_abandon(ctlfd);
545 (void) close(ctlfd);
546 ct_event_free(ev);
547 (void) pthread_mutex_unlock(&ses_sslmt);
548 continue;
549 }
550
551 /* find control device for ack/abandon */
552 (void) pthread_mutex_lock(&stp->set_lock);
553 (void) snprintf(path, PATH_MAX, CTFS_ROOT "/device/%ld/ctl",
554 ctid);
555 ctlfd = open64(path, O_WRONLY);
556 if (event != CT_EV_NEGEND) {
557 /* if this is an offline event, do the offline */
558 ses_ct_print("got contract offline event");
559 if (stp->set_target) {
560 ses_ct_print("contract thread rele");
561 ses_snap_rele(stp->set_snap);
562 ses_close(stp->set_target);
563 stp->set_target = NULL;
564 }
565 (void) ct_ctl_ack(ctlfd, evid);
566 } else {
567 /* if this is the negend, then abandon the contract */
568 ses_ct_print("got contract negend");
569 if (stp->set_ctid) {
570 (void) snprintf(buf, sizeof (buf),
571 "abandon old contract %d", stp->set_ctid);
572 ses_ct_print(buf);
573 stp->set_ctid = NULL;
574 }
575 (void) ct_ctl_abandon(ctlfd);
576 }
577 (void) close(ctlfd);
578 (void) pthread_mutex_unlock(&stp->set_lock);
579 ct_event_free(ev);
580 (void) pthread_mutex_unlock(&ses_sslmt);
581 }
582 (void) close(efd);
583 return (NULL);
584 }
585
586 int
587 find_thr_sig(void)
588 {
589 int i;
590 sigset_t oset, rset;
591 int sig[] = {SIGTERM, SIGUSR1, SIGUSR2};
592 int sig_sz = sizeof (sig) / sizeof (int);
593 int rc = SIGTERM;
594
595 /* prefered set of signals that are likely used to terminate threads */
596 (void) sigemptyset(&oset);
597 (void) pthread_sigmask(SIG_SETMASK, NULL, &oset);
598 for (i = 0; i < sig_sz; i++) {
599 if (sigismember(&oset, sig[i]) == 0) {
600 return (sig[i]);
601 }
602 }
603
604 /* reserved set of signals that are not allowed to terminate thread */
605 (void) sigemptyset(&rset);
606 (void) sigaddset(&rset, SIGABRT);
607 (void) sigaddset(&rset, SIGKILL);
608 (void) sigaddset(&rset, SIGSTOP);
609 (void) sigaddset(&rset, SIGCANCEL);
610
611 /* Find signal that is not masked and not in the reserved list. */
612 for (i = 1; i < MAXSIG; i++) {
613 if (sigismember(&rset, i) == 1) {
614 continue;
615 }
616 if (sigismember(&oset, i) == 0) {
617 return (i);
618 }
619 }
620
621 return (rc);
622 }
623
624 /*ARGSUSED*/
625 static void
626 ses_handler(int sig)
627 {
628 }
629
630 static void
631 ses_thread_init(topo_mod_t *mod)
632 {
633 pthread_attr_t *attr = NULL;
634 struct sigaction act;
635 ses_mod_list_t *smod;
636
637 (void) pthread_mutex_lock(&sesthread.mt);
638 sesthread.count++;
639 smod = topo_mod_zalloc(mod, sizeof (*smod));
640 smod->smod_mod = mod;
641 smod->smod_next = ses_smod;
642 ses_smod = smod;
643 if (sesthread.tid == 0) {
644 /* find a suitable signal to use for killing the thread below */
645 sesthread.thr_sig = find_thr_sig();
646
647 /* if don't have a handler for this signal, create one */
648 (void) sigaction(sesthread.thr_sig, NULL, &act);
649 if (act.sa_handler == SIG_DFL || act.sa_handler == SIG_IGN)
650 act.sa_handler = ses_handler;
651 (void) sigaction(sesthread.thr_sig, &act, NULL);
652
653 /* create a thread to listen for offline events */
654 (void) pthread_create(&sesthread.tid,
655 attr, ses_contract_thread, NULL);
656 }
657 (void) pthread_mutex_unlock(&sesthread.mt);
658 }
659
660 static void
661 ses_thread_fini(topo_mod_t *mod)
662 {
663 ses_mod_list_t *smod, *prev_smod;
664
665 (void) pthread_mutex_lock(&sesthread.mt);
666 prev_smod = NULL;
667 for (smod = ses_smod; smod != NULL; smod = smod->smod_next) {
668 if (smod->smod_mod == mod) {
669 if (prev_smod == NULL)
670 ses_smod = smod->smod_next;
671 else
672 prev_smod->smod_next = smod->smod_next;
673 topo_mod_free(mod, smod, sizeof (*smod));
674 break;
675 }
676 prev_smod = smod;
677 }
678 if (--sesthread.count > 0) {
679 (void) pthread_mutex_unlock(&sesthread.mt);
680 return;
681 }
682 sesthread.doexit = 1;
683 (void) pthread_mutex_unlock(&sesthread.mt);
684 (void) pthread_kill(sesthread.tid, sesthread.thr_sig);
685 (void) pthread_join(sesthread.tid, NULL);
686 sesthread.tid = 0;
687 }
688
689 static void
690 ses_create_contract(topo_mod_t *mod, ses_enum_target_t *stp)
691 {
692 int tfd, len, rval;
693 char link_path[PATH_MAX];
694
695 stp->set_ctid = NULL;
696
697 /* convert "/dev" path into "/devices" path */
698 if ((len = readlink(stp->set_devpath, link_path, PATH_MAX)) < 0) {
699 topo_mod_dprintf(mod, "readlink failed");
700 return;
701 }
702 link_path[len] = '\0';
703
704 /* set up template to create new contract */
705 tfd = open64(CTFS_ROOT "/device/template", O_RDWR);
706 (void) ct_tmpl_set_critical(tfd, CT_DEV_EV_OFFLINE);
707 (void) ct_tmpl_set_cookie(tfd, (uint64_t)(uintptr_t)stp);
708
709 /* strip "../../devices" off the front and create the contract */
710 if ((rval = ct_dev_tmpl_set_minor(tfd, &link_path[13])) != 0)
711 topo_mod_dprintf(mod, "failed to set minor %s rval = %d",
712 &link_path[13], rval);
713 else if ((rval = ct_tmpl_create(tfd, &stp->set_ctid)) != 0)
714 topo_mod_dprintf(mod, "failed to create ctid rval = %d", rval);
715 else
716 topo_mod_dprintf(mod, "created ctid=%d", stp->set_ctid);
717 (void) close(tfd);
718 }
719
720 static void
721 ses_target_free(topo_mod_t *mod, ses_enum_target_t *stp)
722 {
723 if (--stp->set_refcount == 0) {
724 /* check if already closed due to contract offline request */
725 (void) pthread_mutex_lock(&stp->set_lock);
726 if (stp->set_target) {
727 ses_snap_rele(stp->set_snap);
728 ses_close(stp->set_target);
729 stp->set_target = NULL;
730 }
731 if (stp->set_ctid) {
732 int ctlfd;
733 char path[PATH_MAX];
734
735 topo_mod_dprintf(mod, "abandon old contract %d",
736 stp->set_ctid);
737 (void) snprintf(path, PATH_MAX,
738 CTFS_ROOT "/device/%ld/ctl", stp->set_ctid);
739 ctlfd = open64(path, O_WRONLY);
740 (void) ct_ctl_abandon(ctlfd);
741 (void) close(ctlfd);
742 stp->set_ctid = NULL;
743 }
744 (void) pthread_mutex_unlock(&stp->set_lock);
745 ses_ssl_free(mod, stp);
746 topo_mod_strfree(mod, stp->set_devpath);
747 topo_mod_free(mod, stp, sizeof (ses_enum_target_t));
748 }
749 }
750
751 static void
752 ses_data_free(ses_enum_data_t *sdp, ses_enum_chassis_t *pcp)
753 {
754 topo_mod_t *mod = sdp->sed_mod;
755 ses_enum_chassis_t *cp;
756 ses_enum_node_t *np;
757 ses_enum_target_t *tp;
758 ses_alt_node_t *ap;
759 topo_list_t *cpl;
760
761
762 if (pcp != NULL)
763 cpl = &pcp->sec_subchassis;
764 else
765 cpl = &sdp->sed_chassis;
766
767 while ((cp = topo_list_next(cpl)) != NULL) {
768 topo_list_delete(cpl, cp);
769
770 while ((np = topo_list_next(&cp->sec_nodes)) != NULL) {
771 while ((ap = topo_list_next(&np->sen_alt_nodes)) !=
772 NULL) {
773 topo_list_delete(&np->sen_alt_nodes, ap);
774 topo_mod_free(mod, ap, sizeof (ses_alt_node_t));
775 }
776 topo_list_delete(&cp->sec_nodes, np);
777 topo_mod_free(mod, np, sizeof (ses_enum_node_t));
778 }
779
780 while ((tp = topo_list_next(&cp->sec_targets)) != NULL) {
781 topo_list_delete(&cp->sec_targets, tp);
782 ses_target_free(mod, tp);
783 }
784
785 topo_mod_free(mod, cp, sizeof (ses_enum_chassis_t));
786 }
787
788 if (pcp == NULL) {
789 dev_list_free(mod, &sdp->sed_devs);
790 topo_mod_free(mod, sdp, sizeof (ses_enum_data_t));
791 }
792 }
793
794 /*
795 * For enclosure nodes, we have a special contains method. By default, the hc
796 * walker will compare the node name and instance number to determine if an
797 * FMRI matches. For enclosures where the enumeration order is impossible to
798 * predict, we instead use the chassis-id as a unique identifier, and ignore
799 * the instance number.
800 */
801 static int
802 fmri_contains(topo_mod_t *mod, nvlist_t *nv1, nvlist_t *nv2)
803 {
804 uint8_t v1, v2;
805 nvlist_t **hcp1, **hcp2;
806 int err, i;
807 uint_t nhcp1, nhcp2;
808 nvlist_t *a1, *a2;
809 char *c1, *c2;
810 int mindepth;
811
812 if (nvlist_lookup_uint8(nv1, FM_VERSION, &v1) != 0 ||
813 nvlist_lookup_uint8(nv2, FM_VERSION, &v2) != 0 ||
814 v1 > FM_HC_SCHEME_VERSION || v2 > FM_HC_SCHEME_VERSION)
815 return (topo_mod_seterrno(mod, EMOD_FMRI_VERSION));
816
817 err = nvlist_lookup_nvlist_array(nv1, FM_FMRI_HC_LIST, &hcp1, &nhcp1);
818 err |= nvlist_lookup_nvlist_array(nv2, FM_FMRI_HC_LIST, &hcp2, &nhcp2);
819 if (err != 0)
820 return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
821
822 /*
823 * If the chassis-id doesn't match, then these FMRIs are not
824 * equivalent. If one of the FMRIs doesn't have a chassis ID, then we
825 * have no choice but to fall back to the instance ID.
826 */
827 if (nvlist_lookup_nvlist(nv1, FM_FMRI_AUTHORITY, &a1) == 0 &&
828 nvlist_lookup_nvlist(nv2, FM_FMRI_AUTHORITY, &a2) == 0 &&
829 nvlist_lookup_string(a1, FM_FMRI_AUTH_CHASSIS, &c1) == 0 &&
830 nvlist_lookup_string(a2, FM_FMRI_AUTH_CHASSIS, &c2) == 0) {
831 if (strcmp(c1, c2) != 0)
832 return (0);
833
834 mindepth = 1;
835 } else {
836 mindepth = 0;
837 }
838
839 if (nhcp2 < nhcp1)
840 return (0);
841
842 for (i = 0; i < nhcp1; i++) {
843 char *nm1 = NULL;
844 char *nm2 = NULL;
845 char *id1 = NULL;
846 char *id2 = NULL;
847
848 (void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_NAME, &nm1);
849 (void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_NAME, &nm2);
850 (void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_ID, &id1);
851 (void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_ID, &id2);
852 if (nm1 == NULL || nm2 == NULL || id1 == NULL || id2 == NULL)
853 return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
854
855 if (strcmp(nm1, nm2) == 0 &&
856 (i < mindepth || strcmp(id1, id2) == 0))
857 continue;
858
859 return (0);
860 }
861
862 return (1);
863 }
864
865 /*ARGSUSED*/
866 static int
867 ses_contains(topo_mod_t *mod, tnode_t *tn, topo_version_t version,
868 nvlist_t *in, nvlist_t **out)
869 {
870 int ret;
871 nvlist_t *nv1, *nv2;
872
873 if (version > TOPO_METH_CONTAINS_VERSION)
874 return (topo_mod_seterrno(mod, EMOD_VER_NEW));
875
876 if (nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_FMRI, &nv1) != 0 ||
877 nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_SUBFMRI, &nv2) != 0)
878 return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
879
880 ret = fmri_contains(mod, nv1, nv2);
881 if (ret < 0)
882 return (-1);
883
884 if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) == 0) {
885 if (nvlist_add_uint32(*out, TOPO_METH_CONTAINS_RET,
886 ret) == 0)
887 return (0);
888 else
889 nvlist_free(*out);
890 }
891
892 return (-1);
893
894 }
895
896 /*
897 * Return a current instance of the node. This is somewhat complicated because
898 * we need to take a new snapshot in order to get the new data, but we don't
899 * want to be constantly taking SES snapshots if the consumer is going to do a
900 * series of queries. So we adopt the strategy of assuming that the SES state
901 * is not going to be rapidly changing, and limit our snapshot frequency to
902 * some defined bounds.
903 */
904 ses_node_t *
905 ses_node_lock(topo_mod_t *mod, tnode_t *tn)
906 {
907 ses_enum_target_t *tp = topo_node_getspecific(tn);
908 hrtime_t now;
909 ses_snap_t *snap;
910 int err;
911 uint64_t nodeid;
912 ses_node_t *np;
913
914 if (tp == NULL) {
915 (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP);
916 return (NULL);
917 }
918
919 (void) pthread_mutex_lock(&tp->set_lock);
920
921 /*
922 * Determine if we need to take a new snapshot.
923 */
924 now = gethrtime();
925
926 if (tp->set_target == NULL) {
927 /*
928 * We may have closed the device but not yet abandoned the
929 * contract (ie we've had the offline event but not yet the
930 * negend). If so, just return failure.
931 */
932 if (tp->set_ctid != NULL) {
933 (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP);
934 (void) pthread_mutex_unlock(&tp->set_lock);
935 return (NULL);
936 }
937
938 /*
939 * The device has been closed due to a contract offline
940 * request, then we need to reopen it and create a new contract.
941 */
942 if ((tp->set_target =
943 ses_open(LIBSES_VERSION, tp->set_devpath)) == NULL) {
944 sysevent_id_t eid;
945
946 (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP);
947 (void) pthread_mutex_unlock(&tp->set_lock);
948 topo_mod_dprintf(mod, "recheck_dir - "
949 "can no longer open %s", tp->set_devpath);
950 (void) sysevent_post_event(EC_PLATFORM,
951 ESC_PLATFORM_SP_RESET, SUNW_VENDOR, "fmd", NULL,
952 &eid);
953 return (NULL);
954 }
955 topo_mod_dprintf(mod, "reopen contract");
956 ses_create_contract(mod, tp);
957 tp->set_snap = ses_snap_hold(tp->set_target);
958 tp->set_snaptime = gethrtime();
959 } else if (now - tp->set_snaptime > (ses_snap_freq * 1000 * 1000) &&
960 (snap = ses_snap_new(tp->set_target)) != NULL) {
961 if (ses_snap_generation(snap) !=
962 ses_snap_generation(tp->set_snap)) {
963 /*
964 * If we find ourselves in this situation, we're in
965 * trouble. The generation count has changed, which
966 * indicates that our current topology is out of date.
967 * But we need to consult the new topology in order to
968 * determine presence at this moment in time. We can't
969 * go back and change the topo snapshot in situ, so
970 * we'll just have to fail the call in this unlikely
971 * scenario.
972 */
973 ses_snap_rele(snap);
974 (void) topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP);
975 (void) pthread_mutex_unlock(&tp->set_lock);
976 return (NULL);
977 } else {
978 ses_snap_rele(tp->set_snap);
979 tp->set_snap = snap;
980 }
981 tp->set_snaptime = gethrtime();
982 }
983
984 snap = tp->set_snap;
985
986 verify(topo_prop_get_uint64(tn, TOPO_PGROUP_SES,
987 TOPO_PROP_NODE_ID, &nodeid, &err) == 0);
988 verify((np = ses_node_lookup(snap, nodeid)) != NULL);
989
990 return (np);
991 }
992
993 /*ARGSUSED*/
994 void
995 ses_node_unlock(topo_mod_t *mod, tnode_t *tn)
996 {
997 ses_enum_target_t *tp = topo_node_getspecific(tn);
998
999 verify(tp != NULL);
1000
1001 (void) pthread_mutex_unlock(&tp->set_lock);
1002 }
1003
1004 /*
1005 * Determine if the element is present.
1006 */
1007 /*ARGSUSED*/
1008 static int
1009 ses_present(topo_mod_t *mod, tnode_t *tn, topo_version_t version,
1010 nvlist_t *in, nvlist_t **out)
1011 {
1012 boolean_t present;
1013 ses_node_t *np;
1014 nvlist_t *props, *nvl;
1015 uint64_t status;
1016
1017 if ((np = ses_node_lock(mod, tn)) == NULL)
1018 return (-1);
1019
1020 /*
1021 * If the SES properties are not there or
1022 * status cannot be determined, continue
1023 * and indicate status is unknown.
1024 */
1025 if (((props = ses_node_props(np)) == NULL) ||
1026 (nvlist_lookup_uint64(props,
1027 SES_PROP_STATUS_CODE, &status) != 0)) {
1028 status = SES_ESC_UNKNOWN;
1029 }
1030
1031 ses_node_unlock(mod, tn);
1032
1033 present = (status != SES_ESC_NOT_INSTALLED);
1034
1035 if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0)
1036 return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
1037
1038 if (nvlist_add_uint32(nvl, TOPO_METH_PRESENT_RET,
1039 present) != 0) {
1040 nvlist_free(nvl);
1041 return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
1042 }
1043
1044 *out = nvl;
1045
1046 return (0);
1047 }
1048
1049 /*
1050 * Sets standard properties for a ses node (enclosure, bay, controller
1051 * or expander).
1052 * This includes setting the FRU, as well as setting the
1053 * authority information. When the fru topo node(frutn) is not NULL
1054 * its resouce should be used as FRU.
1055 */
1056 static int
1057 ses_set_standard_props(topo_mod_t *mod, tnode_t *frutn, tnode_t *tn,
1058 nvlist_t *auth, uint64_t nodeid, const char *path)
1059 {
1060 int err;
1061 char *product, *chassis;
1062 nvlist_t *fmri;
1063
1064 /*
1065 * Set the authority explicitly if specified.
1066 */
1067 if (auth) {
1068 verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT,
1069 &product) == 0);
1070 verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_CHASSIS,
1071 &chassis) == 0);
1072 if (topo_prop_set_string(tn, FM_FMRI_AUTHORITY,
1073 FM_FMRI_AUTH_PRODUCT, TOPO_PROP_IMMUTABLE, product,
1074 &err) != 0 ||
1075 topo_prop_set_string(tn, FM_FMRI_AUTHORITY,
1076 FM_FMRI_AUTH_CHASSIS, TOPO_PROP_IMMUTABLE, chassis,
1077 &err) != 0 ||
1078 topo_prop_set_string(tn, FM_FMRI_AUTHORITY,
1079 FM_FMRI_AUTH_SERVER, TOPO_PROP_IMMUTABLE, "",
1080 &err) != 0) {
1081 topo_mod_dprintf(mod, "failed to add authority "
1082 "properties: %s\n", topo_strerror(err));
1083 return (topo_mod_seterrno(mod, err));
1084 }
1085 }
1086
1087 /*
1088 * Copy the resource and set that as the FRU.
1089 */
1090 if (frutn != NULL) {
1091 if (topo_node_resource(frutn, &fmri, &err) != 0) {
1092 topo_mod_dprintf(mod,
1093 "topo_node_resource() failed : %s\n",
1094 topo_strerror(err));
1095 return (topo_mod_seterrno(mod, err));
1096 }
1097 } else {
1098 if (topo_node_resource(tn, &fmri, &err) != 0) {
1099 topo_mod_dprintf(mod,
1100 "topo_node_resource() failed : %s\n",
1101 topo_strerror(err));
1102 return (topo_mod_seterrno(mod, err));
1103 }
1104 }
1105
1106 if (topo_node_fru_set(tn, fmri, 0, &err) != 0) {
1107 topo_mod_dprintf(mod,
1108 "topo_node_fru_set() failed : %s\n",
1109 topo_strerror(err));
1110 nvlist_free(fmri);
1111 return (topo_mod_seterrno(mod, err));
1112 }
1113
1114 nvlist_free(fmri);
1115
1116 /*
1117 * Set the SES-specific properties so that consumers can query
1118 * additional information about the particular SES element.
1119 */
1120 if (topo_pgroup_create(tn, &ses_pgroup, &err) != 0) {
1121 topo_mod_dprintf(mod, "failed to create propgroup "
1122 "%s: %s\n", TOPO_PGROUP_SES, topo_strerror(err));
1123 return (-1);
1124 }
1125
1126 if (topo_prop_set_uint64(tn, TOPO_PGROUP_SES,
1127 TOPO_PROP_NODE_ID, TOPO_PROP_IMMUTABLE,
1128 nodeid, &err) != 0) {
1129 topo_mod_dprintf(mod,
1130 "failed to create property %s: %s\n",
1131 TOPO_PROP_NODE_ID, topo_strerror(err));
1132 return (-1);
1133 }
1134
1135 if (topo_prop_set_string(tn, TOPO_PGROUP_SES,
1136 TOPO_PROP_TARGET_PATH, TOPO_PROP_IMMUTABLE,
1137 path, &err) != 0) {
1138 topo_mod_dprintf(mod,
1139 "failed to create property %s: %s\n",
1140 TOPO_PROP_TARGET_PATH, topo_strerror(err));
1141 return (-1);
1142 }
1143
1144 return (0);
1145 }
1146
1147 /*
1148 * Iterate over the SES phy information. If any of the ports indicates that it's
1149 * a SATA device and we haven't matched any disk devices yet, that means
1150 * that the HBA was able to create a WWN for the SATA device based on its GUID,
1151 * which is good. However, SES includes the WWN for the device's STP bridge. In
1152 * theory, if the driver includes the WWN based on the SATA guid then it should
1153 * also set the bridge-port property indicating the WWN that should match the
1154 * SATA device.
1155 */
1156 static int
1157 ses_create_disk_bridge(ses_enum_data_t *sdp, tnode_t *pnode, nvlist_t *props,
1158 tnode_t **child)
1159 {
1160 nvlist_t **phys;
1161 uint_t i, n_phys;
1162 topo_mod_t *mod = sdp->sed_mod;
1163
1164 if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, &phys,
1165 &n_phys) != 0)
1166 return (1);
1167
1168 for (i = 0; i < n_phys; i++) {
1169 uint64_t wwn;
1170 boolean_t sata;
1171 char wwnstr[64];
1172
1173 if (nvlist_lookup_uint64(phys[i], SES_SAS_PROP_ADDR,
1174 &wwn) != 0 || wwn == 0) {
1175 continue;
1176 }
1177
1178 if (nvlist_lookup_boolean_value(phys[i],
1179 SES_SAS_PROP_SATA_DEVICE, &sata) != 0 || !sata) {
1180 continue;
1181 }
1182
1183 if (scsi_wwn_to_wwnstr(wwn, 0, wwnstr) == NULL)
1184 continue;
1185
1186 if (disk_declare_bridge(mod, pnode, &sdp->sed_devs,
1187 wwnstr, child) == 0) {
1188 return (0);
1189 }
1190
1191 }
1192
1193 return (1);
1194 }
1195
1196 /*
1197 * Callback to add a disk to a given bay. We first check the status-code to
1198 * determine if a disk is present, ignoring those that aren't in an appropriate
1199 * state. We then scan the parent bay node's SAS address array to determine
1200 * possible attached SAS addresses. We create a disk node if the disk is not
1201 * SAS or the SES target does not support the necessary pages for this; if we
1202 * find the SAS address, we create a disk node and also correlate it with
1203 * the corresponding Solaris device node to fill in the rest of the data.
1204 */
1205 static int
1206 ses_create_disk(ses_enum_data_t *sdp, tnode_t *pnode, nvlist_t *props)
1207 {
1208 topo_mod_t *mod = sdp->sed_mod;
1209 uint64_t status;
1210 uint_t s, nsas;
1211 char **paths;
1212 int err, ret;
1213 tnode_t *child = NULL;
1214
1215 /*
1216 * Skip devices that are not in a present (and possibly damaged) state.
1217 */
1218 if (nvlist_lookup_uint64(props, SES_PROP_STATUS_CODE, &status) != 0)
1219 return (0);
1220
1221 if (status != SES_ESC_UNSUPPORTED &&
1222 status != SES_ESC_OK &&
1223 status != SES_ESC_CRITICAL &&
1224 status != SES_ESC_NONCRITICAL &&
1225 status != SES_ESC_UNRECOVERABLE &&
1226 status != SES_ESC_NO_ACCESS &&
1227 status != SES_ESC_UNKNOWN)
1228 return (0);
1229
1230 topo_mod_dprintf(mod, "found attached disk");
1231
1232 /*
1233 * Create the disk range.
1234 */
1235 if (topo_node_range_create(mod, pnode, DISK, 0, 0) != 0) {
1236 topo_mod_dprintf(mod,
1237 "topo_node_create_range() failed: %s",
1238 topo_mod_errmsg(mod));
1239 return (-1);
1240 }
1241
1242 /*
1243 * Look through all SAS addresses and attempt to correlate them to a
1244 * known Solaris device. If we don't find a matching node, then we
1245 * don't enumerate the disk node.
1246 * Note that TOPO_PROP_SAS_ADDR prop includes SAS address from
1247 * alternate elements that represent the same device.
1248 */
1249 if (topo_prop_get_string_array(pnode, TOPO_PGROUP_SES,
1250 TOPO_PROP_SAS_ADDR, &paths, &nsas, &err) != 0)
1251 return (0);
1252
1253 err = 0;
1254
1255 for (s = 0; s < nsas; s++) {
1256 ret = disk_declare_addr(mod, pnode, &sdp->sed_devs, paths[s],
1257 &child);
1258 if (ret == 0) {
1259 break;
1260 } else if (ret < 0) {
1261 err = -1;
1262 break;
1263 }
1264 }
1265
1266 /*
1267 * We need to take another pass through the properties for this bay by
1268 * iterating over the phys and noting if any of these are SATA. Note,
1269 * this information isn't commonly part of the topo tree at this time,
1270 * hence why we end up going back and iterating over the properties
1271 * ourselves.
1272 */
1273 if (s == nsas) {
1274 if (ses_create_disk_bridge(sdp, pnode, props, &child) != 0)
1275 (void) disk_declare_non_enumerated(mod, pnode, &child);
1276 }
1277
1278 /* copy sas_addresses (target-ports) from parent (with 'w'added) */
1279 if (child != NULL) {
1280 int i;
1281 char **tports;
1282 uint64_t wwn;
1283
1284 tports = topo_mod_zalloc(mod, sizeof (char *) * nsas);
1285 if (tports != NULL) {
1286 for (i = 0; i < nsas; i++) {
1287 if (scsi_wwnstr_to_wwn(paths[i], &wwn) !=
1288 DDI_SUCCESS)
1289 break;
1290 tports[i] = scsi_wwn_to_wwnstr(wwn, 1, NULL);
1291 if (tports[i] == NULL)
1292 break;
1293 }
1294 /* if they all worked then create the property */
1295 if (i == nsas)
1296 (void) topo_prop_set_string_array(child,
1297 TOPO_PGROUP_STORAGE,
1298 TOPO_STORAGE_TARGET_PORT_L0IDS,
1299 TOPO_PROP_IMMUTABLE, (const char **)tports,
1300 nsas, &err);
1301
1302 for (i = 0; i < nsas; i++)
1303 if (tports[i] != NULL)
1304 scsi_free_wwnstr(tports[i]);
1305 topo_mod_free(mod, tports, sizeof (char *) * nsas);
1306 }
1307 }
1308
1309 for (s = 0; s < nsas; s++)
1310 topo_mod_free(mod, paths[s], strlen(paths[s]) + 1);
1311 topo_mod_free(mod, paths, nsas * sizeof (char *));
1312
1313 return (err);
1314 }
1315
1316 static int
1317 ses_add_bay_props(topo_mod_t *mod, tnode_t *tn, ses_enum_node_t *snp)
1318 {
1319 ses_alt_node_t *ap;
1320 ses_node_t *np;
1321 nvlist_t *props;
1322
1323 nvlist_t **phys;
1324 uint_t i, j, n_phys, all_phys = 0;
1325 char **paths;
1326 uint64_t addr;
1327 size_t len;
1328 int terr, err = -1;
1329
1330 for (ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL;
1331 ap = topo_list_next(ap)) {
1332 np = ap->san_node;
1333 props = ses_node_props(np);
1334
1335 if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS,
1336 &phys, &n_phys) != 0)
1337 continue;
1338
1339 all_phys += n_phys;
1340 }
1341
1342 if (all_phys == 0)
1343 return (0);
1344
1345 if ((paths = topo_mod_zalloc(mod, all_phys * sizeof (char *))) == NULL)
1346 return (-1);
1347
1348 for (i = 0, ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL;
1349 ap = topo_list_next(ap)) {
1350 np = ap->san_node;
1351 props = ses_node_props(np);
1352
1353 if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS,
1354 &phys, &n_phys) != 0)
1355 continue;
1356
1357 for (j = 0; j < n_phys; j++) {
1358 if (nvlist_lookup_uint64(phys[j], SES_SAS_PROP_ADDR,
1359 &addr) != 0)
1360 continue;
1361
1362 len = snprintf(NULL, 0, "%016llx", addr) + 1;
1363 if ((paths[i] = topo_mod_alloc(mod, len)) == NULL)
1364 goto error;
1365
1366 (void) snprintf(paths[i], len, "%016llx", addr);
1367
1368 ++i;
1369 }
1370 }
1371
1372 err = topo_prop_set_string_array(tn, TOPO_PGROUP_SES,
1373 TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE,
1374 (const char **)paths, i, &terr);
1375 if (err != 0)
1376 err = topo_mod_seterrno(mod, terr);
1377
1378 error:
1379 for (i = 0; i < all_phys && paths[i] != NULL; i++)
1380 topo_mod_free(mod, paths[i], strlen(paths[i]) + 1);
1381 topo_mod_free(mod, paths, all_phys * sizeof (char *));
1382
1383 return (err);
1384 }
1385
1386 /*
1387 * Callback to create a basic node (bay, psu, fan, or controller and expander).
1388 */
1389 static int
1390 ses_create_generic(ses_enum_data_t *sdp, ses_enum_node_t *snp, tnode_t *pnode,
1391 tnode_t *frutn, const char *nodename, const char *labelname,
1392 tnode_t **node)
1393 {
1394 ses_node_t *np = snp->sen_node;
1395 ses_node_t *parent;
1396 uint64_t instance = snp->sen_instance;
1397 topo_mod_t *mod = sdp->sed_mod;
1398 nvlist_t *props, *aprops;
1399 nvlist_t *auth = NULL, *fmri = NULL;
1400 tnode_t *tn = NULL;
1401 char label[128];
1402 int err;
1403 char *part = NULL, *serial = NULL, *revision = NULL;
1404 char *desc;
1405 boolean_t report;
1406
1407 props = ses_node_props(np);
1408
1409 (void) nvlist_lookup_string(props, LIBSES_PROP_PART, &part);
1410 (void) nvlist_lookup_string(props, LIBSES_PROP_SERIAL, &serial);
1411
1412 topo_mod_dprintf(mod, "adding %s %llu", nodename, instance);
1413
1414 /*
1415 * Create the node. The interesting information is all copied from the
1416 * parent enclosure node, so there is not much to do.
1417 */
1418 if ((auth = topo_mod_auth(mod, pnode)) == NULL)
1419 goto error;
1420
1421 /*
1422 * We want to report revision information for the controller nodes, but
1423 * we do not get per-element revision information. However, we do have
1424 * revision information for the entire enclosure, and we can use the
1425 * 'reported-via' property to know that this controller corresponds to
1426 * the given revision information. This means we cannot get revision
1427 * information for targets we are not explicitly connected to, but
1428 * there is little we can do about the situation.
1429 */
1430 if (strcmp(nodename, CONTROLLER) == 0 &&
1431 nvlist_lookup_boolean_value(props, SES_PROP_REPORT, &report) == 0 &&
1432 report) {
1433 for (parent = ses_node_parent(np); parent != NULL;
1434 parent = ses_node_parent(parent)) {
1435 if (ses_node_type(parent) == SES_NODE_ENCLOSURE) {
1436 (void) nvlist_lookup_string(
1437 ses_node_props(parent),
1438 SES_EN_PROP_REV, &revision);
1439 break;
1440 }
1441 }
1442 }
1443
1444 if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION,
1445 nodename, (topo_instance_t)instance, NULL, auth, part, revision,
1446 serial)) == NULL) {
1447 topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
1448 topo_mod_errmsg(mod));
1449 goto error;
1450 }
1451
1452 if ((tn = topo_node_bind(mod, pnode, nodename,
1453 instance, fmri)) == NULL) {
1454 topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
1455 topo_mod_errmsg(mod));
1456 goto error;
1457 }
1458
1459 /*
1460 * For the node label, we look for the following in order:
1461 *
1462 * <ses-description>
1463 * <ses-class-description> <instance>
1464 * <default-type-label> <instance>
1465 */
1466 if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 ||
1467 desc[0] == '\0') {
1468 parent = ses_node_parent(np);
1469 aprops = ses_node_props(parent);
1470 if (nvlist_lookup_string(aprops, SES_PROP_CLASS_DESCRIPTION,
1471 &desc) != 0 || desc[0] == '\0')
1472 desc = (char *)labelname;
1473 (void) snprintf(label, sizeof (label), "%s %llu", desc,
1474 instance);
1475 desc = label;
1476 }
1477
1478 if (topo_node_label_set(tn, desc, &err) != 0)
1479 goto error;
1480
1481 if (ses_set_standard_props(mod, frutn, tn, NULL, ses_node_id(np),
1482 snp->sen_target->set_devpath) != 0)
1483 goto error;
1484
1485 if (strcmp(nodename, BAY) == 0) {
1486 if (ses_add_bay_props(mod, tn, snp) != 0)
1487 goto error;
1488
1489 if (ses_create_disk(sdp, tn, props) != 0)
1490 goto error;
1491
1492 if (topo_method_register(mod, tn, ses_bay_methods) != 0) {
1493 topo_mod_dprintf(mod,
1494 "topo_method_register() failed: %s",
1495 topo_mod_errmsg(mod));
1496 goto error;
1497 }
1498 } else if ((strcmp(nodename, FAN) == 0) ||
1499 (strcmp(nodename, PSU) == 0) ||
1500 (strcmp(nodename, CONTROLLER) == 0)) {
1501 /*
1502 * Only fan, psu, and controller nodes have a 'present' method.
1503 * Bay nodes are always present, and disk nodes are present by
1504 * virtue of being enumerated and SAS expander nodes and
1505 * SAS connector nodes are also always present once
1506 * the parent controller is found.
1507 */
1508 if (topo_method_register(mod, tn, ses_component_methods) != 0) {
1509 topo_mod_dprintf(mod,
1510 "topo_method_register() failed: %s",
1511 topo_mod_errmsg(mod));
1512 goto error;
1513 }
1514
1515 }
1516
1517 snp->sen_target->set_refcount++;
1518 topo_node_setspecific(tn, snp->sen_target);
1519
1520 nvlist_free(auth);
1521 nvlist_free(fmri);
1522 if (node != NULL) *node = tn;
1523 return (0);
1524
1525 error:
1526 nvlist_free(auth);
1527 nvlist_free(fmri);
1528 return (-1);
1529 }
1530
1531 /*
1532 * Create SAS expander specific props.
1533 */
1534 /*ARGSUSED*/
1535 static int
1536 ses_set_expander_props(ses_enum_data_t *sdp, ses_enum_node_t *snp,
1537 tnode_t *ptnode, tnode_t *tnode, int *phycount, int64_t *connlist)
1538 {
1539 ses_node_t *np = snp->sen_node;
1540 topo_mod_t *mod = sdp->sed_mod;
1541 nvlist_t *auth = NULL, *fmri = NULL;
1542 nvlist_t *props, **phylist;
1543 int err, i;
1544 uint_t pcount;
1545 uint64_t sasaddr, connidx;
1546 char sasaddr_str[17];
1547 boolean_t found = B_FALSE, ses_found = B_FALSE;
1548 dev_di_node_t *dnode, *sesdnode;
1549
1550 props = ses_node_props(np);
1551
1552 /*
1553 * the uninstalled expander is not enumerated by checking
1554 * the element status code. No present present' method provided.
1555 */
1556 /*
1557 * Get the Expander SAS address. It should exist.
1558 */
1559 if (nvlist_lookup_uint64(props, SES_EXP_PROP_SAS_ADDR,
1560 &sasaddr) != 0) {
1561 topo_mod_dprintf(mod,
1562 "Failed to get prop %s.", SES_EXP_PROP_SAS_ADDR);
1563 goto error;
1564 }
1565
1566 (void) sprintf(sasaddr_str, "%llx", sasaddr);
1567
1568 /* search matching dev_di_node. */
1569 for (dnode = topo_list_next(&sdp->sed_devs); dnode != NULL;
1570 dnode = topo_list_next(dnode)) {
1571 for (i = 0; i < dnode->ddn_ppath_count; i++) {
1572 if ((dnode->ddn_target_port[i] != NULL) &&
1573 (strstr(dnode->ddn_target_port[i],
1574 sasaddr_str) != NULL)) {
1575 found = B_TRUE;
1576 break;
1577 }
1578 }
1579 if (found)
1580 break;
1581 }
1582
1583 if (!found) {
1584 topo_mod_dprintf(mod,
1585 "ses_set_expander_props: Failed to find matching "
1586 "devinfo node for Exapnder SAS address %s",
1587 SES_EXP_PROP_SAS_ADDR);
1588 /* continue on to get storage group props. */
1589 } else {
1590 /* create/set the devfs-path and devid in the smp group */
1591 if (topo_pgroup_create(tnode, &smp_pgroup, &err) != 0) {
1592 topo_mod_dprintf(mod, "ses_set_expander_props: "
1593 "failed to create smp property group %s\n",
1594 topo_strerror(err));
1595 goto error;
1596 } else {
1597 if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP,
1598 TOPO_PROP_SMP_TARGET_PORT, TOPO_PROP_IMMUTABLE,
1599 dnode->ddn_target_port[i], &err) != 0) {
1600 topo_mod_dprintf(mod, "ses_set_expander_props: "
1601 "set %S error %s\n", TOPO_PROP_SAS_ADDR,
1602 topo_strerror(err));
1603 }
1604 if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP,
1605 TOPO_PROP_SMP_DEV_PATH, TOPO_PROP_IMMUTABLE,
1606 dnode->ddn_dpath, &err) != 0) {
1607 topo_mod_dprintf(mod, "ses_set_expander_props: "
1608 "set dev error %s\n", topo_strerror(err));
1609 }
1610 if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP,
1611 TOPO_PROP_SMP_DEVID, TOPO_PROP_IMMUTABLE,
1612 dnode->ddn_devid, &err) != 0) {
1613 topo_mod_dprintf(mod, "ses_set_expander_props: "
1614 "set devid error %s\n", topo_strerror(err));
1615 }
1616 if (dnode->ddn_ppath_count != 0 &&
1617 topo_prop_set_string_array(tnode, TOPO_PGROUP_SMP,
1618 TOPO_PROP_SMP_PHYS_PATH, TOPO_PROP_IMMUTABLE,
1619 (const char **)dnode->ddn_ppath,
1620 dnode->ddn_ppath_count, &err) != 0) {
1621 topo_mod_dprintf(mod, "ses_set_expander_props: "
1622 "set phys-path error %s\n",
1623 topo_strerror(err));
1624 }
1625 }
1626 }
1627
1628 /* update the ses property group with SES target info */
1629 if ((topo_pgroup_create(tnode, &ses_pgroup, &err) != 0) &&
1630 (err != ETOPO_PROP_DEFD)) {
1631 /* SES prop group doesn't exist but failed to be created. */
1632 topo_mod_dprintf(mod, "ses_set_expander_props: "
1633 "ses pgroup create error %s\n", topo_strerror(err));
1634 goto error;
1635 } else {
1636 /* locate assciated enclosure dev_di_node. */
1637 for (sesdnode = topo_list_next(&sdp->sed_devs);
1638 sesdnode != NULL; sesdnode = topo_list_next(sesdnode)) {
1639 for (i = 0; i < sesdnode->ddn_ppath_count; i++) {
1640 /*
1641 * check if attached port exists and
1642 * its node type is enclosure and
1643 * attached port is same as sas address of
1644 * the expander and
1645 * bridge port for virtual phy indication
1646 * exist.
1647 */
1648 if ((sesdnode->ddn_attached_port[i] != NULL) &&
1649 (sesdnode->ddn_dtype == DTYPE_ESI) &&
1650 (strstr(sesdnode->ddn_attached_port[i],
1651 sasaddr_str) != NULL) &&
1652 (sesdnode->ddn_bridge_port[i] != NULL)) {
1653 ses_found = B_TRUE;
1654 break;
1655 }
1656 }
1657 if (ses_found) break;
1658 }
1659
1660 if (ses_found) {
1661 if (topo_prop_set_string(tnode, TOPO_PGROUP_SES,
1662 TOPO_PROP_SES_TARGET_PORT, TOPO_PROP_IMMUTABLE,
1663 sesdnode->ddn_target_port[i], &err) != 0) {
1664 topo_mod_dprintf(mod, "ses_set_expander_props: "
1665 "set ses %S error %s\n", TOPO_PROP_SAS_ADDR,
1666 topo_strerror(err));
1667 }
1668 if (topo_prop_set_string(tnode, TOPO_PGROUP_SES,
1669 TOPO_PROP_SES_DEV_PATH, TOPO_PROP_IMMUTABLE,
1670 sesdnode->ddn_dpath, &err) != 0) {
1671 topo_mod_dprintf(mod, "ses_set_expander_props: "
1672 "set ses dev error %s\n",
1673 topo_strerror(err));
1674 }
1675 if (topo_prop_set_string(tnode, TOPO_PGROUP_SES,
1676 TOPO_PROP_SES_DEVID, TOPO_PROP_IMMUTABLE,
1677 sesdnode->ddn_devid, &err) != 0) {
1678 topo_mod_dprintf(mod, "ses_set_expander_props: "
1679 "set ses devid error %s\n",
1680 topo_strerror(err));
1681 }
1682 if (sesdnode->ddn_ppath_count != 0 &&
1683 topo_prop_set_string_array(tnode, TOPO_PGROUP_SES,
1684 TOPO_PROP_SES_PHYS_PATH, TOPO_PROP_IMMUTABLE,
1685 (const char **)sesdnode->ddn_ppath,
1686 sesdnode->ddn_ppath_count, &err) != 0) {
1687 topo_mod_dprintf(mod, "ses_set_expander_props: "
1688 "set ses phys-path error %s\n",
1689 topo_strerror(err));
1690 }
1691
1692 }
1693 }
1694
1695 /* create the storage group */
1696 if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) {
1697 topo_mod_dprintf(mod, "ses_set_expander_props: "
1698 "create storage error %s\n", topo_strerror(err));
1699 goto error;
1700 } else {
1701 /* set the SAS address prop out of expander element status. */
1702 if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE,
1703 TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE, sasaddr_str,
1704 &err) != 0) {
1705 topo_mod_dprintf(mod, "ses_set_expander_props: "
1706 "set %S error %s\n", TOPO_PROP_SAS_ADDR,
1707 topo_strerror(err));
1708 }
1709
1710 /* Get the phy information for the expander */
1711 if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS,
1712 &phylist, &pcount) != 0) {
1713 topo_mod_dprintf(mod,
1714 "Failed to get prop %s.", SES_SAS_PROP_PHYS);
1715 } else {
1716 /*
1717 * For each phy, get the connector element index and
1718 * stores into connector element index array.
1719 */
1720 *phycount = pcount;
1721 for (i = 0; i < pcount; i++) {
1722 if (nvlist_lookup_uint64(phylist[i],
1723 SES_PROP_CE_IDX, &connidx) == 0) {
1724 if (connidx != 0xff) {
1725 connlist[i] = connidx;
1726 } else {
1727 connlist[i] = -1;
1728 }
1729 } else {
1730 /* Fail to get the index. set to -1. */
1731 connlist[i] = -1;
1732 }
1733 }
1734
1735 /* set the phy count prop of the expander. */
1736 if (topo_prop_set_uint64(tnode, TOPO_PGROUP_STORAGE,
1737 TOPO_PROP_PHY_COUNT, TOPO_PROP_IMMUTABLE, pcount,
1738 &err) != 0) {
1739 topo_mod_dprintf(mod, "ses_set_expander_props: "
1740 "set %S error %s\n", TOPO_PROP_PHY_COUNT,
1741 topo_strerror(err));
1742 }
1743
1744 /*
1745 * set the connector element index of
1746 * the expander phys.
1747 */
1748 }
1749
1750 /* populate other misc storage group properties */
1751 if (found) {
1752 if (dnode->ddn_mfg && (topo_prop_set_string(tnode,
1753 TOPO_PGROUP_STORAGE, TOPO_STORAGE_MANUFACTURER,
1754 TOPO_PROP_IMMUTABLE, dnode->ddn_mfg, &err) != 0)) {
1755 topo_mod_dprintf(mod, "ses_set_expander_props: "
1756 "set mfg error %s\n", topo_strerror(err));
1757 }
1758
1759 if (dnode->ddn_model && (topo_prop_set_string(tnode,
1760 TOPO_PGROUP_STORAGE, TOPO_STORAGE_MODEL,
1761 TOPO_PROP_IMMUTABLE,
1762 dnode->ddn_model, &err) != 0)) {
1763 topo_mod_dprintf(mod, "ses_set_expander_props: "
1764 "set model error %s\n", topo_strerror(err));
1765 }
1766
1767 if (dnode->ddn_serial && (topo_prop_set_string(tnode,
1768 TOPO_PGROUP_STORAGE, TOPO_STORAGE_SERIAL_NUM,
1769 TOPO_PROP_IMMUTABLE,
1770 dnode->ddn_serial, &err) != 0)) {
1771 topo_mod_dprintf(mod, "ses_set_expander_props: "
1772 "set serial error %s\n",
1773 topo_strerror(err));
1774 }
1775
1776 if (dnode->ddn_firm && (topo_prop_set_string(tnode,
1777 TOPO_PGROUP_STORAGE,
1778 TOPO_STORAGE_FIRMWARE_REV, TOPO_PROP_IMMUTABLE,
1779 dnode->ddn_firm, &err) != 0)) {
1780 topo_mod_dprintf(mod, "ses_set_expander_props: "
1781 "set firm error %s\n", topo_strerror(err));
1782 }
1783 }
1784 }
1785
1786 return (0);
1787
1788 error:
1789 nvlist_free(auth);
1790 nvlist_free(fmri);
1791 return (-1);
1792 }
1793
1794 /*
1795 * Create SAS expander specific props.
1796 */
1797 /*ARGSUSED*/
1798 static int
1799 ses_set_connector_props(ses_enum_data_t *sdp, ses_enum_node_t *snp,
1800 tnode_t *tnode, int64_t phy_mask)
1801 {
1802 ses_node_t *np = snp->sen_node;
1803 topo_mod_t *mod = sdp->sed_mod;
1804 nvlist_t *props;
1805 int err, i;
1806 uint64_t conntype;
1807 char phymask_str[17], *conntype_str;
1808 boolean_t found;
1809
1810 props = ses_node_props(np);
1811
1812 /*
1813 * convert phy mask to string.
1814 */
1815 (void) snprintf(phymask_str, 17, "%llx", phy_mask);
1816
1817 /* create the storage group */
1818 if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) {
1819 topo_mod_dprintf(mod, "ses_set_expander_props: "
1820 "create storage error %s\n", topo_strerror(err));
1821 return (-1);
1822 } else {
1823 /* set the SAS address prop of the expander. */
1824 if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE,
1825 TOPO_STORAGE_SAS_PHY_MASK, TOPO_PROP_IMMUTABLE,
1826 phymask_str, &err) != 0) {
1827 topo_mod_dprintf(mod, "ses_set_expander_props: "
1828 "set %S error %s\n", TOPO_STORAGE_SAS_PHY_MASK,
1829 topo_strerror(err));
1830 }
1831
1832 /* Get the connector type information for the expander */
1833 if (nvlist_lookup_uint64(props,
1834 SES_SC_PROP_CONNECTOR_TYPE, &conntype) != 0) {
1835 topo_mod_dprintf(mod, "Failed to get prop %s.",
1836 TOPO_STORAGE_SAS_PHY_MASK);
1837 } else {
1838 found = B_FALSE;
1839 for (i = 0; ; i++) {
1840 if (sas_connector_type_list[i].sct_type ==
1841 SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) {
1842 break;
1843 }
1844 if (sas_connector_type_list[i].sct_type ==
1845 conntype) {
1846 conntype_str =
1847 sas_connector_type_list[i].sct_name;
1848 found = B_TRUE;
1849 break;
1850 }
1851 }
1852
1853 if (!found) {
1854 if (conntype <
1855 SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) {
1856 conntype_str =
1857 SAS_CONNECTOR_TYPE_RESERVED;
1858 } else {
1859 conntype_str =
1860 SAS_CONNECTOR_TYPE_NOT_DEFINED;
1861 }
1862 }
1863
1864 /* set the phy count prop of the expander. */
1865 if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE,
1866 TOPO_STORAGE_SAS_CONNECTOR_TYPE,
1867 TOPO_PROP_IMMUTABLE, conntype_str, &err) != 0) {
1868 topo_mod_dprintf(mod, "ses_set_expander_props: "
1869 "set %S error %s\n", TOPO_PROP_PHY_COUNT,
1870 topo_strerror(err));
1871 }
1872 }
1873 }
1874
1875 return (0);
1876 }
1877
1878 /*
1879 * Instantiate SAS expander nodes for a given ESC Electronics node(controller)
1880 * nodes.
1881 */
1882 /*ARGSUSED*/
1883 static int
1884 ses_create_esc_sasspecific(ses_enum_data_t *sdp, ses_enum_node_t *snp,
1885 tnode_t *pnode, ses_enum_chassis_t *cp,
1886 boolean_t dorange)
1887 {
1888 topo_mod_t *mod = sdp->sed_mod;
1889 tnode_t *exptn, *contn;
1890 boolean_t found;
1891 sas_connector_phy_data_t connectors[64] = {NULL};
1892 uint64_t max;
1893 ses_enum_node_t *ctlsnp, *xsnp, *consnp;
1894 ses_node_t *np = snp->sen_node;
1895 nvlist_t *props, *psprops;
1896 uint64_t index, psindex, conindex, psstatus, i, j, count;
1897 int64_t cidxlist[256] = {NULL};
1898 int phycount;
1899
1900 props = ses_node_props(np);
1901
1902 if (nvlist_lookup_uint64(props, SES_PROP_ELEMENT_ONLY_INDEX,
1903 &index) != 0)
1904 return (-1);
1905
1906 /*
1907 * For SES constroller node, check to see if there are
1908 * associated SAS expanders.
1909 */
1910 found = B_FALSE;
1911 max = 0;
1912 for (ctlsnp = topo_list_next(&cp->sec_nodes); ctlsnp != NULL;
1913 ctlsnp = topo_list_next(ctlsnp)) {
1914 if (ctlsnp->sen_type == SES_ET_SAS_EXPANDER) {
1915 found = B_TRUE;
1916 if (ctlsnp->sen_instance > max)
1917 max = ctlsnp->sen_instance;
1918 }
1919 }
1920
1921 /*
1922 * No SAS expander found notthing to process.
1923 */
1924 if (!found)
1925 return (0);
1926
1927 topo_mod_dprintf(mod, "%s Controller %d: creating "
1928 "%llu %s nodes", cp->sec_csn, index, max + 1, SASEXPANDER);
1929
1930 /*
1931 * The max number represent the number of elements
1932 * deducted from the highest SES_PROP_ELEMENT_CLASS_INDEX
1933 * of SET_ET_SAS_EXPANDER type element.
1934 *
1935 * There may be multiple ESC Electronics element(controllers)
1936 * within JBOD(typicall two for redundancy) and SAS expander
1937 * elements are associated with only one of them. We are
1938 * still creating the range based max number here.
1939 * That will cover the case that all expanders are associated
1940 * with one SES controller.
1941 */
1942 if (dorange && topo_node_range_create(mod, pnode,
1943 SASEXPANDER, 0, max) != 0) {
1944 topo_mod_dprintf(mod,
1945 "topo_node_create_range() failed: %s",
1946 topo_mod_errmsg(mod));
1947 return (-1);
1948 }
1949
1950 /*
1951 * Search exapnders with the parent index matching with
1952 * ESC Electronics element index.
1953 * Note the index used here is a global index across
1954 * SES elements.
1955 */
1956 for (xsnp = topo_list_next(&cp->sec_nodes); xsnp != NULL;
1957 xsnp = topo_list_next(xsnp)) {
1958 if (xsnp->sen_type == SES_ET_SAS_EXPANDER) {
1959 /*
1960 * get the parent ESC controller.
1961 */
1962 psprops = ses_node_props(xsnp->sen_node);
1963 if (nvlist_lookup_uint64(psprops,
1964 SES_PROP_STATUS_CODE, &psstatus) == 0) {
1965 if (psstatus == SES_ESC_NOT_INSTALLED) {
1966 /*
1967 * Not installed.
1968 * Don't create a ndoe.
1969 */
1970 continue;
1971 }
1972 } else {
1973 /*
1974 * The element should have status code.
1975 * If not there is no way to find
1976 * out if the expander element exist or
1977 * not.
1978 */
1979 continue;
1980 }
1981
1982 /* Get the physical parent index to compare. */
1983 if (nvlist_lookup_uint64(psprops,
1984 LIBSES_PROP_PHYS_PARENT, &psindex) == 0) {
1985 if (index == psindex) {
1986 /* indentation moved forward */
1987 /*
1988 * Handle basic node information of SAS expander
1989 * element - binding to parent node and
1990 * allocating FMRI...
1991 */
1992 if (ses_create_generic(sdp, xsnp, pnode, pnode, SASEXPANDER,
1993 "SAS-EXPANDER", &exptn) != 0)
1994 continue;
1995 /*
1996 * Now handle SAS expander unique portion of node creation.
1997 * The max nubmer of the phy count is 256 since SES-2
1998 * defines as 1 byte field. The cidxlist has the same
1999 * number of elements.
2000 *
2001 * We use size 64 array to store the connectors.
2002 * Typically a connectors associated with 4 phys so that
2003 * matches with the max number of connecters associated
2004 * with an expander.
2005 * The phy count goes up to 38 for Sun supported
2006 * JBOD.
2007 */
2008 (void) memset(cidxlist, 0, sizeof (int64_t) * 64);
2009 if (ses_set_expander_props(sdp, xsnp, pnode, exptn, &phycount,
2010 cidxlist) != 0) {
2011 /*
2012 * error on getting specific prop failed.
2013 * continue on. Note that the node is
2014 * left bound.
2015 */
2016 continue;
2017 }
2018
2019 /*
2020 * count represetns the number of connectors discovered so far.
2021 */
2022 count = 0;
2023 (void) memset(connectors, 0,
2024 sizeof (sas_connector_phy_data_t) * 64);
2025 for (i = 0; i < phycount; i++) {
2026 if (cidxlist[i] != -1) {
2027 /* connector index is valid. */
2028 for (j = 0; j < count; j++) {
2029 if (connectors[j].scpd_index ==
2030 cidxlist[i]) {
2031 /*
2032 * Just update phy mask.
2033 * The postion for connector
2034 * index lists(cidxlist index)
2035 * is set.
2036 */
2037 connectors[j].scpd_pm =
2038 connectors[j].scpd_pm |
2039 (1ULL << i);
2040 break;
2041 }
2042 }
2043 /*
2044 * If j and count matche a new connector
2045 * index is found.
2046 */
2047 if (j == count) {
2048 /* add a new index and phy mask. */
2049 connectors[count].scpd_index =
2050 cidxlist[i];
2051 connectors[count].scpd_pm =
2052 connectors[count].scpd_pm |
2053 (1ULL << i);
2054 count++;
2055 }
2056 }
2057 }
2058
2059 /*
2060 * create range for the connector nodes.
2061 * The class index of the ses connector element
2062 * is set as the instance nubmer for the node.
2063 * Even though one expander may not have all connectors
2064 * are associated with we are creating the range with
2065 * max possible instance number.
2066 */
2067 found = B_FALSE;
2068 max = 0;
2069 for (consnp = topo_list_next(&cp->sec_nodes);
2070 consnp != NULL; consnp = topo_list_next(consnp)) {
2071 if (consnp->sen_type == SES_ET_SAS_CONNECTOR) {
2072 psprops = ses_node_props(consnp->sen_node);
2073 found = B_TRUE;
2074 if (consnp->sen_instance > max)
2075 max = consnp->sen_instance;
2076 }
2077 }
2078
2079 /*
2080 * No SAS connector found nothing to process.
2081 */
2082 if (!found)
2083 return (0);
2084
2085 if (dorange && topo_node_range_create(mod, exptn,
2086 RECEPTACLE, 0, max) != 0) {
2087 topo_mod_dprintf(mod,
2088 "topo_node_create_range() failed: %s",
2089 topo_mod_errmsg(mod));
2090 return (-1);
2091 }
2092
2093 /* search matching connector element using the index. */
2094 for (i = 0; i < count; i++) {
2095 found = B_FALSE;
2096 for (consnp = topo_list_next(&cp->sec_nodes);
2097 consnp != NULL; consnp = topo_list_next(consnp)) {
2098 if (consnp->sen_type == SES_ET_SAS_CONNECTOR) {
2099 psprops = ses_node_props(
2100 consnp->sen_node);
2101 /*
2102 * Get the physical parent index to
2103 * compare.
2104 * The connector elements are children
2105 * of ESC Electronics element even
2106 * though we enumerate them under
2107 * an expander in libtopo.
2108 */
2109 if (nvlist_lookup_uint64(psprops,
2110 SES_PROP_ELEMENT_ONLY_INDEX,
2111 &conindex) == 0) {
2112 if (conindex ==
2113 connectors[i].scpd_index) {
2114 found = B_TRUE;
2115 break;
2116 }
2117 }
2118 }
2119 }
2120
2121 /* now create a libtopo node. */
2122 if (found) {
2123 /* Create generic props. */
2124 if (ses_create_generic(sdp, consnp, exptn,
2125 topo_node_parent(exptn),
2126 RECEPTACLE, "RECEPTACLE", &contn) !=
2127 0) {
2128 continue;
2129 }
2130 /* Create connector specific props. */
2131 if (ses_set_connector_props(sdp, consnp,
2132 contn, connectors[i].scpd_pm) != 0) {
2133 continue;
2134 }
2135 }
2136 }
2137 /* end indentation change */
2138 }
2139 }
2140 }
2141 }
2142
2143 return (0);
2144 }
2145
2146 /*
2147 * Instantiate any protocol specific portion of a node.
2148 */
2149 /*ARGSUSED*/
2150 static int
2151 ses_create_protocol_specific(ses_enum_data_t *sdp, ses_enum_node_t *snp,
2152 tnode_t *pnode, uint64_t type, ses_enum_chassis_t *cp,
2153 boolean_t dorange)
2154 {
2155
2156 if (type == SES_ET_ESC_ELECTRONICS) {
2157 /* create SAS specific children(expanders and connectors. */
2158 return (ses_create_esc_sasspecific(sdp, snp, pnode, cp,
2159 dorange));
2160 }
2161
2162 return (0);
2163 }
2164
2165 /*
2166 * Instantiate any children of a given type.
2167 */
2168 static int
2169 ses_create_children(ses_enum_data_t *sdp, tnode_t *pnode, uint64_t type,
2170 const char *nodename, const char *defaultlabel, ses_enum_chassis_t *cp,
2171 boolean_t dorange)
2172 {
2173 topo_mod_t *mod = sdp->sed_mod;
2174 boolean_t found;
2175 uint64_t max;
2176 ses_enum_node_t *snp;
2177 tnode_t *tn;
2178
2179 /*
2180 * First go through and count how many matching nodes we have.
2181 */
2182 max = 0;
2183 found = B_FALSE;
2184 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2185 snp = topo_list_next(snp)) {
2186 if (snp->sen_type == type) {
2187 found = B_TRUE;
2188 if (snp->sen_instance > max)
2189 max = snp->sen_instance;
2190 }
2191 }
2192
2193 /*
2194 * No enclosure should export both DEVICE and ARRAY_DEVICE elements.
2195 * Since we map both of these to 'disk', if an enclosure does this, we
2196 * just ignore the array elements.
2197 */
2198 if (!found ||
2199 (type == SES_ET_ARRAY_DEVICE && cp->sec_hasdev))
2200 return (0);
2201
2202 topo_mod_dprintf(mod, "%s: creating %llu %s nodes",
2203 cp->sec_csn, max + 1, nodename);
2204
2205 if (dorange && topo_node_range_create(mod, pnode,
2206 nodename, 0, max) != 0) {
2207 topo_mod_dprintf(mod,
2208 "topo_node_create_range() failed: %s",
2209 topo_mod_errmsg(mod));
2210 return (-1);
2211 }
2212
2213 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2214 snp = topo_list_next(snp)) {
2215 if (snp->sen_type == type) {
2216 /*
2217 * With flat layout of ses nodes there is no
2218 * way to find out the direct FRU for a node.
2219 * Passing NULL for fru topo node. Note that
2220 * ses_create_children_from_phys_tree() provides
2221 * the actual direct FRU for a node.
2222 */
2223 if (ses_create_generic(sdp, snp, pnode, NULL,
2224 nodename, defaultlabel, &tn) != 0)
2225 return (-1);
2226 /*
2227 * For some SES element there may be protocol specific
2228 * information to process. Here we are processing
2229 * the association between enclosure controller and
2230 * SAS expanders.
2231 */
2232 if (type == SES_ET_ESC_ELECTRONICS) {
2233 /* create SAS expander node */
2234 if (ses_create_protocol_specific(sdp, snp,
2235 tn, type, cp, dorange) != 0) {
2236 return (-1);
2237 }
2238 }
2239
2240 }
2241 }
2242
2243 return (0);
2244 }
2245
2246 /*
2247 * Instantiate a new subchassis instance in the topology.
2248 */
2249 static int
2250 ses_create_subchassis(ses_enum_data_t *sdp, tnode_t *pnode,
2251 ses_enum_chassis_t *scp)
2252 {
2253 topo_mod_t *mod = sdp->sed_mod;
2254 tnode_t *tn;
2255 nvlist_t *props;
2256 nvlist_t *auth = NULL, *fmri = NULL;
2257 uint64_t instance = scp->sec_instance;
2258 char *desc;
2259 char label[128];
2260 char **paths;
2261 int i, err;
2262 ses_enum_target_t *stp;
2263 int ret = -1;
2264
2265 /*
2266 * Copy authority information from parent enclosure node
2267 */
2268 if ((auth = topo_mod_auth(mod, pnode)) == NULL)
2269 goto error;
2270
2271 /*
2272 * Record the subchassis serial number in the FMRI.
2273 * For now, we assume that logical id is the subchassis serial number.
2274 * If this assumption changes in future, then the following
2275 * piece of code will need to be updated via an RFE.
2276 */
2277 if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION,
2278 SUBCHASSIS, (topo_instance_t)instance, NULL, auth, NULL, NULL,
2279 NULL)) == NULL) {
2280 topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
2281 topo_mod_errmsg(mod));
2282 goto error;
2283 }
2284
2285 if ((tn = topo_node_bind(mod, pnode, SUBCHASSIS,
2286 instance, fmri)) == NULL) {
2287 topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
2288 topo_mod_errmsg(mod));
2289 goto error;
2290 }
2291
2292 props = ses_node_props(scp->sec_enclosure);
2293
2294 /*
2295 * Look for the subchassis label in the following order:
2296 * <ses-description>
2297 * <ses-class-description> <instance>
2298 * <default-type-label> <instance>
2299 *
2300 * For subchassis, the default label is "SUBCHASSIS"
2301 */
2302 if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 ||
2303 desc[0] == '\0') {
2304 if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION,
2305 &desc) == 0 && desc[0] != '\0')
2306 (void) snprintf(label, sizeof (label), "%s %llu", desc,
2307 instance);
2308 else
2309 (void) snprintf(label, sizeof (label),
2310 "SUBCHASSIS %llu", instance);
2311 desc = label;
2312 }
2313
2314 if (topo_node_label_set(tn, desc, &err) != 0)
2315 goto error;
2316
2317 if (ses_set_standard_props(mod, NULL, tn, NULL,
2318 ses_node_id(scp->sec_enclosure), scp->sec_target->set_devpath) != 0)
2319 goto error;
2320
2321 /*
2322 * Set the 'chassis-type' property for this subchassis. This is either
2323 * 'ses-class-description' or 'subchassis'.
2324 */
2325 if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION, &desc) != 0)
2326 desc = "subchassis";
2327
2328 if (topo_prop_set_string(tn, TOPO_PGROUP_SES,
2329 TOPO_PROP_CHASSIS_TYPE, TOPO_PROP_IMMUTABLE, desc, &err) != 0) {
2330 topo_mod_dprintf(mod, "failed to create property %s: %s\n",
2331 TOPO_PROP_CHASSIS_TYPE, topo_strerror(err));
2332 goto error;
2333 }
2334
2335 /*
2336 * For enclosures, we want to include all possible targets (for upgrade
2337 * purposes).
2338 */
2339 for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL;
2340 stp = topo_list_next(stp), i++)
2341 ;
2342
2343 verify(i != 0);
2344 paths = alloca(i * sizeof (char *));
2345
2346 for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL;
2347 stp = topo_list_next(stp), i++)
2348 paths[i] = stp->set_devpath;
2349
2350 if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES,
2351 TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths,
2352 i, &err) != 0) {
2353 topo_mod_dprintf(mod, "failed to create property %s: %s\n",
2354 TOPO_PROP_PATHS, topo_strerror(err));
2355 goto error;
2356 }
2357
2358 if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) {
2359 topo_mod_dprintf(mod, "topo_method_register() failed: %s",
2360 topo_mod_errmsg(mod));
2361 goto error;
2362 }
2363
2364 /*
2365 * Create the nodes for controllers and bays.
2366 */
2367 if (ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS,
2368 CONTROLLER, "CONTROLLER", scp, B_TRUE) != 0 ||
2369 ses_create_children(sdp, tn, SES_ET_DEVICE,
2370 BAY, "BAY", scp, B_TRUE) != 0 ||
2371 ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE,
2372 BAY, "BAY", scp, B_TRUE) != 0)
2373 goto error;
2374
2375 ret = 0;
2376
2377 error:
2378 nvlist_free(auth);
2379 nvlist_free(fmri);
2380 return (ret);
2381 }
2382
2383 /*
2384 * Function we use to insert a node.
2385 */
2386 static int
2387 ses_phys_tree_insert(topo_mod_t *mod, ses_phys_tree_t **sproot,
2388 ses_phys_tree_t *child)
2389 {
2390 uint64_t ppindex, eindex, pindex;
2391 ses_phys_tree_t *node_ptr;
2392 int ret = 0;
2393
2394 assert(sproot != NULL);
2395 assert(child != NULL);
2396
2397 if (*sproot == NULL) {
2398 *sproot = child;
2399 return (0);
2400 }
2401
2402 pindex = child->spt_pindex;
2403 ppindex = (*sproot)->spt_pindex;
2404 eindex = (*sproot)->spt_eonlyindex;
2405
2406 /*
2407 * If the element only index of the root is same as the physical
2408 * parent index of a node to be added, add the node as a child of
2409 * the current root.
2410 */
2411 if (eindex == pindex) {
2412 (void) ses_phys_tree_insert(mod, &(*sproot)->spt_child, child);
2413 child->spt_parent = *sproot;
2414 } else if (ppindex == pindex) {
2415 /*
2416 * if the physical parent of the current root and the child
2417 * is same, then this should be a sibling node.
2418 * Siblings can be different element types and arrange
2419 * them by group.
2420 */
2421 if ((*sproot)->spt_senumnode->sen_type ==
2422 child->spt_senumnode->sen_type) {
2423 child->spt_sibling = *sproot;
2424 *sproot = child;
2425 } else {
2426 /* add a node in front of matching element type. */
2427 node_ptr = *sproot;
2428 while (node_ptr->spt_sibling != NULL) {
2429 if (node_ptr->spt_sibling->
2430 spt_senumnode->sen_type ==
2431 child->spt_senumnode->sen_type) {
2432 child->spt_sibling =
2433 node_ptr->spt_sibling;
2434 node_ptr->spt_sibling = child;
2435 break;
2436 }
2437 node_ptr = node_ptr->spt_sibling;
2438 }
2439 /* no matching. Add the child at the end. */
2440 if (node_ptr->spt_sibling == NULL) {
2441 node_ptr->spt_sibling = child;
2442 }
2443 }
2444 child->spt_parent = (*sproot)->spt_parent;
2445 } else {
2446 /*
2447 * The root and the node is not directly related.
2448 * Try to insert to the child sub-tree first and then try to
2449 * insert to the sibling sub-trees. If fails for both
2450 * the caller will retry insertion later.
2451 */
2452 if ((*sproot)->spt_child) {
2453 ret = ses_phys_tree_insert(mod, &(*sproot)->spt_child,
2454 child);
2455 }
2456 if ((*sproot)->spt_child == NULL || ret != 0) {
2457 if ((*sproot)->spt_sibling) {
2458 ret = ses_phys_tree_insert(mod,
2459 &(*sproot)->spt_sibling, child);
2460 } else {
2461 ret = 1;
2462 }
2463 }
2464 return (ret);
2465 }
2466 return (0);
2467 }
2468
2469 /*
2470 * Construct tree view of ses elements through parent phyiscal element index.
2471 * The root of tree is already constructed using the enclosure element.
2472 */
2473 static int
2474 ses_construct_phys_tree(ses_enum_data_t *sdp, ses_enum_chassis_t *cp,
2475 ses_phys_tree_t *sproot)
2476 {
2477 ses_enum_node_t *snp;
2478 ses_phys_tree_t *child;
2479 ses_phys_tree_t *u_watch = NULL;
2480 ses_phys_tree_t *u_head = NULL;
2481 ses_phys_tree_t *u_tail = NULL;
2482 int u_inserted = 0, u_left = 0;
2483 nvlist_t *props;
2484 topo_mod_t *mod = sdp->sed_mod;
2485
2486 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2487 snp = topo_list_next(snp)) {
2488 if ((child = topo_mod_zalloc(mod,
2489 sizeof (ses_phys_tree_t))) == NULL) {
2490 topo_mod_dprintf(mod,
2491 "failed to allocate root.");
2492 return (-1);
2493 }
2494 child->spt_snode = snp->sen_node;
2495 props = ses_node_props(snp->sen_node);
2496 if (nvlist_lookup_uint64(props,
2497 LIBSES_PROP_PHYS_PARENT, &child->spt_pindex) != 0) {
2498 /*
2499 * the prop should exist. continue to see if
2500 * we can build a partial tree with other elements.
2501 */
2502 topo_mod_dprintf(mod,
2503 "ses_construct_phys_tree(): Failed to find prop %s "
2504 "on ses element type %d and instance %d "
2505 "(CSN %s).", LIBSES_PROP_PHYS_PARENT,
2506 snp->sen_type, snp->sen_instance, cp->sec_csn);
2507 topo_mod_free(mod, child, sizeof (ses_phys_tree_t));
2508 continue;
2509 } else {
2510 if (nvlist_lookup_boolean_value(props,
2511 LIBSES_PROP_FRU, &child->spt_isfru) != 0) {
2512 topo_mod_dprintf(mod,
2513 "ses_construct_phys_tree(): Failed to "
2514 "find prop %s on ses element type %d "
2515 "and instance %d (CSN %s).",
2516 LIBSES_PROP_FRU,
2517 snp->sen_type, snp->sen_instance,
2518 cp->sec_csn);
2519 /*
2520 * Ignore if the prop doesn't exist.
2521 * Note that the enclosure itself should be
2522 * a FRU so if no FRU found the enclosure FRU
2523 * can be a direct FRU.
2524 */
2525 }
2526 verify(nvlist_lookup_uint64(props,
2527 SES_PROP_ELEMENT_ONLY_INDEX,
2528 &child->spt_eonlyindex) == 0);
2529 verify(nvlist_lookup_uint64(props,
2530 SES_PROP_ELEMENT_CLASS_INDEX,
2531 &child->spt_cindex) == 0);
2532 }
2533 child->spt_senumnode = snp;
2534 if (ses_phys_tree_insert(mod, &sproot, child) != 0) {
2535 /* collect unresolved element to process later. */
2536 if (u_head == NULL) {
2537 u_head = child;
2538 u_tail = child;
2539 } else {
2540 child->spt_sibling = u_head;
2541 u_head = child;
2542 }
2543 }
2544 }
2545
2546 /*
2547 * The parent of a child node may not be inserted yet.
2548 * Trying to insert the child until no child is left or
2549 * no child is not added further. For the latter
2550 * the hierarchical relationship between elements
2551 * should be checked through SUNW,FRUID page.
2552 * u_watch is a watch dog to check the prgress of unresolved
2553 * node.
2554 */
2555 u_watch = u_tail;
2556 while (u_head) {
2557 child = u_head;
2558 u_head = u_head->spt_sibling;
2559 if (u_head == NULL)
2560 u_tail = NULL;
2561 child->spt_sibling = NULL;
2562 if (ses_phys_tree_insert(mod, &sproot, child) != 0) {
2563 u_tail->spt_sibling = child;
2564 u_tail = child;
2565 if (child == u_watch) {
2566 /*
2567 * We just scanned one round for the
2568 * unresolved list. Check to see whether we
2569 * have nodes inserted, if none, we should
2570 * break in case of an indefinite loop.
2571 */
2572 if (u_inserted == 0) {
2573 /*
2574 * Indicate there is unhandled node.
2575 * Chain free the whole unsolved
2576 * list here.
2577 */
2578 u_left++;
2579 break;
2580 } else {
2581 u_inserted = 0;
2582 u_watch = u_tail;
2583 }
2584 }
2585 } else {
2586 /*
2587 * We just inserted one rpnode, increment the
2588 * unsolved_inserted counter. We will utilize this
2589 * counter to detect an indefinite insertion loop.
2590 */
2591 u_inserted++;
2592 if (child == u_watch) {
2593 /*
2594 * watch dog node itself is inserted.
2595 * Set it to the tail and refresh the watching.
2596 */
2597 u_watch = u_tail;
2598 u_inserted = 0;
2599 u_left = 0;
2600 }
2601 }
2602 }
2603
2604 /* check if there is left out unresolved nodes. */
2605 if (u_left) {
2606 topo_mod_dprintf(mod, "ses_construct_phys_tree(): "
2607 "Failed to construct physical view of the following "
2608 "ses elements of Chassis CSN %s.", cp->sec_csn);
2609 while (u_head) {
2610 u_tail = u_head->spt_sibling;
2611 topo_mod_dprintf(mod,
2612 "\telement type (%d) and instance (%d)",
2613 u_head->spt_senumnode->sen_type,
2614 u_head->spt_senumnode->sen_instance);
2615 topo_mod_free(mod, u_head, sizeof (ses_phys_tree_t));
2616 u_head = u_tail;
2617 }
2618 return (-1);
2619 }
2620
2621 return (0);
2622 }
2623
2624 /*
2625 * Free the whole phys tree.
2626 */
2627 static void ses_phys_tree_free(topo_mod_t *mod, ses_phys_tree_t *sproot)
2628 {
2629 if (sproot == NULL)
2630 return;
2631
2632 /* Free child tree. */
2633 if (sproot->spt_child) {
2634 ses_phys_tree_free(mod, sproot->spt_child);
2635 }
2636
2637 /* Free sibling trees. */
2638 if (sproot->spt_sibling) {
2639 ses_phys_tree_free(mod, sproot->spt_sibling);
2640 }
2641
2642 /* Free root node itself. */
2643 topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t));
2644 }
2645
2646 /*
2647 * Parses phys_enum_type table to get the index of the given type.
2648 */
2649 static boolean_t
2650 is_type_enumerated(ses_phys_tree_t *node, int *index)
2651 {
2652 int i;
2653
2654 for (i = 0; i < N_PHYS_ENUM_TYPES; i++) {
2655 if (node->spt_senumnode->sen_type ==
2656 phys_enum_type_list[i].pet_type) {
2657 *index = i;
2658 return (B_TRUE);
2659 }
2660 }
2661 return (B_FALSE);
2662 }
2663
2664 /*
2665 * Recusrive routine for top-down enumeration of the tree.
2666 */
2667 static int
2668 ses_enumerate_node(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp,
2669 ses_phys_tree_t *parent, int mrange[])
2670 {
2671 topo_mod_t *mod = sdp->sed_mod;
2672 ses_phys_tree_t *child = NULL;
2673 int i, ret = 0, ret_ch;
2674 uint64_t prevtype = SES_ET_UNSPECIFIED;
2675 ses_phys_tree_t *dirfru = NULL;
2676 tnode_t *tn = NULL, *frutn = NULL;
2677
2678 if (parent == NULL) {
2679 return (0);
2680 }
2681
2682 for (child = parent->spt_child; child != NULL;
2683 child = child->spt_sibling) {
2684 if (is_type_enumerated(child, &i)) {
2685 if (prevtype != phys_enum_type_list[i].pet_type) {
2686 /* check if range needs to be created. */
2687 if (phys_enum_type_list[i].pet_dorange &&
2688 topo_node_range_create(mod, pnode,
2689 phys_enum_type_list[i].pet_nodename, 0,
2690 mrange[i]) != 0) {
2691 topo_mod_dprintf(mod,
2692 "topo_node_create_range() failed: "
2693 "%s", topo_mod_errmsg(mod));
2694 return (-1);
2695 }
2696 prevtype = phys_enum_type_list[i].pet_type;
2697 }
2698
2699 if (!(child->spt_isfru)) {
2700 for (dirfru = parent; dirfru != NULL;
2701 dirfru = dirfru->spt_parent) {
2702 if (dirfru->spt_isfru) {
2703 break;
2704 }
2705 }
2706 /* found direct FRU node. */
2707 if (dirfru) {
2708 frutn = dirfru->spt_tnode;
2709 } else {
2710 frutn = NULL;
2711 }
2712 } else {
2713 frutn = NULL;
2714 }
2715
2716 if (ses_create_generic(sdp, child->spt_senumnode,
2717 pnode, frutn, phys_enum_type_list[i].pet_nodename,
2718 phys_enum_type_list[i].pet_defaultlabel, &tn) != 0)
2719 return (-1);
2720
2721 child->spt_tnode = tn;
2722 /*
2723 * For some SES element there may be protocol specific
2724 * information to process. Here we are processing
2725 * the association between enclosure controller and
2726 * SAS expanders.
2727 */
2728 if (phys_enum_type_list[i].pet_type ==
2729 SES_ET_ESC_ELECTRONICS) {
2730 /* create SAS expander node */
2731 if (ses_create_protocol_specific(sdp,
2732 child->spt_senumnode, tn,
2733 phys_enum_type_list[i].pet_type,
2734 cp, phys_enum_type_list[i].pet_dorange) !=
2735 0) {
2736 return (-1);
2737 }
2738 }
2739 } else {
2740 continue;
2741 }
2742 ret_ch = ses_enumerate_node(sdp, tn, cp, child, mrange);
2743 if (ret_ch)
2744 ret = ret_ch; /* there was an error and set the ret. */
2745 }
2746
2747 return (ret);
2748 }
2749
2750 /*
2751 * Instantiate types of nodes that are specified in the hierarchy
2752 * element type list.
2753 */
2754 static int
2755 ses_create_children_from_phys_tree(ses_enum_data_t *sdp, tnode_t *pnode,
2756 ses_enum_chassis_t *cp, ses_phys_tree_t *phys_tree)
2757 {
2758 topo_mod_t *mod = sdp->sed_mod;
2759 int mrange[N_PHYS_ENUM_TYPES] = { 0 };
2760 ses_enum_node_t *snp;
2761 int i, ret;
2762
2763 /*
2764 * First get max range for each type of element to be enumerated.
2765 */
2766 for (i = 0; i < N_PHYS_ENUM_TYPES; i++) {
2767 if (phys_enum_type_list[i].pet_dorange) {
2768 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2769 snp = topo_list_next(snp)) {
2770 if (snp->sen_type ==
2771 phys_enum_type_list[i].pet_type) {
2772 if (snp->sen_instance > mrange[i])
2773 mrange[i] =
2774 snp->sen_instance;
2775 }
2776 }
2777 }
2778 }
2779
2780 topo_mod_dprintf(mod, "%s: creating nodes from FRU hierarchy tree.",
2781 cp->sec_csn);
2782
2783 if ((ret = ses_enumerate_node(sdp, pnode, cp, phys_tree, mrange)) !=
2784 0) {
2785 topo_mod_dprintf(mod,
2786 "ses_create_children_from_phys_tree() failed: ");
2787 return (ret);
2788 }
2789
2790 return (0);
2791 }
2792
2793 /*
2794 * Instantiate a new chassis instance in the topology.
2795 */
2796 static int
2797 ses_create_chassis(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp)
2798 {
2799 topo_mod_t *mod = sdp->sed_mod;
2800 nvlist_t *props;
2801 char *raw_manufacturer, *raw_model, *raw_revision;
2802 char *manufacturer = NULL, *model = NULL, *product = NULL;
2803 char *revision = NULL;
2804 char *serial;
2805 char **paths;
2806 size_t prodlen;
2807 tnode_t *tn;
2808 nvlist_t *fmri = NULL, *auth = NULL;
2809 int ret = -1;
2810 ses_enum_node_t *snp;
2811 ses_enum_target_t *stp;
2812 ses_enum_chassis_t *scp;
2813 int i, err;
2814 uint64_t sc_count = 0, pindex;
2815 ses_phys_tree_t *sproot = NULL;
2816 hrtime_t start;
2817 hrtime_t end;
2818 double duration;
2819
2820 /*
2821 * Ignore any internal enclosures.
2822 */
2823 if (cp->sec_internal)
2824 return (0);
2825
2826 /*
2827 * Check to see if there are any devices presennt in the chassis. If
2828 * not, ignore the chassis alltogether. This is most useful for
2829 * ignoring internal HBAs that present a SES target but don't actually
2830 * manage any of the devices.
2831 */
2832 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2833 snp = topo_list_next(snp)) {
2834 if (snp->sen_type == SES_ET_DEVICE ||
2835 snp->sen_type == SES_ET_ARRAY_DEVICE)
2836 break;
2837 }
2838
2839 if (snp == NULL)
2840 return (0);
2841
2842 props = ses_node_props(cp->sec_enclosure);
2843
2844 /*
2845 * We use the following property mappings:
2846 *
2847 * manufacturer vendor-id
2848 * model product-id
2849 * serial-number libses-chassis-serial
2850 */
2851 verify(nvlist_lookup_string(props, SES_EN_PROP_VID,
2852 &raw_manufacturer) == 0);
2853 verify(nvlist_lookup_string(props, SES_EN_PROP_PID, &raw_model) == 0);
2854 verify(nvlist_lookup_string(props, SES_EN_PROP_REV,
2855 &raw_revision) == 0);
2856 verify(nvlist_lookup_string(props, LIBSES_EN_PROP_CSN, &serial) == 0);
2857
2858 /*
2859 * To construct the authority information, we 'clean' each string by
2860 * removing any offensive characters and trimmming whitespace. For the
2861 * 'product-id', we use a concatenation of 'manufacturer-model'. We
2862 * also take the numerical serial number and convert it to a string.
2863 */
2864 if ((manufacturer = disk_auth_clean(mod, raw_manufacturer)) == NULL ||
2865 (model = disk_auth_clean(mod, raw_model)) == NULL ||
2866 (revision = disk_auth_clean(mod, raw_revision)) == NULL) {
2867 goto error;
2868 }
2869
2870 prodlen = strlen(manufacturer) + strlen(model) + 2;
2871 if ((product = topo_mod_alloc(mod, prodlen)) == NULL)
2872 goto error;
2873
2874 (void) snprintf(product, prodlen, "%s-%s", manufacturer, model);
2875
2876 /*
2877 * Construct the topo node and bind it to our parent.
2878 */
2879 if (topo_mod_nvalloc(mod, &auth, NV_UNIQUE_NAME) != 0)
2880 goto error;
2881
2882 if (nvlist_add_string(auth, FM_FMRI_AUTH_PRODUCT, product) != 0 ||
2883 nvlist_add_string(auth, FM_FMRI_AUTH_CHASSIS, serial) != 0) {
2884 (void) topo_mod_seterrno(mod, EMOD_NVL_INVAL);
2885 goto error;
2886 }
2887
2888 /*
2889 * We pass NULL for the parent FMRI because there is no resource
2890 * associated with it. For the toplevel enclosure, we leave the
2891 * serial/part/revision portions empty, which are reserved for
2892 * individual components within the chassis.
2893 */
2894 if ((fmri = topo_mod_hcfmri(mod, NULL, FM_HC_SCHEME_VERSION,
2895 SES_ENCLOSURE, cp->sec_instance, NULL, auth,
2896 model, revision, serial)) == NULL) {
2897 topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
2898 topo_mod_errmsg(mod));
2899 goto error;
2900 }
2901
2902 if ((tn = topo_node_bind(mod, pnode, SES_ENCLOSURE,
2903 cp->sec_instance, fmri)) == NULL) {
2904 topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
2905 topo_mod_errmsg(mod));
2906 goto error;
2907 }
2908
2909 if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) {
2910 topo_mod_dprintf(mod,
2911 "topo_method_register() failed: %s",
2912 topo_mod_errmsg(mod));
2913 goto error;
2914 }
2915
2916 if (ses_set_standard_props(mod, NULL, tn, auth,
2917 ses_node_id(cp->sec_enclosure), cp->sec_target->set_devpath) != 0)
2918 goto error;
2919
2920 /*
2921 * For enclosures, we want to include all possible targets (for upgrade
2922 * purposes).
2923 */
2924 for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL;
2925 stp = topo_list_next(stp), i++)
2926 ;
2927
2928 verify(i != 0);
2929 paths = alloca(i * sizeof (char *));
2930
2931 for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL;
2932 stp = topo_list_next(stp), i++)
2933 paths[i] = stp->set_devpath;
2934
2935
2936 if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES,
2937 TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths,
2938 i, &err) != 0) {
2939 topo_mod_dprintf(mod,
2940 "failed to create property %s: %s\n",
2941 TOPO_PROP_PATHS, topo_strerror(err));
2942 goto error;
2943 }
2944
2945 if (nvlist_lookup_uint64(props,
2946 LIBSES_PROP_PHYS_PARENT, &pindex) == 0) {
2947 start = gethrtime(); /* to mearusre performance */
2948 /*
2949 * The enclosure is supported through SUNW,FRUID.
2950 * Need to enumerate the nodes through hierarchical order.
2951 */
2952 if ((sproot = topo_mod_zalloc(mod,
2953 sizeof (ses_phys_tree_t))) == NULL) {
2954 topo_mod_dprintf(mod,
2955 "failed to allocate root: %s\n",
2956 topo_strerror(err));
2957 goto error;
2958 }
2959 sproot->spt_pindex = pindex;
2960 if (nvlist_lookup_boolean_value(props,
2961 LIBSES_PROP_FRU, &sproot->spt_isfru) != 0) {
2962 topo_mod_dprintf(mod,
2963 "ses_create_chassis(): Failed to find prop %s "
2964 "on enclosure element (CSN %s).",
2965 LIBSES_PROP_FRU, cp->sec_csn);
2966 /* an enclosure should be a FRU. continue to process. */
2967 sproot->spt_isfru = B_TRUE;
2968 }
2969 if (nvlist_lookup_uint64(props,
2970 SES_PROP_ELEMENT_ONLY_INDEX,
2971 &sproot->spt_eonlyindex) != 0) {
2972 topo_mod_dprintf(mod,
2973 "ses_create_chassis(): Failed to find prop %s "
2974 "on enclosure element (CSN %s).",
2975 LIBSES_PROP_PHYS_PARENT, cp->sec_csn);
2976 topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t));
2977 goto error;
2978 }
2979 if (sproot->spt_pindex != sproot->spt_eonlyindex) {
2980 topo_mod_dprintf(mod, "ses_create_chassis(): "
2981 "Enclosure element(CSN %s) should have "
2982 "itself as the parent to be the root node "
2983 "of FRU hierarchical tree.)", cp->sec_csn);
2984 topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t));
2985 goto error;
2986 } else {
2987 sproot->spt_snode = cp->sec_enclosure;
2988 sproot->spt_tnode = tn;
2989 /* construct a tree. */
2990 if (ses_construct_phys_tree(sdp, cp, sproot) != 0) {
2991 topo_mod_dprintf(mod, "ses_create_chassis(): "
2992 "Failed to construct FRU hierarchical "
2993 "tree on enclosure (CSN %s.)",
2994 cp->sec_csn);
2995 }
2996
2997 /* enumerate elements from the tree. */
2998 if (ses_create_children_from_phys_tree(sdp, tn, cp,
2999 sproot) != 0) {
3000 topo_mod_dprintf(mod, "ses_create_chassis(): "
3001 "Failed to create children topo nodes out "
3002 "of FRU hierarchical tree on enclosure "
3003 "(CSN %s).", cp->sec_csn);
3004 }
3005 /* destroy the phys tree. */
3006 ses_phys_tree_free(mod, sproot);
3007 }
3008
3009 end = gethrtime();
3010 duration = end - start;
3011 duration /= HR_SECOND;
3012 topo_mod_dprintf(mod,
3013 "FRU boundary tree based enumeration: %.6f seconds",
3014 duration);
3015 } else {
3016 /*
3017 * Create the nodes for power supplies, fans, controllers and
3018 * devices. Note that SAS exopander nodes and connector nodes
3019 * are handled through protocol specific processing of
3020 * controllers.
3021 */
3022 if (ses_create_children(sdp, tn, SES_ET_POWER_SUPPLY,
3023 PSU, "PSU", cp, B_TRUE) != 0 ||
3024 ses_create_children(sdp, tn, SES_ET_COOLING,
3025 FAN, "FAN", cp, B_TRUE) != 0 ||
3026 ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS,
3027 CONTROLLER, "CONTROLLER", cp, B_TRUE) != 0 ||
3028 ses_create_children(sdp, tn, SES_ET_DEVICE,
3029 BAY, "BAY", cp, B_TRUE) != 0 ||
3030 ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE,
3031 BAY, "BAY", cp, B_TRUE) != 0)
3032 goto error;
3033 }
3034
3035 if (cp->sec_maxinstance >= 0 &&
3036 (topo_node_range_create(mod, tn, SUBCHASSIS, 0,
3037 cp->sec_maxinstance) != 0)) {
3038 topo_mod_dprintf(mod, "topo_node_create_range() failed: %s",
3039 topo_mod_errmsg(mod));
3040 goto error;
3041 }
3042
3043 for (scp = topo_list_next(&cp->sec_subchassis); scp != NULL;
3044 scp = topo_list_next(scp)) {
3045
3046 if (ses_create_subchassis(sdp, tn, scp) != 0)
3047 goto error;
3048
3049 topo_mod_dprintf(mod, "created Subchassis node with "
3050 "instance %u\nand target (%s) under Chassis with CSN %s",
3051 scp->sec_instance, scp->sec_target->set_devpath,
3052 cp->sec_csn);
3053
3054 sc_count++;
3055 }
3056
3057 topo_mod_dprintf(mod, "%s: created %llu %s nodes",
3058 cp->sec_csn, sc_count, SUBCHASSIS);
3059
3060 cp->sec_target->set_refcount++;
3061 topo_node_setspecific(tn, cp->sec_target);
3062
3063 ret = 0;
3064 error:
3065 topo_mod_strfree(mod, manufacturer);
3066 topo_mod_strfree(mod, model);
3067 topo_mod_strfree(mod, revision);
3068 topo_mod_strfree(mod, product);
3069
3070 nvlist_free(fmri);
3071 nvlist_free(auth);
3072 return (ret);
3073 }
3074
3075 /*
3076 * Create a bay node explicitly enumerated via XML.
3077 */
3078 static int
3079 ses_create_bays(ses_enum_data_t *sdp, tnode_t *pnode)
3080 {
3081 topo_mod_t *mod = sdp->sed_mod;
3082 ses_enum_chassis_t *cp;
3083
3084 /*
3085 * Iterate over chassis looking for an internal enclosure. This
3086 * property is set via a vendor-specific plugin, and there should only
3087 * ever be a single internal chassis in a system.
3088 */
3089 for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL;
3090 cp = topo_list_next(cp)) {
3091 if (cp->sec_internal)
3092 break;
3093 }
3094
3095 if (cp == NULL) {
3096 topo_mod_dprintf(mod, "failed to find internal chassis\n");
3097 return (-1);
3098 }
3099
3100 if (ses_create_children(sdp, pnode, SES_ET_DEVICE,
3101 BAY, "BAY", cp, B_FALSE) != 0 ||
3102 ses_create_children(sdp, pnode, SES_ET_ARRAY_DEVICE,
3103 BAY, "BAY", cp, B_FALSE) != 0)
3104 return (-1);
3105
3106 return (0);
3107 }
3108
3109 /*
3110 * Initialize chassis or subchassis.
3111 */
3112 static int
3113 ses_init_chassis(topo_mod_t *mod, ses_enum_data_t *sdp, ses_enum_chassis_t *pcp,
3114 ses_enum_chassis_t *cp, ses_node_t *np, nvlist_t *props,
3115 uint64_t subchassis, ses_chassis_type_e flags)
3116 {
3117 boolean_t internal, ident;
3118
3119 assert((flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS |
3120 SES_DUP_CHASSIS | SES_DUP_SUBCHASSIS)) != 0);
3121
3122 assert(cp != NULL);
3123 assert(np != NULL);
3124 assert(props != NULL);
3125
3126 if (flags & (SES_NEW_SUBCHASSIS | SES_DUP_SUBCHASSIS))
3127 assert(pcp != NULL);
3128
3129 topo_mod_dprintf(mod, "ses_init_chassis: %s: index %llu, flags (%d)",
3130 sdp->sed_name, subchassis, flags);
3131
3132 if (flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS)) {
3133
3134 topo_mod_dprintf(mod, "new chassis/subchassis");
3135 if (nvlist_lookup_boolean_value(props,
3136 LIBSES_EN_PROP_INTERNAL, &internal) == 0)
3137 cp->sec_internal = internal;
3138
3139 cp->sec_enclosure = np;
3140 cp->sec_target = sdp->sed_target;
3141
3142 if (flags & SES_NEW_CHASSIS) {
3143 if (!cp->sec_internal)
3144 cp->sec_instance = sdp->sed_instance++;
3145 topo_list_append(&sdp->sed_chassis, cp);
3146 } else {
3147 if (subchassis != NO_SUBCHASSIS)
3148 cp->sec_instance = subchassis;
3149 else
3150 cp->sec_instance = pcp->sec_scinstance++;
3151
3152 if (cp->sec_instance > pcp->sec_maxinstance)
3153 pcp->sec_maxinstance = cp->sec_instance;
3154
3155 topo_list_append(&pcp->sec_subchassis, cp);
3156 }
3157
3158 } else {
3159 topo_mod_dprintf(mod, "dup chassis/subchassis");
3160 if (nvlist_lookup_boolean_value(props,
3161 SES_PROP_IDENT, &ident) == 0) {
3162 topo_mod_dprintf(mod, "overriding enclosure node");
3163
3164 cp->sec_enclosure = np;
3165 cp->sec_target = sdp->sed_target;
3166 }
3167 }
3168
3169 topo_list_append(&cp->sec_targets, sdp->sed_target);
3170 sdp->sed_current = cp;
3171
3172 return (0);
3173 }
3174
3175 /*
3176 * Gather nodes from the current SES target into our chassis list, merging the
3177 * results if necessary.
3178 */
3179 static ses_walk_action_t
3180 ses_enum_gather(ses_node_t *np, void *data)
3181 {
3182 nvlist_t *props = ses_node_props(np);
3183 ses_enum_data_t *sdp = data;
3184 topo_mod_t *mod = sdp->sed_mod;
3185 ses_enum_chassis_t *cp, *scp;
3186 ses_enum_node_t *snp;
3187 ses_alt_node_t *sap;
3188 char *csn;
3189 uint64_t instance, type;
3190 uint64_t prevstatus, status;
3191 boolean_t report;
3192 uint64_t subchassis = NO_SUBCHASSIS;
3193
3194 if (ses_node_type(np) == SES_NODE_ENCLOSURE) {
3195 /*
3196 * If we have already identified the chassis for this target,
3197 * then this is a secondary enclosure and we should ignore it,
3198 * along with the rest of the tree (since this is depth-first).
3199 */
3200 if (sdp->sed_current != NULL)
3201 return (SES_WALK_ACTION_TERMINATE);
3202
3203 /*
3204 * Go through the list of chassis we have seen so far and see
3205 * if this serial number matches one of the known values.
3206 * If so, check whether this enclosure is a subchassis.
3207 */
3208 if (nvlist_lookup_string(props, LIBSES_EN_PROP_CSN,
3209 &csn) != 0)
3210 return (SES_WALK_ACTION_TERMINATE);
3211
3212 (void) nvlist_lookup_uint64(props, LIBSES_EN_PROP_SUBCHASSIS_ID,
3213 &subchassis);
3214
3215 topo_mod_dprintf(mod, "ses_enum_gather: Enclosure Node (%s) "
3216 "CSN (%s), subchassis (%llu)", sdp->sed_name, csn,
3217 subchassis);
3218
3219 /*
3220 * We need to determine whether this enclosure node
3221 * represents a chassis or a subchassis. Since we may
3222 * receive the enclosure nodes in a non-deterministic
3223 * manner, we need to account for all possible combinations:
3224 * 1. Chassis for the current CSN has not yet been
3225 * allocated
3226 * 1.1 This is a new chassis:
3227 * allocate and instantiate the chassis
3228 * 1.2 This is a new subchassis:
3229 * allocate a placeholder chassis
3230 * allocate and instantiate the subchassis
3231 * link the subchassis to the chassis
3232 * 2. Chassis for the current CSN has been allocated
3233 * 2.1 This is a duplicate chassis enclosure
3234 * check whether to override old chassis
3235 * append to chassis' target list
3236 * 2.2 Only placeholder chassis exists
3237 * fill in the chassis fields
3238 * 2.3 This is a new subchassis
3239 * allocate and instantiate the subchassis
3240 * link the subchassis to the chassis
3241 * 2.4 This is a duplicate subchassis enclosure
3242 * check whether to override old chassis
3243 * append to chassis' target list
3244 */
3245
3246 for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL;
3247 cp = topo_list_next(cp))
3248 if (strcmp(cp->sec_csn, csn) == 0)
3249 break;
3250
3251 if (cp == NULL) {
3252 /* 1. Haven't seen a chassis with this CSN before */
3253
3254 if ((cp = topo_mod_zalloc(mod,
3255 sizeof (ses_enum_chassis_t))) == NULL)
3256 goto error;
3257
3258 cp->sec_scinstance = SES_STARTING_SUBCHASSIS;
3259 cp->sec_maxinstance = -1;
3260 cp->sec_csn = csn;
3261
3262 if (subchassis == NO_SUBCHASSIS) {
3263 /* 1.1 This is a new chassis */
3264
3265 topo_mod_dprintf(mod, "%s: Initialize new "
3266 "chassis with CSN %s", sdp->sed_name, csn);
3267
3268 if (ses_init_chassis(mod, sdp, NULL, cp,
3269 np, props, NO_SUBCHASSIS,
3270 SES_NEW_CHASSIS) < 0)
3271 goto error;
3272 } else {
3273 /* 1.2 This is a new subchassis */
3274
3275 topo_mod_dprintf(mod, "%s: Initialize new "
3276 "subchassis with CSN %s and index %llu",
3277 sdp->sed_name, csn, subchassis);
3278
3279 if ((scp = topo_mod_zalloc(mod,
3280 sizeof (ses_enum_chassis_t))) == NULL)
3281 goto error;
3282
3283 scp->sec_csn = csn;
3284
3285 if (ses_init_chassis(mod, sdp, cp, scp, np,
3286 props, subchassis, SES_NEW_SUBCHASSIS) < 0)
3287 goto error;
3288 }
3289 } else {
3290 /*
3291 * We have a chassis or subchassis with this CSN. If
3292 * it's a chassis, we must check to see whether it is
3293 * a placeholder previously created because we found a
3294 * subchassis with this CSN. We will know that because
3295 * the sec_target value will not be set; it is set only
3296 * in ses_init_chassis(). In that case, initialise it
3297 * as a new chassis; otherwise, it's a duplicate and we
3298 * need to append only.
3299 */
3300 if (subchassis == NO_SUBCHASSIS) {
3301 if (cp->sec_target != NULL) {
3302 /* 2.1 This is a duplicate chassis */
3303
3304 topo_mod_dprintf(mod, "%s: Append "
3305 "duplicate chassis with CSN (%s)",
3306 sdp->sed_name, csn);
3307
3308 if (ses_init_chassis(mod, sdp, NULL, cp,
3309 np, props, NO_SUBCHASSIS,
3310 SES_DUP_CHASSIS) < 0)
3311 goto error;
3312 } else {
3313 /* Placeholder chassis - init it up */
3314 topo_mod_dprintf(mod, "%s: Initialize"
3315 "placeholder chassis with CSN %s",
3316 sdp->sed_name, csn);
3317
3318 if (ses_init_chassis(mod, sdp, NULL,
3319 cp, np, props, NO_SUBCHASSIS,
3320 SES_NEW_CHASSIS) < 0)
3321 goto error;
3322
3323 }
3324 } else {
3325 /* This is a subchassis */
3326
3327 for (scp = topo_list_next(&cp->sec_subchassis);
3328 scp != NULL; scp = topo_list_next(scp))
3329 if (scp->sec_instance == subchassis)
3330 break;
3331
3332 if (scp == NULL) {
3333 /* 2.3 This is a new subchassis */
3334
3335 topo_mod_dprintf(mod, "%s: Initialize "
3336 "new subchassis with CSN (%s) "
3337 "and LID (%s)",
3338 sdp->sed_name, csn);
3339
3340 if ((scp = topo_mod_zalloc(mod,
3341 sizeof (ses_enum_chassis_t)))
3342 == NULL)
3343 goto error;
3344
3345 scp->sec_csn = csn;
3346
3347 if (ses_init_chassis(mod, sdp, cp, scp,
3348 np, props, subchassis,
3349 SES_NEW_SUBCHASSIS) < 0)
3350 goto error;
3351 } else {
3352 /* 2.4 This is a duplicate subchassis */
3353
3354 topo_mod_dprintf(mod, "%s: Append "
3355 "duplicate subchassis with "
3356 "CSN (%s)", sdp->sed_name, csn);
3357
3358 if (ses_init_chassis(mod, sdp, cp, scp,
3359 np, props, subchassis,
3360 SES_DUP_SUBCHASSIS) < 0)
3361 goto error;
3362 }
3363 }
3364 }
3365 } else if (ses_node_type(np) == SES_NODE_ELEMENT) {
3366 /*
3367 * If we haven't yet seen an enclosure node and identified the
3368 * current chassis, something is very wrong; bail out.
3369 */
3370 if (sdp->sed_current == NULL)
3371 return (SES_WALK_ACTION_TERMINATE);
3372
3373 /*
3374 * If this isn't one of the element types we care about, then
3375 * ignore it.
3376 */
3377 verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_TYPE,
3378 &type) == 0);
3379 if (type != SES_ET_DEVICE &&
3380 type != SES_ET_ARRAY_DEVICE &&
3381 type != SES_ET_SUNW_FANBOARD &&
3382 type != SES_ET_SUNW_FANMODULE &&
3383 type != SES_ET_COOLING &&
3384 type != SES_ET_SUNW_POWERBOARD &&
3385 type != SES_ET_SUNW_POWERMODULE &&
3386 type != SES_ET_POWER_SUPPLY &&
3387 type != SES_ET_ESC_ELECTRONICS &&
3388 type != SES_ET_SAS_EXPANDER &&
3389 type != SES_ET_SAS_CONNECTOR)
3390 return (SES_WALK_ACTION_CONTINUE);
3391
3392 /*
3393 * Get the current instance number and see if we already know
3394 * about this element. If so, it means we have multiple paths
3395 * to the same elements, and we should ignore the current path.
3396 */
3397 verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_CLASS_INDEX,
3398 &instance) == 0);
3399 if (type == SES_ET_DEVICE || type == SES_ET_ARRAY_DEVICE)
3400 (void) nvlist_lookup_uint64(props, SES_PROP_BAY_NUMBER,
3401 &instance);
3402
3403 cp = sdp->sed_current;
3404
3405 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
3406 snp = topo_list_next(snp)) {
3407 if (snp->sen_type == type &&
3408 snp->sen_instance == instance)
3409 break;
3410 }
3411
3412 /*
3413 * We prefer the new element under the following circumstances:
3414 *
3415 * - The currently known element's status is unknown or not
3416 * available, but the new element has a known status. This
3417 * occurs if a given element is only available through a
3418 * particular target.
3419 *
3420 * - This is an ESC_ELECTRONICS element, and the 'reported-via'
3421 * property is set. This allows us to get reliable firmware
3422 * revision information from the enclosure node.
3423 */
3424 if (snp != NULL) {
3425 if (nvlist_lookup_uint64(
3426 ses_node_props(snp->sen_node),
3427 SES_PROP_STATUS_CODE, &prevstatus) != 0)
3428 prevstatus = SES_ESC_UNSUPPORTED;
3429 if (nvlist_lookup_uint64(
3430 props, SES_PROP_STATUS_CODE, &status) != 0)
3431 status = SES_ESC_UNSUPPORTED;
3432 if (nvlist_lookup_boolean_value(
3433 props, SES_PROP_REPORT, &report) != 0)
3434 report = B_FALSE;
3435
3436 if ((SES_STATUS_UNAVAIL(prevstatus) &&
3437 !SES_STATUS_UNAVAIL(status)) ||
3438 (type == SES_ET_ESC_ELECTRONICS &&
3439 report)) {
3440 snp->sen_node = np;
3441 snp->sen_target = sdp->sed_target;
3442 }
3443
3444 if ((sap = topo_mod_zalloc(mod,
3445 sizeof (ses_alt_node_t))) == NULL)
3446 goto error;
3447
3448 sap->san_node = np;
3449 topo_list_append(&snp->sen_alt_nodes, sap);
3450
3451 return (SES_WALK_ACTION_CONTINUE);
3452 }
3453
3454 if ((snp = topo_mod_zalloc(mod,
3455 sizeof (ses_enum_node_t))) == NULL)
3456 goto error;
3457
3458 if ((sap = topo_mod_zalloc(mod,
3459 sizeof (ses_alt_node_t))) == NULL) {
3460 topo_mod_free(mod, snp, sizeof (ses_enum_node_t));
3461 goto error;
3462 }
3463
3464 topo_mod_dprintf(mod, "%s: adding node (%llu, %llu)",
3465 sdp->sed_name, type, instance);
3466 snp->sen_node = np;
3467 snp->sen_type = type;
3468 snp->sen_instance = instance;
3469 snp->sen_target = sdp->sed_target;
3470 sap->san_node = np;
3471 topo_list_append(&snp->sen_alt_nodes, sap);
3472 topo_list_append(&cp->sec_nodes, snp);
3473
3474 if (type == SES_ET_DEVICE)
3475 cp->sec_hasdev = B_TRUE;
3476 }
3477
3478 return (SES_WALK_ACTION_CONTINUE);
3479
3480 error:
3481 sdp->sed_errno = -1;
3482 return (SES_WALK_ACTION_TERMINATE);
3483 }
3484
3485 static int
3486 ses_process_dir(const char *dirpath, ses_enum_data_t *sdp)
3487 {
3488 topo_mod_t *mod = sdp->sed_mod;
3489 DIR *dir;
3490 struct dirent *dp;
3491 char path[PATH_MAX];
3492 ses_enum_target_t *stp;
3493 int err = -1;
3494
3495 /*
3496 * Open the SES target directory and iterate over any available
3497 * targets.
3498 */
3499 if ((dir = opendir(dirpath)) == NULL) {
3500 /*
3501 * If the SES target directory does not exist, then return as if
3502 * there are no active targets.
3503 */
3504 topo_mod_dprintf(mod, "failed to open ses "
3505 "directory '%s'", dirpath);
3506 return (0);
3507 }
3508
3509 while ((dp = readdir(dir)) != NULL) {
3510 if (strcmp(dp->d_name, ".") == 0 ||
3511 strcmp(dp->d_name, "..") == 0)
3512 continue;
3513
3514 /*
3515 * Create a new target instance and take a snapshot.
3516 */
3517 if ((stp = topo_mod_zalloc(mod,
3518 sizeof (ses_enum_target_t))) == NULL)
3519 goto error;
3520
3521 (void) pthread_mutex_init(&stp->set_lock, NULL);
3522
3523 (void) snprintf(path, sizeof (path), "%s/%s", dirpath,
3524 dp->d_name);
3525
3526 /*
3527 * We keep track of the SES device path and export it on a
3528 * per-node basis to allow higher level software to get to the
3529 * corresponding SES state.
3530 */
3531 if ((stp->set_devpath = topo_mod_strdup(mod, path)) == NULL) {
3532 topo_mod_free(mod, stp, sizeof (ses_enum_target_t));
3533 goto error;
3534 }
3535
3536 if ((stp->set_target =
3537 ses_open(LIBSES_VERSION, path)) == NULL) {
3538 topo_mod_dprintf(mod, "failed to open ses target "
3539 "'%s': %s", dp->d_name, ses_errmsg());
3540 ses_sof_alloc(mod, stp->set_devpath);
3541 topo_mod_free(mod, stp, sizeof (ses_enum_target_t));
3542 continue;
3543 }
3544 topo_mod_dprintf(mod, "open contract");
3545 ses_ssl_alloc(mod, stp);
3546 ses_create_contract(mod, stp);
3547
3548 stp->set_refcount = 1;
3549 sdp->sed_target = stp;
3550 stp->set_snap = ses_snap_hold(stp->set_target);
3551 stp->set_snaptime = gethrtime();
3552
3553 /*
3554 * Enumerate over all SES elements and merge them into the
3555 * correct ses_enum_chassis_t.
3556 */
3557 sdp->sed_current = NULL;
3558 sdp->sed_errno = 0;
3559 sdp->sed_name = dp->d_name;
3560 (void) ses_walk(stp->set_snap, ses_enum_gather, sdp);
3561
3562 if (sdp->sed_errno != 0)
3563 goto error;
3564 }
3565
3566 err = 0;
3567 error:
3568 (void) closedir(dir);
3569 return (err);
3570 }
3571
3572 static void
3573 ses_release(topo_mod_t *mod, tnode_t *tn)
3574 {
3575 ses_enum_target_t *stp;
3576
3577 if ((stp = topo_node_getspecific(tn)) != NULL) {
3578 topo_node_setspecific(tn, NULL);
3579 ses_target_free(mod, stp);
3580 }
3581 }
3582
3583 /*ARGSUSED*/
3584 static int
3585 ses_enum(topo_mod_t *mod, tnode_t *rnode, const char *name,
3586 topo_instance_t min, topo_instance_t max, void *arg, void *notused)
3587 {
3588 ses_enum_chassis_t *cp;
3589 ses_enum_data_t *data;
3590
3591 /*
3592 * Check to make sure we're being invoked sensibly, and that we're not
3593 * being invoked as part of a post-processing step.
3594 */
3595 if (strcmp(name, SES_ENCLOSURE) != 0 && strcmp(name, BAY) != 0)
3596 return (0);
3597
3598 /*
3599 * If this is the first time we've called our enumeration method, then
3600 * gather information about any available enclosures.
3601 */
3602 if ((data = topo_mod_getspecific(mod)) == NULL) {
3603 ses_sof_freeall(mod);
3604 if ((data = topo_mod_zalloc(mod, sizeof (ses_enum_data_t))) ==
3605 NULL)
3606 return (-1);
3607
3608 data->sed_mod = mod;
3609 topo_mod_setspecific(mod, data);
3610
3611 if (dev_list_gather(mod, &data->sed_devs) != 0)
3612 goto error;
3613
3614 /*
3615 * We search both the ses(7D) and sgen(7D) locations, so we are
3616 * independent of any particular driver class bindings.
3617 */
3618 if (ses_process_dir("/dev/es", data) != 0 ||
3619 ses_process_dir("/dev/scsi/ses", data) != 0)
3620 goto error;
3621 }
3622
3623 if (strcmp(name, SES_ENCLOSURE) == 0) {
3624 /*
3625 * This is a request to enumerate external enclosures. Go
3626 * through all the targets and create chassis nodes where
3627 * necessary.
3628 */
3629 for (cp = topo_list_next(&data->sed_chassis); cp != NULL;
3630 cp = topo_list_next(cp)) {
3631 if (ses_create_chassis(data, rnode, cp) != 0)
3632 goto error;
3633 }
3634 } else {
3635 /*
3636 * This is a request to enumerate a specific bay underneath the
3637 * root chassis (for internal disks).
3638 */
3639 if (ses_create_bays(data, rnode) != 0)
3640 goto error;
3641 }
3642
3643 /*
3644 * This is a bit of a kludge. In order to allow internal disks to be
3645 * enumerated and share snapshot-specific information with the external
3646 * enclosure enumeration, we rely on the fact that we will be invoked
3647 * for the 'ses-enclosure' node last.
3648 */
3649 if (strcmp(name, SES_ENCLOSURE) == 0) {
3650 for (cp = topo_list_next(&data->sed_chassis); cp != NULL;
3651 cp = topo_list_next(cp))
3652 ses_data_free(data, cp);
3653 ses_data_free(data, NULL);
3654 topo_mod_setspecific(mod, NULL);
3655 }
3656 return (0);
3657
3658 error:
3659 for (cp = topo_list_next(&data->sed_chassis); cp != NULL;
3660 cp = topo_list_next(cp))
3661 ses_data_free(data, cp);
3662 ses_data_free(data, NULL);
3663 topo_mod_setspecific(mod, NULL);
3664 return (-1);
3665 }
3666
3667 static const topo_modops_t ses_ops =
3668 { ses_enum, ses_release };
3669
3670 static topo_modinfo_t ses_info =
3671 { SES_ENCLOSURE, FM_FMRI_SCHEME_HC, SES_VERSION, &ses_ops };
3672
3673 /*ARGSUSED*/
3674 int
3675 _topo_init(topo_mod_t *mod, topo_version_t version)
3676 {
3677 int rval;
3678
3679 if (getenv("TOPOSESDEBUG") != NULL)
3680 topo_mod_setdebug(mod);
3681
3682 topo_mod_dprintf(mod, "initializing %s enumerator\n",
3683 SES_ENCLOSURE);
3684
3685 if ((rval = topo_mod_register(mod, &ses_info, TOPO_VERSION)) == 0)
3686 ses_thread_init(mod);
3687
3688 return (rval);
3689 }
3690
3691 void
3692 _topo_fini(topo_mod_t *mod)
3693 {
3694 ses_thread_fini(mod);
3695 ses_sof_freeall(mod);
3696 topo_mod_unregister(mod);
3697 }