/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/sysevent/dr.h>
#include <sys/sysevent/eventdefs.h>
#include <sys/sunddi.h> /* for the EC's for DEVFS */

#include <errno.h>
#include <string.h>
#include <strings.h>
#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <pthread.h>

#include <libsysevent.h>
#include <sys/sysevent_impl.h>

#include <libnvpair.h>
#include <config_admin.h>

#include "disk_monitor.h"
#include "hotplug_mgr.h"
#include "schg_mgr.h"
#include "dm_platform.h"

typedef struct sysevent_event {
        sysevent_t      *evp;
} sysevent_event_t;

/* Lock guarantees the ordering of the incoming sysevents */
static pthread_t g_sysev_tid;
static pthread_mutex_t g_event_handler_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t g_event_handler_cond = PTHREAD_COND_INITIALIZER;
static qu_t *g_sysev_queue = NULL;
static thread_state_t g_sysev_thread_state = TS_NOT_RUNNING;
/*
 * The sysevent handle is bound to the main sysevent handler
 * (event_handler), for each of the hotplug sysevents.
 */
static sysevent_handle_t *sysevent_handle = NULL;

static void free_sysevent_event(void *p);

static int
nsleep(int seconds)
{
        struct timespec tspec;

        tspec.tv_sec = seconds;
        tspec.tv_nsec = 0;

        return (nanosleep(&tspec, NULL));
}

static int
config_list_ext_poll(int num, char * const *path,
    cfga_list_data_t **list_array, int *nlist, int flag)
{
        boolean_t done = B_FALSE;
        boolean_t timedout = B_FALSE;
        boolean_t interrupted = B_FALSE;
        int timeout = 0;
        int e;
#define TIMEOUT_MAX 60

        do {
                switch ((e = config_list_ext(num, path, list_array,
                    nlist, NULL, NULL, NULL, flag))) {

                case CFGA_OK:

                        return (CFGA_OK);

                case CFGA_BUSY:
                case CFGA_SYSTEM_BUSY:

                        if (timeout++ >= TIMEOUT_MAX)
                                timedout = B_TRUE;
                        else {
                                if (nsleep(1) < 0)
                                        interrupted = (errno == EINTR);
                        }
                        break;

                default:
                        done = B_TRUE;
                        break;

                }
        } while (!done && !timedout && !interrupted);

        return (e);
}

/*
 * Given a physical attachment point with a dynamic component
 * (as in the case of SCSI APs), ensure the 'controller'
 * portion of the dynamic component matches the physical portion.
 * Argument 'adjusted' must point to a buffer of at least
 * MAXPATHLEN bytes.
 */
void
adjust_dynamic_ap(const char *apid, char *adjusted)
{
        cfga_list_data_t *list_array = NULL;
        int nlist;
        char *ap_path[1];
        char phys[MAXPATHLEN];
        char dev_phys[MAXPATHLEN];
        char *dyn;
        int c, t, d;

        dm_assert((strlen(apid) + 8 /* strlen("/devices") */) < MAXPATHLEN);

        /* In the case of any error, return the unadjusted APID */
        (void) strcpy(adjusted, apid);

        /* if AP is not dynamic or not a disk node, no need to adjust it */
        dyn = strstr(apid, "::");
        if ((dyn == NULL) || (dyn == apid) ||
            (sscanf(dyn, "::dsk/c%dt%dd%d", &c, &t, &d) != 3))
                return;

        /*
         * Copy the AP_ID and terminate it at the '::' that we know
         * for a fact it contains.  Pre-pend '/devices' for the sake
         * of cfgadm_scsi, and get the cfgadm data for the controller.
         */
        (void) strcpy(phys, apid);
        *strstr(phys, "::") = '\0';
        (void) snprintf(dev_phys, MAXPATHLEN, "/devices%s", phys);
        ap_path[0] = dev_phys;

        if (config_list_ext_poll(1, ap_path, &list_array, &nlist, 0)
            != CFGA_OK)
                return;

        dm_assert(nlist == 1);

        if (sscanf(list_array[0].ap_log_id, "c%d", &c) == 1)
                (void) snprintf(adjusted, MAXPATHLEN, "%s::dsk/c%dt%dd%d",
                    phys, c, t, d);

        free(list_array);
}

static int
disk_ap_is_scsi(const char *ap_path)
{
        return (strstr(ap_path, ":scsi:") != NULL);
}

