/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include <sys/types.h>
#include <sys/file.h>
#include <sys/errno.h>
#include <sys/open.h>
#include <sys/cred.h>
#include <sys/conf.h>
#include <sys/modctl.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/policy.h>
#include <sys/pool.h>
#include <sys/pool_impl.h>

/*
 * The kernel pools subsystem is accessed and manipulated through the pool
 * device, which has two minor nodes /dev/pool, and /dev/poolctl.  User
 * processes can comminicate with pools through ioctls on these devices.
 *
 * The poolctl device (POOL_CTL_PARENT) can be used to modify and take
 * snapshot of the current configuration.  Only one process on the system
 * can have it open at any given time.  This device is also used to enable
 * or disable pools.  If pools are disabled, the pool driver can be unloaded
 * and completely removed from the system.
 *
 * The pool "info" device (POOL_INFO_PARENT) can only be used to obtain
 * snapshots of the current configuration and change/query pool bindings.
 * While some reconfiguration transaction via the poolctl device is in
 * progress, all processes using this "info" device will be provided with
 * the snapshot taken at the beginning of that transaction.
 */

#define POOL_CTL_PARENT         0
#define POOL_INFO_PARENT        1

static dev_info_t *pool_devi;   /* pool device information */
static int pool_openctl;        /* poolctl device is already open */

/*ARGSUSED*/
static int
pool_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
        int error = DDI_FAILURE;

        switch (infocmd) {
        case DDI_INFO_DEVT2DEVINFO:
                *result = pool_devi;
                error = DDI_SUCCESS;
                break;
        case DDI_INFO_DEVT2INSTANCE:
                /*
                 * All dev_t's map to the same, single instance.
                 */
                *result = NULL;
                error = DDI_SUCCESS;
                break;
        default:
                break;
        }
        return (error);
}

static int
pool_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
        int ret = DDI_SUCCESS;

        switch (cmd) {
        case DDI_DETACH:
                pool_lock();
                if (pool_state == POOL_ENABLED) {
                        ret = DDI_FAILURE;
                        pool_unlock();
                        break;
                }
                ddi_remove_minor_node(devi, NULL);
                pool_devi = NULL;
                pool_unlock();
                break;
        default:
                ret = DDI_FAILURE;
        }
        return (ret);
}

static int
pool_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
        switch (cmd) {
        case DDI_ATTACH:
                if (pool_devi != NULL)
                        return (DDI_FAILURE);
                if (ddi_create_minor_node(devi, "poolctl", S_IFCHR,
                    POOL_CTL_PARENT, DDI_PSEUDO, 0) == DDI_FAILURE ||
                    ddi_create_minor_node(devi, "pool", S_IFCHR,
                    POOL_INFO_PARENT, DDI_PSEUDO, 0) == DDI_FAILURE) {
                        ddi_remove_minor_node(devi, NULL);
                        return (DDI_FAILURE);
                }
                pool_devi = devi;
                ddi_report_dev(devi);
                break;
        case DDI_RESUME:
                break;
        default:
                return (DDI_FAILURE);
        }
        return (DDI_SUCCESS);

}

/*
 * There is only one instance of the pool control device, poolctl,
 * and multiple instances of the pool info device, pool.
 */
/*ARGSUSED*/
static int
pool_open(dev_t *devp, int flag, int otype, cred_t *credp)
{
        minor_t minor = getminor(*devp);

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

        switch (minor) {
        case POOL_CTL_PARENT:
                if (secpolicy_pool(CRED()) != 0)
                        return (EPERM);
                if (pool_lock_intr() != 0)
                        return (EINTR);
                if (pool_openctl == 1) {
                        pool_unlock();
                        return (EBUSY);
                }
                pool_openctl = 1;
                pool_unlock();
                break;
        case POOL_INFO_PARENT:
                break;
        default:
                return (ENXIO);
        }
        return (0);
}

