Another patch from Garrett: remove bad block bitmap checking code. Everything

produced in the list ten years has some variant of internal error correction
(disks, cdrom, flash), so if it has user-visible bad blocks on it the
hardware has exhausted its remapping reserve and is dying, and you need to get
your data off pronto.  (The one exception I can think of is floppies, and I
don't care.)

2 files changed, 10 insertions, 419 deletions

diff --git a/e2fsprogs/e2fsck.c b/e2fsprogs/e2fsck.c
index 7e1c82e54..eadb0f64d 100644
--- a/e2fsprogs/e2fsck.c
+++ b/e2fsprogs/e2fsck.c
@@ -101,7 +101,6 @@ struct problem_context {
 };
 
 
-
 /*
  * Function declarations
  */
@@ -227,124 +226,6 @@ static void do_cache_destroy(kmem_cache_t *cache)
 	free(cache);
 }
 
-/*
- * badblocks.c --- replace/append bad blocks to the bad block inode
- */
-
-static int check_bb_inode_blocks(ext2_filsys fs, blk_t *block_nr, int blockcnt,
-				 void *priv_data);
-
-
-static void invalid_block(ext2_filsys fs FSCK_ATTR((unused)), blk_t blk)
-{
-	printf(_("Bad block %u out of range; ignored.\n"), blk);
-	return;
-}
-
-static void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
-			  int replace_bad_blocks)
-{
-	ext2_filsys fs = ctx->fs;
-	errcode_t       retval;
-	badblocks_list  bb_list = 0;
-	FILE            *f;
-	char            buf[1024];
-
-	e2fsck_read_bitmaps(ctx);
-
-	/*
-	 * Make sure the bad block inode is sane.  If there are any
-	 * illegal blocks, clear them.
-	 */
-	retval = ext2fs_block_iterate(fs, EXT2_BAD_INO, 0, 0,
-				      check_bb_inode_blocks, 0);
-	if (retval) {
-		bb_error_msg(_("while sanity checking the bad blocks inode"));
-		goto fatal;
-	}
-
-	/*
-	 * If we're appending to the bad blocks inode, read in the
-	 * current bad blocks.
-	 */
-	if (!replace_bad_blocks) {
-		retval = ext2fs_read_bb_inode(fs, &bb_list);
-		if (retval) {
-			bb_error_msg(_("while reading the bad blocks inode"));
-			goto fatal;
-		}
-	}
-
-	/*
-	 * Now read in the bad blocks from the file; if
-	 * bad_blocks_file is null, then try to run the badblocks
-	 * command.
-	 */
-	if (bad_blocks_file) {
-		f = fopen(bad_blocks_file, "r");
-		if (!f) {
-			bb_error_msg(_("while trying to open %s"), bad_blocks_file);
-			goto fatal;
-		}
-	} else {
-		sprintf(buf, "badblocks -b %d %s%s%s %d", fs->blocksize,
-			(ctx->options & E2F_OPT_PREEN) ? "" : "-s ",
-			(ctx->options & E2F_OPT_WRITECHECK) ? "-n " : "",
-			fs->device_name, fs->super->s_blocks_count);
-		f = popen(buf, "r");
-		if (!f) {
-			bb_error_msg(_("while trying popen '%s'"), buf);
-			goto fatal;
-		}
-	}
-	retval = ext2fs_read_bb_FILE(fs, f, &bb_list, invalid_block);
-	if (bad_blocks_file)
-		fclose(f);
-	else
-		pclose(f);
-	if (retval) {
-		bb_error_msg(_("while reading in list of bad blocks from file"));
-		goto fatal;
-	}
-
-	/*
-	 * Finally, update the bad blocks from the bad_block_map
-	 */
-	retval = ext2fs_update_bb_inode(fs, bb_list);
-	if (retval) {
-		bb_error_msg(_("while updating bad block inode"));
-		goto fatal;
-	}
-
-	ext2fs_badblocks_list_free(bb_list);
-	return;
-
-fatal:
-	ctx->flags |= E2F_FLAG_ABORT;
-	return;
-
-}
-
-static int check_bb_inode_blocks(ext2_filsys fs,
-				 blk_t *block_nr,
-				 int blockcnt FSCK_ATTR((unused)),
-				 void *priv_data FSCK_ATTR((unused)))
-{
-	if (!*block_nr)
-		return 0;
-
-	/*
-	 * If the block number is outrageous, clear it and ignore it.
-	 */
-	if (*block_nr >= fs->super->s_blocks_count ||
-	    *block_nr < fs->super->s_first_data_block) {
-		printf(_("Warning illegal block %u found in bad block inode.  Cleared.\n"), *block_nr);
-		*block_nr = 0;
-		return BLOCK_CHANGED;
-	}
-
-	return 0;
-}
 
 /*
  * Dictionary Abstract Data Type
@@ -1081,8 +962,6 @@ static errcode_t e2fsck_reset_context(e2fsck_t ctx)
 	ctx->block_dup_map = 0;
 	ext2fs_free_block_bitmap(ctx->block_ea_map);
 	ctx->block_ea_map = 0;
-	ext2fs_free_inode_bitmap(ctx->inode_bb_map);
-	ctx->inode_bb_map = 0;
 	ext2fs_free_inode_bitmap(ctx->inode_bad_map);
 	ctx->inode_bad_map = 0;
 	ext2fs_free_inode_bitmap(ctx->inode_imagic_map);
@@ -1107,7 +986,6 @@ static errcode_t e2fsck_reset_context(e2fsck_t ctx)
 	ctx->fs_fast_symlinks_count = 0;
 	ctx->fs_fifo_count = 0;
 	ctx->fs_total_count = 0;
-	ctx->fs_badblocks_count = 0;
 	ctx->fs_sockets_count = 0;
 	ctx->fs_ind_count = 0;
 	ctx->fs_dind_count = 0;
@@ -2983,7 +2861,6 @@ static int region_allocate(region_t region, region_addr_t start, int n)
  *      - A bitmap of which inodes are directories.     (inode_dir_map)
  *      - A bitmap of which inodes are regular files.   (inode_reg_map)
  *      - A bitmap of which inodes have bad fields.     (inode_bad_map)
- *      - A bitmap of which inodes are in bad blocks.   (inode_bb_map)
  *      - A bitmap of which inodes are imagic inodes.   (inode_imagic_map)
  *      - A bitmap of which blocks are in use.          (block_found_map)
  *      - A bitmap of which blocks are in use by two inodes     (block_dup_map)
@@ -3009,7 +2886,6 @@ static int process_bad_block(ext2_filsys fs, blk_t *block_nr,
 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
 			 char *block_buf);
 static void mark_table_blocks(e2fsck_t ctx);
-static void alloc_bb_map(e2fsck_t ctx);
 static void alloc_imagic_map(e2fsck_t ctx);
 static void mark_inode_bad(e2fsck_t ctx, ino_t ino);
 static void handle_fs_bad_blocks(e2fsck_t ctx);
@@ -3462,10 +3338,6 @@ static void e2fsck_pass1(e2fsck_t ctx)
 		if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
 			return;
 		if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) {
-			if (!ctx->inode_bb_map)
-				alloc_bb_map(ctx);
-			ext2fs_mark_inode_bitmap(ctx->inode_bb_map, ino);
-			ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
 			continue;
 		}
 		if (pctx.errcode) {
@@ -3947,26 +3819,6 @@ static void mark_inode_bad(e2fsck_t ctx, ino_t ino)
 
 
 /*
- * This procedure will allocate the inode "bb" (badblock) map table
- */
-static void alloc_bb_map(e2fsck_t ctx)
-{
-	struct          problem_context pctx;
-
-	clear_problem_context(&pctx);
-	pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
-					      _("inode in bad block map"),
-					      &ctx->inode_bb_map);
-	if (pctx.errcode) {
-		pctx.num = 4;
-		fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
-		/* Should never get here */
-		ctx->flags |= E2F_FLAG_ABORT;
-		return;
-	}
-}
-
-/*
  * This procedure will allocate the inode imagic table
  */
 static void alloc_imagic_map(e2fsck_t ctx)
