X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=e2fsck%2Fpass5.c;h=c1d45a5f14ed5e0725414a59c407ce4b8976b5ba;hb=5adb971551656597c568bac6b6c06e1506f89046;hp=86b5225d0ecdae88901c160df876d5f2a263a5e5;hpb=0a7baccf61847633d560f162c2ee999fd5dd1405;p=tools%2Fe2fsprogs.git

diff --git a/e2fsck/pass5.c b/e2fsck/pass5.c
index 86b5225..c1d45a5 100644
--- a/e2fsck/pass5.c
+++ b/e2fsck/pass5.c
@@ -21,8 +21,6 @@
 #include "e2fsck.h"
 #include "problem.h"
 
-#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
-
 static void check_block_bitmaps(e2fsck_t ctx);
 static void check_inode_bitmaps(e2fsck_t ctx);
 static void check_inode_end(e2fsck_t ctx);
@@ -75,6 +73,8 @@ void e2fsck_pass5(e2fsck_t ctx)
 	ctx->inode_dir_map = 0;
 	ext2fs_free_block_bitmap(ctx->block_found_map);
 	ctx->block_found_map = 0;
+	ext2fs_free_block_bitmap(ctx->block_metadata_map);
+	ctx->block_metadata_map = 0;
 
 	print_resource_track(ctx, _("Pass 5"), &rtrack, ctx->fs->io);
 }
