/*
 * 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) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * DR control module for LDoms
 */

#include <sys/sysmacros.h>
#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ddi_impldefs.h>
#include <sys/stat.h>
#include <sys/door.h>
#include <sys/open.h>
#include <sys/note.h>
#include <sys/ldoms.h>
#include <sys/dr_util.h>
#include <sys/drctl.h>
#include <sys/drctl_impl.h>


static int drctl_attach(dev_info_t *, ddi_attach_cmd_t);
static int drctl_detach(dev_info_t *, ddi_detach_cmd_t);
static int drctl_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);

static int drctl_open(dev_t *, int, int, cred_t *);
static int drctl_close(dev_t, int, int, cred_t *);
static int drctl_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

static void *pack_message(int, int, int, void *, size_t *, size_t *);
static int send_message(void *, size_t, drctl_resp_t **, size_t *);


/*
 * Configuration data structures
 */
static struct cb_ops drctl_cb_ops = {
        drctl_open,             /* open */
        drctl_close,            /* close */
        nodev,                  /* strategy */
        nodev,                  /* print */
        nodev,                  /* dump */
        nodev,                  /* read */
        nodev,                  /* write */
        drctl_ioctl,            /* ioctl */
        nodev,                  /* devmap */
        nodev,                  /* mmap */
        nodev,                  /* segmap */
        nochpoll,               /* poll */
        ddi_prop_op,            /* prop_op */
        NULL,                   /* streamtab */
        D_MP | D_NEW,           /* driver compatibility flag */
        CB_REV,                 /* cb_ops revision */
        nodev,                  /* async read */
        nodev                   /* async write */
};


static struct dev_ops drctl_ops = {
        DEVO_REV,               /* devo_rev */
        0,                      /* refcnt */
        drctl_getinfo,          /* info */
        nulldev,                /* identify */
        nulldev,                /* probe */
        drctl_attach,           /* attach */
        drctl_detach,           /* detach */
        nodev,                  /* reset */
        &drctl_cb_ops,          /* driver operations */
        NULL,                   /* bus operations */
        NULL,                   /* power */
        ddi_quiesce_not_needed,         /* quiesce */
};

static struct modldrv modldrv = {
        &mod_driverops,         /* type of module - driver */
        "DR Control pseudo driver",
        &drctl_ops
};

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


/*
 * Locking strategy
 *
 * One of the reasons for this module's existence is to serialize
 * DR requests which might be coming from different sources.  Only
 * one operation is allowed to be in progress at any given time.
 *
 * A single lock word (the 'drc_busy' element below) is NULL
 * when there is no operation in progress.  When a client of this
 * module initiates an operation it grabs the mutex 'drc_lock' in
 * order to examine the lock word ('drc_busy').  If no other
 * operation is in progress, the lock word will be NULL.  If so,
 * a cookie which uniquely identifies the requestor is stored in
 * the lock word, and the mutex is released.  Attempts by other
 * clients to initiate an operation will fail.
 *
 * When the lock-holding client's operation is completed, the
 * client will call a "finalize" function in this module, providing
 * the cookie passed with the original request.  Since the cookie
 * matches, the operation will succeed and the lock word will be
 * cleared.  At this point, an new operation may be initiated.
 */

/*
 * Driver private data
 */
static struct drctl_unit {
        kmutex_t                drc_lock;       /* global driver lock */
        dev_info_t              *drc_dip;       /* dev_info pointer */
        kcondvar_t              drc_busy_cv;    /* block for !busy */
        drctl_cookie_t          drc_busy;       /* NULL if free else a unique */
                                                /* identifier for caller */
        int                     drc_cmd;        /* the cmd underway (or -1) */
        int                     drc_flags;      /* saved flag from above cmd */
        int                     drc_inst;       /* our single instance */
        uint_t                  drc_state;      /* driver state */
} drctl_state;

static struct drctl_unit *drctlp = &drctl_state;

int
_init(void)
{
        int rv;

        drctlp->drc_inst = -1;
        mutex_init(&drctlp->drc_lock, NULL, MUTEX_DRIVER, NULL);
        cv_init(&drctlp->drc_busy_cv, NULL, CV_DRIVER, NULL);

        if ((rv = mod_install(&modlinkage)) != 0)
                mutex_destroy(&drctlp->drc_lock);

        return (rv);
}


int
_fini(void)
{
        int rv;

        if ((rv = mod_remove(&modlinkage)) != 0)
                return (rv);
        cv_destroy(&drctlp->drc_busy_cv);
        mutex_destroy(&drctlp->drc_lock);
        return (0);
}


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


