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


/*
 * Sysevent Driver for GPEC
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/cred.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/open.h>           /* OTYP_CHR definition */
#include <sys/sysmacros.h>      /* L_BITSMINOR definition */
#include <sys/bitmap.h>
#include <sys/sysevent.h>
#include <sys/sysevent_impl.h>

static dev_info_t *sysevent_devi;

/* Definitions for binding handle array */
static ulong_t sysevent_bitmap_initial = 1;     /* index 0 indicates error */
static ulong_t *sysevent_minor_bitmap = &sysevent_bitmap_initial;
static size_t sysevent_minor_bits = BT_NBIPUL;
static kmutex_t sysevent_minor_mutex;

/*
 * evchan_ctl acts as a container for the binding handle
 */
typedef struct evchan_ctl {
        evchan_t *chp;
} evchan_ctl_t;

static void *evchan_ctlp;

/*
 * Check if it's a null terminated array - to avoid DoS attack
 * It is supposed that string points to an array with
 * a minimum length of len. len must be strlen + 1.
 * Checks for printable characters are already done in library.
 */
static int
sysevent_isstrend(char *string, size_t len)
{
        /* Return 0 if string has length of zero */
        if (len > 0) {
                return (string[len - 1] == '\0' ? 1 : 0);
        } else {
                return (0);
        }
}

/*
 * Following sysevent_minor_* routines map
 * a binding handle (evchan_t *) to a minor number
 * Has to be called w/ locks held.
 */
static ulong_t *
sysevent_minor_alloc(void)
{
        ulong_t *bhst = sysevent_minor_bitmap;

        /* Increase bitmap by one BT_NBIPUL */
        if (sysevent_minor_bits + BT_NBIPUL > SYSEVENT_MINOR_MAX) {
                return ((ulong_t *)NULL);
        }
        sysevent_minor_bitmap = kmem_zalloc(
            BT_SIZEOFMAP(sysevent_minor_bits + BT_NBIPUL), KM_SLEEP);
        bcopy(bhst, sysevent_minor_bitmap, BT_SIZEOFMAP(sysevent_minor_bits));
        if (bhst != &sysevent_bitmap_initial)
                kmem_free(bhst, BT_SIZEOFMAP(sysevent_minor_bits));
        sysevent_minor_bits += BT_NBIPUL;

        return (sysevent_minor_bitmap);
}

static void
sysevent_minor_free(ulong_t *bitmap)
{
        if (bitmap != &sysevent_bitmap_initial)
                kmem_free(bitmap, BT_SIZEOFMAP(sysevent_minor_bits));
}

static index_t
sysevent_minor_get(void)
{
        index_t idx;
        ulong_t *bhst;

        /* Search for an available index */
        mutex_enter(&sysevent_minor_mutex);
        if ((idx = bt_availbit(sysevent_minor_bitmap,
            sysevent_minor_bits)) == -1) {
                /* All busy - allocate additional binding handle bitmap space */
                if ((bhst = sysevent_minor_alloc()) == NULL) {
                        /* Reached our maximum of id's == SHRT_MAX */
                        mutex_exit(&sysevent_minor_mutex);
                        return (0);
                } else {
                        sysevent_minor_bitmap = bhst;
                }
                idx = bt_availbit(sysevent_minor_bitmap, sysevent_minor_bits);
        }
        BT_SET(sysevent_minor_bitmap, idx);
        mutex_exit(&sysevent_minor_mutex);
        return (idx);
}

static void
sysevent_minor_rele(index_t idx)
{
        mutex_enter(&sysevent_minor_mutex);
        ASSERT(BT_TEST(sysevent_minor_bitmap, idx) == 1);
        BT_CLEAR(sysevent_minor_bitmap, idx);
        mutex_exit(&sysevent_minor_mutex);
}

static void
sysevent_minor_init(void)
{
        mutex_init(&sysevent_minor_mutex, NULL, MUTEX_DEFAULT, NULL);
}

