wifi: cfg80211: add first kunit tests, for element defrag

Add a couple of tests for element defragmentation, to
see that the function works correctly.

Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Gregory Greenman <gregory.greenman@intel.com>
Link: https://lore.kernel.org/r/20230827135854.e2a5cead1816.I09f0edc19d162b54ee330991c728c1e9aa42ebf6@changeid
Signed-off-by: Johannes Berg <johannes.berg@intel.com>

diff --git a/net/wireless/Kconfig b/net/wireless/Kconfig
index f620acd..a9ac85e 100644 (file)
--- a/net/wireless/Kconfig
+++ b/net/wireless/Kconfig
@@ -201,6 +201,17 @@ config CFG80211_WEXT_EXPORT
          Drivers should select this option if they require cfg80211's
          wext compatibility symbols to be exported.
 
+config CFG80211_KUNIT_TEST
+       tristate "KUnit tests for cfg80211" if !KUNIT_ALL_TESTS
+       depends on KUNIT
+       depends on CFG80211
+       default KUNIT_ALL_TESTS
+       depends on !KERNEL_6_2
+       help
+         Enable this option to test cfg80211 functions with kunit.
+
+         If unsure, say N.
+
 endif # CFG80211
 
 config LIB80211

diff --git a/net/wireless/Makefile b/net/wireless/Makefile
index 527ae66..089c841 100644 (file)
--- a/net/wireless/Makefile
+++ b/net/wireless/Makefile
@@ -4,6 +4,7 @@ obj-$(CONFIG_LIB80211) += lib80211.o
 obj-$(CONFIG_LIB80211_CRYPT_WEP) += lib80211_crypt_wep.o
 obj-$(CONFIG_LIB80211_CRYPT_CCMP) += lib80211_crypt_ccmp.o
 obj-$(CONFIG_LIB80211_CRYPT_TKIP) += lib80211_crypt_tkip.o
+obj-y += tests/
 
 obj-$(CONFIG_WEXT_CORE) += wext-core.o
 obj-$(CONFIG_WEXT_PROC) += wext-proc.o

diff --git a/net/wireless/tests/Makefile b/net/wireless/tests/Makefile
new file mode 100644 (file)
index 0000000..fa8e297
--- /dev/null
+++ b/net/wireless/tests/Makefile
@@ -0,0 +1,3 @@
+cfg80211-tests-y += module.o fragmentation.o
+
+obj-$(CONFIG_CFG80211_KUNIT_TEST) += cfg80211-tests.o

