1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Test cases for bitmap API. 4 */ 5 6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 7 8 #include <linux/bitmap.h> 9 #include <linux/init.h> 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/printk.h> 13 #include <linux/slab.h> 14 #include <linux/string.h> 15 #include <linux/uaccess.h> 16 17 #include "../tools/testing/selftests/kselftest_module.h" 18 19 #define EXP1_IN_BITS (sizeof(exp1) * 8) 20 21 KSTM_MODULE_GLOBALS(); 22 23 static char pbl_buffer[PAGE_SIZE] __initdata; 24 static char print_buf[PAGE_SIZE * 2] __initdata; 25 26 static const unsigned long exp1[] __initconst = { 27 BITMAP_FROM_U64(1), 28 BITMAP_FROM_U64(2), 29 BITMAP_FROM_U64(0x0000ffff), 30 BITMAP_FROM_U64(0xffff0000), 31 BITMAP_FROM_U64(0x55555555), 32 BITMAP_FROM_U64(0xaaaaaaaa), 33 BITMAP_FROM_U64(0x11111111), 34 BITMAP_FROM_U64(0x22222222), 35 BITMAP_FROM_U64(0xffffffff), 36 BITMAP_FROM_U64(0xfffffffe), 37 BITMAP_FROM_U64(0x3333333311111111ULL), 38 BITMAP_FROM_U64(0xffffffff77777777ULL), 39 BITMAP_FROM_U64(0), 40 BITMAP_FROM_U64(0x00008000), 41 BITMAP_FROM_U64(0x80000000), 42 }; 43 44 static const unsigned long exp2[] __initconst = { 45 BITMAP_FROM_U64(0x3333333311111111ULL), 46 BITMAP_FROM_U64(0xffffffff77777777ULL), 47 }; 48 49 /* Fibonacci sequence */ 50 static const unsigned long exp2_to_exp3_mask[] __initconst = { 51 BITMAP_FROM_U64(0x008000020020212eULL), 52 }; 53 /* exp3_0_1 = (exp2[0] & ~exp2_to_exp3_mask) | (exp2[1] & exp2_to_exp3_mask) */ 54 static const unsigned long exp3_0_1[] __initconst = { 55 BITMAP_FROM_U64(0x33b3333311313137ULL), 56 }; 57 /* exp3_1_0 = (exp2[1] & ~exp2_to_exp3_mask) | (exp2[0] & exp2_to_exp3_mask) */ 58 static const unsigned long exp3_1_0[] __initconst = { 59 BITMAP_FROM_U64(0xff7fffff77575751ULL), 60 }; 61 62 static bool __init 63 __check_eq_ulong(const char *srcfile, unsigned int line, 64 const unsigned long exp_ulong, unsigned long x) 65 { 66 if (exp_ulong != x) { 67 pr_err("[%s:%u] expected %lu, got %lu\n", 68 srcfile, line, exp_ulong, x); 69 return false; 70 } 71 return true; 72 } 73 74 static bool __init 75 __check_eq_bitmap(const char *srcfile, unsigned int line, 76 const unsigned long *exp_bmap, const unsigned long *bmap, 77 unsigned int nbits) 78 { 79 if (!bitmap_equal(exp_bmap, bmap, nbits)) { 80 pr_warn("[%s:%u] bitmaps contents differ: expected \"%*pbl\", got \"%*pbl\"\n", 81 srcfile, line, 82 nbits, exp_bmap, nbits, bmap); 83 return false; 84 } 85 return true; 86 } 87 88 static bool __init 89 __check_eq_pbl(const char *srcfile, unsigned int line, 90 const char *expected_pbl, 91 const unsigned long *bitmap, unsigned int nbits) 92 { 93 snprintf(pbl_buffer, sizeof(pbl_buffer), "%*pbl", nbits, bitmap); 94 if (strcmp(expected_pbl, pbl_buffer)) { 95 pr_warn("[%s:%u] expected \"%s\", got \"%s\"\n", 96 srcfile, line, 97 expected_pbl, pbl_buffer); 98 return false; 99 } 100 return true; 101 } 102 103 static bool __init __check_eq_clump8(const char *srcfile, unsigned int line, 104 const unsigned int offset, 105 const unsigned int size, 106 const unsigned char *const clump_exp, 107 const unsigned long *const clump) 108 { 109 unsigned long exp; 110 111 if (offset >= size) { 112 pr_warn("[%s:%u] bit offset for clump out-of-bounds: expected less than %u, got %u\n", 113 srcfile, line, size, offset); 114 return false; 115 } 116 117 exp = clump_exp[offset / 8]; 118 if (!exp) { 119 pr_warn("[%s:%u] bit offset for zero clump: expected nonzero clump, got bit offset %u with clump value 0", 120 srcfile, line, offset); 121 return false; 122 } 123 124 if (*clump != exp) { 125 pr_warn("[%s:%u] expected clump value of 0x%lX, got clump value of 0x%lX", 126 srcfile, line, exp, *clump); 127 return false; 128 } 129 130 return true; 131 } 132 133 static bool __init 134 __check_eq_str(const char *srcfile, unsigned int line, 135 const char *exp_str, const char *str, 136 unsigned int len) 137 { 138 bool eq; 139 140 eq = strncmp(exp_str, str, len) == 0; 141 if (!eq) 142 pr_err("[%s:%u] expected %s, got %s\n", srcfile, line, exp_str, str); 143 144 return eq; 145 } 146 147 #define __expect_eq(suffix, ...) \ 148 ({ \ 149 int result = 0; \ 150 total_tests++; \ 151 if (!__check_eq_ ## suffix(__FILE__, __LINE__, \ 152 ##__VA_ARGS__)) { \ 153 failed_tests++; \ 154 result = 1; \ 155 } \ 156 result; \ 157 }) 158 159 #define expect_eq_ulong(...) __expect_eq(ulong, ##__VA_ARGS__) 160 #define expect_eq_uint(x, y) expect_eq_ulong((unsigned int)(x), (unsigned int)(y)) 161 #define expect_eq_bitmap(...) __expect_eq(bitmap, ##__VA_ARGS__) 162 #define expect_eq_pbl(...) __expect_eq(pbl, ##__VA_ARGS__) 163 #define expect_eq_u32_array(...) __expect_eq(u32_array, ##__VA_ARGS__) 164 #define expect_eq_clump8(...) __expect_eq(clump8, ##__VA_ARGS__) 165 #define expect_eq_str(...) __expect_eq(str, ##__VA_ARGS__) 166 167 static void __init test_zero_clear(void) 168 { 169 DECLARE_BITMAP(bmap, 1024); 170 171 /* Known way to set all bits */ 172 memset(bmap, 0xff, 128); 173 174 expect_eq_pbl("0-22", bmap, 23); 175 expect_eq_pbl("0-1023", bmap, 1024); 176 177 /* single-word bitmaps */ 178 bitmap_clear(bmap, 0, 9); 179 expect_eq_pbl("9-1023", bmap, 1024); 180 181 bitmap_zero(bmap, 35); 182 expect_eq_pbl("64-1023", bmap, 1024); 183 184 /* cross boundaries operations */ 185 bitmap_clear(bmap, 79, 19); 186 expect_eq_pbl("64-78,98-1023", bmap, 1024); 187 188 bitmap_zero(bmap, 115); 189 expect_eq_pbl("128-1023", bmap, 1024); 190 191 /* Zeroing entire area */ 192 bitmap_zero(bmap, 1024); 193 expect_eq_pbl("", bmap, 1024); 194 } 195 196 static void __init test_find_nth_bit(void) 197 { 198 unsigned long b, bit, cnt = 0; 199 DECLARE_BITMAP(bmap, 64 * 3); 200 201 bitmap_zero(bmap, 64 * 3); 202 __set_bit(10, bmap); 203 __set_bit(20, bmap); 204 __set_bit(30, bmap); 205 __set_bit(40, bmap); 206 __set_bit(50, bmap); 207 __set_bit(60, bmap); 208 __set_bit(80, bmap); 209 __set_bit(123, bmap); 210 211 expect_eq_uint(10, find_nth_bit(bmap, 64 * 3, 0)); 212 expect_eq_uint(20, find_nth_bit(bmap, 64 * 3, 1)); 213 expect_eq_uint(30, find_nth_bit(bmap, 64 * 3, 2)); 214 expect_eq_uint(40, find_nth_bit(bmap, 64 * 3, 3)); 215 expect_eq_uint(50, find_nth_bit(bmap, 64 * 3, 4)); 216 expect_eq_uint(60, find_nth_bit(bmap, 64 * 3, 5)); 217 expect_eq_uint(80, find_nth_bit(bmap, 64 * 3, 6)); 218 expect_eq_uint(123, find_nth_bit(bmap, 64 * 3, 7)); 219 expect_eq_uint(0, !!(find_nth_bit(bmap, 64 * 3, 8) < 64 * 3)); 220 221 expect_eq_uint(10, find_nth_bit(bmap, 64 * 3 - 1, 0)); 222 expect_eq_uint(20, find_nth_bit(bmap, 64 * 3 - 1, 1)); 223 expect_eq_uint(30, find_nth_bit(bmap, 64 * 3 - 1, 2)); 224 expect_eq_uint(40, find_nth_bit(bmap, 64 * 3 - 1, 3)); 225 expect_eq_uint(50, find_nth_bit(bmap, 64 * 3 - 1, 4)); 226 expect_eq_uint(60, find_nth_bit(bmap, 64 * 3 - 1, 5)); 227 expect_eq_uint(80, find_nth_bit(bmap, 64 * 3 - 1, 6)); 228 expect_eq_uint(123, find_nth_bit(bmap, 64 * 3 - 1, 7)); 229 expect_eq_uint(0, !!(find_nth_bit(bmap, 64 * 3 - 1, 8) < 64 * 3 - 1)); 230 231 for_each_set_bit(bit, exp1, EXP1_IN_BITS) { 232 b = find_nth_bit(exp1, EXP1_IN_BITS, cnt++); 233 expect_eq_uint(b, bit); 234 } 235 } 236 237 static void __init 238 test_bitmap_find_next_zero_area_off(void) 239 { 240 DECLARE_BITMAP(bmap, 192); 241 242 bitmap_set(bmap, 0, 192); 243 244 bitmap_clear(bmap, 0, 8); 245 __clear_bit(50, bmap); 246 bitmap_clear(bmap, 60, 18); 247 __set_bit(69, bmap); 248 __clear_bit(80, bmap); 249 bitmap_clear(bmap, 100, 10); 250 __clear_bit(120, bmap); 251 bitmap_clear(bmap, 145, 8); 252 bitmap_clear(bmap, 160, 32); 253 254 expect_eq_uint(0, 255 bitmap_find_next_zero_area_off(bmap, 192, 0, 8, 0, 0)); 256 expect_eq_uint(0, 257 bitmap_find_next_zero_area_off(bmap, 192, 0, 8, 3, 0)); 258 expect_eq_uint(163, 259 bitmap_find_next_zero_area_off(bmap, 192, 0, 8, 3, 1)); 260 expect_eq_uint(60, 261 bitmap_find_next_zero_area_off(bmap, 192, 1, 8, 0, 0)); 262 expect_eq_uint(160, 263 bitmap_find_next_zero_area_off(bmap, 192, 1, 8, 7, 0)); 264 expect_eq_uint(60, 265 bitmap_find_next_zero_area_off(bmap, 192, 1, 8, 7, 4)); 266 expect_eq_uint(100, 267 bitmap_find_next_zero_area_off(bmap, 192, 0, 10, 0, 0)); 268 expect_eq_uint(160, 269 bitmap_find_next_zero_area_off(bmap, 192, 0, 32, 0, 0)); 270 expect_eq_uint(1, 271 !!(bitmap_find_next_zero_area_off(bmap, 192, 0, 33, 0, 0) >= 192)); 272 } 273 274 static void __init test_fill_set(void) 275 { 276 DECLARE_BITMAP(bmap, 1024); 277 278 /* Known way to clear all bits */ 279 memset(bmap, 0x00, 128); 280 281 expect_eq_pbl("", bmap, 23); 282 expect_eq_pbl("", bmap, 1024); 283 284 /* single-word bitmaps */ 285 bitmap_set(bmap, 0, 9); 286 expect_eq_pbl("0-8", bmap, 1024); 287 288 bitmap_fill(bmap, 35); 289 expect_eq_pbl("0-63", bmap, 1024); 290 291 /* cross boundaries operations */ 292 bitmap_set(bmap, 79, 19); 293 expect_eq_pbl("0-63,79-97", bmap, 1024); 294 295 bitmap_fill(bmap, 115); 296 expect_eq_pbl("0-127", bmap, 1024); 297 298 /* Zeroing entire area */ 299 bitmap_fill(bmap, 1024); 300 expect_eq_pbl("0-1023", bmap, 1024); 301 } 302 303 static void __init test_copy(void) 304 { 305 DECLARE_BITMAP(bmap1, 1024); 306 DECLARE_BITMAP(bmap2, 1024); 307 308 bitmap_zero(bmap1, 1024); 309 bitmap_zero(bmap2, 1024); 310 311 /* single-word bitmaps */ 312 bitmap_set(bmap1, 0, 19); 313 bitmap_copy(bmap2, bmap1, 23); 314 expect_eq_pbl("0-18", bmap2, 1024); 315 316 bitmap_set(bmap2, 0, 23); 317 bitmap_copy(bmap2, bmap1, 23); 318 expect_eq_pbl("0-18", bmap2, 1024); 319 320 /* multi-word bitmaps */ 321 bitmap_set(bmap1, 0, 109); 322 bitmap_copy(bmap2, bmap1, 1024); 323 expect_eq_pbl("0-108", bmap2, 1024); 324 325 bitmap_fill(bmap2, 1024); 326 bitmap_copy(bmap2, bmap1, 1024); 327 expect_eq_pbl("0-108", bmap2, 1024); 328 329 /* the following tests assume a 32- or 64-bit arch (even 128b 330 * if we care) 331 */ 332 333 bitmap_fill(bmap2, 1024); 334 bitmap_copy(bmap2, bmap1, 109); /* ... but 0-padded til word length */ 335 expect_eq_pbl("0-108,128-1023", bmap2, 1024); 336 337 bitmap_fill(bmap2, 1024); 338 bitmap_copy(bmap2, bmap1, 97); /* ... but aligned on word length */ 339 expect_eq_pbl("0-108,128-1023", bmap2, 1024); 340 } 341 342 static void __init test_bitmap_region(void) 343 { 344 int pos, order; 345 346 DECLARE_BITMAP(bmap, 1000); 347 348 bitmap_zero(bmap, 1000); 349 350 for (order = 0; order < 10; order++) { 351 pos = bitmap_find_free_region(bmap, 1000, order); 352 if (order == 0) 353 expect_eq_uint(pos, 0); 354 else 355 expect_eq_uint(pos, order < 9 ? BIT(order) : -ENOMEM); 356 } 357 358 bitmap_release_region(bmap, 0, 0); 359 for (order = 1; order < 9; order++) 360 bitmap_release_region(bmap, BIT(order), order); 361 362 expect_eq_uint(bitmap_weight(bmap, 1000), 0); 363 } 364 365 #define EXP2_IN_BITS (sizeof(exp2) * 8) 366 367 static void __init test_replace(void) 368 { 369 unsigned int nbits = 64; 370 unsigned int nlongs = DIV_ROUND_UP(nbits, BITS_PER_LONG); 371 DECLARE_BITMAP(bmap, 1024); 372 373 BUILD_BUG_ON(EXP2_IN_BITS < nbits * 2); 374 375 bitmap_zero(bmap, 1024); 376 bitmap_replace(bmap, &exp2[0 * nlongs], &exp2[1 * nlongs], exp2_to_exp3_mask, nbits); 377 expect_eq_bitmap(bmap, exp3_0_1, nbits); 378 379 bitmap_zero(bmap, 1024); 380 bitmap_replace(bmap, &exp2[1 * nlongs], &exp2[0 * nlongs], exp2_to_exp3_mask, nbits); 381 expect_eq_bitmap(bmap, exp3_1_0, nbits); 382 383 bitmap_fill(bmap, 1024); 384 bitmap_replace(bmap, &exp2[0 * nlongs], &exp2[1 * nlongs], exp2_to_exp3_mask, nbits); 385 expect_eq_bitmap(bmap, exp3_0_1, nbits); 386 387 bitmap_fill(bmap, 1024); 388 bitmap_replace(bmap, &exp2[1 * nlongs], &exp2[0 * nlongs], exp2_to_exp3_mask, nbits); 389 expect_eq_bitmap(bmap, exp3_1_0, nbits); 390 } 391 392 static const unsigned long sg_mask[] __initconst = { 393 BITMAP_FROM_U64(0x000000000000035aULL), 394 BITMAP_FROM_U64(0x0000000000000000ULL), 395 }; 396 397 static const unsigned long sg_src[] __initconst = { 398 BITMAP_FROM_U64(0x0000000000000667ULL), 399 BITMAP_FROM_U64(0x0000000000000000ULL), 400 }; 401 402 static const unsigned long sg_gather_exp[] __initconst = { 403 BITMAP_FROM_U64(0x0000000000000029ULL), 404 BITMAP_FROM_U64(0x0000000000000000ULL), 405 }; 406 407 static const unsigned long sg_scatter_exp[] __initconst = { 408 BITMAP_FROM_U64(0x000000000000021aULL), 409 BITMAP_FROM_U64(0x0000000000000000ULL), 410 }; 411 412 static void __init test_bitmap_sg(void) 413 { 414 unsigned int nbits = 64; 415 DECLARE_BITMAP(bmap_gather, 100); 416 DECLARE_BITMAP(bmap_scatter, 100); 417 DECLARE_BITMAP(bmap_tmp, 100); 418 DECLARE_BITMAP(bmap_res, 100); 419 420 /* Simple gather call */ 421 bitmap_zero(bmap_gather, 100); 422 bitmap_gather(bmap_gather, sg_src, sg_mask, nbits); 423 expect_eq_bitmap(sg_gather_exp, bmap_gather, 100); 424 425 /* Simple scatter call */ 426 bitmap_zero(bmap_scatter, 100); 427 bitmap_scatter(bmap_scatter, sg_src, sg_mask, nbits); 428 expect_eq_bitmap(sg_scatter_exp, bmap_scatter, 100); 429 430 /* Scatter/gather relationship */ 431 bitmap_zero(bmap_tmp, 100); 432 bitmap_zero(bmap_res, 100); 433 bitmap_gather(bmap_tmp, bmap_scatter, sg_mask, nbits); 434 bitmap_scatter(bmap_res, bmap_tmp, sg_mask, nbits); 435 expect_eq_bitmap(bmap_scatter, bmap_res, 100); 436 } 437 438 #define PARSE_TIME 0x1 439 #define NO_LEN 0x2 440 441 struct test_bitmap_parselist{ 442 const int errno; 443 const char *in; 444 const unsigned long *expected; 445 const int nbits; 446 const int flags; 447 }; 448 449 static const struct test_bitmap_parselist parselist_tests[] __initconst = { 450 #define step (sizeof(u64) / sizeof(unsigned long)) 451 452 {0, "0", &exp1[0], 8, 0}, 453 {0, "1", &exp1[1 * step], 8, 0}, 454 {0, "0-15", &exp1[2 * step], 32, 0}, 455 {0, "16-31", &exp1[3 * step], 32, 0}, 456 {0, "0-31:1/2", &exp1[4 * step], 32, 0}, 457 {0, "1-31:1/2", &exp1[5 * step], 32, 0}, 458 {0, "0-31:1/4", &exp1[6 * step], 32, 0}, 459 {0, "1-31:1/4", &exp1[7 * step], 32, 0}, 460 {0, "0-31:4/4", &exp1[8 * step], 32, 0}, 461 {0, "1-31:4/4", &exp1[9 * step], 32, 0}, 462 {0, "0-31:1/4,32-63:2/4", &exp1[10 * step], 64, 0}, 463 {0, "0-31:3/4,32-63:4/4", &exp1[11 * step], 64, 0}, 464 {0, " ,, 0-31:3/4 ,, 32-63:4/4 ,, ", &exp1[11 * step], 64, 0}, 465 466 {0, "0-31:1/4,32-63:2/4,64-95:3/4,96-127:4/4", exp2, 128, 0}, 467 468 {0, "0-2047:128/256", NULL, 2048, PARSE_TIME}, 469 470 {0, "", &exp1[12 * step], 8, 0}, 471 {0, "\n", &exp1[12 * step], 8, 0}, 472 {0, ",, ,, , , ,", &exp1[12 * step], 8, 0}, 473 {0, " , ,, , , ", &exp1[12 * step], 8, 0}, 474 {0, " , ,, , , \n", &exp1[12 * step], 8, 0}, 475 476 {0, "0-0", &exp1[0], 32, 0}, 477 {0, "1-1", &exp1[1 * step], 32, 0}, 478 {0, "15-15", &exp1[13 * step], 32, 0}, 479 {0, "31-31", &exp1[14 * step], 32, 0}, 480 481 {0, "0-0:0/1", &exp1[12 * step], 32, 0}, 482 {0, "0-0:1/1", &exp1[0], 32, 0}, 483 {0, "0-0:1/31", &exp1[0], 32, 0}, 484 {0, "0-0:31/31", &exp1[0], 32, 0}, 485 {0, "1-1:1/1", &exp1[1 * step], 32, 0}, 486 {0, "0-15:16/31", &exp1[2 * step], 32, 0}, 487 {0, "15-15:1/2", &exp1[13 * step], 32, 0}, 488 {0, "15-15:31/31", &exp1[13 * step], 32, 0}, 489 {0, "15-31:1/31", &exp1[13 * step], 32, 0}, 490 {0, "16-31:16/31", &exp1[3 * step], 32, 0}, 491 {0, "31-31:31/31", &exp1[14 * step], 32, 0}, 492 493 {0, "N-N", &exp1[14 * step], 32, 0}, 494 {0, "0-0:1/N", &exp1[0], 32, 0}, 495 {0, "0-0:N/N", &exp1[0], 32, 0}, 496 {0, "0-15:16/N", &exp1[2 * step], 32, 0}, 497 {0, "15-15:N/N", &exp1[13 * step], 32, 0}, 498 {0, "15-N:1/N", &exp1[13 * step], 32, 0}, 499 {0, "16-N:16/N", &exp1[3 * step], 32, 0}, 500 {0, "N-N:N/N", &exp1[14 * step], 32, 0}, 501 502 {0, "0-N:1/3,1-N:1/3,2-N:1/3", &exp1[8 * step], 32, 0}, 503 {0, "0-31:1/3,1-31:1/3,2-31:1/3", &exp1[8 * step], 32, 0}, 504 {0, "1-10:8/12,8-31:24/29,0-31:0/3", &exp1[9 * step], 32, 0}, 505 {0, "1-1:1/4294967295", &exp1[1 * step], 32, 0}, 506 {0, "15-15:1/4294967281", &exp1[13 * step], 32, 0}, 507 508 {0, "all", &exp1[8 * step], 32, 0}, 509 {0, "0, 1, all, ", &exp1[8 * step], 32, 0}, 510 {0, "all:1/2", &exp1[4 * step], 32, 0}, 511 {0, "ALL:1/2", &exp1[4 * step], 32, 0}, 512 {-EINVAL, "al", NULL, 8, 0}, 513 {-EINVAL, "alll", NULL, 8, 0}, 514 515 {-EINVAL, "-1", NULL, 8, 0}, 516 {-EINVAL, "-0", NULL, 8, 0}, 517 {-EINVAL, "10-1", NULL, 8, 0}, 518 {-ERANGE, "8-8", NULL, 8, 0}, 519 {-ERANGE, "0-31", NULL, 8, 0}, 520 {-EINVAL, "0-31:", NULL, 32, 0}, 521 {-EINVAL, "0-31:0", NULL, 32, 0}, 522 {-EINVAL, "0-31:0/", NULL, 32, 0}, 523 {-EINVAL, "0-31:0/0", NULL, 32, 0}, 524 {-EINVAL, "0-31:1/0", NULL, 32, 0}, 525 {-EINVAL, "0-31:10/1", NULL, 32, 0}, 526 {-EOVERFLOW, "0-98765432123456789:10/1", NULL, 8, 0}, 527 528 {-EINVAL, "a-31", NULL, 8, 0}, 529 {-EINVAL, "0-a1", NULL, 8, 0}, 530 {-EINVAL, "a-31:10/1", NULL, 8, 0}, 531 {-EINVAL, "0-31:a/1", NULL, 8, 0}, 532 {-EINVAL, "0-\n", NULL, 8, 0}, 533 {-EINVAL, "0-7:1/2N", NULL, 8, 0}, 534 {-EINVAL, "0-7:1/2all", NULL, 8, 0}, 535 {-EINVAL, "all:1/2N", NULL, 8, 0}, 536 537 }; 538 539 static void __init test_bitmap_parselist(void) 540 { 541 int i; 542 int err; 543 ktime_t time; 544 DECLARE_BITMAP(bmap, 2048); 545 546 for (i = 0; i < ARRAY_SIZE(parselist_tests); i++) { 547 #define ptest parselist_tests[i] 548 549 time = ktime_get(); 550 err = bitmap_parselist(ptest.in, bmap, ptest.nbits); 551 time = ktime_get() - time; 552 553 if (err != ptest.errno) { 554 pr_err("parselist: %d: input is %s, errno is %d, expected %d\n", 555 i, ptest.in, err, ptest.errno); 556 failed_tests++; 557 continue; 558 } 559 560 if (!err && ptest.expected 561 && !__bitmap_equal(bmap, ptest.expected, ptest.nbits)) { 562 pr_err("parselist: %d: input is %s, result is 0x%lx, expected 0x%lx\n", 563 i, ptest.in, bmap[0], 564 *ptest.expected); 565 failed_tests++; 566 continue; 567 } 568 569 if (ptest.flags & PARSE_TIME) 570 pr_info("parselist('%s'):\t%llu\n", ptest.in, time); 571 572 #undef ptest 573 } 574 } 575 576 static void __init test_bitmap_printlist(void) 577 { 578 unsigned long *bmap = kmalloc(PAGE_SIZE, GFP_KERNEL); 579 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 580 char expected[256]; 581 int ret, slen; 582 ktime_t time; 583 584 if (!buf || !bmap) 585 goto out; 586 587 memset(bmap, -1, PAGE_SIZE); 588 slen = snprintf(expected, 256, "0-%ld", PAGE_SIZE * 8 - 1); 589 if (slen < 0) 590 goto out; 591 592 time = ktime_get(); 593 ret = scnprintf(buf, PAGE_SIZE, "%*pbl", (int)PAGE_SIZE * 8, bmap); 594 time = ktime_get() - time; 595 596 if (ret != slen) { 597 pr_err("scnprintf(\"%%*pbl\"): result is %d, expected %d\n", ret, slen); 598 failed_tests++; 599 goto out; 600 } 601 602 if (strncmp(buf, expected, slen)) { 603 pr_err("scnprintf(\"%%*pbl\"): result is %s, expected %s\n", buf, expected); 604 failed_tests++; 605 goto out; 606 } 607 608 pr_info("scnprintf(\"%%*pbl\", '%s'):\t%llu\n", buf, time); 609 out: 610 kfree(buf); 611 kfree(bmap); 612 } 613 614 static const unsigned long parse_test[] __initconst = { 615 BITMAP_FROM_U64(0), 616 BITMAP_FROM_U64(1), 617 BITMAP_FROM_U64(0xdeadbeef), 618 BITMAP_FROM_U64(0x100000000ULL), 619 }; 620 621 static const unsigned long parse_test2[] __initconst = { 622 BITMAP_FROM_U64(0x100000000ULL), BITMAP_FROM_U64(0xdeadbeef), 623 BITMAP_FROM_U64(0x100000000ULL), BITMAP_FROM_U64(0xbaadf00ddeadbeef), 624 BITMAP_FROM_U64(0x100000000ULL), BITMAP_FROM_U64(0x0badf00ddeadbeef), 625 }; 626 627 static const struct test_bitmap_parselist parse_tests[] __initconst = { 628 {0, "", &parse_test[0 * step], 32, 0}, 629 {0, " ", &parse_test[0 * step], 32, 0}, 630 {0, "0", &parse_test[0 * step], 32, 0}, 631 {0, "0\n", &parse_test[0 * step], 32, 0}, 632 {0, "1", &parse_test[1 * step], 32, 0}, 633 {0, "deadbeef", &parse_test[2 * step], 32, 0}, 634 {0, "1,0", &parse_test[3 * step], 33, 0}, 635 {0, "deadbeef,\n,0,1", &parse_test[2 * step], 96, 0}, 636 637 {0, "deadbeef,1,0", &parse_test2[0 * 2 * step], 96, 0}, 638 {0, "baadf00d,deadbeef,1,0", &parse_test2[1 * 2 * step], 128, 0}, 639 {0, "badf00d,deadbeef,1,0", &parse_test2[2 * 2 * step], 124, 0}, 640 {0, "badf00d,deadbeef,1,0", &parse_test2[2 * 2 * step], 124, NO_LEN}, 641 {0, " badf00d,deadbeef,1,0 ", &parse_test2[2 * 2 * step], 124, 0}, 642 {0, " , badf00d,deadbeef,1,0 , ", &parse_test2[2 * 2 * step], 124, 0}, 643 {0, " , badf00d, ,, ,,deadbeef,1,0 , ", &parse_test2[2 * 2 * step], 124, 0}, 644 645 {-EINVAL, "goodfood,deadbeef,1,0", NULL, 128, 0}, 646 {-EOVERFLOW, "3,0", NULL, 33, 0}, 647 {-EOVERFLOW, "123badf00d,deadbeef,1,0", NULL, 128, 0}, 648 {-EOVERFLOW, "badf00d,deadbeef,1,0", NULL, 90, 0}, 649 {-EOVERFLOW, "fbadf00d,deadbeef,1,0", NULL, 95, 0}, 650 {-EOVERFLOW, "badf00d,deadbeef,1,0", NULL, 100, 0}, 651 652 {-EINVAL, "x12345678", NULL, 32, 0}, 653 {-EINVAL, "1g12345678", NULL, 64, 0}, 654 {-EINVAL, "0x0000000f", NULL, 64, 0}, 655 #undef step 656 }; 657 658 static void __init test_bitmap_parse(void) 659 { 660 int i; 661 int err; 662 ktime_t time; 663 DECLARE_BITMAP(bmap, 2048); 664 665 for (i = 0; i < ARRAY_SIZE(parse_tests); i++) { 666 struct test_bitmap_parselist test = parse_tests[i]; 667 size_t len = test.flags & NO_LEN ? UINT_MAX : strlen(test.in); 668 669 time = ktime_get(); 670 err = bitmap_parse(test.in, len, bmap, test.nbits); 671 time = ktime_get() - time; 672 673 if (err != test.errno) { 674 pr_err("parse: %d: input is %s, errno is %d, expected %d\n", 675 i, test.in, err, test.errno); 676 failed_tests++; 677 continue; 678 } 679 680 if (!err && test.expected 681 && !__bitmap_equal(bmap, test.expected, test.nbits)) { 682 pr_err("parse: %d: input is %s, result is 0x%lx, expected 0x%lx\n", 683 i, test.in, bmap[0], 684 *test.expected); 685 failed_tests++; 686 continue; 687 } 688 689 if (test.flags & PARSE_TIME) 690 pr_info("parse: %d: input is '%s' OK, Time: %llu\n", 691 i, test.in, time); 692 } 693 } 694 695 static void __init test_bitmap_arr32(void) 696 { 697 unsigned int nbits, next_bit; 698 u32 arr[EXP1_IN_BITS / 32]; 699 DECLARE_BITMAP(bmap2, EXP1_IN_BITS); 700 701 memset(arr, 0xa5, sizeof(arr)); 702 703 for (nbits = 1; nbits < EXP1_IN_BITS; ++nbits) { 704 bitmap_to_arr32(arr, exp1, nbits); 705 bitmap_from_arr32(bmap2, arr, nbits); 706 expect_eq_bitmap(bmap2, exp1, nbits); 707 708 next_bit = find_next_bit(bmap2, 709 round_up(nbits, BITS_PER_LONG), nbits); 710 if (next_bit < round_up(nbits, BITS_PER_LONG)) { 711 pr_err("bitmap_copy_arr32(nbits == %d:" 712 " tail is not safely cleared: %d\n", 713 nbits, next_bit); 714 failed_tests++; 715 } 716 717 if (nbits < EXP1_IN_BITS - 32) 718 expect_eq_uint(arr[DIV_ROUND_UP(nbits, 32)], 719 0xa5a5a5a5); 720 } 721 } 722 723 static void __init test_bitmap_arr64(void) 724 { 725 unsigned int nbits, next_bit; 726 u64 arr[EXP1_IN_BITS / 64]; 727 DECLARE_BITMAP(bmap2, EXP1_IN_BITS); 728 729 memset(arr, 0xa5, sizeof(arr)); 730 731 for (nbits = 1; nbits < EXP1_IN_BITS; ++nbits) { 732 memset(bmap2, 0xff, sizeof(arr)); 733 bitmap_to_arr64(arr, exp1, nbits); 734 bitmap_from_arr64(bmap2, arr, nbits); 735 expect_eq_bitmap(bmap2, exp1, nbits); 736 737 next_bit = find_next_bit(bmap2, round_up(nbits, BITS_PER_LONG), nbits); 738 if (next_bit < round_up(nbits, BITS_PER_LONG)) { 739 pr_err("bitmap_copy_arr64(nbits == %d:" 740 " tail is not safely cleared: %d\n", nbits, next_bit); 741 failed_tests++; 742 } 743 744 if ((nbits % 64) && 745 (arr[(nbits - 1) / 64] & ~GENMASK_ULL((nbits - 1) % 64, 0))) { 746 pr_err("bitmap_to_arr64(nbits == %d): tail is not safely cleared: 0x%016llx (must be 0x%016llx)\n", 747 nbits, arr[(nbits - 1) / 64], 748 GENMASK_ULL((nbits - 1) % 64, 0)); 749 failed_tests++; 750 } 751 752 if (nbits < EXP1_IN_BITS - 64) 753 expect_eq_uint(arr[DIV_ROUND_UP(nbits, 64)], 0xa5a5a5a5); 754 } 755 } 756 757 static void noinline __init test_mem_optimisations(void) 758 { 759 DECLARE_BITMAP(bmap1, 1024); 760 DECLARE_BITMAP(bmap2, 1024); 761 unsigned int start, nbits; 762 763 for (start = 0; start < 1024; start += 8) { 764 for (nbits = 1; nbits < 1024 - start; nbits += 8) { 765 memset(bmap1, 0x5a, sizeof(bmap1)); 766 memset(bmap2, 0x5a, sizeof(bmap2)); 767 768 bitmap_set(bmap1, start, nbits); 769 __bitmap_set(bmap2, start, nbits); 770 if (!bitmap_equal(bmap1, bmap2, 1024)) { 771 printk("set not equal %d %d\n", start, nbits); 772 failed_tests++; 773 } 774 if (!__bitmap_equal(bmap1, bmap2, 1024)) { 775 printk("set not __equal %d %d\n", start, nbits); 776 failed_tests++; 777 } 778 779 bitmap_clear(bmap1, start, nbits); 780 __bitmap_clear(bmap2, start, nbits); 781 if (!bitmap_equal(bmap1, bmap2, 1024)) { 782 printk("clear not equal %d %d\n", start, nbits); 783 failed_tests++; 784 } 785 if (!__bitmap_equal(bmap1, bmap2, 1024)) { 786 printk("clear not __equal %d %d\n", start, 787 nbits); 788 failed_tests++; 789 } 790 } 791 } 792 } 793 794 static const unsigned char clump_exp[] __initconst = { 795 0x01, /* 1 bit set */ 796 0x02, /* non-edge 1 bit set */ 797 0x00, /* zero bits set */ 798 0x38, /* 3 bits set across 4-bit boundary */ 799 0x38, /* Repeated clump */ 800 0x0F, /* 4 bits set */ 801 0xFF, /* all bits set */ 802 0x05, /* non-adjacent 2 bits set */ 803 }; 804 805 static void __init test_for_each_set_clump8(void) 806 { 807 #define CLUMP_EXP_NUMBITS 64 808 DECLARE_BITMAP(bits, CLUMP_EXP_NUMBITS); 809 unsigned int start; 810 unsigned long clump; 811 812 /* set bitmap to test case */ 813 bitmap_zero(bits, CLUMP_EXP_NUMBITS); 814 bitmap_set(bits, 0, 1); /* 0x01 */ 815 bitmap_set(bits, 9, 1); /* 0x02 */ 816 bitmap_set(bits, 27, 3); /* 0x28 */ 817 bitmap_set(bits, 35, 3); /* 0x28 */ 818 bitmap_set(bits, 40, 4); /* 0x0F */ 819 bitmap_set(bits, 48, 8); /* 0xFF */ 820 bitmap_set(bits, 56, 1); /* 0x05 - part 1 */ 821 bitmap_set(bits, 58, 1); /* 0x05 - part 2 */ 822 823 for_each_set_clump8(start, clump, bits, CLUMP_EXP_NUMBITS) 824 expect_eq_clump8(start, CLUMP_EXP_NUMBITS, clump_exp, &clump); 825 } 826 827 static void __init test_for_each_set_bit_wrap(void) 828 { 829 DECLARE_BITMAP(orig, 500); 830 DECLARE_BITMAP(copy, 500); 831 unsigned int wr, bit; 832 833 bitmap_zero(orig, 500); 834 835 /* Set individual bits */ 836 for (bit = 0; bit < 500; bit += 10) 837 bitmap_set(orig, bit, 1); 838 839 /* Set range of bits */ 840 bitmap_set(orig, 100, 50); 841 842 for (wr = 0; wr < 500; wr++) { 843 bitmap_zero(copy, 500); 844 845 for_each_set_bit_wrap(bit, orig, 500, wr) 846 bitmap_set(copy, bit, 1); 847 848 expect_eq_bitmap(orig, copy, 500); 849 } 850 } 851 852 static void __init test_for_each_set_bit(void) 853 { 854 DECLARE_BITMAP(orig, 500); 855 DECLARE_BITMAP(copy, 500); 856 unsigned int bit; 857 858 bitmap_zero(orig, 500); 859 bitmap_zero(copy, 500); 860 861 /* Set individual bits */ 862 for (bit = 0; bit < 500; bit += 10) 863 bitmap_set(orig, bit, 1); 864 865 /* Set range of bits */ 866 bitmap_set(orig, 100, 50); 867 868 for_each_set_bit(bit, orig, 500) 869 bitmap_set(copy, bit, 1); 870 871 expect_eq_bitmap(orig, copy, 500); 872 } 873 874 static void __init test_for_each_set_bit_from(void) 875 { 876 DECLARE_BITMAP(orig, 500); 877 DECLARE_BITMAP(copy, 500); 878 unsigned int wr, bit; 879 880 bitmap_zero(orig, 500); 881 882 /* Set individual bits */ 883 for (bit = 0; bit < 500; bit += 10) 884 bitmap_set(orig, bit, 1); 885 886 /* Set range of bits */ 887 bitmap_set(orig, 100, 50); 888 889 for (wr = 0; wr < 500; wr++) { 890 DECLARE_BITMAP(tmp, 500); 891 892 bitmap_zero(copy, 500); 893 bit = wr; 894 895 for_each_set_bit_from(bit, orig, 500) 896 bitmap_set(copy, bit, 1); 897 898 bitmap_copy(tmp, orig, 500); 899 bitmap_clear(tmp, 0, wr); 900 expect_eq_bitmap(tmp, copy, 500); 901 } 902 } 903 904 static void __init test_bitmap_weight(void) 905 { 906 unsigned int bit, w1, w2, w; 907 DECLARE_BITMAP(b, 30); 908 DECLARE_BITMAP(b1, 128); 909 910 bitmap_parselist("all:1/2", b, 30); 911 912 /* Test inline implementation */ 913 w = bitmap_weight(b, 30); 914 w1 = bitmap_weight(b, 15); 915 w2 = bitmap_weight_from(b, 15, 30); 916 917 expect_eq_uint(15, w); 918 expect_eq_uint(8, w1); 919 expect_eq_uint(7, w2); 920 921 /* Test outline implementation */ 922 w = bitmap_weight(exp1, EXP1_IN_BITS); 923 for (bit = 1; bit < EXP1_IN_BITS; bit++) { 924 w1 = bitmap_weight(exp1, bit); 925 w2 = bitmap_weight_from(exp1, bit, EXP1_IN_BITS); 926 expect_eq_uint(w1 + w2, w); 927 } 928 929 /* Test out-of-range */ 930 w = bitmap_weight_from(b, 31, 30); 931 expect_eq_uint(0, !!(w < 30)); 932 933 /* 934 * Test bitmap_weight() for correctness in case of some bits set between 935 * nbits and end of the last word. 936 */ 937 bitmap_fill(b1, 128); 938 939 /* Inline */ 940 expect_eq_uint(30, bitmap_weight(b1, 30)); 941 expect_eq_uint(100, bitmap_weight(b1, 100)); 942 943 /* Outline */ 944 for (int i = 1; i < 128; i++) 945 expect_eq_uint(i, bitmap_weight(b1, i)); 946 } 947 948 static void __init test_for_each_clear_bit(void) 949 { 950 DECLARE_BITMAP(orig, 500); 951 DECLARE_BITMAP(copy, 500); 952 unsigned int bit; 953 954 bitmap_fill(orig, 500); 955 bitmap_fill(copy, 500); 956 957 /* Set individual bits */ 958 for (bit = 0; bit < 500; bit += 10) 959 bitmap_clear(orig, bit, 1); 960 961 /* Set range of bits */ 962 bitmap_clear(orig, 100, 50); 963 964 for_each_clear_bit(bit, orig, 500) 965 bitmap_clear(copy, bit, 1); 966 967 expect_eq_bitmap(orig, copy, 500); 968 } 969 970 static void __init test_for_each_clear_bit_from(void) 971 { 972 DECLARE_BITMAP(orig, 500); 973 DECLARE_BITMAP(copy, 500); 974 unsigned int wr, bit; 975 976 bitmap_fill(orig, 500); 977 978 /* Set individual bits */ 979 for (bit = 0; bit < 500; bit += 10) 980 bitmap_clear(orig, bit, 1); 981 982 /* Set range of bits */ 983 bitmap_clear(orig, 100, 50); 984 985 for (wr = 0; wr < 500; wr++) { 986 DECLARE_BITMAP(tmp, 500); 987 988 bitmap_fill(copy, 500); 989 bit = wr; 990 991 for_each_clear_bit_from(bit, orig, 500) 992 bitmap_clear(copy, bit, 1); 993 994 bitmap_copy(tmp, orig, 500); 995 bitmap_set(tmp, 0, wr); 996 expect_eq_bitmap(tmp, copy, 500); 997 } 998 } 999 1000 static void __init test_for_each_set_bitrange(void) 1001 { 1002 DECLARE_BITMAP(orig, 500); 1003 DECLARE_BITMAP(copy, 500); 1004 unsigned int s, e; 1005 1006 bitmap_zero(orig, 500); 1007 bitmap_zero(copy, 500); 1008 1009 /* Set individual bits */ 1010 for (s = 0; s < 500; s += 10) 1011 bitmap_set(orig, s, 1); 1012 1013 /* Set range of bits */ 1014 bitmap_set(orig, 100, 50); 1015 1016 for_each_set_bitrange(s, e, orig, 500) 1017 bitmap_set(copy, s, e-s); 1018 1019 expect_eq_bitmap(orig, copy, 500); 1020 } 1021 1022 static void __init test_for_each_clear_bitrange(void) 1023 { 1024 DECLARE_BITMAP(orig, 500); 1025 DECLARE_BITMAP(copy, 500); 1026 unsigned int s, e; 1027 1028 bitmap_fill(orig, 500); 1029 bitmap_fill(copy, 500); 1030 1031 /* Set individual bits */ 1032 for (s = 0; s < 500; s += 10) 1033 bitmap_clear(orig, s, 1); 1034 1035 /* Set range of bits */ 1036 bitmap_clear(orig, 100, 50); 1037 1038 for_each_clear_bitrange(s, e, orig, 500) 1039 bitmap_clear(copy, s, e-s); 1040 1041 expect_eq_bitmap(orig, copy, 500); 1042 } 1043 1044 static void __init test_for_each_set_bitrange_from(void) 1045 { 1046 DECLARE_BITMAP(orig, 500); 1047 DECLARE_BITMAP(copy, 500); 1048 unsigned int wr, s, e; 1049 1050 bitmap_zero(orig, 500); 1051 1052 /* Set individual bits */ 1053 for (s = 0; s < 500; s += 10) 1054 bitmap_set(orig, s, 1); 1055 1056 /* Set range of bits */ 1057 bitmap_set(orig, 100, 50); 1058 1059 for (wr = 0; wr < 500; wr++) { 1060 DECLARE_BITMAP(tmp, 500); 1061 1062 bitmap_zero(copy, 500); 1063 s = wr; 1064 1065 for_each_set_bitrange_from(s, e, orig, 500) 1066 bitmap_set(copy, s, e - s); 1067 1068 bitmap_copy(tmp, orig, 500); 1069 bitmap_clear(tmp, 0, wr); 1070 expect_eq_bitmap(tmp, copy, 500); 1071 } 1072 } 1073 1074 static void __init test_for_each_clear_bitrange_from(void) 1075 { 1076 DECLARE_BITMAP(orig, 500); 1077 DECLARE_BITMAP(copy, 500); 1078 unsigned int wr, s, e; 1079 1080 bitmap_fill(orig, 500); 1081 1082 /* Set individual bits */ 1083 for (s = 0; s < 500; s += 10) 1084 bitmap_clear(orig, s, 1); 1085 1086 /* Set range of bits */ 1087 bitmap_set(orig, 100, 50); 1088 1089 for (wr = 0; wr < 500; wr++) { 1090 DECLARE_BITMAP(tmp, 500); 1091 1092 bitmap_fill(copy, 500); 1093 s = wr; 1094 1095 for_each_clear_bitrange_from(s, e, orig, 500) 1096 bitmap_clear(copy, s, e - s); 1097 1098 bitmap_copy(tmp, orig, 500); 1099 bitmap_set(tmp, 0, wr); 1100 expect_eq_bitmap(tmp, copy, 500); 1101 } 1102 } 1103 1104 struct test_bitmap_cut { 1105 unsigned int first; 1106 unsigned int cut; 1107 unsigned int nbits; 1108 unsigned long in[4]; 1109 unsigned long expected[4]; 1110 }; 1111 1112 static struct test_bitmap_cut test_cut[] = { 1113 { 0, 0, 8, { 0x0000000aUL, }, { 0x0000000aUL, }, }, 1114 { 0, 0, 32, { 0xdadadeadUL, }, { 0xdadadeadUL, }, }, 1115 { 0, 3, 8, { 0x000000aaUL, }, { 0x00000015UL, }, }, 1116 { 3, 3, 8, { 0x000000aaUL, }, { 0x00000012UL, }, }, 1117 { 0, 1, 32, { 0xa5a5a5a5UL, }, { 0x52d2d2d2UL, }, }, 1118 { 0, 8, 32, { 0xdeadc0deUL, }, { 0x00deadc0UL, }, }, 1119 { 1, 1, 32, { 0x5a5a5a5aUL, }, { 0x2d2d2d2cUL, }, }, 1120 { 0, 15, 32, { 0xa5a5a5a5UL, }, { 0x00014b4bUL, }, }, 1121 { 0, 16, 32, { 0xa5a5a5a5UL, }, { 0x0000a5a5UL, }, }, 1122 { 15, 15, 32, { 0xa5a5a5a5UL, }, { 0x000125a5UL, }, }, 1123 { 15, 16, 32, { 0xa5a5a5a5UL, }, { 0x0000a5a5UL, }, }, 1124 { 16, 15, 32, { 0xa5a5a5a5UL, }, { 0x0001a5a5UL, }, }, 1125 1126 { BITS_PER_LONG, BITS_PER_LONG, BITS_PER_LONG, 1127 { 0xa5a5a5a5UL, 0xa5a5a5a5UL, }, 1128 { 0xa5a5a5a5UL, 0xa5a5a5a5UL, }, 1129 }, 1130 { 1, BITS_PER_LONG - 1, BITS_PER_LONG, 1131 { 0xa5a5a5a5UL, 0xa5a5a5a5UL, }, 1132 { 0x00000001UL, 0x00000001UL, }, 1133 }, 1134 1135 { 0, BITS_PER_LONG * 2, BITS_PER_LONG * 2 + 1, 1136 { 0xa5a5a5a5UL, 0x00000001UL, 0x00000001UL, 0x00000001UL }, 1137 { 0x00000001UL, }, 1138 }, 1139 { 16, BITS_PER_LONG * 2 + 1, BITS_PER_LONG * 2 + 1 + 16, 1140 { 0x0000ffffUL, 0x5a5a5a5aUL, 0x5a5a5a5aUL, 0x5a5a5a5aUL }, 1141 { 0x2d2dffffUL, }, 1142 }, 1143 }; 1144 1145 static void __init test_bitmap_cut(void) 1146 { 1147 unsigned long b[5], *in = &b[1], *out = &b[0]; /* Partial overlap */ 1148 int i; 1149 1150 for (i = 0; i < ARRAY_SIZE(test_cut); i++) { 1151 struct test_bitmap_cut *t = &test_cut[i]; 1152 1153 memcpy(in, t->in, sizeof(t->in)); 1154 1155 bitmap_cut(out, in, t->first, t->cut, t->nbits); 1156 1157 expect_eq_bitmap(t->expected, out, t->nbits); 1158 } 1159 } 1160 1161 struct test_bitmap_print { 1162 const unsigned long *bitmap; 1163 unsigned long nbits; 1164 const char *mask; 1165 const char *list; 1166 }; 1167 1168 static const unsigned long small_bitmap[] __initconst = { 1169 BITMAP_FROM_U64(0x3333333311111111ULL), 1170 }; 1171 1172 static const char small_mask[] __initconst = "33333333,11111111\n"; 1173 static const char small_list[] __initconst = "0,4,8,12,16,20,24,28,32-33,36-37,40-41,44-45,48-49,52-53,56-57,60-61\n"; 1174 1175 static const unsigned long large_bitmap[] __initconst = { 1176 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1177 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1178 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1179 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1180 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1181 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1182 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1183 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1184 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1185 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1186 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1187 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1188 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1189 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1190 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1191 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1192 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1193 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1194 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1195 BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL), 1196 }; 1197 1198 static const char large_mask[] __initconst = "33333333,11111111,33333333,11111111," 1199 "33333333,11111111,33333333,11111111," 1200 "33333333,11111111,33333333,11111111," 1201 "33333333,11111111,33333333,11111111," 1202 "33333333,11111111,33333333,11111111," 1203 "33333333,11111111,33333333,11111111," 1204 "33333333,11111111,33333333,11111111," 1205 "33333333,11111111,33333333,11111111," 1206 "33333333,11111111,33333333,11111111," 1207 "33333333,11111111,33333333,11111111," 1208 "33333333,11111111,33333333,11111111," 1209 "33333333,11111111,33333333,11111111," 1210 "33333333,11111111,33333333,11111111," 1211 "33333333,11111111,33333333,11111111," 1212 "33333333,11111111,33333333,11111111," 1213 "33333333,11111111,33333333,11111111," 1214 "33333333,11111111,33333333,11111111," 1215 "33333333,11111111,33333333,11111111," 1216 "33333333,11111111,33333333,11111111," 1217 "33333333,11111111,33333333,11111111\n"; 1218 1219 static const char large_list[] __initconst = /* more than 4KB */ 1220 "0,4,8,12,16,20,24,28,32-33,36-37,40-41,44-45,48-49,52-53,56-57,60-61,64,68,72,76,80,84,88,92,96-97,100-101,104-1" 1221 "05,108-109,112-113,116-117,120-121,124-125,128,132,136,140,144,148,152,156,160-161,164-165,168-169,172-173,176-1" 1222 "77,180-181,184-185,188-189,192,196,200,204,208,212,216,220,224-225,228-229,232-233,236-237,240-241,244-245,248-2" 1223 "49,252-253,256,260,264,268,272,276,280,284,288-289,292-293,296-297,300-301,304-305,308-309,312-313,316-317,320,3" 1224 "24,328,332,336,340,344,348,352-353,356-357,360-361,364-365,368-369,372-373,376-377,380-381,384,388,392,396,400,4" 1225 "04,408,412,416-417,420-421,424-425,428-429,432-433,436-437,440-441,444-445,448,452,456,460,464,468,472,476,480-4" 1226 "81,484-485,488-489,492-493,496-497,500-501,504-505,508-509,512,516,520,524,528,532,536,540,544-545,548-549,552-5" 1227 "53,556-557,560-561,564-565,568-569,572-573,576,580,584,588,592,596,600,604,608-609,612-613,616-617,620-621,624-6" 1228 "25,628-629,632-633,636-637,640,644,648,652,656,660,664,668,672-673,676-677,680-681,684-685,688-689,692-693,696-6" 1229 "97,700-701,704,708,712,716,720,724,728,732,736-737,740-741,744-745,748-749,752-753,756-757,760-761,764-765,768,7" 1230 "72,776,780,784,788,792,796,800-801,804-805,808-809,812-813,816-817,820-821,824-825,828-829,832,836,840,844,848,8" 1231 "52,856,860,864-865,868-869,872-873,876-877,880-881,884-885,888-889,892-893,896,900,904,908,912,916,920,924,928-9" 1232 "29,932-933,936-937,940-941,944-945,948-949,952-953,956-957,960,964,968,972,976,980,984,988,992-993,996-997,1000-" 1233 "1001,1004-1005,1008-1009,1012-1013,1016-1017,1020-1021,1024,1028,1032,1036,1040,1044,1048,1052,1056-1057,1060-10" 1234 "61,1064-1065,1068-1069,1072-1073,1076-1077,1080-1081,1084-1085,1088,1092,1096,1100,1104,1108,1112,1116,1120-1121" 1235 ",1124-1125,1128-1129,1132-1133,1136-1137,1140-1141,1144-1145,1148-1149,1152,1156,1160,1164,1168,1172,1176,1180,1" 1236 "184-1185,1188-1189,1192-1193,1196-1197,1200-1201,1204-1205,1208-1209,1212-1213,1216,1220,1224,1228,1232,1236,124" 1237 "0,1244,1248-1249,1252-1253,1256-1257,1260-1261,1264-1265,1268-1269,1272-1273,1276-1277,1280,1284,1288,1292,1296," 1238 "1300,1304,1308,1312-1313,1316-1317,1320-1321,1324-1325,1328-1329,1332-1333,1336-1337,1340-1341,1344,1348,1352,13" 1239 "56,1360,1364,1368,1372,1376-1377,1380-1381,1384-1385,1388-1389,1392-1393,1396-1397,1400-1401,1404-1405,1408,1412" 1240 ",1416,1420,1424,1428,1432,1436,1440-1441,1444-1445,1448-1449,1452-1453,1456-1457,1460-1461,1464-1465,1468-1469,1" 1241 "472,1476,1480,1484,1488,1492,1496,1500,1504-1505,1508-1509,1512-1513,1516-1517,1520-1521,1524-1525,1528-1529,153" 1242 "2-1533,1536,1540,1544,1548,1552,1556,1560,1564,1568-1569,1572-1573,1576-1577,1580-1581,1584-1585,1588-1589,1592-" 1243 "1593,1596-1597,1600,1604,1608,1612,1616,1620,1624,1628,1632-1633,1636-1637,1640-1641,1644-1645,1648-1649,1652-16" 1244 "53,1656-1657,1660-1661,1664,1668,1672,1676,1680,1684,1688,1692,1696-1697,1700-1701,1704-1705,1708-1709,1712-1713" 1245 ",1716-1717,1720-1721,1724-1725,1728,1732,1736,1740,1744,1748,1752,1756,1760-1761,1764-1765,1768-1769,1772-1773,1" 1246 "776-1777,1780-1781,1784-1785,1788-1789,1792,1796,1800,1804,1808,1812,1816,1820,1824-1825,1828-1829,1832-1833,183" 1247 "6-1837,1840-1841,1844-1845,1848-1849,1852-1853,1856,1860,1864,1868,1872,1876,1880,1884,1888-1889,1892-1893,1896-" 1248 "1897,1900-1901,1904-1905,1908-1909,1912-1913,1916-1917,1920,1924,1928,1932,1936,1940,1944,1948,1952-1953,1956-19" 1249 "57,1960-1961,1964-1965,1968-1969,1972-1973,1976-1977,1980-1981,1984,1988,1992,1996,2000,2004,2008,2012,2016-2017" 1250 ",2020-2021,2024-2025,2028-2029,2032-2033,2036-2037,2040-2041,2044-2045,2048,2052,2056,2060,2064,2068,2072,2076,2" 1251 "080-2081,2084-2085,2088-2089,2092-2093,2096-2097,2100-2101,2104-2105,2108-2109,2112,2116,2120,2124,2128,2132,213" 1252 "6,2140,2144-2145,2148-2149,2152-2153,2156-2157,2160-2161,2164-2165,2168-2169,2172-2173,2176,2180,2184,2188,2192," 1253 "2196,2200,2204,2208-2209,2212-2213,2216-2217,2220-2221,2224-2225,2228-2229,2232-2233,2236-2237,2240,2244,2248,22" 1254 "52,2256,2260,2264,2268,2272-2273,2276-2277,2280-2281,2284-2285,2288-2289,2292-2293,2296-2297,2300-2301,2304,2308" 1255 ",2312,2316,2320,2324,2328,2332,2336-2337,2340-2341,2344-2345,2348-2349,2352-2353,2356-2357,2360-2361,2364-2365,2" 1256 "368,2372,2376,2380,2384,2388,2392,2396,2400-2401,2404-2405,2408-2409,2412-2413,2416-2417,2420-2421,2424-2425,242" 1257 "8-2429,2432,2436,2440,2444,2448,2452,2456,2460,2464-2465,2468-2469,2472-2473,2476-2477,2480-2481,2484-2485,2488-" 1258 "2489,2492-2493,2496,2500,2504,2508,2512,2516,2520,2524,2528-2529,2532-2533,2536-2537,2540-2541,2544-2545,2548-25" 1259 "49,2552-2553,2556-2557\n"; 1260 1261 static const struct test_bitmap_print test_print[] __initconst = { 1262 { small_bitmap, sizeof(small_bitmap) * BITS_PER_BYTE, small_mask, small_list }, 1263 { large_bitmap, sizeof(large_bitmap) * BITS_PER_BYTE, large_mask, large_list }, 1264 }; 1265 1266 static void __init test_bitmap_print_buf(void) 1267 { 1268 int i; 1269 1270 for (i = 0; i < ARRAY_SIZE(test_print); i++) { 1271 const struct test_bitmap_print *t = &test_print[i]; 1272 int n; 1273 1274 n = bitmap_print_bitmask_to_buf(print_buf, t->bitmap, t->nbits, 1275 0, 2 * PAGE_SIZE); 1276 expect_eq_uint(strlen(t->mask) + 1, n); 1277 expect_eq_str(t->mask, print_buf, n); 1278 1279 n = bitmap_print_list_to_buf(print_buf, t->bitmap, t->nbits, 1280 0, 2 * PAGE_SIZE); 1281 expect_eq_uint(strlen(t->list) + 1, n); 1282 expect_eq_str(t->list, print_buf, n); 1283 1284 /* test by non-zero offset */ 1285 if (strlen(t->list) > PAGE_SIZE) { 1286 n = bitmap_print_list_to_buf(print_buf, t->bitmap, t->nbits, 1287 PAGE_SIZE, PAGE_SIZE); 1288 expect_eq_uint(strlen(t->list) + 1 - PAGE_SIZE, n); 1289 expect_eq_str(t->list + PAGE_SIZE, print_buf, n); 1290 } 1291 } 1292 } 1293 1294 /* 1295 * FIXME: Clang breaks compile-time evaluations when KASAN and GCOV are enabled. 1296 * To workaround it, GCOV is force-disabled in Makefile for this configuration. 1297 */ 1298 static void __init test_bitmap_const_eval(void) 1299 { 1300 DECLARE_BITMAP(bitmap, BITS_PER_LONG); 1301 unsigned long initvar = BIT(2); 1302 unsigned long bitopvar = 0; 1303 unsigned long var = 0; 1304 int res; 1305 1306 /* 1307 * Compilers must be able to optimize all of those to compile-time 1308 * constants on any supported optimization level (-O2, -Os) and any 1309 * architecture. Otherwise, trigger a build bug. 1310 * The whole function gets optimized out then, there's nothing to do 1311 * in runtime. 1312 */ 1313 1314 /* Equals to `unsigned long bitmap[1] = { GENMASK(6, 5), }` */ 1315 bitmap_clear(bitmap, 0, BITS_PER_LONG); 1316 if (!test_bit(7, bitmap)) 1317 bitmap_set(bitmap, 5, 2); 1318 1319 /* Equals to `unsigned long bitopvar = BIT(20)` */ 1320 __change_bit(31, &bitopvar); 1321 bitmap_shift_right(&bitopvar, &bitopvar, 11, BITS_PER_LONG); 1322 1323 /* Equals to `unsigned long var = BIT(25)` */ 1324 var |= BIT(25); 1325 if (var & BIT(0)) 1326 var ^= GENMASK(9, 6); 1327 1328 /* __const_hweight<32|64>(GENMASK(6, 5)) == 2 */ 1329 res = bitmap_weight(bitmap, 20); 1330 BUILD_BUG_ON(!__builtin_constant_p(res)); 1331 BUILD_BUG_ON(res != 2); 1332 1333 /* !(BIT(31) & BIT(18)) == 1 */ 1334 res = !test_bit(18, &bitopvar); 1335 BUILD_BUG_ON(!__builtin_constant_p(res)); 1336 BUILD_BUG_ON(!res); 1337 1338 /* BIT(2) & GENMASK(14, 8) == 0 */ 1339 res = initvar & GENMASK(14, 8); 1340 BUILD_BUG_ON(!__builtin_constant_p(res)); 1341 BUILD_BUG_ON(res); 1342 1343 /* ~BIT(25) */ 1344 BUILD_BUG_ON(!__builtin_constant_p(~var)); 1345 BUILD_BUG_ON(~var != ~BIT(25)); 1346 1347 /* ~BIT(25) | BIT(25) == ~0UL */ 1348 bitmap_complement(&var, &var, BITS_PER_LONG); 1349 __assign_bit(25, &var, true); 1350 1351 /* !(~(~0UL)) == 1 */ 1352 res = bitmap_full(&var, BITS_PER_LONG); 1353 BUILD_BUG_ON(!__builtin_constant_p(res)); 1354 BUILD_BUG_ON(!res); 1355 } 1356 1357 /* 1358 * Test bitmap should be big enough to include the cases when start is not in 1359 * the first word, and start+nbits lands in the following word. 1360 */ 1361 #define TEST_BIT_LEN (1000) 1362 1363 /* 1364 * Helper function to test bitmap_write() overwriting the chosen byte pattern. 1365 */ 1366 static void __init test_bitmap_write_helper(const char *pattern) 1367 { 1368 DECLARE_BITMAP(bitmap, TEST_BIT_LEN); 1369 DECLARE_BITMAP(exp_bitmap, TEST_BIT_LEN); 1370 DECLARE_BITMAP(pat_bitmap, TEST_BIT_LEN); 1371 unsigned long w, r, bit; 1372 int i, n, nbits; 1373 1374 /* 1375 * Only parse the pattern once and store the result in the intermediate 1376 * bitmap. 1377 */ 1378 bitmap_parselist(pattern, pat_bitmap, TEST_BIT_LEN); 1379 1380 /* 1381 * Check that writing a single bit does not accidentally touch the 1382 * adjacent bits. 1383 */ 1384 for (i = 0; i < TEST_BIT_LEN; i++) { 1385 bitmap_copy(bitmap, pat_bitmap, TEST_BIT_LEN); 1386 bitmap_copy(exp_bitmap, pat_bitmap, TEST_BIT_LEN); 1387 for (bit = 0; bit <= 1; bit++) { 1388 bitmap_write(bitmap, bit, i, 1); 1389 __assign_bit(i, exp_bitmap, bit); 1390 expect_eq_bitmap(exp_bitmap, bitmap, 1391 TEST_BIT_LEN); 1392 } 1393 } 1394 1395 /* Ensure writing 0 bits does not change anything. */ 1396 bitmap_copy(bitmap, pat_bitmap, TEST_BIT_LEN); 1397 bitmap_copy(exp_bitmap, pat_bitmap, TEST_BIT_LEN); 1398 for (i = 0; i < TEST_BIT_LEN; i++) { 1399 bitmap_write(bitmap, ~0UL, i, 0); 1400 expect_eq_bitmap(exp_bitmap, bitmap, TEST_BIT_LEN); 1401 } 1402 1403 for (nbits = BITS_PER_LONG; nbits >= 1; nbits--) { 1404 w = IS_ENABLED(CONFIG_64BIT) ? 0xdeadbeefdeadbeefUL 1405 : 0xdeadbeefUL; 1406 w >>= (BITS_PER_LONG - nbits); 1407 for (i = 0; i <= TEST_BIT_LEN - nbits; i++) { 1408 bitmap_copy(bitmap, pat_bitmap, TEST_BIT_LEN); 1409 bitmap_copy(exp_bitmap, pat_bitmap, TEST_BIT_LEN); 1410 for (n = 0; n < nbits; n++) 1411 __assign_bit(i + n, exp_bitmap, w & BIT(n)); 1412 bitmap_write(bitmap, w, i, nbits); 1413 expect_eq_bitmap(exp_bitmap, bitmap, TEST_BIT_LEN); 1414 r = bitmap_read(bitmap, i, nbits); 1415 expect_eq_ulong(r, w); 1416 } 1417 } 1418 } 1419 1420 static void __init test_bitmap_read_write(void) 1421 { 1422 unsigned char *pattern[3] = {"", "all:1/2", "all"}; 1423 DECLARE_BITMAP(bitmap, TEST_BIT_LEN); 1424 unsigned long zero_bits = 0, bits_per_long = BITS_PER_LONG; 1425 unsigned long val; 1426 int i, pi; 1427 1428 /* 1429 * Reading/writing zero bits should not crash the kernel. 1430 * READ_ONCE() prevents constant folding. 1431 */ 1432 bitmap_write(NULL, 0, 0, READ_ONCE(zero_bits)); 1433 /* Return value of bitmap_read() is undefined here. */ 1434 bitmap_read(NULL, 0, READ_ONCE(zero_bits)); 1435 1436 /* 1437 * Reading/writing more than BITS_PER_LONG bits should not crash the 1438 * kernel. READ_ONCE() prevents constant folding. 1439 */ 1440 bitmap_write(NULL, 0, 0, READ_ONCE(bits_per_long) + 1); 1441 /* Return value of bitmap_read() is undefined here. */ 1442 bitmap_read(NULL, 0, READ_ONCE(bits_per_long) + 1); 1443 1444 /* 1445 * Ensure that bitmap_read() reads the same value that was previously 1446 * written, and two consequent values are correctly merged. 1447 * The resulting bit pattern is asymmetric to rule out possible issues 1448 * with bit numeration order. 1449 */ 1450 for (i = 0; i < TEST_BIT_LEN - 7; i++) { 1451 bitmap_zero(bitmap, TEST_BIT_LEN); 1452 1453 bitmap_write(bitmap, 0b10101UL, i, 5); 1454 val = bitmap_read(bitmap, i, 5); 1455 expect_eq_ulong(0b10101UL, val); 1456 1457 bitmap_write(bitmap, 0b101UL, i + 5, 3); 1458 val = bitmap_read(bitmap, i + 5, 3); 1459 expect_eq_ulong(0b101UL, val); 1460 1461 val = bitmap_read(bitmap, i, 8); 1462 expect_eq_ulong(0b10110101UL, val); 1463 } 1464 1465 for (pi = 0; pi < ARRAY_SIZE(pattern); pi++) 1466 test_bitmap_write_helper(pattern[pi]); 1467 } 1468 1469 static void __init test_bitmap_read_perf(void) 1470 { 1471 DECLARE_BITMAP(bitmap, TEST_BIT_LEN); 1472 unsigned int cnt, nbits, i; 1473 unsigned long val; 1474 ktime_t time; 1475 1476 bitmap_fill(bitmap, TEST_BIT_LEN); 1477 time = ktime_get(); 1478 for (cnt = 0; cnt < 5; cnt++) { 1479 for (nbits = 1; nbits <= BITS_PER_LONG; nbits++) { 1480 for (i = 0; i < TEST_BIT_LEN; i++) { 1481 if (i + nbits > TEST_BIT_LEN) 1482 break; 1483 /* 1484 * Prevent the compiler from optimizing away the 1485 * bitmap_read() by using its value. 1486 */ 1487 WRITE_ONCE(val, bitmap_read(bitmap, i, nbits)); 1488 } 1489 } 1490 } 1491 time = ktime_get() - time; 1492 pr_info("%s:\t\t%llu\n", __func__, time); 1493 } 1494 1495 static void __init test_bitmap_write_perf(void) 1496 { 1497 DECLARE_BITMAP(bitmap, TEST_BIT_LEN); 1498 unsigned int cnt, nbits, i; 1499 unsigned long val = 0xfeedface; 1500 ktime_t time; 1501 1502 bitmap_zero(bitmap, TEST_BIT_LEN); 1503 time = ktime_get(); 1504 for (cnt = 0; cnt < 5; cnt++) { 1505 for (nbits = 1; nbits <= BITS_PER_LONG; nbits++) { 1506 for (i = 0; i < TEST_BIT_LEN; i++) { 1507 if (i + nbits > TEST_BIT_LEN) 1508 break; 1509 bitmap_write(bitmap, val, i, nbits); 1510 } 1511 } 1512 } 1513 time = ktime_get() - time; 1514 pr_info("%s:\t\t%llu\n", __func__, time); 1515 } 1516 1517 /* 1518 * nbits == 0 is most commonly not a valid case. Bitmap users should revisit 1519 * the caller logic. Bitmap API doesn't provide any guarantees on returned 1520 * value. The pointers are not dereferenced. The return value is intentionally 1521 * ignored. 1522 */ 1523 static void __init test_zero_nbits(void) 1524 { 1525 static volatile __always_used unsigned long ret __initdata; 1526 1527 bitmap_clear(NULL, 0, 0); 1528 bitmap_complement(NULL, NULL, 0); 1529 bitmap_copy(NULL, NULL, 0); 1530 bitmap_copy_clear_tail(NULL, NULL, 0); 1531 bitmap_fill(NULL, 0); 1532 bitmap_from_arr32(NULL, NULL, 0); 1533 bitmap_from_arr64(NULL, NULL, 0); 1534 bitmap_or(NULL, NULL, NULL, 0); 1535 bitmap_set(NULL, 0, 0); 1536 bitmap_shift_left(NULL, NULL, 0, 0); 1537 bitmap_shift_right(NULL, NULL, 0, 0); 1538 bitmap_to_arr32(NULL, NULL, 0); 1539 bitmap_to_arr64(NULL, NULL, 0); 1540 bitmap_write(NULL, 0, 0, 0); 1541 bitmap_xor(NULL, NULL, NULL, 0); 1542 bitmap_zero(NULL, 0); 1543 1544 ret = bitmap_and(NULL, NULL, NULL, 0); 1545 ret = bitmap_empty(NULL, 0); 1546 ret = bitmap_equal(NULL, NULL, 0); 1547 ret = bitmap_full(NULL, 0); 1548 ret = bitmap_or_equal(NULL, NULL, NULL, 0); 1549 ret = bitmap_read(NULL, 0, 0); 1550 ret = bitmap_subset(NULL, NULL, 0); 1551 ret = bitmap_weight(NULL, 0); 1552 ret = bitmap_weight_and(NULL, NULL, 0); 1553 ret = bitmap_weight_andnot(NULL, NULL, 0); 1554 ret = bitmap_weight_from(NULL, 0, 0); 1555 ret = bitmap_weighted_or(NULL, NULL, NULL, 0); 1556 1557 ret = find_first_and_and_bit(NULL, NULL, NULL, 0); 1558 ret = find_first_and_bit(NULL, NULL, 0); 1559 ret = find_first_andnot_bit(NULL, NULL, 0); 1560 ret = find_first_bit(NULL, 0); 1561 ret = find_first_zero_bit(NULL, 0); 1562 ret = find_last_bit(NULL, 0); 1563 ret = find_next_and_bit(NULL, NULL, 0, 0); 1564 ret = find_next_andnot_bit(NULL, NULL, 0, 0); 1565 ret = find_next_bit(NULL, 0, 0); 1566 ret = find_next_clump8(NULL, NULL, 0, 0); 1567 ret = find_next_zero_bit(NULL, 0, 0); 1568 ret = find_nth_and_bit(NULL, NULL, 0, 0); 1569 ret = find_nth_bit(NULL, 0, 0); 1570 ret = find_random_bit(NULL, 0); 1571 } 1572 1573 #undef TEST_BIT_LEN 1574 1575 static void __init selftest(void) 1576 { 1577 test_zero_clear(); 1578 test_fill_set(); 1579 test_copy(); 1580 test_bitmap_region(); 1581 test_replace(); 1582 test_bitmap_sg(); 1583 test_bitmap_arr32(); 1584 test_bitmap_arr64(); 1585 test_bitmap_parse(); 1586 test_bitmap_parselist(); 1587 test_bitmap_printlist(); 1588 test_mem_optimisations(); 1589 test_bitmap_cut(); 1590 test_bitmap_print_buf(); 1591 test_bitmap_const_eval(); 1592 test_bitmap_read_write(); 1593 test_bitmap_read_perf(); 1594 test_bitmap_weight(); 1595 test_bitmap_write_perf(); 1596 test_zero_nbits(); 1597 1598 test_find_nth_bit(); 1599 test_for_each_set_bit(); 1600 test_for_each_set_bit_from(); 1601 test_for_each_clear_bit(); 1602 test_for_each_clear_bit_from(); 1603 test_for_each_set_bitrange(); 1604 test_for_each_clear_bitrange(); 1605 test_for_each_set_bitrange_from(); 1606 test_for_each_clear_bitrange_from(); 1607 test_for_each_set_clump8(); 1608 test_for_each_set_bit_wrap(); 1609 test_bitmap_find_next_zero_area_off(); 1610 } 1611 1612 KSTM_MODULE_LOADERS(test_bitmap); 1613 MODULE_AUTHOR("david decotigny <david.decotigny@googlers.com>"); 1614 MODULE_DESCRIPTION("Test cases for bitmap API"); 1615 MODULE_LICENSE("GPL"); 1616