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

/*
 * sun4v domain services PRI driver
 */

#include <sys/types.h>
#include <sys/file.h>
#include <sys/errno.h>
#include <sys/open.h>
#include <sys/cred.h>
#include <sys/uio.h>
#include <sys/stat.h>
#include <sys/ksynch.h>
#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/devops.h>
#include <sys/debug.h>
#include <sys/cmn_err.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ds.h>
#include <sys/hypervisor_api.h>
#include <sys/machsystm.h>
#include <sys/sysmacros.h>
#include <sys/hsvc.h>
#include <sys/bitmap.h>
#include <sys/ds_pri.h>

static uint_t ds_pri_debug = 0;
#define DS_PRI_DBG      if (ds_pri_debug) printf

#define DS_PRI_NAME     "ds_pri"

#define TEST_HARNESS
#ifdef TEST_HARNESS
#define DS_PRI_MAX_PRI_SIZE     (64 * 1024)

#define DSIOC_TEST_REG  97
#define DSIOC_TEST_UNREG        98
#define DSIOC_TEST_DATA 99

struct ds_pri_test_data {
        size_t          size;
        void            *data;
};

struct ds_pri_test_data32 {
        size32_t        size;
        caddr32_t       data;
};
#endif /* TEST_HARNESS */

typedef enum {
        DS_PRI_REQUEST  = 0,
        DS_PRI_DATA     = 1,
        DS_PRI_UPDATE   = 2
} ds_pri_msg_type_t;

typedef struct {
        struct {
                uint64_t        seq_num;
                uint64_t        type;
        } hdr;
        uint8_t         data[1];
} ds_pri_msg_t;

/*
 * The following are bit field flags. No service implies no DS PRI and
 * no outstanding request.
 */
typedef enum {
        DS_PRI_NO_SERVICE = 0x0,
        DS_PRI_HAS_SERVICE = 0x1,
        DS_PRI_REQUESTED = 0x2,
        DS_PRI_HAS_PRI = 0x4
} ds_pri_flags_t;

struct ds_pri_state {
        dev_info_t      *dip;
        int             instance;

        kmutex_t        lock;
        kcondvar_t      cv;

        /* PRI/DS */
        ds_pri_flags_t  state;
        uint64_t        gencount;
        ds_svc_hdl_t    ds_pri_handle;
        void            *ds_pri;
        size_t          ds_pri_len;
        uint64_t        req_id;
        uint64_t        last_req_id;
        int             num_opens;
};

typedef struct ds_pri_state ds_pri_state_t;

static void *ds_pri_statep;

static void request_pri(ds_pri_state_t *sp);
static uint64_t ds_get_hv_pri(ds_pri_state_t *sp);

static int ds_pri_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int ds_pri_attach(dev_info_t *, ddi_attach_cmd_t);
static int ds_pri_detach(dev_info_t *, ddi_detach_cmd_t);
static int ds_pri_open(dev_t *, int, int, cred_t *);
static int ds_pri_close(dev_t, int, int, cred_t *);
static int ds_pri_read(dev_t, struct uio *, cred_t *);
static int ds_pri_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

/*
 * DS Callbacks
 */
static void ds_pri_reg_handler(ds_cb_arg_t, ds_ver_t *, ds_svc_hdl_t);
static void ds_pri_unreg_handler(ds_cb_arg_t arg);
static void ds_pri_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen);

/*
 * PRI DS capability registration
 */

static ds_ver_t ds_pri_ver_1_0 = { 1, 0 };

static ds_capability_t ds_pri_cap = {
        "pri",
        &ds_pri_ver_1_0,
        1
};

/*
 * PRI DS Client callback vector
 */
static ds_clnt_ops_t ds_pri_ops = {
        ds_pri_reg_handler,     /* ds_reg_cb */
        ds_pri_unreg_handler,   /* ds_unreg_cb */
        ds_pri_data_handler,    /* ds_data_cb */
        NULL                    /* cb_arg */
};

/*
 * DS PRI driver Ops Vector
 */
static struct cb_ops ds_pri_cb_ops = {
        ds_pri_open,            /* cb_open */
        ds_pri_close,           /* cb_close */
        nodev,                  /* cb_strategy */
        nodev,                  /* cb_print */
        nodev,                  /* cb_dump */
        ds_pri_read,            /* cb_read */
        nodev,                  /* cb_write */
        ds_pri_ioctl,           /* cb_ioctl */
        nodev,                  /* cb_devmap */
        nodev,                  /* cb_mmap */
        nodev,                  /* cb_segmap */
        nochpoll,               /* cb_chpoll */
        ddi_prop_op,            /* cb_prop_op */
        (struct streamtab *)NULL, /* cb_str */
        D_MP | D_64BIT,         /* cb_flag */
        CB_REV,                 /* cb_rev */
        nodev,                  /* cb_aread */
        nodev                   /* cb_awrite */
};