/*ARGSUSED*/
static int
pool_close(dev_t dev, int flag, int otype, cred_t *credp)
{
        if (otype != OTYP_CHR)
                return (EINVAL);
        if (getminor(dev) == 0) {
                /*
                 * We could be closing the poolctl device without finishing
                 * the commit transaction first, so do that now.
                 */
                pool_lock();
                (void) pool_commit(0);  /* cannot fail since arg is 0 */
                pool_openctl = 0;
                pool_unlock();
        }
        return (0);
}

/*
 * Main pool interface.
 */
/* ARGSUSED4 */
static int
pool_ioctl(dev_t dev, int cmd, intptr_t arg, int  mode, cred_t *credp,
    int *rvalp)
{
        pool_xtransfer_t xtransfer;
        pool_transfer_t transfer;
        pool_destroy_t destroy;
        pool_propget_t propget;
        pool_propput_t propput;
        pool_proprm_t proprm;
        pool_status_t status;
        pool_dissoc_t dissoc;
        pool_create_t create;
        pool_assoc_t assoc;
        pool_bindq_t bindq;
        pool_query_t query;
        pool_bind_t bind;
#ifdef  _MULTI_DATAMODEL
        pool_xtransfer32_t xtransfer32;
        pool_propput32_t propput32;
        pool_propget32_t propget32;
        pool_proprm32_t proprm32;
        pool_query32_t query32;
#endif  /* _MULTI_DATAMODEL */
        char *kbuf = NULL;
        size_t kbufsz = 0;
        int snapshot = 0;
        char *prop_name;
        size_t size = 0;
        nvlist_t *list;
        nvpair_t *pair;
        char *listbuf;
        minor_t minor;
        uint_t model;
        id_t *id_buf;
        int ret = 0;

        model = ddi_model_convert_from(mode & FMODELS);
        minor = getminor(dev);

        /*
         * Check basic permissions first.
         */
        switch (cmd) {
        case POOL_STATUS:
        case POOL_CREATE:
        case POOL_ASSOC:
        case POOL_DISSOC:
        case POOL_DESTROY:
        case POOL_TRANSFER:
        case POOL_XTRANSFER:
        case POOL_PROPPUT:
        case POOL_PROPRM:
        case POOL_COMMIT:
                if (minor != POOL_CTL_PARENT)
                        return (EINVAL);
                /*FALLTHROUGH*/
        case POOL_BIND:
                if (secpolicy_pool(CRED()) != 0)
                        return (EPERM);
                break;
        }

        switch (cmd) {
        case POOL_STATUS:
                if (ddi_copyin((void *)arg, &status,
                    sizeof (pool_status_t), mode) != 0)
                        return (EFAULT);
                if (pool_lock_intr() != 0)
                        return (EINTR);
                ret = pool_status(status.ps_io_state);
                pool_unlock();
                break;
        case POOL_STATUSQ:
                /*
                 * No need to grab pool_lock() to look at the current state.
                 */
                status.ps_io_state = pool_state;
                if (ddi_copyout(&status, (void *)arg,
                    sizeof (pool_status_t), mode) != 0)
                        return (EFAULT);
                break;
        case POOL_QUERY:
                switch (model) {
#ifdef _MULTI_DATAMODEL
                case DDI_MODEL_ILP32:
                        if (ddi_copyin((void *)arg, &query32,
                            sizeof (pool_query32_t), mode) != 0)
                                return (EFAULT);
                        query.pq_io_bufsize = query32.pq_io_bufsize;
                        query.pq_io_buf = (char *)(uintptr_t)query32.pq_io_buf;
                        break;
#endif  /* _MULTI_DATAMODEL */
                default:
                case DDI_MODEL_NONE:
                        if (ddi_copyin((void *)arg, &query,
                            sizeof (pool_query_t), mode) != 0)
                                return (EFAULT);
                }
                if (pool_lock_intr() != 0)
                        return (EINTR);
                if (pool_state == POOL_DISABLED) {
                        pool_unlock();
                        return (ENOTACTIVE);
                }
                if (minor != 0 && pool_buf != NULL) {
                        /*
                         * Return last snapshot if some
                         * transaction is still in progress
                         */
                        if (kbufsz != 0 && pool_bufsz > kbufsz) {
                                pool_unlock();
                                return (ENOMEM);
                        }
                        kbuf = pool_buf;
                        kbufsz = size = pool_bufsz;
                        snapshot = 1;
                } else if (query.pq_io_bufsize != 0) {
                        kbufsz = query.pq_io_bufsize;
                        kbuf = kmem_alloc(kbufsz, KM_NOSLEEP);
                        if (kbuf == NULL) {
                                pool_unlock();
                                return (ENOMEM);
                        }
                        ret = pool_pack_conf(kbuf, kbufsz, &size);
                } else {
                        ret = pool_pack_conf(NULL, 0, &size);
                }
                if (ret == 0) {
                        switch (model) {
#ifdef  _MULTI_DATAMODEL
                        case DDI_MODEL_ILP32:
                                query32.pq_io_bufsize = size;
                                if (ddi_copyout((caddr_t)&query32, (void *)arg,
                                    sizeof (pool_query32_t), mode) != 0)
                                        ret = EFAULT;
                                break;
#endif  /* _MULTI_DATAMODEL */
                        default:
                        case DDI_MODEL_NONE:
                                query.pq_io_bufsize = size;
                                if (ddi_copyout(&query, (void *)arg,
                                    sizeof (pool_query_t), mode) != 0)
                                        ret = EFAULT;
                        }
                        if (ret == 0 && query.pq_io_buf != NULL &&
                            ddi_copyout(kbuf, query.pq_io_buf, size, mode) != 0)
                                ret = EFAULT;
                }
                pool_unlock();
                if (snapshot == 0)
                        kmem_free(kbuf, kbufsz);
                break;
        case POOL_CREATE:
                if (ddi_copyin((void *)arg,
                    &create, sizeof (pool_create_t), mode) != 0)
                        return (EFAULT);
                if (pool_lock_intr() != 0)
                        return (EINTR);
                ret = pool_create(create.pc_o_type,
                    create.pc_o_sub_type, &create.pc_i_id);
                pool_unlock();
                if (ret == 0 && ddi_copyout(&create, (void *)arg,
                    sizeof (pool_create_t), mode) != 0)
                        ret = EFAULT;
                break;
        case POOL_ASSOC:
                if (ddi_copyin((void *)arg, &assoc,
                    sizeof (pool_assoc_t), mode) != 0)
                        return (EFAULT);
                if (pool_lock_intr() != 0)
                        return (EINTR);
                ret = pool_assoc(assoc.pa_o_pool_id,
                    assoc.pa_o_id_type, assoc.pa_o_res_id);
                pool_unlock();
                break;
        case POOL_DISSOC:
                if (ddi_copyin((void *)arg, &dissoc,
                    sizeof (pool_dissoc_t), mode) != 0)
                        return (EFAULT);
                if (pool_lock_intr() != 0)
                        return (EINTR);
                ret = pool_dissoc(dissoc.pd_o_pool_id, dissoc.pd_o_id_type);
                pool_unlock();
                break;
        case POOL_DESTROY:
                if (ddi_copyin((void *)arg, &destroy,
                    sizeof (pool_destroy_t), mode) != 0)
                        return (EFAULT);
                if (pool_lock_intr() != 0)
                        return (EINTR);
                ret = pool_destroy(destroy.pd_o_type, destroy.pd_o_sub_type,
                    destroy.pd_o_id);
                pool_unlock();
                break;
        case POOL_TRANSFER:
                if (ddi_copyin((void *)arg, &transfer,
                    sizeof (pool_transfer_t), mode) != 0)
                        return (EFAULT);
                if (pool_lock_intr() != 0)
                        return (EINTR);
                ret = pool_transfer(transfer.pt_o_id_type, transfer.pt_o_src_id,
                    transfer.pt_o_tgt_id, transfer.pt_o_qty);
                pool_unlock();
                break;
        case POOL_XTRANSFER:
                switch (model) {
#ifdef _MULTI_DATAMODEL
                case DDI_MODEL_ILP32:
                        if (ddi_copyin((void *)arg, &xtransfer32,
                            sizeof (pool_xtransfer32_t), mode) != 0)
                                return (EFAULT);
                        xtransfer.px_o_id_type = xtransfer32.px_o_id_type;
                        xtransfer.px_o_src_id = xtransfer32.px_o_src_id;
                        xtransfer.px_o_tgt_id = xtransfer32.px_o_tgt_id;
                        xtransfer.px_o_complist_size =
                            xtransfer32.px_o_complist_size;
                        xtransfer.px_o_comp_list =
                            (id_t *)(uintptr_t)xtransfer32.px_o_comp_list;
                        break;
#endif /* _MULTI_DATAMODEL */
                default:
                case DDI_MODEL_NONE:
                        if (ddi_copyin((void *)arg, &xtransfer,
                            sizeof (pool_xtransfer_t), mode) != 0)
                                return (EFAULT);
                }
                /*
                 * Copy in IDs to transfer from the userland
                 */
                if (xtransfer.px_o_complist_size > POOL_IDLIST_SIZE)
                        return (EINVAL);
                id_buf = kmem_alloc(xtransfer.px_o_complist_size *
                    sizeof (id_t), KM_SLEEP);
                if (ddi_copyin((void *)xtransfer.px_o_comp_list, id_buf,
                    xtransfer.px_o_complist_size * sizeof (id_t), mode) != 0) {
                        kmem_free(id_buf, xtransfer.px_o_complist_size *
                            sizeof (id_t));
                        return (EFAULT);
                }
                if (pool_lock_intr() != 0) {
                        kmem_free(id_buf, xtransfer.px_o_complist_size *
                            sizeof (id_t));
                        return (EINTR);
                }
                ret = pool_xtransfer(xtransfer.px_o_id_type,
                    xtransfer.px_o_src_id, xtransfer.px_o_tgt_id,
                    xtransfer.px_o_complist_size, id_buf);
                pool_unlock();
                kmem_free(id_buf, xtransfer.px_o_complist_size *
                    sizeof (id_t));
                break;
        case POOL_BIND:
                if (ddi_copyin((void *)arg, &bind,
                    sizeof (pool_bind_t), mode) != 0)
                        return (EFAULT);
                if (pool_lock_intr() != 0)
                        return (EINTR);
                ret = pool_bind(bind.pb_o_pool_id, bind.pb_o_id_type,
                    bind.pb_o_id);
                pool_unlock();
                break;
        case POOL_BINDQ:
                if (ddi_copyin((void *)arg, &bindq,
                    sizeof (pool_bindq_t), mode) != 0) {
                        return (EFAULT);
                }
                if (pool_lock_intr() != 0)
                        return (EINTR);
                if ((ret = pool_query_binding(bindq.pb_o_id_type,
                    bindq.pb_o_id, &bindq.pb_i_id)) == 0 &&
                    ddi_copyout(&bindq, (void *)arg,
                    sizeof (pool_bindq_t), mode) != 0)
                        ret = EFAULT;
                pool_unlock();
                break;
        case POOL_PROPGET:
                switch (model) {
#ifdef _MULTI_DATAMODEL
                case DDI_MODEL_ILP32:
                        if (ddi_copyin((void *)arg, &propget32,
                            sizeof (pool_propget32_t), mode) != 0)
                                return (EFAULT);
                        propget.pp_o_id = propget32.pp_o_id;
                        propget.pp_o_id_type = propget32.pp_o_id_type;
                        propget.pp_o_id_subtype = propget32.pp_o_id_subtype;
                        propget.pp_o_prop_name =
                            (char *)(uintptr_t)propget32.pp_o_prop_name;
                        propget.pp_o_prop_name_size =
                            propget32.pp_o_prop_name_size;
                        propget.pp_i_buf =
                            (char *)(uintptr_t)propget32.pp_i_buf;
                        propget.pp_i_bufsize = propget32.pp_i_bufsize;
                        break;
#endif  /* _MULTI_DATAMODEL */
                default:
                case DDI_MODEL_NONE:
                        if (ddi_copyin((void *)arg, &propget,
                            sizeof (pool_propget_t), mode) != 0)
                                return (EFAULT);
                }
                if (propget.pp_o_prop_name_size + 1 > POOL_PROPNAME_SIZE)
                        return (EINVAL);
                prop_name = kmem_alloc(propget.pp_o_prop_name_size + 1,
                    KM_SLEEP);
                if (ddi_copyin(propget.pp_o_prop_name, prop_name,
                    propget.pp_o_prop_name_size + 1, mode) != 0) {
                        kmem_free(prop_name, propget.pp_o_prop_name_size + 1);
                        return (EFAULT);
                }
                list = NULL;
                if (pool_lock_intr() != 0) {
                        kmem_free(prop_name, propget.pp_o_prop_name_size + 1);
                        return (EINTR);
                }
                ret = pool_propget(prop_name, propget.pp_o_id_type,
                    propget.pp_o_id_subtype, propget.pp_o_id, &list);
                pool_unlock();
                kmem_free(prop_name, propget.pp_o_prop_name_size + 1);
                if (ret != 0)
                        return (ret);
                ret = nvlist_pack(list, &kbuf, &kbufsz, NV_ENCODE_NATIVE, 0);
                if (ret != 0) {
                        nvlist_free(list);
                        return (ret);
                }
                switch (model) {
#ifdef  _MULTI_DATAMODEL
                case DDI_MODEL_ILP32:
                        propget32.pp_i_bufsize = kbufsz;
                        if (ddi_copyout((caddr_t)&propget32, (void *)arg,
                            sizeof (pool_propget32_t), mode) != 0)
                                ret = EFAULT;
                        break;
#endif  /* _MULTI_DATAMODEL */
                default:
                case DDI_MODEL_NONE:
                        if (ddi_copyout(&propget, (void *)arg,
                            sizeof (pool_propget_t), mode) != 0)
                                ret = EFAULT;
                }
                if (ret == 0) {
                        if (propget.pp_i_buf == NULL) {
                                ret = 0;
                        } else if (propget.pp_i_bufsize >= kbufsz) {
                                if (ddi_copyout(kbuf, propget.pp_i_buf,
                                    kbufsz, mode) != 0)
                                        ret = EFAULT;
                        } else {
                                ret = ENOMEM;
                        }
                }
                kmem_free(kbuf, kbufsz);
                nvlist_free(list);
                break;
        case POOL_PROPPUT:
                switch (model) {
#ifdef _MULTI_DATAMODEL
                case DDI_MODEL_ILP32:
                        if (ddi_copyin((void *)arg, &propput32,
                            sizeof (pool_propput32_t), mode) != 0)
                                return (EFAULT);
                        propput.pp_o_id_type = propput32.pp_o_id_type;
                        propput.pp_o_id_sub_type = propput32.pp_o_id_sub_type;
                        propput.pp_o_id = propput32.pp_o_id;
                        propput.pp_o_bufsize = propput32.pp_o_bufsize;
                        propput.pp_o_buf =
                            (char *)(uintptr_t)propput32.pp_o_buf;
                        break;
#endif  /* _MULTI_DATAMODEL */
                default:
                case DDI_MODEL_NONE:
                        if (ddi_copyin((void *)arg, &propput,
                            sizeof (pool_propput_t), mode) != 0)
                                return (EFAULT);
                }
                if (propput.pp_o_bufsize > POOL_PROPBUF_SIZE)
                        return (EINVAL);
                listbuf = kmem_alloc(propput.pp_o_bufsize, KM_SLEEP);
                if (ddi_copyin(propput.pp_o_buf, listbuf,
                    propput.pp_o_bufsize, mode) != 0) {
                        kmem_free(listbuf, propput.pp_o_bufsize);
                        return (EFAULT);
                }
                if (nvlist_unpack(listbuf, propput.pp_o_bufsize,
                    &list, KM_SLEEP) != 0) {
                        kmem_free(listbuf, propput.pp_o_bufsize);
                        return (EFAULT);
                }
                if (pool_lock_intr() != 0) {
                        nvlist_free(list);
                        kmem_free(listbuf, propput.pp_o_bufsize);
                        return (EINTR);
                }
                /*
                 * Extract the nvpair from the list. The list may
                 * contain multiple properties.
                 */
                for (pair = nvlist_next_nvpair(list, NULL); pair != NULL;
                    pair = nvlist_next_nvpair(list, pair)) {
                        if ((ret = pool_propput(propput.pp_o_id_type,
                            propput.pp_o_id_sub_type,
                            propput.pp_o_id, pair)) != 0)
                                break;
                }
                pool_unlock();
                nvlist_free(list);
                kmem_free(listbuf, propput.pp_o_bufsize);
                break;
        case POOL_PROPRM:
                switch (model) {
#ifdef _MULTI_DATAMODEL
                case DDI_MODEL_ILP32:
                        if (ddi_copyin((void *)arg, &proprm32,
                            sizeof (pool_proprm32_t), mode) != 0)
                                return (EFAULT);
                        proprm.pp_o_id_type = proprm32.pp_o_id_type;
                        proprm.pp_o_id_sub_type = proprm32.pp_o_id_sub_type;
                        proprm.pp_o_id = proprm32.pp_o_id;
                        proprm.pp_o_prop_name_size =
                            proprm32.pp_o_prop_name_size;
                        proprm.pp_o_prop_name =
                            (void *)(uintptr_t)proprm32.pp_o_prop_name;
                        break;
#endif  /* _MULTI_DATAMODEL */
                default:
                case DDI_MODEL_NONE:
                        if (ddi_copyin((void *)arg, &proprm,
                            sizeof (pool_proprm_t), mode) != 0)
                                return (EFAULT);
                }
                if (proprm.pp_o_prop_name_size + 1 > POOL_PROPNAME_SIZE)
                        return (EINVAL);
                prop_name = kmem_alloc(proprm.pp_o_prop_name_size + 1,
                    KM_SLEEP);
                if (ddi_copyin(proprm.pp_o_prop_name, prop_name,
                    proprm.pp_o_prop_name_size + 1, mode) != 0) {
                        kmem_free(prop_name, proprm.pp_o_prop_name_size + 1);
                        return (EFAULT);
                }
                if (pool_lock_intr() != 0) {
                        kmem_free(prop_name, proprm.pp_o_prop_name_size + 1);
                        return (EINTR);
                }
                ret = pool_proprm(proprm.pp_o_id_type,
                    proprm.pp_o_id_sub_type, proprm.pp_o_id, prop_name);
                pool_unlock();
                kmem_free(prop_name, proprm.pp_o_prop_name_size + 1);
                break;
        case POOL_COMMIT:
                if (pool_lock_intr() != 0)
                        return (EINTR);
                ret = pool_commit((int)arg);
                pool_unlock();
                break;
        default:
                return (EINVAL);
        }
        return (ret);
}

