[PATCH RFC net 3/3] net: test stacked VLAN headers before TX offloads

[Gabriel Goller <g.goller@proxmox.com>]

Cover the QinQ regression without requiring an igb NIC, so incorrect L3
header offsets are caught before they reach hardware offload processing.

The IPv4 and IPv6 cases fail without the TX header fix and pass with it.
All 22 enabled net_core KUnit cases pass in QEMU. This does not validate
segmentation on physical hardware.

Signed-off-by: Gabriel Goller <g.goller@proxmox.com>
---
 net/core/net_test.c | 145 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 145 insertions(+)

diff --git a/net/core/net_test.c b/net/core/net_test.c
index 2b5080c22663..73a795f1443e 100644
--- a/net/core/net_test.c
+++ b/net/core/net_test.c
@@ -1721,7 +1721,152 @@ static void netmem_ref_test_tcp_devmem_recv(struct kunit *test)
 #endif
 #endif
 
+/* VLAN TX offloads need the L3 header, not the inner VLAN header. */
+
+#include <linux/if_vlan.h>
+#include <linux/etherdevice.h>
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/tcp.h>
+#include <net/flow_dissector.h>
+
+static void vlan_test_free_skb(void *ptr)
+{
+	kfree_skb(ptr);
+}
+
+static void vlan_test_free_netdev(void *ptr)
+{
+	free_netdev(ptr);
+}
+
+static netdev_features_t vlan_test_features_check(struct sk_buff *skb,
+						  struct net_device *dev,
+						  netdev_features_t features)
+{
+	struct kunit *test = *(struct kunit **)netdev_priv(dev);
+	unsigned int ip_len = vlan_get_protocol(skb) == htons(ETH_P_IP) ?
+			      sizeof(struct iphdr) : sizeof(struct ipv6hdr);
+
+	KUNIT_EXPECT_EQ(test, skb_network_offset(skb),
+			skb_transport_offset(skb) - ip_len);
+
+	/* Like igb, allow hardware TSO with multiple VLAN tags. */
+	return features;
+}
+
+static const struct net_device_ops vlan_test_netdev_ops = {
+	.ndo_features_check = vlan_test_features_check,
+};
+
+static void vlan_xmit_test(struct kunit *test)
+{
+	const __be16 *proto = test->param_value;
+	unsigned int ip_len = *proto == htons(ETH_P_IP) ?
+			      sizeof(struct iphdr) : sizeof(struct ipv6hdr);
+	unsigned int len = ETH_HLEN + ip_len + sizeof(struct tcphdr) + 2880;
+	struct net_device *dev;
+	struct flow_keys keys;
+	struct sk_buff *skb, *xmit;
+	unsigned int nhoff;
+	bool again = false;
+	int i;
+
+	dev = alloc_netdev(sizeof(test), "vlan_test%d", NET_NAME_UNKNOWN,
+			   ether_setup);
+	KUNIT_ASSERT_NOT_NULL(test, dev);
+	KUNIT_ASSERT_EQ(test,
+			kunit_add_action_or_reset(test, vlan_test_free_netdev, dev),
+			0);
+	dev->netdev_ops = &vlan_test_netdev_ops;
+	*(struct kunit **)netdev_priv(dev) = test;
+	dev->features = NETIF_F_HW_CSUM | NETIF_F_SG | NETIF_F_TSO |
+			NETIF_F_TSO6 | NETIF_F_HW_VLAN_CTAG_TX;
+	dev->vlan_features = dev->features;
+
+	skb = alloc_skb(len, GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, skb);
+	KUNIT_ASSERT_EQ(test,
+			kunit_add_action_or_reset(test, vlan_test_free_skb, skb),
+			0);
+	skb_put_zero(skb, len);
+	skb_reset_mac_header(skb);
+	skb_set_network_header(skb, ETH_HLEN);
+	skb_set_transport_header(skb, ETH_HLEN + ip_len);
+	skb_reset_mac_len(skb);
+	skb->protocol = *proto;
+	skb->dev = dev;
+	eth_hdr(skb)->h_proto = *proto;
+	if (*proto == htons(ETH_P_IP)) {
+		ip_hdr(skb)->version = 4;
+		ip_hdr(skb)->ihl = 5;
+		ip_hdr(skb)->protocol = IPPROTO_TCP;
+		ip_hdr(skb)->tot_len = htons(len - ETH_HLEN);
+	} else {
+		ipv6_hdr(skb)->version = 6;
+		ipv6_hdr(skb)->nexthdr = IPPROTO_TCP;
+		ipv6_hdr(skb)->payload_len = htons(len - ETH_HLEN - ip_len);
+	}
+	tcp_hdr(skb)->source = htons(1234);
+	tcp_hdr(skb)->dest = htons(4321);
+	tcp_hdr(skb)->doff = sizeof(struct tcphdr) / 4;
+	skb->ip_summed = CHECKSUM_PARTIAL;
+	skb->csum_start = skb->transport_header;
+	skb->csum_offset = offsetof(struct tcphdr, check);
+	skb_shinfo(skb)->gso_size = 1440;
+	skb_shinfo(skb)->gso_segs = 2;
+	skb_shinfo(skb)->gso_type = *proto == htons(ETH_P_IP) ?
+				  SKB_GSO_TCPV4 : SKB_GSO_TCPV6;
+
+	for (i = 0; i < 3; i++) {
+		KUNIT_ASSERT_EQ(test,
+				skb_vlan_push(skb, htons(ETH_P_8021Q), 200 + i),
+				0);
+		skb_reset_mac_len(skb);
+		/* Classification after a push must still see all VLAN tags. */
+		memset(&keys, 0, sizeof(keys));
+		KUNIT_EXPECT_TRUE(test,
+				  __skb_flow_dissect(&init_net, skb,
+						     &flow_keys_dissector, &keys,
+						     NULL, 0, 0, 0, 0));
+		KUNIT_EXPECT_EQ(test, keys.basic.n_proto, *proto);
+		KUNIT_EXPECT_EQ(test, keys.basic.ip_proto, IPPROTO_TCP);
+		KUNIT_EXPECT_EQ(test, keys.ports.src, htons(1234));
+		KUNIT_EXPECT_EQ(test, keys.ports.dst, htons(4321));
+		KUNIT_EXPECT_EQ(test, (u16)keys.vlan.vlan_id, 200 + i);
+
+		xmit = skb_clone(skb, GFP_KERNEL);
+		KUNIT_ASSERT_NOT_NULL(test, xmit);
+		xmit = validate_xmit_skb_list(xmit, dev, &again);
+		KUNIT_ASSERT_NOT_ERR_OR_NULL(test, xmit);
+		nhoff = ETH_HLEN + i * VLAN_HLEN;
+		KUNIT_EXPECT_EQ(test, skb_network_offset(xmit), nhoff);
+		KUNIT_EXPECT_EQ(test, skb_transport_offset(xmit), nhoff + ip_len);
+		KUNIT_EXPECT_EQ(test, skb_checksum_start_offset(xmit),
+				nhoff + ip_len);
+		KUNIT_EXPECT_EQ(test, (u8)ip_hdr(xmit)->version,
+				*proto == htons(ETH_P_IP) ? 4 : 6);
+		KUNIT_EXPECT_TRUE(test, skb_is_gso(xmit));
+		KUNIT_EXPECT_PTR_EQ(test, xmit->next, NULL);
+		kfree_skb_list(xmit);
+	}
+}
+
+static const __be16 vlan_test_protos[] = {
+	htons(ETH_P_IP),
+	htons(ETH_P_IPV6),
+};
+
+static void vlan_test_desc(const __be16 *proto, char *desc)
+{
+	snprintf(desc, KUNIT_PARAM_DESC_SIZE, "%s",
+		 *proto == htons(ETH_P_IP) ? "IPv4" : "IPv6");
+}
+
+KUNIT_ARRAY_PARAM(vlan, vlan_test_protos, vlan_test_desc);
+
 static struct kunit_case net_test_cases[] = {
+	KUNIT_CASE_PARAM(vlan_xmit_test, vlan_gen_params),
 	KUNIT_CASE_PARAM(gso_test_func, gso_test_gen_params),
 	KUNIT_CASE_PARAM(ip_tunnel_flags_test_run,
 			 ip_tunnel_flags_test_gen_params),

-- 
2.47.3