net/virtio: support Rx checksum offload

Signed-off-by: Olivier Matz <olivier.matz@6wind.com>
Acked-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>

diff --git a/doc/guides/rel_notes/release_16_11.rst b/doc/guides/rel_notes/release_16_11.rst
index 660c3fc..4805a1f 100644 (file)
--- a/doc/guides/rel_notes/release_16_11.rst
+++ b/doc/guides/rel_notes/release_16_11.rst
@@ -83,6 +83,10 @@ New Features
 
   Added extended statistics to vhost PMD from per port perspective.
 
+* **Supported offloads with virtio.**
+
+  * Rx checksums
+
 * **Added virtio NEON support for ARM.**
 
 * **Updated the ixgbe base driver.**

diff --git a/drivers/net/virtio/virtio_ethdev.c b/drivers/net/virtio/virtio_ethdev.c
index 7048f84..6dff6e9 100644 (file)
--- a/drivers/net/virtio/virtio_ethdev.c
+++ b/drivers/net/virtio/virtio_ethdev.c
@@ -1280,7 +1280,7 @@ eth_virtio_dev_init(struct rte_eth_dev *eth_dev)
        eth_dev->data->dev_flags = dev_flags;
 
        /* reset device and negotiate default features */
-       ret = virtio_init_device(eth_dev, VIRTIO_PMD_GUEST_FEATURES);
+       ret = virtio_init_device(eth_dev, VIRTIO_PMD_DEFAULT_GUEST_FEATURES);
        if (ret < 0)
                return ret;
 
@@ -1366,13 +1366,10 @@ virtio_dev_configure(struct rte_eth_dev *dev)
        int ret;
 
        PMD_INIT_LOG(DEBUG, "configure");
+       req_features = VIRTIO_PMD_DEFAULT_GUEST_FEATURES;
+       if (rxmode->hw_ip_checksum)
+               req_features |= (1ULL << VIRTIO_NET_F_GUEST_CSUM);
 
-       if (rxmode->hw_ip_checksum) {
-               PMD_DRV_LOG(ERR, "HW IP checksum not supported");
-               return -EINVAL;
-       }
-
-       req_features = VIRTIO_PMD_GUEST_FEATURES;
        /* if request features changed, reinit the device */
        if (req_features != hw->req_guest_features) {
                ret = virtio_init_device(dev, req_features);
@@ -1380,6 +1377,13 @@ virtio_dev_configure(struct rte_eth_dev *dev)
                        return ret;
        }
 
+       if (rxmode->hw_ip_checksum &&
+               !vtpci_with_feature(hw, VIRTIO_NET_F_GUEST_CSUM)) {
+               PMD_DRV_LOG(NOTICE,
+                       "rx ip checksum not available on this host");
+               return -ENOTSUP;
+       }
+
        /* Setup and start control queue */
        if (vtpci_with_feature(hw, VIRTIO_NET_F_CTRL_VQ)) {
                ret = virtio_dev_cq_queue_setup(dev,
@@ -1593,6 +1597,9 @@ virtio_dev_info_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
        dev_info->default_txconf = (struct rte_eth_txconf) {
                .txq_flags = ETH_TXQ_FLAGS_NOOFFLOADS
        };
+       dev_info->rx_offload_capa =
+               DEV_RX_OFFLOAD_TCP_CKSUM |
+               DEV_RX_OFFLOAD_UDP_CKSUM;
 }
 
 /*

diff --git a/drivers/net/virtio/virtio_ethdev.h b/drivers/net/virtio/virtio_ethdev.h
index 2fd28ea..7043a68 100644 (file)
--- a/drivers/net/virtio/virtio_ethdev.h
+++ b/drivers/net/virtio/virtio_ethdev.h
@@ -54,7 +54,7 @@
 #define VIRTIO_MAX_RX_PKTLEN  9728
 
 /* Features desired/implemented by this driver. */
-#define VIRTIO_PMD_GUEST_FEATURES              \
+#define VIRTIO_PMD_DEFAULT_GUEST_FEATURES      \
        (1u << VIRTIO_NET_F_MAC           |     \
         1u << VIRTIO_NET_F_STATUS        |     \
         1u << VIRTIO_NET_F_MQ            |     \

diff --git a/drivers/net/virtio/virtio_rxtx.c b/drivers/net/virtio/virtio_rxtx.c
index 9ab441b..fc0d84b 100644 (file)
--- a/drivers/net/virtio/virtio_rxtx.c
+++ b/drivers/net/virtio/virtio_rxtx.c
@@ -51,6 +51,8 @@
 #include <rte_errno.h>
 #include <rte_byteorder.h>
 #include <rte_cpuflags.h>
+#include <rte_net.h>
+#include <rte_ip.h>
 
 #include "virtio_logs.h"
 #include "virtio_ethdev.h"
@@ -632,6 +634,63 @@ virtio_update_packet_stats(struct virtnet_stats *stats, struct rte_mbuf *mbuf)
        }
 }
 