/*
 * Do the attach work
 */
static int
drctl_do_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        _NOTE(ARGUNUSED(cmd))

        char *str = "drctl_do_attach";
        int retval = DDI_SUCCESS;

        if (drctlp->drc_inst != -1) {
                cmn_err(CE_WARN, "%s: an instance is already attached!", str);
                return (DDI_FAILURE);
        }
        drctlp->drc_inst = ddi_get_instance(dip);

        retval = ddi_create_minor_node(dip, "drctl", S_IFCHR,
            drctlp->drc_inst, DDI_PSEUDO, 0);
        if (retval != DDI_SUCCESS) {
                cmn_err(CE_WARN, "%s: can't create minor node", str);
                drctlp->drc_inst = -1;
                return (retval);
        }

        drctlp->drc_dip = dip;
        ddi_report_dev(dip);

        return (retval);
}


static int
drctl_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        switch (cmd) {
        case DDI_ATTACH:
                return (drctl_do_attach(dip, cmd));

        default:
                return (DDI_FAILURE);
        }
}


/* ARGSUSED */
static int
drctl_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        switch (cmd) {
        case DDI_DETACH:
                drctlp->drc_inst = -1;
                ddi_remove_minor_node(dip, "drctl");
                return (DDI_SUCCESS);

        default:
                return (DDI_FAILURE);
        }
}

static int
drctl_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
{
        _NOTE(ARGUNUSED(dip, cmd, arg, resultp))

        return (0);
}

static int
drctl_open(dev_t *devp, int flag, int otyp, cred_t *cred_p)
{
        _NOTE(ARGUNUSED(devp, flag, cred_p))

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

        return (0);
}

static int
drctl_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
{
        _NOTE(ARGUNUSED(dev, flag, otyp, cred_p))

        return (0);
}

/*
 * Create a reponse structure which includes an array of drctl_rsrc_t
 * structures in which each status element is set to the 'status'
 * arg.  There is no error text, so set the 'offset' elements to 0.
 */
static drctl_resp_t *
drctl_generate_resp(drctl_rsrc_t *res,
    int count, size_t *rsize, drctl_status_t status)
{
        int             i;
        size_t          size;
        drctl_rsrc_t    *rsrc;
        drctl_resp_t    *resp;

        size = offsetof(drctl_resp_t, resp_resources) + (count * sizeof (*res));
        resp  = kmem_alloc(size, KM_SLEEP);
        DR_DBG_KMEM("%s: alloc addr %p size %ld\n",
            __func__, (void *)resp, size);

        resp->resp_type = DRCTL_RESP_OK;
        rsrc = resp->resp_resources;

        bcopy(res, rsrc, count * sizeof (*res));

        for (i = 0; i < count; i++) {
                rsrc[i].status = status;
                rsrc[i].offset = 0;
        }

        *rsize = size;

        return (resp);
}

/*
 * Generate an error response message.
 */
static drctl_resp_t *
drctl_generate_err_resp(char *msg, size_t *size)
{
        drctl_resp_t    *resp;

        ASSERT(msg != NULL);
        ASSERT(size != NULL);

        *size = offsetof(drctl_resp_t, resp_err_msg) + strlen(msg) + 1;
        resp = kmem_alloc(*size, KM_SLEEP);
        DR_DBG_KMEM("%s: alloc addr %p size %ld\n",
            __func__, (void *)resp, *size);

        resp->resp_type = DRCTL_RESP_ERR;
        (void) strcpy(resp->resp_err_msg, msg);

        return (resp);
}

/*
 * Since response comes from userland, verify that it is at least the
 * minimum size based on the size of the original request.  Verify
 * that any offsets to error strings are within the string area of
 * the response and, force the string area to be null-terminated.
 */
static int
verify_response(int cmd,
    int count, drctl_resp_t *resp, size_t sent_len, size_t resp_len)
{
        drctl_rsrc_t *rsrc = resp->resp_resources;
        size_t rcvd_len = resp_len - (offsetof(drctl_resp_t, resp_resources));
        int is_cpu = 0;
        int i;

        switch (cmd) {
        case DRCTL_CPU_CONFIG_REQUEST:
        case DRCTL_CPU_UNCONFIG_REQUEST:
                if (rcvd_len < sent_len)
                        return (EIO);
                is_cpu = 1;
                break;
        case DRCTL_IO_UNCONFIG_REQUEST:
        case DRCTL_IO_CONFIG_REQUEST:
                if (count != 1)
                        return (EIO);
                break;
        case DRCTL_MEM_CONFIG_REQUEST:
        case DRCTL_MEM_UNCONFIG_REQUEST:
                break;
        default:
                return (EIO);
        }

        for (i = 0; i < count; i++)
                if ((rsrc[i].offset > 0) &&
                    /* string can't be inside the bounds of original request */
                    (((rsrc[i].offset < sent_len) && is_cpu) ||
                    /* string must start inside the message */
                    (rsrc[i].offset >= rcvd_len)))
                        return (EIO);

        /* If there are any strings, terminate the string area. */
        if (rcvd_len > sent_len)
                *((char *)rsrc + rcvd_len - 1) = '\0';

        return (0);
}