/*
 * Looks up the attachment point's state and returns it in one of
 * the hotplug states that the state change manager understands.
 */
hotplug_state_t
disk_ap_state_to_hotplug_state(diskmon_t *diskp)
{
        hotplug_state_t state = HPS_UNKNOWN;
        cfga_list_data_t *list_array = NULL;
        int rv, nlist;
        char *app = (char *)dm_prop_lookup(diskp->app_props,
            DISK_AP_PROP_APID);
        char adj_app[MAXPATHLEN];
        char *ap_path[1];
        char *devices_app;
        int len;
        boolean_t list_valid = B_FALSE;

        dm_assert(app != NULL);

        adjust_dynamic_ap(app, adj_app);
        ap_path[0] = adj_app;
        devices_app = NULL;

        rv = config_list_ext_poll(1, ap_path, &list_array, &nlist,
            CFGA_FLAG_LIST_ALL);

        if (rv != CFGA_OK) {
                /*
                 * The SATA and SCSI libcfgadm plugins add a
                 * /devices to the phys id; to use it, we must
                 * prepend this string before the call.
                 */
                len = 8 /* strlen("/devices") */ + strlen(adj_app) + 1;
                devices_app = dmalloc(len);
                (void) snprintf(devices_app, len, "/devices%s",
                    adj_app);
                ap_path[0] = devices_app;

                rv = config_list_ext_poll(1, ap_path, &list_array, &nlist,
                    CFGA_FLAG_LIST_ALL);
        }

        /*
         * cfgadm_scsi will return an error for an absent target,
         * so treat an error as "absent"; otherwise, make sure
         * cfgadm_xxx has returned a list of 1 item
         */
        if (rv == CFGA_OK) {
                dm_assert(nlist == 1);
                list_valid = B_TRUE;
        } else if (disk_ap_is_scsi(ap_path[0]))
                state = HPS_ABSENT;

        if (devices_app != NULL)
                dfree(devices_app, len);

        if (list_valid) {
                /*
                 * The following truth table defines how each state is
                 * computed:
                 *
                 * +----------------------------------------------+
                 * |              | o_state | r_state | condition |
                 * |              +---------+---------+-----------|
                 * | Absent       |Don'tCare|Disc/Empt| Don'tCare |
                 * | Present      |Unconfgrd|Connected|  unknown  |
                 * | Configured   |Configred|Connected| Don'tCare |
                 * | Unconfigured |Unconfgrd|Connected|    OK     |
                 * +--------------+---------+---------+-----------+
                 */

                if (list_array[0].ap_r_state == CFGA_STAT_EMPTY ||
                    list_array[0].ap_r_state == CFGA_STAT_DISCONNECTED)
                        state = HPS_ABSENT;
                else if (list_array[0].ap_r_state == CFGA_STAT_CONNECTED &&
                    list_array[0].ap_o_state == CFGA_STAT_UNCONFIGURED &&
                    list_array[0].ap_cond == CFGA_COND_UNKNOWN)
                        state = HPS_PRESENT;
                else if (list_array[0].ap_r_state == CFGA_STAT_CONNECTED &&
                    list_array[0].ap_o_state == CFGA_STAT_UNCONFIGURED &&
                    list_array[0].ap_cond != CFGA_COND_UNKNOWN)
                        state = HPS_UNCONFIGURED;
                else if (list_array[0].ap_r_state == CFGA_STAT_CONNECTED &&
                    list_array[0].ap_o_state == CFGA_STAT_CONFIGURED)
                        state = HPS_CONFIGURED;

                free(list_array);
        }

        return (state);
}

/*
 * Examine the sysevent passed in and returns the hotplug state that
 * the sysevent states (or implies, in the case of attachment point
 * events).
 */
