static int
hn_nvs_disconn_chim(struct hn_softc *sc)
{
int error;
if (sc->hn_flags & HN_FLAG_CHIM_CONNECTED) {
struct hn_nvs_chim_disconn disconn;
/*
* Disconnect chimney sending buffer from NVS.
*/
memset(&disconn, 0, sizeof(disconn));
disconn.nvs_type = HN_NVS_TYPE_CHIM_DISCONN;
disconn.nvs_sig = HN_NVS_CHIM_SIG;
/* NOTE: No response. */
error = hn_nvs_req_send(sc, &disconn, sizeof(disconn));
if (error) {
if_printf(sc->hn_ifp,
"send nvs chim disconn failed: %d\n", error);
return (error);
}
sc->hn_flags &= ~HN_FLAG_CHIM_CONNECTED;
/*
* Wait for the hypervisor to receive this NVS request.
*/
while (!vmbus_chan_tx_empty(sc->hn_prichan))
pause("waittx", 1);
/*
* Linger long enough for NVS to disconnect chimney
* sending buffer.
*/
pause("lingtx", (200 * hz) / 1000);
}
if (sc->hn_chim_gpadl != 0) {
/*
* Disconnect chimney sending buffer from primary channel.
*/
error = vmbus_chan_gpadl_disconnect(sc->hn_prichan,
sc->hn_chim_gpadl);
if (error) {
if_printf(sc->hn_ifp,
"chim gpadl disconn failed: %d\n", error);
return (error);
}
sc->hn_chim_gpadl = 0;
}
if (sc->hn_chim_bmap != NULL) {
free(sc->hn_chim_bmap, M_DEVBUF);
sc->hn_chim_bmap = NULL;
}
return (0);
}
static int
hn_nvs_disconn_rxbuf(struct hn_softc *sc)
{
int error;
if (sc->hn_flags & HN_FLAG_RXBUF_CONNECTED) {
struct hn_nvs_rxbuf_disconn disconn;
/*
* Disconnect RXBUF from NVS.
*/
memset(&disconn, 0, sizeof(disconn));
disconn.nvs_type = HN_NVS_TYPE_RXBUF_DISCONN;
disconn.nvs_sig = HN_NVS_RXBUF_SIG;
/* NOTE: No response. */
error = hn_nvs_req_send(sc, &disconn, sizeof(disconn));
if (error) {
if_printf(sc->hn_ifp,
"send nvs rxbuf disconn failed: %d\n", error);
return (error);
}
sc->hn_flags &= ~HN_FLAG_RXBUF_CONNECTED;
/*
* Wait for the hypervisor to receive this NVS request.
*/
while (!vmbus_chan_tx_empty(sc->hn_prichan))
pause("waittx", 1);
/*
* Linger long enough for NVS to disconnect RXBUF.
*/
pause("lingtx", (200 * hz) / 1000);
}
if (sc->hn_rxbuf_gpadl != 0) {
/*
* Disconnect RXBUF from primary channel.
*/
error = vmbus_chan_gpadl_disconnect(sc->hn_prichan,
sc->hn_rxbuf_gpadl);
if (error) {
if_printf(sc->hn_ifp,
"rxbuf gpadl disconn failed: %d\n", error);
return (error);
}
sc->hn_rxbuf_gpadl = 0;
}
return (0);
}
static void
vmbus_chan_close_internal(struct vmbus_channel *chan)
{
struct vmbus_softc *sc = chan->ch_vmbus;
struct vmbus_msghc *mh;
struct vmbus_chanmsg_chclose *req;
struct taskqueue *tq = chan->ch_tq;
int error;
/* TODO: stringent check */
atomic_clear_int(&chan->ch_stflags, VMBUS_CHAN_ST_OPENED);
/*
* Free this channel's sysctl tree attached to its device's
* sysctl tree.
*/
sysctl_ctx_free(&chan->ch_sysctl_ctx);
/*
* Set ch_tq to NULL to avoid more requests be scheduled.
* XXX pretty broken; need rework.
*/
chan->ch_tq = NULL;
taskqueue_drain(tq, &chan->ch_task);
chan->ch_cb = NULL;
/*
* Close this channel.
*/
mh = vmbus_msghc_get(sc, sizeof(*req));
if (mh == NULL) {
device_printf(sc->vmbus_dev,
"can not get msg hypercall for chclose(chan%u)\n",
chan->ch_id);
return;
}
req = vmbus_msghc_dataptr(mh);
req->chm_hdr.chm_type = VMBUS_CHANMSG_TYPE_CHCLOSE;
req->chm_chanid = chan->ch_id;
error = vmbus_msghc_exec_noresult(mh);
vmbus_msghc_put(sc, mh);
if (error) {
device_printf(sc->vmbus_dev,
"chclose(chan%u) msg hypercall exec failed: %d\n",
chan->ch_id, error);
return;
} else if (bootverbose) {
device_printf(sc->vmbus_dev, "close chan%u\n", chan->ch_id);
}
/*
* Disconnect the TX+RX bufrings from this channel.
*/
if (chan->ch_bufring_gpadl) {
vmbus_chan_gpadl_disconnect(chan, chan->ch_bufring_gpadl);
chan->ch_bufring_gpadl = 0;
}
/*
* Destroy the TX+RX bufrings.
*/
if (chan->ch_bufring != NULL) {
hyperv_dmamem_free(&chan->ch_bufring_dma, chan->ch_bufring);
chan->ch_bufring = NULL;
}
}
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;
}
/*
* Net VSC destroy send buffer
*/
static int
hv_nv_destroy_send_buffer(netvsc_dev *net_dev)
{
nvsp_msg *revoke_pkt;
int ret = 0;
/*
* If we got a section count, it means we received a
* send_rx_buf_complete msg
* (ie sent nvsp_msg_1_type_send_rx_buf msg) therefore,
* we need to send a revoke msg here
*/
if (net_dev->send_section_size) {
/* Send the revoke send buffer */
revoke_pkt = &net_dev->revoke_packet;
memset(revoke_pkt, 0, sizeof(nvsp_msg));
revoke_pkt->hdr.msg_type =
nvsp_msg_1_type_revoke_send_buf;
revoke_pkt->msgs.vers_1_msgs.revoke_send_buf.id =
NETVSC_SEND_BUFFER_ID;
ret = vmbus_chan_send(net_dev->sc->hn_prichan,
VMBUS_CHANPKT_TYPE_INBAND, 0,
revoke_pkt, sizeof(nvsp_msg),
(uint64_t)(uintptr_t)revoke_pkt);
/*
* If we failed here, we might as well return and have a leak
* rather than continue and a bugchk
*/
if (ret != 0) {
return (ret);
}
}
/* Tear down the gpadl on the vsp end */
if (net_dev->send_buf_gpadl_handle) {
ret = vmbus_chan_gpadl_disconnect(net_dev->sc->hn_prichan,
net_dev->send_buf_gpadl_handle);
/*
* If we failed here, we might as well return and have a leak
* rather than continue and a bugchk
*/
if (ret != 0) {
return (ret);
}
net_dev->send_buf_gpadl_handle = 0;
}
if (net_dev->send_buf) {
/* Free up the receive buffer */
hyperv_dmamem_free(&net_dev->txbuf_dma, net_dev->send_buf);
net_dev->send_buf = NULL;
}
if (net_dev->send_section_bitsmap) {
free(net_dev->send_section_bitsmap, M_NETVSC);
}
return (ret);
}