static int
drctl_config_common(int cmd, int flags, drctl_rsrc_t *res,
    int count, drctl_resp_t **rbuf, size_t *rsize, size_t *rq_size)
{
        int     rv = 0;
        size_t  size;
        char    *bufp;

        switch (cmd) {
        case DRCTL_CPU_CONFIG_REQUEST:
        case DRCTL_CPU_CONFIG_NOTIFY:
        case DRCTL_CPU_UNCONFIG_REQUEST:
        case DRCTL_CPU_UNCONFIG_NOTIFY:
        case DRCTL_IO_UNCONFIG_REQUEST:
        case DRCTL_IO_UNCONFIG_NOTIFY:
        case DRCTL_IO_CONFIG_REQUEST:
        case DRCTL_IO_CONFIG_NOTIFY:
        case DRCTL_MEM_CONFIG_REQUEST:
        case DRCTL_MEM_CONFIG_NOTIFY:
        case DRCTL_MEM_UNCONFIG_REQUEST:
        case DRCTL_MEM_UNCONFIG_NOTIFY:
                rv = 0;
                break;
        default:
                rv = ENOTSUP;
                break;
        }

        if (rv != 0) {
                DR_DBG_CTL("%s: invalid cmd %d\n", __func__, cmd);
                return (rv);
        }

        /*
         * If the operation is a FORCE, we don't send a message to
         * the daemon.  But, the upstream clients still expect a
         * response, so generate a response with all ops 'allowed'.
         */
        if (flags == DRCTL_FLAG_FORCE) {
                if (rbuf != NULL)
                        *rbuf = drctl_generate_resp(res,
                            count, rsize, DRCTL_STATUS_ALLOW);
                return (0);
        }

        bufp = pack_message(cmd, flags, count, (void *)res, &size, rq_size);
        DR_DBG_CTL("%s: from pack_message, bufp = %p size %ld\n",
            __func__, (void *)bufp, size);

        if (bufp == NULL || size == 0)
                return (EINVAL);

        return (send_message(bufp, size, rbuf, rsize));
}

/*
 * Prepare for a reconfig operation.
 */
int
drctl_config_init(int cmd, int flags, drctl_rsrc_t *res,
    int count, drctl_resp_t **rbuf, size_t *rsize, drctl_cookie_t ck)
{
        static char inval_msg[] = "Invalid command format received.\n";
        static char unsup_msg[] = "Unsuppported command received.\n";
        static char unk_msg  [] = "Failure reason unknown.\n";
        static char rsp_msg  [] = "Invalid response from "
            "reconfiguration daemon.\n";
        static char drd_msg  [] = "Cannot communicate with reconfiguration "
            "daemon (drd) in target domain.\n"
            "drd(8) SMF service may not be enabled.\n";
        static char busy_msg [] = "Busy executing earlier command; "
            "please try again later.\n";
        size_t rq_size;
        char *ermsg;
        int rv;

        if (ck == 0) {
                *rbuf = drctl_generate_err_resp(inval_msg, rsize);

                return (EINVAL);
        }

        mutex_enter(&drctlp->drc_lock);
        if (drctlp->drc_busy != NULL) {
                mutex_exit(&drctlp->drc_lock);
                *rbuf = drctl_generate_err_resp(busy_msg, rsize);

                return (EBUSY);
        }

        DR_DBG_CTL("%s: cmd %d flags %d res %p count %d\n",
            __func__, cmd, flags, (void *)res, count);

        /* Mark the link busy.  Below we will fill in the actual cookie. */
        drctlp->drc_busy = (drctl_cookie_t)-1;
        mutex_exit(&drctlp->drc_lock);

        rv = drctl_config_common(cmd, flags, res, count, rbuf, rsize, &rq_size);
        if (rv == 0) {
                /*
                 * If the upcall to the daemon returned successfully, we
                 * still need to validate the format of the returned msg.
                 */
                if ((rv = verify_response(cmd,
                    count, *rbuf, rq_size, *rsize)) != 0) {
                        DR_DBG_KMEM("%s: free addr %p size %ld\n",
                            __func__, (void *)*rbuf, *rsize);
                        kmem_free(*rbuf, *rsize);
                        *rbuf = drctl_generate_err_resp(rsp_msg, rsize);
                        drctlp->drc_busy = NULL;
                        cv_broadcast(&drctlp->drc_busy_cv);
                } else { /* message format is valid */
                        drctlp->drc_busy = ck;
                        drctlp->drc_cmd = cmd;
                        drctlp->drc_flags = flags;
                }
        } else {
                switch (rv) {
                case ENOTSUP:
                        ermsg = unsup_msg;
                        break;
                case EIO:
                        ermsg = drd_msg;
                        break;
                default:
                        ermsg = unk_msg;
                        break;
                }

                *rbuf = drctl_generate_err_resp(ermsg, rsize);

                drctlp->drc_cmd = -1;
                drctlp->drc_flags = 0;
                drctlp->drc_busy = NULL;
                cv_broadcast(&drctlp->drc_busy_cv);
        }
        return (rv);
}

