net/failsafe: add plug-in support

[dpdk.git] / drivers / net / virtio / virtio_rxtx.c

diff --git a/drivers/net/virtio/virtio_rxtx.c b/drivers/net/virtio/virtio_rxtx.c
index 22d97a4..e30377c 100644 (file)
--- a/drivers/net/virtio/virtio_rxtx.c
+++ b/drivers/net/virtio/virtio_rxtx.c
@@ -72,6 +72,15 @@
 #define VIRTIO_SIMPLE_FLAGS ((uint32_t)ETH_TXQ_FLAGS_NOMULTSEGS | \
        ETH_TXQ_FLAGS_NOOFFLOADS)
 
+int
+virtio_dev_rx_queue_done(void *rxq, uint16_t offset)
+{
+       struct virtnet_rx *rxvq = rxq;
+       struct virtqueue *vq = rxvq->vq;
+
+       return VIRTQUEUE_NUSED(vq) >= offset;
+}
+
 static void
 vq_ring_free_chain(struct virtqueue *vq, uint16_t desc_idx)
 {
@@ -124,7 +133,7 @@ virtqueue_dequeue_burst_rx(struct virtqueue *vq, struct rte_mbuf **rx_pkts,
                cookie = (struct rte_mbuf *)vq->vq_descx[desc_idx].cookie;
 
                if (unlikely(cookie == NULL)) {
-                       PMD_DRV_LOG(ERR, "vring descriptor with no mbuf cookie at %u\n",
+                       PMD_DRV_LOG(ERR, "vring descriptor with no mbuf cookie at %u",
                                vq->vq_used_cons_idx);
                        break;
                }
@@ -258,6 +267,12 @@ tx_offload_enabled(struct virtio_hw *hw)
                vtpci_with_feature(hw, VIRTIO_NET_F_HOST_TSO6);
 }
 
+/* avoid write operation when necessary, to lessen cache issues */
+#define ASSIGN_UNLESS_EQUAL(var, val) do {     \
+       if ((var) != (val))                     \
+               (var) = (val);                  \
+} while (0)
+
 static inline void
 virtqueue_enqueue_xmit(struct virtnet_tx *txvq, struct rte_mbuf *cookie,
                       uint16_t needed, int use_indirect, int can_push)
@@ -286,8 +301,14 @@ virtqueue_enqueue_xmit(struct virtnet_tx *txvq, struct rte_mbuf *cookie,
                hdr = (struct virtio_net_hdr *)
                        rte_pktmbuf_prepend(cookie, head_size);
                /* if offload disabled, it is not zeroed below, do it now */
-               if (offload == 0)
-                       memset(hdr, 0, head_size);
+               if (offload == 0) {
+                       ASSIGN_UNLESS_EQUAL(hdr->csum_start, 0);
+                       ASSIGN_UNLESS_EQUAL(hdr->csum_offset, 0);
+                       ASSIGN_UNLESS_EQUAL(hdr->flags, 0);
+                       ASSIGN_UNLESS_EQUAL(hdr->gso_type, 0);
+                       ASSIGN_UNLESS_EQUAL(hdr->gso_size, 0);
+                       ASSIGN_UNLESS_EQUAL(hdr->hdr_len, 0);
+               }
        } else if (use_indirect) {
                /* setup tx ring slot to point to indirect
                 * descriptor list stored in reserved region.
@@ -337,9 +358,9 @@ virtqueue_enqueue_xmit(struct virtnet_tx *txvq, struct rte_mbuf *cookie,
                        break;
 
                default:
-                       hdr->csum_start = 0;
-                       hdr->csum_offset = 0;
-                       hdr->flags = 0;
+                       ASSIGN_UNLESS_EQUAL(hdr->csum_start, 0);
+                       ASSIGN_UNLESS_EQUAL(hdr->csum_offset, 0);
+                       ASSIGN_UNLESS_EQUAL(hdr->flags, 0);
                        break;
                }
 
@@ -355,9 +376,9 @@ virtqueue_enqueue_xmit(struct virtnet_tx *txvq, struct rte_mbuf *cookie,
                                cookie->l3_len +
                                cookie->l4_len;
                } else {
-                       hdr->gso_type = 0;
-                       hdr->gso_size = 0;
-                       hdr->hdr_len = 0;
+                       ASSIGN_UNLESS_EQUAL(hdr->gso_type, 0);
+                       ASSIGN_UNLESS_EQUAL(hdr->gso_size, 0);
+                       ASSIGN_UNLESS_EQUAL(hdr->hdr_len, 0);
                }
        }
 
@@ -704,7 +725,7 @@ virtio_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
 {
        struct virtnet_rx *rxvq = rx_queue;
        struct virtqueue *vq = rxvq->vq;
-       struct virtio_hw *hw;
+       struct virtio_hw *hw = vq->hw;
        struct rte_mbuf *rxm, *new_mbuf;
        uint16_t nb_used, num, nb_rx;
        uint32_t len[VIRTIO_MBUF_BURST_SZ];
@@ -715,20 +736,23 @@ virtio_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
        int offload;
        struct virtio_net_hdr *hdr;
 
+       nb_rx = 0;
+       if (unlikely(hw->started == 0))
+               return nb_rx;
+
        nb_used = VIRTQUEUE_NUSED(vq);
 
        virtio_rmb();
 
-       num = (uint16_t)(likely(nb_used <= nb_pkts) ? nb_used : nb_pkts);
-       num = (uint16_t)(likely(num <= VIRTIO_MBUF_BURST_SZ) ? num : VIRTIO_MBUF_BURST_SZ);
+       num = likely(nb_used <= nb_pkts) ? nb_used : nb_pkts;
+       if (unlikely(num > VIRTIO_MBUF_BURST_SZ))
+               num = VIRTIO_MBUF_BURST_SZ;
        if (likely(num > DESC_PER_CACHELINE))
                num = num - ((vq->vq_used_cons_idx + num) % DESC_PER_CACHELINE);
 
        num = virtqueue_dequeue_burst_rx(vq, rcv_pkts, len, num);
        PMD_RX_LOG(DEBUG, "used:%d dequeue:%d", nb_used, num);
 
-       hw = vq->hw;
-       nb_rx = 0;
        nb_enqueued = 0;
        hdr_size = hw->vtnet_hdr_size;
        offload = rx_offload_enabled(hw);
@@ -751,8 +775,6 @@ virtio_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
                rxm->ol_flags = 0;
                rxm->vlan_tci = 0;
 
-               rxm->nb_segs = 1;
-               rxm->next = NULL;
                rxm->pkt_len = (uint32_t)(len[i] - hdr_size);
                rxm->data_len = (uint16_t)(len[i] - hdr_size);
 
@@ -772,7 +794,7 @@ virtio_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
 
                rx_pkts[nb_rx++] = rxm;
 
-               rxvq->stats.bytes += rx_pkts[nb_rx - 1]->pkt_len;
+               rxvq->stats.bytes += rxm->pkt_len;
                virtio_update_packet_stats(&rxvq->stats, rxm);
        }
 
@@ -815,7 +837,7 @@ virtio_recv_mergeable_pkts(void *rx_queue,
 {
        struct virtnet_rx *rxvq = rx_queue;
        struct virtqueue *vq = rxvq->vq;
-       struct virtio_hw *hw;
+       struct virtio_hw *hw = vq->hw;
        struct rte_mbuf *rxm, *new_mbuf;
        uint16_t nb_used, num, nb_rx;
        uint32_t len[VIRTIO_MBUF_BURST_SZ];
@@ -829,14 +851,16 @@ virtio_recv_mergeable_pkts(void *rx_queue,
        uint32_t hdr_size;
        int offload;
 
+       nb_rx = 0;
+       if (unlikely(hw->started == 0))
+               return nb_rx;
+
        nb_used = VIRTQUEUE_NUSED(vq);
 
        virtio_rmb();
 
        PMD_RX_LOG(DEBUG, "used:%d", nb_used);
 
-       hw = vq->hw;
-       nb_rx = 0;
        i = 0;
        nb_enqueued = 0;
        seg_num = 0;
@@ -879,7 +903,6 @@ virtio_recv_mergeable_pkts(void *rx_queue,
 
                rxm->data_off = RTE_PKTMBUF_HEADROOM;
                rxm->nb_segs = seg_num;
-               rxm->next = NULL;
                rxm->ol_flags = 0;
                rxm->vlan_tci = 0;
                rxm->pkt_len = (uint32_t)(len[0] - hdr_size);
@@ -924,7 +947,6 @@ virtio_recv_mergeable_pkts(void *rx_queue,
                                rxm = rcv_pkts[extra_idx];
 
                                rxm->data_off = RTE_PKTMBUF_HEADROOM - hdr_size;
-                               rxm->next = NULL;
                                rxm->pkt_len = (uint32_t)(len[extra_idx]);
                                rxm->data_len = (uint16_t)(len[extra_idx]);
 
@@ -988,9 +1010,12 @@ virtio_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
        struct virtqueue *vq = txvq->vq;
        struct virtio_hw *hw = vq->hw;
        uint16_t hdr_size = hw->vtnet_hdr_size;
-       uint16_t nb_used, nb_tx;
+       uint16_t nb_used, nb_tx = 0;
        int error;
 
+       if (unlikely(hw->started == 0))
+               return nb_tx;
+
        if (unlikely(nb_pkts < 1))
                return nb_pkts;
 
@@ -1015,7 +1040,8 @@ virtio_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
                }
 
                /* optimize ring usage */
-               if (vtpci_with_feature(hw, VIRTIO_F_ANY_LAYOUT) &&
+               if ((vtpci_with_feature(hw, VIRTIO_F_ANY_LAYOUT) ||
+                     vtpci_with_feature(hw, VIRTIO_F_VERSION_1)) &&
                    rte_mbuf_refcnt_read(txm) == 1 &&
                    RTE_MBUF_DIRECT(txm) &&
                    txm->nb_segs == 1 &&