static hotplug_state_t
disk_sysev_to_state(diskmon_t *diskp, sysevent_t *evp)
{
        const char *class_name, *subclass;
        hotplug_state_t state = HPS_UNKNOWN;
        sysevent_value_t se_val;

        /*
         * The state mapping is as follows:
         *
         * Sysevent                             State
         * --------------------------------------------------------
         * EC_DEVFS/ESC_DEVFS_DEVI_ADD          Configured
         * EC_DEVFS/ESC_DEVFS_DEVI_REMOVE       Unconfigured
         * EC_DR/ESC_DR_AP_STATE_CHANGE         *[Absent/Present]
         *
         * (The EC_DR event requires a probe of the attachment point
         * to determine the AP's state if there is no usable HINT)
         *
         */

        class_name = sysevent_get_class_name(evp);
        subclass = sysevent_get_subclass_name(evp);

        if (strcmp(class_name, EC_DEVFS) == 0) {
                if (strcmp(subclass, ESC_DEVFS_DEVI_ADD) == 0) {

                        state = HPS_CONFIGURED;

                } else if (strcmp(subclass, ESC_DEVFS_DEVI_REMOVE) == 0) {

                        state = HPS_UNCONFIGURED;

                }

        } else if (strcmp(class_name, EC_DR) == 0 &&
            ((strcmp(subclass, ESC_DR_AP_STATE_CHANGE) == 0) ||
            (strcmp(subclass, ESC_DR_TARGET_STATE_CHANGE) == 0))) {

                if (sysevent_lookup_attr(evp, DR_HINT, SE_DATA_TYPE_STRING,
                    &se_val) == 0 && se_val.value.sv_string != NULL) {

                        if (strcmp(se_val.value.sv_string, DR_HINT_INSERT)
                            == 0) {

                                state = HPS_PRESENT;

                        } else if (strcmp(se_val.value.sv_string,
                            DR_HINT_REMOVE) == 0) {

                                state = HPS_ABSENT;
                        }

                }

                /*
                 * If the state could not be determined by the hint
                 * (or there was no hint), ask the AP directly.
                 * SCSI HBAs may send an insertion sysevent
                 * *after* configuring the target node, so double-
                 * check HPS_PRESENT
                 */
                if ((state == HPS_UNKNOWN) || (state = HPS_PRESENT))
                        state = disk_ap_state_to_hotplug_state(diskp);
        }

        return (state);
}

static void
disk_split_ap_path_sata(const char *ap_path, char *device, int *target)
{
        char *p;
        int n;

        /*
         *  /devices/rootnode/.../device:target
         */
        (void) strncpy(device, ap_path, MAXPATHLEN);
        p = strrchr(device, ':');
        dm_assert(p != NULL);
        n = sscanf(p, ":%d", target);
        dm_assert(n == 1);
        *p = '\0';
}

static void
disk_split_ap_path_scsi(const char *ap_path, char *device, int *target)
{
        char *p;
        int n;

        /*
         *  /devices/rootnode/.../device:scsi::dsk/cXtXdX
         */

        (void) strncpy(device, ap_path, MAXPATHLEN);
        p = strrchr(device, ':');
        dm_assert(p != NULL);

        n = sscanf(p, ":dsk/c%*dt%dd%*d", target);
        dm_assert(n == 1);

        *strchr(device, ':') = '\0';
}

static void
disk_split_ap_path(const char *ap_path, char *device, int *target)
{
        /*
         * The AP path comes in two forms; for SATA devices,
         * is is of the form:
         *   /devices/rootnode/.../device:portnum
         * and for SCSI devices, it is of the form:
         *  /devices/rootnode/.../device:scsi::dsk/cXtXdX
         */

        if (disk_ap_is_scsi(ap_path))
                disk_split_ap_path_scsi(ap_path, device, target);
        else
                disk_split_ap_path_sata(ap_path, device, target);
}

static void
disk_split_device_path(const char *dev_path, char *device, int *target)
{
        char *t, *p, *e;

        /*
         * The disk device path is of the form:
         * /rootnode/.../device/target@tgtid,tgtlun
         */

        (void) strncpy(device, dev_path, MAXPATHLEN);
        e = t = strrchr(device, '/');
        dm_assert(t != NULL);

        t = strchr(t, '@');
        dm_assert(t != NULL);
        t += 1;

        if ((p = strchr(t, ',')) != NULL)
                *p = '\0';

        *target = strtol(t, 0, 16);
        *e = '\0';
}

/*
 * Returns the diskmon that corresponds to the physical disk path
 * passed in.
 */