static struct cb_ops pool_cb_ops = {
        pool_open,              /* open */
        pool_close,             /* close */
        nodev,                  /* strategy */
        nodev,                  /* print */
        nodev,                  /* dump */
        nodev,                  /* read */
        nodev,                  /* write */
        pool_ioctl,             /* ioctl */
        nodev,                  /* devmap */
        nodev,                  /* mmap */
        nodev,                  /* segmap */
        nochpoll,               /* poll */
        nodev,                  /* cb_prop_op */
        (struct streamtab *)0,  /* streamtab */
        D_NEW | D_MP            /* driver compatibility flags */
};

static struct dev_ops pool_ops = {
        DEVO_REV,               /* devo_rev */
        0,                      /* refcnt */
        pool_info,              /* info */
        nulldev,                /* identify */
        nulldev,                /* probe */
        pool_attach,            /* attach */
        pool_detach,            /* detach */
        nodev,                  /* reset */
        &pool_cb_ops,           /* cb_ops */
        (struct bus_ops *)NULL, /* bus_ops */
        nulldev,                /* power */
        ddi_quiesce_not_needed,         /* quiesce */
};

/*
 * Module linkage information for the kernel
 */
static struct modldrv modldrv = {
        &mod_driverops,         /* this one is a pseudo driver */
        "pool driver",
        &pool_ops
};

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

int
_init(void)
{
        return (mod_install(&modlinkage));
}

int
_fini(void)
{
        return (mod_remove(&modlinkage));
}

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