diff --git a/net/wireless/tests/fragmentation.c b/net/wireless/tests/fragmentation.c
new file mode 100644 (file)
index 0000000..49a339c
--- /dev/null
+++ b/net/wireless/tests/fragmentation.c
@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * KUnit tests for element fragmentation
+ *
+ * Copyright (C) 2023 Intel Corporation
+ */
+#include <linux/ieee80211.h>
+#include <net/cfg80211.h>
+#include <kunit/test.h>
+
+static void defragment_0(struct kunit *test)
+{
+       ssize_t ret;
+       static const u8 input[] = {
+               [0] = WLAN_EID_EXTENSION,
+               [1] = 254,
+               [2] = WLAN_EID_EXT_EHT_MULTI_LINK,
+               [27] = 27,
+               [123] = 123,
+               [254 + 2] = WLAN_EID_FRAGMENT,
+               [254 + 3] = 7,
+               [254 + 3 + 7] = 0, /* for size */
+       };
+       u8 *data = kunit_kzalloc(test, sizeof(input), GFP_KERNEL);
+
+       KUNIT_ASSERT_NOT_NULL(test, data);
+
+       ret = cfg80211_defragment_element((void *)input,
+                                         input, sizeof(input),
+                                         data, sizeof(input),
+                                         WLAN_EID_FRAGMENT);
+       KUNIT_EXPECT_EQ(test, ret, 253);
+       KUNIT_EXPECT_MEMEQ(test, data, input + 3, 253);
+}
+
+static void defragment_1(struct kunit *test)
+{
+       ssize_t ret;
+       static const u8 input[] = {
+               [0] = WLAN_EID_EXTENSION,
+               [1] = 255,
+               [2] = WLAN_EID_EXT_EHT_MULTI_LINK,
+               [27] = 27,
+               [123] = 123,
+               [255 + 2] = WLAN_EID_FRAGMENT,
+               [255 + 3] = 7,
+               [255 + 3 + 1] = 0xaa,
+               [255 + 3 + 8] = WLAN_EID_FRAGMENT, /* not used */
+               [255 + 3 + 9] = 1,
+               [255 + 3 + 10] = 0, /* for size */
+       };
+       u8 *data = kunit_kzalloc(test, sizeof(input), GFP_KERNEL);
+       const struct element *elem;
+       int count = 0;
+
+       KUNIT_ASSERT_NOT_NULL(test, data);
+
+       for_each_element(elem, input, sizeof(input))
+               count++;
+
+       /* check the elements are right */
+       KUNIT_ASSERT_EQ(test, count, 3);
+
+       ret = cfg80211_defragment_element((void *)input,
+                                         input, sizeof(input),
+                                         data, sizeof(input),
+                                         WLAN_EID_FRAGMENT);
+       /* this means the last fragment was not used */
+       KUNIT_EXPECT_EQ(test, ret, 254 + 7);
+       KUNIT_EXPECT_MEMEQ(test, data, input + 3, 254);
+       KUNIT_EXPECT_MEMEQ(test, data + 254, input + 255 + 4, 7);
+}
+
+static void defragment_2(struct kunit *test)
+{
+       ssize_t ret;
+       static const u8 input[] = {
+               [0] = WLAN_EID_EXTENSION,
+               [1] = 255,
+               [2] = WLAN_EID_EXT_EHT_MULTI_LINK,
+               [27] = 27,
+               [123] = 123,
+
+               [257 + 0] = WLAN_EID_FRAGMENT,
+               [257 + 1] = 255,
+               [257 + 20] = 0xaa,
+
+               [2 * 257 + 0] = WLAN_EID_FRAGMENT,
+               [2 * 257 + 1] = 1,
+               [2 * 257 + 2] = 0xcc,
+               [2 * 257 + 3] = WLAN_EID_FRAGMENT, /* not used */
+               [2 * 257 + 4] = 1,
+               [2 * 257 + 5] = 0, /* for size */
+       };
+       u8 *data = kunit_kzalloc(test, sizeof(input), GFP_KERNEL);
+       const struct element *elem;
+       int count = 0;
+
+       KUNIT_ASSERT_NOT_NULL(test, data);
+
+       for_each_element(elem, input, sizeof(input))
+               count++;
+
+       /* check the elements are right */
+       KUNIT_ASSERT_EQ(test, count, 4);
+
+       ret = cfg80211_defragment_element((void *)input,
+                                         input, sizeof(input),
+                                         data, sizeof(input),
+                                         WLAN_EID_FRAGMENT);
+       /* this means the last fragment was not used */
+       KUNIT_EXPECT_EQ(test, ret, 254 + 255 + 1);
+       KUNIT_EXPECT_MEMEQ(test, data, input + 3, 254);
+       KUNIT_EXPECT_MEMEQ(test, data + 254, input + 257 + 2, 255);
+       KUNIT_EXPECT_MEMEQ(test, data + 254 + 255, input + 2 * 257 + 2, 1);
+}
+
+static void defragment_at_end(struct kunit *test)
+{
+       ssize_t ret;
+       static const u8 input[] = {
+               [0] = WLAN_EID_EXTENSION,
+               [1] = 255,
+               [2] = WLAN_EID_EXT_EHT_MULTI_LINK,
+               [27] = 27,
+               [123] = 123,
+               [255 + 2] = WLAN_EID_FRAGMENT,
+               [255 + 3] = 7,
+               [255 + 3 + 7] = 0, /* for size */
+       };
+       u8 *data = kunit_kzalloc(test, sizeof(input), GFP_KERNEL);
+
+       KUNIT_ASSERT_NOT_NULL(test, data);
+
+       ret = cfg80211_defragment_element((void *)input,
+                                         input, sizeof(input),
+                                         data, sizeof(input),
+                                         WLAN_EID_FRAGMENT);
+       KUNIT_EXPECT_EQ(test, ret, 254 + 7);
+       KUNIT_EXPECT_MEMEQ(test, data, input + 3, 254);
+       KUNIT_EXPECT_MEMEQ(test, data + 254, input + 255 + 4, 7);
+}
+
+static struct kunit_case element_fragmentation_test_cases[] = {
+       KUNIT_CASE(defragment_0),
+       KUNIT_CASE(defragment_1),
+       KUNIT_CASE(defragment_2),
+       KUNIT_CASE(defragment_at_end),
+       {}
+};
+
+static struct kunit_suite element_fragmentation = {
+       .name = "cfg80211-element-defragmentation",
+       .test_cases = element_fragmentation_test_cases,
+};
+
+kunit_test_suite(element_fragmentation);

diff --git a/net/wireless/tests/module.c b/net/wireless/tests/module.c
new file mode 100644 (file)
index 0000000..9ff7b2c
--- /dev/null
+++ b/net/wireless/tests/module.c
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * This is just module boilerplate for the cfg80211 kunit module.
+ *
+ * Copyright (C) 2023 Intel Corporation
+ */
+#include <linux/module.h>
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("tests for cfg80211");