static struct dev_ops ds_pri_dev_ops = {
        DEVO_REV,               /* devo_rev */
        0,                      /* devo_refcnt */
        ds_pri_getinfo,         /* devo_getinfo */
        nulldev,                /* devo_identify */
        nulldev,                /* devo_probe */
        ds_pri_attach,          /* devo_attach */
        ds_pri_detach,          /* devo_detach */
        nodev,                  /* devo_reset */
        &ds_pri_cb_ops,         /* devo_cb_ops */
        (struct bus_ops *)NULL, /* devo_bus_ops */
        nulldev,                /* devo_power */
        ddi_quiesce_not_needed,         /* devo_quiesce */
};

static struct modldrv modldrv = {
        &mod_driverops,
        "Domain Services PRI Driver",
        &ds_pri_dev_ops
};

static struct modlinkage modlinkage = {
        MODREV_1,
        (void *)&modldrv,
        NULL
};

static boolean_t hsvc_pboot_available = B_FALSE;
static hsvc_info_t pboot_hsvc = {
        HSVC_REV_1, NULL, HSVC_GROUP_PBOOT, 1, 0, NULL
};

int
_init(void)
{
        int retval;
        uint64_t        hsvc_pboot_minor;
        uint64_t        status;

        status = hsvc_register(&pboot_hsvc, &hsvc_pboot_minor);
        if (status == H_EOK) {
                hsvc_pboot_available = B_TRUE;
        } else {
                DS_PRI_DBG("hypervisor services not negotiated "
                    "for group number: 0x%lx errorno: 0x%lx\n",
                    pboot_hsvc.hsvc_group, status);
        }

        retval = ddi_soft_state_init(&ds_pri_statep,
            sizeof (ds_pri_state_t), 0);
        if (retval != 0)
                return (retval);

        retval = mod_install(&modlinkage);
        if (retval != 0) {
                ddi_soft_state_fini(&ds_pri_statep);
                return (retval);
        }

        return (retval);
}


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


int
_fini(void)
{
        int retval;

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

        ddi_soft_state_fini(&ds_pri_statep);

        if (hsvc_pboot_available)
                (void) hsvc_unregister(&pboot_hsvc);

        return (retval);
}


/*ARGSUSED*/
static int
ds_pri_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
{
        ds_pri_state_t *sp;
        int retval = DDI_FAILURE;

        ASSERT(resultp != NULL);

        switch (cmd) {
        case DDI_INFO_DEVT2DEVINFO:
                sp = ddi_get_soft_state(ds_pri_statep, getminor((dev_t)arg));
                if (sp != NULL) {
                        *resultp = sp->dip;
                        retval = DDI_SUCCESS;
                } else
                        *resultp = NULL;
                break;

        case DDI_INFO_DEVT2INSTANCE:
                *resultp = (void *)(uintptr_t)getminor((dev_t)arg);
                retval = DDI_SUCCESS;
                break;

        default:
                break;
        }

        return (retval);
}


static int
ds_pri_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        int instance;
        ds_pri_state_t *sp;
        int rv;
        uint64_t status;

        switch (cmd) {
        case DDI_ATTACH:
                break;

        case DDI_RESUME:
                return (DDI_SUCCESS);

        default:
                return (DDI_FAILURE);
        }

        instance = ddi_get_instance(dip);

        if (ddi_soft_state_zalloc(ds_pri_statep, instance) !=
            DDI_SUCCESS) {
                cmn_err(CE_WARN, "%s@%d: Unable to allocate state",
                    DS_PRI_NAME, instance);
                return (DDI_FAILURE);
        }
        sp = ddi_get_soft_state(ds_pri_statep, instance);

        mutex_init(&sp->lock, NULL, MUTEX_DEFAULT, NULL);
        cv_init(&sp->cv, NULL, CV_DEFAULT, NULL);

        if (ddi_create_minor_node(dip, DS_PRI_NAME, S_IFCHR, instance,
            DDI_PSEUDO, 0) != DDI_SUCCESS) {
                cmn_err(CE_WARN, "%s@%d: Unable to create minor node",
                    DS_PRI_NAME, instance);
                goto fail;
        }

        if (ds_pri_ops.cb_arg != NULL)
                goto fail;
        ds_pri_ops.cb_arg = dip;

        sp->state = DS_PRI_NO_SERVICE;

        /* Until the service registers the handle is invalid */
        sp->ds_pri_handle = DS_INVALID_HDL;

        sp->ds_pri = NULL;
        sp->ds_pri_len = 0;
        sp->req_id = 0;
        sp->num_opens = 0;

        /*
         * See if we can get the static hv pri data. Static pri data
         * is only available for privileged domains.
         */
        if (hsvc_pboot_available) {
                if ((status = ds_get_hv_pri(sp)) != 0) {
                        cmn_err(CE_NOTE, "ds_get_hv_pri failed: 0x%lx", status);
                }
        }

        if ((rv = ds_cap_init(&ds_pri_cap, &ds_pri_ops)) != 0) {
                cmn_err(CE_NOTE, "ds_cap_init failed: %d", rv);
                goto fail;
        }

        ddi_report_dev(dip);

        return (DDI_SUCCESS);

