static int
vmbus_connect(struct vmbus_softc *sc, uint32_t version)
{
struct vmbus_chanmsg_connect *req;
const struct vmbus_message *msg;
struct vmbus_msghc *mh;
int error, done = 0;
mh = vmbus_msghc_get(sc, sizeof(*req));
if (mh == NULL)
return ENXIO;
req = vmbus_msghc_dataptr(mh);
req->chm_hdr.chm_type = VMBUS_CHANMSG_TYPE_CONNECT;
req->chm_ver = version;
req->chm_evtflags = sc->vmbus_evtflags_dma.hv_paddr;
req->chm_mnf1 = sc->vmbus_mnf1_dma.hv_paddr;
req->chm_mnf2 = sc->vmbus_mnf2_dma.hv_paddr;
error = vmbus_msghc_exec(sc, mh);
if (error) {
vmbus_msghc_put(sc, mh);
return error;
}
msg = vmbus_msghc_wait_result(sc, mh);
done = ((const struct vmbus_chanmsg_connect_resp *)
msg->msg_data)->chm_done;
vmbus_msghc_put(sc, mh);
return (done ? 0 : EOPNOTSUPP);
}
/*
* Disconnect the GPA from the target channel
*/
int
vmbus_chan_gpadl_disconnect(struct vmbus_channel *chan, uint32_t gpadl)
{
struct vmbus_softc *sc = chan->ch_vmbus;
struct vmbus_msghc *mh;
struct vmbus_chanmsg_gpadl_disconn *req;
int error;
mh = vmbus_msghc_get(sc, sizeof(*req));
if (mh == NULL) {
device_printf(sc->vmbus_dev,
"can not get msg hypercall for gpa x->chan%u\n",
chan->ch_id);
return EBUSY;
}
req = vmbus_msghc_dataptr(mh);
req->chm_hdr.chm_type = VMBUS_CHANMSG_TYPE_GPADL_DISCONN;
req->chm_chanid = chan->ch_id;
req->chm_gpadl = gpadl;
error = vmbus_msghc_exec(sc, mh);
if (error) {
device_printf(sc->vmbus_dev,
"gpa x->chan%u msg hypercall exec failed: %d\n",
chan->ch_id, error);
vmbus_msghc_put(sc, mh);
return error;
}
vmbus_msghc_wait_result(sc, mh);
/* Discard result; no useful information */
vmbus_msghc_put(sc, mh);
return 0;
}
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;
}
int
vmbus_chan_open(struct vmbus_channel *chan, int txbr_size, int rxbr_size,
const void *udata, int udlen, vmbus_chan_callback_t cb, void *cbarg)
{
struct vmbus_softc *sc = chan->ch_vmbus;
const struct vmbus_chanmsg_chopen_resp *resp;
const struct vmbus_message *msg;
struct vmbus_chanmsg_chopen *req;
struct vmbus_msghc *mh;
uint32_t status;
int error;
uint8_t *br;
if (udlen > VMBUS_CHANMSG_CHOPEN_UDATA_SIZE) {
device_printf(sc->vmbus_dev,
"invalid udata len %d for chan%u\n", udlen, chan->ch_id);
return EINVAL;
}
KASSERT((txbr_size & PAGE_MASK) == 0,
("send bufring size is not multiple page"));
KASSERT((rxbr_size & PAGE_MASK) == 0,
("recv bufring size is not multiple page"));
if (atomic_testandset_int(&chan->ch_stflags,
VMBUS_CHAN_ST_OPENED_SHIFT))
panic("double-open chan%u", chan->ch_id);
chan->ch_cb = cb;
chan->ch_cbarg = cbarg;
vmbus_chan_update_evtflagcnt(sc, chan);
chan->ch_tq = VMBUS_PCPU_GET(chan->ch_vmbus, event_tq, chan->ch_cpuid);
if (chan->ch_flags & VMBUS_CHAN_FLAG_BATCHREAD)
TASK_INIT(&chan->ch_task, 0, vmbus_chan_task, chan);
else
TASK_INIT(&chan->ch_task, 0, vmbus_chan_task_nobatch, chan);
/*
* Allocate the TX+RX bufrings.
* XXX should use ch_dev dtag
*/
br = hyperv_dmamem_alloc(bus_get_dma_tag(sc->vmbus_dev),
PAGE_SIZE, 0, txbr_size + rxbr_size, &chan->ch_bufring_dma,
BUS_DMA_WAITOK | BUS_DMA_ZERO);
if (br == NULL) {
device_printf(sc->vmbus_dev, "bufring allocation failed\n");
error = ENOMEM;
goto failed;
}
chan->ch_bufring = br;
/* TX bufring comes first */
vmbus_txbr_setup(&chan->ch_txbr, br, txbr_size);
/* RX bufring immediately follows TX bufring */
vmbus_rxbr_setup(&chan->ch_rxbr, br + txbr_size, rxbr_size);
/* Create sysctl tree for this channel */
vmbus_chan_sysctl_create(chan);
/*
* Connect the bufrings, both RX and TX, to this channel.
*/
error = vmbus_chan_gpadl_connect(chan, chan->ch_bufring_dma.hv_paddr,
txbr_size + rxbr_size, &chan->ch_bufring_gpadl);
if (error) {
device_printf(sc->vmbus_dev,
"failed to connect bufring GPADL to chan%u\n", chan->ch_id);
goto failed;
}
/*
* Open channel w/ the bufring GPADL on the target CPU.
*/
mh = vmbus_msghc_get(sc, sizeof(*req));
if (mh == NULL) {
device_printf(sc->vmbus_dev,
"can not get msg hypercall for chopen(chan%u)\n",
chan->ch_id);
error = ENXIO;
goto failed;
}
req = vmbus_msghc_dataptr(mh);
req->chm_hdr.chm_type = VMBUS_CHANMSG_TYPE_CHOPEN;
req->chm_chanid = chan->ch_id;
req->chm_openid = chan->ch_id;
req->chm_gpadl = chan->ch_bufring_gpadl;
req->chm_vcpuid = chan->ch_vcpuid;
req->chm_txbr_pgcnt = txbr_size >> PAGE_SHIFT;
if (udlen > 0)
memcpy(req->chm_udata, udata, udlen);
error = vmbus_msghc_exec(sc, mh);
if (error) {
device_printf(sc->vmbus_dev,
"chopen(chan%u) msg hypercall exec failed: %d\n",
chan->ch_id, error);
vmbus_msghc_put(sc, mh);
goto failed;
}
msg = vmbus_msghc_wait_result(sc, mh);
resp = (const struct vmbus_chanmsg_chopen_resp *)msg->msg_data;
status = resp->chm_status;
vmbus_msghc_put(sc, mh);
if (status == 0) {
if (bootverbose) {
device_printf(sc->vmbus_dev, "chan%u opened\n",
chan->ch_id);
}
return 0;
}
device_printf(sc->vmbus_dev, "failed to open chan%u\n", chan->ch_id);
error = ENXIO;
failed:
if (chan->ch_bufring_gpadl) {
vmbus_chan_gpadl_disconnect(chan, chan->ch_bufring_gpadl);
chan->ch_bufring_gpadl = 0;
}
if (chan->ch_bufring != NULL) {
hyperv_dmamem_free(&chan->ch_bufring_dma, chan->ch_bufring);
chan->ch_bufring = NULL;
}
atomic_clear_int(&chan->ch_stflags, VMBUS_CHAN_ST_OPENED);
return error;
}
