sys/dev/hyperv/netvsc/if_hn.c

   1 /*-
   2  * Copyright (c) 2010-2012 Citrix Inc.
   3  * Copyright (c) 2009-2012,2016 Microsoft Corp.
   4  * Copyright (c) 2012 NetApp Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice unmodified, this list of conditions, and the following
  12  *    disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /*-
  30  * Copyright (c) 2004-2006 Kip Macy
  31  * All rights reserved.
  32  *
  33  * Redistribution and use in source and binary forms, with or without
  34  * modification, are permitted provided that the following conditions
  35  * are met:
  36  * 1. Redistributions of source code must retain the above copyright
  37  *    notice, this list of conditions and the following disclaimer.
  38  * 2. Redistributions in binary form must reproduce the above copyright
  39  *    notice, this list of conditions and the following disclaimer in the
  40  *    documentation and/or other materials provided with the distribution.
  41  *
  42  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  43  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  44  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  45  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  46  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  47  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  48  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  49  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  50  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  51  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  52  * SUCH DAMAGE.
  53  */
  54
  55 #include <sys/cdefs.h>
  56 __FBSDID("$FreeBSD$");
  57
  58 #include "opt_inet6.h"
  59 #include "opt_inet.h"
  60 #include "opt_hn.h"
  61
  62 #include <sys/param.h>
  63 #include <sys/bus.h>
  64 #include <sys/kernel.h>
  65 #include <sys/limits.h>
  66 #include <sys/malloc.h>
  67 #include <sys/mbuf.h>
  68 #include <sys/module.h>
  69 #include <sys/proc.h>
  70 #include <sys/queue.h>
  71 #include <sys/lock.h>
  72 #include <sys/smp.h>
  73 #include <sys/socket.h>
  74 #include <sys/sockio.h>
  75 #include <sys/sx.h>
  76 #include <sys/sysctl.h>
  77 #include <sys/systm.h>
  78 #include <sys/taskqueue.h>
  79 #include <sys/buf_ring.h>
  80 #include <sys/eventhandler.h>
  81
  82 #include <machine/atomic.h>
  83 #include <machine/in_cksum.h>
  84
  85 #include <net/bpf.h>
  86 #include <net/ethernet.h>
  87 #include <net/if.h>
  88 #include <net/if_arp.h>
  89 #include <net/if_dl.h>
  90 #include <net/if_media.h>
  91 #include <net/if_types.h>
  92 #include <net/if_var.h>
  93 #include <net/if_vlan_var.h>
  94 #include <net/rndis.h>
  95
  96 #include <netinet/in_systm.h>
  97 #include <netinet/in.h>
  98 #include <netinet/ip.h>
  99 #include <netinet/ip6.h>
 100 #include <netinet/tcp.h>
 101 #include <netinet/tcp_lro.h>
 102 #include <netinet/udp.h>
 103
 104 #include <dev/hyperv/include/hyperv.h>
 105 #include <dev/hyperv/include/hyperv_busdma.h>
 106 #include <dev/hyperv/include/vmbus.h>
 107 #include <dev/hyperv/include/vmbus_xact.h>
 108
 109 #include <dev/hyperv/netvsc/ndis.h>
 110 #include <dev/hyperv/netvsc/if_hnreg.h>
 111 #include <dev/hyperv/netvsc/if_hnvar.h>
 112 #include <dev/hyperv/netvsc/hn_nvs.h>
 113 #include <dev/hyperv/netvsc/hn_rndis.h>
 114
 115 #include "vmbus_if.h"
 116
 117 #define HN_IFSTART_SUPPORT
 118
 119 #define HN_RING_CNT_DEF_MAX             8
 120
 121 /* YYY should get it from the underlying channel */
 122 #define HN_TX_DESC_CNT                  512
 123
 124 #define HN_RNDIS_PKT_LEN                                        \
 125         (sizeof(struct rndis_packet_msg) +                      \
 126          HN_RNDIS_PKTINFO_SIZE(HN_NDIS_HASH_VALUE_SIZE) +       \
 127          HN_RNDIS_PKTINFO_SIZE(NDIS_VLAN_INFO_SIZE) +           \
 128          HN_RNDIS_PKTINFO_SIZE(NDIS_LSO2_INFO_SIZE) +           \
 129          HN_RNDIS_PKTINFO_SIZE(NDIS_TXCSUM_INFO_SIZE))
 130 #define HN_RNDIS_PKT_BOUNDARY           PAGE_SIZE
 131 #define HN_RNDIS_PKT_ALIGN              CACHE_LINE_SIZE
 132
 133 #define HN_TX_DATA_BOUNDARY             PAGE_SIZE
 134 #define HN_TX_DATA_MAXSIZE              IP_MAXPACKET
 135 #define HN_TX_DATA_SEGSIZE              PAGE_SIZE
 136 /* -1 for RNDIS packet message */
 137 #define HN_TX_DATA_SEGCNT_MAX           (HN_GPACNT_MAX - 1)
 138
 139 #define HN_DIRECT_TX_SIZE_DEF           128
 140
 141 #define HN_EARLY_TXEOF_THRESH           8
 142
 143 #define HN_PKTBUF_LEN_DEF               (16 * 1024)
 144
 145 #define HN_LROENT_CNT_DEF               128
 146
 147 #define HN_LRO_LENLIM_MULTIRX_DEF       (12 * ETHERMTU)
 148 #define HN_LRO_LENLIM_DEF               (25 * ETHERMTU)
 149 /* YYY 2*MTU is a bit rough, but should be good enough. */
 150 #define HN_LRO_LENLIM_MIN(ifp)          (2 * (ifp)->if_mtu)
 151
 152 #define HN_LRO_ACKCNT_DEF               1
 153
 154 #define HN_LOCK_INIT(sc)                \
 155         sx_init(&(sc)->hn_lock, device_get_nameunit((sc)->hn_dev))
 156 #define HN_LOCK_DESTROY(sc)             sx_destroy(&(sc)->hn_lock)
 157 #define HN_LOCK_ASSERT(sc)              sx_assert(&(sc)->hn_lock, SA_XLOCKED)
 158 #define HN_LOCK(sc)                                     \
 159 do {                                                    \
 160         while (sx_try_xlock(&(sc)->hn_lock) == 0)       \
 161                 DELAY(1000);                            \
 162 } while (0)
 163 #define HN_UNLOCK(sc)                   sx_xunlock(&(sc)->hn_lock)
 164
 165 #define HN_CSUM_IP_MASK                 (CSUM_IP | CSUM_IP_TCP | CSUM_IP_UDP)
 166 #define HN_CSUM_IP6_MASK                (CSUM_IP6_TCP | CSUM_IP6_UDP)
 167 #define HN_CSUM_IP_HWASSIST(sc)         \
 168         ((sc)->hn_tx_ring[0].hn_csum_assist & HN_CSUM_IP_MASK)
 169 #define HN_CSUM_IP6_HWASSIST(sc)        \
 170         ((sc)->hn_tx_ring[0].hn_csum_assist & HN_CSUM_IP6_MASK)
 171
 172 #define HN_PKTSIZE_MIN(align)           \
 173         roundup2(ETHER_MIN_LEN + ETHER_VLAN_ENCAP_LEN - ETHER_CRC_LEN + \
 174             HN_RNDIS_PKT_LEN, (align))
 175 #define HN_PKTSIZE(m, align)            \
 176         roundup2((m)->m_pkthdr.len + HN_RNDIS_PKT_LEN, (align))
 177
 178 #define HN_RING_IDX2CPU(sc, idx)        (((sc)->hn_cpu + (idx)) % mp_ncpus)
 179
 180 struct hn_txdesc {
 181 #ifndef HN_USE_TXDESC_BUFRING
 182         SLIST_ENTRY(hn_txdesc)          link;
 183 #endif
 184         STAILQ_ENTRY(hn_txdesc)         agg_link;
 185
 186         /* Aggregated txdescs, in sending order. */
 187         STAILQ_HEAD(, hn_txdesc)        agg_list;
 188
 189         /* The oldest packet, if transmission aggregation happens. */
 190         struct mbuf                     *m;
 191         struct hn_tx_ring               *txr;
 192         int                             refs;
 193         uint32_t                        flags;  /* HN_TXD_FLAG_ */
 194         struct hn_nvs_sendctx           send_ctx;
 195         uint32_t                        chim_index;
 196         int                             chim_size;
 197
 198         bus_dmamap_t                    data_dmap;
 199
 200         bus_addr_t                      rndis_pkt_paddr;
 201         struct rndis_packet_msg         *rndis_pkt;
 202         bus_dmamap_t                    rndis_pkt_dmap;
 203 };
 204
 205 #define HN_TXD_FLAG_ONLIST              0x0001
 206 #define HN_TXD_FLAG_DMAMAP              0x0002
 207 #define HN_TXD_FLAG_ONAGG               0x0004
 208
 209 struct hn_rxinfo {
 210         uint32_t                        vlan_info;
 211         uint32_t                        csum_info;
 212         uint32_t                        hash_info;
 213         uint32_t                        hash_value;
 214 };
 215
 216 struct hn_update_vf {
 217         struct hn_rx_ring       *rxr;
 218         struct ifnet            *vf;
 219 };
 220
 221 #define HN_RXINFO_VLAN                  0x0001
 222 #define HN_RXINFO_CSUM                  0x0002
 223 #define HN_RXINFO_HASHINF               0x0004
 224 #define HN_RXINFO_HASHVAL               0x0008
 225 #define HN_RXINFO_ALL                   \
 226         (HN_RXINFO_VLAN |               \
 227          HN_RXINFO_CSUM |               \
 228          HN_RXINFO_HASHINF |            \
 229          HN_RXINFO_HASHVAL)
 230
 231 #define HN_NDIS_VLAN_INFO_INVALID       0xffffffff
 232 #define HN_NDIS_RXCSUM_INFO_INVALID     0
 233 #define HN_NDIS_HASH_INFO_INVALID       0
 234
 235 static int                      hn_probe(device_t);
 236 static int                      hn_attach(device_t);
 237 static int                      hn_detach(device_t);
 238 static int                      hn_shutdown(device_t);
 239 static void                     hn_chan_callback(struct vmbus_channel *,
 240                                     void *);
 241
 242 static void                     hn_init(void *);
 243 static int                      hn_ioctl(struct ifnet *, u_long, caddr_t);
 244 #ifdef HN_IFSTART_SUPPORT
 245 static void                     hn_start(struct ifnet *);
 246 #endif
 247 static int                      hn_transmit(struct ifnet *, struct mbuf *);
 248 static void                     hn_xmit_qflush(struct ifnet *);
 249 static int                      hn_ifmedia_upd(struct ifnet *);
 250 static void                     hn_ifmedia_sts(struct ifnet *,
 251                                     struct ifmediareq *);
 252
 253 static int                      hn_rndis_rxinfo(const void *, int,
 254                                     struct hn_rxinfo *);
 255 static void                     hn_rndis_rx_data(struct hn_rx_ring *,
 256                                     const void *, int);
 257 static void                     hn_rndis_rx_status(struct hn_softc *,
 258                                     const void *, int);
 259
 260 static void                     hn_nvs_handle_notify(struct hn_softc *,
 261                                     const struct vmbus_chanpkt_hdr *);
 262 static void                     hn_nvs_handle_comp(struct hn_softc *,
 263                                     struct vmbus_channel *,
 264                                     const struct vmbus_chanpkt_hdr *);
 265 static void                     hn_nvs_handle_rxbuf(struct hn_rx_ring *,
 266                                     struct vmbus_channel *,
 267                                     const struct vmbus_chanpkt_hdr *);
 268 static void                     hn_nvs_ack_rxbuf(struct hn_rx_ring *,
 269                                     struct vmbus_channel *, uint64_t);
 270
 271 #if __FreeBSD_version >= 1100099
 272 static int                      hn_lro_lenlim_sysctl(SYSCTL_HANDLER_ARGS);
 273 static int                      hn_lro_ackcnt_sysctl(SYSCTL_HANDLER_ARGS);
 274 #endif
 275 static int                      hn_trust_hcsum_sysctl(SYSCTL_HANDLER_ARGS);
 276 static int                      hn_chim_size_sysctl(SYSCTL_HANDLER_ARGS);
 277 #if __FreeBSD_version < 1100095
 278 static int                      hn_rx_stat_int_sysctl(SYSCTL_HANDLER_ARGS);
 279 #else
 280 static int                      hn_rx_stat_u64_sysctl(SYSCTL_HANDLER_ARGS);
 281 #endif
 282 static int                      hn_rx_stat_ulong_sysctl(SYSCTL_HANDLER_ARGS);
 283 static int                      hn_tx_stat_ulong_sysctl(SYSCTL_HANDLER_ARGS);
 284 static int                      hn_tx_conf_int_sysctl(SYSCTL_HANDLER_ARGS);
 285 static int                      hn_ndis_version_sysctl(SYSCTL_HANDLER_ARGS);
 286 static int                      hn_caps_sysctl(SYSCTL_HANDLER_ARGS);
 287 static int                      hn_hwassist_sysctl(SYSCTL_HANDLER_ARGS);
 288 static int                      hn_rxfilter_sysctl(SYSCTL_HANDLER_ARGS);
 289 static int                      hn_rss_key_sysctl(SYSCTL_HANDLER_ARGS);
 290 static int                      hn_rss_ind_sysctl(SYSCTL_HANDLER_ARGS);
 291 static int                      hn_rss_hash_sysctl(SYSCTL_HANDLER_ARGS);
 292 static int                      hn_txagg_size_sysctl(SYSCTL_HANDLER_ARGS);
 293 static int                      hn_txagg_pkts_sysctl(SYSCTL_HANDLER_ARGS);
 294 static int                      hn_txagg_pktmax_sysctl(SYSCTL_HANDLER_ARGS);
 295 static int                      hn_txagg_align_sysctl(SYSCTL_HANDLER_ARGS);
 296 static int                      hn_polling_sysctl(SYSCTL_HANDLER_ARGS);
 297 static int                      hn_vf_sysctl(SYSCTL_HANDLER_ARGS);
 298
 299 static void                     hn_stop(struct hn_softc *, bool);
 300 static void                     hn_init_locked(struct hn_softc *);
 301 static int                      hn_chan_attach(struct hn_softc *,
 302                                     struct vmbus_channel *);
 303 static void                     hn_chan_detach(struct hn_softc *,
 304                                     struct vmbus_channel *);
 305 static int                      hn_attach_subchans(struct hn_softc *);
 306 static void                     hn_detach_allchans(struct hn_softc *);
 307 static void                     hn_chan_rollup(struct hn_rx_ring *,
 308                                     struct hn_tx_ring *);
 309 static void                     hn_set_ring_inuse(struct hn_softc *, int);
 310 static int                      hn_synth_attach(struct hn_softc *, int);
 311 static void                     hn_synth_detach(struct hn_softc *);
 312 static int                      hn_synth_alloc_subchans(struct hn_softc *,
 313                                     int *);
 314 static bool                     hn_synth_attachable(const struct hn_softc *);
 315 static void                     hn_suspend(struct hn_softc *);
 316 static void                     hn_suspend_data(struct hn_softc *);
 317 static void                     hn_suspend_mgmt(struct hn_softc *);
 318 static void                     hn_resume(struct hn_softc *);
 319 static void                     hn_resume_data(struct hn_softc *);
 320 static void                     hn_resume_mgmt(struct hn_softc *);
 321 static void                     hn_suspend_mgmt_taskfunc(void *, int);
 322 static void                     hn_chan_drain(struct hn_softc *,
 323                                     struct vmbus_channel *);
 324 static void                     hn_polling(struct hn_softc *, u_int);
 325 static void                     hn_chan_polling(struct vmbus_channel *, u_int);
 326
 327 static void                     hn_update_link_status(struct hn_softc *);
 328 static void                     hn_change_network(struct hn_softc *);
 329 static void                     hn_link_taskfunc(void *, int);
 330 static void                     hn_netchg_init_taskfunc(void *, int);
 331 static void                     hn_netchg_status_taskfunc(void *, int);
 332 static void                     hn_link_status(struct hn_softc *);
 333
 334 static int                      hn_create_rx_data(struct hn_softc *, int);
 335 static void                     hn_destroy_rx_data(struct hn_softc *);
 336 static int                      hn_check_iplen(const struct mbuf *, int);
 337 static int                      hn_set_rxfilter(struct hn_softc *, uint32_t);
 338 static int                      hn_rxfilter_config(struct hn_softc *);
 339 static int                      hn_rss_reconfig(struct hn_softc *);
 340 static void                     hn_rss_ind_fixup(struct hn_softc *);
 341 static int                      hn_rxpkt(struct hn_rx_ring *, const void *,
 342                                     int, const struct hn_rxinfo *);
 343
 344 static int                      hn_tx_ring_create(struct hn_softc *, int);
 345 static void                     hn_tx_ring_destroy(struct hn_tx_ring *);
 346 static int                      hn_create_tx_data(struct hn_softc *, int);
 347 static void                     hn_fixup_tx_data(struct hn_softc *);
 348 static void                     hn_destroy_tx_data(struct hn_softc *);
 349 static void                     hn_txdesc_dmamap_destroy(struct hn_txdesc *);
 350 static void                     hn_txdesc_gc(struct hn_tx_ring *,
 351                                     struct hn_txdesc *);
 352 static int                      hn_encap(struct ifnet *, struct hn_tx_ring *,
 353                                     struct hn_txdesc *, struct mbuf **);
 354 static int                      hn_txpkt(struct ifnet *, struct hn_tx_ring *,
 355                                     struct hn_txdesc *);
 356 static void                     hn_set_chim_size(struct hn_softc *, int);
 357 static void                     hn_set_tso_maxsize(struct hn_softc *, int, int);
 358 static bool                     hn_tx_ring_pending(struct hn_tx_ring *);
 359 static void                     hn_tx_ring_qflush(struct hn_tx_ring *);
 360 static void                     hn_resume_tx(struct hn_softc *, int);
 361 static void                     hn_set_txagg(struct hn_softc *);
 362 static void                     *hn_try_txagg(struct ifnet *,
 363                                     struct hn_tx_ring *, struct hn_txdesc *,
 364                                     int);
 365 static int                      hn_get_txswq_depth(const struct hn_tx_ring *);
 366 static void                     hn_txpkt_done(struct hn_nvs_sendctx *,
 367                                     struct hn_softc *, struct vmbus_channel *,
 368                                     const void *, int);
 369 static int                      hn_txpkt_sglist(struct hn_tx_ring *,
 370                                     struct hn_txdesc *);
 371 static int                      hn_txpkt_chim(struct hn_tx_ring *,
 372                                     struct hn_txdesc *);
 373 static int                      hn_xmit(struct hn_tx_ring *, int);
 374 static void                     hn_xmit_taskfunc(void *, int);
 375 static void                     hn_xmit_txeof(struct hn_tx_ring *);
 376 static void                     hn_xmit_txeof_taskfunc(void *, int);
 377 #ifdef HN_IFSTART_SUPPORT
 378 static int                      hn_start_locked(struct hn_tx_ring *, int);
 379 static void                     hn_start_taskfunc(void *, int);
 380 static void                     hn_start_txeof(struct hn_tx_ring *);
 381 static void                     hn_start_txeof_taskfunc(void *, int);
 382 #endif
 383
 384 SYSCTL_NODE(_hw, OID_AUTO, hn, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
 385     "Hyper-V network interface");
 386
 387 /* Trust tcp segements verification on host side. */
 388 static int                      hn_trust_hosttcp = 1;
 389 SYSCTL_INT(_hw_hn, OID_AUTO, trust_hosttcp, CTLFLAG_RDTUN,
 390     &hn_trust_hosttcp, 0,
 391     "Trust tcp segement verification on host side, "
 392     "when csum info is missing (global setting)");
 393
 394 /* Trust udp datagrams verification on host side. */
 395 static int                      hn_trust_hostudp = 1;
 396 SYSCTL_INT(_hw_hn, OID_AUTO, trust_hostudp, CTLFLAG_RDTUN,
 397     &hn_trust_hostudp, 0,
 398     "Trust udp datagram verification on host side, "
 399     "when csum info is missing (global setting)");
 400
 401 /* Trust ip packets verification on host side. */
 402 static int                      hn_trust_hostip = 1;
 403 SYSCTL_INT(_hw_hn, OID_AUTO, trust_hostip, CTLFLAG_RDTUN,
 404     &hn_trust_hostip, 0,
 405     "Trust ip packet verification on host side, "
 406     "when csum info is missing (global setting)");
 407
 408 /* Limit TSO burst size */
 409 static int                      hn_tso_maxlen = IP_MAXPACKET;
 410 SYSCTL_INT(_hw_hn, OID_AUTO, tso_maxlen, CTLFLAG_RDTUN,
 411     &hn_tso_maxlen, 0, "TSO burst limit");
 412
 413 /* Limit chimney send size */
 414 static int                      hn_tx_chimney_size = 0;
 415 SYSCTL_INT(_hw_hn, OID_AUTO, tx_chimney_size, CTLFLAG_RDTUN,
 416     &hn_tx_chimney_size, 0, "Chimney send packet size limit");
 417
 418 /* Limit the size of packet for direct transmission */
 419 static int                      hn_direct_tx_size = HN_DIRECT_TX_SIZE_DEF;
 420 SYSCTL_INT(_hw_hn, OID_AUTO, direct_tx_size, CTLFLAG_RDTUN,
 421     &hn_direct_tx_size, 0, "Size of the packet for direct transmission");
 422
 423 /* # of LRO entries per RX ring */
 424 #if defined(INET) || defined(INET6)
 425 #if __FreeBSD_version >= 1100095
 426 static int                      hn_lro_entry_count = HN_LROENT_CNT_DEF;
 427 SYSCTL_INT(_hw_hn, OID_AUTO, lro_entry_count, CTLFLAG_RDTUN,
 428     &hn_lro_entry_count, 0, "LRO entry count");
 429 #endif
 430 #endif
 431
 432 static int                      hn_tx_taskq_cnt = 1;
 433 SYSCTL_INT(_hw_hn, OID_AUTO, tx_taskq_cnt, CTLFLAG_RDTUN,
 434     &hn_tx_taskq_cnt, 0, "# of TX taskqueues");
 435
 436 #define HN_TX_TASKQ_M_INDEP     0
 437 #define HN_TX_TASKQ_M_GLOBAL    1
 438 #define HN_TX_TASKQ_M_EVTTQ     2
 439
 440 static int                      hn_tx_taskq_mode = HN_TX_TASKQ_M_INDEP;
 441 SYSCTL_INT(_hw_hn, OID_AUTO, tx_taskq_mode, CTLFLAG_RDTUN,
 442     &hn_tx_taskq_mode, 0, "TX taskqueue modes: "
 443     "0 - independent, 1 - share global tx taskqs, 2 - share event taskqs");
 444
 445 #ifndef HN_USE_TXDESC_BUFRING
 446 static int                      hn_use_txdesc_bufring = 0;
 447 #else
 448 static int                      hn_use_txdesc_bufring = 1;
 449 #endif
 450 SYSCTL_INT(_hw_hn, OID_AUTO, use_txdesc_bufring, CTLFLAG_RD,
 451     &hn_use_txdesc_bufring, 0, "Use buf_ring for TX descriptors");
 452
 453 #ifdef HN_IFSTART_SUPPORT
 454 /* Use ifnet.if_start instead of ifnet.if_transmit */
 455 static int                      hn_use_if_start = 0;
 456 SYSCTL_INT(_hw_hn, OID_AUTO, use_if_start, CTLFLAG_RDTUN,
 457     &hn_use_if_start, 0, "Use if_start TX method");
 458 #endif
 459
 460 /* # of channels to use */
 461 static int                      hn_chan_cnt = 0;
 462 SYSCTL_INT(_hw_hn, OID_AUTO, chan_cnt, CTLFLAG_RDTUN,
 463     &hn_chan_cnt, 0,
 464     "# of channels to use; each channel has one RX ring and one TX ring");
 465
 466 /* # of transmit rings to use */
 467 static int                      hn_tx_ring_cnt = 0;
 468 SYSCTL_INT(_hw_hn, OID_AUTO, tx_ring_cnt, CTLFLAG_RDTUN,
 469     &hn_tx_ring_cnt, 0, "# of TX rings to use");
 470
 471 /* Software TX ring deptch */
 472 static int                      hn_tx_swq_depth = 0;
 473 SYSCTL_INT(_hw_hn, OID_AUTO, tx_swq_depth, CTLFLAG_RDTUN,
 474     &hn_tx_swq_depth, 0, "Depth of IFQ or BUFRING");
 475
 476 /* Enable sorted LRO, and the depth of the per-channel mbuf queue */
 477 #if __FreeBSD_version >= 1100095
 478 static u_int                    hn_lro_mbufq_depth = 0;
 479 SYSCTL_UINT(_hw_hn, OID_AUTO, lro_mbufq_depth, CTLFLAG_RDTUN,
 480     &hn_lro_mbufq_depth, 0, "Depth of LRO mbuf queue");
 481 #endif
 482
 483 /* Packet transmission aggregation size limit */
 484 static int                      hn_tx_agg_size = -1;
 485 SYSCTL_INT(_hw_hn, OID_AUTO, tx_agg_size, CTLFLAG_RDTUN,
 486     &hn_tx_agg_size, 0, "Packet transmission aggregation size limit");
 487
 488 /* Packet transmission aggregation count limit */
 489 static int                      hn_tx_agg_pkts = -1;
 490 SYSCTL_INT(_hw_hn, OID_AUTO, tx_agg_pkts, CTLFLAG_RDTUN,
 491     &hn_tx_agg_pkts, 0, "Packet transmission aggregation packet limit");
 492
 493 static u_int                    hn_cpu_index;   /* next CPU for channel */
 494 static struct taskqueue         **hn_tx_taskque;/* shared TX taskqueues */
 495
 496 static const uint8_t
 497 hn_rss_key_default[NDIS_HASH_KEYSIZE_TOEPLITZ] = {
 498         0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2,
 499         0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0,
 500         0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4,
 501         0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c,
 502         0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa
 503 };
 504
 505 static device_method_t hn_methods[] = {
 506         /* Device interface */
 507         DEVMETHOD(device_probe,         hn_probe),
 508         DEVMETHOD(device_attach,        hn_attach),
 509         DEVMETHOD(device_detach,        hn_detach),
 510         DEVMETHOD(device_shutdown,      hn_shutdown),
 511         DEVMETHOD_END
 512 };
 513
 514 static driver_t hn_driver = {
 515         "hn",
 516         hn_methods,
 517         sizeof(struct hn_softc)
 518 };
 519
 520 static devclass_t hn_devclass;
 521
 522 DRIVER_MODULE(hn, vmbus, hn_driver, hn_devclass, 0, 0);
 523 MODULE_VERSION(hn, 1);
 524 MODULE_DEPEND(hn, vmbus, 1, 1, 1);
 525
 526 #if __FreeBSD_version >= 1100099
 527 static void
 528 hn_set_lro_lenlim(struct hn_softc *sc, int lenlim)
 529 {
 530         int i;
 531
 532         for (i = 0; i < sc->hn_rx_ring_cnt; ++i)
 533                 sc->hn_rx_ring[i].hn_lro.lro_length_lim = lenlim;
 534 }
 535 #endif
 536
 537 static int
 538 hn_txpkt_sglist(struct hn_tx_ring *txr, struct hn_txdesc *txd)
 539 {
 540
 541         KASSERT(txd->chim_index == HN_NVS_CHIM_IDX_INVALID &&
 542             txd->chim_size == 0, ("invalid rndis sglist txd"));
 543         return (hn_nvs_send_rndis_sglist(txr->hn_chan, HN_NVS_RNDIS_MTYPE_DATA,
 544             &txd->send_ctx, txr->hn_gpa, txr->hn_gpa_cnt));
 545 }
 546
 547 static int
 548 hn_txpkt_chim(struct hn_tx_ring *txr, struct hn_txdesc *txd)
 549 {
 550         struct hn_nvs_rndis rndis;
 551
 552         KASSERT(txd->chim_index != HN_NVS_CHIM_IDX_INVALID &&
 553             txd->chim_size > 0, ("invalid rndis chim txd"));
 554
 555         rndis.nvs_type = HN_NVS_TYPE_RNDIS;
 556         rndis.nvs_rndis_mtype = HN_NVS_RNDIS_MTYPE_DATA;
 557         rndis.nvs_chim_idx = txd->chim_index;
 558         rndis.nvs_chim_sz = txd->chim_size;
 559
 560         return (hn_nvs_send(txr->hn_chan, VMBUS_CHANPKT_FLAG_RC,
 561             &rndis, sizeof(rndis), &txd->send_ctx));
 562 }
 563
 564 static __inline uint32_t
 565 hn_chim_alloc(struct hn_softc *sc)
 566 {
 567         int i, bmap_cnt = sc->hn_chim_bmap_cnt;
 568         u_long *bmap = sc->hn_chim_bmap;
 569         uint32_t ret = HN_NVS_CHIM_IDX_INVALID;
 570
 571         for (i = 0; i < bmap_cnt; ++i) {
 572                 int idx;
 573
 574                 idx = ffsl(~bmap[i]);
 575                 if (idx == 0)
 576                         continue;
 577
 578                 --idx; /* ffsl is 1-based */
 579                 KASSERT(i * LONG_BIT + idx < sc->hn_chim_cnt,
 580                     ("invalid i %d and idx %d", i, idx));
 581
 582                 if (atomic_testandset_long(&bmap[i], idx))
 583                         continue;
 584
 585                 ret = i * LONG_BIT + idx;
 586                 break;
 587         }
 588         return (ret);
 589 }
 590
 591 static __inline void
 592 hn_chim_free(struct hn_softc *sc, uint32_t chim_idx)
 593 {
 594         u_long mask;
 595         uint32_t idx;
 596
 597         idx = chim_idx / LONG_BIT;
 598         KASSERT(idx < sc->hn_chim_bmap_cnt,
 599             ("invalid chimney index 0x%x", chim_idx));
 600
 601         mask = 1UL << (chim_idx % LONG_BIT);
 602         KASSERT(sc->hn_chim_bmap[idx] & mask,
 603             ("index bitmap 0x%lx, chimney index %u, "
 604              "bitmap idx %d, bitmask 0x%lx",
 605              sc->hn_chim_bmap[idx], chim_idx, idx, mask));
 606
 607         atomic_clear_long(&sc->hn_chim_bmap[idx], mask);
 608 }
 609
 610 #if defined(INET6) || defined(INET)
 611 /*
 612  * NOTE: If this function failed, the m_head would be freed.
 613  */
 614 static __inline struct mbuf *
 615 hn_tso_fixup(struct mbuf *m_head)
 616 {
 617         struct ether_vlan_header *evl;
 618         struct tcphdr *th;
 619         int ehlen;
 620
 621         KASSERT(M_WRITABLE(m_head), ("TSO mbuf not writable"));
 622
 623 #define PULLUP_HDR(m, len)                              \
 624 do {                                                    \
 625         if (__predict_false((m)->m_len < (len))) {      \
 626                 (m) = m_pullup((m), (len));             \
 627                 if ((m) == NULL)                        \
 628                         return (NULL);                  \
 629         }                                               \
 630 } while (0)
 631
 632         PULLUP_HDR(m_head, sizeof(*evl));
 633         evl = mtod(m_head, struct ether_vlan_header *);
 634         if (evl->evl_encap_proto == ntohs(ETHERTYPE_VLAN))
 635                 ehlen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
 636         else
 637                 ehlen = ETHER_HDR_LEN;
 638
 639 #ifdef INET
 640         if (m_head->m_pkthdr.csum_flags & CSUM_IP_TSO) {
 641                 struct ip *ip;
 642                 int iphlen;
 643
 644                 PULLUP_HDR(m_head, ehlen + sizeof(*ip));
 645                 ip = mtodo(m_head, ehlen);
 646                 iphlen = ip->ip_hl << 2;
 647
 648                 PULLUP_HDR(m_head, ehlen + iphlen + sizeof(*th));
 649                 th = mtodo(m_head, ehlen + iphlen);
 650
 651                 ip->ip_len = 0;
 652                 ip->ip_sum = 0;
 653                 th->th_sum = in_pseudo(ip->ip_src.s_addr,
 654                     ip->ip_dst.s_addr, htons(IPPROTO_TCP));
 655         }
 656 #endif
 657 #if defined(INET6) && defined(INET)
 658         else
 659 #endif
 660 #ifdef INET6
 661         {
 662                 struct ip6_hdr *ip6;
 663
 664                 PULLUP_HDR(m_head, ehlen + sizeof(*ip6));
 665                 ip6 = mtodo(m_head, ehlen);
 666                 if (ip6->ip6_nxt != IPPROTO_TCP) {
 667                         m_freem(m_head);
 668                         return (NULL);
 669                 }
 670
 671                 PULLUP_HDR(m_head, ehlen + sizeof(*ip6) + sizeof(*th));
 672                 th = mtodo(m_head, ehlen + sizeof(*ip6));
 673
 674                 ip6->ip6_plen = 0;
 675                 th->th_sum = in6_cksum_pseudo(ip6, 0, IPPROTO_TCP, 0);
 676         }
 677 #endif
 678         return (m_head);
 679
 680 #undef PULLUP_HDR
 681 }
 682 #endif  /* INET6 || INET */
 683
 684 static int
 685 hn_set_rxfilter(struct hn_softc *sc, uint32_t filter)
 686 {
 687         int error = 0;
 688
 689         HN_LOCK_ASSERT(sc);
 690
 691         if (sc->hn_rx_filter != filter) {
 692                 error = hn_rndis_set_rxfilter(sc, filter);
 693                 if (!error)
 694                         sc->hn_rx_filter = filter;
 695         }
 696         return (error);
 697 }
 698
 699 static int
 700 hn_rxfilter_config(struct hn_softc *sc)
 701 {
 702         struct ifnet *ifp = sc->hn_ifp;
 703         uint32_t filter;
 704
 705         HN_LOCK_ASSERT(sc);
 706
 707         if ((ifp->if_flags & IFF_PROMISC) ||
 708             (sc->hn_flags & HN_FLAG_VF)) {
 709                 filter = NDIS_PACKET_TYPE_PROMISCUOUS;
 710         } else {
 711                 filter = NDIS_PACKET_TYPE_DIRECTED;
 712                 if (ifp->if_flags & IFF_BROADCAST)
 713                         filter |= NDIS_PACKET_TYPE_BROADCAST;
 714                 /* TODO: support multicast list */
 715                 if ((ifp->if_flags & IFF_ALLMULTI) ||
 716                     !TAILQ_EMPTY(&ifp->if_multiaddrs))
 717                         filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
 718         }
 719         return (hn_set_rxfilter(sc, filter));
 720 }
 721
 722 static void
 723 hn_set_txagg(struct hn_softc *sc)
 724 {
 725         uint32_t size, pkts;
 726         int i;
 727
 728         /*
 729          * Setup aggregation size.
 730          */
 731         if (sc->hn_agg_size < 0)
 732                 size = UINT32_MAX;
 733         else
 734                 size = sc->hn_agg_size;
 735
 736         if (sc->hn_rndis_agg_size < size)
 737                 size = sc->hn_rndis_agg_size;
 738
 739         /* NOTE: We only aggregate packets using chimney sending buffers. */
 740         if (size > (uint32_t)sc->hn_chim_szmax)
 741                 size = sc->hn_chim_szmax;
 742
 743         if (size <= 2 * HN_PKTSIZE_MIN(sc->hn_rndis_agg_align)) {
 744                 /* Disable */
 745                 size = 0;
 746                 pkts = 0;
 747                 goto done;
 748         }
 749
 750         /* NOTE: Type of the per TX ring setting is 'int'. */
 751         if (size > INT_MAX)
 752                 size = INT_MAX;
 753
 754         /*
 755          * Setup aggregation packet count.
 756          */
 757         if (sc->hn_agg_pkts < 0)
 758                 pkts = UINT32_MAX;
 759         else
 760                 pkts = sc->hn_agg_pkts;
 761
 762         if (sc->hn_rndis_agg_pkts < pkts)
 763                 pkts = sc->hn_rndis_agg_pkts;
 764
 765         if (pkts <= 1) {
 766                 /* Disable */
 767                 size = 0;
 768                 pkts = 0;
 769                 goto done;
 770         }
 771
 772         /* NOTE: Type of the per TX ring setting is 'short'. */
 773         if (pkts > SHRT_MAX)
 774                 pkts = SHRT_MAX;
 775
 776 done:
 777         /* NOTE: Type of the per TX ring setting is 'short'. */
 778         if (sc->hn_rndis_agg_align > SHRT_MAX) {
 779                 /* Disable */
 780                 size = 0;
 781                 pkts = 0;
 782         }
 783
 784         if (bootverbose) {
 785                 if_printf(sc->hn_ifp, "TX agg size %u, pkts %u, align %u\n",
 786                     size, pkts, sc->hn_rndis_agg_align);
 787         }
 788
 789         for (i = 0; i < sc->hn_tx_ring_cnt; ++i) {
 790                 struct hn_tx_ring *txr = &sc->hn_tx_ring[i];
 791
 792                 mtx_lock(&txr->hn_tx_lock);
 793                 txr->hn_agg_szmax = size;
 794                 txr->hn_agg_pktmax = pkts;
 795                 txr->hn_agg_align = sc->hn_rndis_agg_align;
 796                 mtx_unlock(&txr->hn_tx_lock);
 797         }
 798 }
 799
 800 static int
 801 hn_get_txswq_depth(const struct hn_tx_ring *txr)
 802 {
 803
 804         KASSERT(txr->hn_txdesc_cnt > 0, ("tx ring is not setup yet"));
 805         if (hn_tx_swq_depth < txr->hn_txdesc_cnt)
 806                 return txr->hn_txdesc_cnt;
 807         return hn_tx_swq_depth;
 808 }
 809
 810 static int
 811 hn_rss_reconfig(struct hn_softc *sc)
 812 {
 813         int error;
 814
 815         HN_LOCK_ASSERT(sc);
 816
 817         if ((sc->hn_flags & HN_FLAG_SYNTH_ATTACHED) == 0)
 818                 return (ENXIO);
 819
 820         /*
 821          * Disable RSS first.
 822          *
 823          * NOTE:
 824          * Direct reconfiguration by setting the UNCHG flags does
 825          * _not_ work properly.
 826          */
 827         if (bootverbose)
 828                 if_printf(sc->hn_ifp, "disable RSS\n");
 829         error = hn_rndis_conf_rss(sc, NDIS_RSS_FLAG_DISABLE);
 830         if (error) {
 831                 if_printf(sc->hn_ifp, "RSS disable failed\n");
 832                 return (error);
 833         }
 834
 835         /*
 836          * Reenable the RSS w/ the updated RSS key or indirect
 837          * table.
 838          */
 839         if (bootverbose)
 840                 if_printf(sc->hn_ifp, "reconfig RSS\n");
 841         error = hn_rndis_conf_rss(sc, NDIS_RSS_FLAG_NONE);
 842         if (error) {
 843                 if_printf(sc->hn_ifp, "RSS reconfig failed\n");
 844                 return (error);
 845         }
 846         return (0);
 847 }
 848
 849 static void
 850 hn_rss_ind_fixup(struct hn_softc *sc)
 851 {
 852         struct ndis_rssprm_toeplitz *rss = &sc->hn_rss;
 853         int i, nchan;
 854
 855         nchan = sc->hn_rx_ring_inuse;
 856         KASSERT(nchan > 1, ("invalid # of channels %d", nchan));
 857
 858         /*
 859          * Check indirect table to make sure that all channels in it
 860          * can be used.
 861          */
 862         for (i = 0; i < NDIS_HASH_INDCNT; ++i) {
 863                 if (rss->rss_ind[i] >= nchan) {
 864                         if_printf(sc->hn_ifp,
 865                             "RSS indirect table %d fixup: %u -> %d\n",
 866                             i, rss->rss_ind[i], nchan - 1);
 867                         rss->rss_ind[i] = nchan - 1;
 868                 }
 869         }
 870 }
 871
 872 static int
 873 hn_ifmedia_upd(struct ifnet *ifp __unused)
 874 {
 875
 876         return EOPNOTSUPP;
 877 }
 878
 879 static void
 880 hn_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
 881 {
 882         struct hn_softc *sc = ifp->if_softc;
 883
 884         ifmr->ifm_status = IFM_AVALID;
 885         ifmr->ifm_active = IFM_ETHER;
 886
 887         if ((sc->hn_link_flags & HN_LINK_FLAG_LINKUP) == 0) {
 888                 ifmr->ifm_active |= IFM_NONE;
 889                 return;
 890         }
 891         ifmr->ifm_status |= IFM_ACTIVE;
 892         ifmr->ifm_active |= IFM_10G_T | IFM_FDX;
 893 }
 894
 895 static void
 896 hn_update_vf_task(void *arg, int pending __unused)
 897 {
 898         struct hn_update_vf *uv = arg;
 899
 900         uv->rxr->hn_vf = uv->vf;
 901 }
 902
 903 static void
 904 hn_update_vf(struct hn_softc *sc, struct ifnet *vf)
 905 {
 906         struct hn_rx_ring *rxr;
 907         struct hn_update_vf uv;
 908         struct task task;
 909         int i;
 910
 911         HN_LOCK_ASSERT(sc);
 912
 913         TASK_INIT(&task, 0, hn_update_vf_task, &uv);
 914
 915         for (i = 0; i < sc->hn_rx_ring_cnt; ++i) {
 916                 rxr = &sc->hn_rx_ring[i];
 917
 918                 if (i < sc->hn_rx_ring_inuse) {
 919                         uv.rxr = rxr;
 920                         uv.vf = vf;
 921                         vmbus_chan_run_task(rxr->hn_chan, &task);
 922                 } else {
 923                         rxr->hn_vf = vf;
 924                 }
 925         }
 926 }
 927
 928 static void
 929 hn_set_vf(struct hn_softc *sc, struct ifnet *ifp, bool vf)
 930 {
 931         struct ifnet *hn_ifp;
 932
 933         HN_LOCK(sc);
 934
 935         if (!(sc->hn_flags & HN_FLAG_SYNTH_ATTACHED))
 936                 goto out;
 937
 938         hn_ifp = sc->hn_ifp;
 939
 940         if (ifp == hn_ifp)
 941                 goto out;
 942
 943         if (ifp->if_alloctype != IFT_ETHER)
 944                 goto out;
 945
 946         /* Ignore lagg/vlan interfaces */
 947         if (strcmp(ifp->if_dname, "lagg") == 0 ||
 948             strcmp(ifp->if_dname, "vlan") == 0)
 949                 goto out;
 950
 951         if (bcmp(IF_LLADDR(ifp), IF_LLADDR(hn_ifp), ETHER_ADDR_LEN) != 0)
 952                 goto out;
 953
 954         /* Now we're sure 'ifp' is a real VF device. */
 955         if (vf) {
 956                 if (sc->hn_flags & HN_FLAG_VF)
 957                         goto out;
 958
 959                 sc->hn_flags |= HN_FLAG_VF;
 960                 hn_rxfilter_config(sc);
 961         } else {
 962                 if (!(sc->hn_flags & HN_FLAG_VF))
 963                         goto out;
 964
 965                 sc->hn_flags &= ~HN_FLAG_VF;
 966                 if (sc->hn_ifp->if_drv_flags & IFF_DRV_RUNNING)
 967                         hn_rxfilter_config(sc);
 968                 else
 969                         hn_set_rxfilter(sc, NDIS_PACKET_TYPE_NONE);
 970         }
 971
 972         hn_nvs_set_datapath(sc,
 973             vf ? HN_NVS_DATAPATH_VF : HN_NVS_DATAPATH_SYNTHETIC);
 974
 975         hn_update_vf(sc, vf ? ifp : NULL);
 976
 977         if (vf) {
 978                 hn_suspend_mgmt(sc);
 979                 sc->hn_link_flags &=
 980                     ~(HN_LINK_FLAG_LINKUP | HN_LINK_FLAG_NETCHG);
 981                 if_link_state_change(sc->hn_ifp, LINK_STATE_DOWN);
 982         } else {
 983                 hn_resume_mgmt(sc);
 984         }
 985
 986         devctl_notify("HYPERV_NIC_VF", if_name(hn_ifp),
 987             vf ? "VF_UP" : "VF_DOWN", NULL);
 988
 989         if (bootverbose)
 990                 if_printf(hn_ifp, "Data path is switched %s %s\n",
 991                     vf ? "to" : "from", if_name(ifp));
 992 out:
 993         HN_UNLOCK(sc);
 994 }
 995
 996 static void
 997 hn_ifnet_event(void *arg, struct ifnet *ifp, int event)
 998 {
 999         if (event != IFNET_EVENT_UP && event != IFNET_EVENT_DOWN)
1000                 return;
1001
1002         hn_set_vf(arg, ifp, event == IFNET_EVENT_UP);
1003 }
1004
1005 static void
1006 hn_ifaddr_event(void *arg, struct ifnet *ifp)
1007 {
1008         hn_set_vf(arg, ifp, ifp->if_flags & IFF_UP);
1009 }
1010
1011 /* {F8615163-DF3E-46c5-913F-F2D2F965ED0E} */
1012 static const struct hyperv_guid g_net_vsc_device_type = {
1013         .hv_guid = {0x63, 0x51, 0x61, 0xF8, 0x3E, 0xDF, 0xc5, 0x46,
1014                 0x91, 0x3F, 0xF2, 0xD2, 0xF9, 0x65, 0xED, 0x0E}
1015 };
1016
1017 static int
1018 hn_probe(device_t dev)
1019 {
1020
1021         if (VMBUS_PROBE_GUID(device_get_parent(dev), dev,
1022             &g_net_vsc_device_type) == 0) {
1023                 device_set_desc(dev, "Hyper-V Network Interface");
1024                 return BUS_PROBE_DEFAULT;
1025         }
1026         return ENXIO;
1027 }
1028
1029 static int
1030 hn_attach(device_t dev)
1031 {
1032         struct hn_softc *sc = device_get_softc(dev);
1033         struct sysctl_oid_list *child;
1034         struct sysctl_ctx_list *ctx;
1035         uint8_t eaddr[ETHER_ADDR_LEN];
1036         struct ifnet *ifp = NULL;
1037         int error, ring_cnt, tx_ring_cnt;
1038
1039         sc->hn_dev = dev;
1040         sc->hn_prichan = vmbus_get_channel(dev);
1041         HN_LOCK_INIT(sc);
1042
1043         /*
1044          * Initialize these tunables once.
1045          */
1046         sc->hn_agg_size = hn_tx_agg_size;
1047         sc->hn_agg_pkts = hn_tx_agg_pkts;
1048
1049         /*
1050          * Setup taskqueue for transmission.
1051          */
1052         if (hn_tx_taskq_mode == HN_TX_TASKQ_M_INDEP) {
1053                 int i;
1054
1055                 sc->hn_tx_taskqs =
1056                     malloc(hn_tx_taskq_cnt * sizeof(struct taskqueue *),
1057                     M_DEVBUF, M_WAITOK);
1058                 for (i = 0; i < hn_tx_taskq_cnt; ++i) {
1059                         sc->hn_tx_taskqs[i] = taskqueue_create("hn_tx",
1060                             M_WAITOK, taskqueue_thread_enqueue,
1061                             &sc->hn_tx_taskqs[i]);
1062                         taskqueue_start_threads(&sc->hn_tx_taskqs[i], 1, PI_NET,
1063                             "%s tx%d", device_get_nameunit(dev), i);
1064                 }
1065         } else if (hn_tx_taskq_mode == HN_TX_TASKQ_M_GLOBAL) {
1066                 sc->hn_tx_taskqs = hn_tx_taskque;
1067         }
1068
1069         /*
1070          * Setup taskqueue for mangement tasks, e.g. link status.
1071          */
1072         sc->hn_mgmt_taskq0 = taskqueue_create("hn_mgmt", M_WAITOK,
1073             taskqueue_thread_enqueue, &sc->hn_mgmt_taskq0);
1074         taskqueue_start_threads(&sc->hn_mgmt_taskq0, 1, PI_NET, "%s mgmt",
1075             device_get_nameunit(dev));
1076         TASK_INIT(&sc->hn_link_task, 0, hn_link_taskfunc, sc);
1077         TASK_INIT(&sc->hn_netchg_init, 0, hn_netchg_init_taskfunc, sc);
1078         TIMEOUT_TASK_INIT(sc->hn_mgmt_taskq0, &sc->hn_netchg_status, 0,
1079             hn_netchg_status_taskfunc, sc);
1080
1081         /*
1082          * Allocate ifnet and setup its name earlier, so that if_printf
1083          * can be used by functions, which will be called after
1084          * ether_ifattach().
1085          */
1086         ifp = sc->hn_ifp = sc->arpcom.ac_ifp = if_alloc(IFT_ETHER);
1087         ifp->if_softc = sc;
1088         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
1089
1090         /*
1091          * Initialize ifmedia earlier so that it can be unconditionally
1092          * destroyed, if error happened later on.
1093          */
1094         ifmedia_init(&sc->hn_media, 0, hn_ifmedia_upd, hn_ifmedia_sts);
1095
1096         /*
1097          * Figure out the # of RX rings (ring_cnt) and the # of TX rings
1098          * to use (tx_ring_cnt).
1099          *
1100          * NOTE:
1101          * The # of RX rings to use is same as the # of channels to use.
1102          */
1103         ring_cnt = hn_chan_cnt;
1104         if (ring_cnt <= 0) {
1105                 /* Default */
1106                 ring_cnt = mp_ncpus;
1107                 if (ring_cnt > HN_RING_CNT_DEF_MAX)
1108                         ring_cnt = HN_RING_CNT_DEF_MAX;
1109         } else if (ring_cnt > mp_ncpus) {
1110                 ring_cnt = mp_ncpus;
1111         }
1112
1113         tx_ring_cnt = hn_tx_ring_cnt;
1114         if (tx_ring_cnt <= 0 || tx_ring_cnt > ring_cnt)
1115                 tx_ring_cnt = ring_cnt;
1116 #ifdef HN_IFSTART_SUPPORT
1117         if (hn_use_if_start) {
1118                 /* ifnet.if_start only needs one TX ring. */
1119                 tx_ring_cnt = 1;
1120         }
1121 #endif
1122
1123         /*
1124          * Set the leader CPU for channels.
1125          */
1126         sc->hn_cpu = atomic_fetchadd_int(&hn_cpu_index, ring_cnt) % mp_ncpus;
1127
1128         /*
1129          * Create enough TX/RX rings, even if only limited number of
1130          * channels can be allocated.
1131          */
1132         error = hn_create_tx_data(sc, tx_ring_cnt);
1133         if (error)
1134                 goto failed;
1135         error = hn_create_rx_data(sc, ring_cnt);
1136         if (error)
1137                 goto failed;
1138
1139         /*
1140          * Create transaction context for NVS and RNDIS transactions.
1141          */
1142         sc->hn_xact = vmbus_xact_ctx_create(bus_get_dma_tag(dev),
1143             HN_XACT_REQ_SIZE, HN_XACT_RESP_SIZE, 0);
1144         if (sc->hn_xact == NULL) {
1145                 error = ENXIO;
1146                 goto failed;
1147         }
1148
1149         /*
1150          * Install orphan handler for the revocation of this device's
1151          * primary channel.
1152          *
1153          * NOTE:
1154          * The processing order is critical here:
1155          * Install the orphan handler, _before_ testing whether this
1156          * device's primary channel has been revoked or not.
1157          */
1158         vmbus_chan_set_orphan(sc->hn_prichan, sc->hn_xact);
1159         if (vmbus_chan_is_revoked(sc->hn_prichan)) {
1160                 error = ENXIO;
1161                 goto failed;
1162         }
1163
1164         /*
1165          * Attach the synthetic parts, i.e. NVS and RNDIS.
1166          */
1167         error = hn_synth_attach(sc, ETHERMTU);
1168         if (error)
1169                 goto failed;
1170
1171         error = hn_rndis_get_eaddr(sc, eaddr);
1172         if (error)
1173                 goto failed;
1174
1175 #if __FreeBSD_version >= 1100099
1176         if (sc->hn_rx_ring_inuse > 1) {
1177                 /*
1178                  * Reduce TCP segment aggregation limit for multiple
1179                  * RX rings to increase ACK timeliness.
1180                  */
1181                 hn_set_lro_lenlim(sc, HN_LRO_LENLIM_MULTIRX_DEF);
1182         }
1183 #endif
1184
1185         /*
1186          * Fixup TX stuffs after synthetic parts are attached.
1187          */
1188         hn_fixup_tx_data(sc);
1189
1190         ctx = device_get_sysctl_ctx(dev);
1191         child = SYSCTL_CHILDREN(device_get_sysctl_tree(dev));
1192         SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "nvs_version", CTLFLAG_RD,
1193             &sc->hn_nvs_ver, 0, "NVS version");
1194         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "ndis_version",
1195             CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, sc, 0,
1196             hn_ndis_version_sysctl, "A", "NDIS version");
1197         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "caps",
1198             CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, sc, 0,
1199             hn_caps_sysctl, "A", "capabilities");
1200         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "hwassist",
1201             CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, sc, 0,
1202             hn_hwassist_sysctl, "A", "hwassist");
1203         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rxfilter",
1204             CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, sc, 0,
1205             hn_rxfilter_sysctl, "A", "rxfilter");
1206         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rss_hash",
1207             CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, sc, 0,
1208             hn_rss_hash_sysctl, "A", "RSS hash");
1209         SYSCTL_ADD_INT(ctx, child, OID_AUTO, "rss_ind_size",
1210             CTLFLAG_RD, &sc->hn_rss_ind_size, 0, "RSS indirect entry count");
1211         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rss_key",
1212             CTLTYPE_OPAQUE | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
1213             hn_rss_key_sysctl, "IU", "RSS key");
1214         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rss_ind",
1215             CTLTYPE_OPAQUE | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
1216             hn_rss_ind_sysctl, "IU", "RSS indirect table");
1217         SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "rndis_agg_size",
1218             CTLFLAG_RD, &sc->hn_rndis_agg_size, 0,
1219             "RNDIS offered packet transmission aggregation size limit");
1220         SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "rndis_agg_pkts",
1221             CTLFLAG_RD, &sc->hn_rndis_agg_pkts, 0,
1222             "RNDIS offered packet transmission aggregation count limit");
1223         SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "rndis_agg_align",
1224             CTLFLAG_RD, &sc->hn_rndis_agg_align, 0,
1225             "RNDIS packet transmission aggregation alignment");
1226         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "agg_size",
1227             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
1228             hn_txagg_size_sysctl, "I",
1229             "Packet transmission aggregation size, 0 -- disable, -1 -- auto");
1230         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "agg_pkts",
1231             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
1232             hn_txagg_pkts_sysctl, "I",
1233             "Packet transmission aggregation packets, "
1234             "0 -- disable, -1 -- auto");
1235         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "polling",
1236             CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
1237             hn_polling_sysctl, "I",
1238             "Polling frequency: [100,1000000], 0 disable polling");
1239         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "vf",
1240             CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, sc, 0,
1241             hn_vf_sysctl, "A", "Virtual Function's name");
1242
1243         /*
1244          * Setup the ifmedia, which has been initialized earlier.
1245          */
1246         ifmedia_add(&sc->hn_media, IFM_ETHER | IFM_AUTO, 0, NULL);
1247         ifmedia_set(&sc->hn_media, IFM_ETHER | IFM_AUTO);
1248         /* XXX ifmedia_set really should do this for us */
1249         sc->hn_media.ifm_media = sc->hn_media.ifm_cur->ifm_media;
1250
1251         /*
1252          * Setup the ifnet for this interface.
1253          */
1254
1255 #ifdef __LP64__
1256         ifp->if_baudrate = IF_Gbps(10);
1257 #else
1258         /* if_baudrate is 32bits on 32bit system. */
1259         ifp->if_baudrate = IF_Gbps(1);
1260 #endif
1261         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1262         ifp->if_ioctl = hn_ioctl;
1263         ifp->if_init = hn_init;
1264 #ifdef HN_IFSTART_SUPPORT
1265         if (hn_use_if_start) {
1266                 int qdepth = hn_get_txswq_depth(&sc->hn_tx_ring[0]);
1267
1268                 ifp->if_start = hn_start;
1269                 IFQ_SET_MAXLEN(&ifp->if_snd, qdepth);
1270                 ifp->if_snd.ifq_drv_maxlen = qdepth - 1;
1271                 IFQ_SET_READY(&ifp->if_snd);
1272         } else
1273 #endif
1274         {
1275                 ifp->if_transmit = hn_transmit;
1276                 ifp->if_qflush = hn_xmit_qflush;
1277         }
1278
1279         ifp->if_capabilities |= IFCAP_RXCSUM | IFCAP_LRO;
1280 #ifdef foo
1281         /* We can't diff IPv6 packets from IPv4 packets on RX path. */
1282         ifp->if_capabilities |= IFCAP_RXCSUM_IPV6;
1283 #endif
1284         if (sc->hn_caps & HN_CAP_VLAN) {
1285                 /* XXX not sure about VLAN_MTU. */
1286                 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
1287         }
1288
1289         ifp->if_hwassist = sc->hn_tx_ring[0].hn_csum_assist;
1290         if (ifp->if_hwassist & HN_CSUM_IP_MASK)
1291                 ifp->if_capabilities |= IFCAP_TXCSUM;
1292         if (ifp->if_hwassist & HN_CSUM_IP6_MASK)
1293                 ifp->if_capabilities |= IFCAP_TXCSUM_IPV6;
1294         if (sc->hn_caps & HN_CAP_TSO4) {
1295                 ifp->if_capabilities |= IFCAP_TSO4;
1296                 ifp->if_hwassist |= CSUM_IP_TSO;
1297         }
1298         if (sc->hn_caps & HN_CAP_TSO6) {
1299                 ifp->if_capabilities |= IFCAP_TSO6;
1300                 ifp->if_hwassist |= CSUM_IP6_TSO;
1301         }
1302
1303         /* Enable all available capabilities by default. */
1304         ifp->if_capenable = ifp->if_capabilities;
1305
1306         /*
1307          * Disable IPv6 TSO and TXCSUM by default, they still can
1308          * be enabled through SIOCSIFCAP.
1309          */
1310         ifp->if_capenable &= ~(IFCAP_TXCSUM_IPV6 | IFCAP_TSO6);
1311         ifp->if_hwassist &= ~(HN_CSUM_IP6_MASK | CSUM_IP6_TSO);
1312
1313         if (ifp->if_capabilities & (IFCAP_TSO6 | IFCAP_TSO4)) {
1314                 hn_set_tso_maxsize(sc, hn_tso_maxlen, ETHERMTU);
1315                 ifp->if_hw_tsomaxsegcount = HN_TX_DATA_SEGCNT_MAX;
1316                 ifp->if_hw_tsomaxsegsize = PAGE_SIZE;
1317         }
1318
1319         ether_ifattach(ifp, eaddr);
1320
1321         if ((ifp->if_capabilities & (IFCAP_TSO6 | IFCAP_TSO4)) && bootverbose) {
1322                 if_printf(ifp, "TSO segcnt %u segsz %u\n",
1323                     ifp->if_hw_tsomaxsegcount, ifp->if_hw_tsomaxsegsize);
1324         }
1325
1326         /* Inform the upper layer about the long frame support. */
1327         ifp->if_hdrlen = sizeof(struct ether_vlan_header);
1328
1329         /*
1330          * Kick off link status check.
1331          */
1332         sc->hn_mgmt_taskq = sc->hn_mgmt_taskq0;
1333         hn_update_link_status(sc);
1334
1335         sc->hn_ifnet_evthand = EVENTHANDLER_REGISTER(ifnet_event,
1336             hn_ifnet_event, sc, EVENTHANDLER_PRI_ANY);
1337
1338         sc->hn_ifaddr_evthand = EVENTHANDLER_REGISTER(ifaddr_event,
1339             hn_ifaddr_event, sc, EVENTHANDLER_PRI_ANY);
1340
1341         return (0);
1342 failed:
1343         if (sc->hn_flags & HN_FLAG_SYNTH_ATTACHED)
1344                 hn_synth_detach(sc);
1345         hn_detach(dev);
1346         return (error);
1347 }
1348
1349 static int
1350 hn_detach(device_t dev)
1351 {
1352         struct hn_softc *sc = device_get_softc(dev);
1353         struct ifnet *ifp = sc->hn_ifp;
1354
1355         if (sc->hn_ifaddr_evthand != NULL)
1356                 EVENTHANDLER_DEREGISTER(ifaddr_event, sc->hn_ifaddr_evthand);
1357         if (sc->hn_ifnet_evthand != NULL)
1358                 EVENTHANDLER_DEREGISTER(ifnet_event, sc->hn_ifnet_evthand);
1359
1360         if (sc->hn_xact != NULL && vmbus_chan_is_revoked(sc->hn_prichan)) {
1361                 /*
1362                  * In case that the vmbus missed the orphan handler
1363                  * installation.
1364                  */
1365                 vmbus_xact_ctx_orphan(sc->hn_xact);
1366         }
1367
1368         if (device_is_attached(dev)) {
1369                 HN_LOCK(sc);
1370                 if (sc->hn_flags & HN_FLAG_SYNTH_ATTACHED) {
1371                         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1372                                 hn_stop(sc, true);
1373                         /*
1374                          * NOTE:
1375                          * hn_stop() only suspends data, so managment
1376                          * stuffs have to be suspended manually here.
1377                          */
1378                         hn_suspend_mgmt(sc);
1379                         hn_synth_detach(sc);
1380                 }
1381                 HN_UNLOCK(sc);
1382                 ether_ifdetach(ifp);
1383         }
1384
1385         ifmedia_removeall(&sc->hn_media);
1386         hn_destroy_rx_data(sc);
1387         hn_destroy_tx_data(sc);
1388
1389         if (sc->hn_tx_taskqs != NULL && sc->hn_tx_taskqs != hn_tx_taskque) {
1390                 int i;
1391
1392                 for (i = 0; i < hn_tx_taskq_cnt; ++i)
1393                         taskqueue_free(sc->hn_tx_taskqs[i]);
1394                 free(sc->hn_tx_taskqs, M_DEVBUF);
1395         }
1396         taskqueue_free(sc->hn_mgmt_taskq0);
1397
1398         if (sc->hn_xact != NULL) {
1399                 /*
1400                  * Uninstall the orphan handler _before_ the xact is
1401                  * destructed.
1402                  */
1403                 vmbus_chan_unset_orphan(sc->hn_prichan);
1404                 vmbus_xact_ctx_destroy(sc->hn_xact);
1405         }
1406
1407         if_free(ifp);
1408
1409         HN_LOCK_DESTROY(sc);
1410         return (0);
1411 }
1412
1413 static int
1414 hn_shutdown(device_t dev)
1415 {
1416
1417         return (0);
1418 }
1419
1420 static void
1421 hn_link_status(struct hn_softc *sc)
1422 {
1423         uint32_t link_status;
1424         int error;
1425
1426         error = hn_rndis_get_linkstatus(sc, &link_status);
1427         if (error) {
1428                 /* XXX what to do? */
1429                 return;
1430         }
1431
1432         if (link_status == NDIS_MEDIA_STATE_CONNECTED)
1433                 sc->hn_link_flags |= HN_LINK_FLAG_LINKUP;
1434         else
1435                 sc->hn_link_flags &= ~HN_LINK_FLAG_LINKUP;
1436         if_link_state_change(sc->hn_ifp,
1437             (sc->hn_link_flags & HN_LINK_FLAG_LINKUP) ?
1438             LINK_STATE_UP : LINK_STATE_DOWN);
1439 }
1440
1441 static void
1442 hn_link_taskfunc(void *xsc, int pending __unused)
1443 {
1444         struct hn_softc *sc = xsc;
1445
1446         if (sc->hn_link_flags & HN_LINK_FLAG_NETCHG)
1447                 return;
1448         hn_link_status(sc);
1449 }
1450
1451 static void
1452 hn_netchg_init_taskfunc(void *xsc, int pending __unused)
1453 {
1454         struct hn_softc *sc = xsc;
1455
1456         /* Prevent any link status checks from running. */
1457         sc->hn_link_flags |= HN_LINK_FLAG_NETCHG;
1458
1459         /*
1460          * Fake up a [link down --> link up] state change; 5 seconds
1461          * delay is used, which closely simulates miibus reaction
1462          * upon link down event.
1463          */
1464         sc->hn_link_flags &= ~HN_LINK_FLAG_LINKUP;
1465         if_link_state_change(sc->hn_ifp, LINK_STATE_DOWN);
1466         taskqueue_enqueue_timeout(sc->hn_mgmt_taskq0,
1467             &sc->hn_netchg_status, 5 * hz);
1468 }
1469
1470 static void
1471 hn_netchg_status_taskfunc(void *xsc, int pending __unused)
1472 {
1473         struct hn_softc *sc = xsc;
1474
1475         /* Re-allow link status checks. */
1476         sc->hn_link_flags &= ~HN_LINK_FLAG_NETCHG;
1477         hn_link_status(sc);
1478 }
1479
1480 static void
1481 hn_update_link_status(struct hn_softc *sc)
1482 {
1483
1484         if (sc->hn_mgmt_taskq != NULL)
1485                 taskqueue_enqueue(sc->hn_mgmt_taskq, &sc->hn_link_task);
1486 }
1487
1488 static void
1489 hn_change_network(struct hn_softc *sc)
1490 {
1491
1492         if (sc->hn_mgmt_taskq != NULL)
1493                 taskqueue_enqueue(sc->hn_mgmt_taskq, &sc->hn_netchg_init);
1494 }
1495
1496 static __inline int
1497 hn_txdesc_dmamap_load(struct hn_tx_ring *txr, struct hn_txdesc *txd,
1498     struct mbuf **m_head, bus_dma_segment_t *segs, int *nsegs)
1499 {
1500         struct mbuf *m = *m_head;
1501         int error;
1502
1503         KASSERT(txd->chim_index == HN_NVS_CHIM_IDX_INVALID, ("txd uses chim"));
1504
1505         error = bus_dmamap_load_mbuf_sg(txr->hn_tx_data_dtag, txd->data_dmap,
1506             m, segs, nsegs, BUS_DMA_NOWAIT);
1507         if (error == EFBIG) {
1508                 struct mbuf *m_new;
1509
1510                 m_new = m_collapse(m, M_NOWAIT, HN_TX_DATA_SEGCNT_MAX);
1511                 if (m_new == NULL)
1512                         return ENOBUFS;
1513                 else
1514                         *m_head = m = m_new;
1515                 txr->hn_tx_collapsed++;
1516
1517                 error = bus_dmamap_load_mbuf_sg(txr->hn_tx_data_dtag,
1518                     txd->data_dmap, m, segs, nsegs, BUS_DMA_NOWAIT);
1519         }
1520         if (!error) {
1521                 bus_dmamap_sync(txr->hn_tx_data_dtag, txd->data_dmap,
1522                     BUS_DMASYNC_PREWRITE);
1523                 txd->flags |= HN_TXD_FLAG_DMAMAP;
1524         }
1525         return error;
1526 }
1527
1528 static __inline int
1529 hn_txdesc_put(struct hn_tx_ring *txr, struct hn_txdesc *txd)
1530 {
1531
1532         KASSERT((txd->flags & HN_TXD_FLAG_ONLIST) == 0,
1533             ("put an onlist txd %#x", txd->flags));
1534         KASSERT((txd->flags & HN_TXD_FLAG_ONAGG) == 0,
1535             ("put an onagg txd %#x", txd->flags));
1536
1537         KASSERT(txd->refs > 0, ("invalid txd refs %d", txd->refs));
1538         if (atomic_fetchadd_int(&txd->refs, -1) != 1)
1539                 return 0;
1540
1541         if (!STAILQ_EMPTY(&txd->agg_list)) {
1542                 struct hn_txdesc *tmp_txd;
1543
1544                 while ((tmp_txd = STAILQ_FIRST(&txd->agg_list)) != NULL) {
1545                         int freed;
1546
1547                         KASSERT(STAILQ_EMPTY(&tmp_txd->agg_list),
1548                             ("resursive aggregation on aggregated txdesc"));
1549                         KASSERT((tmp_txd->flags & HN_TXD_FLAG_ONAGG),
1550                             ("not aggregated txdesc"));
1551                         KASSERT((tmp_txd->flags & HN_TXD_FLAG_DMAMAP) == 0,
1552                             ("aggregated txdesc uses dmamap"));
1553                         KASSERT(tmp_txd->chim_index == HN_NVS_CHIM_IDX_INVALID,
1554                             ("aggregated txdesc consumes "
1555                              "chimney sending buffer"));
1556                         KASSERT(tmp_txd->chim_size == 0,
1557                             ("aggregated txdesc has non-zero "
1558                              "chimney sending size"));
1559
1560                         STAILQ_REMOVE_HEAD(&txd->agg_list, agg_link);
1561                         tmp_txd->flags &= ~HN_TXD_FLAG_ONAGG;
1562                         freed = hn_txdesc_put(txr, tmp_txd);
1563                         KASSERT(freed, ("failed to free aggregated txdesc"));
1564                 }
1565         }
1566
1567         if (txd->chim_index != HN_NVS_CHIM_IDX_INVALID) {
1568                 KASSERT((txd->flags & HN_TXD_FLAG_DMAMAP) == 0,
1569                     ("chim txd uses dmamap"));
1570                 hn_chim_free(txr->hn_sc, txd->chim_index);
1571                 txd->chim_index = HN_NVS_CHIM_IDX_INVALID;
1572                 txd->chim_size = 0;
1573         } else if (txd->flags & HN_TXD_FLAG_DMAMAP) {
1574                 bus_dmamap_sync(txr->hn_tx_data_dtag,
1575                     txd->data_dmap, BUS_DMASYNC_POSTWRITE);
1576                 bus_dmamap_unload(txr->hn_tx_data_dtag,
1577                     txd->data_dmap);
1578                 txd->flags &= ~HN_TXD_FLAG_DMAMAP;
1579         }
1580
1581         if (txd->m != NULL) {
1582                 m_freem(txd->m);
1583                 txd->m = NULL;
1584         }
1585
1586         txd->flags |= HN_TXD_FLAG_ONLIST;
1587 #ifndef HN_USE_TXDESC_BUFRING
1588         mtx_lock_spin(&txr->hn_txlist_spin);
1589         KASSERT(txr->hn_txdesc_avail >= 0 &&
1590             txr->hn_txdesc_avail < txr->hn_txdesc_cnt,
1591             ("txdesc_put: invalid txd avail %d", txr->hn_txdesc_avail));
1592         txr->hn_txdesc_avail++;
1593         SLIST_INSERT_HEAD(&txr->hn_txlist, txd, link);
1594         mtx_unlock_spin(&txr->hn_txlist_spin);
1595 #else   /* HN_USE_TXDESC_BUFRING */
1596 #ifdef HN_DEBUG
1597         atomic_add_int(&txr->hn_txdesc_avail, 1);
1598 #endif
1599         buf_ring_enqueue(txr->hn_txdesc_br, txd);
1600 #endif  /* !HN_USE_TXDESC_BUFRING */
1601
1602         return 1;
1603 }
1604
1605 static __inline struct hn_txdesc *
1606 hn_txdesc_get(struct hn_tx_ring *txr)
1607 {
1608         struct hn_txdesc *txd;
1609
1610 #ifndef HN_USE_TXDESC_BUFRING
1611         mtx_lock_spin(&txr->hn_txlist_spin);
1612         txd = SLIST_FIRST(&txr->hn_txlist);
1613         if (txd != NULL) {
1614                 KASSERT(txr->hn_txdesc_avail > 0,
1615                     ("txdesc_get: invalid txd avail %d", txr->hn_txdesc_avail));
1616                 txr->hn_txdesc_avail--;
1617                 SLIST_REMOVE_HEAD(&txr->hn_txlist, link);
1618         }
1619         mtx_unlock_spin(&txr->hn_txlist_spin);
1620 #else
1621         txd = buf_ring_dequeue_sc(txr->hn_txdesc_br);
1622 #endif
1623
1624         if (txd != NULL) {
1625 #ifdef HN_USE_TXDESC_BUFRING
1626 #ifdef HN_DEBUG
1627                 atomic_subtract_int(&txr->hn_txdesc_avail, 1);
1628 #endif
1629 #endif  /* HN_USE_TXDESC_BUFRING */
1630                 KASSERT(txd->m == NULL && txd->refs == 0 &&
1631                     STAILQ_EMPTY(&txd->agg_list) &&
1632                     txd->chim_index == HN_NVS_CHIM_IDX_INVALID &&
1633                     txd->chim_size == 0 &&
1634                     (txd->flags & HN_TXD_FLAG_ONLIST) &&
1635                     (txd->flags & HN_TXD_FLAG_ONAGG) == 0 &&
1636                     (txd->flags & HN_TXD_FLAG_DMAMAP) == 0, ("invalid txd"));
1637                 txd->flags &= ~HN_TXD_FLAG_ONLIST;
1638                 txd->refs = 1;
1639         }
1640         return txd;
1641 }
1642
1643 static __inline void
1644 hn_txdesc_hold(struct hn_txdesc *txd)
1645 {
1646
1647         /* 0->1 transition will never work */
1648         KASSERT(txd->refs > 0, ("invalid txd refs %d", txd->refs));
1649         atomic_add_int(&txd->refs, 1);
1650 }
1651
1652 static __inline void
1653 hn_txdesc_agg(struct hn_txdesc *agg_txd, struct hn_txdesc *txd)
1654 {
1655
1656         KASSERT((agg_txd->flags & HN_TXD_FLAG_ONAGG) == 0,
1657             ("recursive aggregation on aggregating txdesc"));
1658
1659         KASSERT((txd->flags & HN_TXD_FLAG_ONAGG) == 0,
1660             ("already aggregated"));
1661         KASSERT(STAILQ_EMPTY(&txd->agg_list),
1662             ("recursive aggregation on to-be-aggregated txdesc"));
1663
1664         txd->flags |= HN_TXD_FLAG_ONAGG;
1665         STAILQ_INSERT_TAIL(&agg_txd->agg_list, txd, agg_link);
1666 }
1667
1668 static bool
1669 hn_tx_ring_pending(struct hn_tx_ring *txr)
1670 {
1671         bool pending = false;
1672
1673 #ifndef HN_USE_TXDESC_BUFRING
1674         mtx_lock_spin(&txr->hn_txlist_spin);
1675         if (txr->hn_txdesc_avail != txr->hn_txdesc_cnt)
1676                 pending = true;
1677         mtx_unlock_spin(&txr->hn_txlist_spin);
1678 #else
1679         if (!buf_ring_full(txr->hn_txdesc_br))
1680                 pending = true;
1681 #endif
1682         return (pending);
1683 }
1684
1685 static __inline void
1686 hn_txeof(struct hn_tx_ring *txr)
1687 {
1688         txr->hn_has_txeof = 0;
1689         txr->hn_txeof(txr);
1690 }
1691
1692 static void
1693 hn_txpkt_done(struct hn_nvs_sendctx *sndc, struct hn_softc *sc,
1694     struct vmbus_channel *chan, const void *data __unused, int dlen __unused)
1695 {
1696         struct hn_txdesc *txd = sndc->hn_cbarg;
1697         struct hn_tx_ring *txr;
1698
1699         txr = txd->txr;
1700         KASSERT(txr->hn_chan == chan,
1701             ("channel mismatch, on chan%u, should be chan%u",
1702              vmbus_chan_id(chan), vmbus_chan_id(txr->hn_chan)));
1703
1704         txr->hn_has_txeof = 1;
1705         hn_txdesc_put(txr, txd);
1706
1707         ++txr->hn_txdone_cnt;
1708         if (txr->hn_txdone_cnt >= HN_EARLY_TXEOF_THRESH) {
1709                 txr->hn_txdone_cnt = 0;
1710                 if (txr->hn_oactive)
1711                         hn_txeof(txr);
1712         }
1713 }
1714
1715 static void
1716 hn_chan_rollup(struct hn_rx_ring *rxr, struct hn_tx_ring *txr)
1717 {
1718 #if defined(INET) || defined(INET6)
1719         struct lro_ctrl *lro = &rxr->hn_lro;
1720         struct lro_entry *queued;
1721
1722         while ((queued = SLIST_FIRST(&lro->lro_active)) != NULL) {
1723                 SLIST_REMOVE_HEAD(&lro->lro_active, next);
1724                 tcp_lro_flush(lro, queued);
1725         }
1726 #endif
1727
1728         /*
1729          * NOTE:
1730          * 'txr' could be NULL, if multiple channels and
1731          * ifnet.if_start method are enabled.
1732          */
1733         if (txr == NULL || !txr->hn_has_txeof)
1734                 return;
1735
1736         txr->hn_txdone_cnt = 0;
1737         hn_txeof(txr);
1738 }
1739
1740 static __inline uint32_t
1741 hn_rndis_pktmsg_offset(uint32_t ofs)
1742 {
1743
1744         KASSERT(ofs >= sizeof(struct rndis_packet_msg),
1745             ("invalid RNDIS packet msg offset %u", ofs));
1746         return (ofs - __offsetof(struct rndis_packet_msg, rm_dataoffset));
1747 }
1748
1749 static __inline void *
1750 hn_rndis_pktinfo_append(struct rndis_packet_msg *pkt, size_t pktsize,
1751     size_t pi_dlen, uint32_t pi_type)
1752 {
1753         const size_t pi_size = HN_RNDIS_PKTINFO_SIZE(pi_dlen);
1754         struct rndis_pktinfo *pi;
1755
1756         KASSERT((pi_size & RNDIS_PACKET_MSG_OFFSET_ALIGNMASK) == 0,
1757             ("unaligned pktinfo size %zu, pktinfo dlen %zu", pi_size, pi_dlen));
1758
1759         /*
1760          * Per-packet-info does not move; it only grows.
1761          *
1762          * NOTE:
1763          * rm_pktinfooffset in this phase counts from the beginning
1764          * of rndis_packet_msg.
1765          */
1766         KASSERT(pkt->rm_pktinfooffset + pkt->rm_pktinfolen + pi_size <= pktsize,
1767             ("%u pktinfo overflows RNDIS packet msg", pi_type));
1768         pi = (struct rndis_pktinfo *)((uint8_t *)pkt + pkt->rm_pktinfooffset +
1769             pkt->rm_pktinfolen);
1770         pkt->rm_pktinfolen += pi_size;
1771
1772         pi->rm_size = pi_size;
1773         pi->rm_type = pi_type;
1774         pi->rm_pktinfooffset = RNDIS_PKTINFO_OFFSET;
1775
1776         return (pi->rm_data);
1777 }
1778
1779 static __inline int
1780 hn_flush_txagg(struct ifnet *ifp, struct hn_tx_ring *txr)
1781 {
1782         struct hn_txdesc *txd;
1783         struct mbuf *m;
1784         int error, pkts;
1785
1786         txd = txr->hn_agg_txd;
1787         KASSERT(txd != NULL, ("no aggregate txdesc"));
1788
1789         /*
1790          * Since hn_txpkt() will reset this temporary stat, save
1791          * it now, so that oerrors can be updated properly, if
1792          * hn_txpkt() ever fails.
1793          */
1794         pkts = txr->hn_stat_pkts;
1795
1796         /*
1797          * Since txd's mbuf will _not_ be freed upon hn_txpkt()
1798          * failure, save it for later freeing, if hn_txpkt() ever
1799          * fails.
1800          */
1801         m = txd->m;
1802         error = hn_txpkt(ifp, txr, txd);
1803         if (__predict_false(error)) {
1804                 /* txd is freed, but m is not. */
1805                 m_freem(m);
1806
1807                 txr->hn_flush_failed++;
1808                 if_inc_counter(ifp, IFCOUNTER_OERRORS, pkts);
1809         }
1810
1811         /* Reset all aggregation states. */
1812         txr->hn_agg_txd = NULL;
1813         txr->hn_agg_szleft = 0;
1814         txr->hn_agg_pktleft = 0;
1815         txr->hn_agg_prevpkt = NULL;
1816
1817         return (error);
1818 }
1819
1820 static void *
1821 hn_try_txagg(struct ifnet *ifp, struct hn_tx_ring *txr, struct hn_txdesc *txd,
1822     int pktsize)
1823 {
1824         void *chim;
1825
1826         if (txr->hn_agg_txd != NULL) {
1827                 if (txr->hn_agg_pktleft >= 1 && txr->hn_agg_szleft > pktsize) {
1828                         struct hn_txdesc *agg_txd = txr->hn_agg_txd;
1829                         struct rndis_packet_msg *pkt = txr->hn_agg_prevpkt;
1830                         int olen;
1831
1832                         /*
1833                          * Update the previous RNDIS packet's total length,
1834                          * it can be increased due to the mandatory alignment
1835                          * padding for this RNDIS packet.  And update the
1836                          * aggregating txdesc's chimney sending buffer size
1837                          * accordingly.
1838                          *
1839                          * XXX
1840                          * Zero-out the padding, as required by the RNDIS spec.
1841                          */
1842                         olen = pkt->rm_len;
1843                         pkt->rm_len = roundup2(olen, txr->hn_agg_align);
1844                         agg_txd->chim_size += pkt->rm_len - olen;
1845
1846                         /* Link this txdesc to the parent. */
1847                         hn_txdesc_agg(agg_txd, txd);
1848
1849                         chim = (uint8_t *)pkt + pkt->rm_len;
1850                         /* Save the current packet for later fixup. */
1851                         txr->hn_agg_prevpkt = chim;
1852
1853                         txr->hn_agg_pktleft--;
1854                         txr->hn_agg_szleft -= pktsize;
1855                         if (txr->hn_agg_szleft <=
1856                             HN_PKTSIZE_MIN(txr->hn_agg_align)) {
1857                                 /*
1858                                  * Probably can't aggregate more packets,
1859                                  * flush this aggregating txdesc proactively.
1860                                  */
1861                                 txr->hn_agg_pktleft = 0;
1862                         }
1863                         /* Done! */
1864                         return (chim);
1865                 }
1866                 hn_flush_txagg(ifp, txr);
1867         }
1868         KASSERT(txr->hn_agg_txd == NULL, ("lingering aggregating txdesc"));
1869
1870         txr->hn_tx_chimney_tried++;
1871         txd->chim_index = hn_chim_alloc(txr->hn_sc);
1872         if (txd->chim_index == HN_NVS_CHIM_IDX_INVALID)
1873                 return (NULL);
1874         txr->hn_tx_chimney++;
1875
1876         chim = txr->hn_sc->hn_chim +
1877             (txd->chim_index * txr->hn_sc->hn_chim_szmax);
1878
1879         if (txr->hn_agg_pktmax > 1 &&
1880             txr->hn_agg_szmax > pktsize + HN_PKTSIZE_MIN(txr->hn_agg_align)) {
1881                 txr->hn_agg_txd = txd;
1882                 txr->hn_agg_pktleft = txr->hn_agg_pktmax - 1;
1883                 txr->hn_agg_szleft = txr->hn_agg_szmax - pktsize;
1884                 txr->hn_agg_prevpkt = chim;
1885         }
1886         return (chim);
1887 }
1888
1889 /*
1890  * NOTE:
1891  * If this function fails, then both txd and m_head0 will be freed.
1892  */
1893 static int
1894 hn_encap(struct ifnet *ifp, struct hn_tx_ring *txr, struct hn_txdesc *txd,
1895     struct mbuf **m_head0)
1896 {
1897         bus_dma_segment_t segs[HN_TX_DATA_SEGCNT_MAX];
1898         int error, nsegs, i;
1899         struct mbuf *m_head = *m_head0;
1900         struct rndis_packet_msg *pkt;
1901         uint32_t *pi_data;
1902         void *chim = NULL;
1903         int pkt_hlen, pkt_size;
1904
1905         pkt = txd->rndis_pkt;
1906         pkt_size = HN_PKTSIZE(m_head, txr->hn_agg_align);
1907         if (pkt_size < txr->hn_chim_size) {
1908                 chim = hn_try_txagg(ifp, txr, txd, pkt_size);
1909                 if (chim != NULL)
1910                         pkt = chim;
1911         } else {
1912                 if (txr->hn_agg_txd != NULL)
1913                         hn_flush_txagg(ifp, txr);
1914         }
1915
1916         pkt->rm_type = REMOTE_NDIS_PACKET_MSG;
1917         pkt->rm_len = m_head->m_pkthdr.len;
1918         pkt->rm_dataoffset = 0;
1919         pkt->rm_datalen = m_head->m_pkthdr.len;
1920         pkt->rm_oobdataoffset = 0;
1921         pkt->rm_oobdatalen = 0;
1922         pkt->rm_oobdataelements = 0;
1923         pkt->rm_pktinfooffset = sizeof(*pkt);
1924         pkt->rm_pktinfolen = 0;
1925         pkt->rm_vchandle = 0;
1926         pkt->rm_reserved = 0;
1927
1928         if (txr->hn_tx_flags & HN_TX_FLAG_HASHVAL) {
1929                 /*
1930                  * Set the hash value for this packet, so that the host could
1931                  * dispatch the TX done event for this packet back to this TX
1932                  * ring's channel.
1933                  */
1934                 pi_data = hn_rndis_pktinfo_append(pkt, HN_RNDIS_PKT_LEN,
1935                     HN_NDIS_HASH_VALUE_SIZE, HN_NDIS_PKTINFO_TYPE_HASHVAL);
1936                 *pi_data = txr->hn_tx_idx;
1937         }
1938
1939         if (m_head->m_flags & M_VLANTAG) {
1940                 pi_data = hn_rndis_pktinfo_append(pkt, HN_RNDIS_PKT_LEN,
1941                     NDIS_VLAN_INFO_SIZE, NDIS_PKTINFO_TYPE_VLAN);
1942                 *pi_data = NDIS_VLAN_INFO_MAKE(
1943                     EVL_VLANOFTAG(m_head->m_pkthdr.ether_vtag),
1944                     EVL_PRIOFTAG(m_head->m_pkthdr.ether_vtag),
1945                     EVL_CFIOFTAG(m_head->m_pkthdr.ether_vtag));
1946         }
1947
1948         if (m_head->m_pkthdr.csum_flags & CSUM_TSO) {
1949 #if defined(INET6) || defined(INET)
1950                 pi_data = hn_rndis_pktinfo_append(pkt, HN_RNDIS_PKT_LEN,
1951                     NDIS_LSO2_INFO_SIZE, NDIS_PKTINFO_TYPE_LSO);
1952 #ifdef INET
1953                 if (m_head->m_pkthdr.csum_flags & CSUM_IP_TSO) {
1954                         *pi_data = NDIS_LSO2_INFO_MAKEIPV4(0,
1955                             m_head->m_pkthdr.tso_segsz);
1956                 }
1957 #endif
1958 #if defined(INET6) && defined(INET)
1959                 else
1960 #endif
1961 #ifdef INET6
1962                 {
1963                         *pi_data = NDIS_LSO2_INFO_MAKEIPV6(0,
1964                             m_head->m_pkthdr.tso_segsz);
1965                 }
1966 #endif
1967 #endif  /* INET6 || INET */
1968         } else if (m_head->m_pkthdr.csum_flags & txr->hn_csum_assist) {
1969                 pi_data = hn_rndis_pktinfo_append(pkt, HN_RNDIS_PKT_LEN,
1970                     NDIS_TXCSUM_INFO_SIZE, NDIS_PKTINFO_TYPE_CSUM);
1971                 if (m_head->m_pkthdr.csum_flags &
1972                     (CSUM_IP6_TCP | CSUM_IP6_UDP)) {
1973                         *pi_data = NDIS_TXCSUM_INFO_IPV6;
1974                 } else {
1975                         *pi_data = NDIS_TXCSUM_INFO_IPV4;
1976                         if (m_head->m_pkthdr.csum_flags & CSUM_IP)
1977                                 *pi_data |= NDIS_TXCSUM_INFO_IPCS;
1978                 }
1979
1980                 if (m_head->m_pkthdr.csum_flags & (CSUM_IP_TCP | CSUM_IP6_TCP))
1981                         *pi_data |= NDIS_TXCSUM_INFO_TCPCS;
1982                 else if (m_head->m_pkthdr.csum_flags &
1983                     (CSUM_IP_UDP | CSUM_IP6_UDP))
1984                         *pi_data |= NDIS_TXCSUM_INFO_UDPCS;
1985         }
1986
1987         pkt_hlen = pkt->rm_pktinfooffset + pkt->rm_pktinfolen;
1988         /* Fixup RNDIS packet message total length */
1989         pkt->rm_len += pkt_hlen;
1990         /* Convert RNDIS packet message offsets */
1991         pkt->rm_dataoffset = hn_rndis_pktmsg_offset(pkt_hlen);
1992         pkt->rm_pktinfooffset = hn_rndis_pktmsg_offset(pkt->rm_pktinfooffset);
1993
1994         /*
1995          * Fast path: Chimney sending.
1996          */
1997         if (chim != NULL) {
1998                 struct hn_txdesc *tgt_txd = txd;
1999
2000                 if (txr->hn_agg_txd != NULL) {
2001                         tgt_txd = txr->hn_agg_txd;
2002 #ifdef INVARIANTS
2003                         *m_head0 = NULL;
2004 #endif
2005                 }
2006
2007                 KASSERT(pkt == chim,
2008                     ("RNDIS pkt not in chimney sending buffer"));
2009                 KASSERT(tgt_txd->chim_index != HN_NVS_CHIM_IDX_INVALID,
2010                     ("chimney sending buffer is not used"));
2011                 tgt_txd->chim_size += pkt->rm_len;
2012
2013                 m_copydata(m_head, 0, m_head->m_pkthdr.len,
2014                     ((uint8_t *)chim) + pkt_hlen);
2015
2016                 txr->hn_gpa_cnt = 0;
2017                 txr->hn_sendpkt = hn_txpkt_chim;
2018                 goto done;
2019         }
2020
2021         KASSERT(txr->hn_agg_txd == NULL, ("aggregating sglist txdesc"));
2022         KASSERT(txd->chim_index == HN_NVS_CHIM_IDX_INVALID,
2023             ("chimney buffer is used"));
2024         KASSERT(pkt == txd->rndis_pkt, ("RNDIS pkt not in txdesc"));
2025
2026         error = hn_txdesc_dmamap_load(txr, txd, &m_head, segs, &nsegs);
2027         if (__predict_false(error)) {
2028                 int freed;
2029
2030                 /*
2031                  * This mbuf is not linked w/ the txd yet, so free it now.
2032                  */
2033                 m_freem(m_head);
2034                 *m_head0 = NULL;
2035
2036                 freed = hn_txdesc_put(txr, txd);
2037                 KASSERT(freed != 0,
2038                     ("fail to free txd upon txdma error"));
2039
2040                 txr->hn_txdma_failed++;
2041                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2042                 return error;
2043         }
2044         *m_head0 = m_head;
2045
2046         /* +1 RNDIS packet message */
2047         txr->hn_gpa_cnt = nsegs + 1;
2048
2049         /* send packet with page buffer */
2050         txr->hn_gpa[0].gpa_page = atop(txd->rndis_pkt_paddr);
2051         txr->hn_gpa[0].gpa_ofs = txd->rndis_pkt_paddr & PAGE_MASK;
2052         txr->hn_gpa[0].gpa_len = pkt_hlen;
2053
2054         /*
2055          * Fill the page buffers with mbuf info after the page
2056          * buffer for RNDIS packet message.
2057          */
2058         for (i = 0; i < nsegs; ++i) {
2059                 struct vmbus_gpa *gpa = &txr->hn_gpa[i + 1];
2060
2061                 gpa->gpa_page = atop(segs[i].ds_addr);
2062                 gpa->gpa_ofs = segs[i].ds_addr & PAGE_MASK;
2063                 gpa->gpa_len = segs[i].ds_len;
2064         }
2065
2066         txd->chim_index = HN_NVS_CHIM_IDX_INVALID;
2067         txd->chim_size = 0;
2068         txr->hn_sendpkt = hn_txpkt_sglist;
2069 done:
2070         txd->m = m_head;
2071
2072         /* Set the completion routine */
2073         hn_nvs_sendctx_init(&txd->send_ctx, hn_txpkt_done, txd);
2074
2075         /* Update temporary stats for later use. */
2076         txr->hn_stat_pkts++;
2077         txr->hn_stat_size += m_head->m_pkthdr.len;
2078         if (m_head->m_flags & M_MCAST)
2079                 txr->hn_stat_mcasts++;
2080
2081         return 0;
2082 }
2083
2084 /*
2085  * NOTE:
2086  * If this function fails, then txd will be freed, but the mbuf
2087  * associated w/ the txd will _not_ be freed.
2088  */
2089 static int
2090 hn_txpkt(struct ifnet *ifp, struct hn_tx_ring *txr, struct hn_txdesc *txd)
2091 {
2092         int error, send_failed = 0, has_bpf;
2093
2094 again:
2095         has_bpf = bpf_peers_present(ifp->if_bpf);
2096         if (has_bpf) {
2097                 /*
2098                  * Make sure that this txd and any aggregated txds are not
2099                  * freed before ETHER_BPF_MTAP.
2100                  */
2101                 hn_txdesc_hold(txd);
2102         }
2103         error = txr->hn_sendpkt(txr, txd);
2104         if (!error) {
2105                 if (has_bpf) {
2106                         const struct hn_txdesc *tmp_txd;
2107
2108                         ETHER_BPF_MTAP(ifp, txd->m);
2109                         STAILQ_FOREACH(tmp_txd, &txd->agg_list, agg_link)
2110                                 ETHER_BPF_MTAP(ifp, tmp_txd->m);
2111                 }
2112
2113                 if_inc_counter(ifp, IFCOUNTER_OPACKETS, txr->hn_stat_pkts);
2114 #ifdef HN_IFSTART_SUPPORT
2115                 if (!hn_use_if_start)
2116 #endif
2117                 {
2118                         if_inc_counter(ifp, IFCOUNTER_OBYTES,
2119                             txr->hn_stat_size);
2120                         if (txr->hn_stat_mcasts != 0) {
2121                                 if_inc_counter(ifp, IFCOUNTER_OMCASTS,
2122                                     txr->hn_stat_mcasts);
2123                         }
2124                 }
2125                 txr->hn_pkts += txr->hn_stat_pkts;
2126                 txr->hn_sends++;
2127         }
2128         if (has_bpf)
2129                 hn_txdesc_put(txr, txd);
2130
2131         if (__predict_false(error)) {
2132                 int freed;
2133
2134                 /*
2135                  * This should "really rarely" happen.
2136                  *
2137                  * XXX Too many RX to be acked or too many sideband
2138                  * commands to run?  Ask netvsc_channel_rollup()
2139                  * to kick start later.
2140                  */
2141                 txr->hn_has_txeof = 1;
2142                 if (!send_failed) {
2143                         txr->hn_send_failed++;
2144                         send_failed = 1;
2145                         /*
2146                          * Try sending again after set hn_has_txeof;
2147                          * in case that we missed the last
2148                          * netvsc_channel_rollup().
2149                          */
2150                         goto again;
2151                 }
2152                 if_printf(ifp, "send failed\n");
2153
2154                 /*
2155                  * Caller will perform further processing on the
2156                  * associated mbuf, so don't free it in hn_txdesc_put();
2157                  * only unload it from the DMA map in hn_txdesc_put(),
2158                  * if it was loaded.
2159                  */
2160                 txd->m = NULL;
2161                 freed = hn_txdesc_put(txr, txd);
2162                 KASSERT(freed != 0,
2163                     ("fail to free txd upon send error"));
2164
2165                 txr->hn_send_failed++;
2166         }
2167
2168         /* Reset temporary stats, after this sending is done. */
2169         txr->hn_stat_size = 0;
2170         txr->hn_stat_pkts = 0;
2171         txr->hn_stat_mcasts = 0;
2172
2173         return (error);
2174 }
2175
2176 /*
2177  * Append the specified data to the indicated mbuf chain,
2178  * Extend the mbuf chain if the new data does not fit in
2179  * existing space.
2180  *
2181  * This is a minor rewrite of m_append() from sys/kern/uipc_mbuf.c.
2182  * There should be an equivalent in the kernel mbuf code,
2183  * but there does not appear to be one yet.
2184  *
2185  * Differs from m_append() in that additional mbufs are
2186  * allocated with cluster size MJUMPAGESIZE, and filled
2187  * accordingly.
2188  *
2189  * Return 1 if able to complete the job; otherwise 0.
2190  */
2191 static int
2192 hv_m_append(struct mbuf *m0, int len, c_caddr_t cp)
2193 {
2194         struct mbuf *m, *n;
2195         int remainder, space;
2196
2197         for (m = m0; m->m_next != NULL; m = m->m_next)
2198                 ;
2199         remainder = len;
2200         space = M_TRAILINGSPACE(m);
2201         if (space > 0) {
2202                 /*
2203                  * Copy into available space.
2204                  */
2205                 if (space > remainder)
2206                         space = remainder;
2207                 bcopy(cp, mtod(m, caddr_t) + m->m_len, space);
2208                 m->m_len += space;
2209                 cp += space;
2210                 remainder -= space;
2211         }
2212         while (remainder > 0) {
2213                 /*
2214                  * Allocate a new mbuf; could check space
2215                  * and allocate a cluster instead.
2216                  */
2217                 n = m_getjcl(M_DONTWAIT, m->m_type, 0, MJUMPAGESIZE);
2218                 if (n == NULL)
2219                         break;
2220                 n->m_len = min(MJUMPAGESIZE, remainder);
2221                 bcopy(cp, mtod(n, caddr_t), n->m_len);
2222                 cp += n->m_len;
2223                 remainder -= n->m_len;
2224                 m->m_next = n;
2225                 m = n;
2226         }
2227         if (m0->m_flags & M_PKTHDR)
2228                 m0->m_pkthdr.len += len - remainder;
2229
2230         return (remainder == 0);
2231 }
2232
2233 #if defined(INET) || defined(INET6)
2234 static __inline int
2235 hn_lro_rx(struct lro_ctrl *lc, struct mbuf *m)
2236 {
2237 #if __FreeBSD_version >= 1100095
2238         if (hn_lro_mbufq_depth) {
2239                 tcp_lro_queue_mbuf(lc, m);
2240                 return 0;
2241         }
2242 #endif
2243         return tcp_lro_rx(lc, m, 0);
2244 }
2245 #endif
2246
2247 static int
2248 hn_rxpkt(struct hn_rx_ring *rxr, const void *data, int dlen,
2249     const struct hn_rxinfo *info)
2250 {
2251         struct ifnet *ifp;
2252         struct mbuf *m_new;
2253         int size, do_lro = 0, do_csum = 1;
2254         int hash_type = M_HASHTYPE_OPAQUE;
2255
2256         /* If the VF is active, inject the packet through the VF */
2257         ifp = rxr->hn_vf ? rxr->hn_vf : rxr->hn_ifp;
2258
2259         if (dlen <= MHLEN) {
2260                 m_new = m_gethdr(M_NOWAIT, MT_DATA);
2261                 if (m_new == NULL) {
2262                         if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
2263                         return (0);
2264                 }
2265                 memcpy(mtod(m_new, void *), data, dlen);
2266                 m_new->m_pkthdr.len = m_new->m_len = dlen;
2267                 rxr->hn_small_pkts++;
2268         } else {
2269                 /*
2270                  * Get an mbuf with a cluster.  For packets 2K or less,
2271                  * get a standard 2K cluster.  For anything larger, get a
2272                  * 4K cluster.  Any buffers larger than 4K can cause problems
2273                  * if looped around to the Hyper-V TX channel, so avoid them.
2274                  */
2275                 size = MCLBYTES;
2276                 if (dlen > MCLBYTES) {
2277                         /* 4096 */
2278                         size = MJUMPAGESIZE;
2279                 }
2280
2281                 m_new = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, size);
2282                 if (m_new == NULL) {
2283                         if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
2284                         return (0);
2285                 }
2286
2287                 hv_m_append(m_new, dlen, data);
2288         }
2289         m_new->m_pkthdr.rcvif = ifp;
2290
2291         if (__predict_false((ifp->if_capenable & IFCAP_RXCSUM) == 0))
2292                 do_csum = 0;
2293
2294         /* receive side checksum offload */
2295         if (info->csum_info != HN_NDIS_RXCSUM_INFO_INVALID) {
2296                 /* IP csum offload */
2297                 if ((info->csum_info & NDIS_RXCSUM_INFO_IPCS_OK) && do_csum) {
2298                         m_new->m_pkthdr.csum_flags |=
2299                             (CSUM_IP_CHECKED | CSUM_IP_VALID);
2300                         rxr->hn_csum_ip++;
2301                 }
2302
2303                 /* TCP/UDP csum offload */
2304                 if ((info->csum_info & (NDIS_RXCSUM_INFO_UDPCS_OK |
2305                      NDIS_RXCSUM_INFO_TCPCS_OK)) && do_csum) {
2306                         m_new->m_pkthdr.csum_flags |=
2307                             (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
2308                         m_new->m_pkthdr.csum_data = 0xffff;
2309                         if (info->csum_info & NDIS_RXCSUM_INFO_TCPCS_OK)
2310                                 rxr->hn_csum_tcp++;
2311                         else
2312                                 rxr->hn_csum_udp++;
2313                 }
2314
2315                 /*
2316                  * XXX
2317                  * As of this write (Oct 28th, 2016), host side will turn
2318                  * on only TCPCS_OK and IPCS_OK even for UDP datagrams, so
2319                  * the do_lro setting here is actually _not_ accurate.  We
2320                  * depend on the RSS hash type check to reset do_lro.
2321                  */
2322                 if ((info->csum_info &
2323                      (NDIS_RXCSUM_INFO_TCPCS_OK | NDIS_RXCSUM_INFO_IPCS_OK)) ==
2324                     (NDIS_RXCSUM_INFO_TCPCS_OK | NDIS_RXCSUM_INFO_IPCS_OK))
2325                         do_lro = 1;
2326         } else {
2327                 const struct ether_header *eh;
2328                 uint16_t etype;
2329                 int hoff;
2330
2331                 hoff = sizeof(*eh);
2332                 if (m_new->m_len < hoff)
2333                         goto skip;
2334                 eh = mtod(m_new, struct ether_header *);
2335                 etype = ntohs(eh->ether_type);
2336                 if (etype == ETHERTYPE_VLAN) {
2337                         const struct ether_vlan_header *evl;
2338
2339                         hoff = sizeof(*evl);
2340                         if (m_new->m_len < hoff)
2341                                 goto skip;
2342                         evl = mtod(m_new, struct ether_vlan_header *);
2343                         etype = ntohs(evl->evl_proto);
2344                 }
2345
2346                 if (etype == ETHERTYPE_IP) {
2347                         int pr;
2348
2349                         pr = hn_check_iplen(m_new, hoff);
2350                         if (pr == IPPROTO_TCP) {
2351                                 if (do_csum &&
2352                                     (rxr->hn_trust_hcsum &
2353                                      HN_TRUST_HCSUM_TCP)) {
2354                                         rxr->hn_csum_trusted++;
2355                                         m_new->m_pkthdr.csum_flags |=
2356                                            (CSUM_IP_CHECKED | CSUM_IP_VALID |
2357                                             CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
2358                                         m_new->m_pkthdr.csum_data = 0xffff;
2359                                 }
2360                                 do_lro = 1;
2361                         } else if (pr == IPPROTO_UDP) {
2362                                 if (do_csum &&
2363                                     (rxr->hn_trust_hcsum &
2364                                      HN_TRUST_HCSUM_UDP)) {
2365                                         rxr->hn_csum_trusted++;
2366                                         m_new->m_pkthdr.csum_flags |=
2367                                            (CSUM_IP_CHECKED | CSUM_IP_VALID |
2368                                             CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
2369                                         m_new->m_pkthdr.csum_data = 0xffff;
2370                                 }
2371                         } else if (pr != IPPROTO_DONE && do_csum &&
2372                             (rxr->hn_trust_hcsum & HN_TRUST_HCSUM_IP)) {
2373                                 rxr->hn_csum_trusted++;
2374                                 m_new->m_pkthdr.csum_flags |=
2375                                     (CSUM_IP_CHECKED | CSUM_IP_VALID);
2376                         }
2377                 }
2378         }
2379 skip:
2380         if (info->vlan_info != HN_NDIS_VLAN_INFO_INVALID) {
2381                 m_new->m_pkthdr.ether_vtag = EVL_MAKETAG(
2382                     NDIS_VLAN_INFO_ID(info->vlan_info),
2383                     NDIS_VLAN_INFO_PRI(info->vlan_info),
2384                     NDIS_VLAN_INFO_CFI(info->vlan_info));
2385                 m_new->m_flags |= M_VLANTAG;
2386         }
2387
2388         if (info->hash_info != HN_NDIS_HASH_INFO_INVALID) {
2389                 rxr->hn_rss_pkts++;
2390                 m_new->m_pkthdr.flowid = info->hash_value;
2391                 if ((info->hash_info & NDIS_HASH_FUNCTION_MASK) ==
2392                     NDIS_HASH_FUNCTION_TOEPLITZ) {
2393                         uint32_t type = (info->hash_info & NDIS_HASH_TYPE_MASK);
2394
2395                         /*
2396                          * NOTE:
2397                          * do_lro is resetted, if the hash types are not TCP
2398                          * related.  See the comment in the above csum_flags
2399                          * setup section.
2400                          */
2401                         switch (type) {
2402                         case NDIS_HASH_IPV4:
2403                                 hash_type = M_HASHTYPE_RSS_IPV4;
2404                                 do_lro = 0;
2405                                 break;
2406
2407                         case NDIS_HASH_TCP_IPV4:
2408                                 hash_type = M_HASHTYPE_RSS_TCP_IPV4;
2409                                 break;
2410
2411                         case NDIS_HASH_IPV6:
2412                                 hash_type = M_HASHTYPE_RSS_IPV6;
2413                                 do_lro = 0;
2414                                 break;
2415
2416                         case NDIS_HASH_IPV6_EX:
2417                                 hash_type = M_HASHTYPE_RSS_IPV6_EX;
2418                                 do_lro = 0;
2419                                 break;
2420
2421                         case NDIS_HASH_TCP_IPV6:
2422                                 hash_type = M_HASHTYPE_RSS_TCP_IPV6;
2423                                 break;
2424
2425                         case NDIS_HASH_TCP_IPV6_EX:
2426                                 hash_type = M_HASHTYPE_RSS_TCP_IPV6_EX;
2427                                 break;
2428                         }
2429                 }
2430         } else {
2431                 m_new->m_pkthdr.flowid = rxr->hn_rx_idx;
2432         }
2433         M_HASHTYPE_SET(m_new, hash_type);
2434
2435         /*
2436          * Note:  Moved RX completion back to hv_nv_on_receive() so all
2437          * messages (not just data messages) will trigger a response.
2438          */
2439
2440         ifp->if_ipackets++;
2441         rxr->hn_pkts++;
2442
2443         if ((ifp->if_capenable & IFCAP_LRO) && do_lro) {
2444 #if defined(INET) || defined(INET6)
2445                 struct lro_ctrl *lro = &rxr->hn_lro;
2446
2447                 if (lro->lro_cnt) {
2448                         rxr->hn_lro_tried++;
2449                         if (hn_lro_rx(lro, m_new) == 0) {
2450                                 /* DONE! */
2451                                 return 0;
2452                         }
2453                 }
2454 #endif
2455         }
2456
2457         /* We're not holding the lock here, so don't release it */
2458         (*ifp->if_input)(ifp, m_new);
2459
2460         return (0);
2461 }
2462
2463 static int
2464 hn_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2465 {
2466         struct hn_softc *sc = ifp->if_softc;
2467         struct ifreq *ifr = (struct ifreq *)data;
2468         int mask, error = 0;
2469
2470         switch (cmd) {
2471         case SIOCSIFMTU:
2472                 if (ifr->ifr_mtu > HN_MTU_MAX) {
2473                         error = EINVAL;
2474                         break;
2475                 }
2476
2477                 HN_LOCK(sc);
2478
2479                 if ((sc->hn_flags & HN_FLAG_SYNTH_ATTACHED) == 0) {
2480                         HN_UNLOCK(sc);
2481                         break;
2482                 }
2483
2484                 if ((sc->hn_caps & HN_CAP_MTU) == 0) {
2485                         /* Can't change MTU */
2486                         HN_UNLOCK(sc);
2487                         error = EOPNOTSUPP;
2488                         break;
2489                 }
2490
2491                 if (ifp->if_mtu == ifr->ifr_mtu) {
2492                         HN_UNLOCK(sc);
2493                         break;
2494                 }
2495
2496                 /*
2497                  * Suspend this interface before the synthetic parts
2498                  * are ripped.
2499                  */
2500                 hn_suspend(sc);
2501
2502                 /*
2503                  * Detach the synthetics parts, i.e. NVS and RNDIS.
2504                  */
2505                 hn_synth_detach(sc);
2506
2507                 /*
2508                  * Reattach the synthetic parts, i.e. NVS and RNDIS,
2509                  * with the new MTU setting.
2510                  */
2511                 error = hn_synth_attach(sc, ifr->ifr_mtu);
2512                 if (error) {
2513                         HN_UNLOCK(sc);
2514                         break;
2515                 }
2516
2517                 /*
2518                  * Commit the requested MTU, after the synthetic parts
2519                  * have been successfully attached.
2520                  */
2521                 ifp->if_mtu = ifr->ifr_mtu;
2522
2523                 /*
2524                  * Make sure that various parameters based on MTU are
2525                  * still valid, after the MTU change.
2526                  */
2527                 if (sc->hn_tx_ring[0].hn_chim_size > sc->hn_chim_szmax)
2528                         hn_set_chim_size(sc, sc->hn_chim_szmax);
2529                 hn_set_tso_maxsize(sc, hn_tso_maxlen, ifp->if_mtu);
2530 #if __FreeBSD_version >= 1100099
2531                 if (sc->hn_rx_ring[0].hn_lro.lro_length_lim <
2532                     HN_LRO_LENLIM_MIN(ifp))
2533                         hn_set_lro_lenlim(sc, HN_LRO_LENLIM_MIN(ifp));
2534 #endif
2535
2536                 /*
2537                  * All done!  Resume the interface now.
2538                  */
2539                 hn_resume(sc);
2540
2541                 HN_UNLOCK(sc);
2542                 break;
2543
2544         case SIOCSIFFLAGS:
2545                 HN_LOCK(sc);
2546
2547                 if ((sc->hn_flags & HN_FLAG_SYNTH_ATTACHED) == 0) {
2548                         HN_UNLOCK(sc);
2549                         break;
2550                 }
2551
2552                 if (ifp->if_flags & IFF_UP) {
2553                         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
2554                                 /*
2555                                  * Caller meight hold mutex, e.g.
2556                                  * bpf; use busy-wait for the RNDIS
2557                                  * reply.
2558                                  */
2559                                 HN_NO_SLEEPING(sc);
2560                                 hn_rxfilter_config(sc);
2561                                 HN_SLEEPING_OK(sc);
2562                         } else {
2563                                 hn_init_locked(sc);
2564                         }
2565                 } else {
2566                         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
2567                                 hn_stop(sc, false);
2568                 }
2569                 sc->hn_if_flags = ifp->if_flags;
2570
2571                 HN_UNLOCK(sc);
2572                 break;
2573
2574         case SIOCSIFCAP:
2575                 HN_LOCK(sc);
2576                 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
2577
2578                 if (mask & IFCAP_TXCSUM) {
2579                         ifp->if_capenable ^= IFCAP_TXCSUM;
2580                         if (ifp->if_capenable & IFCAP_TXCSUM)
2581                                 ifp->if_hwassist |= HN_CSUM_IP_HWASSIST(sc);
2582                         else
2583                                 ifp->if_hwassist &= ~HN_CSUM_IP_HWASSIST(sc);
2584                 }
2585                 if (mask & IFCAP_TXCSUM_IPV6) {
2586                         ifp->if_capenable ^= IFCAP_TXCSUM_IPV6;
2587                         if (ifp->if_capenable & IFCAP_TXCSUM_IPV6)
2588                                 ifp->if_hwassist |= HN_CSUM_IP6_HWASSIST(sc);
2589                         else
2590                                 ifp->if_hwassist &= ~HN_CSUM_IP6_HWASSIST(sc);
2591                 }
2592
2593                 /* TODO: flip RNDIS offload parameters for RXCSUM. */
2594                 if (mask & IFCAP_RXCSUM)
2595                         ifp->if_capenable ^= IFCAP_RXCSUM;
2596 #ifdef foo
2597                 /* We can't diff IPv6 packets from IPv4 packets on RX path. */
2598                 if (mask & IFCAP_RXCSUM_IPV6)
2599                         ifp->if_capenable ^= IFCAP_RXCSUM_IPV6;
2600 #endif
2601
2602                 if (mask & IFCAP_LRO)
2603                         ifp->if_capenable ^= IFCAP_LRO;
2604
2605                 if (mask & IFCAP_TSO4) {
2606                         ifp->if_capenable ^= IFCAP_TSO4;
2607                         if (ifp->if_capenable & IFCAP_TSO4)
2608                                 ifp->if_hwassist |= CSUM_IP_TSO;
2609                         else
2610                                 ifp->if_hwassist &= ~CSUM_IP_TSO;
2611                 }
2612                 if (mask & IFCAP_TSO6) {
2613                         ifp->if_capenable ^= IFCAP_TSO6;
2614                         if (ifp->if_capenable & IFCAP_TSO6)
2615                                 ifp->if_hwassist |= CSUM_IP6_TSO;
2616                         else
2617                                 ifp->if_hwassist &= ~CSUM_IP6_TSO;
2618                 }
2619
2620                 HN_UNLOCK(sc);
2621                 break;
2622
2623         case SIOCADDMULTI:
2624         case SIOCDELMULTI:
2625                 HN_LOCK(sc);
2626
2627                 if ((sc->hn_flags & HN_FLAG_SYNTH_ATTACHED) == 0) {
2628                         HN_UNLOCK(sc);
2629                         break;
2630                 }
2631                 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
2632                         /*
2633                          * Multicast uses mutex; use busy-wait for
2634                          * the RNDIS reply.
2635                          */
2636                         HN_NO_SLEEPING(sc);
2637                         hn_rxfilter_config(sc);
2638                         HN_SLEEPING_OK(sc);
2639                 }
2640
2641                 HN_UNLOCK(sc);
2642                 break;
2643
2644         case SIOCSIFMEDIA:
2645         case SIOCGIFMEDIA:
2646                 error = ifmedia_ioctl(ifp, ifr, &sc->hn_media, cmd);
2647                 break;
2648
2649         default:
2650                 error = ether_ioctl(ifp, cmd, data);
2651                 break;
2652         }
2653         return (error);
2654 }
2655
2656 static void
2657 hn_stop(struct hn_softc *sc, bool detaching)
2658 {
2659         struct ifnet *ifp = sc->hn_ifp;
2660         int i;
2661
2662         HN_LOCK_ASSERT(sc);
2663
2664         KASSERT(sc->hn_flags & HN_FLAG_SYNTH_ATTACHED,
2665             ("synthetic parts were not attached"));
2666
2667         /* Disable polling. */
2668         hn_polling(sc, 0);
2669
2670         /* Clear RUNNING bit _before_ hn_suspend_data() */
2671         atomic_clear_int(&ifp->if_drv_flags, IFF_DRV_RUNNING);
2672         hn_suspend_data(sc);
2673
2674         /* Clear OACTIVE bit. */
2675         atomic_clear_int(&ifp->if_drv_flags, IFF_DRV_OACTIVE);
2676         for (i = 0; i < sc->hn_tx_ring_inuse; ++i)
2677                 sc->hn_tx_ring[i].hn_oactive = 0;
2678
2679         /*
2680          * If the VF is active, make sure the filter is not 0, even if
2681          * the synthetic NIC is down.
2682          */
2683         if (!detaching && (sc->hn_flags & HN_FLAG_VF))
2684                 hn_rxfilter_config(sc);
2685 }
2686
2687 static void
2688 hn_init_locked(struct hn_softc *sc)
2689 {
2690         struct ifnet *ifp = sc->hn_ifp;
2691         int i;
2692
2693         HN_LOCK_ASSERT(sc);
2694
2695         if ((sc->hn_flags & HN_FLAG_SYNTH_ATTACHED) == 0)
2696                 return;
2697
2698         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
2699                 return;
2700
2701         /* Configure RX filter */
2702         hn_rxfilter_config(sc);
2703
2704         /* Clear OACTIVE bit. */
2705         atomic_clear_int(&ifp->if_drv_flags, IFF_DRV_OACTIVE);
2706         for (i = 0; i < sc->hn_tx_ring_inuse; ++i)
2707                 sc->hn_tx_ring[i].hn_oactive = 0;
2708
2709         /* Clear TX 'suspended' bit. */
2710         hn_resume_tx(sc, sc->hn_tx_ring_inuse);
2711
2712         /* Everything is ready; unleash! */
2713         atomic_set_int(&ifp->if_drv_flags, IFF_DRV_RUNNING);
2714
2715         /* Re-enable polling if requested. */
2716         if (sc->hn_pollhz > 0)
2717                 hn_polling(sc, sc->hn_pollhz);
2718 }
2719
2720 static void
2721 hn_init(void *xsc)
2722 {
2723         struct hn_softc *sc = xsc;
2724
2725         HN_LOCK(sc);
2726         hn_init_locked(sc);
2727         HN_UNLOCK(sc);
2728 }
2729
2730 #if __FreeBSD_version >= 1100099
2731
2732 static int
2733 hn_lro_lenlim_sysctl(SYSCTL_HANDLER_ARGS)
2734 {
2735         struct hn_softc *sc = arg1;
2736         unsigned int lenlim;
2737         int error;
2738
2739         lenlim = sc->hn_rx_ring[0].hn_lro.lro_length_lim;
2740         error = sysctl_handle_int(oidp, &lenlim, 0, req);
2741         if (error || req->newptr == NULL)
2742                 return error;
2743
2744         HN_LOCK(sc);
2745         if (lenlim < HN_LRO_LENLIM_MIN(sc->hn_ifp) ||
2746             lenlim > TCP_LRO_LENGTH_MAX) {
2747                 HN_UNLOCK(sc);
2748                 return EINVAL;
2749         }
2750         hn_set_lro_lenlim(sc, lenlim);
2751         HN_UNLOCK(sc);
2752
2753         return 0;
2754 }
2755
2756 static int
2757 hn_lro_ackcnt_sysctl(SYSCTL_HANDLER_ARGS)
2758 {
2759         struct hn_softc *sc = arg1;
2760         int ackcnt, error, i;
2761
2762         /*
2763          * lro_ackcnt_lim is append count limit,
2764          * +1 to turn it into aggregation limit.
2765          */
2766         ackcnt = sc->hn_rx_ring[0].hn_lro.lro_ackcnt_lim + 1;
2767         error = sysctl_handle_int(oidp, &ackcnt, 0, req);
2768         if (error || req->newptr == NULL)
2769                 return error;
2770
2771         if (ackcnt < 2 || ackcnt > (TCP_LRO_ACKCNT_MAX + 1))
2772                 return EINVAL;
2773
2774         /*
2775          * Convert aggregation limit back to append
2776          * count limit.
2777          */
2778         --ackcnt;
2779         HN_LOCK(sc);
2780         for (i = 0; i < sc->hn_rx_ring_cnt; ++i)
2781                 sc->hn_rx_ring[i].hn_lro.lro_ackcnt_lim = ackcnt;
2782         HN_UNLOCK(sc);
2783         return 0;
2784 }
2785
2786 #endif
2787
2788 static int
2789 hn_trust_hcsum_sysctl(SYSCTL_HANDLER_ARGS)
2790 {
2791         struct hn_softc *sc = arg1;
2792         int hcsum = arg2;
2793         int on, error, i;
2794
2795         on = 0;
2796         if (sc->hn_rx_ring[0].hn_trust_hcsum & hcsum)
2797                 on = 1;
2798
2799         error = sysctl_handle_int(oidp, &on, 0, req);
2800         if (error || req->newptr == NULL)
2801                 return error;
2802
2803         HN_LOCK(sc);
2804         for (i = 0; i < sc->hn_rx_ring_cnt; ++i) {
2805                 struct hn_rx_ring *rxr = &sc->hn_rx_ring[i];
2806
2807                 if (on)
2808                         rxr->hn_trust_hcsum |= hcsum;
2809                 else
2810                         rxr->hn_trust_hcsum &= ~hcsum;
2811         }
2812         HN_UNLOCK(sc);
2813         return 0;
2814 }
2815
2816 static int
2817 hn_chim_size_sysctl(SYSCTL_HANDLER_ARGS)
2818 {
2819         struct hn_softc *sc = arg1;
2820         int chim_size, error;
2821
2822         chim_size = sc->hn_tx_ring[0].hn_chim_size;
2823         error = sysctl_handle_int(oidp, &chim_size, 0, req);
2824         if (error || req->newptr == NULL)
2825                 return error;
2826
2827         if (chim_size > sc->hn_chim_szmax || chim_size <= 0)
2828                 return EINVAL;
2829
2830         HN_LOCK(sc);
2831         hn_set_chim_size(sc, chim_size);
2832         HN_UNLOCK(sc);
2833         return 0;
2834 }
2835
2836 #if __FreeBSD_version < 1100095
2837 static int
2838 hn_rx_stat_int_sysctl(SYSCTL_HANDLER_ARGS)
2839 {
2840         struct hn_softc *sc = arg1;
2841         int ofs = arg2, i, error;
2842         struct hn_rx_ring *rxr;
2843         uint64_t stat;
2844
2845         stat = 0;
2846         for (i = 0; i < sc->hn_rx_ring_inuse; ++i) {
2847                 rxr = &sc->hn_rx_ring[i];
2848                 stat += *((int *)((uint8_t *)rxr + ofs));
2849         }
2850
2851         error = sysctl_handle_64(oidp, &stat, 0, req);
2852         if (error || req->newptr == NULL)
2853                 return error;
2854
2855         /* Zero out this stat. */
2856         for (i = 0; i < sc->hn_rx_ring_inuse; ++i) {
2857                 rxr = &sc->hn_rx_ring[i];
2858                 *((int *)((uint8_t *)rxr + ofs)) = 0;
2859         }
2860         return 0;
2861 }
2862 #else
2863 static int
2864 hn_rx_stat_u64_sysctl(SYSCTL_HANDLER_ARGS)
2865 {
2866         struct hn_softc *sc = arg1;
2867         int ofs = arg2, i, error;
2868         struct hn_rx_ring *rxr;
2869         uint64_t stat;
2870
2871         stat = 0;
2872         for (i = 0; i < sc->hn_rx_ring_cnt; ++i) {
2873                 rxr = &sc->hn_rx_ring[i];
2874                 stat += *((uint64_t *)((uint8_t *)rxr + ofs));
2875         }
2876
2877         error = sysctl_handle_64(oidp, &stat, 0, req);
2878         if (error || req->newptr == NULL)
2879                 return error;
2880
2881         /* Zero out this stat. */
2882         for (i = 0; i < sc->hn_rx_ring_cnt; ++i) {
2883                 rxr = &sc->hn_rx_ring[i];
2884                 *((uint64_t *)((uint8_t *)rxr + ofs)) = 0;
2885         }
2886         return 0;
2887 }
2888
2889 #endif
2890
2891 static int
2892 hn_rx_stat_ulong_sysctl(SYSCTL_HANDLER_ARGS)
2893 {
2894         struct hn_softc *sc = arg1;
2895         int ofs = arg2, i, error;
2896         struct hn_rx_ring *rxr;
2897         u_long stat;
2898
2899         stat = 0;
2900         for (i = 0; i < sc->hn_rx_ring_cnt; ++i) {
2901                 rxr = &sc->hn_rx_ring[i];
2902                 stat += *((u_long *)((uint8_t *)rxr + ofs));
2903         }
2904
2905         error = sysctl_handle_long(oidp, &stat, 0, req);
2906         if (error || req->newptr == NULL)
2907                 return error;
2908
2909         /* Zero out this stat. */
2910         for (i = 0; i < sc->hn_rx_ring_cnt; ++i) {
2911                 rxr = &sc->hn_rx_ring[i];
2912                 *((u_long *)((uint8_t *)rxr + ofs)) = 0;
2913         }
2914         return 0;
2915 }
2916
2917 static int
2918 hn_tx_stat_ulong_sysctl(SYSCTL_HANDLER_ARGS)
2919 {
2920         struct hn_softc *sc = arg1;
2921         int ofs = arg2, i, error;
2922         struct hn_tx_ring *txr;
2923         u_long stat;
2924
2925         stat = 0;
2926         for (i = 0; i < sc->hn_tx_ring_cnt; ++i) {
2927                 txr = &sc->hn_tx_ring[i];
2928                 stat += *((u_long *)((uint8_t *)txr + ofs));
2929         }
2930
2931         error = sysctl_handle_long(oidp, &stat, 0, req);
2932         if (error || req->newptr == NULL)
2933                 return error;
2934
2935         /* Zero out this stat. */
2936         for (i = 0; i < sc->hn_tx_ring_cnt; ++i) {
2937                 txr = &sc->hn_tx_ring[i];
2938                 *((u_long *)((uint8_t *)txr + ofs)) = 0;
2939         }
2940         return 0;
2941 }
2942
2943 static int
2944 hn_tx_conf_int_sysctl(SYSCTL_HANDLER_ARGS)
2945 {
2946         struct hn_softc *sc = arg1;
2947         int ofs = arg2, i, error, conf;
2948         struct hn_tx_ring *txr;
2949
2950         txr = &sc->hn_tx_ring[0];
2951         conf = *((int *)((uint8_t *)txr + ofs));
2952
2953         error = sysctl_handle_int(oidp, &conf, 0, req);
2954         if (error || req->newptr == NULL)
2955                 return error;
2956
2957         HN_LOCK(sc);
2958         for (i = 0; i < sc->hn_tx_ring_cnt; ++i) {
2959                 txr = &sc->hn_tx_ring[i];
2960                 *((int *)((uint8_t *)txr + ofs)) = conf;
2961         }
2962         HN_UNLOCK(sc);
2963
2964         return 0;
2965 }
2966
2967 static int
2968 hn_txagg_size_sysctl(SYSCTL_HANDLER_ARGS)
2969 {
2970         struct hn_softc *sc = arg1;
2971         int error, size;
2972
2973         size = sc->hn_agg_size;
2974         error = sysctl_handle_int(oidp, &size, 0, req);
2975         if (error || req->newptr == NULL)
2976                 return (error);
2977
2978         HN_LOCK(sc);
2979         sc->hn_agg_size = size;
2980         hn_set_txagg(sc);
2981         HN_UNLOCK(sc);
2982
2983         return (0);
2984 }
2985
2986 static int
2987 hn_txagg_pkts_sysctl(SYSCTL_HANDLER_ARGS)
2988 {
2989         struct hn_softc *sc = arg1;
2990         int error, pkts;
2991
2992         pkts = sc->hn_agg_pkts;
2993         error = sysctl_handle_int(oidp, &pkts, 0, req);
2994         if (error || req->newptr == NULL)
2995                 return (error);
2996
2997         HN_LOCK(sc);
2998         sc->hn_agg_pkts = pkts;
2999         hn_set_txagg(sc);
3000         HN_UNLOCK(sc);
3001
3002         return (0);
3003 }
3004
3005 static int
3006 hn_txagg_pktmax_sysctl(SYSCTL_HANDLER_ARGS)
3007 {
3008         struct hn_softc *sc = arg1;
3009         int pkts;
3010
3011         pkts = sc->hn_tx_ring[0].hn_agg_pktmax;
3012         return (sysctl_handle_int(oidp, &pkts, 0, req));
3013 }
3014
3015 static int
3016 hn_txagg_align_sysctl(SYSCTL_HANDLER_ARGS)
3017 {
3018         struct hn_softc *sc = arg1;
3019         int align;
3020
3021         align = sc->hn_tx_ring[0].hn_agg_align;
3022         return (sysctl_handle_int(oidp, &align, 0, req));
3023 }
3024
3025 static void
3026 hn_chan_polling(struct vmbus_channel *chan, u_int pollhz)
3027 {
3028         if (pollhz == 0)
3029                 vmbus_chan_poll_disable(chan);
3030         else
3031                 vmbus_chan_poll_enable(chan, pollhz);
3032 }
3033
3034 static void
3035 hn_polling(struct hn_softc *sc, u_int pollhz)
3036 {
3037         int nsubch = sc->hn_rx_ring_inuse - 1;
3038
3039         HN_LOCK_ASSERT(sc);
3040
3041         if (nsubch > 0) {
3042                 struct vmbus_channel **subch;
3043                 int i;
3044
3045                 subch = vmbus_subchan_get(sc->hn_prichan, nsubch);
3046                 for (i = 0; i < nsubch; ++i)
3047                         hn_chan_polling(subch[i], pollhz);
3048                 vmbus_subchan_rel(subch, nsubch);
3049         }
3050         hn_chan_polling(sc->hn_prichan, pollhz);
3051 }
3052
3053 static int
3054 hn_polling_sysctl(SYSCTL_HANDLER_ARGS)
3055 {
3056         struct hn_softc *sc = arg1;
3057         int pollhz, error;
3058
3059         pollhz = sc->hn_pollhz;
3060         error = sysctl_handle_int(oidp, &pollhz, 0, req);
3061         if (error || req->newptr == NULL)
3062                 return (error);
3063
3064         if (pollhz != 0 &&
3065             (pollhz < VMBUS_CHAN_POLLHZ_MIN || pollhz > VMBUS_CHAN_POLLHZ_MAX))
3066                 return (EINVAL);
3067
3068         HN_LOCK(sc);
3069         if (sc->hn_pollhz != pollhz) {
3070                 sc->hn_pollhz = pollhz;
3071                 if ((sc->hn_ifp->if_drv_flags & IFF_DRV_RUNNING) &&
3072                     (sc->hn_flags & HN_FLAG_SYNTH_ATTACHED))
3073                         hn_polling(sc, sc->hn_pollhz);
3074         }
3075         HN_UNLOCK(sc);
3076
3077         return (0);
3078 }
3079
3080 static int
3081 hn_ndis_version_sysctl(SYSCTL_HANDLER_ARGS)
3082 {
3083         struct hn_softc *sc = arg1;
3084         char verstr[16];
3085
3086         snprintf(verstr, sizeof(verstr), "%u.%u",
3087             HN_NDIS_VERSION_MAJOR(sc->hn_ndis_ver),
3088             HN_NDIS_VERSION_MINOR(sc->hn_ndis_ver));
3089         return sysctl_handle_string(oidp, verstr, sizeof(verstr), req);
3090 }
3091
3092 static int
3093 hn_caps_sysctl(SYSCTL_HANDLER_ARGS)
3094 {
3095         struct hn_softc *sc = arg1;
3096         char caps_str[128];
3097         uint32_t caps;
3098
3099         HN_LOCK(sc);
3100         caps = sc->hn_caps;
3101         HN_UNLOCK(sc);
3102         snprintf(caps_str, sizeof(caps_str), "%b", caps, HN_CAP_BITS);
3103         return sysctl_handle_string(oidp, caps_str, sizeof(caps_str), req);
3104 }
3105
3106 static int
3107 hn_hwassist_sysctl(SYSCTL_HANDLER_ARGS)
3108 {
3109         struct hn_softc *sc = arg1;
3110         char assist_str[128];
3111         uint32_t hwassist;
3112
3113         HN_LOCK(sc);
3114         hwassist = sc->hn_ifp->if_hwassist;
3115         HN_UNLOCK(sc);
3116         snprintf(assist_str, sizeof(assist_str), "%b", hwassist, CSUM_BITS);
3117         return sysctl_handle_string(oidp, assist_str, sizeof(assist_str), req);
3118 }
3119
3120 static int
3121 hn_rxfilter_sysctl(SYSCTL_HANDLER_ARGS)
3122 {
3123         struct hn_softc *sc = arg1;
3124         char filter_str[128];
3125         uint32_t filter;
3126
3127         HN_LOCK(sc);
3128         filter = sc->hn_rx_filter;
3129         HN_UNLOCK(sc);
3130         snprintf(filter_str, sizeof(filter_str), "%b", filter,
3131             NDIS_PACKET_TYPES);
3132         return sysctl_handle_string(oidp, filter_str, sizeof(filter_str), req);
3133 }
3134
3135 static int
3136 hn_rss_key_sysctl(SYSCTL_HANDLER_ARGS)
3137 {
3138         struct hn_softc *sc = arg1;
3139         int error;
3140
3141         HN_LOCK(sc);
3142
3143         error = SYSCTL_OUT(req, sc->hn_rss.rss_key, sizeof(sc->hn_rss.rss_key));
3144         if (error || req->newptr == NULL)
3145                 goto back;
3146
3147         error = SYSCTL_IN(req, sc->hn_rss.rss_key, sizeof(sc->hn_rss.rss_key));
3148         if (error)
3149                 goto back;
3150         sc->hn_flags |= HN_FLAG_HAS_RSSKEY;
3151
3152         if (sc->hn_rx_ring_inuse > 1) {
3153                 error = hn_rss_reconfig(sc);
3154         } else {
3155                 /* Not RSS capable, at least for now; just save the RSS key. */
3156                 error = 0;
3157         }
3158 back:
3159         HN_UNLOCK(sc);
3160         return (error);
3161 }
3162
3163 static int
3164 hn_rss_ind_sysctl(SYSCTL_HANDLER_ARGS)
3165 {
3166         struct hn_softc *sc = arg1;
3167         int error;
3168
3169         HN_LOCK(sc);
3170
3171         error = SYSCTL_OUT(req, sc->hn_rss.rss_ind, sizeof(sc->hn_rss.rss_ind));
3172         if (error || req->newptr == NULL)
3173                 goto back;
3174
3175         /*
3176          * Don't allow RSS indirect table change, if this interface is not
3177          * RSS capable currently.
3178          */
3179         if (sc->hn_rx_ring_inuse == 1) {
3180                 error = EOPNOTSUPP;
3181                 goto back;
3182         }
3183
3184         error = SYSCTL_IN(req, sc->hn_rss.rss_ind, sizeof(sc->hn_rss.rss_ind));
3185         if (error)
3186                 goto back;
3187         sc->hn_flags |= HN_FLAG_HAS_RSSIND;
3188
3189         hn_rss_ind_fixup(sc);
3190         error = hn_rss_reconfig(sc);
3191 back:
3192         HN_UNLOCK(sc);
3193         return (error);
3194 }
3195
3196 static int
3197 hn_rss_hash_sysctl(SYSCTL_HANDLER_ARGS)
3198 {
3199         struct hn_softc *sc = arg1;
3200         char hash_str[128];
3201         uint32_t hash;
3202
3203         HN_LOCK(sc);
3204         hash = sc->hn_rss_hash;
3205         HN_UNLOCK(sc);
3206         snprintf(hash_str, sizeof(hash_str), "%b", hash, NDIS_HASH_BITS);
3207         return sysctl_handle_string(oidp, hash_str, sizeof(hash_str), req);
3208 }
3209
3210 static int
3211 hn_vf_sysctl(SYSCTL_HANDLER_ARGS)
3212 {
3213         struct hn_softc *sc = arg1;
3214         char vf_name[128];
3215         struct ifnet *vf;
3216
3217         HN_LOCK(sc);
3218         vf_name[0] = '\0';
3219         vf = sc->hn_rx_ring[0].hn_vf;
3220         if (vf != NULL)
3221                 snprintf(vf_name, sizeof(vf_name), "%s", if_name(vf));
3222         HN_UNLOCK(sc);
3223         return sysctl_handle_string(oidp, vf_name, sizeof(vf_name), req);
3224 }
3225
3226 static int
3227 hn_check_iplen(const struct mbuf *m, int hoff)
3228 {
3229         const struct ip *ip;
3230         int len, iphlen, iplen;
3231         const struct tcphdr *th;
3232         int thoff;                              /* TCP data offset */
3233
3234         len = hoff + sizeof(struct ip);
3235
3236         /* The packet must be at least the size of an IP header. */
3237         if (m->m_pkthdr.len < len)
3238                 return IPPROTO_DONE;
3239
3240         /* The fixed IP header must reside completely in the first mbuf. */
3241         if (m->m_len < len)
3242                 return IPPROTO_DONE;
3243
3244         ip = mtodo(m, hoff);
3245
3246         /* Bound check the packet's stated IP header length. */
3247         iphlen = ip->ip_hl << 2;
3248         if (iphlen < sizeof(struct ip))         /* minimum header length */
3249                 return IPPROTO_DONE;
3250
3251         /* The full IP header must reside completely in the one mbuf. */
3252         if (m->m_len < hoff + iphlen)
3253                 return IPPROTO_DONE;
3254
3255         iplen = ntohs(ip->ip_len);
3256
3257         /*
3258          * Check that the amount of data in the buffers is as
3259          * at least much as the IP header would have us expect.
3260          */
3261         if (m->m_pkthdr.len < hoff + iplen)
3262                 return IPPROTO_DONE;
3263
3264         /*
3265          * Ignore IP fragments.
3266          */
3267         if (ntohs(ip->ip_off) & (IP_OFFMASK | IP_MF))
3268                 return IPPROTO_DONE;
3269
3270         /*
3271          * The TCP/IP or UDP/IP header must be entirely contained within
3272          * the first fragment of a packet.
3273          */
3274         switch (ip->ip_p) {
3275         case IPPROTO_TCP:
3276                 if (iplen < iphlen + sizeof(struct tcphdr))
3277                         return IPPROTO_DONE;
3278                 if (m->m_len < hoff + iphlen + sizeof(struct tcphdr))
3279                         return IPPROTO_DONE;
3280                 th = (const struct tcphdr *)((const uint8_t *)ip + iphlen);
3281                 thoff = th->th_off << 2;
3282                 if (thoff < sizeof(struct tcphdr) || thoff + iphlen > iplen)
3283                         return IPPROTO_DONE;
3284                 if (m->m_len < hoff + iphlen + thoff)
3285                         return IPPROTO_DONE;
3286                 break;
3287         case IPPROTO_UDP:
3288                 if (iplen < iphlen + sizeof(struct udphdr))
3289                         return IPPROTO_DONE;
3290                 if (m->m_len < hoff + iphlen + sizeof(struct udphdr))
3291                         return IPPROTO_DONE;
3292                 break;
3293         default:
3294                 if (iplen < iphlen)
3295                         return IPPROTO_DONE;
3296                 break;
3297         }
3298         return ip->ip_p;
3299 }
3300
3301 static int
3302 hn_create_rx_data(struct hn_softc *sc, int ring_cnt)
3303 {
3304         struct sysctl_oid_list *child;
3305         struct sysctl_ctx_list *ctx;
3306         device_t dev = sc->hn_dev;
3307 #if defined(INET) || defined(INET6)
3308 #if __FreeBSD_version >= 1100095
3309         int lroent_cnt;
3310 #endif
3311 #endif
3312         int i;
3313
3314         /*
3315          * Create RXBUF for reception.
3316          *
3317          * NOTE:
3318          * - It is shared by all channels.
3319          * - A large enough buffer is allocated, certain version of NVSes
3320          *   may further limit the usable space.
3321          */
3322         sc->hn_rxbuf = hyperv_dmamem_alloc(bus_get_dma_tag(dev),
3323             PAGE_SIZE, 0, HN_RXBUF_SIZE, &sc->hn_rxbuf_dma,
3324             BUS_DMA_WAITOK | BUS_DMA_ZERO);
3325         if (sc->hn_rxbuf == NULL) {
3326                 device_printf(sc->hn_dev, "allocate rxbuf failed\n");
3327                 return (ENOMEM);
3328         }
3329
3330         sc->hn_rx_ring_cnt = ring_cnt;
3331         sc->hn_rx_ring_inuse = sc->hn_rx_ring_cnt;
3332
3333         sc->hn_rx_ring = malloc(sizeof(struct hn_rx_ring) * sc->hn_rx_ring_cnt,
3334             M_DEVBUF, M_WAITOK | M_ZERO);
3335
3336 #if defined(INET) || defined(INET6)
3337 #if __FreeBSD_version >= 1100095
3338         lroent_cnt = hn_lro_entry_count;
3339         if (lroent_cnt < TCP_LRO_ENTRIES)
3340                 lroent_cnt = TCP_LRO_ENTRIES;
3341         if (bootverbose)
3342                 device_printf(dev, "LRO: entry count %d\n", lroent_cnt);
3343 #endif
3344 #endif  /* INET || INET6 */
3345
3346         ctx = device_get_sysctl_ctx(dev);
3347         child = SYSCTL_CHILDREN(device_get_sysctl_tree(dev));
3348
3349         /* Create dev.hn.UNIT.rx sysctl tree */
3350         sc->hn_rx_sysctl_tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "rx",
3351             CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
3352
3353         for (i = 0; i < sc->hn_rx_ring_cnt; ++i) {
3354                 struct hn_rx_ring *rxr = &sc->hn_rx_ring[i];
3355
3356                 rxr->hn_br = hyperv_dmamem_alloc(bus_get_dma_tag(dev),
3357                     PAGE_SIZE, 0, HN_TXBR_SIZE + HN_RXBR_SIZE,
3358                     &rxr->hn_br_dma, BUS_DMA_WAITOK);
3359                 if (rxr->hn_br == NULL) {
3360                         device_printf(dev, "allocate bufring failed\n");
3361                         return (ENOMEM);
3362                 }
3363
3364                 if (hn_trust_hosttcp)
3365                         rxr->hn_trust_hcsum |= HN_TRUST_HCSUM_TCP;
3366                 if (hn_trust_hostudp)
3367                         rxr->hn_trust_hcsum |= HN_TRUST_HCSUM_UDP;
3368                 if (hn_trust_hostip)
3369                         rxr->hn_trust_hcsum |= HN_TRUST_HCSUM_IP;
3370                 rxr->hn_ifp = sc->hn_ifp;
3371                 if (i < sc->hn_tx_ring_cnt)
3372                         rxr->hn_txr = &sc->hn_tx_ring[i];
3373                 rxr->hn_pktbuf_len = HN_PKTBUF_LEN_DEF;
3374                 rxr->hn_pktbuf = malloc(rxr->hn_pktbuf_len, M_DEVBUF, M_WAITOK);
3375                 rxr->hn_rx_idx = i;
3376                 rxr->hn_rxbuf = sc->hn_rxbuf;
3377
3378                 /*
3379                  * Initialize LRO.
3380                  */
3381 #if defined(INET) || defined(INET6)
3382 #if __FreeBSD_version >= 1100095
3383                 tcp_lro_init_args(&rxr->hn_lro, sc->hn_ifp, lroent_cnt,
3384                     hn_lro_mbufq_depth);
3385 #else
3386                 tcp_lro_init(&rxr->hn_lro);
3387                 rxr->hn_lro.ifp = sc->hn_ifp;
3388 #endif
3389 #if __FreeBSD_version >= 1100099
3390                 rxr->hn_lro.lro_length_lim = HN_LRO_LENLIM_DEF;
3391                 rxr->hn_lro.lro_ackcnt_lim = HN_LRO_ACKCNT_DEF;
3392 #endif
3393 #endif  /* INET || INET6 */
3394
3395                 if (sc->hn_rx_sysctl_tree != NULL) {
3396                         char name[16];
3397
3398                         /*
3399                          * Create per RX ring sysctl tree:
3400                          * dev.hn.UNIT.rx.RINGID
3401                          */
3402                         snprintf(name, sizeof(name), "%d", i);
3403                         rxr->hn_rx_sysctl_tree = SYSCTL_ADD_NODE(ctx,
3404                             SYSCTL_CHILDREN(sc->hn_rx_sysctl_tree),
3405                             OID_AUTO, name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
3406
3407                         if (rxr->hn_rx_sysctl_tree != NULL) {
3408                                 SYSCTL_ADD_ULONG(ctx,
3409                                     SYSCTL_CHILDREN(rxr->hn_rx_sysctl_tree),
3410                                     OID_AUTO, "packets", CTLFLAG_RW,
3411                                     &rxr->hn_pkts, "# of packets received");
3412                                 SYSCTL_ADD_ULONG(ctx,
3413                                     SYSCTL_CHILDREN(rxr->hn_rx_sysctl_tree),
3414                                     OID_AUTO, "rss_pkts", CTLFLAG_RW,
3415                                     &rxr->hn_rss_pkts,
3416                                     "# of packets w/ RSS info received");
3417                                 SYSCTL_ADD_INT(ctx,
3418                                     SYSCTL_CHILDREN(rxr->hn_rx_sysctl_tree),
3419                                     OID_AUTO, "pktbuf_len", CTLFLAG_RD,
3420                                     &rxr->hn_pktbuf_len, 0,
3421                                     "Temporary channel packet buffer length");
3422                         }
3423                 }
3424         }
3425
3426         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "lro_queued",
3427             CTLTYPE_U64 | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3428             __offsetof(struct hn_rx_ring, hn_lro.lro_queued),
3429 #if __FreeBSD_version < 1100095
3430             hn_rx_stat_int_sysctl,
3431 #else
3432             hn_rx_stat_u64_sysctl,
3433 #endif
3434             "LU", "LRO queued");
3435         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "lro_flushed",
3436             CTLTYPE_U64 | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3437             __offsetof(struct hn_rx_ring, hn_lro.lro_flushed),
3438 #if __FreeBSD_version < 1100095
3439             hn_rx_stat_int_sysctl,
3440 #else
3441             hn_rx_stat_u64_sysctl,
3442 #endif
3443             "LU", "LRO flushed");
3444         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "lro_tried",
3445             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3446             __offsetof(struct hn_rx_ring, hn_lro_tried),
3447             hn_rx_stat_ulong_sysctl, "LU", "# of LRO tries");
3448 #if __FreeBSD_version >= 1100099
3449         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "lro_length_lim",
3450             CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
3451             hn_lro_lenlim_sysctl, "IU",
3452             "Max # of data bytes to be aggregated by LRO");
3453         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "lro_ackcnt_lim",
3454             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
3455             hn_lro_ackcnt_sysctl, "I",
3456             "Max # of ACKs to be aggregated by LRO");
3457 #endif
3458         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "trust_hosttcp",
3459             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, HN_TRUST_HCSUM_TCP,
3460             hn_trust_hcsum_sysctl, "I",
3461             "Trust tcp segement verification on host side, "
3462             "when csum info is missing");
3463         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "trust_hostudp",
3464             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, HN_TRUST_HCSUM_UDP,
3465             hn_trust_hcsum_sysctl, "I",
3466             "Trust udp datagram verification on host side, "
3467             "when csum info is missing");
3468         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "trust_hostip",
3469             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, HN_TRUST_HCSUM_IP,
3470             hn_trust_hcsum_sysctl, "I",
3471             "Trust ip packet verification on host side, "
3472             "when csum info is missing");
3473         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "csum_ip",
3474             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3475             __offsetof(struct hn_rx_ring, hn_csum_ip),
3476             hn_rx_stat_ulong_sysctl, "LU", "RXCSUM IP");
3477         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "csum_tcp",
3478             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3479             __offsetof(struct hn_rx_ring, hn_csum_tcp),
3480             hn_rx_stat_ulong_sysctl, "LU", "RXCSUM TCP");
3481         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "csum_udp",
3482             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3483             __offsetof(struct hn_rx_ring, hn_csum_udp),
3484             hn_rx_stat_ulong_sysctl, "LU", "RXCSUM UDP");
3485         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "csum_trusted",
3486             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3487             __offsetof(struct hn_rx_ring, hn_csum_trusted),
3488             hn_rx_stat_ulong_sysctl, "LU",
3489             "# of packets that we trust host's csum verification");
3490         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "small_pkts",
3491             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3492             __offsetof(struct hn_rx_ring, hn_small_pkts),
3493             hn_rx_stat_ulong_sysctl, "LU", "# of small packets received");
3494         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "rx_ack_failed",
3495             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3496             __offsetof(struct hn_rx_ring, hn_ack_failed),
3497             hn_rx_stat_ulong_sysctl, "LU", "# of RXBUF ack failures");
3498         SYSCTL_ADD_INT(ctx, child, OID_AUTO, "rx_ring_cnt",
3499             CTLFLAG_RD, &sc->hn_rx_ring_cnt, 0, "# created RX rings");
3500         SYSCTL_ADD_INT(ctx, child, OID_AUTO, "rx_ring_inuse",
3501             CTLFLAG_RD, &sc->hn_rx_ring_inuse, 0, "# used RX rings");
3502
3503         return (0);
3504 }
3505
3506 static void
3507 hn_destroy_rx_data(struct hn_softc *sc)
3508 {
3509         int i;
3510
3511         if (sc->hn_rxbuf != NULL) {
3512                 if ((sc->hn_flags & HN_FLAG_RXBUF_REF) == 0)
3513                         hyperv_dmamem_free(&sc->hn_rxbuf_dma, sc->hn_rxbuf);
3514                 else
3515                         device_printf(sc->hn_dev, "RXBUF is referenced\n");
3516                 sc->hn_rxbuf = NULL;
3517         }
3518
3519         if (sc->hn_rx_ring_cnt == 0)
3520                 return;
3521
3522         for (i = 0; i < sc->hn_rx_ring_cnt; ++i) {
3523                 struct hn_rx_ring *rxr = &sc->hn_rx_ring[i];
3524
3525                 if (rxr->hn_br == NULL)
3526                         continue;
3527                 if ((rxr->hn_rx_flags & HN_RX_FLAG_BR_REF) == 0) {
3528                         hyperv_dmamem_free(&rxr->hn_br_dma, rxr->hn_br);
3529                 } else {
3530                         device_printf(sc->hn_dev,
3531                             "%dth channel bufring is referenced", i);
3532                 }
3533                 rxr->hn_br = NULL;
3534
3535 #if defined(INET) || defined(INET6)
3536                 tcp_lro_free(&rxr->hn_lro);
3537 #endif
3538                 free(rxr->hn_pktbuf, M_DEVBUF);
3539         }
3540         free(sc->hn_rx_ring, M_DEVBUF);
3541         sc->hn_rx_ring = NULL;
3542
3543         sc->hn_rx_ring_cnt = 0;
3544         sc->hn_rx_ring_inuse = 0;
3545 }
3546
3547 static int
3548 hn_tx_ring_create(struct hn_softc *sc, int id)
3549 {
3550         struct hn_tx_ring *txr = &sc->hn_tx_ring[id];
3551         device_t dev = sc->hn_dev;
3552         bus_dma_tag_t parent_dtag;
3553         int error, i;
3554
3555         txr->hn_sc = sc;
3556         txr->hn_tx_idx = id;
3557
3558 #ifndef HN_USE_TXDESC_BUFRING
3559         mtx_init(&txr->hn_txlist_spin, "hn txlist", NULL, MTX_SPIN);
3560 #endif
3561         mtx_init(&txr->hn_tx_lock, "hn tx", NULL, MTX_DEF);
3562
3563         txr->hn_txdesc_cnt = HN_TX_DESC_CNT;
3564         txr->hn_txdesc = malloc(sizeof(struct hn_txdesc) * txr->hn_txdesc_cnt,
3565             M_DEVBUF, M_WAITOK | M_ZERO);
3566 #ifndef HN_USE_TXDESC_BUFRING
3567         SLIST_INIT(&txr->hn_txlist);
3568 #else
3569         txr->hn_txdesc_br = buf_ring_alloc(txr->hn_txdesc_cnt, M_DEVBUF,
3570             M_WAITOK, &txr->hn_tx_lock);
3571 #endif
3572
3573         if (hn_tx_taskq_mode == HN_TX_TASKQ_M_EVTTQ) {
3574                 txr->hn_tx_taskq = VMBUS_GET_EVENT_TASKQ(
3575                     device_get_parent(dev), dev, HN_RING_IDX2CPU(sc, id));
3576         } else {
3577                 txr->hn_tx_taskq = sc->hn_tx_taskqs[id % hn_tx_taskq_cnt];
3578         }
3579
3580 #ifdef HN_IFSTART_SUPPORT
3581         if (hn_use_if_start) {
3582                 txr->hn_txeof = hn_start_txeof;
3583                 TASK_INIT(&txr->hn_tx_task, 0, hn_start_taskfunc, txr);
3584                 TASK_INIT(&txr->hn_txeof_task, 0, hn_start_txeof_taskfunc, txr);
3585         } else
3586 #endif
3587         {
3588                 int br_depth;
3589
3590                 txr->hn_txeof = hn_xmit_txeof;
3591                 TASK_INIT(&txr->hn_tx_task, 0, hn_xmit_taskfunc, txr);
3592                 TASK_INIT(&txr->hn_txeof_task, 0, hn_xmit_txeof_taskfunc, txr);
3593
3594                 br_depth = hn_get_txswq_depth(txr);
3595                 txr->hn_mbuf_br = buf_ring_alloc(br_depth, M_DEVBUF,
3596                     M_WAITOK, &txr->hn_tx_lock);
3597         }
3598
3599         txr->hn_direct_tx_size = hn_direct_tx_size;
3600
3601         /*
3602          * Always schedule transmission instead of trying to do direct
3603          * transmission.  This one gives the best performance so far.
3604          */
3605         txr->hn_sched_tx = 1;
3606
3607         parent_dtag = bus_get_dma_tag(dev);
3608
3609         /* DMA tag for RNDIS packet messages. */
3610         error = bus_dma_tag_create(parent_dtag, /* parent */
3611             HN_RNDIS_PKT_ALIGN,         /* alignment */
3612             HN_RNDIS_PKT_BOUNDARY,      /* boundary */
3613             BUS_SPACE_MAXADDR,          /* lowaddr */
3614             BUS_SPACE_MAXADDR,          /* highaddr */
3615             NULL, NULL,                 /* filter, filterarg */
3616             HN_RNDIS_PKT_LEN,           /* maxsize */
3617             1,                          /* nsegments */
3618             HN_RNDIS_PKT_LEN,           /* maxsegsize */
3619             0,                          /* flags */
3620             NULL,                       /* lockfunc */
3621             NULL,                       /* lockfuncarg */
3622             &txr->hn_tx_rndis_dtag);
3623         if (error) {
3624                 device_printf(dev, "failed to create rndis dmatag\n");
3625                 return error;
3626         }
3627
3628         /* DMA tag for data. */
3629         error = bus_dma_tag_create(parent_dtag, /* parent */
3630             1,                          /* alignment */
3631             HN_TX_DATA_BOUNDARY,        /* boundary */
3632             BUS_SPACE_MAXADDR,          /* lowaddr */
3633             BUS_SPACE_MAXADDR,          /* highaddr */
3634             NULL, NULL,                 /* filter, filterarg */
3635             HN_TX_DATA_MAXSIZE,         /* maxsize */
3636             HN_TX_DATA_SEGCNT_MAX,      /* nsegments */
3637             HN_TX_DATA_SEGSIZE,         /* maxsegsize */
3638             0,                          /* flags */
3639             NULL,                       /* lockfunc */
3640             NULL,                       /* lockfuncarg */
3641             &txr->hn_tx_data_dtag);
3642         if (error) {
3643                 device_printf(dev, "failed to create data dmatag\n");
3644                 return error;
3645         }
3646
3647         for (i = 0; i < txr->hn_txdesc_cnt; ++i) {
3648                 struct hn_txdesc *txd = &txr->hn_txdesc[i];
3649
3650                 txd->txr = txr;
3651                 txd->chim_index = HN_NVS_CHIM_IDX_INVALID;
3652                 STAILQ_INIT(&txd->agg_list);
3653
3654                 /*
3655                  * Allocate and load RNDIS packet message.
3656                  */
3657                 error = bus_dmamem_alloc(txr->hn_tx_rndis_dtag,
3658                     (void **)&txd->rndis_pkt,
3659                     BUS_DMA_WAITOK | BUS_DMA_COHERENT | BUS_DMA_ZERO,
3660                     &txd->rndis_pkt_dmap);
3661                 if (error) {
3662                         device_printf(dev,
3663                             "failed to allocate rndis_packet_msg, %d\n", i);
3664                         return error;
3665                 }
3666
3667                 error = bus_dmamap_load(txr->hn_tx_rndis_dtag,
3668                     txd->rndis_pkt_dmap,
3669                     txd->rndis_pkt, HN_RNDIS_PKT_LEN,
3670                     hyperv_dma_map_paddr, &txd->rndis_pkt_paddr,
3671                     BUS_DMA_NOWAIT);
3672                 if (error) {
3673                         device_printf(dev,
3674                             "failed to load rndis_packet_msg, %d\n", i);
3675                         bus_dmamem_free(txr->hn_tx_rndis_dtag,
3676                             txd->rndis_pkt, txd->rndis_pkt_dmap);
3677                         return error;
3678                 }
3679
3680                 /* DMA map for TX data. */
3681                 error = bus_dmamap_create(txr->hn_tx_data_dtag, 0,
3682                     &txd->data_dmap);
3683                 if (error) {
3684                         device_printf(dev,
3685                             "failed to allocate tx data dmamap\n");
3686                         bus_dmamap_unload(txr->hn_tx_rndis_dtag,
3687                             txd->rndis_pkt_dmap);
3688                         bus_dmamem_free(txr->hn_tx_rndis_dtag,
3689                             txd->rndis_pkt, txd->rndis_pkt_dmap);
3690                         return error;
3691                 }
3692
3693                 /* All set, put it to list */
3694                 txd->flags |= HN_TXD_FLAG_ONLIST;
3695 #ifndef HN_USE_TXDESC_BUFRING
3696                 SLIST_INSERT_HEAD(&txr->hn_txlist, txd, link);
3697 #else
3698                 buf_ring_enqueue(txr->hn_txdesc_br, txd);
3699 #endif
3700         }
3701         txr->hn_txdesc_avail = txr->hn_txdesc_cnt;
3702
3703         if (sc->hn_tx_sysctl_tree != NULL) {
3704                 struct sysctl_oid_list *child;
3705                 struct sysctl_ctx_list *ctx;
3706                 char name[16];
3707
3708                 /*
3709                  * Create per TX ring sysctl tree:
3710                  * dev.hn.UNIT.tx.RINGID
3711                  */
3712                 ctx = device_get_sysctl_ctx(dev);
3713                 child = SYSCTL_CHILDREN(sc->hn_tx_sysctl_tree);
3714
3715                 snprintf(name, sizeof(name), "%d", id);
3716                 txr->hn_tx_sysctl_tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO,
3717                     name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
3718
3719                 if (txr->hn_tx_sysctl_tree != NULL) {
3720                         child = SYSCTL_CHILDREN(txr->hn_tx_sysctl_tree);
3721
3722 #ifdef HN_DEBUG
3723                         SYSCTL_ADD_INT(ctx, child, OID_AUTO, "txdesc_avail",
3724                             CTLFLAG_RD, &txr->hn_txdesc_avail, 0,
3725                             "# of available TX descs");
3726 #endif
3727 #ifdef HN_IFSTART_SUPPORT
3728                         if (!hn_use_if_start)
3729 #endif
3730                         {
3731                                 SYSCTL_ADD_INT(ctx, child, OID_AUTO, "oactive",
3732                                     CTLFLAG_RD, &txr->hn_oactive, 0,
3733                                     "over active");
3734                         }
3735                         SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "packets",
3736                             CTLFLAG_RW, &txr->hn_pkts,
3737                             "# of packets transmitted");
3738                         SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "sends",
3739                             CTLFLAG_RW, &txr->hn_sends, "# of sends");
3740                 }
3741         }
3742
3743         return 0;
3744 }
3745
3746 static void
3747 hn_txdesc_dmamap_destroy(struct hn_txdesc *txd)
3748 {
3749         struct hn_tx_ring *txr = txd->txr;
3750
3751         KASSERT(txd->m == NULL, ("still has mbuf installed"));
3752         KASSERT((txd->flags & HN_TXD_FLAG_DMAMAP) == 0, ("still dma mapped"));
3753
3754         bus_dmamap_unload(txr->hn_tx_rndis_dtag, txd->rndis_pkt_dmap);
3755         bus_dmamem_free(txr->hn_tx_rndis_dtag, txd->rndis_pkt,
3756             txd->rndis_pkt_dmap);
3757         bus_dmamap_destroy(txr->hn_tx_data_dtag, txd->data_dmap);
3758 }
3759
3760 static void
3761 hn_txdesc_gc(struct hn_tx_ring *txr, struct hn_txdesc *txd)
3762 {
3763
3764         KASSERT(txd->refs == 0 || txd->refs == 1,
3765             ("invalid txd refs %d", txd->refs));
3766
3767         /* Aggregated txds will be freed by their aggregating txd. */
3768         if (txd->refs > 0 && (txd->flags & HN_TXD_FLAG_ONAGG) == 0) {
3769                 int freed;
3770
3771                 freed = hn_txdesc_put(txr, txd);
3772                 KASSERT(freed, ("can't free txdesc"));
3773         }
3774 }
3775
3776 static void
3777 hn_tx_ring_destroy(struct hn_tx_ring *txr)
3778 {
3779         int i;
3780
3781         if (txr->hn_txdesc == NULL)
3782                 return;
3783
3784         /*
3785          * NOTE:
3786          * Because the freeing of aggregated txds will be deferred
3787          * to the aggregating txd, two passes are used here:
3788          * - The first pass GCes any pending txds.  This GC is necessary,
3789          *   since if the channels are revoked, hypervisor will not
3790          *   deliver send-done for all pending txds.
3791          * - The second pass frees the busdma stuffs, i.e. after all txds
3792          *   were freed.
3793          */
3794         for (i = 0; i < txr->hn_txdesc_cnt; ++i)
3795                 hn_txdesc_gc(txr, &txr->hn_txdesc[i]);
3796         for (i = 0; i < txr->hn_txdesc_cnt; ++i)
3797                 hn_txdesc_dmamap_destroy(&txr->hn_txdesc[i]);
3798
3799         if (txr->hn_tx_data_dtag != NULL)
3800                 bus_dma_tag_destroy(txr->hn_tx_data_dtag);
3801         if (txr->hn_tx_rndis_dtag != NULL)
3802                 bus_dma_tag_destroy(txr->hn_tx_rndis_dtag);
3803
3804 #ifdef HN_USE_TXDESC_BUFRING
3805         buf_ring_free(txr->hn_txdesc_br, M_DEVBUF);
3806 #endif
3807
3808         free(txr->hn_txdesc, M_DEVBUF);
3809         txr->hn_txdesc = NULL;
3810
3811         if (txr->hn_mbuf_br != NULL)
3812                 buf_ring_free(txr->hn_mbuf_br, M_DEVBUF);
3813
3814 #ifndef HN_USE_TXDESC_BUFRING
3815         mtx_destroy(&txr->hn_txlist_spin);
3816 #endif
3817         mtx_destroy(&txr->hn_tx_lock);
3818 }
3819
3820 static int
3821 hn_create_tx_data(struct hn_softc *sc, int ring_cnt)
3822 {
3823         struct sysctl_oid_list *child;
3824         struct sysctl_ctx_list *ctx;
3825         int i;
3826
3827         /*
3828          * Create TXBUF for chimney sending.
3829          *
3830          * NOTE: It is shared by all channels.
3831          */
3832         sc->hn_chim = hyperv_dmamem_alloc(bus_get_dma_tag(sc->hn_dev),
3833             PAGE_SIZE, 0, HN_CHIM_SIZE, &sc->hn_chim_dma,
3834             BUS_DMA_WAITOK | BUS_DMA_ZERO);
3835         if (sc->hn_chim == NULL) {
3836                 device_printf(sc->hn_dev, "allocate txbuf failed\n");
3837                 return (ENOMEM);
3838         }
3839
3840         sc->hn_tx_ring_cnt = ring_cnt;
3841         sc->hn_tx_ring_inuse = sc->hn_tx_ring_cnt;
3842
3843         sc->hn_tx_ring = malloc(sizeof(struct hn_tx_ring) * sc->hn_tx_ring_cnt,
3844             M_DEVBUF, M_WAITOK | M_ZERO);
3845
3846         ctx = device_get_sysctl_ctx(sc->hn_dev);
3847         child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->hn_dev));
3848
3849         /* Create dev.hn.UNIT.tx sysctl tree */
3850         sc->hn_tx_sysctl_tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "tx",
3851             CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
3852
3853         for (i = 0; i < sc->hn_tx_ring_cnt; ++i) {
3854                 int error;
3855
3856                 error = hn_tx_ring_create(sc, i);
3857                 if (error)
3858                         return error;
3859         }
3860
3861         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "no_txdescs",
3862             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3863             __offsetof(struct hn_tx_ring, hn_no_txdescs),
3864             hn_tx_stat_ulong_sysctl, "LU", "# of times short of TX descs");
3865         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "send_failed",
3866             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3867             __offsetof(struct hn_tx_ring, hn_send_failed),
3868             hn_tx_stat_ulong_sysctl, "LU", "# of hyper-v sending failure");
3869         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "txdma_failed",
3870             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3871             __offsetof(struct hn_tx_ring, hn_txdma_failed),
3872             hn_tx_stat_ulong_sysctl, "LU", "# of TX DMA failure");
3873         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "agg_flush_failed",
3874             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3875             __offsetof(struct hn_tx_ring, hn_flush_failed),
3876             hn_tx_stat_ulong_sysctl, "LU",
3877             "# of packet transmission aggregation flush failure");
3878         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "tx_collapsed",
3879             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3880             __offsetof(struct hn_tx_ring, hn_tx_collapsed),
3881             hn_tx_stat_ulong_sysctl, "LU", "# of TX mbuf collapsed");
3882         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "tx_chimney",
3883             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3884             __offsetof(struct hn_tx_ring, hn_tx_chimney),
3885             hn_tx_stat_ulong_sysctl, "LU", "# of chimney send");
3886         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "tx_chimney_tried",
3887             CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3888             __offsetof(struct hn_tx_ring, hn_tx_chimney_tried),
3889             hn_tx_stat_ulong_sysctl, "LU", "# of chimney send tries");
3890         SYSCTL_ADD_INT(ctx, child, OID_AUTO, "txdesc_cnt",
3891             CTLFLAG_RD, &sc->hn_tx_ring[0].hn_txdesc_cnt, 0,
3892             "# of total TX descs");
3893         SYSCTL_ADD_INT(ctx, child, OID_AUTO, "tx_chimney_max",
3894             CTLFLAG_RD, &sc->hn_chim_szmax, 0,
3895             "Chimney send packet size upper boundary");
3896         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "tx_chimney_size",
3897             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0,
3898             hn_chim_size_sysctl, "I", "Chimney send packet size limit");
3899         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "direct_tx_size",
3900             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3901             __offsetof(struct hn_tx_ring, hn_direct_tx_size),
3902             hn_tx_conf_int_sysctl, "I",
3903             "Size of the packet for direct transmission");
3904         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "sched_tx",
3905             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, sc,
3906             __offsetof(struct hn_tx_ring, hn_sched_tx),
3907             hn_tx_conf_int_sysctl, "I",
3908             "Always schedule transmission "
3909             "instead of doing direct transmission");
3910         SYSCTL_ADD_INT(ctx, child, OID_AUTO, "tx_ring_cnt",
3911             CTLFLAG_RD, &sc->hn_tx_ring_cnt, 0, "# created TX rings");
3912         SYSCTL_ADD_INT(ctx, child, OID_AUTO, "tx_ring_inuse",
3913             CTLFLAG_RD, &sc->hn_tx_ring_inuse, 0, "# used TX rings");
3914         SYSCTL_ADD_INT(ctx, child, OID_AUTO, "agg_szmax",
3915             CTLFLAG_RD, &sc->hn_tx_ring[0].hn_agg_szmax, 0,
3916             "Applied packet transmission aggregation size");
3917         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "agg_pktmax",
3918             CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, sc, 0,
3919             hn_txagg_pktmax_sysctl, "I",
3920             "Applied packet transmission aggregation packets");
3921         SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "agg_align",
3922             CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, sc, 0,
3923             hn_txagg_align_sysctl, "I",
3924             "Applied packet transmission aggregation alignment");
3925
3926         return 0;
3927 }
3928
3929 static void
3930 hn_set_chim_size(struct hn_softc *sc, int chim_size)
3931 {
3932         int i;
3933
3934         for (i = 0; i < sc->hn_tx_ring_cnt; ++i)
3935                 sc->hn_tx_ring[i].hn_chim_size = chim_size;
3936 }
3937
3938 static void
3939 hn_set_tso_maxsize(struct hn_softc *sc, int tso_maxlen, int mtu)
3940 {
3941         struct ifnet *ifp = sc->hn_ifp;
3942         int tso_minlen;
3943
3944         if ((ifp->if_capabilities & (IFCAP_TSO4 | IFCAP_TSO6)) == 0)
3945                 return;
3946
3947         KASSERT(sc->hn_ndis_tso_sgmin >= 2,
3948             ("invalid NDIS tso sgmin %d", sc->hn_ndis_tso_sgmin));
3949         tso_minlen = sc->hn_ndis_tso_sgmin * mtu;
3950
3951         KASSERT(sc->hn_ndis_tso_szmax >= tso_minlen &&
3952             sc->hn_ndis_tso_szmax <= IP_MAXPACKET,
3953             ("invalid NDIS tso szmax %d", sc->hn_ndis_tso_szmax));
3954
3955         if (tso_maxlen < tso_minlen)
3956                 tso_maxlen = tso_minlen;
3957         else if (tso_maxlen > IP_MAXPACKET)
3958                 tso_maxlen = IP_MAXPACKET;
3959         if (tso_maxlen > sc->hn_ndis_tso_szmax)
3960                 tso_maxlen = sc->hn_ndis_tso_szmax;
3961         ifp->if_hw_tsomax = tso_maxlen - (ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN);
3962         if (bootverbose)
3963                 if_printf(ifp, "TSO size max %u\n", ifp->if_hw_tsomax);
3964 }
3965
3966 static void
3967 hn_fixup_tx_data(struct hn_softc *sc)
3968 {
3969         uint64_t csum_assist;
3970         int i;
3971
3972         hn_set_chim_size(sc, sc->hn_chim_szmax);
3973         if (hn_tx_chimney_size > 0 &&
3974             hn_tx_chimney_size < sc->hn_chim_szmax)
3975                 hn_set_chim_size(sc, hn_tx_chimney_size);
3976
3977         csum_assist = 0;
3978         if (sc->hn_caps & HN_CAP_IPCS)
3979                 csum_assist |= CSUM_IP;
3980         if (sc->hn_caps & HN_CAP_TCP4CS)
3981                 csum_assist |= CSUM_IP_TCP;
3982         if (sc->hn_caps & HN_CAP_UDP4CS)
3983                 csum_assist |= CSUM_IP_UDP;
3984         if (sc->hn_caps & HN_CAP_TCP6CS)
3985                 csum_assist |= CSUM_IP6_TCP;
3986         if (sc->hn_caps & HN_CAP_UDP6CS)
3987                 csum_assist |= CSUM_IP6_UDP;
3988         for (i = 0; i < sc->hn_tx_ring_cnt; ++i)
3989                 sc->hn_tx_ring[i].hn_csum_assist = csum_assist;
3990
3991         if (sc->hn_caps & HN_CAP_HASHVAL) {
3992                 /*
3993                  * Support HASHVAL pktinfo on TX path.
3994                  */
3995                 if (bootverbose)
3996                         if_printf(sc->hn_ifp, "support HASHVAL pktinfo\n");
3997                 for (i = 0; i < sc->hn_tx_ring_cnt; ++i)
3998                         sc->hn_tx_ring[i].hn_tx_flags |= HN_TX_FLAG_HASHVAL;
3999         }
4000 }
4001
4002 static void
4003 hn_destroy_tx_data(struct hn_softc *sc)
4004 {
4005         int i;
4006
4007         if (sc->hn_chim != NULL) {
4008                 if ((sc->hn_flags & HN_FLAG_CHIM_REF) == 0) {
4009                         hyperv_dmamem_free(&sc->hn_chim_dma, sc->hn_chim);
4010                 } else {
4011                         device_printf(sc->hn_dev,
4012                             "chimney sending buffer is referenced");
4013                 }
4014                 sc->hn_chim = NULL;
4015         }
4016
4017         if (sc->hn_tx_ring_cnt == 0)
4018                 return;
4019
4020         for (i = 0; i < sc->hn_tx_ring_cnt; ++i)
4021                 hn_tx_ring_destroy(&sc->hn_tx_ring[i]);
4022
4023         free(sc->hn_tx_ring, M_DEVBUF);
4024         sc->hn_tx_ring = NULL;
4025
4026         sc->hn_tx_ring_cnt = 0;
4027         sc->hn_tx_ring_inuse = 0;
4028 }
4029
4030 #ifdef HN_IFSTART_SUPPORT
4031
4032 static void
4033 hn_start_taskfunc(void *xtxr, int pending __unused)
4034 {
4035         struct hn_tx_ring *txr = xtxr;
4036
4037         mtx_lock(&txr->hn_tx_lock);
4038         hn_start_locked(txr, 0);
4039         mtx_unlock(&txr->hn_tx_lock);
4040 }
4041
4042 static int
4043 hn_start_locked(struct hn_tx_ring *txr, int len)
4044 {
4045         struct hn_softc *sc = txr->hn_sc;
4046         struct ifnet *ifp = sc->hn_ifp;
4047         int sched = 0;
4048
4049         KASSERT(hn_use_if_start,
4050             ("hn_start_locked is called, when if_start is disabled"));
4051         KASSERT(txr == &sc->hn_tx_ring[0], ("not the first TX ring"));
4052         mtx_assert(&txr->hn_tx_lock, MA_OWNED);
4053         KASSERT(txr->hn_agg_txd == NULL, ("lingering aggregating txdesc"));
4054
4055         if (__predict_false(txr->hn_suspended))
4056                 return (0);
4057
4058         if ((ifp->if_drv_flags & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) !=
4059             IFF_DRV_RUNNING)
4060                 return (0);
4061
4062         while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
4063                 struct hn_txdesc *txd;
4064                 struct mbuf *m_head;
4065                 int error;
4066
4067                 IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
4068                 if (m_head == NULL)
4069                         break;
4070
4071                 if (len > 0 && m_head->m_pkthdr.len > len) {
4072                         /*
4073                          * This sending could be time consuming; let callers
4074                          * dispatch this packet sending (and sending of any
4075                          * following up packets) to tx taskqueue.
4076                          */
4077                         IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
4078                         sched = 1;
4079                         break;
4080                 }
4081
4082 #if defined(INET6) || defined(INET)
4083                 if (m_head->m_pkthdr.csum_flags & CSUM_TSO) {
4084                         m_head = hn_tso_fixup(m_head);
4085                         if (__predict_false(m_head == NULL)) {
4086                                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
4087                                 continue;
4088                         }
4089                 }
4090 #endif
4091
4092                 txd = hn_txdesc_get(txr);
4093                 if (txd == NULL) {
4094                         txr->hn_no_txdescs++;
4095                         IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
4096                         atomic_set_int(&ifp->if_drv_flags, IFF_DRV_OACTIVE);
4097                         break;
4098                 }
4099
4100                 error = hn_encap(ifp, txr, txd, &m_head);
4101                 if (error) {
4102                         /* Both txd and m_head are freed */
4103                         KASSERT(txr->hn_agg_txd == NULL,
4104                             ("encap failed w/ pending aggregating txdesc"));
4105                         continue;
4106                 }
4107
4108                 if (txr->hn_agg_pktleft == 0) {
4109                         if (txr->hn_agg_txd != NULL) {
4110                                 KASSERT(m_head == NULL,
4111                                     ("pending mbuf for aggregating txdesc"));
4112                                 error = hn_flush_txagg(ifp, txr);
4113                                 if (__predict_false(error)) {
4114                                         atomic_set_int(&ifp->if_drv_flags,
4115                                             IFF_DRV_OACTIVE);
4116                                         break;
4117                                 }
4118                         } else {
4119                                 KASSERT(m_head != NULL, ("mbuf was freed"));
4120                                 error = hn_txpkt(ifp, txr, txd);
4121                                 if (__predict_false(error)) {
4122                                         /* txd is freed, but m_head is not */
4123                                         IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
4124                                         atomic_set_int(&ifp->if_drv_flags,
4125                                             IFF_DRV_OACTIVE);
4126                                         break;
4127                                 }
4128                         }
4129                 }
4130 #ifdef INVARIANTS
4131                 else {
4132                         KASSERT(txr->hn_agg_txd != NULL,
4133                             ("no aggregating txdesc"));
4134                         KASSERT(m_head == NULL,
4135                             ("pending mbuf for aggregating txdesc"));
4136                 }
4137 #endif
4138         }
4139
4140         /* Flush pending aggerated transmission. */
4141         if (txr->hn_agg_txd != NULL)
4142                 hn_flush_txagg(ifp, txr);
4143         return (sched);
4144 }
4145
4146 static void
4147 hn_start(struct ifnet *ifp)
4148 {
4149         struct hn_softc *sc = ifp->if_softc;
4150         struct hn_tx_ring *txr = &sc->hn_tx_ring[0];
4151
4152         if (txr->hn_sched_tx)
4153                 goto do_sched;
4154
4155         if (mtx_trylock(&txr->hn_tx_lock)) {
4156                 int sched;
4157
4158                 sched = hn_start_locked(txr, txr->hn_direct_tx_size);
4159                 mtx_unlock(&txr->hn_tx_lock);
4160                 if (!sched)
4161                         return;
4162         }
4163 do_sched:
4164         taskqueue_enqueue(txr->hn_tx_taskq, &txr->hn_tx_task);
4165 }
4166
4167 static void
4168 hn_start_txeof_taskfunc(void *xtxr, int pending __unused)
4169 {
4170         struct hn_tx_ring *txr = xtxr;
4171
4172         mtx_lock(&txr->hn_tx_lock);
4173         atomic_clear_int(&txr->hn_sc->hn_ifp->if_drv_flags, IFF_DRV_OACTIVE);
4174         hn_start_locked(txr, 0);
4175         mtx_unlock(&txr->hn_tx_lock);
4176 }
4177
4178 static void
4179 hn_start_txeof(struct hn_tx_ring *txr)
4180 {
4181         struct hn_softc *sc = txr->hn_sc;
4182         struct ifnet *ifp = sc->hn_ifp;
4183
4184         KASSERT(txr == &sc->hn_tx_ring[0], ("not the first TX ring"));
4185
4186         if (txr->hn_sched_tx)
4187                 goto do_sched;
4188
4189         if (mtx_trylock(&txr->hn_tx_lock)) {
4190                 int sched;
4191
4192                 atomic_clear_int(&ifp->if_drv_flags, IFF_DRV_OACTIVE);
4193                 sched = hn_start_locked(txr, txr->hn_direct_tx_size);
4194                 mtx_unlock(&txr->hn_tx_lock);
4195                 if (sched) {
4196                         taskqueue_enqueue(txr->hn_tx_taskq,
4197                             &txr->hn_tx_task);
4198                 }
4199         } else {
4200 do_sched:
4201                 /*
4202                  * Release the OACTIVE earlier, with the hope, that
4203                  * others could catch up.  The task will clear the
4204                  * flag again with the hn_tx_lock to avoid possible
4205                  * races.
4206                  */
4207                 atomic_clear_int(&ifp->if_drv_flags, IFF_DRV_OACTIVE);
4208                 taskqueue_enqueue(txr->hn_tx_taskq, &txr->hn_txeof_task);
4209         }
4210 }
4211
4212 #endif  /* HN_IFSTART_SUPPORT */
4213
4214 static int
4215 hn_xmit(struct hn_tx_ring *txr, int len)
4216 {
4217         struct hn_softc *sc = txr->hn_sc;
4218         struct ifnet *ifp = sc->hn_ifp;
4219         struct mbuf *m_head;
4220         int sched = 0;
4221
4222         mtx_assert(&txr->hn_tx_lock, MA_OWNED);
4223 #ifdef HN_IFSTART_SUPPORT
4224         KASSERT(hn_use_if_start == 0,
4225             ("hn_xmit is called, when if_start is enabled"));
4226 #endif
4227         KASSERT(txr->hn_agg_txd == NULL, ("lingering aggregating txdesc"));
4228
4229         if (__predict_false(txr->hn_suspended))
4230                 return (0);
4231
4232         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || txr->hn_oactive)
4233                 return (0);
4234
4235         while ((m_head = drbr_peek(ifp, txr->hn_mbuf_br)) != NULL) {
4236                 struct hn_txdesc *txd;
4237                 int error;
4238
4239                 if (len > 0 && m_head->m_pkthdr.len > len) {
4240                         /*
4241                          * This sending could be time consuming; let callers
4242                          * dispatch this packet sending (and sending of any
4243                          * following up packets) to tx taskqueue.
4244                          */
4245                         drbr_putback(ifp, txr->hn_mbuf_br, m_head);
4246                         sched = 1;
4247                         break;
4248                 }
4249
4250                 txd = hn_txdesc_get(txr);
4251                 if (txd == NULL) {
4252                         txr->hn_no_txdescs++;
4253                         drbr_putback(ifp, txr->hn_mbuf_br, m_head);
4254                         txr->hn_oactive = 1;
4255                         break;
4256                 }
4257
4258                 error = hn_encap(ifp, txr, txd, &m_head);
4259                 if (error) {
4260                         /* Both txd and m_head are freed; discard */
4261                         KASSERT(txr->hn_agg_txd == NULL,
4262                             ("encap failed w/ pending aggregating txdesc"));
4263                         drbr_advance(ifp, txr->hn_mbuf_br);
4264                         continue;
4265                 }
4266
4267                 if (txr->hn_agg_pktleft == 0) {
4268                         if (txr->hn_agg_txd != NULL) {
4269                                 KASSERT(m_head == NULL,
4270                                     ("pending mbuf for aggregating txdesc"));
4271                                 error = hn_flush_txagg(ifp, txr);
4272                                 if (__predict_false(error)) {
4273                                         txr->hn_oactive = 1;
4274                                         break;
4275                                 }
4276                         } else {
4277                                 KASSERT(m_head != NULL, ("mbuf was freed"));
4278                                 error = hn_txpkt(ifp, txr, txd);
4279                                 if (__predict_false(error)) {
4280                                         /* txd is freed, but m_head is not */
4281                                         drbr_putback(ifp, txr->hn_mbuf_br,
4282                                             m_head);
4283                                         txr->hn_oactive = 1;
4284                                         break;
4285                                 }
4286                         }
4287                 }
4288 #ifdef INVARIANTS
4289                 else {
4290                         KASSERT(txr->hn_agg_txd != NULL,
4291                             ("no aggregating txdesc"));
4292                         KASSERT(m_head == NULL,
4293                             ("pending mbuf for aggregating txdesc"));
4294                 }
4295 #endif
4296
4297                 /* Sent */
4298                 drbr_advance(ifp, txr->hn_mbuf_br);
4299         }
4300
4301         /* Flush pending aggerated transmission. */
4302         if (txr->hn_agg_txd != NULL)
4303                 hn_flush_txagg(ifp, txr);
4304         return (sched);
4305 }
4306
4307 static int
4308 hn_transmit(struct ifnet *ifp, struct mbuf *m)
4309 {
4310         struct hn_softc *sc = ifp->if_softc;
4311         struct hn_tx_ring *txr;
4312         int error, idx = 0;
4313
4314 #if defined(INET6) || defined(INET)
4315         /*
4316          * Perform TSO packet header fixup now, since the TSO
4317          * packet header should be cache-hot.
4318          */
4319         if (m->m_pkthdr.csum_flags & CSUM_TSO) {
4320                 m = hn_tso_fixup(m);
4321                 if (__predict_false(m == NULL)) {
4322                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
4323                         return EIO;
4324                 }
4325         }
4326 #endif
4327
4328         /*
4329          * Select the TX ring based on flowid
4330          */
4331         if (M_HASHTYPE_GET(m) != M_HASHTYPE_NONE)
4332                 idx = m->m_pkthdr.flowid % sc->hn_tx_ring_inuse;
4333         txr = &sc->hn_tx_ring[idx];
4334
4335         error = drbr_enqueue(ifp, txr->hn_mbuf_br, m);
4336         if (error) {
4337                 if_inc_counter(ifp, IFCOUNTER_OQDROPS, 1);
4338                 return error;
4339         }
4340
4341         if (txr->hn_oactive)
4342                 return 0;
4343
4344         if (txr->hn_sched_tx)
4345                 goto do_sched;
4346
4347         if (mtx_trylock(&txr->hn_tx_lock)) {
4348                 int sched;
4349
4350                 sched = hn_xmit(txr, txr->hn_direct_tx_size);
4351                 mtx_unlock(&txr->hn_tx_lock);
4352                 if (!sched)
4353                         return 0;
4354         }
4355 do_sched:
4356         taskqueue_enqueue(txr->hn_tx_taskq, &txr->hn_tx_task);
4357         return 0;
4358 }
4359
4360 static void
4361 hn_tx_ring_qflush(struct hn_tx_ring *txr)
4362 {
4363         struct mbuf *m;
4364
4365         mtx_lock(&txr->hn_tx_lock);
4366         while ((m = buf_ring_dequeue_sc(txr->hn_mbuf_br)) != NULL)
4367                 m_freem(m);
4368         mtx_unlock(&txr->hn_tx_lock);
4369 }
4370
4371 static void
4372 hn_xmit_qflush(struct ifnet *ifp)
4373 {
4374         struct hn_softc *sc = ifp->if_softc;
4375         int i;
4376
4377         for (i = 0; i < sc->hn_tx_ring_inuse; ++i)
4378                 hn_tx_ring_qflush(&sc->hn_tx_ring[i]);
4379         if_qflush(ifp);
4380 }
4381
4382 static void
4383 hn_xmit_txeof(struct hn_tx_ring *txr)
4384 {
4385
4386         if (txr->hn_sched_tx)
4387                 goto do_sched;
4388
4389         if (mtx_trylock(&txr->hn_tx_lock)) {
4390                 int sched;
4391
4392                 txr->hn_oactive = 0;
4393                 sched = hn_xmit(txr, txr->hn_direct_tx_size);
4394                 mtx_unlock(&txr->hn_tx_lock);
4395                 if (sched) {
4396                         taskqueue_enqueue(txr->hn_tx_taskq,
4397                             &txr->hn_tx_task);
4398                 }
4399         } else {
4400 do_sched:
4401                 /*
4402                  * Release the oactive earlier, with the hope, that
4403                  * others could catch up.  The task will clear the
4404                  * oactive again with the hn_tx_lock to avoid possible
4405                  * races.
4406                  */
4407                 txr->hn_oactive = 0;
4408                 taskqueue_enqueue(txr->hn_tx_taskq, &txr->hn_txeof_task);
4409         }
4410 }
4411
4412 static void
4413 hn_xmit_taskfunc(void *xtxr, int pending __unused)
4414 {
4415         struct hn_tx_ring *txr = xtxr;
4416
4417         mtx_lock(&txr->hn_tx_lock);
4418         hn_xmit(txr, 0);
4419         mtx_unlock(&txr->hn_tx_lock);
4420 }
4421
4422 static void
4423 hn_xmit_txeof_taskfunc(void *xtxr, int pending __unused)
4424 {
4425         struct hn_tx_ring *txr = xtxr;
4426
4427         mtx_lock(&txr->hn_tx_lock);
4428         txr->hn_oactive = 0;
4429         hn_xmit(txr, 0);
4430         mtx_unlock(&txr->hn_tx_lock);
4431 }
4432
4433 static int
4434 hn_chan_attach(struct hn_softc *sc, struct vmbus_channel *chan)
4435 {
4436         struct vmbus_chan_br cbr;
4437         struct hn_rx_ring *rxr;
4438         struct hn_tx_ring *txr = NULL;
4439         int idx, error;
4440
4441         idx = vmbus_chan_subidx(chan);
4442
4443         /*
4444          * Link this channel to RX/TX ring.
4445          */
4446         KASSERT(idx >= 0 && idx < sc->hn_rx_ring_inuse,
4447             ("invalid channel index %d, should > 0 && < %d",
4448              idx, sc->hn_rx_ring_inuse));
4449         rxr = &sc->hn_rx_ring[idx];
4450         KASSERT((rxr->hn_rx_flags & HN_RX_FLAG_ATTACHED) == 0,
4451             ("RX ring %d already attached", idx));
4452         rxr->hn_rx_flags |= HN_RX_FLAG_ATTACHED;
4453         rxr->hn_chan = chan;
4454
4455         if (bootverbose) {
4456                 if_printf(sc->hn_ifp, "link RX ring %d to chan%u\n",
4457                     idx, vmbus_chan_id(chan));
4458         }
4459
4460         if (idx < sc->hn_tx_ring_inuse) {
4461                 txr = &sc->hn_tx_ring[idx];
4462                 KASSERT((txr->hn_tx_flags & HN_TX_FLAG_ATTACHED) == 0,
4463                     ("TX ring %d already attached", idx));
4464                 txr->hn_tx_flags |= HN_TX_FLAG_ATTACHED;
4465
4466                 txr->hn_chan = chan;
4467                 if (bootverbose) {
4468                         if_printf(sc->hn_ifp, "link TX ring %d to chan%u\n",
4469                             idx, vmbus_chan_id(chan));
4470                 }
4471         }
4472
4473         /* Bind this channel to a proper CPU. */
4474         vmbus_chan_cpu_set(chan, HN_RING_IDX2CPU(sc, idx));
4475
4476         /*
4477          * Open this channel
4478          */
4479         cbr.cbr = rxr->hn_br;
4480         cbr.cbr_paddr = rxr->hn_br_dma.hv_paddr;
4481         cbr.cbr_txsz = HN_TXBR_SIZE;
4482         cbr.cbr_rxsz = HN_RXBR_SIZE;
4483         error = vmbus_chan_open_br(chan, &cbr, NULL, 0, hn_chan_callback, rxr);
4484         if (error) {
4485                 if (error == EISCONN) {
4486                         if_printf(sc->hn_ifp, "bufring is connected after "
4487                             "chan%u open failure\n", vmbus_chan_id(chan));
4488                         rxr->hn_rx_flags |= HN_RX_FLAG_BR_REF;
4489                 } else {
4490                         if_printf(sc->hn_ifp, "open chan%u failed: %d\n",
4491                             vmbus_chan_id(chan), error);
4492                 }
4493         }
4494         return (error);
4495 }
4496
4497 static void
4498 hn_chan_detach(struct hn_softc *sc, struct vmbus_channel *chan)
4499 {
4500         struct hn_rx_ring *rxr;
4501         int idx, error;
4502
4503         idx = vmbus_chan_subidx(chan);
4504
4505         /*
4506          * Link this channel to RX/TX ring.
4507          */
4508         KASSERT(idx >= 0 && idx < sc->hn_rx_ring_inuse,
4509             ("invalid channel index %d, should > 0 && < %d",
4510              idx, sc->hn_rx_ring_inuse));
4511         rxr = &sc->hn_rx_ring[idx];
4512         KASSERT((rxr->hn_rx_flags & HN_RX_FLAG_ATTACHED),
4513             ("RX ring %d is not attached", idx));
4514         rxr->hn_rx_flags &= ~HN_RX_FLAG_ATTACHED;
4515
4516         if (idx < sc->hn_tx_ring_inuse) {
4517                 struct hn_tx_ring *txr = &sc->hn_tx_ring[idx];
4518
4519                 KASSERT((txr->hn_tx_flags & HN_TX_FLAG_ATTACHED),
4520                     ("TX ring %d is not attached attached", idx));
4521                 txr->hn_tx_flags &= ~HN_TX_FLAG_ATTACHED;
4522         }
4523
4524         /*
4525          * Close this channel.
4526          *
4527          * NOTE:
4528          * Channel closing does _not_ destroy the target channel.
4529          */
4530         error = vmbus_chan_close_direct(chan);
4531         if (error == EISCONN) {
4532                 if_printf(sc->hn_ifp, "chan%u bufring is connected "
4533                     "after being closed\n", vmbus_chan_id(chan));
4534                 rxr->hn_rx_flags |= HN_RX_FLAG_BR_REF;
4535         } else if (error) {
4536                 if_printf(sc->hn_ifp, "chan%u close failed: %d\n",
4537                     vmbus_chan_id(chan), error);
4538         }
4539 }
4540
4541 static int
4542 hn_attach_subchans(struct hn_softc *sc)
4543 {
4544         struct vmbus_channel **subchans;
4545         int subchan_cnt = sc->hn_rx_ring_inuse - 1;
4546         int i, error = 0;
4547
4548         KASSERT(subchan_cnt > 0, ("no sub-channels"));
4549
4550         /* Attach the sub-channels. */
4551         subchans = vmbus_subchan_get(sc->hn_prichan, subchan_cnt);
4552         for (i = 0; i < subchan_cnt; ++i) {
4553                 int error1;
4554
4555                 error1 = hn_chan_attach(sc, subchans[i]);
4556                 if (error1) {
4557                         error = error1;
4558                         /* Move on; all channels will be detached later. */
4559                 }
4560         }
4561         vmbus_subchan_rel(subchans, subchan_cnt);
4562
4563         if (error) {
4564                 if_printf(sc->hn_ifp, "sub-channels attach failed: %d\n", error);
4565         } else {
4566                 if (bootverbose) {
4567                         if_printf(sc->hn_ifp, "%d sub-channels attached\n",
4568                             subchan_cnt);
4569                 }
4570         }
4571         return (error);
4572 }
4573
4574 static void
4575 hn_detach_allchans(struct hn_softc *sc)
4576 {
4577         struct vmbus_channel **subchans;
4578         int subchan_cnt = sc->hn_rx_ring_inuse - 1;
4579         int i;
4580
4581         if (subchan_cnt == 0)
4582                 goto back;
4583
4584         /* Detach the sub-channels. */
4585         subchans = vmbus_subchan_get(sc->hn_prichan, subchan_cnt);
4586         for (i = 0; i < subchan_cnt; ++i)
4587                 hn_chan_detach(sc, subchans[i]);
4588         vmbus_subchan_rel(subchans, subchan_cnt);
4589
4590 back:
4591         /*
4592          * Detach the primary channel, _after_ all sub-channels
4593          * are detached.
4594          */
4595         hn_chan_detach(sc, sc->hn_prichan);
4596
4597         /* Wait for sub-channels to be destroyed, if any. */
4598         vmbus_subchan_drain(sc->hn_prichan);
4599
4600 #ifdef INVARIANTS
4601         for (i = 0; i < sc->hn_rx_ring_cnt; ++i) {
4602                 KASSERT((sc->hn_rx_ring[i].hn_rx_flags &
4603                     HN_RX_FLAG_ATTACHED) == 0,
4604                     ("%dth RX ring is still attached", i));
4605         }
4606         for (i = 0; i < sc->hn_tx_ring_cnt; ++i) {
4607                 KASSERT((sc->hn_tx_ring[i].hn_tx_flags &
4608                     HN_TX_FLAG_ATTACHED) == 0,
4609                     ("%dth TX ring is still attached", i));
4610         }
4611 #endif
4612 }
4613
4614 static int
4615 hn_synth_alloc_subchans(struct hn_softc *sc, int *nsubch)
4616 {
4617         struct vmbus_channel **subchans;
4618         int nchan, rxr_cnt, error;
4619
4620         nchan = *nsubch + 1;
4621         if (nchan == 1) {
4622                 /*
4623                  * Multiple RX/TX rings are not requested.
4624                  */
4625                 *nsubch = 0;
4626                 return (0);
4627         }
4628
4629         /*
4630          * Query RSS capabilities, e.g. # of RX rings, and # of indirect
4631          * table entries.
4632          */
4633         error = hn_rndis_query_rsscaps(sc, &rxr_cnt);
4634         if (error) {
4635                 /* No RSS; this is benign. */
4636                 *nsubch = 0;
4637                 return (0);
4638         }
4639         if (bootverbose) {
4640                 if_printf(sc->hn_ifp, "RX rings offered %u, requested %d\n",
4641                     rxr_cnt, nchan);
4642         }
4643
4644         if (nchan > rxr_cnt)
4645                 nchan = rxr_cnt;
4646         if (nchan == 1) {
4647                 if_printf(sc->hn_ifp, "only 1 channel is supported, no vRSS\n");
4648                 *nsubch = 0;
4649                 return (0);
4650         }
4651
4652         /*
4653          * Allocate sub-channels from NVS.
4654          */
4655         *nsubch = nchan - 1;
4656         error = hn_nvs_alloc_subchans(sc, nsubch);
4657         if (error || *nsubch == 0) {
4658                 /* Failed to allocate sub-channels. */
4659                 *nsubch = 0;
4660                 return (0);
4661         }
4662
4663         /*
4664          * Wait for all sub-channels to become ready before moving on.
4665          */
4666         subchans = vmbus_subchan_get(sc->hn_prichan, *nsubch);
4667         vmbus_subchan_rel(subchans, *nsubch);
4668         return (0);
4669 }
4670
4671 static bool
4672 hn_synth_attachable(const struct hn_softc *sc)
4673 {
4674         int i;
4675
4676         if (sc->hn_flags & HN_FLAG_ERRORS)
4677                 return (false);
4678
4679         for (i = 0; i < sc->hn_rx_ring_cnt; ++i) {
4680                 const struct hn_rx_ring *rxr = &sc->hn_rx_ring[i];
4681
4682                 if (rxr->hn_rx_flags & HN_RX_FLAG_BR_REF)
4683                         return (false);
4684         }
4685         return (true);
4686 }
4687
4688 static int
4689 hn_synth_attach(struct hn_softc *sc, int mtu)
4690 {
4691 #define ATTACHED_NVS            0x0002
4692 #define ATTACHED_RNDIS          0x0004
4693
4694         struct ndis_rssprm_toeplitz *rss = &sc->hn_rss;
4695         int error, nsubch, nchan, i;
4696         uint32_t old_caps, attached = 0;
4697
4698         KASSERT((sc->hn_flags & HN_FLAG_SYNTH_ATTACHED) == 0,
4699             ("synthetic parts were attached"));
4700
4701         if (!hn_synth_attachable(sc))
4702                 return (ENXIO);
4703
4704         /* Save capabilities for later verification. */
4705         old_caps = sc->hn_caps;
4706         sc->hn_caps = 0;
4707
4708         /* Clear RSS stuffs. */
4709         sc->hn_rss_ind_size = 0;
4710         sc->hn_rss_hash = 0;
4711
4712         /*
4713          * Attach the primary channel _before_ attaching NVS and RNDIS.
4714          */
4715         error = hn_chan_attach(sc, sc->hn_prichan);
4716         if (error)
4717                 goto failed;
4718
4719         /*
4720          * Attach NVS.
4721          */
4722         error = hn_nvs_attach(sc, mtu);
4723         if (error)
4724                 goto failed;
4725         attached |= ATTACHED_NVS;
4726
4727         /*
4728          * Attach RNDIS _after_ NVS is attached.
4729          */
4730         error = hn_rndis_attach(sc, mtu);
4731         if (error)
4732                 goto failed;
4733         attached |= ATTACHED_RNDIS;
4734
4735         /*
4736          * Make sure capabilities are not changed.
4737          */
4738         if (device_is_attached(sc->hn_dev) && old_caps != sc->hn_caps) {
4739                 if_printf(sc->hn_ifp, "caps mismatch old 0x%08x, new 0x%08x\n",
4740                     old_caps, sc->hn_caps);
4741                 error = ENXIO;
4742                 goto failed;
4743         }
4744
4745         /*
4746          * Allocate sub-channels for multi-TX/RX rings.
4747          *
4748          * NOTE:
4749          * The # of RX rings that can be used is equivalent to the # of
4750          * channels to be requested.
4751          */
4752         nsubch = sc->hn_rx_ring_cnt - 1;
4753         error = hn_synth_alloc_subchans(sc, &nsubch);
4754         if (error)
4755                 goto failed;
4756         /* NOTE: _Full_ synthetic parts detach is required now. */
4757         sc->hn_flags |= HN_FLAG_SYNTH_ATTACHED;
4758
4759         /*
4760          * Set the # of TX/RX rings that could be used according to
4761          * the # of channels that NVS offered.
4762          */
4763         nchan = nsubch + 1;
4764         hn_set_ring_inuse(sc, nchan);
4765         if (nchan == 1) {
4766                 /* Only the primary channel can be used; done */
4767                 goto back;
4768         }
4769
4770         /*
4771          * Attach the sub-channels.
4772          *
4773          * NOTE: hn_set_ring_inuse() _must_ have been called.
4774          */
4775         error = hn_attach_subchans(sc);
4776         if (error)
4777                 goto failed;
4778
4779         /*
4780          * Configure RSS key and indirect table _after_ all sub-channels
4781          * are attached.
4782          */
4783         if ((sc->hn_flags & HN_FLAG_HAS_RSSKEY) == 0) {
4784                 /*
4785                  * RSS key is not set yet; set it to the default RSS key.
4786                  */
4787                 if (bootverbose)
4788                         if_printf(sc->hn_ifp, "setup default RSS key\n");
4789                 memcpy(rss->rss_key, hn_rss_key_default, sizeof(rss->rss_key));
4790                 sc->hn_flags |= HN_FLAG_HAS_RSSKEY;
4791         }
4792
4793         if ((sc->hn_flags & HN_FLAG_HAS_RSSIND) == 0) {
4794                 /*
4795                  * RSS indirect table is not set yet; set it up in round-
4796                  * robin fashion.
4797                  */
4798                 if (bootverbose) {
4799                         if_printf(sc->hn_ifp, "setup default RSS indirect "
4800                             "table\n");
4801                 }
4802                 for (i = 0; i < NDIS_HASH_INDCNT; ++i)
4803                         rss->rss_ind[i] = i % nchan;
4804                 sc->hn_flags |= HN_FLAG_HAS_RSSIND;
4805         } else {
4806                 /*
4807                  * # of usable channels may be changed, so we have to
4808                  * make sure that all entries in RSS indirect table
4809                  * are valid.
4810                  *
4811                  * NOTE: hn_set_ring_inuse() _must_ have been called.
4812                  */
4813                 hn_rss_ind_fixup(sc);
4814         }
4815
4816         error = hn_rndis_conf_rss(sc, NDIS_RSS_FLAG_NONE);
4817         if (error)
4818                 goto failed;
4819 back:
4820         /*
4821          * Fixup transmission aggregation setup.
4822          */
4823         hn_set_txagg(sc);
4824         return (0);
4825
4826 failed:
4827         if (sc->hn_flags & HN_FLAG_SYNTH_ATTACHED) {
4828                 hn_synth_detach(sc);
4829         } else {
4830                 if (attached & ATTACHED_RNDIS)
4831                         hn_rndis_detach(sc);
4832                 if (attached & ATTACHED_NVS)
4833                         hn_nvs_detach(sc);
4834                 hn_chan_detach(sc, sc->hn_prichan);
4835                 /* Restore old capabilities. */
4836                 sc->hn_caps = old_caps;
4837         }
4838         return (error);
4839
4840 #undef ATTACHED_RNDIS
4841 #undef ATTACHED_NVS
4842 }
4843
4844 /*
4845  * NOTE:
4846  * The interface must have been suspended though hn_suspend(), before
4847  * this function get called.
4848  */
4849 static void
4850 hn_synth_detach(struct hn_softc *sc)
4851 {
4852
4853         KASSERT(sc->hn_flags & HN_FLAG_SYNTH_ATTACHED,
4854             ("synthetic parts were not attached"));
4855
4856         /* Detach the RNDIS first. */
4857         hn_rndis_detach(sc);
4858
4859         /* Detach NVS. */
4860         hn_nvs_detach(sc);
4861
4862         /* Detach all of the channels. */
4863         hn_detach_allchans(sc);
4864
4865         sc->hn_flags &= ~HN_FLAG_SYNTH_ATTACHED;
4866 }
4867
4868 static void
4869 hn_set_ring_inuse(struct hn_softc *sc, int ring_cnt)
4870 {
4871         KASSERT(ring_cnt > 0 && ring_cnt <= sc->hn_rx_ring_cnt,
4872             ("invalid ring count %d", ring_cnt));
4873
4874         if (sc->hn_tx_ring_cnt > ring_cnt)
4875                 sc->hn_tx_ring_inuse = ring_cnt;
4876         else
4877                 sc->hn_tx_ring_inuse = sc->hn_tx_ring_cnt;
4878         sc->hn_rx_ring_inuse = ring_cnt;
4879
4880         if (bootverbose) {
4881                 if_printf(sc->hn_ifp, "%d TX ring, %d RX ring\n",
4882                     sc->hn_tx_ring_inuse, sc->hn_rx_ring_inuse);
4883         }
4884 }
4885
4886 static void
4887 hn_chan_drain(struct hn_softc *sc, struct vmbus_channel *chan)
4888 {
4889
4890         /*
4891          * NOTE:
4892          * The TX bufring will not be drained by the hypervisor,
4893          * if the primary channel is revoked.
4894          */
4895         while (!vmbus_chan_rx_empty(chan) ||
4896             (!vmbus_chan_is_revoked(sc->hn_prichan) &&
4897              !vmbus_chan_tx_empty(chan)))
4898                 pause("waitch", 1);
4899         vmbus_chan_intr_drain(chan);
4900 }
4901
4902 static void
4903 hn_suspend_data(struct hn_softc *sc)
4904 {
4905         struct vmbus_channel **subch = NULL;
4906         struct hn_tx_ring *txr;
4907         int i, nsubch;
4908
4909         HN_LOCK_ASSERT(sc);
4910
4911         /*
4912          * Suspend TX.
4913          */
4914         for (i = 0; i < sc->hn_tx_ring_inuse; ++i) {
4915                 txr = &sc->hn_tx_ring[i];
4916
4917                 mtx_lock(&txr->hn_tx_lock);
4918                 txr->hn_suspended = 1;
4919                 mtx_unlock(&txr->hn_tx_lock);
4920                 /* No one is able send more packets now. */
4921
4922                 /*
4923                  * Wait for all pending sends to finish.
4924                  *
4925                  * NOTE:
4926                  * We will _not_ receive all pending send-done, if the
4927                  * primary channel is revoked.
4928                  */
4929                 while (hn_tx_ring_pending(txr) &&
4930                     !vmbus_chan_is_revoked(sc->hn_prichan))
4931                         pause("hnwtx", 1 /* 1 tick */);
4932         }
4933
4934         /*
4935          * Disable RX by clearing RX filter.
4936          */
4937         hn_set_rxfilter(sc, NDIS_PACKET_TYPE_NONE);
4938
4939         /*
4940          * Give RNDIS enough time to flush all pending data packets.
4941          */
4942         pause("waitrx", (200 * hz) / 1000);
4943
4944         /*
4945          * Drain RX/TX bufrings and interrupts.
4946          */
4947         nsubch = sc->hn_rx_ring_inuse - 1;
4948         if (nsubch > 0)
4949                 subch = vmbus_subchan_get(sc->hn_prichan, nsubch);
4950
4951         if (subch != NULL) {
4952                 for (i = 0; i < nsubch; ++i)
4953                         hn_chan_drain(sc, subch[i]);
4954         }
4955         hn_chan_drain(sc, sc->hn_prichan);
4956
4957         if (subch != NULL)
4958                 vmbus_subchan_rel(subch, nsubch);
4959
4960         /*
4961          * Drain any pending TX tasks.
4962          *
4963          * NOTE:
4964          * The above hn_chan_drain() can dispatch TX tasks, so the TX
4965          * tasks will have to be drained _after_ the above hn_chan_drain()
4966          * calls.
4967          */
4968         for (i = 0; i < sc->hn_tx_ring_inuse; ++i) {
4969                 txr = &sc->hn_tx_ring[i];
4970
4971                 taskqueue_drain(txr->hn_tx_taskq, &txr->hn_tx_task);
4972                 taskqueue_drain(txr->hn_tx_taskq, &txr->hn_txeof_task);
4973         }
4974 }
4975
4976 static void
4977 hn_suspend_mgmt_taskfunc(void *xsc, int pending __unused)
4978 {
4979
4980         ((struct hn_softc *)xsc)->hn_mgmt_taskq = NULL;
4981 }
4982
4983 static void
4984 hn_suspend_mgmt(struct hn_softc *sc)
4985 {
4986         struct task task;
4987
4988         HN_LOCK_ASSERT(sc);
4989
4990         /*
4991          * Make sure that hn_mgmt_taskq0 can nolonger be accessed
4992          * through hn_mgmt_taskq.
4993          */
4994         TASK_INIT(&task, 0, hn_suspend_mgmt_taskfunc, sc);
4995         vmbus_chan_run_task(sc->hn_prichan, &task);
4996
4997         /*
4998          * Make sure that all pending management tasks are completed.
4999          */
5000         taskqueue_drain(sc->hn_mgmt_taskq0, &sc->hn_netchg_init);
5001         taskqueue_drain_timeout(sc->hn_mgmt_taskq0, &sc->hn_netchg_status);
5002         taskqueue_drain_all(sc->hn_mgmt_taskq0);
5003 }
5004
5005 static void
5006 hn_suspend(struct hn_softc *sc)
5007 {
5008
5009         /* Disable polling. */
5010         hn_polling(sc, 0);
5011
5012         if ((sc->hn_ifp->if_drv_flags & IFF_DRV_RUNNING) ||
5013             (sc->hn_flags & HN_FLAG_VF))
5014                 hn_suspend_data(sc);
5015         hn_suspend_mgmt(sc);
5016 }
5017
5018 static void
5019 hn_resume_tx(struct hn_softc *sc, int tx_ring_cnt)
5020 {
5021         int i;
5022
5023         KASSERT(tx_ring_cnt <= sc->hn_tx_ring_cnt,
5024             ("invalid TX ring count %d", tx_ring_cnt));
5025
5026         for (i = 0; i < tx_ring_cnt; ++i) {
5027                 struct hn_tx_ring *txr = &sc->hn_tx_ring[i];
5028
5029                 mtx_lock(&txr->hn_tx_lock);
5030                 txr->hn_suspended = 0;
5031                 mtx_unlock(&txr->hn_tx_lock);
5032         }
5033 }
5034
5035 static void
5036 hn_resume_data(struct hn_softc *sc)
5037 {
5038         int i;
5039
5040         HN_LOCK_ASSERT(sc);
5041
5042         /*
5043          * Re-enable RX.
5044          */
5045         hn_rxfilter_config(sc);
5046
5047         /*
5048          * Make sure to clear suspend status on "all" TX rings,
5049          * since hn_tx_ring_inuse can be changed after
5050          * hn_suspend_data().
5051          */
5052         hn_resume_tx(sc, sc->hn_tx_ring_cnt);
5053
5054 #ifdef HN_IFSTART_SUPPORT
5055         if (!hn_use_if_start)
5056 #endif
5057         {
5058                 /*
5059                  * Flush unused drbrs, since hn_tx_ring_inuse may be
5060                  * reduced.
5061                  */
5062                 for (i = sc->hn_tx_ring_inuse; i < sc->hn_tx_ring_cnt; ++i)
5063                         hn_tx_ring_qflush(&sc->hn_tx_ring[i]);
5064         }
5065
5066         /*
5067          * Kick start TX.
5068          */
5069         for (i = 0; i < sc->hn_tx_ring_inuse; ++i) {
5070                 struct hn_tx_ring *txr = &sc->hn_tx_ring[i];
5071
5072                 /*
5073                  * Use txeof task, so that any pending oactive can be
5074                  * cleared properly.
5075                  */
5076                 taskqueue_enqueue(txr->hn_tx_taskq, &txr->hn_txeof_task);
5077         }
5078 }
5079
5080 static void
5081 hn_resume_mgmt(struct hn_softc *sc)
5082 {
5083
5084         sc->hn_mgmt_taskq = sc->hn_mgmt_taskq0;
5085
5086         /*
5087          * Kick off network change detection, if it was pending.
5088          * If no network change was pending, start link status
5089          * checks, which is more lightweight than network change
5090          * detection.
5091          */
5092         if (sc->hn_link_flags & HN_LINK_FLAG_NETCHG)
5093                 hn_change_network(sc);
5094         else
5095                 hn_update_link_status(sc);
5096 }
5097
5098 static void
5099 hn_resume(struct hn_softc *sc)
5100 {
5101
5102         if ((sc->hn_ifp->if_drv_flags & IFF_DRV_RUNNING) ||
5103             (sc->hn_flags & HN_FLAG_VF))
5104                 hn_resume_data(sc);
5105
5106         /*
5107          * When the VF is activated, the synthetic interface is changed
5108          * to DOWN in hn_set_vf(). Here, if the VF is still active, we
5109          * don't call hn_resume_mgmt() until the VF is deactivated in
5110          * hn_set_vf().
5111          */
5112         if (!(sc->hn_flags & HN_FLAG_VF))
5113                 hn_resume_mgmt(sc);
5114
5115         /*
5116          * Re-enable polling if this interface is running and
5117          * the polling is requested.
5118          */
5119         if ((sc->hn_ifp->if_drv_flags & IFF_DRV_RUNNING) && sc->hn_pollhz > 0)
5120                 hn_polling(sc, sc->hn_pollhz);
5121 }
5122
5123 static void
5124 hn_rndis_rx_status(struct hn_softc *sc, const void *data, int dlen)
5125 {
5126         const struct rndis_status_msg *msg;
5127         int ofs;
5128
5129         if (dlen < sizeof(*msg)) {
5130                 if_printf(sc->hn_ifp, "invalid RNDIS status\n");
5131                 return;
5132         }
5133         msg = data;
5134
5135         switch (msg->rm_status) {
5136         case RNDIS_STATUS_MEDIA_CONNECT:
5137         case RNDIS_STATUS_MEDIA_DISCONNECT:
5138                 hn_update_link_status(sc);
5139                 break;
5140
5141         case RNDIS_STATUS_TASK_OFFLOAD_CURRENT_CONFIG:
5142                 /* Not really useful; ignore. */
5143                 break;
5144
5145         case RNDIS_STATUS_NETWORK_CHANGE:
5146                 ofs = RNDIS_STBUFOFFSET_ABS(msg->rm_stbufoffset);
5147                 if (dlen < ofs + msg->rm_stbuflen ||
5148                     msg->rm_stbuflen < sizeof(uint32_t)) {
5149                         if_printf(sc->hn_ifp, "network changed\n");
5150                 } else {
5151                         uint32_t change;
5152
5153                         memcpy(&change, ((const uint8_t *)msg) + ofs,
5154                             sizeof(change));
5155                         if_printf(sc->hn_ifp, "network changed, change %u\n",
5156                             change);
5157                 }
5158                 hn_change_network(sc);
5159                 break;
5160
5161         default:
5162                 if_printf(sc->hn_ifp, "unknown RNDIS status 0x%08x\n",
5163                     msg->rm_status);
5164                 break;
5165         }
5166 }
5167
5168 static int
5169 hn_rndis_rxinfo(const void *info_data, int info_dlen, struct hn_rxinfo *info)
5170 {
5171         const struct rndis_pktinfo *pi = info_data;
5172         uint32_t mask = 0;
5173
5174         while (info_dlen != 0) {
5175                 const void *data;
5176                 uint32_t dlen;
5177
5178                 if (__predict_false(info_dlen < sizeof(*pi)))
5179                         return (EINVAL);
5180                 if (__predict_false(info_dlen < pi->rm_size))
5181                         return (EINVAL);
5182                 info_dlen -= pi->rm_size;
5183
5184                 if (__predict_false(pi->rm_size & RNDIS_PKTINFO_SIZE_ALIGNMASK))
5185                         return (EINVAL);
5186                 if (__predict_false(pi->rm_size < pi->rm_pktinfooffset))
5187                         return (EINVAL);
5188                 dlen = pi->rm_size - pi->rm_pktinfooffset;
5189                 data = pi->rm_data;
5190
5191                 switch (pi->rm_type) {
5192                 case NDIS_PKTINFO_TYPE_VLAN:
5193                         if (__predict_false(dlen < NDIS_VLAN_INFO_SIZE))
5194                                 return (EINVAL);
5195                         info->vlan_info = *((const uint32_t *)data);
5196                         mask |= HN_RXINFO_VLAN;
5197                         break;
5198
5199                 case NDIS_PKTINFO_TYPE_CSUM:
5200                         if (__predict_false(dlen < NDIS_RXCSUM_INFO_SIZE))
5201                                 return (EINVAL);
5202                         info->csum_info = *((const uint32_t *)data);
5203                         mask |= HN_RXINFO_CSUM;
5204                         break;
5205
5206                 case HN_NDIS_PKTINFO_TYPE_HASHVAL:
5207                         if (__predict_false(dlen < HN_NDIS_HASH_VALUE_SIZE))
5208                                 return (EINVAL);
5209                         info->hash_value = *((const uint32_t *)data);
5210                         mask |= HN_RXINFO_HASHVAL;
5211                         break;
5212
5213                 case HN_NDIS_PKTINFO_TYPE_HASHINF:
5214                         if (__predict_false(dlen < HN_NDIS_HASH_INFO_SIZE))
5215                                 return (EINVAL);
5216                         info->hash_info = *((const uint32_t *)data);
5217                         mask |= HN_RXINFO_HASHINF;
5218                         break;
5219
5220                 default:
5221                         goto next;
5222                 }
5223
5224                 if (mask == HN_RXINFO_ALL) {
5225                         /* All found; done */
5226                         break;
5227                 }
5228 next:
5229                 pi = (const struct rndis_pktinfo *)
5230                     ((const uint8_t *)pi + pi->rm_size);
5231         }
5232
5233         /*
5234          * Final fixup.
5235          * - If there is no hash value, invalidate the hash info.
5236          */
5237         if ((mask & HN_RXINFO_HASHVAL) == 0)
5238                 info->hash_info = HN_NDIS_HASH_INFO_INVALID;
5239         return (0);
5240 }
5241
5242 static __inline bool
5243 hn_rndis_check_overlap(int off, int len, int check_off, int check_len)
5244 {
5245
5246         if (off < check_off) {
5247                 if (__predict_true(off + len <= check_off))
5248                         return (false);
5249         } else if (off > check_off) {
5250                 if (__predict_true(check_off + check_len <= off))
5251                         return (false);
5252         }
5253         return (true);
5254 }
5255
5256 static void
5257 hn_rndis_rx_data(struct hn_rx_ring *rxr, const void *data, int dlen)
5258 {
5259         const struct rndis_packet_msg *pkt;
5260         struct hn_rxinfo info;
5261         int data_off, pktinfo_off, data_len, pktinfo_len;
5262
5263         /*
5264          * Check length.
5265          */
5266         if (__predict_false(dlen < sizeof(*pkt))) {
5267                 if_printf(rxr->hn_ifp, "invalid RNDIS packet msg\n");
5268                 return;
5269         }
5270         pkt = data;
5271
5272         if (__predict_false(dlen < pkt->rm_len)) {
5273                 if_printf(rxr->hn_ifp, "truncated RNDIS packet msg, "
5274                     "dlen %d, msglen %u\n", dlen, pkt->rm_len);
5275                 return;
5276         }
5277         if (__predict_false(pkt->rm_len <
5278             pkt->rm_datalen + pkt->rm_oobdatalen + pkt->rm_pktinfolen)) {
5279                 if_printf(rxr->hn_ifp, "invalid RNDIS packet msglen, "
5280                     "msglen %u, data %u, oob %u, pktinfo %u\n",
5281                     pkt->rm_len, pkt->rm_datalen, pkt->rm_oobdatalen,
5282                     pkt->rm_pktinfolen);
5283                 return;
5284         }
5285         if (__predict_false(pkt->rm_datalen == 0)) {
5286                 if_printf(rxr->hn_ifp, "invalid RNDIS packet msg, no data\n");
5287                 return;
5288         }
5289
5290         /*
5291          * Check offests.
5292          */
5293 #define IS_OFFSET_INVALID(ofs)                  \
5294         ((ofs) < RNDIS_PACKET_MSG_OFFSET_MIN || \
5295          ((ofs) & RNDIS_PACKET_MSG_OFFSET_ALIGNMASK))
5296
5297         /* XXX Hyper-V does not meet data offset alignment requirement */
5298         if (__predict_false(pkt->rm_dataoffset < RNDIS_PACKET_MSG_OFFSET_MIN)) {
5299                 if_printf(rxr->hn_ifp, "invalid RNDIS packet msg, "
5300                     "data offset %u\n", pkt->rm_dataoffset);
5301                 return;
5302         }
5303         if (__predict_false(pkt->rm_oobdataoffset > 0 &&
5304             IS_OFFSET_INVALID(pkt->rm_oobdataoffset))) {
5305                 if_printf(rxr->hn_ifp, "invalid RNDIS packet msg, "
5306                     "oob offset %u\n", pkt->rm_oobdataoffset);
5307                 return;
5308         }
5309         if (__predict_true(pkt->rm_pktinfooffset > 0) &&
5310             __predict_false(IS_OFFSET_INVALID(pkt->rm_pktinfooffset))) {
5311                 if_printf(rxr->hn_ifp, "invalid RNDIS packet msg, "
5312                     "pktinfo offset %u\n", pkt->rm_pktinfooffset);
5313                 return;
5314         }
5315
5316 #undef IS_OFFSET_INVALID
5317
5318         data_off = RNDIS_PACKET_MSG_OFFSET_ABS(pkt->rm_dataoffset);
5319         data_len = pkt->rm_datalen;
5320         pktinfo_off = RNDIS_PACKET_MSG_OFFSET_ABS(pkt->rm_pktinfooffset);
5321         pktinfo_len = pkt->rm_pktinfolen;
5322
5323         /*
5324          * Check OOB coverage.
5325          */
5326         if (__predict_false(pkt->rm_oobdatalen != 0)) {
5327                 int oob_off, oob_len;
5328
5329                 if_printf(rxr->hn_ifp, "got oobdata\n");
5330                 oob_off = RNDIS_PACKET_MSG_OFFSET_ABS(pkt->rm_oobdataoffset);
5331                 oob_len = pkt->rm_oobdatalen;
5332
5333                 if (__predict_false(oob_off + oob_len > pkt->rm_len)) {
5334                         if_printf(rxr->hn_ifp, "invalid RNDIS packet msg, "
5335                             "oob overflow, msglen %u, oob abs %d len %d\n",
5336                             pkt->rm_len, oob_off, oob_len);
5337                         return;
5338                 }
5339
5340                 /*
5341                  * Check against data.
5342                  */
5343                 if (hn_rndis_check_overlap(oob_off, oob_len,
5344                     data_off, data_len)) {
5345                         if_printf(rxr->hn_ifp, "invalid RNDIS packet msg, "
5346                             "oob overlaps data, oob abs %d len %d, "
5347                             "data abs %d len %d\n",
5348                             oob_off, oob_len, data_off, data_len);
5349                         return;
5350                 }
5351
5352                 /*
5353                  * Check against pktinfo.
5354                  */
5355                 if (pktinfo_len != 0 &&
5356                     hn_rndis_check_overlap(oob_off, oob_len,
5357                     pktinfo_off, pktinfo_len)) {
5358                         if_printf(rxr->hn_ifp, "invalid RNDIS packet msg, "
5359                             "oob overlaps pktinfo, oob abs %d len %d, "
5360                             "pktinfo abs %d len %d\n",
5361                             oob_off, oob_len, pktinfo_off, pktinfo_len);
5362                         return;
5363                 }
5364         }
5365
5366         /*
5367          * Check per-packet-info coverage and find useful per-packet-info.
5368          */
5369         info.vlan_info = HN_NDIS_VLAN_INFO_INVALID;
5370         info.csum_info = HN_NDIS_RXCSUM_INFO_INVALID;
5371         info.hash_info = HN_NDIS_HASH_INFO_INVALID;
5372         if (__predict_true(pktinfo_len != 0)) {
5373                 bool overlap;
5374                 int error;
5375
5376                 if (__predict_false(pktinfo_off + pktinfo_len > pkt->rm_len)) {
5377                         if_printf(rxr->hn_ifp, "invalid RNDIS packet msg, "
5378                             "pktinfo overflow, msglen %u, "
5379                             "pktinfo abs %d len %d\n",
5380                             pkt->rm_len, pktinfo_off, pktinfo_len);
5381                         return;
5382                 }
5383
5384                 /*
5385                  * Check packet info coverage.
5386                  */
5387                 overlap = hn_rndis_check_overlap(pktinfo_off, pktinfo_len,
5388                     data_off, data_len);
5389                 if (__predict_false(overlap)) {
5390                         if_printf(rxr->hn_ifp, "invalid RNDIS packet msg, "
5391                             "pktinfo overlap data, pktinfo abs %d len %d, "
5392                             "data abs %d len %d\n",
5393                             pktinfo_off, pktinfo_len, data_off, data_len);
5394                         return;
5395                 }
5396
5397                 /*
5398                  * Find useful per-packet-info.
5399                  */
5400                 error = hn_rndis_rxinfo(((const uint8_t *)pkt) + pktinfo_off,
5401                     pktinfo_len, &info);
5402                 if (__predict_false(error)) {
5403                         if_printf(rxr->hn_ifp, "invalid RNDIS packet msg "
5404                             "pktinfo\n");
5405                         return;
5406                 }
5407         }
5408
5409         if (__predict_false(data_off + data_len > pkt->rm_len)) {
5410                 if_printf(rxr->hn_ifp, "invalid RNDIS packet msg, "
5411                     "data overflow, msglen %u, data abs %d len %d\n",
5412                     pkt->rm_len, data_off, data_len);
5413                 return;
5414         }
5415         hn_rxpkt(rxr, ((const uint8_t *)pkt) + data_off, data_len, &info);
5416 }
5417
5418 static __inline void
5419 hn_rndis_rxpkt(struct hn_rx_ring *rxr, const void *data, int dlen)
5420 {
5421         const struct rndis_msghdr *hdr;
5422
5423         if (__predict_false(dlen < sizeof(*hdr))) {
5424                 if_printf(rxr->hn_ifp, "invalid RNDIS msg\n");
5425                 return;
5426         }
5427         hdr = data;
5428
5429         if (__predict_true(hdr->rm_type == REMOTE_NDIS_PACKET_MSG)) {
5430                 /* Hot data path. */
5431                 hn_rndis_rx_data(rxr, data, dlen);
5432                 /* Done! */
5433                 return;
5434         }
5435
5436         if (hdr->rm_type == REMOTE_NDIS_INDICATE_STATUS_MSG)
5437                 hn_rndis_rx_status(rxr->hn_ifp->if_softc, data, dlen);
5438         else
5439                 hn_rndis_rx_ctrl(rxr->hn_ifp->if_softc, data, dlen);
5440 }
5441
5442 static void
5443 hn_nvs_handle_notify(struct hn_softc *sc, const struct vmbus_chanpkt_hdr *pkt)
5444 {
5445         const struct hn_nvs_hdr *hdr;
5446
5447         if (VMBUS_CHANPKT_DATALEN(pkt) < sizeof(*hdr)) {
5448                 if_printf(sc->hn_ifp, "invalid nvs notify\n");
5449                 return;
5450         }
5451         hdr = VMBUS_CHANPKT_CONST_DATA(pkt);
5452
5453         if (hdr->nvs_type == HN_NVS_TYPE_TXTBL_NOTE) {
5454                 /* Useless; ignore */
5455                 return;
5456         }
5457         if_printf(sc->hn_ifp, "got notify, nvs type %u\n", hdr->nvs_type);
5458 }
5459
5460 static void
5461 hn_nvs_handle_comp(struct hn_softc *sc, struct vmbus_channel *chan,
5462     const struct vmbus_chanpkt_hdr *pkt)
5463 {
5464         struct hn_nvs_sendctx *sndc;
5465
5466         sndc = (struct hn_nvs_sendctx *)(uintptr_t)pkt->cph_xactid;
5467         sndc->hn_cb(sndc, sc, chan, VMBUS_CHANPKT_CONST_DATA(pkt),
5468             VMBUS_CHANPKT_DATALEN(pkt));
5469         /*
5470          * NOTE:
5471          * 'sndc' CAN NOT be accessed anymore, since it can be freed by
5472          * its callback.
5473          */
5474 }
5475
5476 static void
5477 hn_nvs_handle_rxbuf(struct hn_rx_ring *rxr, struct vmbus_channel *chan,
5478     const struct vmbus_chanpkt_hdr *pkthdr)
5479 {
5480         const struct vmbus_chanpkt_rxbuf *pkt;
5481         const struct hn_nvs_hdr *nvs_hdr;
5482         int count, i, hlen;
5483
5484         if (__predict_false(VMBUS_CHANPKT_DATALEN(pkthdr) < sizeof(*nvs_hdr))) {
5485                 if_printf(rxr->hn_ifp, "invalid nvs RNDIS\n");
5486                 return;
5487         }
5488         nvs_hdr = VMBUS_CHANPKT_CONST_DATA(pkthdr);
5489
5490         /* Make sure that this is a RNDIS message. */
5491         if (__predict_false(nvs_hdr->nvs_type != HN_NVS_TYPE_RNDIS)) {
5492                 if_printf(rxr->hn_ifp, "nvs type %u, not RNDIS\n",
5493                     nvs_hdr->nvs_type);
5494                 return;
5495         }
5496
5497         hlen = VMBUS_CHANPKT_GETLEN(pkthdr->cph_hlen);
5498         if (__predict_false(hlen < sizeof(*pkt))) {
5499                 if_printf(rxr->hn_ifp, "invalid rxbuf chanpkt\n");
5500                 return;
5501         }
5502         pkt = (const struct vmbus_chanpkt_rxbuf *)pkthdr;
5503
5504         if (__predict_false(pkt->cp_rxbuf_id != HN_NVS_RXBUF_SIG)) {
5505                 if_printf(rxr->hn_ifp, "invalid rxbuf_id 0x%08x\n",
5506                     pkt->cp_rxbuf_id);
5507                 return;
5508         }
5509
5510         count = pkt->cp_rxbuf_cnt;
5511         if (__predict_false(hlen <
5512             __offsetof(struct vmbus_chanpkt_rxbuf, cp_rxbuf[count]))) {
5513                 if_printf(rxr->hn_ifp, "invalid rxbuf_cnt %d\n", count);
5514                 return;
5515         }
5516
5517         /* Each range represents 1 RNDIS pkt that contains 1 Ethernet frame */
5518         for (i = 0; i < count; ++i) {
5519                 int ofs, len;
5520
5521                 ofs = pkt->cp_rxbuf[i].rb_ofs;
5522                 len = pkt->cp_rxbuf[i].rb_len;
5523                 if (__predict_false(ofs + len > HN_RXBUF_SIZE)) {
5524                         if_printf(rxr->hn_ifp, "%dth RNDIS msg overflow rxbuf, "
5525                             "ofs %d, len %d\n", i, ofs, len);
5526                         continue;
5527                 }
5528                 hn_rndis_rxpkt(rxr, rxr->hn_rxbuf + ofs, len);
5529         }
5530
5531         /*
5532          * Ack the consumed RXBUF associated w/ this channel packet,
5533          * so that this RXBUF can be recycled by the hypervisor.
5534          */
5535         hn_nvs_ack_rxbuf(rxr, chan, pkt->cp_hdr.cph_xactid);
5536 }
5537
5538 static void
5539 hn_nvs_ack_rxbuf(struct hn_rx_ring *rxr, struct vmbus_channel *chan,
5540     uint64_t tid)
5541 {
5542         struct hn_nvs_rndis_ack ack;
5543         int retries, error;
5544
5545         ack.nvs_type = HN_NVS_TYPE_RNDIS_ACK;
5546         ack.nvs_status = HN_NVS_STATUS_OK;
5547
5548         retries = 0;
5549 again:
5550         error = vmbus_chan_send(chan, VMBUS_CHANPKT_TYPE_COMP,
5551             VMBUS_CHANPKT_FLAG_NONE, &ack, sizeof(ack), tid);
5552         if (__predict_false(error == EAGAIN)) {
5553                 /*
5554                  * NOTE:
5555                  * This should _not_ happen in real world, since the
5556                  * consumption of the TX bufring from the TX path is
5557                  * controlled.
5558                  */
5559                 if (rxr->hn_ack_failed == 0)
5560                         if_printf(rxr->hn_ifp, "RXBUF ack retry\n");
5561                 rxr->hn_ack_failed++;
5562                 retries++;
5563                 if (retries < 10) {
5564                         DELAY(100);
5565                         goto again;
5566                 }
5567                 /* RXBUF leaks! */
5568                 if_printf(rxr->hn_ifp, "RXBUF ack failed\n");
5569         }
5570 }
5571
5572 static void
5573 hn_chan_callback(struct vmbus_channel *chan, void *xrxr)
5574 {
5575         struct hn_rx_ring *rxr = xrxr;
5576         struct hn_softc *sc = rxr->hn_ifp->if_softc;
5577
5578         for (;;) {
5579                 struct vmbus_chanpkt_hdr *pkt = rxr->hn_pktbuf;
5580                 int error, pktlen;
5581
5582                 pktlen = rxr->hn_pktbuf_len;
5583                 error = vmbus_chan_recv_pkt(chan, pkt, &pktlen);
5584                 if (__predict_false(error == ENOBUFS)) {
5585                         void *nbuf;
5586                         int nlen;
5587
5588                         /*
5589                          * Expand channel packet buffer.
5590                          *
5591                          * XXX
5592                          * Use M_WAITOK here, since allocation failure
5593                          * is fatal.
5594                          */
5595                         nlen = rxr->hn_pktbuf_len * 2;
5596                         while (nlen < pktlen)
5597                                 nlen *= 2;
5598                         nbuf = malloc(nlen, M_DEVBUF, M_WAITOK);
5599
5600                         if_printf(rxr->hn_ifp, "expand pktbuf %d -> %d\n",
5601                             rxr->hn_pktbuf_len, nlen);
5602
5603                         free(rxr->hn_pktbuf, M_DEVBUF);
5604                         rxr->hn_pktbuf = nbuf;
5605                         rxr->hn_pktbuf_len = nlen;
5606                         /* Retry! */
5607                         continue;
5608                 } else if (__predict_false(error == EAGAIN)) {
5609                         /* No more channel packets; done! */
5610                         break;
5611                 }
5612                 KASSERT(!error, ("vmbus_chan_recv_pkt failed: %d", error));
5613
5614                 switch (pkt->cph_type) {
5615                 case VMBUS_CHANPKT_TYPE_COMP:
5616                         hn_nvs_handle_comp(sc, chan, pkt);
5617                         break;
5618
5619                 case VMBUS_CHANPKT_TYPE_RXBUF:
5620                         hn_nvs_handle_rxbuf(rxr, chan, pkt);
5621                         break;
5622
5623                 case VMBUS_CHANPKT_TYPE_INBAND:
5624                         hn_nvs_handle_notify(sc, pkt);
5625                         break;
5626
5627                 default:
5628                         if_printf(rxr->hn_ifp, "unknown chan pkt %u\n",
5629                             pkt->cph_type);
5630                         break;
5631                 }
5632         }
5633         hn_chan_rollup(rxr, rxr->hn_txr);
5634 }
5635
5636 static void
5637 hn_tx_taskq_create(void *arg __unused)
5638 {
5639         int i;
5640
5641         /*
5642          * Fix the # of TX taskqueues.
5643          */
5644         if (hn_tx_taskq_cnt <= 0)
5645                 hn_tx_taskq_cnt = 1;
5646         else if (hn_tx_taskq_cnt > mp_ncpus)
5647                 hn_tx_taskq_cnt = mp_ncpus;
5648
5649         /*
5650          * Fix the TX taskqueue mode.
5651          */
5652         switch (hn_tx_taskq_mode) {
5653         case HN_TX_TASKQ_M_INDEP:
5654         case HN_TX_TASKQ_M_GLOBAL:
5655         case HN_TX_TASKQ_M_EVTTQ:
5656                 break;
5657         default:
5658                 hn_tx_taskq_mode = HN_TX_TASKQ_M_INDEP;
5659                 break;
5660         }
5661
5662         if (vm_guest != VM_GUEST_HV)
5663                 return;
5664
5665         if (hn_tx_taskq_mode != HN_TX_TASKQ_M_GLOBAL)
5666                 return;
5667
5668         hn_tx_taskque = malloc(hn_tx_taskq_cnt * sizeof(struct taskqueue *),
5669             M_DEVBUF, M_WAITOK);
5670         for (i = 0; i < hn_tx_taskq_cnt; ++i) {
5671                 hn_tx_taskque[i] = taskqueue_create("hn_tx", M_WAITOK,
5672                     taskqueue_thread_enqueue, &hn_tx_taskque[i]);
5673                 taskqueue_start_threads(&hn_tx_taskque[i], 1, PI_NET,
5674                     "hn tx%d", i);
5675         }
5676 }
5677 SYSINIT(hn_txtq_create, SI_SUB_DRIVERS, SI_ORDER_SECOND,
5678     hn_tx_taskq_create, NULL);
5679
5680 static void
5681 hn_tx_taskq_destroy(void *arg __unused)
5682 {
5683
5684         if (hn_tx_taskque != NULL) {
5685                 int i;
5686
5687                 for (i = 0; i < hn_tx_taskq_cnt; ++i)
5688                         taskqueue_free(hn_tx_taskque[i]);
5689                 free(hn_tx_taskque, M_DEVBUF);
5690         }
5691 }
5692 SYSUNINIT(hn_txtq_destroy, SI_SUB_DRIVERS, SI_ORDER_SECOND,
5693     hn_tx_taskq_destroy, NULL);