/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
/*
 * Copyright 2019 Joyent, Inc.
 */

#include <stdio.h>
#include <stdlib.h>
#include <stropts.h>
#include <synch.h>
#include <thread.h>
#include <libsysevent.h>
#include <sys/sysevent/eventdefs.h>
#include <sys/sysevent/dev.h>
#include <errno.h>
#include <libgen.h>
#include <unistd.h>

#include "libdiskmgt.h"
#include "disks_private.h"

#pragma fini(libdiskmgt_fini)

struct event_list {
        struct event_list       *next;
        nvlist_t                *event;
};

static mutex_t                  shp_lock = ERRORCHECKMUTEX;
static sysevent_handle_t        *shp = NULL;

static struct event_list        *events = NULL;
static int                      event_error = 0;
static int                      event_break = 0;
static mutex_t                  queue_lock;
static sema_t                   semaphore;

/*
 * When we add a controller we get an add event for each drive on the
 * controller.  We don't want to walk the devtree for each drive since
 * we will get the same information each time.  So, the solution is to
 * wait for a few seconds for all of the add events to come in and then
 * do a single walk.  If an add event comes in after we start the walk, we
 * need to do another walk since we might have missed that drive.
 *
 * State: 0 - no walker; 1 - walker waiting; 2 - walker running
 *      0 -> 1; wait a few seconds
 *      1 -> 2; walking the devtree
 *      2 -> either 0 or 1 (see below)
 * While running (state 2), if event comes in, go back to waiting (state 1)
 * after the walk otherwise go back to none (state 0).
 *
 * walker_lock protects walker_state & events_pending
 */
#define WALK_NONE               0
#define WALK_WAITING            1
#define WALK_RUNNING            2
#define WALK_WAIT_TIME          60      /* wait 60 seconds */

static mutex_t                  walker_lock = ERRORCHECKMUTEX;
static cond_t                   walker_cv = DEFAULTCV;
static int                      walker_state = WALK_NONE;

static int                      events_pending = 0;

static int                      sendevents = 0;

static void             add_event_to_queue(nvlist_t *event);
static void             *cb_watch_events(void *);
static void             event_handler(sysevent_t *ev);
static void             print_nvlist(char *prefix, nvlist_t *list);
static void             walk_devtree(void);
static void             *walker(void *arg);

static void(*callback)(nvlist_t *, int) = NULL;

static boolean_t                shutting_down = B_FALSE;

static void
libdiskmgt_fini(void)
{
        mutex_enter(&shp_lock);
        if (shp != NULL) {
                sysevent_unsubscribe_event(shp, EC_ALL);
                sysevent_unbind_handle(shp);
                shp = NULL;
        }
        /*
         * At this point a new invocation of walker() can't occur.  However,
         * if one was already running then we need to wait for it to finish
         * because if we allow ourselves to be unloaded out from underneath
         * it, then bad things will happen.
         */
        mutex_enter(&walker_lock);
        shutting_down = B_TRUE;
        while (walker_state != WALK_NONE)
                (void) cond_wait(&walker_cv, &walker_lock);

        mutex_exit(&walker_lock);
}

nvlist_t *
dm_get_event(int *errp)
{
        nvlist_t *event = NULL;

        *errp = 0;

        /* wait until there is an event in the queue */
        /*CONSTCOND*/
        while (1) {
            (void) sema_wait(&semaphore);

            if (event_break) {
                event_break = 0;
                *errp = EINTR;
                break;
            }

            (void) mutex_lock(&queue_lock);

            /* first see if we ran out of memory since the last call */
            if (event_error != 0) {
                *errp = event_error;
                event_error = 0;

            } else if (events != NULL) {
                struct event_list *tmpp;

                event = events->event;
                tmpp = events->next;
                free(events);
                events = tmpp;
            }

            (void) mutex_unlock(&queue_lock);

            if (*errp != 0 || event != NULL) {
                break;
            }
        }

        return (event);
}

void
dm_init_event_queue(void (*cb)(nvlist_t *, int), int *errp)
{
        if (sendevents == 1) {
            /* we were already initialized, see what changes to make */
            *errp = 0;
            if (cb != callback) {

                callback = cb;
                if (cb == NULL) {
                    /* clearing the cb so shutdown the internal cb thread */
                    event_break = 1;
                    (void) sema_post(&semaphore);

                } else {
                    /* installing a cb; we didn't have one before */
                    thread_t watch_thread;

                    *errp = thr_create(NULL, 0, cb_watch_events, NULL,
                        THR_DAEMON, &watch_thread);
                }
            }

        } else {
            /* first time to initialize */
            sendevents = 1;

            *errp = sema_init(&semaphore, 0, USYNC_THREAD, NULL);
            if (*errp != 0) {
                return;
            }

            if (cb != NULL) {
                thread_t watch_thread;

                callback = cb;

                *errp = thr_create(NULL, 0, cb_watch_events, NULL, THR_DAEMON,
                    &watch_thread);
            }
        }
}

