Skip to content

Commit 519b76a

Browse files
Ye Bintytso
Ye Bin
authored and
tytso
committed
ext4: fix mballoc-test.c is not compiled when EXT4_KUNIT_TESTS=M
Now, only EXT4_KUNIT_TESTS=Y testcase will be compiled in 'mballoc.c'. To solve this issue, the ext4 test code needs to be decoupled. The ext4 test module is compiled into a separate module. Reported-by: ChenXiaoSong <chenxiaosong@kylinos.cn> Closes: https://patchwork.kernel.org/project/cifs-client/patch/20260118091313.1988168-2-chenxiaosong.chenxiaosong@linux.dev/ Fixes: 7c9fa39 ("ext4: add first unit test for ext4_mb_new_blocks_simple in mballoc") Signed-off-by: Ye Bin <yebin10@huawei.com> Reviewed-by: Jan Kara <jack@suse.cz> Link: https://patch.msgid.link/20260314075258.1317579-3-yebin@huaweicloud.com Signed-off-by: Theodore Ts'o <tytso@mit.edu>
1 parent 49504a5 commit 519b76a

4 files changed

Lines changed: 172 additions & 45 deletions

File tree

‎fs/ext4/Makefile‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ ext4-y := balloc.o bitmap.o block_validity.o dir.o ext4_jbd2.o extents.o \
1414

1515
ext4-$(CONFIG_EXT4_FS_POSIX_ACL) += acl.o
1616
ext4-$(CONFIG_EXT4_FS_SECURITY) += xattr_security.o
17-
ext4-inode-test-objs += inode-test.o
18-
obj-$(CONFIG_EXT4_KUNIT_TESTS) += ext4-inode-test.o
17+
ext4-test-objs += inode-test.o mballoc-test.o
18+
obj-$(CONFIG_EXT4_KUNIT_TESTS) += ext4-test.o
1919
ext4-$(CONFIG_FS_VERITY) += verity.o
2020
ext4-$(CONFIG_FS_ENCRYPTION) += crypto.o

‎fs/ext4/mballoc-test.c‎

Lines changed: 41 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@
88
#include <linux/random.h>
99

1010
#include "ext4.h"
11+
#include "mballoc.h"
1112

