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