drivers/net/netvsc/hn_rxtx.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2016-2018 Microsoft Corporation
   3  * Copyright(c) 2013-2016 Brocade Communications Systems, Inc.
   4  * All rights reserved.
   5  */
   6
   7 #include <stdint.h>
   8 #include <string.h>
   9 #include <stdio.h>
  10 #include <errno.h>
  11 #include <unistd.h>
  12 #include <strings.h>
  13 #include <malloc.h>
  14
  15 #include <rte_ethdev.h>
  16 #include <rte_memcpy.h>
  17 #include <rte_string_fns.h>
  18 #include <rte_memzone.h>
  19 #include <rte_malloc.h>
  20 #include <rte_atomic.h>
  21 #include <rte_bitmap.h>
  22 #include <rte_branch_prediction.h>
  23 #include <rte_ether.h>
  24 #include <rte_common.h>
  25 #include <rte_errno.h>
  26 #include <rte_memory.h>
  27 #include <rte_eal.h>
  28 #include <rte_dev.h>
  29 #include <rte_net.h>
  30 #include <rte_bus_vmbus.h>
  31 #include <rte_spinlock.h>
  32
  33 #include "hn_logs.h"
  34 #include "hn_var.h"
  35 #include "hn_rndis.h"
  36 #include "hn_nvs.h"
  37 #include "ndis.h"
  38
  39 #define HN_NVS_SEND_MSG_SIZE \
  40         (sizeof(struct vmbus_chanpkt_hdr) + sizeof(struct hn_nvs_rndis))
  41
  42 #define HN_TXD_CACHE_SIZE       32 /* per cpu tx_descriptor pool cache */
  43 #define HN_TXCOPY_THRESHOLD     512
  44
  45 #define HN_RXCOPY_THRESHOLD     256
  46 #define HN_RXQ_EVENT_DEFAULT    2048
  47
  48 struct hn_rxinfo {
  49         uint32_t        vlan_info;
  50         uint32_t        csum_info;
  51         uint32_t        hash_info;
  52         uint32_t        hash_value;
  53 };
  54
  55 #define HN_RXINFO_VLAN                  0x0001
  56 #define HN_RXINFO_CSUM                  0x0002
  57 #define HN_RXINFO_HASHINF               0x0004
  58 #define HN_RXINFO_HASHVAL               0x0008
  59 #define HN_RXINFO_ALL                   \
  60         (HN_RXINFO_VLAN |               \
  61          HN_RXINFO_CSUM |               \
  62          HN_RXINFO_HASHINF |            \
  63          HN_RXINFO_HASHVAL)
  64
  65 #define HN_NDIS_VLAN_INFO_INVALID       0xffffffff
  66 #define HN_NDIS_RXCSUM_INFO_INVALID     0
  67 #define HN_NDIS_HASH_INFO_INVALID       0
  68
  69 /*
  70  * Per-transmit book keeping.
  71  * A slot in transmit ring (chim_index) is reserved for each transmit.
  72  *
  73  * There are two types of transmit:
  74  *   - buffered transmit where chimney buffer is used and RNDIS header
  75  *     is in the buffer. mbuf == NULL for this case.
  76  *
  77  *   - direct transmit where RNDIS header is in the in  rndis_pkt
  78  *     mbuf is freed after transmit.
  79  *
  80  * Descriptors come from per-port pool which is used
  81  * to limit number of outstanding requests per device.
  82  */
  83 struct hn_txdesc {
  84         struct rte_mbuf *m;
  85
  86         uint16_t        queue_id;
  87         uint32_t        chim_index;
  88         uint32_t        chim_size;
  89         uint32_t        data_size;
  90         uint32_t        packets;
  91
  92         struct rndis_packet_msg *rndis_pkt;
  93 };
  94
  95 #define HN_RNDIS_PKT_LEN                                \
  96         (sizeof(struct rndis_packet_msg) +              \
  97          RNDIS_PKTINFO_SIZE(NDIS_HASH_VALUE_SIZE) +     \
  98          RNDIS_PKTINFO_SIZE(NDIS_VLAN_INFO_SIZE) +      \
  99          RNDIS_PKTINFO_SIZE(NDIS_LSO2_INFO_SIZE) +      \
 100          RNDIS_PKTINFO_SIZE(NDIS_TXCSUM_INFO_SIZE))
 101
 102 #define HN_RNDIS_PKT_ALIGNED    RTE_ALIGN(HN_RNDIS_PKT_LEN, RTE_CACHE_LINE_SIZE)
 103
 104 /* Minimum space required for a packet */
 105 #define HN_PKTSIZE_MIN(align) \
 106         RTE_ALIGN(RTE_ETHER_MIN_LEN + HN_RNDIS_PKT_LEN, align)
 107
 108 #define DEFAULT_TX_FREE_THRESH 32
 109
 110 static void
 111 hn_update_packet_stats(struct hn_stats *stats, const struct rte_mbuf *m)
 112 {
 113         uint32_t s = m->pkt_len;
 114         const struct rte_ether_addr *ea;
 115
 116         if (s == 64) {
 117                 stats->size_bins[1]++;
 118         } else if (s > 64 && s < 1024) {
 119                 uint32_t bin;
 120
 121                 /* count zeros, and offset into correct bin */
 122                 bin = (sizeof(s) * 8) - __builtin_clz(s) - 5;
 123                 stats->size_bins[bin]++;
 124         } else {
 125                 if (s < 64)
 126                         stats->size_bins[0]++;
 127                 else if (s < 1519)
 128                         stats->size_bins[6]++;
 129                 else
 130                         stats->size_bins[7]++;
 131         }
 132
 133         ea = rte_pktmbuf_mtod(m, const struct rte_ether_addr *);
 134         if (rte_is_multicast_ether_addr(ea)) {
 135                 if (rte_is_broadcast_ether_addr(ea))
 136                         stats->broadcast++;
 137                 else
 138                         stats->multicast++;
 139         }
 140 }
 141
 142 static inline unsigned int hn_rndis_pktlen(const struct rndis_packet_msg *pkt)
 143 {
 144         return pkt->pktinfooffset + pkt->pktinfolen;
 145 }
 146
 147 static inline uint32_t
 148 hn_rndis_pktmsg_offset(uint32_t ofs)
 149 {
 150         return ofs - offsetof(struct rndis_packet_msg, dataoffset);
 151 }
 152
 153 static void hn_txd_init(struct rte_mempool *mp __rte_unused,
 154                         void *opaque, void *obj, unsigned int idx)
 155 {
 156         struct hn_tx_queue *txq = opaque;
 157         struct hn_txdesc *txd = obj;
 158
 159         memset(txd, 0, sizeof(*txd));
 160
 161         txd->queue_id = txq->queue_id;
 162         txd->chim_index = NVS_CHIM_IDX_INVALID;
 163         txd->rndis_pkt = (struct rndis_packet_msg *)(char *)txq->tx_rndis
 164                 + idx * HN_RNDIS_PKT_ALIGNED;
 165 }
 166
 167 int
 168 hn_chim_init(struct rte_eth_dev *dev)
 169 {
 170         struct hn_data *hv = dev->data->dev_private;
 171         uint32_t i, chim_bmp_size;
 172
 173         rte_spinlock_init(&hv->chim_lock);
 174         chim_bmp_size = rte_bitmap_get_memory_footprint(hv->chim_cnt);
 175         hv->chim_bmem = rte_zmalloc("hn_chim_bitmap", chim_bmp_size,
 176                                     RTE_CACHE_LINE_SIZE);
 177         if (hv->chim_bmem == NULL) {
 178                 PMD_INIT_LOG(ERR, "failed to allocate bitmap size %u",
 179                              chim_bmp_size);
 180                 return -1;
 181         }
 182
 183         hv->chim_bmap = rte_bitmap_init(hv->chim_cnt,
 184                                         hv->chim_bmem, chim_bmp_size);
 185         if (hv->chim_bmap == NULL) {
 186                 PMD_INIT_LOG(ERR, "failed to init chim bitmap");
 187                 return -1;
 188         }
 189
 190         for (i = 0; i < hv->chim_cnt; i++)
 191                 rte_bitmap_set(hv->chim_bmap, i);
 192
 193         return 0;
 194 }
 195
 196 void
 197 hn_chim_uninit(struct rte_eth_dev *dev)
 198 {
 199         struct hn_data *hv = dev->data->dev_private;
 200
 201         rte_bitmap_free(hv->chim_bmap);
 202         rte_free(hv->chim_bmem);
 203         hv->chim_bmem = NULL;
 204 }
 205
 206 static uint32_t hn_chim_alloc(struct hn_data *hv)
 207 {
 208         uint32_t index = NVS_CHIM_IDX_INVALID;
 209         uint64_t slab;
 210
 211         rte_spinlock_lock(&hv->chim_lock);
 212         if (rte_bitmap_scan(hv->chim_bmap, &index, &slab))
 213                 rte_bitmap_clear(hv->chim_bmap, index);
 214         rte_spinlock_unlock(&hv->chim_lock);
 215
 216         return index;
 217 }
 218
 219 static void hn_chim_free(struct hn_data *hv, uint32_t chim_idx)
 220 {
 221         if (chim_idx >= hv->chim_cnt) {
 222                 PMD_DRV_LOG(ERR, "Invalid chimney index %u", chim_idx);
 223         } else {
 224                 rte_spinlock_lock(&hv->chim_lock);
 225                 rte_bitmap_set(hv->chim_bmap, chim_idx);
 226                 rte_spinlock_unlock(&hv->chim_lock);
 227         }
 228 }
 229
 230 static void hn_reset_txagg(struct hn_tx_queue *txq)
 231 {
 232         txq->agg_szleft = txq->agg_szmax;
 233         txq->agg_pktleft = txq->agg_pktmax;
 234         txq->agg_txd = NULL;
 235         txq->agg_prevpkt = NULL;
 236 }
 237
 238 int
 239 hn_dev_tx_queue_setup(struct rte_eth_dev *dev,
 240                       uint16_t queue_idx, uint16_t nb_desc,
 241                       unsigned int socket_id,
 242                       const struct rte_eth_txconf *tx_conf)
 243
 244 {
 245         struct hn_data *hv = dev->data->dev_private;
 246         struct hn_tx_queue *txq;
 247         char name[RTE_MEMPOOL_NAMESIZE];
 248         uint32_t tx_free_thresh;
 249         int err = -ENOMEM;
 250
 251         PMD_INIT_FUNC_TRACE();
 252
 253         txq = rte_zmalloc_socket("HN_TXQ", sizeof(*txq), RTE_CACHE_LINE_SIZE,
 254                                  socket_id);
 255         if (!txq)
 256                 return -ENOMEM;
 257
 258         txq->hv = hv;
 259         txq->chan = hv->channels[queue_idx];
 260         txq->port_id = dev->data->port_id;
 261         txq->queue_id = queue_idx;
 262
 263         tx_free_thresh = tx_conf->tx_free_thresh;
 264         if (tx_free_thresh == 0)
 265                 tx_free_thresh = RTE_MIN(nb_desc / 4,
 266                                          DEFAULT_TX_FREE_THRESH);
 267
 268         if (tx_free_thresh + 3 >= nb_desc) {
 269                 PMD_INIT_LOG(ERR,
 270                              "tx_free_thresh must be less than the number of TX entries minus 3(%u)."
 271                              " (tx_free_thresh=%u port=%u queue=%u)\n",
 272                              nb_desc - 3,
 273                              tx_free_thresh, dev->data->port_id, queue_idx);
 274                 return -EINVAL;
 275         }
 276
 277         txq->free_thresh = tx_free_thresh;
 278
 279         snprintf(name, sizeof(name),
 280                  "hn_txd_%u_%u", dev->data->port_id, queue_idx);
 281
 282         PMD_INIT_LOG(DEBUG, "TX descriptor pool %s n=%u size=%zu",
 283                      name, nb_desc, sizeof(struct hn_txdesc));
 284
 285         txq->tx_rndis = rte_calloc("hn_txq_rndis", nb_desc,
 286                                    HN_RNDIS_PKT_ALIGNED, RTE_CACHE_LINE_SIZE);
 287         if (txq->tx_rndis == NULL)
 288                 goto error;
 289
 290         txq->txdesc_pool = rte_mempool_create(name, nb_desc,
 291                                               sizeof(struct hn_txdesc),
 292                                               0, 0, NULL, NULL,
 293                                               hn_txd_init, txq,
 294                                               dev->device->numa_node, 0);
 295         if (txq->txdesc_pool == NULL) {
 296                 PMD_DRV_LOG(ERR,
 297                             "mempool %s create failed: %d", name, rte_errno);
 298                 goto error;
 299         }
 300
 301         txq->agg_szmax  = RTE_MIN(hv->chim_szmax, hv->rndis_agg_size);
 302         txq->agg_pktmax = hv->rndis_agg_pkts;
 303         txq->agg_align  = hv->rndis_agg_align;
 304
 305         hn_reset_txagg(txq);
 306
 307         err = hn_vf_tx_queue_setup(dev, queue_idx, nb_desc,
 308                                      socket_id, tx_conf);
 309         if (err == 0) {
 310                 dev->data->tx_queues[queue_idx] = txq;
 311                 return 0;
 312         }
 313
 314 error:
 315         if (txq->txdesc_pool)
 316                 rte_mempool_free(txq->txdesc_pool);
 317         rte_free(txq->tx_rndis);
 318         rte_free(txq);
 319         return err;
 320 }
 321
 322 void
 323 hn_dev_tx_queue_info(struct rte_eth_dev *dev, uint16_t queue_id,
 324                      struct rte_eth_txq_info *qinfo)
 325 {
 326         struct hn_tx_queue *txq = dev->data->tx_queues[queue_id];
 327
 328         qinfo->nb_desc = txq->txdesc_pool->size;
 329         qinfo->conf.offloads = dev->data->dev_conf.txmode.offloads;
 330 }
 331
 332 static struct hn_txdesc *hn_txd_get(struct hn_tx_queue *txq)
 333 {
 334         struct hn_txdesc *txd;
 335
 336         if (rte_mempool_get(txq->txdesc_pool, (void **)&txd)) {
 337                 ++txq->stats.ring_full;
 338                 PMD_TX_LOG(DEBUG, "tx pool exhausted!");
 339                 return NULL;
 340         }
 341
 342         txd->m = NULL;
 343         txd->packets = 0;
 344         txd->data_size = 0;
 345         txd->chim_size = 0;
 346
 347         return txd;
 348 }
 349
 350 static void hn_txd_put(struct hn_tx_queue *txq, struct hn_txdesc *txd)
 351 {
 352         rte_mempool_put(txq->txdesc_pool, txd);
 353 }
 354
 355 void
 356 hn_dev_tx_queue_release(void *arg)
 357 {
 358         struct hn_tx_queue *txq = arg;
 359
 360         PMD_INIT_FUNC_TRACE();
 361
 362         if (!txq)
 363                 return;
 364
 365         if (txq->txdesc_pool)
 366                 rte_mempool_free(txq->txdesc_pool);
 367
 368         rte_free(txq->tx_rndis);
 369         rte_free(txq);
 370 }
 371
 372 static void
 373 hn_nvs_send_completed(struct rte_eth_dev *dev, uint16_t queue_id,
 374                       unsigned long xactid, const struct hn_nvs_rndis_ack *ack)
 375 {
 376         struct hn_data *hv = dev->data->dev_private;
 377         struct hn_txdesc *txd = (struct hn_txdesc *)xactid;
 378         struct hn_tx_queue *txq;
 379
 380         /* Control packets are sent with xacid == 0 */
 381         if (!txd)
 382                 return;
 383
 384         txq = dev->data->tx_queues[queue_id];
 385         if (likely(ack->status == NVS_STATUS_OK)) {
 386                 PMD_TX_LOG(DEBUG, "port %u:%u complete tx %u packets %u bytes %u",
 387                            txq->port_id, txq->queue_id, txd->chim_index,
 388                            txd->packets, txd->data_size);
 389                 txq->stats.bytes += txd->data_size;
 390                 txq->stats.packets += txd->packets;
 391         } else {
 392                 PMD_TX_LOG(NOTICE, "port %u:%u complete tx %u failed status %u",
 393                            txq->port_id, txq->queue_id, txd->chim_index, ack->status);
 394                 ++txq->stats.errors;
 395         }
 396
 397         if (txd->chim_index != NVS_CHIM_IDX_INVALID)
 398                 hn_chim_free(hv, txd->chim_index);
 399
 400         rte_pktmbuf_free(txd->m);
 401         hn_txd_put(txq, txd);
 402 }
 403
 404 /* Handle transmit completion events */
 405 static void
 406 hn_nvs_handle_comp(struct rte_eth_dev *dev, uint16_t queue_id,
 407                    const struct vmbus_chanpkt_hdr *pkt,
 408                    const void *data)
 409 {
 410         const struct hn_nvs_hdr *hdr = data;
 411
 412         switch (hdr->type) {
 413         case NVS_TYPE_RNDIS_ACK:
 414                 hn_nvs_send_completed(dev, queue_id, pkt->xactid, data);
 415                 break;
 416
 417         default:
 418                 PMD_TX_LOG(NOTICE,
 419                            "unexpected send completion type %u",
 420                            hdr->type);
 421         }
 422 }
 423
 424 /* Parse per-packet info (meta data) */
 425 static int
 426 hn_rndis_rxinfo(const void *info_data, unsigned int info_dlen,
 427                 struct hn_rxinfo *info)
 428 {
 429         const struct rndis_pktinfo *pi = info_data;
 430         uint32_t mask = 0;
 431
 432         while (info_dlen != 0) {
 433                 const void *data;
 434                 uint32_t dlen;
 435
 436                 if (unlikely(info_dlen < sizeof(*pi)))
 437                         return -EINVAL;
 438
 439                 if (unlikely(info_dlen < pi->size))
 440                         return -EINVAL;
 441                 info_dlen -= pi->size;
 442
 443                 if (unlikely(pi->size & RNDIS_PKTINFO_SIZE_ALIGNMASK))
 444                         return -EINVAL;
 445                 if (unlikely(pi->size < pi->offset))
 446                         return -EINVAL;
 447
 448                 dlen = pi->size - pi->offset;
 449                 data = pi->data;
 450
 451                 switch (pi->type) {
 452                 case NDIS_PKTINFO_TYPE_VLAN:
 453                         if (unlikely(dlen < NDIS_VLAN_INFO_SIZE))
 454                                 return -EINVAL;
 455                         info->vlan_info = *((const uint32_t *)data);
 456                         mask |= HN_RXINFO_VLAN;
 457                         break;
 458
 459                 case NDIS_PKTINFO_TYPE_CSUM:
 460                         if (unlikely(dlen < NDIS_RXCSUM_INFO_SIZE))
 461                                 return -EINVAL;
 462                         info->csum_info = *((const uint32_t *)data);
 463                         mask |= HN_RXINFO_CSUM;
 464                         break;
 465
 466                 case NDIS_PKTINFO_TYPE_HASHVAL:
 467                         if (unlikely(dlen < NDIS_HASH_VALUE_SIZE))
 468                                 return -EINVAL;
 469                         info->hash_value = *((const uint32_t *)data);
 470                         mask |= HN_RXINFO_HASHVAL;
 471                         break;
 472
 473                 case NDIS_PKTINFO_TYPE_HASHINF:
 474                         if (unlikely(dlen < NDIS_HASH_INFO_SIZE))
 475                                 return -EINVAL;
 476                         info->hash_info = *((const uint32_t *)data);
 477                         mask |= HN_RXINFO_HASHINF;
 478                         break;
 479
 480                 default:
 481                         goto next;
 482                 }
 483
 484                 if (mask == HN_RXINFO_ALL)
 485                         break; /* All found; done */
 486 next:
 487                 pi = (const struct rndis_pktinfo *)
 488                     ((const uint8_t *)pi + pi->size);
 489         }
 490
 491         /*
 492          * Final fixup.
 493          * - If there is no hash value, invalidate the hash info.
 494          */
 495         if (!(mask & HN_RXINFO_HASHVAL))
 496                 info->hash_info = HN_NDIS_HASH_INFO_INVALID;
 497         return 0;
 498 }
 499
 500 /*
 501  * Ack the consumed RXBUF associated w/ this channel packet,
 502  * so that this RXBUF can be recycled by the hypervisor.
 503  */
 504 static void hn_rx_buf_release(struct hn_rx_bufinfo *rxb)
 505 {
 506         struct rte_mbuf_ext_shared_info *shinfo = &rxb->shinfo;
 507         struct hn_data *hv = rxb->hv;
 508
 509         if (rte_mbuf_ext_refcnt_update(shinfo, -1) == 0) {
 510                 hn_nvs_ack_rxbuf(rxb->chan, rxb->xactid);
 511                 --hv->rxbuf_outstanding;
 512         }
 513 }
 514
 515 static void hn_rx_buf_free_cb(void *buf __rte_unused, void *opaque)
 516 {
 517         hn_rx_buf_release(opaque);
 518 }
 519
 520 static struct hn_rx_bufinfo *hn_rx_buf_init(const struct hn_rx_queue *rxq,
 521                                             const struct vmbus_chanpkt_rxbuf *pkt)
 522 {
 523         struct hn_rx_bufinfo *rxb;
 524
 525         rxb = rxq->hv->rxbuf_info + pkt->hdr.xactid;
 526         rxb->chan = rxq->chan;
 527         rxb->xactid = pkt->hdr.xactid;
 528         rxb->hv = rxq->hv;
 529
 530         rxb->shinfo.free_cb = hn_rx_buf_free_cb;
 531         rxb->shinfo.fcb_opaque = rxb;
 532         rte_mbuf_ext_refcnt_set(&rxb->shinfo, 1);
 533         return rxb;
 534 }
 535
 536 static void hn_rxpkt(struct hn_rx_queue *rxq, struct hn_rx_bufinfo *rxb,
 537                      uint8_t *data, unsigned int headroom, unsigned int dlen,
 538                      const struct hn_rxinfo *info)
 539 {
 540         struct hn_data *hv = rxq->hv;
 541         struct rte_mbuf *m;
 542
 543         m = rte_pktmbuf_alloc(rxq->mb_pool);
 544         if (unlikely(!m)) {
 545                 struct rte_eth_dev *dev =
 546                         &rte_eth_devices[rxq->port_id];
 547
 548                 dev->data->rx_mbuf_alloc_failed++;
 549                 return;
 550         }
 551
 552         /*
 553          * For large packets, avoid copy if possible but need to keep
 554          * some space available in receive area for later packets.
 555          */
 556         if (dlen >= HN_RXCOPY_THRESHOLD &&
 557             hv->rxbuf_outstanding < hv->rxbuf_section_cnt / 2) {
 558                 struct rte_mbuf_ext_shared_info *shinfo;
 559                 const void *rxbuf;
 560                 rte_iova_t iova;
 561
 562                 /*
 563                  * Build an external mbuf that points to recveive area.
 564                  * Use refcount to handle multiple packets in same
 565                  * receive buffer section.
 566                  */
 567                 rxbuf = hv->rxbuf_res->addr;
 568                 iova = rte_mem_virt2iova(rxbuf) + RTE_PTR_DIFF(data, rxbuf);
 569                 shinfo = &rxb->shinfo;
 570
 571                 if (rte_mbuf_ext_refcnt_update(shinfo, 1) == 1)
 572                         ++hv->rxbuf_outstanding;
 573
 574                 rte_pktmbuf_attach_extbuf(m, data, iova,
 575                                           dlen + headroom, shinfo);
 576                 m->data_off = headroom;
 577         } else {
 578                 /* Mbuf's in pool must be large enough to hold small packets */
 579                 if (unlikely(rte_pktmbuf_tailroom(m) < dlen)) {
 580                         rte_pktmbuf_free_seg(m);
 581                         ++rxq->stats.errors;
 582                         return;
 583                 }
 584                 rte_memcpy(rte_pktmbuf_mtod(m, void *),
 585                            data + headroom, dlen);
 586         }
 587
 588         m->port = rxq->port_id;
 589         m->pkt_len = dlen;
 590         m->data_len = dlen;
 591         m->packet_type = rte_net_get_ptype(m, NULL,
 592                                            RTE_PTYPE_L2_MASK |
 593                                            RTE_PTYPE_L3_MASK |
 594                                            RTE_PTYPE_L4_MASK);
 595
 596         if (info->vlan_info != HN_NDIS_VLAN_INFO_INVALID) {
 597                 m->vlan_tci = info->vlan_info;
 598                 m->ol_flags |= PKT_RX_VLAN_STRIPPED | PKT_RX_VLAN;
 599
 600                 /* NDIS always strips tag, put it back if necessary */
 601                 if (!hv->vlan_strip && rte_vlan_insert(&m)) {
 602                         PMD_DRV_LOG(DEBUG, "vlan insert failed");
 603                         ++rxq->stats.errors;
 604                         rte_pktmbuf_free(m);
 605                         return;
 606                 }
 607         }
 608
 609         if (info->csum_info != HN_NDIS_RXCSUM_INFO_INVALID) {
 610                 if (info->csum_info & NDIS_RXCSUM_INFO_IPCS_OK)
 611                         m->ol_flags |= PKT_RX_IP_CKSUM_GOOD;
 612
 613                 if (info->csum_info & (NDIS_RXCSUM_INFO_UDPCS_OK
 614                                        | NDIS_RXCSUM_INFO_TCPCS_OK))
 615                         m->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
 616                 else if (info->csum_info & (NDIS_RXCSUM_INFO_TCPCS_FAILED
 617                                             | NDIS_RXCSUM_INFO_UDPCS_FAILED))
 618                         m->ol_flags |= PKT_RX_L4_CKSUM_BAD;
 619         }
 620
 621         if (info->hash_info != HN_NDIS_HASH_INFO_INVALID) {
 622                 m->ol_flags |= PKT_RX_RSS_HASH;
 623                 m->hash.rss = info->hash_value;
 624         }
 625
 626         PMD_RX_LOG(DEBUG,
 627                    "port %u:%u RX id %"PRIu64" size %u type %#x ol_flags %#"PRIx64,
 628                    rxq->port_id, rxq->queue_id, rxb->xactid,
 629                    m->pkt_len, m->packet_type, m->ol_flags);
 630
 631         ++rxq->stats.packets;
 632         rxq->stats.bytes += m->pkt_len;
 633         hn_update_packet_stats(&rxq->stats, m);
 634
 635         if (unlikely(rte_ring_sp_enqueue(rxq->rx_ring, m) != 0)) {
 636                 ++rxq->stats.ring_full;
 637                 rte_pktmbuf_free(m);
 638         }
 639 }
 640
 641 static void hn_rndis_rx_data(struct hn_rx_queue *rxq,
 642                              struct hn_rx_bufinfo *rxb,
 643                              void *data, uint32_t dlen)
 644 {
 645         unsigned int data_off, data_len, pktinfo_off, pktinfo_len;
 646         const struct rndis_packet_msg *pkt = data;
 647         struct hn_rxinfo info = {
 648                 .vlan_info = HN_NDIS_VLAN_INFO_INVALID,
 649                 .csum_info = HN_NDIS_RXCSUM_INFO_INVALID,
 650                 .hash_info = HN_NDIS_HASH_INFO_INVALID,
 651         };
 652         int err;
 653
 654         hn_rndis_dump(pkt);
 655
 656         if (unlikely(dlen < sizeof(*pkt)))
 657                 goto error;
 658
 659         if (unlikely(dlen < pkt->len))
 660                 goto error; /* truncated RNDIS from host */
 661
 662         if (unlikely(pkt->len < pkt->datalen
 663                      + pkt->oobdatalen + pkt->pktinfolen))
 664                 goto error;
 665
 666         if (unlikely(pkt->datalen == 0))
 667                 goto error;
 668
 669         /* Check offsets. */
 670         if (unlikely(pkt->dataoffset < RNDIS_PACKET_MSG_OFFSET_MIN))
 671                 goto error;
 672
 673         if (likely(pkt->pktinfooffset > 0) &&
 674             unlikely(pkt->pktinfooffset < RNDIS_PACKET_MSG_OFFSET_MIN ||
 675                      (pkt->pktinfooffset & RNDIS_PACKET_MSG_OFFSET_ALIGNMASK)))
 676                 goto error;
 677
 678         data_off = RNDIS_PACKET_MSG_OFFSET_ABS(pkt->dataoffset);
 679         data_len = pkt->datalen;
 680         pktinfo_off = RNDIS_PACKET_MSG_OFFSET_ABS(pkt->pktinfooffset);
 681         pktinfo_len = pkt->pktinfolen;
 682
 683         if (likely(pktinfo_len > 0)) {
 684                 err = hn_rndis_rxinfo((const uint8_t *)pkt + pktinfo_off,
 685                                       pktinfo_len, &info);
 686                 if (err)
 687                         goto error;
 688         }
 689
 690         if (unlikely(data_off + data_len > pkt->len))
 691                 goto error;
 692
 693         if (unlikely(data_len < RTE_ETHER_HDR_LEN))
 694                 goto error;
 695
 696         hn_rxpkt(rxq, rxb, data, data_off, data_len, &info);
 697         return;
 698 error:
 699         ++rxq->stats.errors;
 700 }
 701
 702 static void
 703 hn_rndis_receive(struct rte_eth_dev *dev, struct hn_rx_queue *rxq,
 704                  struct hn_rx_bufinfo *rxb, void *buf, uint32_t len)
 705 {
 706         const struct rndis_msghdr *hdr = buf;
 707
 708         switch (hdr->type) {
 709         case RNDIS_PACKET_MSG:
 710                 if (dev->data->dev_started)
 711                         hn_rndis_rx_data(rxq, rxb, buf, len);
 712                 break;
 713
 714         case RNDIS_INDICATE_STATUS_MSG:
 715                 hn_rndis_link_status(dev, buf);
 716                 break;
 717
 718         case RNDIS_INITIALIZE_CMPLT:
 719         case RNDIS_QUERY_CMPLT:
 720         case RNDIS_SET_CMPLT:
 721                 hn_rndis_receive_response(rxq->hv, buf, len);
 722                 break;
 723
 724         default:
 725                 PMD_DRV_LOG(NOTICE,
 726                             "unexpected RNDIS message (type %#x len %u)",
 727                             hdr->type, len);
 728                 break;
 729         }
 730 }
 731
 732 static void
 733 hn_nvs_handle_rxbuf(struct rte_eth_dev *dev,
 734                     struct hn_data *hv,
 735                     struct hn_rx_queue *rxq,
 736                     const struct vmbus_chanpkt_hdr *hdr,
 737                     const void *buf)
 738 {
 739         const struct vmbus_chanpkt_rxbuf *pkt;
 740         const struct hn_nvs_hdr *nvs_hdr = buf;
 741         uint32_t rxbuf_sz = hv->rxbuf_res->len;
 742         char *rxbuf = hv->rxbuf_res->addr;
 743         unsigned int i, hlen, count;
 744         struct hn_rx_bufinfo *rxb;
 745
 746         /* At minimum we need type header */
 747         if (unlikely(vmbus_chanpkt_datalen(hdr) < sizeof(*nvs_hdr))) {
 748                 PMD_RX_LOG(ERR, "invalid receive nvs RNDIS");
 749                 return;
 750         }
 751
 752         /* Make sure that this is a RNDIS message. */
 753         if (unlikely(nvs_hdr->type != NVS_TYPE_RNDIS)) {
 754                 PMD_RX_LOG(ERR, "nvs type %u, not RNDIS",
 755                            nvs_hdr->type);
 756                 return;
 757         }
 758
 759         hlen = vmbus_chanpkt_getlen(hdr->hlen);
 760         if (unlikely(hlen < sizeof(*pkt))) {
 761                 PMD_RX_LOG(ERR, "invalid rxbuf chanpkt");
 762                 return;
 763         }
 764
 765         pkt = container_of(hdr, const struct vmbus_chanpkt_rxbuf, hdr);
 766         if (unlikely(pkt->rxbuf_id != NVS_RXBUF_SIG)) {
 767                 PMD_RX_LOG(ERR, "invalid rxbuf_id 0x%08x",
 768                            pkt->rxbuf_id);
 769                 return;
 770         }
 771
 772         count = pkt->rxbuf_cnt;
 773         if (unlikely(hlen < offsetof(struct vmbus_chanpkt_rxbuf,
 774                                      rxbuf[count]))) {
 775                 PMD_RX_LOG(ERR, "invalid rxbuf_cnt %u", count);
 776                 return;
 777         }
 778
 779         if (pkt->hdr.xactid > hv->rxbuf_section_cnt) {
 780                 PMD_RX_LOG(ERR, "invalid rxbuf section id %" PRIx64,
 781                            pkt->hdr.xactid);
 782                 return;
 783         }
 784
 785         /* Setup receive buffer info to allow for callback */
 786         rxb = hn_rx_buf_init(rxq, pkt);
 787
 788         /* Each range represents 1 RNDIS pkt that contains 1 Ethernet frame */
 789         for (i = 0; i < count; ++i) {
 790                 unsigned int ofs, len;
 791
 792                 ofs = pkt->rxbuf[i].ofs;
 793                 len = pkt->rxbuf[i].len;
 794
 795                 if (unlikely(ofs + len > rxbuf_sz)) {
 796                         PMD_RX_LOG(ERR,
 797                                    "%uth RNDIS msg overflow ofs %u, len %u",
 798                                    i, ofs, len);
 799                         continue;
 800                 }
 801
 802                 if (unlikely(len == 0)) {
 803                         PMD_RX_LOG(ERR, "%uth RNDIS msg len %u", i, len);
 804                         continue;
 805                 }
 806
 807                 hn_rndis_receive(dev, rxq, rxb,
 808                                  rxbuf + ofs, len);
 809         }
 810
 811         /* Send ACK now if external mbuf not used */
 812         hn_rx_buf_release(rxb);
 813 }
 814
 815 /*
 816  * Called when NVS inband events are received.
 817  * Send up a two part message with port_id and the NVS message
 818  * to the pipe to the netvsc-vf-event control thread.
 819  */
 820 static void hn_nvs_handle_notify(struct rte_eth_dev *dev,
 821                                  const struct vmbus_chanpkt_hdr *pkt,
 822                                  const void *data)
 823 {
 824         const struct hn_nvs_hdr *hdr = data;
 825
 826         switch (hdr->type) {
 827         case NVS_TYPE_TXTBL_NOTE:
 828                 /* Transmit indirection table has locking problems
 829                  * in DPDK and therefore not implemented
 830                  */
 831                 PMD_DRV_LOG(DEBUG, "host notify of transmit indirection table");
 832                 break;
 833
 834         case NVS_TYPE_VFASSOC_NOTE:
 835                 hn_nvs_handle_vfassoc(dev, pkt, data);
 836                 break;
 837
 838         default:
 839                 PMD_DRV_LOG(INFO,
 840                             "got notify, nvs type %u", hdr->type);
 841         }
 842 }
 843
 844 struct hn_rx_queue *hn_rx_queue_alloc(struct hn_data *hv,
 845                                       uint16_t queue_id,
 846                                       unsigned int socket_id)
 847 {
 848         struct hn_rx_queue *rxq;
 849
 850         rxq = rte_zmalloc_socket("HN_RXQ", sizeof(*rxq),
 851                                  RTE_CACHE_LINE_SIZE, socket_id);
 852         if (!rxq)
 853                 return NULL;
 854
 855         rxq->hv = hv;
 856         rxq->chan = hv->channels[queue_id];
 857         rte_spinlock_init(&rxq->ring_lock);
 858         rxq->port_id = hv->port_id;
 859         rxq->queue_id = queue_id;
 860         rxq->event_sz = HN_RXQ_EVENT_DEFAULT;
 861         rxq->event_buf = rte_malloc_socket("HN_EVENTS", HN_RXQ_EVENT_DEFAULT,
 862                                            RTE_CACHE_LINE_SIZE, socket_id);
 863         if (!rxq->event_buf) {
 864                 rte_free(rxq);
 865                 return NULL;
 866         }
 867
 868         return rxq;
 869 }
 870
 871 void
 872 hn_dev_rx_queue_info(struct rte_eth_dev *dev, uint16_t queue_id,
 873                      struct rte_eth_rxq_info *qinfo)
 874 {
 875         struct hn_rx_queue *rxq = dev->data->rx_queues[queue_id];
 876
 877         qinfo->mp = rxq->mb_pool;
 878         qinfo->nb_desc = rxq->rx_ring->size;
 879         qinfo->conf.offloads = dev->data->dev_conf.rxmode.offloads;
 880 }
 881
 882 int
 883 hn_dev_rx_queue_setup(struct rte_eth_dev *dev,
 884                       uint16_t queue_idx, uint16_t nb_desc,
 885                       unsigned int socket_id,
 886                       const struct rte_eth_rxconf *rx_conf,
 887                       struct rte_mempool *mp)
 888 {
 889         struct hn_data *hv = dev->data->dev_private;
 890         char ring_name[RTE_RING_NAMESIZE];
 891         struct hn_rx_queue *rxq;
 892         unsigned int count;
 893         int error = -ENOMEM;
 894
 895         PMD_INIT_FUNC_TRACE();
 896
 897         if (queue_idx == 0) {
 898                 rxq = hv->primary;
 899         } else {
 900                 rxq = hn_rx_queue_alloc(hv, queue_idx, socket_id);
 901                 if (!rxq)
 902                         return -ENOMEM;
 903         }
 904
 905         rxq->mb_pool = mp;
 906         count = rte_mempool_avail_count(mp) / dev->data->nb_rx_queues;
 907         if (nb_desc == 0 || nb_desc > count)
 908                 nb_desc = count;
 909
 910         /*
 911          * Staging ring from receive event logic to rx_pkts.
 912          * rx_pkts assumes caller is handling multi-thread issue.
 913          * event logic has locking.
 914          */
 915         snprintf(ring_name, sizeof(ring_name),
 916                  "hn_rx_%u_%u", dev->data->port_id, queue_idx);
 917         rxq->rx_ring = rte_ring_create(ring_name,
 918                                        rte_align32pow2(nb_desc),
 919                                        socket_id, 0);
 920         if (!rxq->rx_ring)
 921                 goto fail;
 922
 923         error = hn_vf_rx_queue_setup(dev, queue_idx, nb_desc,
 924                                      socket_id, rx_conf, mp);
 925         if (error)
 926                 goto fail;
 927
 928         dev->data->rx_queues[queue_idx] = rxq;
 929         return 0;
 930
 931 fail:
 932         rte_ring_free(rxq->rx_ring);
 933         rte_free(rxq->event_buf);
 934         rte_free(rxq);
 935         return error;
 936 }
 937
 938 static void
 939 hn_rx_queue_free(struct hn_rx_queue *rxq, bool keep_primary)
 940 {
 941
 942         if (!rxq)
 943                 return;
 944
 945         rte_ring_free(rxq->rx_ring);
 946         rxq->rx_ring = NULL;
 947         rxq->mb_pool = NULL;
 948
 949         hn_vf_rx_queue_release(rxq->hv, rxq->queue_id);
 950
 951         /* Keep primary queue to allow for control operations */
 952         if (keep_primary && rxq == rxq->hv->primary)
 953                 return;
 954
 955         rte_free(rxq->event_buf);
 956         rte_free(rxq);
 957 }
 958
 959 void
 960 hn_dev_rx_queue_release(void *arg)
 961 {
 962         struct hn_rx_queue *rxq = arg;
 963
 964         PMD_INIT_FUNC_TRACE();
 965
 966         hn_rx_queue_free(rxq, true);
 967 }
 968
 969 int
 970 hn_dev_tx_done_cleanup(void *arg, uint32_t free_cnt)
 971 {
 972         struct hn_tx_queue *txq = arg;
 973
 974         return hn_process_events(txq->hv, txq->queue_id, free_cnt);
 975 }
 976
 977 /*
 978  * Process pending events on the channel.
 979  * Called from both Rx queue poll and Tx cleanup
 980  */
 981 uint32_t hn_process_events(struct hn_data *hv, uint16_t queue_id,
 982                            uint32_t tx_limit)
 983 {
 984         struct rte_eth_dev *dev = &rte_eth_devices[hv->port_id];
 985         struct hn_rx_queue *rxq;
 986         uint32_t bytes_read = 0;
 987         uint32_t tx_done = 0;
 988         int ret = 0;
 989
 990         rxq = queue_id == 0 ? hv->primary : dev->data->rx_queues[queue_id];
 991
 992         /*
 993          * Since channel is shared between Rx and TX queue need to have a lock
 994          * since DPDK does not force same CPU to be used for Rx/Tx.
 995          */
 996         if (unlikely(!rte_spinlock_trylock(&rxq->ring_lock)))
 997                 return 0;
 998
 999         for (;;) {
1000                 const struct vmbus_chanpkt_hdr *pkt;
1001                 uint32_t len = rxq->event_sz;
1002                 const void *data;
1003
1004 retry:
1005                 ret = rte_vmbus_chan_recv_raw(rxq->chan, rxq->event_buf, &len);
1006                 if (ret == -EAGAIN)
1007                         break;  /* ring is empty */
1008
1009                 if (unlikely(ret == -ENOBUFS)) {
1010                         /* event buffer not large enough to read ring */
1011
1012                         PMD_DRV_LOG(DEBUG,
1013                                     "event buffer expansion (need %u)", len);
1014                         rxq->event_sz = len + len / 4;
1015                         rxq->event_buf = rte_realloc(rxq->event_buf, rxq->event_sz,
1016                                                      RTE_CACHE_LINE_SIZE);
1017                         if (rxq->event_buf)
1018                                 goto retry;
1019                         /* out of memory, no more events now */
1020                         rxq->event_sz = 0;
1021                         break;
1022                 }
1023
1024                 if (unlikely(ret <= 0)) {
1025                         /* This indicates a failure to communicate (or worse) */
1026                         rte_exit(EXIT_FAILURE,
1027                                  "vmbus ring buffer error: %d", ret);
1028                 }
1029
1030                 bytes_read += ret;
1031                 pkt = (const struct vmbus_chanpkt_hdr *)rxq->event_buf;
1032                 data = (char *)rxq->event_buf + vmbus_chanpkt_getlen(pkt->hlen);
1033
1034                 switch (pkt->type) {
1035                 case VMBUS_CHANPKT_TYPE_COMP:
1036                         ++tx_done;
1037                         hn_nvs_handle_comp(dev, queue_id, pkt, data);
1038                         break;
1039
1040                 case VMBUS_CHANPKT_TYPE_RXBUF:
1041                         hn_nvs_handle_rxbuf(dev, hv, rxq, pkt, data);
1042                         break;
1043
1044                 case VMBUS_CHANPKT_TYPE_INBAND:
1045                         hn_nvs_handle_notify(dev, pkt, data);
1046                         break;
1047
1048                 default:
1049                         PMD_DRV_LOG(ERR, "unknown chan pkt %u", pkt->type);
1050                         break;
1051                 }
1052
1053                 if (tx_limit && tx_done >= tx_limit)
1054                         break;
1055         }
1056
1057         if (bytes_read > 0)
1058                 rte_vmbus_chan_signal_read(rxq->chan, bytes_read);
1059
1060         rte_spinlock_unlock(&rxq->ring_lock);
1061
1062         return tx_done;
1063 }
1064
1065 static void hn_append_to_chim(struct hn_tx_queue *txq,
1066                               struct rndis_packet_msg *pkt,
1067                               const struct rte_mbuf *m)
1068 {
1069         struct hn_txdesc *txd = txq->agg_txd;
1070         uint8_t *buf = (uint8_t *)pkt;
1071         unsigned int data_offs;
1072
1073         hn_rndis_dump(pkt);
1074
1075         data_offs = RNDIS_PACKET_MSG_OFFSET_ABS(pkt->dataoffset);
1076         txd->chim_size += pkt->len;
1077         txd->data_size += m->pkt_len;
1078         ++txd->packets;
1079         hn_update_packet_stats(&txq->stats, m);
1080
1081         for (; m; m = m->next) {
1082                 uint16_t len = rte_pktmbuf_data_len(m);
1083
1084                 rte_memcpy(buf + data_offs,
1085                            rte_pktmbuf_mtod(m, const char *), len);
1086                 data_offs += len;
1087         }
1088 }
1089
1090 /*
1091  * Send pending aggregated data in chimney buffer (if any).
1092  * Returns error if send was unsuccessful because channel ring buffer
1093  * was full.
1094  */
1095 static int hn_flush_txagg(struct hn_tx_queue *txq, bool *need_sig)
1096
1097 {
1098         struct hn_txdesc *txd = txq->agg_txd;
1099         struct hn_nvs_rndis rndis;
1100         int ret;
1101
1102         if (!txd)
1103                 return 0;
1104
1105         rndis = (struct hn_nvs_rndis) {
1106                 .type = NVS_TYPE_RNDIS,
1107                 .rndis_mtype = NVS_RNDIS_MTYPE_DATA,
1108                 .chim_idx = txd->chim_index,
1109                 .chim_sz = txd->chim_size,
1110         };
1111
1112         PMD_TX_LOG(DEBUG, "port %u:%u tx %u size %u",
1113                    txq->port_id, txq->queue_id, txd->chim_index, txd->chim_size);
1114
1115         ret = hn_nvs_send(txq->chan, VMBUS_CHANPKT_FLAG_RC,
1116                           &rndis, sizeof(rndis), (uintptr_t)txd, need_sig);
1117
1118         if (likely(ret == 0))
1119                 hn_reset_txagg(txq);
1120         else
1121                 PMD_TX_LOG(NOTICE, "port %u:%u send failed: %d",
1122                            txq->port_id, txq->queue_id, ret);
1123
1124         return ret;
1125 }
1126
1127 /*
1128  * Try and find a place in a send chimney buffer to put
1129  * the small packet. If space is available, this routine
1130  * returns a pointer of where to place the data.
1131  * If no space, caller should try direct transmit.
1132  */
1133 static void *
1134 hn_try_txagg(struct hn_data *hv, struct hn_tx_queue *txq,
1135              struct hn_txdesc *txd, uint32_t pktsize)
1136 {
1137         struct hn_txdesc *agg_txd = txq->agg_txd;
1138         struct rndis_packet_msg *pkt;
1139         void *chim;
1140
1141         if (agg_txd) {
1142                 unsigned int padding, olen;
1143
1144                 /*
1145                  * Update the previous RNDIS packet's total length,
1146                  * it can be increased due to the mandatory alignment
1147                  * padding for this RNDIS packet.  And update the
1148                  * aggregating txdesc's chimney sending buffer size
1149                  * accordingly.
1150                  *
1151                  * Zero-out the padding, as required by the RNDIS spec.
1152                  */
1153                 pkt = txq->agg_prevpkt;
1154                 olen = pkt->len;
1155                 padding = RTE_ALIGN(olen, txq->agg_align) - olen;
1156                 if (padding > 0) {
1157                         agg_txd->chim_size += padding;
1158                         pkt->len += padding;
1159                         memset((uint8_t *)pkt + olen, 0, padding);
1160                 }
1161
1162                 chim = (uint8_t *)pkt + pkt->len;
1163                 txq->agg_prevpkt = chim;
1164                 txq->agg_pktleft--;
1165                 txq->agg_szleft -= pktsize;
1166                 if (txq->agg_szleft < HN_PKTSIZE_MIN(txq->agg_align)) {
1167                         /*
1168                          * Probably can't aggregate more packets,
1169                          * flush this aggregating txdesc proactively.
1170                          */
1171                         txq->agg_pktleft = 0;
1172                 }
1173
1174                 hn_txd_put(txq, txd);
1175                 return chim;
1176         }
1177
1178         txd->chim_index = hn_chim_alloc(hv);
1179         if (txd->chim_index == NVS_CHIM_IDX_INVALID)
1180                 return NULL;
1181
1182         chim = (uint8_t *)hv->chim_res->addr
1183                         + txd->chim_index * hv->chim_szmax;
1184
1185         txq->agg_txd = txd;
1186         txq->agg_pktleft = txq->agg_pktmax - 1;
1187         txq->agg_szleft = txq->agg_szmax - pktsize;
1188         txq->agg_prevpkt = chim;
1189
1190         return chim;
1191 }
1192
1193 static inline void *
1194 hn_rndis_pktinfo_append(struct rndis_packet_msg *pkt,
1195                         uint32_t pi_dlen, uint32_t pi_type)
1196 {
1197         const uint32_t pi_size = RNDIS_PKTINFO_SIZE(pi_dlen);
1198         struct rndis_pktinfo *pi;
1199
1200         /*
1201          * Per-packet-info does not move; it only grows.
1202          *
1203          * NOTE:
1204          * pktinfooffset in this phase counts from the beginning
1205          * of rndis_packet_msg.
1206          */
1207         pi = (struct rndis_pktinfo *)((uint8_t *)pkt + hn_rndis_pktlen(pkt));
1208
1209         pkt->pktinfolen += pi_size;
1210
1211         pi->size = pi_size;
1212         pi->type = pi_type;
1213         pi->offset = RNDIS_PKTINFO_OFFSET;
1214
1215         return pi->data;
1216 }
1217
1218 /* Put RNDIS header and packet info on packet */
1219 static void hn_encap(struct rndis_packet_msg *pkt,
1220                      uint16_t queue_id,
1221                      const struct rte_mbuf *m)
1222 {
1223         unsigned int hlen = m->l2_len + m->l3_len;
1224         uint32_t *pi_data;
1225         uint32_t pkt_hlen;
1226
1227         pkt->type = RNDIS_PACKET_MSG;
1228         pkt->len = m->pkt_len;
1229         pkt->dataoffset = 0;
1230         pkt->datalen = m->pkt_len;
1231         pkt->oobdataoffset = 0;
1232         pkt->oobdatalen = 0;
1233         pkt->oobdataelements = 0;
1234         pkt->pktinfooffset = sizeof(*pkt);
1235         pkt->pktinfolen = 0;
1236         pkt->vchandle = 0;
1237         pkt->reserved = 0;
1238
1239         /*
1240          * Set the hash value for this packet, to the queue_id to cause
1241          * TX done event for this packet on the right channel.
1242          */
1243         pi_data = hn_rndis_pktinfo_append(pkt, NDIS_HASH_VALUE_SIZE,
1244                                           NDIS_PKTINFO_TYPE_HASHVAL);
1245         *pi_data = queue_id;
1246
1247         if (m->ol_flags & PKT_TX_VLAN_PKT) {
1248                 pi_data = hn_rndis_pktinfo_append(pkt, NDIS_VLAN_INFO_SIZE,
1249                                                   NDIS_PKTINFO_TYPE_VLAN);
1250                 *pi_data = m->vlan_tci;
1251         }
1252
1253         if (m->ol_flags & PKT_TX_TCP_SEG) {
1254                 pi_data = hn_rndis_pktinfo_append(pkt, NDIS_LSO2_INFO_SIZE,
1255                                                   NDIS_PKTINFO_TYPE_LSO);
1256
1257                 if (m->ol_flags & PKT_TX_IPV6) {
1258                         *pi_data = NDIS_LSO2_INFO_MAKEIPV6(hlen,
1259                                                            m->tso_segsz);
1260                 } else {
1261                         *pi_data = NDIS_LSO2_INFO_MAKEIPV4(hlen,
1262                                                            m->tso_segsz);
1263                 }
1264         } else if (m->ol_flags &
1265                    (PKT_TX_TCP_CKSUM | PKT_TX_UDP_CKSUM | PKT_TX_IP_CKSUM)) {
1266                 pi_data = hn_rndis_pktinfo_append(pkt, NDIS_TXCSUM_INFO_SIZE,
1267                                                   NDIS_PKTINFO_TYPE_CSUM);
1268                 *pi_data = 0;
1269
1270                 if (m->ol_flags & PKT_TX_IPV6)
1271                         *pi_data |= NDIS_TXCSUM_INFO_IPV6;
1272                 if (m->ol_flags & PKT_TX_IPV4) {
1273                         *pi_data |= NDIS_TXCSUM_INFO_IPV4;
1274
1275                         if (m->ol_flags & PKT_TX_IP_CKSUM)
1276                                 *pi_data |= NDIS_TXCSUM_INFO_IPCS;
1277                 }
1278
1279                 if (m->ol_flags & PKT_TX_TCP_CKSUM)
1280                         *pi_data |= NDIS_TXCSUM_INFO_MKTCPCS(hlen);
1281                 else if (m->ol_flags & PKT_TX_UDP_CKSUM)
1282                         *pi_data |= NDIS_TXCSUM_INFO_MKUDPCS(hlen);
1283         }
1284
1285         pkt_hlen = pkt->pktinfooffset + pkt->pktinfolen;
1286         /* Fixup RNDIS packet message total length */
1287         pkt->len += pkt_hlen;
1288
1289         /* Convert RNDIS packet message offsets */
1290         pkt->dataoffset = hn_rndis_pktmsg_offset(pkt_hlen);
1291         pkt->pktinfooffset = hn_rndis_pktmsg_offset(pkt->pktinfooffset);
1292 }
1293
1294 /* How many scatter gather list elements ar needed */
1295 static unsigned int hn_get_slots(const struct rte_mbuf *m)
1296 {
1297         unsigned int slots = 1; /* for RNDIS header */
1298
1299         while (m) {
1300                 unsigned int size = rte_pktmbuf_data_len(m);
1301                 unsigned int offs = rte_mbuf_data_iova(m) & PAGE_MASK;
1302
1303                 slots += (offs + size + PAGE_SIZE - 1) / PAGE_SIZE;
1304                 m = m->next;
1305         }
1306
1307         return slots;
1308 }
1309
1310 /* Build scatter gather list from chained mbuf */
1311 static unsigned int hn_fill_sg(struct vmbus_gpa *sg,
1312                                const struct rte_mbuf *m)
1313 {
1314         unsigned int segs = 0;
1315
1316         while (m) {
1317                 rte_iova_t addr = rte_mbuf_data_iova(m);
1318                 unsigned int page = addr / PAGE_SIZE;
1319                 unsigned int offset = addr & PAGE_MASK;
1320                 unsigned int len = rte_pktmbuf_data_len(m);
1321
1322                 while (len > 0) {
1323                         unsigned int bytes = RTE_MIN(len, PAGE_SIZE - offset);
1324
1325                         sg[segs].page = page;
1326                         sg[segs].ofs = offset;
1327                         sg[segs].len = bytes;
1328                         segs++;
1329
1330                         ++page;
1331                         offset = 0;
1332                         len -= bytes;
1333                 }
1334                 m = m->next;
1335         }
1336
1337         return segs;
1338 }
1339
1340 /* Transmit directly from mbuf */
1341 static int hn_xmit_sg(struct hn_tx_queue *txq,
1342                       const struct hn_txdesc *txd, const struct rte_mbuf *m,
1343                       bool *need_sig)
1344 {
1345         struct vmbus_gpa sg[hn_get_slots(m)];
1346         struct hn_nvs_rndis nvs_rndis = {
1347                 .type = NVS_TYPE_RNDIS,
1348                 .rndis_mtype = NVS_RNDIS_MTYPE_DATA,
1349                 .chim_sz = txd->chim_size,
1350         };
1351         rte_iova_t addr;
1352         unsigned int segs;
1353
1354         /* attach aggregation data if present */
1355         if (txd->chim_size > 0)
1356                 nvs_rndis.chim_idx = txd->chim_index;
1357         else
1358                 nvs_rndis.chim_idx = NVS_CHIM_IDX_INVALID;
1359
1360         hn_rndis_dump(txd->rndis_pkt);
1361
1362         /* pass IOVA of rndis header in first segment */
1363         addr = rte_malloc_virt2iova(txd->rndis_pkt);
1364         if (unlikely(addr == RTE_BAD_IOVA)) {
1365                 PMD_DRV_LOG(ERR, "RNDIS transmit can not get iova");
1366                 return -EINVAL;
1367         }
1368
1369         sg[0].page = addr / PAGE_SIZE;
1370         sg[0].ofs = addr & PAGE_MASK;
1371         sg[0].len = RNDIS_PACKET_MSG_OFFSET_ABS(hn_rndis_pktlen(txd->rndis_pkt));
1372         segs = 1;
1373
1374         hn_update_packet_stats(&txq->stats, m);
1375
1376         segs += hn_fill_sg(sg + 1, m);
1377
1378         PMD_TX_LOG(DEBUG, "port %u:%u tx %u segs %u size %u",
1379                    txq->port_id, txq->queue_id, txd->chim_index,
1380                    segs, nvs_rndis.chim_sz);
1381
1382         return hn_nvs_send_sglist(txq->chan, sg, segs,
1383                                   &nvs_rndis, sizeof(nvs_rndis),
1384                                   (uintptr_t)txd, need_sig);
1385 }
1386
1387 uint16_t
1388 hn_xmit_pkts(void *ptxq, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
1389 {
1390         struct hn_tx_queue *txq = ptxq;
1391         uint16_t queue_id = txq->queue_id;
1392         struct hn_data *hv = txq->hv;
1393         struct rte_eth_dev *vf_dev;
1394         bool need_sig = false;
1395         uint16_t nb_tx, tx_thresh;
1396         int ret;
1397
1398         if (unlikely(hv->closed))
1399                 return 0;
1400
1401         /*
1402          * Always check for events on the primary channel
1403          * because that is where hotplug notifications occur.
1404          */
1405         tx_thresh = RTE_MAX(txq->free_thresh, nb_pkts);
1406         if (txq->queue_id == 0 ||
1407             rte_mempool_avail_count(txq->txdesc_pool) < tx_thresh)
1408                 hn_process_events(hv, txq->queue_id, 0);
1409
1410         /* Transmit over VF if present and up */
1411         rte_rwlock_read_lock(&hv->vf_lock);
1412         vf_dev = hn_get_vf_dev(hv);
1413         if (vf_dev && vf_dev->data->dev_started) {
1414                 void *sub_q = vf_dev->data->tx_queues[queue_id];
1415
1416                 nb_tx = (*vf_dev->tx_pkt_burst)(sub_q, tx_pkts, nb_pkts);
1417                 rte_rwlock_read_unlock(&hv->vf_lock);
1418                 return nb_tx;
1419         }
1420         rte_rwlock_read_unlock(&hv->vf_lock);
1421
1422         for (nb_tx = 0; nb_tx < nb_pkts; nb_tx++) {
1423                 struct rte_mbuf *m = tx_pkts[nb_tx];
1424                 uint32_t pkt_size = m->pkt_len + HN_RNDIS_PKT_LEN;
1425                 struct rndis_packet_msg *pkt;
1426                 struct hn_txdesc *txd;
1427
1428                 txd = hn_txd_get(txq);
1429                 if (txd == NULL)
1430                         break;
1431
1432                 /* For small packets aggregate them in chimney buffer */
1433                 if (m->pkt_len < HN_TXCOPY_THRESHOLD && pkt_size <= txq->agg_szmax) {
1434                         /* If this packet will not fit, then flush  */
1435                         if (txq->agg_pktleft == 0 ||
1436                             RTE_ALIGN(pkt_size, txq->agg_align) > txq->agg_szleft) {
1437                                 if (hn_flush_txagg(txq, &need_sig))
1438                                         goto fail;
1439                         }
1440
1441
1442                         pkt = hn_try_txagg(hv, txq, txd, pkt_size);
1443                         if (unlikely(!pkt))
1444                                 break;
1445
1446                         hn_encap(pkt, queue_id, m);
1447                         hn_append_to_chim(txq, pkt, m);
1448
1449                         rte_pktmbuf_free(m);
1450
1451                         /* if buffer is full, flush */
1452                         if (txq->agg_pktleft == 0 &&
1453                             hn_flush_txagg(txq, &need_sig))
1454                                 goto fail;
1455                 } else {
1456                         /* Send any outstanding packets in buffer */
1457                         if (txq->agg_txd && hn_flush_txagg(txq, &need_sig))
1458                                 goto fail;
1459
1460                         pkt = txd->rndis_pkt;
1461                         txd->m = m;
1462                         txd->data_size = m->pkt_len;
1463                         ++txd->packets;
1464
1465                         hn_encap(pkt, queue_id, m);
1466
1467                         ret = hn_xmit_sg(txq, txd, m, &need_sig);
1468                         if (unlikely(ret != 0)) {
1469                                 PMD_TX_LOG(NOTICE, "sg send failed: %d", ret);
1470                                 ++txq->stats.errors;
1471                                 hn_txd_put(txq, txd);
1472                                 goto fail;
1473                         }
1474                 }
1475         }
1476
1477         /* If partial buffer left, then try and send it.
1478          * if that fails, then reuse it on next send.
1479          */
1480         hn_flush_txagg(txq, &need_sig);
1481
1482 fail:
1483         if (need_sig)
1484                 rte_vmbus_chan_signal_tx(txq->chan);
1485
1486         return nb_tx;
1487 }
1488
1489 static uint16_t
1490 hn_recv_vf(uint16_t vf_port, const struct hn_rx_queue *rxq,
1491            struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
1492 {
1493         uint16_t i, n;
1494
1495         if (unlikely(nb_pkts == 0))
1496                 return 0;
1497
1498         n = rte_eth_rx_burst(vf_port, rxq->queue_id, rx_pkts, nb_pkts);
1499
1500         /* relabel the received mbufs */
1501         for (i = 0; i < n; i++)
1502                 rx_pkts[i]->port = rxq->port_id;
1503
1504         return n;
1505 }
1506
1507 uint16_t
1508 hn_recv_pkts(void *prxq, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
1509 {
1510         struct hn_rx_queue *rxq = prxq;
1511         struct hn_data *hv = rxq->hv;
1512         struct rte_eth_dev *vf_dev;
1513         uint16_t nb_rcv;
1514
1515         if (unlikely(hv->closed))
1516                 return 0;
1517
1518         /* Check for new completions (and hotplug) */
1519         if (likely(rte_ring_count(rxq->rx_ring) < nb_pkts))
1520                 hn_process_events(hv, rxq->queue_id, 0);
1521
1522         /* Always check the vmbus path for multicast and new flows */
1523         nb_rcv = rte_ring_sc_dequeue_burst(rxq->rx_ring,
1524                                            (void **)rx_pkts, nb_pkts, NULL);
1525
1526         /* If VF is available, check that as well */
1527         rte_rwlock_read_lock(&hv->vf_lock);
1528         vf_dev = hn_get_vf_dev(hv);
1529         if (vf_dev && vf_dev->data->dev_started)
1530                 nb_rcv += hn_recv_vf(vf_dev->data->port_id, rxq,
1531                                      rx_pkts + nb_rcv, nb_pkts - nb_rcv);
1532
1533         rte_rwlock_read_unlock(&hv->vf_lock);
1534         return nb_rcv;
1535 }
1536
1537 void
1538 hn_dev_free_queues(struct rte_eth_dev *dev)
1539 {
1540         unsigned int i;
1541
1542         for (i = 0; i < dev->data->nb_rx_queues; i++) {
1543                 struct hn_rx_queue *rxq = dev->data->rx_queues[i];
1544
1545                 hn_rx_queue_free(rxq, false);
1546                 dev->data->rx_queues[i] = NULL;
1547         }
1548         dev->data->nb_rx_queues = 0;
1549
1550         for (i = 0; i < dev->data->nb_tx_queues; i++) {
1551                 hn_dev_tx_queue_release(dev->data->tx_queues[i]);
1552                 dev->data->tx_queues[i] = NULL;
1553         }
1554         dev->data->nb_tx_queues = 0;
1555 }