commit f2f28f1d09c0a00b3fc569422f881931d857fac9 Author: Alex Zhuravlev AuthorDate: Tue Oct 28 17:59:09 2008 +0000 Subject: ext4: detect on-disk corruption of block bitmap Detect on-disk corruption of block bitmap and better checking of preallocated blocks. Bugzilla-ID: b=16680 Signed-off-by: Alex Zhuravlev Reviewed-by: Kalpak Shah Signed-off-by: Andreas Dilger --- fs/ext4/ext4.h | 1 + fs/ext4/mballoc.c | 103 ++++++++++++++++++++++++++++++++++++++++------ fs/ext4/mballoc.h | 2 +- 3 files changed, 93 insertions(+), 13 deletions(-) diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h index d7ae1b1..f4a1557 100644 --- a/fs/ext4/ext4.h +++ b/fs/ext4/ext4.h @@ -3480,6 +3480,7 @@ struct ext4_group_info { ext4_grpblk_t bb_largest_free_order;/* order of largest frag in BG */ ext4_group_t bb_group; /* Group number */ struct list_head bb_prealloc_list; + unsigned long bb_prealloc_nr; #ifdef DOUBLE_CHECK void *bb_bitmap; #endif diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c index 9952908..5dbd7e7 100644 --- a/fs/ext4/mballoc.c +++ b/fs/ext4/mballoc.c @@ -399,7 +399,7 @@ static const char * const ext4_groupinfo_slab_names[NR_GRPINFO_CACHES] = { "ext4_groupinfo_64k", "ext4_groupinfo_128k" }; -static void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap, +static int ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap, ext4_group_t group); static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap, ext4_group_t group); @@ -1105,7 +1105,7 @@ mb_set_largest_free_order(struct super_block *sb, struct ext4_group_info *grp) } static noinline_for_stack -void ext4_mb_generate_buddy(struct super_block *sb, +int ext4_mb_generate_buddy(struct super_block *sb, void *buddy, void *bitmap, ext4_group_t group) { struct ext4_group_info *grp = ext4_get_group_info(sb, group); @@ -1149,6 +1149,7 @@ void ext4_mb_generate_buddy(struct super_block *sb, grp->bb_free = free; ext4_mark_group_bitmap_corrupted(sb, group, EXT4_GROUP_INFO_BBITMAP_CORRUPT); + return -EIO; } mb_set_largest_free_order(sb, grp); @@ -1158,6 +1159,8 @@ void ext4_mb_generate_buddy(struct super_block *sb, atomic_inc(&sbi->s_mb_buddies_generated); atomic64_add(period, &sbi->s_mb_generation_time); mb_update_avg_fragment_size(sb, grp); + + return 0; } /* The buddy information is attached the buddy cache inode @@ -1260,7 +1263,7 @@ static int ext4_mb_init_cache(struct page *page, char *incore, gfp_t gfp) } first_block = page->index * blocks_per_page; - for (i = 0; i < blocks_per_page; i++) { + for (i = 0; i < blocks_per_page && err == 0; i++) { group = (first_block + i) >> 1; if (group >= ngroups) break; @@ -1304,7 +1307,7 @@ static int ext4_mb_init_cache(struct page *page, char *incore, gfp_t gfp) ext4_lock_group(sb, group); /* init the buddy */ memset(data, 0xff, blocksize); - ext4_mb_generate_buddy(sb, data, incore, group); + err = ext4_mb_generate_buddy(sb, data, incore, group); ext4_unlock_group(sb, group); incore = NULL; } else { @@ -1319,7 +1322,7 @@ static int ext4_mb_init_cache(struct page *page, char *incore, gfp_t gfp) memcpy(data, bitmap, blocksize); /* mark all preallocated blks used in in-core bitmap */ - ext4_mb_generate_from_pa(sb, data, group); + err = ext4_mb_generate_from_pa(sb, data, group); ext4_mb_generate_from_freelist(sb, data, group); ext4_unlock_group(sb, group); @@ -1329,7 +1332,8 @@ static int ext4_mb_init_cache(struct page *page, char *incore, gfp_t gfp) incore = data; } } - SetPageUptodate(page); + if (likely(err == 0)) + SetPageUptodate(page); out: if (bh) { @@ -2858,9 +2862,11 @@ static void *ext4_mb_seq_groups_next(struct seq_file *seq, void *v, loff_t *pos) static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v) { struct super_block *sb = pde_data(file_inode(seq->file)); + struct ext4_group_desc *gdp; ext4_group_t group = (ext4_group_t) ((unsigned long) v); int i; int err, buddy_loaded = 0; + int free = 0; struct ext4_buddy e4b; struct ext4_group_info *grinfo; unsigned char blocksize_bits = min_t(unsigned char, @@ -2873,7 +2879,7 @@ static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v) group--; if (group == 0) - seq_puts(seq, "#group: free frags first [" + seq_puts(seq, "#group: bfree gfree frags first pa [" " 2^0 2^1 2^2 2^3 2^4 2^5 2^6 " " 2^7 2^8 2^9 2^10 2^11 2^12 2^13 ]\n"); @@ -2891,13 +2897,19 @@ static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v) buddy_loaded = 1; } + gdp = ext4_get_group_desc(sb, group, NULL); + if (gdp != NULL) + free = ext4_free_group_clusters(sb, gdp); + memcpy(&sg, ext4_get_group_info(sb, group), i); if (buddy_loaded) ext4_mb_unload_buddy(&e4b); - seq_printf(seq, "#%-5u: %-5u %-5u %-5u [", group, sg.info.bb_free, - sg.info.bb_fragments, sg.info.bb_first_free); + seq_printf(seq, "#%-5lu: %-5u %-5u %-5u %-5u %-5lu [", + (long unsigned int)group, sg.info.bb_free, free, + sg.info.bb_fragments, sg.info.bb_first_free, + sg.info.bb_prealloc_nr); for (i = 0; i <= 13; i++) seq_printf(seq, " %-5u", i <= blocksize_bits + 1 ? sg.info.bb_counters[i] : 0); @@ -4589,23 +4601,72 @@ static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap, return; } +/* + * check free blocks in bitmap match free block in group descriptor + * do this before taking preallocated blocks into account to be able + * to detect on-disk corruptions. The group lock should be hold by the + * caller. + */ +int ext4_mb_check_ondisk_bitmap(struct super_block *sb, void *bitmap, + struct ext4_group_desc *gdp, int group) +{ + unsigned short max = EXT4_CLUSTERS_PER_GROUP(sb); + unsigned short i, first, free = 0; + unsigned short free_in_gdp = ext4_free_group_clusters(sb, gdp); + + if (free_in_gdp == 0 && gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) + return 0; + + i = mb_find_next_zero_bit(bitmap, max, 0); + + while (i < max) { + first = i; + i = mb_find_next_bit(bitmap, max, i); + if (i > max) + i = max; + free += i - first; + if (i < max) + i = mb_find_next_zero_bit(bitmap, max, i); + } + + if (free != free_in_gdp) { + ext4_error(sb, "on-disk bitmap for group %d" + "corrupted: %u blocks free in bitmap, %u - in gd\n", + group, free, free_in_gdp); + return -EIO; + } + return 0; +} + /* * the function goes through all preallocation in this group and marks them * used in in-core bitmap. buddy must be generated from this bitmap * Need to be called with ext4 group lock held */ static noinline_for_stack -void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap, +int ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap, ext4_group_t group) { struct ext4_group_info *grp = ext4_get_group_info(sb, group); struct ext4_prealloc_space *pa; + struct ext4_group_desc *gdp; struct list_head *cur; ext4_group_t groupnr; ext4_grpblk_t start; int preallocated = 0; + int skip = 0, count = 0; + int err; int len; + gdp = ext4_get_group_desc(sb, group, NULL); + if (gdp == NULL) + return -EIO; + + /* before applying preallocations, check bitmap consistency */ + err = ext4_mb_check_ondisk_bitmap(sb, bitmap, gdp, group); + if (err) + return err; + /* all form of preallocation discards first load group, * so the only competing code is preallocation use. * we don't need any locking here @@ -4621,13 +4682,23 @@ void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap, &groupnr, &start); len = pa->pa_len; spin_unlock(&pa->pa_lock); - if (unlikely(len == 0)) + if (unlikely(len == 0)) { + skip++; continue; + } BUG_ON(groupnr != group); mb_set_bits(bitmap, start, len); preallocated += len; + count++; + } + if (count + skip != grp->bb_prealloc_nr) { + ext4_error(sb, "lost preallocations: " + "count %d, bb_prealloc_nr %lu, skip %d\n", + count, grp->bb_prealloc_nr, skip); + return -EIO; } mb_debug(sb, "preallocated %d for group %u\n", preallocated, group); + return 0; } static void ext4_mb_mark_pa_deleted(struct super_block *sb, @@ -4711,6 +4782,7 @@ static void ext4_mb_put_pa(struct ext4_allocation_context *ac, */ ext4_lock_group(sb, grp); list_del(&pa->pa_group_list); + ext4_get_group_info(sb, grp)->bb_prealloc_nr--; ext4_unlock_group(sb, grp); spin_lock(pa->pa_obj_lock); @@ -4802,6 +4874,7 @@ ext4_mb_new_inode_pa(struct ext4_allocation_context *ac) pa->pa_inode = ac->ac_inode; list_add(&pa->pa_group_list, &grp->bb_prealloc_list); + grp->bb_prealloc_nr++; spin_lock(pa->pa_obj_lock); list_add_rcu(&pa->pa_inode_list, &ei->i_prealloc_list); @@ -4857,6 +4930,7 @@ ext4_mb_new_group_pa(struct ext4_allocation_context *ac) pa->pa_inode = NULL; list_add(&pa->pa_group_list, &grp->bb_prealloc_list); + grp->bb_prealloc_nr++; /* * We will later add the new pa to the right bucket @@ -5021,6 +5095,8 @@ ext4_mb_discard_group_preallocations(struct super_block *sb, spin_unlock(&pa->pa_lock); + BUG_ON(grp->bb_prealloc_nr == 0); + grp->bb_prealloc_nr--; list_del(&pa->pa_group_list); list_add(&pa->u.pa_tmp_list, &list); } @@ -5148,7 +5224,7 @@ repeat: if (err) { ext4_error_err(sb, -err, "Error %d loading buddy information for %u", err, group); - continue; + return; } bitmap_bh = ext4_read_block_bitmap(sb, group); @@ -5161,6 +5237,8 @@ repeat: } ext4_lock_group(sb, group); + BUG_ON(e4b.bd_info->bb_prealloc_nr == 0); + e4b.bd_info->bb_prealloc_nr--; list_del(&pa->pa_group_list); ext4_mb_release_inode_pa(&e4b, bitmap_bh, pa); ext4_unlock_group(sb, group); @@ -5455,6 +5533,7 @@ ext4_mb_discard_lg_preallocations(struct super_block *sb, } ext4_lock_group(sb, group); list_del(&pa->pa_group_list); + ext4_get_group_info(sb, group)->bb_prealloc_nr--; ext4_mb_release_group_pa(&e4b, pa); ext4_unlock_group(sb, group); diff --git a/fs/ext4/mballoc.h b/fs/ext4/mballoc.h index 39da92c..b6c4a30 100644 --- a/fs/ext4/mballoc.h +++ b/fs/ext4/mballoc.h @@ -66,7 +66,7 @@ /* * for which requests use 2^N search using buddies */ -#define MB_DEFAULT_ORDER2_REQS 2 +#define MB_DEFAULT_ORDER2_REQS 8 /* * default group prealloc size 512 blocks -- 2.34.1