void
events_new_event(char *name, int dtype, char *etype)
{
        nvlist_t        *event = NULL;

        if (!sendevents) {
            return;
        }

        if (nvlist_alloc(&event, NVATTRS, 0) != 0) {
            event = NULL;

        } else {
            int error = 0;

            if (name != NULL &&
                nvlist_add_string(event, DM_EV_NAME, name) != 0) {
                error = ENOMEM;
            }

            if (dtype != -1 &&
                nvlist_add_uint32(event, DM_EV_DTYPE, dtype) != 0) {
                error = ENOMEM;
            }

            if (nvlist_add_string(event, DM_EV_TYPE, etype) != 0) {
                error = ENOMEM;
            }

            if (error != 0) {
                nvlist_free(event);
                event = NULL;
            }
        }

        add_event_to_queue(event);
}

void
events_new_slice_event(char *dev, char *type)
{
        events_new_event(basename(dev), DM_SLICE, type);
}

int
events_start_event_watcher()
{
        const char *subclass_list[1];
        int ret = -1;

        mutex_enter(&shp_lock);
        if (shp != NULL) {
                ret = 0;
                goto out;
        }

        /* Bind event handler and create subscriber handle */
        shp = sysevent_bind_handle(event_handler);
        if (shp == NULL) {
                if (dm_debug) {
                        (void) fprintf(stderr, "ERROR: sysevent bind failed: "
                            "%d\n", errno);
                }
                goto out;
        }

        subclass_list[0] = ESC_DISK;
        if (sysevent_subscribe_event(shp, EC_DEV_ADD, subclass_list, 1) != 0 ||
            sysevent_subscribe_event(shp, EC_DEV_REMOVE, subclass_list, 1) !=
            0) {

                sysevent_unsubscribe_event(shp, EC_ALL);
                sysevent_unbind_handle(shp);
                shp = NULL;

                if (dm_debug) {
                        (void) fprintf(stderr, "ERROR: sysevent subscribe "
                            "failed: %d\n", errno);
                }
                goto out;
        }
        ret = 0;
out:
        mutex_exit(&shp_lock);
        return (ret);
}

static void
add_event_to_queue(nvlist_t *event)
{
        (void) mutex_lock(&queue_lock);

        if (event == NULL) {
            event_error = ENOMEM;
            (void) mutex_unlock(&queue_lock);
            return;
        }

        if (events == NULL) {

            events = (struct event_list *)malloc(sizeof (struct event_list));
            if (events == NULL) {
                event_error = ENOMEM;
                nvlist_free(event);
            } else {
                events->next = NULL;
                events->event = event;
            }

        } else {
            /* already have events in the queue */
            struct event_list *ep;
            struct event_list *new_event;

            /* find the last element in the list */
            for (ep = events; ep->next != NULL; ep = ep->next);

            new_event = (struct event_list *)malloc(sizeof (struct event_list));
            if (new_event == NULL) {
                event_error = ENOMEM;
                nvlist_free(event);
            } else {
                new_event->next = NULL;
                new_event->event = event;
                ep->next = new_event;
            }
        }

        (void) mutex_unlock(&queue_lock);

        (void) sema_post(&semaphore);
}

static void *
cb_watch_events(void *arg __unused)
{
        nvlist_t        *event;
        int             error;

        /*CONSTCOND*/
        while (1) {
            event = dm_get_event(&error);
            if (callback == NULL) {
                /* end the thread */
                return (NULL);
            }
            callback(event, error);
        }
}

