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 2015 Nexenta Systems, Inc. All rights reserved.
26 * Copyright (c) 2018, 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 (void) sigaddset(&sigset, sesthread.thr_sig);
482 (void) 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 verify((props = ses_node_props(np)) != NULL);
1021 verify(nvlist_lookup_uint64(props,
1022 SES_PROP_STATUS_CODE, &status) == 0);
1023
1024 ses_node_unlock(mod, tn);
1025
1026 present = (status != SES_ESC_NOT_INSTALLED);
1027
1028 if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0)
1029 return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
1030
1031 if (nvlist_add_uint32(nvl, TOPO_METH_PRESENT_RET,
1032 present) != 0) {
1033 nvlist_free(nvl);
1034 return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
1035 }
1036
1037 *out = nvl;
1038
1039 return (0);
1040 }
1041
1042 /*
1043 * Sets standard properties for a ses node (enclosure, bay, controller
1044 * or expander).
1045 * This includes setting the FRU, as well as setting the
1046 * authority information. When the fru topo node(frutn) is not NULL
1047 * its resouce should be used as FRU.
1048 */
1049 static int
1050 ses_set_standard_props(topo_mod_t *mod, tnode_t *frutn, tnode_t *tn,
1051 nvlist_t *auth, uint64_t nodeid, const char *path)
1052 {
1053 int err;
1054 char *product, *chassis;
1055 nvlist_t *fmri;
1056
1057 /*
1058 * Set the authority explicitly if specified.
1059 */
1060 if (auth) {
1061 verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT,
1062 &product) == 0);
1063 verify(nvlist_lookup_string(auth, FM_FMRI_AUTH_CHASSIS,
1064 &chassis) == 0);
1065 if (topo_prop_set_string(tn, FM_FMRI_AUTHORITY,
1066 FM_FMRI_AUTH_PRODUCT, TOPO_PROP_IMMUTABLE, product,
1067 &err) != 0 ||
1068 topo_prop_set_string(tn, FM_FMRI_AUTHORITY,
1069 FM_FMRI_AUTH_CHASSIS, TOPO_PROP_IMMUTABLE, chassis,
1070 &err) != 0 ||
1071 topo_prop_set_string(tn, FM_FMRI_AUTHORITY,
1072 FM_FMRI_AUTH_SERVER, TOPO_PROP_IMMUTABLE, "",
1073 &err) != 0) {
1074 topo_mod_dprintf(mod, "failed to add authority "
1075 "properties: %s\n", topo_strerror(err));
1076 return (topo_mod_seterrno(mod, err));
1077 }
1078 }
1079
1080 /*
1081 * Copy the resource and set that as the FRU.
1082 */
1083 if (frutn != NULL) {
1084 if (topo_node_resource(frutn, &fmri, &err) != 0) {
1085 topo_mod_dprintf(mod,
1086 "topo_node_resource() failed : %s\n",
1087 topo_strerror(err));
1088 return (topo_mod_seterrno(mod, err));
1089 }
1090 } else {
1091 if (topo_node_resource(tn, &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 }
1098
1099 if (topo_node_fru_set(tn, fmri, 0, &err) != 0) {
1100 topo_mod_dprintf(mod,
1101 "topo_node_fru_set() failed : %s\n",
1102 topo_strerror(err));
1103 nvlist_free(fmri);
1104 return (topo_mod_seterrno(mod, err));
1105 }
1106
1107 nvlist_free(fmri);
1108
1109 /*
1110 * Set the SES-specific properties so that consumers can query
1111 * additional information about the particular SES element.
1112 */
1113 if (topo_pgroup_create(tn, &ses_pgroup, &err) != 0) {
1114 topo_mod_dprintf(mod, "failed to create propgroup "
1115 "%s: %s\n", TOPO_PGROUP_SES, topo_strerror(err));
1116 return (-1);
1117 }
1118
1119 if (topo_prop_set_uint64(tn, TOPO_PGROUP_SES,
1120 TOPO_PROP_NODE_ID, TOPO_PROP_IMMUTABLE,
1121 nodeid, &err) != 0) {
1122 topo_mod_dprintf(mod,
1123 "failed to create property %s: %s\n",
1124 TOPO_PROP_NODE_ID, topo_strerror(err));
1125 return (-1);
1126 }
1127
1128 if (topo_prop_set_string(tn, TOPO_PGROUP_SES,
1129 TOPO_PROP_TARGET_PATH, TOPO_PROP_IMMUTABLE,
1130 path, &err) != 0) {
1131 topo_mod_dprintf(mod,
1132 "failed to create property %s: %s\n",
1133 TOPO_PROP_TARGET_PATH, topo_strerror(err));
1134 return (-1);
1135 }
1136
1137 return (0);
1138 }
1139
1140 /*
1141 * Iterate over the SES phy information. If any of the ports indicates that it's
1142 * a SATA device and we haven't matched any disk devices yet, that means
1143 * that the HBA was able to create a WWN for the SATA device based on its GUID,
1144 * which is good. However, SES includes the WWN for the device's STP bridge. In
1145 * theory, if the driver includes the WWN based on the SATA guid then it should
1146 * also set the bridge-port property indicating the WWN that should match the
1147 * SATA device.
1148 */
1149 static int
1150 ses_create_disk_bridge(ses_enum_data_t *sdp, tnode_t *pnode, nvlist_t *props,
1151 tnode_t **child)
1152 {
1153 nvlist_t **phys;
1154 uint_t i, n_phys;
1155 topo_mod_t *mod = sdp->sed_mod;
1156
1157 if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS, &phys,
1158 &n_phys) != 0)
1159 return (1);
1160
1161 for (i = 0; i < n_phys; i++) {
1162 uint64_t wwn;
1163 boolean_t sata;
1164 char wwnstr[64];
1165
1166 if (nvlist_lookup_uint64(phys[i], SES_SAS_PROP_ADDR,
1167 &wwn) != 0 || wwn == 0) {
1168 continue;
1169 }
1170
1171 if (nvlist_lookup_boolean_value(phys[i],
1172 SES_SAS_PROP_SATA_DEVICE, &sata) != 0 || !sata) {
1173 continue;
1174 }
1175
1176 if (scsi_wwn_to_wwnstr(wwn, 0, wwnstr) == NULL)
1177 continue;
1178
1179 if (disk_declare_bridge(mod, pnode, &sdp->sed_devs,
1180 wwnstr, child) == 0) {
1181 return (0);
1182 }
1183
1184 }
1185
1186 return (1);
1187 }
1188
1189 /*
1190 * Callback to add a disk to a given bay. We first check the status-code to
1191 * determine if a disk is present, ignoring those that aren't in an appropriate
1192 * state. We then scan the parent bay node's SAS address array to determine
1193 * possible attached SAS addresses. We create a disk node if the disk is not
1194 * SAS or the SES target does not support the necessary pages for this; if we
1195 * find the SAS address, we create a disk node and also correlate it with
1196 * the corresponding Solaris device node to fill in the rest of the data.
1197 */
1198 static int
1199 ses_create_disk(ses_enum_data_t *sdp, tnode_t *pnode, nvlist_t *props)
1200 {
1201 topo_mod_t *mod = sdp->sed_mod;
1202 uint64_t status;
1203 uint_t s, nsas;
1204 char **paths;
1205 int err, ret;
1206 tnode_t *child = NULL;
1207
1208 /*
1209 * Skip devices that are not in a present (and possibly damaged) state.
1210 */
1211 if (nvlist_lookup_uint64(props, SES_PROP_STATUS_CODE, &status) != 0)
1212 return (0);
1213
1214 if (status != SES_ESC_UNSUPPORTED &&
1215 status != SES_ESC_OK &&
1216 status != SES_ESC_CRITICAL &&
1217 status != SES_ESC_NONCRITICAL &&
1218 status != SES_ESC_UNRECOVERABLE &&
1219 status != SES_ESC_NO_ACCESS &&
1220 status != SES_ESC_UNKNOWN)
1221 return (0);
1222
1223 topo_mod_dprintf(mod, "found attached disk");
1224
1225 /*
1226 * Create the disk range.
1227 */
1228 if (topo_node_range_create(mod, pnode, DISK, 0, 0) != 0) {
1229 topo_mod_dprintf(mod,
1230 "topo_node_create_range() failed: %s",
1231 topo_mod_errmsg(mod));
1232 return (-1);
1233 }
1234
1235 /*
1236 * Look through all SAS addresses and attempt to correlate them to a
1237 * known Solaris device. If we don't find a matching node, then we
1238 * don't enumerate the disk node.
1239 * Note that TOPO_PROP_SAS_ADDR prop includes SAS address from
1240 * alternate elements that represent the same device.
1241 */
1242 if (topo_prop_get_string_array(pnode, TOPO_PGROUP_SES,
1243 TOPO_PROP_SAS_ADDR, &paths, &nsas, &err) != 0)
1244 return (0);
1245
1246 err = 0;
1247
1248 for (s = 0; s < nsas; s++) {
1249 ret = disk_declare_addr(mod, pnode, &sdp->sed_devs, paths[s],
1250 &child);
1251 if (ret == 0) {
1252 break;
1253 } else if (ret < 0) {
1254 err = -1;
1255 break;
1256 }
1257 }
1258
1259 /*
1260 * We need to take another pass through the properties for this bay by
1261 * iterating over the phys and noting if any of these are SATA. Note,
1262 * this information isn't commonly part of the topo tree at this time,
1263 * hence why we end up going back and iterating over the properties
1264 * ourselves.
1265 */
1266 if (s == nsas) {
1267 if (ses_create_disk_bridge(sdp, pnode, props, &child) != 0)
1268 (void) disk_declare_non_enumerated(mod, pnode, &child);
1269 }
1270
1271 /* copy sas_addresses (target-ports) from parent (with 'w'added) */
1272 if (child != NULL) {
1273 int i;
1274 char **tports;
1275 uint64_t wwn;
1276
1277 tports = topo_mod_zalloc(mod, sizeof (char *) * nsas);
1278 if (tports != NULL) {
1279 for (i = 0; i < nsas; i++) {
1280 if (scsi_wwnstr_to_wwn(paths[i], &wwn) !=
1281 DDI_SUCCESS)
1282 break;
1283 tports[i] = scsi_wwn_to_wwnstr(wwn, 1, NULL);
1284 if (tports[i] == NULL)
1285 break;
1286 }
1287 /* if they all worked then create the property */
1288 if (i == nsas)
1289 (void) topo_prop_set_string_array(child,
1290 TOPO_PGROUP_STORAGE,
1291 TOPO_STORAGE_TARGET_PORT_L0IDS,
1292 TOPO_PROP_IMMUTABLE, (const char **)tports,
1293 nsas, &err);
1294
1295 for (i = 0; i < nsas; i++)
1296 if (tports[i] != NULL)
1297 scsi_free_wwnstr(tports[i]);
1298 topo_mod_free(mod, tports, sizeof (char *) * nsas);
1299 }
1300 }
1301
1302 for (s = 0; s < nsas; s++)
1303 topo_mod_free(mod, paths[s], strlen(paths[s]) + 1);
1304 topo_mod_free(mod, paths, nsas * sizeof (char *));
1305
1306 return (err);
1307 }
1308
1309 static int
1310 ses_add_bay_props(topo_mod_t *mod, tnode_t *tn, ses_enum_node_t *snp)
1311 {
1312 ses_alt_node_t *ap;
1313 ses_node_t *np;
1314 nvlist_t *props;
1315
1316 nvlist_t **phys;
1317 uint_t i, j, n_phys, all_phys = 0;
1318 char **paths;
1319 uint64_t addr;
1320 size_t len;
1321 int terr, err = -1;
1322
1323 for (ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL;
1324 ap = topo_list_next(ap)) {
1325 np = ap->san_node;
1326 props = ses_node_props(np);
1327
1328 if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS,
1329 &phys, &n_phys) != 0)
1330 continue;
1331
1332 all_phys += n_phys;
1333 }
1334
1335 if (all_phys == 0)
1336 return (0);
1337
1338 if ((paths = topo_mod_zalloc(mod, all_phys * sizeof (char *))) == NULL)
1339 return (-1);
1340
1341 for (i = 0, ap = topo_list_next(&snp->sen_alt_nodes); ap != NULL;
1342 ap = topo_list_next(ap)) {
1343 np = ap->san_node;
1344 props = ses_node_props(np);
1345
1346 if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS,
1347 &phys, &n_phys) != 0)
1348 continue;
1349
1350 for (j = 0; j < n_phys; j++) {
1351 if (nvlist_lookup_uint64(phys[j], SES_SAS_PROP_ADDR,
1352 &addr) != 0)
1353 continue;
1354
1355 len = snprintf(NULL, 0, "%016llx", addr) + 1;
1356 if ((paths[i] = topo_mod_alloc(mod, len)) == NULL)
1357 goto error;
1358
1359 (void) snprintf(paths[i], len, "%016llx", addr);
1360
1361 ++i;
1362 }
1363 }
1364
1365 err = topo_prop_set_string_array(tn, TOPO_PGROUP_SES,
1366 TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE,
1367 (const char **)paths, i, &terr);
1368 if (err != 0)
1369 err = topo_mod_seterrno(mod, terr);
1370
1371 error:
1372 for (i = 0; i < all_phys && paths[i] != NULL; i++)
1373 topo_mod_free(mod, paths[i], strlen(paths[i]) + 1);
1374 topo_mod_free(mod, paths, all_phys * sizeof (char *));
1375
1376 return (err);
1377 }
1378
1379 /*
1380 * Callback to create a basic node (bay, psu, fan, or controller and expander).
1381 */
1382 static int
1383 ses_create_generic(ses_enum_data_t *sdp, ses_enum_node_t *snp, tnode_t *pnode,
1384 tnode_t *frutn, const char *nodename, const char *labelname,
1385 tnode_t **node)
1386 {
1387 ses_node_t *np = snp->sen_node;
1388 ses_node_t *parent;
1389 uint64_t instance = snp->sen_instance;
1390 topo_mod_t *mod = sdp->sed_mod;
1391 nvlist_t *props, *aprops;
1392 nvlist_t *auth = NULL, *fmri = NULL;
1393 tnode_t *tn = NULL;
1394 char label[128];
1395 int err;
1396 char *part = NULL, *serial = NULL, *revision = NULL;
1397 char *desc;
1398 boolean_t report;
1399
1400 props = ses_node_props(np);
1401
1402 (void) nvlist_lookup_string(props, LIBSES_PROP_PART, &part);
1403 (void) nvlist_lookup_string(props, LIBSES_PROP_SERIAL, &serial);
1404
1405 topo_mod_dprintf(mod, "adding %s %llu", nodename, instance);
1406
1407 /*
1408 * Create the node. The interesting information is all copied from the
1409 * parent enclosure node, so there is not much to do.
1410 */
1411 if ((auth = topo_mod_auth(mod, pnode)) == NULL)
1412 goto error;
1413
1414 /*
1415 * We want to report revision information for the controller nodes, but
1416 * we do not get per-element revision information. However, we do have
1417 * revision information for the entire enclosure, and we can use the
1418 * 'reported-via' property to know that this controller corresponds to
1419 * the given revision information. This means we cannot get revision
1420 * information for targets we are not explicitly connected to, but
1421 * there is little we can do about the situation.
1422 */
1423 if (strcmp(nodename, CONTROLLER) == 0 &&
1424 nvlist_lookup_boolean_value(props, SES_PROP_REPORT, &report) == 0 &&
1425 report) {
1426 for (parent = ses_node_parent(np); parent != NULL;
1427 parent = ses_node_parent(parent)) {
1428 if (ses_node_type(parent) == SES_NODE_ENCLOSURE) {
1429 (void) nvlist_lookup_string(
1430 ses_node_props(parent),
1431 SES_EN_PROP_REV, &revision);
1432 break;
1433 }
1434 }
1435 }
1436
1437 if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION,
1438 nodename, (topo_instance_t)instance, NULL, auth, part, revision,
1439 serial)) == NULL) {
1440 topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
1441 topo_mod_errmsg(mod));
1442 goto error;
1443 }
1444
1445 if ((tn = topo_node_bind(mod, pnode, nodename,
1446 instance, fmri)) == NULL) {
1447 topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
1448 topo_mod_errmsg(mod));
1449 goto error;
1450 }
1451
1452 /*
1453 * For the node label, we look for the following in order:
1454 *
1455 * <ses-description>
1456 * <ses-class-description> <instance>
1457 * <default-type-label> <instance>
1458 */
1459 if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 ||
1460 desc[0] == '\0') {
1461 parent = ses_node_parent(np);
1462 aprops = ses_node_props(parent);
1463 if (nvlist_lookup_string(aprops, SES_PROP_CLASS_DESCRIPTION,
1464 &desc) != 0 || desc[0] == '\0')
1465 desc = (char *)labelname;
1466 (void) snprintf(label, sizeof (label), "%s %llu", desc,
1467 instance);
1468 desc = label;
1469 }
1470
1471 if (topo_node_label_set(tn, desc, &err) != 0)
1472 goto error;
1473
1474 if (ses_set_standard_props(mod, frutn, tn, NULL, ses_node_id(np),
1475 snp->sen_target->set_devpath) != 0)
1476 goto error;
1477
1478 if (strcmp(nodename, BAY) == 0) {
1479 if (ses_add_bay_props(mod, tn, snp) != 0)
1480 goto error;
1481
1482 if (ses_create_disk(sdp, tn, props) != 0)
1483 goto error;
1484
1485 if (topo_method_register(mod, tn, ses_bay_methods) != 0) {
1486 topo_mod_dprintf(mod,
1487 "topo_method_register() failed: %s",
1488 topo_mod_errmsg(mod));
1489 goto error;
1490 }
1491 } else if ((strcmp(nodename, FAN) == 0) ||
1492 (strcmp(nodename, PSU) == 0) ||
1493 (strcmp(nodename, CONTROLLER) == 0)) {
1494 /*
1495 * Only fan, psu, and controller nodes have a 'present' method.
1496 * Bay nodes are always present, and disk nodes are present by
1497 * virtue of being enumerated and SAS expander nodes and
1498 * SAS connector nodes are also always present once
1499 * the parent controller is found.
1500 */
1501 if (topo_method_register(mod, tn, ses_component_methods) != 0) {
1502 topo_mod_dprintf(mod,
1503 "topo_method_register() failed: %s",
1504 topo_mod_errmsg(mod));
1505 goto error;
1506 }
1507
1508 }
1509
1510 snp->sen_target->set_refcount++;
1511 topo_node_setspecific(tn, snp->sen_target);
1512
1513 nvlist_free(auth);
1514 nvlist_free(fmri);
1515 if (node != NULL) *node = tn;
1516 return (0);
1517
1518 error:
1519 nvlist_free(auth);
1520 nvlist_free(fmri);
1521 return (-1);
1522 }
1523
1524 /*
1525 * Create SAS expander specific props.
1526 */
1527 /*ARGSUSED*/
1528 static int
1529 ses_set_expander_props(ses_enum_data_t *sdp, ses_enum_node_t *snp,
1530 tnode_t *ptnode, tnode_t *tnode, int *phycount, int64_t *connlist)
1531 {
1532 ses_node_t *np = snp->sen_node;
1533 topo_mod_t *mod = sdp->sed_mod;
1534 nvlist_t *auth = NULL, *fmri = NULL;
1535 nvlist_t *props, **phylist;
1536 int err, i;
1537 uint_t pcount;
1538 uint64_t sasaddr, connidx;
1539 char sasaddr_str[17];
1540 boolean_t found = B_FALSE, ses_found = B_FALSE;
1541 dev_di_node_t *dnode, *sesdnode;
1542
1543 props = ses_node_props(np);
1544
1545 /*
1546 * the uninstalled expander is not enumerated by checking
1547 * the element status code. No present present' method provided.
1548 */
1549 /*
1550 * Get the Expander SAS address. It should exist.
1551 */
1552 if (nvlist_lookup_uint64(props, SES_EXP_PROP_SAS_ADDR,
1553 &sasaddr) != 0) {
1554 topo_mod_dprintf(mod,
1555 "Failed to get prop %s.", SES_EXP_PROP_SAS_ADDR);
1556 goto error;
1557 }
1558
1559 (void) sprintf(sasaddr_str, "%llx", sasaddr);
1560
1561 /* search matching dev_di_node. */
1562 for (dnode = topo_list_next(&sdp->sed_devs); dnode != NULL;
1563 dnode = topo_list_next(dnode)) {
1564 for (i = 0; i < dnode->ddn_ppath_count; i++) {
1565 if ((dnode->ddn_target_port[i] != NULL) &&
1566 (strstr(dnode->ddn_target_port[i],
1567 sasaddr_str) != NULL)) {
1568 found = B_TRUE;
1569 break;
1570 }
1571 }
1572 if (found)
1573 break;
1574 }
1575
1576 if (!found) {
1577 topo_mod_dprintf(mod,
1578 "ses_set_expander_props: Failed to find matching "
1579 "devinfo node for Exapnder SAS address %s",
1580 SES_EXP_PROP_SAS_ADDR);
1581 /* continue on to get storage group props. */
1582 } else {
1583 /* create/set the devfs-path and devid in the smp group */
1584 if (topo_pgroup_create(tnode, &smp_pgroup, &err) != 0) {
1585 topo_mod_dprintf(mod, "ses_set_expander_props: "
1586 "failed to create smp property group %s\n",
1587 topo_strerror(err));
1588 goto error;
1589 } else {
1590 if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP,
1591 TOPO_PROP_SMP_TARGET_PORT, TOPO_PROP_IMMUTABLE,
1592 dnode->ddn_target_port[i], &err) != 0) {
1593 topo_mod_dprintf(mod, "ses_set_expander_props: "
1594 "set %S error %s\n", TOPO_PROP_SAS_ADDR,
1595 topo_strerror(err));
1596 }
1597 if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP,
1598 TOPO_PROP_SMP_DEV_PATH, TOPO_PROP_IMMUTABLE,
1599 dnode->ddn_dpath, &err) != 0) {
1600 topo_mod_dprintf(mod, "ses_set_expander_props: "
1601 "set dev error %s\n", topo_strerror(err));
1602 }
1603 if (topo_prop_set_string(tnode, TOPO_PGROUP_SMP,
1604 TOPO_PROP_SMP_DEVID, TOPO_PROP_IMMUTABLE,
1605 dnode->ddn_devid, &err) != 0) {
1606 topo_mod_dprintf(mod, "ses_set_expander_props: "
1607 "set devid error %s\n", topo_strerror(err));
1608 }
1609 if (dnode->ddn_ppath_count != 0 &&
1610 topo_prop_set_string_array(tnode, TOPO_PGROUP_SMP,
1611 TOPO_PROP_SMP_PHYS_PATH, TOPO_PROP_IMMUTABLE,
1612 (const char **)dnode->ddn_ppath,
1613 dnode->ddn_ppath_count, &err) != 0) {
1614 topo_mod_dprintf(mod, "ses_set_expander_props: "
1615 "set phys-path error %s\n",
1616 topo_strerror(err));
1617 }
1618 }
1619 }
1620
1621 /* update the ses property group with SES target info */
1622 if ((topo_pgroup_create(tnode, &ses_pgroup, &err) != 0) &&
1623 (err != ETOPO_PROP_DEFD)) {
1624 /* SES prop group doesn't exist but failed to be created. */
1625 topo_mod_dprintf(mod, "ses_set_expander_props: "
1626 "ses pgroup create error %s\n", topo_strerror(err));
1627 goto error;
1628 } else {
1629 /* locate assciated enclosure dev_di_node. */
1630 for (sesdnode = topo_list_next(&sdp->sed_devs);
1631 sesdnode != NULL; sesdnode = topo_list_next(sesdnode)) {
1632 for (i = 0; i < sesdnode->ddn_ppath_count; i++) {
1633 /*
1634 * check if attached port exists and
1635 * its node type is enclosure and
1636 * attached port is same as sas address of
1637 * the expander and
1638 * bridge port for virtual phy indication
1639 * exist.
1640 */
1641 if ((sesdnode->ddn_attached_port[i] != NULL) &&
1642 (sesdnode->ddn_dtype == DTYPE_ESI) &&
1643 (strstr(sesdnode->ddn_attached_port[i],
1644 sasaddr_str) != NULL) &&
1645 (sesdnode->ddn_bridge_port[i] != NULL)) {
1646 ses_found = B_TRUE;
1647 break;
1648 }
1649 }
1650 if (ses_found) break;
1651 }
1652
1653 if (ses_found) {
1654 if (topo_prop_set_string(tnode, TOPO_PGROUP_SES,
1655 TOPO_PROP_SES_TARGET_PORT, TOPO_PROP_IMMUTABLE,
1656 sesdnode->ddn_target_port[i], &err) != 0) {
1657 topo_mod_dprintf(mod, "ses_set_expander_props: "
1658 "set ses %S error %s\n", TOPO_PROP_SAS_ADDR,
1659 topo_strerror(err));
1660 }
1661 if (topo_prop_set_string(tnode, TOPO_PGROUP_SES,
1662 TOPO_PROP_SES_DEV_PATH, TOPO_PROP_IMMUTABLE,
1663 sesdnode->ddn_dpath, &err) != 0) {
1664 topo_mod_dprintf(mod, "ses_set_expander_props: "
1665 "set ses dev error %s\n",
1666 topo_strerror(err));
1667 }
1668 if (topo_prop_set_string(tnode, TOPO_PGROUP_SES,
1669 TOPO_PROP_SES_DEVID, TOPO_PROP_IMMUTABLE,
1670 sesdnode->ddn_devid, &err) != 0) {
1671 topo_mod_dprintf(mod, "ses_set_expander_props: "
1672 "set ses devid error %s\n",
1673 topo_strerror(err));
1674 }
1675 if (sesdnode->ddn_ppath_count != 0 &&
1676 topo_prop_set_string_array(tnode, TOPO_PGROUP_SES,
1677 TOPO_PROP_SES_PHYS_PATH, TOPO_PROP_IMMUTABLE,
1678 (const char **)sesdnode->ddn_ppath,
1679 sesdnode->ddn_ppath_count, &err) != 0) {
1680 topo_mod_dprintf(mod, "ses_set_expander_props: "
1681 "set ses phys-path error %s\n",
1682 topo_strerror(err));
1683 }
1684
1685 }
1686 }
1687
1688 /* create the storage group */
1689 if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) {
1690 topo_mod_dprintf(mod, "ses_set_expander_props: "
1691 "create storage error %s\n", topo_strerror(err));
1692 goto error;
1693 } else {
1694 /* set the SAS address prop out of expander element status. */
1695 if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE,
1696 TOPO_PROP_SAS_ADDR, TOPO_PROP_IMMUTABLE, sasaddr_str,
1697 &err) != 0) {
1698 topo_mod_dprintf(mod, "ses_set_expander_props: "
1699 "set %S error %s\n", TOPO_PROP_SAS_ADDR,
1700 topo_strerror(err));
1701 }
1702
1703 /* Get the phy information for the expander */
1704 if (nvlist_lookup_nvlist_array(props, SES_SAS_PROP_PHYS,
1705 &phylist, &pcount) != 0) {
1706 topo_mod_dprintf(mod,
1707 "Failed to get prop %s.", SES_SAS_PROP_PHYS);
1708 } else {
1709 /*
1710 * For each phy, get the connector element index and
1711 * stores into connector element index array.
1712 */
1713 *phycount = pcount;
1714 for (i = 0; i < pcount; i++) {
1715 if (nvlist_lookup_uint64(phylist[i],
1716 SES_PROP_CE_IDX, &connidx) == 0) {
1717 if (connidx != 0xff) {
1718 connlist[i] = connidx;
1719 } else {
1720 connlist[i] = -1;
1721 }
1722 } else {
1723 /* Fail to get the index. set to -1. */
1724 connlist[i] = -1;
1725 }
1726 }
1727
1728 /* set the phy count prop of the expander. */
1729 if (topo_prop_set_uint64(tnode, TOPO_PGROUP_STORAGE,
1730 TOPO_PROP_PHY_COUNT, TOPO_PROP_IMMUTABLE, pcount,
1731 &err) != 0) {
1732 topo_mod_dprintf(mod, "ses_set_expander_props: "
1733 "set %S error %s\n", TOPO_PROP_PHY_COUNT,
1734 topo_strerror(err));
1735 }
1736
1737 /*
1738 * set the connector element index of
1739 * the expander phys.
1740 */
1741 }
1742
1743 /* populate other misc storage group properties */
1744 if (found) {
1745 if (dnode->ddn_mfg && (topo_prop_set_string(tnode,
1746 TOPO_PGROUP_STORAGE, TOPO_STORAGE_MANUFACTURER,
1747 TOPO_PROP_IMMUTABLE, dnode->ddn_mfg, &err) != 0)) {
1748 topo_mod_dprintf(mod, "ses_set_expander_props: "
1749 "set mfg error %s\n", topo_strerror(err));
1750 }
1751
1752 if (dnode->ddn_model && (topo_prop_set_string(tnode,
1753 TOPO_PGROUP_STORAGE, TOPO_STORAGE_MODEL,
1754 TOPO_PROP_IMMUTABLE,
1755 dnode->ddn_model, &err) != 0)) {
1756 topo_mod_dprintf(mod, "ses_set_expander_props: "
1757 "set model error %s\n", topo_strerror(err));
1758 }
1759
1760 if (dnode->ddn_serial && (topo_prop_set_string(tnode,
1761 TOPO_PGROUP_STORAGE, TOPO_STORAGE_SERIAL_NUM,
1762 TOPO_PROP_IMMUTABLE,
1763 dnode->ddn_serial, &err) != 0)) {
1764 topo_mod_dprintf(mod, "ses_set_expander_props: "
1765 "set serial error %s\n",
1766 topo_strerror(err));
1767 }
1768
1769 if (dnode->ddn_firm && (topo_prop_set_string(tnode,
1770 TOPO_PGROUP_STORAGE,
1771 TOPO_STORAGE_FIRMWARE_REV, TOPO_PROP_IMMUTABLE,
1772 dnode->ddn_firm, &err) != 0)) {
1773 topo_mod_dprintf(mod, "ses_set_expander_props: "
1774 "set firm error %s\n", topo_strerror(err));
1775 }
1776 }
1777 }
1778
1779 return (0);
1780
1781 error:
1782 nvlist_free(auth);
1783 nvlist_free(fmri);
1784 return (-1);
1785 }
1786
1787 /*
1788 * Create SAS expander specific props.
1789 */
1790 /*ARGSUSED*/
1791 static int
1792 ses_set_connector_props(ses_enum_data_t *sdp, ses_enum_node_t *snp,
1793 tnode_t *tnode, int64_t phy_mask)
1794 {
1795 ses_node_t *np = snp->sen_node;
1796 topo_mod_t *mod = sdp->sed_mod;
1797 nvlist_t *props;
1798 int err, i;
1799 uint64_t conntype;
1800 char phymask_str[17], *conntype_str;
1801 boolean_t found;
1802
1803 props = ses_node_props(np);
1804
1805 /*
1806 * convert phy mask to string.
1807 */
1808 (void) snprintf(phymask_str, 17, "%llx", phy_mask);
1809
1810 /* create the storage group */
1811 if (topo_pgroup_create(tnode, &storage_pgroup, &err) != 0) {
1812 topo_mod_dprintf(mod, "ses_set_expander_props: "
1813 "create storage error %s\n", topo_strerror(err));
1814 return (-1);
1815 } else {
1816 /* set the SAS address prop of the expander. */
1817 if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE,
1818 TOPO_STORAGE_SAS_PHY_MASK, TOPO_PROP_IMMUTABLE,
1819 phymask_str, &err) != 0) {
1820 topo_mod_dprintf(mod, "ses_set_expander_props: "
1821 "set %S error %s\n", TOPO_STORAGE_SAS_PHY_MASK,
1822 topo_strerror(err));
1823 }
1824
1825 /* Get the connector type information for the expander */
1826 if (nvlist_lookup_uint64(props,
1827 SES_SC_PROP_CONNECTOR_TYPE, &conntype) != 0) {
1828 topo_mod_dprintf(mod, "Failed to get prop %s.",
1829 TOPO_STORAGE_SAS_PHY_MASK);
1830 } else {
1831 found = B_FALSE;
1832 for (i = 0; ; i++) {
1833 if (sas_connector_type_list[i].sct_type ==
1834 SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) {
1835 break;
1836 }
1837 if (sas_connector_type_list[i].sct_type ==
1838 conntype) {
1839 conntype_str =
1840 sas_connector_type_list[i].sct_name;
1841 found = B_TRUE;
1842 break;
1843 }
1844 }
1845
1846 if (!found) {
1847 if (conntype <
1848 SAS_CONNECTOR_TYPE_CODE_NOT_DEFINED) {
1849 conntype_str =
1850 SAS_CONNECTOR_TYPE_RESERVED;
1851 } else {
1852 conntype_str =
1853 SAS_CONNECTOR_TYPE_NOT_DEFINED;
1854 }
1855 }
1856
1857 /* set the phy count prop of the expander. */
1858 if (topo_prop_set_string(tnode, TOPO_PGROUP_STORAGE,
1859 TOPO_STORAGE_SAS_CONNECTOR_TYPE,
1860 TOPO_PROP_IMMUTABLE, conntype_str, &err) != 0) {
1861 topo_mod_dprintf(mod, "ses_set_expander_props: "
1862 "set %S error %s\n", TOPO_PROP_PHY_COUNT,
1863 topo_strerror(err));
1864 }
1865 }
1866 }
1867
1868 return (0);
1869 }
1870
1871 /*
1872 * Instantiate SAS expander nodes for a given ESC Electronics node(controller)
1873 * nodes.
1874 */
1875 /*ARGSUSED*/
1876 static int
1877 ses_create_esc_sasspecific(ses_enum_data_t *sdp, ses_enum_node_t *snp,
1878 tnode_t *pnode, ses_enum_chassis_t *cp,
1879 boolean_t dorange)
1880 {
1881 topo_mod_t *mod = sdp->sed_mod;
1882 tnode_t *exptn, *contn;
1883 boolean_t found;
1884 sas_connector_phy_data_t connectors[64] = {NULL};
1885 uint64_t max;
1886 ses_enum_node_t *ctlsnp, *xsnp, *consnp;
1887 ses_node_t *np = snp->sen_node;
1888 nvlist_t *props, *psprops;
1889 uint64_t index, psindex, conindex, psstatus, i, j, count;
1890 int64_t cidxlist[256] = {NULL};
1891 int phycount;
1892
1893 props = ses_node_props(np);
1894
1895 if (nvlist_lookup_uint64(props, SES_PROP_ELEMENT_ONLY_INDEX,
1896 &index) != 0)
1897 return (-1);
1898
1899 /*
1900 * For SES constroller node, check to see if there are
1901 * associated SAS expanders.
1902 */
1903 found = B_FALSE;
1904 max = 0;
1905 for (ctlsnp = topo_list_next(&cp->sec_nodes); ctlsnp != NULL;
1906 ctlsnp = topo_list_next(ctlsnp)) {
1907 if (ctlsnp->sen_type == SES_ET_SAS_EXPANDER) {
1908 found = B_TRUE;
1909 if (ctlsnp->sen_instance > max)
1910 max = ctlsnp->sen_instance;
1911 }
1912 }
1913
1914 /*
1915 * No SAS expander found notthing to process.
1916 */
1917 if (!found)
1918 return (0);
1919
1920 topo_mod_dprintf(mod, "%s Controller %d: creating "
1921 "%llu %s nodes", cp->sec_csn, index, max + 1, SASEXPANDER);
1922
1923 /*
1924 * The max number represent the number of elements
1925 * deducted from the highest SES_PROP_ELEMENT_CLASS_INDEX
1926 * of SET_ET_SAS_EXPANDER type element.
1927 *
1928 * There may be multiple ESC Electronics element(controllers)
1929 * within JBOD(typicall two for redundancy) and SAS expander
1930 * elements are associated with only one of them. We are
1931 * still creating the range based max number here.
1932 * That will cover the case that all expanders are associated
1933 * with one SES controller.
1934 */
1935 if (dorange && topo_node_range_create(mod, pnode,
1936 SASEXPANDER, 0, max) != 0) {
1937 topo_mod_dprintf(mod,
1938 "topo_node_create_range() failed: %s",
1939 topo_mod_errmsg(mod));
1940 return (-1);
1941 }
1942
1943 /*
1944 * Search exapnders with the parent index matching with
1945 * ESC Electronics element index.
1946 * Note the index used here is a global index across
1947 * SES elements.
1948 */
1949 for (xsnp = topo_list_next(&cp->sec_nodes); xsnp != NULL;
1950 xsnp = topo_list_next(xsnp)) {
1951 if (xsnp->sen_type == SES_ET_SAS_EXPANDER) {
1952 /*
1953 * get the parent ESC controller.
1954 */
1955 psprops = ses_node_props(xsnp->sen_node);
1956 if (nvlist_lookup_uint64(psprops,
1957 SES_PROP_STATUS_CODE, &psstatus) == 0) {
1958 if (psstatus == SES_ESC_NOT_INSTALLED) {
1959 /*
1960 * Not installed.
1961 * Don't create a ndoe.
1962 */
1963 continue;
1964 }
1965 } else {
1966 /*
1967 * The element should have status code.
1968 * If not there is no way to find
1969 * out if the expander element exist or
1970 * not.
1971 */
1972 continue;
1973 }
1974
1975 /* Get the physical parent index to compare. */
1976 if (nvlist_lookup_uint64(psprops,
1977 LIBSES_PROP_PHYS_PARENT, &psindex) == 0) {
1978 if (index == psindex) {
1979 /* indentation moved forward */
1980 /*
1981 * Handle basic node information of SAS expander
1982 * element - binding to parent node and
1983 * allocating FMRI...
1984 */
1985 if (ses_create_generic(sdp, xsnp, pnode, pnode, SASEXPANDER,
1986 "SAS-EXPANDER", &exptn) != 0)
1987 continue;
1988 /*
1989 * Now handle SAS expander unique portion of node creation.
1990 * The max nubmer of the phy count is 256 since SES-2
1991 * defines as 1 byte field. The cidxlist has the same
1992 * number of elements.
1993 *
1994 * We use size 64 array to store the connectors.
1995 * Typically a connectors associated with 4 phys so that
1996 * matches with the max number of connecters associated
1997 * with an expander.
1998 * The phy count goes up to 38 for Sun supported
1999 * JBOD.
2000 */
2001 (void) memset(cidxlist, 0, sizeof (int64_t) * 64);
2002 if (ses_set_expander_props(sdp, xsnp, pnode, exptn, &phycount,
2003 cidxlist) != 0) {
2004 /*
2005 * error on getting specific prop failed.
2006 * continue on. Note that the node is
2007 * left bound.
2008 */
2009 continue;
2010 }
2011
2012 /*
2013 * count represetns the number of connectors discovered so far.
2014 */
2015 count = 0;
2016 (void) memset(connectors, 0,
2017 sizeof (sas_connector_phy_data_t) * 64);
2018 for (i = 0; i < phycount; i++) {
2019 if (cidxlist[i] != -1) {
2020 /* connector index is valid. */
2021 for (j = 0; j < count; j++) {
2022 if (connectors[j].scpd_index ==
2023 cidxlist[i]) {
2024 /*
2025 * Just update phy mask.
2026 * The postion for connector
2027 * index lists(cidxlist index)
2028 * is set.
2029 */
2030 connectors[j].scpd_pm =
2031 connectors[j].scpd_pm |
2032 (1ULL << i);
2033 break;
2034 }
2035 }
2036 /*
2037 * If j and count matche a new connector
2038 * index is found.
2039 */
2040 if (j == count) {
2041 /* add a new index and phy mask. */
2042 connectors[count].scpd_index =
2043 cidxlist[i];
2044 connectors[count].scpd_pm =
2045 connectors[count].scpd_pm |
2046 (1ULL << i);
2047 count++;
2048 }
2049 }
2050 }
2051
2052 /*
2053 * create range for the connector nodes.
2054 * The class index of the ses connector element
2055 * is set as the instance nubmer for the node.
2056 * Even though one expander may not have all connectors
2057 * are associated with we are creating the range with
2058 * max possible instance number.
2059 */
2060 found = B_FALSE;
2061 max = 0;
2062 for (consnp = topo_list_next(&cp->sec_nodes);
2063 consnp != NULL; consnp = topo_list_next(consnp)) {
2064 if (consnp->sen_type == SES_ET_SAS_CONNECTOR) {
2065 psprops = ses_node_props(consnp->sen_node);
2066 found = B_TRUE;
2067 if (consnp->sen_instance > max)
2068 max = consnp->sen_instance;
2069 }
2070 }
2071
2072 /*
2073 * No SAS connector found nothing to process.
2074 */
2075 if (!found)
2076 return (0);
2077
2078 if (dorange && topo_node_range_create(mod, exptn,
2079 RECEPTACLE, 0, max) != 0) {
2080 topo_mod_dprintf(mod,
2081 "topo_node_create_range() failed: %s",
2082 topo_mod_errmsg(mod));
2083 return (-1);
2084 }
2085
2086 /* search matching connector element using the index. */
2087 for (i = 0; i < count; i++) {
2088 found = B_FALSE;
2089 for (consnp = topo_list_next(&cp->sec_nodes);
2090 consnp != NULL; consnp = topo_list_next(consnp)) {
2091 if (consnp->sen_type == SES_ET_SAS_CONNECTOR) {
2092 psprops = ses_node_props(
2093 consnp->sen_node);
2094 /*
2095 * Get the physical parent index to
2096 * compare.
2097 * The connector elements are children
2098 * of ESC Electronics element even
2099 * though we enumerate them under
2100 * an expander in libtopo.
2101 */
2102 if (nvlist_lookup_uint64(psprops,
2103 SES_PROP_ELEMENT_ONLY_INDEX,
2104 &conindex) == 0) {
2105 if (conindex ==
2106 connectors[i].scpd_index) {
2107 found = B_TRUE;
2108 break;
2109 }
2110 }
2111 }
2112 }
2113
2114 /* now create a libtopo node. */
2115 if (found) {
2116 /* Create generic props. */
2117 if (ses_create_generic(sdp, consnp, exptn,
2118 topo_node_parent(exptn),
2119 RECEPTACLE, "RECEPTACLE", &contn) !=
2120 0) {
2121 continue;
2122 }
2123 /* Create connector specific props. */
2124 if (ses_set_connector_props(sdp, consnp,
2125 contn, connectors[i].scpd_pm) != 0) {
2126 continue;
2127 }
2128 }
2129 }
2130 /* end indentation change */
2131 }
2132 }
2133 }
2134 }
2135
2136 return (0);
2137 }
2138
2139 /*
2140 * Instantiate any protocol specific portion of a node.
2141 */
2142 /*ARGSUSED*/
2143 static int
2144 ses_create_protocol_specific(ses_enum_data_t *sdp, ses_enum_node_t *snp,
2145 tnode_t *pnode, uint64_t type, ses_enum_chassis_t *cp,
2146 boolean_t dorange)
2147 {
2148
2149 if (type == SES_ET_ESC_ELECTRONICS) {
2150 /* create SAS specific children(expanders and connectors. */
2151 return (ses_create_esc_sasspecific(sdp, snp, pnode, cp,
2152 dorange));
2153 }
2154
2155 return (0);
2156 }
2157
2158 /*
2159 * Instantiate any children of a given type.
2160 */
2161 static int
2162 ses_create_children(ses_enum_data_t *sdp, tnode_t *pnode, uint64_t type,
2163 const char *nodename, const char *defaultlabel, ses_enum_chassis_t *cp,
2164 boolean_t dorange)
2165 {
2166 topo_mod_t *mod = sdp->sed_mod;
2167 boolean_t found;
2168 uint64_t max;
2169 ses_enum_node_t *snp;
2170 tnode_t *tn;
2171
2172 /*
2173 * First go through and count how many matching nodes we have.
2174 */
2175 max = 0;
2176 found = B_FALSE;
2177 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2178 snp = topo_list_next(snp)) {
2179 if (snp->sen_type == type) {
2180 found = B_TRUE;
2181 if (snp->sen_instance > max)
2182 max = snp->sen_instance;
2183 }
2184 }
2185
2186 /*
2187 * No enclosure should export both DEVICE and ARRAY_DEVICE elements.
2188 * Since we map both of these to 'disk', if an enclosure does this, we
2189 * just ignore the array elements.
2190 */
2191 if (!found ||
2192 (type == SES_ET_ARRAY_DEVICE && cp->sec_hasdev))
2193 return (0);
2194
2195 topo_mod_dprintf(mod, "%s: creating %llu %s nodes",
2196 cp->sec_csn, max + 1, nodename);
2197
2198 if (dorange && topo_node_range_create(mod, pnode,
2199 nodename, 0, max) != 0) {
2200 topo_mod_dprintf(mod,
2201 "topo_node_create_range() failed: %s",
2202 topo_mod_errmsg(mod));
2203 return (-1);
2204 }
2205
2206 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2207 snp = topo_list_next(snp)) {
2208 if (snp->sen_type == type) {
2209 /*
2210 * With flat layout of ses nodes there is no
2211 * way to find out the direct FRU for a node.
2212 * Passing NULL for fru topo node. Note that
2213 * ses_create_children_from_phys_tree() provides
2214 * the actual direct FRU for a node.
2215 */
2216 if (ses_create_generic(sdp, snp, pnode, NULL,
2217 nodename, defaultlabel, &tn) != 0)
2218 return (-1);
2219 /*
2220 * For some SES element there may be protocol specific
2221 * information to process. Here we are processing
2222 * the association between enclosure controller and
2223 * SAS expanders.
2224 */
2225 if (type == SES_ET_ESC_ELECTRONICS) {
2226 /* create SAS expander node */
2227 if (ses_create_protocol_specific(sdp, snp,
2228 tn, type, cp, dorange) != 0) {
2229 return (-1);
2230 }
2231 }
2232
2233 }
2234 }
2235
2236 return (0);
2237 }
2238
2239 /*
2240 * Instantiate a new subchassis instance in the topology.
2241 */
2242 static int
2243 ses_create_subchassis(ses_enum_data_t *sdp, tnode_t *pnode,
2244 ses_enum_chassis_t *scp)
2245 {
2246 topo_mod_t *mod = sdp->sed_mod;
2247 tnode_t *tn;
2248 nvlist_t *props;
2249 nvlist_t *auth = NULL, *fmri = NULL;
2250 uint64_t instance = scp->sec_instance;
2251 char *desc;
2252 char label[128];
2253 char **paths;
2254 int i, err;
2255 ses_enum_target_t *stp;
2256 int ret = -1;
2257
2258 /*
2259 * Copy authority information from parent enclosure node
2260 */
2261 if ((auth = topo_mod_auth(mod, pnode)) == NULL)
2262 goto error;
2263
2264 /*
2265 * Record the subchassis serial number in the FMRI.
2266 * For now, we assume that logical id is the subchassis serial number.
2267 * If this assumption changes in future, then the following
2268 * piece of code will need to be updated via an RFE.
2269 */
2270 if ((fmri = topo_mod_hcfmri(mod, pnode, FM_HC_SCHEME_VERSION,
2271 SUBCHASSIS, (topo_instance_t)instance, NULL, auth, NULL, NULL,
2272 NULL)) == NULL) {
2273 topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
2274 topo_mod_errmsg(mod));
2275 goto error;
2276 }
2277
2278 if ((tn = topo_node_bind(mod, pnode, SUBCHASSIS,
2279 instance, fmri)) == NULL) {
2280 topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
2281 topo_mod_errmsg(mod));
2282 goto error;
2283 }
2284
2285 props = ses_node_props(scp->sec_enclosure);
2286
2287 /*
2288 * Look for the subchassis label in the following order:
2289 * <ses-description>
2290 * <ses-class-description> <instance>
2291 * <default-type-label> <instance>
2292 *
2293 * For subchassis, the default label is "SUBCHASSIS"
2294 */
2295 if (nvlist_lookup_string(props, SES_PROP_DESCRIPTION, &desc) != 0 ||
2296 desc[0] == '\0') {
2297 if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION,
2298 &desc) == 0 && desc[0] != '\0')
2299 (void) snprintf(label, sizeof (label), "%s %llu", desc,
2300 instance);
2301 else
2302 (void) snprintf(label, sizeof (label),
2303 "SUBCHASSIS %llu", instance);
2304 desc = label;
2305 }
2306
2307 if (topo_node_label_set(tn, desc, &err) != 0)
2308 goto error;
2309
2310 if (ses_set_standard_props(mod, NULL, tn, NULL,
2311 ses_node_id(scp->sec_enclosure), scp->sec_target->set_devpath) != 0)
2312 goto error;
2313
2314 /*
2315 * Set the 'chassis-type' property for this subchassis. This is either
2316 * 'ses-class-description' or 'subchassis'.
2317 */
2318 if (nvlist_lookup_string(props, SES_PROP_CLASS_DESCRIPTION, &desc) != 0)
2319 desc = "subchassis";
2320
2321 if (topo_prop_set_string(tn, TOPO_PGROUP_SES,
2322 TOPO_PROP_CHASSIS_TYPE, TOPO_PROP_IMMUTABLE, desc, &err) != 0) {
2323 topo_mod_dprintf(mod, "failed to create property %s: %s\n",
2324 TOPO_PROP_CHASSIS_TYPE, topo_strerror(err));
2325 goto error;
2326 }
2327
2328 /*
2329 * For enclosures, we want to include all possible targets (for upgrade
2330 * purposes).
2331 */
2332 for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL;
2333 stp = topo_list_next(stp), i++)
2334 ;
2335
2336 verify(i != 0);
2337 paths = alloca(i * sizeof (char *));
2338
2339 for (i = 0, stp = topo_list_next(&scp->sec_targets); stp != NULL;
2340 stp = topo_list_next(stp), i++)
2341 paths[i] = stp->set_devpath;
2342
2343 if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES,
2344 TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths,
2345 i, &err) != 0) {
2346 topo_mod_dprintf(mod, "failed to create property %s: %s\n",
2347 TOPO_PROP_PATHS, topo_strerror(err));
2348 goto error;
2349 }
2350
2351 if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) {
2352 topo_mod_dprintf(mod, "topo_method_register() failed: %s",
2353 topo_mod_errmsg(mod));
2354 goto error;
2355 }
2356
2357 /*
2358 * Create the nodes for controllers and bays.
2359 */
2360 if (ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS,
2361 CONTROLLER, "CONTROLLER", scp, B_TRUE) != 0 ||
2362 ses_create_children(sdp, tn, SES_ET_DEVICE,
2363 BAY, "BAY", scp, B_TRUE) != 0 ||
2364 ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE,
2365 BAY, "BAY", scp, B_TRUE) != 0)
2366 goto error;
2367
2368 ret = 0;
2369
2370 error:
2371 nvlist_free(auth);
2372 nvlist_free(fmri);
2373 return (ret);
2374 }
2375
2376 /*
2377 * Function we use to insert a node.
2378 */
2379 static int
2380 ses_phys_tree_insert(topo_mod_t *mod, ses_phys_tree_t **sproot,
2381 ses_phys_tree_t *child)
2382 {
2383 uint64_t ppindex, eindex, pindex;
2384 ses_phys_tree_t *node_ptr;
2385 int ret = 0;
2386
2387 assert(sproot != NULL);
2388 assert(child != NULL);
2389
2390 if (*sproot == NULL) {
2391 *sproot = child;
2392 return (0);
2393 }
2394
2395 pindex = child->spt_pindex;
2396 ppindex = (*sproot)->spt_pindex;
2397 eindex = (*sproot)->spt_eonlyindex;
2398
2399 /*
2400 * If the element only index of the root is same as the physical
2401 * parent index of a node to be added, add the node as a child of
2402 * the current root.
2403 */
2404 if (eindex == pindex) {
2405 (void) ses_phys_tree_insert(mod, &(*sproot)->spt_child, child);
2406 child->spt_parent = *sproot;
2407 } else if (ppindex == pindex) {
2408 /*
2409 * if the physical parent of the current root and the child
2410 * is same, then this should be a sibling node.
2411 * Siblings can be different element types and arrange
2412 * them by group.
2413 */
2414 if ((*sproot)->spt_senumnode->sen_type ==
2415 child->spt_senumnode->sen_type) {
2416 child->spt_sibling = *sproot;
2417 *sproot = child;
2418 } else {
2419 /* add a node in front of matching element type. */
2420 node_ptr = *sproot;
2421 while (node_ptr->spt_sibling != NULL) {
2422 if (node_ptr->spt_sibling->
2423 spt_senumnode->sen_type ==
2424 child->spt_senumnode->sen_type) {
2425 child->spt_sibling =
2426 node_ptr->spt_sibling;
2427 node_ptr->spt_sibling = child;
2428 break;
2429 }
2430 node_ptr = node_ptr->spt_sibling;
2431 }
2432 /* no matching. Add the child at the end. */
2433 if (node_ptr->spt_sibling == NULL) {
2434 node_ptr->spt_sibling = child;
2435 }
2436 }
2437 child->spt_parent = (*sproot)->spt_parent;
2438 } else {
2439 /*
2440 * The root and the node is not directly related.
2441 * Try to insert to the child sub-tree first and then try to
2442 * insert to the sibling sub-trees. If fails for both
2443 * the caller will retry insertion later.
2444 */
2445 if ((*sproot)->spt_child) {
2446 ret = ses_phys_tree_insert(mod, &(*sproot)->spt_child,
2447 child);
2448 }
2449 if ((*sproot)->spt_child == NULL || ret != 0) {
2450 if ((*sproot)->spt_sibling) {
2451 ret = ses_phys_tree_insert(mod,
2452 &(*sproot)->spt_sibling, child);
2453 } else {
2454 ret = 1;
2455 }
2456 }
2457 return (ret);
2458 }
2459 return (0);
2460 }
2461
2462 /*
2463 * Construct tree view of ses elements through parent phyiscal element index.
2464 * The root of tree is already constructed using the enclosure element.
2465 */
2466 static int
2467 ses_construct_phys_tree(ses_enum_data_t *sdp, ses_enum_chassis_t *cp,
2468 ses_phys_tree_t *sproot)
2469 {
2470 ses_enum_node_t *snp;
2471 ses_phys_tree_t *child;
2472 ses_phys_tree_t *u_watch = NULL;
2473 ses_phys_tree_t *u_head = NULL;
2474 ses_phys_tree_t *u_tail = NULL;
2475 int u_inserted = 0, u_left = 0;
2476 nvlist_t *props;
2477 topo_mod_t *mod = sdp->sed_mod;
2478
2479 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2480 snp = topo_list_next(snp)) {
2481 if ((child = topo_mod_zalloc(mod,
2482 sizeof (ses_phys_tree_t))) == NULL) {
2483 topo_mod_dprintf(mod,
2484 "failed to allocate root.");
2485 return (-1);
2486 }
2487 child->spt_snode = snp->sen_node;
2488 props = ses_node_props(snp->sen_node);
2489 if (nvlist_lookup_uint64(props,
2490 LIBSES_PROP_PHYS_PARENT, &child->spt_pindex) != 0) {
2491 /*
2492 * the prop should exist. continue to see if
2493 * we can build a partial tree with other elements.
2494 */
2495 topo_mod_dprintf(mod,
2496 "ses_construct_phys_tree(): Failed to find prop %s "
2497 "on ses element type %d and instance %d "
2498 "(CSN %s).", LIBSES_PROP_PHYS_PARENT,
2499 snp->sen_type, snp->sen_instance, cp->sec_csn);
2500 topo_mod_free(mod, child, sizeof (ses_phys_tree_t));
2501 continue;
2502 } else {
2503 if (nvlist_lookup_boolean_value(props,
2504 LIBSES_PROP_FRU, &child->spt_isfru) != 0) {
2505 topo_mod_dprintf(mod,
2506 "ses_construct_phys_tree(): Failed to "
2507 "find prop %s on ses element type %d "
2508 "and instance %d (CSN %s).",
2509 LIBSES_PROP_FRU,
2510 snp->sen_type, snp->sen_instance,
2511 cp->sec_csn);
2512 /*
2513 * Ignore if the prop doesn't exist.
2514 * Note that the enclosure itself should be
2515 * a FRU so if no FRU found the enclosure FRU
2516 * can be a direct FRU.
2517 */
2518 }
2519 verify(nvlist_lookup_uint64(props,
2520 SES_PROP_ELEMENT_ONLY_INDEX,
2521 &child->spt_eonlyindex) == 0);
2522 verify(nvlist_lookup_uint64(props,
2523 SES_PROP_ELEMENT_CLASS_INDEX,
2524 &child->spt_cindex) == 0);
2525 }
2526 child->spt_senumnode = snp;
2527 if (ses_phys_tree_insert(mod, &sproot, child) != 0) {
2528 /* collect unresolved element to process later. */
2529 if (u_head == NULL) {
2530 u_head = child;
2531 u_tail = child;
2532 } else {
2533 child->spt_sibling = u_head;
2534 u_head = child;
2535 }
2536 }
2537 }
2538
2539 /*
2540 * The parent of a child node may not be inserted yet.
2541 * Trying to insert the child until no child is left or
2542 * no child is not added further. For the latter
2543 * the hierarchical relationship between elements
2544 * should be checked through SUNW,FRUID page.
2545 * u_watch is a watch dog to check the prgress of unresolved
2546 * node.
2547 */
2548 u_watch = u_tail;
2549 while (u_head) {
2550 child = u_head;
2551 u_head = u_head->spt_sibling;
2552 if (u_head == NULL)
2553 u_tail = NULL;
2554 child->spt_sibling = NULL;
2555 if (ses_phys_tree_insert(mod, &sproot, child) != 0) {
2556 u_tail->spt_sibling = child;
2557 u_tail = child;
2558 if (child == u_watch) {
2559 /*
2560 * We just scanned one round for the
2561 * unresolved list. Check to see whether we
2562 * have nodes inserted, if none, we should
2563 * break in case of an indefinite loop.
2564 */
2565 if (u_inserted == 0) {
2566 /*
2567 * Indicate there is unhandled node.
2568 * Chain free the whole unsolved
2569 * list here.
2570 */
2571 u_left++;
2572 break;
2573 } else {
2574 u_inserted = 0;
2575 u_watch = u_tail;
2576 }
2577 }
2578 } else {
2579 /*
2580 * We just inserted one rpnode, increment the
2581 * unsolved_inserted counter. We will utilize this
2582 * counter to detect an indefinite insertion loop.
2583 */
2584 u_inserted++;
2585 if (child == u_watch) {
2586 /*
2587 * watch dog node itself is inserted.
2588 * Set it to the tail and refresh the watching.
2589 */
2590 u_watch = u_tail;
2591 u_inserted = 0;
2592 u_left = 0;
2593 }
2594 }
2595 }
2596
2597 /* check if there is left out unresolved nodes. */
2598 if (u_left) {
2599 topo_mod_dprintf(mod, "ses_construct_phys_tree(): "
2600 "Failed to construct physical view of the following "
2601 "ses elements of Chassis CSN %s.", cp->sec_csn);
2602 while (u_head) {
2603 u_tail = u_head->spt_sibling;
2604 topo_mod_dprintf(mod,
2605 "\telement type (%d) and instance (%d)",
2606 u_head->spt_senumnode->sen_type,
2607 u_head->spt_senumnode->sen_instance);
2608 topo_mod_free(mod, u_head, sizeof (ses_phys_tree_t));
2609 u_head = u_tail;
2610 }
2611 return (-1);
2612 }
2613
2614 return (0);
2615 }
2616
2617 /*
2618 * Free the whole phys tree.
2619 */
2620 static void ses_phys_tree_free(topo_mod_t *mod, ses_phys_tree_t *sproot)
2621 {
2622 if (sproot == NULL)
2623 return;
2624
2625 /* Free child tree. */
2626 if (sproot->spt_child) {
2627 ses_phys_tree_free(mod, sproot->spt_child);
2628 }
2629
2630 /* Free sibling trees. */
2631 if (sproot->spt_sibling) {
2632 ses_phys_tree_free(mod, sproot->spt_sibling);
2633 }
2634
2635 /* Free root node itself. */
2636 topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t));
2637 }
2638
2639 /*
2640 * Parses phys_enum_type table to get the index of the given type.
2641 */
2642 static boolean_t
2643 is_type_enumerated(ses_phys_tree_t *node, int *index)
2644 {
2645 int i;
2646
2647 for (i = 0; i < N_PHYS_ENUM_TYPES; i++) {
2648 if (node->spt_senumnode->sen_type ==
2649 phys_enum_type_list[i].pet_type) {
2650 *index = i;
2651 return (B_TRUE);
2652 }
2653 }
2654 return (B_FALSE);
2655 }
2656
2657 /*
2658 * Recusrive routine for top-down enumeration of the tree.
2659 */
2660 static int
2661 ses_enumerate_node(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp,
2662 ses_phys_tree_t *parent, int mrange[])
2663 {
2664 topo_mod_t *mod = sdp->sed_mod;
2665 ses_phys_tree_t *child = NULL;
2666 int i, ret = 0, ret_ch;
2667 uint64_t prevtype = SES_ET_UNSPECIFIED;
2668 ses_phys_tree_t *dirfru = NULL;
2669 tnode_t *tn = NULL, *frutn = NULL;
2670
2671 if (parent == NULL) {
2672 return (0);
2673 }
2674
2675 for (child = parent->spt_child; child != NULL;
2676 child = child->spt_sibling) {
2677 if (is_type_enumerated(child, &i)) {
2678 if (prevtype != phys_enum_type_list[i].pet_type) {
2679 /* check if range needs to be created. */
2680 if (phys_enum_type_list[i].pet_dorange &&
2681 topo_node_range_create(mod, pnode,
2682 phys_enum_type_list[i].pet_nodename, 0,
2683 mrange[i]) != 0) {
2684 topo_mod_dprintf(mod,
2685 "topo_node_create_range() failed: "
2686 "%s", topo_mod_errmsg(mod));
2687 return (-1);
2688 }
2689 prevtype = phys_enum_type_list[i].pet_type;
2690 }
2691
2692 if (!(child->spt_isfru)) {
2693 for (dirfru = parent; dirfru != NULL;
2694 dirfru = dirfru->spt_parent) {
2695 if (dirfru->spt_isfru) {
2696 break;
2697 }
2698 }
2699 /* found direct FRU node. */
2700 if (dirfru) {
2701 frutn = dirfru->spt_tnode;
2702 } else {
2703 frutn = NULL;
2704 }
2705 } else {
2706 frutn = NULL;
2707 }
2708
2709 if (ses_create_generic(sdp, child->spt_senumnode,
2710 pnode, frutn, phys_enum_type_list[i].pet_nodename,
2711 phys_enum_type_list[i].pet_defaultlabel, &tn) != 0)
2712 return (-1);
2713
2714 child->spt_tnode = tn;
2715 /*
2716 * For some SES element there may be protocol specific
2717 * information to process. Here we are processing
2718 * the association between enclosure controller and
2719 * SAS expanders.
2720 */
2721 if (phys_enum_type_list[i].pet_type ==
2722 SES_ET_ESC_ELECTRONICS) {
2723 /* create SAS expander node */
2724 if (ses_create_protocol_specific(sdp,
2725 child->spt_senumnode, tn,
2726 phys_enum_type_list[i].pet_type,
2727 cp, phys_enum_type_list[i].pet_dorange) !=
2728 0) {
2729 return (-1);
2730 }
2731 }
2732 } else {
2733 continue;
2734 }
2735 ret_ch = ses_enumerate_node(sdp, tn, cp, child, mrange);
2736 if (ret_ch)
2737 ret = ret_ch; /* there was an error and set the ret. */
2738 }
2739
2740 return (ret);
2741 }
2742
2743 /*
2744 * Instantiate types of nodes that are specified in the hierarchy
2745 * element type list.
2746 */
2747 static int
2748 ses_create_children_from_phys_tree(ses_enum_data_t *sdp, tnode_t *pnode,
2749 ses_enum_chassis_t *cp, ses_phys_tree_t *phys_tree)
2750 {
2751 topo_mod_t *mod = sdp->sed_mod;
2752 int mrange[N_PHYS_ENUM_TYPES] = { 0 };
2753 ses_enum_node_t *snp;
2754 int i, ret;
2755
2756 /*
2757 * First get max range for each type of element to be enumerated.
2758 */
2759 for (i = 0; i < N_PHYS_ENUM_TYPES; i++) {
2760 if (phys_enum_type_list[i].pet_dorange) {
2761 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2762 snp = topo_list_next(snp)) {
2763 if (snp->sen_type ==
2764 phys_enum_type_list[i].pet_type) {
2765 if (snp->sen_instance > mrange[i])
2766 mrange[i] =
2767 snp->sen_instance;
2768 }
2769 }
2770 }
2771 }
2772
2773 topo_mod_dprintf(mod, "%s: creating nodes from FRU hierarchy tree.",
2774 cp->sec_csn);
2775
2776 if ((ret = ses_enumerate_node(sdp, pnode, cp, phys_tree, mrange)) !=
2777 0) {
2778 topo_mod_dprintf(mod,
2779 "ses_create_children_from_phys_tree() failed: ");
2780 return (ret);
2781 }
2782
2783 return (0);
2784 }
2785
2786 /*
2787 * Instantiate a new chassis instance in the topology.
2788 */
2789 static int
2790 ses_create_chassis(ses_enum_data_t *sdp, tnode_t *pnode, ses_enum_chassis_t *cp)
2791 {
2792 topo_mod_t *mod = sdp->sed_mod;
2793 nvlist_t *props;
2794 char *raw_manufacturer, *raw_model, *raw_revision;
2795 char *manufacturer = NULL, *model = NULL, *product = NULL;
2796 char *revision = NULL;
2797 char *serial;
2798 char **paths;
2799 size_t prodlen;
2800 tnode_t *tn;
2801 nvlist_t *fmri = NULL, *auth = NULL;
2802 int ret = -1;
2803 ses_enum_node_t *snp;
2804 ses_enum_target_t *stp;
2805 ses_enum_chassis_t *scp;
2806 int i, err;
2807 uint64_t sc_count = 0, pindex;
2808 ses_phys_tree_t *sproot = NULL;
2809 hrtime_t start;
2810 hrtime_t end;
2811 double duration;
2812
2813 /*
2814 * Ignore any internal enclosures.
2815 */
2816 if (cp->sec_internal)
2817 return (0);
2818
2819 /*
2820 * Check to see if there are any devices presennt in the chassis. If
2821 * not, ignore the chassis alltogether. This is most useful for
2822 * ignoring internal HBAs that present a SES target but don't actually
2823 * manage any of the devices.
2824 */
2825 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
2826 snp = topo_list_next(snp)) {
2827 if (snp->sen_type == SES_ET_DEVICE ||
2828 snp->sen_type == SES_ET_ARRAY_DEVICE)
2829 break;
2830 }
2831
2832 if (snp == NULL)
2833 return (0);
2834
2835 props = ses_node_props(cp->sec_enclosure);
2836
2837 /*
2838 * We use the following property mappings:
2839 *
2840 * manufacturer vendor-id
2841 * model product-id
2842 * serial-number libses-chassis-serial
2843 */
2844 verify(nvlist_lookup_string(props, SES_EN_PROP_VID,
2845 &raw_manufacturer) == 0);
2846 verify(nvlist_lookup_string(props, SES_EN_PROP_PID, &raw_model) == 0);
2847 verify(nvlist_lookup_string(props, SES_EN_PROP_REV,
2848 &raw_revision) == 0);
2849 verify(nvlist_lookup_string(props, LIBSES_EN_PROP_CSN, &serial) == 0);
2850
2851 /*
2852 * To construct the authority information, we 'clean' each string by
2853 * removing any offensive characters and trimmming whitespace. For the
2854 * 'product-id', we use a concatenation of 'manufacturer-model'. We
2855 * also take the numerical serial number and convert it to a string.
2856 */
2857 if ((manufacturer = topo_mod_clean_str(mod, raw_manufacturer)) ==
2858 NULL || (model = topo_mod_clean_str(mod, raw_model)) == NULL ||
2859 (revision = topo_mod_clean_str(mod, raw_revision)) == NULL) {
2860 goto error;
2861 }
2862
2863 prodlen = strlen(manufacturer) + strlen(model) + 2;
2864 if ((product = topo_mod_alloc(mod, prodlen)) == NULL)
2865 goto error;
2866
2867 (void) snprintf(product, prodlen, "%s-%s", manufacturer, model);
2868
2869 /*
2870 * Construct the topo node and bind it to our parent.
2871 */
2872 if (topo_mod_nvalloc(mod, &auth, NV_UNIQUE_NAME) != 0)
2873 goto error;
2874
2875 if (nvlist_add_string(auth, FM_FMRI_AUTH_PRODUCT, product) != 0 ||
2876 nvlist_add_string(auth, FM_FMRI_AUTH_CHASSIS, serial) != 0) {
2877 (void) topo_mod_seterrno(mod, EMOD_NVL_INVAL);
2878 goto error;
2879 }
2880
2881 /*
2882 * We pass NULL for the parent FMRI because there is no resource
2883 * associated with it. For the toplevel enclosure, we leave the
2884 * serial/part/revision portions empty, which are reserved for
2885 * individual components within the chassis.
2886 */
2887 if ((fmri = topo_mod_hcfmri(mod, NULL, FM_HC_SCHEME_VERSION,
2888 SES_ENCLOSURE, cp->sec_instance, NULL, auth,
2889 model, revision, serial)) == NULL) {
2890 topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
2891 topo_mod_errmsg(mod));
2892 goto error;
2893 }
2894
2895 if ((tn = topo_node_bind(mod, pnode, SES_ENCLOSURE,
2896 cp->sec_instance, fmri)) == NULL) {
2897 topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
2898 topo_mod_errmsg(mod));
2899 goto error;
2900 }
2901
2902 if (topo_method_register(mod, tn, ses_enclosure_methods) != 0) {
2903 topo_mod_dprintf(mod,
2904 "topo_method_register() failed: %s",
2905 topo_mod_errmsg(mod));
2906 goto error;
2907 }
2908
2909 if (ses_set_standard_props(mod, NULL, tn, auth,
2910 ses_node_id(cp->sec_enclosure), cp->sec_target->set_devpath) != 0)
2911 goto error;
2912
2913 /*
2914 * For enclosures, we want to include all possible targets (for upgrade
2915 * purposes).
2916 */
2917 for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL;
2918 stp = topo_list_next(stp), i++)
2919 ;
2920
2921 verify(i != 0);
2922 paths = alloca(i * sizeof (char *));
2923
2924 for (i = 0, stp = topo_list_next(&cp->sec_targets); stp != NULL;
2925 stp = topo_list_next(stp), i++)
2926 paths[i] = stp->set_devpath;
2927
2928
2929 if (topo_prop_set_string_array(tn, TOPO_PGROUP_SES,
2930 TOPO_PROP_PATHS, TOPO_PROP_IMMUTABLE, (const char **)paths,
2931 i, &err) != 0) {
2932 topo_mod_dprintf(mod,
2933 "failed to create property %s: %s\n",
2934 TOPO_PROP_PATHS, topo_strerror(err));
2935 goto error;
2936 }
2937
2938 if (nvlist_lookup_uint64(props,
2939 LIBSES_PROP_PHYS_PARENT, &pindex) == 0) {
2940 start = gethrtime(); /* to mearusre performance */
2941 /*
2942 * The enclosure is supported through SUNW,FRUID.
2943 * Need to enumerate the nodes through hierarchical order.
2944 */
2945 if ((sproot = topo_mod_zalloc(mod,
2946 sizeof (ses_phys_tree_t))) == NULL) {
2947 topo_mod_dprintf(mod,
2948 "failed to allocate root: %s\n",
2949 topo_strerror(err));
2950 goto error;
2951 }
2952 sproot->spt_pindex = pindex;
2953 if (nvlist_lookup_boolean_value(props,
2954 LIBSES_PROP_FRU, &sproot->spt_isfru) != 0) {
2955 topo_mod_dprintf(mod,
2956 "ses_create_chassis(): Failed to find prop %s "
2957 "on enclosure element (CSN %s).",
2958 LIBSES_PROP_FRU, cp->sec_csn);
2959 /* an enclosure should be a FRU. continue to process. */
2960 sproot->spt_isfru = B_TRUE;
2961 }
2962 if (nvlist_lookup_uint64(props,
2963 SES_PROP_ELEMENT_ONLY_INDEX,
2964 &sproot->spt_eonlyindex) != 0) {
2965 topo_mod_dprintf(mod,
2966 "ses_create_chassis(): Failed to find prop %s "
2967 "on enclosure element (CSN %s).",
2968 LIBSES_PROP_PHYS_PARENT, cp->sec_csn);
2969 topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t));
2970 goto error;
2971 }
2972 if (sproot->spt_pindex != sproot->spt_eonlyindex) {
2973 topo_mod_dprintf(mod, "ses_create_chassis(): "
2974 "Enclosure element(CSN %s) should have "
2975 "itself as the parent to be the root node "
2976 "of FRU hierarchical tree.)", cp->sec_csn);
2977 topo_mod_free(mod, sproot, sizeof (ses_phys_tree_t));
2978 goto error;
2979 } else {
2980 sproot->spt_snode = cp->sec_enclosure;
2981 sproot->spt_tnode = tn;
2982 /* construct a tree. */
2983 if (ses_construct_phys_tree(sdp, cp, sproot) != 0) {
2984 topo_mod_dprintf(mod, "ses_create_chassis(): "
2985 "Failed to construct FRU hierarchical "
2986 "tree on enclosure (CSN %s.)",
2987 cp->sec_csn);
2988 }
2989
2990 /* enumerate elements from the tree. */
2991 if (ses_create_children_from_phys_tree(sdp, tn, cp,
2992 sproot) != 0) {
2993 topo_mod_dprintf(mod, "ses_create_chassis(): "
2994 "Failed to create children topo nodes out "
2995 "of FRU hierarchical tree on enclosure "
2996 "(CSN %s).", cp->sec_csn);
2997 }
2998 /* destroy the phys tree. */
2999 ses_phys_tree_free(mod, sproot);
3000 }
3001
3002 end = gethrtime();
3003 duration = end - start;
3004 duration /= HR_SECOND;
3005 topo_mod_dprintf(mod,
3006 "FRU boundary tree based enumeration: %.6f seconds",
3007 duration);
3008 } else {
3009 /*
3010 * Create the nodes for power supplies, fans, controllers and
3011 * devices. Note that SAS exopander nodes and connector nodes
3012 * are handled through protocol specific processing of
3013 * controllers.
3014 */
3015 if (ses_create_children(sdp, tn, SES_ET_POWER_SUPPLY,
3016 PSU, "PSU", cp, B_TRUE) != 0 ||
3017 ses_create_children(sdp, tn, SES_ET_COOLING,
3018 FAN, "FAN", cp, B_TRUE) != 0 ||
3019 ses_create_children(sdp, tn, SES_ET_ESC_ELECTRONICS,
3020 CONTROLLER, "CONTROLLER", cp, B_TRUE) != 0 ||
3021 ses_create_children(sdp, tn, SES_ET_DEVICE,
3022 BAY, "BAY", cp, B_TRUE) != 0 ||
3023 ses_create_children(sdp, tn, SES_ET_ARRAY_DEVICE,
3024 BAY, "BAY", cp, B_TRUE) != 0)
3025 goto error;
3026 }
3027
3028 if (cp->sec_maxinstance >= 0 &&
3029 (topo_node_range_create(mod, tn, SUBCHASSIS, 0,
3030 cp->sec_maxinstance) != 0)) {
3031 topo_mod_dprintf(mod, "topo_node_create_range() failed: %s",
3032 topo_mod_errmsg(mod));
3033 goto error;
3034 }
3035
3036 for (scp = topo_list_next(&cp->sec_subchassis); scp != NULL;
3037 scp = topo_list_next(scp)) {
3038
3039 if (ses_create_subchassis(sdp, tn, scp) != 0)
3040 goto error;
3041
3042 topo_mod_dprintf(mod, "created Subchassis node with "
3043 "instance %u\nand target (%s) under Chassis with CSN %s",
3044 scp->sec_instance, scp->sec_target->set_devpath,
3045 cp->sec_csn);
3046
3047 sc_count++;
3048 }
3049
3050 topo_mod_dprintf(mod, "%s: created %llu %s nodes",
3051 cp->sec_csn, sc_count, SUBCHASSIS);
3052
3053 cp->sec_target->set_refcount++;
3054 topo_node_setspecific(tn, cp->sec_target);
3055
3056 ret = 0;
3057 error:
3058 topo_mod_strfree(mod, manufacturer);
3059 topo_mod_strfree(mod, model);
3060 topo_mod_strfree(mod, revision);
3061 topo_mod_strfree(mod, product);
3062
3063 nvlist_free(fmri);
3064 nvlist_free(auth);
3065 return (ret);
3066 }
3067
3068 /*
3069 * Create a bay node explicitly enumerated via XML.
3070 */
3071 static int
3072 ses_create_bays(ses_enum_data_t *sdp, tnode_t *pnode)
3073 {
3074 topo_mod_t *mod = sdp->sed_mod;
3075 ses_enum_chassis_t *cp;
3076
3077 /*
3078 * Iterate over chassis looking for an internal enclosure. This
3079 * property is set via a vendor-specific plugin, and there should only
3080 * ever be a single internal chassis in a system.
3081 */
3082 for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL;
3083 cp = topo_list_next(cp)) {
3084 if (cp->sec_internal)
3085 break;
3086 }
3087
3088 if (cp == NULL) {
3089 topo_mod_dprintf(mod, "failed to find internal chassis\n");
3090 return (-1);
3091 }
3092
3093 if (ses_create_children(sdp, pnode, SES_ET_DEVICE,
3094 BAY, "BAY", cp, B_FALSE) != 0 ||
3095 ses_create_children(sdp, pnode, SES_ET_ARRAY_DEVICE,
3096 BAY, "BAY", cp, B_FALSE) != 0)
3097 return (-1);
3098
3099 return (0);
3100 }
3101
3102 /*
3103 * Initialize chassis or subchassis.
3104 */
3105 static int
3106 ses_init_chassis(topo_mod_t *mod, ses_enum_data_t *sdp, ses_enum_chassis_t *pcp,
3107 ses_enum_chassis_t *cp, ses_node_t *np, nvlist_t *props,
3108 uint64_t subchassis, ses_chassis_type_e flags)
3109 {
3110 boolean_t internal, ident;
3111
3112 assert((flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS |
3113 SES_DUP_CHASSIS | SES_DUP_SUBCHASSIS)) != 0);
3114
3115 assert(cp != NULL);
3116 assert(np != NULL);
3117 assert(props != NULL);
3118
3119 if (flags & (SES_NEW_SUBCHASSIS | SES_DUP_SUBCHASSIS))
3120 assert(pcp != NULL);
3121
3122 topo_mod_dprintf(mod, "ses_init_chassis: %s: index %llu, flags (%d)",
3123 sdp->sed_name, subchassis, flags);
3124
3125 if (flags & (SES_NEW_CHASSIS | SES_NEW_SUBCHASSIS)) {
3126
3127 topo_mod_dprintf(mod, "new chassis/subchassis");
3128 if (nvlist_lookup_boolean_value(props,
3129 LIBSES_EN_PROP_INTERNAL, &internal) == 0)
3130 cp->sec_internal = internal;
3131
3132 cp->sec_enclosure = np;
3133 cp->sec_target = sdp->sed_target;
3134
3135 if (flags & SES_NEW_CHASSIS) {
3136 if (!cp->sec_internal)
3137 cp->sec_instance = sdp->sed_instance++;
3138 topo_list_append(&sdp->sed_chassis, cp);
3139 } else {
3140 if (subchassis != NO_SUBCHASSIS)
3141 cp->sec_instance = subchassis;
3142 else
3143 cp->sec_instance = pcp->sec_scinstance++;
3144
3145 if (cp->sec_instance > pcp->sec_maxinstance)
3146 pcp->sec_maxinstance = cp->sec_instance;
3147
3148 topo_list_append(&pcp->sec_subchassis, cp);
3149 }
3150
3151 } else {
3152 topo_mod_dprintf(mod, "dup chassis/subchassis");
3153 if (nvlist_lookup_boolean_value(props,
3154 SES_PROP_IDENT, &ident) == 0) {
3155 topo_mod_dprintf(mod, "overriding enclosure node");
3156
3157 cp->sec_enclosure = np;
3158 cp->sec_target = sdp->sed_target;
3159 }
3160 }
3161
3162 topo_list_append(&cp->sec_targets, sdp->sed_target);
3163 sdp->sed_current = cp;
3164
3165 return (0);
3166 }
3167
3168 /*
3169 * Gather nodes from the current SES target into our chassis list, merging the
3170 * results if necessary.
3171 */
3172 static ses_walk_action_t
3173 ses_enum_gather(ses_node_t *np, void *data)
3174 {
3175 nvlist_t *props = ses_node_props(np);
3176 ses_enum_data_t *sdp = data;
3177 topo_mod_t *mod = sdp->sed_mod;
3178 ses_enum_chassis_t *cp, *scp;
3179 ses_enum_node_t *snp;
3180 ses_alt_node_t *sap;
3181 char *csn;
3182 uint64_t instance, type;
3183 uint64_t prevstatus, status;
3184 boolean_t report;
3185 uint64_t subchassis = NO_SUBCHASSIS;
3186
3187 if (ses_node_type(np) == SES_NODE_ENCLOSURE) {
3188 /*
3189 * If we have already identified the chassis for this target,
3190 * then this is a secondary enclosure and we should ignore it,
3191 * along with the rest of the tree (since this is depth-first).
3192 */
3193 if (sdp->sed_current != NULL)
3194 return (SES_WALK_ACTION_TERMINATE);
3195
3196 /*
3197 * Go through the list of chassis we have seen so far and see
3198 * if this serial number matches one of the known values.
3199 * If so, check whether this enclosure is a subchassis.
3200 */
3201 if (nvlist_lookup_string(props, LIBSES_EN_PROP_CSN,
3202 &csn) != 0)
3203 return (SES_WALK_ACTION_TERMINATE);
3204
3205 (void) nvlist_lookup_uint64(props, LIBSES_EN_PROP_SUBCHASSIS_ID,
3206 &subchassis);
3207
3208 topo_mod_dprintf(mod, "ses_enum_gather: Enclosure Node (%s) "
3209 "CSN (%s), subchassis (%llu)", sdp->sed_name, csn,
3210 subchassis);
3211
3212 /*
3213 * We need to determine whether this enclosure node
3214 * represents a chassis or a subchassis. Since we may
3215 * receive the enclosure nodes in a non-deterministic
3216 * manner, we need to account for all possible combinations:
3217 * 1. Chassis for the current CSN has not yet been
3218 * allocated
3219 * 1.1 This is a new chassis:
3220 * allocate and instantiate the chassis
3221 * 1.2 This is a new subchassis:
3222 * allocate a placeholder chassis
3223 * allocate and instantiate the subchassis
3224 * link the subchassis to the chassis
3225 * 2. Chassis for the current CSN has been allocated
3226 * 2.1 This is a duplicate chassis enclosure
3227 * check whether to override old chassis
3228 * append to chassis' target list
3229 * 2.2 Only placeholder chassis exists
3230 * fill in the chassis fields
3231 * 2.3 This is a new subchassis
3232 * allocate and instantiate the subchassis
3233 * link the subchassis to the chassis
3234 * 2.4 This is a duplicate subchassis enclosure
3235 * check whether to override old chassis
3236 * append to chassis' target list
3237 */
3238
3239 for (cp = topo_list_next(&sdp->sed_chassis); cp != NULL;
3240 cp = topo_list_next(cp))
3241 if (strcmp(cp->sec_csn, csn) == 0)
3242 break;
3243
3244 if (cp == NULL) {
3245 /* 1. Haven't seen a chassis with this CSN before */
3246
3247 if ((cp = topo_mod_zalloc(mod,
3248 sizeof (ses_enum_chassis_t))) == NULL)
3249 goto error;
3250
3251 cp->sec_scinstance = SES_STARTING_SUBCHASSIS;
3252 cp->sec_maxinstance = -1;
3253 cp->sec_csn = csn;
3254
3255 if (subchassis == NO_SUBCHASSIS) {
3256 /* 1.1 This is a new chassis */
3257
3258 topo_mod_dprintf(mod, "%s: Initialize new "
3259 "chassis with CSN %s", sdp->sed_name, csn);
3260
3261 if (ses_init_chassis(mod, sdp, NULL, cp,
3262 np, props, NO_SUBCHASSIS,
3263 SES_NEW_CHASSIS) < 0)
3264 goto error;
3265 } else {
3266 /* 1.2 This is a new subchassis */
3267
3268 topo_mod_dprintf(mod, "%s: Initialize new "
3269 "subchassis with CSN %s and index %llu",
3270 sdp->sed_name, csn, subchassis);
3271
3272 if ((scp = topo_mod_zalloc(mod,
3273 sizeof (ses_enum_chassis_t))) == NULL)
3274 goto error;
3275
3276 scp->sec_csn = csn;
3277
3278 if (ses_init_chassis(mod, sdp, cp, scp, np,
3279 props, subchassis, SES_NEW_SUBCHASSIS) < 0)
3280 goto error;
3281 }
3282 } else {
3283 /*
3284 * We have a chassis or subchassis with this CSN. If
3285 * it's a chassis, we must check to see whether it is
3286 * a placeholder previously created because we found a
3287 * subchassis with this CSN. We will know that because
3288 * the sec_target value will not be set; it is set only
3289 * in ses_init_chassis(). In that case, initialise it
3290 * as a new chassis; otherwise, it's a duplicate and we
3291 * need to append only.
3292 */
3293 if (subchassis == NO_SUBCHASSIS) {
3294 if (cp->sec_target != NULL) {
3295 /* 2.1 This is a duplicate chassis */
3296
3297 topo_mod_dprintf(mod, "%s: Append "
3298 "duplicate chassis with CSN (%s)",
3299 sdp->sed_name, csn);
3300
3301 if (ses_init_chassis(mod, sdp, NULL, cp,
3302 np, props, NO_SUBCHASSIS,
3303 SES_DUP_CHASSIS) < 0)
3304 goto error;
3305 } else {
3306 /* Placeholder chassis - init it up */
3307 topo_mod_dprintf(mod, "%s: Initialize"
3308 "placeholder chassis with CSN %s",
3309 sdp->sed_name, csn);
3310
3311 if (ses_init_chassis(mod, sdp, NULL,
3312 cp, np, props, NO_SUBCHASSIS,
3313 SES_NEW_CHASSIS) < 0)
3314 goto error;
3315
3316 }
3317 } else {
3318 /* This is a subchassis */
3319
3320 for (scp = topo_list_next(&cp->sec_subchassis);
3321 scp != NULL; scp = topo_list_next(scp))
3322 if (scp->sec_instance == subchassis)
3323 break;
3324
3325 if (scp == NULL) {
3326 /* 2.3 This is a new subchassis */
3327
3328 topo_mod_dprintf(mod, "%s: Initialize "
3329 "new subchassis with CSN (%s) "
3330 "and LID (%s)",
3331 sdp->sed_name, csn);
3332
3333 if ((scp = topo_mod_zalloc(mod,
3334 sizeof (ses_enum_chassis_t)))
3335 == NULL)
3336 goto error;
3337
3338 scp->sec_csn = csn;
3339
3340 if (ses_init_chassis(mod, sdp, cp, scp,
3341 np, props, subchassis,
3342 SES_NEW_SUBCHASSIS) < 0)
3343 goto error;
3344 } else {
3345 /* 2.4 This is a duplicate subchassis */
3346
3347 topo_mod_dprintf(mod, "%s: Append "
3348 "duplicate subchassis with "
3349 "CSN (%s)", sdp->sed_name, csn);
3350
3351 if (ses_init_chassis(mod, sdp, cp, scp,
3352 np, props, subchassis,
3353 SES_DUP_SUBCHASSIS) < 0)
3354 goto error;
3355 }
3356 }
3357 }
3358 } else if (ses_node_type(np) == SES_NODE_ELEMENT) {
3359 /*
3360 * If we haven't yet seen an enclosure node and identified the
3361 * current chassis, something is very wrong; bail out.
3362 */
3363 if (sdp->sed_current == NULL)
3364 return (SES_WALK_ACTION_TERMINATE);
3365
3366 /*
3367 * If this isn't one of the element types we care about, then
3368 * ignore it.
3369 */
3370 verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_TYPE,
3371 &type) == 0);
3372 if (type != SES_ET_DEVICE &&
3373 type != SES_ET_ARRAY_DEVICE &&
3374 type != SES_ET_SUNW_FANBOARD &&
3375 type != SES_ET_SUNW_FANMODULE &&
3376 type != SES_ET_COOLING &&
3377 type != SES_ET_SUNW_POWERBOARD &&
3378 type != SES_ET_SUNW_POWERMODULE &&
3379 type != SES_ET_POWER_SUPPLY &&
3380 type != SES_ET_ESC_ELECTRONICS &&
3381 type != SES_ET_SAS_EXPANDER &&
3382 type != SES_ET_SAS_CONNECTOR)
3383 return (SES_WALK_ACTION_CONTINUE);
3384
3385 /*
3386 * Get the current instance number and see if we already know
3387 * about this element. If so, it means we have multiple paths
3388 * to the same elements, and we should ignore the current path.
3389 */
3390 verify(nvlist_lookup_uint64(props, SES_PROP_ELEMENT_CLASS_INDEX,
3391 &instance) == 0);
3392 if (type == SES_ET_DEVICE || type == SES_ET_ARRAY_DEVICE)
3393 (void) nvlist_lookup_uint64(props, SES_PROP_BAY_NUMBER,
3394 &instance);
3395
3396 cp = sdp->sed_current;
3397
3398 for (snp = topo_list_next(&cp->sec_nodes); snp != NULL;
3399 snp = topo_list_next(snp)) {
3400 if (snp->sen_type == type &&
3401 snp->sen_instance == instance)
3402 break;
3403 }
3404
3405 /*
3406 * We prefer the new element under the following circumstances:
3407 *
3408 * - The currently known element's status is unknown or not
3409 * available, but the new element has a known status. This
3410 * occurs if a given element is only available through a
3411 * particular target.
3412 *
3413 * - This is an ESC_ELECTRONICS element, and the 'reported-via'
3414 * property is set. This allows us to get reliable firmware
3415 * revision information from the enclosure node.
3416 */
3417 if (snp != NULL) {
3418 if (nvlist_lookup_uint64(
3419 ses_node_props(snp->sen_node),
3420 SES_PROP_STATUS_CODE, &prevstatus) != 0)
3421 prevstatus = SES_ESC_UNSUPPORTED;
3422 if (nvlist_lookup_uint64(
3423 props, SES_PROP_STATUS_CODE, &status) != 0)
3424 status = SES_ESC_UNSUPPORTED;
3425 if (nvlist_lookup_boolean_value(
3426 props, SES_PROP_REPORT, &report) != 0)
3427 report = B_FALSE;
3428
3429 if ((SES_STATUS_UNAVAIL(prevstatus) &&
3430 !SES_STATUS_UNAVAIL(status)) ||
3431 (type == SES_ET_ESC_ELECTRONICS &&
3432 report)) {
3433 snp->sen_node = np;
3434 snp->sen_target = sdp->sed_target;
3435 }
3436
3437 if ((sap = topo_mod_zalloc(mod,
3438 sizeof (ses_alt_node_t))) == NULL)
3439 goto error;
3440
3441 sap->san_node = np;
3442 topo_list_append(&snp->sen_alt_nodes, sap);
3443
3444 return (SES_WALK_ACTION_CONTINUE);
3445 }
3446
3447 if ((snp = topo_mod_zalloc(mod,
3448 sizeof (ses_enum_node_t))) == NULL)
3449 goto error;
3450
3451 if ((sap = topo_mod_zalloc(mod,
3452 sizeof (ses_alt_node_t))) == NULL) {
3453 topo_mod_free(mod, snp, sizeof (ses_enum_node_t));
3454 goto error;
3455 }
3456
3457 topo_mod_dprintf(mod, "%s: adding node (%llu, %llu)",
3458 sdp->sed_name, type, instance);
3459 snp->sen_node = np;
3460 snp->sen_type = type;
3461 snp->sen_instance = instance;
3462 snp->sen_target = sdp->sed_target;
3463 sap->san_node = np;
3464 topo_list_append(&snp->sen_alt_nodes, sap);
3465 topo_list_append(&cp->sec_nodes, snp);
3466
3467 if (type == SES_ET_DEVICE)
3468 cp->sec_hasdev = B_TRUE;
3469 }
3470
3471 return (SES_WALK_ACTION_CONTINUE);
3472
3473 error:
3474 sdp->sed_errno = -1;
3475 return (SES_WALK_ACTION_TERMINATE);
3476 }
3477
3478 static int
3479 ses_process_dir(const char *dirpath, ses_enum_data_t *sdp)
3480 {
3481 topo_mod_t *mod = sdp->sed_mod;
3482 DIR *dir;
3483 struct dirent *dp;
3484 char path[PATH_MAX];
3485 ses_enum_target_t *stp;
3486 int err = -1;
3487
3488 /*
3489 * Open the SES target directory and iterate over any available
3490 * targets.
3491 */
3492 if ((dir = opendir(dirpath)) == NULL) {
3493 /*
3494 * If the SES target directory does not exist, then return as if
3495 * there are no active targets.
3496 */
3497 topo_mod_dprintf(mod, "failed to open ses "
3498 "directory '%s'", dirpath);
3499 return (0);
3500 }
3501
3502 while ((dp = readdir(dir)) != NULL) {
3503 if (strcmp(dp->d_name, ".") == 0 ||
3504 strcmp(dp->d_name, "..") == 0)
3505 continue;
3506
3507 /*
3508 * Create a new target instance and take a snapshot.
3509 */
3510 if ((stp = topo_mod_zalloc(mod,
3511 sizeof (ses_enum_target_t))) == NULL)
3512 goto error;
3513
3514 (void) pthread_mutex_init(&stp->set_lock, NULL);
3515
3516 (void) snprintf(path, sizeof (path), "%s/%s", dirpath,
3517 dp->d_name);
3518
3519 /*
3520 * We keep track of the SES device path and export it on a
3521 * per-node basis to allow higher level software to get to the
3522 * corresponding SES state.
3523 */
3524 if ((stp->set_devpath = topo_mod_strdup(mod, path)) == NULL) {
3525 topo_mod_free(mod, stp, sizeof (ses_enum_target_t));
3526 goto error;
3527 }
3528
3529 if ((stp->set_target =
3530 ses_open(LIBSES_VERSION, path)) == NULL) {
3531 topo_mod_dprintf(mod, "failed to open ses target "
3532 "'%s': %s", dp->d_name, ses_errmsg());
3533 ses_sof_alloc(mod, stp->set_devpath);
3534 topo_mod_free(mod, stp, sizeof (ses_enum_target_t));
3535 continue;
3536 }
3537 topo_mod_dprintf(mod, "open contract");
3538 ses_ssl_alloc(mod, stp);
3539 ses_create_contract(mod, stp);
3540
3541 stp->set_refcount = 1;
3542 sdp->sed_target = stp;
3543 stp->set_snap = ses_snap_hold(stp->set_target);
3544 stp->set_snaptime = gethrtime();
3545
3546 /*
3547 * Enumerate over all SES elements and merge them into the
3548 * correct ses_enum_chassis_t.
3549 */
3550 sdp->sed_current = NULL;
3551 sdp->sed_errno = 0;
3552 sdp->sed_name = dp->d_name;
3553 (void) ses_walk(stp->set_snap, ses_enum_gather, sdp);
3554
3555 if (sdp->sed_errno != 0)
3556 goto error;
3557 }
3558
3559 err = 0;
3560 error:
3561 (void) closedir(dir);
3562 return (err);
3563 }
3564
3565 static void
3566 ses_release(topo_mod_t *mod, tnode_t *tn)
3567 {
3568 ses_enum_target_t *stp;
3569
3570 if ((stp = topo_node_getspecific(tn)) != NULL) {
3571 topo_node_setspecific(tn, NULL);
3572 ses_target_free(mod, stp);
3573 }
3574 }
3575
3576 /*ARGSUSED*/
3577 static int
3578 ses_enum(topo_mod_t *mod, tnode_t *rnode, const char *name,
3579 topo_instance_t min, topo_instance_t max, void *arg, void *notused)
3580 {
3581 ses_enum_chassis_t *cp;
3582 ses_enum_data_t *data;
3583
3584 /*
3585 * Check to make sure we're being invoked sensibly, and that we're not
3586 * being invoked as part of a post-processing step.
3587 */
3588 if (strcmp(name, SES_ENCLOSURE) != 0 && strcmp(name, BAY) != 0)
3589 return (0);
3590
3591 /*
3592 * If this is the first time we've called our enumeration method, then
3593 * gather information about any available enclosures.
3594 */
3595 if ((data = topo_mod_getspecific(mod)) == NULL) {
3596 ses_sof_freeall(mod);
3597 if ((data = topo_mod_zalloc(mod, sizeof (ses_enum_data_t))) ==
3598 NULL)
3599 return (-1);
3600
3601 data->sed_mod = mod;
3602 topo_mod_setspecific(mod, data);
3603
3604 if (dev_list_gather(mod, &data->sed_devs) != 0)
3605 goto error;
3606
3607 /*
3608 * We search both the ses(7D) and sgen(7D) locations, so we are
3609 * independent of any particular driver class bindings.
3610 */
3611 if (ses_process_dir("/dev/es", data) != 0 ||
3612 ses_process_dir("/dev/scsi/ses", data) != 0)
3613 goto error;
3614 }
3615
3616 if (strcmp(name, SES_ENCLOSURE) == 0) {
3617 /*
3618 * This is a request to enumerate external enclosures. Go
3619 * through all the targets and create chassis nodes where
3620 * necessary.
3621 */
3622 for (cp = topo_list_next(&data->sed_chassis); cp != NULL;
3623 cp = topo_list_next(cp)) {
3624 if (ses_create_chassis(data, rnode, cp) != 0)
3625 goto error;
3626 }
3627 } else {
3628 /*
3629 * This is a request to enumerate a specific bay underneath the
3630 * root chassis (for internal disks).
3631 */
3632 if (ses_create_bays(data, rnode) != 0)
3633 goto error;
3634 }
3635
3636 /*
3637 * This is a bit of a kludge. In order to allow internal disks to be
3638 * enumerated and share snapshot-specific information with the external
3639 * enclosure enumeration, we rely on the fact that we will be invoked
3640 * for the 'ses-enclosure' node last.
3641 */
3642 if (strcmp(name, SES_ENCLOSURE) == 0) {
3643 for (cp = topo_list_next(&data->sed_chassis); cp != NULL;
3644 cp = topo_list_next(cp))
3645 ses_data_free(data, cp);
3646 ses_data_free(data, NULL);
3647 topo_mod_setspecific(mod, NULL);
3648 }
3649 return (0);
3650
3651 error:
3652 for (cp = topo_list_next(&data->sed_chassis); cp != NULL;
3653 cp = topo_list_next(cp))
3654 ses_data_free(data, cp);
3655 ses_data_free(data, NULL);
3656 topo_mod_setspecific(mod, NULL);
3657 return (-1);
3658 }
3659
3660 static const topo_modops_t ses_ops =
3661 { ses_enum, ses_release };
3662
3663 static topo_modinfo_t ses_info =
3664 { SES_ENCLOSURE, FM_FMRI_SCHEME_HC, SES_VERSION, &ses_ops };
3665
3666 /*ARGSUSED*/
3667 int
3668 _topo_init(topo_mod_t *mod, topo_version_t version)
3669 {
3670 int rval;
3671
3672 if (getenv("TOPOSESDEBUG") != NULL)
3673 topo_mod_setdebug(mod);
3674
3675 topo_mod_dprintf(mod, "initializing %s enumerator\n",
3676 SES_ENCLOSURE);
3677
3678 if ((rval = topo_mod_register(mod, &ses_info, TOPO_VERSION)) == 0)
3679 ses_thread_init(mod);
3680
3681 return (rval);
3682 }
3683
3684 void
3685 _topo_fini(topo_mod_t *mod)
3686 {
3687 ses_thread_fini(mod);
3688 ses_sof_freeall(mod);
3689 topo_mod_unregister(mod);
3690 }