X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=lib%2Fvhost%2Fvirtio_net.c;h=5f432b0d7745a0cd01c7baf2049b0cda472b99f2;hb=a2dfcd1ff609f5a4fd3b65774618a35c5c9f73c6;hp=6e5d82c1a8333f08367948d3c1869edbafaf3ff5;hpb=92ed77dce68d45e7a343163cdc41ac9bdd099eec;p=dpdk.git diff --git a/lib/vhost/virtio_net.c b/lib/vhost/virtio_net.c index 6e5d82c1a8..5f432b0d77 100644 --- a/lib/vhost/virtio_net.c +++ b/lib/vhost/virtio_net.c @@ -11,6 +11,7 @@ #include #include #include +#include #include #include #include @@ -25,7 +26,8 @@ #define MAX_BATCH_LEN 256 -#define VHOST_ASYNC_BATCH_THRESHOLD 32 +/* DMA device copy operation tracking array. */ +struct async_dma_info dma_copy_track[RTE_DMADEV_DEFAULT_MAX]; static __rte_always_inline bool rxvq_is_mergeable(struct virtio_net *dev) @@ -45,6 +47,135 @@ is_valid_virt_queue_idx(uint32_t idx, int is_tx, uint32_t nr_vring) return (is_tx ^ (idx & 1)) == 0 && idx < nr_vring; } +static __rte_always_inline int64_t +vhost_async_dma_transfer_one(struct virtio_net *dev, struct vhost_virtqueue *vq, + int16_t dma_id, uint16_t vchan_id, uint16_t flag_idx, + struct vhost_iov_iter *pkt) +{ + struct async_dma_vchan_info *dma_info = &dma_copy_track[dma_id].vchans[vchan_id]; + uint16_t ring_mask = dma_info->ring_mask; + static bool vhost_async_dma_copy_log; + + + struct vhost_iovec *iov = pkt->iov; + int copy_idx = 0; + uint32_t nr_segs = pkt->nr_segs; + uint16_t i; + + if (rte_dma_burst_capacity(dma_id, vchan_id) < nr_segs) + return -1; + + for (i = 0; i < nr_segs; i++) { + copy_idx = rte_dma_copy(dma_id, vchan_id, (rte_iova_t)iov[i].src_addr, + (rte_iova_t)iov[i].dst_addr, iov[i].len, RTE_DMA_OP_FLAG_LLC); + /** + * Since all memory is pinned and DMA vChannel + * ring has enough space, failure should be a + * rare case. If failure happens, it means DMA + * device encounters serious errors; in this + * case, please stop async data-path and check + * what has happened to DMA device. + */ + if (unlikely(copy_idx < 0)) { + if (!vhost_async_dma_copy_log) { + VHOST_LOG_DATA(ERR, "(%s) DMA copy failed for channel %d:%u\n", + dev->ifname, dma_id, vchan_id); + vhost_async_dma_copy_log = true; + } + return -1; + } + } + + /** + * Only store packet completion flag address in the last copy's + * slot, and other slots are set to NULL. + */ + dma_info->pkts_cmpl_flag_addr[copy_idx & ring_mask] = &vq->async->pkts_cmpl_flag[flag_idx]; + + return nr_segs; +} + +static __rte_always_inline uint16_t +vhost_async_dma_transfer(struct virtio_net *dev, struct vhost_virtqueue *vq, + int16_t dma_id, uint16_t vchan_id, uint16_t head_idx, + struct vhost_iov_iter *pkts, uint16_t nr_pkts) +{ + struct async_dma_vchan_info *dma_info = &dma_copy_track[dma_id].vchans[vchan_id]; + int64_t ret, nr_copies = 0; + uint16_t pkt_idx; + + rte_spinlock_lock(&dma_info->dma_lock); + + for (pkt_idx = 0; pkt_idx < nr_pkts; pkt_idx++) { + ret = vhost_async_dma_transfer_one(dev, vq, dma_id, vchan_id, head_idx, + &pkts[pkt_idx]); + if (unlikely(ret < 0)) + break; + + nr_copies += ret; + head_idx++; + if (head_idx >= vq->size) + head_idx -= vq->size; + } + + if (likely(nr_copies > 0)) + rte_dma_submit(dma_id, vchan_id); + + rte_spinlock_unlock(&dma_info->dma_lock); + + return pkt_idx; +} + +static __rte_always_inline uint16_t +vhost_async_dma_check_completed(struct virtio_net *dev, int16_t dma_id, uint16_t vchan_id, + uint16_t max_pkts) +{ + struct async_dma_vchan_info *dma_info = &dma_copy_track[dma_id].vchans[vchan_id]; + uint16_t ring_mask = dma_info->ring_mask; + uint16_t last_idx = 0; + uint16_t nr_copies; + uint16_t copy_idx; + uint16_t i; + bool has_error = false; + static bool vhost_async_dma_complete_log; + + rte_spinlock_lock(&dma_info->dma_lock); + + /** + * Print error log for debugging, if DMA reports error during + * DMA transfer. We do not handle error in vhost level. + */ + nr_copies = rte_dma_completed(dma_id, vchan_id, max_pkts, &last_idx, &has_error); + if (unlikely(!vhost_async_dma_complete_log && has_error)) { + VHOST_LOG_DATA(ERR, "(%s) DMA completion failure on channel %d:%u\n", dev->ifname, + dma_id, vchan_id); + vhost_async_dma_complete_log = true; + } else if (nr_copies == 0) { + goto out; + } + + copy_idx = last_idx - nr_copies + 1; + for (i = 0; i < nr_copies; i++) { + bool *flag; + + flag = dma_info->pkts_cmpl_flag_addr[copy_idx & ring_mask]; + if (flag) { + /** + * Mark the packet flag as received. The flag + * could belong to another virtqueue but write + * is atomic. + */ + *flag = true; + dma_info->pkts_cmpl_flag_addr[copy_idx & ring_mask] = NULL; + } + copy_idx++; + } + +out: + rte_spinlock_unlock(&dma_info->dma_lock); + return nr_copies; +} + static inline void do_data_copy_enqueue(struct virtio_net *dev, struct vhost_virtqueue *vq) { @@ -411,25 +542,25 @@ vhost_shadow_enqueue_single_packed(struct virtio_net *dev, static __rte_always_inline void virtio_enqueue_offload(struct rte_mbuf *m_buf, struct virtio_net_hdr *net_hdr) { - uint64_t csum_l4 = m_buf->ol_flags & PKT_TX_L4_MASK; + uint64_t csum_l4 = m_buf->ol_flags & RTE_MBUF_F_TX_L4_MASK; - if (m_buf->ol_flags & PKT_TX_TCP_SEG) - csum_l4 |= PKT_TX_TCP_CKSUM; + if (m_buf->ol_flags & RTE_MBUF_F_TX_TCP_SEG) + csum_l4 |= RTE_MBUF_F_TX_TCP_CKSUM; if (csum_l4) { net_hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM; net_hdr->csum_start = m_buf->l2_len + m_buf->l3_len; switch (csum_l4) { - case PKT_TX_TCP_CKSUM: + case RTE_MBUF_F_TX_TCP_CKSUM: net_hdr->csum_offset = (offsetof(struct rte_tcp_hdr, cksum)); break; - case PKT_TX_UDP_CKSUM: + case RTE_MBUF_F_TX_UDP_CKSUM: net_hdr->csum_offset = (offsetof(struct rte_udp_hdr, dgram_cksum)); break; - case PKT_TX_SCTP_CKSUM: + case RTE_MBUF_F_TX_SCTP_CKSUM: net_hdr->csum_offset = (offsetof(struct rte_sctp_hdr, cksum)); break; @@ -441,7 +572,7 @@ virtio_enqueue_offload(struct rte_mbuf *m_buf, struct virtio_net_hdr *net_hdr) } /* IP cksum verification cannot be bypassed, then calculate here */ - if (m_buf->ol_flags & PKT_TX_IP_CKSUM) { + if (m_buf->ol_flags & RTE_MBUF_F_TX_IP_CKSUM) { struct rte_ipv4_hdr *ipv4_hdr; ipv4_hdr = rte_pktmbuf_mtod_offset(m_buf, struct rte_ipv4_hdr *, @@ -450,15 +581,15 @@ virtio_enqueue_offload(struct rte_mbuf *m_buf, struct virtio_net_hdr *net_hdr) ipv4_hdr->hdr_checksum = rte_ipv4_cksum(ipv4_hdr); } - if (m_buf->ol_flags & PKT_TX_TCP_SEG) { - if (m_buf->ol_flags & PKT_TX_IPV4) + if (m_buf->ol_flags & RTE_MBUF_F_TX_TCP_SEG) { + if (m_buf->ol_flags & RTE_MBUF_F_TX_IPV4) net_hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4; else net_hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6; net_hdr->gso_size = m_buf->tso_segsz; net_hdr->hdr_len = m_buf->l2_len + m_buf->l3_len + m_buf->l4_len; - } else if (m_buf->ol_flags & PKT_TX_UDP_SEG) { + } else if (m_buf->ol_flags & RTE_MBUF_F_TX_UDP_SEG) { net_hdr->gso_type = VIRTIO_NET_HDR_GSO_UDP; net_hdr->gso_size = m_buf->tso_segsz; net_hdr->hdr_len = m_buf->l2_len + m_buf->l3_len + @@ -794,208 +925,158 @@ copy_vnet_hdr_to_desc(struct virtio_net *dev, struct vhost_virtqueue *vq, } static __rte_always_inline int -copy_mbuf_to_desc(struct virtio_net *dev, struct vhost_virtqueue *vq, - struct rte_mbuf *m, struct buf_vector *buf_vec, - uint16_t nr_vec, uint16_t num_buffers) +async_iter_initialize(struct virtio_net *dev, struct vhost_async *async) { - uint32_t vec_idx = 0; - uint32_t mbuf_offset, mbuf_avail; - uint32_t buf_offset, buf_avail; - uint64_t buf_addr, buf_iova, buf_len; - uint32_t cpy_len; - uint64_t hdr_addr; - struct rte_mbuf *hdr_mbuf; - struct batch_copy_elem *batch_copy = vq->batch_copy_elems; - struct virtio_net_hdr_mrg_rxbuf tmp_hdr, *hdr = NULL; - int error = 0; + struct vhost_iov_iter *iter; - if (unlikely(m == NULL)) { - error = -1; - goto out; - } - - buf_addr = buf_vec[vec_idx].buf_addr; - buf_iova = buf_vec[vec_idx].buf_iova; - buf_len = buf_vec[vec_idx].buf_len; - - if (unlikely(buf_len < dev->vhost_hlen && nr_vec <= 1)) { - error = -1; - goto out; - } - - hdr_mbuf = m; - hdr_addr = buf_addr; - if (unlikely(buf_len < dev->vhost_hlen)) { - memset(&tmp_hdr, 0, sizeof(struct virtio_net_hdr_mrg_rxbuf)); - hdr = &tmp_hdr; - } else - hdr = (struct virtio_net_hdr_mrg_rxbuf *)(uintptr_t)hdr_addr; - - VHOST_LOG_DATA(DEBUG, "(%d) RX: num merge buffers %d\n", - dev->vid, num_buffers); - - if (unlikely(buf_len < dev->vhost_hlen)) { - buf_offset = dev->vhost_hlen - buf_len; - vec_idx++; - buf_addr = buf_vec[vec_idx].buf_addr; - buf_iova = buf_vec[vec_idx].buf_iova; - buf_len = buf_vec[vec_idx].buf_len; - buf_avail = buf_len - buf_offset; - } else { - buf_offset = dev->vhost_hlen; - buf_avail = buf_len - dev->vhost_hlen; + if (unlikely(async->iovec_idx >= VHOST_MAX_ASYNC_VEC)) { + VHOST_LOG_DATA(ERR, "(%s) no more async iovec available\n", dev->ifname); + return -1; } - mbuf_avail = rte_pktmbuf_data_len(m); - mbuf_offset = 0; - while (mbuf_avail != 0 || m->next != NULL) { - /* done with current buf, get the next one */ - if (buf_avail == 0) { - vec_idx++; - if (unlikely(vec_idx >= nr_vec)) { - error = -1; - goto out; - } + iter = async->iov_iter + async->iter_idx; + iter->iov = async->iovec + async->iovec_idx; + iter->nr_segs = 0; - buf_addr = buf_vec[vec_idx].buf_addr; - buf_iova = buf_vec[vec_idx].buf_iova; - buf_len = buf_vec[vec_idx].buf_len; + return 0; +} - buf_offset = 0; - buf_avail = buf_len; - } +static __rte_always_inline int +async_iter_add_iovec(struct virtio_net *dev, struct vhost_async *async, + void *src, void *dst, size_t len) +{ + struct vhost_iov_iter *iter; + struct vhost_iovec *iovec; - /* done with current mbuf, get the next one */ - if (mbuf_avail == 0) { - m = m->next; + if (unlikely(async->iovec_idx >= VHOST_MAX_ASYNC_VEC)) { + static bool vhost_max_async_vec_log; - mbuf_offset = 0; - mbuf_avail = rte_pktmbuf_data_len(m); + if (!vhost_max_async_vec_log) { + VHOST_LOG_DATA(ERR, "(%s) no more async iovec available\n", dev->ifname); + vhost_max_async_vec_log = true; } - if (hdr_addr) { - virtio_enqueue_offload(hdr_mbuf, &hdr->hdr); - if (rxvq_is_mergeable(dev)) - ASSIGN_UNLESS_EQUAL(hdr->num_buffers, - num_buffers); + return -1; + } - if (unlikely(hdr == &tmp_hdr)) { - copy_vnet_hdr_to_desc(dev, vq, buf_vec, hdr); - } else { - PRINT_PACKET(dev, (uintptr_t)hdr_addr, - dev->vhost_hlen, 0); - vhost_log_cache_write_iova(dev, vq, - buf_vec[0].buf_iova, - dev->vhost_hlen); - } + iter = async->iov_iter + async->iter_idx; + iovec = async->iovec + async->iovec_idx; - hdr_addr = 0; - } + iovec->src_addr = src; + iovec->dst_addr = dst; + iovec->len = len; - cpy_len = RTE_MIN(buf_avail, mbuf_avail); + iter->nr_segs++; + async->iovec_idx++; - if (likely(cpy_len > MAX_BATCH_LEN || - vq->batch_copy_nb_elems >= vq->size)) { - rte_memcpy((void *)((uintptr_t)(buf_addr + buf_offset)), - rte_pktmbuf_mtod_offset(m, void *, mbuf_offset), - cpy_len); - vhost_log_cache_write_iova(dev, vq, - buf_iova + buf_offset, - cpy_len); - PRINT_PACKET(dev, (uintptr_t)(buf_addr + buf_offset), - cpy_len, 0); - } else { - batch_copy[vq->batch_copy_nb_elems].dst = - (void *)((uintptr_t)(buf_addr + buf_offset)); - batch_copy[vq->batch_copy_nb_elems].src = - rte_pktmbuf_mtod_offset(m, void *, mbuf_offset); - batch_copy[vq->batch_copy_nb_elems].log_addr = - buf_iova + buf_offset; - batch_copy[vq->batch_copy_nb_elems].len = cpy_len; - vq->batch_copy_nb_elems++; - } + return 0; +} - mbuf_avail -= cpy_len; - mbuf_offset += cpy_len; - buf_avail -= cpy_len; - buf_offset += cpy_len; - } +static __rte_always_inline void +async_iter_finalize(struct vhost_async *async) +{ + async->iter_idx++; +} -out: +static __rte_always_inline void +async_iter_cancel(struct vhost_async *async) +{ + struct vhost_iov_iter *iter; - return error; + iter = async->iov_iter + async->iter_idx; + async->iovec_idx -= iter->nr_segs; + iter->nr_segs = 0; + iter->iov = NULL; } static __rte_always_inline void -async_fill_vec(struct iovec *v, void *base, size_t len) +async_iter_reset(struct vhost_async *async) { - v->iov_base = base; - v->iov_len = len; + async->iter_idx = 0; + async->iovec_idx = 0; } -static __rte_always_inline void -async_fill_iter(struct rte_vhost_iov_iter *it, size_t count, - struct iovec *vec, unsigned long nr_seg) +static __rte_always_inline int +async_mbuf_to_desc_seg(struct virtio_net *dev, struct vhost_virtqueue *vq, + struct rte_mbuf *m, uint32_t mbuf_offset, + uint64_t buf_iova, uint32_t cpy_len) { - it->offset = 0; - it->count = count; + struct vhost_async *async = vq->async; + uint64_t mapped_len; + uint32_t buf_offset = 0; + void *host_iova; + + while (cpy_len) { + host_iova = (void *)(uintptr_t)gpa_to_first_hpa(dev, + buf_iova + buf_offset, cpy_len, &mapped_len); + if (unlikely(!host_iova)) { + VHOST_LOG_DATA(ERR, "(%s) %s: failed to get host iova.\n", + dev->ifname, __func__); + return -1; + } - if (count) { - it->iov = vec; - it->nr_segs = nr_seg; - } else { - it->iov = 0; - it->nr_segs = 0; + if (unlikely(async_iter_add_iovec(dev, async, + (void *)(uintptr_t)rte_pktmbuf_iova_offset(m, + mbuf_offset), + host_iova, (size_t)mapped_len))) + return -1; + + cpy_len -= (uint32_t)mapped_len; + mbuf_offset += (uint32_t)mapped_len; + buf_offset += (uint32_t)mapped_len; } + + return 0; } static __rte_always_inline void -async_fill_desc(struct rte_vhost_async_desc *desc, - struct rte_vhost_iov_iter *src, struct rte_vhost_iov_iter *dst) +sync_mbuf_to_desc_seg(struct virtio_net *dev, struct vhost_virtqueue *vq, + struct rte_mbuf *m, uint32_t mbuf_offset, + uint64_t buf_addr, uint64_t buf_iova, uint32_t cpy_len) { - desc->src = src; - desc->dst = dst; + struct batch_copy_elem *batch_copy = vq->batch_copy_elems; + + if (likely(cpy_len > MAX_BATCH_LEN || vq->batch_copy_nb_elems >= vq->size)) { + rte_memcpy((void *)((uintptr_t)(buf_addr)), + rte_pktmbuf_mtod_offset(m, void *, mbuf_offset), + cpy_len); + vhost_log_cache_write_iova(dev, vq, buf_iova, cpy_len); + PRINT_PACKET(dev, (uintptr_t)(buf_addr), cpy_len, 0); + } else { + batch_copy[vq->batch_copy_nb_elems].dst = + (void *)((uintptr_t)(buf_addr)); + batch_copy[vq->batch_copy_nb_elems].src = + rte_pktmbuf_mtod_offset(m, void *, mbuf_offset); + batch_copy[vq->batch_copy_nb_elems].log_addr = buf_iova; + batch_copy[vq->batch_copy_nb_elems].len = cpy_len; + vq->batch_copy_nb_elems++; + } } static __rte_always_inline int -async_mbuf_to_desc(struct virtio_net *dev, struct vhost_virtqueue *vq, - struct rte_mbuf *m, struct buf_vector *buf_vec, - uint16_t nr_vec, uint16_t num_buffers, - struct iovec *src_iovec, struct iovec *dst_iovec, - struct rte_vhost_iov_iter *src_it, - struct rte_vhost_iov_iter *dst_it) +mbuf_to_desc(struct virtio_net *dev, struct vhost_virtqueue *vq, + struct rte_mbuf *m, struct buf_vector *buf_vec, + uint16_t nr_vec, uint16_t num_buffers, bool is_async) { uint32_t vec_idx = 0; uint32_t mbuf_offset, mbuf_avail; uint32_t buf_offset, buf_avail; uint64_t buf_addr, buf_iova, buf_len; - uint32_t cpy_len, cpy_threshold; + uint32_t cpy_len; uint64_t hdr_addr; struct rte_mbuf *hdr_mbuf; - struct batch_copy_elem *batch_copy = vq->batch_copy_elems; struct virtio_net_hdr_mrg_rxbuf tmp_hdr, *hdr = NULL; - int error = 0; - uint64_t mapped_len; - - uint32_t tlen = 0; - int tvec_idx = 0; - void *hpa; + struct vhost_async *async = vq->async; - if (unlikely(m == NULL)) { - error = -1; - goto out; - } - - cpy_threshold = vq->async_threshold; + if (unlikely(m == NULL)) + return -1; buf_addr = buf_vec[vec_idx].buf_addr; buf_iova = buf_vec[vec_idx].buf_iova; buf_len = buf_vec[vec_idx].buf_len; - if (unlikely(buf_len < dev->vhost_hlen && nr_vec <= 1)) { - error = -1; - goto out; - } + if (unlikely(buf_len < dev->vhost_hlen && nr_vec <= 1)) + return -1; hdr_mbuf = m; hdr_addr = buf_addr; @@ -1005,8 +1086,8 @@ async_mbuf_to_desc(struct virtio_net *dev, struct vhost_virtqueue *vq, } else hdr = (struct virtio_net_hdr_mrg_rxbuf *)(uintptr_t)hdr_addr; - VHOST_LOG_DATA(DEBUG, "(%d) RX: num merge buffers %d\n", - dev->vid, num_buffers); + VHOST_LOG_DATA(DEBUG, "(%s) RX: num merge buffers %d\n", + dev->ifname, num_buffers); if (unlikely(buf_len < dev->vhost_hlen)) { buf_offset = dev->vhost_hlen - buf_len; @@ -1023,14 +1104,17 @@ async_mbuf_to_desc(struct virtio_net *dev, struct vhost_virtqueue *vq, mbuf_avail = rte_pktmbuf_data_len(m); mbuf_offset = 0; + if (is_async) { + if (async_iter_initialize(dev, async)) + return -1; + } + while (mbuf_avail != 0 || m->next != NULL) { /* done with current buf, get the next one */ if (buf_avail == 0) { vec_idx++; - if (unlikely(vec_idx >= nr_vec)) { - error = -1; - goto out; - } + if (unlikely(vec_idx >= nr_vec)) + goto error; buf_addr = buf_vec[vec_idx].buf_addr; buf_iova = buf_vec[vec_idx].buf_iova; @@ -1069,69 +1153,31 @@ async_mbuf_to_desc(struct virtio_net *dev, struct vhost_virtqueue *vq, cpy_len = RTE_MIN(buf_avail, mbuf_avail); - while (unlikely(cpy_len && cpy_len >= cpy_threshold)) { - hpa = (void *)(uintptr_t)gpa_to_first_hpa(dev, - buf_iova + buf_offset, - cpy_len, &mapped_len); - - if (unlikely(!hpa || mapped_len < cpy_threshold)) - break; - - async_fill_vec(src_iovec + tvec_idx, - (void *)(uintptr_t)rte_pktmbuf_iova_offset(m, - mbuf_offset), (size_t)mapped_len); - - async_fill_vec(dst_iovec + tvec_idx, - hpa, (size_t)mapped_len); - - tlen += (uint32_t)mapped_len; - cpy_len -= (uint32_t)mapped_len; - mbuf_avail -= (uint32_t)mapped_len; - mbuf_offset += (uint32_t)mapped_len; - buf_avail -= (uint32_t)mapped_len; - buf_offset += (uint32_t)mapped_len; - tvec_idx++; - } - - if (likely(cpy_len)) { - if (unlikely(vq->batch_copy_nb_elems >= vq->size)) { - rte_memcpy( - (void *)((uintptr_t)(buf_addr + buf_offset)), - rte_pktmbuf_mtod_offset(m, void *, mbuf_offset), - cpy_len); - - PRINT_PACKET(dev, - (uintptr_t)(buf_addr + buf_offset), - cpy_len, 0); - } else { - batch_copy[vq->batch_copy_nb_elems].dst = - (void *)((uintptr_t)(buf_addr + buf_offset)); - batch_copy[vq->batch_copy_nb_elems].src = - rte_pktmbuf_mtod_offset(m, void *, mbuf_offset); - batch_copy[vq->batch_copy_nb_elems].log_addr = - buf_iova + buf_offset; - batch_copy[vq->batch_copy_nb_elems].len = - cpy_len; - vq->batch_copy_nb_elems++; - } - - mbuf_avail -= cpy_len; - mbuf_offset += cpy_len; - buf_avail -= cpy_len; - buf_offset += cpy_len; + if (is_async) { + if (async_mbuf_to_desc_seg(dev, vq, m, mbuf_offset, + buf_iova + buf_offset, cpy_len) < 0) + goto error; + } else { + sync_mbuf_to_desc_seg(dev, vq, m, mbuf_offset, + buf_addr + buf_offset, + buf_iova + buf_offset, cpy_len); } + mbuf_avail -= cpy_len; + mbuf_offset += cpy_len; + buf_avail -= cpy_len; + buf_offset += cpy_len; } -out: - if (tlen) { - async_fill_iter(src_it, tlen, src_iovec, tvec_idx); - async_fill_iter(dst_it, tlen, dst_iovec, tvec_idx); - } else { - src_it->count = 0; - } + if (is_async) + async_iter_finalize(async); - return error; + return 0; +error: + if (is_async) + async_iter_cancel(async); + + return -1; } static __rte_always_inline int @@ -1188,7 +1234,7 @@ vhost_enqueue_single_packed(struct virtio_net *dev, avail_idx -= vq->size; } - if (copy_mbuf_to_desc(dev, vq, pkt, buf_vec, nr_vec, num_buffers) < 0) + if (mbuf_to_desc(dev, vq, pkt, buf_vec, nr_vec, num_buffers, false) < 0) return -1; vhost_shadow_enqueue_single_packed(dev, vq, buffer_len, buffer_buf_id, @@ -1222,19 +1268,18 @@ virtio_dev_rx_split(struct virtio_net *dev, struct vhost_virtqueue *vq, pkt_len, buf_vec, &num_buffers, avail_head, &nr_vec) < 0)) { VHOST_LOG_DATA(DEBUG, - "(%d) failed to get enough desc from vring\n", - dev->vid); + "(%s) failed to get enough desc from vring\n", + dev->ifname); vq->shadow_used_idx -= num_buffers; break; } - VHOST_LOG_DATA(DEBUG, "(%d) current index %d | end index %d\n", - dev->vid, vq->last_avail_idx, + VHOST_LOG_DATA(DEBUG, "(%s) current index %d | end index %d\n", + dev->ifname, vq->last_avail_idx, vq->last_avail_idx + num_buffers); - if (copy_mbuf_to_desc(dev, vq, pkts[pkt_idx], - buf_vec, nr_vec, - num_buffers) < 0) { + if (mbuf_to_desc(dev, vq, pkts[pkt_idx], buf_vec, nr_vec, + num_buffers, false) < 0) { vq->shadow_used_idx -= num_buffers; break; } @@ -1303,67 +1348,6 @@ virtio_dev_rx_sync_batch_check(struct virtio_net *dev, return 0; } -static __rte_always_inline int -virtio_dev_rx_async_batch_check(struct virtio_net *dev, - struct vhost_virtqueue *vq, - struct rte_mbuf **pkts, - uint64_t *desc_addrs, - uint64_t *lens) -{ - bool wrap_counter = vq->avail_wrap_counter; - struct vring_packed_desc *descs = vq->desc_packed; - uint16_t avail_idx = vq->last_avail_idx; - uint16_t used_idx = vq->last_used_idx; - uint32_t buf_offset = sizeof(struct virtio_net_hdr_mrg_rxbuf); - uint32_t cpy_threshold = vq->async_threshold; - uint16_t i; - - vhost_for_each_try_unroll(i, 0, PACKED_BATCH_SIZE) { - if (unlikely(pkts[i]->data_len >= cpy_threshold)) - return -1; - } - - if (unlikely(avail_idx & PACKED_BATCH_MASK)) - return -1; - - if (unlikely((avail_idx + PACKED_BATCH_SIZE) > vq->size)) - return -1; - - if (unlikely((used_idx + PACKED_BATCH_SIZE) > vq->size)) - return -1; - - vhost_for_each_try_unroll(i, 0, PACKED_BATCH_SIZE) { - if (unlikely(pkts[i]->next != NULL)) - return -1; - if (unlikely(!desc_is_avail(&descs[avail_idx + i], - wrap_counter))) - return -1; - } - - vhost_for_each_try_unroll(i, 0, PACKED_BATCH_SIZE) - lens[i] = descs[avail_idx + i].len; - - vhost_for_each_try_unroll(i, 0, PACKED_BATCH_SIZE) { - if (unlikely(pkts[i]->pkt_len > (lens[i] - buf_offset))) - return -1; - } - - vhost_for_each_try_unroll(i, 0, PACKED_BATCH_SIZE) - desc_addrs[i] = vhost_iova_to_vva(dev, vq, - descs[avail_idx + i].addr, - &lens[i], - VHOST_ACCESS_RW); - - vhost_for_each_try_unroll(i, 0, PACKED_BATCH_SIZE) { - if (unlikely(!desc_addrs[i])) - return -1; - if (unlikely(lens[i] != descs[avail_idx + i].len)) - return -1; - } - - return 0; -} - static __rte_always_inline void virtio_dev_rx_batch_packed_copy(struct virtio_net *dev, struct vhost_virtqueue *vq, @@ -1415,41 +1399,15 @@ virtio_dev_rx_sync_batch_packed(struct virtio_net *dev, uint64_t desc_addrs[PACKED_BATCH_SIZE]; uint64_t lens[PACKED_BATCH_SIZE]; - if (virtio_dev_rx_sync_batch_check(dev, vq, pkts, desc_addrs, lens) == -1) - return -1; - - if (vq->shadow_used_idx) { - do_data_copy_enqueue(dev, vq); - vhost_flush_enqueue_shadow_packed(dev, vq); - } - - virtio_dev_rx_batch_packed_copy(dev, vq, pkts, desc_addrs, lens); - - return 0; -} - -static __rte_always_inline int -virtio_dev_rx_async_batch_packed(struct virtio_net *dev, - struct vhost_virtqueue *vq, - struct rte_mbuf **pkts, - struct rte_mbuf **comp_pkts, uint32_t *pkt_done) -{ - uint16_t i; - uint64_t desc_addrs[PACKED_BATCH_SIZE]; - uint64_t lens[PACKED_BATCH_SIZE]; - - if (virtio_dev_rx_async_batch_check(dev, vq, pkts, desc_addrs, lens) == -1) + if (virtio_dev_rx_sync_batch_check(dev, vq, pkts, desc_addrs, lens) == -1) return -1; - virtio_dev_rx_batch_packed_copy(dev, vq, pkts, desc_addrs, lens); - if (vq->shadow_used_idx) { do_data_copy_enqueue(dev, vq); vhost_flush_enqueue_shadow_packed(dev, vq); } - vhost_for_each_try_unroll(i, 0, PACKED_BATCH_SIZE) - comp_pkts[(*pkt_done)++] = pkts[i]; + virtio_dev_rx_batch_packed_copy(dev, vq, pkts, desc_addrs, lens); return 0; } @@ -1464,14 +1422,13 @@ virtio_dev_rx_single_packed(struct virtio_net *dev, if (unlikely(vhost_enqueue_single_packed(dev, vq, pkt, buf_vec, &nr_descs) < 0)) { - VHOST_LOG_DATA(DEBUG, - "(%d) failed to get enough desc from vring\n", - dev->vid); + VHOST_LOG_DATA(DEBUG, "(%s) failed to get enough desc from vring\n", + dev->ifname); return -1; } - VHOST_LOG_DATA(DEBUG, "(%d) current index %d | end index %d\n", - dev->vid, vq->last_avail_idx, + VHOST_LOG_DATA(DEBUG, "(%s) current index %d | end index %d\n", + dev->ifname, vq->last_avail_idx, vq->last_avail_idx + nr_descs); vq_inc_last_avail_packed(vq, nr_descs); @@ -1522,10 +1479,10 @@ virtio_dev_rx(struct virtio_net *dev, uint16_t queue_id, struct vhost_virtqueue *vq; uint32_t nb_tx = 0; - VHOST_LOG_DATA(DEBUG, "(%d) %s\n", dev->vid, __func__); + VHOST_LOG_DATA(DEBUG, "(%s) %s\n", dev->ifname, __func__); if (unlikely(!is_valid_virt_queue_idx(queue_id, 0, dev->nr_vring))) { - VHOST_LOG_DATA(ERR, "(%d) %s: invalid virtqueue idx %d.\n", - dev->vid, __func__, queue_id); + VHOST_LOG_DATA(ERR, "(%s) %s: invalid virtqueue idx %d.\n", + dev->ifname, __func__, queue_id); return 0; } @@ -1572,9 +1529,8 @@ rte_vhost_enqueue_burst(int vid, uint16_t queue_id, return 0; if (unlikely(!(dev->flags & VIRTIO_DEV_BUILTIN_VIRTIO_NET))) { - VHOST_LOG_DATA(ERR, - "(%d) %s: built-in vhost net backend is disabled.\n", - dev->vid, __func__); + VHOST_LOG_DATA(ERR, "(%s) %s: built-in vhost net backend is disabled.\n", + dev->ifname, __func__); return 0; } @@ -1582,11 +1538,14 @@ rte_vhost_enqueue_burst(int vid, uint16_t queue_id, } static __rte_always_inline uint16_t -virtio_dev_rx_async_get_info_idx(uint16_t pkts_idx, - uint16_t vq_size, uint16_t n_inflight) +async_get_first_inflight_pkt_idx(struct vhost_virtqueue *vq) { - return pkts_idx > n_inflight ? (pkts_idx - n_inflight) : - (vq_size - n_inflight + pkts_idx) % vq_size; + struct vhost_async *async = vq->async; + + if (async->pkts_idx >= async->pkts_inflight_n) + return async->pkts_idx - async->pkts_inflight_n; + else + return vq->size - async->pkts_inflight_n + async->pkts_idx; } static __rte_always_inline void @@ -1623,31 +1582,20 @@ store_dma_desc_info_packed(struct vring_used_elem_packed *s_ring, } static __rte_noinline uint32_t -virtio_dev_rx_async_submit_split(struct virtio_net *dev, - struct vhost_virtqueue *vq, uint16_t queue_id, - struct rte_mbuf **pkts, uint32_t count, - struct rte_mbuf **comp_pkts, uint32_t *comp_count) +virtio_dev_rx_async_submit_split(struct virtio_net *dev, struct vhost_virtqueue *vq, + uint16_t queue_id, struct rte_mbuf **pkts, uint32_t count, + int16_t dma_id, uint16_t vchan_id) { - uint32_t pkt_idx = 0, pkt_burst_idx = 0; - uint16_t num_buffers; struct buf_vector buf_vec[BUF_VECTOR_MAX]; + uint32_t pkt_idx = 0; + uint16_t num_buffers; uint16_t avail_head; - struct rte_vhost_iov_iter *it_pool = vq->it_pool; - struct iovec *vec_pool = vq->vec_pool; - struct rte_vhost_async_desc tdes[MAX_PKT_BURST]; - struct iovec *src_iovec = vec_pool; - struct iovec *dst_iovec = vec_pool + (VHOST_MAX_ASYNC_VEC >> 1); + struct vhost_async *async = vq->async; + struct async_inflight_info *pkts_info = async->pkts_info; + uint32_t pkt_err = 0; + uint16_t n_xfer; uint16_t slot_idx = 0; - uint16_t segs_await = 0; - uint16_t iovec_idx = 0, it_idx = 0; - struct async_inflight_info *pkts_info = vq->async_pkts_info; - uint32_t n_pkts = 0, pkt_err = 0; - uint32_t num_async_pkts = 0, num_done_pkts = 0; - struct { - uint16_t pkt_idx; - uint16_t last_avail_idx; - } async_pkts_log[MAX_PKT_BURST]; /* * The ordering between avail index and desc reads need to be enforced. @@ -1656,205 +1604,91 @@ virtio_dev_rx_async_submit_split(struct virtio_net *dev, rte_prefetch0(&vq->avail->ring[vq->last_avail_idx & (vq->size - 1)]); + async_iter_reset(async); + for (pkt_idx = 0; pkt_idx < count; pkt_idx++) { uint32_t pkt_len = pkts[pkt_idx]->pkt_len + dev->vhost_hlen; uint16_t nr_vec = 0; - if (unlikely(reserve_avail_buf_split(dev, vq, - pkt_len, buf_vec, &num_buffers, - avail_head, &nr_vec) < 0)) { - VHOST_LOG_DATA(DEBUG, - "(%d) failed to get enough desc from vring\n", - dev->vid); + if (unlikely(reserve_avail_buf_split(dev, vq, pkt_len, buf_vec, + &num_buffers, avail_head, &nr_vec) < 0)) { + VHOST_LOG_DATA(DEBUG, "(%s) failed to get enough desc from vring\n", + dev->ifname); vq->shadow_used_idx -= num_buffers; break; } - VHOST_LOG_DATA(DEBUG, "(%d) current index %d | end index %d\n", - dev->vid, vq->last_avail_idx, - vq->last_avail_idx + num_buffers); + VHOST_LOG_DATA(DEBUG, "(%s) current index %d | end index %d\n", + dev->ifname, vq->last_avail_idx, vq->last_avail_idx + num_buffers); - if (async_mbuf_to_desc(dev, vq, pkts[pkt_idx], buf_vec, nr_vec, num_buffers, - &src_iovec[iovec_idx], &dst_iovec[iovec_idx], - &it_pool[it_idx], &it_pool[it_idx + 1]) < 0) { + if (mbuf_to_desc(dev, vq, pkts[pkt_idx], buf_vec, nr_vec, num_buffers, true) < 0) { vq->shadow_used_idx -= num_buffers; break; } - slot_idx = (vq->async_pkts_idx + num_async_pkts) & - (vq->size - 1); - if (it_pool[it_idx].count) { - uint16_t from, to; - - async_fill_desc(&tdes[pkt_burst_idx++], - &it_pool[it_idx], &it_pool[it_idx + 1]); - pkts_info[slot_idx].descs = num_buffers; - pkts_info[slot_idx].mbuf = pkts[pkt_idx]; - async_pkts_log[num_async_pkts].pkt_idx = pkt_idx; - async_pkts_log[num_async_pkts++].last_avail_idx = - vq->last_avail_idx; - - iovec_idx += it_pool[it_idx].nr_segs; - it_idx += 2; - - segs_await += it_pool[it_idx].nr_segs; - - /** - * recover shadow used ring and keep DMA-occupied - * descriptors. - */ - from = vq->shadow_used_idx - num_buffers; - to = vq->async_desc_idx_split & (vq->size - 1); - - store_dma_desc_info_split(vq->shadow_used_split, - vq->async_descs_split, vq->size, from, to, num_buffers); - - vq->async_desc_idx_split += num_buffers; - vq->shadow_used_idx -= num_buffers; - } else - comp_pkts[num_done_pkts++] = pkts[pkt_idx]; + slot_idx = (async->pkts_idx + pkt_idx) & (vq->size - 1); + pkts_info[slot_idx].descs = num_buffers; + pkts_info[slot_idx].mbuf = pkts[pkt_idx]; vq->last_avail_idx += num_buffers; - - /* - * conditions to trigger async device transfer: - * - buffered packet number reaches transfer threshold - * - unused async iov number is less than max vhost vector - */ - if (unlikely(pkt_burst_idx >= VHOST_ASYNC_BATCH_THRESHOLD || - ((VHOST_MAX_ASYNC_VEC >> 1) - segs_await < - BUF_VECTOR_MAX))) { - n_pkts = vq->async_ops.transfer_data(dev->vid, - queue_id, tdes, 0, pkt_burst_idx); - iovec_idx = 0; - it_idx = 0; - - segs_await = 0; - vq->async_pkts_inflight_n += n_pkts; - - if (unlikely(n_pkts < pkt_burst_idx)) { - /* - * log error packets number here and do actual - * error processing when applications poll - * completion - */ - pkt_err = pkt_burst_idx - n_pkts; - pkt_burst_idx = 0; - break; - } - - pkt_burst_idx = 0; - } } - if (pkt_burst_idx) { - n_pkts = vq->async_ops.transfer_data(dev->vid, - queue_id, tdes, 0, pkt_burst_idx); - vq->async_pkts_inflight_n += n_pkts; - - if (unlikely(n_pkts < pkt_burst_idx)) - pkt_err = pkt_burst_idx - n_pkts; - } + if (unlikely(pkt_idx == 0)) + return 0; - do_data_copy_enqueue(dev, vq); + n_xfer = vhost_async_dma_transfer(dev, vq, dma_id, vchan_id, async->pkts_idx, + async->iov_iter, pkt_idx); + pkt_err = pkt_idx - n_xfer; if (unlikely(pkt_err)) { uint16_t num_descs = 0; - num_async_pkts -= pkt_err; - /* calculate the sum of descriptors of DMA-error packets. */ + VHOST_LOG_DATA(DEBUG, "(%s) %s: failed to transfer %u packets for queue %u.\n", + dev->ifname, __func__, pkt_err, queue_id); + + /* update number of completed packets */ + pkt_idx = n_xfer; + + /* calculate the sum of descriptors to revert */ while (pkt_err-- > 0) { num_descs += pkts_info[slot_idx & (vq->size - 1)].descs; slot_idx--; } - vq->async_desc_idx_split -= num_descs; + /* recover shadow used ring and available ring */ - vq->shadow_used_idx -= (vq->last_avail_idx - - async_pkts_log[num_async_pkts].last_avail_idx - - num_descs); - vq->last_avail_idx = - async_pkts_log[num_async_pkts].last_avail_idx; - pkt_idx = async_pkts_log[num_async_pkts].pkt_idx; - num_done_pkts = pkt_idx - num_async_pkts; + vq->shadow_used_idx -= num_descs; + vq->last_avail_idx -= num_descs; } - vq->async_pkts_idx += num_async_pkts; - *comp_count = num_done_pkts; - + /* keep used descriptors */ if (likely(vq->shadow_used_idx)) { - flush_shadow_used_ring_split(dev, vq); - vhost_vring_call_split(dev, vq); - } - - return pkt_idx; -} - -static __rte_always_inline void -vhost_update_used_packed(struct vhost_virtqueue *vq, - struct vring_used_elem_packed *shadow_ring, - uint16_t count) -{ - int i; - uint16_t used_idx = vq->last_used_idx; - uint16_t head_idx = vq->last_used_idx; - uint16_t head_flags = 0; - - if (count == 0) - return; - - /* Split loop in two to save memory barriers */ - for (i = 0; i < count; i++) { - vq->desc_packed[used_idx].id = shadow_ring[i].id; - vq->desc_packed[used_idx].len = shadow_ring[i].len; - - used_idx += shadow_ring[i].count; - if (used_idx >= vq->size) - used_idx -= vq->size; - } - - /* The ordering for storing desc flags needs to be enforced. */ - rte_atomic_thread_fence(__ATOMIC_RELEASE); - - for (i = 0; i < count; i++) { - uint16_t flags; + uint16_t to = async->desc_idx_split & (vq->size - 1); - if (vq->shadow_used_packed[i].len) - flags = VRING_DESC_F_WRITE; - else - flags = 0; + store_dma_desc_info_split(vq->shadow_used_split, + async->descs_split, vq->size, 0, to, + vq->shadow_used_idx); - if (vq->used_wrap_counter) { - flags |= VRING_DESC_F_USED; - flags |= VRING_DESC_F_AVAIL; - } else { - flags &= ~VRING_DESC_F_USED; - flags &= ~VRING_DESC_F_AVAIL; - } + async->desc_idx_split += vq->shadow_used_idx; - if (i > 0) { - vq->desc_packed[vq->last_used_idx].flags = flags; - } else { - head_idx = vq->last_used_idx; - head_flags = flags; - } + async->pkts_idx += pkt_idx; + if (async->pkts_idx >= vq->size) + async->pkts_idx -= vq->size; - vq_inc_last_used_packed(vq, shadow_ring[i].count); + async->pkts_inflight_n += pkt_idx; + vq->shadow_used_idx = 0; } - vq->desc_packed[head_idx].flags = head_flags; + return pkt_idx; } + static __rte_always_inline int -vhost_enqueue_async_single_packed(struct virtio_net *dev, +vhost_enqueue_async_packed(struct virtio_net *dev, struct vhost_virtqueue *vq, struct rte_mbuf *pkt, struct buf_vector *buf_vec, uint16_t *nr_descs, - uint16_t *nr_buffers, - struct vring_packed_desc *async_descs, - struct iovec *src_iovec, struct iovec *dst_iovec, - struct rte_vhost_iov_iter *src_it, - struct rte_vhost_iov_iter *dst_it) + uint16_t *nr_buffers) { uint16_t nr_vec = 0; uint16_t avail_idx = vq->last_avail_idx; @@ -1881,8 +1715,11 @@ vhost_enqueue_async_single_packed(struct virtio_net *dev, if (unlikely(++tries > max_tries)) return -1; - if (unlikely(fill_vec_buf_packed(dev, vq, avail_idx, &desc_count, buf_vec, &nr_vec, - &buf_id, &len, VHOST_ACCESS_RW) < 0)) + if (unlikely(fill_vec_buf_packed(dev, vq, + avail_idx, &desc_count, + buf_vec, &nr_vec, + &buf_id, &len, + VHOST_ACCESS_RW) < 0)) return -1; len = RTE_MIN(len, size); @@ -1892,28 +1729,14 @@ vhost_enqueue_async_single_packed(struct virtio_net *dev, buffer_buf_id[*nr_buffers] = buf_id; buffer_desc_count[*nr_buffers] = desc_count; *nr_buffers += 1; - *nr_descs += desc_count; avail_idx += desc_count; if (avail_idx >= vq->size) avail_idx -= vq->size; } - if (async_mbuf_to_desc(dev, vq, pkt, buf_vec, nr_vec, *nr_buffers, src_iovec, dst_iovec, - src_it, dst_it) < 0) + if (unlikely(mbuf_to_desc(dev, vq, pkt, buf_vec, nr_vec, *nr_buffers, true) < 0)) return -1; - /* store descriptors for DMA */ - if (avail_idx >= *nr_descs) { - rte_memcpy(async_descs, &vq->desc_packed[vq->last_avail_idx], - *nr_descs * sizeof(struct vring_packed_desc)); - } else { - uint16_t nr_copy = vq->size - vq->last_avail_idx; - - rte_memcpy(async_descs, &vq->desc_packed[vq->last_avail_idx], - nr_copy * sizeof(struct vring_packed_desc)); - rte_memcpy(async_descs + nr_copy, vq->desc_packed, - (*nr_descs - nr_copy) * sizeof(struct vring_packed_desc)); - } vhost_shadow_enqueue_packed(vq, buffer_len, buffer_buf_id, buffer_desc_count, *nr_buffers); @@ -1921,37 +1744,31 @@ vhost_enqueue_async_single_packed(struct virtio_net *dev, } static __rte_always_inline int16_t -virtio_dev_rx_async_single_packed(struct virtio_net *dev, struct vhost_virtqueue *vq, - struct rte_mbuf *pkt, uint16_t *nr_descs, uint16_t *nr_buffers, - struct vring_packed_desc *async_descs, - struct iovec *src_iovec, struct iovec *dst_iovec, - struct rte_vhost_iov_iter *src_it, struct rte_vhost_iov_iter *dst_it) +virtio_dev_rx_async_packed(struct virtio_net *dev, struct vhost_virtqueue *vq, + struct rte_mbuf *pkt, uint16_t *nr_descs, uint16_t *nr_buffers) { struct buf_vector buf_vec[BUF_VECTOR_MAX]; - if (unlikely(vhost_enqueue_async_single_packed(dev, vq, pkt, buf_vec, nr_descs, nr_buffers, - async_descs, src_iovec, dst_iovec, - src_it, dst_it) < 0)) { - VHOST_LOG_DATA(DEBUG, "(%d) failed to get enough desc from vring\n", dev->vid); + if (unlikely(vhost_enqueue_async_packed(dev, vq, pkt, buf_vec, + nr_descs, nr_buffers) < 0)) { + VHOST_LOG_DATA(DEBUG, "(%s) failed to get enough desc from vring\n", dev->ifname); return -1; } - VHOST_LOG_DATA(DEBUG, "(%d) current index %d | end index %d\n", - dev->vid, vq->last_avail_idx, vq->last_avail_idx + *nr_descs); + VHOST_LOG_DATA(DEBUG, "(%s) current index %d | end index %d\n", + dev->ifname, vq->last_avail_idx, vq->last_avail_idx + *nr_descs); return 0; } static __rte_always_inline void -dma_error_handler_packed(struct vhost_virtqueue *vq, struct vring_packed_desc *async_descs, - uint16_t async_descs_idx, uint16_t slot_idx, uint32_t nr_err, - uint32_t *pkt_idx, uint32_t *num_async_pkts, uint32_t *num_done_pkts) +dma_error_handler_packed(struct vhost_virtqueue *vq, uint16_t slot_idx, + uint32_t nr_err, uint32_t *pkt_idx) { uint16_t descs_err = 0; uint16_t buffers_err = 0; - struct async_inflight_info *pkts_info = vq->async_pkts_info; + struct async_inflight_info *pkts_info = vq->async->pkts_info; - *num_async_pkts -= nr_err; *pkt_idx -= nr_err; /* calculate the sum of buffers and descs of DMA-error packets. */ while (nr_err-- > 0) { @@ -1960,167 +1777,83 @@ dma_error_handler_packed(struct vhost_virtqueue *vq, struct vring_packed_desc *a slot_idx--; } - vq->async_buffer_idx_packed -= buffers_err; - if (vq->last_avail_idx >= descs_err) { vq->last_avail_idx -= descs_err; - - rte_memcpy(&vq->desc_packed[vq->last_avail_idx], - &async_descs[async_descs_idx - descs_err], - descs_err * sizeof(struct vring_packed_desc)); } else { - uint16_t nr_copy; - vq->last_avail_idx = vq->last_avail_idx + vq->size - descs_err; - nr_copy = vq->size - vq->last_avail_idx; - rte_memcpy(&vq->desc_packed[vq->last_avail_idx], - &async_descs[async_descs_idx - descs_err], - nr_copy * sizeof(struct vring_packed_desc)); - descs_err -= nr_copy; - rte_memcpy(&vq->desc_packed[0], &async_descs[async_descs_idx - descs_err], - descs_err * sizeof(struct vring_packed_desc)); vq->avail_wrap_counter ^= 1; } - *num_done_pkts = *pkt_idx - *num_async_pkts; + vq->shadow_used_idx -= buffers_err; } static __rte_noinline uint32_t -virtio_dev_rx_async_submit_packed(struct virtio_net *dev, - struct vhost_virtqueue *vq, uint16_t queue_id, - struct rte_mbuf **pkts, uint32_t count, - struct rte_mbuf **comp_pkts, uint32_t *comp_count) +virtio_dev_rx_async_submit_packed(struct virtio_net *dev, struct vhost_virtqueue *vq, + uint16_t queue_id, struct rte_mbuf **pkts, uint32_t count, + int16_t dma_id, uint16_t vchan_id) { - uint32_t pkt_idx = 0, pkt_burst_idx = 0; + uint32_t pkt_idx = 0; uint32_t remained = count; - uint16_t async_descs_idx = 0; + uint16_t n_xfer; uint16_t num_buffers; uint16_t num_descs; - struct rte_vhost_iov_iter *it_pool = vq->it_pool; - struct iovec *vec_pool = vq->vec_pool; - struct rte_vhost_async_desc tdes[MAX_PKT_BURST]; - struct iovec *src_iovec = vec_pool; - struct iovec *dst_iovec = vec_pool + (VHOST_MAX_ASYNC_VEC >> 1); + struct vhost_async *async = vq->async; + struct async_inflight_info *pkts_info = async->pkts_info; + uint32_t pkt_err = 0; uint16_t slot_idx = 0; - uint16_t segs_await = 0; - uint16_t iovec_idx = 0, it_idx = 0; - struct async_inflight_info *pkts_info = vq->async_pkts_info; - uint32_t n_pkts = 0, pkt_err = 0; - uint32_t num_async_pkts = 0, num_done_pkts = 0; - struct vring_packed_desc async_descs[vq->size]; do { rte_prefetch0(&vq->desc_packed[vq->last_avail_idx]); - if (remained >= PACKED_BATCH_SIZE) { - if (!virtio_dev_rx_async_batch_packed(dev, vq, - &pkts[pkt_idx], comp_pkts, &num_done_pkts)) { - pkt_idx += PACKED_BATCH_SIZE; - remained -= PACKED_BATCH_SIZE; - continue; - } - } num_buffers = 0; num_descs = 0; - if (unlikely(virtio_dev_rx_async_single_packed(dev, vq, pkts[pkt_idx], - &num_descs, &num_buffers, - &async_descs[async_descs_idx], - &src_iovec[iovec_idx], &dst_iovec[iovec_idx], - &it_pool[it_idx], &it_pool[it_idx + 1]) < 0)) + if (unlikely(virtio_dev_rx_async_packed(dev, vq, pkts[pkt_idx], + &num_descs, &num_buffers) < 0)) break; - VHOST_LOG_DATA(DEBUG, "(%d) current index %d | end index %d\n", - dev->vid, vq->last_avail_idx, - vq->last_avail_idx + num_descs); - - slot_idx = (vq->async_pkts_idx + num_async_pkts) % vq->size; - if (it_pool[it_idx].count) { - uint16_t from; - - async_descs_idx += num_descs; - async_fill_desc(&tdes[pkt_burst_idx++], - &it_pool[it_idx], &it_pool[it_idx + 1]); - pkts_info[slot_idx].descs = num_descs; - pkts_info[slot_idx].nr_buffers = num_buffers; - pkts_info[slot_idx].mbuf = pkts[pkt_idx]; - num_async_pkts++; - iovec_idx += it_pool[it_idx].nr_segs; - it_idx += 2; - - segs_await += it_pool[it_idx].nr_segs; + slot_idx = (async->pkts_idx + pkt_idx) % vq->size; - /** - * recover shadow used ring and keep DMA-occupied - * descriptors. - */ - from = vq->shadow_used_idx - num_buffers; - store_dma_desc_info_packed(vq->shadow_used_packed, - vq->async_buffers_packed, vq->size, from, - vq->async_buffer_idx_packed, num_buffers); - - vq->async_buffer_idx_packed += num_buffers; - if (vq->async_buffer_idx_packed >= vq->size) - vq->async_buffer_idx_packed -= vq->size; - vq->shadow_used_idx -= num_buffers; - } else { - comp_pkts[num_done_pkts++] = pkts[pkt_idx]; - } + pkts_info[slot_idx].descs = num_descs; + pkts_info[slot_idx].nr_buffers = num_buffers; + pkts_info[slot_idx].mbuf = pkts[pkt_idx]; pkt_idx++; remained--; vq_inc_last_avail_packed(vq, num_descs); + } while (pkt_idx < count); - /* - * conditions to trigger async device transfer: - * - buffered packet number reaches transfer threshold - * - unused async iov number is less than max vhost vector - */ - if (unlikely(pkt_burst_idx >= VHOST_ASYNC_BATCH_THRESHOLD || - ((VHOST_MAX_ASYNC_VEC >> 1) - segs_await < BUF_VECTOR_MAX))) { - n_pkts = vq->async_ops.transfer_data(dev->vid, queue_id, - tdes, 0, pkt_burst_idx); - iovec_idx = 0; - it_idx = 0; - segs_await = 0; - vq->async_pkts_inflight_n += n_pkts; - - if (unlikely(n_pkts < pkt_burst_idx)) { - /* - * log error packets number here and do actual - * error processing when applications poll - * completion - */ - pkt_err = pkt_burst_idx - n_pkts; - pkt_burst_idx = 0; - break; - } + if (unlikely(pkt_idx == 0)) + return 0; - pkt_burst_idx = 0; - } - } while (pkt_idx < count); + n_xfer = vhost_async_dma_transfer(dev, vq, dma_id, vchan_id, async->pkts_idx, + async->iov_iter, pkt_idx); - if (pkt_burst_idx) { - n_pkts = vq->async_ops.transfer_data(dev->vid, queue_id, tdes, 0, pkt_burst_idx); - vq->async_pkts_inflight_n += n_pkts; + async_iter_reset(async); - if (unlikely(n_pkts < pkt_burst_idx)) - pkt_err = pkt_burst_idx - n_pkts; + pkt_err = pkt_idx - n_xfer; + if (unlikely(pkt_err)) { + VHOST_LOG_DATA(DEBUG, "(%s) %s: failed to transfer %u packets for queue %u.\n", + dev->ifname, __func__, pkt_err, queue_id); + dma_error_handler_packed(vq, slot_idx, pkt_err, &pkt_idx); } - do_data_copy_enqueue(dev, vq); + if (likely(vq->shadow_used_idx)) { + /* keep used descriptors. */ + store_dma_desc_info_packed(vq->shadow_used_packed, async->buffers_packed, + vq->size, 0, async->buffer_idx_packed, + vq->shadow_used_idx); - if (unlikely(pkt_err)) - dma_error_handler_packed(vq, async_descs, async_descs_idx, slot_idx, pkt_err, - &pkt_idx, &num_async_pkts, &num_done_pkts); - vq->async_pkts_idx += num_async_pkts; - if (vq->async_pkts_idx >= vq->size) - vq->async_pkts_idx -= vq->size; - *comp_count = num_done_pkts; + async->buffer_idx_packed += vq->shadow_used_idx; + if (async->buffer_idx_packed >= vq->size) + async->buffer_idx_packed -= vq->size; - if (likely(vq->shadow_used_idx)) { - vhost_flush_enqueue_shadow_packed(dev, vq); - vhost_vring_call_packed(dev, vq); + async->pkts_idx += pkt_idx; + if (async->pkts_idx >= vq->size) + async->pkts_idx -= vq->size; + + vq->shadow_used_idx = 0; + async->pkts_inflight_n += pkt_idx; } return pkt_idx; @@ -2129,28 +1862,29 @@ virtio_dev_rx_async_submit_packed(struct virtio_net *dev, static __rte_always_inline void write_back_completed_descs_split(struct vhost_virtqueue *vq, uint16_t n_descs) { + struct vhost_async *async = vq->async; uint16_t nr_left = n_descs; uint16_t nr_copy; uint16_t to, from; do { - from = vq->last_async_desc_idx_split & (vq->size - 1); + from = async->last_desc_idx_split & (vq->size - 1); nr_copy = nr_left + from <= vq->size ? nr_left : vq->size - from; to = vq->last_used_idx & (vq->size - 1); if (to + nr_copy <= vq->size) { - rte_memcpy(&vq->used->ring[to], &vq->async_descs_split[from], + rte_memcpy(&vq->used->ring[to], &async->descs_split[from], nr_copy * sizeof(struct vring_used_elem)); } else { uint16_t size = vq->size - to; - rte_memcpy(&vq->used->ring[to], &vq->async_descs_split[from], + rte_memcpy(&vq->used->ring[to], &async->descs_split[from], size * sizeof(struct vring_used_elem)); - rte_memcpy(&vq->used->ring[0], &vq->async_descs_split[from + size], + rte_memcpy(&vq->used->ring[0], &async->descs_split[from + size], (nr_copy - size) * sizeof(struct vring_used_elem)); } - vq->last_async_desc_idx_split += nr_copy; + async->last_desc_idx_split += nr_copy; vq->last_used_idx += nr_copy; nr_left -= nr_copy; } while (nr_left > 0); @@ -2160,129 +1894,239 @@ static __rte_always_inline void write_back_completed_descs_packed(struct vhost_virtqueue *vq, uint16_t n_buffers) { - uint16_t nr_left = n_buffers; - uint16_t from, to; - - do { - from = vq->last_async_buffer_idx_packed; - to = (from + nr_left) % vq->size; - if (to > from) { - vhost_update_used_packed(vq, vq->async_buffers_packed + from, to - from); - vq->last_async_buffer_idx_packed += nr_left; - nr_left = 0; - } else { - vhost_update_used_packed(vq, vq->async_buffers_packed + from, - vq->size - from); - vq->last_async_buffer_idx_packed = 0; - nr_left -= vq->size - from; - } - } while (nr_left > 0); -} + struct vhost_async *async = vq->async; + uint16_t from = async->last_buffer_idx_packed; + uint16_t used_idx = vq->last_used_idx; + uint16_t head_idx = vq->last_used_idx; + uint16_t head_flags = 0; + uint16_t i; -uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, - struct rte_mbuf **pkts, uint16_t count) -{ - struct virtio_net *dev = get_device(vid); - struct vhost_virtqueue *vq; - uint16_t n_pkts_cpl = 0, n_pkts_put = 0, n_descs = 0, n_buffers = 0; - uint16_t start_idx, pkts_idx, vq_size; - struct async_inflight_info *pkts_info; - uint16_t from, i; + /* Split loop in two to save memory barriers */ + for (i = 0; i < n_buffers; i++) { + vq->desc_packed[used_idx].id = async->buffers_packed[from].id; + vq->desc_packed[used_idx].len = async->buffers_packed[from].len; - if (!dev) - return 0; + used_idx += async->buffers_packed[from].count; + if (used_idx >= vq->size) + used_idx -= vq->size; - VHOST_LOG_DATA(DEBUG, "(%d) %s\n", dev->vid, __func__); - if (unlikely(!is_valid_virt_queue_idx(queue_id, 0, dev->nr_vring))) { - VHOST_LOG_DATA(ERR, "(%d) %s: invalid virtqueue idx %d.\n", - dev->vid, __func__, queue_id); - return 0; + from++; + if (from >= vq->size) + from = 0; } - vq = dev->virtqueue[queue_id]; + /* The ordering for storing desc flags needs to be enforced. */ + rte_atomic_thread_fence(__ATOMIC_RELEASE); - if (unlikely(!vq->async_registered)) { - VHOST_LOG_DATA(ERR, "(%d) %s: async not registered for queue id %d.\n", - dev->vid, __func__, queue_id); - return 0; - } + from = async->last_buffer_idx_packed; - rte_spinlock_lock(&vq->access_lock); + for (i = 0; i < n_buffers; i++) { + uint16_t flags; + + if (async->buffers_packed[from].len) + flags = VRING_DESC_F_WRITE; + else + flags = 0; + + if (vq->used_wrap_counter) { + flags |= VRING_DESC_F_USED; + flags |= VRING_DESC_F_AVAIL; + } else { + flags &= ~VRING_DESC_F_USED; + flags &= ~VRING_DESC_F_AVAIL; + } + + if (i > 0) { + vq->desc_packed[vq->last_used_idx].flags = flags; + } else { + head_idx = vq->last_used_idx; + head_flags = flags; + } - pkts_idx = vq->async_pkts_idx % vq->size; - pkts_info = vq->async_pkts_info; - vq_size = vq->size; - start_idx = virtio_dev_rx_async_get_info_idx(pkts_idx, - vq_size, vq->async_pkts_inflight_n); + vq_inc_last_used_packed(vq, async->buffers_packed[from].count); + + from++; + if (from == vq->size) + from = 0; + } - if (count > vq->async_last_pkts_n) - n_pkts_cpl = vq->async_ops.check_completed_copies(vid, - queue_id, 0, count - vq->async_last_pkts_n); - n_pkts_cpl += vq->async_last_pkts_n; + vq->desc_packed[head_idx].flags = head_flags; + async->last_buffer_idx_packed = from; +} - n_pkts_put = RTE_MIN(count, n_pkts_cpl); - if (unlikely(n_pkts_put == 0)) { - vq->async_last_pkts_n = n_pkts_cpl; - goto done; +static __rte_always_inline uint16_t +vhost_poll_enqueue_completed(struct virtio_net *dev, uint16_t queue_id, + struct rte_mbuf **pkts, uint16_t count, int16_t dma_id, + uint16_t vchan_id) +{ + struct vhost_virtqueue *vq = dev->virtqueue[queue_id]; + struct vhost_async *async = vq->async; + struct async_inflight_info *pkts_info = async->pkts_info; + uint16_t nr_cpl_pkts = 0; + uint16_t n_descs = 0, n_buffers = 0; + uint16_t start_idx, from, i; + + /* Check completed copies for the given DMA vChannel */ + vhost_async_dma_check_completed(dev, dma_id, vchan_id, VHOST_DMA_MAX_COPY_COMPLETE); + + start_idx = async_get_first_inflight_pkt_idx(vq); + /** + * Calculate the number of copy completed packets. + * Note that there may be completed packets even if + * no copies are reported done by the given DMA vChannel, + * as it's possible that a virtqueue uses multiple DMA + * vChannels. + */ + from = start_idx; + while (vq->async->pkts_cmpl_flag[from] && count--) { + vq->async->pkts_cmpl_flag[from] = false; + from++; + if (from >= vq->size) + from -= vq->size; + nr_cpl_pkts++; } - if (vq_is_packed(dev)) { - for (i = 0; i < n_pkts_put; i++) { - from = (start_idx + i) % vq_size; - n_buffers += pkts_info[from].nr_buffers; - pkts[i] = pkts_info[from].mbuf; - } - } else { - for (i = 0; i < n_pkts_put; i++) { - from = (start_idx + i) & (vq_size - 1); - n_descs += pkts_info[from].descs; - pkts[i] = pkts_info[from].mbuf; - } + if (nr_cpl_pkts == 0) + return 0; + + for (i = 0; i < nr_cpl_pkts; i++) { + from = (start_idx + i) % vq->size; + /* Only used with packed ring */ + n_buffers += pkts_info[from].nr_buffers; + /* Only used with split ring */ + n_descs += pkts_info[from].descs; + pkts[i] = pkts_info[from].mbuf; } - vq->async_last_pkts_n = n_pkts_cpl - n_pkts_put; - vq->async_pkts_inflight_n -= n_pkts_put; + async->pkts_inflight_n -= nr_cpl_pkts; if (likely(vq->enabled && vq->access_ok)) { if (vq_is_packed(dev)) { write_back_completed_descs_packed(vq, n_buffers); - vhost_vring_call_packed(dev, vq); } else { write_back_completed_descs_split(vq, n_descs); - - __atomic_add_fetch(&vq->used->idx, n_descs, - __ATOMIC_RELEASE); + __atomic_add_fetch(&vq->used->idx, n_descs, __ATOMIC_RELEASE); vhost_vring_call_split(dev, vq); } } else { if (vq_is_packed(dev)) { - vq->last_async_buffer_idx_packed += n_buffers; - if (vq->last_async_buffer_idx_packed >= vq->size) - vq->last_async_buffer_idx_packed -= vq->size; + async->last_buffer_idx_packed += n_buffers; + if (async->last_buffer_idx_packed >= vq->size) + async->last_buffer_idx_packed -= vq->size; } else { - vq->last_async_desc_idx_split += n_descs; + async->last_desc_idx_split += n_descs; } } -done: + return nr_cpl_pkts; +} + +uint16_t +rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, + struct rte_mbuf **pkts, uint16_t count, int16_t dma_id, + uint16_t vchan_id) +{ + struct virtio_net *dev = get_device(vid); + struct vhost_virtqueue *vq; + uint16_t n_pkts_cpl = 0; + + if (unlikely(!dev)) + return 0; + + VHOST_LOG_DATA(DEBUG, "(%s) %s\n", dev->ifname, __func__); + if (unlikely(!is_valid_virt_queue_idx(queue_id, 0, dev->nr_vring))) { + VHOST_LOG_DATA(ERR, "(%s) %s: invalid virtqueue idx %d.\n", + dev->ifname, __func__, queue_id); + return 0; + } + + if (unlikely(!dma_copy_track[dma_id].vchans || + !dma_copy_track[dma_id].vchans[vchan_id].pkts_cmpl_flag_addr)) { + VHOST_LOG_DATA(ERR, "(%s) %s: invalid channel %d:%u.\n", dev->ifname, __func__, + dma_id, vchan_id); + return 0; + } + + vq = dev->virtqueue[queue_id]; + + if (!rte_spinlock_trylock(&vq->access_lock)) { + VHOST_LOG_DATA(DEBUG, "(%s) %s: virtqueue %u is busy.\n", dev->ifname, __func__, + queue_id); + return 0; + } + + if (unlikely(!vq->async)) { + VHOST_LOG_DATA(ERR, "(%s) %s: async not registered for virtqueue %d.\n", + dev->ifname, __func__, queue_id); + goto out; + } + + n_pkts_cpl = vhost_poll_enqueue_completed(dev, queue_id, pkts, count, dma_id, vchan_id); + +out: rte_spinlock_unlock(&vq->access_lock); - return n_pkts_put; + return n_pkts_cpl; +} + +uint16_t +rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id, + struct rte_mbuf **pkts, uint16_t count, int16_t dma_id, + uint16_t vchan_id) +{ + struct virtio_net *dev = get_device(vid); + struct vhost_virtqueue *vq; + uint16_t n_pkts_cpl = 0; + + if (!dev) + return 0; + + VHOST_LOG_DATA(DEBUG, "(%s) %s\n", dev->ifname, __func__); + if (unlikely(!is_valid_virt_queue_idx(queue_id, 0, dev->nr_vring))) { + VHOST_LOG_DATA(ERR, "(%s) %s: invalid virtqueue idx %d.\n", + dev->ifname, __func__, queue_id); + return 0; + } + + vq = dev->virtqueue[queue_id]; + + if (unlikely(!vq->async)) { + VHOST_LOG_DATA(ERR, "(%s) %s: async not registered for queue id %d.\n", + dev->ifname, __func__, queue_id); + return 0; + } + + if (unlikely(!dma_copy_track[dma_id].vchans || + !dma_copy_track[dma_id].vchans[vchan_id].pkts_cmpl_flag_addr)) { + VHOST_LOG_DATA(ERR, "(%s) %s: invalid channel %d:%u.\n", dev->ifname, __func__, + dma_id, vchan_id); + return 0; + } + + n_pkts_cpl = vhost_poll_enqueue_completed(dev, queue_id, pkts, count, dma_id, vchan_id); + + return n_pkts_cpl; } static __rte_always_inline uint32_t virtio_dev_rx_async_submit(struct virtio_net *dev, uint16_t queue_id, - struct rte_mbuf **pkts, uint32_t count, - struct rte_mbuf **comp_pkts, uint32_t *comp_count) + struct rte_mbuf **pkts, uint32_t count, int16_t dma_id, uint16_t vchan_id) { struct vhost_virtqueue *vq; uint32_t nb_tx = 0; - VHOST_LOG_DATA(DEBUG, "(%d) %s\n", dev->vid, __func__); + VHOST_LOG_DATA(DEBUG, "(%s) %s\n", dev->ifname, __func__); if (unlikely(!is_valid_virt_queue_idx(queue_id, 0, dev->nr_vring))) { - VHOST_LOG_DATA(ERR, "(%d) %s: invalid virtqueue idx %d.\n", - dev->vid, __func__, queue_id); + VHOST_LOG_DATA(ERR, "(%s) %s: invalid virtqueue idx %d.\n", + dev->ifname, __func__, queue_id); + return 0; + } + + if (unlikely(!dma_copy_track[dma_id].vchans || + !dma_copy_track[dma_id].vchans[vchan_id].pkts_cmpl_flag_addr)) { + VHOST_LOG_DATA(ERR, "(%s) %s: invalid channel %d:%u.\n", dev->ifname, __func__, + dma_id, vchan_id); return 0; } @@ -2290,7 +2134,7 @@ virtio_dev_rx_async_submit(struct virtio_net *dev, uint16_t queue_id, rte_spinlock_lock(&vq->access_lock); - if (unlikely(!vq->enabled || !vq->async_registered)) + if (unlikely(!vq->enabled || !vq->async)) goto out_access_unlock; if (dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM)) @@ -2305,13 +2149,11 @@ virtio_dev_rx_async_submit(struct virtio_net *dev, uint16_t queue_id, goto out; if (vq_is_packed(dev)) - nb_tx = virtio_dev_rx_async_submit_packed(dev, - vq, queue_id, pkts, count, comp_pkts, - comp_count); + nb_tx = virtio_dev_rx_async_submit_packed(dev, vq, queue_id, + pkts, count, dma_id, vchan_id); else - nb_tx = virtio_dev_rx_async_submit_split(dev, - vq, queue_id, pkts, count, comp_pkts, - comp_count); + nb_tx = virtio_dev_rx_async_submit_split(dev, vq, queue_id, + pkts, count, dma_id, vchan_id); out: if (dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM)) @@ -2325,24 +2167,21 @@ out_access_unlock: uint16_t rte_vhost_submit_enqueue_burst(int vid, uint16_t queue_id, - struct rte_mbuf **pkts, uint16_t count, - struct rte_mbuf **comp_pkts, uint32_t *comp_count) + struct rte_mbuf **pkts, uint16_t count, int16_t dma_id, + uint16_t vchan_id) { struct virtio_net *dev = get_device(vid); - *comp_count = 0; if (!dev) return 0; if (unlikely(!(dev->flags & VIRTIO_DEV_BUILTIN_VIRTIO_NET))) { - VHOST_LOG_DATA(ERR, - "(%d) %s: built-in vhost net backend is disabled.\n", - dev->vid, __func__); + VHOST_LOG_DATA(ERR, "(%s) %s: built-in vhost net backend is disabled.\n", + dev->ifname, __func__); return 0; } - return virtio_dev_rx_async_submit(dev, queue_id, pkts, count, comp_pkts, - comp_count); + return virtio_dev_rx_async_submit(dev, queue_id, pkts, count, dma_id, vchan_id); } static inline bool @@ -2397,7 +2236,7 @@ parse_headers(struct rte_mbuf *m, uint8_t *l4_proto) m->l3_len = rte_ipv4_hdr_len(ipv4_hdr); if (data_len < m->l2_len + m->l3_len) goto error; - m->ol_flags |= PKT_TX_IPV4; + m->ol_flags |= RTE_MBUF_F_TX_IPV4; *l4_proto = ipv4_hdr->next_proto_id; break; case RTE_ETHER_TYPE_IPV6: @@ -2406,7 +2245,7 @@ parse_headers(struct rte_mbuf *m, uint8_t *l4_proto) ipv6_hdr = rte_pktmbuf_mtod_offset(m, struct rte_ipv6_hdr *, m->l2_len); m->l3_len = sizeof(struct rte_ipv6_hdr); - m->ol_flags |= PKT_TX_IPV6; + m->ol_flags |= RTE_MBUF_F_TX_IPV6; *l4_proto = ipv6_hdr->proto; break; default: @@ -2445,7 +2284,8 @@ error: } static __rte_always_inline void -vhost_dequeue_offload_legacy(struct virtio_net_hdr *hdr, struct rte_mbuf *m) +vhost_dequeue_offload_legacy(struct virtio_net *dev, struct virtio_net_hdr *hdr, + struct rte_mbuf *m) { uint8_t l4_proto = 0; struct rte_tcp_hdr *tcp_hdr = NULL; @@ -2461,17 +2301,17 @@ vhost_dequeue_offload_legacy(struct virtio_net_hdr *hdr, struct rte_mbuf *m) case (offsetof(struct rte_tcp_hdr, cksum)): if (l4_proto != IPPROTO_TCP) goto error; - m->ol_flags |= PKT_TX_TCP_CKSUM; + m->ol_flags |= RTE_MBUF_F_TX_TCP_CKSUM; break; case (offsetof(struct rte_udp_hdr, dgram_cksum)): if (l4_proto != IPPROTO_UDP) goto error; - m->ol_flags |= PKT_TX_UDP_CKSUM; + m->ol_flags |= RTE_MBUF_F_TX_UDP_CKSUM; break; case (offsetof(struct rte_sctp_hdr, cksum)): if (l4_proto != IPPROTO_SCTP) goto error; - m->ol_flags |= PKT_TX_SCTP_CKSUM; + m->ol_flags |= RTE_MBUF_F_TX_SCTP_CKSUM; break; default: goto error; @@ -2493,20 +2333,20 @@ vhost_dequeue_offload_legacy(struct virtio_net_hdr *hdr, struct rte_mbuf *m) tcp_len = (tcp_hdr->data_off & 0xf0) >> 2; if (data_len < m->l2_len + m->l3_len + tcp_len) goto error; - m->ol_flags |= PKT_TX_TCP_SEG; + m->ol_flags |= RTE_MBUF_F_TX_TCP_SEG; m->tso_segsz = hdr->gso_size; m->l4_len = tcp_len; break; case VIRTIO_NET_HDR_GSO_UDP: if (l4_proto != IPPROTO_UDP) goto error; - m->ol_flags |= PKT_TX_UDP_SEG; + m->ol_flags |= RTE_MBUF_F_TX_UDP_SEG; m->tso_segsz = hdr->gso_size; m->l4_len = sizeof(struct rte_udp_hdr); break; default: - VHOST_LOG_DATA(WARNING, - "unsupported gso type %u.\n", hdr->gso_type); + VHOST_LOG_DATA(WARNING, "(%s) unsupported gso type %u.\n", + dev->ifname, hdr->gso_type); goto error; } } @@ -2519,8 +2359,8 @@ error: } static __rte_always_inline void -vhost_dequeue_offload(struct virtio_net_hdr *hdr, struct rte_mbuf *m, - bool legacy_ol_flags) +vhost_dequeue_offload(struct virtio_net *dev, struct virtio_net_hdr *hdr, + struct rte_mbuf *m, bool legacy_ol_flags) { struct rte_net_hdr_lens hdr_lens; int l4_supported = 0; @@ -2530,11 +2370,11 @@ vhost_dequeue_offload(struct virtio_net_hdr *hdr, struct rte_mbuf *m, return; if (legacy_ol_flags) { - vhost_dequeue_offload_legacy(hdr, m); + vhost_dequeue_offload_legacy(dev, hdr, m); return; } - m->ol_flags |= PKT_RX_IP_CKSUM_UNKNOWN; + m->ol_flags |= RTE_MBUF_F_RX_IP_CKSUM_UNKNOWN; ptype = rte_net_get_ptype(m, &hdr_lens, RTE_PTYPE_ALL_MASK); m->packet_type = ptype; @@ -2561,7 +2401,7 @@ vhost_dequeue_offload(struct virtio_net_hdr *hdr, struct rte_mbuf *m, hdrlen = hdr_lens.l2_len + hdr_lens.l3_len + hdr_lens.l4_len; if (hdr->csum_start <= hdrlen && l4_supported != 0) { - m->ol_flags |= PKT_RX_L4_CKSUM_NONE; + m->ol_flags |= RTE_MBUF_F_RX_L4_CKSUM_NONE; } else { /* Unknown proto or tunnel, do sw cksum. We can assume * the cksum field is in the first segment since the @@ -2591,13 +2431,13 @@ vhost_dequeue_offload(struct virtio_net_hdr *hdr, struct rte_mbuf *m, case VIRTIO_NET_HDR_GSO_TCPV6: if ((ptype & RTE_PTYPE_L4_MASK) != RTE_PTYPE_L4_TCP) break; - m->ol_flags |= PKT_RX_LRO | PKT_RX_L4_CKSUM_NONE; + m->ol_flags |= RTE_MBUF_F_RX_LRO | RTE_MBUF_F_RX_L4_CKSUM_NONE; m->tso_segsz = hdr->gso_size; break; case VIRTIO_NET_HDR_GSO_UDP: if ((ptype & RTE_PTYPE_L4_MASK) != RTE_PTYPE_L4_UDP) break; - m->ol_flags |= PKT_RX_LRO | PKT_RX_L4_CKSUM_NONE; + m->ol_flags |= RTE_MBUF_F_RX_LRO | RTE_MBUF_F_RX_L4_CKSUM_NONE; m->tso_segsz = hdr->gso_size; break; default: @@ -2743,8 +2583,8 @@ copy_desc_to_mbuf(struct virtio_net *dev, struct vhost_virtqueue *vq, if (mbuf_avail == 0) { cur = rte_pktmbuf_alloc(mbuf_pool); if (unlikely(cur == NULL)) { - VHOST_LOG_DATA(ERR, "Failed to " - "allocate memory for mbuf.\n"); + VHOST_LOG_DATA(ERR, "(%s) failed to allocate memory for mbuf.\n", + dev->ifname); error = -1; goto out; } @@ -2764,7 +2604,7 @@ copy_desc_to_mbuf(struct virtio_net *dev, struct vhost_virtqueue *vq, m->pkt_len += mbuf_offset; if (hdr) - vhost_dequeue_offload(hdr, m, legacy_ol_flags); + vhost_dequeue_offload(dev, hdr, m, legacy_ol_flags); out: @@ -2778,7 +2618,7 @@ virtio_dev_extbuf_free(void *addr __rte_unused, void *opaque) } static int -virtio_dev_extbuf_alloc(struct rte_mbuf *pkt, uint32_t size) +virtio_dev_extbuf_alloc(struct virtio_net *dev, struct rte_mbuf *pkt, uint32_t size) { struct rte_mbuf_ext_shared_info *shinfo = NULL; uint32_t total_len = RTE_PKTMBUF_HEADROOM + size; @@ -2802,7 +2642,7 @@ virtio_dev_extbuf_alloc(struct rte_mbuf *pkt, uint32_t size) virtio_dev_extbuf_free, buf); if (unlikely(shinfo == NULL)) { rte_free(buf); - VHOST_LOG_DATA(ERR, "Failed to init shinfo\n"); + VHOST_LOG_DATA(ERR, "(%s) failed to init shinfo\n", dev->ifname); return -1; } @@ -2824,7 +2664,7 @@ virtio_dev_pktmbuf_prep(struct virtio_net *dev, struct rte_mbuf *pkt, return 0; /* attach an external buffer if supported */ - if (dev->extbuf && !virtio_dev_extbuf_alloc(pkt, data_len)) + if (dev->extbuf && !virtio_dev_extbuf_alloc(dev, pkt, data_len)) return 0; /* check if chained buffers are allowed */ @@ -2856,12 +2696,12 @@ virtio_dev_tx_split(struct virtio_net *dev, struct vhost_virtqueue *vq, rte_prefetch0(&vq->avail->ring[vq->last_avail_idx & (vq->size - 1)]); - VHOST_LOG_DATA(DEBUG, "(%d) %s\n", dev->vid, __func__); + VHOST_LOG_DATA(DEBUG, "(%s) %s\n", dev->ifname, __func__); count = RTE_MIN(count, MAX_PKT_BURST); count = RTE_MIN(count, free_entries); - VHOST_LOG_DATA(DEBUG, "(%d) about to dequeue %u buffers\n", - dev->vid, count); + VHOST_LOG_DATA(DEBUG, "(%s) about to dequeue %u buffers\n", + dev->ifname, count); if (rte_pktmbuf_alloc_bulk(mbuf_pool, pkts, count)) return 0; @@ -2890,9 +2730,8 @@ virtio_dev_tx_split(struct virtio_net *dev, struct vhost_virtqueue *vq, * is required. Drop this packet. */ if (!allocerr_warned) { - VHOST_LOG_DATA(ERR, - "Failed mbuf alloc of size %d from %s on %s.\n", - buf_len, mbuf_pool->name, dev->ifname); + VHOST_LOG_DATA(ERR, "(%s) failed mbuf alloc of size %d from %s.\n", + dev->ifname, buf_len, mbuf_pool->name); allocerr_warned = true; } dropped += 1; @@ -2904,8 +2743,7 @@ virtio_dev_tx_split(struct virtio_net *dev, struct vhost_virtqueue *vq, mbuf_pool, legacy_ol_flags); if (unlikely(err)) { if (!allocerr_warned) { - VHOST_LOG_DATA(ERR, - "Failed to copy desc to mbuf on %s.\n", + VHOST_LOG_DATA(ERR, "(%s) failed to copy desc to mbuf.\n", dev->ifname); allocerr_warned = true; } @@ -3048,7 +2886,7 @@ virtio_dev_tx_batch_packed(struct virtio_net *dev, if (virtio_net_with_host_offload(dev)) { vhost_for_each_try_unroll(i, 0, PACKED_BATCH_SIZE) { hdr = (struct virtio_net_hdr *)(desc_addrs[i]); - vhost_dequeue_offload(hdr, pkts[i], legacy_ol_flags); + vhost_dequeue_offload(dev, hdr, pkts[i], legacy_ol_flags); } } @@ -3087,9 +2925,8 @@ vhost_dequeue_single_packed(struct virtio_net *dev, if (unlikely(virtio_dev_pktmbuf_prep(dev, pkts, buf_len))) { if (!allocerr_warned) { - VHOST_LOG_DATA(ERR, - "Failed mbuf alloc of size %d from %s on %s.\n", - buf_len, mbuf_pool->name, dev->ifname); + VHOST_LOG_DATA(ERR, "(%s) failed mbuf alloc of size %d from %s.\n", + dev->ifname, buf_len, mbuf_pool->name); allocerr_warned = true; } return -1; @@ -3099,8 +2936,7 @@ vhost_dequeue_single_packed(struct virtio_net *dev, mbuf_pool, legacy_ol_flags); if (unlikely(err)) { if (!allocerr_warned) { - VHOST_LOG_DATA(ERR, - "Failed to copy desc to mbuf on %s.\n", + VHOST_LOG_DATA(ERR, "(%s) failed to copy desc to mbuf.\n", dev->ifname); allocerr_warned = true; } @@ -3216,16 +3052,14 @@ rte_vhost_dequeue_burst(int vid, uint16_t queue_id, return 0; if (unlikely(!(dev->flags & VIRTIO_DEV_BUILTIN_VIRTIO_NET))) { - VHOST_LOG_DATA(ERR, - "(%d) %s: built-in vhost net backend is disabled.\n", - dev->vid, __func__); + VHOST_LOG_DATA(ERR, "(%s) %s: built-in vhost net backend is disabled.\n", + dev->ifname, __func__); return 0; } if (unlikely(!is_valid_virt_queue_idx(queue_id, 1, dev->nr_vring))) { - VHOST_LOG_DATA(ERR, - "(%d) %s: invalid virtqueue idx %d.\n", - dev->vid, __func__, queue_id); + VHOST_LOG_DATA(ERR, "(%s) %s: invalid virtqueue idx %d.\n", + dev->ifname, __func__, queue_id); return 0; } @@ -3270,10 +3104,16 @@ rte_vhost_dequeue_burst(int vid, uint16_t queue_id, rarp_mbuf = rte_net_make_rarp_packet(mbuf_pool, &dev->mac); if (rarp_mbuf == NULL) { - VHOST_LOG_DATA(ERR, "Failed to make RARP packet.\n"); + VHOST_LOG_DATA(ERR, "(%s) failed to make RARP packet.\n", dev->ifname); count = 0; goto out; } + /* + * Inject it to the head of "pkts" array, so that switch's mac + * learning table will get updated first. + */ + pkts[0] = rarp_mbuf; + pkts++; count -= 1; } @@ -3296,15 +3136,8 @@ out: out_access_unlock: rte_spinlock_unlock(&vq->access_lock); - if (unlikely(rarp_mbuf != NULL)) { - /* - * Inject it to the head of "pkts" array, so that switch's mac - * learning table will get updated first. - */ - memmove(&pkts[1], pkts, count * sizeof(struct rte_mbuf *)); - pkts[0] = rarp_mbuf; + if (unlikely(rarp_mbuf != NULL)) count += 1; - } return count; }