fail:
        if (sp->ds_pri)
                kmem_free(sp->ds_pri, sp->ds_pri_len);
        ddi_remove_minor_node(dip, NULL);
        cv_destroy(&sp->cv);
        mutex_destroy(&sp->lock);
        ddi_soft_state_free(ds_pri_statep, instance);
        return (DDI_FAILURE);

}


/*ARGSUSED*/
static int
ds_pri_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        ds_pri_state_t *sp;
        int instance;
        int rv;

        instance = ddi_get_instance(dip);
        sp = ddi_get_soft_state(ds_pri_statep, instance);

        switch (cmd) {
        case DDI_DETACH:
                break;

        case DDI_SUSPEND:
                return (DDI_SUCCESS);

        default:
                return (DDI_FAILURE);
        }

        /* This really shouldn't fail - but check anyway */
        if ((rv = ds_cap_fini(&ds_pri_cap)) != 0) {
                cmn_err(CE_WARN, "ds_cap_fini failed: %d", rv);
        }

        if (sp != NULL && sp->ds_pri_len != 0)
                kmem_free(sp->ds_pri, sp->ds_pri_len);

        ds_pri_ops.cb_arg = NULL;

        ddi_remove_minor_node(dip, NULL);
        cv_destroy(&sp->cv);
        mutex_destroy(&sp->lock);
        ddi_soft_state_free(ds_pri_statep, instance);

        return (DDI_SUCCESS);
}


/*ARGSUSED*/
static int
ds_pri_open(dev_t *devp, int flag, int otyp, cred_t *credp)
{
        ds_pri_state_t *sp;
        int instance;

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

        instance = getminor(*devp);
        sp = ddi_get_soft_state(ds_pri_statep, instance);
        if (sp == NULL)
                return (ENXIO);

        mutex_enter(&sp->lock);

        /*
         * Proceed if we have PRI data (possibly obtained from
         * static HV PRI or last pushed DS PRI data update).
         * If no PRI data and we have no DS PRI service then this
         * means that PRI DS has never called the registration callback.
         * A while loop is necessary as we might have been woken up
         * prematurely, e.g., due to a debugger or "pstack" etc.
         * Wait here and the callback will signal us when it has completed
         * its work.
         */
        if (!(sp->state & DS_PRI_HAS_PRI)) {
                while (!(sp->state & DS_PRI_HAS_SERVICE)) {
                        if (cv_wait_sig(&sp->cv, &sp->lock) == 0) {
                                mutex_exit(&sp->lock);
                                return (EINTR);
                        }
                }
        }

        sp->num_opens++;
        mutex_exit(&sp->lock);

        DS_PRI_DBG("ds_pri_open: state = 0x%x\n", sp->state);

        return (0);
}


/*ARGSUSED*/
static int
ds_pri_close(dev_t dev, int flag, int otyp, cred_t *credp)
{
        int instance;
        ds_pri_state_t *sp;

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

        DS_PRI_DBG("ds_pri_close\n");

        instance = getminor(dev);
        if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
                return (ENXIO);

        mutex_enter(&sp->lock);
        if (!(sp->state & DS_PRI_HAS_SERVICE)) {
                mutex_exit(&sp->lock);
                return (0);
        }

        if (--sp->num_opens > 0) {
                mutex_exit(&sp->lock);
                return (0);
        }

        sp->state &= ~DS_PRI_REQUESTED;
        mutex_exit(&sp->lock);
        return (0);
}