@@ -4570,222 +4422,20 @@ mark_dir:
 	return ret_code;
 }
 
-static int process_bad_block(ext2_filsys fs,
+static int process_bad_block(ext2_filsys fs FSCK_ATTR((unused)),
 		      blk_t *block_nr,
 		      e2_blkcnt_t blockcnt,
 		      blk_t ref_block FSCK_ATTR((unused)),
 		      int ref_offset FSCK_ATTR((unused)),
-		      void *priv_data)
+		      void *priv_data EXT2FS_ATTR((unused)))
 {
-	struct process_block_struct_1 *p;
-	blk_t           blk = *block_nr;
-	blk_t           first_block;
-	dgrp_t          i;
-	struct problem_context *pctx;
-	e2fsck_t        ctx;
-
 	/*
 	 * Note: This function processes blocks for the bad blocks
 	 * inode, which is never compressed.  So we don't use HOLE_BLKADDR().
 	 */
 
-	if (!blk)
-		return 0;
-
-	p = (struct process_block_struct_1 *) priv_data;
-	ctx = p->ctx;
-	pctx = p->pctx;
-
-	pctx->ino = EXT2_BAD_INO;
-	pctx->blk = blk;
-	pctx->blkcount = blockcnt;
-
-	if ((blk < fs->super->s_first_data_block) ||
-	    (blk >= fs->super->s_blocks_count)) {
-		if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
-			*block_nr = 0;
-			return BLOCK_CHANGED;
-		} else
-			return 0;
-	}
-
-	if (blockcnt < 0) {
-		if (ext2fs_test_block_bitmap(p->fs_meta_blocks, blk)) {
-			p->bbcheck = 1;
-			if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) {
-				*block_nr = 0;
-				return BLOCK_CHANGED;
-			}
-		} else if (ext2fs_test_block_bitmap(ctx->block_found_map,
-						    blk)) {
-			p->bbcheck = 1;
-			if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK,
-					pctx)) {
-				*block_nr = 0;
-				return BLOCK_CHANGED;
-			}
-			if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-				return BLOCK_ABORT;
-		} else
-			mark_block_used(ctx, blk);
-		return 0;
-	}
-
-	ctx->fs_badblocks_count++;
-	/*
-	 * If the block is not used, then mark it as used and return.
-	 * If it is already marked as found, this must mean that
-	 * there's an overlap between the filesystem table blocks
-	 * (bitmaps and inode table) and the bad block list.
-	 */
-	if (!ext2fs_test_block_bitmap(ctx->block_found_map, blk)) {
-		ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
-		return 0;
-	}
-	/*
-	 * Try to find the where the filesystem block was used...
-	 */
-	first_block = fs->super->s_first_data_block;
-
-	for (i = 0; i < fs->group_desc_count; i++ ) {
-		pctx->group = i;
-		pctx->blk = blk;
-		if (!ext2fs_bg_has_super(fs, i))
-			goto skip_super;
-		if (blk == first_block) {
-			if (i == 0) {
-				if (fix_problem(ctx,
-						PR_1_BAD_PRIMARY_SUPERBLOCK,
-						pctx)) {
-					*block_nr = 0;
-					return BLOCK_CHANGED;
-				}
-				return 0;
-			}
-			fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx);
-			return 0;
-		}
-		if ((blk > first_block) &&
-		    (blk <= first_block + fs->desc_blocks)) {
-			if (i == 0) {
-				pctx->blk = *block_nr;
-				if (fix_problem(ctx,
-			PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) {
-					*block_nr = 0;
-					return BLOCK_CHANGED;
-				}
-				return 0;
-			}
-			fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx);
-			return 0;
-		}
-	skip_super:
-		if (blk == fs->group_desc[i].bg_block_bitmap) {
-			if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) {
-				ctx->invalid_block_bitmap_flag[i]++;
-				ctx->invalid_bitmaps++;
-			}
-			return 0;
-		}
-		if (blk == fs->group_desc[i].bg_inode_bitmap) {
-			if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) {
-				ctx->invalid_inode_bitmap_flag[i]++;
-				ctx->invalid_bitmaps++;
-			}
-			return 0;
-		}
-		if ((blk >= fs->group_desc[i].bg_inode_table) &&
-		    (blk < (fs->group_desc[i].bg_inode_table +
-			    fs->inode_blocks_per_group))) {
-			/*
-			 * If there are bad blocks in the inode table,
-			 * the inode scan code will try to do
-			 * something reasonable automatically.
-			 */
-			return 0;
-		}
-		first_block += fs->super->s_blocks_per_group;
-	}
-	/*
-	 * If we've gotten to this point, then the only
-	 * possibility is that the bad block inode meta data
-	 * is using a bad block.
-	 */
-	if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) ||
-	    (blk == p->inode->i_block[EXT2_DIND_BLOCK]) ||
-	    (blk == p->inode->i_block[EXT2_TIND_BLOCK])) {
-		p->bbcheck = 1;
-		if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) {
-			*block_nr = 0;
-			return BLOCK_CHANGED;
-		}
-		if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-			return BLOCK_ABORT;
-		return 0;
-	}
-
-	pctx->group = -1;
-
-	/* Warn user that the block wasn't claimed */
-	fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx);
-
-	return 0;
-}
-
-static void new_table_block(e2fsck_t ctx, blk_t first_block, int group,
-			    const char *name, int num, blk_t *new_block)
-{
-	ext2_filsys fs = ctx->fs;
-	blk_t           old_block = *new_block;
-	int             i;
-	char            *buf;
-	struct problem_context  pctx;
-
-	clear_problem_context(&pctx);
-
-	pctx.group = group;
-	pctx.blk = old_block;
-	pctx.str = name;
-
-	pctx.errcode = ext2fs_get_free_blocks(fs, first_block,
-			first_block + fs->super->s_blocks_per_group,
-					num, ctx->block_found_map, new_block);
-	if (pctx.errcode) {
-		pctx.num = num;
-		fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx);
-		ext2fs_unmark_valid(fs);
-		return;
-	}
-	pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf);
-	if (pctx.errcode) {
-		fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx);
-		ext2fs_unmark_valid(fs);
-		return;
-	}
-	ext2fs_mark_super_dirty(fs);
-	fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
-	pctx.blk2 = *new_block;
-	fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO :
-			  PR_1_RELOC_TO), &pctx);
-	pctx.blk2 = 0;
-	for (i = 0; i < num; i++) {
-		pctx.blk = i;
-		ext2fs_mark_block_bitmap(ctx->block_found_map, (*new_block)+i);
-		if (old_block) {
-			pctx.errcode = io_channel_read_blk(fs->io,
-				   old_block + i, 1, buf);
-			if (pctx.errcode)
-				fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx);
-		} else
-			memset(buf, 0, fs->blocksize);
-
-		pctx.blk = (*new_block) + i;
-		pctx.errcode = io_channel_write_blk(fs->io, pctx.blk,
-					      1, buf);
-		if (pctx.errcode)
-			fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx);
-	}
-	ext2fs_free_mem(&buf);
+	printf("Unrecoverable Error: Found %lli bad blocks starting at block number: %u\n", blockcnt, *block_nr);
+	return BLOCK_ERROR;
 }
 
 /*
@@ -4797,28 +4447,8 @@ static void new_table_block(e2fsck_t ctx, blk_t first_block, int group,
  */
 static void handle_fs_bad_blocks(e2fsck_t ctx)
 {
-	ext2_filsys fs = ctx->fs;
-	dgrp_t          i;
-	int             first_block = fs->super->s_first_data_block;
-
-	for (i = 0; i < fs->group_desc_count; i++) {
-		if (ctx->invalid_block_bitmap_flag[i]) {
-			new_table_block(ctx, first_block, i, _("block bitmap"),
-					1, &fs->group_desc[i].bg_block_bitmap);
-		}
-		if (ctx->invalid_inode_bitmap_flag[i]) {
-			new_table_block(ctx, first_block, i, _("inode bitmap"),
-					1, &fs->group_desc[i].bg_inode_bitmap);
-		}
-		if (ctx->invalid_inode_table_flag[i]) {
-			new_table_block(ctx, first_block, i, _("inode table"),
-					fs->inode_blocks_per_group,
-					&fs->group_desc[i].bg_inode_table);
-			ctx->flags |= E2F_FLAG_RESTART;
-		}
-		first_block += fs->super->s_blocks_per_group;
-	}
-	ctx->invalid_bitmaps = 0;
+	printf("Bad blocks detected on your filesystem\n"
+		"You should get your data off as the device will soon die\n");
 }
 
 /*
@@ -6579,14 +6209,6 @@ static int check_dir_block(ext2_filsys fs,
 			 * If the inode is unused, offer to clear it.
 			 */
 			problem = PR_2_UNUSED_INODE;