+/* Optionally fill offload information in structure */
+static int
+virtio_rx_offload(struct rte_mbuf *m, struct virtio_net_hdr *hdr)
+{
+       struct rte_net_hdr_lens hdr_lens;
+       uint32_t hdrlen, ptype;
+       int l4_supported = 0;
+
+       /* nothing to do */
+       if (hdr->flags == 0 && hdr->gso_type == VIRTIO_NET_HDR_GSO_NONE)
+               return 0;
+
+       m->ol_flags |= PKT_RX_IP_CKSUM_UNKNOWN;
+
+       ptype = rte_net_get_ptype(m, &hdr_lens, RTE_PTYPE_ALL_MASK);
+       m->packet_type = ptype;
+       if ((ptype & RTE_PTYPE_L4_MASK) == RTE_PTYPE_L4_TCP ||
+           (ptype & RTE_PTYPE_L4_MASK) == RTE_PTYPE_L4_UDP ||
+           (ptype & RTE_PTYPE_L4_MASK) == RTE_PTYPE_L4_SCTP)
+               l4_supported = 1;
+
+       if (hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
+               hdrlen = hdr_lens.l2_len + hdr_lens.l3_len + hdr_lens.l4_len;
+               if (hdr->csum_start <= hdrlen && l4_supported) {
+                       m->ol_flags |= PKT_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
+                        * buffers we provided to the host are large enough.
+                        * In case of SCTP, this will be wrong since it's a CRC
+                        * but there's nothing we can do.
+                        */
+                       uint16_t csum, off;
+
+                       rte_raw_cksum_mbuf(m, hdr->csum_start,
+                               rte_pktmbuf_pkt_len(m) - hdr->csum_start,
+                               &csum);
+                       if (likely(csum != 0xffff))
+                               csum = ~csum;
+                       off = hdr->csum_offset + hdr->csum_start;
+                       if (rte_pktmbuf_data_len(m) >= off + 1)
+                               *rte_pktmbuf_mtod_offset(m, uint16_t *,
+                                       off) = csum;
+               }
+       } else if (hdr->flags & VIRTIO_NET_HDR_F_DATA_VALID && l4_supported) {
+               m->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
+       }
+
+       return 0;
+}
+
+static inline int
+rx_offload_enabled(struct virtio_hw *hw)
+{
+       return vtpci_with_feature(hw, VIRTIO_NET_F_GUEST_CSUM);
+}
+
 #define VIRTIO_MBUF_BURST_SZ 64
 #define DESC_PER_CACHELINE (RTE_CACHE_LINE_SIZE / sizeof(struct vring_desc))
 uint16_t
@@ -647,6 +706,8 @@ virtio_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
        int error;
        uint32_t i, nb_enqueued;
        uint32_t hdr_size;
+       int offload;
+       struct virtio_net_hdr *hdr;
 
        nb_used = VIRTQUEUE_NUSED(vq);
 
@@ -664,6 +725,7 @@ virtio_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
        nb_rx = 0;
        nb_enqueued = 0;
        hdr_size = hw->vtnet_hdr_size;
+       offload = rx_offload_enabled(hw);
 
        for (i = 0; i < num ; i++) {
                rxm = rcv_pkts[i];
@@ -688,9 +750,18 @@ virtio_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
                rxm->pkt_len = (uint32_t)(len[i] - hdr_size);
                rxm->data_len = (uint16_t)(len[i] - hdr_size);
 
+               hdr = (struct virtio_net_hdr *)((char *)rxm->buf_addr +
+                       RTE_PKTMBUF_HEADROOM - hdr_size);
+
                if (hw->vlan_strip)
                        rte_vlan_strip(rxm);
 
+               if (offload && virtio_rx_offload(rxm, hdr) < 0) {
+                       virtio_discard_rxbuf(vq, rxm);
+                       rxvq->stats.errors++;
+                       continue;
+               }
+
                VIRTIO_DUMP_PACKET(rxm, rxm->data_len);
 
                rx_pkts[nb_rx++] = rxm;
@@ -750,6 +821,7 @@ virtio_recv_mergeable_pkts(void *rx_queue,
        uint16_t extra_idx;
        uint32_t seg_res;
        uint32_t hdr_size;
+       int offload;
 
        nb_used = VIRTQUEUE_NUSED(vq);
 
@@ -765,6 +837,7 @@ virtio_recv_mergeable_pkts(void *rx_queue,
        extra_idx = 0;
        seg_res = 0;
        hdr_size = hw->vtnet_hdr_size;
+       offload = rx_offload_enabled(hw);
 
        while (i < nb_used) {
                struct virtio_net_hdr_mrg_rxbuf *header;
@@ -810,6 +883,12 @@ virtio_recv_mergeable_pkts(void *rx_queue,
                rx_pkts[nb_rx] = rxm;
                prev = rxm;
 
+               if (offload && virtio_rx_offload(rxm, &header->hdr) < 0) {
+                       virtio_discard_rxbuf(vq, rxm);
+                       rxvq->stats.errors++;
+                       continue;
+               }
+
                seg_res = seg_num - 1;
 
                while (seg_res != 0) {

diff --git a/drivers/net/virtio/virtqueue.h b/drivers/net/virtio/virtqueue.h
index 6737b81..ef0027b 100644 (file)
--- a/drivers/net/virtio/virtqueue.h
+++ b/drivers/net/virtio/virtqueue.h
@@ -223,6 +223,7 @@ struct virtqueue {
  */
 struct virtio_net_hdr {
 #define VIRTIO_NET_HDR_F_NEEDS_CSUM 1    /**< Use csum_start,csum_offset*/
+#define VIRTIO_NET_HDR_F_DATA_VALID 2    /**< Checksum is valid */
        uint8_t flags;
 #define VIRTIO_NET_HDR_GSO_NONE     0    /**< Not a GSO frame */
 #define VIRTIO_NET_HDR_GSO_TCPV4    1    /**< GSO frame, IPv4 TCP (TSO) */