/*ARGSUSED*/
static int
ds_pri_read(dev_t dev, struct uio *uiop, cred_t *credp)
{
        ds_pri_state_t *sp;
        int instance;
        size_t len;
        int retval;
        caddr_t tmpbufp;
        offset_t off = uiop->uio_offset;

        instance = getminor(dev);
        if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
                return (ENXIO);

        len = uiop->uio_resid;

        if (len == 0)
                return (0);

        mutex_enter(&sp->lock);

        DS_PRI_DBG("ds_pri_read: state = 0x%x\n", sp->state);

        /* block or bail if there is no current PRI */
        if (!(sp->state & DS_PRI_HAS_PRI)) {
                DS_PRI_DBG("ds_pri_read: no PRI held\n");

                if (uiop->uio_fmode & (FNDELAY | FNONBLOCK)) {
                        mutex_exit(&sp->lock);
                        return (EAGAIN);
                }

                while (!(sp->state & DS_PRI_HAS_PRI)) {
                        DS_PRI_DBG("ds_pri_read: state = 0x%x\n", sp->state);
                        request_pri(sp);
                        if (cv_wait_sig(&sp->cv, &sp->lock) == 0) {
                                mutex_exit(&sp->lock);
                                return (EINTR);
                        }
                }
        }

        if (len > sp->ds_pri_len)
                len = sp->ds_pri_len;

        if (len == 0) {
                mutex_exit(&sp->lock);
                return (0);
        }

        /*
         * We're supposed to move the data out to userland, but
         * that can suspend because of page faults etc., and meanwhile
         * other parts of this driver want to update the PRI buffer ...
         * we could hold the data buffer locked with a flag etc.,
         * but that's still a lock ... a simpler mechanism - if not quite
         * as performance efficient is to simply clone here the part of
         * the buffer we care about and then the original can be released
         * for further updates while the uiomove continues.
         */

        tmpbufp = kmem_alloc(len, KM_SLEEP);
        bcopy(((caddr_t)sp->ds_pri), tmpbufp, len);
        mutex_exit(&sp->lock);

        retval = uiomove(tmpbufp, len, UIO_READ, uiop);

        kmem_free(tmpbufp, len);

        /*
         * restore uio_offset after uiomove since the driver
         * does not support the concept of position.
         */
        uiop->uio_offset = off;

        return (retval);
}


/*ARGSUSED*/
static int
ds_pri_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
        ds_pri_state_t *sp;
        int instance;

        instance = getminor(dev);
        if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
                return (ENXIO);

        switch (cmd) {
        case DSPRI_GETINFO: {
                struct dspri_info info;

                if (!(mode & FREAD))
                        return (EACCES);

                /*
                 * We are not guaranteed that ddi_copyout(9F) will read
                 * atomically anything larger than a byte.  Therefore we
                 * must duplicate the size before copying it out to the user.
                 */
                mutex_enter(&sp->lock);

loop:;
                if (sp->state & DS_PRI_HAS_PRI) {
                        /* If we have a PRI simply return the info */
                        info.size = sp->ds_pri_len;
                        info.token = sp->gencount;
                } else
                if (!(sp->state & DS_PRI_HAS_SERVICE)) {
                        /* If we have no service return a nil response */
                        info.size = 0;
                        info.token = 0;
                } else {
                        request_pri(sp);
                        /* wait for something & check again */
                        if (cv_wait_sig(&sp->cv, &sp->lock) == 0) {
                                mutex_exit(&sp->lock);
                                return (EINTR);
                        }
                        goto loop;
                }
                DS_PRI_DBG("ds_pri_ioctl: DSPRI_GETINFO sz=0x%lx tok=0x%lx\n",
                    info.size, info.token);
                mutex_exit(&sp->lock);

                if (ddi_copyout(&info, (void *)arg, sizeof (info), mode) != 0)
                        return (EFAULT);
                break;
        }

        case DSPRI_WAIT: {
                uint64_t gencount;

                if (ddi_copyin((void *)arg, &gencount, sizeof (gencount),
                    mode) != 0)
                        return (EFAULT);

                mutex_enter(&sp->lock);

                DS_PRI_DBG("ds_pri_ioctl: DSPRI_WAIT gen=0x%lx sp->gen=0x%lx\n",
                    gencount, sp->gencount);

                while ((sp->state & DS_PRI_HAS_PRI) == 0 ||
                    gencount == sp->gencount) {
                        if ((sp->state & DS_PRI_HAS_PRI) == 0)
                                request_pri(sp);
                        if (cv_wait_sig(&sp->cv, &sp->lock) == 0) {
                                mutex_exit(&sp->lock);
                                return (EINTR);
                        }
                }
                mutex_exit(&sp->lock);
                break;
        }

        default:
                return (ENOTTY);
        }
        return (0);
}


        /* assumes sp->lock is held when called */