/*
 * Complete a reconfig operation.
 */
int
drctl_config_fini(drctl_cookie_t ck, drctl_rsrc_t *res, int count)
{
        int rv;
        int notify_cmd;
        int flags;
        size_t rq_size;

        mutex_enter(&drctlp->drc_lock);
        if (drctlp->drc_busy != ck) {
                mutex_exit(&drctlp->drc_lock);
                return (EBUSY);
        }
        mutex_exit(&drctlp->drc_lock);

        flags = drctlp->drc_flags;
        /*
         * Flip the saved _REQUEST command to its corresponding
         * _NOTIFY command.
         */
        switch (drctlp->drc_cmd) {
        case DRCTL_CPU_CONFIG_REQUEST:
                notify_cmd = DRCTL_CPU_CONFIG_NOTIFY;
                break;

        case DRCTL_CPU_UNCONFIG_REQUEST:
                notify_cmd = DRCTL_CPU_UNCONFIG_NOTIFY;
                break;

        case DRCTL_IO_UNCONFIG_REQUEST:
                notify_cmd = DRCTL_IO_UNCONFIG_NOTIFY;
                break;

        case DRCTL_IO_CONFIG_REQUEST:
                notify_cmd = DRCTL_IO_CONFIG_NOTIFY;
                break;

        case DRCTL_MEM_CONFIG_REQUEST:
                notify_cmd = DRCTL_MEM_CONFIG_NOTIFY;
                break;

        case DRCTL_MEM_UNCONFIG_REQUEST:
                notify_cmd = DRCTL_MEM_UNCONFIG_NOTIFY;
                break;

        default:
                /* none of the above should have been accepted in _init */
                ASSERT(0);
                cmn_err(CE_CONT,
                    "drctl_config_fini: bad cmd %d\n", drctlp->drc_cmd);
                rv = EINVAL;
                goto done;
        }

        rv = drctl_config_common(notify_cmd,
            flags, res, count, NULL, 0, &rq_size);

done:
                drctlp->drc_cmd = -1;
                drctlp->drc_flags = 0;
                drctlp->drc_busy = NULL;
                cv_broadcast(&drctlp->drc_busy_cv);
                return (rv);
}

static int
drctl_ioctl(dev_t dev,
    int cmd, intptr_t arg, int mode, cred_t *cred_p, int *rval_p)
{
        _NOTE(ARGUNUSED(dev, mode, cred_p, rval_p))

        int rv;

        switch (cmd) {
        case DRCTL_IOCTL_CONNECT_SERVER:
                rv = i_drctl_ioctl(cmd, arg);
                break;
        default:
                rv = ENOTSUP;
        }

        *rval_p = (rv == 0) ? 0 : -1;

        return (rv);
}

/*
 * Accept a preformatted request from caller and send a message to
 * the daemon.  A pointer to the daemon's response buffer is passed
 * back in obufp, its size in osize.
 */
