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