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