xref: /titanic_52/usr/src/uts/common/io/sysevent.c (revision 7aa76ffc594f84c1c092911a84f85a79ddb44c73) 
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  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 
26 /*
27  * Sysevent Driver for GPEC
28  */
29 
30 #include <sys/types.h>
31 #include <sys/param.h>
32 #include <sys/cred.h>
33 #include <sys/file.h>
34 #include <sys/stat.h>
35 #include <sys/conf.h>
36 #include <sys/ddi.h>
37 #include <sys/sunddi.h>
38 #include <sys/modctl.h>
39 #include <sys/open.h>		/* OTYP_CHR definition */
40 #include <sys/sysmacros.h>	/* L_BITSMINOR definition */
41 #include <sys/bitmap.h>
42 #include <sys/sysevent.h>
43 #include <sys/sysevent_impl.h>
44 
45 static dev_info_t *sysevent_devi;
46 
47 /* Definitions for binding handle array */
48 static ulong_t sysevent_bitmap_initial = 1;	/* index 0 indicates error */
49 static ulong_t *sysevent_minor_bitmap = &sysevent_bitmap_initial;
50 static size_t sysevent_minor_bits = BT_NBIPUL;
51 static kmutex_t sysevent_minor_mutex;
52 
53 /*
54  * evchan_ctl acts as a container for the binding handle
55  */
56 typedef struct evchan_ctl {
57 	evchan_t *chp;
58 } evchan_ctl_t;
59 
60 static void *evchan_ctlp;
61 
62 /*
63  * Check if it's a null terminated array - to avoid DoS attack
64  * It is supposed that string points to an array with
65  * a minimum length of len. len must be strlen + 1.
66  * Checks for printable characters are already done in library.
67  */
68 static int
69 sysevent_isstrend(char *string, size_t len)
70 {
71 	/* Return 0 if string has length of zero */
72 	if (len > 0) {
73 		return (string[len - 1] == '\0' ? 1 : 0);
74 	} else {
75 		return (0);
76 	}
77 }
78 
79 /*
80  * Following sysevent_minor_* routines map
81  * a binding handle (evchan_t *) to a minor number
82  * Has to be called w/ locks held.
83  */
84 static ulong_t *
85 sysevent_minor_alloc(void)
86 {
87 	ulong_t *bhst = sysevent_minor_bitmap;
88 
89 	/* Increase bitmap by one BT_NBIPUL */
90 	if (sysevent_minor_bits + BT_NBIPUL > SYSEVENT_MINOR_MAX) {
91 		return ((ulong_t *)NULL);
92 	}
93 	sysevent_minor_bitmap = kmem_zalloc(
94 	    BT_SIZEOFMAP(sysevent_minor_bits + BT_NBIPUL), KM_SLEEP);
95 	bcopy(bhst, sysevent_minor_bitmap, BT_SIZEOFMAP(sysevent_minor_bits));
96 	if (bhst != &sysevent_bitmap_initial)
97 		kmem_free(bhst, BT_SIZEOFMAP(sysevent_minor_bits));
98 	sysevent_minor_bits += BT_NBIPUL;
99 
100 	return (sysevent_minor_bitmap);
101 }
102 
103 static void
104 sysevent_minor_free(ulong_t *bitmap)
105 {
106 	if (bitmap != &sysevent_bitmap_initial)
107 		kmem_free(bitmap, BT_SIZEOFMAP(sysevent_minor_bits));
108 }
109 
110 static index_t
111 sysevent_minor_get(void)
112 {
113 	index_t idx;
114 	ulong_t *bhst;
115 
116 	/* Search for an available index */
117 	mutex_enter(&sysevent_minor_mutex);
118 	if ((idx = bt_availbit(sysevent_minor_bitmap,
119 	    sysevent_minor_bits)) == -1) {
120 		/* All busy - allocate additional binding handle bitmap space */
121 		if ((bhst = sysevent_minor_alloc()) == NULL) {
122 			/* Reached our maximum of id's == SHRT_MAX */
123 			mutex_exit(&sysevent_minor_mutex);
124 			return (0);
125 		} else {
126 			sysevent_minor_bitmap = bhst;
127 		}
128 		idx = bt_availbit(sysevent_minor_bitmap, sysevent_minor_bits);
129 	}
130 	BT_SET(sysevent_minor_bitmap, idx);
131 	mutex_exit(&sysevent_minor_mutex);
132 	return (idx);
133 }
134 
135 static void
136 sysevent_minor_rele(index_t idx)
137 {
138 	mutex_enter(&sysevent_minor_mutex);
139 	ASSERT(BT_TEST(sysevent_minor_bitmap, idx) == 1);
140 	BT_CLEAR(sysevent_minor_bitmap, idx);
141 	mutex_exit(&sysevent_minor_mutex);
142 }
143 
144 static void
145 sysevent_minor_init(void)
146 {
147 	mutex_init(&sysevent_minor_mutex, NULL, MUTEX_DEFAULT, NULL);
148 }
149 
150 /* ARGSUSED */
151 static int
152 sysevent_publish(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
153 {
154 	int km_flags;
155 	sev_publish_args_t uargs;
156 	sysevent_impl_t *ev;
157 	evchan_ctl_t *ctl;
158 
159 	ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
160 	if (ctl == NULL || ctl->chp == NULL)
161 		return (ENXIO);
162 
163 	if (copyin(arg, &uargs, sizeof (sev_publish_args_t)) != 0)
164 		return (EFAULT);
165 
166 	/*
167 	 * This limits the size of an event
168 	 */
169 	if (uargs.ev.len > MAX_EV_SIZE_LEN)
170 		return (EOVERFLOW);
171 
172 	/*
173 	 * Check for valid uargs.flags
174 	 */
175 	if (uargs.flags & ~(EVCH_NOSLEEP | EVCH_SLEEP | EVCH_QWAIT))
176 		return (EINVAL);
177 
178 	/*
179 	 * Check that at least one of EVCH_NOSLEEP or EVCH_SLEEP is
180 	 * specified
181 	 */
182 	km_flags = uargs.flags & (EVCH_NOSLEEP | EVCH_SLEEP);
183 	if (km_flags != EVCH_NOSLEEP && km_flags != EVCH_SLEEP)
184 		return (EINVAL);
185 
186 	ev = evch_usrallocev(uargs.ev.len, uargs.flags);
187 
188 	if (copyin((void *)(uintptr_t)uargs.ev.name, ev, uargs.ev.len) != 0) {
189 		evch_usrfreeev(ev);
190 		return (EFAULT);
191 	}
192 
193 	return (evch_usrpostevent(ctl->chp, ev, uargs.flags));
194 
195 	/* Event will be freed internally */
196 }
197 
198 /*
199  * sysevent_chan_open - used to open a channel in the GPEC channel layer
200  */
201 
202 /* ARGSUSED */
203 static int
204 sysevent_chan_open(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
205 {
206 	sev_bind_args_t uargs;
207 	evchan_ctl_t *ctl;
208 	char *chan_name;
209 	int ec;
210 
211 	ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
212 	if (ctl == NULL) {
213 		return (ENXIO);
214 	}
215 
216 	if (copyin(arg, &uargs, sizeof (sev_bind_args_t)) != 0)
217 		return (EFAULT);
218 
219 	if (uargs.chan_name.len > MAX_CHNAME_LEN)
220 		return (EINVAL);
221 
222 	chan_name = kmem_alloc(uargs.chan_name.len, KM_SLEEP);
223 
224 	if (copyin((void *)(uintptr_t)uargs.chan_name.name, chan_name,
225 	    uargs.chan_name.len) != 0) {
226 		kmem_free(chan_name, uargs.chan_name.len);
227 		return (EFAULT);
228 	}
229 
230 	if (!sysevent_isstrend(chan_name, uargs.chan_name.len)) {
231 		kmem_free(chan_name, uargs.chan_name.len);
232 		return (EINVAL);
233 	}
234 
235 	/*
236 	 * Check of uargs.flags and uargs.perms just to avoid DoS attacks.
237 	 * libsysevent does this carefully
238 	 */
239 	ctl->chp = evch_usrchanopen((const char *)chan_name,
240 	    uargs.flags & EVCH_B_FLAGS, &ec);
241 
242 	kmem_free(chan_name, uargs.chan_name.len);
243 
244 	if (ec != 0) {
245 		return (ec);
246 	}
247 
248 	return (0);
249 }
250 
251 /* ARGSUSED */
252 static int
253 sysevent_chan_control(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
254 {
255 	sev_control_args_t uargs;
256 	evchan_ctl_t *ctl;
257 	int rc;
258 
259 	ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
260 	if (ctl == NULL || ctl->chp == NULL)
261 		return (ENXIO);
262 
263 	if (copyin(arg, &uargs, sizeof (sev_control_args_t)) != 0)
264 		return (EFAULT);
265 
266 	switch (uargs.cmd) {
267 	case EVCH_GET_CHAN_LEN:
268 	case EVCH_GET_CHAN_LEN_MAX:
269 		rc = evch_usrcontrol_get(ctl->chp, uargs.cmd, &uargs.value);
270 		if (rc == 0) {
271 			if (copyout((void *)&uargs, arg,
272 			    sizeof (sev_control_args_t)) != 0) {
273 				rc = EFAULT;
274 			}
275 		}
276 		break;
277 	case EVCH_SET_CHAN_LEN:
278 		rc = evch_usrcontrol_set(ctl->chp, uargs.cmd, uargs.value);
279 		break;
280 	default:
281 		rc = EINVAL;
282 	}
283 	return (rc);
284 }
285 
286 /* ARGSUSED */
287 static int
288 sysevent_subscribe(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
289 {
290 	sev_subscribe_args_t uargs;
291 	char *sid;
292 	char *class_info = NULL;
293 	evchan_ctl_t *ctl;
294 	int rc;
295 
296 	ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
297 	if (ctl == NULL || ctl->chp == NULL)
298 		return (ENXIO);
299 
300 	if (copyin(arg, &uargs, sizeof (sev_subscribe_args_t)) != 0)
301 		return (EFAULT);
302 
303 	if (uargs.sid.len > MAX_SUBID_LEN ||
304 	    uargs.class_info.len > MAX_CLASS_LEN)
305 		return (EINVAL);
306 
307 	sid = kmem_alloc(uargs.sid.len, KM_SLEEP);
308 	if (copyin((void *)(uintptr_t)uargs.sid.name,
309 	    sid, uargs.sid.len) != 0) {
310 		kmem_free(sid, uargs.sid.len);
311 		return (EFAULT);
312 	}
313 	if (!sysevent_isstrend(sid, uargs.sid.len)) {
314 		kmem_free(sid, uargs.sid.len);
315 		return (EINVAL);
316 	}
317 
318 	/* If class string empty then class EC_ALL is assumed */
319 	if (uargs.class_info.len != 0) {
320 		class_info = kmem_alloc(uargs.class_info.len, KM_SLEEP);
321 		if (copyin((void *)(uintptr_t)uargs.class_info.name, class_info,
322 		    uargs.class_info.len) != 0) {
323 			kmem_free(class_info, uargs.class_info.len);
324 			kmem_free(sid, uargs.sid.len);
325 			return (EFAULT);
326 		}
327 		if (!sysevent_isstrend(class_info, uargs.class_info.len)) {
328 			kmem_free(class_info, uargs.class_info.len);
329 			kmem_free(sid, uargs.sid.len);
330 			return (EINVAL);
331 		}
332 	}
333 
334 	/*
335 	 * Check of uargs.flags just to avoid DoS attacks
336 	 * libsysevent does this carefully.
337 	 */
338 	rc = evch_usrsubscribe(ctl->chp, sid, class_info,
339 	    (int)uargs.door_desc, uargs.flags);
340 
341 	kmem_free(class_info, uargs.class_info.len);
342 	kmem_free(sid, uargs.sid.len);
343 
344 	return (rc);
345 }
346 
347 /* ARGSUSED */
348 static int
349 sysevent_unsubscribe(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
350 {
351 	sev_unsubscribe_args_t uargs;
352 	char *sid;
353 	evchan_ctl_t *ctl;
354 
355 	if (copyin(arg, &uargs, sizeof (sev_unsubscribe_args_t)) != 0)
356 		return (EFAULT);
357 
358 	ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
359 	if (ctl == NULL || ctl->chp == NULL)
360 		return (ENXIO);
361 
362 	if (uargs.sid.len > MAX_SUBID_LEN)
363 		return (EINVAL);
364 
365 	/* Unsubscribe for all */
366 	if (uargs.sid.len == 0) {
367 		evch_usrunsubscribe(ctl->chp, NULL, 0);
368 		return (0);
369 	}
370 
371 	sid = kmem_alloc(uargs.sid.len, KM_SLEEP);
372 
373 	if (copyin((void *)(uintptr_t)uargs.sid.name,
374 	    sid, uargs.sid.len) != 0) {
375 		kmem_free(sid, uargs.sid.len);
376 		return (EFAULT);
377 	}
378 
379 	evch_usrunsubscribe(ctl->chp, sid, 0);
380 
381 	kmem_free(sid, uargs.sid.len);
382 
383 	return (0);
384 }
385 
386 /* ARGSUSED */
387 static int
388 sysevent_channames(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
389 {
390 	sev_chandata_args_t uargs;
391 	char *buf;
392 	int len;
393 	int rc = 0;
394 
395 	if (copyin(arg, &uargs, sizeof (sev_chandata_args_t)) != 0)
396 		return (EFAULT);
397 
398 	if (uargs.out_data.len == 0 || uargs.out_data.len > EVCH_MAX_DATA_SIZE)
399 		return (EINVAL);
400 
401 	buf = kmem_alloc(uargs.out_data.len, KM_SLEEP);
402 
403 	if ((len = evch_usrgetchnames(buf, uargs.out_data.len)) == -1) {
404 		rc = EOVERFLOW;
405 	}
406 
407 	if (rc == 0) {
408 		ASSERT(len <= uargs.out_data.len);
409 		if (copyout(buf,
410 		    (void *)(uintptr_t)uargs.out_data.name, len) != 0) {
411 			rc = EFAULT;
412 		}
413 	}
414 
415 	kmem_free(buf, uargs.out_data.len);
416 
417 	return (rc);
418 }
419 
420 /* ARGSUSED */
421 static int
422 sysevent_chandata(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
423 {
424 	sev_chandata_args_t uargs;
425 	char *channel;
426 	char *buf;
427 	int len;
428 	int rc = 0;
429 
430 	if (copyin(arg, &uargs, sizeof (sev_chandata_args_t)) != 0)
431 		return (EFAULT);
432 
433 	if (uargs.in_data.len > MAX_CHNAME_LEN ||
434 	    uargs.out_data.len > EVCH_MAX_DATA_SIZE)
435 		return (EINVAL);
436 
437 	channel = kmem_alloc(uargs.in_data.len, KM_SLEEP);
438 
439 	if (copyin((void *)(uintptr_t)uargs.in_data.name, channel,
440 	    uargs.in_data.len) != 0) {
441 		kmem_free(channel, uargs.in_data.len);
442 		return (EFAULT);
443 	}
444 
445 	if (!sysevent_isstrend(channel, uargs.in_data.len)) {
446 		kmem_free(channel, uargs.in_data.len);
447 		return (EINVAL);
448 	}
449 
450 	buf = kmem_alloc(uargs.out_data.len, KM_SLEEP);
451 
452 	len = evch_usrgetchdata(channel, buf, uargs.out_data.len);
453 	if (len == 0) {
454 		rc = EOVERFLOW;
455 	} else if (len == -1) {
456 		rc = ENOENT;
457 	}
458 
459 	if (rc == 0) {
460 		ASSERT(len <= uargs.out_data.len);
461 		if (copyout(buf,
462 		    (void *)(uintptr_t)uargs.out_data.name, len) != 0) {
463 			rc = EFAULT;
464 		}
465 	}
466 
467 	kmem_free(buf, uargs.out_data.len);
468 	kmem_free(channel, uargs.in_data.len);
469 
470 	return (rc);
471 }
472 
473 /* ARGSUSED */
474 static int
475 sysevent_setpropnvl(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
476 {
477 	sev_propnvl_args_t uargs;
478 	nvlist_t *nvl = NULL;
479 	evchan_ctl_t *ctl;
480 	size_t bufsz;
481 	char *buf;
482 
483 	ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
484 	if (ctl == NULL || ctl->chp == NULL)
485 		return (ENXIO);
486 
487 	if (copyin(arg, &uargs, sizeof (uargs)) != 0)
488 		return (EFAULT);
489 
490 	if (uargs.packednvl.name != 0) {
491 		bufsz = uargs.packednvl.len;
492 
493 		if (bufsz == 0)
494 			return (EINVAL);
495 
496 		if (bufsz > EVCH_MAX_DATA_SIZE)
497 			return (EOVERFLOW);
498 
499 		buf = kmem_alloc(bufsz, KM_SLEEP);
500 
501 		if (copyin((void *)(uintptr_t)uargs.packednvl.name, buf,
502 		    bufsz) != 0 ||
503 		    nvlist_unpack(buf, bufsz, &nvl, KM_SLEEP) != 0) {
504 			kmem_free(buf, bufsz);
505 			return (EFAULT);
506 		}
507 
508 		kmem_free(buf, bufsz);
509 
510 		if (nvl == NULL)
511 			return (EINVAL);
512 	}
513 
514 	evch_usrsetpropnvl(ctl->chp, nvl);
515 	return (0);
516 }
517 
518 /* ARGSUSED */
519 static int
520 sysevent_getpropnvl(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
521 {
522 	sev_propnvl_args_t uargs;
523 	size_t reqsz, avlsz;
524 	evchan_ctl_t *ctl;
525 	nvlist_t *nvl;
526 	int64_t gen;
527 	int rc;
528 
529 	ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
530 
531 	if (ctl == NULL || ctl->chp == NULL)
532 		return (ENXIO);
533 
534 	if (copyin(arg, &uargs, sizeof (uargs)) != 0)
535 		return (EFAULT);
536 
537 	if ((rc = evch_usrgetpropnvl(ctl->chp, &nvl, &gen)) != 0)
538 		return (rc);
539 
540 	if (nvl != NULL) {
541 		avlsz = uargs.packednvl.len;
542 
543 		if (nvlist_size(nvl, &reqsz, NV_ENCODE_NATIVE) != 0) {
544 			nvlist_free(nvl);
545 			return (EINVAL);
546 		}
547 
548 		if (reqsz > EVCH_MAX_DATA_SIZE) {
549 			nvlist_free(nvl);
550 			return (E2BIG);
551 		}
552 
553 		if (reqsz <= avlsz) {
554 			char *buf = kmem_alloc(reqsz, KM_SLEEP);
555 
556 			if (nvlist_pack(nvl, &buf, &reqsz,
557 			    NV_ENCODE_NATIVE, 0) != 0 || copyout(buf,
558 			    (void *)(uintptr_t)uargs.packednvl.name,
559 			    reqsz) != 0) {
560 				kmem_free(buf, reqsz);
561 				nvlist_free(nvl);
562 				return (EFAULT);
563 			}
564 			kmem_free(buf, reqsz);
565 			rc = 0;
566 		} else {
567 			rc = EOVERFLOW;
568 		}
569 		uargs.packednvl.len = (uint32_t)reqsz;
570 		nvlist_free(nvl);
571 	} else {
572 		uargs.packednvl.len = 0;
573 		rc = 0;
574 	}
575 
576 	uargs.generation = gen;
577 	if (copyout((void *)&uargs, arg, sizeof (uargs)) != 0)
578 		rc = EFAULT;
579 
580 	return (rc);
581 }
582 
583 /*ARGSUSED*/
584 static int
585 sysevent_ioctl(dev_t dev, int cmd, intptr_t arg,
586     int flag, cred_t *cr, int *rvalp)
587 {
588 	int rc;
589 
590 	switch (cmd) {
591 	case SEV_PUBLISH:
592 		rc = sysevent_publish(dev, rvalp, (void *)arg, flag, cr);
593 		break;
594 	case SEV_CHAN_OPEN:
595 		rc = sysevent_chan_open(dev, rvalp, (void *)arg, flag, cr);
596 		break;
597 	case SEV_CHAN_CONTROL:
598 		rc = sysevent_chan_control(dev, rvalp, (void *)arg, flag, cr);
599 		break;
600 	case SEV_SUBSCRIBE:
601 		rc = sysevent_subscribe(dev, rvalp, (void *)arg, flag, cr);
602 		break;
603 	case SEV_UNSUBSCRIBE:
604 		rc = sysevent_unsubscribe(dev, rvalp, (void *)arg, flag, cr);
605 		break;
606 	case SEV_CHANNAMES:
607 		rc = sysevent_channames(dev, rvalp, (void *)arg, flag, cr);
608 		break;
609 	case SEV_CHANDATA:
610 		rc = sysevent_chandata(dev, rvalp, (void *)arg, flag, cr);
611 		break;
612 	case SEV_SETPROPNVL:
613 		rc = sysevent_setpropnvl(dev, rvalp, (void *)arg, flag, cr);
614 		break;
615 	case SEV_GETPROPNVL:
616 		rc = sysevent_getpropnvl(dev, rvalp, (void *)arg, flag, cr);
617 		break;
618 	default:
619 		rc = EINVAL;
620 	}
621 
622 	return (rc);
623 }
624 
625 /*ARGSUSED*/
626 static int
627 sysevent_open(dev_t *devp, int flag, int otyp, cred_t *cr)
628 {
629 	int minor;
630 
631 	if (otyp != OTYP_CHR)
632 		return (EINVAL);
633 
634 	if (getminor(*devp) != 0)
635 		return (ENXIO);
636 
637 	minor = sysevent_minor_get();
638 	if (minor == 0)
639 		/* All minors are busy */
640 		return (EBUSY);
641 
642 	if (ddi_soft_state_zalloc(evchan_ctlp, minor)
643 	    != DDI_SUCCESS) {
644 		sysevent_minor_rele(minor);
645 		return (ENOMEM);
646 	}
647 
648 	*devp = makedevice(getmajor(*devp), minor);
649 
650 	return (0);
651 }
652 
653 /*ARGSUSED*/
654 static int
655 sysevent_close(dev_t dev, int flag, int otyp, cred_t *cr)
656 {
657 	int minor = (int)getminor(dev);
658 	evchan_ctl_t *ctl;
659 
660 	if (otyp != OTYP_CHR)
661 		return (EINVAL);
662 
663 	ctl = ddi_get_soft_state(evchan_ctlp, minor);
664 	if (ctl == NULL) {
665 		return (ENXIO);
666 	}
667 
668 	if (ctl->chp) {
669 		/* Release all non-persistant subscriptions */
670 		evch_usrunsubscribe(ctl->chp, NULL, EVCH_SUB_KEEP);
671 		evch_usrchanclose(ctl->chp);
672 	}
673 
674 	ddi_soft_state_free(evchan_ctlp, minor);
675 	sysevent_minor_rele(minor);
676 
677 	return (0);
678 }
679 
680 /* ARGSUSED */
681 static int
682 sysevent_info(dev_info_t *dip, ddi_info_cmd_t infocmd,
683     void *arg, void **result)
684 {
685 	switch (infocmd) {
686 	case DDI_INFO_DEVT2DEVINFO:
687 		*result = sysevent_devi;
688 		return (DDI_SUCCESS);
689 	case DDI_INFO_DEVT2INSTANCE:
690 		*result = 0;
691 		return (DDI_SUCCESS);
692 	}
693 	return (DDI_FAILURE);
694 }
695 
696 /* ARGSUSED */
697 static int
698 sysevent_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
699 {
700 
701 	if (cmd != DDI_ATTACH) {
702 		return (DDI_FAILURE);
703 	}
704 
705 	if (ddi_create_minor_node(devi, "sysevent", S_IFCHR,
706 	    0, DDI_PSEUDO, NULL) == DDI_FAILURE) {
707 		ddi_remove_minor_node(devi, NULL);
708 		return (DDI_FAILURE);
709 	}
710 	sysevent_devi = devi;
711 
712 	sysevent_minor_init();
713 
714 	return (DDI_SUCCESS);
715 }
716 
717 static int
718 sysevent_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
719 {
720 	if (cmd != DDI_DETACH) {
721 		return (DDI_FAILURE);
722 	}
723 
724 	sysevent_minor_free(sysevent_minor_bitmap);
725 	ddi_remove_minor_node(devi, NULL);
726 	return (DDI_SUCCESS);
727 }
728 
729 static struct cb_ops sysevent_cb_ops = {
730 	sysevent_open,		/* open */
731 	sysevent_close,		/* close */
732 	nodev,			/* strategy */
733 	nodev,			/* print */
734 	nodev,			/* dump */
735 	nodev,			/* read */
736 	nodev,			/* write */
737 	sysevent_ioctl,		/* ioctl */
738 	nodev,			/* devmap */
739 	nodev,			/* mmap */
740 	nodev,			/* segmap */
741 	nochpoll,		/* poll */
742 	ddi_prop_op,		/* prop_op */
743 	0,			/* streamtab  */
744 	D_NEW|D_MP,		/* flag */
745 	NULL,			/* aread */
746 	NULL			/* awrite */
747 };
748 
749 static struct dev_ops sysevent_ops = {
750 	DEVO_REV,		/* devo_rev */
751 	0,			/* refcnt  */
752 	sysevent_info,		/* info */
753 	nulldev,		/* identify */
754 	nulldev,		/* probe */
755 	sysevent_attach,	/* attach */
756 	sysevent_detach,	/* detach */
757 	nodev,			/* reset */
758 	&sysevent_cb_ops,	/* driver operations */
759 	(struct bus_ops *)0,	/* no bus operations */
760 	nulldev,		/* power */
761 	ddi_quiesce_not_needed,		/* quiesce */
762 };
763 
764 static struct modldrv modldrv = {
765 	&mod_driverops, "sysevent driver", &sysevent_ops
766 };
767 
768 static struct modlinkage modlinkage = {
769 	MODREV_1, &modldrv, NULL
770 };
771 
772 int
773 _init(void)
774 {
775 	int s;
776 
777 	s = ddi_soft_state_init(&evchan_ctlp, sizeof (evchan_ctl_t), 1);
778 	if (s != 0)
779 		return (s);
780 
781 	if ((s = mod_install(&modlinkage)) != 0)
782 		ddi_soft_state_fini(&evchan_ctlp);
783 	return (s);
784 }
785 
786 int
787 _fini(void)
788 {
789 	int s;
790 
791 	if ((s = mod_remove(&modlinkage)) != 0)
792 		return (s);
793 
794 	ddi_soft_state_fini(&evchan_ctlp);
795 	return (s);
796 }
797 
798 int
799 _info(struct modinfo *modinfop)
800 {
801 	return (mod_info(&modlinkage, modinfop));
802 }
803