-		} else if (ctx->inode_bb_map &&
-			   (ext2fs_test_inode_bitmap(ctx->inode_bb_map,
-						     dirent->inode))) {
-			/*
-			 * If the inode is in a bad block, offer to
-			 * clear it.
-			 */
-			problem = PR_2_BB_INODE;
 		} else if ((dot_state > 1) &&
 			   ((dirent->name_len & 0xFF) == 1) &&
 			   (dirent->name[0] == '.')) {
@@ -7863,7 +7485,6 @@ errcode_t e2fsck_expand_directory(e2fsck_t ctx, ext2_ino_t dir,
  * pass4.c -- pass #4 of e2fsck: Check reference counts
  *
  * Pass 4 frees the following data structures:
- *      - A bitmap of which inodes are in bad blocks.   (inode_bb_map)
  *      - A bitmap of which inodes are imagic inodes.   (inode_imagic_map)
  */
 
@@ -7967,9 +7588,7 @@ static void e2fsck_pass4(e2fsck_t ctx)
 			continue;
 		if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, i)) ||
 		    (ctx->inode_imagic_map &&
-		     ext2fs_test_inode_bitmap(ctx->inode_imagic_map, i)) ||
-		    (ctx->inode_bb_map &&
-		     ext2fs_test_inode_bitmap(ctx->inode_bb_map, i)))
+		     ext2fs_test_inode_bitmap(ctx->inode_imagic_map, i)))
 			continue;
 		ext2fs_icount_fetch(ctx->inode_link_info, i, &link_count);
 		ext2fs_icount_fetch(ctx->inode_count, i, &link_counted);
