Print this page
6659 nvlist_free(NULL) is a no-op
Split |
Close |
Expand all |
Collapse all |
--- old/usr/src/uts/common/os/evchannels.c
+++ new/usr/src/uts/common/os/evchannels.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 */
24 24
25 25 /*
26 26 * This file contains the source of the general purpose event channel extension
27 27 * to the sysevent framework. This implementation is made up mainly of four
28 28 * layers of functionality: the event queues (evch_evq_*()), the handling of
29 29 * channels (evch_ch*()), the kernel interface (sysevent_evc_*()) and the
30 30 * interface for the sysevent pseudo driver (evch_usr*()).
31 31 * Libsysevent.so uses the pseudo driver sysevent's ioctl to access the event
32 32 * channel extensions. The driver in turn uses the evch_usr*() functions below.
33 33 *
34 34 * The interfaces for user land and kernel are declared in sys/sysevent.h
35 35 * Internal data structures for event channels are defined in
36 36 * sys/sysevent_impl.h.
37 37 *
38 38 * The basic data structure for an event channel is of type evch_chan_t.
39 39 * All channels are maintained by a list named evch_list. The list head
40 40 * is of type evch_dlist_t.
41 41 */
42 42
43 43 #include <sys/types.h>
44 44 #include <sys/errno.h>
45 45 #include <sys/stropts.h>
46 46 #include <sys/debug.h>
47 47 #include <sys/ddi.h>
48 48 #include <sys/vmem.h>
49 49 #include <sys/cmn_err.h>
50 50 #include <sys/callb.h>
51 51 #include <sys/sysevent.h>
52 52 #include <sys/sysevent_impl.h>
53 53 #include <sys/sysmacros.h>
54 54 #include <sys/disp.h>
55 55 #include <sys/atomic.h>
56 56 #include <sys/door.h>
57 57 #include <sys/zone.h>
58 58 #include <sys/sdt.h>
59 59
60 60 /* Back-off delay for door_ki_upcall */
61 61 #define EVCH_MIN_PAUSE 8
62 62 #define EVCH_MAX_PAUSE 128
63 63
64 64 #define GEVENT(ev) ((evch_gevent_t *)((char *)ev - \
65 65 offsetof(evch_gevent_t, ge_payload)))
66 66
67 67 #define EVCH_EVQ_EVCOUNT(x) ((&(x)->eq_eventq)->sq_count)
68 68 #define EVCH_EVQ_HIGHWM(x) ((&(x)->eq_eventq)->sq_highwm)
69 69
70 70 #define CH_HOLD_PEND 1
71 71 #define CH_HOLD_PEND_INDEF 2
72 72
73 73 struct evch_globals {
74 74 evch_dlist_t evch_list;
75 75 kmutex_t evch_list_lock;
76 76 };
77 77
78 78 /* Variables used by event channel routines */
79 79 static int evq_initcomplete = 0;
80 80 static zone_key_t evch_zone_key;
81 81 static uint32_t evch_channels_max;
82 82 static uint32_t evch_bindings_max = EVCH_MAX_BINDS_PER_CHANNEL;
83 83 static uint32_t evch_events_max;
84 84
85 85 static void evch_evq_unsub(evch_eventq_t *, evch_evqsub_t *);
86 86 static void evch_evq_destroy(evch_eventq_t *);
87 87
88 88 /*
89 89 * List handling. These functions handle a doubly linked list. The list has
90 90 * to be protected by the calling functions. evch_dlist_t is the list head.
91 91 * Every node of the list has to put a evch_dlelem_t data type in its data
92 92 * structure as its first element.
93 93 *
94 94 * evch_dl_init - Initialize list head
95 95 * evch_dl_fini - Terminate list handling
96 96 * evch_dl_is_init - Returns one if list is initialized
97 97 * evch_dl_add - Add element to end of list
98 98 * evch_dl_del - Remove given element from list
99 99 * evch_dl_search - Lookup element in list
100 100 * evch_dl_getnum - Get number of elements in list
101 101 * evch_dl_next - Get next elements of list
102 102 */
103 103
104 104 static void
105 105 evch_dl_init(evch_dlist_t *hp)
106 106 {
107 107 hp->dh_head.dl_prev = hp->dh_head.dl_next = &hp->dh_head;
108 108 hp->dh_count = 0;
109 109 }
110 110
111 111 /*
112 112 * Assumes that list is empty.
113 113 */
114 114 static void
115 115 evch_dl_fini(evch_dlist_t *hp)
116 116 {
117 117 hp->dh_head.dl_prev = hp->dh_head.dl_next = NULL;
118 118 }
119 119
120 120 static int
121 121 evch_dl_is_init(evch_dlist_t *hp)
122 122 {
123 123 return (hp->dh_head.dl_next != NULL ? 1 : 0);
124 124 }
125 125
126 126 /*
127 127 * Add an element at the end of the list.
128 128 */
129 129 static void
130 130 evch_dl_add(evch_dlist_t *hp, evch_dlelem_t *el)
131 131 {
132 132 evch_dlelem_t *x = hp->dh_head.dl_prev;
133 133 evch_dlelem_t *y = &hp->dh_head;
134 134
135 135 x->dl_next = el;
136 136 y->dl_prev = el;
137 137 el->dl_next = y;
138 138 el->dl_prev = x;
139 139 hp->dh_count++;
140 140 }
141 141
142 142 /*
143 143 * Remove arbitrary element out of dlist.
144 144 */
145 145 static void
146 146 evch_dl_del(evch_dlist_t *hp, evch_dlelem_t *p)
147 147 {
148 148 ASSERT(hp->dh_count > 0 && p != &hp->dh_head);
149 149 p->dl_prev->dl_next = p->dl_next;
150 150 p->dl_next->dl_prev = p->dl_prev;
151 151 p->dl_prev = NULL;
152 152 p->dl_next = NULL;
153 153 hp->dh_count--;
154 154 }
155 155
156 156 /*
157 157 * Search an element in a list. Caller provides comparison callback function.
158 158 */
159 159 static evch_dlelem_t *
160 160 evch_dl_search(evch_dlist_t *hp, int (*cmp)(evch_dlelem_t *, char *), char *s)
161 161 {
162 162 evch_dlelem_t *p;
163 163
164 164 for (p = hp->dh_head.dl_next; p != &hp->dh_head; p = p->dl_next) {
165 165 if (cmp(p, s) == 0) {
166 166 return (p);
167 167 }
168 168 }
169 169 return (NULL);
170 170 }
171 171
172 172 /*
173 173 * Return number of elements in the list.
174 174 */
175 175 static int
176 176 evch_dl_getnum(evch_dlist_t *hp)
177 177 {
178 178 return (hp->dh_count);
179 179 }
180 180
181 181 /*
182 182 * Find next element of a evch_dlist_t list. Find first element if el == NULL.
183 183 * Returns NULL if end of list is reached.
184 184 */
185 185 static void *
186 186 evch_dl_next(evch_dlist_t *hp, void *el)
187 187 {
188 188 evch_dlelem_t *ep = (evch_dlelem_t *)el;
189 189
190 190 if (hp->dh_count == 0) {
191 191 return (NULL);
192 192 }
193 193 if (ep == NULL) {
194 194 return (hp->dh_head.dl_next);
195 195 }
196 196 if ((ep = ep->dl_next) == (evch_dlelem_t *)hp) {
197 197 return (NULL);
198 198 }
199 199 return ((void *)ep);
200 200 }
201 201
202 202 /*
203 203 * Queue handling routines. Mutexes have to be entered previously.
204 204 *
205 205 * evch_q_init - Initialize queue head
206 206 * evch_q_in - Put element into queue
207 207 * evch_q_out - Get element out of queue
208 208 * evch_q_next - Iterate over the elements of a queue
209 209 */
210 210 static void
211 211 evch_q_init(evch_squeue_t *q)
212 212 {
213 213 q->sq_head = NULL;
214 214 q->sq_tail = (evch_qelem_t *)q;
215 215 q->sq_count = 0;
216 216 q->sq_highwm = 0;
217 217 }
218 218
219 219 /*
220 220 * Put element into the queue q
221 221 */
222 222 static void
223 223 evch_q_in(evch_squeue_t *q, evch_qelem_t *el)
224 224 {
225 225 q->sq_tail->q_next = el;
226 226 el->q_next = NULL;
227 227 q->sq_tail = el;
228 228 q->sq_count++;
229 229 if (q->sq_count > q->sq_highwm) {
230 230 q->sq_highwm = q->sq_count;
231 231 }
232 232 }
233 233
234 234 /*
235 235 * Returns NULL if queue is empty.
236 236 */
237 237 static evch_qelem_t *
238 238 evch_q_out(evch_squeue_t *q)
239 239 {
240 240 evch_qelem_t *el;
241 241
242 242 if ((el = q->sq_head) != NULL) {
243 243 q->sq_head = el->q_next;
244 244 q->sq_count--;
245 245 if (q->sq_head == NULL) {
246 246 q->sq_tail = (evch_qelem_t *)q;
247 247 }
248 248 }
249 249 return (el);
250 250 }
251 251
252 252 /*
253 253 * Returns element after *el or first if el == NULL. NULL is returned
254 254 * if queue is empty or *el points to the last element in the queue.
255 255 */
256 256 static evch_qelem_t *
257 257 evch_q_next(evch_squeue_t *q, evch_qelem_t *el)
258 258 {
259 259 if (el == NULL)
260 260 return (q->sq_head);
261 261 return (el->q_next);
262 262 }
263 263
264 264 /*
265 265 * Event queue handling functions. An event queue is the basic building block
266 266 * of an event channel. One event queue makes up the publisher-side event queue.
267 267 * Further event queues build the per-subscriber queues of an event channel.
268 268 * Each queue is associated an event delivery thread.
269 269 * These functions support a two-step initialization. First step, when kernel
270 270 * memory is ready and second when threads are ready.
271 271 * Events consist of an administrating evch_gevent_t structure with the event
272 272 * data appended as variable length payload.
273 273 * The internal interface functions for the event queue handling are:
274 274 *
275 275 * evch_evq_create - create an event queue
276 276 * evch_evq_thrcreate - create thread for an event queue.
277 277 * evch_evq_destroy - delete an event queue
278 278 * evch_evq_sub - Subscribe to event delivery from an event queue
279 279 * evch_evq_unsub - Unsubscribe
280 280 * evch_evq_pub - Post an event into an event queue
281 281 * evch_evq_stop - Put delivery thread on hold
282 282 * evch_evq_continue - Resume event delivery thread
283 283 * evch_evq_status - Return status of delivery thread, running or on hold
284 284 * evch_evq_evzalloc - Allocate an event structure
285 285 * evch_evq_evfree - Free an event structure
286 286 * evch_evq_evadd_dest - Add a destructor function to an event structure
287 287 * evch_evq_evnext - Iterate over events non-destructive
288 288 */
289 289
290 290 /*ARGSUSED*/
291 291 static void *
292 292 evch_zoneinit(zoneid_t zoneid)
293 293 {
294 294 struct evch_globals *eg;
295 295
296 296 eg = kmem_zalloc(sizeof (*eg), KM_SLEEP);
297 297 evch_dl_init(&eg->evch_list);
298 298 return (eg);
299 299 }
300 300
301 301 /*ARGSUSED*/
302 302 static void
303 303 evch_zonefree(zoneid_t zoneid, void *arg)
304 304 {
305 305 struct evch_globals *eg = arg;
306 306 evch_chan_t *chp;
307 307 evch_subd_t *sdp;
308 308
309 309 mutex_enter(&eg->evch_list_lock);
310 310
311 311 /*
312 312 * Keep picking the head element off the list until there are no
313 313 * more.
314 314 */
315 315 while ((chp = evch_dl_next(&eg->evch_list, NULL)) != NULL) {
316 316
317 317 /*
318 318 * Since all processes are gone, all bindings should be gone,
319 319 * and only channels with SUB_KEEP subscribers should remain.
320 320 */
321 321 mutex_enter(&chp->ch_mutex);
322 322 ASSERT(chp->ch_bindings == 0);
323 323 ASSERT(evch_dl_getnum(&chp->ch_subscr) != 0 ||
324 324 chp->ch_holdpend == CH_HOLD_PEND_INDEF);
325 325
326 326 /* Forcibly unsubscribe each remaining subscription */
327 327 while ((sdp = evch_dl_next(&chp->ch_subscr, NULL)) != NULL) {
328 328 /*
329 329 * We should only be tearing down persistent
330 330 * subscribers at this point, since all processes
331 331 * from this zone are gone.
332 332 */
333 333 ASSERT(sdp->sd_active == 0);
334 334 ASSERT((sdp->sd_persist & EVCH_SUB_KEEP) != 0);
335 335 /*
336 336 * Disconnect subscriber queue from main event queue.
337 337 */
338 338 evch_evq_unsub(chp->ch_queue, sdp->sd_msub);
339 339
340 340 /* Destruct per subscriber queue */
341 341 evch_evq_unsub(sdp->sd_queue, sdp->sd_ssub);
342 342 evch_evq_destroy(sdp->sd_queue);
343 343 /*
344 344 * Eliminate the subscriber data from channel list.
345 345 */
346 346 evch_dl_del(&chp->ch_subscr, &sdp->sd_link);
347 347 kmem_free(sdp->sd_classname, sdp->sd_clnsize);
348 348 kmem_free(sdp->sd_ident, strlen(sdp->sd_ident) + 1);
349 349 kmem_free(sdp, sizeof (evch_subd_t));
350 350 }
351 351
352 352 /* Channel must now have no subscribers */
353 353 ASSERT(evch_dl_getnum(&chp->ch_subscr) == 0);
354 354
355 355 /* Just like unbind */
356 356 mutex_exit(&chp->ch_mutex);
357 357 evch_dl_del(&eg->evch_list, &chp->ch_link);
358 358 evch_evq_destroy(chp->ch_queue);
359 359 mutex_destroy(&chp->ch_mutex);
360 360 mutex_destroy(&chp->ch_pubmx);
361 361 cv_destroy(&chp->ch_pubcv);
362 362 kmem_free(chp->ch_name, chp->ch_namelen);
363 363 kmem_free(chp, sizeof (evch_chan_t));
364 364 }
365 365
366 366 mutex_exit(&eg->evch_list_lock);
367 367 /* all channels should now be gone */
368 368 ASSERT(evch_dl_getnum(&eg->evch_list) == 0);
369 369 kmem_free(eg, sizeof (*eg));
370 370 }
371 371
372 372 /*
373 373 * Frees evch_gevent_t structure including the payload, if the reference count
374 374 * drops to or below zero. Below zero happens when the event is freed
375 375 * without beeing queued into a queue.
376 376 */
377 377 static void
378 378 evch_gevent_free(evch_gevent_t *evp)
379 379 {
380 380 int32_t refcnt;
381 381
382 382 refcnt = (int32_t)atomic_dec_32_nv(&evp->ge_refcount);
383 383 if (refcnt <= 0) {
384 384 if (evp->ge_destruct != NULL) {
385 385 evp->ge_destruct((void *)&(evp->ge_payload),
386 386 evp->ge_dstcookie);
387 387 }
388 388 kmem_free(evp, evp->ge_size);
389 389 }
390 390 }
391 391
392 392 /*
393 393 * Deliver is called for every subscription to the current event
394 394 * It calls the registered filter function and then the registered delivery
395 395 * callback routine. Returns 0 on success. The callback routine returns
396 396 * EVQ_AGAIN or EVQ_SLEEP in case the event could not be delivered.
397 397 */
398 398 static int
399 399 evch_deliver(evch_evqsub_t *sp, evch_gevent_t *ep)
400 400 {
401 401 void *uep = &ep->ge_payload;
402 402 int res = EVQ_DELIVER;
403 403
404 404 if (sp->su_filter != NULL) {
405 405 res = sp->su_filter(uep, sp->su_fcookie);
406 406 }
407 407 if (res == EVQ_DELIVER) {
408 408 return (sp->su_callb(uep, sp->su_cbcookie));
409 409 }
410 410 return (0);
411 411 }
412 412
413 413 /*
414 414 * Holds event delivery in case of eq_holdmode set or in case the
415 415 * event queue is empty. Mutex must be held when called.
416 416 * Wakes up a thread waiting for the delivery thread reaching the hold mode.
417 417 */
418 418 static void
419 419 evch_delivery_hold(evch_eventq_t *eqp, callb_cpr_t *cpip)
420 420 {
421 421 if (eqp->eq_tabortflag == 0) {
422 422 do {
423 423 if (eqp->eq_holdmode) {
424 424 cv_signal(&eqp->eq_onholdcv);
425 425 }
426 426 CALLB_CPR_SAFE_BEGIN(cpip);
427 427 cv_wait(&eqp->eq_thrsleepcv, &eqp->eq_queuemx);
428 428 CALLB_CPR_SAFE_END(cpip, &eqp->eq_queuemx);
429 429 } while (eqp->eq_holdmode);
430 430 }
431 431 }
432 432
433 433 /*
434 434 * Event delivery thread. Enumerates all subscribers and calls evch_deliver()
435 435 * for each one.
436 436 */
437 437 static void
438 438 evch_delivery_thr(evch_eventq_t *eqp)
439 439 {
440 440 evch_qelem_t *qep;
441 441 callb_cpr_t cprinfo;
442 442 int res;
443 443 evch_evqsub_t *sub;
444 444 int deltime;
445 445 int repeatcount;
446 446 char thnam[32];
447 447
448 448 (void) snprintf(thnam, sizeof (thnam), "sysevent_chan-%d",
449 449 (int)eqp->eq_thrid);
450 450 CALLB_CPR_INIT(&cprinfo, &eqp->eq_queuemx, callb_generic_cpr, thnam);
451 451 mutex_enter(&eqp->eq_queuemx);
452 452 while (eqp->eq_tabortflag == 0) {
453 453 while (eqp->eq_holdmode == 0 && eqp->eq_tabortflag == 0 &&
454 454 (qep = evch_q_out(&eqp->eq_eventq)) != NULL) {
455 455
456 456 /* Filter and deliver event to all subscribers */
457 457 deltime = EVCH_MIN_PAUSE;
458 458 repeatcount = EVCH_MAX_TRY_DELIVERY;
459 459 eqp->eq_curevent = qep->q_objref;
460 460 sub = evch_dl_next(&eqp->eq_subscr, NULL);
461 461 while (sub != NULL) {
462 462 eqp->eq_dactive = 1;
463 463 mutex_exit(&eqp->eq_queuemx);
464 464 res = evch_deliver(sub, qep->q_objref);
465 465 mutex_enter(&eqp->eq_queuemx);
466 466 eqp->eq_dactive = 0;
467 467 cv_signal(&eqp->eq_dactivecv);
468 468 switch (res) {
469 469 case EVQ_SLEEP:
470 470 /*
471 471 * Wait for subscriber to return.
472 472 */
473 473 eqp->eq_holdmode = 1;
474 474 evch_delivery_hold(eqp, &cprinfo);
475 475 if (eqp->eq_tabortflag) {
476 476 break;
477 477 }
478 478 continue;
479 479 case EVQ_AGAIN:
480 480 CALLB_CPR_SAFE_BEGIN(&cprinfo);
481 481 mutex_exit(&eqp->eq_queuemx);
482 482 delay(deltime);
483 483 deltime =
484 484 deltime > EVCH_MAX_PAUSE ?
485 485 deltime : deltime << 1;
486 486 mutex_enter(&eqp->eq_queuemx);
487 487 CALLB_CPR_SAFE_END(&cprinfo,
488 488 &eqp->eq_queuemx);
489 489 if (repeatcount-- > 0) {
490 490 continue;
491 491 }
492 492 break;
493 493 }
494 494 if (eqp->eq_tabortflag) {
495 495 break;
496 496 }
497 497 sub = evch_dl_next(&eqp->eq_subscr, sub);
498 498 repeatcount = EVCH_MAX_TRY_DELIVERY;
499 499 }
500 500 eqp->eq_curevent = NULL;
501 501
502 502 /* Free event data and queue element */
503 503 evch_gevent_free((evch_gevent_t *)qep->q_objref);
504 504 kmem_free(qep, qep->q_objsize);
505 505 }
506 506
507 507 /* Wait for next event or end of hold mode if set */
508 508 evch_delivery_hold(eqp, &cprinfo);
509 509 }
510 510 CALLB_CPR_EXIT(&cprinfo); /* Does mutex_exit of eqp->eq_queuemx */
511 511 thread_exit();
512 512 }
513 513
514 514 /*
515 515 * Create the event delivery thread for an existing event queue.
516 516 */
517 517 static void
518 518 evch_evq_thrcreate(evch_eventq_t *eqp)
519 519 {
520 520 kthread_t *thp;
521 521
522 522 thp = thread_create(NULL, 0, evch_delivery_thr, (char *)eqp, 0, &p0,
523 523 TS_RUN, minclsyspri);
524 524 eqp->eq_thrid = thp->t_did;
525 525 }
526 526
527 527 /*
528 528 * Create event queue.
529 529 */
530 530 static evch_eventq_t *
531 531 evch_evq_create()
532 532 {
533 533 evch_eventq_t *p;
534 534
535 535 /* Allocate and initialize event queue descriptor */
536 536 p = kmem_zalloc(sizeof (evch_eventq_t), KM_SLEEP);
537 537 mutex_init(&p->eq_queuemx, NULL, MUTEX_DEFAULT, NULL);
538 538 cv_init(&p->eq_thrsleepcv, NULL, CV_DEFAULT, NULL);
539 539 evch_q_init(&p->eq_eventq);
540 540 evch_dl_init(&p->eq_subscr);
541 541 cv_init(&p->eq_dactivecv, NULL, CV_DEFAULT, NULL);
542 542 cv_init(&p->eq_onholdcv, NULL, CV_DEFAULT, NULL);
543 543
544 544 /* Create delivery thread */
545 545 if (evq_initcomplete) {
546 546 evch_evq_thrcreate(p);
547 547 }
548 548 return (p);
549 549 }
550 550
551 551 /*
552 552 * Destroy an event queue. All subscribers have to be unsubscribed prior to
553 553 * this call.
554 554 */
555 555 static void
556 556 evch_evq_destroy(evch_eventq_t *eqp)
557 557 {
558 558 evch_qelem_t *qep;
559 559
560 560 ASSERT(evch_dl_getnum(&eqp->eq_subscr) == 0);
561 561 /* Kill delivery thread */
562 562 if (eqp->eq_thrid != NULL) {
563 563 mutex_enter(&eqp->eq_queuemx);
564 564 eqp->eq_tabortflag = 1;
565 565 eqp->eq_holdmode = 0;
566 566 cv_signal(&eqp->eq_thrsleepcv);
567 567 mutex_exit(&eqp->eq_queuemx);
568 568 thread_join(eqp->eq_thrid);
569 569 }
570 570
571 571 /* Get rid of stale events in the event queue */
572 572 while ((qep = (evch_qelem_t *)evch_q_out(&eqp->eq_eventq)) != NULL) {
573 573 evch_gevent_free((evch_gevent_t *)qep->q_objref);
574 574 kmem_free(qep, qep->q_objsize);
575 575 }
576 576
577 577 /* Wrap up event queue structure */
578 578 cv_destroy(&eqp->eq_onholdcv);
579 579 cv_destroy(&eqp->eq_dactivecv);
580 580 cv_destroy(&eqp->eq_thrsleepcv);
581 581 evch_dl_fini(&eqp->eq_subscr);
582 582 mutex_destroy(&eqp->eq_queuemx);
583 583
584 584 /* Free descriptor structure */
585 585 kmem_free(eqp, sizeof (evch_eventq_t));
586 586 }
587 587
588 588 /*
589 589 * Subscribe to an event queue. Every subscriber provides a filter callback
590 590 * routine and an event delivery callback routine.
591 591 */
592 592 static evch_evqsub_t *
593 593 evch_evq_sub(evch_eventq_t *eqp, filter_f filter, void *fcookie,
594 594 deliver_f callb, void *cbcookie)
595 595 {
596 596 evch_evqsub_t *sp = kmem_zalloc(sizeof (evch_evqsub_t), KM_SLEEP);
597 597
598 598 /* Initialize subscriber structure */
599 599 sp->su_filter = filter;
600 600 sp->su_fcookie = fcookie;
601 601 sp->su_callb = callb;
602 602 sp->su_cbcookie = cbcookie;
603 603
604 604 /* Add subscription to queue */
605 605 mutex_enter(&eqp->eq_queuemx);
606 606 evch_dl_add(&eqp->eq_subscr, &sp->su_link);
607 607 mutex_exit(&eqp->eq_queuemx);
608 608 return (sp);
609 609 }
610 610
611 611 /*
612 612 * Unsubscribe from an event queue.
613 613 */
614 614 static void
615 615 evch_evq_unsub(evch_eventq_t *eqp, evch_evqsub_t *sp)
616 616 {
617 617 mutex_enter(&eqp->eq_queuemx);
618 618
619 619 /* Wait if delivery is just in progress */
620 620 if (eqp->eq_dactive) {
621 621 cv_wait(&eqp->eq_dactivecv, &eqp->eq_queuemx);
622 622 }
623 623 evch_dl_del(&eqp->eq_subscr, &sp->su_link);
624 624 mutex_exit(&eqp->eq_queuemx);
625 625 kmem_free(sp, sizeof (evch_evqsub_t));
626 626 }
627 627
628 628 /*
629 629 * Publish an event. Returns 0 on success and -1 if memory alloc failed.
630 630 */
631 631 static int
632 632 evch_evq_pub(evch_eventq_t *eqp, void *ev, int flags)
633 633 {
634 634 size_t size;
635 635 evch_qelem_t *qep;
636 636 evch_gevent_t *evp = GEVENT(ev);
637 637
638 638 size = sizeof (evch_qelem_t);
639 639 if (flags & EVCH_TRYHARD) {
640 640 qep = kmem_alloc_tryhard(size, &size, KM_NOSLEEP);
641 641 } else {
642 642 qep = kmem_alloc(size, flags & EVCH_NOSLEEP ?
643 643 KM_NOSLEEP : KM_SLEEP);
644 644 }
645 645 if (qep == NULL) {
646 646 return (-1);
647 647 }
648 648 qep->q_objref = (void *)evp;
649 649 qep->q_objsize = size;
650 650 atomic_inc_32(&evp->ge_refcount);
651 651 mutex_enter(&eqp->eq_queuemx);
652 652 evch_q_in(&eqp->eq_eventq, qep);
653 653
654 654 /* Wakeup delivery thread */
655 655 cv_signal(&eqp->eq_thrsleepcv);
656 656 mutex_exit(&eqp->eq_queuemx);
657 657 return (0);
658 658 }
659 659
660 660 /*
661 661 * Enter hold mode of an event queue. Event delivery thread stops event
662 662 * handling after delivery of current event (if any).
663 663 */
664 664 static void
665 665 evch_evq_stop(evch_eventq_t *eqp)
666 666 {
667 667 mutex_enter(&eqp->eq_queuemx);
668 668 eqp->eq_holdmode = 1;
669 669 if (evq_initcomplete) {
670 670 cv_signal(&eqp->eq_thrsleepcv);
671 671 cv_wait(&eqp->eq_onholdcv, &eqp->eq_queuemx);
672 672 }
673 673 mutex_exit(&eqp->eq_queuemx);
674 674 }
675 675
676 676 /*
677 677 * Continue event delivery.
678 678 */
679 679 static void
680 680 evch_evq_continue(evch_eventq_t *eqp)
681 681 {
682 682 mutex_enter(&eqp->eq_queuemx);
683 683 eqp->eq_holdmode = 0;
684 684 cv_signal(&eqp->eq_thrsleepcv);
685 685 mutex_exit(&eqp->eq_queuemx);
686 686 }
687 687
688 688 /*
689 689 * Returns status of delivery thread. 0 if running and 1 if on hold.
690 690 */
691 691 static int
692 692 evch_evq_status(evch_eventq_t *eqp)
693 693 {
694 694 return (eqp->eq_holdmode);
695 695 }
696 696
697 697 /*
698 698 * Add a destructor function to an event structure.
699 699 */
700 700 static void
701 701 evch_evq_evadd_dest(void *ev, destr_f destructor, void *cookie)
702 702 {
703 703 evch_gevent_t *evp = GEVENT(ev);
704 704
705 705 evp->ge_destruct = destructor;
706 706 evp->ge_dstcookie = cookie;
707 707 }
708 708
709 709 /*
710 710 * Allocate evch_gevent_t structure. Return address of payload offset of
711 711 * evch_gevent_t. If EVCH_TRYHARD allocation is requested, we use
712 712 * kmem_alloc_tryhard to alloc memory of at least paylsize bytes.
713 713 *
714 714 * If either memory allocation is unsuccessful, we return NULL.
715 715 */
716 716 static void *
717 717 evch_evq_evzalloc(size_t paylsize, int flag)
718 718 {
719 719 evch_gevent_t *evp;
720 720 size_t rsize, evsize, ge_size;
721 721
722 722 rsize = offsetof(evch_gevent_t, ge_payload) + paylsize;
723 723 if (flag & EVCH_TRYHARD) {
724 724 evp = kmem_alloc_tryhard(rsize, &evsize, KM_NOSLEEP);
725 725 ge_size = evsize;
726 726 } else {
727 727 evp = kmem_alloc(rsize, flag & EVCH_NOSLEEP ? KM_NOSLEEP :
728 728 KM_SLEEP);
729 729 ge_size = rsize;
730 730 }
731 731
732 732 if (evp) {
733 733 bzero(evp, rsize);
734 734 evp->ge_size = ge_size;
735 735 return (&evp->ge_payload);
736 736 }
737 737 return (evp);
738 738 }
739 739
740 740 /*
741 741 * Free event structure. Argument ev is address of payload offset.
742 742 */
743 743 static void
744 744 evch_evq_evfree(void *ev)
745 745 {
746 746 evch_gevent_free(GEVENT(ev));
747 747 }
748 748
749 749 /*
750 750 * Iterate over all events in the event queue. Begin with an event
751 751 * which is currently being delivered. No mutexes are grabbed and no
752 752 * resources allocated so that this function can be called in panic
753 753 * context too. This function has to be called with ev == NULL initially.
754 754 * Actually argument ev is only a flag. Internally the member eq_nextev
755 755 * is used to determine the next event. But ev allows for the convenient
756 756 * use like
757 757 * ev = NULL;
758 758 * while ((ev = evch_evq_evnext(evp, ev)) != NULL) ...
759 759 */
760 760 static void *
761 761 evch_evq_evnext(evch_eventq_t *evq, void *ev)
762 762 {
763 763 if (ev == NULL) {
764 764 evq->eq_nextev = NULL;
765 765 if (evq->eq_curevent != NULL)
766 766 return (&evq->eq_curevent->ge_payload);
767 767 }
768 768 evq->eq_nextev = evch_q_next(&evq->eq_eventq, evq->eq_nextev);
769 769 if (evq->eq_nextev == NULL)
770 770 return (NULL);
771 771 return (&((evch_gevent_t *)evq->eq_nextev->q_objref)->ge_payload);
772 772 }
773 773
774 774 /*
775 775 * Channel handling functions. First some support functions. Functions belonging
776 776 * to the channel handling interface start with evch_ch. The following functions
777 777 * make up the channel handling internal interfaces:
778 778 *
779 779 * evch_chinit - Initialize channel handling
780 780 * evch_chinitthr - Second step init: initialize threads
781 781 * evch_chbind - Bind to a channel
782 782 * evch_chunbind - Unbind from a channel
783 783 * evch_chsubscribe - Subscribe to a sysevent class
784 784 * evch_chunsubscribe - Unsubscribe
785 785 * evch_chpublish - Publish an event
786 786 * evch_chgetnames - Get names of all channels
787 787 * evch_chgetchdata - Get data of a channel
788 788 * evch_chrdevent_init - Init event q traversal
789 789 * evch_chgetnextev - Read out events queued for a subscriber
790 790 * evch_chrdevent_fini - Finish event q traversal
791 791 */
792 792
793 793 /*
794 794 * Compare channel name. Used for evch_dl_search to find a channel with the
795 795 * name s.
796 796 */
797 797 static int
798 798 evch_namecmp(evch_dlelem_t *ep, char *s)
799 799 {
800 800 return (strcmp(((evch_chan_t *)ep)->ch_name, s));
801 801 }
802 802
803 803 /*
804 804 * Simple wildcarded match test of event class string 'class' to
805 805 * wildcarded subscription string 'pat'. Recursive only if
806 806 * 'pat' includes a wildcard, otherwise essentially just strcmp.
807 807 */
808 808 static int
809 809 evch_clsmatch(char *class, const char *pat)
810 810 {
811 811 char c;
812 812
813 813 do {
814 814 if ((c = *pat++) == '\0')
815 815 return (*class == '\0');
816 816
817 817 if (c == '*') {
818 818 while (*pat == '*')
819 819 pat++; /* consecutive *'s can be collapsed */
820 820
821 821 if (*pat == '\0')
822 822 return (1);
823 823
824 824 while (*class != '\0') {
825 825 if (evch_clsmatch(class++, pat) != 0)
826 826 return (1);
827 827 }
828 828
829 829 return (0);
830 830 }
831 831 } while (c == *class++);
832 832
833 833 return (0);
834 834 }
835 835
836 836 /*
837 837 * Sysevent filter callback routine. Enables event delivery only if it matches
838 838 * the event class pattern string given by parameter cookie.
839 839 */
840 840 static int
841 841 evch_class_filter(void *ev, void *cookie)
842 842 {
843 843 const char *pat = (const char *)cookie;
844 844
845 845 if (pat == NULL || evch_clsmatch(SE_CLASS_NAME(ev), pat))
846 846 return (EVQ_DELIVER);
847 847
848 848 return (EVQ_IGNORE);
849 849 }
850 850
851 851 /*
852 852 * Callback routine to propagate the event into a per subscriber queue.
853 853 */
854 854 static int
855 855 evch_subq_deliver(void *evp, void *cookie)
856 856 {
857 857 evch_subd_t *p = (evch_subd_t *)cookie;
858 858
859 859 (void) evch_evq_pub(p->sd_queue, evp, EVCH_SLEEP);
860 860 return (EVQ_CONT);
861 861 }
862 862
863 863 /*
864 864 * Call kernel callback routine for sysevent kernel delivery.
865 865 */
866 866 static int
867 867 evch_kern_deliver(void *evp, void *cookie)
868 868 {
869 869 sysevent_impl_t *ev = (sysevent_impl_t *)evp;
870 870 evch_subd_t *sdp = (evch_subd_t *)cookie;
871 871
872 872 return (sdp->sd_callback(ev, sdp->sd_cbcookie));
873 873 }
874 874
875 875 /*
876 876 * Door upcall for user land sysevent delivery.
877 877 */
878 878 static int
879 879 evch_door_deliver(void *evp, void *cookie)
880 880 {
881 881 int error;
882 882 size_t size;
883 883 sysevent_impl_t *ev = (sysevent_impl_t *)evp;
884 884 door_arg_t darg;
885 885 evch_subd_t *sdp = (evch_subd_t *)cookie;
886 886 int nticks = EVCH_MIN_PAUSE;
887 887 uint32_t retval;
888 888 int retry = 20;
889 889
890 890 /* Initialize door args */
891 891 size = sizeof (sysevent_impl_t) + SE_PAYLOAD_SZ(ev);
892 892
893 893 darg.rbuf = (char *)&retval;
894 894 darg.rsize = sizeof (retval);
895 895 darg.data_ptr = (char *)ev;
896 896 darg.data_size = size;
897 897 darg.desc_ptr = NULL;
898 898 darg.desc_num = 0;
899 899
900 900 for (;;) {
901 901 if ((error = door_ki_upcall_limited(sdp->sd_door, &darg,
902 902 NULL, SIZE_MAX, 0)) == 0) {
903 903 break;
904 904 }
905 905 switch (error) {
906 906 case EAGAIN:
907 907 /* Cannot deliver event - process may be forking */
908 908 delay(nticks);
909 909 nticks <<= 1;
910 910 if (nticks > EVCH_MAX_PAUSE) {
911 911 nticks = EVCH_MAX_PAUSE;
912 912 }
913 913 if (retry-- <= 0) {
914 914 cmn_err(CE_CONT, "event delivery thread: "
915 915 "door_ki_upcall error EAGAIN\n");
916 916 return (EVQ_CONT);
917 917 }
918 918 break;
919 919 case EINTR:
920 920 case EBADF:
921 921 /* Process died */
922 922 return (EVQ_SLEEP);
923 923 default:
924 924 cmn_err(CE_CONT,
925 925 "event delivery thread: door_ki_upcall error %d\n",
926 926 error);
927 927 return (EVQ_CONT);
928 928 }
929 929 }
930 930 if (retval == EAGAIN) {
931 931 return (EVQ_AGAIN);
932 932 }
933 933 return (EVQ_CONT);
934 934 }
935 935
936 936 /*
937 937 * Callback routine for evch_dl_search() to compare subscriber id's. Used by
938 938 * evch_subscribe() and evch_chrdevent_init().
939 939 */
940 940 static int
941 941 evch_subidcmp(evch_dlelem_t *ep, char *s)
942 942 {
943 943 return (strcmp(((evch_subd_t *)ep)->sd_ident, s));
944 944 }
945 945
946 946 /*
947 947 * Callback routine for evch_dl_search() to find a subscriber with EVCH_SUB_DUMP
948 948 * set (indicated by sub->sd_dump != 0). Used by evch_chrdevent_init() and
949 949 * evch_subscribe(). Needs to returns 0 if subscriber with sd_dump set is
950 950 * found.
951 951 */
952 952 /*ARGSUSED1*/
953 953 static int
954 954 evch_dumpflgcmp(evch_dlelem_t *ep, char *s)
955 955 {
956 956 return (((evch_subd_t *)ep)->sd_dump ? 0 : 1);
957 957 }
958 958
959 959 /*
960 960 * Event destructor function. Used to maintain the number of events per channel.
961 961 */
962 962 /*ARGSUSED*/
963 963 static void
964 964 evch_destr_event(void *ev, void *ch)
965 965 {
966 966 evch_chan_t *chp = (evch_chan_t *)ch;
967 967
968 968 mutex_enter(&chp->ch_pubmx);
969 969 chp->ch_nevents--;
970 970 cv_signal(&chp->ch_pubcv);
971 971 mutex_exit(&chp->ch_pubmx);
972 972 }
973 973
974 974 /*
975 975 * Integer square root according to Newton's iteration.
976 976 */
977 977 static uint32_t
978 978 evch_isqrt(uint64_t n)
979 979 {
980 980 uint64_t x = n >> 1;
981 981 uint64_t xn = x - 1;
982 982 static uint32_t lowval[] = { 0, 1, 1, 2 };
983 983
984 984 if (n < 4) {
985 985 return (lowval[n]);
986 986 }
987 987 while (xn < x) {
988 988 x = xn;
989 989 xn = (x + n / x) / 2;
990 990 }
991 991 return ((uint32_t)xn);
992 992 }
993 993
994 994 /*
995 995 * First step sysevent channel initialization. Called when kernel memory
996 996 * allocator is initialized.
997 997 */
998 998 static void
999 999 evch_chinit()
1000 1000 {
1001 1001 size_t k;
1002 1002
1003 1003 /*
1004 1004 * Calculate limits: max no of channels and max no of events per
1005 1005 * channel. The smallest machine with 128 MByte will allow for
1006 1006 * >= 8 channels and an upper limit of 2048 events per channel.
1007 1007 * The event limit is the number of channels times 256 (hence
1008 1008 * the shift factor of 8). These number where selected arbitrarily.
1009 1009 */
1010 1010 k = kmem_maxavail() >> 20;
1011 1011 evch_channels_max = min(evch_isqrt(k), EVCH_MAX_CHANNELS);
1012 1012 evch_events_max = evch_channels_max << 8;
1013 1013
1014 1014 /*
1015 1015 * Will trigger creation of the global zone's evch state.
1016 1016 */
1017 1017 zone_key_create(&evch_zone_key, evch_zoneinit, NULL, evch_zonefree);
1018 1018 }
1019 1019
1020 1020 /*
1021 1021 * Second step sysevent channel initialization. Called when threads are ready.
1022 1022 */
1023 1023 static void
1024 1024 evch_chinitthr()
1025 1025 {
1026 1026 struct evch_globals *eg;
1027 1027 evch_chan_t *chp;
1028 1028 evch_subd_t *sdp;
1029 1029
1030 1030 /*
1031 1031 * We're early enough in boot that we know that only the global
1032 1032 * zone exists; we only need to initialize its threads.
1033 1033 */
1034 1034 eg = zone_getspecific(evch_zone_key, global_zone);
1035 1035 ASSERT(eg != NULL);
1036 1036
1037 1037 for (chp = evch_dl_next(&eg->evch_list, NULL); chp != NULL;
1038 1038 chp = evch_dl_next(&eg->evch_list, chp)) {
1039 1039 for (sdp = evch_dl_next(&chp->ch_subscr, NULL); sdp;
1040 1040 sdp = evch_dl_next(&chp->ch_subscr, sdp)) {
1041 1041 evch_evq_thrcreate(sdp->sd_queue);
1042 1042 }
1043 1043 evch_evq_thrcreate(chp->ch_queue);
1044 1044 }
1045 1045 evq_initcomplete = 1;
1046 1046 }
1047 1047
1048 1048 /*
1049 1049 * Sysevent channel bind. Create channel and allocate binding structure.
1050 1050 */
1051 1051 static int
1052 1052 evch_chbind(const char *chnam, evch_bind_t **scpp, uint32_t flags)
1053 1053 {
1054 1054 struct evch_globals *eg;
1055 1055 evch_bind_t *bp;
1056 1056 evch_chan_t *p;
1057 1057 char *chn;
1058 1058 size_t namlen;
1059 1059 int rv;
1060 1060
1061 1061 eg = zone_getspecific(evch_zone_key, curproc->p_zone);
1062 1062 ASSERT(eg != NULL);
1063 1063
1064 1064 /* Create channel if it does not exist */
1065 1065 ASSERT(evch_dl_is_init(&eg->evch_list));
1066 1066 if ((namlen = strlen(chnam) + 1) > MAX_CHNAME_LEN) {
1067 1067 return (EINVAL);
1068 1068 }
1069 1069 mutex_enter(&eg->evch_list_lock);
1070 1070 if ((p = (evch_chan_t *)evch_dl_search(&eg->evch_list, evch_namecmp,
1071 1071 (char *)chnam)) == NULL) {
1072 1072 if (flags & EVCH_CREAT) {
1073 1073 if (evch_dl_getnum(&eg->evch_list) >=
1074 1074 evch_channels_max) {
1075 1075 mutex_exit(&eg->evch_list_lock);
1076 1076 return (ENOMEM);
1077 1077 }
1078 1078 chn = kmem_alloc(namlen, KM_SLEEP);
1079 1079 bcopy(chnam, chn, namlen);
1080 1080
1081 1081 /* Allocate and initialize channel descriptor */
1082 1082 p = kmem_zalloc(sizeof (evch_chan_t), KM_SLEEP);
1083 1083 p->ch_name = chn;
1084 1084 p->ch_namelen = namlen;
1085 1085 mutex_init(&p->ch_mutex, NULL, MUTEX_DEFAULT, NULL);
1086 1086 p->ch_queue = evch_evq_create();
1087 1087 evch_dl_init(&p->ch_subscr);
1088 1088 if (evq_initcomplete) {
1089 1089 p->ch_uid = crgetuid(curthread->t_cred);
1090 1090 p->ch_gid = crgetgid(curthread->t_cred);
1091 1091 }
1092 1092 cv_init(&p->ch_pubcv, NULL, CV_DEFAULT, NULL);
1093 1093 mutex_init(&p->ch_pubmx, NULL, MUTEX_DEFAULT, NULL);
1094 1094 p->ch_maxev = min(EVCH_DEFAULT_EVENTS, evch_events_max);
1095 1095 p->ch_maxsubscr = EVCH_MAX_SUBSCRIPTIONS;
1096 1096 p->ch_maxbinds = evch_bindings_max;
1097 1097 p->ch_ctime = gethrestime_sec();
1098 1098
1099 1099 if (flags & (EVCH_HOLD_PEND | EVCH_HOLD_PEND_INDEF)) {
1100 1100 if (flags & EVCH_HOLD_PEND_INDEF)
1101 1101 p->ch_holdpend = CH_HOLD_PEND_INDEF;
1102 1102 else
1103 1103 p->ch_holdpend = CH_HOLD_PEND;
1104 1104
1105 1105 evch_evq_stop(p->ch_queue);
1106 1106 }
1107 1107
1108 1108 /* Put new descriptor into channel list */
1109 1109 evch_dl_add(&eg->evch_list, (evch_dlelem_t *)p);
1110 1110 } else {
1111 1111 mutex_exit(&eg->evch_list_lock);
1112 1112 return (ENOENT);
1113 1113 }
1114 1114 }
1115 1115
1116 1116 /* Check for max binds and create binding */
1117 1117 mutex_enter(&p->ch_mutex);
1118 1118 if (p->ch_bindings >= p->ch_maxbinds) {
1119 1119 rv = ENOMEM;
1120 1120 /*
1121 1121 * No need to destroy the channel because this call did not
1122 1122 * create it. Other bindings will be present if ch_maxbinds
1123 1123 * is exceeded.
1124 1124 */
1125 1125 goto errorexit;
1126 1126 }
1127 1127 bp = kmem_alloc(sizeof (evch_bind_t), KM_SLEEP);
1128 1128 bp->bd_channel = p;
1129 1129 bp->bd_sublst = NULL;
1130 1130 p->ch_bindings++;
1131 1131 rv = 0;
1132 1132 *scpp = bp;
1133 1133 errorexit:
1134 1134 mutex_exit(&p->ch_mutex);
1135 1135 mutex_exit(&eg->evch_list_lock);
1136 1136 return (rv);
1137 1137 }
1138 1138
1139 1139 /*
1140 1140 * Unbind: Free bind structure. Remove channel if last binding was freed.
1141 1141 */
1142 1142 static void
1143 1143 evch_chunbind(evch_bind_t *bp)
1144 1144 {
1145 1145 struct evch_globals *eg;
1146 1146 evch_chan_t *chp = bp->bd_channel;
1147 1147
1148 1148 eg = zone_getspecific(evch_zone_key, curproc->p_zone);
1149 1149 ASSERT(eg != NULL);
1150 1150
1151 1151 mutex_enter(&eg->evch_list_lock);
1152 1152 mutex_enter(&chp->ch_mutex);
1153 1153 ASSERT(chp->ch_bindings > 0);
1154 1154 chp->ch_bindings--;
1155 1155 kmem_free(bp, sizeof (evch_bind_t));
1156 1156 if (chp->ch_bindings == 0 && evch_dl_getnum(&chp->ch_subscr) == 0 &&
↓ open down ↓ |
1156 lines elided |
↑ open up ↑ |
1157 1157 (chp->ch_nevents == 0 || chp->ch_holdpend != CH_HOLD_PEND_INDEF)) {
1158 1158 /*
1159 1159 * No more bindings and no persistent subscriber(s). If there
1160 1160 * are no events in the channel then destroy the channel;
1161 1161 * otherwise destroy the channel only if we're not holding
1162 1162 * pending events indefinitely.
1163 1163 */
1164 1164 mutex_exit(&chp->ch_mutex);
1165 1165 evch_dl_del(&eg->evch_list, &chp->ch_link);
1166 1166 evch_evq_destroy(chp->ch_queue);
1167 - if (chp->ch_propnvl)
1168 - nvlist_free(chp->ch_propnvl);
1167 + nvlist_free(chp->ch_propnvl);
1169 1168 mutex_destroy(&chp->ch_mutex);
1170 1169 mutex_destroy(&chp->ch_pubmx);
1171 1170 cv_destroy(&chp->ch_pubcv);
1172 1171 kmem_free(chp->ch_name, chp->ch_namelen);
1173 1172 kmem_free(chp, sizeof (evch_chan_t));
1174 1173 } else
1175 1174 mutex_exit(&chp->ch_mutex);
1176 1175 mutex_exit(&eg->evch_list_lock);
1177 1176 }
1178 1177
1179 1178 static int
1180 1179 wildcard_count(const char *class)
1181 1180 {
1182 1181 int count = 0;
1183 1182 char c;
1184 1183
1185 1184 if (class == NULL)
1186 1185 return (0);
1187 1186
1188 1187 while ((c = *class++) != '\0') {
1189 1188 if (c == '*')
1190 1189 count++;
1191 1190 }
1192 1191
1193 1192 return (count);
1194 1193 }
1195 1194
1196 1195 /*
1197 1196 * Subscribe to a channel. dtype is either EVCH_DELKERN for kernel callbacks
1198 1197 * or EVCH_DELDOOR for door upcall delivery to user land. Depending on dtype
1199 1198 * dinfo gives the call back routine address or the door handle.
1200 1199 */
1201 1200 static int
1202 1201 evch_chsubscribe(evch_bind_t *bp, int dtype, const char *sid, const char *class,
1203 1202 void *dinfo, void *cookie, int flags, pid_t pid)
1204 1203 {
1205 1204 evch_chan_t *chp = bp->bd_channel;
1206 1205 evch_eventq_t *eqp = chp->ch_queue;
1207 1206 evch_subd_t *sdp;
1208 1207 evch_subd_t *esp;
1209 1208 int (*delivfkt)();
1210 1209 char *clb = NULL;
1211 1210 int clblen = 0;
1212 1211 char *subid;
1213 1212 int subidblen;
1214 1213
1215 1214 /*
1216 1215 * Check if only known flags are set.
1217 1216 */
1218 1217 if (flags & ~(EVCH_SUB_KEEP | EVCH_SUB_DUMP))
1219 1218 return (EINVAL);
1220 1219
1221 1220 /*
1222 1221 * Enforce a limit on the number of wildcards allowed in the class
1223 1222 * subscription string (limits recursion in pattern matching).
1224 1223 */
1225 1224 if (wildcard_count(class) > EVCH_WILDCARD_MAX)
1226 1225 return (EINVAL);
1227 1226
1228 1227 /*
1229 1228 * Check if we have already a subscription with that name and if we
1230 1229 * have to reconnect the subscriber to a persistent subscription.
1231 1230 */
1232 1231 mutex_enter(&chp->ch_mutex);
1233 1232 if ((esp = (evch_subd_t *)evch_dl_search(&chp->ch_subscr,
1234 1233 evch_subidcmp, (char *)sid)) != NULL) {
1235 1234 int error = 0;
1236 1235 if ((flags & EVCH_SUB_KEEP) && (esp->sd_active == 0)) {
1237 1236 /*
1238 1237 * Subscription with the name on hold, reconnect to
1239 1238 * existing queue.
1240 1239 */
1241 1240 ASSERT(dtype == EVCH_DELDOOR);
1242 1241 esp->sd_subnxt = bp->bd_sublst;
1243 1242 bp->bd_sublst = esp;
1244 1243 esp->sd_pid = pid;
1245 1244 esp->sd_door = (door_handle_t)dinfo;
1246 1245 esp->sd_active++;
1247 1246 evch_evq_continue(esp->sd_queue);
1248 1247 } else {
1249 1248 /* Subscriber with given name already exists */
1250 1249 error = EEXIST;
1251 1250 }
1252 1251 mutex_exit(&chp->ch_mutex);
1253 1252 return (error);
1254 1253 }
1255 1254
1256 1255 if (evch_dl_getnum(&chp->ch_subscr) >= chp->ch_maxsubscr) {
1257 1256 mutex_exit(&chp->ch_mutex);
1258 1257 return (ENOMEM);
1259 1258 }
1260 1259
1261 1260 if (flags & EVCH_SUB_DUMP && evch_dl_search(&chp->ch_subscr,
1262 1261 evch_dumpflgcmp, NULL) != NULL) {
1263 1262 /*
1264 1263 * Subscription with EVCH_SUB_DUMP flagged already exists.
1265 1264 * Only one subscription with EVCH_SUB_DUMP possible. Return
1266 1265 * error.
1267 1266 */
1268 1267 mutex_exit(&chp->ch_mutex);
1269 1268 return (EINVAL);
1270 1269 }
1271 1270
1272 1271 if (class != NULL) {
1273 1272 clblen = strlen(class) + 1;
1274 1273 clb = kmem_alloc(clblen, KM_SLEEP);
1275 1274 bcopy(class, clb, clblen);
1276 1275 }
1277 1276
1278 1277 subidblen = strlen(sid) + 1;
1279 1278 subid = kmem_alloc(subidblen, KM_SLEEP);
1280 1279 bcopy(sid, subid, subidblen);
1281 1280
1282 1281 /* Create per subscriber queue */
1283 1282 sdp = kmem_zalloc(sizeof (evch_subd_t), KM_SLEEP);
1284 1283 sdp->sd_queue = evch_evq_create();
1285 1284
1286 1285 /* Subscribe to subscriber queue */
1287 1286 sdp->sd_persist = flags & EVCH_SUB_KEEP ? 1 : 0;
1288 1287 sdp->sd_dump = flags & EVCH_SUB_DUMP ? 1 : 0;
1289 1288 sdp->sd_type = dtype;
1290 1289 sdp->sd_cbcookie = cookie;
1291 1290 sdp->sd_ident = subid;
1292 1291 if (dtype == EVCH_DELKERN) {
1293 1292 sdp->sd_callback = (kerndlv_f)dinfo;
1294 1293 delivfkt = evch_kern_deliver;
1295 1294 } else {
1296 1295 sdp->sd_door = (door_handle_t)dinfo;
1297 1296 delivfkt = evch_door_deliver;
1298 1297 }
1299 1298 sdp->sd_ssub =
1300 1299 evch_evq_sub(sdp->sd_queue, NULL, NULL, delivfkt, (void *)sdp);
1301 1300
1302 1301 /* Connect per subscriber queue to main event queue */
1303 1302 sdp->sd_msub = evch_evq_sub(eqp, evch_class_filter, clb,
1304 1303 evch_subq_deliver, (void *)sdp);
1305 1304 sdp->sd_classname = clb;
1306 1305 sdp->sd_clnsize = clblen;
1307 1306 sdp->sd_pid = pid;
1308 1307 sdp->sd_active++;
1309 1308
1310 1309 /* Add subscription to binding */
1311 1310 sdp->sd_subnxt = bp->bd_sublst;
1312 1311 bp->bd_sublst = sdp;
1313 1312
1314 1313 /* Add subscription to channel */
1315 1314 evch_dl_add(&chp->ch_subscr, &sdp->sd_link);
1316 1315 if (chp->ch_holdpend && evch_dl_getnum(&chp->ch_subscr) == 1) {
1317 1316
1318 1317 /* Let main event queue run in case of HOLDPEND */
1319 1318 evch_evq_continue(eqp);
1320 1319 }
1321 1320 mutex_exit(&chp->ch_mutex);
1322 1321
1323 1322 return (0);
1324 1323 }
1325 1324
1326 1325 /*
1327 1326 * If flag == EVCH_SUB_KEEP only non-persistent subscriptions are deleted.
1328 1327 * When sid == NULL all subscriptions except the ones with EVCH_SUB_KEEP set
1329 1328 * are removed.
1330 1329 */
1331 1330 static void
1332 1331 evch_chunsubscribe(evch_bind_t *bp, const char *sid, uint32_t flags)
1333 1332 {
1334 1333 evch_subd_t *sdp;
1335 1334 evch_subd_t *next;
1336 1335 evch_subd_t *prev;
1337 1336 evch_chan_t *chp = bp->bd_channel;
1338 1337
1339 1338 mutex_enter(&chp->ch_mutex);
1340 1339 if (chp->ch_holdpend) {
1341 1340 evch_evq_stop(chp->ch_queue); /* Hold main event queue */
1342 1341 }
1343 1342 prev = NULL;
1344 1343 for (sdp = bp->bd_sublst; sdp; sdp = next) {
1345 1344 if (sid == NULL || strcmp(sid, sdp->sd_ident) == 0) {
1346 1345 if (flags == 0 || sdp->sd_persist == 0) {
1347 1346 /*
1348 1347 * Disconnect subscriber queue from main event
1349 1348 * queue.
1350 1349 */
1351 1350 evch_evq_unsub(chp->ch_queue, sdp->sd_msub);
1352 1351
1353 1352 /* Destruct per subscriber queue */
1354 1353 evch_evq_unsub(sdp->sd_queue, sdp->sd_ssub);
1355 1354 evch_evq_destroy(sdp->sd_queue);
1356 1355 /*
1357 1356 * Eliminate the subscriber data from channel
1358 1357 * list.
1359 1358 */
1360 1359 evch_dl_del(&chp->ch_subscr, &sdp->sd_link);
1361 1360 kmem_free(sdp->sd_classname, sdp->sd_clnsize);
1362 1361 if (sdp->sd_type == EVCH_DELDOOR) {
1363 1362 door_ki_rele(sdp->sd_door);
1364 1363 }
1365 1364 next = sdp->sd_subnxt;
1366 1365 if (prev) {
1367 1366 prev->sd_subnxt = next;
1368 1367 } else {
1369 1368 bp->bd_sublst = next;
1370 1369 }
1371 1370 kmem_free(sdp->sd_ident,
1372 1371 strlen(sdp->sd_ident) + 1);
1373 1372 kmem_free(sdp, sizeof (evch_subd_t));
1374 1373 } else {
1375 1374 /*
1376 1375 * EVCH_SUB_KEEP case
1377 1376 */
1378 1377 evch_evq_stop(sdp->sd_queue);
1379 1378 if (sdp->sd_type == EVCH_DELDOOR) {
1380 1379 door_ki_rele(sdp->sd_door);
1381 1380 }
1382 1381 sdp->sd_active--;
1383 1382 ASSERT(sdp->sd_active == 0);
1384 1383 next = sdp->sd_subnxt;
1385 1384 prev = sdp;
1386 1385 }
1387 1386 if (sid != NULL) {
1388 1387 break;
1389 1388 }
1390 1389 } else {
1391 1390 next = sdp->sd_subnxt;
1392 1391 prev = sdp;
1393 1392 }
1394 1393 }
1395 1394 if (!(chp->ch_holdpend && evch_dl_getnum(&chp->ch_subscr) == 0)) {
1396 1395 /*
1397 1396 * Continue dispatch thread except if no subscribers are present
1398 1397 * in HOLDPEND mode.
1399 1398 */
1400 1399 evch_evq_continue(chp->ch_queue);
1401 1400 }
1402 1401 mutex_exit(&chp->ch_mutex);
1403 1402 }
1404 1403
1405 1404 /*
1406 1405 * Publish an event. Returns zero on success and an error code else.
1407 1406 */
1408 1407 static int
1409 1408 evch_chpublish(evch_bind_t *bp, sysevent_impl_t *ev, int flags)
1410 1409 {
1411 1410 evch_chan_t *chp = bp->bd_channel;
1412 1411
1413 1412 DTRACE_SYSEVENT2(post, evch_bind_t *, bp, sysevent_impl_t *, ev);
1414 1413
1415 1414 mutex_enter(&chp->ch_pubmx);
1416 1415 if (chp->ch_nevents >= chp->ch_maxev) {
1417 1416 if (!(flags & EVCH_QWAIT)) {
1418 1417 evch_evq_evfree(ev);
1419 1418 mutex_exit(&chp->ch_pubmx);
1420 1419 return (EAGAIN);
1421 1420 } else {
1422 1421 while (chp->ch_nevents >= chp->ch_maxev) {
1423 1422 if (cv_wait_sig(&chp->ch_pubcv,
1424 1423 &chp->ch_pubmx) == 0) {
1425 1424
1426 1425 /* Got Signal, return EINTR */
1427 1426 evch_evq_evfree(ev);
1428 1427 mutex_exit(&chp->ch_pubmx);
1429 1428 return (EINTR);
1430 1429 }
1431 1430 }
1432 1431 }
1433 1432 }
1434 1433 chp->ch_nevents++;
1435 1434 mutex_exit(&chp->ch_pubmx);
1436 1435 SE_TIME(ev) = gethrtime();
1437 1436 SE_SEQ(ev) = log_sysevent_new_id();
1438 1437 /*
1439 1438 * Add the destructor function to the event structure, now that the
1440 1439 * event is accounted for. The only task of the descructor is to
1441 1440 * decrement the channel event count. The evq_*() routines (including
1442 1441 * the event delivery thread) do not have knowledge of the channel
1443 1442 * data. So the anonymous destructor handles the channel data for it.
1444 1443 */
1445 1444 evch_evq_evadd_dest(ev, evch_destr_event, (void *)chp);
1446 1445 return (evch_evq_pub(chp->ch_queue, ev, flags) == 0 ? 0 : EAGAIN);
1447 1446 }
1448 1447
1449 1448 /*
1450 1449 * Fills a buffer consecutive with the names of all available channels.
1451 1450 * Returns the length of all name strings or -1 if buffer size was unsufficient.
1452 1451 */
1453 1452 static int
1454 1453 evch_chgetnames(char *buf, size_t size)
1455 1454 {
1456 1455 struct evch_globals *eg;
1457 1456 int len = 0;
1458 1457 char *addr = buf;
1459 1458 int max = size;
1460 1459 evch_chan_t *chp;
1461 1460
1462 1461 eg = zone_getspecific(evch_zone_key, curproc->p_zone);
1463 1462 ASSERT(eg != NULL);
1464 1463
1465 1464 mutex_enter(&eg->evch_list_lock);
1466 1465 for (chp = evch_dl_next(&eg->evch_list, NULL); chp != NULL;
1467 1466 chp = evch_dl_next(&eg->evch_list, chp)) {
1468 1467 len += chp->ch_namelen;
1469 1468 if (len >= max) {
1470 1469 mutex_exit(&eg->evch_list_lock);
1471 1470 return (-1);
1472 1471 }
1473 1472 bcopy(chp->ch_name, addr, chp->ch_namelen);
1474 1473 addr += chp->ch_namelen;
1475 1474 }
1476 1475 mutex_exit(&eg->evch_list_lock);
1477 1476 addr[0] = 0;
1478 1477 return (len + 1);
1479 1478 }
1480 1479
1481 1480 /*
1482 1481 * Fills the data of one channel and all subscribers of that channel into
1483 1482 * a buffer. Returns -1 if the channel name is invalid and 0 on buffer overflow.
1484 1483 */
1485 1484 static int
1486 1485 evch_chgetchdata(char *chname, void *buf, size_t size)
1487 1486 {
1488 1487 struct evch_globals *eg;
1489 1488 char *cpaddr;
1490 1489 int bufmax;
1491 1490 int buflen;
1492 1491 evch_chan_t *chp;
1493 1492 sev_chinfo_t *p = (sev_chinfo_t *)buf;
1494 1493 int chdlen;
1495 1494 evch_subd_t *sdp;
1496 1495 sev_subinfo_t *subp;
1497 1496 int idlen;
1498 1497 int len;
1499 1498
1500 1499 eg = zone_getspecific(evch_zone_key, curproc->p_zone);
1501 1500 ASSERT(eg != NULL);
1502 1501
1503 1502 mutex_enter(&eg->evch_list_lock);
1504 1503 chp = (evch_chan_t *)evch_dl_search(&eg->evch_list, evch_namecmp,
1505 1504 chname);
1506 1505 if (chp == NULL) {
1507 1506 mutex_exit(&eg->evch_list_lock);
1508 1507 return (-1);
1509 1508 }
1510 1509 chdlen = offsetof(sev_chinfo_t, cd_subinfo);
1511 1510 if (size < chdlen) {
1512 1511 mutex_exit(&eg->evch_list_lock);
1513 1512 return (0);
1514 1513 }
1515 1514 p->cd_version = 0;
1516 1515 p->cd_suboffs = chdlen;
1517 1516 p->cd_uid = chp->ch_uid;
1518 1517 p->cd_gid = chp->ch_gid;
1519 1518 p->cd_perms = 0;
1520 1519 p->cd_ctime = chp->ch_ctime;
1521 1520 p->cd_maxev = chp->ch_maxev;
1522 1521 p->cd_evhwm = EVCH_EVQ_HIGHWM(chp->ch_queue);
1523 1522 p->cd_nevents = EVCH_EVQ_EVCOUNT(chp->ch_queue);
1524 1523 p->cd_maxsub = chp->ch_maxsubscr;
1525 1524 p->cd_nsub = evch_dl_getnum(&chp->ch_subscr);
1526 1525 p->cd_maxbinds = chp->ch_maxbinds;
1527 1526 p->cd_nbinds = chp->ch_bindings;
1528 1527 p->cd_holdpend = chp->ch_holdpend;
1529 1528 p->cd_limev = evch_events_max;
1530 1529 cpaddr = (char *)p + chdlen;
1531 1530 bufmax = size - chdlen;
1532 1531 buflen = 0;
1533 1532
1534 1533 for (sdp = evch_dl_next(&chp->ch_subscr, NULL); sdp != NULL;
1535 1534 sdp = evch_dl_next(&chp->ch_subscr, sdp)) {
1536 1535 idlen = strlen(sdp->sd_ident) + 1;
1537 1536 len = SE_ALIGN(offsetof(sev_subinfo_t, sb_strings) + idlen +
1538 1537 sdp->sd_clnsize);
1539 1538 buflen += len;
1540 1539 if (buflen >= bufmax) {
1541 1540 mutex_exit(&eg->evch_list_lock);
1542 1541 return (0);
1543 1542 }
1544 1543 subp = (sev_subinfo_t *)cpaddr;
1545 1544 subp->sb_nextoff = len;
1546 1545 subp->sb_stroff = offsetof(sev_subinfo_t, sb_strings);
1547 1546 if (sdp->sd_classname) {
1548 1547 bcopy(sdp->sd_classname, subp->sb_strings + idlen,
1549 1548 sdp->sd_clnsize);
1550 1549 subp->sb_clnamoff = idlen;
1551 1550 } else {
1552 1551 subp->sb_clnamoff = idlen - 1;
1553 1552 }
1554 1553 subp->sb_pid = sdp->sd_pid;
1555 1554 subp->sb_nevents = EVCH_EVQ_EVCOUNT(sdp->sd_queue);
1556 1555 subp->sb_evhwm = EVCH_EVQ_HIGHWM(sdp->sd_queue);
1557 1556 subp->sb_persist = sdp->sd_persist;
1558 1557 subp->sb_status = evch_evq_status(sdp->sd_queue);
1559 1558 subp->sb_active = sdp->sd_active;
1560 1559 subp->sb_dump = sdp->sd_dump;
1561 1560 bcopy(sdp->sd_ident, subp->sb_strings, idlen);
1562 1561 cpaddr += len;
1563 1562 }
1564 1563 mutex_exit(&eg->evch_list_lock);
↓ open down ↓ |
386 lines elided |
↑ open up ↑ |
1565 1564 return (chdlen + buflen);
1566 1565 }
1567 1566
1568 1567 static void
1569 1568 evch_chsetpropnvl(evch_bind_t *bp, nvlist_t *nvl)
1570 1569 {
1571 1570 evch_chan_t *chp = bp->bd_channel;
1572 1571
1573 1572 mutex_enter(&chp->ch_mutex);
1574 1573
1575 - if (chp->ch_propnvl)
1576 - nvlist_free(chp->ch_propnvl);
1574 + nvlist_free(chp->ch_propnvl);
1577 1575
1578 1576 chp->ch_propnvl = nvl;
1579 1577 chp->ch_propnvlgen++;
1580 1578
1581 1579 mutex_exit(&chp->ch_mutex);
1582 1580 }
1583 1581
1584 1582 static int
1585 1583 evch_chgetpropnvl(evch_bind_t *bp, nvlist_t **nvlp, int64_t *genp)
1586 1584 {
1587 1585 evch_chan_t *chp = bp->bd_channel;
1588 1586 int rc = 0;
1589 1587
1590 1588 mutex_enter(&chp->ch_mutex);
1591 1589
1592 1590 if (chp->ch_propnvl != NULL)
1593 1591 rc = (nvlist_dup(chp->ch_propnvl, nvlp, 0) == 0) ? 0 : ENOMEM;
1594 1592 else
1595 1593 *nvlp = NULL; /* rc still 0 */
1596 1594
1597 1595 if (genp)
1598 1596 *genp = chp->ch_propnvlgen;
1599 1597
1600 1598 mutex_exit(&chp->ch_mutex);
1601 1599
1602 1600 if (rc != 0)
1603 1601 *nvlp = NULL;
1604 1602
1605 1603 return (rc);
1606 1604
1607 1605 }
1608 1606
1609 1607 /*
1610 1608 * Init iteration of all events of a channel. This function creates a new
1611 1609 * event queue and puts all events from the channel into that queue.
1612 1610 * Subsequent calls to evch_chgetnextev will deliver the events from that
1613 1611 * queue. Only one thread per channel is allowed to read through the events.
1614 1612 * Returns 0 on success and 1 if there is already someone reading the
1615 1613 * events.
1616 1614 * If argument subid == NULL, we look for a subscriber which has
1617 1615 * flag EVCH_SUB_DUMP set.
1618 1616 */
1619 1617 /*
1620 1618 * Static variables that are used to traverse events of a channel in panic case.
1621 1619 */
1622 1620 static evch_chan_t *evch_chan;
1623 1621 static evch_eventq_t *evch_subq;
1624 1622 static sysevent_impl_t *evch_curev;
1625 1623
1626 1624 static evchanq_t *
1627 1625 evch_chrdevent_init(evch_chan_t *chp, char *subid)
1628 1626 {
1629 1627 evch_subd_t *sdp;
1630 1628 void *ev;
1631 1629 int pmqstat; /* Prev status of main queue */
1632 1630 int psqstat; /* Prev status of subscriber queue */
1633 1631 evchanq_t *snp; /* Pointer to q with snapshot of ev */
1634 1632 compare_f compfunc;
1635 1633
1636 1634 compfunc = subid == NULL ? evch_dumpflgcmp : evch_subidcmp;
1637 1635 if (panicstr != NULL) {
1638 1636 evch_chan = chp;
1639 1637 evch_subq = NULL;
1640 1638 evch_curev = NULL;
1641 1639 if ((sdp = (evch_subd_t *)evch_dl_search(&chp->ch_subscr,
1642 1640 compfunc, subid)) != NULL) {
1643 1641 evch_subq = sdp->sd_queue;
1644 1642 }
1645 1643 return (NULL);
1646 1644 }
1647 1645 mutex_enter(&chp->ch_mutex);
1648 1646 sdp = (evch_subd_t *)evch_dl_search(&chp->ch_subscr, compfunc, subid);
1649 1647 /*
1650 1648 * Stop main event queue and subscriber queue if not already
1651 1649 * in stop mode.
1652 1650 */
1653 1651 pmqstat = evch_evq_status(chp->ch_queue);
1654 1652 if (pmqstat == 0)
1655 1653 evch_evq_stop(chp->ch_queue);
1656 1654 if (sdp != NULL) {
1657 1655 psqstat = evch_evq_status(sdp->sd_queue);
1658 1656 if (psqstat == 0)
1659 1657 evch_evq_stop(sdp->sd_queue);
1660 1658 }
1661 1659 /*
1662 1660 * Create event queue to make a snapshot of all events in the
1663 1661 * channel.
1664 1662 */
1665 1663 snp = kmem_alloc(sizeof (evchanq_t), KM_SLEEP);
1666 1664 snp->sn_queue = evch_evq_create();
1667 1665 evch_evq_stop(snp->sn_queue);
1668 1666 /*
1669 1667 * Make a snapshot of the subscriber queue and the main event queue.
1670 1668 */
1671 1669 if (sdp != NULL) {
1672 1670 ev = NULL;
1673 1671 while ((ev = evch_evq_evnext(sdp->sd_queue, ev)) != NULL) {
1674 1672 (void) evch_evq_pub(snp->sn_queue, ev, EVCH_SLEEP);
1675 1673 }
1676 1674 }
1677 1675 ev = NULL;
1678 1676 while ((ev = evch_evq_evnext(chp->ch_queue, ev)) != NULL) {
1679 1677 (void) evch_evq_pub(snp->sn_queue, ev, EVCH_SLEEP);
1680 1678 }
1681 1679 snp->sn_nxtev = NULL;
1682 1680 /*
1683 1681 * Restart main and subscriber queue if previously stopped
1684 1682 */
1685 1683 if (sdp != NULL && psqstat == 0)
1686 1684 evch_evq_continue(sdp->sd_queue);
1687 1685 if (pmqstat == 0)
1688 1686 evch_evq_continue(chp->ch_queue);
1689 1687 mutex_exit(&chp->ch_mutex);
1690 1688 return (snp);
1691 1689 }
1692 1690
1693 1691 /*
1694 1692 * Free all resources of the event queue snapshot. In case of panic
1695 1693 * context snp must be NULL and no resources need to be free'ed.
1696 1694 */
1697 1695 static void
1698 1696 evch_chrdevent_fini(evchanq_t *snp)
1699 1697 {
1700 1698 if (snp != NULL) {
1701 1699 evch_evq_destroy(snp->sn_queue);
1702 1700 kmem_free(snp, sizeof (evchanq_t));
1703 1701 }
1704 1702 }
1705 1703
1706 1704 /*
1707 1705 * Get address of next event from an event channel.
1708 1706 * This function might be called in a panic context. In that case
1709 1707 * no resources will be allocated and no locks grabbed.
1710 1708 * In normal operation context a snapshot of the event queues of the
1711 1709 * specified event channel will be taken.
1712 1710 */
1713 1711 static sysevent_impl_t *
1714 1712 evch_chgetnextev(evchanq_t *snp)
1715 1713 {
1716 1714 if (panicstr != NULL) {
1717 1715 if (evch_chan == NULL)
1718 1716 return (NULL);
1719 1717 if (evch_subq != NULL) {
1720 1718 /*
1721 1719 * We have a subscriber queue. Traverse this queue
1722 1720 * first.
1723 1721 */
1724 1722 if ((evch_curev = (sysevent_impl_t *)
1725 1723 evch_evq_evnext(evch_subq, evch_curev)) != NULL) {
1726 1724 return (evch_curev);
1727 1725 } else {
1728 1726 /*
1729 1727 * All subscriber events traversed. evch_subq
1730 1728 * == NULL indicates to take the main event
1731 1729 * queue now.
1732 1730 */
1733 1731 evch_subq = NULL;
1734 1732 }
1735 1733 }
1736 1734 /*
1737 1735 * Traverse the main event queue.
1738 1736 */
1739 1737 if ((evch_curev = (sysevent_impl_t *)
1740 1738 evch_evq_evnext(evch_chan->ch_queue, evch_curev)) ==
1741 1739 NULL) {
1742 1740 evch_chan = NULL;
1743 1741 }
1744 1742 return (evch_curev);
1745 1743 }
1746 1744 ASSERT(snp != NULL);
1747 1745 snp->sn_nxtev = (sysevent_impl_t *)evch_evq_evnext(snp->sn_queue,
1748 1746 snp->sn_nxtev);
1749 1747 return (snp->sn_nxtev);
1750 1748 }
1751 1749
1752 1750 /*
1753 1751 * The functions below build up the interface for the kernel to bind/unbind,
1754 1752 * subscribe/unsubscribe and publish to event channels. It consists of the
1755 1753 * following functions:
1756 1754 *
1757 1755 * sysevent_evc_bind - Bind to a channel. Create a channel if required
1758 1756 * sysevent_evc_unbind - Unbind from a channel. Destroy ch. if last unbind
1759 1757 * sysevent_evc_subscribe - Subscribe to events from a channel
1760 1758 * sysevent_evc_unsubscribe - Unsubscribe from an event class
1761 1759 * sysevent_evc_publish - Publish an event to an event channel
1762 1760 * sysevent_evc_control - Various control operation on event channel
1763 1761 * sysevent_evc_setpropnvl - Set channel property nvlist
1764 1762 * sysevent_evc_getpropnvl - Get channel property nvlist
1765 1763 *
1766 1764 * The function below are for evaluating a sysevent:
1767 1765 *
1768 1766 * sysevent_get_class_name - Get pointer to event class string
1769 1767 * sysevent_get_subclass_name - Get pointer to event subclass string
1770 1768 * sysevent_get_seq - Get unique event sequence number
1771 1769 * sysevent_get_time - Get hrestime of event publish
1772 1770 * sysevent_get_size - Get size of event structure
1773 1771 * sysevent_get_pub - Get publisher string
1774 1772 * sysevent_get_attr_list - Get copy of attribute list
1775 1773 *
1776 1774 * The following interfaces represent stability level project privat
1777 1775 * and allow to save the events of an event channel even in a panic case.
1778 1776 *
1779 1777 * sysevent_evc_walk_init - Take a snapshot of the events in a channel
1780 1778 * sysevent_evc_walk_step - Read next event from snapshot
1781 1779 * sysevent_evc_walk_fini - Free resources from event channel snapshot
1782 1780 * sysevent_evc_event_attr - Get event payload address and size
1783 1781 */
1784 1782 /*
1785 1783 * allocate sysevent structure with optional space for attributes
1786 1784 */
1787 1785 static sysevent_impl_t *
1788 1786 sysevent_evc_alloc(const char *class, const char *subclass, const char *pub,
1789 1787 size_t pub_sz, size_t atsz, uint32_t flag)
1790 1788 {
1791 1789 int payload_sz;
1792 1790 int class_sz, subclass_sz;
1793 1791 int aligned_class_sz, aligned_subclass_sz, aligned_pub_sz;
1794 1792 sysevent_impl_t *ev;
1795 1793
1796 1794 /*
1797 1795 * Calculate and reserve space for the class, subclass and
1798 1796 * publisher strings in the event buffer
1799 1797 */
1800 1798 class_sz = strlen(class) + 1;
1801 1799 subclass_sz = strlen(subclass) + 1;
1802 1800
1803 1801 ASSERT((class_sz <= MAX_CLASS_LEN) && (subclass_sz <=
1804 1802 MAX_SUBCLASS_LEN) && (pub_sz <= MAX_PUB_LEN));
1805 1803
1806 1804 /* String sizes must be 64-bit aligned in the event buffer */
1807 1805 aligned_class_sz = SE_ALIGN(class_sz);
1808 1806 aligned_subclass_sz = SE_ALIGN(subclass_sz);
1809 1807 aligned_pub_sz = SE_ALIGN(pub_sz);
1810 1808
1811 1809 /*
1812 1810 * Calculate payload size. Consider the space needed for alignment
1813 1811 * and subtract the size of the uint64_t placeholder variables of
1814 1812 * sysevent_impl_t.
1815 1813 */
1816 1814 payload_sz = (aligned_class_sz - sizeof (uint64_t)) +
1817 1815 (aligned_subclass_sz - sizeof (uint64_t)) +
1818 1816 (aligned_pub_sz - sizeof (uint64_t)) - sizeof (uint64_t) +
1819 1817 atsz;
1820 1818
1821 1819 /*
1822 1820 * Allocate event buffer plus additional payload overhead
1823 1821 */
1824 1822 if ((ev = evch_evq_evzalloc(sizeof (sysevent_impl_t) +
1825 1823 payload_sz, flag)) == NULL) {
1826 1824 return (NULL);
1827 1825 }
1828 1826
1829 1827 /* Initialize the event buffer data */
1830 1828 SE_VERSION(ev) = SYS_EVENT_VERSION;
1831 1829 bcopy(class, SE_CLASS_NAME(ev), class_sz);
1832 1830
1833 1831 SE_SUBCLASS_OFF(ev) = SE_ALIGN(offsetof(sysevent_impl_t,
1834 1832 se_class_name)) + aligned_class_sz;
1835 1833 bcopy(subclass, SE_SUBCLASS_NAME(ev), subclass_sz);
1836 1834
1837 1835 SE_PUB_OFF(ev) = SE_SUBCLASS_OFF(ev) + aligned_subclass_sz;
1838 1836 bcopy(pub, SE_PUB_NAME(ev), pub_sz);
1839 1837
1840 1838 SE_ATTR_PTR(ev) = (uint64_t)0;
1841 1839 SE_PAYLOAD_SZ(ev) = payload_sz;
1842 1840
1843 1841 return (ev);
1844 1842 }
1845 1843
1846 1844 /*
1847 1845 * Initialize event channel handling queues.
1848 1846 */
1849 1847 void
1850 1848 sysevent_evc_init()
1851 1849 {
1852 1850 evch_chinit();
1853 1851 }
1854 1852
1855 1853 /*
1856 1854 * Second initialization step: create threads, if event channels are already
1857 1855 * created
1858 1856 */
1859 1857 void
1860 1858 sysevent_evc_thrinit()
1861 1859 {
1862 1860 evch_chinitthr();
1863 1861 }
1864 1862
1865 1863 int
1866 1864 sysevent_evc_bind(const char *ch_name, evchan_t **scpp, uint32_t flags)
1867 1865 {
1868 1866 ASSERT(ch_name != NULL && scpp != NULL);
1869 1867 ASSERT((flags & ~EVCH_B_FLAGS) == 0);
1870 1868 return (evch_chbind(ch_name, (evch_bind_t **)scpp, flags));
1871 1869 }
1872 1870
1873 1871 int
1874 1872 sysevent_evc_unbind(evchan_t *scp)
1875 1873 {
1876 1874 evch_bind_t *bp = (evch_bind_t *)scp;
1877 1875
1878 1876 ASSERT(scp != NULL);
1879 1877 evch_chunsubscribe(bp, NULL, 0);
1880 1878 evch_chunbind(bp);
1881 1879
1882 1880 return (0);
1883 1881 }
1884 1882
1885 1883 int
1886 1884 sysevent_evc_subscribe(evchan_t *scp, const char *sid, const char *class,
1887 1885 int (*callb)(sysevent_t *ev, void *cookie),
1888 1886 void *cookie, uint32_t flags)
1889 1887 {
1890 1888 ASSERT(scp != NULL && sid != NULL && class != NULL && callb != NULL);
1891 1889 ASSERT(flags == 0);
1892 1890 if (strlen(sid) > MAX_SUBID_LEN) {
1893 1891 return (EINVAL);
1894 1892 }
1895 1893 if (strcmp(class, EC_ALL) == 0) {
1896 1894 class = NULL;
1897 1895 }
1898 1896 return (evch_chsubscribe((evch_bind_t *)scp, EVCH_DELKERN, sid, class,
1899 1897 (void *)callb, cookie, 0, 0));
1900 1898 }
1901 1899
1902 1900 int
1903 1901 sysevent_evc_unsubscribe(evchan_t *scp, const char *sid)
1904 1902 {
1905 1903 ASSERT(scp != NULL && sid != NULL);
1906 1904 if (strcmp(sid, EVCH_ALLSUB) == 0) {
1907 1905 sid = NULL;
1908 1906 }
1909 1907 evch_chunsubscribe((evch_bind_t *)scp, sid, 0);
1910 1908
1911 1909 return (0);
1912 1910 }
1913 1911
1914 1912 /*
1915 1913 * Publish kernel event. Returns 0 on success, error code else.
1916 1914 * Optional attribute data is packed into the event structure.
1917 1915 */
1918 1916 int
1919 1917 sysevent_evc_publish(evchan_t *scp, const char *class, const char *subclass,
1920 1918 const char *vendor, const char *pubs, nvlist_t *attr, uint32_t flags)
1921 1919 {
1922 1920 sysevent_impl_t *evp;
1923 1921 char pub[MAX_PUB_LEN];
1924 1922 int pub_sz; /* includes terminating 0 */
1925 1923 int km_flags;
1926 1924 size_t asz = 0;
1927 1925 uint64_t attr_offset;
1928 1926 caddr_t patt;
1929 1927 int err;
1930 1928
1931 1929 ASSERT(scp != NULL && class != NULL && subclass != NULL &&
1932 1930 vendor != NULL && pubs != NULL);
1933 1931
1934 1932 ASSERT((flags & ~(EVCH_SLEEP | EVCH_NOSLEEP | EVCH_TRYHARD |
1935 1933 EVCH_QWAIT)) == 0);
1936 1934
1937 1935 km_flags = flags & (EVCH_SLEEP | EVCH_NOSLEEP | EVCH_TRYHARD);
1938 1936 ASSERT(km_flags == EVCH_SLEEP || km_flags == EVCH_NOSLEEP ||
1939 1937 km_flags == EVCH_TRYHARD);
1940 1938
1941 1939 pub_sz = snprintf(pub, MAX_PUB_LEN, "%s:kern:%s", vendor, pubs) + 1;
1942 1940 if (pub_sz > MAX_PUB_LEN)
1943 1941 return (EINVAL);
1944 1942
1945 1943 if (attr != NULL) {
1946 1944 if ((err = nvlist_size(attr, &asz, NV_ENCODE_NATIVE)) != 0) {
1947 1945 return (err);
1948 1946 }
1949 1947 }
1950 1948 evp = sysevent_evc_alloc(class, subclass, pub, pub_sz, asz, km_flags);
1951 1949 if (evp == NULL) {
1952 1950 return (ENOMEM);
1953 1951 }
1954 1952 if (attr != NULL) {
1955 1953 /*
1956 1954 * Pack attributes into event buffer. Event buffer already
1957 1955 * has enough room for the packed nvlist.
1958 1956 */
1959 1957 attr_offset = SE_ATTR_OFF(evp);
1960 1958 patt = (caddr_t)evp + attr_offset;
1961 1959
1962 1960 err = nvlist_pack(attr, &patt, &asz, NV_ENCODE_NATIVE,
1963 1961 km_flags & EVCH_SLEEP ? KM_SLEEP : KM_NOSLEEP);
1964 1962
1965 1963 ASSERT(err != ENOMEM);
1966 1964
1967 1965 if (err != 0) {
1968 1966 return (EINVAL);
1969 1967 }
1970 1968
1971 1969 evp->seh_attr_off = attr_offset;
1972 1970 SE_FLAG(evp) = SE_PACKED_BUF;
1973 1971 }
1974 1972 return (evch_chpublish((evch_bind_t *)scp, evp, flags));
1975 1973 }
1976 1974
1977 1975 int
1978 1976 sysevent_evc_control(evchan_t *scp, int cmd, ...)
1979 1977 {
1980 1978 va_list ap;
1981 1979 evch_chan_t *chp = ((evch_bind_t *)scp)->bd_channel;
1982 1980 uint32_t *chlenp;
1983 1981 uint32_t chlen;
1984 1982 uint32_t ochlen;
1985 1983 int rc = 0;
1986 1984
1987 1985 if (scp == NULL) {
1988 1986 return (EINVAL);
1989 1987 }
1990 1988
1991 1989 va_start(ap, cmd);
1992 1990 mutex_enter(&chp->ch_mutex);
1993 1991 switch (cmd) {
1994 1992 case EVCH_GET_CHAN_LEN:
1995 1993 chlenp = va_arg(ap, uint32_t *);
1996 1994 *chlenp = chp->ch_maxev;
1997 1995 break;
1998 1996 case EVCH_SET_CHAN_LEN:
1999 1997 chlen = va_arg(ap, uint32_t);
2000 1998 ochlen = chp->ch_maxev;
2001 1999 chp->ch_maxev = min(chlen, evch_events_max);
2002 2000 if (ochlen < chp->ch_maxev) {
2003 2001 cv_signal(&chp->ch_pubcv);
2004 2002 }
2005 2003 break;
2006 2004 case EVCH_GET_CHAN_LEN_MAX:
2007 2005 *va_arg(ap, uint32_t *) = evch_events_max;
2008 2006 break;
2009 2007 default:
2010 2008 rc = EINVAL;
2011 2009 }
2012 2010
2013 2011 mutex_exit(&chp->ch_mutex);
2014 2012 va_end(ap);
2015 2013 return (rc);
2016 2014 }
2017 2015
2018 2016 int
2019 2017 sysevent_evc_setpropnvl(evchan_t *scp, nvlist_t *nvl)
2020 2018 {
2021 2019 nvlist_t *nvlcp = nvl;
2022 2020
2023 2021 if (nvl != NULL && nvlist_dup(nvl, &nvlcp, 0) != 0)
2024 2022 return (ENOMEM);
2025 2023
2026 2024 evch_chsetpropnvl((evch_bind_t *)scp, nvlcp);
2027 2025
2028 2026 return (0);
2029 2027 }
2030 2028
2031 2029 int
2032 2030 sysevent_evc_getpropnvl(evchan_t *scp, nvlist_t **nvlp)
2033 2031 {
2034 2032 return (evch_chgetpropnvl((evch_bind_t *)scp, nvlp, NULL));
2035 2033 }
2036 2034
2037 2035 /*
2038 2036 * Project private interface to take a snapshot of all events of the
2039 2037 * specified event channel. Argument subscr may be a subscriber id, the empty
2040 2038 * string "", or NULL. The empty string indicates that no subscriber is
2041 2039 * selected, for example if a previous subscriber died. sysevent_evc_walk_next()
2042 2040 * will deliver events from the main event queue in this case. If subscr is
2043 2041 * NULL, the subscriber with the EVCH_SUB_DUMP flag set (subd->sd_dump != 0)
2044 2042 * will be selected.
2045 2043 *
2046 2044 * In panic case this function returns NULL. This is legal. The NULL has
2047 2045 * to be delivered to sysevent_evc_walk_step() and sysevent_evc_walk_fini().
2048 2046 */
2049 2047 evchanq_t *
2050 2048 sysevent_evc_walk_init(evchan_t *scp, char *subscr)
2051 2049 {
2052 2050 if (panicstr != NULL && scp == NULL)
2053 2051 return (NULL);
2054 2052 ASSERT(scp != NULL);
2055 2053 return (evch_chrdevent_init(((evch_bind_t *)scp)->bd_channel, subscr));
2056 2054 }
2057 2055
2058 2056 /*
2059 2057 * Project private interface to read events from a previously taken
2060 2058 * snapshot (with sysevent_evc_walk_init). In case of panic events
2061 2059 * are retrieved directly from the channel data structures. No resources
2062 2060 * are allocated and no mutexes are grabbed in panic context.
2063 2061 */
2064 2062 sysevent_t *
2065 2063 sysevent_evc_walk_step(evchanq_t *evcq)
2066 2064 {
2067 2065 return ((sysevent_t *)evch_chgetnextev(evcq));
2068 2066 }
2069 2067
2070 2068 /*
2071 2069 * Project private interface to free a previously taken snapshot.
2072 2070 */
2073 2071 void
2074 2072 sysevent_evc_walk_fini(evchanq_t *evcq)
2075 2073 {
2076 2074 evch_chrdevent_fini(evcq);
2077 2075 }
2078 2076
2079 2077 /*
2080 2078 * Get address and size of an event payload. Returns NULL when no
2081 2079 * payload present.
2082 2080 */
2083 2081 char *
2084 2082 sysevent_evc_event_attr(sysevent_t *ev, size_t *plsize)
2085 2083 {
2086 2084 char *attrp;
2087 2085 size_t aoff;
2088 2086 size_t asz;
2089 2087
2090 2088 aoff = SE_ATTR_OFF(ev);
2091 2089 attrp = (char *)ev + aoff;
2092 2090 asz = *plsize = SE_SIZE(ev) - aoff;
2093 2091 return (asz ? attrp : NULL);
2094 2092 }
2095 2093
2096 2094 /*
2097 2095 * sysevent_get_class_name - Get class name string
2098 2096 */
2099 2097 char *
2100 2098 sysevent_get_class_name(sysevent_t *ev)
2101 2099 {
2102 2100 return (SE_CLASS_NAME(ev));
2103 2101 }
2104 2102
2105 2103 /*
2106 2104 * sysevent_get_subclass_name - Get subclass name string
2107 2105 */
2108 2106 char *
2109 2107 sysevent_get_subclass_name(sysevent_t *ev)
2110 2108 {
2111 2109 return (SE_SUBCLASS_NAME(ev));
2112 2110 }
2113 2111
2114 2112 /*
2115 2113 * sysevent_get_seq - Get event sequence id
2116 2114 */
2117 2115 uint64_t
2118 2116 sysevent_get_seq(sysevent_t *ev)
2119 2117 {
2120 2118 return (SE_SEQ(ev));
2121 2119 }
2122 2120
2123 2121 /*
2124 2122 * sysevent_get_time - Get event timestamp
2125 2123 */
2126 2124 void
2127 2125 sysevent_get_time(sysevent_t *ev, hrtime_t *etime)
2128 2126 {
2129 2127 *etime = SE_TIME(ev);
2130 2128 }
2131 2129
2132 2130 /*
2133 2131 * sysevent_get_size - Get event buffer size
2134 2132 */
2135 2133 size_t
2136 2134 sysevent_get_size(sysevent_t *ev)
2137 2135 {
2138 2136 return ((size_t)SE_SIZE(ev));
2139 2137 }
2140 2138
2141 2139 /*
2142 2140 * sysevent_get_pub - Get publisher name string
2143 2141 */
2144 2142 char *
2145 2143 sysevent_get_pub(sysevent_t *ev)
2146 2144 {
2147 2145 return (SE_PUB_NAME(ev));
2148 2146 }
2149 2147
2150 2148 /*
2151 2149 * sysevent_get_attr_list - stores address of a copy of the attribute list
2152 2150 * associated with the given sysevent buffer. The list must be freed by the
2153 2151 * caller.
2154 2152 */
2155 2153 int
2156 2154 sysevent_get_attr_list(sysevent_t *ev, nvlist_t **nvlist)
2157 2155 {
2158 2156 int error;
2159 2157 caddr_t attr;
2160 2158 size_t attr_len;
2161 2159 uint64_t attr_offset;
2162 2160
2163 2161 *nvlist = NULL;
2164 2162 if (SE_FLAG(ev) != SE_PACKED_BUF) {
2165 2163 return (EINVAL);
2166 2164 }
2167 2165 attr_offset = SE_ATTR_OFF(ev);
2168 2166 if (SE_SIZE(ev) == attr_offset) {
2169 2167 return (EINVAL);
2170 2168 }
2171 2169
2172 2170 /* unpack nvlist */
2173 2171 attr = (caddr_t)ev + attr_offset;
2174 2172 attr_len = SE_SIZE(ev) - attr_offset;
2175 2173 if ((error = nvlist_unpack(attr, attr_len, nvlist, 0)) != 0) {
2176 2174 error = error != ENOMEM ? EINVAL : error;
2177 2175 return (error);
2178 2176 }
2179 2177 return (0);
2180 2178 }
2181 2179
2182 2180 /*
2183 2181 * Functions called by the sysevent driver for general purpose event channels
2184 2182 *
2185 2183 * evch_usrchanopen - Create/Bind to an event channel
2186 2184 * evch_usrchanclose - Unbind/Destroy event channel
2187 2185 * evch_usrallocev - Allocate event data structure
2188 2186 * evch_usrfreeev - Free event data structure
2189 2187 * evch_usrpostevent - Publish event
2190 2188 * evch_usrsubscribe - Subscribe (register callback function)
2191 2189 * evch_usrunsubscribe - Unsubscribe
2192 2190 * evch_usrcontrol_set - Set channel properties
2193 2191 * evch_usrcontrol_get - Get channel properties
2194 2192 * evch_usrgetchnames - Get list of channel names
2195 2193 * evch_usrgetchdata - Get data of an event channel
2196 2194 * evch_usrsetpropnvl - Set channel properties nvlist
2197 2195 * evch_usrgetpropnvl - Get channel properties nvlist
2198 2196 */
2199 2197 evchan_t *
2200 2198 evch_usrchanopen(const char *name, uint32_t flags, int *err)
2201 2199 {
2202 2200 evch_bind_t *bp = NULL;
2203 2201
2204 2202 *err = evch_chbind(name, &bp, flags);
2205 2203 return ((evchan_t *)bp);
2206 2204 }
2207 2205
2208 2206 /*
2209 2207 * Unbind from the channel.
2210 2208 */
2211 2209 void
2212 2210 evch_usrchanclose(evchan_t *cbp)
2213 2211 {
2214 2212 evch_chunbind((evch_bind_t *)cbp);
2215 2213 }
2216 2214
2217 2215 /*
2218 2216 * Allocates log_evch_eventq_t structure but returns the pointer of the embedded
2219 2217 * sysevent_impl_t structure as the opaque sysevent_t * data type
2220 2218 */
2221 2219 sysevent_impl_t *
2222 2220 evch_usrallocev(size_t evsize, uint32_t flags)
2223 2221 {
2224 2222 return ((sysevent_impl_t *)evch_evq_evzalloc(evsize, flags));
2225 2223 }
2226 2224
2227 2225 /*
2228 2226 * Free evch_eventq_t structure
2229 2227 */
2230 2228 void
2231 2229 evch_usrfreeev(sysevent_impl_t *ev)
2232 2230 {
2233 2231 evch_evq_evfree((void *)ev);
2234 2232 }
2235 2233
2236 2234 /*
2237 2235 * Posts an event to the given channel. The event structure has to be
2238 2236 * allocated by evch_usrallocev(). Returns zero on success and an error
2239 2237 * code else. Attributes have to be packed and included in the event structure.
2240 2238 *
2241 2239 */
2242 2240 int
2243 2241 evch_usrpostevent(evchan_t *bp, sysevent_impl_t *ev, uint32_t flags)
2244 2242 {
2245 2243 return (evch_chpublish((evch_bind_t *)bp, ev, flags));
2246 2244 }
2247 2245
2248 2246 /*
2249 2247 * Subscribe function for user land subscriptions
2250 2248 */
2251 2249 int
2252 2250 evch_usrsubscribe(evchan_t *bp, const char *sid, const char *class,
2253 2251 int d, uint32_t flags)
2254 2252 {
2255 2253 door_handle_t dh = door_ki_lookup(d);
2256 2254 int rv;
2257 2255
2258 2256 if (dh == NULL) {
2259 2257 return (EINVAL);
2260 2258 }
2261 2259 if ((rv = evch_chsubscribe((evch_bind_t *)bp, EVCH_DELDOOR, sid, class,
2262 2260 (void *)dh, NULL, flags, curproc->p_pid)) != 0) {
2263 2261 door_ki_rele(dh);
2264 2262 }
2265 2263 return (rv);
2266 2264 }
2267 2265
2268 2266 /*
2269 2267 * Flag can be EVCH_SUB_KEEP or 0. EVCH_SUB_KEEP preserves persistent
2270 2268 * subscribers
2271 2269 */
2272 2270 void
2273 2271 evch_usrunsubscribe(evchan_t *bp, const char *subid, uint32_t flags)
2274 2272 {
2275 2273 evch_chunsubscribe((evch_bind_t *)bp, subid, flags);
2276 2274 }
2277 2275
2278 2276 /*ARGSUSED*/
2279 2277 int
2280 2278 evch_usrcontrol_set(evchan_t *bp, int cmd, uint32_t value)
2281 2279 {
2282 2280 evch_chan_t *chp = ((evch_bind_t *)bp)->bd_channel;
2283 2281 uid_t uid = crgetuid(curthread->t_cred);
2284 2282 int rc = 0;
2285 2283
2286 2284 mutex_enter(&chp->ch_mutex);
2287 2285 switch (cmd) {
2288 2286 case EVCH_SET_CHAN_LEN:
2289 2287 if (uid && uid != chp->ch_uid) {
2290 2288 rc = EACCES;
2291 2289 break;
2292 2290 }
2293 2291 chp->ch_maxev = min(value, evch_events_max);
2294 2292 break;
2295 2293 default:
2296 2294 rc = EINVAL;
2297 2295 }
2298 2296 mutex_exit(&chp->ch_mutex);
2299 2297 return (rc);
2300 2298 }
2301 2299
2302 2300 /*ARGSUSED*/
2303 2301 int
2304 2302 evch_usrcontrol_get(evchan_t *bp, int cmd, uint32_t *value)
2305 2303 {
2306 2304 evch_chan_t *chp = ((evch_bind_t *)bp)->bd_channel;
2307 2305 int rc = 0;
2308 2306
2309 2307 mutex_enter(&chp->ch_mutex);
2310 2308 switch (cmd) {
2311 2309 case EVCH_GET_CHAN_LEN:
2312 2310 *value = chp->ch_maxev;
2313 2311 break;
2314 2312 case EVCH_GET_CHAN_LEN_MAX:
2315 2313 *value = evch_events_max;
2316 2314 break;
2317 2315 default:
2318 2316 rc = EINVAL;
2319 2317 }
2320 2318 mutex_exit(&chp->ch_mutex);
2321 2319 return (rc);
2322 2320 }
2323 2321
2324 2322 int
2325 2323 evch_usrgetchnames(char *buf, size_t size)
2326 2324 {
2327 2325 return (evch_chgetnames(buf, size));
2328 2326 }
2329 2327
2330 2328 int
2331 2329 evch_usrgetchdata(char *chname, void *buf, size_t size)
2332 2330 {
2333 2331 return (evch_chgetchdata(chname, buf, size));
2334 2332 }
2335 2333
2336 2334 void
2337 2335 evch_usrsetpropnvl(evchan_t *bp, nvlist_t *nvl)
2338 2336 {
2339 2337 evch_chsetpropnvl((evch_bind_t *)bp, nvl);
2340 2338 }
2341 2339
2342 2340 int
2343 2341 evch_usrgetpropnvl(evchan_t *bp, nvlist_t **nvlp, int64_t *genp)
2344 2342 {
2345 2343 return (evch_chgetpropnvl((evch_bind_t *)bp, nvlp, genp));
2346 2344 }
↓ open down ↓ |
760 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX