struct vmbus_msghc *
vmbus_msghc_get(struct vmbus_softc *sc, size_t dsize)
{
struct vmbus_msghc *mh;
if (dsize > HYPERCALL_POSTMSGIN_DSIZE_MAX)
panic("invalid data size %zu", dsize);
mh = vmbus_msghc_get1(sc->vmbus_msg_hc, VMBUS_MSGHC_CTXF_DESTROY);
if (mh == NULL)
return NULL;
vmbus_msghc_reset(mh, dsize);
return mh;
}
struct vmbus_msghc *
vmbus_msghc_get(struct vmbus_softc *sc, size_t dsize)
{
struct vmbus_msghc *mh;
struct vmbus_xact *xact;
if (dsize > HYPERCALL_POSTMSGIN_DSIZE_MAX)
panic("invalid data size %zu", dsize);
xact = vmbus_xact_get(sc->vmbus_xc,
dsize + __offsetof(struct hypercall_postmsg_in, hc_data[0]));
if (xact == NULL)
return (NULL);
mh = vmbus_xact_priv(xact, sizeof(*mh));
mh->mh_xact = xact;
vmbus_msghc_reset(mh, dsize);
return (mh);
}
int
vmbus_chan_gpadl_connect(struct vmbus_channel *chan, bus_addr_t paddr,
int size, uint32_t *gpadl0)
{
struct vmbus_softc *sc = chan->ch_vmbus;
struct vmbus_msghc *mh;
struct vmbus_chanmsg_gpadl_conn *req;
const struct vmbus_message *msg;
size_t reqsz;
uint32_t gpadl, status;
int page_count, range_len, i, cnt, error;
uint64_t page_id;
/*
* Preliminary checks.
*/
KASSERT((size & PAGE_MASK) == 0,
("invalid GPA size %d, not multiple page size", size));
page_count = size >> PAGE_SHIFT;
KASSERT((paddr & PAGE_MASK) == 0,
("GPA is not page aligned %jx", (uintmax_t)paddr));
page_id = paddr >> PAGE_SHIFT;
range_len = __offsetof(struct vmbus_gpa_range, gpa_page[page_count]);
/*
* We don't support multiple GPA ranges.
*/
if (range_len > UINT16_MAX) {
device_printf(sc->vmbus_dev, "GPA too large, %d pages\n",
page_count);
return EOPNOTSUPP;
}
/*
* Allocate GPADL id.
*/
gpadl = vmbus_gpadl_alloc(sc);
*gpadl0 = gpadl;
/*
* Connect this GPADL to the target channel.
*
* NOTE:
* Since each message can only hold small set of page
* addresses, several messages may be required to
* complete the connection.
*/
if (page_count > VMBUS_CHANMSG_GPADL_CONN_PGMAX)
cnt = VMBUS_CHANMSG_GPADL_CONN_PGMAX;
else
cnt = page_count;
page_count -= cnt;
reqsz = __offsetof(struct vmbus_chanmsg_gpadl_conn,
chm_range.gpa_page[cnt]);
mh = vmbus_msghc_get(sc, reqsz);
if (mh == NULL) {
device_printf(sc->vmbus_dev,
"can not get msg hypercall for gpadl->chan%u\n",
chan->ch_id);
return EIO;
}
req = vmbus_msghc_dataptr(mh);
req->chm_hdr.chm_type = VMBUS_CHANMSG_TYPE_GPADL_CONN;
req->chm_chanid = chan->ch_id;
req->chm_gpadl = gpadl;
req->chm_range_len = range_len;
req->chm_range_cnt = 1;
req->chm_range.gpa_len = size;
req->chm_range.gpa_ofs = 0;
for (i = 0; i < cnt; ++i)
req->chm_range.gpa_page[i] = page_id++;
error = vmbus_msghc_exec(sc, mh);
if (error) {
device_printf(sc->vmbus_dev,
"gpadl->chan%u msg hypercall exec failed: %d\n",
chan->ch_id, error);
vmbus_msghc_put(sc, mh);
return error;
}
while (page_count > 0) {
struct vmbus_chanmsg_gpadl_subconn *subreq;
if (page_count > VMBUS_CHANMSG_GPADL_SUBCONN_PGMAX)
cnt = VMBUS_CHANMSG_GPADL_SUBCONN_PGMAX;
else
cnt = page_count;
page_count -= cnt;
reqsz = __offsetof(struct vmbus_chanmsg_gpadl_subconn,
chm_gpa_page[cnt]);
vmbus_msghc_reset(mh, reqsz);
subreq = vmbus_msghc_dataptr(mh);
subreq->chm_hdr.chm_type = VMBUS_CHANMSG_TYPE_GPADL_SUBCONN;
subreq->chm_gpadl = gpadl;
for (i = 0; i < cnt; ++i)
subreq->chm_gpa_page[i] = page_id++;
vmbus_msghc_exec_noresult(mh);
}
KASSERT(page_count == 0, ("invalid page count %d", page_count));
msg = vmbus_msghc_wait_result(sc, mh);
status = ((const struct vmbus_chanmsg_gpadl_connresp *)
msg->msg_data)->chm_status;
vmbus_msghc_put(sc, mh);
if (status != 0) {
device_printf(sc->vmbus_dev, "gpadl->chan%u failed: "
"status %u\n", chan->ch_id, status);
return EIO;
} else {
if (bootverbose) {
device_printf(sc->vmbus_dev, "gpadl->chan%u "
"succeeded\n", chan->ch_id);
}
}
return 0;
}
