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