static diskmon_t *
disk_match_by_device_path(diskmon_t *disklistp, const char *dev_path)
{
        char dev_device[MAXPATHLEN];
        int dev_target;
        char ap_device[MAXPATHLEN];
        int ap_target;

        dm_assert(disklistp != NULL);
        dm_assert(dev_path != NULL);

        if (strncmp(dev_path, DEVICES_PREFIX, 8) == 0)
                dev_path += 8;

        /* pare dev_path into device and target components */
        disk_split_device_path(dev_path, (char *)&dev_device, &dev_target);

        /*
         * The AP path specified in the configuration properties is
         * the path to an attachment point minor node whose port number is
         * equal to the target number on the disk "major" node sent by the
         * sysevent.  To match them, we need to extract the target id and
         * construct an AP string to compare to the AP path in the diskmon.
         */
        while (disklistp != NULL) {
                char *app = (char *)dm_prop_lookup(disklistp->app_props,
                    DISK_AP_PROP_APID);
                dm_assert(app != NULL);

                /* Not necessary to adjust the APID here */
                if (strncmp(app, DEVICES_PREFIX, 8) == 0)
                        app += 8;

                disk_split_ap_path(app, (char *)&ap_device, &ap_target);

                if ((strcmp(dev_device, ap_device) == 0) &&
                    (dev_target == ap_target))
                        return (disklistp);

                disklistp = disklistp->next;
        }
        return (NULL);
}

static diskmon_t *
disk_match_by_ap_id(diskmon_t *disklistp, const char *ap_id)
{
        const char *disk_ap_id;
        dm_assert(disklistp != NULL);
        dm_assert(ap_id != NULL);

        /* Match only the device-tree portion of the name */
        if (strncmp(ap_id, DEVICES_PREFIX, 8 /* strlen("/devices") */) == 0)
                ap_id += 8;

        while (disklistp != NULL) {
                disk_ap_id = dm_prop_lookup(disklistp->app_props,
                    DISK_AP_PROP_APID);

                dm_assert(disk_ap_id != NULL);

                if (strcmp(disk_ap_id, ap_id) == 0)
                        return (disklistp);

                disklistp = disklistp->next;
        }
        return (NULL);
}

static diskmon_t *
disk_match_by_target_id(diskmon_t *disklistp, const char *target_path)
{
        const char *disk_ap_id;

        char match_device[MAXPATHLEN];
        int match_target;

        char ap_device[MAXPATHLEN];
        int ap_target;


        /* Match only the device-tree portion of the name */
        if (strncmp(target_path, DEVICES_PREFIX, 8) == 0)
                target_path += 8;
        disk_split_ap_path(target_path, (char *)&match_device, &match_target);

        while (disklistp != NULL) {

                disk_ap_id = dm_prop_lookup(disklistp->app_props,
                    DISK_AP_PROP_APID);
                dm_assert(disk_ap_id != NULL);

                disk_split_ap_path(disk_ap_id, (char *)&ap_device, &ap_target);
                if ((match_target == ap_target) &&
                    (strcmp(match_device, ap_device) == 0))
                        return (disklistp);

                disklistp = disklistp->next;
        }
        return (NULL);
}

static diskmon_t *
match_sysevent_to_disk(diskmon_t *disklistp, sysevent_t *evp)
{
        diskmon_t *dmp = NULL;
        sysevent_value_t se_val;
        char *class_name = sysevent_get_class_name(evp);
        char *subclass = sysevent_get_subclass_name(evp);

        se_val.value.sv_string = NULL;

        if (strcmp(class_name, EC_DEVFS) == 0) {
                /* EC_DEVFS-class events have a `DEVFS_PATHNAME' property */
                if (sysevent_lookup_attr(evp, DEVFS_PATHNAME,
                    SE_DATA_TYPE_STRING, &se_val) == 0 &&
                    se_val.value.sv_string != NULL) {

                        dmp = disk_match_by_device_path(disklistp,
                            se_val.value.sv_string);

                }

        } else if (strcmp(class_name, EC_DR) == 0 &&
            strcmp(subclass, ESC_DR_AP_STATE_CHANGE) == 0) {

                /* EC_DR-class events have a `DR_AP_ID' property */
                if (sysevent_lookup_attr(evp, DR_AP_ID, SE_DATA_TYPE_STRING,
                    &se_val) == 0 && se_val.value.sv_string != NULL) {

                        dmp = disk_match_by_ap_id(disklistp,
                            se_val.value.sv_string);
                }
        } else if (strcmp(class_name, EC_DR) == 0 &&
            strcmp(subclass, ESC_DR_TARGET_STATE_CHANGE) == 0) {
                /* get DR_TARGET_ID */
                if (sysevent_lookup_attr(evp, DR_TARGET_ID,
                    SE_DATA_TYPE_STRING, &se_val) == 0 &&
                    se_val.value.sv_string != NULL) {
                        dmp = disk_match_by_target_id(disklistp,
                            se_val.value.sv_string);
                }
        }

        if (se_val.value.sv_string)
                log_msg(MM_HPMGR, "match_sysevent_to_disk: device/ap: %s\n",
                    se_val.value.sv_string);

        return (dmp);
}


