virtio-net: enable IPv6 checksum and TSO offload

The virtio-net offload paths were hardcoded to ETHERTYPE_IP: the TX path only
built VIRTIO_NET_HDR_GSO_TCPV4 and the RX checksum path rejected everything but
IPv4 (with a literal "How come - no support for IPv6?!" comment). As a result
IPv6 traffic computed checksums in software and never used TCP segmentation
offload, so high-throughput IPv6 sends/receives burned more CPU than IPv4 even
though the stack (tcp_output) already emits CSUM_TCP_IPV6.

This teaches the driver about IPv6:
- negotiate VIRTIO_NET_F_HOST_TSO6 / VIRTIO_NET_F_GUEST_TSO6
- advertise IFCAP_TSO6 and CSUM_TCP_IPV6 | CSUM_UDP_IPV6 in if_hwassist/caps
- TX: add an ETHERTYPE_IPV6 case that sets csum_start past the 40-byte base
  header and gso_type = VIRTIO_NET_HDR_GSO_TCPV6 (packets with extension
  headers have ip6_nxt != TCP/UDP and fall back to software checksums)
- RX: accept ETHERTYPE_IPV6 in the checksum-offload path (the TCP/UDP checksum
  offset logic is identical for v4 and v6)
- use large receive buffers when GUEST_TSO6 is negotiated too

Boot-tested with IPv6 SLAAC over virtio-net: loopback + concurrent dual-stack
TCP pass and a global address is configured through the modified TX/RX paths.

Author: gburd

drivers/virtio-net.cc

@@ -36,6 +36,7 @@
 #include <bsd/sys/net/if_vlan_var.h>
 #include <bsd/sys/netinet/in.h>
 #include <bsd/sys/netinet/ip.h>
+#include <bsd/sys/netinet/ip6.h>
 #include <bsd/sys/netinet/udp.h>
 #include <bsd/sys/netinet/tcp.h>
 
@@ -283,15 +284,22 @@ net::net(virtio_device& dev)
 
     if (_csum) {
         _ifn->if_capabilities |= IFCAP_TXCSUM;
+        // Advertise IPv6 checksum offload alongside IPv4; tcp_output already
+        // sets CSUM_TCP_IPV6 for v6 segments.
+        _ifn->if_hwassist = CSUM_TCP | CSUM_UDP | CSUM_TCP_IPV6 | CSUM_UDP_IPV6;
         if (_host_tso4) {
             _ifn->if_capabilities |= IFCAP_TSO4;
-            _ifn->if_hwassist = CSUM_TCP | CSUM_UDP | CSUM_TSO;
+            _ifn->if_hwassist |= CSUM_TSO;
+        }
+        if (_host_tso6) {
+            _ifn->if_capabilities |= IFCAP_TSO6;
+            _ifn->if_hwassist |= CSUM_TSO;
         }
     }
 
     if (_guest_csum) {
         _ifn->if_capabilities |= IFCAP_RXCSUM;
-        if (_guest_tso4)
+        if (_guest_tso4 || _guest_tso6)
             _ifn->if_capabilities |= IFCAP_LRO;
     }
 
@@ -382,18 +390,21 @@ void net::read_config()
     _guest_csum = get_guest_feature_bit(VIRTIO_NET_F_GUEST_CSUM);
     _guest_tso4 = get_guest_feature_bit(VIRTIO_NET_F_GUEST_TSO4);
     _host_tso4 = get_guest_feature_bit(VIRTIO_NET_F_HOST_TSO4);
+    _guest_tso6 = get_guest_feature_bit(VIRTIO_NET_F_GUEST_TSO6);
+    _host_tso6 = get_guest_feature_bit(VIRTIO_NET_F_HOST_TSO6);
     _guest_ufo = get_guest_feature_bit(VIRTIO_NET_F_GUEST_UFO);
 
     net_i("Features: %s=%d,%s=%d", "Status", _status, "TSO_ECN", _tso_ecn);
     net_i("Features: %s=%d,%s=%d", "Host TSO ECN", _host_tso_ecn, "CSUM", _csum);
     net_i("Features: %s=%d,%s=%d", "Guest_csum", _guest_csum, "guest tso4", _guest_tso4);
     net_i("Features: %s=%d,%s=%d", "host tso4", _host_tso4, "MRG_RX_BUF", _mergeable_bufs);