@@ -8004,8 +7623,6 @@ static void e2fsck_pass4(e2fsck_t ctx)
 	}
 	ext2fs_free_icount(ctx->inode_link_info); ctx->inode_link_info = 0;
 	ext2fs_free_icount(ctx->inode_count); ctx->inode_count = 0;
-	ext2fs_free_inode_bitmap(ctx->inode_bb_map);
-	ctx->inode_bb_map = 0;
 	ext2fs_free_inode_bitmap(ctx->inode_imagic_map);
 	ctx->inode_imagic_map = 0;
 	ext2fs_free_mem(&buf);
@@ -12981,10 +12598,6 @@ static int cflag;               /* check disk */
 static int show_version_only;
 static int verbose;
 
-static int replace_bad_blocks;
-static int keep_bad_blocks;
-static char *bad_blocks_file;
-
 #define P_E2(singular, plural, n)       n, ((n) == 1 ? singular : plural)
 
 static void show_stats(e2fsck_t ctx)
@@ -13024,7 +12637,6 @@ static void show_stats(e2fsck_t ctx)
 		ctx->fs_ind_count, ctx->fs_dind_count, ctx->fs_tind_count);
 	printf ("%8d block%s used (%d%%)\n", P_E2("", "s", blocks_used),
 		(int) ((long long) 100 * blocks_used / blocks));
