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