From 6b5a4b68736798df1031404a2fad06d031253ef7 Mon Sep 17 00:00:00 2001 From: Andy Shevchenko Date: Thu, 26 Feb 2026 12:16:44 +0100 Subject: bitmap: Add test for out-of-boundary modifications for scatter & gather Make sure that bitmap_scatter() and bitmap_gather() do not modify the bits outside of the given nbits span. Signed-off-by: Andy Shevchenko Signed-off-by: Yury Norov --- lib/test_bitmap.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) (limited to 'lib') diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c index c83829ef557f..2952a6147e81 100644 --- a/lib/test_bitmap.c +++ b/lib/test_bitmap.c @@ -354,18 +354,22 @@ static void __init test_replace(void) static const unsigned long sg_mask[] __initconst = { BITMAP_FROM_U64(0x000000000000035aULL), + BITMAP_FROM_U64(0x0000000000000000ULL), }; static const unsigned long sg_src[] __initconst = { BITMAP_FROM_U64(0x0000000000000667ULL), + BITMAP_FROM_U64(0x0000000000000000ULL), }; static const unsigned long sg_gather_exp[] __initconst = { BITMAP_FROM_U64(0x0000000000000029ULL), + BITMAP_FROM_U64(0x0000000000000000ULL), }; static const unsigned long sg_scatter_exp[] __initconst = { BITMAP_FROM_U64(0x000000000000021aULL), + BITMAP_FROM_U64(0x0000000000000000ULL), }; static void __init test_bitmap_sg(void) @@ -379,18 +383,18 @@ static void __init test_bitmap_sg(void) /* Simple gather call */ bitmap_zero(bmap_gather, 100); bitmap_gather(bmap_gather, sg_src, sg_mask, nbits); - expect_eq_bitmap(sg_gather_exp, bmap_gather, nbits); + expect_eq_bitmap(sg_gather_exp, bmap_gather, 100); /* Simple scatter call */ bitmap_zero(bmap_scatter, 100); bitmap_scatter(bmap_scatter, sg_src, sg_mask, nbits); - expect_eq_bitmap(sg_scatter_exp, bmap_scatter, nbits); + expect_eq_bitmap(sg_scatter_exp, bmap_scatter, 100); /* Scatter/gather relationship */ bitmap_zero(bmap_tmp, 100); bitmap_gather(bmap_tmp, bmap_scatter, sg_mask, nbits); bitmap_scatter(bmap_res, bmap_tmp, sg_mask, nbits); - expect_eq_bitmap(bmap_scatter, bmap_res, nbits); + expect_eq_bitmap(bmap_scatter, bmap_res, 100); } #define PARSE_TIME 0x1 -- cgit v1.2.3 From d1a43793c484e4f1e896dd2fee52b034f8c4f965 Mon Sep 17 00:00:00 2001 From: Yury Norov Date: Thu, 19 Feb 2026 13:13:57 -0500 Subject: bitmap: switch test to scnprintf("%*pbl") scnprintf("%*pbl") is more verbose than bitmap_print_to_pagebuf(). Switch the test to using it. This also improves the test output because bitmap_print_to_pagebuf() adds \n at the end of the printed bitmap, which breaks the test format. Signed-off-by: Yury Norov --- lib/test_bitmap.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'lib') diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c index 2952a6147e81..8d07b5411897 100644 --- a/lib/test_bitmap.c +++ b/lib/test_bitmap.c @@ -548,22 +548,22 @@ static void __init test_bitmap_printlist(void) goto out; time = ktime_get(); - ret = bitmap_print_to_pagebuf(true, buf, bmap, PAGE_SIZE * 8); + ret = scnprintf(buf, PAGE_SIZE, "%*pbl", (int)PAGE_SIZE * 8, bmap); time = ktime_get() - time; - if (ret != slen + 1) { - pr_err("bitmap_print_to_pagebuf: result is %d, expected %d\n", ret, slen); + if (ret != slen) { + pr_err("bitmap_printlist: result is %d, expected %d\n", ret, slen); failed_tests++; goto out; } if (strncmp(buf, expected, slen)) { - pr_err("bitmap_print_to_pagebuf: result is %s, expected %s\n", buf, expected); + pr_err("bitmap_printlist: result is %s, expected %s\n", buf, expected); failed_tests++; goto out; } - pr_info("bitmap_print_to_pagebuf: input is '%s', Time: %llu\n", buf, time); + pr_info("bitmap_printlist: input is '%s', Time: %llu\n", buf, time); out: kfree(buf); kfree(bmap); -- cgit v1.2.3 From e63375d39a2e90edc25e96560f14d28193347b04 Mon Sep 17 00:00:00 2001 From: Yury Norov Date: Thu, 19 Feb 2026 13:13:58 -0500 Subject: bitmap: align test_bitmap output Different subtests print output in slightly different formats. Unify the format for better visual representation. The test output before: [ 0.553474] test_bitmap: parselist: 14: input is '0-2047:128/256' OK, Time: 202 [ 0.555121] test_bitmap: bitmap_print_to_pagebuf: input is '0-32767 [ 0.555121] ', Time: 1278 [ 0.578392] test_bitmap: Time spent in test_bitmap_read_perf: 427864 [ 0.580137] test_bitmap: Time spent in test_bitmap_write_perf: 793554 [ 0.581957] test_bitmap: all 390447 tests passed And after: [ 0.314982] test_bitmap: parselist('0-2047:128/256'): 135 [ 0.315517] test_bitmap: scnprintf("%*pbl", '0-32767'): 342 [ 0.330045] test_bitmap: test_bitmap_read_perf: 252294 [ 0.331132] test_bitmap: test_bitmap_write_perf: 539001 [ 0.332163] test_bitmap: all 390447 tests passed Signed-off-by: Yury Norov --- lib/test_bitmap.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) (limited to 'lib') diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c index 8d07b5411897..1c352c1edfa5 100644 --- a/lib/test_bitmap.c +++ b/lib/test_bitmap.c @@ -524,8 +524,7 @@ static void __init test_bitmap_parselist(void) } if (ptest.flags & PARSE_TIME) - pr_info("parselist: %d: input is '%s' OK, Time: %llu\n", - i, ptest.in, time); + pr_info("parselist('%s'):\t%llu\n", ptest.in, time); #undef ptest } @@ -552,18 +551,18 @@ static void __init test_bitmap_printlist(void) time = ktime_get() - time; if (ret != slen) { - pr_err("bitmap_printlist: result is %d, expected %d\n", ret, slen); + pr_err("scnprintf(\"%%*pbl\"): result is %d, expected %d\n", ret, slen); failed_tests++; goto out; } if (strncmp(buf, expected, slen)) { - pr_err("bitmap_printlist: result is %s, expected %s\n", buf, expected); + pr_err("scnprintf(\"%%*pbl\"): result is %s, expected %s\n", buf, expected); failed_tests++; goto out; } - pr_info("bitmap_printlist: input is '%s', Time: %llu\n", buf, time); + pr_info("scnprintf(\"%%*pbl\", '%s'):\t%llu\n", buf, time); out: kfree(buf); kfree(bmap); @@ -1399,7 +1398,7 @@ static void __init test_bitmap_read_perf(void) } } time = ktime_get() - time; - pr_info("Time spent in %s:\t%llu\n", __func__, time); + pr_info("%s:\t\t%llu\n", __func__, time); } static void __init test_bitmap_write_perf(void) @@ -1421,7 +1420,7 @@ static void __init test_bitmap_write_perf(void) } } time = ktime_get() - time; - pr_info("Time spent in %s:\t%llu\n", __func__, time); + pr_info("%s:\t\t%llu\n", __func__, time); } #undef TEST_BIT_LEN -- cgit v1.2.3 From a676643709115816d3ce7e50aa5b5a4af1ee6c45 Mon Sep 17 00:00:00 2001 From: Yury Norov Date: Wed, 25 Feb 2026 18:58:32 -0500 Subject: bitmap: drop __find_nth_andnot_bit() Remove find_nth_andnot_bit() leftovers. CC: Rasmus Villemoes CC: Andrew Morton CC: Shaopeng Tan Fixes: b0c85e99458a ("cpumask: Remove unnecessary cpumask_nth_andnot()") Signed-off-by: Yury Norov --- lib/find_bit.c | 7 ------- 1 file changed, 7 deletions(-) (limited to 'lib') diff --git a/lib/find_bit.c b/lib/find_bit.c index 5a0066c26d9a..5ac52dfce730 100644 --- a/lib/find_bit.c +++ b/lib/find_bit.c @@ -172,13 +172,6 @@ unsigned long __find_nth_and_bit(const unsigned long *addr1, const unsigned long } EXPORT_SYMBOL(__find_nth_and_bit); -unsigned long __find_nth_andnot_bit(const unsigned long *addr1, const unsigned long *addr2, - unsigned long size, unsigned long n) -{ - return FIND_NTH_BIT(addr1[idx] & ~addr2[idx], size, n); -} -EXPORT_SYMBOL(__find_nth_andnot_bit); - unsigned long __find_nth_and_andnot_bit(const unsigned long *addr1, const unsigned long *addr2, const unsigned long *addr3, -- cgit v1.2.3 From 6c88ba561cfc2c5f35067519f46310059a9dc39a Mon Sep 17 00:00:00 2001 From: Akinobu Mita Date: Wed, 11 Mar 2026 00:21:26 +0900 Subject: lib/find_bit_benchmark: avoid clearing randomly filled bitmap in test_find_first_bit() test_find_first_bit() searches for a set bit from the beginning of the test bitmap and clears it repeatedly, eventually clearing the entire bitmap. After test_find_first_bit() is executed, test_find_first_and_bit() and test_find_next_and_bit() are executed without randomly reinitializing the cleared bitmap. In the first phase (testing find_bit() with a random-filled bitmap), test_find_first_bit() only operates on 1/10 of the entire size of the testing bitmap, so this isn't a big problem. However, in the second phase (testing find_bit() with a sparse bitmap), test_find_first_bit() clears the entire test bitmap, so the subsequent test_find_first_and_bit() and test_find_next_and_bit() will not find any set bits. This is probably not the intended benchmark. To fix this issue, test_find_first_bit() operates on a duplicated bitmap and does not clear the original test bitmap. The same is already done in test_find_first_and_bit(). While we're at it, add const qualifiers to the bitmap pointer arguments in the test functions. Signed-off-by: Akinobu Mita Cc: Rasmus Villemoes Signed-off-by: Yury Norov --- lib/find_bit_benchmark.c | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) (limited to 'lib') diff --git a/lib/find_bit_benchmark.c b/lib/find_bit_benchmark.c index 402e160e7186..00d9dc61cd46 100644 --- a/lib/find_bit_benchmark.c +++ b/lib/find_bit_benchmark.c @@ -30,18 +30,20 @@ static DECLARE_BITMAP(bitmap, BITMAP_LEN) __initdata; static DECLARE_BITMAP(bitmap2, BITMAP_LEN) __initdata; /* - * This is Schlemiel the Painter's algorithm. It should be called after - * all other tests for the same bitmap because it sets all bits of bitmap to 1. + * This is Schlemiel the Painter's algorithm. */ -static int __init test_find_first_bit(void *bitmap, unsigned long len) +static int __init test_find_first_bit(const void *bitmap, unsigned long len) { + static DECLARE_BITMAP(cp, BITMAP_LEN) __initdata; unsigned long i, cnt; ktime_t time; + bitmap_copy(cp, bitmap, BITMAP_LEN); + time = ktime_get(); for (cnt = i = 0; i < len; cnt++) { - i = find_first_bit(bitmap, len); - __clear_bit(i, bitmap); + i = find_first_bit(cp, len); + __clear_bit(i, cp); } time = ktime_get() - time; pr_err("find_first_bit: %18llu ns, %6ld iterations\n", time, cnt); @@ -49,7 +51,8 @@ static int __init test_find_first_bit(void *bitmap, unsigned long len) return 0; } -static int __init test_find_first_and_bit(void *bitmap, const void *bitmap2, unsigned long len) +static int __init test_find_first_and_bit(const void *bitmap, const void *bitmap2, + unsigned long len) { static DECLARE_BITMAP(cp, BITMAP_LEN) __initdata; unsigned long i, cnt; -- cgit v1.2.3 From bf31ddc14f8c6bcd4987c31fe2bc9e93e433b41a Mon Sep 17 00:00:00 2001 From: Yury Norov Date: Mon, 22 Dec 2025 14:11:37 -0500 Subject: bitmap: add bitmap_weight_from() The function calculates a Hamming weight of a bitmap starting from an arbitrary bit. Signed-off-by: Yury Norov --- lib/test_bitmap.c | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) (limited to 'lib') diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c index 1c352c1edfa5..cd4cb36e42a5 100644 --- a/lib/test_bitmap.c +++ b/lib/test_bitmap.c @@ -854,6 +854,31 @@ static void __init test_for_each_set_bit_from(void) } } +static void __init test_bitmap_weight(void) +{ + unsigned int bit, w1, w2, w; + DECLARE_BITMAP(b, 30); + + bitmap_parselist("all:1/2", b, 30); + + /* Test inline implementation */ + w = bitmap_weight(b, 30); + w1 = bitmap_weight(b, 15); + w2 = bitmap_weight_from(b, 15, 30); + + expect_eq_uint(15, w); + expect_eq_uint(8, w1); + expect_eq_uint(7, w2); + + /* Test outline implementation */ + w = bitmap_weight(exp1, EXP1_IN_BITS); + for (bit = 0; bit < EXP1_IN_BITS; bit++) { + w1 = bitmap_weight(exp1, bit); + w2 = bitmap_weight_from(exp1, bit, EXP1_IN_BITS); + expect_eq_uint(w1 + w2, w); + } +} + static void __init test_for_each_clear_bit(void) { DECLARE_BITMAP(orig, 500); @@ -1444,6 +1469,7 @@ static void __init selftest(void) test_bitmap_const_eval(); test_bitmap_read_write(); test_bitmap_read_perf(); + test_bitmap_weight(); test_bitmap_write_perf(); test_find_nth_bit(); -- cgit v1.2.3 From 18c48899653fa7a04120537c228031b5c7e4e9d6 Mon Sep 17 00:00:00 2001 From: Yury Norov Date: Tue, 10 Mar 2026 16:53:02 -0400 Subject: lib: crypto: fix comments for count_leading_zeros() count_leading_zeros() is based on fls(), which is defined for x == 0, contrary to __ffs() family. The comment in crypto/mpi erroneously states that the function may return undef in such case. Fix the comment together with the outdated function signature, and now that COUNT_LEADING_ZEROS_0 is not referenced in the codebase, get rid of it too. Reviewed-by: Andy Shevchenko Acked-by: Eric Biggers Signed-off-by: Yury Norov --- lib/crypto/mpi/longlong.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'lib') diff --git a/lib/crypto/mpi/longlong.h b/lib/crypto/mpi/longlong.h index b6fa1d08fb55..6d31c3a729f1 100644 --- a/lib/crypto/mpi/longlong.h +++ b/lib/crypto/mpi/longlong.h @@ -66,12 +66,12 @@ * denominator). Like udiv_qrnnd but the numbers are signed. The quotient * is rounded towards 0. * - * 5) count_leading_zeros(count, x) counts the number of zero-bits from the + * 5) count_leading_zeros(x) counts the number of zero-bits from the * msb to the first non-zero bit in the UWtype X. This is the number of - * steps X needs to be shifted left to set the msb. Undefined for X == 0, - * unless the symbol COUNT_LEADING_ZEROS_0 is defined to some value. + * steps X needs to be shifted left to set the msb. + * count_leading_zeros(0) == BITS_PER_LONG * - * 6) count_trailing_zeros(count, x) like count_leading_zeros, but counts + * 6) count_trailing_zeros() like count_leading_zeros(), but counts * from the least significant end. * * 7) add_ssaaaa(high_sum, low_sum, high_addend_1, low_addend_1, -- cgit v1.2.3 From e9cf8f83c9857a32494002c72b5f6e36ff4dfcd5 Mon Sep 17 00:00:00 2001 From: Yury Norov Date: Wed, 18 Mar 2026 20:43:46 -0400 Subject: bitmap: test bitmap_weight() for more Test the function for correctness when some bits are set in the last word of bitmap beyond nbits. This is motivated by commit a9dadc1c512807f9 ("powerpc/xive: Fix the size of the cpumask used in xive_find_target_in_mask()"). Signed-off-by: Yury Norov --- lib/test_bitmap.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) (limited to 'lib') diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c index cd4cb36e42a5..eeb497016ed3 100644 --- a/lib/test_bitmap.c +++ b/lib/test_bitmap.c @@ -858,6 +858,7 @@ static void __init test_bitmap_weight(void) { unsigned int bit, w1, w2, w; DECLARE_BITMAP(b, 30); + DECLARE_BITMAP(b1, 128); bitmap_parselist("all:1/2", b, 30); @@ -877,6 +878,24 @@ static void __init test_bitmap_weight(void) w2 = bitmap_weight_from(exp1, bit, EXP1_IN_BITS); expect_eq_uint(w1 + w2, w); } + + /* Test out-of-range */ + w = bitmap_weight_from(b, 31, 30); + expect_eq_uint(0, !!(w < 30)); + + /* + * Test bitmap_weight() for correctness in case of some bits set between + * nbits and end of the last word. + */ + bitmap_fill(b1, 128); + + /* Inline */ + expect_eq_uint(30, bitmap_weight(b1, 30)); + expect_eq_uint(100, bitmap_weight(b1, 100)); + + /* Outline */ + for (int i = 1; i < 128; i++) + expect_eq_uint(i, bitmap_weight(b1, i)); } static void __init test_for_each_clear_bit(void) -- cgit v1.2.3 From 2a4d3706d864d19ba8772b7a5e74328ac5c1007d Mon Sep 17 00:00:00 2001 From: Yury Norov Date: Wed, 18 Mar 2026 20:43:47 -0400 Subject: bitmap: exclude nbits == 0 cases from bitmap test Bitmap API handles nbits == 0 in most cases correctly, i.e. it doesn't dereferene underlying bitmap and returns a sane value where convenient, or implementation defined, or undef. Implicitly testing nbits == 0 case, however, may make an impression that this is a regular case. This is wrong. In most cases nbits == 0 is a sign of an error on a client side. The tests should not make such an implression. This patch reworks the existing tests to not test nbits == 0. The following patch adds an explicit test for it with an appropriate precaution. Signed-off-by: Yury Norov --- lib/test_bitmap.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'lib') diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c index eeb497016ed3..b6f27c632c75 100644 --- a/lib/test_bitmap.c +++ b/lib/test_bitmap.c @@ -653,7 +653,7 @@ static void __init test_bitmap_arr32(void) memset(arr, 0xa5, sizeof(arr)); - for (nbits = 0; nbits < EXP1_IN_BITS; ++nbits) { + for (nbits = 1; nbits < EXP1_IN_BITS; ++nbits) { bitmap_to_arr32(arr, exp1, nbits); bitmap_from_arr32(bmap2, arr, nbits); expect_eq_bitmap(bmap2, exp1, nbits); @@ -681,7 +681,7 @@ static void __init test_bitmap_arr64(void) memset(arr, 0xa5, sizeof(arr)); - for (nbits = 0; nbits < EXP1_IN_BITS; ++nbits) { + for (nbits = 1; nbits < EXP1_IN_BITS; ++nbits) { memset(bmap2, 0xff, sizeof(arr)); bitmap_to_arr64(arr, exp1, nbits); bitmap_from_arr64(bmap2, arr, nbits); @@ -714,7 +714,7 @@ static void noinline __init test_mem_optimisations(void) unsigned int start, nbits; for (start = 0; start < 1024; start += 8) { - for (nbits = 0; nbits < 1024 - start; nbits += 8) { + for (nbits = 1; nbits < 1024 - start; nbits += 8) { memset(bmap1, 0x5a, sizeof(bmap1)); memset(bmap2, 0x5a, sizeof(bmap2)); @@ -873,7 +873,7 @@ static void __init test_bitmap_weight(void) /* Test outline implementation */ w = bitmap_weight(exp1, EXP1_IN_BITS); - for (bit = 0; bit < EXP1_IN_BITS; bit++) { + for (bit = 1; bit < EXP1_IN_BITS; bit++) { w1 = bitmap_weight(exp1, bit); w2 = bitmap_weight_from(exp1, bit, EXP1_IN_BITS); expect_eq_uint(w1 + w2, w); -- cgit v1.2.3 From 95d324fb1b48434f4c659e4c245c3bdeecdff22c Mon Sep 17 00:00:00 2001 From: Yury Norov Date: Wed, 18 Mar 2026 20:43:48 -0400 Subject: bitmap: add test_zero_nbits() In most real-life cases, 0-length bitmap provided by user is a sign of an error. The API doesn't provide any guarantees on returned value, and the bitmap pointers are not dereferenced. Signed-off-by: Yury Norov --- lib/bitmap.c | 2 ++ lib/test_bitmap.c | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+) (limited to 'lib') diff --git a/lib/bitmap.c b/lib/bitmap.c index 9dc526507875..1b897f94e0ff 100644 --- a/lib/bitmap.c +++ b/lib/bitmap.c @@ -69,6 +69,7 @@ bool __bitmap_or_equal(const unsigned long *bitmap1, tmp = (bitmap1[k] | bitmap2[k]) ^ bitmap3[k]; return (tmp & BITMAP_LAST_WORD_MASK(bits)) == 0; } +EXPORT_SYMBOL(__bitmap_or_equal); void __bitmap_complement(unsigned long *dst, const unsigned long *src, unsigned int bits) { @@ -360,6 +361,7 @@ unsigned int __bitmap_weighted_or(unsigned long *dst, const unsigned long *bitma { return BITMAP_WEIGHT(({dst[idx] = bitmap1[idx] | bitmap2[idx]; dst[idx]; }), bits); } +EXPORT_SYMBOL(__bitmap_weighted_or); void __bitmap_set(unsigned long *map, unsigned int start, int len) { diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c index b6f27c632c75..69813c10e6c0 100644 --- a/lib/test_bitmap.c +++ b/lib/test_bitmap.c @@ -1467,6 +1467,62 @@ static void __init test_bitmap_write_perf(void) pr_info("%s:\t\t%llu\n", __func__, time); } +/* + * nbits == 0 is most commonly not a valid case. Bitmap users should revisit + * the caller logic. Bitmap API doesn't provide any guarantees on returned + * value. The pointers are not dereferenced. The return value is intentionally + * ignored. + */ +static void __init test_zero_nbits(void) +{ + static volatile __always_used unsigned long ret __initdata; + + bitmap_clear(NULL, 0, 0); + bitmap_complement(NULL, NULL, 0); + bitmap_copy(NULL, NULL, 0); + bitmap_copy_clear_tail(NULL, NULL, 0); + bitmap_fill(NULL, 0); + bitmap_from_arr32(NULL, NULL, 0); + bitmap_from_arr64(NULL, NULL, 0); + bitmap_or(NULL, NULL, NULL, 0); + bitmap_set(NULL, 0, 0); + bitmap_shift_left(NULL, NULL, 0, 0); + bitmap_shift_right(NULL, NULL, 0, 0); + bitmap_to_arr32(NULL, NULL, 0); + bitmap_to_arr64(NULL, NULL, 0); + bitmap_write(NULL, 0, 0, 0); + bitmap_xor(NULL, NULL, NULL, 0); + bitmap_zero(NULL, 0); + + ret = bitmap_and(NULL, NULL, NULL, 0); + ret = bitmap_empty(NULL, 0); + ret = bitmap_equal(NULL, NULL, 0); + ret = bitmap_full(NULL, 0); + ret = bitmap_or_equal(NULL, NULL, NULL, 0); + ret = bitmap_read(NULL, 0, 0); + ret = bitmap_subset(NULL, NULL, 0); + ret = bitmap_weight(NULL, 0); + ret = bitmap_weight_and(NULL, NULL, 0); + ret = bitmap_weight_andnot(NULL, NULL, 0); + ret = bitmap_weight_from(NULL, 0, 0); + ret = bitmap_weighted_or(NULL, NULL, NULL, 0); + + ret = find_first_and_and_bit(NULL, NULL, NULL, 0); + ret = find_first_and_bit(NULL, NULL, 0); + ret = find_first_andnot_bit(NULL, NULL, 0); + ret = find_first_bit(NULL, 0); + ret = find_first_zero_bit(NULL, 0); + ret = find_last_bit(NULL, 0); + ret = find_next_and_bit(NULL, NULL, 0, 0); + ret = find_next_andnot_bit(NULL, NULL, 0, 0); + ret = find_next_bit(NULL, 0, 0); + ret = find_next_clump8(NULL, NULL, 0, 0); + ret = find_next_zero_bit(NULL, 0, 0); + ret = find_nth_and_bit(NULL, NULL, 0, 0); + ret = find_nth_bit(NULL, 0, 0); + ret = find_random_bit(NULL, 0); +} + #undef TEST_BIT_LEN static void __init selftest(void) @@ -1490,6 +1546,7 @@ static void __init selftest(void) test_bitmap_read_perf(); test_bitmap_weight(); test_bitmap_write_perf(); + test_zero_nbits(); test_find_nth_bit(); test_for_each_set_bit(); -- cgit v1.2.3 From d57e74f10461b80c77d1678f646720f616fb8553 Mon Sep 17 00:00:00 2001 From: Yury Norov Date: Sun, 1 Mar 2026 20:11:55 -0500 Subject: bitmap: introduce bitmap_weighted_xor() The function helps to XOR bitmaps and calculate Hamming weight of the result in one pass. Reviewed-by: Aleksandr Loktionov Reviewed-by: Jacob Keller Signed-off-by: Yury Norov --- lib/bitmap.c | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'lib') diff --git a/lib/bitmap.c b/lib/bitmap.c index 1b897f94e0ff..b9bfa157e095 100644 --- a/lib/bitmap.c +++ b/lib/bitmap.c @@ -363,6 +363,13 @@ unsigned int __bitmap_weighted_or(unsigned long *dst, const unsigned long *bitma } EXPORT_SYMBOL(__bitmap_weighted_or); +unsigned int __bitmap_weighted_xor(unsigned long *dst, const unsigned long *bitmap1, + const unsigned long *bitmap2, unsigned int bits) +{ + return BITMAP_WEIGHT(({dst[idx] = bitmap1[idx] ^ bitmap2[idx]; dst[idx]; }), bits); +} +EXPORT_SYMBOL(__bitmap_weighted_xor); + void __bitmap_set(unsigned long *map, unsigned int start, int len) { unsigned long *p = map + BIT_WORD(start); -- cgit v1.2.3 From 7ca1d7f939964e31fe8ecbca70d96423d511fb93 Mon Sep 17 00:00:00 2001 From: Yury Norov Date: Tue, 3 Mar 2026 15:08:40 -0500 Subject: lib/prime_numbers: drop temporary buffer in dump_primes() The function uses temporary buffer to convert primes bitmap into human readable format. Switch to using kunit_info("%*pbl")", and drop the buffer. Signed-off-by: Yury Norov --- lib/math/tests/prime_numbers_kunit.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) (limited to 'lib') diff --git a/lib/math/tests/prime_numbers_kunit.c b/lib/math/tests/prime_numbers_kunit.c index 2f1643208c66..55ac160c6dfa 100644 --- a/lib/math/tests/prime_numbers_kunit.c +++ b/lib/math/tests/prime_numbers_kunit.c @@ -8,12 +8,10 @@ static void dump_primes(void *ctx, const struct primes *p) { - static char buf[PAGE_SIZE]; struct kunit_suite *suite = ctx; - bitmap_print_to_pagebuf(true, buf, p->primes, p->sz); - kunit_info(suite, "primes.{last=%lu, .sz=%lu, .primes[]=...x%lx} = %s", - p->last, p->sz, p->primes[BITS_TO_LONGS(p->sz) - 1], buf); + kunit_info(suite, "primes.{last=%lu, .sz=%lu, .primes[]=...x%lx} = %*pbl", + p->last, p->sz, p->primes[BITS_TO_LONGS(p->sz) - 1], (int)p->sz, p->primes); } static void prime_numbers_test(struct kunit *test) -- cgit v1.2.3