/*
 * 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 (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Copyright (c) 2018, Joyent, Inc.
 */

/*
 * 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_dec_32_nv(&evp->ge_refcount);
        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 != 0) {
                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_inc_32(&evp->ge_refcount);
        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);
                nvlist_free(chp->ch_propnvl);
                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);
}

static void
evch_chsetpropnvl(evch_bind_t *bp, nvlist_t *nvl)
{
        evch_chan_t *chp = bp->bd_channel;

        mutex_enter(&chp->ch_mutex);

        nvlist_free(chp->ch_propnvl);

        chp->ch_propnvl = nvl;
        chp->ch_propnvlgen++;

        mutex_exit(&chp->ch_mutex);
}

static int
evch_chgetpropnvl(evch_bind_t *bp, nvlist_t **nvlp, int64_t *genp)
{
        evch_chan_t *chp = bp->bd_channel;
        int rc = 0;

        mutex_enter(&chp->ch_mutex);

        if (chp->ch_propnvl != NULL)
                rc = (nvlist_dup(chp->ch_propnvl, nvlp, 0) == 0) ? 0 : ENOMEM;
        else
                *nvlp = NULL;   /* rc still 0 */

        if (genp)
                *genp = chp->ch_propnvlgen;

        mutex_exit(&chp->ch_mutex);

        if (rc != 0)
                *nvlp = NULL;

        return (rc);

}

/*
 * 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);

        psqstat = 0;
        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
 * sysevent_evc_setpropnvl  - Set channel property nvlist
 * sysevent_evc_getpropnvl  - Get channel property nvlist
 *
 * 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;
        uint32_t        *chlenp;
        uint32_t        chlen;
        uint32_t        ochlen;
        int             rc = 0;

        if (scp == NULL) {
                return (EINVAL);
        }

        chp = ((evch_bind_t *)scp)->bd_channel;

        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);
}

int
sysevent_evc_setpropnvl(evchan_t *scp, nvlist_t *nvl)
{
        nvlist_t *nvlcp = nvl;

        if (nvl != NULL && nvlist_dup(nvl, &nvlcp, 0) != 0)
                return (ENOMEM);

        evch_chsetpropnvl((evch_bind_t *)scp, nvlcp);

        return (0);
}

int
sysevent_evc_getpropnvl(evchan_t *scp, nvlist_t **nvlp)
{
        return (evch_chgetpropnvl((evch_bind_t *)scp, nvlp, NULL));
}

/*
 * 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
 * evch_usrsetpropnvl   - Set channel properties nvlist
 * evch_usrgetpropnvl   - Get channel properties nvlist
 */
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));
}

void
evch_usrsetpropnvl(evchan_t *bp, nvlist_t *nvl)
{
        evch_chsetpropnvl((evch_bind_t *)bp, nvl);
}

int
evch_usrgetpropnvl(evchan_t *bp, nvlist_t **nvlp, int64_t *genp)
{
        return (evch_chgetpropnvl((evch_bind_t *)bp, nvlp, genp));
}