/*
 * The disk hotplug monitor (DHPM) listens for disk hotplug events and calls the
 * state-change functionality when a disk's state changes.  The DHPM listens for
 * hotplug events via sysevent subscriptions to the following sysevent
 * classes/subclasses: { EC_DEVFS/ESC_DEVFS_BRANCH_ADD,
 * EC_DEVFS/ESC_DEVFS_BRANCH_REMOVE, EC_DEVFS/ESC_DEVFS_DEVI_ADD,
 * EC_DEVFS/ESC_DEVFS_DEVI_REMOVE, EC_DR/ESC_DR_AP_STATE_CHANGE }.  Once the
 * event is received, the device path sent as part of the event is matched
 * to one of the disks described by the configuration data structures.
 */
static void
dm_process_sysevent(sysevent_t *dupev)
{
        char            *class_name;
        char            *pub;
        char            *subclass = sysevent_get_subclass_name(dupev);
        diskmon_t       *diskp;

        class_name = sysevent_get_class_name(dupev);
        log_msg(MM_HPMGR, "****EVENT: %s %s (by %s)\n", class_name,
            subclass,
            ((pub = sysevent_get_pub_name(dupev)) != NULL) ? pub : "UNKNOWN");

        if (pub)
                free(pub);

        if (strcmp(class_name, EC_PLATFORM) == 0 &&
            strcmp(subclass, ESC_PLATFORM_SP_RESET) == 0) {
                if (dm_platform_resync() != 0)
                        log_warn("failed to resync SP platform\n");
                sysevent_free(dupev);
                return;
        }

        /*
         * We will handle this event if the event's target matches one of the
         * disks we're monitoring
         */
        if ((diskp = match_sysevent_to_disk(config_data->disk_list, dupev))
            != NULL) {

                dm_state_change(diskp, disk_sysev_to_state(diskp, dupev));
        }

        sysevent_free(dupev);
}

static void
dm_fmd_sysevent_thread(void *queuep)
{
        qu_t                    *qp = (qu_t *)queuep;
        sysevent_event_t        *sevevp;

        /* Signal the thread spawner that we're running */
        dm_assert(pthread_mutex_lock(&g_event_handler_lock) == 0);
        if (g_sysev_thread_state != TS_EXIT_REQUESTED)
                g_sysev_thread_state = TS_RUNNING;
        (void) pthread_cond_broadcast(&g_event_handler_cond);
        dm_assert(pthread_mutex_unlock(&g_event_handler_lock) == 0);

        while (g_sysev_thread_state != TS_EXIT_REQUESTED) {
                if ((sevevp = (sysevent_event_t *)queue_remove(qp)) == NULL)
                        continue;

                dm_process_sysevent(sevevp->evp);

                free_sysevent_event(sevevp);
        }

        /* Signal the thread spawner that we've exited */
        dm_assert(pthread_mutex_lock(&g_event_handler_lock) == 0);
        g_sysev_thread_state = TS_EXITED;
        (void) pthread_cond_broadcast(&g_event_handler_cond);
        dm_assert(pthread_mutex_unlock(&g_event_handler_lock) == 0);

        log_msg(MM_HPMGR, "FMD sysevent handler thread exiting...");
}

static sysevent_event_t *
new_sysevent_event(sysevent_t *ev)
{
        /*
         * Cannot use dmalloc for this because the thread isn't a FMD-created
         * thread!
         */
        sysevent_event_t *sevevp = malloc(sizeof (sysevent_event_t));
        sevevp->evp = ev;
        return (sevevp);
}

static void
free_sysevent_event(void *p)
{
        /* the sysevent_event was allocated with malloc(): */
        free(p);
}

static void
event_handler(sysevent_t *ev)
{
        /* The duplicated sysevent will be freed in the child thread */
        sysevent_t      *dupev = sysevent_dup(ev);

        /*
         * Add this sysevent to the work queue of our FMA thread so we can
         * handle the sysevent and use the FMA API (e.g. for memory
         * allocation, etc.) in the sysevent handler.
         */
        queue_add(g_sysev_queue, new_sysevent_event(dupev));
}

