Documentation/ABI/testing/sysfs-amd-pmf: Add ABI doc for AMD PMF
[linux.git] / lib / test_bitmap.c
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 KSTM_MODULE_GLOBALS();
20
21 static char pbl_buffer[PAGE_SIZE] __initdata;
22 static char print_buf[PAGE_SIZE * 2] __initdata;
23
24 static const unsigned long exp1[] __initconst = {
25         BITMAP_FROM_U64(1),
26         BITMAP_FROM_U64(2),
27         BITMAP_FROM_U64(0x0000ffff),
28         BITMAP_FROM_U64(0xffff0000),
29         BITMAP_FROM_U64(0x55555555),
30         BITMAP_FROM_U64(0xaaaaaaaa),
31         BITMAP_FROM_U64(0x11111111),
32         BITMAP_FROM_U64(0x22222222),
33         BITMAP_FROM_U64(0xffffffff),
34         BITMAP_FROM_U64(0xfffffffe),
35         BITMAP_FROM_U64(0x3333333311111111ULL),
36         BITMAP_FROM_U64(0xffffffff77777777ULL),
37         BITMAP_FROM_U64(0),
38         BITMAP_FROM_U64(0x00008000),
39         BITMAP_FROM_U64(0x80000000),
40 };
41
42 static const unsigned long exp2[] __initconst = {
43         BITMAP_FROM_U64(0x3333333311111111ULL),
44         BITMAP_FROM_U64(0xffffffff77777777ULL),
45 };
46
47 /* Fibonacci sequence */
48 static const unsigned long exp2_to_exp3_mask[] __initconst = {
49         BITMAP_FROM_U64(0x008000020020212eULL),
50 };
51 /* exp3_0_1 = (exp2[0] & ~exp2_to_exp3_mask) | (exp2[1] & exp2_to_exp3_mask) */
52 static const unsigned long exp3_0_1[] __initconst = {
53         BITMAP_FROM_U64(0x33b3333311313137ULL),
54 };
55 /* exp3_1_0 = (exp2[1] & ~exp2_to_exp3_mask) | (exp2[0] & exp2_to_exp3_mask) */
56 static const unsigned long exp3_1_0[] __initconst = {
57         BITMAP_FROM_U64(0xff7fffff77575751ULL),
58 };
59
60 static bool __init
61 __check_eq_uint(const char *srcfile, unsigned int line,
62                 const unsigned int exp_uint, unsigned int x)
63 {
64         if (exp_uint != x) {
65                 pr_err("[%s:%u] expected %u, got %u\n",
66                         srcfile, line, exp_uint, x);
67                 return false;
68         }
69         return true;
70 }
71
72
73 static bool __init
74 __check_eq_bitmap(const char *srcfile, unsigned int line,
75                   const unsigned long *exp_bmap, const unsigned long *bmap,
76                   unsigned int nbits)
77 {
78         if (!bitmap_equal(exp_bmap, bmap, nbits)) {
79                 pr_warn("[%s:%u] bitmaps contents differ: expected \"%*pbl\", got \"%*pbl\"\n",
80                         srcfile, line,
81                         nbits, exp_bmap, nbits, bmap);
82                 return false;
83         }
84         return true;
85 }
86
87 static bool __init
88 __check_eq_pbl(const char *srcfile, unsigned int line,
89                const char *expected_pbl,
90                const unsigned long *bitmap, unsigned int nbits)
91 {
92         snprintf(pbl_buffer, sizeof(pbl_buffer), "%*pbl", nbits, bitmap);
93         if (strcmp(expected_pbl, pbl_buffer)) {
94                 pr_warn("[%s:%u] expected \"%s\", got \"%s\"\n",
95                         srcfile, line,
96                         expected_pbl, pbl_buffer);
97                 return false;
98         }
99         return true;
100 }
101
102 static bool __init
103 __check_eq_u32_array(const char *srcfile, unsigned int line,
104                      const u32 *exp_arr, unsigned int exp_len,
105                      const u32 *arr, unsigned int len) __used;
106 static bool __init
107 __check_eq_u32_array(const char *srcfile, unsigned int line,
108                      const u32 *exp_arr, unsigned int exp_len,
109                      const u32 *arr, unsigned int len)
110 {
111         if (exp_len != len) {
112                 pr_warn("[%s:%u] array length differ: expected %u, got %u\n",
113                         srcfile, line,
114                         exp_len, len);
115                 return false;
116         }
117
118         if (memcmp(exp_arr, arr, len*sizeof(*arr))) {
119                 pr_warn("[%s:%u] array contents differ\n", srcfile, line);
120                 print_hex_dump(KERN_WARNING, "  exp:  ", DUMP_PREFIX_OFFSET,
121                                32, 4, exp_arr, exp_len*sizeof(*exp_arr), false);
122                 print_hex_dump(KERN_WARNING, "  got:  ", DUMP_PREFIX_OFFSET,
123                                32, 4, arr, len*sizeof(*arr), false);
124                 return false;
125         }
126
127         return true;
128 }
129
130 static bool __init __check_eq_clump8(const char *srcfile, unsigned int line,
131                                     const unsigned int offset,
132                                     const unsigned int size,
133                                     const unsigned char *const clump_exp,
134                                     const unsigned long *const clump)
135 {
136         unsigned long exp;
137
138         if (offset >= size) {
139                 pr_warn("[%s:%u] bit offset for clump out-of-bounds: expected less than %u, got %u\n",
140                         srcfile, line, size, offset);
141                 return false;
142         }
143
144         exp = clump_exp[offset / 8];
145         if (!exp) {
146                 pr_warn("[%s:%u] bit offset for zero clump: expected nonzero clump, got bit offset %u with clump value 0",
147                         srcfile, line, offset);
148                 return false;
149         }
150
151         if (*clump != exp) {
152                 pr_warn("[%s:%u] expected clump value of 0x%lX, got clump value of 0x%lX",
153                         srcfile, line, exp, *clump);
154                 return false;
155         }
156
157         return true;
158 }
159
160 static bool __init
161 __check_eq_str(const char *srcfile, unsigned int line,
162                 const char *exp_str, const char *str,
163                 unsigned int len)
164 {
165         bool eq;
166
167         eq = strncmp(exp_str, str, len) == 0;
168         if (!eq)
169                 pr_err("[%s:%u] expected %s, got %s\n", srcfile, line, exp_str, str);
170
171         return eq;
172 }
173
174 #define __expect_eq(suffix, ...)                                        \
175         ({                                                              \
176                 int result = 0;                                         \
177                 total_tests++;                                          \
178                 if (!__check_eq_ ## suffix(__FILE__, __LINE__,          \
179                                            ##__VA_ARGS__)) {            \
180                         failed_tests++;                                 \
181                         result = 1;                                     \
182                 }                                                       \
183                 result;                                                 \
184         })
185
186 #define expect_eq_uint(...)             __expect_eq(uint, ##__VA_ARGS__)
187 #define expect_eq_bitmap(...)           __expect_eq(bitmap, ##__VA_ARGS__)
188 #define expect_eq_pbl(...)              __expect_eq(pbl, ##__VA_ARGS__)
189 #define expect_eq_u32_array(...)        __expect_eq(u32_array, ##__VA_ARGS__)
190 #define expect_eq_clump8(...)           __expect_eq(clump8, ##__VA_ARGS__)
191 #define expect_eq_str(...)              __expect_eq(str, ##__VA_ARGS__)
192
193 static void __init test_zero_clear(void)
194 {
195         DECLARE_BITMAP(bmap, 1024);
196
197         /* Known way to set all bits */
198         memset(bmap, 0xff, 128);
199
200         expect_eq_pbl("0-22", bmap, 23);
201         expect_eq_pbl("0-1023", bmap, 1024);
202
203         /* single-word bitmaps */
204         bitmap_clear(bmap, 0, 9);
205         expect_eq_pbl("9-1023", bmap, 1024);
206
207         bitmap_zero(bmap, 35);
208         expect_eq_pbl("64-1023", bmap, 1024);
209
210         /* cross boundaries operations */
211         bitmap_clear(bmap, 79, 19);
212         expect_eq_pbl("64-78,98-1023", bmap, 1024);
213
214         bitmap_zero(bmap, 115);
215         expect_eq_pbl("128-1023", bmap, 1024);
216
217         /* Zeroing entire area */
218         bitmap_zero(bmap, 1024);
219         expect_eq_pbl("", bmap, 1024);
220 }
221
222 static void __init test_fill_set(void)
223 {
224         DECLARE_BITMAP(bmap, 1024);
225
226         /* Known way to clear all bits */
227         memset(bmap, 0x00, 128);
228
229         expect_eq_pbl("", bmap, 23);
230         expect_eq_pbl("", bmap, 1024);
231
232         /* single-word bitmaps */
233         bitmap_set(bmap, 0, 9);
234         expect_eq_pbl("0-8", bmap, 1024);
235
236         bitmap_fill(bmap, 35);
237         expect_eq_pbl("0-63", bmap, 1024);
238
239         /* cross boundaries operations */
240         bitmap_set(bmap, 79, 19);
241         expect_eq_pbl("0-63,79-97", bmap, 1024);
242
243         bitmap_fill(bmap, 115);
244         expect_eq_pbl("0-127", bmap, 1024);
245
246         /* Zeroing entire area */
247         bitmap_fill(bmap, 1024);
248         expect_eq_pbl("0-1023", bmap, 1024);
249 }
250
251 static void __init test_copy(void)
252 {
253         DECLARE_BITMAP(bmap1, 1024);
254         DECLARE_BITMAP(bmap2, 1024);
255
256         bitmap_zero(bmap1, 1024);
257         bitmap_zero(bmap2, 1024);
258
259         /* single-word bitmaps */
260         bitmap_set(bmap1, 0, 19);
261         bitmap_copy(bmap2, bmap1, 23);
262         expect_eq_pbl("0-18", bmap2, 1024);
263
264         bitmap_set(bmap2, 0, 23);
265         bitmap_copy(bmap2, bmap1, 23);
266         expect_eq_pbl("0-18", bmap2, 1024);
267
268         /* multi-word bitmaps */
269         bitmap_set(bmap1, 0, 109);
270         bitmap_copy(bmap2, bmap1, 1024);
271         expect_eq_pbl("0-108", bmap2, 1024);
272
273         bitmap_fill(bmap2, 1024);
274         bitmap_copy(bmap2, bmap1, 1024);
275         expect_eq_pbl("0-108", bmap2, 1024);
276
277         /* the following tests assume a 32- or 64-bit arch (even 128b
278          * if we care)
279          */
280
281         bitmap_fill(bmap2, 1024);
282         bitmap_copy(bmap2, bmap1, 109);  /* ... but 0-padded til word length */
283         expect_eq_pbl("0-108,128-1023", bmap2, 1024);
284
285         bitmap_fill(bmap2, 1024);
286         bitmap_copy(bmap2, bmap1, 97);  /* ... but aligned on word length */
287         expect_eq_pbl("0-108,128-1023", bmap2, 1024);
288 }
289
290 #define EXP2_IN_BITS    (sizeof(exp2) * 8)
291
292 static void __init test_replace(void)
293 {
294         unsigned int nbits = 64;
295         unsigned int nlongs = DIV_ROUND_UP(nbits, BITS_PER_LONG);
296         DECLARE_BITMAP(bmap, 1024);
297
298         BUILD_BUG_ON(EXP2_IN_BITS < nbits * 2);
299
300         bitmap_zero(bmap, 1024);
301         bitmap_replace(bmap, &exp2[0 * nlongs], &exp2[1 * nlongs], exp2_to_exp3_mask, nbits);
302         expect_eq_bitmap(bmap, exp3_0_1, nbits);
303
304         bitmap_zero(bmap, 1024);
305         bitmap_replace(bmap, &exp2[1 * nlongs], &exp2[0 * nlongs], exp2_to_exp3_mask, nbits);
306         expect_eq_bitmap(bmap, exp3_1_0, nbits);
307
308         bitmap_fill(bmap, 1024);
309         bitmap_replace(bmap, &exp2[0 * nlongs], &exp2[1 * nlongs], exp2_to_exp3_mask, nbits);
310         expect_eq_bitmap(bmap, exp3_0_1, nbits);
311
312         bitmap_fill(bmap, 1024);
313         bitmap_replace(bmap, &exp2[1 * nlongs], &exp2[0 * nlongs], exp2_to_exp3_mask, nbits);
314         expect_eq_bitmap(bmap, exp3_1_0, nbits);
315 }
316
317 #define PARSE_TIME      0x1
318 #define NO_LEN          0x2
319
320 struct test_bitmap_parselist{
321         const int errno;
322         const char *in;
323         const unsigned long *expected;
324         const int nbits;
325         const int flags;
326 };
327
328 static const struct test_bitmap_parselist parselist_tests[] __initconst = {
329 #define step (sizeof(u64) / sizeof(unsigned long))
330
331         {0, "0",                        &exp1[0], 8, 0},
332         {0, "1",                        &exp1[1 * step], 8, 0},
333         {0, "0-15",                     &exp1[2 * step], 32, 0},
334         {0, "16-31",                    &exp1[3 * step], 32, 0},
335         {0, "0-31:1/2",                 &exp1[4 * step], 32, 0},
336         {0, "1-31:1/2",                 &exp1[5 * step], 32, 0},
337         {0, "0-31:1/4",                 &exp1[6 * step], 32, 0},
338         {0, "1-31:1/4",                 &exp1[7 * step], 32, 0},
339         {0, "0-31:4/4",                 &exp1[8 * step], 32, 0},
340         {0, "1-31:4/4",                 &exp1[9 * step], 32, 0},
341         {0, "0-31:1/4,32-63:2/4",       &exp1[10 * step], 64, 0},
342         {0, "0-31:3/4,32-63:4/4",       &exp1[11 * step], 64, 0},
343         {0, "  ,,  0-31:3/4  ,, 32-63:4/4  ,,  ",       &exp1[11 * step], 64, 0},
344
345         {0, "0-31:1/4,32-63:2/4,64-95:3/4,96-127:4/4",  exp2, 128, 0},
346
347         {0, "0-2047:128/256", NULL, 2048, PARSE_TIME},
348
349         {0, "",                         &exp1[12 * step], 8, 0},
350         {0, "\n",                       &exp1[12 * step], 8, 0},
351         {0, ",,  ,,  , ,  ,",           &exp1[12 * step], 8, 0},
352         {0, " ,  ,,  , ,   ",           &exp1[12 * step], 8, 0},
353         {0, " ,  ,,  , ,   \n",         &exp1[12 * step], 8, 0},
354
355         {0, "0-0",                      &exp1[0], 32, 0},
356         {0, "1-1",                      &exp1[1 * step], 32, 0},
357         {0, "15-15",                    &exp1[13 * step], 32, 0},
358         {0, "31-31",                    &exp1[14 * step], 32, 0},
359
360         {0, "0-0:0/1",                  &exp1[12 * step], 32, 0},
361         {0, "0-0:1/1",                  &exp1[0], 32, 0},
362         {0, "0-0:1/31",                 &exp1[0], 32, 0},
363         {0, "0-0:31/31",                &exp1[0], 32, 0},
364         {0, "1-1:1/1",                  &exp1[1 * step], 32, 0},
365         {0, "0-15:16/31",               &exp1[2 * step], 32, 0},
366         {0, "15-15:1/2",                &exp1[13 * step], 32, 0},
367         {0, "15-15:31/31",              &exp1[13 * step], 32, 0},
368         {0, "15-31:1/31",               &exp1[13 * step], 32, 0},
369         {0, "16-31:16/31",              &exp1[3 * step], 32, 0},
370         {0, "31-31:31/31",              &exp1[14 * step], 32, 0},
371
372         {0, "N-N",                      &exp1[14 * step], 32, 0},
373         {0, "0-0:1/N",                  &exp1[0], 32, 0},
374         {0, "0-0:N/N",                  &exp1[0], 32, 0},
375         {0, "0-15:16/N",                &exp1[2 * step], 32, 0},
376         {0, "15-15:N/N",                &exp1[13 * step], 32, 0},
377         {0, "15-N:1/N",                 &exp1[13 * step], 32, 0},
378         {0, "16-N:16/N",                &exp1[3 * step], 32, 0},
379         {0, "N-N:N/N",                  &exp1[14 * step], 32, 0},
380
381         {0, "0-N:1/3,1-N:1/3,2-N:1/3",          &exp1[8 * step], 32, 0},
382         {0, "0-31:1/3,1-31:1/3,2-31:1/3",       &exp1[8 * step], 32, 0},
383         {0, "1-10:8/12,8-31:24/29,0-31:0/3",    &exp1[9 * step], 32, 0},
384
385         {0,       "all",                &exp1[8 * step], 32, 0},
386         {0,       "0, 1, all,  ",       &exp1[8 * step], 32, 0},
387         {0,       "all:1/2",            &exp1[4 * step], 32, 0},
388         {0,       "ALL:1/2",            &exp1[4 * step], 32, 0},
389         {-EINVAL, "al", NULL, 8, 0},
390         {-EINVAL, "alll", NULL, 8, 0},
391
392         {-EINVAL, "-1", NULL, 8, 0},
393         {-EINVAL, "-0", NULL, 8, 0},
394         {-EINVAL, "10-1", NULL, 8, 0},
395         {-ERANGE, "8-8", NULL, 8, 0},
396         {-ERANGE, "0-31", NULL, 8, 0},
397         {-EINVAL, "0-31:", NULL, 32, 0},
398         {-EINVAL, "0-31:0", NULL, 32, 0},
399         {-EINVAL, "0-31:0/", NULL, 32, 0},
400         {-EINVAL, "0-31:0/0", NULL, 32, 0},
401         {-EINVAL, "0-31:1/0", NULL, 32, 0},
402         {-EINVAL, "0-31:10/1", NULL, 32, 0},
403         {-EOVERFLOW, "0-98765432123456789:10/1", NULL, 8, 0},
404
405         {-EINVAL, "a-31", NULL, 8, 0},
406         {-EINVAL, "0-a1", NULL, 8, 0},
407         {-EINVAL, "a-31:10/1", NULL, 8, 0},
408         {-EINVAL, "0-31:a/1", NULL, 8, 0},
409         {-EINVAL, "0-\n", NULL, 8, 0},
410
411 };
412
413 static void __init test_bitmap_parselist(void)
414 {
415         int i;
416         int err;
417         ktime_t time;
418         DECLARE_BITMAP(bmap, 2048);
419
420         for (i = 0; i < ARRAY_SIZE(parselist_tests); i++) {
421 #define ptest parselist_tests[i]
422
423                 time = ktime_get();
424                 err = bitmap_parselist(ptest.in, bmap, ptest.nbits);
425                 time = ktime_get() - time;
426
427                 if (err != ptest.errno) {
428                         pr_err("parselist: %d: input is %s, errno is %d, expected %d\n",
429                                         i, ptest.in, err, ptest.errno);
430                         continue;
431                 }
432
433                 if (!err && ptest.expected
434                          && !__bitmap_equal(bmap, ptest.expected, ptest.nbits)) {
435                         pr_err("parselist: %d: input is %s, result is 0x%lx, expected 0x%lx\n",
436                                         i, ptest.in, bmap[0],
437                                         *ptest.expected);
438                         continue;
439                 }
440
441                 if (ptest.flags & PARSE_TIME)
442                         pr_err("parselist: %d: input is '%s' OK, Time: %llu\n",
443                                         i, ptest.in, time);
444
445 #undef ptest
446         }
447 }
448
449 static void __init test_bitmap_printlist(void)
450 {
451         unsigned long *bmap = kmalloc(PAGE_SIZE, GFP_KERNEL);
452         char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
453         char expected[256];
454         int ret, slen;
455         ktime_t time;
456
457         if (!buf || !bmap)
458                 goto out;
459
460         memset(bmap, -1, PAGE_SIZE);
461         slen = snprintf(expected, 256, "0-%ld", PAGE_SIZE * 8 - 1);
462         if (slen < 0)
463                 goto out;
464
465         time = ktime_get();
466         ret = bitmap_print_to_pagebuf(true, buf, bmap, PAGE_SIZE * 8);
467         time = ktime_get() - time;
468
469         if (ret != slen + 1) {
470                 pr_err("bitmap_print_to_pagebuf: result is %d, expected %d\n", ret, slen);
471                 goto out;
472         }
473
474         if (strncmp(buf, expected, slen)) {
475                 pr_err("bitmap_print_to_pagebuf: result is %s, expected %s\n", buf, expected);
476                 goto out;
477         }
478
479         pr_err("bitmap_print_to_pagebuf: input is '%s', Time: %llu\n", buf, time);
480 out:
481         kfree(buf);
482         kfree(bmap);
483 }
484
485 static const unsigned long parse_test[] __initconst = {
486         BITMAP_FROM_U64(0),
487         BITMAP_FROM_U64(1),
488         BITMAP_FROM_U64(0xdeadbeef),
489         BITMAP_FROM_U64(0x100000000ULL),
490 };
491
492 static const unsigned long parse_test2[] __initconst = {
493         BITMAP_FROM_U64(0x100000000ULL), BITMAP_FROM_U64(0xdeadbeef),
494         BITMAP_FROM_U64(0x100000000ULL), BITMAP_FROM_U64(0xbaadf00ddeadbeef),
495         BITMAP_FROM_U64(0x100000000ULL), BITMAP_FROM_U64(0x0badf00ddeadbeef),
496 };
497
498 static const struct test_bitmap_parselist parse_tests[] __initconst = {
499         {0, "",                         &parse_test[0 * step], 32, 0},
500         {0, " ",                        &parse_test[0 * step], 32, 0},
501         {0, "0",                        &parse_test[0 * step], 32, 0},
502         {0, "0\n",                      &parse_test[0 * step], 32, 0},
503         {0, "1",                        &parse_test[1 * step], 32, 0},
504         {0, "deadbeef",                 &parse_test[2 * step], 32, 0},
505         {0, "1,0",                      &parse_test[3 * step], 33, 0},
506         {0, "deadbeef,\n,0,1",          &parse_test[2 * step], 96, 0},
507
508         {0, "deadbeef,1,0",             &parse_test2[0 * 2 * step], 96, 0},
509         {0, "baadf00d,deadbeef,1,0",    &parse_test2[1 * 2 * step], 128, 0},
510         {0, "badf00d,deadbeef,1,0",     &parse_test2[2 * 2 * step], 124, 0},
511         {0, "badf00d,deadbeef,1,0",     &parse_test2[2 * 2 * step], 124, NO_LEN},
512         {0, "  badf00d,deadbeef,1,0  ", &parse_test2[2 * 2 * step], 124, 0},
513         {0, " , badf00d,deadbeef,1,0 , ",       &parse_test2[2 * 2 * step], 124, 0},
514         {0, " , badf00d, ,, ,,deadbeef,1,0 , ", &parse_test2[2 * 2 * step], 124, 0},
515
516         {-EINVAL,    "goodfood,deadbeef,1,0",   NULL, 128, 0},
517         {-EOVERFLOW, "3,0",                     NULL, 33, 0},
518         {-EOVERFLOW, "123badf00d,deadbeef,1,0", NULL, 128, 0},
519         {-EOVERFLOW, "badf00d,deadbeef,1,0",    NULL, 90, 0},
520         {-EOVERFLOW, "fbadf00d,deadbeef,1,0",   NULL, 95, 0},
521         {-EOVERFLOW, "badf00d,deadbeef,1,0",    NULL, 100, 0},
522 #undef step
523 };
524
525 static void __init test_bitmap_parse(void)
526 {
527         int i;
528         int err;
529         ktime_t time;
530         DECLARE_BITMAP(bmap, 2048);
531
532         for (i = 0; i < ARRAY_SIZE(parse_tests); i++) {
533                 struct test_bitmap_parselist test = parse_tests[i];
534                 size_t len = test.flags & NO_LEN ? UINT_MAX : strlen(test.in);
535
536                 time = ktime_get();
537                 err = bitmap_parse(test.in, len, bmap, test.nbits);
538                 time = ktime_get() - time;
539
540                 if (err != test.errno) {
541                         pr_err("parse: %d: input is %s, errno is %d, expected %d\n",
542                                         i, test.in, err, test.errno);
543                         continue;
544                 }
545
546                 if (!err && test.expected
547                          && !__bitmap_equal(bmap, test.expected, test.nbits)) {
548                         pr_err("parse: %d: input is %s, result is 0x%lx, expected 0x%lx\n",
549                                         i, test.in, bmap[0],
550                                         *test.expected);
551                         continue;
552                 }
553
554                 if (test.flags & PARSE_TIME)
555                         pr_err("parse: %d: input is '%s' OK, Time: %llu\n",
556                                         i, test.in, time);
557         }
558 }
559
560 #define EXP1_IN_BITS    (sizeof(exp1) * 8)
561
562 static void __init test_bitmap_arr32(void)
563 {
564         unsigned int nbits, next_bit;
565         u32 arr[EXP1_IN_BITS / 32];
566         DECLARE_BITMAP(bmap2, EXP1_IN_BITS);
567
568         memset(arr, 0xa5, sizeof(arr));
569
570         for (nbits = 0; nbits < EXP1_IN_BITS; ++nbits) {
571                 bitmap_to_arr32(arr, exp1, nbits);
572                 bitmap_from_arr32(bmap2, arr, nbits);
573                 expect_eq_bitmap(bmap2, exp1, nbits);
574
575                 next_bit = find_next_bit(bmap2,
576                                 round_up(nbits, BITS_PER_LONG), nbits);
577                 if (next_bit < round_up(nbits, BITS_PER_LONG))
578                         pr_err("bitmap_copy_arr32(nbits == %d:"
579                                 " tail is not safely cleared: %d\n",
580                                 nbits, next_bit);
581
582                 if (nbits < EXP1_IN_BITS - 32)
583                         expect_eq_uint(arr[DIV_ROUND_UP(nbits, 32)],
584                                                                 0xa5a5a5a5);
585         }
586 }
587
588 static void __init test_bitmap_arr64(void)
589 {
590         unsigned int nbits, next_bit;
591         u64 arr[EXP1_IN_BITS / 64];
592         DECLARE_BITMAP(bmap2, EXP1_IN_BITS);
593
594         memset(arr, 0xa5, sizeof(arr));
595
596         for (nbits = 0; nbits < EXP1_IN_BITS; ++nbits) {
597                 memset(bmap2, 0xff, sizeof(arr));
598                 bitmap_to_arr64(arr, exp1, nbits);
599                 bitmap_from_arr64(bmap2, arr, nbits);
600                 expect_eq_bitmap(bmap2, exp1, nbits);
601
602                 next_bit = find_next_bit(bmap2, round_up(nbits, BITS_PER_LONG), nbits);
603                 if (next_bit < round_up(nbits, BITS_PER_LONG))
604                         pr_err("bitmap_copy_arr64(nbits == %d:"
605                                 " tail is not safely cleared: %d\n", nbits, next_bit);
606
607                 if ((nbits % 64) &&
608                     (arr[(nbits - 1) / 64] & ~GENMASK_ULL((nbits - 1) % 64, 0)))
609                         pr_err("bitmap_to_arr64(nbits == %d): tail is not safely cleared: 0x%016llx (must be 0x%016llx)\n",
610                                nbits, arr[(nbits - 1) / 64],
611                                GENMASK_ULL((nbits - 1) % 64, 0));
612
613                 if (nbits < EXP1_IN_BITS - 64)
614                         expect_eq_uint(arr[DIV_ROUND_UP(nbits, 64)], 0xa5a5a5a5);
615         }
616 }
617
618 static void noinline __init test_mem_optimisations(void)
619 {
620         DECLARE_BITMAP(bmap1, 1024);
621         DECLARE_BITMAP(bmap2, 1024);
622         unsigned int start, nbits;
623
624         for (start = 0; start < 1024; start += 8) {
625                 for (nbits = 0; nbits < 1024 - start; nbits += 8) {
626                         memset(bmap1, 0x5a, sizeof(bmap1));
627                         memset(bmap2, 0x5a, sizeof(bmap2));
628
629                         bitmap_set(bmap1, start, nbits);
630                         __bitmap_set(bmap2, start, nbits);
631                         if (!bitmap_equal(bmap1, bmap2, 1024)) {
632                                 printk("set not equal %d %d\n", start, nbits);
633                                 failed_tests++;
634                         }
635                         if (!__bitmap_equal(bmap1, bmap2, 1024)) {
636                                 printk("set not __equal %d %d\n", start, nbits);
637                                 failed_tests++;
638                         }
639
640                         bitmap_clear(bmap1, start, nbits);
641                         __bitmap_clear(bmap2, start, nbits);
642                         if (!bitmap_equal(bmap1, bmap2, 1024)) {
643                                 printk("clear not equal %d %d\n", start, nbits);
644                                 failed_tests++;
645                         }
646                         if (!__bitmap_equal(bmap1, bmap2, 1024)) {
647                                 printk("clear not __equal %d %d\n", start,
648                                                                         nbits);
649                                 failed_tests++;
650                         }
651                 }
652         }
653 }
654
655 static const unsigned char clump_exp[] __initconst = {
656         0x01,   /* 1 bit set */
657         0x02,   /* non-edge 1 bit set */
658         0x00,   /* zero bits set */
659         0x38,   /* 3 bits set across 4-bit boundary */
660         0x38,   /* Repeated clump */
661         0x0F,   /* 4 bits set */
662         0xFF,   /* all bits set */
663         0x05,   /* non-adjacent 2 bits set */
664 };
665
666 static void __init test_for_each_set_clump8(void)
667 {
668 #define CLUMP_EXP_NUMBITS 64
669         DECLARE_BITMAP(bits, CLUMP_EXP_NUMBITS);
670         unsigned int start;
671         unsigned long clump;
672
673         /* set bitmap to test case */
674         bitmap_zero(bits, CLUMP_EXP_NUMBITS);
675         bitmap_set(bits, 0, 1);         /* 0x01 */
676         bitmap_set(bits, 9, 1);         /* 0x02 */
677         bitmap_set(bits, 27, 3);        /* 0x28 */
678         bitmap_set(bits, 35, 3);        /* 0x28 */
679         bitmap_set(bits, 40, 4);        /* 0x0F */
680         bitmap_set(bits, 48, 8);        /* 0xFF */
681         bitmap_set(bits, 56, 1);        /* 0x05 - part 1 */
682         bitmap_set(bits, 58, 1);        /* 0x05 - part 2 */
683
684         for_each_set_clump8(start, clump, bits, CLUMP_EXP_NUMBITS)
685                 expect_eq_clump8(start, CLUMP_EXP_NUMBITS, clump_exp, &clump);
686 }
687
688 struct test_bitmap_cut {
689         unsigned int first;
690         unsigned int cut;
691         unsigned int nbits;
692         unsigned long in[4];
693         unsigned long expected[4];
694 };
695
696 static struct test_bitmap_cut test_cut[] = {
697         {  0,  0,  8, { 0x0000000aUL, }, { 0x0000000aUL, }, },
698         {  0,  0, 32, { 0xdadadeadUL, }, { 0xdadadeadUL, }, },
699         {  0,  3,  8, { 0x000000aaUL, }, { 0x00000015UL, }, },
700         {  3,  3,  8, { 0x000000aaUL, }, { 0x00000012UL, }, },
701         {  0,  1, 32, { 0xa5a5a5a5UL, }, { 0x52d2d2d2UL, }, },
702         {  0,  8, 32, { 0xdeadc0deUL, }, { 0x00deadc0UL, }, },
703         {  1,  1, 32, { 0x5a5a5a5aUL, }, { 0x2d2d2d2cUL, }, },
704         {  0, 15, 32, { 0xa5a5a5a5UL, }, { 0x00014b4bUL, }, },
705         {  0, 16, 32, { 0xa5a5a5a5UL, }, { 0x0000a5a5UL, }, },
706         { 15, 15, 32, { 0xa5a5a5a5UL, }, { 0x000125a5UL, }, },
707         { 15, 16, 32, { 0xa5a5a5a5UL, }, { 0x0000a5a5UL, }, },
708         { 16, 15, 32, { 0xa5a5a5a5UL, }, { 0x0001a5a5UL, }, },
709
710         { BITS_PER_LONG, BITS_PER_LONG, BITS_PER_LONG,
711                 { 0xa5a5a5a5UL, 0xa5a5a5a5UL, },
712                 { 0xa5a5a5a5UL, 0xa5a5a5a5UL, },
713         },
714         { 1, BITS_PER_LONG - 1, BITS_PER_LONG,
715                 { 0xa5a5a5a5UL, 0xa5a5a5a5UL, },
716                 { 0x00000001UL, 0x00000001UL, },
717         },
718
719         { 0, BITS_PER_LONG * 2, BITS_PER_LONG * 2 + 1,
720                 { 0xa5a5a5a5UL, 0x00000001UL, 0x00000001UL, 0x00000001UL },
721                 { 0x00000001UL, },
722         },
723         { 16, BITS_PER_LONG * 2 + 1, BITS_PER_LONG * 2 + 1 + 16,
724                 { 0x0000ffffUL, 0x5a5a5a5aUL, 0x5a5a5a5aUL, 0x5a5a5a5aUL },
725                 { 0x2d2dffffUL, },
726         },
727 };
728
729 static void __init test_bitmap_cut(void)
730 {
731         unsigned long b[5], *in = &b[1], *out = &b[0];  /* Partial overlap */
732         int i;
733
734         for (i = 0; i < ARRAY_SIZE(test_cut); i++) {
735                 struct test_bitmap_cut *t = &test_cut[i];
736
737                 memcpy(in, t->in, sizeof(t->in));
738
739                 bitmap_cut(out, in, t->first, t->cut, t->nbits);
740
741                 expect_eq_bitmap(t->expected, out, t->nbits);
742         }
743 }
744
745 struct test_bitmap_print {
746         const unsigned long *bitmap;
747         unsigned long nbits;
748         const char *mask;
749         const char *list;
750 };
751
752 static const unsigned long small_bitmap[] __initconst = {
753         BITMAP_FROM_U64(0x3333333311111111ULL),
754 };
755
756 static const char small_mask[] __initconst = "33333333,11111111\n";
757 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";
758
759 static const unsigned long large_bitmap[] __initconst = {
760         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
761         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
762         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
763         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
764         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
765         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
766         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
767         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
768         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
769         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
770         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
771         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
772         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
773         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
774         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
775         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
776         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
777         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
778         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
779         BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
780 };
781
782 static const char large_mask[] __initconst = "33333333,11111111,33333333,11111111,"
783                                         "33333333,11111111,33333333,11111111,"
784                                         "33333333,11111111,33333333,11111111,"
785                                         "33333333,11111111,33333333,11111111,"
786                                         "33333333,11111111,33333333,11111111,"
787                                         "33333333,11111111,33333333,11111111,"
788                                         "33333333,11111111,33333333,11111111,"
789                                         "33333333,11111111,33333333,11111111,"
790                                         "33333333,11111111,33333333,11111111,"
791                                         "33333333,11111111,33333333,11111111,"
792                                         "33333333,11111111,33333333,11111111,"
793                                         "33333333,11111111,33333333,11111111,"
794                                         "33333333,11111111,33333333,11111111,"
795                                         "33333333,11111111,33333333,11111111,"
796                                         "33333333,11111111,33333333,11111111,"
797                                         "33333333,11111111,33333333,11111111,"
798                                         "33333333,11111111,33333333,11111111,"
799                                         "33333333,11111111,33333333,11111111,"
800                                         "33333333,11111111,33333333,11111111,"
801                                         "33333333,11111111,33333333,11111111\n";
802
803 static const char large_list[] __initconst = /* more than 4KB */
804         "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"
805         "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"
806         "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"
807         "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"
808         "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"
809         "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"
810         "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"
811         "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"
812         "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"
813         "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"
814         "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"
815         "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"
816         "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-"
817         "1001,1004-1005,1008-1009,1012-1013,1016-1017,1020-1021,1024,1028,1032,1036,1040,1044,1048,1052,1056-1057,1060-10"
818         "61,1064-1065,1068-1069,1072-1073,1076-1077,1080-1081,1084-1085,1088,1092,1096,1100,1104,1108,1112,1116,1120-1121"
819         ",1124-1125,1128-1129,1132-1133,1136-1137,1140-1141,1144-1145,1148-1149,1152,1156,1160,1164,1168,1172,1176,1180,1"
820         "184-1185,1188-1189,1192-1193,1196-1197,1200-1201,1204-1205,1208-1209,1212-1213,1216,1220,1224,1228,1232,1236,124"
821         "0,1244,1248-1249,1252-1253,1256-1257,1260-1261,1264-1265,1268-1269,1272-1273,1276-1277,1280,1284,1288,1292,1296,"
822         "1300,1304,1308,1312-1313,1316-1317,1320-1321,1324-1325,1328-1329,1332-1333,1336-1337,1340-1341,1344,1348,1352,13"
823         "56,1360,1364,1368,1372,1376-1377,1380-1381,1384-1385,1388-1389,1392-1393,1396-1397,1400-1401,1404-1405,1408,1412"
824         ",1416,1420,1424,1428,1432,1436,1440-1441,1444-1445,1448-1449,1452-1453,1456-1457,1460-1461,1464-1465,1468-1469,1"
825         "472,1476,1480,1484,1488,1492,1496,1500,1504-1505,1508-1509,1512-1513,1516-1517,1520-1521,1524-1525,1528-1529,153"
826         "2-1533,1536,1540,1544,1548,1552,1556,1560,1564,1568-1569,1572-1573,1576-1577,1580-1581,1584-1585,1588-1589,1592-"
827         "1593,1596-1597,1600,1604,1608,1612,1616,1620,1624,1628,1632-1633,1636-1637,1640-1641,1644-1645,1648-1649,1652-16"
828         "53,1656-1657,1660-1661,1664,1668,1672,1676,1680,1684,1688,1692,1696-1697,1700-1701,1704-1705,1708-1709,1712-1713"
829         ",1716-1717,1720-1721,1724-1725,1728,1732,1736,1740,1744,1748,1752,1756,1760-1761,1764-1765,1768-1769,1772-1773,1"
830         "776-1777,1780-1781,1784-1785,1788-1789,1792,1796,1800,1804,1808,1812,1816,1820,1824-1825,1828-1829,1832-1833,183"
831         "6-1837,1840-1841,1844-1845,1848-1849,1852-1853,1856,1860,1864,1868,1872,1876,1880,1884,1888-1889,1892-1893,1896-"
832         "1897,1900-1901,1904-1905,1908-1909,1912-1913,1916-1917,1920,1924,1928,1932,1936,1940,1944,1948,1952-1953,1956-19"
833         "57,1960-1961,1964-1965,1968-1969,1972-1973,1976-1977,1980-1981,1984,1988,1992,1996,2000,2004,2008,2012,2016-2017"
834         ",2020-2021,2024-2025,2028-2029,2032-2033,2036-2037,2040-2041,2044-2045,2048,2052,2056,2060,2064,2068,2072,2076,2"
835         "080-2081,2084-2085,2088-2089,2092-2093,2096-2097,2100-2101,2104-2105,2108-2109,2112,2116,2120,2124,2128,2132,213"
836         "6,2140,2144-2145,2148-2149,2152-2153,2156-2157,2160-2161,2164-2165,2168-2169,2172-2173,2176,2180,2184,2188,2192,"
837         "2196,2200,2204,2208-2209,2212-2213,2216-2217,2220-2221,2224-2225,2228-2229,2232-2233,2236-2237,2240,2244,2248,22"
838         "52,2256,2260,2264,2268,2272-2273,2276-2277,2280-2281,2284-2285,2288-2289,2292-2293,2296-2297,2300-2301,2304,2308"
839         ",2312,2316,2320,2324,2328,2332,2336-2337,2340-2341,2344-2345,2348-2349,2352-2353,2356-2357,2360-2361,2364-2365,2"
840         "368,2372,2376,2380,2384,2388,2392,2396,2400-2401,2404-2405,2408-2409,2412-2413,2416-2417,2420-2421,2424-2425,242"
841         "8-2429,2432,2436,2440,2444,2448,2452,2456,2460,2464-2465,2468-2469,2472-2473,2476-2477,2480-2481,2484-2485,2488-"
842         "2489,2492-2493,2496,2500,2504,2508,2512,2516,2520,2524,2528-2529,2532-2533,2536-2537,2540-2541,2544-2545,2548-25"
843         "49,2552-2553,2556-2557\n";
844
845 static const struct test_bitmap_print test_print[] __initconst = {
846         { small_bitmap, sizeof(small_bitmap) * BITS_PER_BYTE, small_mask, small_list },
847         { large_bitmap, sizeof(large_bitmap) * BITS_PER_BYTE, large_mask, large_list },
848 };
849
850 static void __init test_bitmap_print_buf(void)
851 {
852         int i;
853
854         for (i = 0; i < ARRAY_SIZE(test_print); i++) {
855                 const struct test_bitmap_print *t = &test_print[i];
856                 int n;
857
858                 n = bitmap_print_bitmask_to_buf(print_buf, t->bitmap, t->nbits,
859                                                 0, 2 * PAGE_SIZE);
860                 expect_eq_uint(strlen(t->mask) + 1, n);
861                 expect_eq_str(t->mask, print_buf, n);
862
863                 n = bitmap_print_list_to_buf(print_buf, t->bitmap, t->nbits,
864                                              0, 2 * PAGE_SIZE);
865                 expect_eq_uint(strlen(t->list) + 1, n);
866                 expect_eq_str(t->list, print_buf, n);
867
868                 /* test by non-zero offset */
869                 if (strlen(t->list) > PAGE_SIZE) {
870                         n = bitmap_print_list_to_buf(print_buf, t->bitmap, t->nbits,
871                                                      PAGE_SIZE, PAGE_SIZE);
872                         expect_eq_uint(strlen(t->list) + 1 - PAGE_SIZE, n);
873                         expect_eq_str(t->list + PAGE_SIZE, print_buf, n);
874                 }
875         }
876 }
877
878 static void __init test_bitmap_const_eval(void)
879 {
880         DECLARE_BITMAP(bitmap, BITS_PER_LONG);
881         unsigned long initvar = BIT(2);
882         unsigned long bitopvar = 0;
883         unsigned long var = 0;
884         int res;
885
886         /*
887          * Compilers must be able to optimize all of those to compile-time
888          * constants on any supported optimization level (-O2, -Os) and any
889          * architecture. Otherwise, trigger a build bug.
890          * The whole function gets optimized out then, there's nothing to do
891          * in runtime.
892          */
893
894         /*
895          * Equals to `unsigned long bitmap[1] = { GENMASK(6, 5), }`.
896          * Clang on s390 optimizes bitops at compile-time as intended, but at
897          * the same time stops treating @bitmap and @bitopvar as compile-time
898          * constants after regular test_bit() is executed, thus triggering the
899          * build bugs below. So, call const_test_bit() there directly until
900          * the compiler is fixed.
901          */
902         bitmap_clear(bitmap, 0, BITS_PER_LONG);
903 #if defined(__s390__) && defined(__clang__)
904         if (!const_test_bit(7, bitmap))
905 #else
906         if (!test_bit(7, bitmap))
907 #endif
908                 bitmap_set(bitmap, 5, 2);
909
910         /* Equals to `unsigned long bitopvar = BIT(20)` */
911         __change_bit(31, &bitopvar);
912         bitmap_shift_right(&bitopvar, &bitopvar, 11, BITS_PER_LONG);
913
914         /* Equals to `unsigned long var = BIT(25)` */
915         var |= BIT(25);
916         if (var & BIT(0))
917                 var ^= GENMASK(9, 6);
918
919         /* __const_hweight<32|64>(GENMASK(6, 5)) == 2 */
920         res = bitmap_weight(bitmap, 20);
921         BUILD_BUG_ON(!__builtin_constant_p(res));
922         BUILD_BUG_ON(res != 2);
923
924         /* !(BIT(31) & BIT(18)) == 1 */
925         res = !test_bit(18, &bitopvar);
926         BUILD_BUG_ON(!__builtin_constant_p(res));
927         BUILD_BUG_ON(!res);
928
929         /* BIT(2) & GENMASK(14, 8) == 0 */
930         res = initvar & GENMASK(14, 8);
931         BUILD_BUG_ON(!__builtin_constant_p(res));
932         BUILD_BUG_ON(res);
933
934         /* ~BIT(25) */
935         BUILD_BUG_ON(!__builtin_constant_p(~var));
936         BUILD_BUG_ON(~var != ~BIT(25));
937 }
938
939 static void __init selftest(void)
940 {
941         test_zero_clear();
942         test_fill_set();
943         test_copy();
944         test_replace();
945         test_bitmap_arr32();
946         test_bitmap_arr64();
947         test_bitmap_parse();
948         test_bitmap_parselist();
949         test_bitmap_printlist();
950         test_mem_optimisations();
951         test_for_each_set_clump8();
952         test_bitmap_cut();
953         test_bitmap_print_buf();
954         test_bitmap_const_eval();
955 }
956
957 KSTM_MODULE_LOADERS(test_bitmap);
958 MODULE_AUTHOR("david decotigny <david.decotigny@googlers.com>");
959 MODULE_LICENSE("GPL");