static int
send_message(void *msg, size_t size, drctl_resp_t **obufp, size_t *osize)
{
        drctl_resp_t *bufp;
        drctl_rsrc_t *rsrcs;
        size_t rsrcs_size;
        int rv;

        rv = i_drctl_send(msg, size, (void **)&rsrcs, &rsrcs_size);

        if ((rv == 0) && ((rsrcs == NULL) ||(rsrcs_size == 0)))
                rv = EINVAL;

        if (rv == 0) {
                if (obufp != NULL) {
                        ASSERT(osize != NULL);

                        *osize =
                            offsetof(drctl_resp_t, resp_resources) + rsrcs_size;
                        bufp =
                            kmem_alloc(*osize, KM_SLEEP);
                        DR_DBG_KMEM("%s: alloc addr %p size %ld\n",
                            __func__, (void *)bufp, *osize);
                        bufp->resp_type = DRCTL_RESP_OK;
                        bcopy(rsrcs, bufp->resp_resources, rsrcs_size);
                        *obufp = bufp;
                }

                DR_DBG_KMEM("%s: free addr %p size %ld\n",
                    __func__, (void *)rsrcs, rsrcs_size);
                kmem_free(rsrcs, rsrcs_size);
        }

        DR_DBG_KMEM("%s:free addr %p size %ld\n", __func__, msg, size);
        kmem_free(msg, size);

        return (rv);
}

static void *
pack_message(int cmd,
    int flags, int count, void *data, size_t *osize, size_t *data_size)
{
        drd_msg_t *msgp = NULL;
        size_t hdr_size = offsetof(drd_msg_t, data);

        switch (cmd) {
        case DRCTL_CPU_CONFIG_REQUEST:
        case DRCTL_CPU_CONFIG_NOTIFY:
        case DRCTL_CPU_UNCONFIG_REQUEST:
        case DRCTL_CPU_UNCONFIG_NOTIFY:
                *data_size = count * sizeof (drctl_rsrc_t);
                break;
        case DRCTL_MEM_CONFIG_REQUEST:
        case DRCTL_MEM_CONFIG_NOTIFY:
        case DRCTL_MEM_UNCONFIG_REQUEST:
        case DRCTL_MEM_UNCONFIG_NOTIFY:
                *data_size = count * sizeof (drctl_rsrc_t);
                break;
        case DRCTL_IO_CONFIG_REQUEST:
        case DRCTL_IO_CONFIG_NOTIFY:
        case DRCTL_IO_UNCONFIG_REQUEST:
        case DRCTL_IO_UNCONFIG_NOTIFY:
                *data_size = sizeof (drctl_rsrc_t) +
                    strlen(((drctl_rsrc_t *)data)->res_dev_path);
                break;
        default:
                cmn_err(CE_WARN,
                    "drctl: pack_message received invalid cmd %d", cmd);
                break;
        }

        if (data_size) {
                *osize = hdr_size + *data_size;
                msgp = kmem_alloc(*osize, KM_SLEEP);
                DR_DBG_KMEM("%s: alloc addr %p size %ld\n",
                    __func__, (void *)msgp, *osize);
                msgp->cmd = cmd;
                msgp->count = count;
                msgp->flags = flags;
                bcopy(data, msgp->data, *data_size);
        }

        return (msgp);
}

/*
 * Depending on the should_block argument, either wait for ongoing DR
 * operations to finish and then block subsequent operations, or if a DR
 * operation is already in progress, return EBUSY immediately without
 * blocking subsequent DR operations.
 */
static int
drctl_block_conditional(boolean_t should_block)
{
        mutex_enter(&drctlp->drc_lock);
        /* If DR in progress and should_block is false, return */
        if (!should_block && drctlp->drc_busy != NULL) {
                mutex_exit(&drctlp->drc_lock);
                return (EBUSY);
        }

        /* Wait for any in progress DR operation to complete */
        while (drctlp->drc_busy != NULL)
                (void) cv_wait_sig(&drctlp->drc_busy_cv, &drctlp->drc_lock);

        /* Mark the link busy */
        drctlp->drc_busy = (drctl_cookie_t)-1;
        drctlp->drc_cmd = DRCTL_DRC_BLOCK;
        drctlp->drc_flags = 0;
        mutex_exit(&drctlp->drc_lock);
        return (0);
}

/*
 * Wait for ongoing DR operations to finish, block subsequent operations.
 */
void
drctl_block(void)
{
        (void) drctl_block_conditional(B_TRUE);
}

/*
 * If a DR operation is already in progress, return EBUSY immediately
 * without blocking subsequent DR operations.
 */
int
drctl_tryblock(void)
{
        return (drctl_block_conditional(B_FALSE));
}

/*
 * Unblock DR operations
 */
void
drctl_unblock(void)
{
        /* Mark the link free */
        mutex_enter(&drctlp->drc_lock);
        drctlp->drc_cmd = -1;
        drctlp->drc_flags = 0;
        drctlp->drc_busy = NULL;
        cv_broadcast(&drctlp->drc_busy_cv);
        mutex_exit(&drctlp->drc_lock);
}