/* ARGSUSED */
static int
sysevent_publish(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
{
        int km_flags;
        sev_publish_args_t uargs;
        sysevent_impl_t *ev;
        evchan_ctl_t *ctl;

        ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
        if (ctl == NULL || ctl->chp == NULL)
                return (ENXIO);

        if (copyin(arg, &uargs, sizeof (sev_publish_args_t)) != 0)
                return (EFAULT);

        /*
         * This limits the size of an event
         */
        if (uargs.ev.len > MAX_EV_SIZE_LEN)
                return (EOVERFLOW);

        /*
         * Check for valid uargs.flags
         */
        if (uargs.flags & ~(EVCH_NOSLEEP | EVCH_SLEEP | EVCH_QWAIT))
                return (EINVAL);

        /*
         * Check that at least one of EVCH_NOSLEEP or EVCH_SLEEP is
         * specified
         */
        km_flags = uargs.flags & (EVCH_NOSLEEP | EVCH_SLEEP);
        if (km_flags != EVCH_NOSLEEP && km_flags != EVCH_SLEEP)
                return (EINVAL);

        ev = evch_usrallocev(uargs.ev.len, uargs.flags);

        if (copyin((void *)(uintptr_t)uargs.ev.name, ev, uargs.ev.len) != 0) {
                evch_usrfreeev(ev);
                return (EFAULT);
        }

        return (evch_usrpostevent(ctl->chp, ev, uargs.flags));

        /* Event will be freed internally */
}

/*
 * sysevent_chan_open - used to open a channel in the GPEC channel layer
 */

/* ARGSUSED */
static int
sysevent_chan_open(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
{
        sev_bind_args_t uargs;
        evchan_ctl_t *ctl;
        char *chan_name;
        int ec;

        ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
        if (ctl == NULL) {
                return (ENXIO);
        }

        if (copyin(arg, &uargs, sizeof (sev_bind_args_t)) != 0)
                return (EFAULT);

        if (uargs.chan_name.len > MAX_CHNAME_LEN)
                return (EINVAL);

        chan_name = kmem_alloc(uargs.chan_name.len, KM_SLEEP);

        if (copyin((void *)(uintptr_t)uargs.chan_name.name, chan_name,
            uargs.chan_name.len) != 0) {
                kmem_free(chan_name, uargs.chan_name.len);
                return (EFAULT);
        }

        if (!sysevent_isstrend(chan_name, uargs.chan_name.len)) {
                kmem_free(chan_name, uargs.chan_name.len);
                return (EINVAL);
        }

        /*
         * Check of uargs.flags and uargs.perms just to avoid DoS attacks.
         * libsysevent does this carefully
         */
        ctl->chp = evch_usrchanopen((const char *)chan_name,
            uargs.flags & EVCH_B_FLAGS, &ec);

        kmem_free(chan_name, uargs.chan_name.len);

        if (ec != 0) {
                return (ec);
        }

        return (0);
}

/* ARGSUSED */
static int
sysevent_chan_control(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
{
        sev_control_args_t uargs;
        evchan_ctl_t *ctl;
        int rc;

        ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
        if (ctl == NULL || ctl->chp == NULL)
                return (ENXIO);

        if (copyin(arg, &uargs, sizeof (sev_control_args_t)) != 0)
                return (EFAULT);

        switch (uargs.cmd) {
        case EVCH_GET_CHAN_LEN:
        case EVCH_GET_CHAN_LEN_MAX:
                rc = evch_usrcontrol_get(ctl->chp, uargs.cmd, &uargs.value);
                if (rc == 0) {
                        if (copyout((void *)&uargs, arg,
                            sizeof (sev_control_args_t)) != 0) {
                                rc = EFAULT;
                        }
                }
                break;
        case EVCH_SET_CHAN_LEN:
                rc = evch_usrcontrol_set(ctl->chp, uargs.cmd, uargs.value);
                break;
        default:
                rc = EINVAL;
        }
        return (rc);
}

/* ARGSUSED */
static int
sysevent_subscribe(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
{
        sev_subscribe_args_t uargs;
        char *sid;
        char *class_info = NULL;
        evchan_ctl_t *ctl;
        int rc;

        ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
        if (ctl == NULL || ctl->chp == NULL)
                return (ENXIO);

        if (copyin(arg, &uargs, sizeof (sev_subscribe_args_t)) != 0)
                return (EFAULT);

        if (uargs.sid.len > MAX_SUBID_LEN ||
            uargs.class_info.len > MAX_CLASS_LEN)
                return (EINVAL);

        sid = kmem_alloc(uargs.sid.len, KM_SLEEP);
        if (copyin((void *)(uintptr_t)uargs.sid.name,
            sid, uargs.sid.len) != 0) {
                kmem_free(sid, uargs.sid.len);
                return (EFAULT);
        }
        if (!sysevent_isstrend(sid, uargs.sid.len)) {
                kmem_free(sid, uargs.sid.len);
                return (EINVAL);
        }

        /* If class string empty then class EC_ALL is assumed */
        if (uargs.class_info.len != 0) {
                class_info = kmem_alloc(uargs.class_info.len, KM_SLEEP);
                if (copyin((void *)(uintptr_t)uargs.class_info.name, class_info,
                    uargs.class_info.len) != 0) {
                        kmem_free(class_info, uargs.class_info.len);
                        kmem_free(sid, uargs.sid.len);
                        return (EFAULT);
                }
                if (!sysevent_isstrend(class_info, uargs.class_info.len)) {
                        kmem_free(class_info, uargs.class_info.len);
                        kmem_free(sid, uargs.sid.len);
                        return (EINVAL);
                }
        }

        /*
         * Check of uargs.flags just to avoid DoS attacks
         * libsysevent does this carefully.
         */
        rc = evch_usrsubscribe(ctl->chp, sid, class_info,
            (int)uargs.door_desc, uargs.flags);

        kmem_free(class_info, uargs.class_info.len);
        kmem_free(sid, uargs.sid.len);

        return (rc);
}

/* ARGSUSED */
static int
sysevent_unsubscribe(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
{
        sev_unsubscribe_args_t uargs;
        char *sid;
        evchan_ctl_t *ctl;

        if (copyin(arg, &uargs, sizeof (sev_unsubscribe_args_t)) != 0)
                return (EFAULT);

        ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
        if (ctl == NULL || ctl->chp == NULL)
                return (ENXIO);

        if (uargs.sid.len > MAX_SUBID_LEN)
                return (EINVAL);

        /* Unsubscribe for all */
        if (uargs.sid.len == 0) {
                evch_usrunsubscribe(ctl->chp, NULL, 0);
                return (0);
        }

        sid = kmem_alloc(uargs.sid.len, KM_SLEEP);

        if (copyin((void *)(uintptr_t)uargs.sid.name,
            sid, uargs.sid.len) != 0) {
                kmem_free(sid, uargs.sid.len);
                return (EFAULT);
        }

        evch_usrunsubscribe(ctl->chp, sid, 0);

        kmem_free(sid, uargs.sid.len);

        return (0);
}

/* ARGSUSED */
static int
sysevent_channames(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
{
        sev_chandata_args_t uargs;
        char *buf;
        int len;
        int rc = 0;

        if (copyin(arg, &uargs, sizeof (sev_chandata_args_t)) != 0)
                return (EFAULT);

        if (uargs.out_data.len == 0 || uargs.out_data.len > EVCH_MAX_DATA_SIZE)
                return (EINVAL);

        buf = kmem_alloc(uargs.out_data.len, KM_SLEEP);

        if ((len = evch_usrgetchnames(buf, uargs.out_data.len)) == -1) {
                rc = EOVERFLOW;
        }

        if (rc == 0) {
                ASSERT(len <= uargs.out_data.len);
                if (copyout(buf,
                    (void *)(uintptr_t)uargs.out_data.name, len) != 0) {
                        rc = EFAULT;
                }
        }

        kmem_free(buf, uargs.out_data.len);

        return (rc);
}

/* ARGSUSED */
static int
sysevent_chandata(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
{
        sev_chandata_args_t uargs;
        char *channel;
        char *buf;
        int len;
        int rc = 0;

        if (copyin(arg, &uargs, sizeof (sev_chandata_args_t)) != 0)
                return (EFAULT);

        if (uargs.in_data.len > MAX_CHNAME_LEN ||
            uargs.out_data.len > EVCH_MAX_DATA_SIZE)
                return (EINVAL);

        channel = kmem_alloc(uargs.in_data.len, KM_SLEEP);

        if (copyin((void *)(uintptr_t)uargs.in_data.name, channel,
            uargs.in_data.len) != 0) {
                kmem_free(channel, uargs.in_data.len);
                return (EFAULT);
        }

        if (!sysevent_isstrend(channel, uargs.in_data.len)) {
                kmem_free(channel, uargs.in_data.len);
                return (EINVAL);
        }

        buf = kmem_alloc(uargs.out_data.len, KM_SLEEP);

        len = evch_usrgetchdata(channel, buf, uargs.out_data.len);
        if (len == 0) {
                rc = EOVERFLOW;
        } else if (len == -1) {
                rc = ENOENT;
        }

        if (rc == 0) {
                ASSERT(len <= uargs.out_data.len);
                if (copyout(buf,
                    (void *)(uintptr_t)uargs.out_data.name, len) != 0) {
                        rc = EFAULT;
                }
        }

        kmem_free(buf, uargs.out_data.len);
        kmem_free(channel, uargs.in_data.len);

        return (rc);
}

/* ARGSUSED */
static int
sysevent_setpropnvl(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
{
        sev_propnvl_args_t uargs;
        nvlist_t *nvl = NULL;
        evchan_ctl_t *ctl;
        size_t bufsz;
        char *buf;

        ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
        if (ctl == NULL || ctl->chp == NULL)
                return (ENXIO);

        if (copyin(arg, &uargs, sizeof (uargs)) != 0)
                return (EFAULT);

        if (uargs.packednvl.name != 0) {
                bufsz = uargs.packednvl.len;

                if (bufsz == 0)
                        return (EINVAL);

                if (bufsz > EVCH_MAX_DATA_SIZE)
                        return (EOVERFLOW);

                buf = kmem_alloc(bufsz, KM_SLEEP);

                if (copyin((void *)(uintptr_t)uargs.packednvl.name, buf,
                    bufsz) != 0 ||
                    nvlist_unpack(buf, bufsz, &nvl, KM_SLEEP) != 0) {
                        kmem_free(buf, bufsz);
                        return (EFAULT);
                }

                kmem_free(buf, bufsz);

                if (nvl == NULL)
                        return (EINVAL);
        }

        evch_usrsetpropnvl(ctl->chp, nvl);
        return (0);
}

/* ARGSUSED */
static int
sysevent_getpropnvl(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
{
        sev_propnvl_args_t uargs;
        size_t reqsz, avlsz;
        evchan_ctl_t *ctl;
        nvlist_t *nvl;
        int64_t gen;
        int rc;

        ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));

        if (ctl == NULL || ctl->chp == NULL)
                return (ENXIO);

        if (copyin(arg, &uargs, sizeof (uargs)) != 0)
                return (EFAULT);

        if ((rc = evch_usrgetpropnvl(ctl->chp, &nvl, &gen)) != 0)
                return (rc);

        if (nvl != NULL) {
                avlsz = uargs.packednvl.len;

                if (nvlist_size(nvl, &reqsz, NV_ENCODE_NATIVE) != 0) {
                        nvlist_free(nvl);
                        return (EINVAL);
                }

                if (reqsz > EVCH_MAX_DATA_SIZE) {
                        nvlist_free(nvl);
                        return (E2BIG);
                }

                if (reqsz <= avlsz) {
                        char *buf = kmem_alloc(reqsz, KM_SLEEP);

                        if (nvlist_pack(nvl, &buf, &reqsz,
                            NV_ENCODE_NATIVE, 0) != 0 || copyout(buf,
                            (void *)(uintptr_t)uargs.packednvl.name,
                            reqsz) != 0) {
                                kmem_free(buf, reqsz);
                                nvlist_free(nvl);
                                return (EFAULT);
                        }
                        kmem_free(buf, reqsz);
                        rc = 0;
                } else {
                        rc = EOVERFLOW;
                }
                uargs.packednvl.len = (uint32_t)reqsz;
                nvlist_free(nvl);
        } else {
                uargs.packednvl.len = 0;
                rc = 0;
        }

        uargs.generation = gen;
        if (copyout((void *)&uargs, arg, sizeof (uargs)) != 0)
                rc = EFAULT;

        return (rc);
}

/*ARGSUSED*/
static int
sysevent_ioctl(dev_t dev, int cmd, intptr_t arg,
    int flag, cred_t *cr, int *rvalp)
{
        int rc;

        switch (cmd) {
        case SEV_PUBLISH:
                rc = sysevent_publish(dev, rvalp, (void *)arg, flag, cr);
                break;
        case SEV_CHAN_OPEN:
                rc = sysevent_chan_open(dev, rvalp, (void *)arg, flag, cr);
                break;
        case SEV_CHAN_CONTROL:
                rc = sysevent_chan_control(dev, rvalp, (void *)arg, flag, cr);
                break;
        case SEV_SUBSCRIBE:
                rc = sysevent_subscribe(dev, rvalp, (void *)arg, flag, cr);
                break;
        case SEV_UNSUBSCRIBE:
                rc = sysevent_unsubscribe(dev, rvalp, (void *)arg, flag, cr);
                break;
        case SEV_CHANNAMES:
                rc = sysevent_channames(dev, rvalp, (void *)arg, flag, cr);
                break;
        case SEV_CHANDATA:
                rc = sysevent_chandata(dev, rvalp, (void *)arg, flag, cr);
                break;
        case SEV_SETPROPNVL:
                rc = sysevent_setpropnvl(dev, rvalp, (void *)arg, flag, cr);
                break;
        case SEV_GETPROPNVL:
                rc = sysevent_getpropnvl(dev, rvalp, (void *)arg, flag, cr);
                break;
        default:
                rc = EINVAL;
        }

        return (rc);
}

/*ARGSUSED*/
static int
sysevent_open(dev_t *devp, int flag, int otyp, cred_t *cr)
{
        int minor;

        if (otyp != OTYP_CHR)
                return (EINVAL);

        if (getminor(*devp) != 0)
                return (ENXIO);

        minor = sysevent_minor_get();
        if (minor == 0)
                /* All minors are busy */
                return (EBUSY);

        if (ddi_soft_state_zalloc(evchan_ctlp, minor)
            != DDI_SUCCESS) {
                sysevent_minor_rele(minor);
                return (ENOMEM);
        }

        *devp = makedevice(getmajor(*devp), minor);

        return (0);
}

/*ARGSUSED*/
static int
sysevent_close(dev_t dev, int flag, int otyp, cred_t *cr)
{
        int minor = (int)getminor(dev);
        evchan_ctl_t *ctl;

        if (otyp != OTYP_CHR)
                return (EINVAL);

        ctl = ddi_get_soft_state(evchan_ctlp, minor);
        if (ctl == NULL) {
                return (ENXIO);
        }

        if (ctl->chp) {
                /* Release all non-persistant subscriptions */
                evch_usrunsubscribe(ctl->chp, NULL, EVCH_SUB_KEEP);
                evch_usrchanclose(ctl->chp);
        }

        ddi_soft_state_free(evchan_ctlp, minor);
        sysevent_minor_rele(minor);

        return (0);
}

/* ARGSUSED */
static int
sysevent_info(dev_info_t *dip, ddi_info_cmd_t infocmd,
    void *arg, void **result)
{
        switch (infocmd) {
        case DDI_INFO_DEVT2DEVINFO:
                *result = sysevent_devi;
                return (DDI_SUCCESS);
        case DDI_INFO_DEVT2INSTANCE:
                *result = 0;
                return (DDI_SUCCESS);
        }
        return (DDI_FAILURE);
}

/* ARGSUSED */
static int
sysevent_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{

        if (cmd != DDI_ATTACH) {
                return (DDI_FAILURE);
        }

        if (ddi_create_minor_node(devi, "sysevent", S_IFCHR,
            0, DDI_PSEUDO, 0) == DDI_FAILURE) {
                ddi_remove_minor_node(devi, NULL);
                return (DDI_FAILURE);
        }
        sysevent_devi = devi;

        sysevent_minor_init();

        return (DDI_SUCCESS);
}

static int
sysevent_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
        if (cmd != DDI_DETACH) {
                return (DDI_FAILURE);
        }

        sysevent_minor_free(sysevent_minor_bitmap);
        ddi_remove_minor_node(devi, NULL);
        return (DDI_SUCCESS);
}

static struct cb_ops sysevent_cb_ops = {
        .cb_open = sysevent_open,
        .cb_close = sysevent_close,
        .cb_strategy = nodev,
        .cb_print = nodev,
        .cb_dump = nodev,
        .cb_read = nodev,
        .cb_write = nodev,
        .cb_ioctl = sysevent_ioctl,
        .cb_devmap = nodev,
        .cb_mmap = nodev,
        .cb_segmap = nodev,
        .cb_chpoll = nochpoll,
        .cb_prop_op = ddi_prop_op,
        .cb_str = NULL,
        .cb_flag = D_NEW | D_MP,
        .cb_rev = CB_REV,
        .cb_aread = NULL,
        .cb_awrite = NULL
};

static struct dev_ops sysevent_ops = {
        DEVO_REV,               /* devo_rev */
        0,                      /* refcnt  */
        sysevent_info,          /* info */
        nulldev,                /* identify */
        nulldev,                /* probe */
        sysevent_attach,        /* attach */
        sysevent_detach,        /* detach */
        nodev,                  /* reset */
        &sysevent_cb_ops,       /* driver operations */
        NULL,                   /* no bus operations */
        nulldev,                /* power */
        ddi_quiesce_not_needed,         /* quiesce */
};

static struct modldrv modldrv = {
        &mod_driverops, "sysevent driver", &sysevent_ops
};

static struct modlinkage modlinkage = {
        MODREV_1, &modldrv, NULL
};

int
_init(void)
{
        int s;

        s = ddi_soft_state_init(&evchan_ctlp, sizeof (evchan_ctl_t), 1);
        if (s != 0)
                return (s);

        if ((s = mod_install(&modlinkage)) != 0)
                ddi_soft_state_fini(&evchan_ctlp);
        return (s);
}

int
_fini(void)
{
        int s;

        if ((s = mod_remove(&modlinkage)) != 0)
                return (s);

        ddi_soft_state_fini(&evchan_ctlp);
        return (s);
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&modlinkage, modinfop));
}