static void
event_handler(sysevent_t *ev)
{
        char            *class_name;
        char            *pub;

        class_name = sysevent_get_class_name(ev);
        if (dm_debug) {
            (void) fprintf(stderr, "****EVENT: %s %s ", class_name,
                sysevent_get_subclass_name(ev));
            if ((pub = sysevent_get_pub_name(ev)) != NULL) {
                (void) fprintf(stderr, "%s\n", pub);
                free(pub);
            } else {
                (void) fprintf(stderr, "\n");
            }
        }

        if (libdiskmgt_str_eq(class_name, EC_DEV_ADD)) {
            /* batch up the adds into a single devtree walk */
            walk_devtree();

        } else if (libdiskmgt_str_eq(class_name, EC_DEV_REMOVE)) {
            nvlist_t    *nvlist = NULL;
            char        *dev_name = NULL;

            (void) sysevent_get_attr_list(ev, &nvlist);
            if (nvlist != NULL) {
                (void) nvlist_lookup_string(nvlist, DEV_NAME, &dev_name);

                if (dm_debug) {
                    print_nvlist("**** ", nvlist);
                }
            }

            if (dev_name != NULL) {
                cache_update(DM_EV_DISK_DELETE, dev_name);
            }

            if (nvlist != NULL) {
                nvlist_free(nvlist);
            }
        }
}

/*
 * This is a debugging function only.
 */
static void
print_nvlist(char *prefix, nvlist_t *list)
{
        nvpair_t        *nvp;

        nvp = nvlist_next_nvpair(list, NULL);
        while (nvp != NULL) {
            char        *attrname;
            char        *str;
            uint32_t    ui32;
            uint64_t    ui64;
            char        **str_array;
            uint_t      cnt;
            int         i;

            attrname = nvpair_name(nvp);
            switch (nvpair_type(nvp)) {
            case DATA_TYPE_STRING:
                (void) nvpair_value_string(nvp, &str);
                (void) fprintf(stderr, "%s%s: %s\n", prefix, attrname, str);
                break;

            case DATA_TYPE_STRING_ARRAY:
                (void) nvpair_value_string_array(nvp, &str_array, &cnt);
                (void) fprintf(stderr, "%s%s:\n", prefix, attrname);
                for (i = 0; i < cnt; i++) {
                    (void) fprintf(stderr, "%s    %s\n", prefix, str_array[i]);
                }
                break;

            case DATA_TYPE_UINT32:
                (void) nvpair_value_uint32(nvp, &ui32);
                (void) fprintf(stderr, "%s%s: %u\n", prefix, attrname, ui32);
                break;

            case DATA_TYPE_UINT64:
                (void) nvpair_value_uint64(nvp, &ui64);
#ifdef _LP64
                (void) fprintf(stderr, "%s%s: %lu\n", prefix, attrname, ui64);
#else
                (void) fprintf(stderr, "%s%s: %llu\n", prefix, attrname, ui64);
#endif
                break;


            case DATA_TYPE_BOOLEAN:
                (void) fprintf(stderr, "%s%s: true\n", prefix, attrname);
                break;

            default:
                (void) fprintf(stderr, "%s%s: UNSUPPORTED TYPE\n", prefix,
                    attrname);
                break;
            }

            nvp = nvlist_next_nvpair(list, nvp);
        }
}

/*
 * Batch up the adds into a single devtree walk.  We can get a bunch of
 * adds when we add a controller since we will get an add event for each
 * drive.
 */
static void
walk_devtree(void)
{
        thread_t        walk_thread;

        mutex_enter(&walker_lock);

        switch (walker_state) {
        case WALK_NONE:
            if (thr_create(NULL, 0, walker, NULL,
                THR_DAEMON, &walk_thread) == 0) {
                walker_state = WALK_WAITING;
            }
            break;

        case WALK_WAITING:
            /* absorb the event and do nothing */
            break;

        case WALK_RUNNING:
            events_pending = 1;
            break;
        }

        mutex_exit(&walker_lock);
}

static void *
walker(void *arg __unused)
{
        int     walk_again = 0;

        do {
            /* start by waiting for a few seconds to absorb extra events */
            (void) sleep(WALK_WAIT_TIME);

            mutex_enter(&walker_lock);
            if (shutting_down) {
                walker_state = WALK_NONE;
                (void) cond_broadcast(&walker_cv);
                mutex_exit(&walker_lock);
                return (NULL);
            }
            walker_state = WALK_RUNNING;
            mutex_exit(&walker_lock);

            cache_update(DM_EV_DISK_ADD, NULL);

            mutex_enter(&walker_lock);
            if (shutting_down) {
                walker_state = WALK_NONE;
                (void) cond_broadcast(&walker_cv);
                mutex_exit(&walker_lock);
                return (NULL);
            }

            if (events_pending) {
                events_pending = 0;
                walker_state = WALK_WAITING;
                walk_again = 1;
            } else {
                walker_state = WALK_NONE;
                walk_again = 0;
            }

            mutex_exit(&walker_lock);

        } while (walk_again);
        return (NULL);
}