1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <sys/types.h>
28 #include <sys/sysevent/dr.h>
29 #include <sys/sysevent/eventdefs.h>
30 #include <sys/sunddi.h> /* for the EC's for DEVFS */
31
32 #include <errno.h>
33 #include <string.h>
34 #include <strings.h>
35 #include <stdio.h>
36 #include <unistd.h>
37 #include <time.h>
38 #include <pthread.h>
39
40 #include <libsysevent.h>
41 #include <sys/sysevent_impl.h>
42
43 #include <libnvpair.h>
44 #include <config_admin.h>
45
46 #include "disk_monitor.h"
47 #include "hotplug_mgr.h"
48 #include "schg_mgr.h"
49 #include "dm_platform.h"
50
51 typedef struct sysevent_event {
52 sysevent_t *evp;
53 } sysevent_event_t;
54
55 /* Lock guarantees the ordering of the incoming sysevents */
56 static pthread_t g_sysev_tid;
57 static pthread_mutex_t g_event_handler_lock = PTHREAD_MUTEX_INITIALIZER;
58 static pthread_cond_t g_event_handler_cond = PTHREAD_COND_INITIALIZER;
59 static qu_t *g_sysev_queue = NULL;
60 static thread_state_t g_sysev_thread_state = TS_NOT_RUNNING;
61 /*
62 * The sysevent handle is bound to the main sysevent handler
63 * (event_handler), for each of the hotplug sysevents.
64 */
65 static sysevent_handle_t *sysevent_handle = NULL;
66
67 static void free_sysevent_event(void *p);
68
69 static int
nsleep(int seconds)70 nsleep(int seconds)
71 {
72 struct timespec tspec;
73
74 tspec.tv_sec = seconds;
75 tspec.tv_nsec = 0;
76
77 return (nanosleep(&tspec, NULL));
78 }
79
80 static int
config_list_ext_poll(int num,char * const * path,cfga_list_data_t ** list_array,int * nlist,int flag)81 config_list_ext_poll(int num, char * const *path,
82 cfga_list_data_t **list_array, int *nlist, int flag)
83 {
84 boolean_t done = B_FALSE;
85 boolean_t timedout = B_FALSE;
86 boolean_t interrupted = B_FALSE;
87 int timeout = 0;
88 int e;
89 #define TIMEOUT_MAX 60
90
91 do {
92 switch ((e = config_list_ext(num, path, list_array,
93 nlist, NULL, NULL, NULL, flag))) {
94
95 case CFGA_OK:
96
97 return (CFGA_OK);
98
99 case CFGA_BUSY:
100 case CFGA_SYSTEM_BUSY:
101
102 if (timeout++ >= TIMEOUT_MAX)
103 timedout = B_TRUE;
104 else {
105 if (nsleep(1) < 0)
106 interrupted = (errno == EINTR);
107 }
108 break;
109
110 default:
111 done = B_TRUE;
112 break;
113
114 }
115 } while (!done && !timedout && !interrupted);
116
117 return (e);
118 }
119
120 /*
121 * Given a physical attachment point with a dynamic component
122 * (as in the case of SCSI APs), ensure the 'controller'
123 * portion of the dynamic component matches the physical portion.
124 * Argument 'adjusted' must point to a buffer of at least
125 * MAXPATHLEN bytes.
126 */
127 void
adjust_dynamic_ap(const char * apid,char * adjusted)128 adjust_dynamic_ap(const char *apid, char *adjusted)
129 {
130 cfga_list_data_t *list_array = NULL;
131 int nlist;
132 char *ap_path[1];
133 char phys[MAXPATHLEN];
134 char dev_phys[MAXPATHLEN];
135 char *dyn;
136 int c, t, d;
137
138 dm_assert((strlen(apid) + 8 /* strlen("/devices") */) < MAXPATHLEN);
139
140 /* In the case of any error, return the unadjusted APID */
141 (void) strcpy(adjusted, apid);
142
143 /* if AP is not dynamic or not a disk node, no need to adjust it */
144 dyn = strstr(apid, "::");
145 if ((dyn == NULL) || (dyn == apid) ||
146 (sscanf(dyn, "::dsk/c%dt%dd%d", &c, &t, &d) != 3))
147 return;
148
149 /*
150 * Copy the AP_ID and terminate it at the '::' that we know
151 * for a fact it contains. Pre-pend '/devices' for the sake
152 * of cfgadm_scsi, and get the cfgadm data for the controller.
153 */
154 (void) strcpy(phys, apid);
155 *strstr(phys, "::") = '\0';
156 (void) snprintf(dev_phys, MAXPATHLEN, "/devices%s", phys);
157 ap_path[0] = dev_phys;
158
159 if (config_list_ext_poll(1, ap_path, &list_array, &nlist, 0)
160 != CFGA_OK)
161 return;
162
163 dm_assert(nlist == 1);
164
165 if (sscanf(list_array[0].ap_log_id, "c%d", &c) == 1)
166 (void) snprintf(adjusted, MAXPATHLEN, "%s::dsk/c%dt%dd%d",
167 phys, c, t, d);
168
169 free(list_array);
170 }
171
172 static int
disk_ap_is_scsi(const char * ap_path)173 disk_ap_is_scsi(const char *ap_path)
174 {
175 return (strstr(ap_path, ":scsi:") != NULL);
176 }
177
178 /*
179 * Looks up the attachment point's state and returns it in one of
180 * the hotplug states that the state change manager understands.
181 */
182 hotplug_state_t
disk_ap_state_to_hotplug_state(diskmon_t * diskp)183 disk_ap_state_to_hotplug_state(diskmon_t *diskp)
184 {
185 hotplug_state_t state = HPS_UNKNOWN;
186 cfga_list_data_t *list_array = NULL;
187 int rv, nlist;
188 char *app = (char *)dm_prop_lookup(diskp->app_props,
189 DISK_AP_PROP_APID);
190 char adj_app[MAXPATHLEN];
191 char *ap_path[1];
192 char *devices_app;
193 int len;
194 boolean_t list_valid = B_FALSE;
195
196 dm_assert(app != NULL);
197
198 adjust_dynamic_ap(app, adj_app);
199 ap_path[0] = adj_app;
200 devices_app = NULL;
201
202 rv = config_list_ext_poll(1, ap_path, &list_array, &nlist,
203 CFGA_FLAG_LIST_ALL);
204
205 if (rv != CFGA_OK) {
206 /*
207 * The SATA and SCSI libcfgadm plugins add a
208 * /devices to the phys id; to use it, we must
209 * prepend this string before the call.
210 */
211 len = 8 /* strlen("/devices") */ + strlen(adj_app) + 1;
212 devices_app = dmalloc(len);
213 (void) snprintf(devices_app, len, "/devices%s",
214 adj_app);
215 ap_path[0] = devices_app;
216
217 rv = config_list_ext_poll(1, ap_path, &list_array, &nlist,
218 CFGA_FLAG_LIST_ALL);
219 }
220
221 /*
222 * cfgadm_scsi will return an error for an absent target,
223 * so treat an error as "absent"; otherwise, make sure
224 * cfgadm_xxx has returned a list of 1 item
225 */
226 if (rv == CFGA_OK) {
227 dm_assert(nlist == 1);
228 list_valid = B_TRUE;
229 } else if (disk_ap_is_scsi(ap_path[0]))
230 state = HPS_ABSENT;
231
232 if (devices_app != NULL)
233 dfree(devices_app, len);
234
235 if (list_valid) {
236 /*
237 * The following truth table defines how each state is
238 * computed:
239 *
240 * +----------------------------------------------+
241 * | | o_state | r_state | condition |
242 * | +---------+---------+-----------|
243 * | Absent |Don'tCare|Disc/Empt| Don'tCare |
244 * | Present |Unconfgrd|Connected| unknown |
245 * | Configured |Configred|Connected| Don'tCare |
246 * | Unconfigured |Unconfgrd|Connected| OK |
247 * +--------------+---------+---------+-----------+
248 */
249
250 if (list_array[0].ap_r_state == CFGA_STAT_EMPTY ||
251 list_array[0].ap_r_state == CFGA_STAT_DISCONNECTED)
252 state = HPS_ABSENT;
253 else if (list_array[0].ap_r_state == CFGA_STAT_CONNECTED &&
254 list_array[0].ap_o_state == CFGA_STAT_UNCONFIGURED &&
255 list_array[0].ap_cond == CFGA_COND_UNKNOWN)
256 state = HPS_PRESENT;
257 else if (list_array[0].ap_r_state == CFGA_STAT_CONNECTED &&
258 list_array[0].ap_o_state == CFGA_STAT_UNCONFIGURED &&
259 list_array[0].ap_cond != CFGA_COND_UNKNOWN)
260 state = HPS_UNCONFIGURED;
261 else if (list_array[0].ap_r_state == CFGA_STAT_CONNECTED &&
262 list_array[0].ap_o_state == CFGA_STAT_CONFIGURED)
263 state = HPS_CONFIGURED;
264
265 free(list_array);
266 }
267
268 return (state);
269 }
270
271 /*
272 * Examine the sysevent passed in and returns the hotplug state that
273 * the sysevent states (or implies, in the case of attachment point
274 * events).
275 */
276 static hotplug_state_t
disk_sysev_to_state(diskmon_t * diskp,sysevent_t * evp)277 disk_sysev_to_state(diskmon_t *diskp, sysevent_t *evp)
278 {
279 const char *class_name, *subclass;
280 hotplug_state_t state = HPS_UNKNOWN;
281 sysevent_value_t se_val;
282
283 /*
284 * The state mapping is as follows:
285 *
286 * Sysevent State
287 * --------------------------------------------------------
288 * EC_DEVFS/ESC_DEVFS_DEVI_ADD Configured
289 * EC_DEVFS/ESC_DEVFS_DEVI_REMOVE Unconfigured
290 * EC_DR/ESC_DR_AP_STATE_CHANGE *[Absent/Present]
291 *
292 * (The EC_DR event requires a probe of the attachment point
293 * to determine the AP's state if there is no usable HINT)
294 *
295 */
296
297 class_name = sysevent_get_class_name(evp);
298 subclass = sysevent_get_subclass_name(evp);
299
300 if (strcmp(class_name, EC_DEVFS) == 0) {
301 if (strcmp(subclass, ESC_DEVFS_DEVI_ADD) == 0) {
302
303 state = HPS_CONFIGURED;
304
305 } else if (strcmp(subclass, ESC_DEVFS_DEVI_REMOVE) == 0) {
306
307 state = HPS_UNCONFIGURED;
308
309 }
310
311 } else if (strcmp(class_name, EC_DR) == 0 &&
312 ((strcmp(subclass, ESC_DR_AP_STATE_CHANGE) == 0) ||
313 (strcmp(subclass, ESC_DR_TARGET_STATE_CHANGE) == 0))) {
314
315 if (sysevent_lookup_attr(evp, DR_HINT, SE_DATA_TYPE_STRING,
316 &se_val) == 0 && se_val.value.sv_string != NULL) {
317
318 if (strcmp(se_val.value.sv_string, DR_HINT_INSERT)
319 == 0) {
320
321 state = HPS_PRESENT;
322
323 } else if (strcmp(se_val.value.sv_string,
324 DR_HINT_REMOVE) == 0) {
325
326 state = HPS_ABSENT;
327 }
328
329 }
330
331 /*
332 * If the state could not be determined by the hint
333 * (or there was no hint), ask the AP directly.
334 * SCSI HBAs may send an insertion sysevent
335 * *after* configuring the target node, so double-
336 * check HPS_PRESENT
337 */
338 if ((state == HPS_UNKNOWN) || (state = HPS_PRESENT))
339 state = disk_ap_state_to_hotplug_state(diskp);
340 }
341
342 return (state);
343 }
344
345 static void
disk_split_ap_path_sata(const char * ap_path,char * device,int * target)346 disk_split_ap_path_sata(const char *ap_path, char *device, int *target)
347 {
348 char *p;
349 int n;
350
351 /*
352 * /devices/rootnode/.../device:target
353 */
354 (void) strncpy(device, ap_path, MAXPATHLEN);
355 p = strrchr(device, ':');
356 dm_assert(p != NULL);
357 n = sscanf(p, ":%d", target);
358 dm_assert(n == 1);
359 *p = '\0';
360 }
361
362 static void
disk_split_ap_path_scsi(const char * ap_path,char * device,int * target)363 disk_split_ap_path_scsi(const char *ap_path, char *device, int *target)
364 {
365 char *p;
366 int n;
367
368 /*
369 * /devices/rootnode/.../device:scsi::dsk/cXtXdX
370 */
371
372 (void) strncpy(device, ap_path, MAXPATHLEN);
373 p = strrchr(device, ':');
374 dm_assert(p != NULL);
375
376 n = sscanf(p, ":dsk/c%*dt%dd%*d", target);
377 dm_assert(n == 1);
378
379 *strchr(device, ':') = '\0';
380 }
381
382 static void
disk_split_ap_path(const char * ap_path,char * device,int * target)383 disk_split_ap_path(const char *ap_path, char *device, int *target)
384 {
385 /*
386 * The AP path comes in two forms; for SATA devices,
387 * is is of the form:
388 * /devices/rootnode/.../device:portnum
389 * and for SCSI devices, it is of the form:
390 * /devices/rootnode/.../device:scsi::dsk/cXtXdX
391 */
392
393 if (disk_ap_is_scsi(ap_path))
394 disk_split_ap_path_scsi(ap_path, device, target);
395 else
396 disk_split_ap_path_sata(ap_path, device, target);
397 }
398
399 static void
disk_split_device_path(const char * dev_path,char * device,int * target)400 disk_split_device_path(const char *dev_path, char *device, int *target)
401 {
402 char *t, *p, *e;
403
404 /*
405 * The disk device path is of the form:
406 * /rootnode/.../device/target@tgtid,tgtlun
407 */
408
409 (void) strncpy(device, dev_path, MAXPATHLEN);
410 e = t = strrchr(device, '/');
411 dm_assert(t != NULL);
412
413 t = strchr(t, '@');
414 dm_assert(t != NULL);
415 t += 1;
416
417 if ((p = strchr(t, ',')) != NULL)
418 *p = '\0';
419
420 *target = strtol(t, 0, 16);
421 *e = '\0';
422 }
423
424 /*
425 * Returns the diskmon that corresponds to the physical disk path
426 * passed in.
427 */
428 static diskmon_t *
disk_match_by_device_path(diskmon_t * disklistp,const char * dev_path)429 disk_match_by_device_path(diskmon_t *disklistp, const char *dev_path)
430 {
431 char dev_device[MAXPATHLEN];
432 int dev_target;
433 char ap_device[MAXPATHLEN];
434 int ap_target;
435
436 dm_assert(disklistp != NULL);
437 dm_assert(dev_path != NULL);
438
439 if (strncmp(dev_path, DEVICES_PREFIX, 8) == 0)
440 dev_path += 8;
441
442 /* pare dev_path into device and target components */
443 disk_split_device_path(dev_path, (char *)&dev_device, &dev_target);
444
445 /*
446 * The AP path specified in the configuration properties is
447 * the path to an attachment point minor node whose port number is
448 * equal to the target number on the disk "major" node sent by the
449 * sysevent. To match them, we need to extract the target id and
450 * construct an AP string to compare to the AP path in the diskmon.
451 */
452 while (disklistp != NULL) {
453 char *app = (char *)dm_prop_lookup(disklistp->app_props,
454 DISK_AP_PROP_APID);
455 dm_assert(app != NULL);
456
457 /* Not necessary to adjust the APID here */
458 if (strncmp(app, DEVICES_PREFIX, 8) == 0)
459 app += 8;
460
461 disk_split_ap_path(app, (char *)&ap_device, &ap_target);
462
463 if ((strcmp(dev_device, ap_device) == 0) &&
464 (dev_target == ap_target))
465 return (disklistp);
466
467 disklistp = disklistp->next;
468 }
469 return (NULL);
470 }
471
472 static diskmon_t *
disk_match_by_ap_id(diskmon_t * disklistp,const char * ap_id)473 disk_match_by_ap_id(diskmon_t *disklistp, const char *ap_id)
474 {
475 const char *disk_ap_id;
476 dm_assert(disklistp != NULL);
477 dm_assert(ap_id != NULL);
478
479 /* Match only the device-tree portion of the name */
480 if (strncmp(ap_id, DEVICES_PREFIX, 8 /* strlen("/devices") */) == 0)
481 ap_id += 8;
482
483 while (disklistp != NULL) {
484 disk_ap_id = dm_prop_lookup(disklistp->app_props,
485 DISK_AP_PROP_APID);
486
487 dm_assert(disk_ap_id != NULL);
488
489 if (strcmp(disk_ap_id, ap_id) == 0)
490 return (disklistp);
491
492 disklistp = disklistp->next;
493 }
494 return (NULL);
495 }
496
497 static diskmon_t *
disk_match_by_target_id(diskmon_t * disklistp,const char * target_path)498 disk_match_by_target_id(diskmon_t *disklistp, const char *target_path)
499 {
500 const char *disk_ap_id;
501
502 char match_device[MAXPATHLEN];
503 int match_target;
504
505 char ap_device[MAXPATHLEN];
506 int ap_target;
507
508
509 /* Match only the device-tree portion of the name */
510 if (strncmp(target_path, DEVICES_PREFIX, 8) == 0)
511 target_path += 8;
512 disk_split_ap_path(target_path, (char *)&match_device, &match_target);
513
514 while (disklistp != NULL) {
515
516 disk_ap_id = dm_prop_lookup(disklistp->app_props,
517 DISK_AP_PROP_APID);
518 dm_assert(disk_ap_id != NULL);
519
520 disk_split_ap_path(disk_ap_id, (char *)&ap_device, &ap_target);
521 if ((match_target == ap_target) &&
522 (strcmp(match_device, ap_device) == 0))
523 return (disklistp);
524
525 disklistp = disklistp->next;
526 }
527 return (NULL);
528 }
529
530 static diskmon_t *
match_sysevent_to_disk(diskmon_t * disklistp,sysevent_t * evp)531 match_sysevent_to_disk(diskmon_t *disklistp, sysevent_t *evp)
532 {
533 diskmon_t *dmp = NULL;
534 sysevent_value_t se_val;
535 char *class_name = sysevent_get_class_name(evp);
536 char *subclass = sysevent_get_subclass_name(evp);
537
538 se_val.value.sv_string = NULL;
539
540 if (strcmp(class_name, EC_DEVFS) == 0) {
541 /* EC_DEVFS-class events have a `DEVFS_PATHNAME' property */
542 if (sysevent_lookup_attr(evp, DEVFS_PATHNAME,
543 SE_DATA_TYPE_STRING, &se_val) == 0 &&
544 se_val.value.sv_string != NULL) {
545
546 dmp = disk_match_by_device_path(disklistp,
547 se_val.value.sv_string);
548
549 }
550
551 } else if (strcmp(class_name, EC_DR) == 0 &&
552 strcmp(subclass, ESC_DR_AP_STATE_CHANGE) == 0) {
553
554 /* EC_DR-class events have a `DR_AP_ID' property */
555 if (sysevent_lookup_attr(evp, DR_AP_ID, SE_DATA_TYPE_STRING,
556 &se_val) == 0 && se_val.value.sv_string != NULL) {
557
558 dmp = disk_match_by_ap_id(disklistp,
559 se_val.value.sv_string);
560 }
561 } else if (strcmp(class_name, EC_DR) == 0 &&
562 strcmp(subclass, ESC_DR_TARGET_STATE_CHANGE) == 0) {
563 /* get DR_TARGET_ID */
564 if (sysevent_lookup_attr(evp, DR_TARGET_ID,
565 SE_DATA_TYPE_STRING, &se_val) == 0 &&
566 se_val.value.sv_string != NULL) {
567 dmp = disk_match_by_target_id(disklistp,
568 se_val.value.sv_string);
569 }
570 }
571
572 if (se_val.value.sv_string)
573 log_msg(MM_HPMGR, "match_sysevent_to_disk: device/ap: %s\n",
574 se_val.value.sv_string);
575
576 return (dmp);
577 }
578
579
580 /*
581 * The disk hotplug monitor (DHPM) listens for disk hotplug events and calls the
582 * state-change functionality when a disk's state changes. The DHPM listens for
583 * hotplug events via sysevent subscriptions to the following sysevent
584 * classes/subclasses: { EC_DEVFS/ESC_DEVFS_BRANCH_ADD,
585 * EC_DEVFS/ESC_DEVFS_BRANCH_REMOVE, EC_DEVFS/ESC_DEVFS_DEVI_ADD,
586 * EC_DEVFS/ESC_DEVFS_DEVI_REMOVE, EC_DR/ESC_DR_AP_STATE_CHANGE }. Once the
587 * event is received, the device path sent as part of the event is matched
588 * to one of the disks described by the configuration data structures.
589 */
590 static void
dm_process_sysevent(sysevent_t * dupev)591 dm_process_sysevent(sysevent_t *dupev)
592 {
593 char *class_name;
594 char *pub;
595 char *subclass = sysevent_get_subclass_name(dupev);
596 diskmon_t *diskp;
597
598 class_name = sysevent_get_class_name(dupev);
599 log_msg(MM_HPMGR, "****EVENT: %s %s (by %s)\n", class_name,
600 subclass,
601 ((pub = sysevent_get_pub_name(dupev)) != NULL) ? pub : "UNKNOWN");
602
603 if (pub)
604 free(pub);
605
606 if (strcmp(class_name, EC_PLATFORM) == 0 &&
607 strcmp(subclass, ESC_PLATFORM_SP_RESET) == 0) {
608 if (dm_platform_resync() != 0)
609 log_warn("failed to resync SP platform\n");
610 sysevent_free(dupev);
611 return;
612 }
613
614 /*
615 * We will handle this event if the event's target matches one of the
616 * disks we're monitoring
617 */
618 if ((diskp = match_sysevent_to_disk(config_data->disk_list, dupev))
619 != NULL) {
620
621 dm_state_change(diskp, disk_sysev_to_state(diskp, dupev));
622 }
623
624 sysevent_free(dupev);
625 }
626
627 static void
dm_fmd_sysevent_thread(void * queuep)628 dm_fmd_sysevent_thread(void *queuep)
629 {
630 qu_t *qp = (qu_t *)queuep;
631 sysevent_event_t *sevevp;
632
633 /* Signal the thread spawner that we're running */
634 dm_assert(pthread_mutex_lock(&g_event_handler_lock) == 0);
635 if (g_sysev_thread_state != TS_EXIT_REQUESTED)
636 g_sysev_thread_state = TS_RUNNING;
637 (void) pthread_cond_broadcast(&g_event_handler_cond);
638 dm_assert(pthread_mutex_unlock(&g_event_handler_lock) == 0);
639
640 while (g_sysev_thread_state != TS_EXIT_REQUESTED) {
641 if ((sevevp = (sysevent_event_t *)queue_remove(qp)) == NULL)
642 continue;
643
644 dm_process_sysevent(sevevp->evp);
645
646 free_sysevent_event(sevevp);
647 }
648
649 /* Signal the thread spawner that we've exited */
650 dm_assert(pthread_mutex_lock(&g_event_handler_lock) == 0);
651 g_sysev_thread_state = TS_EXITED;
652 (void) pthread_cond_broadcast(&g_event_handler_cond);
653 dm_assert(pthread_mutex_unlock(&g_event_handler_lock) == 0);
654
655 log_msg(MM_HPMGR, "FMD sysevent handler thread exiting...");
656 }
657
658 static sysevent_event_t *
new_sysevent_event(sysevent_t * ev)659 new_sysevent_event(sysevent_t *ev)
660 {
661 /*
662 * Cannot use dmalloc for this because the thread isn't a FMD-created
663 * thread!
664 */
665 sysevent_event_t *sevevp = malloc(sizeof (sysevent_event_t));
666 sevevp->evp = ev;
667 return (sevevp);
668 }
669
670 static void
free_sysevent_event(void * p)671 free_sysevent_event(void *p)
672 {
673 /* the sysevent_event was allocated with malloc(): */
674 free(p);
675 }
676
677 static void
event_handler(sysevent_t * ev)678 event_handler(sysevent_t *ev)
679 {
680 /* The duplicated sysevent will be freed in the child thread */
681 sysevent_t *dupev = sysevent_dup(ev);
682
683 /*
684 * Add this sysevent to the work queue of our FMA thread so we can
685 * handle the sysevent and use the FMA API (e.g. for memory
686 * allocation, etc.) in the sysevent handler.
687 */
688 queue_add(g_sysev_queue, new_sysevent_event(dupev));
689 }
690
691 static void
fini_sysevents(void)692 fini_sysevents(void)
693 {
694 sysevent_unsubscribe_event(sysevent_handle, EC_ALL);
695 }
696
697 static int
init_sysevents(void)698 init_sysevents(void)
699 {
700 int rv = 0;
701 const char *devfs_subclasses[] = {
702 ESC_DEVFS_DEVI_ADD,
703 ESC_DEVFS_DEVI_REMOVE
704 };
705 const char *dr_subclasses[] = {
706 ESC_DR_AP_STATE_CHANGE,
707 ESC_DR_TARGET_STATE_CHANGE
708 };
709 const char *platform_subclasses[] = {
710 ESC_PLATFORM_SP_RESET
711 };
712
713 if ((sysevent_handle = sysevent_bind_handle(event_handler)) == NULL) {
714 rv = errno;
715 log_err("Could not initialize the hotplug manager ("
716 "sysevent_bind_handle failure");
717 }
718
719 if (sysevent_subscribe_event(sysevent_handle, EC_DEVFS,
720 devfs_subclasses,
721 sizeof (devfs_subclasses)/sizeof (devfs_subclasses[0])) != 0) {
722
723 log_err("Could not initialize the hotplug manager "
724 "sysevent_subscribe_event(event class = EC_DEVFS) "
725 "failure");
726
727 rv = -1;
728
729 } else if (sysevent_subscribe_event(sysevent_handle, EC_DR,
730 dr_subclasses,
731 sizeof (dr_subclasses)/sizeof (dr_subclasses[0])) != 0) {
732
733 log_err("Could not initialize the hotplug manager "
734 "sysevent_subscribe_event(event class = EC_DR) "
735 "failure");
736
737 /* Unsubscribe from all sysevents in the event of a failure */
738 fini_sysevents();
739
740 rv = -1;
741 } else if (sysevent_subscribe_event(sysevent_handle, EC_PLATFORM,
742 platform_subclasses,
743 sizeof (platform_subclasses)/sizeof (platform_subclasses[0]))
744 != 0) {
745
746 log_err("Could not initialize the hotplug manager "
747 "sysevent_subscribe_event(event class = EC_PLATFORM) "
748 "failure");
749
750 /* Unsubscribe from all sysevents in the event of a failure */
751 fini_sysevents();
752
753 rv = -1;
754 }
755
756
757 return (rv);
758 }
759
760 /*ARGSUSED*/
761 static void
stdfree(void * p,size_t sz)762 stdfree(void *p, size_t sz)
763 {
764 free(p);
765 }
766
767 /*
768 * Assumptions: Each disk's current state was determined and stored in
769 * its diskmon_t.
770 */
771 hotplug_mgr_init_err_t
init_hotplug_manager()772 init_hotplug_manager()
773 {
774 /* Create the queue to which we'll add sysevents */
775 g_sysev_queue = new_queue(B_TRUE, malloc, stdfree, free_sysevent_event);
776
777 /*
778 * Grab the event handler lock before spawning the thread so we can
779 * wait for the thread to transition to the running state.
780 */
781 dm_assert(pthread_mutex_lock(&g_event_handler_lock) == 0);
782
783 /* Create the sysevent handling thread */
784 g_sysev_tid = fmd_thr_create(g_fm_hdl, dm_fmd_sysevent_thread,
785 g_sysev_queue);
786
787 /* Wait for the thread's acknowledgement */
788 while (g_sysev_thread_state != TS_RUNNING)
789 (void) pthread_cond_wait(&g_event_handler_cond,
790 &g_event_handler_lock);
791 dm_assert(pthread_mutex_unlock(&g_event_handler_lock) == 0);
792
793 if (init_sysevents() != 0) {
794 log_warn_e("Error initializing sysevents");
795 return (HPM_ERR_SYSEVENT_INIT);
796 }
797
798 return (0);
799 }
800
801 void
cleanup_hotplug_manager()802 cleanup_hotplug_manager()
803 {
804 /* Unsubscribe from the sysevents */
805 fini_sysevents();
806
807 /*
808 * Wait for the thread to exit before we can destroy
809 * the event queue.
810 */
811 dm_assert(pthread_mutex_lock(&g_event_handler_lock) == 0);
812 g_sysev_thread_state = TS_EXIT_REQUESTED;
813 queue_add(g_sysev_queue, NULL);
814 while (g_sysev_thread_state != TS_EXITED)
815 (void) pthread_cond_wait(&g_event_handler_cond,
816 &g_event_handler_lock);
817 dm_assert(pthread_mutex_unlock(&g_event_handler_lock) == 0);
818 (void) pthread_join(g_sysev_tid, NULL);
819 fmd_thr_destroy(g_fm_hdl, g_sysev_tid);
820
821 /* Finally, destroy the event queue and reset the thread state */
822 queue_free(&g_sysev_queue);
823 g_sysev_thread_state = TS_NOT_RUNNING;
824 }
825