@@ -82,15 +82,13 @@ void e2fsck_pass5(e2fsck_t ctx)
 static void check_inode_bitmap_checksum(e2fsck_t ctx)
 {
 	struct problem_context	pctx;
-	struct ext4_group_desc	*gdp;
-	char		*buf;
+	char		*buf = NULL;
 	dgrp_t		i;
 	int		nbytes;
 	ext2_ino_t	ino_itr;
 	errcode_t	retval;
 
-	if (!EXT2_HAS_RO_COMPAT_FEATURE(ctx->fs->super,
-					EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
+	if (!ext2fs_has_feature_metadata_csum(ctx->fs->super))
 		return;
 
 	/* If bitmap is dirty from being fixed, checksum will be corrected */
@@ -98,10 +96,9 @@ static void check_inode_bitmap_checksum(e2fsck_t ctx)
 		return;
 
 	nbytes = (size_t)(EXT2_INODES_PER_GROUP(ctx->fs->super) / 8);
-	retval = ext2fs_get_memalign(ctx->fs->blocksize, ctx->fs->blocksize,
-				     &buf);
+	retval = ext2fs_get_mem(ctx->fs->blocksize, &buf);
 	if (retval) {
-		com_err(ctx->program_name, 0,
+		com_err(ctx->program_name, 0, "%s",
 		    _("check_inode_bitmap_checksum: Memory allocation error"));
 		fatal_error(ctx, 0);
 	}
@@ -112,8 +109,6 @@ static void check_inode_bitmap_checksum(e2fsck_t ctx)
 			continue;
 
 		ino_itr = 1 + (i * (nbytes << 3));
-		gdp = (struct ext4_group_desc *)ext2fs_group_desc(ctx->fs,
-				ctx->fs->group_desc, i);
 		retval = ext2fs_get_inode_bitmap_range2(ctx->fs->inode_map,
 							ino_itr, nbytes << 3,
 							buf);
@@ -141,15 +136,13 @@ static void check_inode_bitmap_checksum(e2fsck_t ctx)
 static void check_block_bitmap_checksum(e2fsck_t ctx)
 {
 	struct problem_context	pctx;
-	struct ext4_group_desc	*gdp;
-	char		*buf;
+	char		*buf = NULL;
 	dgrp_t		i;
 	int		nbytes;
 	blk64_t		blk_itr;
 	errcode_t	retval;
 
-	if (!EXT2_HAS_RO_COMPAT_FEATURE(ctx->fs->super,
-					EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
+	if (!ext2fs_has_feature_metadata_csum(ctx->fs->super))
 		return;
 
 	/* If bitmap is dirty from being fixed, checksum will be corrected */
@@ -157,10 +150,9 @@ static void check_block_bitmap_checksum(e2fsck_t ctx)
 		return;
 
 	nbytes = (size_t)(EXT2_CLUSTERS_PER_GROUP(ctx->fs->super) / 8);
-	retval = ext2fs_get_memalign(ctx->fs->blocksize, ctx->fs->blocksize,
-				     &buf);
+	retval = ext2fs_get_mem(ctx->fs->blocksize, &buf);
 	if (retval) {
-		com_err(ctx->program_name, 0,
+		com_err(ctx->program_name, 0, "%s",
 		    _("check_block_bitmap_checksum: Memory allocation error"));
 		fatal_error(ctx, 0);
 	}
@@ -172,9 +164,7 @@ static void check_block_bitmap_checksum(e2fsck_t ctx)
 
 		blk_itr = EXT2FS_B2C(ctx->fs,
 				     ctx->fs->super->s_first_data_block) +
-			  (i * (nbytes << 3));
-		gdp = (struct ext4_group_desc *)ext2fs_group_desc(ctx->fs,
-				ctx->fs->group_desc, i);
+			  ((blk64_t) i * (nbytes << 3));
 		retval = ext2fs_get_block_bitmap_range2(ctx->fs->block_map,
 							blk_itr, nbytes << 3,
 							buf);
@@ -276,7 +266,7 @@ static void e2fsck_discard_inodes(e2fsck_t ctx, dgrp_t group,
 
 #define NO_BLK ((blk64_t) -1)
 
-static void print_bitmap_problem(e2fsck_t ctx, int problem,
+static void print_bitmap_problem(e2fsck_t ctx, problem_t problem,
 			    struct problem_context *pctx)
 {
 	switch (problem) {
@@ -310,7 +300,7 @@ static void print_bitmap_problem(e2fsck_t ctx, int problem,
 	pctx->ino = pctx->ino2 = 0;
 }
 
-/* Just to be more succint */
+/* Just to be more succinct */
 #define B2C(x)	EXT2FS_B2C(fs, (x))
 #define EQ_CLSTR(x, y) (B2C(x) == B2C(y))
 #define LE_CLSTR(x, y) (B2C(x) <= B2C(y))
@@ -321,22 +311,17 @@ static void check_block_bitmaps(e2fsck_t ctx)
 	ext2_filsys fs = ctx->fs;
 	blk64_t	i;
 	unsigned int	*free_array;
-	int	group = 0;
+	dgrp_t		g, group = 0;
 	unsigned int	blocks = 0;
 	blk64_t	free_blocks = 0;
 	blk64_t first_free = ext2fs_blocks_count(fs->super);
 	unsigned int	group_free = 0;
 	int	actual, bitmap;
 	struct problem_context	pctx;
-	int	problem, save_problem, fixit, had_problem;
+	problem_t	problem, save_problem;
+	int		fixit, had_problem;
 	errcode_t	retval;
-	int		csum_flag;
-	int		skip_group = 0;
-	int	old_desc_blocks = 0;
-	int	count = 0;
-	int	cmp_block = 0;
 	int	redo_flag = 0;
-	blk64_t	super_blk, old_desc_blk, new_desc_blk;
 	char *actual_buf, *bitmap_buf;
 
 	actual_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize,
@@ -378,14 +363,10 @@ static void check_block_bitmaps(e2fsck_t ctx)
 		goto errout;
 	}
 
-	csum_flag = ext2fs_has_group_desc_csum(fs);
 redo_counts:
 	had_problem = 0;
 	save_problem = 0;
 	pctx.blk = pctx.blk2 = NO_BLK;
-	if (csum_flag &&
-	    (ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT)))
-		skip_group++;
 	for (i = B2C(fs->super->s_first_data_block);
 	     i < ext2fs_blocks_count(fs->super);
 	     i += EXT2FS_CLUSTER_RATIO(fs)) {
@@ -407,7 +388,7 @@ redo_counts:
 		 * to do a discard operation.
 		 */
 		if (!first_block_in_bg ||
-		    (group == (int)fs->group_desc_count - 1) ||
+		    (group == fs->group_desc_count - 1) ||
 		    (ctx->options & E2F_OPT_DISCARD))
 			goto no_optimize;
 
@@ -416,15 +397,11 @@ redo_counts:
 				actual_buf);
 		if (retval)
 			goto no_optimize;
-		if (ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT))
-			memset(bitmap_buf, 0, nbytes);
-		else {
-			retval = ext2fs_get_block_bitmap_range2(fs->block_map,
-					B2C(i), fs->super->s_clusters_per_group,
-					bitmap_buf);
-			if (retval)
-				goto no_optimize;
-		}
+		retval = ext2fs_get_block_bitmap_range2(fs->block_map,
+				B2C(i), fs->super->s_clusters_per_group,
+				bitmap_buf);
+		if (retval)
+			goto no_optimize;
 		if (memcmp(actual_buf, bitmap_buf, nbytes) != 0)
 			goto no_optimize;
 		n = ext2fs_bitcount(actual_buf, nbytes);
@@ -434,73 +411,7 @@ redo_counts:
 		goto next_group;
 	no_optimize:
 
-		if (skip_group) {
-			if (first_block_in_bg) {
-				super_blk = 0;
-				old_desc_blk = 0;
-				new_desc_blk = 0;
-				ext2fs_super_and_bgd_loc2(fs, group, &super_blk,
-					 &old_desc_blk, &new_desc_blk, 0);
-
-				if (fs->super->s_feature_incompat &
-						EXT2_FEATURE_INCOMPAT_META_BG)
-					old_desc_blocks =
-						fs->super->s_first_meta_bg;
-				else
-					old_desc_blocks = fs->desc_blocks +
-					fs->super->s_reserved_gdt_blocks;
-
-				count = 0;
-				cmp_block = fs->super->s_clusters_per_group;
-				if (group == (int)fs->group_desc_count - 1)
-					cmp_block = EXT2FS_NUM_B2C(fs,
-						    ext2fs_group_blocks_count(fs, group));
-			}
-
-			bitmap = 0;
-			if (EQ_CLSTR(i, super_blk) ||
-			    (old_desc_blk && old_desc_blocks &&
-			     GE_CLSTR(i, old_desc_blk) &&
-			     LE_CLSTR(i, old_desc_blk + old_desc_blocks-1)) ||
-			    (new_desc_blk && EQ_CLSTR(i, new_desc_blk)) ||
-			    EQ_CLSTR(i, ext2fs_block_bitmap_loc(fs, group)) ||
-			    EQ_CLSTR(i, ext2fs_inode_bitmap_loc(fs, group)) ||
-			    (GE_CLSTR(i, ext2fs_inode_table_loc(fs, group)) &&
-			     LE_CLSTR(i, (ext2fs_inode_table_loc(fs, group) +
-					  fs->inode_blocks_per_group - 1)))) {
-				bitmap = 1;
-				actual = (actual != 0);
-				count++;
-				cmp_block--;
-			} else if ((EXT2FS_B2C(fs, i) - count -
-				    EXT2FS_B2C(fs, fs->super->s_first_data_block)) %
-				   fs->super->s_clusters_per_group == 0) {
-				/*
-				 * When the compare data blocks in block bitmap
-				 * are 0, count the free block,
-				 * skip the current block group.
-				 */
-				if (ext2fs_test_block_bitmap_range2(
-					    ctx->block_found_map,
-					    EXT2FS_B2C(fs, i),
-					    cmp_block)) {
-					/*
-					 * -1 means to skip the current block
-					 * group.
-					 */
-					blocks = fs->super->s_clusters_per_group - 1;
-					group_free = cmp_block;
-					free_blocks += cmp_block;
-					/*
-					 * The current block group's last block
-					 * is set to i.
-					 */
-					i += EXT2FS_C2B(fs, cmp_block - 1);
-					bitmap = 1;
-					goto do_counts;
-				}
-			}
-		} else if (redo_flag)
+		if (redo_flag)
 			bitmap = actual;
 		else
 			bitmap = ext2fs_fast_test_block_bitmap2(fs->block_map, i);
@@ -519,14 +430,15 @@ redo_counts:
 			 */
 			problem = PR_5_BLOCK_USED;
 
-			if (skip_group) {
+			if (ext2fs_bg_flags_test(fs, group,
+						 EXT2_BG_BLOCK_UNINIT)) {
 				struct problem_context pctx2;
 				pctx2.blk = i;
 				pctx2.group = group;
-				if (fix_problem(ctx, PR_5_BLOCK_UNINIT,&pctx2)){
-					ext2fs_bg_flags_clear(fs, group, EXT2_BG_BLOCK_UNINIT);
-					skip_group = 0;
-				}
+				if (fix_problem(ctx, PR_5_BLOCK_UNINIT,
+						&pctx2))
+					ext2fs_bg_flags_clear(fs, group,
+							EXT2_BG_BLOCK_UNINIT);
 			}
 		}
 		if (pctx.blk == NO_BLK) {
@@ -534,8 +446,8 @@ redo_counts:
 			save_problem = problem;
 		} else {
 			if ((problem == save_problem) &&
-			    (pctx.blk2 == i-1))
-				pctx.blk2++;
+			    (pctx.blk2 == i - EXT2FS_CLUSTER_RATIO(fs)))
+				pctx.blk2 += EXT2FS_CLUSTER_RATIO(fs);
 			else {
 				print_bitmap_problem(ctx, save_problem, &pctx);
 				pctx.blk = pctx.blk2 = i;
@@ -580,16 +492,10 @@ redo_counts:
 			group ++;
 			blocks = 0;
 			group_free = 0;
-			skip_group = 0;
 			if (ctx->progress)
 				if ((ctx->progress)(ctx, 5, group,
 						    fs->group_desc_count*2))
 					goto errout;
-			if (csum_flag &&
-			    (i != ext2fs_blocks_count(fs->super)-1) &&
-			    ext2fs_bg_flags_test(fs, group, 
-						EXT2_BG_BLOCK_UNINIT))
-				skip_group++;
 		}
 	}
 	if (pctx.blk != NO_BLK)
@@ -621,15 +527,15 @@ redo_counts:
 	} else if (fixit == 0)
 		ext2fs_unmark_valid(fs);
 
-	for (i = 0; i < fs->group_desc_count; i++) {
-		if (free_array[i] != ext2fs_bg_free_blocks_count(fs, i)) {
-			pctx.group = i;
-			pctx.blk = ext2fs_bg_free_blocks_count(fs, i);
-			pctx.blk2 = free_array[i];
+	for (g = 0; g < fs->group_desc_count; g++) {
+		if (free_array[g] != ext2fs_bg_free_blocks_count(fs, g)) {
+			pctx.group = g;
+			pctx.blk = ext2fs_bg_free_blocks_count(fs, g);
+			pctx.blk2 = free_array[g];
 
 			if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP,
 					&pctx)) {
-				ext2fs_bg_free_blocks_count_set(fs, i, free_array[i]);
+				ext2fs_bg_free_blocks_count_set(fs, g, free_array[g]);
 				ext2fs_mark_super_dirty(fs);
 			} else
 				ext2fs_unmark_valid(fs);
@@ -659,14 +565,15 @@ static void check_inode_bitmaps(e2fsck_t ctx)
 	unsigned int	free_inodes = 0;
 	int		group_free = 0;
 	int		dirs_count = 0;
-	int		group = 0;
+	dgrp_t		group = 0;
 	unsigned int	inodes = 0;
 	ext2_ino_t	*free_array;
 	ext2_ino_t	*dir_array;
 	int		actual, bitmap;
 	errcode_t	retval;
 	struct problem_context	pctx;
-	int		problem, save_problem, fixit, had_problem;
+	problem_t	problem, save_problem;
+	int		fixit, had_problem;
 	int		csum_flag;
 	int		skip_group = 0;
 	int		redo_flag = 0;
@@ -931,10 +838,11 @@ static void check_inode_end(e2fsck_t ctx)
 	ext2_filsys fs = ctx->fs;
 	ext2_ino_t	end, save_inodes_count, i;
 	struct problem_context	pctx;
+	int asked = 0;
 
 	clear_problem_context(&pctx);
 
-	end = EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count;
+	end = (__u64)EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count;
 	pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, end,
 						     &save_inodes_count);
 	if (pctx.errcode) {
@@ -944,11 +852,12 @@ static void check_inode_end(e2fsck_t ctx)
 		return;
 	}
 	if (save_inodes_count == end)
-		return;
+		goto check_intra_bg_tail;
 
 	/* protect loop from wrap-around if end is maxed */
 	for (i = save_inodes_count + 1; i <= end && i > save_inodes_count; i++) {
 		if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) {
+			asked = 1;
 			if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) {
 				for (; i <= end; i++)
 					ext2fs_mark_inode_bitmap(fs->inode_map,
@@ -968,6 +877,21 @@ static void check_inode_end(e2fsck_t ctx)
 		ctx->flags |= E2F_FLAG_ABORT; /* fatal */
 		return;
 	}
+	/*
+	 * If the number of inodes per block group != blocksize, we
+	 * can also have a potential problem with the tail bits in
+	 * each individual inode bitmap block.  If there is a problem,
+	 * it would have been noticed when the bitmap was loaded.  And
+	 * fixing this is easy; all we need to do force the bitmap to
+	 * be written back to disk.
+	 */
+check_intra_bg_tail:
+	if (!asked && fs->flags & EXT2_FLAG_IBITMAP_TAIL_PROBLEM) {
+		if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx))
+			ext2fs_mark_ib_dirty(fs);
+		else
+			ext2fs_unmark_valid(fs);
+	}
 }
 
 static void check_block_end(e2fsck_t ctx)
@@ -975,11 +899,12 @@ static void check_block_end(e2fsck_t ctx)
 	ext2_filsys fs = ctx->fs;
 	blk64_t	end, save_blocks_count, i;
 	struct problem_context	pctx;
+	int asked = 0;
 
 	clear_problem_context(&pctx);
 
 	end = ext2fs_get_block_bitmap_start2(fs->block_map) +
-		((blk64_t)EXT2_CLUSTERS_PER_GROUP(fs->super) * fs->group_desc_count) - 1;
+		EXT2_GROUPS_TO_CLUSTERS(fs->super, fs->group_desc_count) - 1;
 	pctx.errcode = ext2fs_fudge_block_bitmap_end2(fs->block_map, end,
 						     &save_blocks_count);
 	if (pctx.errcode) {
@@ -989,12 +914,13 @@ static void check_block_end(e2fsck_t ctx)
 		return;
 	}
 	if (save_blocks_count == end)
-		return;
+		goto check_intra_bg_tail;
 
 	/* Protect loop from wrap-around if end is maxed */
 	for (i = save_blocks_count + 1; i <= end && i > save_blocks_count; i++) {
 		if (!ext2fs_test_block_bitmap2(fs->block_map,
 					       EXT2FS_C2B(fs, i))) {
+			asked = 1;
 			if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) {
 				for (; i <= end; i++)
 					ext2fs_mark_block_bitmap2(fs->block_map,
@@ -1014,7 +940,19 @@ static void check_block_end(e2fsck_t ctx)
 		ctx->flags |= E2F_FLAG_ABORT; /* fatal */
 		return;
 	}
+	/*
+	 * If the number of blocks per block group != blocksize, we
+	 * can also have a potential problem with the tail bits in
+	 * each individual block bitmap block.  If there is a problem,
+	 * it would have been noticed when the bitmap was loaded.  And
+	 * fixing this is easy; all we need to do force the bitmap to
+	 * be written back to disk.
+	 */
+check_intra_bg_tail:
+	if (!asked && fs->flags & EXT2_FLAG_BBITMAP_TAIL_PROBLEM) {
+		if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx))
+			ext2fs_mark_bb_dirty(fs);
+		else
+			ext2fs_unmark_valid(fs);
+	}
 }
-
-
-