lib/librte_vhost/virtio_net.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2016 Intel Corporation
   3  */
   4
   5 #include <stdint.h>
   6 #include <stdbool.h>
   7 #include <linux/virtio_net.h>
   8
   9 #include <rte_mbuf.h>
  10 #include <rte_memcpy.h>
  11 #include <rte_ether.h>
  12 #include <rte_ip.h>
  13 #include <rte_vhost.h>
  14 #include <rte_tcp.h>
  15 #include <rte_udp.h>
  16 #include <rte_sctp.h>
  17 #include <rte_arp.h>
  18
  19 #include "iotlb.h"
  20 #include "vhost.h"
  21
  22 #define MAX_PKT_BURST 32
  23
  24 #define MAX_BATCH_LEN 256
  25
  26 static bool
  27 is_valid_virt_queue_idx(uint32_t idx, int is_tx, uint32_t nr_vring)
  28 {
  29         return (is_tx ^ (idx & 1)) == 0 && idx < nr_vring;
  30 }
  31
  32 static __rte_always_inline void
  33 do_flush_shadow_used_ring(struct virtio_net *dev, struct vhost_virtqueue *vq,
  34                           uint16_t to, uint16_t from, uint16_t size)
  35 {
  36         rte_memcpy(&vq->used->ring[to],
  37                         &vq->shadow_used_ring[from],
  38                         size * sizeof(struct vring_used_elem));
  39         vhost_log_used_vring(dev, vq,
  40                         offsetof(struct vring_used, ring[to]),
  41                         size * sizeof(struct vring_used_elem));
  42 }
  43
  44 static __rte_always_inline void
  45 flush_shadow_used_ring(struct virtio_net *dev, struct vhost_virtqueue *vq)
  46 {
  47         uint16_t used_idx = vq->last_used_idx & (vq->size - 1);
  48
  49         if (used_idx + vq->shadow_used_idx <= vq->size) {
  50                 do_flush_shadow_used_ring(dev, vq, used_idx, 0,
  51                                           vq->shadow_used_idx);
  52         } else {
  53                 uint16_t size;
  54
  55                 /* update used ring interval [used_idx, vq->size] */
  56                 size = vq->size - used_idx;
  57                 do_flush_shadow_used_ring(dev, vq, used_idx, 0, size);
  58
  59                 /* update the left half used ring interval [0, left_size] */
  60                 do_flush_shadow_used_ring(dev, vq, 0, size,
  61                                           vq->shadow_used_idx - size);
  62         }
  63         vq->last_used_idx += vq->shadow_used_idx;
  64
  65         rte_smp_wmb();
  66
  67         *(volatile uint16_t *)&vq->used->idx += vq->shadow_used_idx;
  68         vhost_log_used_vring(dev, vq, offsetof(struct vring_used, idx),
  69                 sizeof(vq->used->idx));
  70 }
  71
  72 static __rte_always_inline void
  73 update_shadow_used_ring(struct vhost_virtqueue *vq,
  74                          uint16_t desc_idx, uint16_t len)
  75 {
  76         uint16_t i = vq->shadow_used_idx++;
  77
  78         vq->shadow_used_ring[i].id  = desc_idx;
  79         vq->shadow_used_ring[i].len = len;
  80 }
  81
  82 static inline void
  83 do_data_copy_enqueue(struct virtio_net *dev, struct vhost_virtqueue *vq)
  84 {
  85         struct batch_copy_elem *elem = vq->batch_copy_elems;
  86         uint16_t count = vq->batch_copy_nb_elems;
  87         int i;
  88
  89         for (i = 0; i < count; i++) {
  90                 rte_memcpy(elem[i].dst, elem[i].src, elem[i].len);
  91                 vhost_log_write(dev, elem[i].log_addr, elem[i].len);
  92                 PRINT_PACKET(dev, (uintptr_t)elem[i].dst, elem[i].len, 0);
  93         }
  94 }
  95
  96 static inline void
  97 do_data_copy_dequeue(struct vhost_virtqueue *vq)
  98 {
  99         struct batch_copy_elem *elem = vq->batch_copy_elems;
 100         uint16_t count = vq->batch_copy_nb_elems;
 101         int i;
 102
 103         for (i = 0; i < count; i++)
 104                 rte_memcpy(elem[i].dst, elem[i].src, elem[i].len);
 105 }
 106
 107 /* avoid write operation when necessary, to lessen cache issues */
 108 #define ASSIGN_UNLESS_EQUAL(var, val) do {      \
 109         if ((var) != (val))                     \
 110                 (var) = (val);                  \
 111 } while (0)
 112
 113 static void
 114 virtio_enqueue_offload(struct rte_mbuf *m_buf, struct virtio_net_hdr *net_hdr)
 115 {
 116         uint64_t csum_l4 = m_buf->ol_flags & PKT_TX_L4_MASK;
 117
 118         if (m_buf->ol_flags & PKT_TX_TCP_SEG)
 119                 csum_l4 |= PKT_TX_TCP_CKSUM;
 120
 121         if (csum_l4) {
 122                 net_hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
 123                 net_hdr->csum_start = m_buf->l2_len + m_buf->l3_len;
 124
 125                 switch (csum_l4) {
 126                 case PKT_TX_TCP_CKSUM:
 127                         net_hdr->csum_offset = (offsetof(struct tcp_hdr,
 128                                                 cksum));
 129                         break;
 130                 case PKT_TX_UDP_CKSUM:
 131                         net_hdr->csum_offset = (offsetof(struct udp_hdr,
 132                                                 dgram_cksum));
 133                         break;
 134                 case PKT_TX_SCTP_CKSUM:
 135                         net_hdr->csum_offset = (offsetof(struct sctp_hdr,
 136                                                 cksum));
 137                         break;
 138                 }
 139         } else {
 140                 ASSIGN_UNLESS_EQUAL(net_hdr->csum_start, 0);
 141                 ASSIGN_UNLESS_EQUAL(net_hdr->csum_offset, 0);
 142                 ASSIGN_UNLESS_EQUAL(net_hdr->flags, 0);
 143         }
 144
 145         /* IP cksum verification cannot be bypassed, then calculate here */
 146         if (m_buf->ol_flags & PKT_TX_IP_CKSUM) {
 147                 struct ipv4_hdr *ipv4_hdr;
 148
 149                 ipv4_hdr = rte_pktmbuf_mtod_offset(m_buf, struct ipv4_hdr *,
 150                                                    m_buf->l2_len);
 151                 ipv4_hdr->hdr_checksum = rte_ipv4_cksum(ipv4_hdr);
 152         }
 153
 154         if (m_buf->ol_flags & PKT_TX_TCP_SEG) {
 155                 if (m_buf->ol_flags & PKT_TX_IPV4)
 156                         net_hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
 157                 else
 158                         net_hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
 159                 net_hdr->gso_size = m_buf->tso_segsz;
 160                 net_hdr->hdr_len = m_buf->l2_len + m_buf->l3_len
 161                                         + m_buf->l4_len;
 162         } else if (m_buf->ol_flags & PKT_TX_UDP_SEG) {
 163                 net_hdr->gso_type = VIRTIO_NET_HDR_GSO_UDP;
 164                 net_hdr->gso_size = m_buf->tso_segsz;
 165                 net_hdr->hdr_len = m_buf->l2_len + m_buf->l3_len +
 166                         m_buf->l4_len;
 167         } else {
 168                 ASSIGN_UNLESS_EQUAL(net_hdr->gso_type, 0);
 169                 ASSIGN_UNLESS_EQUAL(net_hdr->gso_size, 0);
 170                 ASSIGN_UNLESS_EQUAL(net_hdr->hdr_len, 0);
 171         }
 172 }
 173
 174 static __rte_always_inline int
 175 copy_mbuf_to_desc(struct virtio_net *dev, struct vhost_virtqueue *vq,
 176                   struct vring_desc *descs, struct rte_mbuf *m,
 177                   uint16_t desc_idx, uint32_t size)
 178 {
 179         uint32_t desc_avail, desc_offset;
 180         uint32_t mbuf_avail, mbuf_offset;
 181         uint32_t cpy_len;
 182         struct vring_desc *desc;
 183         uint64_t desc_addr;
 184         /* A counter to avoid desc dead loop chain */
 185         uint16_t nr_desc = 1;
 186         struct batch_copy_elem *batch_copy = vq->batch_copy_elems;
 187         uint16_t copy_nb = vq->batch_copy_nb_elems;
 188         int error = 0;
 189
 190         desc = &descs[desc_idx];
 191         desc_addr = vhost_iova_to_vva(dev, vq, desc->addr,
 192                                         desc->len, VHOST_ACCESS_RW);
 193         /*
 194          * Checking of 'desc_addr' placed outside of 'unlikely' macro to avoid
 195          * performance issue with some versions of gcc (4.8.4 and 5.3.0) which
 196          * otherwise stores offset on the stack instead of in a register.
 197          */
 198         if (unlikely(desc->len < dev->vhost_hlen) || !desc_addr) {
 199                 error = -1;
 200                 goto out;
 201         }
 202
 203         rte_prefetch0((void *)(uintptr_t)desc_addr);
 204
 205         virtio_enqueue_offload(m, (struct virtio_net_hdr *)(uintptr_t)desc_addr);
 206         vhost_log_write(dev, desc->addr, dev->vhost_hlen);
 207         PRINT_PACKET(dev, (uintptr_t)desc_addr, dev->vhost_hlen, 0);
 208
 209         desc_offset = dev->vhost_hlen;
 210         desc_avail  = desc->len - dev->vhost_hlen;
 211
 212         mbuf_avail  = rte_pktmbuf_data_len(m);
 213         mbuf_offset = 0;
 214         while (mbuf_avail != 0 || m->next != NULL) {
 215                 /* done with current mbuf, fetch next */
 216                 if (mbuf_avail == 0) {
 217                         m = m->next;
 218
 219                         mbuf_offset = 0;
 220                         mbuf_avail  = rte_pktmbuf_data_len(m);
 221                 }
 222
 223                 /* done with current desc buf, fetch next */
 224                 if (desc_avail == 0) {
 225                         if ((desc->flags & VRING_DESC_F_NEXT) == 0) {
 226                                 /* Room in vring buffer is not enough */
 227                                 error = -1;
 228                                 goto out;
 229                         }
 230                         if (unlikely(desc->next >= size || ++nr_desc > size)) {
 231                                 error = -1;
 232                                 goto out;
 233                         }
 234
 235                         desc = &descs[desc->next];
 236                         desc_addr = vhost_iova_to_vva(dev, vq, desc->addr,
 237                                                         desc->len,
 238                                                         VHOST_ACCESS_RW);
 239                         if (unlikely(!desc_addr)) {
 240                                 error = -1;
 241                                 goto out;
 242                         }
 243
 244                         desc_offset = 0;
 245                         desc_avail  = desc->len;
 246                 }
 247
 248                 cpy_len = RTE_MIN(desc_avail, mbuf_avail);
 249                 if (likely(cpy_len > MAX_BATCH_LEN || copy_nb >= vq->size)) {
 250                         rte_memcpy((void *)((uintptr_t)(desc_addr +
 251                                                         desc_offset)),
 252                                 rte_pktmbuf_mtod_offset(m, void *, mbuf_offset),
 253                                 cpy_len);
 254                         vhost_log_write(dev, desc->addr + desc_offset, cpy_len);
 255                         PRINT_PACKET(dev, (uintptr_t)(desc_addr + desc_offset),
 256                                      cpy_len, 0);
 257                 } else {
 258                         batch_copy[copy_nb].dst =
 259                                 (void *)((uintptr_t)(desc_addr + desc_offset));
 260                         batch_copy[copy_nb].src =
 261                                 rte_pktmbuf_mtod_offset(m, void *, mbuf_offset);
 262                         batch_copy[copy_nb].log_addr = desc->addr + desc_offset;
 263                         batch_copy[copy_nb].len = cpy_len;
 264                         copy_nb++;
 265                 }
 266
 267                 mbuf_avail  -= cpy_len;
 268                 mbuf_offset += cpy_len;
 269                 desc_avail  -= cpy_len;
 270                 desc_offset += cpy_len;
 271         }
 272
 273 out:
 274         vq->batch_copy_nb_elems = copy_nb;
 275
 276         return error;
 277 }
 278
 279 /**
 280  * This function adds buffers to the virtio devices RX virtqueue. Buffers can
 281  * be received from the physical port or from another virtio device. A packet
 282  * count is returned to indicate the number of packets that are successfully
 283  * added to the RX queue. This function works when the mbuf is scattered, but
 284  * it doesn't support the mergeable feature.
 285  */
 286 static __rte_always_inline uint32_t
 287 virtio_dev_rx(struct virtio_net *dev, uint16_t queue_id,
 288               struct rte_mbuf **pkts, uint32_t count)
 289 {
 290         struct vhost_virtqueue *vq;
 291         uint16_t avail_idx, free_entries, start_idx;
 292         uint16_t desc_indexes[MAX_PKT_BURST];
 293         struct vring_desc *descs;
 294         uint16_t used_idx;
 295         uint32_t i, sz;
 296
 297         LOG_DEBUG(VHOST_DATA, "(%d) %s\n", dev->vid, __func__);
 298         if (unlikely(!is_valid_virt_queue_idx(queue_id, 0, dev->nr_vring))) {
 299                 RTE_LOG(ERR, VHOST_DATA, "(%d) %s: invalid virtqueue idx %d.\n",
 300                         dev->vid, __func__, queue_id);
 301                 return 0;
 302         }
 303
 304         vq = dev->virtqueue[queue_id];
 305         if (unlikely(vq->enabled == 0))
 306                 return 0;
 307
 308         if (dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))
 309                 vhost_user_iotlb_rd_lock(vq);
 310
 311         if (unlikely(vq->access_ok == 0)) {
 312                 if (unlikely(vring_translate(dev, vq) < 0)) {
 313                         count = 0;
 314                         goto out;
 315                 }
 316         }
 317
 318         avail_idx = *((volatile uint16_t *)&vq->avail->idx);
 319         start_idx = vq->last_used_idx;
 320         free_entries = avail_idx - start_idx;
 321         count = RTE_MIN(count, free_entries);
 322         count = RTE_MIN(count, (uint32_t)MAX_PKT_BURST);
 323         if (count == 0)
 324                 goto out;
 325
 326         LOG_DEBUG(VHOST_DATA, "(%d) start_idx %d | end_idx %d\n",
 327                 dev->vid, start_idx, start_idx + count);
 328
 329         vq->batch_copy_nb_elems = 0;
 330
 331         /* Retrieve all of the desc indexes first to avoid caching issues. */
 332         rte_prefetch0(&vq->avail->ring[start_idx & (vq->size - 1)]);
 333         for (i = 0; i < count; i++) {
 334                 used_idx = (start_idx + i) & (vq->size - 1);
 335                 desc_indexes[i] = vq->avail->ring[used_idx];
 336                 vq->used->ring[used_idx].id = desc_indexes[i];
 337                 vq->used->ring[used_idx].len = pkts[i]->pkt_len +
 338                                                dev->vhost_hlen;
 339                 vhost_log_used_vring(dev, vq,
 340                         offsetof(struct vring_used, ring[used_idx]),
 341                         sizeof(vq->used->ring[used_idx]));
 342         }
 343
 344         rte_prefetch0(&vq->desc[desc_indexes[0]]);
 345         for (i = 0; i < count; i++) {
 346                 uint16_t desc_idx = desc_indexes[i];
 347                 int err;
 348
 349                 if (vq->desc[desc_idx].flags & VRING_DESC_F_INDIRECT) {
 350                         descs = (struct vring_desc *)(uintptr_t)
 351                                 vhost_iova_to_vva(dev,
 352                                                 vq, vq->desc[desc_idx].addr,
 353                                                 vq->desc[desc_idx].len,
 354                                                 VHOST_ACCESS_RO);
 355                         if (unlikely(!descs)) {
 356                                 count = i;
 357                                 break;
 358                         }
 359
 360                         desc_idx = 0;
 361                         sz = vq->desc[desc_idx].len / sizeof(*descs);
 362                 } else {
 363                         descs = vq->desc;
 364                         sz = vq->size;
 365                 }
 366
 367                 err = copy_mbuf_to_desc(dev, vq, descs, pkts[i], desc_idx, sz);
 368                 if (unlikely(err)) {
 369                         count = i;
 370                         break;
 371                 }
 372
 373                 if (i + 1 < count)
 374                         rte_prefetch0(&vq->desc[desc_indexes[i+1]]);
 375         }
 376
 377         do_data_copy_enqueue(dev, vq);
 378
 379         rte_smp_wmb();
 380
 381         *(volatile uint16_t *)&vq->used->idx += count;
 382         vq->last_used_idx += count;
 383         vhost_log_used_vring(dev, vq,
 384                 offsetof(struct vring_used, idx),
 385                 sizeof(vq->used->idx));
 386
 387         vhost_vring_call(dev, vq);
 388 out:
 389         if (dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))
 390                 vhost_user_iotlb_rd_unlock(vq);
 391
 392         return count;
 393 }
 394
 395 static __rte_always_inline int
 396 fill_vec_buf(struct virtio_net *dev, struct vhost_virtqueue *vq,
 397                          uint32_t avail_idx, uint32_t *vec_idx,
 398                          struct buf_vector *buf_vec, uint16_t *desc_chain_head,
 399                          uint16_t *desc_chain_len)
 400 {
 401         uint16_t idx = vq->avail->ring[avail_idx & (vq->size - 1)];
 402         uint32_t vec_id = *vec_idx;
 403         uint32_t len    = 0;
 404         struct vring_desc *descs = vq->desc;
 405
 406         *desc_chain_head = idx;
 407
 408         if (vq->desc[idx].flags & VRING_DESC_F_INDIRECT) {
 409                 descs = (struct vring_desc *)(uintptr_t)
 410                         vhost_iova_to_vva(dev, vq, vq->desc[idx].addr,
 411                                                 vq->desc[idx].len,
 412                                                 VHOST_ACCESS_RO);
 413                 if (unlikely(!descs))
 414                         return -1;
 415
 416                 idx = 0;
 417         }
 418
 419         while (1) {
 420                 if (unlikely(vec_id >= BUF_VECTOR_MAX || idx >= vq->size))
 421                         return -1;
 422
 423                 len += descs[idx].len;
 424                 buf_vec[vec_id].buf_addr = descs[idx].addr;
 425                 buf_vec[vec_id].buf_len  = descs[idx].len;
 426                 buf_vec[vec_id].desc_idx = idx;
 427                 vec_id++;
 428
 429                 if ((descs[idx].flags & VRING_DESC_F_NEXT) == 0)
 430                         break;
 431
 432                 idx = descs[idx].next;
 433         }
 434
 435         *desc_chain_len = len;
 436         *vec_idx = vec_id;
 437
 438         return 0;
 439 }
 440
 441 /*
 442  * Returns -1 on fail, 0 on success
 443  */
 444 static inline int
 445 reserve_avail_buf_mergeable(struct virtio_net *dev, struct vhost_virtqueue *vq,
 446                                 uint32_t size, struct buf_vector *buf_vec,
 447                                 uint16_t *num_buffers, uint16_t avail_head)
 448 {
 449         uint16_t cur_idx;
 450         uint32_t vec_idx = 0;
 451         uint16_t tries = 0;
 452
 453         uint16_t head_idx = 0;
 454         uint16_t len = 0;
 455
 456         *num_buffers = 0;
 457         cur_idx  = vq->last_avail_idx;
 458
 459         while (size > 0) {
 460                 if (unlikely(cur_idx == avail_head))
 461                         return -1;
 462
 463                 if (unlikely(fill_vec_buf(dev, vq, cur_idx, &vec_idx, buf_vec,
 464                                                 &head_idx, &len) < 0))
 465                         return -1;
 466                 len = RTE_MIN(len, size);
 467                 update_shadow_used_ring(vq, head_idx, len);
 468                 size -= len;
 469
 470                 cur_idx++;
 471                 tries++;
 472                 *num_buffers += 1;
 473
 474                 /*
 475                  * if we tried all available ring items, and still
 476                  * can't get enough buf, it means something abnormal
 477                  * happened.
 478                  */
 479                 if (unlikely(tries >= vq->size))
 480                         return -1;
 481         }
 482
 483         return 0;
 484 }
 485
 486 static __rte_always_inline int
 487 copy_mbuf_to_desc_mergeable(struct virtio_net *dev, struct vhost_virtqueue *vq,
 488                             struct rte_mbuf *m, struct buf_vector *buf_vec,
 489                             uint16_t num_buffers)
 490 {
 491         uint32_t vec_idx = 0;
 492         uint64_t desc_addr;
 493         uint32_t mbuf_offset, mbuf_avail;
 494         uint32_t desc_offset, desc_avail;
 495         uint32_t cpy_len;
 496         uint64_t hdr_addr, hdr_phys_addr;
 497         struct rte_mbuf *hdr_mbuf;
 498         struct batch_copy_elem *batch_copy = vq->batch_copy_elems;
 499         uint16_t copy_nb = vq->batch_copy_nb_elems;
 500         int error = 0;
 501
 502         if (unlikely(m == NULL)) {
 503                 error = -1;
 504                 goto out;
 505         }
 506
 507         desc_addr = vhost_iova_to_vva(dev, vq, buf_vec[vec_idx].buf_addr,
 508                                                 buf_vec[vec_idx].buf_len,
 509                                                 VHOST_ACCESS_RW);
 510         if (buf_vec[vec_idx].buf_len < dev->vhost_hlen || !desc_addr) {
 511                 error = -1;
 512                 goto out;
 513         }
 514
 515         hdr_mbuf = m;
 516         hdr_addr = desc_addr;
 517         hdr_phys_addr = buf_vec[vec_idx].buf_addr;
 518         rte_prefetch0((void *)(uintptr_t)hdr_addr);
 519
 520         LOG_DEBUG(VHOST_DATA, "(%d) RX: num merge buffers %d\n",
 521                 dev->vid, num_buffers);
 522
 523         desc_avail  = buf_vec[vec_idx].buf_len - dev->vhost_hlen;
 524         desc_offset = dev->vhost_hlen;
 525
 526         mbuf_avail  = rte_pktmbuf_data_len(m);
 527         mbuf_offset = 0;
 528         while (mbuf_avail != 0 || m->next != NULL) {
 529                 /* done with current desc buf, get the next one */
 530                 if (desc_avail == 0) {
 531                         vec_idx++;
 532                         desc_addr =
 533                                 vhost_iova_to_vva(dev, vq,
 534                                         buf_vec[vec_idx].buf_addr,
 535                                         buf_vec[vec_idx].buf_len,
 536                                         VHOST_ACCESS_RW);
 537                         if (unlikely(!desc_addr)) {
 538                                 error = -1;
 539                                 goto out;
 540                         }
 541
 542                         /* Prefetch buffer address. */
 543                         rte_prefetch0((void *)(uintptr_t)desc_addr);
 544                         desc_offset = 0;
 545                         desc_avail  = buf_vec[vec_idx].buf_len;
 546                 }
 547
 548                 /* done with current mbuf, get the next one */
 549                 if (mbuf_avail == 0) {
 550                         m = m->next;
 551
 552                         mbuf_offset = 0;
 553                         mbuf_avail  = rte_pktmbuf_data_len(m);
 554                 }
 555
 556                 if (hdr_addr) {
 557                         struct virtio_net_hdr_mrg_rxbuf *hdr;
 558
 559                         hdr = (struct virtio_net_hdr_mrg_rxbuf *)(uintptr_t)
 560                                 hdr_addr;
 561                         virtio_enqueue_offload(hdr_mbuf, &hdr->hdr);
 562                         ASSIGN_UNLESS_EQUAL(hdr->num_buffers, num_buffers);
 563
 564                         vhost_log_write(dev, hdr_phys_addr, dev->vhost_hlen);
 565                         PRINT_PACKET(dev, (uintptr_t)hdr_addr,
 566                                      dev->vhost_hlen, 0);
 567
 568                         hdr_addr = 0;
 569                 }
 570
 571                 cpy_len = RTE_MIN(desc_avail, mbuf_avail);
 572
 573                 if (likely(cpy_len > MAX_BATCH_LEN || copy_nb >= vq->size)) {
 574                         rte_memcpy((void *)((uintptr_t)(desc_addr +
 575                                                         desc_offset)),
 576                                 rte_pktmbuf_mtod_offset(m, void *, mbuf_offset),
 577                                 cpy_len);
 578                         vhost_log_write(dev,
 579                                 buf_vec[vec_idx].buf_addr + desc_offset,
 580                                 cpy_len);
 581                         PRINT_PACKET(dev, (uintptr_t)(desc_addr + desc_offset),
 582                                 cpy_len, 0);
 583                 } else {
 584                         batch_copy[copy_nb].dst =
 585                                 (void *)((uintptr_t)(desc_addr + desc_offset));
 586                         batch_copy[copy_nb].src =
 587                                 rte_pktmbuf_mtod_offset(m, void *, mbuf_offset);
 588                         batch_copy[copy_nb].log_addr =
 589                                 buf_vec[vec_idx].buf_addr + desc_offset;
 590                         batch_copy[copy_nb].len = cpy_len;
 591                         copy_nb++;
 592                 }
 593
 594                 mbuf_avail  -= cpy_len;
 595                 mbuf_offset += cpy_len;
 596                 desc_avail  -= cpy_len;
 597                 desc_offset += cpy_len;
 598         }
 599
 600 out:
 601         vq->batch_copy_nb_elems = copy_nb;
 602
 603         return error;
 604 }
 605
 606 static __rte_always_inline uint32_t
 607 virtio_dev_merge_rx(struct virtio_net *dev, uint16_t queue_id,
 608         struct rte_mbuf **pkts, uint32_t count)
 609 {
 610         struct vhost_virtqueue *vq;
 611         uint32_t pkt_idx = 0;
 612         uint16_t num_buffers;
 613         struct buf_vector buf_vec[BUF_VECTOR_MAX];
 614         uint16_t avail_head;
 615
 616         LOG_DEBUG(VHOST_DATA, "(%d) %s\n", dev->vid, __func__);
 617         if (unlikely(!is_valid_virt_queue_idx(queue_id, 0, dev->nr_vring))) {
 618                 RTE_LOG(ERR, VHOST_DATA, "(%d) %s: invalid virtqueue idx %d.\n",
 619                         dev->vid, __func__, queue_id);
 620                 return 0;
 621         }
 622
 623         vq = dev->virtqueue[queue_id];
 624         if (unlikely(vq->enabled == 0))
 625                 return 0;
 626
 627         if (dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))
 628                 vhost_user_iotlb_rd_lock(vq);
 629
 630         if (unlikely(vq->access_ok == 0))
 631                 if (unlikely(vring_translate(dev, vq) < 0))
 632                         goto out;
 633
 634         count = RTE_MIN((uint32_t)MAX_PKT_BURST, count);
 635         if (count == 0)
 636                 goto out;
 637
 638         vq->batch_copy_nb_elems = 0;
 639
 640         rte_prefetch0(&vq->avail->ring[vq->last_avail_idx & (vq->size - 1)]);
 641
 642         vq->shadow_used_idx = 0;
 643         avail_head = *((volatile uint16_t *)&vq->avail->idx);
 644         for (pkt_idx = 0; pkt_idx < count; pkt_idx++) {
 645                 uint32_t pkt_len = pkts[pkt_idx]->pkt_len + dev->vhost_hlen;
 646
 647                 if (unlikely(reserve_avail_buf_mergeable(dev, vq,
 648                                                 pkt_len, buf_vec, &num_buffers,
 649                                                 avail_head) < 0)) {
 650                         LOG_DEBUG(VHOST_DATA,
 651                                 "(%d) failed to get enough desc from vring\n",
 652                                 dev->vid);
 653                         vq->shadow_used_idx -= num_buffers;
 654                         break;
 655                 }
 656
 657                 LOG_DEBUG(VHOST_DATA, "(%d) current index %d | end index %d\n",
 658                         dev->vid, vq->last_avail_idx,
 659                         vq->last_avail_idx + num_buffers);
 660
 661                 if (copy_mbuf_to_desc_mergeable(dev, vq, pkts[pkt_idx],
 662                                                 buf_vec, num_buffers) < 0) {
 663                         vq->shadow_used_idx -= num_buffers;
 664                         break;
 665                 }
 666
 667                 vq->last_avail_idx += num_buffers;
 668         }
 669
 670         do_data_copy_enqueue(dev, vq);
 671
 672         if (likely(vq->shadow_used_idx)) {
 673                 flush_shadow_used_ring(dev, vq);
 674                 vhost_vring_call(dev, vq);
 675         }
 676
 677 out:
 678         if (dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))
 679                 vhost_user_iotlb_rd_unlock(vq);
 680
 681         return pkt_idx;
 682 }
 683
 684 uint16_t
 685 rte_vhost_enqueue_burst(int vid, uint16_t queue_id,
 686         struct rte_mbuf **pkts, uint16_t count)
 687 {
 688         struct virtio_net *dev = get_device(vid);
 689
 690         if (!dev)
 691                 return 0;
 692
 693         if (dev->features & (1 << VIRTIO_NET_F_MRG_RXBUF))
 694                 return virtio_dev_merge_rx(dev, queue_id, pkts, count);
 695         else
 696                 return virtio_dev_rx(dev, queue_id, pkts, count);
 697 }
 698
 699 static inline bool
 700 virtio_net_with_host_offload(struct virtio_net *dev)
 701 {
 702         if (dev->features &
 703                         ((1ULL << VIRTIO_NET_F_CSUM) |
 704                          (1ULL << VIRTIO_NET_F_HOST_ECN) |
 705                          (1ULL << VIRTIO_NET_F_HOST_TSO4) |
 706                          (1ULL << VIRTIO_NET_F_HOST_TSO6) |
 707                          (1ULL << VIRTIO_NET_F_HOST_UFO)))
 708                 return true;
 709
 710         return false;
 711 }
 712
 713 static void
 714 parse_ethernet(struct rte_mbuf *m, uint16_t *l4_proto, void **l4_hdr)
 715 {
 716         struct ipv4_hdr *ipv4_hdr;
 717         struct ipv6_hdr *ipv6_hdr;
 718         void *l3_hdr = NULL;
 719         struct ether_hdr *eth_hdr;
 720         uint16_t ethertype;
 721
 722         eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
 723
 724         m->l2_len = sizeof(struct ether_hdr);
 725         ethertype = rte_be_to_cpu_16(eth_hdr->ether_type);
 726
 727         if (ethertype == ETHER_TYPE_VLAN) {
 728                 struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
 729
 730                 m->l2_len += sizeof(struct vlan_hdr);
 731                 ethertype = rte_be_to_cpu_16(vlan_hdr->eth_proto);
 732         }
 733
 734         l3_hdr = (char *)eth_hdr + m->l2_len;
 735
 736         switch (ethertype) {
 737         case ETHER_TYPE_IPv4:
 738                 ipv4_hdr = l3_hdr;
 739                 *l4_proto = ipv4_hdr->next_proto_id;
 740                 m->l3_len = (ipv4_hdr->version_ihl & 0x0f) * 4;
 741                 *l4_hdr = (char *)l3_hdr + m->l3_len;
 742                 m->ol_flags |= PKT_TX_IPV4;
 743                 break;
 744         case ETHER_TYPE_IPv6:
 745                 ipv6_hdr = l3_hdr;
 746                 *l4_proto = ipv6_hdr->proto;
 747                 m->l3_len = sizeof(struct ipv6_hdr);
 748                 *l4_hdr = (char *)l3_hdr + m->l3_len;
 749                 m->ol_flags |= PKT_TX_IPV6;
 750                 break;
 751         default:
 752                 m->l3_len = 0;
 753                 *l4_proto = 0;
 754                 *l4_hdr = NULL;
 755                 break;
 756         }
 757 }
 758
 759 static __rte_always_inline void
 760 vhost_dequeue_offload(struct virtio_net_hdr *hdr, struct rte_mbuf *m)
 761 {
 762         uint16_t l4_proto = 0;
 763         void *l4_hdr = NULL;
 764         struct tcp_hdr *tcp_hdr = NULL;
 765
 766         if (hdr->flags == 0 && hdr->gso_type == VIRTIO_NET_HDR_GSO_NONE)
 767                 return;
 768
 769         parse_ethernet(m, &l4_proto, &l4_hdr);
 770         if (hdr->flags == VIRTIO_NET_HDR_F_NEEDS_CSUM) {
 771                 if (hdr->csum_start == (m->l2_len + m->l3_len)) {
 772                         switch (hdr->csum_offset) {
 773                         case (offsetof(struct tcp_hdr, cksum)):
 774                                 if (l4_proto == IPPROTO_TCP)
 775                                         m->ol_flags |= PKT_TX_TCP_CKSUM;
 776                                 break;
 777                         case (offsetof(struct udp_hdr, dgram_cksum)):
 778                                 if (l4_proto == IPPROTO_UDP)
 779                                         m->ol_flags |= PKT_TX_UDP_CKSUM;
 780                                 break;
 781                         case (offsetof(struct sctp_hdr, cksum)):
 782                                 if (l4_proto == IPPROTO_SCTP)
 783                                         m->ol_flags |= PKT_TX_SCTP_CKSUM;
 784                                 break;
 785                         default:
 786                                 break;
 787                         }
 788                 }
 789         }
 790
 791         if (l4_hdr && hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
 792                 switch (hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
 793                 case VIRTIO_NET_HDR_GSO_TCPV4:
 794                 case VIRTIO_NET_HDR_GSO_TCPV6:
 795                         tcp_hdr = l4_hdr;
 796                         m->ol_flags |= PKT_TX_TCP_SEG;
 797                         m->tso_segsz = hdr->gso_size;
 798                         m->l4_len = (tcp_hdr->data_off & 0xf0) >> 2;
 799                         break;
 800                 case VIRTIO_NET_HDR_GSO_UDP:
 801                         m->ol_flags |= PKT_TX_UDP_SEG;
 802                         m->tso_segsz = hdr->gso_size;
 803                         m->l4_len = sizeof(struct udp_hdr);
 804                         break;
 805                 default:
 806                         RTE_LOG(WARNING, VHOST_DATA,
 807                                 "unsupported gso type %u.\n", hdr->gso_type);
 808                         break;
 809                 }
 810         }
 811 }
 812
 813 static __rte_always_inline void
 814 put_zmbuf(struct zcopy_mbuf *zmbuf)
 815 {
 816         zmbuf->in_use = 0;
 817 }
 818
 819 static __rte_always_inline int
 820 copy_desc_to_mbuf(struct virtio_net *dev, struct vhost_virtqueue *vq,
 821                   struct vring_desc *descs, uint16_t max_desc,
 822                   struct rte_mbuf *m, uint16_t desc_idx,
 823                   struct rte_mempool *mbuf_pool)
 824 {
 825         struct vring_desc *desc;
 826         uint64_t desc_addr;
 827         uint32_t desc_avail, desc_offset;
 828         uint32_t mbuf_avail, mbuf_offset;
 829         uint32_t cpy_len;
 830         struct rte_mbuf *cur = m, *prev = m;
 831         struct virtio_net_hdr *hdr = NULL;
 832         /* A counter to avoid desc dead loop chain */
 833         uint32_t nr_desc = 1;
 834         struct batch_copy_elem *batch_copy = vq->batch_copy_elems;
 835         uint16_t copy_nb = vq->batch_copy_nb_elems;
 836         int error = 0;
 837
 838         desc = &descs[desc_idx];
 839         if (unlikely((desc->len < dev->vhost_hlen)) ||
 840                         (desc->flags & VRING_DESC_F_INDIRECT)) {
 841                 error = -1;
 842                 goto out;
 843         }
 844
 845         desc_addr = vhost_iova_to_vva(dev,
 846                                         vq, desc->addr,
 847                                         desc->len,
 848                                         VHOST_ACCESS_RO);
 849         if (unlikely(!desc_addr)) {
 850                 error = -1;
 851                 goto out;
 852         }
 853
 854         if (virtio_net_with_host_offload(dev)) {
 855                 hdr = (struct virtio_net_hdr *)((uintptr_t)desc_addr);
 856                 rte_prefetch0(hdr);
 857         }
 858
 859         /*
 860          * A virtio driver normally uses at least 2 desc buffers
 861          * for Tx: the first for storing the header, and others
 862          * for storing the data.
 863          */
 864         if (likely((desc->len == dev->vhost_hlen) &&
 865                    (desc->flags & VRING_DESC_F_NEXT) != 0)) {
 866                 desc = &descs[desc->next];
 867                 if (unlikely(desc->flags & VRING_DESC_F_INDIRECT)) {
 868                         error = -1;
 869                         goto out;
 870                 }
 871
 872                 desc_addr = vhost_iova_to_vva(dev,
 873                                                         vq, desc->addr,
 874                                                         desc->len,
 875                                                         VHOST_ACCESS_RO);
 876                 if (unlikely(!desc_addr)) {
 877                         error = -1;
 878                         goto out;
 879                 }
 880
 881                 desc_offset = 0;
 882                 desc_avail  = desc->len;
 883                 nr_desc    += 1;
 884         } else {
 885                 desc_avail  = desc->len - dev->vhost_hlen;
 886                 desc_offset = dev->vhost_hlen;
 887         }
 888
 889         rte_prefetch0((void *)(uintptr_t)(desc_addr + desc_offset));
 890
 891         PRINT_PACKET(dev, (uintptr_t)(desc_addr + desc_offset), desc_avail, 0);
 892
 893         mbuf_offset = 0;
 894         mbuf_avail  = m->buf_len - RTE_PKTMBUF_HEADROOM;
 895         while (1) {
 896                 uint64_t hpa;
 897
 898                 cpy_len = RTE_MIN(desc_avail, mbuf_avail);
 899
 900                 /*
 901                  * A desc buf might across two host physical pages that are
 902                  * not continuous. In such case (gpa_to_hpa returns 0), data
 903                  * will be copied even though zero copy is enabled.
 904                  */
 905                 if (unlikely(dev->dequeue_zero_copy && (hpa = gpa_to_hpa(dev,
 906                                         desc->addr + desc_offset, cpy_len)))) {
 907                         cur->data_len = cpy_len;
 908                         cur->data_off = 0;
 909                         cur->buf_addr = (void *)(uintptr_t)(desc_addr
 910                                 + desc_offset);
 911                         cur->buf_iova = hpa;
 912
 913                         /*
 914                          * In zero copy mode, one mbuf can only reference data
 915                          * for one or partial of one desc buff.
 916                          */
 917                         mbuf_avail = cpy_len;
 918                 } else {
 919                         if (likely(cpy_len > MAX_BATCH_LEN ||
 920                                    copy_nb >= vq->size ||
 921                                    (hdr && cur == m))) {
 922                                 rte_memcpy(rte_pktmbuf_mtod_offset(cur, void *,
 923                                                                    mbuf_offset),
 924                                            (void *)((uintptr_t)(desc_addr +
 925                                                                 desc_offset)),
 926                                            cpy_len);
 927                         } else {
 928                                 batch_copy[copy_nb].dst =
 929                                         rte_pktmbuf_mtod_offset(cur, void *,
 930                                                                 mbuf_offset);
 931                                 batch_copy[copy_nb].src =
 932                                         (void *)((uintptr_t)(desc_addr +
 933                                                              desc_offset));
 934                                 batch_copy[copy_nb].len = cpy_len;
 935                                 copy_nb++;
 936                         }
 937                 }
 938
 939                 mbuf_avail  -= cpy_len;
 940                 mbuf_offset += cpy_len;
 941                 desc_avail  -= cpy_len;
 942                 desc_offset += cpy_len;
 943
 944                 /* This desc reaches to its end, get the next one */
 945                 if (desc_avail == 0) {
 946                         if ((desc->flags & VRING_DESC_F_NEXT) == 0)
 947                                 break;
 948
 949                         if (unlikely(desc->next >= max_desc ||
 950                                      ++nr_desc > max_desc)) {
 951                                 error = -1;
 952                                 goto out;
 953                         }
 954                         desc = &descs[desc->next];
 955                         if (unlikely(desc->flags & VRING_DESC_F_INDIRECT)) {
 956                                 error = -1;
 957                                 goto out;
 958                         }
 959
 960                         desc_addr = vhost_iova_to_vva(dev,
 961                                                         vq, desc->addr,
 962                                                         desc->len,
 963                                                         VHOST_ACCESS_RO);
 964                         if (unlikely(!desc_addr)) {
 965                                 error = -1;
 966                                 goto out;
 967                         }
 968
 969                         rte_prefetch0((void *)(uintptr_t)desc_addr);
 970
 971                         desc_offset = 0;
 972                         desc_avail  = desc->len;
 973
 974                         PRINT_PACKET(dev, (uintptr_t)desc_addr, desc->len, 0);
 975                 }
 976
 977                 /*
 978                  * This mbuf reaches to its end, get a new one
 979                  * to hold more data.
 980                  */
 981                 if (mbuf_avail == 0) {
 982                         cur = rte_pktmbuf_alloc(mbuf_pool);
 983                         if (unlikely(cur == NULL)) {
 984                                 RTE_LOG(ERR, VHOST_DATA, "Failed to "
 985                                         "allocate memory for mbuf.\n");
 986                                 error = -1;
 987                                 goto out;
 988                         }
 989                         if (unlikely(dev->dequeue_zero_copy))
 990                                 rte_mbuf_refcnt_update(cur, 1);
 991
 992                         prev->next = cur;
 993                         prev->data_len = mbuf_offset;
 994                         m->nb_segs += 1;
 995                         m->pkt_len += mbuf_offset;
 996                         prev = cur;
 997
 998                         mbuf_offset = 0;
 999                         mbuf_avail  = cur->buf_len - RTE_PKTMBUF_HEADROOM;
1000                 }
1001         }
1002
1003         prev->data_len = mbuf_offset;
1004         m->pkt_len    += mbuf_offset;
1005
1006         if (hdr)
1007                 vhost_dequeue_offload(hdr, m);
1008
1009 out:
1010         vq->batch_copy_nb_elems = copy_nb;
1011
1012         return error;
1013 }
1014
1015 static __rte_always_inline void
1016 update_used_ring(struct virtio_net *dev, struct vhost_virtqueue *vq,
1017                  uint32_t used_idx, uint32_t desc_idx)
1018 {
1019         vq->used->ring[used_idx].id  = desc_idx;
1020         vq->used->ring[used_idx].len = 0;
1021         vhost_log_used_vring(dev, vq,
1022                         offsetof(struct vring_used, ring[used_idx]),
1023                         sizeof(vq->used->ring[used_idx]));
1024 }
1025
1026 static __rte_always_inline void
1027 update_used_idx(struct virtio_net *dev, struct vhost_virtqueue *vq,
1028                 uint32_t count)
1029 {
1030         if (unlikely(count == 0))
1031                 return;
1032
1033         rte_smp_wmb();
1034         rte_smp_rmb();
1035
1036         vq->used->idx += count;
1037         vhost_log_used_vring(dev, vq, offsetof(struct vring_used, idx),
1038                         sizeof(vq->used->idx));
1039         vhost_vring_call(dev, vq);
1040 }
1041
1042 static __rte_always_inline struct zcopy_mbuf *
1043 get_zmbuf(struct vhost_virtqueue *vq)
1044 {
1045         uint16_t i;
1046         uint16_t last;
1047         int tries = 0;
1048
1049         /* search [last_zmbuf_idx, zmbuf_size) */
1050         i = vq->last_zmbuf_idx;
1051         last = vq->zmbuf_size;
1052
1053 again:
1054         for (; i < last; i++) {
1055                 if (vq->zmbufs[i].in_use == 0) {
1056                         vq->last_zmbuf_idx = i + 1;
1057                         vq->zmbufs[i].in_use = 1;
1058                         return &vq->zmbufs[i];
1059                 }
1060         }
1061
1062         tries++;
1063         if (tries == 1) {
1064                 /* search [0, last_zmbuf_idx) */
1065                 i = 0;
1066                 last = vq->last_zmbuf_idx;
1067                 goto again;
1068         }
1069
1070         return NULL;
1071 }
1072
1073 static __rte_always_inline bool
1074 mbuf_is_consumed(struct rte_mbuf *m)
1075 {
1076         while (m) {
1077                 if (rte_mbuf_refcnt_read(m) > 1)
1078                         return false;
1079                 m = m->next;
1080         }
1081
1082         return true;
1083 }
1084
1085 uint16_t
1086 rte_vhost_dequeue_burst(int vid, uint16_t queue_id,
1087         struct rte_mempool *mbuf_pool, struct rte_mbuf **pkts, uint16_t count)
1088 {
1089         struct virtio_net *dev;
1090         struct rte_mbuf *rarp_mbuf = NULL;
1091         struct vhost_virtqueue *vq;
1092         uint32_t desc_indexes[MAX_PKT_BURST];
1093         uint32_t used_idx;
1094         uint32_t i = 0;
1095         uint16_t free_entries;
1096         uint16_t avail_idx;
1097
1098         dev = get_device(vid);
1099         if (!dev)
1100                 return 0;
1101
1102         if (unlikely(!is_valid_virt_queue_idx(queue_id, 1, dev->nr_vring))) {
1103                 RTE_LOG(ERR, VHOST_DATA, "(%d) %s: invalid virtqueue idx %d.\n",
1104                         dev->vid, __func__, queue_id);
1105                 return 0;
1106         }
1107
1108         vq = dev->virtqueue[queue_id];
1109         if (unlikely(vq->enabled == 0))
1110                 return 0;
1111
1112         vq->batch_copy_nb_elems = 0;
1113
1114         if (dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))
1115                 vhost_user_iotlb_rd_lock(vq);
1116
1117         if (unlikely(vq->access_ok == 0))
1118                 if (unlikely(vring_translate(dev, vq) < 0))
1119                         goto out;
1120
1121         if (unlikely(dev->dequeue_zero_copy)) {
1122                 struct zcopy_mbuf *zmbuf, *next;
1123                 int nr_updated = 0;
1124
1125                 for (zmbuf = TAILQ_FIRST(&vq->zmbuf_list);
1126                      zmbuf != NULL; zmbuf = next) {
1127                         next = TAILQ_NEXT(zmbuf, next);
1128
1129                         if (mbuf_is_consumed(zmbuf->mbuf)) {
1130                                 used_idx = vq->last_used_idx++ & (vq->size - 1);
1131                                 update_used_ring(dev, vq, used_idx,
1132                                                  zmbuf->desc_idx);
1133                                 nr_updated += 1;
1134
1135                                 TAILQ_REMOVE(&vq->zmbuf_list, zmbuf, next);
1136                                 rte_pktmbuf_free(zmbuf->mbuf);
1137                                 put_zmbuf(zmbuf);
1138                                 vq->nr_zmbuf -= 1;
1139                         }
1140                 }
1141
1142                 update_used_idx(dev, vq, nr_updated);
1143         }
1144
1145         /*
1146          * Construct a RARP broadcast packet, and inject it to the "pkts"
1147          * array, to looks like that guest actually send such packet.
1148          *
1149          * Check user_send_rarp() for more information.
1150          *
1151          * broadcast_rarp shares a cacheline in the virtio_net structure
1152          * with some fields that are accessed during enqueue and
1153          * rte_atomic16_cmpset() causes a write if using cmpxchg. This could
1154          * result in false sharing between enqueue and dequeue.
1155          *
1156          * Prevent unnecessary false sharing by reading broadcast_rarp first
1157          * and only performing cmpset if the read indicates it is likely to
1158          * be set.
1159          */
1160
1161         if (unlikely(rte_atomic16_read(&dev->broadcast_rarp) &&
1162                         rte_atomic16_cmpset((volatile uint16_t *)
1163                                 &dev->broadcast_rarp.cnt, 1, 0))) {
1164
1165                 rarp_mbuf = rte_pktmbuf_alloc(mbuf_pool);
1166                 if (rarp_mbuf == NULL) {
1167                         RTE_LOG(ERR, VHOST_DATA,
1168                                 "Failed to allocate memory for mbuf.\n");
1169                         return 0;
1170                 }
1171
1172                 if (rte_net_make_rarp_packet(rarp_mbuf, &dev->mac) < 0) {
1173                         rte_pktmbuf_free(rarp_mbuf);
1174                         rarp_mbuf = NULL;
1175                 } else {
1176                         count -= 1;
1177                 }
1178         }
1179
1180         free_entries = *((volatile uint16_t *)&vq->avail->idx) -
1181                         vq->last_avail_idx;
1182         if (free_entries == 0)
1183                 goto out;
1184
1185         LOG_DEBUG(VHOST_DATA, "(%d) %s\n", dev->vid, __func__);
1186
1187         /* Prefetch available and used ring */
1188         avail_idx = vq->last_avail_idx & (vq->size - 1);
1189         used_idx  = vq->last_used_idx  & (vq->size - 1);
1190         rte_prefetch0(&vq->avail->ring[avail_idx]);
1191         rte_prefetch0(&vq->used->ring[used_idx]);
1192
1193         count = RTE_MIN(count, MAX_PKT_BURST);
1194         count = RTE_MIN(count, free_entries);
1195         LOG_DEBUG(VHOST_DATA, "(%d) about to dequeue %u buffers\n",
1196                         dev->vid, count);
1197
1198         /* Retrieve all of the head indexes first to avoid caching issues. */
1199         for (i = 0; i < count; i++) {
1200                 avail_idx = (vq->last_avail_idx + i) & (vq->size - 1);
1201                 used_idx  = (vq->last_used_idx  + i) & (vq->size - 1);
1202                 desc_indexes[i] = vq->avail->ring[avail_idx];
1203
1204                 if (likely(dev->dequeue_zero_copy == 0))
1205                         update_used_ring(dev, vq, used_idx, desc_indexes[i]);
1206         }
1207
1208         /* Prefetch descriptor index. */
1209         rte_prefetch0(&vq->desc[desc_indexes[0]]);
1210         for (i = 0; i < count; i++) {
1211                 struct vring_desc *desc;
1212                 uint16_t sz, idx;
1213                 int err;
1214
1215                 if (likely(i + 1 < count))
1216                         rte_prefetch0(&vq->desc[desc_indexes[i + 1]]);
1217
1218                 if (vq->desc[desc_indexes[i]].flags & VRING_DESC_F_INDIRECT) {
1219                         desc = (struct vring_desc *)(uintptr_t)
1220                                 vhost_iova_to_vva(dev, vq,
1221                                                 vq->desc[desc_indexes[i]].addr,
1222                                                 sizeof(*desc),
1223                                                 VHOST_ACCESS_RO);
1224                         if (unlikely(!desc))
1225                                 break;
1226
1227                         rte_prefetch0(desc);
1228                         sz = vq->desc[desc_indexes[i]].len / sizeof(*desc);
1229                         idx = 0;
1230                 } else {
1231                         desc = vq->desc;
1232                         sz = vq->size;
1233                         idx = desc_indexes[i];
1234                 }
1235
1236                 pkts[i] = rte_pktmbuf_alloc(mbuf_pool);
1237                 if (unlikely(pkts[i] == NULL)) {
1238                         RTE_LOG(ERR, VHOST_DATA,
1239                                 "Failed to allocate memory for mbuf.\n");
1240                         break;
1241                 }
1242
1243                 err = copy_desc_to_mbuf(dev, vq, desc, sz, pkts[i], idx,
1244                                         mbuf_pool);
1245                 if (unlikely(err)) {
1246                         rte_pktmbuf_free(pkts[i]);
1247                         break;
1248                 }
1249
1250                 if (unlikely(dev->dequeue_zero_copy)) {
1251                         struct zcopy_mbuf *zmbuf;
1252
1253                         zmbuf = get_zmbuf(vq);
1254                         if (!zmbuf) {
1255                                 rte_pktmbuf_free(pkts[i]);
1256                                 break;
1257                         }
1258                         zmbuf->mbuf = pkts[i];
1259                         zmbuf->desc_idx = desc_indexes[i];
1260
1261                         /*
1262                          * Pin lock the mbuf; we will check later to see
1263                          * whether the mbuf is freed (when we are the last
1264                          * user) or not. If that's the case, we then could
1265                          * update the used ring safely.
1266                          */
1267                         rte_mbuf_refcnt_update(pkts[i], 1);
1268
1269                         vq->nr_zmbuf += 1;
1270                         TAILQ_INSERT_TAIL(&vq->zmbuf_list, zmbuf, next);
1271                 }
1272         }
1273         vq->last_avail_idx += i;
1274
1275         if (likely(dev->dequeue_zero_copy == 0)) {
1276                 do_data_copy_dequeue(vq);
1277                 vq->last_used_idx += i;
1278                 update_used_idx(dev, vq, i);
1279         }
1280
1281 out:
1282         if (dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))
1283                 vhost_user_iotlb_rd_unlock(vq);
1284
1285         if (unlikely(rarp_mbuf != NULL)) {
1286                 /*
1287                  * Inject it to the head of "pkts" array, so that switch's mac
1288                  * learning table will get updated first.
1289                  */
1290                 memmove(&pkts[1], pkts, i * sizeof(struct rte_mbuf *));
1291                 pkts[0] = rarp_mbuf;
1292                 i += 1;
1293         }
1294
1295         return i;
1296 }