net: add skb_segment kunit test

Add unit testing for skb segment. This function is exercised by many
different code paths, such as GSO_PARTIAL or GSO_BY_FRAGS, linear
(with or without head_frag), frags or frag_list skbs, etc.

It is infeasible to manually run tests that cover all code paths when
making changes. The long and complex function also makes it hard to
establish through analysis alone that a patch has no unintended
side-effects.

Add code coverage through kunit regression testing. Introduce kunit
infrastructure for tests under net/core, and add this first test.

This first skb_segment test exercises a simple case: a linear skb.
Follow-on patches will parametrize the test and add more variants.

Tested: Built and ran the test with

    make ARCH=um mrproper

    ./tools/testing/kunit/kunit.py run \
        --kconfig_add CONFIG_NET=y \
        --kconfig_add CONFIG_DEBUG_KERNEL=y \
        --kconfig_add CONFIG_DEBUG_INFO=y \
        --kconfig_add=CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT=y \
        net_core_gso

Signed-off-by: Willem de Bruijn <willemb@google.com>
Reviewed-by: Florian Westphal <fw@strlen.de>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/net/Kconfig b/net/Kconfig
index e248236c29a739b4fee26532eedf56f0cb19195d..3ec6bc98fa05d206ff28511f7d22e18ee8300bbe 100644 (file)
--- a/net/Kconfig
+++ b/net/Kconfig
@@ -508,4 +508,13 @@ config NETDEV_ADDR_LIST_TEST
        default KUNIT_ALL_TESTS
        depends on KUNIT
 
+config NET_TEST
+       tristate "KUnit tests for networking" if !KUNIT_ALL_TESTS
+       depends on KUNIT
+       default KUNIT_ALL_TESTS
+       help
+         KUnit tests covering core networking infra, such as sk_buff.
+
+         If unsure, say N.
+
 endif   # if NET

diff --git a/net/core/Makefile b/net/core/Makefile
index 731db2eaa61076b64b21e0d732cec8d8f89833d4..0cb734cbc24b294526bdefeca8a25960e7a147a5 100644 (file)
--- a/net/core/Makefile
+++ b/net/core/Makefile
@@ -40,3 +40,4 @@ obj-$(CONFIG_NET_SOCK_MSG) += skmsg.o
 obj-$(CONFIG_BPF_SYSCALL) += sock_map.o
 obj-$(CONFIG_BPF_SYSCALL) += bpf_sk_storage.o
 obj-$(CONFIG_OF)       += of_net.o
+obj-$(CONFIG_NET_TEST) += gso_test.o

diff --git a/net/core/gso_test.c b/net/core/gso_test.c
new file mode 100644 (file)
index 0000000..454874c
--- /dev/null
+++ b/net/core/gso_test.c
@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <kunit/test.h>
+#include <linux/skbuff.h>
+
+static const char hdr[] = "abcdefgh";
+static const int gso_size = 1000, last_seg_size = 1;
+
+/* default: create 3 segment gso packet */
+static int payload_len = (2 * gso_size) + last_seg_size;
+
+static void __init_skb(struct sk_buff *skb)
+{
+       skb_reset_mac_header(skb);
+       memcpy(skb_mac_header(skb), hdr, sizeof(hdr));
+
+       /* skb_segment expects skb->data at start of payload */
+       skb_pull(skb, sizeof(hdr));
+       skb_reset_network_header(skb);
+       skb_reset_transport_header(skb);
+
+       /* proto is arbitrary, as long as not ETH_P_TEB or vlan */
+       skb->protocol = htons(ETH_P_ATALK);
+       skb_shinfo(skb)->gso_size = gso_size;
+}
+
+static void gso_test_func(struct kunit *test)
+{
+       const int shinfo_size = SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+       struct sk_buff *skb, *segs, *cur;
+       struct page *page;
+
+       page = alloc_page(GFP_KERNEL);
+       KUNIT_ASSERT_NOT_NULL(test, page);
+       skb = build_skb(page_address(page), sizeof(hdr) + payload_len + shinfo_size);
+       KUNIT_ASSERT_NOT_NULL(test, skb);
+       __skb_put(skb, sizeof(hdr) + payload_len);
+
+       __init_skb(skb);
+
+       segs = skb_segment(skb, NETIF_F_SG | NETIF_F_HW_CSUM);
+       if (IS_ERR(segs)) {
+               KUNIT_FAIL(test, "segs error %lld", PTR_ERR(segs));
+               goto free_gso_skb;
+       } else if (!segs) {
+               KUNIT_FAIL(test, "no segments");
+               goto free_gso_skb;
+       }
+
+       for (cur = segs; cur; cur = cur->next) {
+               /* segs have skb->data pointing to the mac header */
+               KUNIT_ASSERT_PTR_EQ(test, skb_mac_header(cur), cur->data);
+               KUNIT_ASSERT_PTR_EQ(test, skb_network_header(cur), cur->data + sizeof(hdr));
+
+               /* header was copied to all segs */
+               KUNIT_ASSERT_EQ(test, memcmp(skb_mac_header(cur), hdr, sizeof(hdr)), 0);
+
+               /* all segs are gso_size, except for last */
+               if (cur->next) {
+                       KUNIT_ASSERT_EQ(test, cur->len, sizeof(hdr) + gso_size);
+               } else {
+                       KUNIT_ASSERT_EQ(test, cur->len, sizeof(hdr) + last_seg_size);
+
+                       /* last seg can be found through segs->prev pointer */
+                       KUNIT_ASSERT_PTR_EQ(test, cur, segs->prev);
+               }
+       }
+
+       consume_skb(segs);
+free_gso_skb:
+       consume_skb(skb);
+}
+
+static struct kunit_case gso_test_cases[] = {
+       KUNIT_CASE(gso_test_func),
+       {}
+};
+
+static struct kunit_suite gso_test_suite = {
+       .name = "net_core_gso",
+       .test_cases = gso_test_cases,
+};
+
+kunit_test_suite(gso_test_suite);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("KUnit tests for segmentation offload");