5754 prtconf: assertion failure in libpcidb if vendor cannot be looked up

[illumos-gate.git] / usr / src / lib / libsysevent / libsysevent.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 (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <door.h>
#include <unistd.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <synch.h>
#include <pthread.h>
#include <signal.h>
#include <thread.h>
#include <libnvpair.h>
#include <assert.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/modctl.h>
#include <sys/mnttab.h>
#include <sys/sysevent.h>
#include <sys/sysevent_impl.h>

#include "libsysevent.h"
#include "libsysevent_impl.h"

/*
 * libsysevent - The system event framework library
 *
 *              This library provides routines to help with marshalling
 *              and unmarshalling of data contained in a sysevent event
 *              buffer.
 */

#define SE_ENCODE_METHOD        NV_ENCODE_NATIVE

#define dprint  if (libsysevent_debug) (void) printf
static int libsysevent_debug = 0;

static sysevent_t *se_unpack(sysevent_t *);
static int cleanup_id(sysevent_handle_t *shp, uint32_t id, int type);

/*
 * The following routines allow system event publication to the sysevent
 * framework.
 */

/*
 * sysevent_alloc - allocate a sysevent buffer
 */
static sysevent_t *
sysevent_alloc(char *class, int class_sz, char *subclass, int subclass_sz,
        char *pub, int pub_sz, nvlist_t *attr_list)
{
        int payload_sz;
        int aligned_class_sz, aligned_subclass_sz, aligned_pub_sz;
        size_t nvlist_sz = 0;
        char *attr;
        uint64_t attr_offset;
        sysevent_t *ev;

        if (attr_list != NULL) {
                if (nvlist_size(attr_list, &nvlist_sz, SE_ENCODE_METHOD)
                    != 0) {
                        return (NULL);
                }
        }

        /*
         * Calculate and reserve space for the class, subclass and
         * publisher strings in the event buffer
         */

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

        payload_sz = (aligned_class_sz - sizeof (uint64_t)) +
            (aligned_subclass_sz - sizeof (uint64_t)) +
            (aligned_pub_sz - sizeof (uint64_t)) - sizeof (uint64_t) +
            nvlist_sz;

        /*
         * Allocate event buffer plus additional payload overhead.
         */
        ev = calloc(1, sizeof (sysevent_impl_t) + payload_sz);
        if (ev == NULL) {
                return (NULL);
        }

        /* Initialize the event buffer data */
        SE_VERSION(ev) = SYS_EVENT_VERSION;
        (void) bcopy(class, SE_CLASS_NAME(ev), class_sz);

        SE_SUBCLASS_OFF(ev) = SE_ALIGN(offsetof(sysevent_impl_t, se_class_name))
                + aligned_class_sz;
        (void) bcopy(subclass, SE_SUBCLASS_NAME(ev), subclass_sz);

        SE_PUB_OFF(ev) = SE_SUBCLASS_OFF(ev) + aligned_subclass_sz;
        (void) bcopy(pub, SE_PUB_NAME(ev), pub_sz);

        SE_PAYLOAD_SZ(ev) = payload_sz;
        SE_ATTR_PTR(ev) = (uint64_t)0;

        /* Check for attribute list */
        if (attr_list == NULL) {
                return (ev);
        }

        /* Copy attribute data to contiguous memory */
        SE_FLAG(ev) = SE_PACKED_BUF;
        attr_offset = SE_ATTR_OFF(ev);
        attr = (char *)((caddr_t)ev + attr_offset);
        if (nvlist_pack(attr_list, &attr, &nvlist_sz, SE_ENCODE_METHOD,
            0) != 0) {
                free(ev);
                return (NULL);
        }

        return (ev);
}

/*
 * sysevent_post_event - generate a system event via the sysevent framework
 */
int
sysevent_post_event(char *class, char *subclass, char *vendor, char *pub_name,
        nvlist_t *attr_list, sysevent_id_t *eid)
{
        int error;
        sysevent_t *ev;

        ev = sysevent_alloc_event(class, subclass, vendor, pub_name, attr_list);
        if (ev == NULL) {
                return (-1);
        }

        error = modctl(MODEVENTS, (uintptr_t)MODEVENTS_POST_EVENT,
            (uintptr_t)ev, (uintptr_t)SE_SIZE(ev), (uintptr_t)eid, 0);

        sysevent_free(ev);

        if (error) {
                errno = EIO;
                return (-1);
        }

        return (0);
}

/*
 * The following routines are used to free or duplicate a
 * sysevent event buffer.
 */

/*
 * sysevent_dup - Allocate and copy an event buffer
 *      Copies both packed and unpacked to unpacked sysevent.
 */
sysevent_t *
sysevent_dup(sysevent_t *ev)
{
        nvlist_t *nvl, *cnvl = NULL;
        uint64_t attr_offset;
        sysevent_t *copy;

        if (SE_FLAG(ev) == SE_PACKED_BUF)
                return (se_unpack(ev));

        /* Copy event header information */
        attr_offset = SE_ATTR_OFF(ev);
        copy = calloc(1, attr_offset);
        if (copy == NULL)
                return (NULL);
        bcopy(ev, copy, attr_offset);

        nvl = (nvlist_t *)(uintptr_t)SE_ATTR_PTR(ev);
        if (nvl && nvlist_dup(nvl, &cnvl, 0) != 0) {
                free(copy);
                return (NULL);
        }

        SE_ATTR_PTR(copy) = (uintptr_t)cnvl;
        SE_FLAG(copy) = 0;      /* unpacked */
        return (copy);
}

/*
 * sysevent_free - Free memory allocated for an event buffer
 */
void
sysevent_free(sysevent_t *ev)
{
        nvlist_t *attr_list = (nvlist_t *)(uintptr_t)SE_ATTR_PTR(ev);

        if (attr_list)
                nvlist_free(attr_list);
        free(ev);
}

/*
 * The following routines are used to extract attribute data from a sysevent
 * handle.
 */

/*
 * sysevent_get_attr_list - allocate and return an attribute associated with
 *                      the given sysevent buffer.
 */
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_t *nvl;

        *nvlist = NULL;

        /* Duplicate attribute for an unpacked sysevent buffer */
        if (SE_FLAG(ev) != SE_PACKED_BUF) {
                nvl = (nvlist_t *)(uintptr_t)SE_ATTR_PTR(ev);
                if (nvl == NULL) {
                        return (0);
                }
                if ((error = nvlist_dup(nvl, nvlist, 0)) != 0) {
                        if (error == ENOMEM) {
                                errno = error;
                        } else {
                                errno = EINVAL;
                        }
                        return (-1);
                }
                return (0);
        }

        attr_offset = SE_ATTR_OFF(ev);
        if (SE_SIZE(ev) == attr_offset) {
                return (0);
        }

        /* 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) {
                if (error == ENOMEM) {
                        errno = error;
                } else  {
                        errno = EINVAL;
                }
                return (-1);
        }

        return (0);
}

/*
 * sysevent_attr_name - Get name of attribute
 */
char *
sysevent_attr_name(sysevent_attr_t *attr)
{
        if (attr == NULL) {
                errno = EINVAL;
                return (NULL);
        }
        return (nvpair_name((nvpair_t *)attr));
}

/*
 * sysevent_attr_value - Get attribute value data and type
 */
int
sysevent_attr_value(sysevent_attr_t *attr, sysevent_value_t *se_value)
{
        nvpair_t *nvp = attr;

        if (nvp == NULL)
                return (EINVAL);

        /* Convert DATA_TYPE_* to SE_DATA_TYPE_* */
        switch (nvpair_type(nvp)) {
        case DATA_TYPE_BYTE:
                se_value->value_type = SE_DATA_TYPE_BYTE;
                (void) nvpair_value_byte(nvp, &se_value->value.sv_byte);
                break;
        case DATA_TYPE_INT16:
                se_value->value_type = SE_DATA_TYPE_INT16;
                (void) nvpair_value_int16(nvp, &se_value->value.sv_int16);
                break;
        case DATA_TYPE_UINT16:
                se_value->value_type = SE_DATA_TYPE_UINT16;
                (void) nvpair_value_uint16(nvp, &se_value->value.sv_uint16);
                break;
        case DATA_TYPE_INT32:
                se_value->value_type = SE_DATA_TYPE_INT32;
                (void) nvpair_value_int32(nvp, &se_value->value.sv_int32);
                break;
        case DATA_TYPE_UINT32:
                se_value->value_type = SE_DATA_TYPE_UINT32;
                (void) nvpair_value_uint32(nvp, &se_value->value.sv_uint32);
                break;
        case DATA_TYPE_INT64:
                se_value->value_type = SE_DATA_TYPE_INT64;
                (void) nvpair_value_int64(nvp, &se_value->value.sv_int64);
                break;
        case DATA_TYPE_UINT64:
                se_value->value_type = SE_DATA_TYPE_UINT64;
                (void) nvpair_value_uint64(nvp, &se_value->value.sv_uint64);
                break;
        case DATA_TYPE_STRING:
                se_value->value_type = SE_DATA_TYPE_STRING;
                (void) nvpair_value_string(nvp, &se_value->value.sv_string);
                break;
        case DATA_TYPE_BYTE_ARRAY:
                se_value->value_type = SE_DATA_TYPE_BYTES;
                (void) nvpair_value_byte_array(nvp,
                    &se_value->value.sv_bytes.data,
                    (uint_t *)&se_value->value.sv_bytes.size);
                break;
        case DATA_TYPE_HRTIME:
                se_value->value_type = SE_DATA_TYPE_TIME;
                (void) nvpair_value_hrtime(nvp, &se_value->value.sv_time);
                break;
        default:
                return (ENOTSUP);
        }
        return (0);
}

/*
 * sysevent_attr_next - Get next attribute in event attribute list
 */
sysevent_attr_t *
sysevent_attr_next(sysevent_t *ev, sysevent_attr_t *attr)
{
        nvlist_t *nvl;
        nvpair_t *nvp = attr;

        /* all user visible sysevent_t's are unpacked */
        assert(SE_FLAG(ev) != SE_PACKED_BUF);

        if (SE_ATTR_PTR(ev) == (uint64_t)0) {
                return (NULL);
        }

        nvl = (nvlist_t *)(uintptr_t)SE_ATTR_PTR(ev);
        return (nvlist_next_nvpair(nvl, nvp));
}

/*
 * sysevent_lookup_attr - Lookup attribute by name and datatype.
 */
int
sysevent_lookup_attr(sysevent_t *ev, char *name, int datatype,
        sysevent_value_t *se_value)
{
        nvpair_t *nvp;
        nvlist_t *nvl;

        assert(SE_FLAG(ev) != SE_PACKED_BUF);

        if (SE_ATTR_PTR(ev) == (uint64_t)0) {
                return (ENOENT);
        }

        /*
         * sysevent matches on both name and datatype
         * nvlist_look mataches name only. So we walk
         * nvlist manually here.
         */
        nvl = (nvlist_t *)(uintptr_t)SE_ATTR_PTR(ev);
        nvp = nvlist_next_nvpair(nvl, NULL);
        while (nvp) {
                if ((strcmp(name, nvpair_name(nvp)) == 0) &&
                    (sysevent_attr_value(nvp, se_value) == 0) &&
                    (se_value->value_type == datatype))
                        return (0);
                nvp = nvlist_next_nvpair(nvl, nvp);
        }
        return (ENOENT);
}

/* Routines to extract event header information */

/*
 * sysevent_get_class - Get class id
 */
int
sysevent_get_class(sysevent_t *ev)
{
        return (SE_CLASS(ev));
}

/*
 * sysevent_get_subclass - Get subclass id
 */
int
sysevent_get_subclass(sysevent_t *ev)
{
        return (SE_SUBCLASS(ev));
}

/*
 * sysevent_get_class_name - Get class name string
 */
char *
sysevent_get_class_name(sysevent_t *ev)
{
        return (SE_CLASS_NAME(ev));
}

typedef enum {
        PUB_VEND,
        PUB_KEYWD,
        PUB_NAME,
        PUB_PID
} se_pub_id_t;

/*
 * sysevent_get_pub - Get publisher name string
 */
char *
sysevent_get_pub(sysevent_t *ev)
{
        return (SE_PUB_NAME(ev));
}

/*
 * Get the requested string pointed by the token.
 *
 * Return NULL if not found or for insufficient memory.
 */
static char *
parse_pub_id(sysevent_t *ev, se_pub_id_t token)
{
        int i;
        char *pub_id, *pub_element, *str, *next;

        next = pub_id = strdup(sysevent_get_pub(ev));
        for (i = 0; i <= token; ++i) {
                str = strtok_r(next, ":", &next);
                if (str == NULL) {
                        free(pub_id);
                        return (NULL);
                }
        }

        pub_element = strdup(str);
        free(pub_id);
        return (pub_element);
}

/*
 * Return a pointer to the string following the token
 *
 * Note: This is a dedicated function for parsing
 * publisher strings and not for general purpose.
 */
static const char *
pub_idx(const char *pstr, int token)
{
        int i;

        for (i = 1; i <= token; i++) {
                if ((pstr = index(pstr, ':')) == NULL)
                        return (NULL);
                pstr++;
        }

        /* String might be empty */
        if (pstr) {
                if (*pstr == '\0' || *pstr == ':')
                        return (NULL);
        }
        return (pstr);
}

char *
sysevent_get_vendor_name(sysevent_t *ev)
{
        return (parse_pub_id(ev, PUB_VEND));
}

char *
sysevent_get_pub_name(sysevent_t *ev)
{
        return (parse_pub_id(ev, PUB_NAME));
}

/*
 * Provide the pid encoded in the publisher string
 * w/o allocating any resouces.
 */
void
sysevent_get_pid(sysevent_t *ev, pid_t *pid)
{
        const char *part_str;
        const char *pub_str = sysevent_get_pub(ev);

        *pid = (pid_t)SE_KERN_PID;

        part_str = pub_idx(pub_str, PUB_KEYWD);
        if (part_str != NULL && strstr(part_str, SE_KERN_PUB) != NULL)
                return;

        if ((part_str = pub_idx(pub_str, PUB_PID)) == NULL)
                return;

        *pid = (pid_t)atoi(part_str);
}

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

/*
 * The following routines are used by devfsadm_mod.c to propagate event
 * buffers to devfsadmd.  These routines will serve as the basis for
 * event channel publication and subscription.
 */

/*
 * sysevent_alloc_event -
 *      allocate a sysevent buffer for sending through an established event
 *      channel.
 */
sysevent_t *
sysevent_alloc_event(char *class, char *subclass, char *vendor, char *pub_name,
        nvlist_t *attr_list)
{
        int class_sz, subclass_sz, pub_sz;
        char *pub_id;
        sysevent_t *ev;

        if ((class == NULL) || (subclass == NULL) || (vendor == NULL) ||
            (pub_name == NULL)) {
                errno = EINVAL;
                return (NULL);
        }

        class_sz = strlen(class) + 1;
        subclass_sz = strlen(subclass) + 1;
        if ((class_sz > MAX_CLASS_LEN) ||
            (subclass_sz > MAX_SUBCLASS_LEN)) {
                errno = EINVAL;
                return (NULL);
        }

        /*
         * Calculate the publisher size plus string seperators and maximum
         * pid characters
         */
        pub_sz = strlen(vendor) + sizeof (SE_USR_PUB) + strlen(pub_name) + 14;
        if (pub_sz > MAX_PUB_LEN) {
                errno = EINVAL;
                return (NULL);
        }
        pub_id = malloc(pub_sz);
        if (pub_id == NULL) {
                errno = ENOMEM;
                return (NULL);
        }
        if (snprintf(pub_id, pub_sz, "%s:%s%s:%d", vendor, SE_USR_PUB,
            pub_name, (int)getpid()) >= pub_sz) {
                free(pub_id);
                errno = EINVAL;
                return (NULL);
        }
        pub_sz = strlen(pub_id) + 1;

        ev = sysevent_alloc(class, class_sz, subclass, subclass_sz,
            pub_id, pub_sz, attr_list);
        free(pub_id);
        if (ev == NULL) {
                errno = ENOMEM;
                return (NULL);
        }

        return (ev);
}

/*
 * se_unpack - unpack nvlist to a searchable list.
 *      If already unpacked, will do a dup.
 */
static sysevent_t *
se_unpack(sysevent_t *ev)
{
        caddr_t attr;
        size_t attr_len;
        nvlist_t *attrp = NULL;
        uint64_t attr_offset;
        sysevent_t *copy;

        assert(SE_FLAG(ev) == SE_PACKED_BUF);

        /* Copy event header information */
        attr_offset = SE_ATTR_OFF(ev);
        copy = calloc(1, attr_offset);
        if (copy == NULL)
                return (NULL);
        bcopy(ev, copy, attr_offset);
        SE_FLAG(copy) = 0;      /* unpacked */

        /* unpack nvlist */
        attr = (caddr_t)ev + attr_offset;
        attr_len = SE_SIZE(ev) - attr_offset;
        if (attr_len == 0) {
                return (copy);
        }
        if (nvlist_unpack(attr, attr_len, &attrp, 0) != 0) {
                free(copy);
                return (NULL);
        }

        SE_ATTR_PTR(copy) = (uintptr_t)attrp;
        return (copy);
}

/*
 * se_print - Prints elements in an event buffer
 */
void
se_print(FILE *fp, sysevent_t *ev)
{
        char *vendor, *pub;
        pid_t pid;
        hrtime_t hrt;
        nvlist_t *attr_list = NULL;

        (void) sysevent_get_time(ev, &hrt);
        (void) fprintf(fp, "received sysevent id = 0X%llx:%llx\n",
            hrt, (longlong_t)sysevent_get_seq(ev));
        (void) fprintf(fp, "\tclass = %s\n", sysevent_get_class_name(ev));
        (void) fprintf(fp, "\tsubclass = %s\n", sysevent_get_subclass_name(ev));
        if ((vendor =  sysevent_get_vendor_name(ev)) != NULL) {
                (void) fprintf(fp, "\tvendor = %s\n", vendor);
                free(vendor);
        }
        if ((pub = sysevent_get_pub_name(ev)) != NULL) {
                sysevent_get_pid(ev, &pid);
                (void) fprintf(fp, "\tpublisher = %s:%d\n", pub, (int)pid);
                free(pub);
        }

        if (sysevent_get_attr_list(ev, &attr_list) == 0 && attr_list != NULL) {
                nvlist_print(fp, attr_list);
                nvlist_free(attr_list);
        }
}

/*
 * The following routines are provided to support establishment and use
 * of sysevent channels.  A sysevent channel is established between
 * publishers and subscribers of sysevents for an agreed upon channel name.
 * These routines currently support sysevent channels between user-level
 * applications running on the same system.
 *
 * Sysevent channels may be created by a single publisher or subscriber process.
 * Once established, up to MAX_SUBSRCIBERS subscribers may subscribe interest in
 * receiving sysevent notifications on the named channel.  At present, only
 * one publisher is allowed per sysevent channel.
 *
 * The registration information for each channel is kept in the kernel.  A
 * kernel-based registration was chosen for persistence and reliability reasons.
 * If either a publisher or a subscriber exits for any reason, the channel
 * properties are maintained until all publishers and subscribers have exited.
 * Additionally, an in-kernel registration allows the API to be extended to
 * include kernel subscribers as well as userland subscribers in the future.
 *
 * To insure fast lookup of subscriptions, a cached copy of the registration
 * is kept and maintained for the publisher process.  Updates are made
 * everytime a change is made in the kernel.  Changes to the registration are
 * expected to be infrequent.
 *
 * Channel communication between publisher and subscriber processes is
 * implemented primarily via doors.  Each publisher creates a door for
 * registration notifications and each subscriber creates a door for event
 * delivery.
 *
 * Most of these routines are used by syseventd(1M), the sysevent publisher
 * for the syseventd channel.  Processes wishing to receive sysevent
 * notifications from syseventd may use a set of public
 * APIs designed to subscribe to syseventd sysevents.  The subscription
 * APIs are implemented in accordance with PSARC/2001/076.
 *
 */

/*
 * Door handlers for the channel subscribers
 */

/*
 * subscriber_event_handler - generic event handling wrapper for subscribers
 *                      This handler is used to process incoming sysevent
 *                      notifications from channel publishers.
 *                      It is created as a seperate thread in each subscriber
 *                      process per subscription.
 */
static void
subscriber_event_handler(sysevent_handle_t *shp)
{
        subscriber_priv_t *sub_info;
        sysevent_queue_t *evqp;

        sub_info = (subscriber_priv_t *)SH_PRIV_DATA(shp);

        /* See hack alert in sysevent_bind_subscriber_cmn */
        if (sub_info->sp_handler_tid == NULL)
                sub_info->sp_handler_tid = thr_self();

        (void) mutex_lock(&sub_info->sp_qlock);
        for (;;) {
                while (sub_info->sp_evq_head == NULL && SH_BOUND(shp)) {
                        (void) cond_wait(&sub_info->sp_cv, &sub_info->sp_qlock);
                }
                evqp = sub_info->sp_evq_head;
                while (evqp) {
                        (void) mutex_unlock(&sub_info->sp_qlock);
                        (void) sub_info->sp_func(evqp->sq_ev);
                        (void) mutex_lock(&sub_info->sp_qlock);
                        sub_info->sp_evq_head = sub_info->sp_evq_head->sq_next;
                        free(evqp->sq_ev);
                        free(evqp);
                        evqp = sub_info->sp_evq_head;
                }
                if (!SH_BOUND(shp)) {
                        (void) mutex_unlock(&sub_info->sp_qlock);
                        return;
                }
        }

        /* NOTREACHED */
}

/*
 * Data structure used to communicate event subscription cache updates
 * to publishers via a registration door
 */
struct reg_args {
        uint32_t ra_sub_id;
        uint32_t ra_op;
        uint64_t ra_buf_ptr;
};


/*
 * event_deliver_service - generic event delivery service routine.  This routine
 *              is called in response to a door call to post an event.
 *
 */
/*ARGSUSED*/
static void
event_deliver_service(void *cookie, char *args, size_t alen,
    door_desc_t *ddp, uint_t ndid)
{
        int     ret = 0;
        subscriber_priv_t *sub_info;
        sysevent_handle_t *shp;
        sysevent_queue_t *new_eq;

        if (args == NULL || alen < sizeof (uint32_t)) {
                ret = EINVAL;
                goto return_from_door;
        }

        /* Publisher checking on subscriber */
        if (alen == sizeof (uint32_t)) {
                ret = 0;
                goto return_from_door;
        }

        shp = (sysevent_handle_t *)cookie;
        if (shp == NULL) {
                ret = EBADF;
                goto return_from_door;
        }

        /*
         * Mustn't block if we are trying to update the registration with
         * the publisher
         */
        if (mutex_trylock(SH_LOCK(shp)) != 0) {
                ret = EAGAIN;
                goto return_from_door;
        }

        if (!SH_BOUND(shp)) {
                ret = EBADF;
                (void) mutex_unlock(SH_LOCK(shp));
                goto return_from_door;
        }

        sub_info = (subscriber_priv_t *)SH_PRIV_DATA(shp);
        if (sub_info == NULL) {
                ret = EBADF;
                (void) mutex_unlock(SH_LOCK(shp));
                goto return_from_door;
        }

        new_eq = (sysevent_queue_t *)calloc(1,
            sizeof (sysevent_queue_t));
        if (new_eq == NULL) {
                ret = EAGAIN;
                (void) mutex_unlock(SH_LOCK(shp));
                goto return_from_door;
        }

        /*
         * Allocate and copy the event buffer into the subscriber's
         * address space
         */
        new_eq->sq_ev = calloc(1, alen);
        if (new_eq->sq_ev == NULL) {
                free(new_eq);
                ret = EAGAIN;
                (void) mutex_unlock(SH_LOCK(shp));
                goto return_from_door;
        }
        (void) bcopy(args, new_eq->sq_ev, alen);

        (void) mutex_lock(&sub_info->sp_qlock);
        if (sub_info->sp_evq_head == NULL) {
                sub_info->sp_evq_head = new_eq;
        } else {
                sub_info->sp_evq_tail->sq_next = new_eq;
        }
        sub_info->sp_evq_tail = new_eq;

        (void) cond_signal(&sub_info->sp_cv);
        (void) mutex_unlock(&sub_info->sp_qlock);
        (void) mutex_unlock(SH_LOCK(shp));

return_from_door:
        (void) door_return((void *)&ret, sizeof (ret), NULL, 0);
        (void) door_return(NULL, 0, NULL, 0);
}

/*
 * Sysevent subscription information is maintained in the kernel.  Updates
 * to the in-kernel registration database is expected to be infrequent and
 * offers consistency for publishers and subscribers that may come and go
 * for a given channel.
 *
 * To expedite registration lookups by publishers, a cached copy of the
 * kernel registration database is kept per-channel.  Caches are invalidated
 * and refreshed upon state changes to the in-kernel registration database.
 *
 * To prevent stale subscriber data, publishers may remove subsriber
 * registrations from the in-kernel registration database in the event
 * that a particular subscribing process is unresponsive.
 *
 * The following routines provide a mechanism to update publisher and subscriber
 * information for a specified channel.
 */

/*
 * clnt_deliver_event - Deliver an event through the consumer's event
 *                      delivery door
 *
 * Returns -1 if message not delivered. With errno set to cause of error.
 * Returns 0 for success with the results returned in posting buffer.
 */
static int
clnt_deliver_event(int service_door, void *data, size_t datalen,
        void *result, size_t rlen)
{
        int error = 0;
        door_arg_t door_arg;

        door_arg.rbuf = result;
        door_arg.rsize = rlen;
        door_arg.data_ptr = data;
        door_arg.data_size = datalen;
        door_arg.desc_ptr = NULL;
        door_arg.desc_num = 0;

        /*
         * Make door call
         */
        while ((error = door_call(service_door, &door_arg)) != 0) {
                if (errno == EAGAIN || errno == EINTR) {
                        continue;
                } else {
                        error = errno;
                        break;
                }
        }

        return (error);
}

static int
update_publisher_cache(subscriber_priv_t *sub_info, int update_op,
        uint32_t sub_id, size_t datasz, uchar_t *data)
{
        int pub_fd;
        uint32_t result = 0;
        struct reg_args *rargs;

        rargs = (struct reg_args *)calloc(1, sizeof (struct reg_args) +
            datasz);
        if (rargs == NULL) {
                errno = ENOMEM;
                return (-1);
        }

        rargs->ra_sub_id = sub_id;
        rargs->ra_op = update_op;
        bcopy(data, (char *)&rargs->ra_buf_ptr, datasz);

        pub_fd = open(sub_info->sp_door_name, O_RDONLY);
        (void) clnt_deliver_event(pub_fd, (void *)rargs,
            sizeof (struct reg_args) + datasz, &result, sizeof (result));
        (void) close(pub_fd);

        free(rargs);
        if (result != 0) {
                errno = result;
                return (-1);
        }

        return (0);
}


/*
 * update_kernel_registration - update the in-kernel registration for the
 * given channel.
 */
static int
update_kernel_registration(sysevent_handle_t *shp, int update_type,
        int update_op, uint32_t *sub_id, size_t datasz, uchar_t *data)
{
        int error;
        char *channel_name = SH_CHANNEL_NAME(shp);
        se_pubsub_t udata;

        udata.ps_channel_name_len = strlen(channel_name) + 1;
        udata.ps_op = update_op;
        udata.ps_type = update_type;
        udata.ps_buflen = datasz;
        udata.ps_id = *sub_id;

        if ((error = modctl(MODEVENTS, (uintptr_t)MODEVENTS_REGISTER_EVENT,
            (uintptr_t)channel_name, (uintptr_t)data, (uintptr_t)&udata, 0))
            != 0) {
                return (error);
        }

        *sub_id = udata.ps_id;

        return (error);
}

/*
 * get_kernel_registration - get the current subscriber registration for
 * the given channel
 */
static nvlist_t *
get_kernel_registration(char *channel_name, uint32_t class_id)
{
        char *nvlbuf;
        nvlist_t *nvl;
        se_pubsub_t udata;

        nvlbuf = calloc(1, MAX_SUBSCRIPTION_SZ);
        if (nvlbuf == NULL) {
                return (NULL);
        }

        udata.ps_buflen = MAX_SUBSCRIPTION_SZ;
        udata.ps_channel_name_len = strlen(channel_name) + 1;
        udata.ps_id = class_id;
        udata.ps_op = SE_GET_REGISTRATION;
        udata.ps_type = PUBLISHER;

        if (modctl(MODEVENTS, (uintptr_t)MODEVENTS_REGISTER_EVENT,
            (uintptr_t)channel_name, (uintptr_t)nvlbuf, (uintptr_t)&udata, 0)
            != 0) {

                /* Need a bigger buffer to hold channel registration */
                if (errno == EAGAIN) {
                        free(nvlbuf);
                        nvlbuf = calloc(1, udata.ps_buflen);
                        if (nvlbuf == NULL)
                                return (NULL);

                        /* Try again */
                        if (modctl(MODEVENTS,
                            (uintptr_t)MODEVENTS_REGISTER_EVENT,
                            (uintptr_t)channel_name, (uintptr_t)nvlbuf,
                            (uintptr_t)&udata, 0) != 0) {
                                free(nvlbuf);
                                return (NULL);
                        }
                } else {
                        free(nvlbuf);
                        return (NULL);
                }
        }

        if (nvlist_unpack(nvlbuf, udata.ps_buflen, &nvl, 0) != 0) {
                free(nvlbuf);
                return (NULL);
        }
        free(nvlbuf);

        return (nvl);
}

/*
 * The following routines provide a mechanism for publishers to maintain
 * subscriber information.
 */

static void
dealloc_subscribers(sysevent_handle_t *shp)
{
        int i;
        subscriber_data_t *sub;

        for (i = 1; i <= MAX_SUBSCRIBERS; ++i) {
                sub = SH_SUBSCRIBER(shp, i);
                if (sub != NULL) {
                        free(sub->sd_door_name);
                        free(sub);
                }
                SH_SUBSCRIBER(shp, i) = NULL;
        }
}

/*ARGSUSED*/
static int
alloc_subscriber(sysevent_handle_t *shp, uint32_t sub_id, int oflag)
{
        subscriber_data_t *sub;
        char door_name[MAXPATHLEN];

        if (SH_SUBSCRIBER(shp, sub_id) != NULL) {
                return (0);
        }

        /* Allocate and initialize the subscriber data */
        sub = (subscriber_data_t *)calloc(1,
            sizeof (subscriber_data_t));
        if (sub == NULL) {
                return (-1);
        }
        if (snprintf(door_name, MAXPATHLEN, "%s/%d",
            SH_CHANNEL_PATH(shp), sub_id) >= MAXPATHLEN) {
                free(sub);
                return (-1);
        }

        sub->sd_flag = ACTIVE;
        sub->sd_door_name = strdup(door_name);
        if (sub->sd_door_name == NULL) {
                free(sub);
                return (-1);
        }

        SH_SUBSCRIBER(shp, sub_id) = sub;
        return (0);

}

/*
 * The following routines are used to update and maintain the registration cache
 * for a particular sysevent channel.
 */

static uint32_t
hash_func(const char *s)
{
        uint32_t result = 0;
        uint_t g;

        while (*s != '\0') {
                result <<= 4;
                result += (uint32_t)*s++;
                g = result & 0xf0000000;
                if (g != 0) {
                        result ^= g >> 24;
                        result ^= g;
                }
        }

        return (result);
}

subclass_lst_t *
cache_find_subclass(class_lst_t *c_list, char *subclass)
{
        subclass_lst_t *sc_list;

        if (c_list == NULL)
                return (NULL);

        sc_list = c_list->cl_subclass_list;

        while (sc_list != NULL) {
                if (strcmp(sc_list->sl_name, subclass) == 0) {
                        return (sc_list);
                }
                sc_list = sc_list->sl_next;
        }

        return (NULL);
}


static class_lst_t *
cache_find_class(sysevent_handle_t *shp, char *class)
{
        int index;
        class_lst_t *c_list;
        class_lst_t **class_hash = SH_CLASS_HASH(shp);

        if (strcmp(class, EC_ALL) == 0) {
                return (class_hash[0]);
        }

        index = CLASS_HASH(class);
        c_list = class_hash[index];
        while (c_list != NULL) {
                if (strcmp(class, c_list->cl_name) == 0) {
                        break;
                }
                c_list = c_list->cl_next;
        }

        return (c_list);
}

static int
cache_insert_subclass(class_lst_t *c_list, char **subclass_names,
        int subclass_num, uint32_t sub_id)
{
        int i;
        subclass_lst_t *sc_list;

        for (i = 0; i < subclass_num; ++i) {
                if ((sc_list = cache_find_subclass(c_list, subclass_names[i]))
                    != NULL) {
                        sc_list->sl_num[sub_id] = 1;
                } else {
                        sc_list = (subclass_lst_t *)calloc(1,
                            sizeof (subclass_lst_t));
                        if (sc_list == NULL)
                                return (-1);

                        sc_list->sl_name = strdup(subclass_names[i]);
                        if (sc_list->sl_name == NULL) {
                                free(sc_list);
                                return (-1);
                        }

                        sc_list->sl_num[sub_id] = 1;
                        sc_list->sl_next = c_list->cl_subclass_list;
                        c_list->cl_subclass_list = sc_list;
                }
        }

        return (0);
}

static int
cache_insert_class(sysevent_handle_t *shp, char *class,
        char **subclass_names, int subclass_num, uint32_t sub_id)
{
        class_lst_t *c_list;

        if (strcmp(class, EC_ALL) == 0) {
                char *subclass_all = EC_SUB_ALL;

                (void) cache_insert_subclass(SH_CLASS_HASH(shp)[0],
                    (char **)&subclass_all, 1, sub_id);
                return (0);
        }

        /* New class, add to the registration cache */
        if ((c_list = cache_find_class(shp, class)) == NULL) {

                c_list = (class_lst_t *)calloc(1, sizeof (class_lst_t));
                if (c_list == NULL) {
                        return (1);
                }
                c_list->cl_name = strdup(class);
                if (c_list->cl_name == NULL) {
                        free(c_list);
                        return (1);
                }

                c_list->cl_subclass_list = (subclass_lst_t *)
                    calloc(1, sizeof (subclass_lst_t));
                if (c_list->cl_subclass_list == NULL) {
                        free(c_list->cl_name);
                        free(c_list);
                        return (1);
                }
                c_list->cl_subclass_list->sl_name = strdup(EC_SUB_ALL);
                if (c_list->cl_subclass_list->sl_name == NULL) {
                        free(c_list->cl_subclass_list);
                        free(c_list->cl_name);
                        free(c_list);
                        return (1);
                }
                c_list->cl_next = SH_CLASS_HASH(shp)[CLASS_HASH(class)];
                SH_CLASS_HASH(shp)[CLASS_HASH(class)] = c_list;

        }

        /* Update the subclass list */
        if (cache_insert_subclass(c_list, subclass_names, subclass_num,
            sub_id) != 0)
                return (1);

        return (0);
}

static void
cache_remove_all_class(sysevent_handle_t *shp, uint32_t sub_id)
{
        int i;
        class_lst_t *c_list;
        subclass_lst_t *sc_list;

        for (i = 0; i < CLASS_HASH_SZ + 1; ++i) {
                c_list = SH_CLASS_HASH(shp)[i];
                while (c_list != NULL) {
                        sc_list = c_list->cl_subclass_list;
                        while (sc_list != NULL) {
                                sc_list->sl_num[sub_id] = 0;
                                sc_list = sc_list->sl_next;
                        }
                        c_list = c_list->cl_next;
                }
        }
}

static void
cache_remove_class(sysevent_handle_t *shp, char *class, uint32_t sub_id)
{
        class_lst_t *c_list;
        subclass_lst_t *sc_list;

        if (strcmp(class, EC_ALL) == 0) {
                cache_remove_all_class(shp, sub_id);
                return;
        }

        if ((c_list = cache_find_class(shp, class)) == NULL) {
                return;
        }

        sc_list = c_list->cl_subclass_list;
        while (sc_list != NULL) {
                sc_list->sl_num[sub_id] = 0;
                sc_list = sc_list->sl_next;
        }
}

static void
free_cached_registration(sysevent_handle_t *shp)
{
        int i;
        class_lst_t *clist, *next_clist;
        subclass_lst_t *sc_list, *next_sc;

        for (i = 0; i < CLASS_HASH_SZ + 1; i++) {
                clist = SH_CLASS_HASH(shp)[i];
                while (clist != NULL) {
                        sc_list = clist->cl_subclass_list;
                        while (sc_list != NULL) {
                                free(sc_list->sl_name);
                                next_sc = sc_list->sl_next;
                                free(sc_list);
                                sc_list = next_sc;
                        }
                        free(clist->cl_name);
                        next_clist = clist->cl_next;
                        free(clist);
                        clist = next_clist;
                }
                SH_CLASS_HASH(shp)[i] = NULL;
        }
}

static int
create_cached_registration(sysevent_handle_t *shp,
        class_lst_t **class_hash)
{
        int i, j, new_class;
        char *class_name;
        uint_t num_elem;
        uchar_t *subscribers;
        nvlist_t *nvl;
        nvpair_t *nvpair;
        class_lst_t *clist;
        subclass_lst_t *sc_list;

        for (i = 0; i < CLASS_HASH_SZ + 1; ++i) {

                if ((nvl = get_kernel_registration(SH_CHANNEL_NAME(shp), i))
                    == NULL) {
                        if (errno == ENOENT) {
                                class_hash[i] = NULL;
                                continue;
                        } else {
                                goto create_failed;
                        }
                }


                nvpair = NULL;
                if ((nvpair = nvlist_next_nvpair(nvl, nvpair)) == NULL) {
                        goto create_failed;
                }

                new_class = 1;
                while (new_class) {
                        /* Extract the class name from the nvpair */
                        if (nvpair_value_string(nvpair, &class_name) != 0) {
                                goto create_failed;
                        }
                        clist = (class_lst_t *)
                            calloc(1, sizeof (class_lst_t));
                        if (clist == NULL) {
                                goto create_failed;
                        }

                        clist->cl_name = strdup(class_name);
                        if (clist->cl_name == NULL) {
                                free(clist);
                                goto create_failed;
                        }

                        /*
                         * Extract the subclass name and registration
                         * from the nvpair
                         */
                        if ((nvpair = nvlist_next_nvpair(nvl, nvpair))
                            == NULL) {
                                free(clist->cl_name);
                                free(clist);
                                goto create_failed;
                        }

                        clist->cl_next = class_hash[i];
                        class_hash[i] = clist;

                        for (;;) {

                                sc_list = (subclass_lst_t *)calloc(1,
                                    sizeof (subclass_lst_t));
                                if (sc_list == NULL) {
                                        goto create_failed;
                                }

                                sc_list->sl_next = clist->cl_subclass_list;
                                clist->cl_subclass_list = sc_list;

                                sc_list->sl_name = strdup(nvpair_name(nvpair));
                                if (sc_list->sl_name == NULL) {
                                        goto create_failed;
                                }

                                if (nvpair_value_byte_array(nvpair,
                                    &subscribers, &num_elem) != 0) {
                                        goto create_failed;
                                }
                                bcopy(subscribers, (uchar_t *)sc_list->sl_num,
                                    MAX_SUBSCRIBERS + 1);

                                for (j = 1; j <= MAX_SUBSCRIBERS; ++j) {
                                        if (sc_list->sl_num[j] == 0)
                                                continue;

                                        if (alloc_subscriber(shp, j, 1) != 0) {
                                                goto create_failed;
                                        }
                                }

                                /*
                                 * Check next nvpair - either subclass or
                                 * class
                                 */
                                if ((nvpair = nvlist_next_nvpair(nvl, nvpair))
                                    == NULL) {
                                        new_class = 0;
                                        break;
                                } else if (strcmp(nvpair_name(nvpair),
                                    CLASS_NAME) == 0) {
                                        break;
                                }
                        }
                }
                nvlist_free(nvl);
        }
        return (0);

create_failed:
        dealloc_subscribers(shp);
        free_cached_registration(shp);
        if (nvl)
                nvlist_free(nvl);
        return (-1);

}

/*
 * cache_update_service - generic event publisher service routine.  This routine
 *              is called in response to a registration cache update.
 *
 */
/*ARGSUSED*/
static void
cache_update_service(void *cookie, char *args, size_t alen,
    door_desc_t *ddp, uint_t ndid)
{
        int ret = 0;
        uint_t num_elem;
        char *class, **event_list;
        size_t datalen;
        uint32_t sub_id;
        nvlist_t *nvl;
        nvpair_t *nvpair = NULL;
        struct reg_args *rargs;
        sysevent_handle_t *shp;
        subscriber_data_t *sub;

        if (alen < sizeof (struct reg_args) || cookie == NULL) {
                ret = EINVAL;
                goto return_from_door;
        }

        /* LINTED: E_BAD_PTR_CAST_ALIGN */
        rargs = (struct reg_args *)args;
        shp = (sysevent_handle_t *)cookie;

        datalen = alen - sizeof (struct reg_args);
        sub_id = rargs->ra_sub_id;

        (void) mutex_lock(SH_LOCK(shp));

        switch (rargs->ra_op) {
        case SE_UNREGISTER:
                class = (char *)&rargs->ra_buf_ptr;
                cache_remove_class(shp, (char *)class,
                    sub_id);
                break;
        case SE_UNBIND_REGISTRATION:

                sub = SH_SUBSCRIBER(shp, sub_id);
                if (sub == NULL)
                        break;

                free(sub->sd_door_name);
                free(sub);
                cache_remove_class(shp, EC_ALL, sub_id);
                SH_SUBSCRIBER(shp, sub_id) = NULL;

                break;
        case SE_BIND_REGISTRATION:

                /* New subscriber */
                if (alloc_subscriber(shp, sub_id, 0) != 0) {
                        ret = ENOMEM;
                        break;
                }
                break;
        case SE_REGISTER:

                if (SH_SUBSCRIBER(shp, sub_id) == NULL) {
                        ret = EINVAL;
                        break;
                }
                /* Get new registration data */
                if (nvlist_unpack((char *)&rargs->ra_buf_ptr, datalen,
                    &nvl, 0) != 0) {
                        ret =  EFAULT;
                        break;
                }
                if ((nvpair = nvlist_next_nvpair(nvl, nvpair)) == NULL) {
                        nvlist_free(nvl);
                        ret = EFAULT;
                        break;
                }
                if (nvpair_value_string_array(nvpair, &event_list, &num_elem)
                    != 0) {
                        nvlist_free(nvl);
                        ret =  EFAULT;
                        break;
                }
                class = nvpair_name(nvpair);

                ret = cache_insert_class(shp, class,
                    event_list, num_elem, sub_id);
                if (ret != 0) {
                        cache_remove_class(shp, class, sub_id);
                        nvlist_free(nvl);
                        ret =  EFAULT;
                        break;
                }

                nvlist_free(nvl);

                break;
        case SE_CLEANUP:
                /* Cleanup stale subscribers */
                sysevent_cleanup_subscribers(shp);
                break;
        default:
                ret =  EINVAL;
        }

        (void) mutex_unlock(SH_LOCK(shp));

return_from_door:
        (void) door_return((void *)&ret, sizeof (ret), NULL, 0);
        (void) door_return(NULL, 0, NULL, 0);
}

/*
 * sysevent_send_event -
 * Send an event via the communication channel associated with the sysevent
 * handle.  Event notifications are broadcast to all subscribers based upon
 * the event class and subclass.  The handle must have been previously
 * allocated and bound by
 * sysevent_open_channel() and sysevent_bind_publisher()
 */
int
sysevent_send_event(sysevent_handle_t *shp, sysevent_t *ev)
{
        int i, error, sub_fd, result = 0;
        int deliver_error = 0;
        int subscribers_sent = 0;
        int want_resend, resend_cnt = 0;
        char *event_class, *event_subclass;
        uchar_t *all_class_subscribers, *all_subclass_subscribers;
        uchar_t *subclass_subscribers;
        subscriber_data_t *sub;
        subclass_lst_t *sc_lst;

        /* Check for proper registration */
        event_class = sysevent_get_class_name(ev);
        event_subclass = sysevent_get_subclass_name(ev);

        (void) mutex_lock(SH_LOCK(shp));

send_event:

        want_resend = 0;
        if (!SH_BOUND(shp)) {
                (void) mutex_unlock(SH_LOCK(shp));
                errno = EINVAL;
                return (-1);
        }

        /* Find all subscribers for this event class/subclass */
        sc_lst = cache_find_subclass(
            cache_find_class(shp, EC_ALL), EC_SUB_ALL);
        all_class_subscribers = sc_lst->sl_num;

        sc_lst = cache_find_subclass(
            cache_find_class(shp, event_class), EC_SUB_ALL);
        if (sc_lst)
                all_subclass_subscribers = sc_lst->sl_num;
        else
                all_subclass_subscribers = NULL;

        sc_lst = cache_find_subclass(
            cache_find_class(shp, event_class), event_subclass);
        if (sc_lst)
                subclass_subscribers = sc_lst->sl_num;
        else
                subclass_subscribers = NULL;

        /* Send event buffer to all valid subscribers */
        for (i = 1; i <= MAX_SUBSCRIBERS; ++i) {
                if ((all_class_subscribers[i] |
                    (all_subclass_subscribers && all_subclass_subscribers[i]) |
                    (subclass_subscribers && subclass_subscribers[i])) == 0)
                        continue;

                sub = SH_SUBSCRIBER(shp, i);
                assert(sub != NULL);

                /* Check for active subscriber */
                if (!(sub->sd_flag & ACTIVE)) {
                        dprint("sysevent_send_event: subscriber %d inactive\n",
                            i);
                        continue;
                }

                /* Process only resend requests */
                if (resend_cnt > 0 && !(sub->sd_flag & SEND_AGAIN)) {
                        continue;
                }

                if ((sub_fd = open(sub->sd_door_name, O_RDONLY)) == -1) {
                        dprint("sysevent_send_event: Failed to open "
                            "%s: %s\n", sub->sd_door_name, strerror(errno));
                        continue;
                }
                result = 0;
                error = clnt_deliver_event(sub_fd, ev,
                    sysevent_get_size(ev), &result, sizeof (result));

                (void) close(sub_fd);

                /* Successful door call */
                if (error == 0) {
                        switch (result) {
                        /* Subscriber requested EAGAIN */
                        case EAGAIN:
                                if (resend_cnt > SE_MAX_RETRY_LIMIT) {
                                        deliver_error = 1;
                                } else {
                                        want_resend = 1;
                                        dprint("sysevent_send_event: resend "
                                            "requested for %d\n", i);
                                        sub->sd_flag |= SEND_AGAIN;
                                }
                                break;
                        /* Bad sysevent handle for subscriber */
                        case EBADF:
                        case EINVAL:
                                dprint("sysevent_send_event: Bad sysevent "
                                    "handle for %s", sub->sd_door_name);
                                sub->sd_flag = 0;
                                deliver_error = 1;
                                break;
                        /* Successful delivery */
                        default:
                                sub->sd_flag &= ~SEND_AGAIN;
                                ++subscribers_sent;
                        }
                } else {
                        dprint("sysevent_send_event: Failed door call "
                            "to %s: %s: %d\n", sub->sd_door_name,
                            strerror(errno), result);
                        sub->sd_flag = 0;
                        deliver_error = 1;
                }
        }

        if (want_resend) {
                resend_cnt++;
                goto send_event;
        }

        if (deliver_error) {
                sysevent_cleanup_subscribers(shp);
                (void) mutex_unlock(SH_LOCK(shp));
                errno = EFAULT;
                return (-1);
        }

        (void) mutex_unlock(SH_LOCK(shp));

        if (subscribers_sent == 0) {
                dprint("sysevent_send_event: No subscribers for %s:%s\n",
                    event_class, event_subclass);
                errno = ENOENT;
                return (-1);
        }

        return (0);
}

/*
 * Common routine to establish an event channel through which an event
 * publisher or subscriber may post or receive events.
 */
static sysevent_handle_t *
sysevent_open_channel_common(const char *channel_path)
{
        uint32_t sub_id = 0;
        char *begin_path;
        struct stat chan_stat;
        sysevent_handle_t *shp;


        if (channel_path == NULL || strlen(channel_path) + 1 > MAXPATHLEN) {
                errno = EINVAL;
                return (NULL);
        }

        if (mkdir(channel_path, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) < 0) {
                if (errno != EEXIST) {
                        errno = EACCES;
                        return (NULL);
                }
        }

        /* Check channel file permissions */
        if (stat(channel_path, &chan_stat) != 0) {
                dprint("sysevent_open_channel: Invalid permissions for channel "
                    "%s\n", channel_path);
                errno = EACCES;
                return (NULL);
        } else if (chan_stat.st_uid != getuid() ||
            !S_ISDIR(chan_stat.st_mode)) {
                dprint("sysevent_open_channel: Invalid "
                    "permissions for channel %s\n: %d:%d:%d", channel_path,
                    (int)chan_stat.st_uid, (int)chan_stat.st_gid,
                    (int)chan_stat.st_mode);

                errno = EACCES;
                return (NULL);
        }

        shp = calloc(1, sizeof (sysevent_impl_hdl_t));
        if (shp == NULL) {
                errno = ENOMEM;
                return (NULL);
        }

        SH_CHANNEL_NAME(shp) = NULL;
        SH_CHANNEL_PATH(shp) = strdup(channel_path);
        if (SH_CHANNEL_PATH(shp) == NULL) {
                free(shp);
                errno = ENOMEM;
                return (NULL);
        }

        /* Extract the channel name */
        begin_path = SH_CHANNEL_PATH(shp);
        while (*begin_path != '\0' &&
            (begin_path = strpbrk(begin_path, "/")) != NULL) {
                ++begin_path;
                SH_CHANNEL_NAME(shp) = begin_path;
        }

        if (update_kernel_registration(shp, 0,
            SE_OPEN_REGISTRATION, &sub_id, 0, NULL) != 0) {
                dprint("sysevent_open_channel: Failed for channel %s\n",
                    SH_CHANNEL_NAME(shp));
                free(SH_CHANNEL_PATH(shp));
                free(shp);
                errno = EFAULT;
                return (NULL);
        }

        (void) mutex_init(SH_LOCK(shp), USYNC_THREAD, NULL);

        return (shp);
}

/*
 * Establish a sysevent channel for publication and subscription
 */
sysevent_handle_t *
sysevent_open_channel(const char *channel)
{
        int var_run_mounted = 0;
        char full_channel[MAXPATHLEN + 1];
        FILE *fp;
        struct stat chan_stat;
        struct extmnttab m;

        if (channel == NULL) {
                errno = EINVAL;
                return (NULL);
        }

        /*
         * Check that /var/run is mounted as tmpfs before allowing a channel
         * to be opened.
         */
        if ((fp = fopen(MNTTAB, "rF")) == NULL) {
                errno = EACCES;
                return (NULL);
        }

        resetmnttab(fp);

        while (getextmntent(fp, &m, sizeof (struct extmnttab)) == 0) {
                if (strcmp(m.mnt_mountp, "/var/run") == 0 &&
                    strcmp(m.mnt_fstype, "tmpfs") == 0) {
                        var_run_mounted = 1;
                        break;
                }
        }
        (void) fclose(fp);

        if (!var_run_mounted) {
                errno = EACCES;
                return (NULL);
        }

        if (stat(CHAN_PATH, &chan_stat) < 0) {
                if (mkdir(CHAN_PATH,
                    S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) < 0) {
                        dprint("sysevent_open_channel: Unable "
                            "to create channel directory %s:%s\n", CHAN_PATH,
                            strerror(errno));
                        if (errno != EEXIST) {
                                errno = EACCES;
                                return (NULL);
                        }
                }
        }

        if (snprintf(full_channel, MAXPATHLEN, "%s/%s", CHAN_PATH, channel) >=
            MAXPATHLEN) {
                errno = EINVAL;
                return (NULL);
        }

        return (sysevent_open_channel_common(full_channel));
}

/*
 * Establish a sysevent channel for publication and subscription
 * Full path to the channel determined by the caller
 */
sysevent_handle_t *
sysevent_open_channel_alt(const char *channel_path)
{
        return (sysevent_open_channel_common(channel_path));
}

/*
 * sysevent_close_channel - Clean up resources associated with a previously
 *                              opened sysevent channel
 */
void
sysevent_close_channel(sysevent_handle_t *shp)
{
        int error = errno;
        uint32_t sub_id = 0;

        if (shp == NULL) {
                return;
        }

        (void) mutex_lock(SH_LOCK(shp));
        if (SH_BOUND(shp)) {
                (void) mutex_unlock(SH_LOCK(shp));
                if (SH_TYPE(shp) == PUBLISHER)
                        sysevent_unbind_publisher(shp);
                else if (SH_TYPE(shp) == SUBSCRIBER)
                        sysevent_unbind_subscriber(shp);
                (void) mutex_lock(SH_LOCK(shp));
        }

        (void) update_kernel_registration(shp, 0,
            SE_CLOSE_REGISTRATION, &sub_id, 0, NULL);
        (void) mutex_unlock(SH_LOCK(shp));

        free(SH_CHANNEL_PATH(shp));
        free(shp);
        errno = error;
}

/*
 * sysevent_bind_publisher - Bind an event publisher to an event channel
 */
int
sysevent_bind_publisher(sysevent_handle_t *shp)
{
        int error = 0;
        int fd = -1;
        char door_name[MAXPATHLEN];
        uint32_t pub_id;
        struct stat reg_stat;
        publisher_priv_t *pub;

        if (shp == NULL) {
                errno = EINVAL;
                return (-1);
        }

        (void) mutex_lock(SH_LOCK(shp));
        if (SH_BOUND(shp)) {
                (void) mutex_unlock(SH_LOCK(shp));
                errno = EINVAL;
                return (-1);
        }

        if ((pub = (publisher_priv_t *)calloc(1, sizeof (publisher_priv_t))) ==
            NULL) {
                (void) mutex_unlock(SH_LOCK(shp));
                errno = ENOMEM;
                return (-1);
        }
        SH_PRIV_DATA(shp) = (void *)pub;

        if (snprintf(door_name, MAXPATHLEN, "%s/%s",
            SH_CHANNEL_PATH(shp), REG_DOOR) >= MAXPATHLEN) {
                free(pub);
                (void) mutex_unlock(SH_LOCK(shp));
                errno = ENOMEM;
                return (-1);
        }
        if ((SH_DOOR_NAME(shp) = strdup(door_name)) == NULL) {
                free(pub);
                (void) mutex_unlock(SH_LOCK(shp));
                errno = ENOMEM;
                return (-1);
        }

        /* Only one publisher allowed per channel */
        if (stat(SH_DOOR_NAME(shp), &reg_stat) != 0) {
                if (errno != ENOENT) {
                        error = EINVAL;
                        goto fail;
                }
        }

        /*
         * Remove door file for robustness.
         */
        if (unlink(SH_DOOR_NAME(shp)) != 0)
                dprint("sysevent_bind_publisher: Unlink of %s failed.\n",
                    SH_DOOR_NAME(shp));

        /* Open channel registration door */
        fd = open(SH_DOOR_NAME(shp), O_CREAT|O_RDWR,
            S_IREAD|S_IWRITE);
        if (fd == -1) {
                error = EINVAL;
                goto fail;
        }

        /*
         * Create the registration service for this publisher.
         */
        if ((SH_DOOR_DESC(shp) = door_create(cache_update_service,
            (void *)shp, DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) {
                dprint("sysevent_bind_publisher: door create failed: "
                    "%s\n", strerror(errno));
                error = EFAULT;
                goto fail;
        }

        (void) fdetach(SH_DOOR_NAME(shp));
        if (fattach(SH_DOOR_DESC(shp), SH_DOOR_NAME(shp)) != 0) {
                dprint("sysevent_bind_publisher: unable to "
                    "bind event channel: fattach: %s\n",
                    SH_DOOR_NAME(shp));
                error = EACCES;
                goto fail;
        }

        /* Bind this publisher in the kernel registration database */
        if (update_kernel_registration(shp, PUBLISHER,
            SE_BIND_REGISTRATION, &pub_id, 0, NULL) != 0) {
                error = errno;
                goto fail;
        }

        SH_ID(shp) = pub_id;
        SH_BOUND(shp) = 1;
        SH_TYPE(shp) = PUBLISHER;


        /* Create the subscription registration cache */
        if (create_cached_registration(shp, SH_CLASS_HASH(shp)) != 0) {
                (void) update_kernel_registration(shp,
                    PUBLISHER, SE_UNBIND_REGISTRATION, &pub_id, 0, NULL);
                error = EFAULT;
                goto fail;
        }
        (void) close(fd);

        (void) mutex_unlock(SH_LOCK(shp));

        return (0);

fail:
        SH_BOUND(shp) = 0;
        (void) door_revoke(SH_DOOR_DESC(shp));
        (void) fdetach(SH_DOOR_NAME(shp));
        free(SH_DOOR_NAME(shp));
        free(pub);
        (void) close(fd);
        (void) mutex_unlock(SH_LOCK(shp));
        errno = error;
        return (-1);
}

static pthread_once_t xdoor_thrattr_once = PTHREAD_ONCE_INIT;
static pthread_attr_t xdoor_thrattr;

static void
xdoor_thrattr_init(void)
{
        (void) pthread_attr_init(&xdoor_thrattr);
        (void) pthread_attr_setdetachstate(&xdoor_thrattr,
            PTHREAD_CREATE_DETACHED);
        (void) pthread_attr_setscope(&xdoor_thrattr, PTHREAD_SCOPE_SYSTEM);
}

static int
xdoor_server_create(door_info_t *dip, void *(*startf)(void *),
    void *startfarg, void *cookie)
{
        struct sysevent_subattr_impl *xsa = cookie;
        pthread_attr_t *thrattr;
        sigset_t oset;
        int err;

        if (xsa->xs_thrcreate) {
                return (xsa->xs_thrcreate(dip, startf, startfarg,
                    xsa->xs_thrcreate_cookie));
        }

        if (xsa->xs_thrattr == NULL) {
                (void) pthread_once(&xdoor_thrattr_once, xdoor_thrattr_init);
                thrattr = &xdoor_thrattr;
        } else {
                thrattr = xsa->xs_thrattr;
        }

        (void) pthread_sigmask(SIG_SETMASK, &xsa->xs_sigmask, &oset);
        err = pthread_create(NULL, thrattr, startf, startfarg);
        (void) pthread_sigmask(SIG_SETMASK, &oset, NULL);

        return (err == 0 ? 1 : -1);
}

static void
xdoor_server_setup(void *cookie)
{
        struct sysevent_subattr_impl *xsa = cookie;

        if (xsa->xs_thrsetup) {
                xsa->xs_thrsetup(xsa->xs_thrsetup_cookie);
        } else {
                (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
                (void) pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
        }
}

static int
sysevent_bind_subscriber_cmn(sysevent_handle_t *shp,
        void (*event_handler)(sysevent_t *ev),
        sysevent_subattr_t *subattr)
{
        int fd = -1;
        int error = 0;
        uint32_t sub_id = 0;
        char door_name[MAXPATHLEN];
        subscriber_priv_t *sub_info;
        int created;
        struct sysevent_subattr_impl *xsa =
            (struct sysevent_subattr_impl *)subattr;

        if (shp == NULL || event_handler == NULL) {
                errno = EINVAL;
                return (-1);
        }

        (void) mutex_lock(SH_LOCK(shp));
        if (SH_BOUND(shp)) {
                errno = EINVAL;
                (void) mutex_unlock(SH_LOCK(shp));
                return (-1);
        }

        if ((sub_info = (subscriber_priv_t *)calloc(1,
            sizeof (subscriber_priv_t))) == NULL) {
                errno = ENOMEM;
                (void) mutex_unlock(SH_LOCK(shp));
                return (-1);
        }

        if (snprintf(door_name, MAXPATHLEN, "%s/%s",
            SH_CHANNEL_PATH(shp), REG_DOOR) >= MAXPATHLEN) {
                free(sub_info);
                errno = EINVAL;
                (void) mutex_unlock(SH_LOCK(shp));
                return (-1);
        }

        if ((sub_info->sp_door_name = strdup(door_name)) == NULL) {
                free(sub_info);
                errno = ENOMEM;
                (void) mutex_unlock(SH_LOCK(shp));
                return (-1);
        }
        (void) cond_init(&sub_info->sp_cv, USYNC_THREAD, NULL);
        (void) mutex_init(&sub_info->sp_qlock, USYNC_THREAD, NULL);
        sub_info->sp_func = event_handler;

        /* Update the in-kernel registration */
        if (update_kernel_registration(shp, SUBSCRIBER,
            SE_BIND_REGISTRATION, &sub_id, 0, NULL) != 0) {
                error = errno;
                goto fail;
        }
        SH_ID(shp) = sub_id;

        if (snprintf(door_name, MAXPATHLEN, "%s/%d",
            SH_CHANNEL_PATH(shp), sub_id) >= MAXPATHLEN) {
                error = EINVAL;
                goto fail;
        }
        if ((SH_DOOR_NAME(shp) = strdup(door_name)) == NULL) {
                error = ENOMEM;
                goto fail;
        }

        /*
         * Remove door file for robustness.
         */
        if (unlink(SH_DOOR_NAME(shp)) != 0)
                dprint("sysevent_bind_subscriber: Unlink of %s failed.\n",
                    SH_DOOR_NAME(shp));

        fd = open(SH_DOOR_NAME(shp), O_CREAT|O_RDWR, S_IREAD|S_IWRITE);
        if (fd == -1) {
                error = EFAULT;
                goto fail;
        }

        /*
         * Create the sysevent door service for this client.
         * syseventd will use this door service to propagate
         * events to the client.
         */
        if (subattr == NULL) {
                SH_DOOR_DESC(shp) = door_create(event_deliver_service,
                    (void *)shp, DOOR_REFUSE_DESC | DOOR_NO_CANCEL);
        } else {
                SH_DOOR_DESC(shp) = door_xcreate(event_deliver_service,
                    (void *)shp,
                    DOOR_REFUSE_DESC | DOOR_NO_CANCEL | DOOR_NO_DEPLETION_CB,
                    xdoor_server_create, xdoor_server_setup,
                    (void *)subattr, 1);
        }

        if (SH_DOOR_DESC(shp) == -1) {
                dprint("sysevent_bind_subscriber: door create failed: "
                    "%s\n", strerror(errno));
                error = EFAULT;
                goto fail;
        }

        (void) fdetach(SH_DOOR_NAME(shp));
        if (fattach(SH_DOOR_DESC(shp), SH_DOOR_NAME(shp)) != 0) {
                error = EFAULT;
                goto fail;
        }
        (void) close(fd);

        if (update_publisher_cache(sub_info, SE_BIND_REGISTRATION,
            sub_id, 0, NULL) != 0) {
                error = errno;
                (void) update_kernel_registration(shp, SUBSCRIBER,
                    SE_UNBIND_REGISTRATION, &sub_id, 0, NULL);
                goto fail;
        }

        SH_BOUND(shp) = 1;
        SH_TYPE(shp) = SUBSCRIBER;
        SH_PRIV_DATA(shp) = (void *)sub_info;

        /* Create an event handler thread */
        if (xsa == NULL || xsa->xs_thrcreate == NULL) {
                created = thr_create(NULL, NULL,
                    (void *(*)(void *))subscriber_event_handler,
                    shp, THR_BOUND, &sub_info->sp_handler_tid) == 0;
        } else {
                /*
                 * A terrible hack.  We will use the extended private
                 * door thread creation function the caller passed in to
                 * create the event handler thread.  That function will
                 * be called with our chosen thread start function and arg
                 * instead of the usual libc-provided ones, but that's ok
                 * as it is required to use them verbatim anyway.  We will
                 * pass a NULL door_info_t pointer to the function - so
                 * callers depending on this hack had better be prepared
                 * for that.  All this allow the caller to rubberstamp
                 * the created thread as it wishes.  But we don't get
                 * the created threadid with this, so we modify the
                 * thread start function to stash it.
                 */

                created = xsa->xs_thrcreate(NULL,
                    (void *(*)(void *))subscriber_event_handler,
                    shp, xsa->xs_thrcreate_cookie) == 1;
        }

        if (!created) {
                error = EFAULT;
                goto fail;
        }

        (void) mutex_unlock(SH_LOCK(shp));

        return (0);

fail:
        (void) close(fd);
        (void) door_revoke(SH_DOOR_DESC(shp));
        (void) fdetach(SH_DOOR_NAME(shp));
        (void) cond_destroy(&sub_info->sp_cv);
        (void) mutex_destroy(&sub_info->sp_qlock);
        free(sub_info->sp_door_name);
        free(sub_info);
        if (SH_ID(shp)) {
                (void) update_kernel_registration(shp, SUBSCRIBER,
                    SE_UNBIND_REGISTRATION, &sub_id, 0, NULL);
                SH_ID(shp) = 0;
        }
        if (SH_BOUND(shp)) {
                (void) update_publisher_cache(sub_info, SE_UNBIND_REGISTRATION,
                    sub_id, 0, NULL);
                free(SH_DOOR_NAME(shp));
                SH_BOUND(shp) = 0;
        }
        (void) mutex_unlock(SH_LOCK(shp));

        errno = error;

        return (-1);
}

/*
 * sysevent_bind_subscriber - Bind an event receiver to an event channel
 */
int
sysevent_bind_subscriber(sysevent_handle_t *shp,
        void (*event_handler)(sysevent_t *ev))
{
        return (sysevent_bind_subscriber_cmn(shp, event_handler, NULL));
}

/*
 * sysevent_bind_xsubscriber - Bind a subscriber using door_xcreate with
 * attributes specified.
 */
int
sysevent_bind_xsubscriber(sysevent_handle_t *shp,
        void (*event_handler)(sysevent_t *ev), sysevent_subattr_t *subattr)
{
        return (sysevent_bind_subscriber_cmn(shp, event_handler, subattr));
}

/*
 * sysevent_register_event - register an event class and associated subclasses
 *              for an event subscriber
 */
int
sysevent_register_event(sysevent_handle_t *shp,
        const char *ev_class, const char **ev_subclass,
        int subclass_num)
{
        int error;
        char *event_class = (char *)ev_class;
        char **event_subclass_list = (char **)ev_subclass;
        char *nvlbuf = NULL;
        size_t datalen;
        nvlist_t *nvl;

        (void) mutex_lock(SH_LOCK(shp));
        if (event_class == NULL || event_subclass_list == NULL ||
            event_subclass_list[0] == NULL || SH_BOUND(shp) != 1 ||
            subclass_num <= 0) {
                (void) mutex_unlock(SH_LOCK(shp));
                errno = EINVAL;
                return (-1);
        }

        if (nvlist_alloc(&nvl, NV_UNIQUE_NAME_TYPE, 0) != 0) {
                (void) mutex_unlock(SH_LOCK(shp));
                return (-1);
        }
        if (nvlist_add_string_array(nvl, event_class, event_subclass_list,
            subclass_num) != 0) {
                nvlist_free(nvl);
                (void) mutex_unlock(SH_LOCK(shp));
                return (-1);
        }
        if (nvlist_pack(nvl, &nvlbuf, &datalen, NV_ENCODE_NATIVE, 0) != 0) {
                nvlist_free(nvl);
                (void) mutex_unlock(SH_LOCK(shp));
                return (-1);
        }
        nvlist_free(nvl);

        /* Store new subscriber in in-kernel registration */
        if (update_kernel_registration(shp, SUBSCRIBER,
            SE_REGISTER, &SH_ID(shp), datalen, (uchar_t *)nvlbuf)
            != 0) {
                error = errno;
                free(nvlbuf);
                (void) mutex_unlock(SH_LOCK(shp));
                errno = error;
                return (-1);
        }
        /* Update the publisher's cached registration */
        if (update_publisher_cache(
            (subscriber_priv_t *)SH_PRIV_DATA(shp), SE_REGISTER,
            SH_ID(shp), datalen, (uchar_t *)nvlbuf) != 0) {
                error = errno;
                free(nvlbuf);
                (void) mutex_unlock(SH_LOCK(shp));
                errno = error;
                return (-1);
        }

        free(nvlbuf);

        (void) mutex_unlock(SH_LOCK(shp));

        return (0);
}

/*
 * sysevent_unregister_event - Unregister an event class and associated
 *                              subclasses for an event subscriber
 */
void
sysevent_unregister_event(sysevent_handle_t *shp, const char *class)
{
        size_t class_sz;

        (void) mutex_lock(SH_LOCK(shp));

        if (!SH_BOUND(shp)) {
                (void) mutex_unlock(SH_LOCK(shp));
                return;
        }

        /* Remove subscriber from in-kernel registration */
        class_sz = strlen(class) + 1;
        (void) update_kernel_registration(shp, SUBSCRIBER,
            SE_UNREGISTER, &SH_ID(shp), class_sz, (uchar_t *)class);
        /* Update the publisher's cached registration */
        (void) update_publisher_cache(
            (subscriber_priv_t *)SH_PRIV_DATA(shp), SE_UNREGISTER,
            SH_ID(shp), class_sz, (uchar_t *)class);

        (void) mutex_unlock(SH_LOCK(shp));
}

static int
cleanup_id(sysevent_handle_t *shp, uint32_t id, int type)
{
        dprint("cleanup_id: Cleaning up %s/%d\n", SH_CHANNEL_NAME(shp), id);

        /* Remove registration from the kernel */
        if (update_kernel_registration(shp, type, SE_CLEANUP, &id,
            0, NULL) != 0) {
                dprint("cleanup_id: Unable to clean "
                    "up %s/%d\n", SH_CHANNEL_NAME(shp), id);
                return (-1);
        }

        return (0);
}

/*
 * sysevent_cleanup_subscribers: Allows the caller to cleanup resources
 *              allocated to unresponsive subscribers.
 */
void
sysevent_cleanup_subscribers(sysevent_handle_t *shp)
{
        uint32_t ping, result;
        int i, error, sub_fd;
        subscriber_data_t *sub;

        if (!SH_BOUND(shp)) {
                return;
        }

        for (i = 1; i <= MAX_SUBSCRIBERS; ++i) {

                sub = SH_SUBSCRIBER(shp, i);
                if (sub == NULL) {
                        continue;
                }

                if ((sub_fd = open(sub->sd_door_name, O_RDONLY)) == -1) {
                        continue;
                }
                /* Check for valid and responsive subscriber */
                error = clnt_deliver_event(sub_fd, &ping,
                    sizeof (uint32_t), &result, sizeof (result));
                (void) close(sub_fd);

                /* Only cleanup on EBADF (Invalid door descriptor) */
                if (error != EBADF)
                        continue;

                if (cleanup_id(shp, i, SUBSCRIBER) != 0)
                        continue;

                cache_remove_class(shp, EC_ALL, i);

                free(sub->sd_door_name);
                free(sub);
                SH_SUBSCRIBER(shp, i) = NULL;
        }

}

/*
 * sysevent_cleanup_publishers: Allows stale publisher handles to be deallocated
 *              as needed.
 */
void
sysevent_cleanup_publishers(sysevent_handle_t *shp)
{
        (void) cleanup_id(shp, 1, PUBLISHER);
}

/*
 * sysevent_unbind_subscriber: Unbind the subscriber from the sysevent channel.
 */
void
sysevent_unbind_subscriber(sysevent_handle_t *shp)
{
        subscriber_priv_t *sub_info;

        if (shp == NULL)
                return;

        (void) mutex_lock(SH_LOCK(shp));
        if (SH_BOUND(shp) == 0) {
                (void) mutex_unlock(SH_LOCK(shp));
                return;
        }

        /* Update the in-kernel registration */
        (void) update_kernel_registration(shp, SUBSCRIBER,
            SE_UNBIND_REGISTRATION, &SH_ID(shp), 0, NULL);

        /* Update the sysevent channel publisher */
        sub_info = (subscriber_priv_t *)SH_PRIV_DATA(shp);
        (void) update_publisher_cache(sub_info, SE_UNBIND_REGISTRATION,
            SH_ID(shp), 0, NULL);

        /* Close down event delivery facilities */
        (void) door_revoke(SH_DOOR_DESC(shp));
        (void) fdetach(SH_DOOR_NAME(shp));

        /*
         * Release resources and wait for pending event delivery to
         * complete.
         */
        (void) mutex_lock(&sub_info->sp_qlock);
        SH_BOUND(shp) = 0;
        /* Signal event handler and drain the subscriber's event queue */
        (void) cond_signal(&sub_info->sp_cv);
        (void) mutex_unlock(&sub_info->sp_qlock);
        if (sub_info->sp_handler_tid != NULL)
                (void) thr_join(sub_info->sp_handler_tid, NULL, NULL);

        (void) cond_destroy(&sub_info->sp_cv);
        (void) mutex_destroy(&sub_info->sp_qlock);
        free(sub_info->sp_door_name);
        free(sub_info);
        free(SH_DOOR_NAME(shp));
        (void) mutex_unlock(SH_LOCK(shp));
}

/*
 * sysevent_unbind_publisher: Unbind publisher from the sysevent channel.
 */
void
sysevent_unbind_publisher(sysevent_handle_t *shp)
{
        if (shp == NULL)
                return;

        (void) mutex_lock(SH_LOCK(shp));
        if (SH_BOUND(shp) == 0) {
                (void) mutex_unlock(SH_LOCK(shp));
                return;
        }

        /* Close down the registration facilities */
        (void) door_revoke(SH_DOOR_DESC(shp));
        (void) fdetach(SH_DOOR_NAME(shp));

        /* Update the in-kernel registration */
        (void) update_kernel_registration(shp, PUBLISHER,
            SE_UNBIND_REGISTRATION, &SH_ID(shp), 0, NULL);
        SH_BOUND(shp) = 0;

        /* Free resources associated with bind */
        free_cached_registration(shp);
        dealloc_subscribers(shp);

        free(SH_PRIV_DATA(shp));
        free(SH_DOOR_NAME(shp));
        SH_ID(shp) = 0;
        (void) mutex_unlock(SH_LOCK(shp));
}

/*
 * Evolving APIs to subscribe to syseventd(1M) system events.
 */

static sysevent_handle_t *
sysevent_bind_handle_cmn(void (*event_handler)(sysevent_t *ev),
    sysevent_subattr_t *subattr)
{
        sysevent_handle_t *shp;

        if (getuid() != 0) {
                errno = EACCES;
                return (NULL);
        }

        if (event_handler == NULL) {
                errno = EINVAL;
                return (NULL);
        }

        if ((shp = sysevent_open_channel(SYSEVENTD_CHAN)) == NULL) {
                return (NULL);
        }

        if (sysevent_bind_xsubscriber(shp, event_handler, subattr) != 0) {
                /*
                 * Ask syseventd to clean-up any stale subcribers and try to
                 * to bind again
                 */
                if (errno == EBUSY) {
                        int pub_fd;
                        char door_name[MAXPATHLEN];
                        uint32_t result;
                        struct reg_args rargs;

                        if (snprintf(door_name, MAXPATHLEN, "%s/%s",
                            SH_CHANNEL_PATH(shp), REG_DOOR) >= MAXPATHLEN) {
                                sysevent_close_channel(shp);
                                errno = EINVAL;
                                return (NULL);
                        }

                        rargs.ra_op = SE_CLEANUP;
                        pub_fd = open(door_name, O_RDONLY);
                        (void) clnt_deliver_event(pub_fd, (void *)&rargs,
                            sizeof (struct reg_args), &result, sizeof (result));
                        (void) close(pub_fd);

                        /* Try to bind again */
                        if (sysevent_bind_xsubscriber(shp, event_handler,
                            subattr) != 0) {
                                sysevent_close_channel(shp);
                                return (NULL);
                        }
                } else {
                        sysevent_close_channel(shp);
                        return (NULL);
                }
        }

        return (shp);
}

/*
 * sysevent_bind_handle - Bind application event handler for syseventd
 *              subscription.
 */
sysevent_handle_t *
sysevent_bind_handle(void (*event_handler)(sysevent_t *ev))
{
        return (sysevent_bind_handle_cmn(event_handler, NULL));
}

/*
 * sysevent_bind_xhandle - Bind application event handler for syseventd
 *              subscription, using door_xcreate and attributes as specified.
 */
sysevent_handle_t *
sysevent_bind_xhandle(void (*event_handler)(sysevent_t *ev),
    sysevent_subattr_t *subattr)
{
        return (sysevent_bind_handle_cmn(event_handler, subattr));
}

/*
 * sysevent_unbind_handle - Unbind caller from syseventd subscriptions
 */
void
sysevent_unbind_handle(sysevent_handle_t *shp)
{
        sysevent_unbind_subscriber(shp);
        sysevent_close_channel(shp);
}

/*
 * sysevent_subscribe_event - Subscribe to system event notification from
 *                      syseventd(1M) for the class and subclasses specified.
 */
int
sysevent_subscribe_event(sysevent_handle_t *shp, const char *event_class,
        const char **event_subclass_list, int num_subclasses)
{
        return (sysevent_register_event(shp, event_class,
            event_subclass_list, num_subclasses));
}

void
sysevent_unsubscribe_event(sysevent_handle_t *shp, const char *event_class)
{
        sysevent_unregister_event(shp, event_class);
}