-	printf ("%8d bad block%s\n", P_E2("", "s", ctx->fs_badblocks_count));
 	printf ("%8d large file%s\n", P_E2("", "s", ctx->large_files));
 	printf ("\n%8d regular file%s\n", P_E2("", "s", ctx->fs_regular_count));
 	printf ("%8d director%s\n", P_E2("y", "ies", ctx->fs_directory_count));
@@ -13131,8 +12743,7 @@ static void check_if_skip(e2fsck_t ctx)
 	int batt = is_on_batt();
 	time_t now = time(0);
 
-	if ((ctx->options & E2F_OPT_FORCE) || bad_blocks_file ||
-	    cflag || swapfs)
+	if ((ctx->options & E2F_OPT_FORCE) || cflag || swapfs)
 		return;
 
 	if ((fs->super->s_state & EXT2_ERROR_FS) ||
@@ -13519,11 +13130,6 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
 		case 'P':
 			ctx->process_inode_size = atoi(optarg);
 			break;
-		case 'L':
-			replace_bad_blocks++;
-		case 'l':
-			bad_blocks_file = string_copy(optarg, 0);
-			break;
 		case 'd':
 			ctx->options |= E2F_OPT_DEBUG;
 			break;
@@ -13556,9 +13162,6 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
 					  "of e2fsck\n"));
 			exit(1);
 #endif
