OpenSolaris_b135/uts/common/os/evchannels.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* This file contains the source of the general purpose event channel extension
* to the sysevent framework. This implementation is made up mainly of four
* layers of functionality: the event queues (evch_evq_*()), the handling of
* channels (evch_ch*()), the kernel interface (sysevent_evc_*()) and the
* interface for the sysevent pseudo driver (evch_usr*()).
* Libsysevent.so uses the pseudo driver sysevent's ioctl to access the event
* channel extensions. The driver in turn uses the evch_usr*() functions below.
*
* The interfaces for user land and kernel are declared in sys/sysevent.h
* Internal data structures for event channels are defined in
* sys/sysevent_impl.h.
*
* The basic data structure for an event channel is of type evch_chan_t.
* All channels are maintained by a list named evch_list. The list head
* is of type evch_dlist_t.
*/
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/stropts.h>
#include <sys/debug.h>
#include <sys/ddi.h>
#include <sys/vmem.h>
#include <sys/cmn_err.h>
#include <sys/callb.h>
#include <sys/sysevent.h>
#include <sys/sysevent_impl.h>
#include <sys/sysmacros.h>
#include <sys/disp.h>
#include <sys/atomic.h>
#include <sys/door.h>
#include <sys/zone.h>
#include <sys/sdt.h>
/* Back-off delay for door_ki_upcall */
#define EVCH_MIN_PAUSE 8
#define EVCH_MAX_PAUSE 128
#define GEVENT(ev) ((evch_gevent_t *)((char *)ev - \
offsetof(evch_gevent_t, ge_payload)))
#define EVCH_EVQ_EVCOUNT(x) ((&(x)->eq_eventq)->sq_count)
#define EVCH_EVQ_HIGHWM(x) ((&(x)->eq_eventq)->sq_highwm)
#define CH_HOLD_PEND 1
#define CH_HOLD_PEND_INDEF 2
struct evch_globals {
evch_dlist_t evch_list;
kmutex_t evch_list_lock;
};
/* Variables used by event channel routines */
static int evq_initcomplete = 0;
static zone_key_t evch_zone_key;
static uint32_t evch_channels_max;
static uint32_t evch_bindings_max = EVCH_MAX_BINDS_PER_CHANNEL;
static uint32_t evch_events_max;
static void evch_evq_unsub(evch_eventq_t *, evch_evqsub_t *);
static void evch_evq_destroy(evch_eventq_t *);
/*
* List handling. These functions handle a doubly linked list. The list has
* to be protected by the calling functions. evch_dlist_t is the list head.
* Every node of the list has to put a evch_dlelem_t data type in its data
* structure as its first element.
*
* evch_dl_init - Initialize list head
* evch_dl_fini - Terminate list handling
* evch_dl_is_init - Returns one if list is initialized
* evch_dl_add - Add element to end of list
* evch_dl_del - Remove given element from list
* evch_dl_search - Lookup element in list
* evch_dl_getnum - Get number of elements in list
* evch_dl_next - Get next elements of list
*/
static void
evch_dl_init(evch_dlist_t *hp)
{
hp->dh_head.dl_prev = hp->dh_head.dl_next = &hp->dh_head;
hp->dh_count = 0;
}
/*
* Assumes that list is empty.
*/
static void
evch_dl_fini(evch_dlist_t *hp)
{
hp->dh_head.dl_prev = hp->dh_head.dl_next = NULL;
}
static int
evch_dl_is_init(evch_dlist_t *hp)
{
return (hp->dh_head.dl_next != NULL ? 1 : 0);
}
/*
* Add an element at the end of the list.
*/
static void
evch_dl_add(evch_dlist_t *hp, evch_dlelem_t *el)
{
evch_dlelem_t *x = hp->dh_head.dl_prev;
evch_dlelem_t *y = &hp->dh_head;
x->dl_next = el;
y->dl_prev = el;
el->dl_next = y;
el->dl_prev = x;
hp->dh_count++;
}
/*
* Remove arbitrary element out of dlist.
*/
static void
evch_dl_del(evch_dlist_t *hp, evch_dlelem_t *p)
{
ASSERT(hp->dh_count > 0 && p != &hp->dh_head);
p->dl_prev->dl_next = p->dl_next;
p->dl_next->dl_prev = p->dl_prev;
p->dl_prev = NULL;
p->dl_next = NULL;
hp->dh_count--;
}
/*
* Search an element in a list. Caller provides comparison callback function.
*/
static evch_dlelem_t *
evch_dl_search(evch_dlist_t *hp, int (*cmp)(evch_dlelem_t *, char *), char *s)
{
evch_dlelem_t *p;
for (p = hp->dh_head.dl_next; p != &hp->dh_head; p = p->dl_next) {
if (cmp(p, s) == 0) {
return (p);
}
}
return (NULL);
}
/*
* Return number of elements in the list.
*/
static int
evch_dl_getnum(evch_dlist_t *hp)
{
return (hp->dh_count);
}
/*
* Find next element of a evch_dlist_t list. Find first element if el == NULL.
* Returns NULL if end of list is reached.
*/
static void *
evch_dl_next(evch_dlist_t *hp, void *el)
{
evch_dlelem_t *ep = (evch_dlelem_t *)el;
if (hp->dh_count == 0) {
return (NULL);
}
if (ep == NULL) {
return (hp->dh_head.dl_next);
}
if ((ep = ep->dl_next) == (evch_dlelem_t *)hp) {
return (NULL);
}
return ((void *)ep);
}
/*
* Queue handling routines. Mutexes have to be entered previously.
*
* evch_q_init - Initialize queue head
* evch_q_in - Put element into queue
* evch_q_out - Get element out of queue
* evch_q_next - Iterate over the elements of a queue
*/
static void
evch_q_init(evch_squeue_t *q)
{
q->sq_head = NULL;
q->sq_tail = (evch_qelem_t *)q;
q->sq_count = 0;
q->sq_highwm = 0;
}
/*
* Put element into the queue q
*/
static void
evch_q_in(evch_squeue_t *q, evch_qelem_t *el)
{
q->sq_tail->q_next = el;
el->q_next = NULL;
q->sq_tail = el;
q->sq_count++;
if (q->sq_count > q->sq_highwm) {
q->sq_highwm = q->sq_count;
}
}
/*
* Returns NULL if queue is empty.
*/
static evch_qelem_t *
evch_q_out(evch_squeue_t *q)
{
evch_qelem_t *el;
if ((el = q->sq_head) != NULL) {
q->sq_head = el->q_next;
q->sq_count--;
if (q->sq_head == NULL) {
q->sq_tail = (evch_qelem_t *)q;
}
}
return (el);
}
/*
* Returns element after *el or first if el == NULL. NULL is returned
* if queue is empty or *el points to the last element in the queue.
*/
static evch_qelem_t *
evch_q_next(evch_squeue_t *q, evch_qelem_t *el)
{
if (el == NULL)
return (q->sq_head);
return (el->q_next);
}
/*
* Event queue handling functions. An event queue is the basic building block
* of an event channel. One event queue makes up the publisher-side event queue.
* Further event queues build the per-subscriber queues of an event channel.
* Each queue is associated an event delivery thread.
* These functions support a two-step initialization. First step, when kernel
* memory is ready and second when threads are ready.
* Events consist of an administrating evch_gevent_t structure with the event
* data appended as variable length payload.
* The internal interface functions for the event queue handling are:
*
* evch_evq_create - create an event queue
* evch_evq_thrcreate - create thread for an event queue.
* evch_evq_destroy - delete an event queue
* evch_evq_sub - Subscribe to event delivery from an event queue
* evch_evq_unsub - Unsubscribe
* evch_evq_pub - Post an event into an event queue
* evch_evq_stop - Put delivery thread on hold
* evch_evq_continue - Resume event delivery thread
* evch_evq_status - Return status of delivery thread, running or on hold
* evch_evq_evzalloc - Allocate an event structure
* evch_evq_evfree - Free an event structure
* evch_evq_evadd_dest - Add a destructor function to an event structure
* evch_evq_evnext - Iterate over events non-destructive
*/
/*ARGSUSED*/
static void *
evch_zoneinit(zoneid_t zoneid)
{
struct evch_globals *eg;
eg = kmem_zalloc(sizeof (*eg), KM_SLEEP);
evch_dl_init(&eg->evch_list);
return (eg);
}
/*ARGSUSED*/
static void
evch_zonefree(zoneid_t zoneid, void *arg)
{
struct evch_globals *eg = arg;
evch_chan_t *chp;
evch_subd_t *sdp;
mutex_enter(&eg->evch_list_lock);
/*
* Keep picking the head element off the list until there are no
* more.
*/
while ((chp = evch_dl_next(&eg->evch_list, NULL)) != NULL) {
/*
* Since all processes are gone, all bindings should be gone,
* and only channels with SUB_KEEP subscribers should remain.
*/
mutex_enter(&chp->ch_mutex);
ASSERT(chp->ch_bindings == 0);
ASSERT(evch_dl_getnum(&chp->ch_subscr) != 0 ||
chp->ch_holdpend == CH_HOLD_PEND_INDEF);
/* Forcibly unsubscribe each remaining subscription */
while ((sdp = evch_dl_next(&chp->ch_subscr, NULL)) != NULL) {
/*
* We should only be tearing down persistent
* subscribers at this point, since all processes
* from this zone are gone.
*/
ASSERT(sdp->sd_active == 0);
ASSERT((sdp->sd_persist & EVCH_SUB_KEEP) != 0);
/*
* Disconnect subscriber queue from main event queue.
*/
evch_evq_unsub(chp->ch_queue, sdp->sd_msub);
/* Destruct per subscriber queue */
evch_evq_unsub(sdp->sd_queue, sdp->sd_ssub);
evch_evq_destroy(sdp->sd_queue);
/*
* Eliminate the subscriber data from channel list.
*/
evch_dl_del(&chp->ch_subscr, &sdp->sd_link);
kmem_free(sdp->sd_classname, sdp->sd_clnsize);
kmem_free(sdp->sd_ident, strlen(sdp->sd_ident) + 1);
kmem_free(sdp, sizeof (evch_subd_t));
}
/* Channel must now have no subscribers */
ASSERT(evch_dl_getnum(&chp->ch_subscr) == 0);
/* Just like unbind */
mutex_exit(&chp->ch_mutex);
evch_dl_del(&eg->evch_list, &chp->ch_link);
evch_evq_destroy(chp->ch_queue);
mutex_destroy(&chp->ch_mutex);
mutex_destroy(&chp->ch_pubmx);
cv_destroy(&chp->ch_pubcv);
kmem_free(chp->ch_name, chp->ch_namelen);
kmem_free(chp, sizeof (evch_chan_t));
}
mutex_exit(&eg->evch_list_lock);
/* all channels should now be gone */
ASSERT(evch_dl_getnum(&eg->evch_list) == 0);
kmem_free(eg, sizeof (*eg));
}
/*
* Frees evch_gevent_t structure including the payload, if the reference count
* drops to or below zero. Below zero happens when the event is freed
* without beeing queued into a queue.
*/
static void
evch_gevent_free(evch_gevent_t *evp)
{
int32_t refcnt;
refcnt = (int32_t)atomic_add_32_nv(&evp->ge_refcount, -1);
if (refcnt <= 0) {
if (evp->ge_destruct != NULL) {
evp->ge_destruct((void *)&(evp->ge_payload),
evp->ge_dstcookie);
}
kmem_free(evp, evp->ge_size);
}
}
/*
* Deliver is called for every subscription to the current event
* It calls the registered filter function and then the registered delivery
* callback routine. Returns 0 on success. The callback routine returns
* EVQ_AGAIN or EVQ_SLEEP in case the event could not be delivered.
*/
static int
evch_deliver(evch_evqsub_t *sp, evch_gevent_t *ep)
{
void *uep = &ep->ge_payload;
int res = EVQ_DELIVER;
if (sp->su_filter != NULL) {
res = sp->su_filter(uep, sp->su_fcookie);
}
if (res == EVQ_DELIVER) {
return (sp->su_callb(uep, sp->su_cbcookie));
}
return (0);
}
/*
* Holds event delivery in case of eq_holdmode set or in case the
* event queue is empty. Mutex must be held when called.
* Wakes up a thread waiting for the delivery thread reaching the hold mode.
*/
static void
evch_delivery_hold(evch_eventq_t *eqp, callb_cpr_t *cpip)
{
if (eqp->eq_tabortflag == 0) {
do {
if (eqp->eq_holdmode) {
cv_signal(&eqp->eq_onholdcv);
}
CALLB_CPR_SAFE_BEGIN(cpip);
cv_wait(&eqp->eq_thrsleepcv, &eqp->eq_queuemx);
CALLB_CPR_SAFE_END(cpip, &eqp->eq_queuemx);
} while (eqp->eq_holdmode);
}
}
/*
* Event delivery thread. Enumerates all subscribers and calls evch_deliver()
* for each one.
*/
static void
evch_delivery_thr(evch_eventq_t *eqp)
{
evch_qelem_t *qep;
callb_cpr_t cprinfo;
int res;
evch_evqsub_t *sub;
int deltime;
int repeatcount;
char thnam[32];
(void) snprintf(thnam, sizeof (thnam), "sysevent_chan-%d",
(int)eqp->eq_thrid);
CALLB_CPR_INIT(&cprinfo, &eqp->eq_queuemx, callb_generic_cpr, thnam);
mutex_enter(&eqp->eq_queuemx);
while (eqp->eq_tabortflag == 0) {
while (eqp->eq_holdmode == 0 && eqp->eq_tabortflag == 0 &&
(qep = evch_q_out(&eqp->eq_eventq)) != NULL) {
/* Filter and deliver event to all subscribers */
deltime = EVCH_MIN_PAUSE;
repeatcount = EVCH_MAX_TRY_DELIVERY;
eqp->eq_curevent = qep->q_objref;
sub = evch_dl_next(&eqp->eq_subscr, NULL);
while (sub != NULL) {
eqp->eq_dactive = 1;
mutex_exit(&eqp->eq_queuemx);
res = evch_deliver(sub, qep->q_objref);
mutex_enter(&eqp->eq_queuemx);
eqp->eq_dactive = 0;
cv_signal(&eqp->eq_dactivecv);
switch (res) {
case EVQ_SLEEP:
/*
* Wait for subscriber to return.
*/
eqp->eq_holdmode = 1;
evch_delivery_hold(eqp, &cprinfo);
if (eqp->eq_tabortflag) {
break;
}
continue;
case EVQ_AGAIN:
CALLB_CPR_SAFE_BEGIN(&cprinfo);
mutex_exit(&eqp->eq_queuemx);
delay(deltime);
deltime =
deltime > EVCH_MAX_PAUSE ?
deltime : deltime << 1;
mutex_enter(&eqp->eq_queuemx);
CALLB_CPR_SAFE_END(&cprinfo,
&eqp->eq_queuemx);
if (repeatcount-- > 0) {
continue;
}
break;
}
if (eqp->eq_tabortflag) {
break;
}
sub = evch_dl_next(&eqp->eq_subscr, sub);
repeatcount = EVCH_MAX_TRY_DELIVERY;
}
eqp->eq_curevent = NULL;
/* Free event data and queue element */
evch_gevent_free((evch_gevent_t *)qep->q_objref);
kmem_free(qep, qep->q_objsize);
}
/* Wait for next event or end of hold mode if set */
evch_delivery_hold(eqp, &cprinfo);
}
CALLB_CPR_EXIT(&cprinfo); /* Does mutex_exit of eqp->eq_queuemx */
thread_exit();
}
/*
* Create the event delivery thread for an existing event queue.
*/
static void
evch_evq_thrcreate(evch_eventq_t *eqp)
{
kthread_t *thp;
thp = thread_create(NULL, 0, evch_delivery_thr, (char *)eqp, 0, &p0,
TS_RUN, minclsyspri);
eqp->eq_thrid = thp->t_did;
}
/*
* Create event queue.
*/
static evch_eventq_t *
evch_evq_create()
{
evch_eventq_t *p;
/* Allocate and initialize event queue descriptor */
p = kmem_zalloc(sizeof (evch_eventq_t), KM_SLEEP);
mutex_init(&p->eq_queuemx, NULL, MUTEX_DEFAULT, NULL);
cv_init(&p->eq_thrsleepcv, NULL, CV_DEFAULT, NULL);
evch_q_init(&p->eq_eventq);
evch_dl_init(&p->eq_subscr);
cv_init(&p->eq_dactivecv, NULL, CV_DEFAULT, NULL);
cv_init(&p->eq_onholdcv, NULL, CV_DEFAULT, NULL);
/* Create delivery thread */
if (evq_initcomplete) {
evch_evq_thrcreate(p);
}
return (p);
}
/*
* Destroy an event queue. All subscribers have to be unsubscribed prior to
* this call.
*/
static void
evch_evq_destroy(evch_eventq_t *eqp)
{
evch_qelem_t *qep;
ASSERT(evch_dl_getnum(&eqp->eq_subscr) == 0);
/* Kill delivery thread */
if (eqp->eq_thrid != NULL) {
mutex_enter(&eqp->eq_queuemx);
eqp->eq_tabortflag = 1;
eqp->eq_holdmode = 0;
cv_signal(&eqp->eq_thrsleepcv);
mutex_exit(&eqp->eq_queuemx);
thread_join(eqp->eq_thrid);
}
/* Get rid of stale events in the event queue */
while ((qep = (evch_qelem_t *)evch_q_out(&eqp->eq_eventq)) != NULL) {
evch_gevent_free((evch_gevent_t *)qep->q_objref);
kmem_free(qep, qep->q_objsize);
}
/* Wrap up event queue structure */
cv_destroy(&eqp->eq_onholdcv);
cv_destroy(&eqp->eq_dactivecv);
cv_destroy(&eqp->eq_thrsleepcv);
evch_dl_fini(&eqp->eq_subscr);
mutex_destroy(&eqp->eq_queuemx);
/* Free descriptor structure */
kmem_free(eqp, sizeof (evch_eventq_t));
}
/*
* Subscribe to an event queue. Every subscriber provides a filter callback
* routine and an event delivery callback routine.
*/
static evch_evqsub_t *
evch_evq_sub(evch_eventq_t *eqp, filter_f filter, void *fcookie,
deliver_f callb, void *cbcookie)
{
evch_evqsub_t *sp = kmem_zalloc(sizeof (evch_evqsub_t), KM_SLEEP);
/* Initialize subscriber structure */
sp->su_filter = filter;
sp->su_fcookie = fcookie;
sp->su_callb = callb;
sp->su_cbcookie = cbcookie;
/* Add subscription to queue */
mutex_enter(&eqp->eq_queuemx);
evch_dl_add(&eqp->eq_subscr, &sp->su_link);
mutex_exit(&eqp->eq_queuemx);
return (sp);
}
/*
* Unsubscribe from an event queue.
*/
static void
evch_evq_unsub(evch_eventq_t *eqp, evch_evqsub_t *sp)
{
mutex_enter(&eqp->eq_queuemx);
/* Wait if delivery is just in progress */
if (eqp->eq_dactive) {
cv_wait(&eqp->eq_dactivecv, &eqp->eq_queuemx);
}
evch_dl_del(&eqp->eq_subscr, &sp->su_link);
mutex_exit(&eqp->eq_queuemx);
kmem_free(sp, sizeof (evch_evqsub_t));
}
/*
* Publish an event. Returns 0 on success and -1 if memory alloc failed.
*/
static int
evch_evq_pub(evch_eventq_t *eqp, void *ev, int flags)
{
size_t size;
evch_qelem_t *qep;
evch_gevent_t *evp = GEVENT(ev);
size = sizeof (evch_qelem_t);
if (flags & EVCH_TRYHARD) {
qep = kmem_alloc_tryhard(size, &size, KM_NOSLEEP);
} else {
qep = kmem_alloc(size, flags & EVCH_NOSLEEP ?
KM_NOSLEEP : KM_SLEEP);
}
if (qep == NULL) {
return (-1);
}
qep->q_objref = (void *)evp;
qep->q_objsize = size;
atomic_add_32(&evp->ge_refcount, 1);
mutex_enter(&eqp->eq_queuemx);
evch_q_in(&eqp->eq_eventq, qep);
/* Wakeup delivery thread */
cv_signal(&eqp->eq_thrsleepcv);
mutex_exit(&eqp->eq_queuemx);
return (0);
}
/*
* Enter hold mode of an event queue. Event delivery thread stops event
* handling after delivery of current event (if any).
*/
static void
evch_evq_stop(evch_eventq_t *eqp)
{
mutex_enter(&eqp->eq_queuemx);
eqp->eq_holdmode = 1;
if (evq_initcomplete) {
cv_signal(&eqp->eq_thrsleepcv);
cv_wait(&eqp->eq_onholdcv, &eqp->eq_queuemx);
}
mutex_exit(&eqp->eq_queuemx);
}
/*
* Continue event delivery.
*/
static void
evch_evq_continue(evch_eventq_t *eqp)
{
mutex_enter(&eqp->eq_queuemx);
eqp->eq_holdmode = 0;
cv_signal(&eqp->eq_thrsleepcv);
mutex_exit(&eqp->eq_queuemx);
}
/*
* Returns status of delivery thread. 0 if running and 1 if on hold.
*/
static int
evch_evq_status(evch_eventq_t *eqp)
{
return (eqp->eq_holdmode);
}
/*
* Add a destructor function to an event structure.
*/
static void
evch_evq_evadd_dest(void *ev, destr_f destructor, void *cookie)
{
evch_gevent_t *evp = GEVENT(ev);
evp->ge_destruct = destructor;
evp->ge_dstcookie = cookie;
}
/*
* Allocate evch_gevent_t structure. Return address of payload offset of
* evch_gevent_t. If EVCH_TRYHARD allocation is requested, we use
* kmem_alloc_tryhard to alloc memory of at least paylsize bytes.
*
* If either memory allocation is unsuccessful, we return NULL.
*/
static void *
evch_evq_evzalloc(size_t paylsize, int flag)
{
evch_gevent_t *evp;
size_t rsize, evsize, ge_size;
rsize = offsetof(evch_gevent_t, ge_payload) + paylsize;
if (flag & EVCH_TRYHARD) {
evp = kmem_alloc_tryhard(rsize, &evsize, KM_NOSLEEP);
ge_size = evsize;
} else {
evp = kmem_alloc(rsize, flag & EVCH_NOSLEEP ? KM_NOSLEEP :
KM_SLEEP);
ge_size = rsize;
}
if (evp) {
bzero(evp, rsize);
evp->ge_size = ge_size;
return (&evp->ge_payload);
}
return (evp);
}
/*
* Free event structure. Argument ev is address of payload offset.
*/
static void
evch_evq_evfree(void *ev)
{
evch_gevent_free(GEVENT(ev));
}
/*
* Iterate over all events in the event queue. Begin with an event
* which is currently being delivered. No mutexes are grabbed and no
* resources allocated so that this function can be called in panic
* context too. This function has to be called with ev == NULL initially.
* Actually argument ev is only a flag. Internally the member eq_nextev
* is used to determine the next event. But ev allows for the convenient
* use like
* ev = NULL;
* while ((ev = evch_evq_evnext(evp, ev)) != NULL) ...
*/
static void *
evch_evq_evnext(evch_eventq_t *evq, void *ev)
{
if (ev == NULL) {
evq->eq_nextev = NULL;
if (evq->eq_curevent != NULL)
return (&evq->eq_curevent->ge_payload);
}
evq->eq_nextev = evch_q_next(&evq->eq_eventq, evq->eq_nextev);
if (evq->eq_nextev == NULL)
return (NULL);
return (&((evch_gevent_t *)evq->eq_nextev->q_objref)->ge_payload);
}
/*
* Channel handling functions. First some support functions. Functions belonging
* to the channel handling interface start with evch_ch. The following functions
* make up the channel handling internal interfaces:
*
* evch_chinit - Initialize channel handling
* evch_chinitthr - Second step init: initialize threads
* evch_chbind - Bind to a channel
* evch_chunbind - Unbind from a channel
* evch_chsubscribe - Subscribe to a sysevent class
* evch_chunsubscribe - Unsubscribe
* evch_chpublish - Publish an event
* evch_chgetnames - Get names of all channels
* evch_chgetchdata - Get data of a channel
* evch_chrdevent_init - Init event q traversal
* evch_chgetnextev - Read out events queued for a subscriber
* evch_chrdevent_fini - Finish event q traversal
*/
/*
* Compare channel name. Used for evch_dl_search to find a channel with the
* name s.
*/
static int
evch_namecmp(evch_dlelem_t *ep, char *s)
{
return (strcmp(((evch_chan_t *)ep)->ch_name, s));
}
/*
* Simple wildcarded match test of event class string 'class' to
* wildcarded subscription string 'pat'. Recursive only if
* 'pat' includes a wildcard, otherwise essentially just strcmp.
*/
static int
evch_clsmatch(char *class, const char *pat)
{
char c;
do {
if ((c = *pat++) == '\0')
return (*class == '\0');
if (c == '*') {
while (*pat == '*')
pat++; /* consecutive *'s can be collapsed */
if (*pat == '\0')
return (1);
while (*class != '\0') {
if (evch_clsmatch(class++, pat) != 0)
return (1);
}
return (0);
}
} while (c == *class++);
return (0);
}
/*
* Sysevent filter callback routine. Enables event delivery only if it matches
* the event class pattern string given by parameter cookie.
*/
static int
evch_class_filter(void *ev, void *cookie)
{
const char *pat = (const char *)cookie;
if (pat == NULL || evch_clsmatch(SE_CLASS_NAME(ev), pat))
return (EVQ_DELIVER);
return (EVQ_IGNORE);
}
/*
* Callback routine to propagate the event into a per subscriber queue.
*/
static int
evch_subq_deliver(void *evp, void *cookie)
{
evch_subd_t *p = (evch_subd_t *)cookie;
(void) evch_evq_pub(p->sd_queue, evp, EVCH_SLEEP);
return (EVQ_CONT);
}
/*
* Call kernel callback routine for sysevent kernel delivery.
*/
static int
evch_kern_deliver(void *evp, void *cookie)
{
sysevent_impl_t *ev = (sysevent_impl_t *)evp;
evch_subd_t *sdp = (evch_subd_t *)cookie;
return (sdp->sd_callback(ev, sdp->sd_cbcookie));
}
/*
* Door upcall for user land sysevent delivery.
*/
static int
evch_door_deliver(void *evp, void *cookie)
{
int error;
size_t size;
sysevent_impl_t *ev = (sysevent_impl_t *)evp;
door_arg_t darg;
evch_subd_t *sdp = (evch_subd_t *)cookie;
int nticks = EVCH_MIN_PAUSE;
uint32_t retval;
int retry = 20;
/* Initialize door args */
size = sizeof (sysevent_impl_t) + SE_PAYLOAD_SZ(ev);
darg.rbuf = (char *)&retval;
darg.rsize = sizeof (retval);
darg.data_ptr = (char *)ev;
darg.data_size = size;
darg.desc_ptr = NULL;
darg.desc_num = 0;
for (;;) {
if ((error = door_ki_upcall_limited(sdp->sd_door, &darg,
NULL, SIZE_MAX, 0)) == 0) {
break;
}
switch (error) {
case EAGAIN:
/* Cannot deliver event - process may be forking */
delay(nticks);
nticks <<= 1;
if (nticks > EVCH_MAX_PAUSE) {
nticks = EVCH_MAX_PAUSE;
}
if (retry-- <= 0) {
cmn_err(CE_CONT, "event delivery thread: "
"door_ki_upcall error EAGAIN\n");
return (EVQ_CONT);
}
break;
case EINTR:
case EBADF:
/* Process died */
return (EVQ_SLEEP);
default:
cmn_err(CE_CONT,
"event delivery thread: door_ki_upcall error %d\n",
error);
return (EVQ_CONT);
}
}
if (retval == EAGAIN) {
return (EVQ_AGAIN);
}
return (EVQ_CONT);
}
/*
* Callback routine for evch_dl_search() to compare subscriber id's. Used by
* evch_subscribe() and evch_chrdevent_init().
*/
static int
evch_subidcmp(evch_dlelem_t *ep, char *s)
{
return (strcmp(((evch_subd_t *)ep)->sd_ident, s));
}
/*
* Callback routine for evch_dl_search() to find a subscriber with EVCH_SUB_DUMP
* set (indicated by sub->sd_dump != 0). Used by evch_chrdevent_init() and
* evch_subscribe(). Needs to returns 0 if subscriber with sd_dump set is
* found.
*/
/*ARGSUSED1*/
static int
evch_dumpflgcmp(evch_dlelem_t *ep, char *s)
{
return (((evch_subd_t *)ep)->sd_dump ? 0 : 1);
}
/*
* Event destructor function. Used to maintain the number of events per channel.
*/
/*ARGSUSED*/
static void
evch_destr_event(void *ev, void *ch)
{
evch_chan_t *chp = (evch_chan_t *)ch;
mutex_enter(&chp->ch_pubmx);
chp->ch_nevents--;
cv_signal(&chp->ch_pubcv);
mutex_exit(&chp->ch_pubmx);
}
/*
* Integer square root according to Newton's iteration.
*/
static uint32_t
evch_isqrt(uint64_t n)
{
uint64_t x = n >> 1;
uint64_t xn = x - 1;
static uint32_t lowval[] = { 0, 1, 1, 2 };
if (n < 4) {
return (lowval[n]);
}
while (xn < x) {
x = xn;
xn = (x + n / x) / 2;
}
return ((uint32_t)xn);
}
/*
* First step sysevent channel initialization. Called when kernel memory
* allocator is initialized.
*/
static void
evch_chinit()
{
size_t k;
/*
* Calculate limits: max no of channels and max no of events per
* channel. The smallest machine with 128 MByte will allow for
* >= 8 channels and an upper limit of 2048 events per channel.
* The event limit is the number of channels times 256 (hence
* the shift factor of 8). These number where selected arbitrarily.
*/
k = kmem_maxavail() >> 20;
evch_channels_max = min(evch_isqrt(k), EVCH_MAX_CHANNELS);
evch_events_max = evch_channels_max << 8;
/*
* Will trigger creation of the global zone's evch state.
*/
zone_key_create(&evch_zone_key, evch_zoneinit, NULL, evch_zonefree);
}
/*
* Second step sysevent channel initialization. Called when threads are ready.
*/
static void
evch_chinitthr()
{
struct evch_globals *eg;
evch_chan_t *chp;
evch_subd_t *sdp;
/*
* We're early enough in boot that we know that only the global
* zone exists; we only need to initialize its threads.
*/
eg = zone_getspecific(evch_zone_key, global_zone);
ASSERT(eg != NULL);
for (chp = evch_dl_next(&eg->evch_list, NULL); chp != NULL;
chp = evch_dl_next(&eg->evch_list, chp)) {
for (sdp = evch_dl_next(&chp->ch_subscr, NULL); sdp;
sdp = evch_dl_next(&chp->ch_subscr, sdp)) {
evch_evq_thrcreate(sdp->sd_queue);
}
evch_evq_thrcreate(chp->ch_queue);
}
evq_initcomplete = 1;
}
/*
* Sysevent channel bind. Create channel and allocate binding structure.
*/
static int
evch_chbind(const char *chnam, evch_bind_t **scpp, uint32_t flags)
{
struct evch_globals *eg;
evch_bind_t *bp;
evch_chan_t *p;
char *chn;
size_t namlen;
int rv;
eg = zone_getspecific(evch_zone_key, curproc->p_zone);
ASSERT(eg != NULL);
/* Create channel if it does not exist */
ASSERT(evch_dl_is_init(&eg->evch_list));
if ((namlen = strlen(chnam) + 1) > MAX_CHNAME_LEN) {
return (EINVAL);
}
mutex_enter(&eg->evch_list_lock);
if ((p = (evch_chan_t *)evch_dl_search(&eg->evch_list, evch_namecmp,
(char *)chnam)) == NULL) {
if (flags & EVCH_CREAT) {
if (evch_dl_getnum(&eg->evch_list) >=
evch_channels_max) {
mutex_exit(&eg->evch_list_lock);
return (ENOMEM);
}
chn = kmem_alloc(namlen, KM_SLEEP);
bcopy(chnam, chn, namlen);
/* Allocate and initialize channel descriptor */
p = kmem_zalloc(sizeof (evch_chan_t), KM_SLEEP);
p->ch_name = chn;
p->ch_namelen = namlen;
mutex_init(&p->ch_mutex, NULL, MUTEX_DEFAULT, NULL);
p->ch_queue = evch_evq_create();
evch_dl_init(&p->ch_subscr);
if (evq_initcomplete) {
p->ch_uid = crgetuid(curthread->t_cred);
p->ch_gid = crgetgid(curthread->t_cred);
}
cv_init(&p->ch_pubcv, NULL, CV_DEFAULT, NULL);
mutex_init(&p->ch_pubmx, NULL, MUTEX_DEFAULT, NULL);
p->ch_maxev = min(EVCH_DEFAULT_EVENTS, evch_events_max);
p->ch_maxsubscr = EVCH_MAX_SUBSCRIPTIONS;
p->ch_maxbinds = evch_bindings_max;
p->ch_ctime = gethrestime_sec();
if (flags & (EVCH_HOLD_PEND | EVCH_HOLD_PEND_INDEF)) {
if (flags & EVCH_HOLD_PEND_INDEF)
p->ch_holdpend = CH_HOLD_PEND_INDEF;
else
p->ch_holdpend = CH_HOLD_PEND;
evch_evq_stop(p->ch_queue);
}
/* Put new descriptor into channel list */
evch_dl_add(&eg->evch_list, (evch_dlelem_t *)p);
} else {
mutex_exit(&eg->evch_list_lock);
return (ENOENT);
}
}
/* Check for max binds and create binding */
mutex_enter(&p->ch_mutex);
if (p->ch_bindings >= p->ch_maxbinds) {
rv = ENOMEM;
/*
* No need to destroy the channel because this call did not
* create it. Other bindings will be present if ch_maxbinds
* is exceeded.
*/
goto errorexit;
}
bp = kmem_alloc(sizeof (evch_bind_t), KM_SLEEP);
bp->bd_channel = p;
bp->bd_sublst = NULL;
p->ch_bindings++;
rv = 0;
*scpp = bp;
errorexit:
mutex_exit(&p->ch_mutex);
mutex_exit(&eg->evch_list_lock);
return (rv);
}
/*
* Unbind: Free bind structure. Remove channel if last binding was freed.
*/
static void
evch_chunbind(evch_bind_t *bp)
{
struct evch_globals *eg;
evch_chan_t *chp = bp->bd_channel;
eg = zone_getspecific(evch_zone_key, curproc->p_zone);
ASSERT(eg != NULL);
mutex_enter(&eg->evch_list_lock);
mutex_enter(&chp->ch_mutex);
ASSERT(chp->ch_bindings > 0);
chp->ch_bindings--;
kmem_free(bp, sizeof (evch_bind_t));
if (chp->ch_bindings == 0 && evch_dl_getnum(&chp->ch_subscr) == 0 &&
(chp->ch_nevents == 0 || chp->ch_holdpend != CH_HOLD_PEND_INDEF)) {
/*
* No more bindings and no persistent subscriber(s). If there
* are no events in the channel then destroy the channel;
* otherwise destroy the channel only if we're not holding
* pending events indefinitely.
*/
mutex_exit(&chp->ch_mutex);
evch_dl_del(&eg->evch_list, &chp->ch_link);
evch_evq_destroy(chp->ch_queue);
mutex_destroy(&chp->ch_mutex);
mutex_destroy(&chp->ch_pubmx);
cv_destroy(&chp->ch_pubcv);
kmem_free(chp->ch_name, chp->ch_namelen);
kmem_free(chp, sizeof (evch_chan_t));
} else
mutex_exit(&chp->ch_mutex);
mutex_exit(&eg->evch_list_lock);
}
static int
wildcard_count(const char *class)
{
int count = 0;
char c;
if (class == NULL)
return (0);
while ((c = *class++) != '\0') {
if (c == '*')
count++;
}
return (count);
}
/*
* Subscribe to a channel. dtype is either EVCH_DELKERN for kernel callbacks
* or EVCH_DELDOOR for door upcall delivery to user land. Depending on dtype
* dinfo gives the call back routine address or the door handle.
*/
static int
evch_chsubscribe(evch_bind_t *bp, int dtype, const char *sid, const char *class,
void *dinfo, void *cookie, int flags, pid_t pid)
{
evch_chan_t *chp = bp->bd_channel;
evch_eventq_t *eqp = chp->ch_queue;
evch_subd_t *sdp;
evch_subd_t *esp;
int (*delivfkt)();
char *clb = NULL;
int clblen = 0;
char *subid;
int subidblen;
/*
* Check if only known flags are set.
*/
if (flags & ~(EVCH_SUB_KEEP | EVCH_SUB_DUMP))
return (EINVAL);
/*
* Enforce a limit on the number of wildcards allowed in the class
* subscription string (limits recursion in pattern matching).
*/
if (wildcard_count(class) > EVCH_WILDCARD_MAX)
return (EINVAL);
/*
* Check if we have already a subscription with that name and if we
* have to reconnect the subscriber to a persistent subscription.
*/
mutex_enter(&chp->ch_mutex);
if ((esp = (evch_subd_t *)evch_dl_search(&chp->ch_subscr,
evch_subidcmp, (char *)sid)) != NULL) {
int error = 0;
if ((flags & EVCH_SUB_KEEP) && (esp->sd_active == 0)) {
/*
* Subscription with the name on hold, reconnect to
* existing queue.
*/
ASSERT(dtype == EVCH_DELDOOR);
esp->sd_subnxt = bp->bd_sublst;
bp->bd_sublst = esp;
esp->sd_pid = pid;
esp->sd_door = (door_handle_t)dinfo;
esp->sd_active++;
evch_evq_continue(esp->sd_queue);
} else {
/* Subscriber with given name already exists */
error = EEXIST;
}
mutex_exit(&chp->ch_mutex);
return (error);
}
if (evch_dl_getnum(&chp->ch_subscr) >= chp->ch_maxsubscr) {
mutex_exit(&chp->ch_mutex);
return (ENOMEM);
}
if (flags & EVCH_SUB_DUMP && evch_dl_search(&chp->ch_subscr,
evch_dumpflgcmp, NULL) != NULL) {
/*
* Subscription with EVCH_SUB_DUMP flagged already exists.
* Only one subscription with EVCH_SUB_DUMP possible. Return
* error.
*/
mutex_exit(&chp->ch_mutex);
return (EINVAL);
}
if (class != NULL) {
clblen = strlen(class) + 1;
clb = kmem_alloc(clblen, KM_SLEEP);
bcopy(class, clb, clblen);
}
subidblen = strlen(sid) + 1;
subid = kmem_alloc(subidblen, KM_SLEEP);
bcopy(sid, subid, subidblen);
/* Create per subscriber queue */
sdp = kmem_zalloc(sizeof (evch_subd_t), KM_SLEEP);
sdp->sd_queue = evch_evq_create();
/* Subscribe to subscriber queue */
sdp->sd_persist = flags & EVCH_SUB_KEEP ? 1 : 0;
sdp->sd_dump = flags & EVCH_SUB_DUMP ? 1 : 0;
sdp->sd_type = dtype;
sdp->sd_cbcookie = cookie;
sdp->sd_ident = subid;
if (dtype == EVCH_DELKERN) {
sdp->sd_callback = (kerndlv_f)dinfo;
delivfkt = evch_kern_deliver;
} else {
sdp->sd_door = (door_handle_t)dinfo;
delivfkt = evch_door_deliver;
}
sdp->sd_ssub =
evch_evq_sub(sdp->sd_queue, NULL, NULL, delivfkt, (void *)sdp);
/* Connect per subscriber queue to main event queue */
sdp->sd_msub = evch_evq_sub(eqp, evch_class_filter, clb,
evch_subq_deliver, (void *)sdp);
sdp->sd_classname = clb;
sdp->sd_clnsize = clblen;
sdp->sd_pid = pid;
sdp->sd_active++;
/* Add subscription to binding */
sdp->sd_subnxt = bp->bd_sublst;
bp->bd_sublst = sdp;
/* Add subscription to channel */
evch_dl_add(&chp->ch_subscr, &sdp->sd_link);
if (chp->ch_holdpend && evch_dl_getnum(&chp->ch_subscr) == 1) {
/* Let main event queue run in case of HOLDPEND */
evch_evq_continue(eqp);
}
mutex_exit(&chp->ch_mutex);
return (0);
}
/*
* If flag == EVCH_SUB_KEEP only non-persistent subscriptions are deleted.
* When sid == NULL all subscriptions except the ones with EVCH_SUB_KEEP set
* are removed.
*/
static void
evch_chunsubscribe(evch_bind_t *bp, const char *sid, uint32_t flags)
{
evch_subd_t *sdp;
evch_subd_t *next;
evch_subd_t *prev;
evch_chan_t *chp = bp->bd_channel;
mutex_enter(&chp->ch_mutex);
if (chp->ch_holdpend) {
evch_evq_stop(chp->ch_queue); /* Hold main event queue */
}
prev = NULL;
for (sdp = bp->bd_sublst; sdp; sdp = next) {
if (sid == NULL || strcmp(sid, sdp->sd_ident) == 0) {
if (flags == 0 || sdp->sd_persist == 0) {
/*
* Disconnect subscriber queue from main event
* queue.
*/
evch_evq_unsub(chp->ch_queue, sdp->sd_msub);
/* Destruct per subscriber queue */
evch_evq_unsub(sdp->sd_queue, sdp->sd_ssub);
evch_evq_destroy(sdp->sd_queue);
/*
* Eliminate the subscriber data from channel
* list.
*/
evch_dl_del(&chp->ch_subscr, &sdp->sd_link);
kmem_free(sdp->sd_classname, sdp->sd_clnsize);
if (sdp->sd_type == EVCH_DELDOOR) {
door_ki_rele(sdp->sd_door);
}
next = sdp->sd_subnxt;
if (prev) {
prev->sd_subnxt = next;
} else {
bp->bd_sublst = next;
}
kmem_free(sdp->sd_ident,
strlen(sdp->sd_ident) + 1);
kmem_free(sdp, sizeof (evch_subd_t));
} else {
/*
* EVCH_SUB_KEEP case
*/
evch_evq_stop(sdp->sd_queue);
if (sdp->sd_type == EVCH_DELDOOR) {
door_ki_rele(sdp->sd_door);
}
sdp->sd_active--;
ASSERT(sdp->sd_active == 0);
next = sdp->sd_subnxt;
prev = sdp;
}
if (sid != NULL) {
break;
}
} else {
next = sdp->sd_subnxt;
prev = sdp;
}
}
if (!(chp->ch_holdpend && evch_dl_getnum(&chp->ch_subscr) == 0)) {
/*
* Continue dispatch thread except if no subscribers are present
* in HOLDPEND mode.
*/
evch_evq_continue(chp->ch_queue);
}
mutex_exit(&chp->ch_mutex);
}
/*
* Publish an event. Returns zero on success and an error code else.
*/
static int
evch_chpublish(evch_bind_t *bp, sysevent_impl_t *ev, int flags)
{
evch_chan_t *chp = bp->bd_channel;
DTRACE_SYSEVENT2(post, evch_bind_t *, bp, sysevent_impl_t *, ev);
mutex_enter(&chp->ch_pubmx);
if (chp->ch_nevents >= chp->ch_maxev) {
if (!(flags & EVCH_QWAIT)) {
evch_evq_evfree(ev);
mutex_exit(&chp->ch_pubmx);
return (EAGAIN);
} else {
while (chp->ch_nevents >= chp->ch_maxev) {
if (cv_wait_sig(&chp->ch_pubcv,
&chp->ch_pubmx) == 0) {
/* Got Signal, return EINTR */
evch_evq_evfree(ev);
mutex_exit(&chp->ch_pubmx);
return (EINTR);
}
}
}
}
chp->ch_nevents++;
mutex_exit(&chp->ch_pubmx);
SE_TIME(ev) = gethrtime();
SE_SEQ(ev) = log_sysevent_new_id();
/*
* Add the destructor function to the event structure, now that the
* event is accounted for. The only task of the descructor is to
* decrement the channel event count. The evq_*() routines (including
* the event delivery thread) do not have knowledge of the channel
* data. So the anonymous destructor handles the channel data for it.
*/
evch_evq_evadd_dest(ev, evch_destr_event, (void *)chp);
return (evch_evq_pub(chp->ch_queue, ev, flags) == 0 ? 0 : EAGAIN);
}
/*
* Fills a buffer consecutive with the names of all available channels.
* Returns the length of all name strings or -1 if buffer size was unsufficient.
*/
static int
evch_chgetnames(char *buf, size_t size)
{
struct evch_globals *eg;
int len = 0;
char *addr = buf;
int max = size;
evch_chan_t *chp;
eg = zone_getspecific(evch_zone_key, curproc->p_zone);
ASSERT(eg != NULL);
mutex_enter(&eg->evch_list_lock);
for (chp = evch_dl_next(&eg->evch_list, NULL); chp != NULL;
chp = evch_dl_next(&eg->evch_list, chp)) {
len += chp->ch_namelen;
if (len >= max) {
mutex_exit(&eg->evch_list_lock);
return (-1);
}
bcopy(chp->ch_name, addr, chp->ch_namelen);
addr += chp->ch_namelen;
}
mutex_exit(&eg->evch_list_lock);
addr[0] = 0;
return (len + 1);
}
/*
* Fills the data of one channel and all subscribers of that channel into
* a buffer. Returns -1 if the channel name is invalid and 0 on buffer overflow.
*/
static int
evch_chgetchdata(char *chname, void *buf, size_t size)
{
struct evch_globals *eg;
char *cpaddr;
int bufmax;
int buflen;
evch_chan_t *chp;
sev_chinfo_t *p = (sev_chinfo_t *)buf;
int chdlen;
evch_subd_t *sdp;
sev_subinfo_t *subp;
int idlen;
int len;
eg = zone_getspecific(evch_zone_key, curproc->p_zone);
ASSERT(eg != NULL);
mutex_enter(&eg->evch_list_lock);
chp = (evch_chan_t *)evch_dl_search(&eg->evch_list, evch_namecmp,
chname);
if (chp == NULL) {
mutex_exit(&eg->evch_list_lock);
return (-1);
}
chdlen = offsetof(sev_chinfo_t, cd_subinfo);
if (size < chdlen) {
mutex_exit(&eg->evch_list_lock);
return (0);
}
p->cd_version = 0;
p->cd_suboffs = chdlen;
p->cd_uid = chp->ch_uid;
p->cd_gid = chp->ch_gid;
p->cd_perms = 0;
p->cd_ctime = chp->ch_ctime;
p->cd_maxev = chp->ch_maxev;
p->cd_evhwm = EVCH_EVQ_HIGHWM(chp->ch_queue);
p->cd_nevents = EVCH_EVQ_EVCOUNT(chp->ch_queue);
p->cd_maxsub = chp->ch_maxsubscr;
p->cd_nsub = evch_dl_getnum(&chp->ch_subscr);
p->cd_maxbinds = chp->ch_maxbinds;
p->cd_nbinds = chp->ch_bindings;
p->cd_holdpend = chp->ch_holdpend;
p->cd_limev = evch_events_max;
cpaddr = (char *)p + chdlen;
bufmax = size - chdlen;
buflen = 0;
for (sdp = evch_dl_next(&chp->ch_subscr, NULL); sdp != NULL;
sdp = evch_dl_next(&chp->ch_subscr, sdp)) {
idlen = strlen(sdp->sd_ident) + 1;
len = SE_ALIGN(offsetof(sev_subinfo_t, sb_strings) + idlen +
sdp->sd_clnsize);
buflen += len;
if (buflen >= bufmax) {
mutex_exit(&eg->evch_list_lock);
return (0);
}
subp = (sev_subinfo_t *)cpaddr;
subp->sb_nextoff = len;
subp->sb_stroff = offsetof(sev_subinfo_t, sb_strings);
if (sdp->sd_classname) {
bcopy(sdp->sd_classname, subp->sb_strings + idlen,
sdp->sd_clnsize);
subp->sb_clnamoff = idlen;
} else {
subp->sb_clnamoff = idlen - 1;
}
subp->sb_pid = sdp->sd_pid;
subp->sb_nevents = EVCH_EVQ_EVCOUNT(sdp->sd_queue);
subp->sb_evhwm = EVCH_EVQ_HIGHWM(sdp->sd_queue);
subp->sb_persist = sdp->sd_persist;
subp->sb_status = evch_evq_status(sdp->sd_queue);
subp->sb_active = sdp->sd_active;
subp->sb_dump = sdp->sd_dump;
bcopy(sdp->sd_ident, subp->sb_strings, idlen);
cpaddr += len;
}
mutex_exit(&eg->evch_list_lock);
return (chdlen + buflen);
}
/*
* Init iteration of all events of a channel. This function creates a new
* event queue and puts all events from the channel into that queue.
* Subsequent calls to evch_chgetnextev will deliver the events from that
* queue. Only one thread per channel is allowed to read through the events.
* Returns 0 on success and 1 if there is already someone reading the
* events.
* If argument subid == NULL, we look for a subscriber which has
* flag EVCH_SUB_DUMP set.
*/
/*
* Static variables that are used to traverse events of a channel in panic case.
*/
static evch_chan_t *evch_chan;
static evch_eventq_t *evch_subq;
static sysevent_impl_t *evch_curev;
static evchanq_t *
evch_chrdevent_init(evch_chan_t *chp, char *subid)
{
evch_subd_t *sdp;
void *ev;
int pmqstat; /* Prev status of main queue */
int psqstat; /* Prev status of subscriber queue */
evchanq_t *snp; /* Pointer to q with snapshot of ev */
compare_f compfunc;
compfunc = subid == NULL ? evch_dumpflgcmp : evch_subidcmp;
if (panicstr != NULL) {
evch_chan = chp;
evch_subq = NULL;
evch_curev = NULL;
if ((sdp = (evch_subd_t *)evch_dl_search(&chp->ch_subscr,
compfunc, subid)) != NULL) {
evch_subq = sdp->sd_queue;
}
return (NULL);
}
mutex_enter(&chp->ch_mutex);
sdp = (evch_subd_t *)evch_dl_search(&chp->ch_subscr, compfunc, subid);
/*
* Stop main event queue and subscriber queue if not already
* in stop mode.
*/
pmqstat = evch_evq_status(chp->ch_queue);
if (pmqstat == 0)
evch_evq_stop(chp->ch_queue);
if (sdp != NULL) {
psqstat = evch_evq_status(sdp->sd_queue);
if (psqstat == 0)
evch_evq_stop(sdp->sd_queue);
}
/*
* Create event queue to make a snapshot of all events in the
* channel.
*/
snp = kmem_alloc(sizeof (evchanq_t), KM_SLEEP);
snp->sn_queue = evch_evq_create();
evch_evq_stop(snp->sn_queue);
/*
* Make a snapshot of the subscriber queue and the main event queue.
*/
if (sdp != NULL) {
ev = NULL;
while ((ev = evch_evq_evnext(sdp->sd_queue, ev)) != NULL) {
(void) evch_evq_pub(snp->sn_queue, ev, EVCH_SLEEP);
}
}
ev = NULL;
while ((ev = evch_evq_evnext(chp->ch_queue, ev)) != NULL) {
(void) evch_evq_pub(snp->sn_queue, ev, EVCH_SLEEP);
}
snp->sn_nxtev = NULL;
/*
* Restart main and subscriber queue if previously stopped
*/
if (sdp != NULL && psqstat == 0)
evch_evq_continue(sdp->sd_queue);
if (pmqstat == 0)
evch_evq_continue(chp->ch_queue);
mutex_exit(&chp->ch_mutex);
return (snp);
}
/*
* Free all resources of the event queue snapshot. In case of panic
* context snp must be NULL and no resources need to be free'ed.
*/
static void
evch_chrdevent_fini(evchanq_t *snp)
{
if (snp != NULL) {
evch_evq_destroy(snp->sn_queue);
kmem_free(snp, sizeof (evchanq_t));
}
}
/*
* Get address of next event from an event channel.
* This function might be called in a panic context. In that case
* no resources will be allocated and no locks grabbed.
* In normal operation context a snapshot of the event queues of the
* specified event channel will be taken.
*/
static sysevent_impl_t *
evch_chgetnextev(evchanq_t *snp)
{
if (panicstr != NULL) {
if (evch_chan == NULL)
return (NULL);
if (evch_subq != NULL) {
/*
* We have a subscriber queue. Traverse this queue
* first.
*/
if ((evch_curev = (sysevent_impl_t *)
evch_evq_evnext(evch_subq, evch_curev)) != NULL) {
return (evch_curev);
} else {
/*
* All subscriber events traversed. evch_subq
* == NULL indicates to take the main event
* queue now.
*/
evch_subq = NULL;
}
}
/*
* Traverse the main event queue.
*/
if ((evch_curev = (sysevent_impl_t *)
evch_evq_evnext(evch_chan->ch_queue, evch_curev)) ==
NULL) {
evch_chan = NULL;
}
return (evch_curev);
}
ASSERT(snp != NULL);
snp->sn_nxtev = (sysevent_impl_t *)evch_evq_evnext(snp->sn_queue,
snp->sn_nxtev);
return (snp->sn_nxtev);
}
/*
* The functions below build up the interface for the kernel to bind/unbind,
* subscribe/unsubscribe and publish to event channels. It consists of the
* following functions:
*
* sysevent_evc_bind - Bind to a channel. Create a channel if required
* sysevent_evc_unbind - Unbind from a channel. Destroy ch. if last unbind
* sysevent_evc_subscribe - Subscribe to events from a channel
* sysevent_evc_unsubscribe - Unsubscribe from an event class
* sysevent_evc_publish - Publish an event to an event channel
* sysevent_evc_control - Various control operation on event channel
*
* The function below are for evaluating a sysevent:
*
* sysevent_get_class_name - Get pointer to event class string
* sysevent_get_subclass_name - Get pointer to event subclass string
* sysevent_get_seq - Get unique event sequence number
* sysevent_get_time - Get hrestime of event publish
* sysevent_get_size - Get size of event structure
* sysevent_get_pub - Get publisher string
* sysevent_get_attr_list - Get copy of attribute list
*
* The following interfaces represent stability level project privat
* and allow to save the events of an event channel even in a panic case.
*
* sysevent_evc_walk_init - Take a snapshot of the events in a channel
* sysevent_evc_walk_step - Read next event from snapshot
* sysevent_evc_walk_fini - Free resources from event channel snapshot
* sysevent_evc_event_attr - Get event payload address and size
*/
/*
* allocate sysevent structure with optional space for attributes
*/
static sysevent_impl_t *
sysevent_evc_alloc(const char *class, const char *subclass, const char *pub,
size_t pub_sz, size_t atsz, uint32_t flag)
{
int payload_sz;
int class_sz, subclass_sz;
int aligned_class_sz, aligned_subclass_sz, aligned_pub_sz;
sysevent_impl_t *ev;
/*
* Calculate and reserve space for the class, subclass and
* publisher strings in the event buffer
*/
class_sz = strlen(class) + 1;
subclass_sz = strlen(subclass) + 1;
ASSERT((class_sz <= MAX_CLASS_LEN) && (subclass_sz <=
MAX_SUBCLASS_LEN) && (pub_sz <= MAX_PUB_LEN));
/* String sizes must be 64-bit aligned in the event buffer */
aligned_class_sz = SE_ALIGN(class_sz);
aligned_subclass_sz = SE_ALIGN(subclass_sz);
aligned_pub_sz = SE_ALIGN(pub_sz);
/*
* Calculate payload size. Consider the space needed for alignment
* and subtract the size of the uint64_t placeholder variables of
* sysevent_impl_t.
*/
payload_sz = (aligned_class_sz - sizeof (uint64_t)) +
(aligned_subclass_sz - sizeof (uint64_t)) +
(aligned_pub_sz - sizeof (uint64_t)) - sizeof (uint64_t) +
atsz;
/*
* Allocate event buffer plus additional payload overhead
*/
if ((ev = evch_evq_evzalloc(sizeof (sysevent_impl_t) +
payload_sz, flag)) == NULL) {
return (NULL);
}
/* Initialize the event buffer data */
SE_VERSION(ev) = SYS_EVENT_VERSION;
bcopy(class, SE_CLASS_NAME(ev), class_sz);
SE_SUBCLASS_OFF(ev) = SE_ALIGN(offsetof(sysevent_impl_t,
se_class_name)) + aligned_class_sz;
bcopy(subclass, SE_SUBCLASS_NAME(ev), subclass_sz);
SE_PUB_OFF(ev) = SE_SUBCLASS_OFF(ev) + aligned_subclass_sz;
bcopy(pub, SE_PUB_NAME(ev), pub_sz);
SE_ATTR_PTR(ev) = (uint64_t)0;
SE_PAYLOAD_SZ(ev) = payload_sz;
return (ev);
}
/*
* Initialize event channel handling queues.
*/
void
sysevent_evc_init()
{
evch_chinit();
}
/*
* Second initialization step: create threads, if event channels are already
* created
*/
void
sysevent_evc_thrinit()
{
evch_chinitthr();
}
int
sysevent_evc_bind(const char *ch_name, evchan_t **scpp, uint32_t flags)
{
ASSERT(ch_name != NULL && scpp != NULL);
ASSERT((flags & ~EVCH_B_FLAGS) == 0);
return (evch_chbind(ch_name, (evch_bind_t **)scpp, flags));
}
int
sysevent_evc_unbind(evchan_t *scp)
{
evch_bind_t *bp = (evch_bind_t *)scp;
ASSERT(scp != NULL);
evch_chunsubscribe(bp, NULL, 0);
evch_chunbind(bp);
return (0);
}
int
sysevent_evc_subscribe(evchan_t *scp, const char *sid, const char *class,
int (*callb)(sysevent_t *ev, void *cookie),
void *cookie, uint32_t flags)
{
ASSERT(scp != NULL && sid != NULL && class != NULL && callb != NULL);
ASSERT(flags == 0);
if (strlen(sid) > MAX_SUBID_LEN) {
return (EINVAL);
}
if (strcmp(class, EC_ALL) == 0) {
class = NULL;
}
return (evch_chsubscribe((evch_bind_t *)scp, EVCH_DELKERN, sid, class,
(void *)callb, cookie, 0, 0));
}
int
sysevent_evc_unsubscribe(evchan_t *scp, const char *sid)
{
ASSERT(scp != NULL && sid != NULL);
if (strcmp(sid, EVCH_ALLSUB) == 0) {
sid = NULL;
}
evch_chunsubscribe((evch_bind_t *)scp, sid, 0);
return (0);
}
/*
* Publish kernel event. Returns 0 on success, error code else.
* Optional attribute data is packed into the event structure.
*/
int
sysevent_evc_publish(evchan_t *scp, const char *class, const char *subclass,
const char *vendor, const char *pubs, nvlist_t *attr, uint32_t flags)
{
sysevent_impl_t *evp;
char pub[MAX_PUB_LEN];
int pub_sz; /* includes terminating 0 */
int km_flags;
size_t asz = 0;
uint64_t attr_offset;
caddr_t patt;
int err;
ASSERT(scp != NULL && class != NULL && subclass != NULL &&
vendor != NULL && pubs != NULL);
ASSERT((flags & ~(EVCH_SLEEP | EVCH_NOSLEEP | EVCH_TRYHARD |
EVCH_QWAIT)) == 0);
km_flags = flags & (EVCH_SLEEP | EVCH_NOSLEEP | EVCH_TRYHARD);
ASSERT(km_flags == EVCH_SLEEP || km_flags == EVCH_NOSLEEP ||
km_flags == EVCH_TRYHARD);
pub_sz = snprintf(pub, MAX_PUB_LEN, "%s:kern:%s", vendor, pubs) + 1;
if (pub_sz > MAX_PUB_LEN)
return (EINVAL);
if (attr != NULL) {
if ((err = nvlist_size(attr, &asz, NV_ENCODE_NATIVE)) != 0) {
return (err);
}
}
evp = sysevent_evc_alloc(class, subclass, pub, pub_sz, asz, km_flags);
if (evp == NULL) {
return (ENOMEM);
}
if (attr != NULL) {
/*
* Pack attributes into event buffer. Event buffer already
* has enough room for the packed nvlist.
*/
attr_offset = SE_ATTR_OFF(evp);
patt = (caddr_t)evp + attr_offset;
err = nvlist_pack(attr, &patt, &asz, NV_ENCODE_NATIVE,
km_flags & EVCH_SLEEP ? KM_SLEEP : KM_NOSLEEP);
ASSERT(err != ENOMEM);
if (err != 0) {
return (EINVAL);
}
evp->seh_attr_off = attr_offset;
SE_FLAG(evp) = SE_PACKED_BUF;
}
return (evch_chpublish((evch_bind_t *)scp, evp, flags));
}
int
sysevent_evc_control(evchan_t *scp, int cmd, ...)
{
va_list ap;
evch_chan_t *chp = ((evch_bind_t *)scp)->bd_channel;
uint32_t *chlenp;
uint32_t chlen;
uint32_t ochlen;
int rc = 0;
if (scp == NULL) {
return (EINVAL);
}
va_start(ap, cmd);
mutex_enter(&chp->ch_mutex);
switch (cmd) {
case EVCH_GET_CHAN_LEN:
chlenp = va_arg(ap, uint32_t *);
*chlenp = chp->ch_maxev;
break;
case EVCH_SET_CHAN_LEN:
chlen = va_arg(ap, uint32_t);
ochlen = chp->ch_maxev;
chp->ch_maxev = min(chlen, evch_events_max);
if (ochlen < chp->ch_maxev) {
cv_signal(&chp->ch_pubcv);
}
break;
case EVCH_GET_CHAN_LEN_MAX:
*va_arg(ap, uint32_t *) = evch_events_max;
break;
default:
rc = EINVAL;
}
mutex_exit(&chp->ch_mutex);
va_end(ap);
return (rc);
}
/*
* Project private interface to take a snapshot of all events of the
* specified event channel. Argument subscr may be a subscriber id, the empty
* string "", or NULL. The empty string indicates that no subscriber is
* selected, for example if a previous subscriber died. sysevent_evc_walk_next()
* will deliver events from the main event queue in this case. If subscr is
* NULL, the subscriber with the EVCH_SUB_DUMP flag set (subd->sd_dump != 0)
* will be selected.
*
* In panic case this function returns NULL. This is legal. The NULL has
* to be delivered to sysevent_evc_walk_step() and sysevent_evc_walk_fini().
*/
evchanq_t *
sysevent_evc_walk_init(evchan_t *scp, char *subscr)
{
if (panicstr != NULL && scp == NULL)
return (NULL);
ASSERT(scp != NULL);
return (evch_chrdevent_init(((evch_bind_t *)scp)->bd_channel, subscr));
}
/*
* Project private interface to read events from a previously taken
* snapshot (with sysevent_evc_walk_init). In case of panic events
* are retrieved directly from the channel data structures. No resources
* are allocated and no mutexes are grabbed in panic context.
*/
sysevent_t *
sysevent_evc_walk_step(evchanq_t *evcq)
{
return ((sysevent_t *)evch_chgetnextev(evcq));
}
/*
* Project private interface to free a previously taken snapshot.
*/
void
sysevent_evc_walk_fini(evchanq_t *evcq)
{
evch_chrdevent_fini(evcq);
}
/*
* Get address and size of an event payload. Returns NULL when no
* payload present.
*/
char *
sysevent_evc_event_attr(sysevent_t *ev, size_t *plsize)
{
char *attrp;
size_t aoff;
size_t asz;
aoff = SE_ATTR_OFF(ev);
attrp = (char *)ev + aoff;
asz = *plsize = SE_SIZE(ev) - aoff;
return (asz ? attrp : NULL);
}
/*
* sysevent_get_class_name - Get class name string
*/
char *
sysevent_get_class_name(sysevent_t *ev)
{
return (SE_CLASS_NAME(ev));
}
/*
* sysevent_get_subclass_name - Get subclass name string
*/
char *
sysevent_get_subclass_name(sysevent_t *ev)
{
return (SE_SUBCLASS_NAME(ev));
}
/*
* sysevent_get_seq - Get event sequence id
*/
uint64_t
sysevent_get_seq(sysevent_t *ev)
{
return (SE_SEQ(ev));
}
/*
* sysevent_get_time - Get event timestamp
*/
void
sysevent_get_time(sysevent_t *ev, hrtime_t *etime)
{
*etime = SE_TIME(ev);
}
/*
* sysevent_get_size - Get event buffer size
*/
size_t
sysevent_get_size(sysevent_t *ev)
{
return ((size_t)SE_SIZE(ev));
}
/*
* sysevent_get_pub - Get publisher name string
*/
char *
sysevent_get_pub(sysevent_t *ev)
{
return (SE_PUB_NAME(ev));
}
/*
* sysevent_get_attr_list - stores address of a copy of the attribute list
* associated with the given sysevent buffer. The list must be freed by the
* caller.
*/
int
sysevent_get_attr_list(sysevent_t *ev, nvlist_t **nvlist)
{
int error;
caddr_t attr;
size_t attr_len;
uint64_t attr_offset;
*nvlist = NULL;
if (SE_FLAG(ev) != SE_PACKED_BUF) {
return (EINVAL);
}
attr_offset = SE_ATTR_OFF(ev);
if (SE_SIZE(ev) == attr_offset) {
return (EINVAL);
}
/* unpack nvlist */
attr = (caddr_t)ev + attr_offset;
attr_len = SE_SIZE(ev) - attr_offset;
if ((error = nvlist_unpack(attr, attr_len, nvlist, 0)) != 0) {
error = error != ENOMEM ? EINVAL : error;
return (error);
}
return (0);
}
/*
* Functions called by the sysevent driver for general purpose event channels
*
* evch_usrchanopen - Create/Bind to an event channel
* evch_usrchanclose - Unbind/Destroy event channel
* evch_usrallocev - Allocate event data structure
* evch_usrfreeev - Free event data structure
* evch_usrpostevent - Publish event
* evch_usrsubscribe - Subscribe (register callback function)
* evch_usrunsubscribe - Unsubscribe
* evch_usrcontrol_set - Set channel properties
* evch_usrcontrol_get - Get channel properties
* evch_usrgetchnames - Get list of channel names
* evch_usrgetchdata - Get data of an event channel
*/
evchan_t *
evch_usrchanopen(const char *name, uint32_t flags, int *err)
{
evch_bind_t *bp = NULL;
*err = evch_chbind(name, &bp, flags);
return ((evchan_t *)bp);
}
/*
* Unbind from the channel.
*/
void
evch_usrchanclose(evchan_t *cbp)
{
evch_chunbind((evch_bind_t *)cbp);
}
/*
* Allocates log_evch_eventq_t structure but returns the pointer of the embedded
* sysevent_impl_t structure as the opaque sysevent_t * data type
*/
sysevent_impl_t *
evch_usrallocev(size_t evsize, uint32_t flags)
{
return ((sysevent_impl_t *)evch_evq_evzalloc(evsize, flags));
}
/*
* Free evch_eventq_t structure
*/
void
evch_usrfreeev(sysevent_impl_t *ev)
{
evch_evq_evfree((void *)ev);
}
/*
* Posts an event to the given channel. The event structure has to be
* allocated by evch_usrallocev(). Returns zero on success and an error
* code else. Attributes have to be packed and included in the event structure.
*
*/
int
evch_usrpostevent(evchan_t *bp, sysevent_impl_t *ev, uint32_t flags)
{
return (evch_chpublish((evch_bind_t *)bp, ev, flags));
}
/*
* Subscribe function for user land subscriptions
*/
int
evch_usrsubscribe(evchan_t *bp, const char *sid, const char *class,
int d, uint32_t flags)
{
door_handle_t dh = door_ki_lookup(d);
int rv;
if (dh == NULL) {
return (EINVAL);
}
if ((rv = evch_chsubscribe((evch_bind_t *)bp, EVCH_DELDOOR, sid, class,
(void *)dh, NULL, flags, curproc->p_pid)) != 0) {
door_ki_rele(dh);
}
return (rv);
}
/*
* Flag can be EVCH_SUB_KEEP or 0. EVCH_SUB_KEEP preserves persistent
* subscribers
*/
void
evch_usrunsubscribe(evchan_t *bp, const char *subid, uint32_t flags)
{
evch_chunsubscribe((evch_bind_t *)bp, subid, flags);
}
/*ARGSUSED*/
int
evch_usrcontrol_set(evchan_t *bp, int cmd, uint32_t value)
{
evch_chan_t *chp = ((evch_bind_t *)bp)->bd_channel;
uid_t uid = crgetuid(curthread->t_cred);
int rc = 0;
mutex_enter(&chp->ch_mutex);
switch (cmd) {
case EVCH_SET_CHAN_LEN:
if (uid && uid != chp->ch_uid) {
rc = EACCES;
break;
}
chp->ch_maxev = min(value, evch_events_max);
break;
default:
rc = EINVAL;
}
mutex_exit(&chp->ch_mutex);
return (rc);
}
/*ARGSUSED*/
int
evch_usrcontrol_get(evchan_t *bp, int cmd, uint32_t *value)
{
evch_chan_t *chp = ((evch_bind_t *)bp)->bd_channel;
int rc = 0;
mutex_enter(&chp->ch_mutex);
switch (cmd) {
case EVCH_GET_CHAN_LEN:
*value = chp->ch_maxev;
break;
case EVCH_GET_CHAN_LEN_MAX:
*value = evch_events_max;
break;
default:
rc = EINVAL;
}
mutex_exit(&chp->ch_mutex);
return (rc);
}
int
evch_usrgetchnames(char *buf, size_t size)
{
return (evch_chgetnames(buf, size));
}
int
evch_usrgetchdata(char *chname, void *buf, size_t size)
{
return (evch_chgetchdata(chname, buf, size));
}