virtio-net: use mtu size as buffer length for big packets

Currently add_recvbuf_big() allocates MAX_SKB_FRAGS segments for big
packets even when GUEST_* offloads are not present on the device.
However, if guest GSO is not supported, it would be sufficient to
allocate segments to cover just up the MTU size and no further.
Allocating the maximum amount of segments results in a large waste of
buffer space in the queue, which limits the number of packets that can
be buffered and can result in reduced performance.

Therefore, if guest GSO is not supported, use the MTU to calculate the
optimal amount of segments required.

Below is the iperf TCP test results over a Mellanox NIC, using vDPA for
1 VQ, queue size 1024, before and after the change, with the iperf
server running over the virtio-net interface.

MTU(Bytes)/Bandwidth (Gbit/s)
             Before   After
  1500        22.5     22.4
  9000        12.8     25.9

And result of queue size 256.
MTU(Bytes)/Bandwidth (Gbit/s)
             Before   After
  9000        2.15     11.9

With this patch no degradation is observed with multiple below tests and
feature bit combinations. Results are summarized below for q depth of
1024. Interface MTU is 1500 if MTU feature is disabled. MTU is set to 9000
in other tests.

Features/              Bandwidth (Gbit/s)
                         Before   After
mtu off                   20.1     20.2
mtu/indirect on           17.4     17.3
mtu/indirect/packed on    17.2     17.2

Signed-off-by: Gavin Li <gavinl@nvidia.com>
Reviewed-by: Gavi Teitz <gavi@nvidia.com>
Reviewed-by: Parav Pandit <parav@nvidia.com>
Reviewed-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Reviewed-by: Si-Wei Liu <si-wei.liu@oracle.com>
Message-Id: <20220914144911.56422-3-gavinl@nvidia.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Acked-by: Jason Wang <jasowang@redhat.com>

diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index f831a0290998814bc873795032b0926318e78086..a8fa690b11952497ab4b1847135fcfc54d3e6b2b 100644 (file)
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -225,6 +225,9 @@ struct virtnet_info {
        /* I like... big packets and I cannot lie! */
        bool big_packets;
 
+       /* number of sg entries allocated for big packets */
+       unsigned int big_packets_num_skbfrags;
+
        /* Host will merge rx buffers for big packets (shake it! shake it!) */
        bool mergeable_rx_bufs;
 
@@ -1331,10 +1334,10 @@ static int add_recvbuf_big(struct virtnet_info *vi, struct receive_queue *rq,
        char *p;
        int i, err, offset;
 
-       sg_init_table(rq->sg, MAX_SKB_FRAGS + 2);
+       sg_init_table(rq->sg, vi->big_packets_num_skbfrags + 2);
 
-       /* page in rq->sg[MAX_SKB_FRAGS + 1] is list tail */
-       for (i = MAX_SKB_FRAGS + 1; i > 1; --i) {
+       /* page in rq->sg[vi->big_packets_num_skbfrags + 1] is list tail */
+       for (i = vi->big_packets_num_skbfrags + 1; i > 1; --i) {
                first = get_a_page(rq, gfp);
                if (!first) {
                        if (list)
@@ -1365,7 +1368,7 @@ static int add_recvbuf_big(struct virtnet_info *vi, struct receive_queue *rq,
 
        /* chain first in list head */
        first->private = (unsigned long)list;
-       err = virtqueue_add_inbuf(rq->vq, rq->sg, MAX_SKB_FRAGS + 2,
+       err = virtqueue_add_inbuf(rq->vq, rq->sg, vi->big_packets_num_skbfrags + 2,
                                  first, gfp);
        if (err < 0)
                give_pages(rq, first);
@@ -3690,13 +3693,27 @@ static bool virtnet_check_guest_gso(const struct virtnet_info *vi)
                virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_UFO);
 }
 
+static void virtnet_set_big_packets(struct virtnet_info *vi, const int mtu)
+{
+       bool guest_gso = virtnet_check_guest_gso(vi);
+
+       /* If device can receive ANY guest GSO packets, regardless of mtu,
+        * allocate packets of maximum size, otherwise limit it to only
+        * mtu size worth only.
+        */
+       if (mtu > ETH_DATA_LEN || guest_gso) {
+               vi->big_packets = true;
+               vi->big_packets_num_skbfrags = guest_gso ? MAX_SKB_FRAGS : DIV_ROUND_UP(mtu, PAGE_SIZE);
+       }
+}
+
 static int virtnet_probe(struct virtio_device *vdev)
 {
        int i, err = -ENOMEM;
        struct net_device *dev;
        struct virtnet_info *vi;
        u16 max_queue_pairs;
-       int mtu;
+       int mtu = 0;
 
        /* Find if host supports multiqueue/rss virtio_net device */
        max_queue_pairs = 1;
@@ -3784,10 +3801,6 @@ static int virtnet_probe(struct virtio_device *vdev)
        INIT_WORK(&vi->config_work, virtnet_config_changed_work);
        spin_lock_init(&vi->refill_lock);
 
-       /* If we can receive ANY GSO packets, we must allocate large ones. */
-       if (virtnet_check_guest_gso(vi))
-               vi->big_packets = true;
-
        if (virtio_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF))
                vi->mergeable_rx_bufs = true;
 
@@ -3853,12 +3866,10 @@ static int virtnet_probe(struct virtio_device *vdev)
 
                dev->mtu = mtu;
                dev->max_mtu = mtu;
-
-               /* TODO: size buffers correctly in this case. */
-               if (dev->mtu > ETH_DATA_LEN)
-                       vi->big_packets = true;
        }
 
+       virtnet_set_big_packets(vi, mtu);
+
        if (vi->any_header_sg)
                dev->needed_headroom = vi->hdr_len;