-		case 'k':
-			keep_bad_blocks++;
-			break;
 		default:
 			bb_show_usage();
 		}
@@ -13566,7 +13169,7 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
 		return 0;
 	if (optind != argc - 1)
 		bb_show_usage();
-	if ((ctx->options & E2F_OPT_NO) && !bad_blocks_file &&
+	if ((ctx->options & E2F_OPT_NO) &&
 	    !cflag && !swapfs && !(ctx->options & E2F_OPT_COMPRESS_DIRS))
 		ctx->options |= E2F_OPT_READONLY;
 	ctx->io_options = strchr(argv[optind], '?');
@@ -13595,19 +13198,13 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
 		close(fd);
 	}
 #ifdef ENABLE_SWAPFS
-	if (swapfs) {
-		if (cflag || bad_blocks_file) {
+	if (swapfs && cflag) {
 			fprintf(stderr, _("Incompatible options not "
 					  "allowed when byte-swapping.\n"));
 			exit(EXIT_USAGE);
 		}
 	}
 #endif
-	if (cflag && bad_blocks_file) {
-		fprintf(stderr, _("The -c and the -l/-L options may "
-				  "not be both used at the same time.\n"));
-		exit(EXIT_USAGE);
-	}
 	/*
 	 * Set up signal action
 	 */
@@ -13873,10 +13470,6 @@ restart:
 	if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
 		bb_error_msg_and_die(0);
 	check_if_skip(ctx);
-	if (bad_blocks_file)
-		read_bad_blocks_file(ctx, bad_blocks_file, replace_bad_blocks);
-	else if (cflag)
-		read_bad_blocks_file(ctx, 0, !keep_bad_blocks); /* Test disk */
 	if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
 		bb_error_msg_and_die(0);
 #ifdef ENABLE_SWAPFS
diff --git a/e2fsprogs/e2fsck.h b/e2fsprogs/e2fsck.h
index 0957f20a8..43080d24e 100644
--- a/e2fsprogs/e2fsck.h
+++ b/e2fsprogs/e2fsck.h
@@ -518,7 +518,6 @@ struct e2fsck_struct {
 	ext2fs_inode_bitmap inode_used_map; /* Inodes which are in use */
 	ext2fs_inode_bitmap inode_bad_map; /* Inodes which are bad somehow */
 	ext2fs_inode_bitmap inode_dir_map; /* Inodes which are directories */
-	ext2fs_inode_bitmap inode_bb_map; /* Inodes which are in bad blocks */
 	ext2fs_inode_bitmap inode_imagic_map; /* AFS inodes */
 	ext2fs_inode_bitmap inode_reg_map; /* Inodes which are regular files*/
 
@@ -612,7 +611,6 @@ struct e2fsck_struct {
 	int fs_fast_symlinks_count;
 	int fs_fifo_count;
 	int fs_total_count;
-	int fs_badblocks_count;
 	int fs_sockets_count;
 	int fs_ind_count;
 	int fs_dind_count;