static void
request_pri(ds_pri_state_t *sp)
{
        ds_pri_msg_t reqmsg;

        ASSERT(MUTEX_HELD(&sp->lock));

        /* If a request is already pending we're done */
        if (!(sp->state & DS_PRI_HAS_SERVICE))
                return;
        if (sp->state & DS_PRI_REQUESTED)
                return;

        /* If we have an old PRI - remove it */
        if (sp->state & DS_PRI_HAS_PRI) {
                ASSERT(sp->ds_pri_len != 0);
                ASSERT(sp->ds_pri != NULL);

                /* remove the old data if we have an outstanding request */
                kmem_free(sp->ds_pri, sp->ds_pri_len);
                sp->ds_pri_len = 0;
                sp->ds_pri = NULL;
                sp->state &= ~DS_PRI_HAS_PRI;
        } else {
                ASSERT(sp->ds_pri == NULL);
                ASSERT(sp->ds_pri_len == 0);
        }

        reqmsg.hdr.seq_num = ++(sp->req_id);
        reqmsg.hdr.type = DS_PRI_REQUEST;

        DS_PRI_DBG("request_pri: request id 0x%lx\n", sp->req_id);

                /*
                 * Request consists of header only.
                 * We don't care about fail status for ds_send;
                 * if it does fail we will get an unregister callback
                 * from the DS framework and we handle the state change
                 * there.
                 */
        (void) ds_cap_send(sp->ds_pri_handle, &reqmsg, sizeof (reqmsg.hdr));

        sp->state |= DS_PRI_REQUESTED;
        sp->last_req_id = sp->req_id;
}

/*
 * DS Callbacks
 */
/*ARGSUSED*/
static void
ds_pri_reg_handler(ds_cb_arg_t arg, ds_ver_t *ver, ds_svc_hdl_t hdl)
{
        dev_info_t *dip = arg;
        ds_pri_state_t *sp;
        int instance;

        instance = ddi_get_instance(dip);
        if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
                return;

        DS_PRI_DBG("ds_pri_reg_handler: registering handle 0x%lx for version "
            "0x%x:0x%x\n", (uint64_t)hdl, ver->major, ver->minor);

        /* When the domain service comes up automatically update the state */
        mutex_enter(&sp->lock);

        ASSERT(sp->ds_pri_handle == DS_INVALID_HDL);
        sp->ds_pri_handle = hdl;

        ASSERT(!(sp->state & DS_PRI_HAS_SERVICE));
        sp->state |= DS_PRI_HAS_SERVICE;

        /*
         * Cannot request a PRI here, because the reg handler cannot
         * do a DS send operation - we take care of this later.
         * Static hv pri data might be available.
         */

        /* Wake up anyone waiting in open() */
        cv_broadcast(&sp->cv);

        mutex_exit(&sp->lock);
}


static void
ds_pri_unreg_handler(ds_cb_arg_t arg)
{
        dev_info_t *dip = arg;
        ds_pri_state_t *sp;
        int instance;

        instance = ddi_get_instance(dip);
        if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
                return;

        DS_PRI_DBG("ds_pri_unreg_handler: un-registering ds_pri service\n");

        mutex_enter(&sp->lock);

        /*
         * Note that if the service goes offline, we don't
         * free up the current PRI data at hand. It is assumed
         * that PRI DS service will only push new update when
         * it comes online. We mark the state to indicate no
         * DS PRI service is available. The current PRI data if
         * available is provided to the consumers.
         */
        sp->ds_pri_handle = DS_INVALID_HDL;
        sp->state &= ~DS_PRI_HAS_SERVICE;

        mutex_exit(&sp->lock);
}


