xref: /titanic_51/usr/src/lib/libsysevent/libsysevent.c (revision 58dbc5075c2263a035b497f4bb080ab9bfb6aab4)
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 <stdio.h>
28 #include <fcntl.h>
29 #include <errno.h>
30 #include <door.h>
31 #include <unistd.h>
32 #include <stddef.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <strings.h>
36 #include <synch.h>
37 #include <pthread.h>
38 #include <thread.h>
39 #include <libnvpair.h>
40 #include <assert.h>
41 #include <sys/stat.h>
42 #include <sys/types.h>
43 #include <sys/modctl.h>
44 #include <sys/mnttab.h>
45 #include <sys/sysevent.h>
46 #include <sys/sysevent_impl.h>
47 
48 #include "libsysevent.h"
49 #include "libsysevent_impl.h"
50 
51 /*
52  * libsysevent - The system event framework library
53  *
54  *		This library provides routines to help with marshalling
55  *		and unmarshalling of data contained in a sysevent event
56  *		buffer.
57  */
58 
59 #define	SE_ENCODE_METHOD	NV_ENCODE_NATIVE
60 
61 #define	dprint	if (libsysevent_debug) (void) printf
62 static int libsysevent_debug = 0;
63 
64 static sysevent_t *se_unpack(sysevent_t *);
65 static int cleanup_id(sysevent_handle_t *shp, uint32_t id, int type);
66 
67 /*
68  * The following routines allow system event publication to the sysevent
69  * framework.
70  */
71 
72 /*
73  * sysevent_alloc - allocate a sysevent buffer
74  */
75 static sysevent_t *
76 sysevent_alloc(char *class, int class_sz, char *subclass, int subclass_sz,
77 	char *pub, int pub_sz, nvlist_t *attr_list)
78 {
79 	int payload_sz;
80 	int aligned_class_sz, aligned_subclass_sz, aligned_pub_sz;
81 	size_t nvlist_sz = 0;
82 	char *attr;
83 	uint64_t attr_offset;
84 	sysevent_t *ev;
85 
86 	if (attr_list != NULL) {
87 		if (nvlist_size(attr_list, &nvlist_sz, SE_ENCODE_METHOD)
88 		    != 0) {
89 			return (NULL);
90 		}
91 	}
92 
93 	/*
94 	 * Calculate and reserve space for the class, subclass and
95 	 * publisher strings in the event buffer
96 	 */
97 
98 	/* String sizes must be 64-bit aligned in the event buffer */
99 	aligned_class_sz = SE_ALIGN(class_sz);
100 	aligned_subclass_sz = SE_ALIGN(subclass_sz);
101 	aligned_pub_sz = SE_ALIGN(pub_sz);
102 
103 	payload_sz = (aligned_class_sz - sizeof (uint64_t)) +
104 	    (aligned_subclass_sz - sizeof (uint64_t)) +
105 	    (aligned_pub_sz - sizeof (uint64_t)) - sizeof (uint64_t) +
106 	    nvlist_sz;
107 
108 	/*
109 	 * Allocate event buffer plus additional payload overhead.
110 	 */
111 	ev = calloc(1, sizeof (sysevent_impl_t) + payload_sz);
112 	if (ev == NULL) {
113 		return (NULL);
114 	}
115 
116 	/* Initialize the event buffer data */
117 	SE_VERSION(ev) = SYS_EVENT_VERSION;
118 	(void) bcopy(class, SE_CLASS_NAME(ev), class_sz);
119 
120 	SE_SUBCLASS_OFF(ev) = SE_ALIGN(offsetof(sysevent_impl_t, se_class_name))
121 		+ aligned_class_sz;
122 	(void) bcopy(subclass, SE_SUBCLASS_NAME(ev), subclass_sz);
123 
124 	SE_PUB_OFF(ev) = SE_SUBCLASS_OFF(ev) + aligned_subclass_sz;
125 	(void) bcopy(pub, SE_PUB_NAME(ev), pub_sz);
126 
127 	SE_PAYLOAD_SZ(ev) = payload_sz;
128 	SE_ATTR_PTR(ev) = (uint64_t)0;
129 
130 	/* Check for attribute list */
131 	if (attr_list == NULL) {
132 		return (ev);
133 	}
134 
135 	/* Copy attribute data to contiguous memory */
136 	SE_FLAG(ev) = SE_PACKED_BUF;
137 	attr_offset = SE_ATTR_OFF(ev);
138 	attr = (char *)((caddr_t)ev + attr_offset);
139 	if (nvlist_pack(attr_list, &attr, &nvlist_sz, SE_ENCODE_METHOD,
140 	    0) != 0) {
141 		free(ev);
142 		return (NULL);
143 	}
144 
145 	return (ev);
146 }
147 
148 /*
149  * sysevent_post_event - generate a system event via the sysevent framework
150  */
151 int
152 sysevent_post_event(char *class, char *subclass, char *vendor, char *pub_name,
153 	nvlist_t *attr_list, sysevent_id_t *eid)
154 {
155 	int error;
156 	sysevent_t *ev;
157 
158 	ev = sysevent_alloc_event(class, subclass, vendor, pub_name, attr_list);
159 	if (ev == NULL) {
160 		return (-1);
161 	}
162 
163 	error = modctl(MODEVENTS, (uintptr_t)MODEVENTS_POST_EVENT,
164 	    (uintptr_t)ev, (uintptr_t)SE_SIZE(ev), (uintptr_t)eid, 0);
165 
166 	sysevent_free(ev);
167 
168 	if (error) {
169 		errno = EIO;
170 		return (-1);
171 	}
172 
173 	return (0);
174 }
175 
176 /*
177  * The following routines are used to free or duplicate a
178  * sysevent event buffer.
179  */
180 
181 /*
182  * sysevent_dup - Allocate and copy an event buffer
183  *	Copies both packed and unpacked to unpacked sysevent.
184  */
185 sysevent_t *
186 sysevent_dup(sysevent_t *ev)
187 {
188 	nvlist_t *nvl, *cnvl = NULL;
189 	uint64_t attr_offset;
190 	sysevent_t *copy;
191 
192 	if (SE_FLAG(ev) == SE_PACKED_BUF)
193 		return (se_unpack(ev));
194 
195 	/* Copy event header information */
196 	attr_offset = SE_ATTR_OFF(ev);
197 	copy = calloc(1, attr_offset);
198 	if (copy == NULL)
199 		return (NULL);
200 	bcopy(ev, copy, attr_offset);
201 
202 	nvl = (nvlist_t *)(uintptr_t)SE_ATTR_PTR(ev);
203 	if (nvl && nvlist_dup(nvl, &cnvl, 0) != 0) {
204 		free(copy);
205 		return (NULL);
206 	}
207 
208 	SE_ATTR_PTR(copy) = (uintptr_t)cnvl;
209 	SE_FLAG(copy) = 0;	/* unpacked */
210 	return (copy);
211 }
212 
213 /*
214  * sysevent_free - Free memory allocated for an event buffer
215  */
216 void
217 sysevent_free(sysevent_t *ev)
218 {
219 	nvlist_t *attr_list = (nvlist_t *)(uintptr_t)SE_ATTR_PTR(ev);
220 
221 	if (attr_list)
222 		nvlist_free(attr_list);
223 	free(ev);
224 }
225 
226 /*
227  * The following routines are used to extract attribute data from a sysevent
228  * handle.
229  */
230 
231 /*
232  * sysevent_get_attr_list - allocate and return an attribute associated with
233  *			the given sysevent buffer.
234  */
235 int
236 sysevent_get_attr_list(sysevent_t *ev, nvlist_t **nvlist)
237 {
238 	int error;
239 	caddr_t attr;
240 	size_t attr_len;
241 	uint64_t attr_offset;
242 	nvlist_t *nvl;
243 
244 	*nvlist = NULL;
245 
246 	/* Duplicate attribute for an unpacked sysevent buffer */
247 	if (SE_FLAG(ev) != SE_PACKED_BUF) {
248 		nvl = (nvlist_t *)(uintptr_t)SE_ATTR_PTR(ev);
249 		if (nvl == NULL) {
250 			return (0);
251 		}
252 		if ((error = nvlist_dup(nvl, nvlist, 0)) != 0) {
253 			if (error == ENOMEM) {
254 				errno = error;
255 			} else {
256 				errno = EINVAL;
257 			}
258 			return (-1);
259 		}
260 		return (0);
261 	}
262 
263 	attr_offset = SE_ATTR_OFF(ev);
264 	if (SE_SIZE(ev) == attr_offset) {
265 		return (0);
266 	}
267 
268 	/* unpack nvlist */
269 	attr = (caddr_t)ev + attr_offset;
270 	attr_len = SE_SIZE(ev) - attr_offset;
271 	if ((error = nvlist_unpack(attr, attr_len, nvlist, 0)) != 0) {
272 		if (error == ENOMEM) {
273 			errno = error;
274 		} else 	{
275 			errno = EINVAL;
276 		}
277 		return (-1);
278 	}
279 
280 	return (0);
281 }
282 
283 /*
284  * sysevent_attr_name - Get name of attribute
285  */
286 char *
287 sysevent_attr_name(sysevent_attr_t *attr)
288 {
289 	if (attr == NULL) {
290 		errno = EINVAL;
291 		return (NULL);
292 	}
293 	return (nvpair_name((nvpair_t *)attr));
294 }
295 
296 /*
297  * sysevent_attr_value - Get attribute value data and type
298  */
299 int
300 sysevent_attr_value(sysevent_attr_t *attr, sysevent_value_t *se_value)
301 {
302 	nvpair_t *nvp = attr;
303 
304 	if (nvp == NULL)
305 		return (EINVAL);
306 
307 	/* Convert DATA_TYPE_* to SE_DATA_TYPE_* */
308 	switch (nvpair_type(nvp)) {
309 	case DATA_TYPE_BYTE:
310 		se_value->value_type = SE_DATA_TYPE_BYTE;
311 		(void) nvpair_value_byte(nvp, &se_value->value.sv_byte);
312 		break;
313 	case DATA_TYPE_INT16:
314 		se_value->value_type = SE_DATA_TYPE_INT16;
315 		(void) nvpair_value_int16(nvp, &se_value->value.sv_int16);
316 		break;
317 	case DATA_TYPE_UINT16:
318 		se_value->value_type = SE_DATA_TYPE_UINT16;
319 		(void) nvpair_value_uint16(nvp, &se_value->value.sv_uint16);
320 		break;
321 	case DATA_TYPE_INT32:
322 		se_value->value_type = SE_DATA_TYPE_INT32;
323 		(void) nvpair_value_int32(nvp, &se_value->value.sv_int32);
324 		break;
325 	case DATA_TYPE_UINT32:
326 		se_value->value_type = SE_DATA_TYPE_UINT32;
327 		(void) nvpair_value_uint32(nvp, &se_value->value.sv_uint32);
328 		break;
329 	case DATA_TYPE_INT64:
330 		se_value->value_type = SE_DATA_TYPE_INT64;
331 		(void) nvpair_value_int64(nvp, &se_value->value.sv_int64);
332 		break;
333 	case DATA_TYPE_UINT64:
334 		se_value->value_type = SE_DATA_TYPE_UINT64;
335 		(void) nvpair_value_uint64(nvp, &se_value->value.sv_uint64);
336 		break;
337 	case DATA_TYPE_STRING:
338 		se_value->value_type = SE_DATA_TYPE_STRING;
339 		(void) nvpair_value_string(nvp, &se_value->value.sv_string);
340 		break;
341 	case DATA_TYPE_BYTE_ARRAY:
342 		se_value->value_type = SE_DATA_TYPE_BYTES;
343 		(void) nvpair_value_byte_array(nvp,
344 		    &se_value->value.sv_bytes.data,
345 		    (uint_t *)&se_value->value.sv_bytes.size);
346 		break;
347 	case DATA_TYPE_HRTIME:
348 		se_value->value_type = SE_DATA_TYPE_TIME;
349 		(void) nvpair_value_hrtime(nvp, &se_value->value.sv_time);
350 		break;
351 	default:
352 		return (ENOTSUP);
353 	}
354 	return (0);
355 }
356 
357 /*
358  * sysevent_attr_next - Get next attribute in event attribute list
359  */
360 sysevent_attr_t *
361 sysevent_attr_next(sysevent_t *ev, sysevent_attr_t *attr)
362 {
363 	nvlist_t *nvl;
364 	nvpair_t *nvp = attr;
365 
366 	/* all user visible sysevent_t's are unpacked */
367 	assert(SE_FLAG(ev) != SE_PACKED_BUF);
368 
369 	if (SE_ATTR_PTR(ev) == (uint64_t)0) {
370 		return (NULL);
371 	}
372 
373 	nvl = (nvlist_t *)(uintptr_t)SE_ATTR_PTR(ev);
374 	return (nvlist_next_nvpair(nvl, nvp));
375 }
376 
377 /*
378  * sysevent_lookup_attr - Lookup attribute by name and datatype.
379  */
380 int
381 sysevent_lookup_attr(sysevent_t *ev, char *name, int datatype,
382 	sysevent_value_t *se_value)
383 {
384 	nvpair_t *nvp;
385 	nvlist_t *nvl;
386 
387 	assert(SE_FLAG(ev) != SE_PACKED_BUF);
388 
389 	if (SE_ATTR_PTR(ev) == (uint64_t)0) {
390 		return (ENOENT);
391 	}
392 
393 	/*
394 	 * sysevent matches on both name and datatype
395 	 * nvlist_look mataches name only. So we walk
396 	 * nvlist manually here.
397 	 */
398 	nvl = (nvlist_t *)(uintptr_t)SE_ATTR_PTR(ev);
399 	nvp = nvlist_next_nvpair(nvl, NULL);
400 	while (nvp) {
401 		if ((strcmp(name, nvpair_name(nvp)) == 0) &&
402 		    (sysevent_attr_value(nvp, se_value) == 0) &&
403 		    (se_value->value_type == datatype))
404 			return (0);
405 		nvp = nvlist_next_nvpair(nvl, nvp);
406 	}
407 	return (ENOENT);
408 }
409 
410 /* Routines to extract event header information */
411 
412 /*
413  * sysevent_get_class - Get class id
414  */
415 int
416 sysevent_get_class(sysevent_t *ev)
417 {
418 	return (SE_CLASS(ev));
419 }
420 
421 /*
422  * sysevent_get_subclass - Get subclass id
423  */
424 int
425 sysevent_get_subclass(sysevent_t *ev)
426 {
427 	return (SE_SUBCLASS(ev));
428 }
429 
430 /*
431  * sysevent_get_class_name - Get class name string
432  */
433 char *
434 sysevent_get_class_name(sysevent_t *ev)
435 {
436 	return (SE_CLASS_NAME(ev));
437 }
438 
439 typedef enum {
440 	PUB_VEND,
441 	PUB_KEYWD,
442 	PUB_NAME,
443 	PUB_PID
444 } se_pub_id_t;
445 
446 /*
447  * sysevent_get_pub - Get publisher name string
448  */
449 char *
450 sysevent_get_pub(sysevent_t *ev)
451 {
452 	return (SE_PUB_NAME(ev));
453 }
454 
455 /*
456  * Get the requested string pointed by the token.
457  *
458  * Return NULL if not found or for insufficient memory.
459  */
460 static char *
461 parse_pub_id(sysevent_t *ev, se_pub_id_t token)
462 {
463 	int i;
464 	char *pub_id, *pub_element, *str, *next;
465 
466 	next = pub_id = strdup(sysevent_get_pub(ev));
467 	for (i = 0; i <= token; ++i) {
468 		str = strtok_r(next, ":", &next);
469 		if (str == NULL) {
470 			free(pub_id);
471 			return (NULL);
472 		}
473 	}
474 
475 	pub_element = strdup(str);
476 	free(pub_id);
477 	return (pub_element);
478 }
479 
480 /*
481  * Return a pointer to the string following the token
482  *
483  * Note: This is a dedicated function for parsing
484  * publisher strings and not for general purpose.
485  */
486 static const char *
487 pub_idx(const char *pstr, int token)
488 {
489 	int i;
490 
491 	for (i = 1; i <= token; i++) {
492 		if ((pstr = index(pstr, ':')) == NULL)
493 			return (NULL);
494 		pstr++;
495 	}
496 
497 	/* String might be empty */
498 	if (pstr) {
499 		if (*pstr == '\0' || *pstr == ':')
500 			return (NULL);
501 	}
502 	return (pstr);
503 }
504 
505 char *
506 sysevent_get_vendor_name(sysevent_t *ev)
507 {
508 	return (parse_pub_id(ev, PUB_VEND));
509 }
510 
511 char *
512 sysevent_get_pub_name(sysevent_t *ev)
513 {
514 	return (parse_pub_id(ev, PUB_NAME));
515 }
516 
517 /*
518  * Provide the pid encoded in the publisher string
519  * w/o allocating any resouces.
520  */
521 void
522 sysevent_get_pid(sysevent_t *ev, pid_t *pid)
523 {
524 	const char *part_str;
525 	const char *pub_str = sysevent_get_pub(ev);
526 
527 	*pid = (pid_t)SE_KERN_PID;
528 
529 	part_str = pub_idx(pub_str, PUB_KEYWD);
530 	if (part_str != NULL && strstr(part_str, SE_KERN_PUB) != NULL)
531 		return;
532 
533 	if ((part_str = pub_idx(pub_str, PUB_PID)) == NULL)
534 		return;
535 
536 	*pid = (pid_t)atoi(part_str);
537 }
538 
539 /*
540  * sysevent_get_subclass_name - Get subclass name string
541  */
542 char *
543 sysevent_get_subclass_name(sysevent_t *ev)
544 {
545 	return (SE_SUBCLASS_NAME(ev));
546 }
547 
548 /*
549  * sysevent_get_seq - Get event sequence id
550  */
551 uint64_t
552 sysevent_get_seq(sysevent_t *ev)
553 {
554 	return (SE_SEQ(ev));
555 }
556 
557 /*
558  * sysevent_get_time - Get event timestamp
559  */
560 void
561 sysevent_get_time(sysevent_t *ev, hrtime_t *etime)
562 {
563 	*etime = SE_TIME(ev);
564 }
565 
566 /*
567  * sysevent_get_size - Get event buffer size
568  */
569 size_t
570 sysevent_get_size(sysevent_t *ev)
571 {
572 	return ((size_t)SE_SIZE(ev));
573 }
574 
575 /*
576  * The following routines are used by devfsadm_mod.c to propagate event
577  * buffers to devfsadmd.  These routines will serve as the basis for
578  * event channel publication and subscription.
579  */
580 
581 /*
582  * sysevent_alloc_event -
583  *	allocate a sysevent buffer for sending through an established event
584  *	channel.
585  */
586 sysevent_t *
587 sysevent_alloc_event(char *class, char *subclass, char *vendor, char *pub_name,
588 	nvlist_t *attr_list)
589 {
590 	int class_sz, subclass_sz, pub_sz;
591 	char *pub_id;
592 	sysevent_t *ev;
593 
594 	if ((class == NULL) || (subclass == NULL) || (vendor == NULL) ||
595 	    (pub_name == NULL)) {
596 		errno = EINVAL;
597 		return (NULL);
598 	}
599 
600 	class_sz = strlen(class) + 1;
601 	subclass_sz = strlen(subclass) + 1;
602 	if ((class_sz > MAX_CLASS_LEN) ||
603 	    (subclass_sz > MAX_SUBCLASS_LEN)) {
604 		errno = EINVAL;
605 		return (NULL);
606 	}
607 
608 	/*
609 	 * Calculate the publisher size plus string seperators and maximum
610 	 * pid characters
611 	 */
612 	pub_sz = strlen(vendor) + sizeof (SE_USR_PUB) + strlen(pub_name) + 14;
613 	if (pub_sz > MAX_PUB_LEN) {
614 		errno = EINVAL;
615 		return (NULL);
616 	}
617 	pub_id = malloc(pub_sz);
618 	if (pub_id == NULL) {
619 		errno = ENOMEM;
620 		return (NULL);
621 	}
622 	if (snprintf(pub_id, pub_sz, "%s:%s%s:%d", vendor, SE_USR_PUB,
623 	    pub_name, (int)getpid()) >= pub_sz) {
624 		free(pub_id);
625 		errno = EINVAL;
626 		return (NULL);
627 	}
628 	pub_sz = strlen(pub_id) + 1;
629 
630 	ev = sysevent_alloc(class, class_sz, subclass, subclass_sz,
631 	    pub_id, pub_sz, attr_list);
632 	free(pub_id);
633 	if (ev == NULL) {
634 		errno = ENOMEM;
635 		return (NULL);
636 	}
637 
638 	return (ev);
639 }
640 
641 /*
642  * se_unpack - unpack nvlist to a searchable list.
643  *	If already unpacked, will do a dup.
644  */
645 static sysevent_t *
646 se_unpack(sysevent_t *ev)
647 {
648 	caddr_t attr;
649 	size_t attr_len;
650 	nvlist_t *attrp = NULL;
651 	uint64_t attr_offset;
652 	sysevent_t *copy;
653 
654 	assert(SE_FLAG(ev) == SE_PACKED_BUF);
655 
656 	/* Copy event header information */
657 	attr_offset = SE_ATTR_OFF(ev);
658 	copy = calloc(1, attr_offset);
659 	if (copy == NULL)
660 		return (NULL);
661 	bcopy(ev, copy, attr_offset);
662 	SE_FLAG(copy) = 0;	/* unpacked */
663 
664 	/* unpack nvlist */
665 	attr = (caddr_t)ev + attr_offset;
666 	attr_len = SE_SIZE(ev) - attr_offset;
667 	if (attr_len == 0) {
668 		return (copy);
669 	}
670 	if (nvlist_unpack(attr, attr_len, &attrp, 0) != 0) {
671 		free(copy);
672 		return (NULL);
673 	}
674 
675 	SE_ATTR_PTR(copy) = (uintptr_t)attrp;
676 	return (copy);
677 }
678 
679 /*
680  * se_print - Prints elements in an event buffer
681  */
682 void
683 se_print(FILE *fp, sysevent_t *ev)
684 {
685 	char *vendor, *pub;
686 	pid_t pid;
687 	hrtime_t hrt;
688 	nvlist_t *attr_list = NULL;
689 
690 	(void) sysevent_get_time(ev, &hrt);
691 	(void) fprintf(fp, "received sysevent id = 0X%llx:%llx\n",
692 	    hrt, (longlong_t)sysevent_get_seq(ev));
693 	(void) fprintf(fp, "\tclass = %s\n", sysevent_get_class_name(ev));
694 	(void) fprintf(fp, "\tsubclass = %s\n", sysevent_get_subclass_name(ev));
695 	if ((vendor =  sysevent_get_vendor_name(ev)) != NULL) {
696 		(void) fprintf(fp, "\tvendor = %s\n", vendor);
697 		free(vendor);
698 	}
699 	if ((pub = sysevent_get_pub_name(ev)) != NULL) {
700 		sysevent_get_pid(ev, &pid);
701 		(void) fprintf(fp, "\tpublisher = %s:%d\n", pub, (int)pid);
702 		free(pub);
703 	}
704 
705 	if (sysevent_get_attr_list(ev, &attr_list) == 0 && attr_list != NULL) {
706 		nvlist_print(fp, attr_list);
707 		nvlist_free(attr_list);
708 	}
709 }
710 
711 /*
712  * The following routines are provided to support establishment and use
713  * of sysevent channels.  A sysevent channel is established between
714  * publishers and subscribers of sysevents for an agreed upon channel name.
715  * These routines currently support sysevent channels between user-level
716  * applications running on the same system.
717  *
718  * Sysevent channels may be created by a single publisher or subscriber process.
719  * Once established, up to MAX_SUBSRCIBERS subscribers may subscribe interest in
720  * receiving sysevent notifications on the named channel.  At present, only
721  * one publisher is allowed per sysevent channel.
722  *
723  * The registration information for each channel is kept in the kernel.  A
724  * kernel-based registration was chosen for persistence and reliability reasons.
725  * If either a publisher or a subscriber exits for any reason, the channel
726  * properties are maintained until all publishers and subscribers have exited.
727  * Additionally, an in-kernel registration allows the API to be extended to
728  * include kernel subscribers as well as userland subscribers in the future.
729  *
730  * To insure fast lookup of subscriptions, a cached copy of the registration
731  * is kept and maintained for the publisher process.  Updates are made
732  * everytime a change is made in the kernel.  Changes to the registration are
733  * expected to be infrequent.
734  *
735  * Channel communication between publisher and subscriber processes is
736  * implemented primarily via doors.  Each publisher creates a door for
737  * registration notifications and each subscriber creates a door for event
738  * delivery.
739  *
740  * Most of these routines are used by syseventd(1M), the sysevent publisher
741  * for the syseventd channel.  Processes wishing to receive sysevent
742  * notifications from syseventd may use a set of public
743  * APIs designed to subscribe to syseventd sysevents.  The subscription
744  * APIs are implemented in accordance with PSARC/2001/076.
745  *
746  */
747 
748 /*
749  * Door handlers for the channel subscribers
750  */
751 
752 /*
753  * subscriber_event_handler - generic event handling wrapper for subscribers
754  *			This handler is used to process incoming sysevent
755  *			notifications from channel publishers.
756  *			It is created as a seperate thread in each subscriber
757  *			process per subscription.
758  */
759 static void
760 subscriber_event_handler(sysevent_handle_t *shp)
761 {
762 	subscriber_priv_t *sub_info;
763 	sysevent_queue_t *evqp;
764 
765 	sub_info = (subscriber_priv_t *)SH_PRIV_DATA(shp);
766 
767 	(void) mutex_lock(&sub_info->sp_qlock);
768 	for (;;) {
769 		while (sub_info->sp_evq_head == NULL && SH_BOUND(shp)) {
770 			(void) cond_wait(&sub_info->sp_cv, &sub_info->sp_qlock);
771 		}
772 		evqp = sub_info->sp_evq_head;
773 		while (evqp) {
774 			(void) mutex_unlock(&sub_info->sp_qlock);
775 			(void) sub_info->sp_func(evqp->sq_ev);
776 			(void) mutex_lock(&sub_info->sp_qlock);
777 			sub_info->sp_evq_head = sub_info->sp_evq_head->sq_next;
778 			free(evqp->sq_ev);
779 			free(evqp);
780 			evqp = sub_info->sp_evq_head;
781 		}
782 		if (!SH_BOUND(shp)) {
783 			(void) mutex_unlock(&sub_info->sp_qlock);
784 			return;
785 		}
786 	}
787 
788 	/* NOTREACHED */
789 }
790 
791 /*
792  * Data structure used to communicate event subscription cache updates
793  * to publishers via a registration door
794  */
795 struct reg_args {
796 	uint32_t ra_sub_id;
797 	uint32_t ra_op;
798 	uint64_t ra_buf_ptr;
799 };
800 
801 
802 /*
803  * event_deliver_service - generic event delivery service routine.  This routine
804  *		is called in response to a door call to post an event.
805  *
806  */
807 /*ARGSUSED*/
808 static void
809 event_deliver_service(void *cookie, char *args, size_t alen,
810     door_desc_t *ddp, uint_t ndid)
811 {
812 	int	ret = 0;
813 	subscriber_priv_t *sub_info;
814 	sysevent_handle_t *shp;
815 	sysevent_queue_t *new_eq;
816 
817 	if (args == NULL || alen < sizeof (uint32_t)) {
818 		ret = EINVAL;
819 		goto return_from_door;
820 	}
821 
822 	/* Publisher checking on subscriber */
823 	if (alen == sizeof (uint32_t)) {
824 		ret = 0;
825 		goto return_from_door;
826 	}
827 
828 	shp = (sysevent_handle_t *)cookie;
829 	if (shp == NULL) {
830 		ret = EBADF;
831 		goto return_from_door;
832 	}
833 
834 	/*
835 	 * Mustn't block if we are trying to update the registration with
836 	 * the publisher
837 	 */
838 	if (mutex_trylock(SH_LOCK(shp)) != 0) {
839 		ret = EAGAIN;
840 		goto return_from_door;
841 	}
842 
843 	if (!SH_BOUND(shp)) {
844 		ret = EBADF;
845 		(void) mutex_unlock(SH_LOCK(shp));
846 		goto return_from_door;
847 	}
848 
849 	sub_info = (subscriber_priv_t *)SH_PRIV_DATA(shp);
850 	if (sub_info == NULL) {
851 		ret = EBADF;
852 		(void) mutex_unlock(SH_LOCK(shp));
853 		goto return_from_door;
854 	}
855 
856 	new_eq = (sysevent_queue_t *)calloc(1,
857 	    sizeof (sysevent_queue_t));
858 	if (new_eq == NULL) {
859 		ret = EAGAIN;
860 		(void) mutex_unlock(SH_LOCK(shp));
861 		goto return_from_door;
862 	}
863 
864 	/*
865 	 * Allocate and copy the event buffer into the subscriber's
866 	 * address space
867 	 */
868 	new_eq->sq_ev = calloc(1, alen);
869 	if (new_eq->sq_ev == NULL) {
870 		free(new_eq);
871 		ret = EAGAIN;
872 		(void) mutex_unlock(SH_LOCK(shp));
873 		goto return_from_door;
874 	}
875 	(void) bcopy(args, new_eq->sq_ev, alen);
876 
877 	(void) mutex_lock(&sub_info->sp_qlock);
878 	if (sub_info->sp_evq_head == NULL) {
879 		sub_info->sp_evq_head = new_eq;
880 	} else {
881 		sub_info->sp_evq_tail->sq_next = new_eq;
882 	}
883 	sub_info->sp_evq_tail = new_eq;
884 
885 	(void) cond_signal(&sub_info->sp_cv);
886 	(void) mutex_unlock(&sub_info->sp_qlock);
887 	(void) mutex_unlock(SH_LOCK(shp));
888 
889 return_from_door:
890 	(void) door_return((void *)&ret, sizeof (ret), NULL, 0);
891 	(void) door_return(NULL, 0, NULL, 0);
892 }
893 
894 /*
895  * Sysevent subscription information is maintained in the kernel.  Updates
896  * to the in-kernel registration database is expected to be infrequent and
897  * offers consistency for publishers and subscribers that may come and go
898  * for a given channel.
899  *
900  * To expedite registration lookups by publishers, a cached copy of the
901  * kernel registration database is kept per-channel.  Caches are invalidated
902  * and refreshed upon state changes to the in-kernel registration database.
903  *
904  * To prevent stale subscriber data, publishers may remove subsriber
905  * registrations from the in-kernel registration database in the event
906  * that a particular subscribing process is unresponsive.
907  *
908  * The following routines provide a mechanism to update publisher and subscriber
909  * information for a specified channel.
910  */
911 
912 /*
913  * clnt_deliver_event - Deliver an event through the consumer's event
914  *			delivery door
915  *
916  * Returns -1 if message not delivered. With errno set to cause of error.
917  * Returns 0 for success with the results returned in posting buffer.
918  */
919 static int
920 clnt_deliver_event(int service_door, void *data, size_t datalen,
921 	void *result, size_t rlen)
922 {
923 	int error = 0;
924 	door_arg_t door_arg;
925 
926 	door_arg.rbuf = result;
927 	door_arg.rsize = rlen;
928 	door_arg.data_ptr = data;
929 	door_arg.data_size = datalen;
930 	door_arg.desc_ptr = NULL;
931 	door_arg.desc_num = 0;
932 
933 	/*
934 	 * Make door call
935 	 */
936 	while ((error = door_call(service_door, &door_arg)) != 0) {
937 		if (errno == EAGAIN || errno == EINTR) {
938 			continue;
939 		} else {
940 			error = errno;
941 			break;
942 		}
943 	}
944 
945 	return (error);
946 }
947 
948 static int
949 update_publisher_cache(subscriber_priv_t *sub_info, int update_op,
950 	uint32_t sub_id, size_t datasz, uchar_t *data)
951 {
952 	int pub_fd;
953 	uint32_t result = 0;
954 	struct reg_args *rargs;
955 
956 	rargs = (struct reg_args *)calloc(1, sizeof (struct reg_args) +
957 	    datasz);
958 	if (rargs == NULL) {
959 		errno = ENOMEM;
960 		return (-1);
961 	}
962 
963 	rargs->ra_sub_id = sub_id;
964 	rargs->ra_op = update_op;
965 	bcopy(data, (char *)&rargs->ra_buf_ptr, datasz);
966 
967 	pub_fd = open(sub_info->sp_door_name, O_RDONLY);
968 	(void) clnt_deliver_event(pub_fd, (void *)rargs,
969 	    sizeof (struct reg_args) + datasz, &result, sizeof (result));
970 	(void) close(pub_fd);
971 
972 	free(rargs);
973 	if (result != 0) {
974 		errno = result;
975 		return (-1);
976 	}
977 
978 	return (0);
979 }
980 
981 
982 /*
983  * update_kernel_registration - update the in-kernel registration for the
984  * given channel.
985  */
986 static int
987 update_kernel_registration(sysevent_handle_t *shp, int update_type,
988 	int update_op, uint32_t *sub_id, size_t datasz, uchar_t *data)
989 {
990 	int error;
991 	char *channel_name = SH_CHANNEL_NAME(shp);
992 	se_pubsub_t udata;
993 
994 	udata.ps_channel_name_len = strlen(channel_name) + 1;
995 	udata.ps_op = update_op;
996 	udata.ps_type = update_type;
997 	udata.ps_buflen = datasz;
998 	udata.ps_id = *sub_id;
999 
1000 	if ((error = modctl(MODEVENTS, (uintptr_t)MODEVENTS_REGISTER_EVENT,
1001 	    (uintptr_t)channel_name, (uintptr_t)data, (uintptr_t)&udata, 0))
1002 	    != 0) {
1003 		return (error);
1004 	}
1005 
1006 	*sub_id = udata.ps_id;
1007 
1008 	return (error);
1009 }
1010 
1011 /*
1012  * get_kernel_registration - get the current subscriber registration for
1013  * the given channel
1014  */
1015 static nvlist_t *
1016 get_kernel_registration(char *channel_name, uint32_t class_id)
1017 {
1018 	char *nvlbuf;
1019 	nvlist_t *nvl;
1020 	se_pubsub_t udata;
1021 
1022 	nvlbuf = calloc(1, MAX_SUBSCRIPTION_SZ);
1023 	if (nvlbuf == NULL) {
1024 		return (NULL);
1025 	}
1026 
1027 	udata.ps_buflen = MAX_SUBSCRIPTION_SZ;
1028 	udata.ps_channel_name_len = strlen(channel_name) + 1;
1029 	udata.ps_id = class_id;
1030 	udata.ps_op = SE_GET_REGISTRATION;
1031 	udata.ps_type = PUBLISHER;
1032 
1033 	if (modctl(MODEVENTS, (uintptr_t)MODEVENTS_REGISTER_EVENT,
1034 	    (uintptr_t)channel_name, (uintptr_t)nvlbuf, (uintptr_t)&udata, 0)
1035 	    != 0) {
1036 
1037 		/* Need a bigger buffer to hold channel registration */
1038 		if (errno == EAGAIN) {
1039 			free(nvlbuf);
1040 			nvlbuf = calloc(1, udata.ps_buflen);
1041 			if (nvlbuf == NULL)
1042 				return (NULL);
1043 
1044 			/* Try again */
1045 			if (modctl(MODEVENTS,
1046 			    (uintptr_t)MODEVENTS_REGISTER_EVENT,
1047 			    (uintptr_t)channel_name, (uintptr_t)nvlbuf,
1048 			    (uintptr_t)&udata, 0) != 0) {
1049 				free(nvlbuf);
1050 				return (NULL);
1051 			}
1052 		} else {
1053 			free(nvlbuf);
1054 			return (NULL);
1055 		}
1056 	}
1057 
1058 	if (nvlist_unpack(nvlbuf, udata.ps_buflen, &nvl, 0) != 0) {
1059 		free(nvlbuf);
1060 		return (NULL);
1061 	}
1062 	free(nvlbuf);
1063 
1064 	return (nvl);
1065 }
1066 
1067 /*
1068  * The following routines provide a mechanism for publishers to maintain
1069  * subscriber information.
1070  */
1071 
1072 static void
1073 dealloc_subscribers(sysevent_handle_t *shp)
1074 {
1075 	int i;
1076 	subscriber_data_t *sub;
1077 
1078 	for (i = 1; i <= MAX_SUBSCRIBERS; ++i) {
1079 		sub = SH_SUBSCRIBER(shp, i);
1080 		if (sub != NULL) {
1081 			free(sub->sd_door_name);
1082 			free(sub);
1083 		}
1084 		SH_SUBSCRIBER(shp, i) = NULL;
1085 	}
1086 }
1087 
1088 /*ARGSUSED*/
1089 static int
1090 alloc_subscriber(sysevent_handle_t *shp, uint32_t sub_id, int oflag)
1091 {
1092 	subscriber_data_t *sub;
1093 	char door_name[MAXPATHLEN];
1094 
1095 	if (SH_SUBSCRIBER(shp, sub_id) != NULL) {
1096 		return (0);
1097 	}
1098 
1099 	/* Allocate and initialize the subscriber data */
1100 	sub = (subscriber_data_t *)calloc(1,
1101 	    sizeof (subscriber_data_t));
1102 	if (sub == NULL) {
1103 		return (-1);
1104 	}
1105 	if (snprintf(door_name, MAXPATHLEN, "%s/%d",
1106 	    SH_CHANNEL_PATH(shp), sub_id) >= MAXPATHLEN) {
1107 		free(sub);
1108 		return (-1);
1109 	}
1110 
1111 	sub->sd_flag = ACTIVE;
1112 	sub->sd_door_name = strdup(door_name);
1113 	if (sub->sd_door_name == NULL) {
1114 		free(sub);
1115 		return (-1);
1116 	}
1117 
1118 	SH_SUBSCRIBER(shp, sub_id) = sub;
1119 	return (0);
1120 
1121 }
1122 
1123 /*
1124  * The following routines are used to update and maintain the registration cache
1125  * for a particular sysevent channel.
1126  */
1127 
1128 static uint32_t
1129 hash_func(const char *s)
1130 {
1131 	uint32_t result = 0;
1132 	uint_t g;
1133 
1134 	while (*s != '\0') {
1135 		result <<= 4;
1136 		result += (uint32_t)*s++;
1137 		g = result & 0xf0000000;
1138 		if (g != 0) {
1139 			result ^= g >> 24;
1140 			result ^= g;
1141 		}
1142 	}
1143 
1144 	return (result);
1145 }
1146 
1147 subclass_lst_t *
1148 cache_find_subclass(class_lst_t *c_list, char *subclass)
1149 {
1150 	subclass_lst_t *sc_list;
1151 
1152 	if (c_list == NULL)
1153 		return (NULL);
1154 
1155 	sc_list = c_list->cl_subclass_list;
1156 
1157 	while (sc_list != NULL) {
1158 		if (strcmp(sc_list->sl_name, subclass) == 0) {
1159 			return (sc_list);
1160 		}
1161 		sc_list = sc_list->sl_next;
1162 	}
1163 
1164 	return (NULL);
1165 }
1166 
1167 
1168 static class_lst_t *
1169 cache_find_class(sysevent_handle_t *shp, char *class)
1170 {
1171 	int index;
1172 	class_lst_t *c_list;
1173 	class_lst_t **class_hash = SH_CLASS_HASH(shp);
1174 
1175 	if (strcmp(class, EC_ALL) == 0) {
1176 		return (class_hash[0]);
1177 	}
1178 
1179 	index = CLASS_HASH(class);
1180 	c_list = class_hash[index];
1181 	while (c_list != NULL) {
1182 		if (strcmp(class, c_list->cl_name) == 0) {
1183 			break;
1184 		}
1185 		c_list = c_list->cl_next;
1186 	}
1187 
1188 	return (c_list);
1189 }
1190 
1191 static int
1192 cache_insert_subclass(class_lst_t *c_list, char **subclass_names,
1193 	int subclass_num, uint32_t sub_id)
1194 {
1195 	int i;
1196 	subclass_lst_t *sc_list;
1197 
1198 	for (i = 0; i < subclass_num; ++i) {
1199 		if ((sc_list = cache_find_subclass(c_list, subclass_names[i]))
1200 		    != NULL) {
1201 			sc_list->sl_num[sub_id] = 1;
1202 		} else {
1203 			sc_list = (subclass_lst_t *)calloc(1,
1204 			    sizeof (subclass_lst_t));
1205 			if (sc_list == NULL)
1206 				return (-1);
1207 
1208 			sc_list->sl_name = strdup(subclass_names[i]);
1209 			if (sc_list->sl_name == NULL) {
1210 				free(sc_list);
1211 				return (-1);
1212 			}
1213 
1214 			sc_list->sl_num[sub_id] = 1;
1215 			sc_list->sl_next = c_list->cl_subclass_list;
1216 			c_list->cl_subclass_list = sc_list;
1217 		}
1218 	}
1219 
1220 	return (0);
1221 }
1222 
1223 static int
1224 cache_insert_class(sysevent_handle_t *shp, char *class,
1225 	char **subclass_names, int subclass_num, uint32_t sub_id)
1226 {
1227 	class_lst_t *c_list;
1228 
1229 	if (strcmp(class, EC_ALL) == 0) {
1230 		char *subclass_all = EC_SUB_ALL;
1231 
1232 		(void) cache_insert_subclass(SH_CLASS_HASH(shp)[0],
1233 		    (char **)&subclass_all, 1, sub_id);
1234 		return (0);
1235 	}
1236 
1237 	/* New class, add to the registration cache */
1238 	if ((c_list = cache_find_class(shp, class)) == NULL) {
1239 
1240 		c_list = (class_lst_t *)calloc(1, sizeof (class_lst_t));
1241 		if (c_list == NULL) {
1242 			return (1);
1243 		}
1244 		c_list->cl_name = strdup(class);
1245 		if (c_list->cl_name == NULL) {
1246 			free(c_list);
1247 			return (1);
1248 		}
1249 
1250 		c_list->cl_subclass_list = (subclass_lst_t *)
1251 		    calloc(1, sizeof (subclass_lst_t));
1252 		if (c_list->cl_subclass_list == NULL) {
1253 			free(c_list->cl_name);
1254 			free(c_list);
1255 			return (1);
1256 		}
1257 		c_list->cl_subclass_list->sl_name = strdup(EC_SUB_ALL);
1258 		if (c_list->cl_subclass_list->sl_name == NULL) {
1259 			free(c_list->cl_subclass_list);
1260 			free(c_list->cl_name);
1261 			free(c_list);
1262 			return (1);
1263 		}
1264 		c_list->cl_next = SH_CLASS_HASH(shp)[CLASS_HASH(class)];
1265 		SH_CLASS_HASH(shp)[CLASS_HASH(class)] = c_list;
1266 
1267 	}
1268 
1269 	/* Update the subclass list */
1270 	if (cache_insert_subclass(c_list, subclass_names, subclass_num,
1271 	    sub_id) != 0)
1272 		return (1);
1273 
1274 	return (0);
1275 }
1276 
1277 static void
1278 cache_remove_all_class(sysevent_handle_t *shp, uint32_t sub_id)
1279 {
1280 	int i;
1281 	class_lst_t *c_list;
1282 	subclass_lst_t *sc_list;
1283 
1284 	for (i = 0; i < CLASS_HASH_SZ + 1; ++i) {
1285 		c_list = SH_CLASS_HASH(shp)[i];
1286 		while (c_list != NULL) {
1287 			sc_list = c_list->cl_subclass_list;
1288 			while (sc_list != NULL) {
1289 				sc_list->sl_num[sub_id] = 0;
1290 				sc_list = sc_list->sl_next;
1291 			}
1292 			c_list = c_list->cl_next;
1293 		}
1294 	}
1295 }
1296 
1297 static void
1298 cache_remove_class(sysevent_handle_t *shp, char *class, uint32_t sub_id)
1299 {
1300 	class_lst_t *c_list;
1301 	subclass_lst_t *sc_list;
1302 
1303 	if (strcmp(class, EC_ALL) == 0) {
1304 		cache_remove_all_class(shp, sub_id);
1305 		return;
1306 	}
1307 
1308 	if ((c_list = cache_find_class(shp, class)) == NULL) {
1309 		return;
1310 	}
1311 
1312 	sc_list = c_list->cl_subclass_list;
1313 	while (sc_list != NULL) {
1314 		sc_list->sl_num[sub_id] = 0;
1315 		sc_list = sc_list->sl_next;
1316 	}
1317 }
1318 
1319 static void
1320 free_cached_registration(sysevent_handle_t *shp)
1321 {
1322 	int i;
1323 	class_lst_t *clist, *next_clist;
1324 	subclass_lst_t *sc_list, *next_sc;
1325 
1326 	for (i = 0; i < CLASS_HASH_SZ + 1; i++) {
1327 		clist = SH_CLASS_HASH(shp)[i];
1328 		while (clist != NULL) {
1329 			sc_list = clist->cl_subclass_list;
1330 			while (sc_list != NULL) {
1331 				free(sc_list->sl_name);
1332 				next_sc = sc_list->sl_next;
1333 				free(sc_list);
1334 				sc_list = next_sc;
1335 			}
1336 			free(clist->cl_name);
1337 			next_clist = clist->cl_next;
1338 			free(clist);
1339 			clist = next_clist;
1340 		}
1341 		SH_CLASS_HASH(shp)[i] = NULL;
1342 	}
1343 }
1344 
1345 static int
1346 create_cached_registration(sysevent_handle_t *shp,
1347 	class_lst_t **class_hash)
1348 {
1349 	int i, j, new_class;
1350 	char *class_name;
1351 	uint_t num_elem;
1352 	uchar_t *subscribers;
1353 	nvlist_t *nvl;
1354 	nvpair_t *nvpair;
1355 	class_lst_t *clist;
1356 	subclass_lst_t *sc_list;
1357 
1358 	for (i = 0; i < CLASS_HASH_SZ + 1; ++i) {
1359 
1360 		if ((nvl = get_kernel_registration(SH_CHANNEL_NAME(shp), i))
1361 		    == NULL) {
1362 			if (errno == ENOENT) {
1363 				class_hash[i] = NULL;
1364 				continue;
1365 			} else {
1366 				goto create_failed;
1367 			}
1368 		}
1369 
1370 
1371 		nvpair = NULL;
1372 		if ((nvpair = nvlist_next_nvpair(nvl, nvpair)) == NULL) {
1373 			goto create_failed;
1374 		}
1375 
1376 		new_class = 1;
1377 		while (new_class) {
1378 			/* Extract the class name from the nvpair */
1379 			if (nvpair_value_string(nvpair, &class_name) != 0) {
1380 				goto create_failed;
1381 			}
1382 			clist = (class_lst_t *)
1383 			    calloc(1, sizeof (class_lst_t));
1384 			if (clist == NULL) {
1385 				goto create_failed;
1386 			}
1387 
1388 			clist->cl_name = strdup(class_name);
1389 			if (clist->cl_name == NULL) {
1390 				free(clist);
1391 				goto create_failed;
1392 			}
1393 
1394 			/*
1395 			 * Extract the subclass name and registration
1396 			 * from the nvpair
1397 			 */
1398 			if ((nvpair = nvlist_next_nvpair(nvl, nvpair))
1399 			    == NULL) {
1400 				free(clist->cl_name);
1401 				free(clist);
1402 				goto create_failed;
1403 			}
1404 
1405 			clist->cl_next = class_hash[i];
1406 			class_hash[i] = clist;
1407 
1408 			for (;;) {
1409 
1410 				sc_list = (subclass_lst_t *)calloc(1,
1411 				    sizeof (subclass_lst_t));
1412 				if (sc_list == NULL) {
1413 					goto create_failed;
1414 				}
1415 
1416 				sc_list->sl_next = clist->cl_subclass_list;
1417 				clist->cl_subclass_list = sc_list;
1418 
1419 				sc_list->sl_name = strdup(nvpair_name(nvpair));
1420 				if (sc_list->sl_name == NULL) {
1421 					goto create_failed;
1422 				}
1423 
1424 				if (nvpair_value_byte_array(nvpair,
1425 				    &subscribers, &num_elem) != 0) {
1426 					goto create_failed;
1427 				}
1428 				bcopy(subscribers, (uchar_t *)sc_list->sl_num,
1429 				    MAX_SUBSCRIBERS + 1);
1430 
1431 				for (j = 1; j <= MAX_SUBSCRIBERS; ++j) {
1432 					if (sc_list->sl_num[j] == 0)
1433 						continue;
1434 
1435 					if (alloc_subscriber(shp, j, 1) != 0) {
1436 						goto create_failed;
1437 					}
1438 				}
1439 
1440 				/*
1441 				 * Check next nvpair - either subclass or
1442 				 * class
1443 				 */
1444 				if ((nvpair = nvlist_next_nvpair(nvl, nvpair))
1445 				    == NULL) {
1446 					new_class = 0;
1447 					break;
1448 				} else if (strcmp(nvpair_name(nvpair),
1449 				    CLASS_NAME) == 0) {
1450 					break;
1451 				}
1452 			}
1453 		}
1454 		nvlist_free(nvl);
1455 	}
1456 	return (0);
1457 
1458 create_failed:
1459 	dealloc_subscribers(shp);
1460 	free_cached_registration(shp);
1461 	if (nvl)
1462 		nvlist_free(nvl);
1463 	return (-1);
1464 
1465 }
1466 
1467 /*
1468  * cache_update_service - generic event publisher service routine.  This routine
1469  *		is called in response to a registration cache update.
1470  *
1471  */
1472 /*ARGSUSED*/
1473 static void
1474 cache_update_service(void *cookie, char *args, size_t alen,
1475     door_desc_t *ddp, uint_t ndid)
1476 {
1477 	int ret = 0;
1478 	uint_t num_elem;
1479 	char *class, **event_list;
1480 	size_t datalen;
1481 	uint32_t sub_id;
1482 	nvlist_t *nvl;
1483 	nvpair_t *nvpair = NULL;
1484 	struct reg_args *rargs;
1485 	sysevent_handle_t *shp;
1486 	subscriber_data_t *sub;
1487 
1488 	if (alen < sizeof (struct reg_args) || cookie == NULL) {
1489 		ret = EINVAL;
1490 		goto return_from_door;
1491 	}
1492 
1493 	/* LINTED: E_BAD_PTR_CAST_ALIGN */
1494 	rargs = (struct reg_args *)args;
1495 	shp = (sysevent_handle_t *)cookie;
1496 
1497 	datalen = alen - sizeof (struct reg_args);
1498 	sub_id = rargs->ra_sub_id;
1499 
1500 	(void) mutex_lock(SH_LOCK(shp));
1501 
1502 	switch (rargs->ra_op) {
1503 	case SE_UNREGISTER:
1504 		class = (char *)&rargs->ra_buf_ptr;
1505 		cache_remove_class(shp, (char *)class,
1506 		    sub_id);
1507 		break;
1508 	case SE_UNBIND_REGISTRATION:
1509 
1510 		sub = SH_SUBSCRIBER(shp, sub_id);
1511 		if (sub == NULL)
1512 			break;
1513 
1514 		free(sub->sd_door_name);
1515 		free(sub);
1516 		cache_remove_class(shp, EC_ALL, sub_id);
1517 		SH_SUBSCRIBER(shp, sub_id) = NULL;
1518 
1519 		break;
1520 	case SE_BIND_REGISTRATION:
1521 
1522 		/* New subscriber */
1523 		if (alloc_subscriber(shp, sub_id, 0) != 0) {
1524 			ret = ENOMEM;
1525 			break;
1526 		}
1527 		break;
1528 	case SE_REGISTER:
1529 
1530 		if (SH_SUBSCRIBER(shp, sub_id) == NULL) {
1531 			ret = EINVAL;
1532 			break;
1533 		}
1534 		/* Get new registration data */
1535 		if (nvlist_unpack((char *)&rargs->ra_buf_ptr, datalen,
1536 		    &nvl, 0) != 0) {
1537 			ret =  EFAULT;
1538 			break;
1539 		}
1540 		if ((nvpair = nvlist_next_nvpair(nvl, nvpair)) == NULL) {
1541 			nvlist_free(nvl);
1542 			ret = EFAULT;
1543 			break;
1544 		}
1545 		if (nvpair_value_string_array(nvpair, &event_list, &num_elem)
1546 		    != 0) {
1547 			nvlist_free(nvl);
1548 			ret =  EFAULT;
1549 			break;
1550 		}
1551 		class = nvpair_name(nvpair);
1552 
1553 		ret = cache_insert_class(shp, class,
1554 		    event_list, num_elem, sub_id);
1555 		if (ret != 0) {
1556 			cache_remove_class(shp, class, sub_id);
1557 			nvlist_free(nvl);
1558 			ret =  EFAULT;
1559 			break;
1560 		}
1561 
1562 		nvlist_free(nvl);
1563 
1564 		break;
1565 	case SE_CLEANUP:
1566 		/* Cleanup stale subscribers */
1567 		sysevent_cleanup_subscribers(shp);
1568 		break;
1569 	default:
1570 		ret =  EINVAL;
1571 	}
1572 
1573 	(void) mutex_unlock(SH_LOCK(shp));
1574 
1575 return_from_door:
1576 	(void) door_return((void *)&ret, sizeof (ret), NULL, 0);
1577 	(void) door_return(NULL, 0, NULL, 0);
1578 }
1579 
1580 /*
1581  * sysevent_send_event -
1582  * Send an event via the communication channel associated with the sysevent
1583  * handle.  Event notifications are broadcast to all subscribers based upon
1584  * the event class and subclass.  The handle must have been previously
1585  * allocated and bound by
1586  * sysevent_open_channel() and sysevent_bind_publisher()
1587  */
1588 int
1589 sysevent_send_event(sysevent_handle_t *shp, sysevent_t *ev)
1590 {
1591 	int i, error, sub_fd, result = 0;
1592 	int deliver_error = 0;
1593 	int subscribers_sent = 0;
1594 	int want_resend, resend_cnt = 0;
1595 	char *event_class, *event_subclass;
1596 	uchar_t *all_class_subscribers, *all_subclass_subscribers;
1597 	uchar_t *subclass_subscribers;
1598 	subscriber_data_t *sub;
1599 	subclass_lst_t *sc_lst;
1600 
1601 	/* Check for proper registration */
1602 	event_class = sysevent_get_class_name(ev);
1603 	event_subclass = sysevent_get_subclass_name(ev);
1604 
1605 	(void) mutex_lock(SH_LOCK(shp));
1606 
1607 send_event:
1608 
1609 	want_resend = 0;
1610 	if (!SH_BOUND(shp)) {
1611 		(void) mutex_unlock(SH_LOCK(shp));
1612 		errno = EINVAL;
1613 		return (-1);
1614 	}
1615 
1616 	/* Find all subscribers for this event class/subclass */
1617 	sc_lst = cache_find_subclass(
1618 	    cache_find_class(shp, EC_ALL), EC_SUB_ALL);
1619 	all_class_subscribers = sc_lst->sl_num;
1620 
1621 	sc_lst = cache_find_subclass(
1622 	    cache_find_class(shp, event_class), EC_SUB_ALL);
1623 	if (sc_lst)
1624 		all_subclass_subscribers = sc_lst->sl_num;
1625 	else
1626 		all_subclass_subscribers = NULL;
1627 
1628 	sc_lst = cache_find_subclass(
1629 	    cache_find_class(shp, event_class), event_subclass);
1630 	if (sc_lst)
1631 		subclass_subscribers = sc_lst->sl_num;
1632 	else
1633 		subclass_subscribers = NULL;
1634 
1635 	/* Send event buffer to all valid subscribers */
1636 	for (i = 1; i <= MAX_SUBSCRIBERS; ++i) {
1637 		if ((all_class_subscribers[i] |
1638 		    (all_subclass_subscribers && all_subclass_subscribers[i]) |
1639 		    (subclass_subscribers && subclass_subscribers[i])) == 0)
1640 			continue;
1641 
1642 		sub = SH_SUBSCRIBER(shp, i);
1643 		assert(sub != NULL);
1644 
1645 		/* Check for active subscriber */
1646 		if (!(sub->sd_flag & ACTIVE)) {
1647 			dprint("sysevent_send_event: subscriber %d inactive\n",
1648 			    i);
1649 			continue;
1650 		}
1651 
1652 		/* Process only resend requests */
1653 		if (resend_cnt > 0 && !(sub->sd_flag & SEND_AGAIN)) {
1654 			continue;
1655 		}
1656 
1657 		if ((sub_fd = open(sub->sd_door_name, O_RDONLY)) == -1) {
1658 			dprint("sysevent_send_event: Failed to open "
1659 			    "%s: %s\n", sub->sd_door_name, strerror(errno));
1660 			continue;
1661 		}
1662 		result = 0;
1663 		error = clnt_deliver_event(sub_fd, ev,
1664 		    sysevent_get_size(ev), &result, sizeof (result));
1665 
1666 		(void) close(sub_fd);
1667 
1668 		/* Successful door call */
1669 		if (error == 0) {
1670 			switch (result) {
1671 			/* Subscriber requested EAGAIN */
1672 			case EAGAIN:
1673 				if (resend_cnt > SE_MAX_RETRY_LIMIT) {
1674 					deliver_error = 1;
1675 				} else {
1676 					want_resend = 1;
1677 					dprint("sysevent_send_event: resend "
1678 					    "requested for %d\n", i);
1679 					sub->sd_flag |= SEND_AGAIN;
1680 				}
1681 				break;
1682 			/* Bad sysevent handle for subscriber */
1683 			case EBADF:
1684 			case EINVAL:
1685 				dprint("sysevent_send_event: Bad sysevent "
1686 				    "handle for %s", sub->sd_door_name);
1687 				sub->sd_flag = 0;
1688 				deliver_error = 1;
1689 				break;
1690 			/* Successful delivery */
1691 			default:
1692 				sub->sd_flag &= ~SEND_AGAIN;
1693 				++subscribers_sent;
1694 			}
1695 		} else {
1696 			dprint("sysevent_send_event: Failed door call "
1697 			    "to %s: %s: %d\n", sub->sd_door_name,
1698 			    strerror(errno), result);
1699 			sub->sd_flag = 0;
1700 			deliver_error = 1;
1701 		}
1702 	}
1703 
1704 	if (want_resend) {
1705 		resend_cnt++;
1706 		goto send_event;
1707 	}
1708 
1709 	if (deliver_error) {
1710 		sysevent_cleanup_subscribers(shp);
1711 		(void) mutex_unlock(SH_LOCK(shp));
1712 		errno = EFAULT;
1713 		return (-1);
1714 	}
1715 
1716 	(void) mutex_unlock(SH_LOCK(shp));
1717 
1718 	if (subscribers_sent == 0) {
1719 		dprint("sysevent_send_event: No subscribers for %s:%s\n",
1720 		    event_class, event_subclass);
1721 		errno = ENOENT;
1722 		return (-1);
1723 	}
1724 
1725 	return (0);
1726 }
1727 
1728 /*
1729  * Common routine to establish an event channel through which an event
1730  * publisher or subscriber may post or receive events.
1731  */
1732 static sysevent_handle_t *
1733 sysevent_open_channel_common(const char *channel_path)
1734 {
1735 	uint32_t sub_id = 0;
1736 	char *begin_path;
1737 	struct stat chan_stat;
1738 	sysevent_handle_t *shp;
1739 
1740 
1741 	if (channel_path == NULL || strlen(channel_path) + 1 > MAXPATHLEN) {
1742 		errno = EINVAL;
1743 		return (NULL);
1744 	}
1745 
1746 	if (mkdir(channel_path, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) < 0) {
1747 		if (errno != EEXIST) {
1748 			errno = EACCES;
1749 			return (NULL);
1750 		}
1751 	}
1752 
1753 	/* Check channel file permissions */
1754 	if (stat(channel_path, &chan_stat) != 0) {
1755 		dprint("sysevent_open_channel: Invalid permissions for channel "
1756 		    "%s\n", channel_path);
1757 		errno = EACCES;
1758 		return (NULL);
1759 	} else if (chan_stat.st_uid != getuid() ||
1760 	    !S_ISDIR(chan_stat.st_mode)) {
1761 		dprint("sysevent_open_channel: Invalid "
1762 		    "permissions for channel %s\n: %d:%d:%d", channel_path,
1763 		    (int)chan_stat.st_uid, (int)chan_stat.st_gid,
1764 		    (int)chan_stat.st_mode);
1765 
1766 		errno = EACCES;
1767 		return (NULL);
1768 	}
1769 
1770 	shp = calloc(1, sizeof (sysevent_impl_hdl_t));
1771 	if (shp == NULL) {
1772 		errno = ENOMEM;
1773 		return (NULL);
1774 	}
1775 
1776 	SH_CHANNEL_NAME(shp) = NULL;
1777 	SH_CHANNEL_PATH(shp) = strdup(channel_path);
1778 	if (SH_CHANNEL_PATH(shp) == NULL) {
1779 		free(shp);
1780 		errno = ENOMEM;
1781 		return (NULL);
1782 	}
1783 
1784 	/* Extract the channel name */
1785 	begin_path = SH_CHANNEL_PATH(shp);
1786 	while (*begin_path != '\0' &&
1787 	    (begin_path = strpbrk(begin_path, "/")) != NULL) {
1788 		++begin_path;
1789 		SH_CHANNEL_NAME(shp) = begin_path;
1790 	}
1791 
1792 	if (update_kernel_registration(shp, 0,
1793 	    SE_OPEN_REGISTRATION, &sub_id, 0, NULL) != 0) {
1794 		dprint("sysevent_open_channel: Failed for channel %s\n",
1795 		    SH_CHANNEL_NAME(shp));
1796 		free(SH_CHANNEL_PATH(shp));
1797 		free(shp);
1798 		errno = EFAULT;
1799 		return (NULL);
1800 	}
1801 
1802 	(void) mutex_init(SH_LOCK(shp), USYNC_THREAD, NULL);
1803 
1804 	return (shp);
1805 }
1806 
1807 /*
1808  * Establish a sysevent channel for publication and subscription
1809  */
1810 sysevent_handle_t *
1811 sysevent_open_channel(const char *channel)
1812 {
1813 	int var_run_mounted = 0;
1814 	char full_channel[MAXPATHLEN + 1];
1815 	FILE *fp;
1816 	struct stat chan_stat;
1817 	struct extmnttab m;
1818 
1819 	if (channel == NULL) {
1820 		errno = EINVAL;
1821 		return (NULL);
1822 	}
1823 
1824 	/*
1825 	 * Check that /var/run is mounted as tmpfs before allowing a channel
1826 	 * to be opened.
1827 	 */
1828 	if ((fp = fopen(MNTTAB, "rF")) == NULL) {
1829 		errno = EACCES;
1830 		return (NULL);
1831 	}
1832 
1833 	resetmnttab(fp);
1834 
1835 	while (getextmntent(fp, &m, sizeof (struct extmnttab)) == 0) {
1836 		if (strcmp(m.mnt_mountp, "/var/run") == 0 &&
1837 		    strcmp(m.mnt_fstype, "tmpfs") == 0) {
1838 			(void) fclose(fp);
1839 			var_run_mounted = 1;
1840 			break;
1841 		}
1842 	}
1843 	(void) fclose(fp);
1844 
1845 	if (!var_run_mounted) {
1846 		errno = EACCES;
1847 		return (NULL);
1848 	}
1849 
1850 	if (stat(CHAN_PATH, &chan_stat) < 0) {
1851 		if (mkdir(CHAN_PATH,
1852 		    S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) < 0) {
1853 			dprint("sysevent_open_channel: Unable "
1854 			    "to create channel directory %s:%s\n", CHAN_PATH,
1855 			    strerror(errno));
1856 			if (errno != EEXIST) {
1857 				errno = EACCES;
1858 				return (NULL);
1859 			}
1860 		}
1861 	}
1862 
1863 	if (snprintf(full_channel, MAXPATHLEN, "%s/%s", CHAN_PATH, channel) >=
1864 	    MAXPATHLEN) {
1865 		errno = EINVAL;
1866 		return (NULL);
1867 	}
1868 
1869 	return (sysevent_open_channel_common(full_channel));
1870 }
1871 
1872 /*
1873  * Establish a sysevent channel for publication and subscription
1874  * Full path to the channel determined by the caller
1875  */
1876 sysevent_handle_t *
1877 sysevent_open_channel_alt(const char *channel_path)
1878 {
1879 	return (sysevent_open_channel_common(channel_path));
1880 }
1881 
1882 /*
1883  * sysevent_close_channel - Clean up resources associated with a previously
1884  *				opened sysevent channel
1885  */
1886 void
1887 sysevent_close_channel(sysevent_handle_t *shp)
1888 {
1889 	int error = errno;
1890 	uint32_t sub_id = 0;
1891 
1892 	if (shp == NULL) {
1893 		return;
1894 	}
1895 
1896 	(void) mutex_lock(SH_LOCK(shp));
1897 	if (SH_BOUND(shp)) {
1898 		(void) mutex_unlock(SH_LOCK(shp));
1899 		if (SH_TYPE(shp) == PUBLISHER)
1900 			sysevent_unbind_publisher(shp);
1901 		else if (SH_TYPE(shp) == SUBSCRIBER)
1902 			sysevent_unbind_subscriber(shp);
1903 		(void) mutex_lock(SH_LOCK(shp));
1904 	}
1905 
1906 	(void) update_kernel_registration(shp, 0,
1907 	    SE_CLOSE_REGISTRATION, &sub_id, 0, NULL);
1908 	(void) mutex_unlock(SH_LOCK(shp));
1909 
1910 	free(SH_CHANNEL_PATH(shp));
1911 	free(shp);
1912 	errno = error;
1913 }
1914 
1915 /*
1916  * sysevent_bind_publisher - Bind an event publisher to an event channel
1917  */
1918 int
1919 sysevent_bind_publisher(sysevent_handle_t *shp)
1920 {
1921 	int error = 0;
1922 	int fd = -1;
1923 	char door_name[MAXPATHLEN];
1924 	uint32_t pub_id;
1925 	struct stat reg_stat;
1926 	publisher_priv_t *pub;
1927 
1928 	if (shp == NULL) {
1929 		errno = EINVAL;
1930 		return (-1);
1931 	}
1932 
1933 	(void) mutex_lock(SH_LOCK(shp));
1934 	if (SH_BOUND(shp)) {
1935 		(void) mutex_unlock(SH_LOCK(shp));
1936 		errno = EINVAL;
1937 		return (-1);
1938 	}
1939 
1940 	if ((pub = (publisher_priv_t *)calloc(1, sizeof (publisher_priv_t))) ==
1941 	    NULL) {
1942 		(void) mutex_unlock(SH_LOCK(shp));
1943 		errno = ENOMEM;
1944 		return (-1);
1945 	}
1946 	SH_PRIV_DATA(shp) = (void *)pub;
1947 
1948 	if (snprintf(door_name, MAXPATHLEN, "%s/%s",
1949 	    SH_CHANNEL_PATH(shp), REG_DOOR) >= MAXPATHLEN) {
1950 		free(pub);
1951 		(void) mutex_unlock(SH_LOCK(shp));
1952 		errno = ENOMEM;
1953 		return (-1);
1954 	}
1955 	if ((SH_DOOR_NAME(shp) = strdup(door_name)) == NULL) {
1956 		free(pub);
1957 		(void) mutex_unlock(SH_LOCK(shp));
1958 		errno = ENOMEM;
1959 		return (-1);
1960 	}
1961 
1962 	/* Only one publisher allowed per channel */
1963 	if (stat(SH_DOOR_NAME(shp), &reg_stat) != 0) {
1964 		if (errno != ENOENT) {
1965 			error = EINVAL;
1966 			goto fail;
1967 		}
1968 	}
1969 
1970 	/*
1971 	 * Remove door file for robustness.
1972 	 */
1973 	if (unlink(SH_DOOR_NAME(shp)) != 0)
1974 		dprint("sysevent_bind_publisher: Unlink of %s failed.\n",
1975 		    SH_DOOR_NAME(shp));
1976 
1977 	/* Open channel registration door */
1978 	fd = open(SH_DOOR_NAME(shp), O_CREAT|O_RDWR,
1979 	    S_IREAD|S_IWRITE);
1980 	if (fd == -1) {
1981 		error = EINVAL;
1982 		goto fail;
1983 	}
1984 
1985 	/*
1986 	 * Create the registration service for this publisher.
1987 	 */
1988 	if ((SH_DOOR_DESC(shp) = door_create(cache_update_service,
1989 	    (void *)shp, DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) {
1990 		dprint("sysevent_bind_publisher: door create failed: "
1991 		    "%s\n", strerror(errno));
1992 		error = EFAULT;
1993 		goto fail;
1994 	}
1995 
1996 	(void) fdetach(SH_DOOR_NAME(shp));
1997 	if (fattach(SH_DOOR_DESC(shp), SH_DOOR_NAME(shp)) != 0) {
1998 		dprint("sysevent_bind_publisher: unable to "
1999 		    "bind event channel: fattach: %s\n",
2000 		    SH_DOOR_NAME(shp));
2001 		error = EACCES;
2002 		goto fail;
2003 	}
2004 
2005 	/* Bind this publisher in the kernel registration database */
2006 	if (update_kernel_registration(shp, PUBLISHER,
2007 	    SE_BIND_REGISTRATION, &pub_id, 0, NULL) != 0) {
2008 		error = errno;
2009 		goto fail;
2010 	}
2011 
2012 	SH_ID(shp) = pub_id;
2013 	SH_BOUND(shp) = 1;
2014 	SH_TYPE(shp) = PUBLISHER;
2015 
2016 
2017 	/* Create the subscription registration cache */
2018 	if (create_cached_registration(shp, SH_CLASS_HASH(shp)) != 0) {
2019 		(void) update_kernel_registration(shp,
2020 		    PUBLISHER, SE_UNBIND_REGISTRATION, &pub_id, 0, NULL);
2021 		error = EFAULT;
2022 		goto fail;
2023 	}
2024 	(void) close(fd);
2025 
2026 	(void) mutex_unlock(SH_LOCK(shp));
2027 
2028 	return (0);
2029 
2030 fail:
2031 	SH_BOUND(shp) = 0;
2032 	(void) door_revoke(SH_DOOR_DESC(shp));
2033 	(void) fdetach(SH_DOOR_NAME(shp));
2034 	free(SH_DOOR_NAME(shp));
2035 	free(pub);
2036 	(void) close(fd);
2037 	(void) mutex_unlock(SH_LOCK(shp));
2038 	errno = error;
2039 	return (-1);
2040 }
2041 
2042 /*
2043  * sysevent_bind_subscriber - Bind an event receiver to an event channel
2044  */
2045 int
2046 sysevent_bind_subscriber(sysevent_handle_t *shp,
2047 	void (*event_handler)(sysevent_t *ev))
2048 {
2049 	int fd = -1;
2050 	int error = 0;
2051 	uint32_t sub_id = 0;
2052 	char door_name[MAXPATHLEN];
2053 	subscriber_priv_t *sub_info;
2054 
2055 	if (shp == NULL || event_handler == NULL) {
2056 		errno = EINVAL;
2057 		return (-1);
2058 	}
2059 
2060 	(void) mutex_lock(SH_LOCK(shp));
2061 	if (SH_BOUND(shp)) {
2062 		errno = EINVAL;
2063 		(void) mutex_unlock(SH_LOCK(shp));
2064 		return (-1);
2065 	}
2066 
2067 	if ((sub_info = (subscriber_priv_t *)calloc(1,
2068 	    sizeof (subscriber_priv_t))) == NULL) {
2069 		errno = ENOMEM;
2070 		(void) mutex_unlock(SH_LOCK(shp));
2071 		return (-1);
2072 	}
2073 
2074 	if (snprintf(door_name, MAXPATHLEN, "%s/%s",
2075 	    SH_CHANNEL_PATH(shp), REG_DOOR) >= MAXPATHLEN) {
2076 		free(sub_info);
2077 		errno = EINVAL;
2078 		(void) mutex_unlock(SH_LOCK(shp));
2079 		return (-1);
2080 	}
2081 
2082 	if ((sub_info->sp_door_name = strdup(door_name)) == NULL) {
2083 		free(sub_info);
2084 		errno = ENOMEM;
2085 		(void) mutex_unlock(SH_LOCK(shp));
2086 		return (-1);
2087 	}
2088 	(void) cond_init(&sub_info->sp_cv, USYNC_THREAD, NULL);
2089 	(void) mutex_init(&sub_info->sp_qlock, USYNC_THREAD, NULL);
2090 	sub_info->sp_func = event_handler;
2091 
2092 	/* Update the in-kernel registration */
2093 	if (update_kernel_registration(shp, SUBSCRIBER,
2094 	    SE_BIND_REGISTRATION, &sub_id, 0, NULL) != 0) {
2095 		error = errno;
2096 		goto fail;
2097 	}
2098 	SH_ID(shp) = sub_id;
2099 
2100 	if (snprintf(door_name, MAXPATHLEN, "%s/%d",
2101 	    SH_CHANNEL_PATH(shp), sub_id) >= MAXPATHLEN) {
2102 		error = EINVAL;
2103 		goto fail;
2104 	}
2105 	if ((SH_DOOR_NAME(shp) = strdup(door_name)) == NULL) {
2106 		error = ENOMEM;
2107 		goto fail;
2108 	}
2109 
2110 	/*
2111 	 * Remove door file for robustness.
2112 	 */
2113 	if (unlink(SH_DOOR_NAME(shp)) != 0)
2114 		dprint("sysevent_bind_subscriber: Unlink of %s failed.\n",
2115 		    SH_DOOR_NAME(shp));
2116 
2117 	fd = open(SH_DOOR_NAME(shp), O_CREAT|O_RDWR, S_IREAD|S_IWRITE);
2118 	if (fd == -1) {
2119 		error = EFAULT;
2120 		goto fail;
2121 	}
2122 
2123 	/*
2124 	 * Create the sysevent door service for this client.
2125 	 * syseventd will use this door service to propagate
2126 	 * events to the client.
2127 	 */
2128 	if ((SH_DOOR_DESC(shp) = door_create(event_deliver_service,
2129 	    (void *)shp, DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) {
2130 		dprint("sysevent_bind_subscriber: door create failed: "
2131 		    "%s\n", strerror(errno));
2132 		error = EFAULT;
2133 		goto fail;
2134 	}
2135 
2136 	(void) fdetach(SH_DOOR_NAME(shp));
2137 	if (fattach(SH_DOOR_DESC(shp), SH_DOOR_NAME(shp)) != 0) {
2138 		error = EFAULT;
2139 		goto fail;
2140 	}
2141 	(void) close(fd);
2142 
2143 	if (update_publisher_cache(sub_info, SE_BIND_REGISTRATION,
2144 	    sub_id, 0, NULL) != 0) {
2145 		error = errno;
2146 		(void) update_kernel_registration(shp, SUBSCRIBER,
2147 		    SE_UNBIND_REGISTRATION, &sub_id, 0, NULL);
2148 		goto fail;
2149 	}
2150 
2151 	SH_BOUND(shp) = 1;
2152 	SH_TYPE(shp) = SUBSCRIBER;
2153 	SH_PRIV_DATA(shp) = (void *)sub_info;
2154 
2155 
2156 	/* Create an event handler thread */
2157 	if (thr_create(NULL, NULL, (void *(*)(void *))subscriber_event_handler,
2158 	    shp, THR_BOUND, &sub_info->sp_handler_tid) != 0) {
2159 		error = EFAULT;
2160 		goto fail;
2161 	}
2162 
2163 	(void) mutex_unlock(SH_LOCK(shp));
2164 
2165 	return (0);
2166 
2167 fail:
2168 	(void) close(fd);
2169 	(void) door_revoke(SH_DOOR_DESC(shp));
2170 	(void) fdetach(SH_DOOR_NAME(shp));
2171 	(void) cond_destroy(&sub_info->sp_cv);
2172 	(void) mutex_destroy(&sub_info->sp_qlock);
2173 	free(sub_info->sp_door_name);
2174 	free(sub_info);
2175 	if (SH_ID(shp)) {
2176 		(void) update_kernel_registration(shp, SUBSCRIBER,
2177 		    SE_UNBIND_REGISTRATION, &sub_id, 0, NULL);
2178 		SH_ID(shp) = 0;
2179 	}
2180 	if (SH_BOUND(shp)) {
2181 		(void) update_publisher_cache(sub_info, SE_UNBIND_REGISTRATION,
2182 		    sub_id, 0, NULL);
2183 		free(SH_DOOR_NAME(shp));
2184 		SH_BOUND(shp) = 0;
2185 	}
2186 	(void) mutex_unlock(SH_LOCK(shp));
2187 
2188 	errno = error;
2189 
2190 	return (-1);
2191 }
2192 
2193 /*
2194  * sysevent_register_event - register an event class and associated subclasses
2195  *		for an event subscriber
2196  */
2197 int
2198 sysevent_register_event(sysevent_handle_t *shp,
2199 	const char *ev_class, const char **ev_subclass,
2200 	int subclass_num)
2201 {
2202 	int error;
2203 	char *event_class = (char *)ev_class;
2204 	char **event_subclass_list = (char **)ev_subclass;
2205 	char *nvlbuf = NULL;
2206 	size_t datalen;
2207 	nvlist_t *nvl;
2208 
2209 	(void) mutex_lock(SH_LOCK(shp));
2210 	if (event_class == NULL || event_subclass_list == NULL ||
2211 	    event_subclass_list[0] == NULL || SH_BOUND(shp) != 1 ||
2212 	    subclass_num <= 0) {
2213 		(void) mutex_unlock(SH_LOCK(shp));
2214 		errno = EINVAL;
2215 		return (-1);
2216 	}
2217 
2218 	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME_TYPE, 0) != 0) {
2219 		(void) mutex_unlock(SH_LOCK(shp));
2220 		return (-1);
2221 	}
2222 	if (nvlist_add_string_array(nvl, event_class, event_subclass_list,
2223 	    subclass_num) != 0) {
2224 		nvlist_free(nvl);
2225 		(void) mutex_unlock(SH_LOCK(shp));
2226 		return (-1);
2227 	}
2228 	if (nvlist_pack(nvl, &nvlbuf, &datalen, NV_ENCODE_NATIVE, 0) != 0) {
2229 		nvlist_free(nvl);
2230 		(void) mutex_unlock(SH_LOCK(shp));
2231 		return (-1);
2232 	}
2233 	nvlist_free(nvl);
2234 
2235 	/* Store new subscriber in in-kernel registration */
2236 	if (update_kernel_registration(shp, SUBSCRIBER,
2237 	    SE_REGISTER, &SH_ID(shp), datalen, (uchar_t *)nvlbuf)
2238 	    != 0) {
2239 		error = errno;
2240 		free(nvlbuf);
2241 		(void) mutex_unlock(SH_LOCK(shp));
2242 		errno = error;
2243 		return (-1);
2244 	}
2245 	/* Update the publisher's cached registration */
2246 	if (update_publisher_cache(
2247 	    (subscriber_priv_t *)SH_PRIV_DATA(shp), SE_REGISTER,
2248 	    SH_ID(shp), datalen, (uchar_t *)nvlbuf) != 0) {
2249 		error = errno;
2250 		free(nvlbuf);
2251 		(void) mutex_unlock(SH_LOCK(shp));
2252 		errno = error;
2253 		return (-1);
2254 	}
2255 
2256 	free(nvlbuf);
2257 
2258 	(void) mutex_unlock(SH_LOCK(shp));
2259 
2260 	return (0);
2261 }
2262 
2263 /*
2264  * sysevent_unregister_event - Unregister an event class and associated
2265  *				subclasses for an event subscriber
2266  */
2267 void
2268 sysevent_unregister_event(sysevent_handle_t *shp, const char *class)
2269 {
2270 	size_t class_sz;
2271 
2272 	(void) mutex_lock(SH_LOCK(shp));
2273 
2274 	if (!SH_BOUND(shp)) {
2275 		(void) mutex_unlock(SH_LOCK(shp));
2276 		return;
2277 	}
2278 
2279 	/* Remove subscriber from in-kernel registration */
2280 	class_sz = strlen(class) + 1;
2281 	(void) update_kernel_registration(shp, SUBSCRIBER,
2282 	    SE_UNREGISTER, &SH_ID(shp), class_sz, (uchar_t *)class);
2283 	/* Update the publisher's cached registration */
2284 	(void) update_publisher_cache(
2285 	    (subscriber_priv_t *)SH_PRIV_DATA(shp), SE_UNREGISTER,
2286 	    SH_ID(shp), class_sz, (uchar_t *)class);
2287 
2288 	(void) mutex_unlock(SH_LOCK(shp));
2289 }
2290 
2291 static int
2292 cleanup_id(sysevent_handle_t *shp, uint32_t id, int type)
2293 {
2294 	dprint("cleanup_id: Cleaning up %s/%d\n", SH_CHANNEL_NAME(shp), id);
2295 
2296 	/* Remove registration from the kernel */
2297 	if (update_kernel_registration(shp, type, SE_CLEANUP, &id,
2298 	    0, NULL) != 0) {
2299 		dprint("cleanup_id: Unable to clean "
2300 		    "up %s/%d\n", SH_CHANNEL_NAME(shp), id);
2301 		return (-1);
2302 	}
2303 
2304 	return (0);
2305 }
2306 
2307 /*
2308  * sysevent_cleanup_subscribers: Allows the caller to cleanup resources
2309  *		allocated to unresponsive subscribers.
2310  */
2311 void
2312 sysevent_cleanup_subscribers(sysevent_handle_t *shp)
2313 {
2314 	uint32_t ping, result;
2315 	int i, error, sub_fd;
2316 	subscriber_data_t *sub;
2317 
2318 	if (!SH_BOUND(shp)) {
2319 		return;
2320 	}
2321 
2322 	for (i = 1; i <= MAX_SUBSCRIBERS; ++i) {
2323 
2324 		sub = SH_SUBSCRIBER(shp, i);
2325 		if (sub == NULL) {
2326 			continue;
2327 		}
2328 
2329 		if ((sub_fd = open(sub->sd_door_name, O_RDONLY)) == -1) {
2330 			continue;
2331 		}
2332 		/* Check for valid and responsive subscriber */
2333 		error = clnt_deliver_event(sub_fd, &ping,
2334 		    sizeof (uint32_t), &result, sizeof (result));
2335 		(void) close(sub_fd);
2336 
2337 		/* Only cleanup on EBADF (Invalid door descriptor) */
2338 		if (error != EBADF)
2339 			continue;
2340 
2341 		if (cleanup_id(shp, i, SUBSCRIBER) != 0)
2342 			continue;
2343 
2344 		cache_remove_class(shp, EC_ALL, i);
2345 
2346 		free(sub->sd_door_name);
2347 		free(sub);
2348 		SH_SUBSCRIBER(shp, i) = NULL;
2349 	}
2350 
2351 }
2352 
2353 /*
2354  * sysevent_cleanup_publishers: Allows stale publisher handles to be deallocated
2355  *		as needed.
2356  */
2357 void
2358 sysevent_cleanup_publishers(sysevent_handle_t *shp)
2359 {
2360 	(void) cleanup_id(shp, 1, PUBLISHER);
2361 }
2362 
2363 /*
2364  * sysevent_unbind_subscriber: Unbind the subscriber from the sysevent channel.
2365  */
2366 void
2367 sysevent_unbind_subscriber(sysevent_handle_t *shp)
2368 {
2369 	subscriber_priv_t *sub_info;
2370 
2371 	if (shp == NULL)
2372 		return;
2373 
2374 	(void) mutex_lock(SH_LOCK(shp));
2375 	if (SH_BOUND(shp) == 0) {
2376 		(void) mutex_unlock(SH_LOCK(shp));
2377 		return;
2378 	}
2379 
2380 	/* Update the in-kernel registration */
2381 	(void) update_kernel_registration(shp, SUBSCRIBER,
2382 	    SE_UNBIND_REGISTRATION, &SH_ID(shp), 0, NULL);
2383 
2384 	/* Update the sysevent channel publisher */
2385 	sub_info = (subscriber_priv_t *)SH_PRIV_DATA(shp);
2386 	(void) update_publisher_cache(sub_info, SE_UNBIND_REGISTRATION,
2387 	    SH_ID(shp), 0, NULL);
2388 
2389 	/* Close down event delivery facilities */
2390 	(void) door_revoke(SH_DOOR_DESC(shp));
2391 	(void) fdetach(SH_DOOR_NAME(shp));
2392 
2393 
2394 	/*
2395 	 * Release resources and wait for pending event delivery to
2396 	 * complete.
2397 	 */
2398 	(void) mutex_lock(&sub_info->sp_qlock);
2399 	SH_BOUND(shp) = 0;
2400 	/* Signal event handler and drain the subscriber's event queue */
2401 	(void) cond_signal(&sub_info->sp_cv);
2402 	(void) mutex_unlock(&sub_info->sp_qlock);
2403 	(void) thr_join(sub_info->sp_handler_tid, NULL, NULL);
2404 
2405 	(void) cond_destroy(&sub_info->sp_cv);
2406 	(void) mutex_destroy(&sub_info->sp_qlock);
2407 	free(sub_info->sp_door_name);
2408 	free(sub_info);
2409 	free(SH_DOOR_NAME(shp));
2410 	(void) mutex_unlock(SH_LOCK(shp));
2411 }
2412 
2413 /*
2414  * sysevent_unbind_publisher: Unbind publisher from the sysevent channel.
2415  */
2416 void
2417 sysevent_unbind_publisher(sysevent_handle_t *shp)
2418 {
2419 	if (shp == NULL)
2420 		return;
2421 
2422 	(void) mutex_lock(SH_LOCK(shp));
2423 	if (SH_BOUND(shp) == 0) {
2424 		(void) mutex_unlock(SH_LOCK(shp));
2425 		return;
2426 	}
2427 
2428 	/* Close down the registration facilities */
2429 	(void) door_revoke(SH_DOOR_DESC(shp));
2430 	(void) fdetach(SH_DOOR_NAME(shp));
2431 
2432 	/* Update the in-kernel registration */
2433 	(void) update_kernel_registration(shp, PUBLISHER,
2434 	    SE_UNBIND_REGISTRATION, &SH_ID(shp), 0, NULL);
2435 	SH_BOUND(shp) = 0;
2436 
2437 	/* Free resources associated with bind */
2438 	free_cached_registration(shp);
2439 	dealloc_subscribers(shp);
2440 
2441 	free(SH_PRIV_DATA(shp));
2442 	free(SH_DOOR_NAME(shp));
2443 	SH_ID(shp) = 0;
2444 	(void) mutex_unlock(SH_LOCK(shp));
2445 }
2446 
2447 /*
2448  * Evolving APIs to subscribe to syseventd(1M) system events.
2449  */
2450 
2451 /*
2452  * sysevent_bind_handle - Bind application event handler for syseventd
2453  *		subscription.
2454  */
2455 sysevent_handle_t *
2456 sysevent_bind_handle(void (*event_handler)(sysevent_t *ev))
2457 {
2458 	sysevent_handle_t *shp;
2459 
2460 	if (getuid() != 0) {
2461 		errno = EACCES;
2462 		return (NULL);
2463 	}
2464 
2465 	if (event_handler == NULL) {
2466 		errno = EINVAL;
2467 		return (NULL);
2468 	}
2469 
2470 	if ((shp = sysevent_open_channel(SYSEVENTD_CHAN)) == NULL) {
2471 		return (NULL);
2472 	}
2473 
2474 	if (sysevent_bind_subscriber(shp, event_handler) != 0) {
2475 
2476 		/*
2477 		 * Ask syseventd to clean-up any stale subcribers and try to
2478 		 * to bind again
2479 		 */
2480 		if (errno == EBUSY) {
2481 			int pub_fd;
2482 			char door_name[MAXPATHLEN];
2483 			uint32_t result;
2484 			struct reg_args rargs;
2485 
2486 			if (snprintf(door_name, MAXPATHLEN, "%s/%s",
2487 			    SH_CHANNEL_PATH(shp), REG_DOOR) >= MAXPATHLEN) {
2488 				sysevent_close_channel(shp);
2489 				errno = EINVAL;
2490 				return (NULL);
2491 			}
2492 
2493 			rargs.ra_op = SE_CLEANUP;
2494 			pub_fd = open(door_name, O_RDONLY);
2495 			(void) clnt_deliver_event(pub_fd, (void *)&rargs,
2496 			    sizeof (struct reg_args), &result, sizeof (result));
2497 			(void) close(pub_fd);
2498 
2499 			/* Try to bind again */
2500 			if (sysevent_bind_subscriber(shp, event_handler) != 0) {
2501 				sysevent_close_channel(shp);
2502 				return (NULL);
2503 			}
2504 		} else {
2505 			sysevent_close_channel(shp);
2506 			return (NULL);
2507 		}
2508 	}
2509 
2510 	return (shp);
2511 }
2512 
2513 /*
2514  * sysevent_unbind_handle - Unbind caller from syseventd subscriptions
2515  */
2516 void
2517 sysevent_unbind_handle(sysevent_handle_t *shp)
2518 {
2519 	sysevent_unbind_subscriber(shp);
2520 	sysevent_close_channel(shp);
2521 }
2522 
2523 /*
2524  * sysevent_subscribe_event - Subscribe to system event notification from
2525  *			syseventd(1M) for the class and subclasses specified.
2526  */
2527 int
2528 sysevent_subscribe_event(sysevent_handle_t *shp, const char *event_class,
2529 	const char **event_subclass_list, int num_subclasses)
2530 {
2531 	return (sysevent_register_event(shp, event_class,
2532 	    event_subclass_list, num_subclasses));
2533 }
2534 
2535 void
2536 sysevent_unsubscribe_event(sysevent_handle_t *shp, const char *event_class)
2537 {
2538 	sysevent_unregister_event(shp, event_class);
2539 }
2540