1213
struct mbt_grp_ctx {
1314
struct buffer_head bitmap_bh;
@@ -336,7 +337,7 @@ ext4_mb_mark_context_stub(handle_t *handle, struct super_block *sb, bool state,
336337
if (state)
337338
mb_set_bits(bitmap_bh->b_data, blkoff, len);
338339
else
339-
mb_clear_bits(bitmap_bh->b_data, blkoff, len);
340+
mb_clear_bits_test(bitmap_bh->b_data, blkoff, len);
340341

341342
return 0;
342343
}
@@ -413,22 +414,22 @@ static void test_new_blocks_simple(struct kunit *test)
413414

414415
/* get block at goal */
415416
ar.goal = ext4_group_first_block_no(sb, goal_group);
416-
found = ext4_mb_new_blocks_simple(&ar, &err);
417+
found = ext4_mb_new_blocks_simple_test(&ar, &err);
417418
KUNIT_ASSERT_EQ_MSG(test, ar.goal, found,
418419
"failed to alloc block at goal, expected %llu found %llu",
419420
ar.goal, found);
420421

421422
/* get block after goal in goal group */
422423
ar.goal = ext4_group_first_block_no(sb, goal_group);
423-
found = ext4_mb_new_blocks_simple(&ar, &err);
424+
found = ext4_mb_new_blocks_simple_test(&ar, &err);
424425
KUNIT_ASSERT_EQ_MSG(test, ar.goal + EXT4_C2B(sbi, 1), found,
425426
"failed to alloc block after goal in goal group, expected %llu found %llu",
426427
ar.goal + 1, found);
427428

428429
/* get block after goal group */
429430
mbt_ctx_mark_used(sb, goal_group, 0, EXT4_CLUSTERS_PER_GROUP(sb));
430431
ar.goal = ext4_group_first_block_no(sb, goal_group);
431-
found = ext4_mb_new_blocks_simple(&ar, &err);
432+
found = ext4_mb_new_blocks_simple_test(&ar, &err);
432433
KUNIT_ASSERT_EQ_MSG(test,
433434
ext4_group_first_block_no(sb, goal_group + 1), found,
434435
"failed to alloc block after goal group, expected %llu found %llu",
@@ -438,7 +439,7 @@ static void test_new_blocks_simple(struct kunit *test)
438439
for (i = goal_group; i < ext4_get_groups_count(sb); i++)
439440
mbt_ctx_mark_used(sb, i, 0, EXT4_CLUSTERS_PER_GROUP(sb));
440441
ar.goal = ext4_group_first_block_no(sb, goal_group);
441-
found = ext4_mb_new_blocks_simple(&ar, &err);
442+
found = ext4_mb_new_blocks_simple_test(&ar, &err);
442443
KUNIT_ASSERT_EQ_MSG(test,
443444
ext4_group_first_block_no(sb, 0) + EXT4_C2B(sbi, 1), found,
444445
"failed to alloc block before goal group, expected %llu found %llu",
@@ -448,7 +449,7 @@ static void test_new_blocks_simple(struct kunit *test)
448449
for (i = 0; i < ext4_get_groups_count(sb); i++)
449450
mbt_ctx_mark_used(sb, i, 0, EXT4_CLUSTERS_PER_GROUP(sb));
450451
ar.goal = ext4_group_first_block_no(sb, goal_group);
451-
found = ext4_mb_new_blocks_simple(&ar, &err);
452+
found = ext4_mb_new_blocks_simple_test(&ar, &err);
452453
KUNIT_ASSERT_NE_MSG(test, err, 0,
453454
"unexpectedly get block when no block is available");
454455
}
@@ -492,16 +493,16 @@ validate_free_blocks_simple(struct kunit *test, struct super_block *sb,
492493
continue;
493494

494495
bitmap = mbt_ctx_bitmap(sb, i);
495-
bit = mb_find_next_zero_bit(bitmap, max, 0);
496+
bit = mb_find_next_zero_bit_test(bitmap, max, 0);
496497
KUNIT_ASSERT_EQ_MSG(test, bit, max,
497498
"free block on unexpected group %d", i);
498499
}
499500

500501
bitmap = mbt_ctx_bitmap(sb, goal_group);
501-
bit = mb_find_next_zero_bit(bitmap, max, 0);
502+
bit = mb_find_next_zero_bit_test(bitmap, max, 0);
502503
KUNIT_ASSERT_EQ(test, bit, start);
503504

504-
bit = mb_find_next_bit(bitmap, max, bit + 1);
505+
bit = mb_find_next_bit_test(bitmap, max, bit + 1);
505506
KUNIT_ASSERT_EQ(test, bit, start + len);
506507
}
507508

@@ -524,7 +525,7 @@ test_free_blocks_simple_range(struct kunit *test, ext4_group_t goal_group,
524525

525526
block = ext4_group_first_block_no(sb, goal_group) +
526527
EXT4_C2B(sbi, start);
527-
ext4_free_blocks_simple(inode, block, len);
528+
ext4_free_blocks_simple_test(inode, block, len);
528529
validate_free_blocks_simple(test, sb, goal_group, start, len);
529530
mbt_ctx_mark_used(sb, goal_group, 0, EXT4_CLUSTERS_PER_GROUP(sb));
530531
}
@@ -566,15 +567,15 @@ test_mark_diskspace_used_range(struct kunit *test,
566567

567568
bitmap = mbt_ctx_bitmap(sb, TEST_GOAL_GROUP);
568569
memset(bitmap, 0, sb->s_blocksize);
569-
ret = ext4_mb_mark_diskspace_used(ac, NULL);
570+
ret = ext4_mb_mark_diskspace_used_test(ac, NULL);
570571
KUNIT_ASSERT_EQ(test, ret, 0);
571572

572573
max = EXT4_CLUSTERS_PER_GROUP(sb);
573-
i = mb_find_next_bit(bitmap, max, 0);
574+
i = mb_find_next_bit_test(bitmap, max, 0);
574575
KUNIT_ASSERT_EQ(test, i, start);
575-
i = mb_find_next_zero_bit(bitmap, max, i + 1);
576+
i = mb_find_next_zero_bit_test(bitmap, max, i + 1);
576577
KUNIT_ASSERT_EQ(test, i, start + len);
577-
i = mb_find_next_bit(bitmap, max, i + 1);
578+
i = mb_find_next_bit_test(bitmap, max, i + 1);
578579
KUNIT_ASSERT_EQ(test, max, i);
579580
}
580581

@@ -617,54 +618,54 @@ static void mbt_generate_buddy(struct super_block *sb, void *buddy,
617618
max = EXT4_CLUSTERS_PER_GROUP(sb);
618619
bb_h = buddy + sbi->s_mb_offsets[1];
619620

620-
off = mb_find_next_zero_bit(bb, max, 0);
621+
off = mb_find_next_zero_bit_test(bb, max, 0);
621622
grp->bb_first_free = off;
622623
while (off < max) {
623624
grp->bb_counters[0]++;
624625
grp->bb_free++;
625626

626-
if (!(off & 1) && !mb_test_bit(off + 1, bb)) {
627+
if (!(off & 1) && !mb_test_bit_test(off + 1, bb)) {
627628
grp->bb_free++;
628629
grp->bb_counters[0]--;
629-
mb_clear_bit(off >> 1, bb_h);
630+
mb_clear_bit_test(off >> 1, bb_h);
630631
grp->bb_counters[1]++;
631632
grp->bb_largest_free_order = 1;
632633
off++;
633634
}
634635

635-
off = mb_find_next_zero_bit(bb, max, off + 1);
636+
off = mb_find_next_zero_bit_test(bb, max, off + 1);
636637
}
637638

638639
for (order = 1; order < MB_NUM_ORDERS(sb) - 1; order++) {
639640
bb = buddy + sbi->s_mb_offsets[order];
640641
bb_h = buddy + sbi->s_mb_offsets[order + 1];
641642
max = max >> 1;
642-
off = mb_find_next_zero_bit(bb, max, 0);
643+
off = mb_find_next_zero_bit_test(bb, max, 0);
643644

644645
while (off < max) {
645-
if (!(off & 1) && !mb_test_bit(off + 1, bb)) {
646+
if (!(off & 1) && !mb_test_bit_test(off + 1, bb)) {
646647
mb_set_bits(bb, off, 2);
647648
grp->bb_counters[order] -= 2;
648-
mb_clear_bit(off >> 1, bb_h);
649+
mb_clear_bit_test(off >> 1, bb_h);
649650
grp->bb_counters[order + 1]++;
650651
grp->bb_largest_free_order = order + 1;
651652
off++;
652653
}
653654

654-
off = mb_find_next_zero_bit(bb, max, off + 1);
655+
off = mb_find_next_zero_bit_test(bb, max, off + 1);
655656
}
656657
}
657658

658659
max = EXT4_CLUSTERS_PER_GROUP(sb);
659-
off = mb_find_next_zero_bit(bitmap, max, 0);
660+
off = mb_find_next_zero_bit_test(bitmap, max, 0);
660661
while (off < max) {
661662
grp->bb_fragments++;
662663

663-
off = mb_find_next_bit(bitmap, max, off + 1);
664+
off = mb_find_next_bit_test(bitmap, max, off + 1);
664665
if (off + 1 >= max)
665666
break;
666667

667-
off = mb_find_next_zero_bit(bitmap, max, off + 1);
668+
off = mb_find_next_zero_bit_test(bitmap, max, off + 1);
668669
}
669670
}
670671

@@ -706,7 +707,7 @@ do_test_generate_buddy(struct kunit *test, struct super_block *sb, void *bitmap,
706707
/* needed by validation in ext4_mb_generate_buddy */
707708
ext4_grp->bb_free = mbt_grp->bb_free;
708709
memset(ext4_buddy, 0xff, sb->s_blocksize);
709-
ext4_mb_generate_buddy(sb, ext4_buddy, bitmap, TEST_GOAL_GROUP,
710+
ext4_mb_generate_buddy_test(sb, ext4_buddy, bitmap, TEST_GOAL_GROUP,
710711
ext4_grp);
711712

712713
KUNIT_ASSERT_EQ(test, memcmp(mbt_buddy, ext4_buddy, sb->s_blocksize),
@@ -760,7 +761,7 @@ test_mb_mark_used_range(struct kunit *test, struct ext4_buddy *e4b,
760761
ex.fe_group = TEST_GOAL_GROUP;
761762

762763
ext4_lock_group(sb, TEST_GOAL_GROUP);
763-
mb_mark_used(e4b, &ex);
764+
mb_mark_used_test(e4b, &ex);
764765
ext4_unlock_group(sb, TEST_GOAL_GROUP);
765766

766767
mb_set_bits(bitmap, start, len);
@@ -769,7 +770,7 @@ test_mb_mark_used_range(struct kunit *test, struct ext4_buddy *e4b,
769770
memset(buddy, 0xff, sb->s_blocksize);
770771
for (i = 0; i < MB_NUM_ORDERS(sb); i++)
771772
grp->bb_counters[i] = 0;
772-
ext4_mb_generate_buddy(sb, buddy, bitmap, 0, grp);
773+
ext4_mb_generate_buddy_test(sb, buddy, bitmap, 0, grp);
773774

774775
KUNIT_ASSERT_EQ(test, memcmp(buddy, e4b->bd_buddy, sb->s_blocksize),
775776
0);
@@ -798,7 +799,7 @@ static void test_mb_mark_used(struct kunit *test)
798799
bb_counters[MB_NUM_ORDERS(sb)]), GFP_KERNEL);
799800
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, grp);
800801

801-
ret = ext4_mb_load_buddy(sb, TEST_GOAL_GROUP, &e4b);
802+
ret = ext4_mb_load_buddy_test(sb, TEST_GOAL_GROUP, &e4b);
802803
KUNIT_ASSERT_EQ(test, ret, 0);
803804

804805
grp->bb_free = EXT4_CLUSTERS_PER_GROUP(sb);
@@ -809,7 +810,7 @@ static void test_mb_mark_used(struct kunit *test)
809810
test_mb_mark_used_range(test, &e4b, ranges[i].start,
810811
ranges[i].len, bitmap, buddy, grp);
811812

812-
ext4_mb_unload_buddy(&e4b);
813+
ext4_mb_unload_buddy_test(&e4b);
813814
}
814815

815816
static void
@@ -825,16 +826,16 @@ test_mb_free_blocks_range(struct kunit *test, struct ext4_buddy *e4b,
825826
return;
826827

827828
ext4_lock_group(sb, e4b->bd_group);
828-
mb_free_blocks(NULL, e4b, start, len);
829+
mb_free_blocks_test(NULL, e4b, start, len);
829830
ext4_unlock_group(sb, e4b->bd_group);
830831

831-
mb_clear_bits(bitmap, start, len);
832+
mb_clear_bits_test(bitmap, start, len);
832833
/* bypass bb_free validatoin in ext4_mb_generate_buddy */
833834
grp->bb_free += len;
834835
memset(buddy, 0xff, sb->s_blocksize);
835836
for (i = 0; i < MB_NUM_ORDERS(sb); i++)
836837
grp->bb_counters[i] = 0;
837-
ext4_mb_generate_buddy(sb, buddy, bitmap, 0, grp);
838+
ext4_mb_generate_buddy_test(sb, buddy, bitmap, 0, grp);
838839

839840
KUNIT_ASSERT_EQ(test, memcmp(buddy, e4b->bd_buddy, sb->s_blocksize),
840841
0);
@@ -865,15 +866,15 @@ static void test_mb_free_blocks(struct kunit *test)
865866
bb_counters[MB_NUM_ORDERS(sb)]), GFP_KERNEL);
866867
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, grp);
867868

868-
ret = ext4_mb_load_buddy(sb, TEST_GOAL_GROUP, &e4b);
869+
ret = ext4_mb_load_buddy_test(sb, TEST_GOAL_GROUP, &e4b);
869870
KUNIT_ASSERT_EQ(test, ret, 0);
870871

871872
ex.fe_start = 0;
872873
ex.fe_len = EXT4_CLUSTERS_PER_GROUP(sb);
873874
ex.fe_group = TEST_GOAL_GROUP;
874875

875876
ext4_lock_group(sb, TEST_GOAL_GROUP);
876-
mb_mark_used(&e4b, &ex);
877+
mb_mark_used_test(&e4b, &ex);
877878
ext4_unlock_group(sb, TEST_GOAL_GROUP);
878879

879880
grp->bb_free = 0;
@@ -886,7 +887,7 @@ static void test_mb_free_blocks(struct kunit *test)
886887
test_mb_free_blocks_range(test, &e4b, ranges[i].start,
887888
ranges[i].len, bitmap, buddy, grp);
888889

889-
ext4_mb_unload_buddy(&e4b);
890+
ext4_mb_unload_buddy_test(&e4b);
890891
}
891892

892893
#define COUNT_FOR_ESTIMATE 100000
@@ -904,7 +905,7 @@ static void test_mb_mark_used_cost(struct kunit *test)
904905
if (sb->s_blocksize > PAGE_SIZE)
905906
kunit_skip(test, "blocksize exceeds pagesize");
906907

907-
ret = ext4_mb_load_buddy(sb, TEST_GOAL_GROUP, &e4b);
908+
ret = ext4_mb_load_buddy_test(sb, TEST_GOAL_GROUP, &e4b);
908909
KUNIT_ASSERT_EQ(test, ret, 0);
909910

910911
ex.fe_group = TEST_GOAL_GROUP;
@@ -918,7 +919,7 @@ static void test_mb_mark_used_cost(struct kunit *test)
918919
ex.fe_start = ranges[i].start;
919920
ex.fe_len = ranges[i].len;
920921
ext4_lock_group(sb, TEST_GOAL_GROUP);
921-
mb_mark_used(&e4b, &ex);
922+
mb_mark_used_test(&e4b, &ex);
922923
ext4_unlock_group(sb, TEST_GOAL_GROUP);
923924
}
924925
end = jiffies;
@@ -929,14 +930,14 @@ static void test_mb_mark_used_cost(struct kunit *test)
929930
continue;
930931

931932
ext4_lock_group(sb, TEST_GOAL_GROUP);
932-
mb_free_blocks(NULL, &e4b, ranges[i].start,
933+
mb_free_blocks_test(NULL, &e4b, ranges[i].start,
933934
ranges[i].len);
934935
ext4_unlock_group(sb, TEST_GOAL_GROUP);
935936
}
936937
}
937938

938939
kunit_info(test, "costed jiffies %lu\n", all);
939-
ext4_mb_unload_buddy(&e4b);
940+
ext4_mb_unload_buddy_test(&e4b);
940941
}
941942

942943
static const struct mbt_ext4_block_layout mbt_test_layouts[] = {

0 commit comments

Comments
 (0)