MAINTAINERS | 1 + lib/Kconfig.debug | 14 +++++ lib/tests/Makefile | 1 + lib/tests/bitops_kunit.c | 142 +++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 158 insertions(+)
Add a KUnit test suite for the bitops API.
The existing 'lib/test_bitops.c' is preserved as-is because it contains
ad-hoc micro-benchmarks 'test_fns' and is intended to ensure no compiler
warnings from C=1 sparse checker or -Wextra compilations.
Introduce 'lib/tests/bitops_kunit.c' for functional regression testing. It
ports the test logic and data patterns from 'lib/test_bitops.c' to KUnit,
verifying correct behavior across various input patterns and
architecture-specific edge cases using isolated stack-allocated bitmaps.
The following test logic has been ported from test_bitops_startup() in
lib/test_bitops.c:
- set_bit() / clear_bit() / find_first_bit() validation ->
test_set_bit_clear_bit()
- get_count_order() validation -> test_get_count_order()
- get_count_order_long() validation -> test_get_count_order_long()
Also improve the find_first_bit() test to check the full bitmap length
(BITOPS_LENGTH) instead of omitting the last bit, ensuring the bitmap is
completely empty after cleanup.
Verified on x86_64, i386, and arm64 architectures.
Sample KUnit output:
KTAP version 1
# Subtest: bitops
# module: bitops_kunit
1..3
KTAP version 1
# Subtest: test_set_bit_clear_bit
ok 1 BITOPS_4
ok 2 BITOPS_7
ok 3 BITOPS_11
ok 4 BITOPS_31
ok 5 BITOPS_88
# test_set_bit_clear_bit: pass:5 fail:0 skip:0 total:5
ok 1 test_set_bit_clear_bit
KTAP version 1
# Subtest: test_get_count_order
ok 1 0x00000003
ok 2 0x00000004
ok 3 0x00001fff
ok 4 0x00002000
ok 5 0x50000000
ok 6 0x80000000
ok 7 0x80003000
# test_get_count_order: pass:7 fail:0 skip:0 total:7
ok 2 test_get_count_order
KTAP version 1
# Subtest: test_get_count_order_long
ok 1 0x0000000300000000
ok 2 0x0000000400000000
ok 3 0x00001fff00000000
ok 4 0x0000200000000000
ok 5 0x5000000000000000
ok 6 0x8000000000000000
ok 7 0x8000300000000000
# test_get_count_order_long: pass:7 fail:0 skip:0 total:7
ok 3 test_get_count_order_long
Signed-off-by: Ryota Sakamoto <sakamo.ryota@gmail.com>
---
Changes in v2:
- List extracted test logic in the commit message
- Include KTAP execution output
- Clarify in Kconfig help text that this is a partial copy
- Add original authors to CC
- Link to v1: https://lore.kernel.org/r/20260110-kunit-bitops-v1-1-fe39a1ff1a02@gmail.com
---
MAINTAINERS | 1 +
lib/Kconfig.debug | 14 +++++
lib/tests/Makefile | 1 +
lib/tests/bitops_kunit.c | 142 +++++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 158 insertions(+)
diff --git a/MAINTAINERS b/MAINTAINERS
index a0dd762f5648b7e4e6fc62560662e43720422e01..ad978698deedca3e6acdf62145a48d45b579cec2 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -4468,6 +4468,7 @@ F: include/asm-generic/bitops.h
F: include/linux/bitops.h
F: lib/hweight.c
F: lib/test_bitops.c
+F: lib/tests/bitops_kunit.c
F: tools/*/bitops*
BITOPS API BINDINGS [RUST]
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index ba36939fda79bf890834b586c366a28acd434ef9..a3642ab0363d0fa17eb8a395655cdc4b56f031d8 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -2652,6 +2652,20 @@ config TEST_SYSCTL
If unsure, say N.
+config BITOPS_KUNIT
+ tristate "KUnit test for bitops" if !KUNIT_ALL_TESTS
+ depends on KUNIT
+ default KUNIT_ALL_TESTS
+ help
+ This option enables the KUnit test suite for the bitops library
+ which provides functions for bit operations.
+ The test suite checks the functionality of the bitops library.
+
+ Note that this is a partial copy of the original test_bitops module.
+ For the full coverage, enable TEST_BITOPS.
+
+ If unsure, say N.
+
config BITFIELD_KUNIT
tristate "KUnit test bitfield functions at runtime" if !KUNIT_ALL_TESTS
depends on KUNIT
diff --git a/lib/tests/Makefile b/lib/tests/Makefile
index 601dba4b7d966d568d0bb6671dffaf4d68489549..0f24048f36845b13daebcb504e182f738e0a807f 100644
--- a/lib/tests/Makefile
+++ b/lib/tests/Makefile
@@ -5,6 +5,7 @@
# KUnit tests
CFLAGS_bitfield_kunit.o := $(DISABLE_STRUCTLEAK_PLUGIN)
obj-$(CONFIG_BASE64_KUNIT) += base64_kunit.o
+obj-$(CONFIG_BITOPS_KUNIT) += bitops_kunit.o
obj-$(CONFIG_BITFIELD_KUNIT) += bitfield_kunit.o
obj-$(CONFIG_BITS_TEST) += test_bits.o
obj-$(CONFIG_BLACKHOLE_DEV_KUNIT_TEST) += blackhole_dev_kunit.o
diff --git a/lib/tests/bitops_kunit.c b/lib/tests/bitops_kunit.c
new file mode 100644
index 0000000000000000000000000000000000000000..5c47a12760611a0445feb37c252d00f3bf73f6a1
--- /dev/null
+++ b/lib/tests/bitops_kunit.c
@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2026 Ryota Sakamoto <sakamo.ryota@gmail.com>
+ */
+
+#include <linux/bitops.h>
+#include <linux/module.h>
+#include <kunit/test.h>
+
+/* use an enum because that's the most common BITMAP usage */
+enum bitops_fun {
+ BITOPS_4 = 4,
+ BITOPS_7 = 7,
+ BITOPS_11 = 11,
+ BITOPS_31 = 31,
+ BITOPS_88 = 88,
+ BITOPS_LENGTH = 256
+};
+
+struct bitops_test_case {
+ const char *str;
+ const long nr;
+};
+
+static struct bitops_test_case bitops_cases[] = {
+ {
+ .str = "BITOPS_4",
+ .nr = BITOPS_4,
+ },
+ {
+ .str = "BITOPS_7",
+ .nr = BITOPS_7,
+ },
+ {
+ .str = "BITOPS_11",
+ .nr = BITOPS_11,
+ },
+ {
+ .str = "BITOPS_31",
+ .nr = BITOPS_31,
+ },
+ {
+ .str = "BITOPS_88",
+ .nr = BITOPS_88,
+ },
+};
+
+KUNIT_ARRAY_PARAM_DESC(bitops, bitops_cases, str);
+
+static void test_set_bit_clear_bit(struct kunit *test)
+{
+ const struct bitops_test_case *params = test->param_value;
+ DECLARE_BITMAP(bitmap, BITOPS_LENGTH);
+ int bit_set;
+
+ bitmap_zero(bitmap, BITOPS_LENGTH);
+
+ set_bit(params->nr, bitmap);
+ KUNIT_EXPECT_TRUE(test, test_bit(params->nr, bitmap));
+
+ clear_bit(params->nr, bitmap);
+ KUNIT_EXPECT_FALSE(test, test_bit(params->nr, bitmap));
+
+ bit_set = find_first_bit(bitmap, BITOPS_LENGTH);
+ KUNIT_EXPECT_EQ(test, bit_set, BITOPS_LENGTH);
+}
+
+struct order_test_case {
+ const char *str;
+ const unsigned int count;
+ const int expected;
+};
+
+static struct order_test_case order_test_cases[] = {
+ {"0x00000003", 0x00000003, 2},
+ {"0x00000004", 0x00000004, 2},
+ {"0x00001fff", 0x00001fff, 13},
+ {"0x00002000", 0x00002000, 13},
+ {"0x50000000", 0x50000000, 31},
+ {"0x80000000", 0x80000000, 31},
+ {"0x80003000", 0x80003000, 32},
+};
+
+KUNIT_ARRAY_PARAM_DESC(order, order_test_cases, str);
+
+static void test_get_count_order(struct kunit *test)
+{
+ const struct order_test_case *params = test->param_value;
+
+ KUNIT_EXPECT_EQ(test, get_count_order(params->count), params->expected);
+ KUNIT_EXPECT_EQ(test, get_count_order_long(params->count), params->expected);
+}
+
+#ifdef CONFIG_64BIT
+struct order_long_test_case {
+ const char *str;
+ const unsigned long count;
+ const int expected;
+};
+
+static struct order_long_test_case order_long_test_cases[] = {
+ {"0x0000000300000000", 0x0000000300000000, 34},
+ {"0x0000000400000000", 0x0000000400000000, 34},
+ {"0x00001fff00000000", 0x00001fff00000000, 45},
+ {"0x0000200000000000", 0x0000200000000000, 45},
+ {"0x5000000000000000", 0x5000000000000000, 63},
+ {"0x8000000000000000", 0x8000000000000000, 63},
+ {"0x8000300000000000", 0x8000300000000000, 64},
+};
+
+KUNIT_ARRAY_PARAM_DESC(order_long, order_long_test_cases, str);
+
+static void test_get_count_order_long(struct kunit *test)
+{
+ const struct order_long_test_case *params = test->param_value;
+
+ KUNIT_EXPECT_EQ(test, get_count_order_long(params->count), params->expected);
+}
+#endif
+
+static struct kunit_case bitops_test_cases[] = {
+ KUNIT_CASE_PARAM(test_set_bit_clear_bit, bitops_gen_params),
+ KUNIT_CASE_PARAM(test_get_count_order, order_gen_params),
+#ifdef CONFIG_64BIT
+ KUNIT_CASE_PARAM(test_get_count_order_long, order_long_gen_params),
+#endif
+ {},
+};
+
+static struct kunit_suite bitops_test_suite = {
+ .name = "bitops",
+ .test_cases = bitops_test_cases,
+};
+
+kunit_test_suite(bitops_test_suite);
+
+MODULE_AUTHOR("Jesse Brandeburg <jesse.brandeburg@intel.com>");
+MODULE_AUTHOR("Wei Yang <richard.weiyang@gmail.com>");
+MODULE_AUTHOR("Ryota Sakamoto <sakamo.ryota@gmail.com>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Bit testing module");
---
base-commit: 79b95d74470dd97d7d0908d5a3c0734a23e51aa4
change-id: 20260109-kunit-bitops-9abb5cac8cba
Best regards,
--
Ryota Sakamoto <sakamo.ryota@gmail.com>On Sun, Jan 11, 2026 at 02:38:07AM +0900, Ryota Sakamoto wrote:
> Add a KUnit test suite for the bitops API.
>
> The existing 'lib/test_bitops.c' is preserved as-is because it contains
> ad-hoc micro-benchmarks 'test_fns' and is intended to ensure no compiler
> warnings from C=1 sparse checker or -Wextra compilations.
>
> Introduce 'lib/tests/bitops_kunit.c' for functional regression testing. It
> ports the test logic and data patterns from 'lib/test_bitops.c' to KUnit,
> verifying correct behavior across various input patterns and
> architecture-specific edge cases using isolated stack-allocated bitmaps.
>
> The following test logic has been ported from test_bitops_startup() in
> lib/test_bitops.c:
> - set_bit() / clear_bit() / find_first_bit() validation ->
> test_set_bit_clear_bit()
> - get_count_order() validation -> test_get_count_order()
> - get_count_order_long() validation -> test_get_count_order_long()
>
> Also improve the find_first_bit() test to check the full bitmap length
> (BITOPS_LENGTH) instead of omitting the last bit, ensuring the bitmap is
> completely empty after cleanup.
>
> Verified on x86_64, i386, and arm64 architectures.
>
> Sample KUnit output:
>
> KTAP version 1
> # Subtest: bitops
> # module: bitops_kunit
> 1..3
> KTAP version 1
> # Subtest: test_set_bit_clear_bit
> ok 1 BITOPS_4
> ok 2 BITOPS_7
> ok 3 BITOPS_11
> ok 4 BITOPS_31
> ok 5 BITOPS_88
> # test_set_bit_clear_bit: pass:5 fail:0 skip:0 total:5
> ok 1 test_set_bit_clear_bit
> KTAP version 1
> # Subtest: test_get_count_order
> ok 1 0x00000003
> ok 2 0x00000004
> ok 3 0x00001fff
> ok 4 0x00002000
> ok 5 0x50000000
> ok 6 0x80000000
> ok 7 0x80003000
> # test_get_count_order: pass:7 fail:0 skip:0 total:7
> ok 2 test_get_count_order
> KTAP version 1
> # Subtest: test_get_count_order_long
> ok 1 0x0000000300000000
> ok 2 0x0000000400000000
> ok 3 0x00001fff00000000
> ok 4 0x0000200000000000
> ok 5 0x5000000000000000
> ok 6 0x8000000000000000
> ok 7 0x8000300000000000
> # test_get_count_order_long: pass:7 fail:0 skip:0 total:7
> ok 3 test_get_count_order_long
>
> Signed-off-by: Ryota Sakamoto <sakamo.ryota@gmail.com>
Added in bitmap-for-next for testing.
Thanks,
Yury
> ---
> Changes in v2:
> - List extracted test logic in the commit message
> - Include KTAP execution output
> - Clarify in Kconfig help text that this is a partial copy
> - Add original authors to CC
> - Link to v1: https://lore.kernel.org/r/20260110-kunit-bitops-v1-1-fe39a1ff1a02@gmail.com
> ---
> MAINTAINERS | 1 +
> lib/Kconfig.debug | 14 +++++
> lib/tests/Makefile | 1 +
> lib/tests/bitops_kunit.c | 142 +++++++++++++++++++++++++++++++++++++++++++++++
> 4 files changed, 158 insertions(+)
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index a0dd762f5648b7e4e6fc62560662e43720422e01..ad978698deedca3e6acdf62145a48d45b579cec2 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -4468,6 +4468,7 @@ F: include/asm-generic/bitops.h
> F: include/linux/bitops.h
> F: lib/hweight.c
> F: lib/test_bitops.c
> +F: lib/tests/bitops_kunit.c
> F: tools/*/bitops*
>
> BITOPS API BINDINGS [RUST]
> diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
> index ba36939fda79bf890834b586c366a28acd434ef9..a3642ab0363d0fa17eb8a395655cdc4b56f031d8 100644
> --- a/lib/Kconfig.debug
> +++ b/lib/Kconfig.debug
> @@ -2652,6 +2652,20 @@ config TEST_SYSCTL
>
> If unsure, say N.
>
> +config BITOPS_KUNIT
> + tristate "KUnit test for bitops" if !KUNIT_ALL_TESTS
> + depends on KUNIT
> + default KUNIT_ALL_TESTS
> + help
> + This option enables the KUnit test suite for the bitops library
> + which provides functions for bit operations.
> + The test suite checks the functionality of the bitops library.
> +
> + Note that this is a partial copy of the original test_bitops module.
> + For the full coverage, enable TEST_BITOPS.
> +
> + If unsure, say N.
> +
> config BITFIELD_KUNIT
> tristate "KUnit test bitfield functions at runtime" if !KUNIT_ALL_TESTS
> depends on KUNIT
> diff --git a/lib/tests/Makefile b/lib/tests/Makefile
> index 601dba4b7d966d568d0bb6671dffaf4d68489549..0f24048f36845b13daebcb504e182f738e0a807f 100644
> --- a/lib/tests/Makefile
> +++ b/lib/tests/Makefile
> @@ -5,6 +5,7 @@
> # KUnit tests
> CFLAGS_bitfield_kunit.o := $(DISABLE_STRUCTLEAK_PLUGIN)
> obj-$(CONFIG_BASE64_KUNIT) += base64_kunit.o
> +obj-$(CONFIG_BITOPS_KUNIT) += bitops_kunit.o
> obj-$(CONFIG_BITFIELD_KUNIT) += bitfield_kunit.o
> obj-$(CONFIG_BITS_TEST) += test_bits.o
> obj-$(CONFIG_BLACKHOLE_DEV_KUNIT_TEST) += blackhole_dev_kunit.o
> diff --git a/lib/tests/bitops_kunit.c b/lib/tests/bitops_kunit.c
> new file mode 100644
> index 0000000000000000000000000000000000000000..5c47a12760611a0445feb37c252d00f3bf73f6a1
> --- /dev/null
> +++ b/lib/tests/bitops_kunit.c
> @@ -0,0 +1,142 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2020 Intel Corporation
> + * Copyright (C) 2026 Ryota Sakamoto <sakamo.ryota@gmail.com>
> + */
> +
> +#include <linux/bitops.h>
> +#include <linux/module.h>
> +#include <kunit/test.h>
> +
> +/* use an enum because that's the most common BITMAP usage */
> +enum bitops_fun {
> + BITOPS_4 = 4,
> + BITOPS_7 = 7,
> + BITOPS_11 = 11,
> + BITOPS_31 = 31,
> + BITOPS_88 = 88,
> + BITOPS_LENGTH = 256
> +};
> +
> +struct bitops_test_case {
> + const char *str;
> + const long nr;
> +};
> +
> +static struct bitops_test_case bitops_cases[] = {
> + {
> + .str = "BITOPS_4",
> + .nr = BITOPS_4,
> + },
> + {
> + .str = "BITOPS_7",
> + .nr = BITOPS_7,
> + },
> + {
> + .str = "BITOPS_11",
> + .nr = BITOPS_11,
> + },
> + {
> + .str = "BITOPS_31",
> + .nr = BITOPS_31,
> + },
> + {
> + .str = "BITOPS_88",
> + .nr = BITOPS_88,
> + },
> +};
> +
> +KUNIT_ARRAY_PARAM_DESC(bitops, bitops_cases, str);
> +
> +static void test_set_bit_clear_bit(struct kunit *test)
> +{
> + const struct bitops_test_case *params = test->param_value;
> + DECLARE_BITMAP(bitmap, BITOPS_LENGTH);
> + int bit_set;
> +
> + bitmap_zero(bitmap, BITOPS_LENGTH);
> +
> + set_bit(params->nr, bitmap);
> + KUNIT_EXPECT_TRUE(test, test_bit(params->nr, bitmap));
> +
> + clear_bit(params->nr, bitmap);
> + KUNIT_EXPECT_FALSE(test, test_bit(params->nr, bitmap));
> +
> + bit_set = find_first_bit(bitmap, BITOPS_LENGTH);
> + KUNIT_EXPECT_EQ(test, bit_set, BITOPS_LENGTH);
> +}
> +
> +struct order_test_case {
> + const char *str;
> + const unsigned int count;
> + const int expected;
> +};
> +
> +static struct order_test_case order_test_cases[] = {
> + {"0x00000003", 0x00000003, 2},
> + {"0x00000004", 0x00000004, 2},
> + {"0x00001fff", 0x00001fff, 13},
> + {"0x00002000", 0x00002000, 13},
> + {"0x50000000", 0x50000000, 31},
> + {"0x80000000", 0x80000000, 31},
> + {"0x80003000", 0x80003000, 32},
> +};
> +
> +KUNIT_ARRAY_PARAM_DESC(order, order_test_cases, str);
> +
> +static void test_get_count_order(struct kunit *test)
> +{
> + const struct order_test_case *params = test->param_value;
> +
> + KUNIT_EXPECT_EQ(test, get_count_order(params->count), params->expected);
> + KUNIT_EXPECT_EQ(test, get_count_order_long(params->count), params->expected);
> +}
> +
> +#ifdef CONFIG_64BIT
> +struct order_long_test_case {
> + const char *str;
> + const unsigned long count;
> + const int expected;
> +};
> +
> +static struct order_long_test_case order_long_test_cases[] = {
> + {"0x0000000300000000", 0x0000000300000000, 34},
> + {"0x0000000400000000", 0x0000000400000000, 34},
> + {"0x00001fff00000000", 0x00001fff00000000, 45},
> + {"0x0000200000000000", 0x0000200000000000, 45},
> + {"0x5000000000000000", 0x5000000000000000, 63},
> + {"0x8000000000000000", 0x8000000000000000, 63},
> + {"0x8000300000000000", 0x8000300000000000, 64},
> +};
> +
> +KUNIT_ARRAY_PARAM_DESC(order_long, order_long_test_cases, str);
> +
> +static void test_get_count_order_long(struct kunit *test)
> +{
> + const struct order_long_test_case *params = test->param_value;
> +
> + KUNIT_EXPECT_EQ(test, get_count_order_long(params->count), params->expected);
> +}
> +#endif
> +
> +static struct kunit_case bitops_test_cases[] = {
> + KUNIT_CASE_PARAM(test_set_bit_clear_bit, bitops_gen_params),
> + KUNIT_CASE_PARAM(test_get_count_order, order_gen_params),
> +#ifdef CONFIG_64BIT
> + KUNIT_CASE_PARAM(test_get_count_order_long, order_long_gen_params),
> +#endif
> + {},
> +};
> +
> +static struct kunit_suite bitops_test_suite = {
> + .name = "bitops",
> + .test_cases = bitops_test_cases,
> +};
> +
> +kunit_test_suite(bitops_test_suite);
> +
> +MODULE_AUTHOR("Jesse Brandeburg <jesse.brandeburg@intel.com>");
> +MODULE_AUTHOR("Wei Yang <richard.weiyang@gmail.com>");
> +MODULE_AUTHOR("Ryota Sakamoto <sakamo.ryota@gmail.com>");
> +MODULE_LICENSE("GPL");
> +MODULE_DESCRIPTION("Bit testing module");
>
> ---
> base-commit: 79b95d74470dd97d7d0908d5a3c0734a23e51aa4
> change-id: 20260109-kunit-bitops-9abb5cac8cba
>
> Best regards,
> --
> Ryota Sakamoto <sakamo.ryota@gmail.com>
© 2016 - 2026 Red Hat, Inc.