static void
ds_pri_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen)
{
        dev_info_t *dip = arg;
        ds_pri_state_t *sp;
        int instance;
        void *data;
        ds_pri_msg_t    *msgp;
        size_t  pri_size;

        msgp = (ds_pri_msg_t *)buf;

        /* make sure the header is at least valid */
        if (buflen < sizeof (msgp->hdr))
                return;

        DS_PRI_DBG("ds_pri_data_handler: msg buf len 0x%lx : type 0x%lx, "
            "seqn 0x%lx\n", buflen, msgp->hdr.type, msgp->hdr.seq_num);

        instance = ddi_get_instance(dip);
        if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
                return;

        mutex_enter(&sp->lock);

        ASSERT(sp->state & DS_PRI_HAS_SERVICE);

        switch (msgp->hdr.type) {
        case DS_PRI_DATA:       /* in response to a request from us */
                break;
        case DS_PRI_UPDATE:     /* aynch notification */
                        /* our default response to this is to request the PRI */
                /* simply issue a request for the new PRI */
                request_pri(sp);
                goto done;
        default:        /* ignore garbage or unknown message types */
                goto done;
        }

        /*
         * If there is no pending PRI request, then we've received a
         * bogus data message ... so ignore it.
         */

        if (!(sp->state & DS_PRI_REQUESTED)) {
                cmn_err(CE_WARN, "Received DS pri data without request");
                goto done;
        }

        /* response to a request therefore old PRI must be gone */
        ASSERT(!(sp->state & DS_PRI_HAS_PRI));
        ASSERT(sp->ds_pri_len == 0);
        ASSERT(sp->ds_pri == NULL);

        /* response seq_num should match our request seq_num */
        if (msgp->hdr.seq_num != sp->last_req_id) {
                cmn_err(CE_WARN, "Received DS pri data out of sequence with "
                    "request");
                goto done;
        }

        pri_size = buflen - sizeof (msgp->hdr);
        if (pri_size == 0) {
                cmn_err(CE_WARN, "Received DS pri data of size 0");
                goto done;
        }
        data = kmem_alloc(pri_size, KM_SLEEP);
        sp->ds_pri = data;
        sp->ds_pri_len = pri_size;
        bcopy(msgp->data, data, sp->ds_pri_len);
        sp->state &= ~DS_PRI_REQUESTED;
        sp->state |= DS_PRI_HAS_PRI;

        sp->gencount++;
        cv_broadcast(&sp->cv);

done:;
        mutex_exit(&sp->lock);
}

/*
 * Routine to get static PRI data from the Hypervisor.
 * If successful, this PRI data is the last known PRI
 * data generated since the last poweron reset.
 */
static uint64_t
ds_get_hv_pri(ds_pri_state_t *sp)
{
        uint64_t        status;
        uint64_t        pri_size;
        uint64_t        buf_size;
        uint64_t        buf_pa;
        caddr_t         buf_va = NULL;
        caddr_t         pri_data;

        /*
         * Get pri buffer size by calling hcall with buffer size 0.
         */
        pri_size = 0LL;
        status = hv_mach_pri((uint64_t)0, &pri_size);
        if (status == H_ENOTSUPPORTED || status == H_ENOACCESS) {
                /*
                 * hv_mach_pri() is not supported on a guest domain.
                 * Unregister pboot API group to prevent failures.
                 */
                (void) hsvc_unregister(&pboot_hsvc);
                hsvc_pboot_available = B_FALSE;
                DS_PRI_DBG("ds_get_hv_pri: hv_mach_pri service is not "
                    "available. errorno: 0x%lx\n", status);
                return (0);
        } else if (pri_size == 0) {
                return (1);
        } else {
                DS_PRI_DBG("ds_get_hv_pri: hv_mach_pri pri size: 0x%lx\n",
                    pri_size);
        }

        /*
         * contig_mem_alloc requires size to be a power of 2.
         * Increase size to next power of 2 if necessary.
         */
        if (!ISP2(pri_size))
                buf_size = 1 << highbit(pri_size);
        DS_PRI_DBG("ds_get_hv_pri: buf_size = 0x%lx\n", buf_size);

        buf_va = contig_mem_alloc(buf_size);
        if (buf_va == NULL)
                return (1);

        buf_pa = va_to_pa(buf_va);
        DS_PRI_DBG("ds_get_hv_pri: buf_pa 0x%lx\n", buf_pa);
        status = hv_mach_pri(buf_pa, &pri_size);
        DS_PRI_DBG("ds_get_hv_pri: hv_mach_pri status = 0x%lx\n", status);

        if (status == H_EOK) {
                pri_data = kmem_alloc(pri_size, KM_SLEEP);
                sp->ds_pri = pri_data;
                sp->ds_pri_len = pri_size;
                bcopy(buf_va, pri_data, sp->ds_pri_len);
                sp->state |= DS_PRI_HAS_PRI;
                sp->gencount++;
        }

        contig_mem_free(buf_va, buf_size);

        return (status);
}