Lines Matching refs:chan
133 vmbus_chan_signal_tx(const struct vmbus_channel *chan)
135 atomic_set_long(chan->ch_evtflag, chan->ch_evtflag_mask);
136 if (chan->ch_txflags & VMBUS_CHAN_TXF_HASMNF)
137 atomic_set_int(chan->ch_montrig, chan->ch_montrig_mask);
139 hypercall_signal_event(chan->ch_monprm_dma.hv_paddr);
143 vmbus_chan_ins_prilist(struct vmbus_softc *sc, struct vmbus_channel *chan)
147 if (atomic_testandset_int(&chan->ch_stflags,
150 TAILQ_INSERT_TAIL(&sc->vmbus_prichans, chan, ch_prilink);
154 vmbus_chan_rem_prilist(struct vmbus_softc *sc, struct vmbus_channel *chan)
158 if (atomic_testandclear_int(&chan->ch_stflags,
161 TAILQ_REMOVE(&sc->vmbus_prichans, chan, ch_prilink);
166 struct vmbus_channel *chan)
171 if (atomic_testandset_int(&chan->ch_stflags,
174 TAILQ_INSERT_TAIL(&prichan->ch_subchans, chan, ch_sublink);
182 struct vmbus_channel *chan)
191 if (atomic_testandclear_int(&chan->ch_stflags,
194 TAILQ_REMOVE(&prichan->ch_subchans, chan, ch_sublink);
198 vmbus_chan_ins_list(struct vmbus_softc *sc, struct vmbus_channel *chan)
202 if (atomic_testandset_int(&chan->ch_stflags,
205 TAILQ_INSERT_TAIL(&sc->vmbus_chans, chan, ch_link);
209 vmbus_chan_rem_list(struct vmbus_softc *sc, struct vmbus_channel *chan)
213 if (atomic_testandclear_int(&chan->ch_stflags,
216 TAILQ_REMOVE(&sc->vmbus_chans, chan, ch_link);
222 struct vmbus_channel *chan = arg1;
225 if (chan->ch_txflags & VMBUS_CHAN_TXF_HASMNF)
231 vmbus_chan_sysctl_create(struct vmbus_channel *chan)
244 ctx = &chan->ch_sysctl_ctx;
251 SYSCTL_CHILDREN(device_get_sysctl_tree(chan->ch_dev)),
259 if (VMBUS_CHAN_ISPRIMARY(chan))
260 ch_id = chan->ch_id;
262 ch_id = chan->ch_prichan->ch_id;
269 if (!VMBUS_CHAN_ISPRIMARY(chan)) {
284 snprintf(name, sizeof(name), "%d", chan->ch_subidx);
291 "chanid", CTLFLAG_RD, &chan->ch_id, 0, "channel id");
295 "cpu", CTLFLAG_RD, &chan->ch_cpuid, 0, "owner CPU id");
298 chan, 0, vmbus_chan_sysctl_mnf, "I",
307 vmbus_br_sysctl_create(ctx, br_tree, &chan->ch_rxbr.rxbr, "rx");
311 vmbus_br_sysctl_create(ctx, br_tree, &chan->ch_txbr.txbr, "tx");
316 vmbus_chan_open(struct vmbus_channel *chan, int txbr_size, int rxbr_size,
325 KASSERT(chan->ch_bufring == NULL, ("bufrings are allocated"));
326 chan->ch_bufring = hyperv_dmamem_alloc(bus_get_dma_tag(chan->ch_dev),
327 PAGE_SIZE, 0, txbr_size + rxbr_size, &chan->ch_bufring_dma,
329 if (chan->ch_bufring == NULL) {
330 vmbus_chan_printf(chan, "bufring allocation failed\n");
334 cbr.cbr = chan->ch_bufring;
335 cbr.cbr_paddr = chan->ch_bufring_dma.hv_paddr;
339 error = vmbus_chan_open_br(chan, &cbr, udata, udlen, cb, cbarg);
348 vmbus_chan_printf(chan, "chan%u bufring GPADL "
350 "leak %d bytes memory\n", chan->ch_id,
353 hyperv_dmamem_free(&chan->ch_bufring_dma,
354 chan->ch_bufring);
356 chan->ch_bufring = NULL;
362 vmbus_chan_open_br(struct vmbus_channel *chan, const struct vmbus_chan_br *cbr,
365 struct vmbus_softc *sc = chan->ch_vmbus;
375 vmbus_chan_printf(chan,
376 "invalid udata len %d for chan%u\n", udlen, chan->ch_id);
395 if (atomic_testandset_int(&chan->ch_stflags,
397 panic("double-open chan%u", chan->ch_id);
399 chan->ch_cb = cb;
400 chan->ch_cbarg = cbarg;
402 vmbus_chan_update_evtflagcnt(sc, chan);
404 chan->ch_tq = VMBUS_PCPU_GET(chan->ch_vmbus, event_tq, chan->ch_cpuid);
405 if (chan->ch_flags & VMBUS_CHAN_FLAG_BATCHREAD)
409 TASK_INIT(&chan->ch_task, 0, task_fn, chan);
412 vmbus_txbr_setup(&chan->ch_txbr, br, txbr_size);
414 vmbus_rxbr_setup(&chan->ch_rxbr, br + txbr_size, rxbr_size);
417 vmbus_chan_sysctl_create(chan);
422 error = vmbus_chan_gpadl_connect(chan, cbr->cbr_paddr,
423 txbr_size + rxbr_size, &chan->ch_bufring_gpadl);
425 vmbus_chan_printf(chan,
426 "failed to connect bufring GPADL to chan%u\n", chan->ch_id);
434 vmbus_chan_set_chmap(chan);
441 vmbus_chan_printf(chan,
442 "can not get msg hypercall for chopen(chan%u)\n",
443 chan->ch_id);
450 req->chm_chanid = chan->ch_id;
451 req->chm_openid = chan->ch_id;
452 req->chm_gpadl = chan->ch_bufring_gpadl;
453 req->chm_vcpuid = chan->ch_vcpuid;
460 vmbus_chan_printf(chan,
461 "chopen(chan%u) msg hypercall exec failed: %d\n",
462 chan->ch_id, error);
471 if (vmbus_chan_is_revoked(chan)) {
479 vmbus_chan_printf(chan,
480 "chan%u is revoked, when it is being opened\n",
481 chan->ch_id);
516 vmbus_chan_printf(chan, "chan%u opened\n", chan->ch_id);
520 vmbus_chan_printf(chan, "failed to open chan%u\n", chan->ch_id);
524 sysctl_ctx_free(&chan->ch_sysctl_ctx);
525 vmbus_chan_clear_chmap(chan);
526 if (chan->ch_bufring_gpadl != 0) {
529 error1 = vmbus_chan_gpadl_disconnect(chan,
530 chan->ch_bufring_gpadl);
538 chan->ch_bufring_gpadl = 0;
540 atomic_clear_int(&chan->ch_stflags, VMBUS_CHAN_ST_OPENED);
545 vmbus_chan_gpadl_connect(struct vmbus_channel *chan, bus_addr_t paddr,
548 struct vmbus_softc *sc = chan->ch_vmbus;
576 vmbus_chan_printf(chan, "GPA too large, %d pages\n",
604 vmbus_chan_printf(chan,
605 "can not get msg hypercall for gpadl_conn(chan%u)\n",
606 chan->ch_id);
612 req->chm_chanid = chan->ch_id;
623 vmbus_chan_printf(chan,
624 "gpadl_conn(chan%u) msg hypercall exec failed: %d\n",
625 chan->ch_id, error);
660 vmbus_chan_printf(chan, "gpadl_conn(chan%u) failed: %u\n",
661 chan->ch_id, status);
668 vmbus_chan_printf(chan, "gpadl_conn(chan%u) succeeded\n",
669 chan->ch_id);
675 vmbus_chan_wait_revoke(const struct vmbus_channel *chan, bool can_sleep)
682 if (vmbus_chan_is_revoked(chan))
698 vmbus_chan_gpadl_disconnect(struct vmbus_channel *chan, uint32_t gpadl)
700 struct vmbus_softc *sc = chan->ch_vmbus;
709 vmbus_chan_printf(chan,
710 "can not get msg hypercall for gpadl_disconn(chan%u)\n",
711 chan->ch_id);
717 req->chm_chanid = chan->ch_id;
724 if (vmbus_chan_wait_revoke(chan, true)) {
729 vmbus_chan_printf(chan,
730 "gpadl_disconn(revoked chan%u) msg hypercall "
731 "exec failed: %d\n", chan->ch_id, error);
734 vmbus_chan_printf(chan,
735 "gpadl_disconn(chan%u) msg hypercall exec failed: %d\n",
736 chan->ch_id, error);
748 vmbus_chan_detach(struct vmbus_channel *chan)
752 KASSERT(chan->ch_refs > 0, ("chan%u: invalid refcnt %d",
753 chan->ch_id, chan->ch_refs));
754 refs = atomic_fetchadd_int(&chan->ch_refs, -1);
756 if (VMBUS_CHAN_ISPRIMARY(chan)) {
757 KASSERT(refs == 1, ("chan%u: invalid refcnt %d for prichan",
758 chan->ch_id, refs + 1));
766 vmbus_chan_printf(chan, "chan%u detached\n",
767 chan->ch_id);
769 taskqueue_enqueue(chan->ch_mgmt_tq, &chan->ch_detach_task);
776 struct vmbus_channel *chan = xchan;
778 chan->ch_vmbus->vmbus_chmap[chan->ch_id] = NULL;
782 vmbus_chan_clear_chmap(struct vmbus_channel *chan)
786 TASK_INIT(&chmap_task, 0, vmbus_chan_clrchmap_task, chan);
787 vmbus_chan_run_task(chan, &chmap_task);
791 vmbus_chan_set_chmap(struct vmbus_channel *chan)
794 chan->ch_vmbus->vmbus_chmap[chan->ch_id] = chan;
805 vmbus_chan_poll_cancel(struct vmbus_channel *chan)
809 TASK_INIT(&poll_cancel, 0, vmbus_chan_poll_cancel_task, chan);
810 vmbus_chan_run_task(chan, &poll_cancel);
814 vmbus_chan_close_internal(struct vmbus_channel *chan)
816 struct vmbus_softc *sc = chan->ch_vmbus;
828 old_stflags = chan->ch_stflags;
829 if (atomic_cmpset_int(&chan->ch_stflags, old_stflags,
836 vmbus_chan_printf(chan, "chan%u not opened\n",
837 chan->ch_id);
846 sysctl_ctx_free(&chan->ch_sysctl_ctx);
851 vmbus_chan_poll_cancel(chan);
859 vmbus_chan_clear_chmap(chan);
860 taskqueue_drain(chan->ch_tq, &chan->ch_task);
861 chan->ch_tq = NULL;
868 vmbus_chan_printf(chan,
869 "can not get msg hypercall for chclose(chan%u)\n",
870 chan->ch_id);
877 req->chm_chanid = chan->ch_id;
883 vmbus_chan_printf(chan,
884 "chclose(chan%u) msg hypercall exec failed: %d\n",
885 chan->ch_id, error);
890 vmbus_chan_printf(chan, "chan%u closed\n", chan->ch_id);
896 if (chan->ch_bufring_gpadl != 0) {
899 error1 = vmbus_chan_gpadl_disconnect(chan,
900 chan->ch_bufring_gpadl);
908 vmbus_chan_printf(chan, "chan%u bufring GPADL "
909 "is still connected after close\n", chan->ch_id);
910 chan->ch_bufring = NULL;
917 chan->ch_bufring_gpadl = 0;
923 if (chan->ch_bufring != NULL) {
924 hyperv_dmamem_free(&chan->ch_bufring_dma, chan->ch_bufring);
925 chan->ch_bufring = NULL;
931 vmbus_chan_close_direct(struct vmbus_channel *chan)
936 if (VMBUS_CHAN_ISPRIMARY(chan)) {
943 mtx_lock(&chan->ch_subchan_lock);
944 TAILQ_FOREACH(subchan, &chan->ch_subchans, ch_sublink) {
947 ("chan%u: subchan%u is still opened",
948 chan->ch_id, subchan->ch_subidx));
950 mtx_unlock(&chan->ch_subchan_lock);
954 error = vmbus_chan_close_internal(chan);
955 if (!VMBUS_CHAN_ISPRIMARY(chan)) {
960 vmbus_chan_detach(chan);
967 * been added to 'chan' and all to-be-closed channels
971 vmbus_chan_close(struct vmbus_channel *chan)
975 if (!VMBUS_CHAN_ISPRIMARY(chan)) {
986 subchan_cnt = chan->ch_subchan_cnt;
991 subchan = vmbus_subchan_get(chan, subchan_cnt);
1005 vmbus_chan_close_internal(chan);
1009 vmbus_chan_intr_drain(struct vmbus_channel *chan)
1012 taskqueue_drain(chan->ch_tq, &chan->ch_task);
1016 vmbus_chan_send(struct vmbus_channel *chan, uint16_t type, uint16_t flags,
1028 KASSERT(pad_pktlen <= vmbus_txbr_maxpktsz(&chan->ch_txbr),
1044 error = vmbus_txbr_write(&chan->ch_txbr, iov, 3, &send_evt);
1046 vmbus_chan_signal_tx(chan);
1051 vmbus_chan_send_sglist(struct vmbus_channel *chan,
1063 KASSERT(pad_pktlen <= vmbus_txbr_maxpktsz(&chan->ch_txbr),
1083 error = vmbus_txbr_write(&chan->ch_txbr, iov, 4, &send_evt);
1085 vmbus_chan_signal_tx(chan);
1090 vmbus_chan_send_prplist(struct vmbus_channel *chan,
1104 KASSERT(pad_pktlen <= vmbus_txbr_maxpktsz(&chan->ch_txbr),
1124 error = vmbus_txbr_write(&chan->ch_txbr, iov, 4, &send_evt);
1126 vmbus_chan_signal_tx(chan);
1131 vmbus_chan_recv(struct vmbus_channel *chan, void *data, int *dlen0,
1137 error = vmbus_rxbr_peek(&chan->ch_rxbr, &pkt, sizeof(pkt));
1142 vmbus_chan_printf(chan, "invalid hlen %u\n", pkt.cph_hlen);
1147 vmbus_chan_printf(chan, "invalid hlen %u and tlen %u\n",
1166 error = vmbus_rxbr_read(&chan->ch_rxbr, data, dlen, hlen);
1173 vmbus_chan_recv_pkt(struct vmbus_channel *chan,
1179 error = vmbus_rxbr_peek(&chan->ch_rxbr, pkt, pkt_hlen);
1184 vmbus_chan_printf(chan, "invalid hlen %u\n", pkt->cph_hlen);
1189 vmbus_chan_printf(chan, "invalid hlen %u and tlen %u\n",
1207 error = vmbus_rxbr_read(&chan->ch_rxbr, pkt + 1,
1217 struct vmbus_channel *chan = xchan;
1218 vmbus_chan_callback_t cb = chan->ch_cb;
1219 void *cbarg = chan->ch_cbarg;
1221 KASSERT(chan->ch_poll_intvl == 0,
1222 ("chan%u: interrupted in polling mode", chan->ch_id));
1239 cb(chan, cbarg);
1241 left = vmbus_rxbr_intr_unmask(&chan->ch_rxbr);
1246 vmbus_rxbr_intr_mask(&chan->ch_rxbr);
1253 struct vmbus_channel *chan = xchan;
1255 KASSERT(chan->ch_poll_intvl == 0,
1256 ("chan%u: interrupted in polling mode", chan->ch_id));
1257 chan->ch_cb(chan, chan->ch_cbarg);
1263 struct vmbus_channel *chan = xchan;
1265 KASSERT(chan->ch_poll_intvl != 0,
1266 ("chan%u: polling timeout in interrupt mode", chan->ch_id));
1267 taskqueue_enqueue(chan->ch_tq, &chan->ch_poll_task);
1273 struct vmbus_channel *chan = xchan;
1275 KASSERT(chan->ch_poll_intvl != 0,
1276 ("chan%u: polling in interrupt mode", chan->ch_id));
1277 callout_reset_sbt_curcpu(&chan->ch_poll_timeo, chan->ch_poll_intvl, 0,
1278 vmbus_chan_poll_timeout, chan, chan->ch_poll_flags);
1279 chan->ch_cb(chan, chan->ch_cbarg);
1286 struct vmbus_channel *chan = arg->poll_chan;
1296 if (intvl == chan->ch_poll_intvl) {
1300 chan->ch_poll_intvl = intvl;
1306 chan->ch_poll_flags = poll_flags;
1317 chan->ch_vmbus->vmbus_chmap[chan->ch_id] = NULL;
1319 vmbus_rxbr_intr_mask(&chan->ch_rxbr);
1326 taskqueue_cancel(chan->ch_tq, &chan->ch_task, NULL);
1329 taskqueue_enqueue(chan->ch_tq, &chan->ch_poll_task);
1333 vmbus_chan_poll_cancel_intq(struct vmbus_channel *chan)
1336 if (chan->ch_poll_intvl == 0) {
1345 callout_drain(&chan->ch_poll_timeo);
1355 chan->ch_poll_intvl = 0;
1363 taskqueue_cancel(chan->ch_tq, &chan->ch_poll_task, NULL);
1372 struct vmbus_channel *chan = xchan;
1374 if (!vmbus_chan_poll_cancel_intq(chan)) {
1383 chan->ch_vmbus->vmbus_chmap[chan->ch_id] = chan;
1385 vmbus_rxbr_intr_unmask(&chan->ch_rxbr);
1391 taskqueue_enqueue(chan->ch_tq, &chan->ch_task);
1412 struct vmbus_channel *chan;
1417 chan = sc->vmbus_chmap[chid_base + chid_ofs];
1418 if (__predict_false(chan == NULL)) {
1424 if (chan->ch_flags & VMBUS_CHAN_FLAG_BATCHREAD)
1425 vmbus_rxbr_intr_mask(&chan->ch_rxbr);
1426 taskqueue_enqueue(chan->ch_tq, &chan->ch_task);
1459 const struct vmbus_channel *chan)
1464 flag_cnt = (chan->ch_id / VMBUS_EVTFLAG_LEN) + 1;
1465 flag_cnt_ptr = VMBUS_PCPU_PTR(sc, event_flags_cnt, chan->ch_cpuid);
1475 vmbus_chan_printf(chan,
1476 "chan%u update cpu%d flag_cnt to %d\n",
1477 chan->ch_id, chan->ch_cpuid, flag_cnt);
1487 struct vmbus_channel *chan;
1489 chan = malloc(sizeof(*chan), M_DEVBUF, M_WAITOK | M_ZERO);
1491 chan->ch_monprm = hyperv_dmamem_alloc(bus_get_dma_tag(sc->vmbus_dev),
1493 &chan->ch_monprm_dma, BUS_DMA_WAITOK | BUS_DMA_ZERO);
1494 if (chan->ch_monprm == NULL) {
1496 free(chan, M_DEVBUF);
1500 chan->ch_refs = 1;
1501 chan->ch_vmbus = sc;
1502 mtx_init(&chan->ch_subchan_lock, "vmbus subchan", NULL, MTX_DEF);
1503 sx_init(&chan->ch_orphan_lock, "vmbus chorphan");
1504 TAILQ_INIT(&chan->ch_subchans);
1505 vmbus_rxbr_init(&chan->ch_rxbr);
1506 vmbus_txbr_init(&chan->ch_txbr);
1508 TASK_INIT(&chan->ch_poll_task, 0, vmbus_chan_poll_task, chan);
1509 callout_init(&chan->ch_poll_timeo, 1);
1511 return chan;
1515 vmbus_chan_free(struct vmbus_channel *chan)
1518 KASSERT(TAILQ_EMPTY(&chan->ch_subchans) && chan->ch_subchan_cnt == 0,
1520 KASSERT((chan->ch_stflags &
1525 KASSERT(chan->ch_orphan_xact == NULL,
1527 KASSERT(chan->ch_refs == 0, ("chan%u: invalid refcnt %d",
1528 chan->ch_id, chan->ch_refs));
1529 KASSERT(chan->ch_poll_intvl == 0, ("chan%u: polling is activated",
1530 chan->ch_id));
1532 hyperv_dmamem_free(&chan->ch_monprm_dma, chan->ch_monprm);
1533 mtx_destroy(&chan->ch_subchan_lock);
1534 sx_destroy(&chan->ch_orphan_lock);
1535 vmbus_rxbr_deinit(&chan->ch_rxbr);
1536 vmbus_txbr_deinit(&chan->ch_txbr);
1537 free(chan, M_DEVBUF);
1555 device_printf(sc->vmbus_dev, "invalid chan%u offer\n",
1581 "duplicated primary chan%u\n", newchan->ch_id);
1588 "no primary chan for chan%u\n", newchan->ch_id);
1611 KASSERT(newchan->ch_refs == 1, ("chan%u: invalid refcnt %d",
1635 vmbus_chan_printf(newchan, "chan%u subidx%u offer\n",
1646 vmbus_chan_cpu_set(struct vmbus_channel *chan, int cpu)
1650 if (chan->ch_vmbus->vmbus_version == VMBUS_VERSION_WS2008 ||
1651 chan->ch_vmbus->vmbus_version == VMBUS_VERSION_WIN7) {
1656 chan->ch_cpuid = cpu;
1657 chan->ch_vcpuid = VMBUS_PCPU_GET(chan->ch_vmbus, vcpuid, cpu);
1660 vmbus_chan_printf(chan,
1661 "chan%u assigned to cpu%u [vcpu%u]\n",
1662 chan->ch_id, chan->ch_cpuid, chan->ch_vcpuid);
1667 vmbus_chan_cpu_rr(struct vmbus_channel *chan)
1673 vmbus_chan_cpu_set(chan, cpu);
1677 vmbus_chan_cpu_default(struct vmbus_channel *chan)
1684 vmbus_chan_cpu_set(chan, 0);
1692 struct vmbus_channel *chan;
1698 chan = vmbus_chan_alloc(sc);
1699 if (chan == NULL) {
1700 device_printf(sc->vmbus_dev, "allocate chan%u failed\n",
1705 chan->ch_id = offer->chm_chanid;
1706 chan->ch_subidx = offer->chm_subidx;
1707 chan->ch_guid_type = offer->chm_chtype;
1708 chan->ch_guid_inst = offer->chm_chinst;
1711 chan->ch_flags |= VMBUS_CHAN_FLAG_BATCHREAD;
1713 chan->ch_monprm->mp_connid = VMBUS_CONNID_EVENT;
1715 chan->ch_monprm->mp_connid = offer->chm_connid;
1723 chan->ch_txflags |= VMBUS_CHAN_TXF_HASMNF;
1728 chan->ch_montrig =
1731 chan->ch_montrig_mask =
1738 chan->ch_evtflag =
1739 &sc->vmbus_tx_evtflags[chan->ch_id >> VMBUS_EVTFLAG_SHIFT];
1740 chan->ch_evtflag_mask = 1UL << (chan->ch_id & VMBUS_EVTFLAG_MASK);
1745 if (VMBUS_CHAN_ISPRIMARY(chan)) {
1746 chan->ch_mgmt_tq = sc->vmbus_devtq;
1750 chan->ch_mgmt_tq = sc->vmbus_subchtq;
1754 TASK_INIT(&chan->ch_attach_task, 0, attach_fn, chan);
1755 TASK_INIT(&chan->ch_detach_task, 0, detach_fn, chan);
1757 error = vmbus_chan_add(chan);
1759 device_printf(sc->vmbus_dev, "add chan%u failed: %d\n",
1760 chan->ch_id, error);
1761 atomic_subtract_int(&chan->ch_refs, 1);
1762 vmbus_chan_free(chan);
1765 taskqueue_enqueue(chan->ch_mgmt_tq, &chan->ch_attach_task);
1773 struct vmbus_channel *chan;
1777 device_printf(sc->vmbus_dev, "invalid revoked chan%u\n",
1786 TAILQ_FOREACH(chan, &sc->vmbus_chans, ch_link) {
1787 if (chan->ch_id == note->chm_chanid)
1790 if (chan == NULL) {
1792 device_printf(sc->vmbus_dev, "chan%u is not offered\n",
1796 vmbus_chan_rem_list(sc, chan);
1799 if (VMBUS_CHAN_ISPRIMARY(chan)) {
1808 vmbus_chan_rem_prilist(sc, chan);
1818 if (atomic_testandset_int(&chan->ch_stflags,
1822 sx_xlock(&chan->ch_orphan_lock);
1823 if (chan->ch_orphan_xact != NULL)
1824 vmbus_xact_ctx_orphan(chan->ch_orphan_xact);
1825 sx_xunlock(&chan->ch_orphan_lock);
1828 vmbus_chan_printf(chan, "chan%u revoked\n", note->chm_chanid);
1829 vmbus_chan_detach(chan);
1833 vmbus_chan_release(struct vmbus_channel *chan)
1835 struct vmbus_softc *sc = chan->ch_vmbus;
1842 vmbus_chan_printf(chan,
1843 "can not get msg hypercall for chfree(chan%u)\n",
1844 chan->ch_id);
1850 req->chm_chanid = chan->ch_id;
1856 vmbus_chan_printf(chan,
1857 "chfree(chan%u) msg hypercall exec failed: %d\n",
1858 chan->ch_id, error);
1861 vmbus_chan_printf(chan, "chan%u freed\n", chan->ch_id);
1869 struct vmbus_channel *chan = xchan;
1871 KASSERT(VMBUS_CHAN_ISPRIMARY(chan),
1872 ("chan%u is not primary channel", chan->ch_id));
1875 vmbus_delete_child(chan);
1878 vmbus_chan_release(chan);
1881 vmbus_chan_free(chan);
1887 struct vmbus_channel *chan = xchan;
1888 struct vmbus_channel *pri_chan = chan->ch_prichan;
1890 KASSERT(!VMBUS_CHAN_ISPRIMARY(chan),
1891 ("chan%u is primary channel", chan->ch_id));
1894 vmbus_chan_release(chan);
1898 vmbus_chan_rem_sublist(pri_chan, chan);
1904 vmbus_chan_free(chan);
1933 struct vmbus_channel *chan;
1936 TAILQ_FOREACH(chan, &sc->vmbus_chans, ch_link) {
1937 if (VMBUS_CHAN_ISPRIMARY(chan))
1940 if (chan == NULL) {
1945 vmbus_chan_rem_list(sc, chan);
1949 vmbus_chan_rem_prilist(sc, chan);
1952 taskqueue_enqueue(chan->ch_mgmt_tq, &chan->ch_detach_task);
1959 struct vmbus_channel **ret, *chan;
1973 TAILQ_FOREACH(chan, &pri_chan->ch_subchans, ch_sublink) {
1974 /* TODO: refcnt chan */
1975 ret[i] = chan;
2021 vmbus_chan_set_readbatch(struct vmbus_channel *chan, bool on)
2024 chan->ch_flags &= ~VMBUS_CHAN_FLAG_BATCHREAD;
2026 chan->ch_flags |= VMBUS_CHAN_FLAG_BATCHREAD;
2030 vmbus_chan_id(const struct vmbus_channel *chan)
2032 return chan->ch_id;
2036 vmbus_chan_subidx(const struct vmbus_channel *chan)
2038 return chan->ch_subidx;
2042 vmbus_chan_is_primary(const struct vmbus_channel *chan)
2044 if (VMBUS_CHAN_ISPRIMARY(chan))
2051 vmbus_chan_guid_inst(const struct vmbus_channel *chan)
2053 return &chan->ch_guid_inst;
2070 vmbus_chan_tx_empty(const struct vmbus_channel *chan)
2073 return (vmbus_txbr_empty(&chan->ch_txbr));
2077 vmbus_chan_rx_empty(const struct vmbus_channel *chan)
2080 return (vmbus_rxbr_empty(&chan->ch_rxbr));
2084 vmbus_chan_printf(const struct vmbus_channel *chan, const char *fmt, ...)
2090 if (chan->ch_dev == NULL || !device_is_alive(chan->ch_dev))
2091 dev = chan->ch_vmbus->vmbus_dev;
2093 dev = chan->ch_dev;
2104 vmbus_chan_run_task(struct vmbus_channel *chan, struct task *task)
2107 taskqueue_enqueue(chan->ch_tq, task);
2108 taskqueue_drain(chan->ch_tq, task);
2112 vmbus_chan_mgmt_tq(const struct vmbus_channel *chan)
2115 return (chan->ch_mgmt_tq);
2119 vmbus_chan_is_revoked(const struct vmbus_channel *chan)
2122 if (chan->ch_stflags & VMBUS_CHAN_ST_REVOKED)
2128 vmbus_chan_set_orphan(struct vmbus_channel *chan, struct vmbus_xact_ctx *xact)
2131 sx_xlock(&chan->ch_orphan_lock);
2132 chan->ch_orphan_xact = xact;
2133 sx_xunlock(&chan->ch_orphan_lock);
2137 vmbus_chan_unset_orphan(struct vmbus_channel *chan)
2140 sx_xlock(&chan->ch_orphan_lock);
2141 chan->ch_orphan_xact = NULL;
2142 sx_xunlock(&chan->ch_orphan_lock);
2146 vmbus_chan_xact_wait(const struct vmbus_channel *chan,
2155 if (vmbus_chan_is_revoked(chan)) {
2169 while (!vmbus_chan_rx_empty(chan)) {
2180 vmbus_chan_poll_enable(struct vmbus_channel *chan, u_int pollhz)
2185 KASSERT(chan->ch_flags & VMBUS_CHAN_FLAG_BATCHREAD,
2186 ("enable polling on non-batch chan%u", chan->ch_id));
2190 arg.poll_chan = chan;
2193 vmbus_chan_run_task(chan, &poll_cfg);
2197 vmbus_chan_poll_disable(struct vmbus_channel *chan)
2201 KASSERT(chan->ch_flags & VMBUS_CHAN_FLAG_BATCHREAD,
2202 ("disable polling on non-batch chan%u", chan->ch_id));
2204 TASK_INIT(&poll_dis, 0, vmbus_chan_polldis_task, chan);
2205 vmbus_chan_run_task(chan, &poll_dis);