+    net_i("Features: %s=%d,%s=%d", "guest tso6", _guest_tso6, "host tso6", _host_tso6);
 
-    // If VIRTIO_NET_F_MRG_RXBUF is not negotiated and VIRTIO_NET_F_GUEST_TSO4
+    // If VIRTIO_NET_F_MRG_RXBUF is not negotiated and VIRTIO_NET_F_GUEST_TSO4/6
     // or VIRTIO_NET_F_GUEST_UFO are, the VirtIO spec mandates the guest to use
     // large receive buffers
     // For details please see "5.1.6.3.1 Driver Requirements: Setting Up Receive Buffers" in VirtIO spec
-    if (!_mergeable_bufs && (_guest_tso4 || _guest_ufo)) {
+    if (!_mergeable_bufs && (_guest_tso4 || _guest_tso6 || _guest_ufo)) {
         net_i("Set up to use large receive buffers");
         _use_large_buffers = true;
     }
@@ -431,8 +442,9 @@ bool net::bad_rx_csum(struct mbuf* m, struct net_hdr* hdr)
         eth_type = ntohs(evh->evl_proto);
     }
 
-    // How come - no support for IPv6?!
-    if (eth_type != ETHERTYPE_IP) {
+    // The checksum handling below keys off csum_offset (the TCP/UDP checksum
+    // position), which is the same for IPv4 and IPv6, so both are accepted.
+    if (eth_type != ETHERTYPE_IP && eth_type != ETHERTYPE_IPV6) {
         return true;
     }
 
@@ -829,6 +841,23 @@ mbuf* net::txq::offload(mbuf* m, net_hdr* hdr)
         gso_type = net::net_hdr::VIRTIO_NET_HDR_GSO_TCPV4;
         break;
 
+    case ETHERTYPE_IPV6: {
+        if (m->m_hdr.mh_len < ip_offset + (int)sizeof(struct ip6_hdr)) {
+            m = m_pullup(m, ip_offset + sizeof(struct ip6_hdr));
+            if (m == nullptr)
+                return nullptr;
+        }
+
+        struct ip6_hdr* ip6 = (struct ip6_hdr*)(mtod(m, uint8_t*) + ip_offset);
+        ip_proto = ip6->ip6_nxt;
+        // Offload only handles the common no-extension-header case; a packet
+        // with extension headers has ip6_nxt != TCP/UDP and falls through to
+        // the software checksum path below (csum_flags are then ignored).
+        csum_start = ip_offset + sizeof(struct ip6_hdr);
+        gso_type = net::net_hdr::VIRTIO_NET_HDR_GSO_TCPV6;
+        break;
+    }
+
     default:
         return m;
     }
@@ -914,8 +943,10 @@ u64 net::get_driver_features()
                  | (1 << VIRTIO_NET_F_CSUM)       \
                  | (1 << VIRTIO_NET_F_GUEST_CSUM) \
                  | (1 << VIRTIO_NET_F_GUEST_TSO4) \
+                 | (1 << VIRTIO_NET_F_GUEST_TSO6) \
                  | (1 << VIRTIO_NET_F_HOST_ECN)   \
                  | (1 << VIRTIO_NET_F_HOST_TSO4)  \
+                 | (1 << VIRTIO_NET_F_HOST_TSO6)  \
                  | (1 << VIRTIO_NET_F_GUEST_ECN)
                  | (1 << VIRTIO_NET_F_GUEST_UFO)
             );

drivers/virtio-net.hh

@@ -273,6 +273,8 @@ private:
     bool _guest_csum = false;
     bool _guest_tso4 = false;
     bool _host_tso4 = false;
+    bool _guest_tso6 = false;
+    bool _host_tso6 = false;
     bool _guest_ufo = false;
     bool _use_large_buffers = false;