net/virtio: fix mergeable Rx with segmented packet

[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 fa9c855..e23cd04 100644 (file)
--- a/drivers/net/virtio/virtio_rxtx.c
+++ b/drivers/net/virtio/virtio_rxtx.c
@@ -479,13 +479,14 @@ virtio_tso_fix_cksum(struct rte_mbuf *m)
        /* common case: header is not fragmented */
        if (likely(rte_pktmbuf_data_len(m) >= m->l2_len + m->l3_len +
                        m->l4_len)) {
-               struct ipv4_hdr *iph;
-               struct ipv6_hdr *ip6h;
-               struct tcp_hdr *th;
+               struct rte_ipv4_hdr *iph;
+               struct rte_ipv6_hdr *ip6h;
+               struct rte_tcp_hdr *th;
                uint16_t prev_cksum, new_cksum, ip_len, ip_paylen;
                uint32_t tmp;
 
-               iph = rte_pktmbuf_mtod_offset(m, struct ipv4_hdr *, m->l2_len);
+               iph = rte_pktmbuf_mtod_offset(m,
+                                       struct rte_ipv4_hdr *, m->l2_len);
                th = RTE_PTR_ADD(iph, m->l3_len);
                if ((iph->version_ihl >> 4) == 4) {
                        iph->hdr_checksum = 0;
@@ -494,7 +495,7 @@ virtio_tso_fix_cksum(struct rte_mbuf *m)
                        ip_paylen = rte_cpu_to_be_16(rte_be_to_cpu_16(ip_len) -
                                m->l3_len);
                } else {
-                       ip6h = (struct ipv6_hdr *)iph;
+                       ip6h = (struct rte_ipv6_hdr *)iph;
                        ip_paylen = ip6h->payload_len;
                }
 
@@ -538,14 +539,14 @@ virtqueue_xmit_offload(struct virtio_net_hdr *hdr,
                switch (cookie->ol_flags & PKT_TX_L4_MASK) {
                case PKT_TX_UDP_CKSUM:
                        hdr->csum_start = cookie->l2_len + cookie->l3_len;
-                       hdr->csum_offset = offsetof(struct udp_hdr,
+                       hdr->csum_offset = offsetof(struct rte_udp_hdr,
                                dgram_cksum);
                        hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
                        break;
 
                case PKT_TX_TCP_CKSUM:
                        hdr->csum_start = cookie->l2_len + cookie->l3_len;
-                       hdr->csum_offset = offsetof(struct tcp_hdr, cksum);
+                       hdr->csum_offset = offsetof(struct rte_tcp_hdr, cksum);
                        hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
                        break;
 
@@ -889,11 +890,6 @@ virtio_dev_rx_queue_setup(struct rte_eth_dev *dev,
        rxvq = &vq->rxq;
        rxvq->queue_id = queue_idx;
        rxvq->mpool = mp;
-       if (rxvq->mpool == NULL) {
-               rte_exit(EXIT_FAILURE,
-                       "Cannot allocate mbufs for rx virtqueue");
-       }
-
        dev->data->rx_queues[queue_idx] = rxvq;
 
        return 0;
@@ -1114,8 +1110,8 @@ virtio_update_packet_stats(struct virtnet_stats *stats, struct rte_mbuf *mbuf)
        }
 
        ea = rte_pktmbuf_mtod(mbuf, struct rte_ether_addr *);
-       if (is_multicast_ether_addr(ea)) {
-               if (is_broadcast_ether_addr(ea))
+       if (rte_is_multicast_ether_addr(ea)) {
+               if (rte_is_broadcast_ether_addr(ea))
                        stats->broadcast++;
                else
                        stats->multicast++;
@@ -1244,7 +1240,7 @@ virtio_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
 
                PMD_RX_LOG(DEBUG, "packet len:%d", len[i]);
 
-               if (unlikely(len[i] < hdr_size + ETHER_HDR_LEN)) {
+               if (unlikely(len[i] < hdr_size + RTE_ETHER_HDR_LEN)) {
                        PMD_RX_LOG(ERR, "Packet drop");
                        nb_enqueued++;
                        virtio_discard_rxbuf(vq, rxm);
@@ -1347,7 +1343,7 @@ virtio_recv_pkts_packed(void *rx_queue, struct rte_mbuf **rx_pkts,
 
                PMD_RX_LOG(DEBUG, "packet len:%d", len[i]);
 
-               if (unlikely(len[i] < hdr_size + ETHER_HDR_LEN)) {
+               if (unlikely(len[i] < hdr_size + RTE_ETHER_HDR_LEN)) {
                        PMD_RX_LOG(ERR, "Packet drop");
                        nb_enqueued++;
                        virtio_discard_rxbuf(vq, rxm);
@@ -1423,7 +1419,7 @@ virtio_recv_pkts_inorder(void *rx_queue,
        struct virtqueue *vq = rxvq->vq;
        struct virtio_hw *hw = vq->hw;
        struct rte_mbuf *rxm;
-       struct rte_mbuf *prev;
+       struct rte_mbuf *prev = NULL;
        uint16_t nb_used, num, nb_rx;
        uint32_t len[VIRTIO_MBUF_BURST_SZ];
        struct rte_mbuf *rcv_pkts[VIRTIO_MBUF_BURST_SZ];
@@ -1461,7 +1457,7 @@ virtio_recv_pkts_inorder(void *rx_queue,
 
                rxm = rcv_pkts[i];
 
-               if (unlikely(len[i] < hdr_size + ETHER_HDR_LEN)) {
+               if (unlikely(len[i] < hdr_size + RTE_ETHER_HDR_LEN)) {
                        PMD_RX_LOG(ERR, "Packet drop");
                        nb_enqueued++;
                        virtio_discard_rxbuf_inorder(vq, rxm);
@@ -1515,7 +1511,6 @@ virtio_recv_pkts_inorder(void *rx_queue,
                        rxm->data_len = (uint16_t)(len[i]);
 
                        rx_pkts[nb_rx]->pkt_len += (uint32_t)(len[i]);
-                       rx_pkts[nb_rx]->data_len += (uint16_t)(len[i]);
 
                        if (prev)
                                prev->next = rxm;
@@ -1535,7 +1530,6 @@ virtio_recv_pkts_inorder(void *rx_queue,
                uint16_t rcv_cnt = RTE_MIN((uint16_t)seg_res,
                                        VIRTIO_MBUF_BURST_SZ);
 
-               prev = rcv_pkts[nb_rx];
                if (likely(VIRTQUEUE_NUSED(vq) >= rcv_cnt)) {
                        virtio_rmb(hw->weak_barriers);
                        num = virtqueue_dequeue_rx_inorder(vq, rcv_pkts, len,
@@ -1552,7 +1546,6 @@ virtio_recv_pkts_inorder(void *rx_queue,
                                prev->next = rxm;
                                prev = rxm;
                                rx_pkts[nb_rx]->pkt_len += len[extra_idx];
-                               rx_pkts[nb_rx]->data_len += len[extra_idx];
                                extra_idx += 1;
                        };
                        seg_res -= rcv_cnt;
@@ -1615,7 +1608,7 @@ virtio_recv_mergeable_pkts(void *rx_queue,
        struct virtqueue *vq = rxvq->vq;
        struct virtio_hw *hw = vq->hw;
        struct rte_mbuf *rxm;
-       struct rte_mbuf *prev;
+       struct rte_mbuf *prev = NULL;
        uint16_t nb_used, num, nb_rx = 0;
        uint32_t len[VIRTIO_MBUF_BURST_SZ];
        struct rte_mbuf *rcv_pkts[VIRTIO_MBUF_BURST_SZ];
@@ -1653,7 +1646,7 @@ virtio_recv_mergeable_pkts(void *rx_queue,
 
                rxm = rcv_pkts[i];
 
-               if (unlikely(len[i] < hdr_size + ETHER_HDR_LEN)) {
+               if (unlikely(len[i] < hdr_size + RTE_ETHER_HDR_LEN)) {
                        PMD_RX_LOG(ERR, "Packet drop");
                        nb_enqueued++;
                        virtio_discard_rxbuf(vq, rxm);
@@ -1702,7 +1695,6 @@ virtio_recv_mergeable_pkts(void *rx_queue,
                        rxm->data_len = (uint16_t)(len[i]);
 
                        rx_pkts[nb_rx]->pkt_len += (uint32_t)(len[i]);
-                       rx_pkts[nb_rx]->data_len += (uint16_t)(len[i]);
 
                        if (prev)
                                prev->next = rxm;
@@ -1722,7 +1714,6 @@ virtio_recv_mergeable_pkts(void *rx_queue,
                uint16_t rcv_cnt = RTE_MIN((uint16_t)seg_res,
                                        VIRTIO_MBUF_BURST_SZ);
 
-               prev = rcv_pkts[nb_rx];
                if (likely(VIRTQUEUE_NUSED(vq) >= rcv_cnt)) {
                        virtio_rmb(hw->weak_barriers);
                        num = virtqueue_dequeue_burst_rx(vq, rcv_pkts, len,
@@ -1739,7 +1730,6 @@ virtio_recv_mergeable_pkts(void *rx_queue,
                                prev->next = rxm;
                                prev = rxm;
                                rx_pkts[nb_rx]->pkt_len += len[extra_idx];
-                               rx_pkts[nb_rx]->data_len += len[extra_idx];
                                extra_idx += 1;
                        };
                        seg_res -= rcv_cnt;
@@ -1832,7 +1822,7 @@ virtio_recv_mergeable_pkts_packed(void *rx_queue,
 
                rxm = rcv_pkts[i];
 
-               if (unlikely(len[i] < hdr_size + ETHER_HDR_LEN)) {
+               if (unlikely(len[i] < hdr_size + RTE_ETHER_HDR_LEN)) {
                        PMD_RX_LOG(ERR, "Packet drop");
                        nb_enqueued++;
                        virtio_discard_rxbuf(vq, rxm);