static void
fini_sysevents(void)
{
        sysevent_unsubscribe_event(sysevent_handle, EC_ALL);
}

static int
init_sysevents(void)
{
        int rv = 0;
        const char *devfs_subclasses[] = {
                ESC_DEVFS_DEVI_ADD,
                ESC_DEVFS_DEVI_REMOVE
        };
        const char *dr_subclasses[] = {
                ESC_DR_AP_STATE_CHANGE,
                ESC_DR_TARGET_STATE_CHANGE
        };
        const char *platform_subclasses[] = {
                ESC_PLATFORM_SP_RESET
        };

        if ((sysevent_handle = sysevent_bind_handle(event_handler)) == NULL) {
                rv = errno;
                log_err("Could not initialize the hotplug manager ("
                    "sysevent_bind_handle failure");
        }

        if (sysevent_subscribe_event(sysevent_handle, EC_DEVFS,
            devfs_subclasses,
            sizeof (devfs_subclasses)/sizeof (devfs_subclasses[0])) != 0) {

                log_err("Could not initialize the hotplug manager "
                    "sysevent_subscribe_event(event class = EC_DEVFS) "
                    "failure");

                rv = -1;

        } else if (sysevent_subscribe_event(sysevent_handle, EC_DR,
            dr_subclasses,
            sizeof (dr_subclasses)/sizeof (dr_subclasses[0])) != 0) {

                log_err("Could not initialize the hotplug manager "
                    "sysevent_subscribe_event(event class = EC_DR) "
                    "failure");

                /* Unsubscribe from all sysevents in the event of a failure */
                fini_sysevents();

                rv = -1;
        } else if (sysevent_subscribe_event(sysevent_handle, EC_PLATFORM,
            platform_subclasses,
            sizeof (platform_subclasses)/sizeof (platform_subclasses[0]))
            != 0) {

                log_err("Could not initialize the hotplug manager "
                    "sysevent_subscribe_event(event class = EC_PLATFORM) "
                    "failure");

                /* Unsubscribe from all sysevents in the event of a failure */
                fini_sysevents();

                rv = -1;
        }


        return (rv);
}

/*ARGSUSED*/
static void
stdfree(void *p, size_t sz)
{
        free(p);
}

/*
 * Assumptions: Each disk's current state was determined and stored in
 * its diskmon_t.
 */
hotplug_mgr_init_err_t
init_hotplug_manager()
{
        /* Create the queue to which we'll add sysevents */
        g_sysev_queue = new_queue(B_TRUE, malloc, stdfree, free_sysevent_event);

        /*
         * Grab the event handler lock before spawning the thread so we can
         * wait for the thread to transition to the running state.
         */
        dm_assert(pthread_mutex_lock(&g_event_handler_lock) == 0);

        /* Create the sysevent handling thread */
        g_sysev_tid = fmd_thr_create(g_fm_hdl, dm_fmd_sysevent_thread,
            g_sysev_queue);

        /* Wait for the thread's acknowledgement */
        while (g_sysev_thread_state != TS_RUNNING)
                (void) pthread_cond_wait(&g_event_handler_cond,
                    &g_event_handler_lock);
        dm_assert(pthread_mutex_unlock(&g_event_handler_lock) == 0);

        if (init_sysevents() != 0) {
                log_warn_e("Error initializing sysevents");
                return (HPM_ERR_SYSEVENT_INIT);
        }

        return (0);
}

void
cleanup_hotplug_manager()
{
        /* Unsubscribe from the sysevents */
        fini_sysevents();

        /*
         * Wait for the thread to exit before we can destroy
         * the event queue.
         */
        dm_assert(pthread_mutex_lock(&g_event_handler_lock) == 0);
        g_sysev_thread_state = TS_EXIT_REQUESTED;
        queue_add(g_sysev_queue, NULL);
        while (g_sysev_thread_state != TS_EXITED)
                (void) pthread_cond_wait(&g_event_handler_cond,
                    &g_event_handler_lock);
        dm_assert(pthread_mutex_unlock(&g_event_handler_lock) == 0);
        (void) pthread_join(g_sysev_tid, NULL);
        fmd_thr_destroy(g_fm_hdl, g_sysev_tid);

        /* Finally, destroy the event queue and reset the thread state */
        queue_free(&g_sysev_queue);
        g_sysev_thread_state = TS_NOT_RUNNING;
}