[PATCH 00/19] e2fsprogs patchbomb 7/14, part 2.1

[PATCH 00/19] e2fsprogs patchbomb 7/14, part 2.1

[Darrick J. Wong]

Hi all,

Here are revisions to the patchset that I sent last Friday, fixing
e2fsck failures with filesystems containing the metadata checksumming
features.  Like last week, e2fuzz helped me to find the failures.

The first patch fixes a Coverity complaint against e2fuzz.  Patch 2
ensures that e2fsck never clears a block in block_found_map if it's in
marked in the block_metadata_map.  Patch 3 suggests putting lost
inodes in the root directory if it's impossible to recreate the
lost+found directory.  Patch 4 fixes dumpe2fs to complain about
checksum errors without requiring command line options.

Patches 5-8 tear down the foundations of the strict_csum vs
no_strict_csum patchset in favor of checking any object that fails
checksum verification for some basic sanity.  If it finds sanity it'll
try to recover it, otherwise it'll declare it to be garbage and simply
zap it.  Users will not have to decide on a config option.

Patches 9-12 also fix errors when dealing with FS objects that fail
checksum tests.  Library flag handling, error reporting, and inode
re-checking (for regular mode) all receive some treatment.

Patches 13-19 are simple regression tests to check that e2fsck can
deal with various kinds of checksum failures -- errors that trigger
other corrective action; errors that don't make the FS inconsistent
(and would have gone unnoticed without metadata_csu); the checksum
itself being wrong; and total block destruction.

I've tested these e2fsprogs changes against the -next branch as of
7/29.  As I stated in the part 1 introduction, I use several VMs, each
with 32M-1G ramdisks to test with; the test process is "misc/e2fuzz.sh
-B <fuzz> -s <size>", where fuzz is anything from 2 bytes to "0.1%"
of metadata bytes.  I've been running five VMs for the past two days,
and the only new failures it found resulted in the patches 2-3.

Comments and questions are, as always, welcome.

--D

[PATCH 01/19] e2fuzz: fix fs handle cleanup when closing fails

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Fix the handling of 'fs' when closing the FS fails so that we don't
dereference a NULL pointer.  Adapt to use ext2fs_close_free while
we're at it.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Fixes-Coverity-Bug: 1229241
---
 misc/e2fuzz.c |    9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/misc/e2fuzz.c b/misc/e2fuzz.c
index 644c9c5..8c989dd 100644
--- a/misc/e2fuzz.c
+++ b/misc/e2fuzz.c
@@ -279,23 +279,20 @@ int process_fs(const char *fsname)
 	close(fd);
 
 	/* Clean up */
-	ret = ext2fs_close(fs);
+	ret = ext2fs_close_free(&fs);
 	if (ret) {
-		fs = NULL;
 		fprintf(stderr, "%s: error while closing filesystem\n",
 			fsname);
-		goto fail2;
+		return 1;
 	}
 
 	return 0;
 fail3:
 	close(fd);
-fail2:
 	if (corrupt_map != fs->block_map)
 		ext2fs_free_block_bitmap(corrupt_map);
 fail:
-	if (fs)
-		ext2fs_close(fs);
+	ext2fs_close_free(&fs);
 	return 1;
 }
 

[PATCH 02/19] e2fsck: never free critical metadata blocks in the block found map

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Don't allow critical metadata blocks to be marked free in the block
found map.  This can theoretically happen on an FS where a first
inode's ETB/indirect map block is in the inode table, the first inode
is itself unclonable (and thus gets deleted) and there are enough
crosslinked files before and after the first inode to use up all the
free blocks during pass 1b.

(I do actually have a test FS image but it's 256M and it proved very
difficult to craft a bite-sized test case that actually hit this bug.)

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 e2fsck/pass1.c |    7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index 26fe60c..e7a6acd 100644
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -3356,6 +3356,13 @@ static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse)
 {
 	e2fsck_t ctx = (e2fsck_t) fs->priv_data;
 
+	/* Never free a critical metadata block */
+	if (ctx->block_found_map &&
+	    ctx->block_metadata_map &&
+	    inuse < 0 &&
+	    ext2fs_test_block_bitmap2(ctx->block_metadata_map, blk))
+		return;
+
 	if (ctx->block_found_map) {
 		if (inuse > 0)
 			ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);

[PATCH 03/19] e2fsck: use root dir for lost+found when really desperate

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

If we're totally unable to allocate a lost+found directory, ask the
user if he would like to dump orphaned files in the root directory.
Hopefully this enables the user to delete enough files so that a
subsequent run of e2fsck will make more progress.  Better to cram lost
files in the rootdir than the current behavior, which is to fail at
linking them in, thereby leaving them as lost files.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 e2fsck/pass3.c                    |   12 ++++++++++++
 e2fsck/problem.c                  |    5 +++++
 e2fsck/problem.h                  |    3 +++
 tests/f_nospc_create_lnf/expect.1 |   28 ++++++++++++++++++++++++++++
 tests/f_nospc_create_lnf/expect.2 |   25 +++++++++++++++++++++++++
 tests/f_nospc_create_lnf/image.gz |  Bin
 tests/f_nospc_create_lnf/name     |    1 +
 7 files changed, 74 insertions(+)
 create mode 100644 tests/f_nospc_create_lnf/expect.1
 create mode 100644 tests/f_nospc_create_lnf/expect.2
 create mode 100644 tests/f_nospc_create_lnf/image.gz
 create mode 100644 tests/f_nospc_create_lnf/name

diff --git a/e2fsck/pass3.c b/e2fsck/pass3.c
index 31131ab..e6142ad 100644
--- a/e2fsck/pass3.c
+++ b/e2fsck/pass3.c
@@ -450,6 +450,12 @@ unlink:
 		goto skip_new_block;
 	}
 	retval = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk);
+	if (retval == EXT2_ET_BLOCK_ALLOC_FAIL &&
+	    fix_problem(ctx, PR_3_LPF_NO_SPACE, &pctx)) {
+		printf("Delete some files and re-run e2fsck.\n\n");
+		ctx->lost_and_found = EXT2_ROOT_INO;
+		return 0;
+	}
 	if (retval) {
 		pctx.errcode = retval;
 		fix_problem(ctx, PR_3_ERR_LPF_NEW_BLOCK, &pctx);
@@ -464,6 +470,12 @@ skip_new_block:
 	 */
 	retval = ext2fs_new_inode(fs, EXT2_ROOT_INO, 040700,
 				  ctx->inode_used_map, &ino);
+	if (retval == EXT2_ET_INODE_ALLOC_FAIL &&
+	    fix_problem(ctx, PR_3_LPF_NO_SPACE, &pctx)) {
+		printf("Delete some files and re-run e2fsck.\n\n");
+		ctx->lost_and_found = EXT2_ROOT_INO;
+		return 0;
+	}
 	if (retval) {
 		pctx.errcode = retval;
 		fix_problem(ctx, PR_3_ERR_LPF_NEW_INODE, &pctx);
diff --git a/e2fsck/problem.c b/e2fsck/problem.c
index 2c9386f..e68433b 100644
--- a/e2fsck/problem.c
+++ b/e2fsck/problem.c
@@ -1630,6 +1630,11 @@ static struct e2fsck_problem problem_table[] = {
 	  N_("/@l has inline data\n"),
 	  PROMPT_CLEAR, 0 },
 
+	/* Cannot allocate /lost+found. */
+	{ PR_3_LPF_NO_SPACE,
+	  N_("Cannot allocate space for /@l.\nPlace lost files in root directory instead"),
+	  PROMPT_NULL, 0 },
+
 	/* Pass 3A Directory Optimization	*/
 
 	/* Pass 3A: Optimizing directories */
diff --git a/e2fsck/problem.h b/e2fsck/problem.h
index 80ef4a2..496e873 100644
--- a/e2fsck/problem.h
+++ b/e2fsck/problem.h
@@ -973,6 +973,9 @@ struct problem_context {
 /* Lost+found has inline data */
 #define PR_3_LPF_INLINE_DATA		0x030018
 
+/* Cannot allocate lost+found */
+#define PR_3_LPF_NO_SPACE		0x030019
+
 /*
  * Pass 3a --- rehashing diretories
  */
diff --git a/tests/f_nospc_create_lnf/expect.1 b/tests/f_nospc_create_lnf/expect.1
new file mode 100644
index 0000000..fc20628
--- /dev/null
+++ b/tests/f_nospc_create_lnf/expect.1
@@ -0,0 +1,28 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+/lost+found not found.  Create? yes
+
+Cannot allocate space for /lost+found.
+Place lost files in root directory instead? yes
+
+Delete some files and re-run e2fsck.
+
+Pass 3A: Optimizing directories
+Pass 4: Checking reference counts
+Unattached inode 125
+Connect to /lost+found? yes
+
+Inode 125 ref count is 2, should be 1.  Fix? yes
+
+Pass 5: Checking group summary information
+Free blocks count wrong for group #0 (496, counted=495).
+Fix? yes
+
+Free blocks count wrong (496, counted=495).
+Fix? yes
+
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 128/128 files (0.0% non-contiguous), 17/512 blocks
+Exit status is 1
diff --git a/tests/f_nospc_create_lnf/expect.2 b/tests/f_nospc_create_lnf/expect.2
new file mode 100644
index 0000000..5a44649
--- /dev/null
+++ b/tests/f_nospc_create_lnf/expect.2
@@ -0,0 +1,25 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+/lost+found not found.  Create? yes
+
+Cannot allocate space for /lost+found.
+Place lost files in root directory instead? yes
+
+Delete some files and re-run e2fsck.
+
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+Block bitmap differences:  -9
+Fix? yes
+
+Free blocks count wrong for group #0 (494, counted=495).
+Fix? yes
+
+Free blocks count wrong (494, counted=495).
+Fix? yes
+
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 128/128 files (0.0% non-contiguous), 17/512 blocks
+Exit status is 1
diff --git a/tests/f_nospc_create_lnf/image.gz b/tests/f_nospc_create_lnf/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..dc71b61a0028603aac348c61b015fd3c0b25273a
GIT binary patch
literal 4201
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
bI<V-#q63Q#yqW_*K`wuwV)xT%Yia)j*ECk;

literal 0
HcmV?d00001

diff --git a/tests/f_nospc_create_lnf/name b/tests/f_nospc_create_lnf/name
new file mode 100644
index 0000000..df6c932
--- /dev/null
+++ b/tests/f_nospc_create_lnf/name
@@ -0,0 +1 @@
+no space to create lost+found

[PATCH 04/19] dumpe2fs: complain when checksum verification fails

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Warn the user to run e2fsck if the superblock or bitmaps fails
checksum verification.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 misc/dumpe2fs.c |   17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/misc/dumpe2fs.c b/misc/dumpe2fs.c
index 0b84ece..7cbb99b 100644
--- a/misc/dumpe2fs.c
+++ b/misc/dumpe2fs.c
@@ -620,7 +620,7 @@ int main (int argc, char ** argv)
 		flags |= EXT2_FLAG_FORCE;
 	if (image_dump)
 		flags |= EXT2_FLAG_IMAGE_FILE;
-
+try_open_again:
 	if (use_superblock && !use_blocksize) {
 		for (use_blocksize = EXT2_MIN_BLOCK_SIZE;
 		     use_blocksize <= EXT2_MAX_BLOCK_SIZE;
@@ -635,6 +635,13 @@ int main (int argc, char ** argv)
 	} else
 		retval = ext2fs_open (device_name, flags, use_superblock,
 				      use_blocksize, unix_io_manager, &fs);
+	if (retval && !(flags & EXT2_FLAG_IGNORE_CSUM_ERRORS)) {
+		flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
+		goto try_open_again;
+	}
+	if (!retval && (fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS))
+		printf("%s", _("\n*** Checksum errors detected in filesystem!  Run e2fsck now!\n\n"));
+	flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
 	if (retval) {
 		com_err (program_name, retval, _("while trying to open %s"),
 			 device_name);
@@ -663,7 +670,15 @@ int main (int argc, char ** argv)
 			ext2fs_close_free(&fs);
 			exit (0);
 		}
+		fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
+try_bitmaps_again:
 		retval = ext2fs_read_bitmaps (fs);
+		if (retval && !(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS)) {
+			fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
+			goto try_bitmaps_again;
+		}
+		if (!retval && (fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS))
+			printf("%s", _("\n*** Checksum errors detected in bitmaps!  Run e2fsck now!\n\n"));
 		list_desc (fs);
 		if (retval) {
 			printf(_("\n%s: %s: error reading bitmaps: %s\n"),

[PATCH 05/19] libext2fs: check EA block headers when reading in the block

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

When reading an EA block in from disk, do a quick sanity check of the
block header, and return an error if we think we have garbage.  Teach
e2fsck to ignore the new error code in favor of doing its own
checking, and remove the strict_csums bits while we're at it.

(Also document some assumptions in the new ext_attr code.)

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 e2fsck/pass1.c        |   18 ++++++++++++------
 e2fsck/problem.c      |    5 -----
 e2fsck/problem.h      |    3 ---
 lib/ext2fs/ext_attr.c |   25 +++++++++++++++++++------
 4 files changed, 31 insertions(+), 20 deletions(-)

diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index e7a6acd..02683d3 100644
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -1748,12 +1748,16 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
 	pctx->blk = blk;
 	pctx->errcode = ext2fs_read_ext_attr3(fs, blk, block_buf, pctx->ino);
 	if (pctx->errcode == EXT2_ET_EXT_ATTR_CSUM_INVALID) {
-		if (fix_problem(ctx, PR_1_EA_BLOCK_CSUM_INVALID, pctx))
-			goto clear_extattr;
+		pctx->errcode = 0;
 		failed_csum = 1;
-	}
-	if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx))
+	} else if (pctx->errcode == EXT2_ET_BAD_EA_HEADER)
+		pctx->errcode = 0;
+
+	if (pctx->errcode &&
+	    fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) {
+		pctx->errcode = 0;
 		goto clear_extattr;
+	}
 	header = (struct ext2_ext_attr_header *) block_buf;
 	pctx->blk = ext2fs_file_acl_block(fs, inode);
 	if (((ctx->ext_attr_ver == 1) &&
@@ -1769,6 +1773,9 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
 			goto clear_extattr;
 	}
 
+	if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx))
+		goto clear_extattr;
+
 	region = region_create(0, fs->blocksize);
 	if (!region) {
 		fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx);
@@ -2438,8 +2445,7 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
 		}
 	}
 
-	if (ext2fs_file_acl_block(fs, inode) &&
-	    check_ext_attr(ctx, pctx, block_buf)) {
+	if (check_ext_attr(ctx, pctx, block_buf)) {
 		if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
 			goto out;
 		pb.num_blocks++;
diff --git a/e2fsck/problem.c b/e2fsck/problem.c
index e68433b..dc094ed 100644
--- a/e2fsck/problem.c
+++ b/e2fsck/problem.c
@@ -992,11 +992,6 @@ static struct e2fsck_problem problem_table[] = {
 	     "extent\n\t(logical @b %c, @n physical @b %b, len %N)\n"),
 	  PROMPT_FIX, 0 },
 
-	/* Inode extended attribute block checksum does not match block. */
-	{ PR_1_EA_BLOCK_CSUM_INVALID,
-	  N_("@i %i @a @b %b checksum does not match block.  "),
-	  PROMPT_CLEAR, 0 },
-
 	/*
 	 * Inode extended attribute block passes checks, but checksum does not
 	 * match block.
diff --git a/e2fsck/problem.h b/e2fsck/problem.h
index 496e873..af7a73e 100644
--- a/e2fsck/problem.h
+++ b/e2fsck/problem.h
@@ -583,9 +583,6 @@ struct problem_context {
 /* extent block passes checks, but checksum does not match extent block */
 #define PR_1_EXTENT_ONLY_CSUM_INVALID  0x01006A
 
-/* ea block checksum invalid */
-#define PR_1_EA_BLOCK_CSUM_INVALID     0x01006B
-
 /* ea block passes checks, but checksum invalid */
 #define PR_1_EA_BLOCK_ONLY_CSUM_INVALID        0x01006C
 
diff --git a/lib/ext2fs/ext_attr.c b/lib/ext2fs/ext_attr.c
index 308d21d..f3fba96 100644
--- a/lib/ext2fs/ext_attr.c
+++ b/lib/ext2fs/ext_attr.c
@@ -58,12 +58,23 @@ __u32 ext2fs_ext_attr_hash_entry(struct ext2_ext_attr_entry *entry, void *data)
 	return hash;
 }
 
+static errcode_t check_ext_attr_header(struct ext2_ext_attr_header *header)
+{
+	if ((header->h_magic != EXT2_EXT_ATTR_MAGIC_v1 &&
+	     header->h_magic != EXT2_EXT_ATTR_MAGIC) ||
+	    header->h_blocks != 1)
+		return EXT2_ET_BAD_EA_HEADER;
+
+	return 0;
+}
+
 #undef NAME_HASH_SHIFT
 #undef VALUE_HASH_SHIFT
 
 errcode_t ext2fs_read_ext_attr3(ext2_filsys fs, blk64_t block, void *buf,
 				ext2_ino_t inum)
 {
+	int		csum_failed = 0;
 	errcode_t	retval;
 
 	retval = io_channel_read_blk64(fs->io, block, 1, buf);
@@ -72,12 +83,16 @@ errcode_t ext2fs_read_ext_attr3(ext2_filsys fs, blk64_t block, void *buf,
 
 	if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
 	    !ext2fs_ext_attr_block_csum_verify(fs, inum, block, buf))
-		retval = EXT2_ET_EXT_ATTR_CSUM_INVALID;
+		csum_failed = 1;
 
 #ifdef WORDS_BIGENDIAN
 	ext2fs_swap_ext_attr(buf, buf, fs->blocksize, 1);
 #endif
 
+	retval = check_ext_attr_header(buf);
+	if (retval == 0 && csum_failed)
+		retval = EXT2_ET_EXT_ATTR_CSUM_INVALID;
+
 	return retval;
 }
 
@@ -321,6 +336,7 @@ errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino,
 	if (err)
 		goto out2;
 
+	/* We only know how to deal with v2 EA blocks */
 	header = (struct ext2_ext_attr_header *) block_buf;
 	if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
 		err = EXT2_ET_BAD_EA_HEADER;
@@ -380,6 +396,7 @@ static errcode_t prep_ea_block_for_write(ext2_filsys fs, ext2_ino_t ino,
 		if (err)
 			goto out2;
 
+		/* We only know how to deal with v2 EA blocks */
 		header = (struct ext2_ext_attr_header *) block_buf;
 		if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
 			err = EXT2_ET_BAD_EA_HEADER;
@@ -763,17 +780,13 @@ read_ea_block:
 		if (err)
 			goto out3;
 
+		/* We only know how to deal with v2 EA blocks */
 		header = (struct ext2_ext_attr_header *) block_buf;
 		if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
 			err = EXT2_ET_BAD_EA_HEADER;
 			goto out3;
 		}
 
-		if (header->h_blocks != 1) {
-			err = EXT2_ET_BAD_EA_HEADER;
-			goto out3;
-		}

[PATCH 06/19] e2fsck: try to salvage extent blocks with bad checksums

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Remove the code that would zap an extent block immediately if the
checksum failed (i.e. strict_csums).  Instead, we'll only do that if
the extent block header shows obvious structural problems; if the
header checks out, then we'll iterate the block and see if we can
recover some extents.

Requires a minor modification to ext2fs_extent_get such that the
extent block will be returned in the buffer even if the return code
indicates a checksum error.  This brings its behavior in line with
the rest of libext2fs.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 e2fsck/pass1.c      |   45 +++++++++++++++++++--------------------------
 e2fsck/problem.c    |    6 ------
 e2fsck/problem.h    |    3 ---
 lib/ext2fs/extent.c |   10 ++++++----
 4 files changed, 25 insertions(+), 39 deletions(-)

diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index 02683d3..283b0b1 100644
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -2001,7 +2001,10 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx,
 	int			is_dir, is_leaf;
 	problem_t		problem;
 	struct ext2_extent_info	info;
-	int			failed_csum;
+	int			failed_csum = 0;
+
+	if (pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID)
+		failed_csum = 1;
 
 	pctx->errcode = ext2fs_extent_get_info(ehandle, &info);
 	if (pctx->errcode)
@@ -2012,7 +2015,6 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx,
 	while ((pctx->errcode == 0 ||
 		pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) &&
 	       info.num_entries-- > 0) {
-		failed_csum = 0;
 		is_leaf = extent.e_flags & EXT2_EXTENT_FLAGS_LEAF;
 		is_dir = LINUX_S_ISDIR(pctx->inode->i_mode);
 		last_lblk = extent.e_lblk + extent.e_len - 1;
@@ -2023,15 +2025,6 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx,
 		pctx->num = extent.e_len;
 		pctx->blkcount = extent.e_lblk + extent.e_len;
 
-		/* Ask to clear a corrupt extent block */
-		if (try_repairs &&
-		    pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) {
-			problem = PR_1_EXTENT_CSUM_INVALID;
-			if (fix_problem(ctx, problem, pctx))
-				goto fix_problem_now;
-			failed_csum = 1;
-		}
-
 		if (extent.e_pblk == 0 ||
 		    extent.e_pblk < ctx->fs->super->s_first_data_block ||
 		    extent.e_pblk >= ext2fs_blocks_count(ctx->fs->super))
@@ -2069,16 +2062,6 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx,
 			failed_csum = 0;
 		}
 
-		/* Failed csum but passes checks?  Ask to fix checksum. */
-		if (try_repairs && failed_csum && problem == 0 &&
-		    fix_problem(ctx, PR_1_EXTENT_ONLY_CSUM_INVALID, pctx)) {
-			pb->inode_modified = 1;
-			pctx->errcode = ext2fs_extent_replace(ehandle,
-							0, &extent);
-			if (pctx->errcode)
-				return;
-		}
-
 		if (try_repairs && problem) {
 report_problem:
 			if (fix_problem(ctx, problem, pctx)) {
@@ -2124,6 +2107,7 @@ fix_problem_now:
 					pctx->errcode = 0;
 					break;
 				}
+				failed_csum = 0;
 				continue;
 			}
 			goto next;
@@ -2152,15 +2136,13 @@ fix_problem_now:
 			}
 			pctx->errcode = ext2fs_extent_get(ehandle,
 						  EXT2_EXTENT_DOWN, &extent);
-			if (pctx->errcode) {
+			if (pctx->errcode &&
+			    pctx->errcode != EXT2_ET_EXTENT_CSUM_INVALID) {
 				pctx->str = "EXT2_EXTENT_DOWN";
 				problem = PR_1_EXTENT_HEADER_INVALID;
 				if (!next_try_repairs)
 					return;
-				if (pctx->errcode ==
-					EXT2_ET_EXTENT_HEADER_BAD ||
-				    pctx->errcode ==
-					EXT2_ET_EXTENT_CSUM_INVALID)
+				if (pctx->errcode == EXT2_ET_EXTENT_HEADER_BAD)
 					goto report_problem;
 				return;
 			}
@@ -2256,6 +2238,7 @@ fix_problem_now:
 				if (pctx->errcode)
 					goto failed_add_dir_block;
 				last_lblk = extent.e_lblk + extent.e_len - 1;
+				failed_csum = 0;
 			}
 		}
 alloc_later:
@@ -2323,6 +2306,16 @@ alloc_later:
 						  EXT2_EXTENT_NEXT_SIB,
 						  &extent);
 	}
+
+	/* Failed csum but passes checks?  Ask to fix checksum. */
+	if (failed_csum &&
+	    fix_problem(ctx, PR_1_EXTENT_ONLY_CSUM_INVALID, pctx)) {
+		pb->inode_modified = 1;
+		pctx->errcode = ext2fs_extent_replace(ehandle, 0, &extent);
+		if (pctx->errcode)
+			return;
+	}
+
 	if (pctx->errcode == EXT2_ET_EXTENT_NO_NEXT)
 		pctx->errcode = 0;
 }
diff --git a/e2fsck/problem.c b/e2fsck/problem.c
index dc094ed..1b6bdb0 100644
--- a/e2fsck/problem.c
+++ b/e2fsck/problem.c
@@ -977,12 +977,6 @@ static struct e2fsck_problem problem_table[] = {
 	  N_("@i %i passes checks, but checksum does not match @i.  "),
 	  PROMPT_FIX, PR_PREEN_OK },
 
-	/* Inode extent block checksum does not match extent */
-	{ PR_1_EXTENT_CSUM_INVALID,
-	  N_("@i %i extent block checksum does not match extent\n\t(logical @b "
-	     "%c, @n physical @b %b, len %N)\n"),
-	  PROMPT_CLEAR, 0 },
-
 	/*
 	 * Inode extent block passes checks, but checksum does not match
 	 * extent
diff --git a/e2fsck/problem.h b/e2fsck/problem.h
index af7a73e..89db5f3 100644
--- a/e2fsck/problem.h
+++ b/e2fsck/problem.h
@@ -577,9 +577,6 @@ struct problem_context {
 /* inode passes checks, but checksum does not match inode */
 #define PR_1_INODE_ONLY_CSUM_INVALID   0x010068
 
-/* extent block checksum does not match extent block */
-#define PR_1_EXTENT_CSUM_INVALID       0x010069
-
 /* extent block passes checks, but checksum does not match extent block */
 #define PR_1_EXTENT_ONLY_CSUM_INVALID  0x01006A
 
diff --git a/lib/ext2fs/extent.c b/lib/ext2fs/extent.c
index 30673b5..32bc214 100644
--- a/lib/ext2fs/extent.c
+++ b/lib/ext2fs/extent.c
@@ -283,6 +283,7 @@ errcode_t ext2fs_extent_get(ext2_extent_handle_t handle,
 	blk64_t				blk;
 	blk64_t				end_blk;
 	int				orig_op, op;
+	int				failed_csum = 0;
 
 	EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
 
@@ -457,10 +458,8 @@ retry:
 
 		if (!(handle->fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
 		    !ext2fs_extent_block_csum_verify(handle->fs, handle->ino,
-						     eh)) {
-			handle->level--;
-			return EXT2_ET_EXTENT_CSUM_INVALID;
-		}
+						     eh))
+			failed_csum = 1;
 
 		newpath->left = newpath->entries =
 			ext2fs_le16_to_cpu(eh->eh_entries);
@@ -540,6 +539,9 @@ retry:
 	     (path->left != 0)))
 		goto retry;
 
+	if (failed_csum)
+		return EXT2_ET_EXTENT_CSUM_INVALID;
+
 	return 0;
 }
 

[PATCH 07/19] e2fsck: try to salvage corrupt directory entry blocks

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Remove the code that would prompt the user to zap directory entry
blocks with bad checksums (i.e. strict_csums).  Instead, we'll run the
directory entries through the usual repair routines in an attempt to
save whatever we can.  At the same time, refactor the code that
schedules the repair of missing dirblock checksum entries.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 e2fsck/pass2.c   |   34 +++++++++-------------------------
 e2fsck/problem.c |    5 -----
 e2fsck/problem.h |    3 ---
 3 files changed, 9 insertions(+), 33 deletions(-)

diff --git a/e2fsck/pass2.c b/e2fsck/pass2.c
index 69ebab6..ae7768f 100644
--- a/e2fsck/pass2.c
+++ b/e2fsck/pass2.c
@@ -944,32 +944,16 @@ static int check_dir_block(ext2_filsys fs,
 out_htree:
 #endif /* ENABLE_HTREE */
 
-	/* Verify checksum. */
-	if (is_leaf && de_csum_size && !inline_data_size) {
-		/* No space for csum?  Rebuild dirs in pass 3A. */
-		if (!ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf)) {
-			de_csum_size = 0;
-			if (e2fsck_dir_will_be_rehashed(ctx, ino))
-				goto skip_checksum;
-			if (!fix_problem(cd->ctx, PR_2_LEAF_NODE_MISSING_CSUM,
-					 &cd->pctx))
-				goto skip_checksum;
-			e2fsck_rehash_dir_later(ctx, ino);
+	/* Leaf node with no space for csum?  Rebuild dirs in pass 3A. */
+	if (is_leaf && !inline_data_size && failed_csum &&
+	    !ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf)) {
+		de_csum_size = 0;
+		if (e2fsck_dir_will_be_rehashed(ctx, ino) ||
+		    !fix_problem(cd->ctx, PR_2_LEAF_NODE_MISSING_CSUM,
+				 &cd->pctx))
 			goto skip_checksum;
-		}
-		if (failed_csum) {
-			char *buf2;
-			if (!fix_problem(cd->ctx, PR_2_LEAF_NODE_CSUM_INVALID,
-					 &cd->pctx))
-				goto skip_checksum;
-			ext2fs_new_dir_block(fs,
-					     db->blockcnt == 0 ? ino : 0,
-					     EXT2_ROOT_INO, &buf2);
-			memcpy(buf, buf2, fs->blocksize);
-			ext2fs_free_mem(&buf2);
-			dir_modified++;
-			failed_csum = 0;
-		}
+		e2fsck_rehash_dir_later(ctx, ino);
+		goto skip_checksum;
 	}
 	/* htree nodes don't use fake dirents to store checksums */
 	if (!is_leaf)
diff --git a/e2fsck/problem.c b/e2fsck/problem.c
index 1b6bdb0..80ca3a0 100644
--- a/e2fsck/problem.c
+++ b/e2fsck/problem.c
@@ -1477,11 +1477,6 @@ static struct e2fsck_problem problem_table[] = {
 	  N_("@p @h %d: internal node fails checksum.\n"),
 	  PROMPT_CLEAR_HTREE, PR_PREEN_OK },
 
-	/* leaf node fails checksum */
-	{ PR_2_LEAF_NODE_CSUM_INVALID,
-	  N_("@d @i %i, %B, offset %N: @d fails checksum.\n"),
-	  PROMPT_SALVAGE, PR_PREEN_OK },
-
 	/* leaf node has no checksum */
 	{ PR_2_LEAF_NODE_MISSING_CSUM,
 	  N_("@d @i %i, %B, offset %N: @d has no checksum.\n"),
diff --git a/e2fsck/problem.h b/e2fsck/problem.h
index 89db5f3..4813fc6 100644
--- a/e2fsck/problem.h
+++ b/e2fsck/problem.h
@@ -879,9 +879,6 @@ struct problem_context {
 /* htree node fails checksum */
 #define PR_2_HTREE_NODE_CSUM_INVALID	0x02004A
 
-/* dir leaf node fails checksum */
-#define PR_2_LEAF_NODE_CSUM_INVALID	0x02004B

[PATCH 08/19] e2fsck: offer to clear inode table blocks that are insane

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Add a new behavior flag to the inode scan functions; when specified,
this flag will do some simple sanity checking of entire inode table
blocks.  If all the checksums are ok, we can skip checksum
verification on individual inodes later on.  If more than half of the
inodes look "insane" (bad extent tree root or checksum failure) then
ext2fs_get_next_inode_full() can return a special status code
indicating that what's in the buffer is probably garbage.

When e2fsck' inode scan encounters the 'inode is garbage' return code
it'll offer to zap the inode straightaway instead of trying to recover
anything.  This replaces the previous behavior of asking to zap
anything with a checksum error (strict_csum).

Signed-off-by: Darrick J. Wong <darrick.wong@orale.com>
---
 e2fsck/pass1.c            |   18 ++++--
 e2fsck/problem.c          |    8 +--
 e2fsck/problem.h          |    4 +
 lib/ext2fs/ext2_err.et.in |    3 +
 lib/ext2fs/ext2fs.h       |    1 
 lib/ext2fs/inode.c        |  137 ++++++++++++++++++++++++++++++++++++++++++++-
 6 files changed, 154 insertions(+), 17 deletions(-)

diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index 283b0b1..a7792c4 100644
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -809,7 +809,8 @@ void e2fsck_pass1(e2fsck_t ctx)
 		ctx->flags |= E2F_FLAG_ABORT;
 		goto endit;
 	}
-	ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0);
+	ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE |
+				      EXT2_SF_WARN_GARBAGE_INODES, 0);
 	ctx->stashed_inode = inode;
 	scan_struct.ctx = ctx;
 	scan_struct.block_buf = block_buf;
@@ -851,7 +852,8 @@ void e2fsck_pass1(e2fsck_t ctx)
 			continue;
 		}
 		if (pctx.errcode &&
-		    pctx.errcode != EXT2_ET_INODE_CSUM_INVALID) {
+		    pctx.errcode != EXT2_ET_INODE_CSUM_INVALID &&
+		    pctx.errcode != EXT2_ET_INODE_IS_GARBAGE) {
 			fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
 			ctx->flags |= E2F_FLAG_ABORT;
 			goto endit;
@@ -862,12 +864,14 @@ void e2fsck_pass1(e2fsck_t ctx)
 		pctx.inode = inode;
 		ctx->stashed_ino = ino;
 
-		/* Clear corrupt inode? */
-		if (pctx.errcode == EXT2_ET_INODE_CSUM_INVALID) {
-			if (fix_problem(ctx, PR_1_INODE_CSUM_INVALID, &pctx))
-				goto clear_inode;
-			failed_csum = 1;
+		/* Clear trashed inode? */
+		if (pctx.errcode == EXT2_ET_INODE_IS_GARBAGE &&
+		    inode->i_links_count > 0 &&
+		    fix_problem(ctx, PR_1_INODE_IS_GARBAGE, &pctx)) {
+			pctx.errcode = 0;
+			e2fsck_clear_inode(ctx, ino, inode, 0, "pass1");
 		}
+		failed_csum = pctx.errcode != 0;
 
 		if (inode->i_links_count) {
 			pctx.errcode = ext2fs_icount_store(ctx->inode_link_info,
diff --git a/e2fsck/problem.c b/e2fsck/problem.c
index 80ca3a0..452137a 100644
--- a/e2fsck/problem.c
+++ b/e2fsck/problem.c
@@ -967,10 +967,10 @@ static struct e2fsck_problem problem_table[] = {
 	  N_("@i %i has zero length extent\n\t(@n logical @b %c, physical @b %b)\n"),
 	  PROMPT_CLEAR, 0 },
 
-	/* inode checksum does not match inode */
-	{ PR_1_INODE_CSUM_INVALID,
-	  N_("@i %i checksum does not match @i.  "),
-	  PROMPT_CLEAR, PR_PREEN_OK },
+	/* inode seems to contain garbage */
+	{ PR_1_INODE_IS_GARBAGE,
+	  N_("@i %i seems to contain garbage.  "),
+	  PROMPT_CLEAR, 0 },
 
 	/* inode passes checks, but checksum does not match inode */
 	{ PR_1_INODE_ONLY_CSUM_INVALID,
diff --git a/e2fsck/problem.h b/e2fsck/problem.h
index 4813fc6..72cfc4d 100644
--- a/e2fsck/problem.h
+++ b/e2fsck/problem.h
@@ -571,8 +571,8 @@ struct problem_context {
 /* Extent has zero length */
 #define PR_1_EXTENT_LENGTH_ZERO		0x010066
 
-/* inode checksum does not match inode */
-#define PR_1_INODE_CSUM_INVALID                0x010067
+/* inode seems to contain garbage */
+#define PR_1_INODE_IS_GARBAGE		0x010067
 
 /* inode passes checks, but checksum does not match inode */
 #define PR_1_INODE_ONLY_CSUM_INVALID   0x010068
diff --git a/lib/ext2fs/ext2_err.et.in b/lib/ext2fs/ext2_err.et.in
index 51c88d0..2194a18 100644
--- a/lib/ext2fs/ext2_err.et.in
+++ b/lib/ext2fs/ext2_err.et.in
@@ -515,4 +515,7 @@ ec	EXT2_ET_INLINE_DATA_NO_SPACE,
 ec	EXT2_ET_MAGIC_EA_HANDLE,
 	"Wrong magic number for extended attribute structure"
 
+ec	EXT2_ET_INODE_IS_GARBAGE,
+	"Inode seems to contain garbage"
+
 	end
diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h
index 7812956..b4a9f84 100644
--- a/lib/ext2fs/ext2fs.h
+++ b/lib/ext2fs/ext2fs.h
@@ -462,6 +462,7 @@ typedef struct ext2_struct_inode_scan *ext2_inode_scan;
 #define EXT2_SF_BAD_EXTRA_BYTES	0x0004
 #define EXT2_SF_SKIP_MISSING_ITABLE	0x0008
 #define EXT2_SF_DO_LAZY		0x0010
+#define EXT2_SF_WARN_GARBAGE_INODES	0x0020
 
 /*
  * ext2fs_check_if_mounted flags
diff --git a/lib/ext2fs/inode.c b/lib/ext2fs/inode.c
index 0cea9f0..08024cb 100644
--- a/lib/ext2fs/inode.c
+++ b/lib/ext2fs/inode.c
@@ -30,6 +30,10 @@
 #include "ext2fsP.h"
 #include "e2image.h"
 
+#define IBLOCK_STATUS_CSUMS_OK	1
+#define IBLOCK_STATUS_INSANE	2
+#define SCAN_BLOCK_STATUS(scan)	((scan)->temp_buffer + (scan)->inode_size)
+
 struct ext2_struct_inode_scan {
 	errcode_t		magic;
 	ext2_filsys		fs;
@@ -193,12 +197,14 @@ errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks,
 		ext2fs_free_mem(&scan);
 		return retval;
 	}
-	retval = ext2fs_get_mem(scan->inode_size, &scan->temp_buffer);
+	retval = ext2fs_get_mem(scan->inode_size + scan->inode_buffer_blocks,
+				&scan->temp_buffer);
 	if (retval) {
 		ext2fs_free_mem(&scan->inode_buffer);
 		ext2fs_free_mem(&scan);
 		return retval;
 	}
+	memset(SCAN_BLOCK_STATUS(scan), 0, scan->inode_buffer_blocks);
 	if (scan->fs->badblocks && scan->fs->badblocks->num)
 		scan->scan_flags |= EXT2_SF_CHK_BADBLOCKS;
 	if (ext2fs_has_group_desc_csum(fs))
@@ -348,6 +354,114 @@ static errcode_t check_for_inode_bad_blocks(ext2_inode_scan scan,
 	return 0;
 }
 
+static int block_map_looks_insane(ext2_filsys fs,
+				  struct ext2_inode_large *inode)
+{
+	unsigned int i, bad;
+
+	/* We're only interested in block mapped files, dirs, and symlinks */
+	if ((inode->i_flags & EXT4_INLINE_DATA_FL) ||
+	    (inode->i_flags & EXT4_EXTENTS_FL))
+		return 0;
+	if (!LINUX_S_ISREG(inode->i_mode) &&
+	    !LINUX_S_ISLNK(inode->i_mode) &&
+	    !LINUX_S_ISDIR(inode->i_mode))
+		return 0;
+	if (LINUX_S_ISLNK(inode->i_mode) &&
+	    EXT2_I_SIZE(inode) <= sizeof(inode->i_block))
+		return 0;
+
+	/* Unused inodes probably aren't insane */
+	if (inode->i_links_count == 0)
+		return 0;
+
+	/* See if more than half the block maps are insane */
+	for (i = 0, bad = 0; i < EXT2_N_BLOCKS; i++)
+		if (inode->i_block[i] != 0 &&
+		    (inode->i_block[i] < fs->super->s_first_data_block ||
+		     inode->i_block[i] >= ext2fs_blocks_count(fs->super)))
+			bad++;
+	return bad > EXT2_N_BLOCKS / 2;
+}
+
+static int extent_head_looks_insane(struct ext2_inode_large *inode)
+{
+	if (!(inode->i_flags & EXT4_EXTENTS_FL) ||
+	    ext2fs_extent_header_verify(inode->i_block,
+					sizeof(inode->i_block)) == 0)
+		return 0;
+	return 1;
+}
+
+/*
+ * Check all the inodes that we just read into the buffer.  Record what we
+ * find here -- currently, we can observe that all checksums are ok; more
+ * than half the inodes are insane; or no conclusions at all.
+ */
+static void check_inode_block_sanity(ext2_inode_scan scan, blk64_t num_blocks)
+{
+	ext2_ino_t	ino, inodes_to_scan;
+	unsigned int	badness, checksum_failures;
+	unsigned int	inodes_in_buf, inodes_per_block;
+	void		*p;
+	struct ext2_inode_large *inode;
+	char		*block_status;
+	unsigned int	blk;
+
+	if (!(scan->scan_flags & EXT2_SF_WARN_GARBAGE_INODES))
+		return;
+
+	inodes_to_scan = scan->inodes_left;
+	inodes_in_buf = num_blocks * scan->fs->blocksize / scan->inode_size;
+	if (inodes_to_scan > inodes_in_buf)
+		inodes_to_scan = inodes_in_buf;
+
+	p = scan->inode_buffer;
+	ino = scan->current_inode + 1;
+	checksum_failures = badness = 0;
+	block_status = SCAN_BLOCK_STATUS(scan);
+	memset(block_status, 0, scan->inode_buffer_blocks);
+	inodes_per_block = EXT2_INODES_PER_BLOCK(scan->fs->super);
+
+	while (inodes_to_scan > 0) {
+		blk = (p - (void *)scan->inode_buffer) / scan->fs->blocksize;
+		inode = p;
+
+		/* Is this inode insane? */
+		if (!ext2fs_inode_csum_verify(scan->fs, ino, inode)) {
+			checksum_failures++;
+			badness++;
+		} else if (extent_head_looks_insane(inode) ||
+			   block_map_looks_insane(scan->fs, inode))
+			badness++;
+
+		/* If more than half are insane, declare the whole block bad */
+		if (badness > inodes_per_block / 2) {
+			unsigned int ino_adj;
+
+			block_status[blk] |= IBLOCK_STATUS_INSANE;
+			ino_adj = inodes_per_block -
+						((ino - 1) % inodes_per_block);
+			if (ino_adj > inodes_to_scan)
+				ino_adj = inodes_to_scan;
+			inodes_to_scan -= ino_adj;
+			p += scan->inode_size * ino_adj;
+			ino += ino_adj;
+			checksum_failures = badness = 0;
+			continue;
+		}
+
+		if ((ino % inodes_per_block) == 0) {
+			if (checksum_failures == 0)
+				block_status[blk] |= IBLOCK_STATUS_CSUMS_OK;
+			checksum_failures = badness = 0;
+		}
+		inodes_to_scan--;
+		p += scan->inode_size;
+		ino++;
+	};
+}
+
 /*
  * This function is called by ext2fs_get_next_inode when it needs to
  * read in more blocks from the current blockgroup's inode table.
@@ -397,12 +511,15 @@ static errcode_t get_next_blocks(ext2_inode_scan scan)
 		if (retval)
 			return EXT2_ET_NEXT_INODE_READ;
 	}
+	check_inode_block_sanity(scan, num_blocks);
+
 	scan->ptr = scan->inode_buffer;
 	scan->bytes_left = num_blocks * scan->fs->blocksize;
 
 	scan->blocks_left -= num_blocks;
 	if (scan->current_block)
 		scan->current_block += num_blocks;
+
 	return 0;
 }
 
@@ -432,10 +549,14 @@ errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino,
 {
 	errcode_t	retval;
 	int		extra_bytes = 0;
-	const int	length = EXT2_INODE_SIZE(scan->fs->super);
+	int		length;
 	struct ext2_inode_large	*iptr = (struct ext2_inode_large *)inode;
+	char		*iblock_status;
+	unsigned int	iblk;
 
 	EXT2_CHECK_MAGIC(scan, EXT2_ET_MAGIC_INODE_SCAN);
+	length = EXT2_INODE_SIZE(scan->fs->super);
+	iblock_status = SCAN_BLOCK_STATUS(scan);
 
 	/*
 	 * Do we need to start reading a new block group?
@@ -503,6 +624,9 @@ errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino,
 	}
 
 	retval = 0;
+	iblk = scan->current_inode % EXT2_INODES_PER_GROUP(scan->fs->super) /
+				EXT2_INODES_PER_BLOCK(scan->fs->super) %
+				scan->inode_buffer_blocks;
 	if (extra_bytes) {
 		memcpy(scan->temp_buffer+extra_bytes, scan->ptr,
 		       scan->inode_size - extra_bytes);
@@ -510,7 +634,8 @@ errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino,
 		scan->bytes_left -= scan->inode_size - extra_bytes;
 
 		/* Verify the inode checksum. */
-		if (!(scan->fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
+		if (!(iblock_status[iblk] & IBLOCK_STATUS_CSUMS_OK) &&
+		    !(scan->fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
 		    !ext2fs_inode_csum_verify(scan->fs, scan->current_inode + 1,
 				(struct ext2_inode_large *)scan->temp_buffer))
 			retval = EXT2_ET_INODE_CSUM_INVALID;
@@ -529,7 +654,8 @@ errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino,
 		scan->scan_flags &= ~EXT2_SF_BAD_EXTRA_BYTES;
 	} else {
 		/* Verify the inode checksum. */
-		if (!(scan->fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
+		if (!(iblock_status[iblk] & IBLOCK_STATUS_CSUMS_OK) &&
+		    !(scan->fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
 		    !ext2fs_inode_csum_verify(scan->fs, scan->current_inode + 1,
 				(struct ext2_inode_large *)scan->ptr))
 			retval = EXT2_ET_INODE_CSUM_INVALID;
@@ -548,6 +674,9 @@ errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino,
 		if (scan->scan_flags & EXT2_SF_BAD_INODE_BLK)
 			retval = EXT2_ET_BAD_BLOCK_IN_INODE_TABLE;
 	}
+	if ((iblock_status[iblk] & IBLOCK_STATUS_INSANE) &&
+	    (retval == 0 || retval == EXT2_ET_INODE_CSUM_INVALID))
+		retval = EXT2_ET_INODE_IS_GARBAGE;
 
 	scan->inodes_left--;
 	scan->current_inode++;

[PATCH 09/19] e2fsck: correctly preserve fs flags when modifying ignore-csum-error flag

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

When we need to modify the "ignore checksum error" behavior flag to
get us past a library call, it's possible that the library call can
result in other flag bits being changed.  Therefore, it is not correct
to restore unconditionally the previous flags value, since this will
have unintended side effects on the other fs->flags; nor is it correct
to assume that we can unconditionally set (or clear) the "ignore csum
error" flag bit.  Therefore, we must merge the previous value of the
"ignore csum error" flag with the value of flags after the call.

Note that we want to leave checksum verification on as much as
possible because doing so exposes e2fsck bugs where two metadata
blocks are "sharing" the same disk block, and attempting to fix one
before relocating the other causes major filesystem damage.  The
damage is much more obvious when a previously checked piece of
metadata suddenly fails in a subsequent pass.

The modifications to the pass 2, 3, and 3A code are justified as
follows: When e2fsck encounters a block of directory entries and
cannot find the placeholder entry at the end that contains the
checksum, it will try to insert the placeholder.  If that fails, it
will schedule the directory for a pass 3A reconstruction.  Until that
happens, we don't want directory block writing (pass 2), block
iteration (pass 3), or block reading (pass 3A) to fail due to checksum
errors, because failing to find the placeholder is itself a checksum
verification error, which causes e2fsck to abort without fixing
anything.

The e2fsck call to ext2fs_read_bitmaps must never fail due to a
checksum error because e2fsck subsequently (a) verifies the bitmaps
itself; or (b) decides that they don't match what has been observed,
and rewrites them.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 e2fsck/pass2.c     |   14 ++++++++++----
 e2fsck/pass3.c     |   11 ++++++++---
 e2fsck/rehash.c    |    4 +++-
 e2fsck/util.c      |    5 ++++-
 lib/ext2fs/inode.c |    3 ++-
 5 files changed, 27 insertions(+), 10 deletions(-)

diff --git a/e2fsck/pass2.c b/e2fsck/pass2.c
index ae7768f..e968831 100644
--- a/e2fsck/pass2.c
+++ b/e2fsck/pass2.c
@@ -1292,6 +1292,7 @@ skip_checksum:
 		}
 	}
 	if (dir_modified) {
+		int	flags, will_rehash;
 		/* leaf block with no tail?  Rehash dirs later. */
 		if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
 				EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) &&
@@ -1304,8 +1305,11 @@ skip_checksum:
 		}
 
 write_and_fix:
-		if (e2fsck_dir_will_be_rehashed(ctx, ino))
+		will_rehash = e2fsck_dir_will_be_rehashed(ctx, ino);
+		if (will_rehash) {
+			flags = ctx->fs->flags;
 			ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
+		}
 		if (inline_data_size) {
 			cd->pctx.errcode =
 				ext2fs_inline_data_set(fs, ino, 0, buf,
@@ -1313,8 +1317,11 @@ write_and_fix:
 		} else
 			cd->pctx.errcode = ext2fs_write_dir_block4(fs, block_nr,
 								   buf, 0, ino);
-		if (e2fsck_dir_will_be_rehashed(ctx, ino))
-			ctx->fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
+		if (will_rehash)
+			ctx->fs->flags = (flags &
+					  EXT2_FLAG_IGNORE_CSUM_ERRORS) |
+					 (ctx->fs->flags &
+					  ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
 		if (cd->pctx.errcode) {
 			if (!fix_problem(ctx, PR_2_WRITE_DIRBLOCK,
 					 &cd->pctx))
@@ -1590,7 +1597,6 @@ int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir,
 	return 0;
 }
 
-
 /*
  * allocate_dir_block --- this function allocates a new directory
  * 	block for a particular inode; this is done if a directory has
diff --git a/e2fsck/pass3.c b/e2fsck/pass3.c
index e6142ad..0b02961 100644
--- a/e2fsck/pass3.c
+++ b/e2fsck/pass3.c
@@ -699,6 +699,7 @@ static void fix_dotdot(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent)
 	errcode_t	retval;
 	struct fix_dotdot_struct fp;
 	struct problem_context pctx;
+	int		flags, will_rehash;
 
 	fp.fs = fs;
 	fp.parent = parent;
@@ -711,12 +712,16 @@ static void fix_dotdot(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent)
 
 	clear_problem_context(&pctx);
 	pctx.ino = ino;
-	if (e2fsck_dir_will_be_rehashed(ctx, ino))
+	will_rehash = e2fsck_dir_will_be_rehashed(ctx, ino);
+	if (will_rehash) {
+		flags = ctx->fs->flags;
 		ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
+	}
 	retval = ext2fs_dir_iterate(fs, ino, DIRENT_FLAG_INCLUDE_EMPTY,
 				    0, fix_dotdot_proc, &fp);
-	if (e2fsck_dir_will_be_rehashed(ctx, ino))
-		ctx->fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
+	if (will_rehash)
+		ctx->fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) |
+			(ctx->fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
 	if (retval || !fp.done) {
 		pctx.errcode = retval;
 		fix_problem(ctx, retval ? PR_3_FIX_PARENT_ERR :
diff --git a/e2fsck/rehash.c b/e2fsck/rehash.c
index 2983e32..e37e871 100644
--- a/e2fsck/rehash.c
+++ b/e2fsck/rehash.c
@@ -126,10 +126,12 @@ static int fill_dir_block(ext2_filsys fs,
 		dirent = (struct ext2_dir_entry *) dir;
 		(void) ext2fs_set_rec_len(fs, fs->blocksize, dirent);
 	} else {
+		int flags = fs->flags;
 		fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
 		fd->err = ext2fs_read_dir_block4(fs, *block_nr, dir, 0,
 						 fd->dir);
-		fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
+		fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) |
+			    (fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
 		if (fd->err)
 			return BLOCK_ABORT;
 	}
diff --git a/e2fsck/util.c b/e2fsck/util.c
index e36e902..8237328 100644
--- a/e2fsck/util.c
+++ b/e2fsck/util.c
@@ -267,6 +267,7 @@ void e2fsck_read_bitmaps(e2fsck_t ctx)
 	errcode_t	retval;
 	const char	*old_op;
 	unsigned int	save_type;
+	int		flags;
 
 	if (ctx->invalid_bitmaps) {
 		com_err(ctx->program_name, 0,
@@ -278,9 +279,11 @@ void e2fsck_read_bitmaps(e2fsck_t ctx)
 	old_op = ehandler_operation(_("reading inode and block bitmaps"));
 	e2fsck_set_bitmap_type(fs, EXT2FS_BMAP64_RBTREE, "fs_bitmaps",
 			       &save_type);
+	flags = ctx->fs->flags;
 	ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
 	retval = ext2fs_read_bitmaps(fs);
-	ctx->fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
+	ctx->fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) |
+			 (ctx->fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
 	fs->default_bitmap_type = save_type;
 	ehandler_operation(old_op);
 	if (retval) {
diff --git a/lib/ext2fs/inode.c b/lib/ext2fs/inode.c
index 08024cb..a6213ae 100644
--- a/lib/ext2fs/inode.c
+++ b/lib/ext2fs/inode.c
@@ -846,7 +846,8 @@ errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino,
 		retval = ext2fs_read_inode_full(fs, ino,
 						(struct ext2_inode *)w_inode,
 						length);
-		fs->flags = old_flags;
+		fs->flags = (old_flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) |
+			    (fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
 		if (retval)
 			goto errout;
 	}

[PATCH 10/19] libext2fs: Don't cache inodes that fail checksum verification

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

If an inode fails checksum verification, don't stuff a copy of it in
the inode cache, because this can cause the library to fail to return
the "corrupt inode" error code.

In general, this happens if ext2fs_read_inode_full() is called twice
on an inode with an incorrect checksum.  If fs->flags has
EXT2_FLAG_IGNORE_CSUM_ERRORS set during the first call and *unset*
during the second call, the cache hit during the second call fails to
return EXT2_ET_INODE_CSUM_INVALID as you'd expect.  This happens
during fsck because the first read_inode call happens as part of
check_blocks and the second call happens during inode checksum
revalidation.  A file system with a slightly corrupt non-extent inode
will trigger this.

While we're at it, make the inode read function consistent with the
rest of libext2fs -- copy the metadata object into the caller's buffer
even if it fails checksum verification.  This will help e2fsck avoid a
double re-read later on down the line.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 lib/ext2fs/inode.c                      |   15 +++++++++------
 tests/f_no_cache_corrupt_inode/expect.1 |   11 +++++++++++
 tests/f_no_cache_corrupt_inode/expect.2 |    7 +++++++
 tests/f_no_cache_corrupt_inode/image.gz |  Bin
 tests/f_no_cache_corrupt_inode/name     |    1 +
 5 files changed, 28 insertions(+), 6 deletions(-)
 create mode 100644 tests/f_no_cache_corrupt_inode/expect.1
 create mode 100644 tests/f_no_cache_corrupt_inode/expect.2
 create mode 100644 tests/f_no_cache_corrupt_inode/image.gz
 create mode 100644 tests/f_no_cache_corrupt_inode/name

diff --git a/lib/ext2fs/inode.c b/lib/ext2fs/inode.c
index a6213ae..6c766af 100644
--- a/lib/ext2fs/inode.c
+++ b/lib/ext2fs/inode.c
@@ -709,7 +709,7 @@ errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
 	io_channel	io;
 	int		length = EXT2_INODE_SIZE(fs->super);
 	struct ext2_inode_large	*iptr;
-	int		cache_slot;
+	int		cache_slot, fail_csum;
 
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
@@ -787,9 +787,7 @@ errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
 	length = EXT2_INODE_SIZE(fs->super);
 
 	/* Verify the inode checksum. */
-	if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
-	    !ext2fs_inode_csum_verify(fs, ino, iptr))
-		return EXT2_ET_INODE_CSUM_INVALID;
+	fail_csum = !ext2fs_inode_csum_verify(fs, ino, iptr);
 
 #ifdef WORDS_BIGENDIAN
 	ext2fs_swap_inode_full(fs, (struct ext2_inode_large *) iptr,
@@ -798,10 +796,15 @@ errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
 #endif
 
 	/* Update the inode cache bookkeeping */
-	fs->icache->cache_last = cache_slot;
-	fs->icache->cache[cache_slot].ino = ino;
+	if (!fail_csum) {
+		fs->icache->cache_last = cache_slot;
+		fs->icache->cache[cache_slot].ino = ino;
+	}
 	memcpy(inode, iptr, (bufsize > length) ? length : bufsize);
 
+	if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) && fail_csum)
+		return EXT2_ET_INODE_CSUM_INVALID;
+
 	return 0;
 }
 
diff --git a/tests/f_no_cache_corrupt_inode/expect.1 b/tests/f_no_cache_corrupt_inode/expect.1
new file mode 100644
index 0000000..4f82f75
--- /dev/null
+++ b/tests/f_no_cache_corrupt_inode/expect.1
@@ -0,0 +1,11 @@
+Pass 1: Checking inodes, blocks, and sizes
+Inode 12 passes checks, but checksum does not match inode.  Fix? yes
+
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 12/128 files (0.0% non-contiguous), 19/512 blocks
+Exit status is 1
diff --git a/tests/f_no_cache_corrupt_inode/expect.2 b/tests/f_no_cache_corrupt_inode/expect.2
new file mode 100644
index 0000000..1b43315
--- /dev/null
+++ b/tests/f_no_cache_corrupt_inode/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 12/128 files (0.0% non-contiguous), 19/512 blocks
+Exit status is 0
diff --git a/tests/f_no_cache_corrupt_inode/image.gz b/tests/f_no_cache_corrupt_inode/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..e17e9216deac289cf5c13a33be87b1810640a66d
GIT binary patch
literal 2606
zcmb2|=3wyobSapL`Ry(14B<o>h7a#A{ZQZy>*8x|QnKm@V3(D-?OG_n)#_yJ!7jME
zccFxPCX1kBt6$TLWsAF;`vY|rJyPTFYwCAAxQJ1dedE2Sil)~bqkGT(t$SEM{r$V5
z^84lefA)JjF<e?ThsQ|q%aO%5HClpdtCq=KWj(d^V#U*s0h)apXU_8O?RMHzA<=uf
zx777(Vfx+;+L7*iCMn+(*tTZBLGiB(^L{U9TlbZ}?oIvWJ@U7?-M#B~ud{9gI$`~{
zxf=I(#nr{Fdot<o+4QW>&#ou0{Bmr4M&rwy6_4VU%juSV`?OqhEd#^L$xHU%EzDW<
z?ElgobJqIRTYdVPt0{6lLy>`jA>!Y&Pd7g-O%|Nb4&?o-KKcItPl425PH*=!{G4#|
z%h#*_4)4}`VkCStd1)?t_wjx?k7unP7OYm*66uzk1JrTANZ|X^`FE>t1i#FA^?(1n
zRbT%zGB7lJd+|SCBD&hV^8Z5bYM?TQ-QWIe?>@c^EbH)J9w?O2|IZ#sfxw16qFqPl
zgh4nsNrku1cFj5kly<oNk%a}PGJ+Bf_YI>eZLW0GZ$0}^eC_)0ZyanQqF4V<vCS&B
zI`rz7QQ+1sU*vpSFG$bhS${9;gxW<5zD&#Ke)-<tP0b7S?tZ;rVtn^&{r{a`e+Sq}
z^1u6{U+}+w-~IppLehgRv$V?J`@E}{SDUrJ{Zi2%^ZQ=kf7bt~+4Z`<dfC_C1?ng3
ze~F*^Z<P3W&(ldyQe0)UA4hC;xm~x@e&@gZIhjwt)_+Y2S$q45|Ihd@&i|%IA2HLr
zyU*zF>dL)|HA^P`SDl!%e<C*%K_8AP7!85Z5Eu=C(GVC7fzc2kF9bgP-p6Po@Th@-
HL4g4PrH?{0

literal 0
HcmV?d00001

diff --git a/tests/f_no_cache_corrupt_inode/name b/tests/f_no_cache_corrupt_inode/name
new file mode 100644
index 0000000..fb213e2
--- /dev/null
+++ b/tests/f_no_cache_corrupt_inode/name
@@ -0,0 +1 @@
+don't cache inodes that fail checksum verification

[PATCH 11/19] e2fsck: disable checksum verification in a few select places

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Selectively disable checksum verification in a couple more places:

In check_blocks, disable checksum verification when iterating a block
map because the block map iterator function (re)reads the inode, which
could be unchanged since the scan found that the checksum fails.  We
don't want to abort here; we want to keep evaluating the inode, and we
already know if the inode checksum doesn't match.

Further down in check_blocks when we're trying to see if i_size
matches the amount of data stored in the inode, don't allow checksum
errors when we go looking for the size of inline data.  If the
required attribute is at all find-able in the EA block, we'll fix any
other problems with the EA block later.  In the meantime, we don't
want to be truncating files unnecessarily.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 e2fsck/pass1.c |   12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index a7792c4..39ebaae 100644
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -2452,6 +2452,7 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
 		if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL))
 			check_blocks_extents(ctx, pctx, &pb);
 		else {
+			int flags;
 			/*
 			 * If we've modified the inode, write it out before
 			 * iterate() tries to use it.
@@ -2461,6 +2462,7 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
 						   "check_blocks");
 				dirty_inode = 0;
 			}
+			flags = fs->flags;
 			fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
 			pctx->errcode = ext2fs_block_iterate3(fs, ino,
 						pb.is_dir ? BLOCK_FLAG_HOLE : 0,
@@ -2479,7 +2481,8 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
 			if (pb.inode_modified)
 				e2fsck_read_inode(ctx, ino, inode,
 						  "check_blocks");
-			fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
+			fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) |
+				    (fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
 		}
 	} else {
 		/* check inline data */
@@ -2545,10 +2548,17 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
 	if (pb.is_dir) {
 		int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super);
 		if (inode->i_flags & EXT4_INLINE_DATA_FL) {
+			int flags;
 			size_t size;
 
+			flags = ctx->fs->flags;
+			ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
 			if (ext2fs_inline_data_size(ctx->fs, pctx->ino, &size))
 				bad_size = 5;
+			ctx->fs->flags = (flags &
+					  EXT2_FLAG_IGNORE_CSUM_ERRORS) |
+					 (ctx->fs->flags &
+					  ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
 			if (size != inode->i_size)
 				bad_size = 5;
 		} else if (inode->i_size & (fs->blocksize - 1))

[PATCH 12/19] e2fsck: always ask to fix an inode that fails checksum verification

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

If an inode fails checksum verification during pass 1 and the user
doesn't fix or clear the inode as part of the regular inode checks,
ensure that e2fsck remembers to ask the user if he simply wants to
correct the checksum.

We weren't capturing all the ways out of an interation of the inode
scanning loop, which means that not all errors were caught.  Also,
we might as well clear the 'failed csum' flag if we write the inode
directly from the inode scanning loop.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 e2fsck/pass1.c                          |   65 +++++++++++++++++++++++--------
 tests/f_deleted_inode_bad_csum/expect.1 |   11 +++++
 tests/f_deleted_inode_bad_csum/expect.2 |    7 +++
 tests/f_deleted_inode_bad_csum/image.gz |  Bin
 tests/f_deleted_inode_bad_csum/name     |    1 
 5 files changed, 67 insertions(+), 17 deletions(-)
 create mode 100644 tests/f_deleted_inode_bad_csum/expect.1
 create mode 100644 tests/f_deleted_inode_bad_csum/expect.2
 create mode 100644 tests/f_deleted_inode_bad_csum/image.gz
 create mode 100644 tests/f_deleted_inode_bad_csum/name

diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index 39ebaae..5c72f48 100644
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -594,10 +594,7 @@ static errcode_t recheck_bad_inode_checksum(ext2_filsys fs, ext2_ino_t ino,
 
 	retval = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&inode,
 					 sizeof(inode));
-	if (retval)
-		return retval;
-
-	return 0;
+	return retval;
 }
 
 static void reserve_block_for_root_repair(e2fsck_t ctx)
@@ -636,6 +633,29 @@ static void reserve_block_for_lnf_repair(e2fsck_t ctx)
 	ctx->lnf_repair_block = blk;
 }
 
+static void finish_processing_inode(e2fsck_t ctx, ext2_ino_t ino,
+				    struct problem_context *pctx,
+				    int failed_csum)
+{
+	if (!failed_csum)
+		return;
+
+	/*
+	 * If the inode failed the checksum and the user didn't
+	 * clear the inode, test the checksum again -- if it still
+	 * fails, ask the user if the checksum should be corrected.
+	 */
+	pctx->errcode = recheck_bad_inode_checksum(ctx->fs, ino, ctx, pctx);
+	if (pctx->errcode)
+		ctx->flags |= E2F_FLAG_ABORT;
+}
+#define FINISH_INODE_LOOP(ctx, ino, pctx, failed_csum) \
+	do { \
+		finish_processing_inode((ctx), (ino), (pctx), (failed_csum)); \
+		if ((ctx)->flags & E2F_FLAG_ABORT) \
+			return; \
+	} while (0)
+
 void e2fsck_pass1(e2fsck_t ctx)
 {
 	int	i;
@@ -898,6 +918,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 				inlinedata_fs = 1;
 			} else if (!fix_problem(ctx, PR_1_INLINE_DATA_SET, &pctx)) {
 				e2fsck_clear_inode(ctx, ino, inode, 0, "pass1");
+				/* skip FINISH_INODE_LOOP */
 				continue;
 			}
 		}
@@ -932,6 +953,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 				if (ino == EXT2_BAD_INO)
 					ext2fs_mark_inode_bitmap2(ctx->inode_used_map,
 								 ino);
+				/* skip FINISH_INODE_LOOP */
 				continue;
 			}
 		}
@@ -968,6 +990,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 				       sizeof(inode->i_block));
 #endif
 				e2fsck_write_inode(ctx, ino, inode, "pass1");
+				failed_csum = 0;
 			}
 		}
 
@@ -982,6 +1005,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 				memset(inode, 0, sizeof(struct ext2_inode));
 				e2fsck_write_inode(ctx, ino, inode,
 						   "clear bad inode");
+				failed_csum = 0;
 			}
 
 			pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map,
@@ -1016,6 +1040,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 			}
 			ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
 			clear_problem_context(&pctx);
+			FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
 			continue;
 		} else if (ino == EXT2_ROOT_INO) {
 			/*
@@ -1041,6 +1066,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 					inode->i_dtime = 0;
 					e2fsck_write_inode(ctx, ino, inode,
 							   "pass1");
+					failed_csum = 0;
 				}
 			}
 		} else if (ino == EXT2_JOURNAL_INO) {
@@ -1052,8 +1078,10 @@ void e2fsck_pass1(e2fsck_t ctx)
 					inode->i_mode = LINUX_S_IFREG;
 					e2fsck_write_inode(ctx, ino, inode,
 							   "pass1");
+					failed_csum = 0;
 				}
 				check_blocks(ctx, &pctx, block_buf);
+				FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
 				continue;
 			}
 			if ((inode->i_links_count ||
@@ -1065,6 +1093,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 						    ino, 0);
 				e2fsck_write_inode_full(ctx, ino, inode,
 							inode_size, "pass1");
+				failed_csum = 0;
 			}
 		} else if ((ino == EXT4_USR_QUOTA_INO) ||
 			   (ino == EXT4_GRP_QUOTA_INO)) {
@@ -1079,8 +1108,10 @@ void e2fsck_pass1(e2fsck_t ctx)
 					inode->i_mode = LINUX_S_IFREG;
 					e2fsck_write_inode(ctx, ino, inode,
 							"pass1");
+					failed_csum = 0;
 				}
 				check_blocks(ctx, &pctx, block_buf);
+				FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
 				continue;
 			}
 			if ((inode->i_links_count ||
@@ -1092,6 +1123,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 						    ino, 0);
 				e2fsck_write_inode_full(ctx, ino, inode,
 							inode_size, "pass1");
+				failed_csum = 0;
 			}
 		} else if (ino < EXT2_FIRST_INODE(fs->super)) {
 			problem_t problem = 0;
@@ -1113,9 +1145,11 @@ void e2fsck_pass1(e2fsck_t ctx)
 					inode->i_mode = 0;
 					e2fsck_write_inode(ctx, ino, inode,
 							   "pass1");
+					failed_csum = 0;
 				}
 			}
 			check_blocks(ctx, &pctx, block_buf);
+			FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
 			continue;
 		}
 
@@ -1143,6 +1177,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 					0 : ctx->now;
 				e2fsck_write_inode(ctx, ino, inode,
 						   "pass1");
+				failed_csum = 0;
 			}
 		}
 
@@ -1157,8 +1192,10 @@ void e2fsck_pass1(e2fsck_t ctx)
 					inode->i_dtime = ctx->now;
 					e2fsck_write_inode(ctx, ino, inode,
 							   "pass1");
+					failed_csum = 0;
 				}
 			}
+			FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
 			continue;
 		}
 		/*
@@ -1175,6 +1212,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 			if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) {
 				inode->i_dtime = 0;
 				e2fsck_write_inode(ctx, ino, inode, "pass1");
+				failed_csum = 0;
 			}
 		}
 
@@ -1211,6 +1249,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 					inode->i_flags &= ~EXT2_IMAGIC_FL;
 					e2fsck_write_inode(ctx, ino,
 							   inode, "pass1");
+					failed_csum = 0;
 				}
 			}
 		}
@@ -1228,6 +1267,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 		    fix_problem(ctx, PR_1_FAST_SYMLINK_EXTENT_FL, &pctx)) {
 			inode->i_flags &= ~EXT4_EXTENTS_FL;
 			e2fsck_write_inode(ctx, ino, inode, "pass1");
+			failed_csum = 0;
 		}
 
 		if (LINUX_S_ISDIR(inode->i_mode)) {
@@ -1253,10 +1293,12 @@ void e2fsck_pass1(e2fsck_t ctx)
 			check_immutable(ctx, &pctx);
 			ctx->fs_symlinks_count++;
 			if (inode->i_flags & EXT4_INLINE_DATA_FL) {
+				FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
 				continue;
 			} else if (ext2fs_inode_data_blocks(fs, inode) == 0) {
 				ctx->fs_fast_symlinks_count++;
 				check_blocks(ctx, &pctx, block_buf);
+				FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
 				continue;
 			}
 		}
@@ -1293,19 +1335,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 		} else
 			check_blocks(ctx, &pctx, block_buf);
 
-		/*
-		 * If the inode failed the checksum and the user didn't
-		 * clear the inode, test the checksum again -- if it still
-		 * fails, ask the user if the checksum should be corrected.
-		 */
-		if (failed_csum) {
-			pctx.errcode = recheck_bad_inode_checksum(fs, ino, ctx,
-								  &pctx);
-			if (pctx.errcode) {
-				ctx->flags |= E2F_FLAG_ABORT;
-				return;
-			}
-		}
+		FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
 
 		if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
 			goto endit;
@@ -1410,6 +1440,7 @@ endit:
 	if ((ctx->flags & E2F_FLAG_SIGNAL_MASK) == 0)
 		print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io);
 }
+#undef FINISH_INODE_LOOP
 
 /*
  * When the inode_scan routines call this callback at the end of the
diff --git a/tests/f_deleted_inode_bad_csum/expect.1 b/tests/f_deleted_inode_bad_csum/expect.1
new file mode 100644
index 0000000..8420361
--- /dev/null
+++ b/tests/f_deleted_inode_bad_csum/expect.1
@@ -0,0 +1,11 @@
+Pass 1: Checking inodes, blocks, and sizes
+Inode 12 passes checks, but checksum does not match inode.  Fix? yes
+
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 12/128 files (0.0% non-contiguous), 18/512 blocks
+Exit status is 1
diff --git a/tests/f_deleted_inode_bad_csum/expect.2 b/tests/f_deleted_inode_bad_csum/expect.2
new file mode 100644
index 0000000..eb48b40
--- /dev/null
+++ b/tests/f_deleted_inode_bad_csum/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 12/128 files (0.0% non-contiguous), 18/512 blocks
+Exit status is 0
diff --git a/tests/f_deleted_inode_bad_csum/image.gz b/tests/f_deleted_inode_bad_csum/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..a27e50e85f91e2724e846644729b27faefccc561
GIT binary patch
literal 2676
zcmb2|=3w}~<VG+P^V?g#86x2_3?Iy2%Ux1YO<K5cLesYt!NsBzFGNYbJm}@Xzpz~N
zVw05avT4r(gx<1ebO-Fw*doNSx8g$gl&&AG?zS9Ujw{&xn^q*e^}V@oyD|5!HSKC<
zt7qQN|9SrQ_q4S1f18arzki#@;Skxo+*7rsJn5qXcjA_e^&)}s2{!us=FXC{6H(^g
zdh5esog+sNN31cA)7Cz<Zjq5d_vw$WWns=cj0(P7c8}-V`}OjqvwQ95|9iCl+24qb
z)hS>8pZofzcc1X~cR4lR+ZU>)+y5!fP~vW0xO>w1YP0_7OZDwGiM_pgW5>aj?z8Vk
z)>f@w%)sz;@~-{eNqfTI|L;Fmwe{Y<m#6gizvI6DeP71jzw__dzI?&Rz;NL8!fS!N
z{$gj6Y8e<99!#BH_y0X#<Wl=5|5;z~P4%j;|0jR%=)%pLvd{0kn0otrjp-)cv#a%I
z*9x3APoDGo<fhPlPC!!{!oy@v-@jM!{?e^=%Rc_UJFn&sKhU@{{U86Y-M+ta&OG~f
zg*HHegnfPg!`Ih5E`MAP<Qe>92a?Z@|Bwe##DKW+t@oB$0aY5j|G~yWj1KH-8vZBc
zWL51DEZ%zdWdH5?-~W~tZZbIk|G3g8OKvCky>B|sJH7a0&3!ff+UZx`XU=`yDDdmh
z<lx88?X4y)`e--h=^X1l3-4UNGmZV}x%#8MMbH0#srdapu|~;Hk8j(K|LI5n=0Dpt
z>s4g%-$Nz4{{Jmr@UwV@&intr%}>|<dtVXp?$3FjZT0ec%l@5DSp6?vRY&ia{X*CO
z%cG9u%=uvz`~UU&t)G9*pLODNv+Mo$4~lCK*!*8J@Bf+4cWo<kd{=*q(tY~>_{=Nc
zcke1WeoZ9v_sTi1|LpI+oqObS`Rkj{?LRgBu?}DQr~db!%?ooXl`nk@&U9hJ9t@+R
iqaiRF0;3@?8UmvsFd70BhrpRD`&VBR-p0V7zyJWnQ+oUW

literal 0
HcmV?d00001

diff --git a/tests/f_deleted_inode_bad_csum/name b/tests/f_deleted_inode_bad_csum/name
new file mode 100644
index 0000000..516701a
--- /dev/null
+++ b/tests/f_deleted_inode_bad_csum/name
@@ -0,0 +1 @@
+deleted inode with a bad csum that wasn't getting fixed (metadata_csum)

[PATCH 13/19] tests: add regression tests for EA blocks with bad checksums

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Add regression tests for e2fsck dealing with (a) EA block with a bad
checksum; (b) EA block with a bad magic number; and (c) EA block with
damage that isn't otherwise noticeable.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 tests/f_ea_bad_csum/expect.1 |   29 +++++++++++++++++++++++++++++
 tests/f_ea_bad_csum/expect.2 |    7 +++++++
 tests/f_ea_bad_csum/image.gz |  Bin
 tests/f_ea_bad_csum/name     |    1 +
 4 files changed, 37 insertions(+)
 create mode 100644 tests/f_ea_bad_csum/expect.1
 create mode 100644 tests/f_ea_bad_csum/expect.2
 create mode 100644 tests/f_ea_bad_csum/image.gz
 create mode 100644 tests/f_ea_bad_csum/name

diff --git a/tests/f_ea_bad_csum/expect.1 b/tests/f_ea_bad_csum/expect.1
new file mode 100644
index 0000000..4fc365f
--- /dev/null
+++ b/tests/f_ea_bad_csum/expect.1
@@ -0,0 +1,29 @@
+Pass 1: Checking inodes, blocks, and sizes
+Inode 12 has a bad extended attribute block 1074.  Clear? yes
+
+Inode 12, i_blocks is 2, should be 0.  Fix? yes
+
+Extended attribute in inode 13 has a hash (1631637196) which is invalid
+Clear? yes
+
+Inode 13, i_blocks is 2, should be 0.  Fix? yes
+
+Inode 14 extended attribute block 1076 passes checks, but checksum does not match block.  Fix? yes
+
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+Block bitmap differences:  -(1074--1075)
+Fix? yes
+
+Free blocks count wrong for group #0 (971, counted=973).
+Fix? yes
+
+Free blocks count wrong (971, counted=973).
+Fix? yes
+
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 14/128 files (7.1% non-contiguous), 1075/2048 blocks
+Exit status is 1
diff --git a/tests/f_ea_bad_csum/expect.2 b/tests/f_ea_bad_csum/expect.2
new file mode 100644
index 0000000..d83fdfb
--- /dev/null
+++ b/tests/f_ea_bad_csum/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 14/128 files (7.1% non-contiguous), 1075/2048 blocks
+Exit status is 0
diff --git a/tests/f_ea_bad_csum/image.gz b/tests/f_ea_bad_csum/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..e7a25c512feec33336f18ef0954737e91003269c
GIT binary patch
literal 3176
zcmeIy`&ZHj6aa8qEzO-1Zh53>rA*T$X)MiYK1k1*uSB#`o0_HtElpXH(nKSB=?SL`
z^HFMym71Aa<fAmC5_S1DQFMS53>XSBGDRNW?{}X4*1yp4{&3H|Ki<!|_uA3SVc8D+
z!=J5Ji^Q}e(c57El1>H1#}20-_D}}IGKx%(Q2~yvHtdkES~nnVe8#T7S+HnCeU7vZ
zg981&&EN2)jpGe?_fNI#hh5)9`Il{=vkqAp?023~j0nfil06$;>qS8B+aW)9ozR=4
z5o(@c<g@NbnET`b!<gl(Vy~@31!IVU(5!sC>}I*`>1We7>Ku!TvlDP(vSzNL?2j^~
zoS^AK*0p3JRW4V?GVdGTSCJA|lmIa)L%6u4YbgP?rRC)4A}(ZD7g1`NE}S_P*fdy@
z;hmkUtXW?Z+}XS{lu}uNDmkdQt0nkbJs421W^e^1eXV=z>MAq1vepIyfR!eOrrvbn
zBFNScDLlS_!)878-W;Ej>e@?9O5hKo<jcLHdc&)SrCYF+l*P%Oa(mdvVe$!r5Z1i3
zWwW5<jR%eGw-9vUT;zg+koc!8ro~P7?g`pM-bvQX7<t7afK9w74a1jao%O;D)&tk>
z<w<kPadgk&UE!O)E2o}G_%M}5>gPg}x!z#Day!%{b~SkqiwEL&peH0y?O>88jcN&9
zTruNf?7?+fcp>$GX}!eG5_-X-K@+2X#(>=0fNd6&j)mHD&NN0E>Qy$7wC3n-^gg_n
zaZ)RK@B9O)%+o%#aiAkcX4f*{9IcmA^nua(z)7RkRDVH`*xc9m?r6y`n}@a{1>-oK
z;Z(1OPhD_IYT@aK_5e4rLqfL#!{%euO?P+I^?NXm8{y%h!!rTYoJjvl4b4m{JDe{-
zkQsAdJc)?lWmHe+E<KvsvQob}FHUS=fXFKowkHVb=CN^Z*+&k^&MD|`9x*>mpLcIC
zg&d;qfV)<o1O$=*Ua+Qo(c$rI*n?{SVf>PFt)VAx3EHk`2XdHgeOxR9Q*9_n0n+z5
zB`)^%G*G>!INg2RJ#&h=X6-yg)%1*5UYI%Rum2e@)G;_lK#|5xq65?DuSu9@&0f3b
z$HWHmv1TH`@Qo51DpVH9_UY6qYYQnKa@<|@x3T5?ixqO>@Ejb=i~(d=9Nt*UAp*D)
zCw}w{AAQ|4H1b+h_>!gEbD>)o5o0j%Am<^+G7w|Nav}tGGOPr}AX<Lu4qoOF*;Z11
zWqiDNKC~fW2@J${wyHx0iG|9l>H8`d-t&xqz`U1tX4$2TMlDeI{SjGgjfj(_A9w99
z-oqySz8J!9b36@S%+xJYoy2{fzfx+adZVtcNJcJY{bq>ciA_Zyl<Wk74BJqan)i&k
zEV(tZz%+J5cO2xe8y)G>SyMV&tI=(0RJM-Xgi_09Y0$f6Nz>(ujm||-vKBt!1jetf
zn|?WEz7*vaz7<mRV#2Fdh+Py2x5V~?^UglTp9D36=A+kFw;tX06x6*V0mQs{@@lH!
z7^y-?3fg^q5Nq9<z?#4(FK|(b_Xv}qv5ISd(N68}DtOS3pbPZpynJlM@hT;YcRW=P
zt6I>+Rmd|P$WrQ4_WAj@wJ$fVR#uSDZokTnTJe4-aI^z40pxFzLeJIzKb|MsK6$vc
W0oMdRZ2`h{3@q4p;W7+n5Bm?Qd!Nbx

literal 0
HcmV?d00001

diff --git a/tests/f_ea_bad_csum/name b/tests/f_ea_bad_csum/name
new file mode 100644
index 0000000..958b244
--- /dev/null
+++ b/tests/f_ea_bad_csum/name
@@ -0,0 +1 @@
+EA block with bad checksum (metadata_csum)

[PATCH 14/19] tests: add tests for handling of corrupt extents

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Add some regression tests to examine how e2fsck deals with (a) extent
blocks with only a bad checksum; (b) extent blocks with a bad magic
number; and (c) extent entries with corruption.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 tests/f_extent_bad_node/name            |    2 +-
 tests/f_extent_int_bad_csum/expect.1    |   11 +++++++++++
 tests/f_extent_int_bad_csum/expect.2    |    7 +++++++
 tests/f_extent_int_bad_csum/image.gz    |  Bin
 tests/f_extent_int_bad_csum/name        |    1 +
 tests/f_extent_int_bad_extent/expect.1  |   24 ++++++++++++++++++++++++
 tests/f_extent_int_bad_extent/expect.2  |    7 +++++++
 tests/f_extent_int_bad_extent/image.gz  |  Bin
 tests/f_extent_int_bad_extent/name      |    1 +
 tests/f_extent_int_bad_magic/expect.1   |   23 +++++++++++++++++++++++
 tests/f_extent_int_bad_magic/expect.2   |    7 +++++++
 tests/f_extent_int_bad_magic/image.gz   |  Bin
 tests/f_extent_int_bad_magic/name       |    1 +
 tests/f_extent_leaf_bad_csum/expect.1   |   11 +++++++++++
 tests/f_extent_leaf_bad_csum/expect.2   |    7 +++++++
 tests/f_extent_leaf_bad_csum/image.gz   |  Bin
 tests/f_extent_leaf_bad_csum/name       |    1 +
 tests/f_extent_leaf_bad_extent/expect.1 |   24 ++++++++++++++++++++++++
 tests/f_extent_leaf_bad_extent/expect.2 |    7 +++++++
 tests/f_extent_leaf_bad_extent/image.gz |  Bin
 tests/f_extent_leaf_bad_extent/name     |    1 +
 tests/f_extent_leaf_bad_magic/expect.1  |   23 +++++++++++++++++++++++
 tests/f_extent_leaf_bad_magic/expect.2  |    7 +++++++
 tests/f_extent_leaf_bad_magic/image.gz  |  Bin
 tests/f_extent_leaf_bad_magic/name      |    1 +
 25 files changed, 165 insertions(+), 1 deletion(-)
 create mode 100644 tests/f_extent_int_bad_csum/expect.1
 create mode 100644 tests/f_extent_int_bad_csum/expect.2
 create mode 100644 tests/f_extent_int_bad_csum/image.gz
 create mode 100644 tests/f_extent_int_bad_csum/name
 create mode 100644 tests/f_extent_int_bad_extent/expect.1
 create mode 100644 tests/f_extent_int_bad_extent/expect.2
 create mode 100644 tests/f_extent_int_bad_extent/image.gz
 create mode 100644 tests/f_extent_int_bad_extent/name
 create mode 100644 tests/f_extent_int_bad_magic/expect.1
 create mode 100644 tests/f_extent_int_bad_magic/expect.2
 create mode 100644 tests/f_extent_int_bad_magic/image.gz
 create mode 100644 tests/f_extent_int_bad_magic/name
 create mode 100644 tests/f_extent_leaf_bad_csum/expect.1
 create mode 100644 tests/f_extent_leaf_bad_csum/expect.2
 create mode 100644 tests/f_extent_leaf_bad_csum/image.gz
 create mode 100644 tests/f_extent_leaf_bad_csum/name
 create mode 100644 tests/f_extent_leaf_bad_extent/expect.1
 create mode 100644 tests/f_extent_leaf_bad_extent/expect.2
 create mode 100644 tests/f_extent_leaf_bad_extent/image.gz
 create mode 100644 tests/f_extent_leaf_bad_extent/name
 create mode 100644 tests/f_extent_leaf_bad_magic/expect.1
 create mode 100644 tests/f_extent_leaf_bad_magic/expect.2
 create mode 100644 tests/f_extent_leaf_bad_magic/image.gz
 create mode 100644 tests/f_extent_leaf_bad_magic/name

diff --git a/tests/f_extent_bad_node/name b/tests/f_extent_bad_node/name
index 9c9d79f..0b4ab8c 100644
--- a/tests/f_extent_bad_node/name
+++ b/tests/f_extent_bad_node/name
@@ -1 +1 @@
-bad interior node in extent tree
+bad interior node in extent tree (metadata_csum)
diff --git a/tests/f_extent_int_bad_csum/expect.1 b/tests/f_extent_int_bad_csum/expect.1
new file mode 100644
index 0000000..57a2a61
--- /dev/null
+++ b/tests/f_extent_int_bad_csum/expect.1
@@ -0,0 +1,11 @@
+Pass 1: Checking inodes, blocks, and sizes
+Inode 12 extent block passes checks, but checksum does not match extent
+	(logical block 698, invalid physical block 1788, len 1)
+Fix? yes
+
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 12/128 files (16.7% non-contiguous), 1446/2048 blocks
+Exit status is 0
diff --git a/tests/f_extent_int_bad_csum/expect.2 b/tests/f_extent_int_bad_csum/expect.2
new file mode 100644
index 0000000..6f73d98
--- /dev/null
+++ b/tests/f_extent_int_bad_csum/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 12/128 files (16.7% non-contiguous), 1446/2048 blocks
+Exit status is 0
diff --git a/tests/f_extent_int_bad_csum/image.gz b/tests/f_extent_int_bad_csum/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..f3878981239804cbd7244abf21b7130a1129df41
GIT binary patch
literal 7202
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
PwD4$4;Zsk&_SAm>O7k`<

literal 0
HcmV?d00001

diff --git a/tests/f_extent_int_bad_csum/name b/tests/f_extent_int_bad_csum/name
new file mode 100644
index 0000000..87317e3
--- /dev/null
+++ b/tests/f_extent_int_bad_csum/name
@@ -0,0 +1 @@
+bad csum in internal extent (metadata_csum)
diff --git a/tests/f_extent_int_bad_extent/expect.1 b/tests/f_extent_int_bad_extent/expect.1
new file mode 100644
index 0000000..3d2fb58
--- /dev/null
+++ b/tests/f_extent_int_bad_extent/expect.1
@@ -0,0 +1,24 @@
+Pass 1: Checking inodes, blocks, and sizes
+Inode 12 has an invalid extent
+	(logical block 0, invalid physical block 4294967295, len 168)
+Clear? yes
+
+Inode 12, i_blocks is 712, should be 542.  Fix? yes
+
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+Block bitmap differences:  -(1090--1091) -1093 -1095 -1097 -1099 -1101 -1103 -1105 -1107 -1109 -1111 -1113 -1115 -1117 -1119 -1121 -1123 -1125 -1127 -1129 -1131 -1133 -1135 -1137 -1139 -1141 -1143 -1145 -1147 -1149 -1151 -1153 -1155 -1157 -1159 -1161 -1163 -1165 -1167 -1169 -1171 -1173 -1175 -1177 -1179 -1181 -1183 -1185 -1187 -1189 -1191 -1193 -1195 -1197 -1199 -1201 -1203 -1205 -1207 -1209 -1211 -1213 -1215 -1217 -1219 -1221 -1223 -1225 -1227 -1229 -1231 -1233 -1235 -1237 -1239 -1241 -1243 -1245 -1247 -1249 -1251 -1253 -1255 -1257
+Fix? yes
+
+Free blocks count wrong for group #0 (602, counted=687).
+Fix? yes
+
+Free blocks count wrong (602, counted=687).
+Fix? yes
+
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 12/128 files (16.7% non-contiguous), 1361/2048 blocks
+Exit status is 1
diff --git a/tests/f_extent_int_bad_extent/expect.2 b/tests/f_extent_int_bad_extent/expect.2
new file mode 100644
index 0000000..4e72e41
--- /dev/null
+++ b/tests/f_extent_int_bad_extent/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 12/128 files (16.7% non-contiguous), 1361/2048 blocks
+Exit status is 0
diff --git a/tests/f_extent_int_bad_extent/image.gz b/tests/f_extent_int_bad_extent/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..e8745bff45f2a1f226ba59278bcaf7868e4533c8
GIT binary patch
literal 7205
zcmeHLeN+=?zOHMxcDJk9*0W2iC8_=5cCAJi5hNt3>nbQ8kwOvyNu*S%Vu%(oGB`=C
zRoeQ2RtpM}h!BDq!iancn8emDSQR3PlPC~UrHC_pL}iA+gvspe{jcZVbMF1;o^#Kh
z&R_G+dEay1`JLx^e$Vsc9C`7%vW2ds-^?C!vrZ=;0(}qeZ(Y6l<=;KnD7*gj$t$vX
zovt+z8zL+>7Jc!@H7`~?e`izd6HZ0UA5E)wnDoz^-f_NK*^wIihvmhutU0>8<CPu9
zmOFFiinC42J1#UiUm3LiJ~2}~;2GU7owZ17nLHMs&o=XPL*2K_3$ncCP}Mfog1K9i
zO&6y1%F6ol3C9)66~)f&eaEw2buK6!_CMySm-#cp8pE5FI%-dvZ~8Fe<7bVv_N%A2
z{jIz|)s_EgbmeZZ-eue8eaeZPIK0-UX?AspC|kO+vppf@GTvqDng#nyEIeHLNSPW~
zTxn3%mG2sEdDrTnIM~<wZW!5=wK7`}*)q9f&*-ke<ZX39-E?`_RnuWZLD+%@6_1+5
z1H&5w*?nEDk-e$6o*&qtii*m4axF4gcD=$qLfgp{CADQ9D%{#<?_l|^B#iTRJ@LQ4
z`ng{|Q?`1_`sLv9-h*Ru^P~93`w!li*9T92)MZsT;2x)-t%u}=Qwzq%Dx+Hhhi&KA
zW%(Z_30rXuH-b3&&P3VZf@5_ug(BqM&hNQRsU_i7n&&xl*|T(nE|!@H&Xm_2fb(}d
zZf;YKY|Xzm&>T<(0`#VB)SMCF7HUo{{Tacz6qxPQTq9YV=vgDeC%0Mxo=<<ETd!KW
z42dfI<B3d2<^Iba&4-gYg3k6X`xo+r6uR%Snnkb5Qh4vbaJrs{SMcyY)#K)1;HPZ&
z^692=vv;1^GtW%V1Fy}ann^n<J4nCY$GSIEu*I7}6`Gybq8=*+UkaPS?fg4A!M}gi
zuDRK)KgL<=b_^Z{=gd><qD9we=-W`=__Qwnj^@Ci&}-smE;yFqo%(K6TQR)Lc4FLN
zam#rv&BW_(kFQeqzly(WpbnXib=>L5vRoOonpaZtqmWQ6*FN5P6h_%6D~6wlr3Kl6
zK3O?EDdnm@@H)}puu+}B)O|$>#FXb*@$kaiGIRTO&SdMO8DCnYrsF_iSRo-q_o*iK
zt`KQ@gmYjkP17T7k4^Nn=9$@45>-0E7p%#SgZuk<12nw-)_2|Enb}zr0c-B&iNJWP
zjX6Xs_3zlm+<kPe@R`%|f`(>I3iujYxt9HKNzJJ;22EKj_U5nFY|8#b3un>yocAo?
zq(k8z?%S<Fa$BiqU0+1DnpgfML^V1I&gSL2-is}^Ot(h<lt<fDg@Kzh@wYTvalE@}
z{`idZXO%|1E3L0;opsX1ruXEGH8}(peuGDwt<IX;74(L#Zm7{;j(=8eS(r+Xjd#5q
ztT1i;jZ!}}W}xnQ=)-2|uyfV1RqatQD38w8xki1e#(|gbjk1#Q^_okSO-jXNVPvZE
z=Jv@#UaD<=DFq>vgM)rD7F@<}uOtqi-^M|DB9Gr4Et0Sj=v3ka4of*_0-K_9t-aWw
zk+ng0r>9pM?yoxT%wEtH*hhScE0c@j!hP0CyRJqM0d61`p-E7*LDNv_UzVcMT&^U5
z^$oVipO{}W-nWYROQ}Aj(4a8@`$-iqwdhDGRe;QQ=#1La0t4_V>4OYa^m+0IZh#Ec
z^d%sb3`HCcok@E#u$j1xzk@W`b+GnSpc1QeXf}g!q{vtluc-iX$Ro&vU2YTzs3B~=
zLzBuEQdz;K&a+*C4aE1j6bjN?CFTf<z}`WX$-3geHUdSJVs1R0Ph7@ZAX^;0mPkRZ
zwE`Yhjt!ySy^ZX_mHq-`u|p#Ub4VDn#nSPF5%)nh5v?G8i?$oNadbMd7PZ2b2#ST2
zRBJYZDP$qSSKjs~5`RK9wX$+`4S5q6isAKiE+IxW7cG$#jAT26IRn}Zj@I1}@TE_D
zkTx;3HMgHIXHQovYh<OCdLRW@L!3pAAz6B*QNROpiD&o{WU;+P0>^nI%xxyI341yM
z*;UCp-9R$9n(W42a;T*8(-s5y5H~Y-@j{mOK@Bm4&N0F<!cFE#b1QR`>qxe}C|Ulk
zx{<{2Oy(kKMwgxgTi&JqPLOyK;;PnNv@E4|5(KJ1!mD(UWjXaX;xK*$S?J)3J*U-r
z^3k5$>tJk~nRM=nCKRXuX)*XEDm@SK#`vIt)8le53;2L=qX!UQ)f};>jJ+9@12F`J
z&W1QKER%W}xRH2-U&0C<*CEdOq8jxI{$;Wrufdj}2O*A#^C9(jU=NXmE=O!t%=VT1
zW*`mNOyr{1A$d#@tX|HqAochUnACoXY}CfAEci690N9WhP2Ru+=tTr{IE*}p1M=&$
zl6@juE&GI4%wNVg02|52*mr1V>4e{ryD~4Q9AR{|{o{hZ6GwT?9l>X`Y5Wy@m^_a^
zMXuXJBrK5)W}lR8<p0%t2}lMKiSN*VAca*W$wdh|3IAOXASzHjlIgf*?9|(81yP`c
zn8NQP^X<2wkZNhNXaiiUJtt@ZHjr1bw;YhsP;G;?#g_8`Kz@(Ch8{6yRdegK-&z`h
z1oAQi<q|39l;whG!u+a9md+0cw-Q(JQf$y673<De+5k16AU?<2utR9JF-Y%{aueif
z=C{FgVmmqliA0`_<`rNjgX6<ksAC~y+u%tC_mYnUUBl<@bCTg0PpbK^U>ebi_Aw|{
ziQx^NL{JSRF(Bqa+&E7<m`G}|BMzTLUTT5K%Q%IU7&tYSH>oWIhCjj<J6KY9z3@X&
zO!i=qqeu+LD=*4Q)K|$;d_FSb5Q*hw>T0qLZ$Mmz7P04qx{mC?UqTkzxe{fZ^=_6;
zq}K8C6LsCDhO`lSklW%u+4%ys!&?8I+e&uhpJDBe*^qZV%V-JbUm-2{3C!=9BN3ip
zr&3$U^H>*}fv^mPQsFo3MCudZV<HnxMAGbYq(ZHriu?+Hj2Y~iM%{W&Dzy{XNi^eE
zuwi?l)Ovy~r#=GyM#Q3DA#ha)k+asf($dD~>s2FX<o|jV0Xy<Mcq7)0<Cq$KjZwl-
zXiim@m=$Nc$UZG-19p*TutjJl#C$NZOSMvPBRPd-p!1<Z!?3g{hFilvE8E2Xi@ApU
z34e&KvBw&t4I+qrN?<1M;C8GY-HHs_vm_j?0AloR6#E@I#E9KuV~AcV5hdu-`0s!+
z;v_0Yk{rWQQLKC;pATjbNAa~ts3S;f+aOQnhkz+W4|)qKS}#uocLI4tKmIMFblJut
zkz5RZL}J)9+JwAhA29}1!xv?zWpZ-_s35+<^ANe(mmO{N(US$*(f;0cC+#}^p{RQ|
zn%9--rVsccc24zXE06E1`8j4P-PXd%OKxcI&aW{MMlxY=A%D=-r8uS|wXPgbx;|^h
zSk%;^dBW#$wreb|#OS%%{HtJIZ#>MVg>`wY8Lbv}=H9b`yQ{e>op<^xUb@DImszX!
z^uHIvT{V4r{-47q73n>nU8VJ_EYm>e=kx!}6%bYPi`Dx#`EGH#)?Wn;(`ikuelkc6
z7W5^wShMy&QueYRSx0_!4hb8}ra9l_2!a@6Gg&VC^wn=hws+AtwE8D?9ZMaYFgT1#
z3mMOt7P?afp0X?cAy2(wh(0jZo)&=10&Q_tFT2`9bUUX&Rk^xD`Qwl@zW4f&^=@0R
zPTT13^W?U-S2uRM!s_$D=#TpsQZq+WX;McA8-&=8&SxXN&8-TN&y&$Ltr_}OmrIXD
zQT1m7f-Y+4%TwJE;J!@Vy6%<{yx{$-KS#p}nz5Hfe;Dg0o25mx>6UslBri*LN_`ms
zNfgU=&=N2m$Y%6aCt-MEVR&LQhF8&MAd?)z%ItlRGNA?8J5;;}#?l;SNEz!*0vUZv
zZ(i)a-<QpMvMz_W^R{ZjZ{-DYybDXIgR0ki=#Zki=I3YqR8r=n3uu~K>Z85x2~B6n
z<oGn_nRS5dyL4gNugr{$lvyd|h+vy<+il?B(<H;n7LCyVw9a24pPC7OVa48X+7w>o
zn+Xh-fy$|o^yd0i^g$80c$hZ*?9+J2zMp)Wg=#wJmj?Kkt9zBQuoc3-rs>^!aK}AE
z4|&%GW<RdYu&x`Kkon*WO(l`vIeUT0#(UwH2Y+4tT7h3H@NZaweGuce9A_G?`xIeU
z;mV#*L{@9tThxKC1t?46i`Ue&g;Ecg_A57y>jE*vXZR>~0If96(F;@g5mYv^#%`5?
zTgXggjiXb{IW4FFHj!1>1GI=~!1Oxe2L2=RU!n&PN1j3ot8F#xvVaNOje6<?Q4|ju
zbXe2)i~bJ-2h)e;7iDJxJBSOo%NS&^%FJ(5$1sQ8Q!C(8CQOeCVOeotFJtblHG;)d
z36f>7CYhrsH})sgD~97}G2_y#bpkFG&e(eoED%yHNKlp6Xjw+7kRUy6Vf?)?Sza1g
zO>9Lu61g_;zl$1*mtOogz}6E_+JDB|yk1q;Y=xmIYyqJeBnOUlpy)zlNwu<8Ry?o~
z+y-PaQLfBrOYm$qM}e`#*SLwvaV=t9nZ-<A-6LgUTre_h2p7vwSQ^OhaW_+0??p=l
zs3i2L-^h*i$iaN_0Jhl9lE4YdI?G?FT|_DV79!PiOiYB^MD*gtSRUF5F}66-ETEE!
zCN#?k#|qOx5J)5DqQgeU_--^WqCO%z@K_{VFTZG6<$j#xTmAndIjsoV4~0lu42EP?
zRZ;EuDQ&7doNsCi<(u2&z`8sdzm3g8Q;^w?T!x56b?kG3>Qz=DKkL+zH%7bsbc)+g
z=auYKF8oGuy}n5iv5emWd;-Xb)#xBps2A0;wOTp<P4ju+V<3a5!7pG39Y-M6dhSJb
zxxmDb6UWv#Vxi9J5^+(iE(P32)?!c51}LPeL@J7dYqY0jDg0Gn4sjaKN205xVo|(K
z&R+tqCUE=^5^4_;+v4P#`HR8r#5sH`5^dnZf_K5SL_LZixelqs77Je#2tYCM6$(Ma
z2A6~z14FVimTDjo0Evfq6B288iFL&m3yI@%kyuB#gd3}@5rmrS$yz*~A*HfTrnTsS
zwWJgK7VR_I;yp4@)&>D$@;El(C^K?nJSkuXIgTB%`;z77EG?uR2ayuJ7q&!EA28v6
z4kR^%OXX+PSAcl(BnH`wB=T}~Eua8mi8g!?aaHMRWIDBx?8QS7mtJSG2+St(FrJHq
zSIcV#PN?e{N2nJR$bA1wPMow4?lI=BA<a*B%5&N)PY&-RuI^51(-7t8EJS6PBk`PK
zCxc307XhM+5TAintA2yuNPdT}M#>!5jhqA)tbUt+f$YI=V4e0#V@nmQP8|it5cAO<
zM5OOb7M>C`lK1g@m;&96*!0ZyMSKhS5Bv+P#6BOAuNPtNug8b?A!F!!NHF>q<gYR?
z;w^&4<3#Xyi8j$K<Tn5x021OFehyoWRzh<OMHkuM2%5=jct2Kw<|7P_V0N*f9@qz{
znW@p|*h%ydqufV~tORbI;B9jiu!n5KmZJ`c70)%X%VZM%Qg9pb0BtaK8f<mi6EYcp
zx%mR{A+VMB8E-|B?89QtS(%t02C9ih{I|@QC`e+9ktg#*!QDhHu19k1C1Osw<tljw
z{}a+#EtT5h<tcowxtg59#YjjsT&LB^(#&s|>wpZh6kCfD$Potvmi2NeHKb~B`e%iW
z(qq1;?JvDpz)S>HV|1U4QWtF3)<F*x<}}*5fAb|x+w_9(Ea;=BpHudQ7H3r3{bw6r
zyK}Q$s}y22+f?Nf8-0HV#-c1ep=x)(bLyfuU*X>)MPIXGnWm?l{*3*;p@QJNyO*2~
z#-s-K-P|;i?P}}4v{_!Xygg2XoiAy(`DT77ud^1Ae#z^qn?J@T2!_7+$1yNXdiQnV
zf0TIOR(Vv$(}zi-$PBczFl_Qx)quq@W9sb(sh6x4v%=8l2^CC)D_9dA;^UELoZhY(
z)_PmEz!vpULEmwo_rzvVb|8B4{X?oSCco9>n@~^WZq_Xtbv~OO_`%JkkMoz%teqbB
zGmRT}Z6!h9GOAA1+~I8>!9&%tORYQX?4`8cIW~n?xjg}GpF2#SXQ}(jG{SpxaNzN9
z)?Ly?&v+xKL{W3G+|}HrC}^YSWp~qy;hA%O<uF>*h5NP(WbEDc*9<J>sN=@;-g0%(
zp^}-$2nzEbepS)@*`;tV?Qv2w)-0W;KVqh8<s*hZwG4gQ82VVn@{)m65F`!%npnZi
z#Hs<Ci)!G3GwN2d8lS|<917yf!~Z@}QNLII+<d)bzw5()gYNk2FZ^18|FHt<`;^?e
N<Z{k)&%N>7KLJX2H(US!

literal 0
HcmV?d00001

diff --git a/tests/f_extent_int_bad_extent/name b/tests/f_extent_int_bad_extent/name
new file mode 100644
index 0000000..e22f6b4
--- /dev/null
+++ b/tests/f_extent_int_bad_extent/name
@@ -0,0 +1 @@
+bad extent in internal extent (metadata_csum)
diff --git a/tests/f_extent_int_bad_magic/expect.1 b/tests/f_extent_int_bad_magic/expect.1
new file mode 100644
index 0000000..0e82e2b
--- /dev/null
+++ b/tests/f_extent_int_bad_magic/expect.1
@@ -0,0 +1,23 @@
+Pass 1: Checking inodes, blocks, and sizes
+Inode 12 has an invalid extent node (blk 1295, lblk 0)
+Clear? yes
+
+Inode 12, i_blocks is 712, should be 0.  Fix? yes
+
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+Block bitmap differences:  -(1090--1093) -1095 -1097 -1099 -1101 -1103 -1105 -1107 -1109 -1111 -1113 -1115 -1117 -1119 -1121 -1123 -1125 -1127 -1129 -1131 -1133 -1135 -1137 -1139 -1141 -1143 -1145 -1147 -1149 -1151 -1153 -1155 -1157 -1159 -1161 -1163 -1165 -1167 -1169 -1171 -1173 -1175 -1177 -1179 -1181 -1183 -1185 -1187 -1189 -1191 -1193 -1195 -1197 -1199 -1201 -1203 -1205 -1207 -1209 -1211 -1213 -1215 -1217 -1219 -1221 -1223 -1225 -1227 -1229 -1231 -1233 -1235 -1237 -1239 -1241 -1243 -1245 -1247 -1249 -1251 -1253 -1255 -1257 -1259 -1261 -1263 -1265 -1267 -1269 -1271 -1273 -1275 -1277 -1279 -1281 -1283 -1285 -1287 -(1289--1298) -1300 -1302 -1304 -1306 -1308 -1310 -1312 -1314 -1316 -1318 -1320 -1322 -1324 -1326 -1328 -1330 -1332 -1334 -1336 -1338 -1340 -1342 -1344 -1346 -1348 -1350 -1352 
 -1354 -1356 -1358 -1360 -1362 -1364 -1366 -1368 -1370 -1372 -1374 -1376 -1378 -1380 -1382 -1384 -1386 -1388 -1390 -1392 -1394 -1396 -1398 -1400 -1402 -1404 -1406 -1408 -1410 -1412 -1414 -14!
 16 -1418 -1420 -1422 -1424 -1426 -1428 -1430 -1432 -1434 -1436 -1438 -1440 -1442 -1444 -1446 -1448 -1450 -1452 -1454 -1456 -1458 -1460 -1462 -1464 -1466 -1468 -1470 -1472 -1474 -1476 -1478 -1480 -1482 -1484 -1486 -1488 -1490 -1492 -1494 -1496 -1498 -1500 -1502 -1504 -1506 -1508 -1510 -1512 -1514 -1516 -1518 -1520 -1522 -1524 -1526 -1528 -1530 -1532 -1534 -1536 -1538 -1540 -1542 -1544 -1546 -1548 -1550 -1552 -1554 -1556 -1558 -1560 -1562 -1564 -1566 -1568 -1570 -1572 -1574 -1576 -1578 -1580 -1582 -1584 -1586 -1588 -1590 -1592 -1594 -1596 -1598 -1600 -1602 -1604 -1606 -1608 -1610 -1612 -1614 -1616 -1618 -1620 -1622 -1624 -1626 -1628 -1630 -1632 -1634 -1636 -1638 -1640 -1642 -1644 -1646 -1648 -1650 -1652 -1654 -1656 -1658 -1660 -1662 -1664 -1666 -1668 -1670 -1672 -1674 -1676 -1678 -1680 -168
 2 -1684 -1686 -1688 -1690 -1692 -1694 -1696 -1698 -1700 -1702 -1704 -1706 -1708 -1710 -1712 -1714 -1716 -1718 -1720 -1722 -1724 -1726 -1728 -1730 -1732 -1734 -1736 -1738 -1740 -1742 -1744 -!
 1746 -1748 -1750 -1752 -1754 -1756 -1758 -1760 -1762 -1764 -17!
 66 -1768 -1770 -1772 -1774 -1776 -1778 -1780 -1782 -1784 -1786 -1788
+Fix? yes
+
+Free blocks count wrong for group #0 (602, counted=958).
+Fix? yes
+
+Free blocks count wrong (602, counted=958).
+Fix? yes
+
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 12/128 files (8.3% non-contiguous), 1090/2048 blocks
+Exit status is 1
diff --git a/tests/f_extent_int_bad_magic/expect.2 b/tests/f_extent_int_bad_magic/expect.2
new file mode 100644
index 0000000..283cc1f
--- /dev/null
+++ b/tests/f_extent_int_bad_magic/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 12/128 files (8.3% non-contiguous), 1090/2048 blocks
+Exit status is 0
diff --git a/tests/f_extent_int_bad_magic/image.gz b/tests/f_extent_int_bad_magic/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..e00f887cca9e8d6b139083ac51c54b46f0e30fd8
GIT binary patch
literal 7205
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
YUl8~o5qNneXy0G`M#?L%y!Xm~02`7oGynhq

literal 0
HcmV?d00001

diff --git a/tests/f_extent_int_bad_magic/name b/tests/f_extent_int_bad_magic/name
new file mode 100644
index 0000000..a451e9a
--- /dev/null
+++ b/tests/f_extent_int_bad_magic/name
@@ -0,0 +1 @@
+bad magic number in internal extent (metadata_csum)
diff --git a/tests/f_extent_leaf_bad_csum/expect.1 b/tests/f_extent_leaf_bad_csum/expect.1
new file mode 100644
index 0000000..0dc78ad
--- /dev/null
+++ b/tests/f_extent_leaf_bad_csum/expect.1
@@ -0,0 +1,11 @@
+Pass 1: Checking inodes, blocks, and sizes
+Inode 12 extent block passes checks, but checksum does not match extent
+	(logical block 7, invalid physical block 1090, len 1)
+Fix? yes
+
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 12/128 files (16.7% non-contiguous), 1099/2048 blocks
+Exit status is 0
diff --git a/tests/f_extent_leaf_bad_csum/expect.2 b/tests/f_extent_leaf_bad_csum/expect.2
new file mode 100644
index 0000000..a564763
--- /dev/null
+++ b/tests/f_extent_leaf_bad_csum/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 12/128 files (16.7% non-contiguous), 1099/2048 blocks
+Exit status is 0
diff --git a/tests/f_extent_leaf_bad_csum/image.gz b/tests/f_extent_leaf_bad_csum/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..6c778f699725e9db8d94c9c464f3a687a714d757
GIT binary patch
literal 5005
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

literal 0
HcmV?d00001

diff --git a/tests/f_extent_leaf_bad_csum/name b/tests/f_extent_leaf_bad_csum/name
new file mode 100644
index 0000000..62a2285
--- /dev/null
+++ b/tests/f_extent_leaf_bad_csum/name
@@ -0,0 +1 @@
+bad csum in leaf extent (metadata_csum)
diff --git a/tests/f_extent_leaf_bad_extent/expect.1 b/tests/f_extent_leaf_bad_extent/expect.1
new file mode 100644
index 0000000..f96a8a9
--- /dev/null
+++ b/tests/f_extent_leaf_bad_extent/expect.1
@@ -0,0 +1,24 @@
+Pass 1: Checking inodes, blocks, and sizes
+Inode 12 has an invalid extent
+	(logical block 2, invalid physical block 4294967295, len 1)
+Clear? yes
+
+Inode 12, i_blocks is 18, should be 16.  Fix? yes
+
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+Block bitmap differences:  -1096
+Fix? yes
+
+Free blocks count wrong for group #0 (949, counted=950).
+Fix? yes
+
+Free blocks count wrong (949, counted=950).
+Fix? yes
+
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 12/128 files (16.7% non-contiguous), 1098/2048 blocks
+Exit status is 1
diff --git a/tests/f_extent_leaf_bad_extent/expect.2 b/tests/f_extent_leaf_bad_extent/expect.2
new file mode 100644
index 0000000..de1727c
--- /dev/null
+++ b/tests/f_extent_leaf_bad_extent/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 12/128 files (16.7% non-contiguous), 1098/2048 blocks
+Exit status is 0
diff --git a/tests/f_extent_leaf_bad_extent/image.gz b/tests/f_extent_leaf_bad_extent/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..d34d4d4d51d24e4de54f6b38beedc831d8c2d266
GIT binary patch
literal 5008
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
AwEzGB

literal 0
HcmV?d00001

diff --git a/tests/f_extent_leaf_bad_extent/name b/tests/f_extent_leaf_bad_extent/name
new file mode 100644
index 0000000..1bd8bd1
--- /dev/null
+++ b/tests/f_extent_leaf_bad_extent/name
@@ -0,0 +1 @@
+bad extent in leaf extent (metadata_csum)
diff --git a/tests/f_extent_leaf_bad_magic/expect.1 b/tests/f_extent_leaf_bad_magic/expect.1
new file mode 100644
index 0000000..7b6dbf1
--- /dev/null
+++ b/tests/f_extent_leaf_bad_magic/expect.1
@@ -0,0 +1,23 @@
+Pass 1: Checking inodes, blocks, and sizes
+Inode 12 has an invalid extent node (blk 1604, lblk 0)
+Clear? yes
+
+Inode 12, i_blocks is 18, should be 0.  Fix? yes
+
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+Block bitmap differences:  -(1090--1097) -1604
+Fix? yes
+
+Free blocks count wrong for group #0 (949, counted=958).
+Fix? yes
+
+Free blocks count wrong (949, counted=958).
+Fix? yes
+
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 12/128 files (8.3% non-contiguous), 1090/2048 blocks
+Exit status is 1
diff --git a/tests/f_extent_leaf_bad_magic/expect.2 b/tests/f_extent_leaf_bad_magic/expect.2
new file mode 100644
index 0000000..283cc1f
--- /dev/null
+++ b/tests/f_extent_leaf_bad_magic/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 12/128 files (8.3% non-contiguous), 1090/2048 blocks
+Exit status is 0
diff --git a/tests/f_extent_leaf_bad_magic/image.gz b/tests/f_extent_leaf_bad_magic/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..7dd044ffc430e1e7f3750fa628984e750ede9006
GIT binary patch
literal 5008
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

literal 0
HcmV?d00001

diff --git a/tests/f_extent_leaf_bad_magic/name b/tests/f_extent_leaf_bad_magic/name
new file mode 100644
index 0000000..e9f756e
--- /dev/null
+++ b/tests/f_extent_leaf_bad_magic/name
@@ -0,0 +1 @@
+bad magic number in leaf extent (metadata_csum)

[PATCH 15/19] tests: add tests for directory entry blocks with checksum errors

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Add some regression tests to examine how e2fsck handles directory
entry blocks and htree blocks with (a) malformed directory entries;
(b) incorrect checksums; or (c) obviously garbage entries.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 tests/f_dir_bad_csum/expect.1   |   62 +++++++++++++++++++++++++++++++++++++++
 tests/f_dir_bad_csum/expect.2   |    7 ++++
 tests/f_dir_bad_csum/image.gz   |  Bin
 tests/f_dir_bad_csum/name       |    1 +
 tests/f_htree_bad_csum/expect.1 |   28 ++++++++++++++++++
 tests/f_htree_bad_csum/expect.2 |    7 ++++
 tests/f_htree_bad_csum/image.gz |  Bin
 tests/f_htree_bad_csum/name     |    1 +
 8 files changed, 106 insertions(+)
 create mode 100644 tests/f_dir_bad_csum/expect.1
 create mode 100644 tests/f_dir_bad_csum/expect.2
 create mode 100644 tests/f_dir_bad_csum/image.gz
 create mode 100644 tests/f_dir_bad_csum/name
 create mode 100644 tests/f_htree_bad_csum/expect.1
 create mode 100644 tests/f_htree_bad_csum/expect.2
 create mode 100644 tests/f_htree_bad_csum/image.gz
 create mode 100644 tests/f_htree_bad_csum/name

diff --git a/tests/f_dir_bad_csum/expect.1 b/tests/f_dir_bad_csum/expect.1
new file mode 100644
index 0000000..bbcbfcb
--- /dev/null
+++ b/tests/f_dir_bad_csum/expect.1
@@ -0,0 +1,62 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Directory inode 12, block #0, offset 12: directory passes checks but fails checksum.
+Fix? yes
+
+Directory inode 13, block #0, offset 0: directory has no checksum.
+Fix? yes
+
+Directory inode 13, block #0, offset 1012: directory passes checks but fails checksum.
+Fix? yes
+
+Directory inode 14, block #0, offset 0: directory has no checksum.
+Fix? yes
+
+Directory inode 14, block #0, offset 12: directory passes checks but fails checksum.
+Fix? yes
+
+Directory inode 15, block #0, offset 0: directory has no checksum.
+Fix? yes
+
+Directory inode 15, block #0, offset 1000: directory corrupted
+Salvage? yes
+
+Directory inode 16, block #0, offset 0: directory has no checksum.
+Fix? yes
+
+Directory inode 16, block #0, offset 12: directory corrupted
+Salvage? yes
+
+Directory inode 17, block #0, offset 0: directory has no checksum.
+Fix? yes
+
+Directory inode 17, block #0, offset 0: directory corrupted
+Salvage? yes
+
+Missing '.' in directory inode 17.
+Fix? yes
+
+Setting filetype for entry '.' in ??? (17) to 2.
+Missing '..' in directory inode 17.
+Fix? yes
+
+Setting filetype for entry '..' in ??? (17) to 2.
+Entry 'file' in ??? (18) has invalid inode #: 4294967295.
+Clear? yes
+
+Pass 3: Checking directory connectivity
+'..' in /6 (17) is <The NULL inode> (0), should be / (2).
+Fix? yes
+
+Pass 3A: Optimizing directories
+Pass 4: Checking reference counts
+Unattached inode 19
+Connect to /lost+found? yes
+
+Inode 19 ref count is 2, should be 1.  Fix? yes
+
+Pass 5: Checking group summary information
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 19/128 files (5.3% non-contiguous), 1098/2048 blocks
+Exit status is 1
diff --git a/tests/f_dir_bad_csum/expect.2 b/tests/f_dir_bad_csum/expect.2
new file mode 100644
index 0000000..f5a3e5f
--- /dev/null
+++ b/tests/f_dir_bad_csum/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 19/128 files (5.3% non-contiguous), 1098/2048 blocks
+Exit status is 0
diff --git a/tests/f_dir_bad_csum/image.gz b/tests/f_dir_bad_csum/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..4b581876f07c1ec989ef85977dc53741b6356130
GIT binary patch
literal 3499
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

literal 0
HcmV?d00001

diff --git a/tests/f_dir_bad_csum/name b/tests/f_dir_bad_csum/name
new file mode 100644
index 0000000..140ae45
--- /dev/null
+++ b/tests/f_dir_bad_csum/name
@@ -0,0 +1 @@
+dir block w/ missing/bad csum, no tail, or dir block corruption (metadata_csum)
diff --git a/tests/f_htree_bad_csum/expect.1 b/tests/f_htree_bad_csum/expect.1
new file mode 100644
index 0000000..258362b
--- /dev/null
+++ b/tests/f_htree_bad_csum/expect.1
@@ -0,0 +1,28 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Problem in HTREE directory inode 12: root node fails checksum.
+Clear HTree index? yes
+
+Problem in HTREE directory inode 18: root node fails checksum.
+Clear HTree index? yes
+
+Directory inode 24, block #0, offset 1020: directory corrupted
+Salvage? yes
+
+Problem in HTREE directory inode 24: root node fails checksum.
+Clear HTree index? yes
+
+Problem in HTREE directory inode 30: root node fails checksum.
+Clear HTree index? yes
+
+Problem in HTREE directory inode 36: root node fails checksum.
+Clear HTree index? yes
+
+Pass 3: Checking directory connectivity
+Pass 3A: Optimizing directories
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 47/128 files (2.1% non-contiguous), 1108/2048 blocks
+Exit status is 1
diff --git a/tests/f_htree_bad_csum/expect.2 b/tests/f_htree_bad_csum/expect.2
new file mode 100644
index 0000000..7e3523b
--- /dev/null
+++ b/tests/f_htree_bad_csum/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 47/128 files (2.1% non-contiguous), 1108/2048 blocks
+Exit status is 0
diff --git a/tests/f_htree_bad_csum/image.gz b/tests/f_htree_bad_csum/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..def571c7900f39bf236a52f0086fccb54049c8c2
GIT binary patch
literal 5462
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

literal 0
HcmV?d00001

diff --git a/tests/f_htree_bad_csum/name b/tests/f_htree_bad_csum/name
new file mode 100644
index 0000000..ebfc3ea
--- /dev/null
+++ b/tests/f_htree_bad_csum/name
@@ -0,0 +1 @@
+htree block w/ missing/bad csum, bad protective dirent, or htree index corruption (metadata_csum)

[PATCH 16/19] tests: add regression tests for MMP blocks with bad checksums

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Add regression tests to examine how e2fsck deals with MMP blocks with
(a) a bad magic number; and (b) an incorrect checksum.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 e2fsck/unix.c                  |    4 +++-
 tests/m_mmp_bad_csum/expect    |    9 +++++++++
 tests/m_mmp_bad_csum/image.gz  |  Bin
 tests/m_mmp_bad_csum/name      |    1 +
 tests/m_mmp_bad_csum/script    |   30 ++++++++++++++++++++++++++++++
 tests/m_mmp_bad_magic/.log     |    9 +++++++++
 tests/m_mmp_bad_magic/expect   |    9 +++++++++
 tests/m_mmp_bad_magic/image.gz |  Bin
 tests/m_mmp_bad_magic/name     |    1 +
 tests/m_mmp_bad_magic/script   |   30 ++++++++++++++++++++++++++++++
 10 files changed, 92 insertions(+), 1 deletion(-)
 create mode 100644 tests/m_mmp_bad_csum/expect
 create mode 100644 tests/m_mmp_bad_csum/image.gz
 create mode 100644 tests/m_mmp_bad_csum/name
 create mode 100644 tests/m_mmp_bad_csum/script
 create mode 100644 tests/m_mmp_bad_magic/.log
 create mode 100644 tests/m_mmp_bad_magic/expect
 create mode 100644 tests/m_mmp_bad_magic/image.gz
 create mode 100644 tests/m_mmp_bad_magic/name
 create mode 100644 tests/m_mmp_bad_magic/script

diff --git a/e2fsck/unix.c b/e2fsck/unix.c
index d883c9e..f71afbc 100644
--- a/e2fsck/unix.c
+++ b/e2fsck/unix.c
@@ -1166,7 +1166,9 @@ check_error:
 			ext2fs_mmp_clear(fs);
 			retval = 0;
 		}
-	}
+	} else
+		com_err(ctx->program_name, retval, "%s",
+			_("while reading MMP block"));
 	return retval;
 }
 
diff --git a/tests/m_mmp_bad_csum/expect b/tests/m_mmp_bad_csum/expect
new file mode 100644
index 0000000..e15e7b4
--- /dev/null
+++ b/tests/m_mmp_bad_csum/expect
@@ -0,0 +1,9 @@
+Superblock MMP block checksum does not match MMP block.  Fix? yes
+
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 11/128 files (0.0% non-contiguous), 19/512 blocks
+Exit status is 0
diff --git a/tests/m_mmp_bad_csum/image.gz b/tests/m_mmp_bad_csum/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..c896ff60dbbdf68a566007262c54a99b0b912fde
GIT binary patch
literal 2594
zcmb2|=3qEtbUm1f`R!fX4B<cqh6m->JGQP}+o9CR^Xh@pHia(x6(L^Y2jyR^P-qG}
z5_V9{qj05&pdgo(hLr|~)((rV2LY_%?Bb#>EaHJ(&UclLo$e2E(#}}Ab?1BT_j~tD
z-~Hs??%l_$rz>+ZdaRyUB+@>?cT%TDi_==0b*-nEl(#+=S}Yy^wKYKNYi*~~7wve_
ztCy}trDadD$>w^PqSkWq{89d$%lD?|&A+?z_0y{dXa7ug{(1PXI$IwvFaO!l*zJ4j
zw<uL7`hUCj@1cM4^|F{Ar}B*M<=0-{Kc(8AHCu=4Z15>#&xcm+a-ZK6?pfuo&EW8B
zO8frPlQ(QL`lqk*(`RYT=a27`TLWrrFISZp>&s=>GB7YiNO*Z0J&eArbB!Iy`&a$+
z{r}reBIRwb_A=xu_E}r6{{CU#+l)?jKmMoJzt7j3WA!SE6R1$fBv)~db<N^h-|V}8
z{wKSa{^JLVnjHJHzheE5J%9dWw|@ij8{FppUoW$>=I$SPAn(k7Mxaou{eSxn<@p{?
zFQ5O9=YMuS=f<{|@9%HV{t&Y7^@%g<^)G$-5U=t7-|{e^4kEyUiBrU`KLr`w_Lz%<
z2o1QD)F+iZUcGOA;yOFy>hyoFZ8utXPV)`_zwAPc=jy`KDI!L}*SfX5&zxJ{uK488
zho!&%PMDVb?&0Z@`Nex%ORn!Pt>5+fzuK(-xe}K1T^`@P{G~o{?ep13|E)cJJ^cHF
zl%4;pi|p6_y??3prQN^kPcPT~pZfOme%{AVKl*<!c|6}@&A+oh)PuP<7rqPl`6vJX
qjBB4kAvOv|Ltr!nMnhmU1V%$(Gz4f70uA-=*?&|mS7u;PU;qF)f;ad8

literal 0
HcmV?d00001

diff --git a/tests/m_mmp_bad_csum/name b/tests/m_mmp_bad_csum/name
new file mode 100644
index 0000000..61c31d4
--- /dev/null
+++ b/tests/m_mmp_bad_csum/name
@@ -0,0 +1 @@
+mmp with bad csum (metadata_csum)
diff --git a/tests/m_mmp_bad_csum/script b/tests/m_mmp_bad_csum/script
new file mode 100644
index 0000000..d101294
--- /dev/null
+++ b/tests/m_mmp_bad_csum/script
@@ -0,0 +1,30 @@
+# use current directory instead of /tmp becase tmpfs doesn't support DIO
+rm -f $TMPFILE
+TMPFILE=$(mktemp ./tmp-$test_name.XXXXXX)
+
+stat -f $TMPFILE | grep -q "Type: tmpfs"
+if [ $? = 0 ]; then
+	rm -f $TMPFILE
+	echo "$test_name: $test_description: skipped for tmpfs (no O_DIRECT)"
+	return 0
+fi
+gzip -dc < $test_dir/image.gz > $TMPFILE
+
+OUT=$test_dir.log
+EXP=$test_dir/expect
+$FSCK -fy $TMPFILE 2>&1 | sed -f $cmd_dir/filter.sed > $OUT
+echo Exit status is $? >> $OUT
+
+rm -f $TMPFILE
+cmp -s $OUT $EXP
+status=$?
+
+if [ "$status" = 0 ] ; then
+	echo "$test_name: $test_description: ok"
+	touch $test_name.ok
+else
+	echo "$test_name: $test_description: failed"
+	diff $DIFF_OPTS $EXP $OUT > $test_name.failed
+	rm -f $test_name.tmp
+fi
+unset OUT EXP
diff --git a/tests/m_mmp_bad_magic/.log b/tests/m_mmp_bad_magic/.log
new file mode 100644
index 0000000..b5dfb89
--- /dev/null
+++ b/tests/m_mmp_bad_magic/.log
@@ -0,0 +1,9 @@
+Superblock has invalid MMP magic.  Fix? yes
+
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 11/128 files (0.0% non-contiguous), 19/512 blocks
+Exit status is 0
diff --git a/tests/m_mmp_bad_magic/expect b/tests/m_mmp_bad_magic/expect
new file mode 100644
index 0000000..b5dfb89
--- /dev/null
+++ b/tests/m_mmp_bad_magic/expect
@@ -0,0 +1,9 @@
+Superblock has invalid MMP magic.  Fix? yes
+
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 11/128 files (0.0% non-contiguous), 19/512 blocks
+Exit status is 0
diff --git a/tests/m_mmp_bad_magic/image.gz b/tests/m_mmp_bad_magic/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..2d57fbf5fa2ee4939a41f00ea1d3d0b096346d3e
GIT binary patch
literal 2597
zcmb2|=3rQDbUm1f`R!d_50O9yh6m=4+m<a8bmfp+<vjg_Ls#7jgCpJvta98cFWNOk
zi>6P|YjbfCxVmtKvtxjxtd-k^g-z>Z_k;)tmP~ZAx{<p$_uKLbN1K9-%J=10zJFV7
zz1jNx*)xy#-b^%SQCREN9Vp`zJ;}#S@rl;cLe(i^5^Hs)OT4bRD(<xK!gouqi|1=1
zLp*0|&D8b$v`4Sy@l1hbc2DiM*uS={e0`;F?&EN_ycB-^^xyq5)`b-nDL>+`mVW;2
ze){&gcX_*amOpuXboK4?t_!tIj$eLly8YH<_np3Ct!<f4XD%sN>)c=Y%_8pRT2Tgt
z+OEU*Q#~VsrT#ykRI@B(-^&-<yLV2g|GWC@yDj_otpCcuz>turp>wWfed*>1c_8n{
zd(r*>^Z5er2%h@RWYTW&?uEwv!@sv}HMBD{nG;){qG4WfVyh5PVMN9(=Zfp~ds9n;
zul}iDwAJQ6J5V$$`QQBgv+DzE{w)oy2J#)&p8Fr(6SpJnA3u=y>_3n=aA^L2@p|Th
z`275b$N$Ikr}(eCzw6`s`{joZB$ORK7{7m?$K}KIi9eVAVvk}3swWH@qJmbeKgA4G
zXnI^!fUtU;D*hdbc)og{{KNR#wA*iguK)gIol2Bd@ZZ-?&YHT%dxHZ{_(bb#=^9$g
z%eP&Sb2}IQzI}^KG5_()wdcM*xfJ_<+1{7y{?E?%w>|NTkC5%#SquMnYuVn{`IaBL
zZ`ZEh%e(&GpIn{!_W!gup5H&-pX*!xS3iID|J;fwng1ncP5yNrUUk2x-e{_U^m2ZY
s^Z%!HZkY!Pu2C==0;3@?8UmvsFd71*AwZK5IJ5Wt>VIch85k5800I{>HUIzs

literal 0
HcmV?d00001

diff --git a/tests/m_mmp_bad_magic/name b/tests/m_mmp_bad_magic/name
new file mode 100644
index 0000000..15a2d4d
--- /dev/null
+++ b/tests/m_mmp_bad_magic/name
@@ -0,0 +1 @@
+mmp with bad magic (metadata_csum)
diff --git a/tests/m_mmp_bad_magic/script b/tests/m_mmp_bad_magic/script
new file mode 100644
index 0000000..d101294
--- /dev/null
+++ b/tests/m_mmp_bad_magic/script
@@ -0,0 +1,30 @@
+# use current directory instead of /tmp becase tmpfs doesn't support DIO
+rm -f $TMPFILE
+TMPFILE=$(mktemp ./tmp-$test_name.XXXXXX)
+
+stat -f $TMPFILE | grep -q "Type: tmpfs"
+if [ $? = 0 ]; then
+	rm -f $TMPFILE
+	echo "$test_name: $test_description: skipped for tmpfs (no O_DIRECT)"
+	return 0
+fi
+gzip -dc < $test_dir/image.gz > $TMPFILE
+
+OUT=$test_dir.log
+EXP=$test_dir/expect
+$FSCK -fy $TMPFILE 2>&1 | sed -f $cmd_dir/filter.sed > $OUT
+echo Exit status is $? >> $OUT
+
+rm -f $TMPFILE
+cmp -s $OUT $EXP
+status=$?
+
+if [ "$status" = 0 ] ; then
+	echo "$test_name: $test_description: ok"
+	touch $test_name.ok
+else
+	echo "$test_name: $test_description: failed"
+	diff $DIFF_OPTS $EXP $OUT > $test_name.failed
+	rm -f $test_name.tmp
+fi
+unset OUT EXP

[PATCH 17/19] tests: add regression tests for superblocks with bad checksums

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Add regression tests to examine how e2fsck deals with random
superblock corruption such as obviously wrong fields and the checksum
itself being incorrect.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 tests/f_super_bad_csum/expect.1  |   13 +++++++++++++
 tests/f_super_bad_csum/expect.2  |    7 +++++++
 tests/f_super_bad_csum/image.bz2 |  Bin
 tests/f_super_bad_csum/name      |    1 +
 tests/f_super_bad_csum/script    |   33 +++++++++++++++++++++++++++++++++
 5 files changed, 54 insertions(+)
 create mode 100644 tests/f_super_bad_csum/expect.1
 create mode 100644 tests/f_super_bad_csum/expect.2
 create mode 100644 tests/f_super_bad_csum/image.bz2
 create mode 100644 tests/f_super_bad_csum/name
 create mode 100755 tests/f_super_bad_csum/script

diff --git a/tests/f_super_bad_csum/expect.1 b/tests/f_super_bad_csum/expect.1
new file mode 100644
index 0000000..25ced5c
--- /dev/null
+++ b/tests/f_super_bad_csum/expect.1
@@ -0,0 +1,13 @@
+ext2fs_open2: Superblock checksum does not match superblock
+../e2fsck/e2fsck: Superblock invalid, trying backup blocks...
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+Inode bitmap differences: Group 1 inode bitmap does not match checksum.
+FIXED.
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 11/1024 files (0.0% non-contiguous), 1557/16384 blocks
+Exit status is 0
diff --git a/tests/f_super_bad_csum/expect.2 b/tests/f_super_bad_csum/expect.2
new file mode 100644
index 0000000..dd20919
--- /dev/null
+++ b/tests/f_super_bad_csum/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 11/1024 files (0.0% non-contiguous), 1557/16384 blocks
+Exit status is 0
diff --git a/tests/f_super_bad_csum/image.bz2 b/tests/f_super_bad_csum/image.bz2
new file mode 100644
index 0000000000000000000000000000000000000000..cd80d4b837fd0e966595e70d4bb0854b8b63a78b
GIT binary patch
literal 1181
zcmZ>Y%CIzaj8qGbG&$qO$-t0W{~rU~v2+!vn5cJQvuwM{xqY@5Sn7D6eNd27s1g;G
zG&H%mOmO0|9?s6m$^s`+F1}FXIM61nHq$79!N)Db*=JUQ56k8MUtJw~W*SN{Ge}MH
zUBbY?_{xNrts&!t5d$1#fLXjO{$GPu<@&&dQ5jq-m-PobE;zyL?B?UZ);NKe&6h{O
z$b=zLO3LKo0uzP|Heacf%MKUVdKnlvrgRzwA6s!GagoX8REaB<raTTAQj81O8W@1e
zdVEbTNJ&-onk2E!GRffOHL98=w|sKY?nTd2FVB&=G2`3JBcZ7~_09$a9f+MOD#jg>
zZLq%H&hN|D(@j@i_Pq2JoHFIin{Q>N$HFG%*Y97o=tE~h!$lw7XKJ4gtxIW|<8$`;
zo_lp&;d57YXvpWdI7D}>(3<u@X;sJ09|}z3maU<Sw3ds8YrACYc`5Ex%zwIl&YE?f
z9fQ)9#4lWUu_cPrfSXVKEW1+Ub93is2l7kH%B?;WeC&{m>uXU}y3XIf{=~#3;rt&s
z6%x9eCoi5jZHZpel(VL`j*IjC*qIq#zM8da=Lgn^-%+)!1rF<-+72B%b?(x&TlXG4
z`K6L6bT@X{p1u40>l+rc`WOY=h{$Swl=L|Hi4lX>r%hLwjm<6N>e~9I%{uEFn_K9A
zxYIdXX5Fs&g4^tpgTiu>H+FF?V34~gClb-|IABq+P^(-~=TZU5ljjsBcuZjFWEK~m
z(QxF!KD#O|1{EO&P6ig1hGR#bF|aJ?(s{<x0Th4$mIkF>;Tb{-9OnX;{|5?bC>3+6
zr24X~=$_`rx=E|7h1HdT;YGKJEt6StN>gOx8s(6n7t@3^rl)LX;d(GdK`C5N%E95L
ztFW3vD3gN#3j^2RTdbSZ#Qa_@xD^{55vgA|>D8mhuMJOeMmlv)HU7f;F=2D?^j=pt
zRp-NJo@idUJ8RQ5bFL?MkC?M|rLKL&we5}Bab=%tro2C8_v~xFFZ5z|6GPlNrl~Vn
z)~v6Vej}69svYhBDo|gkI)yp+z`}hB+22*gpQ~>6bp9daAr4IQ3$}Z8NN-|Gh~=2>
z^rAEJ_?&h7B_Fq6PP|fDUiC!N>#1hUQO#STO;eU?X=-`}U-Al?az=fJ-~*P2f_Cgv
z7BMg_;M~Bu02mO=msmSQKnxzAkd3aB#GS-8#B!VHvh%S8v8~GW^mJlM6G%#)9L#WZ
z#<mx-DJJh`EIjY>%_GW4RW`-l!r|fMXhRQq^~=sqXEVh`+pH$BdtF#Cqm^BxNhXtF
zD_fhSvtPv(=a~vGd%lXZUc9ii(CLq&31f=J)Lg~ePX8oQO!hnoxMcOIwZNRml1Yq1
z%8awv+Q{aP$*-tHPrg^`GY<W1|J%C3i05McE}b^dhZoiyvtNFsU=910g)Q}}itHCG
z8g4euvfNsj9w}kyqbbnHx#G~y6XCZ~PJe4*X#KH-;q$U@;_Z5YKC`bZuyzg$csS8j
hgn?P_V=I@(%tyK$eZ1yBZN&cn7cX+P2$%pWjsRs0<w^hm

literal 0
HcmV?d00001

diff --git a/tests/f_super_bad_csum/name b/tests/f_super_bad_csum/name
new file mode 100644
index 0000000..745562f
--- /dev/null
+++ b/tests/f_super_bad_csum/name
@@ -0,0 +1 @@
+bad csum in superblock (metadata_csum)
diff --git a/tests/f_super_bad_csum/script b/tests/f_super_bad_csum/script
new file mode 100755
index 0000000..cfd4189
--- /dev/null
+++ b/tests/f_super_bad_csum/script
@@ -0,0 +1,33 @@
+#!/bin/bash
+
+FSCK_OPT=-fy
+IMAGE=$test_dir/image.bz2
+
+bzip2 -d < $IMAGE > $TMPFILE
+#e2label $TMPFILE test_filesys
+
+# Run fsck to fix things?
+EXP1=$test_dir/expect.1
+OUT1=$test_name.1.log
+rm -rf $test_name.failed $test_name.ok
+
+$FSCK $FSCK_OPT $TMPFILE 2>&1 | head -n 1000 | tail -n +2 > $OUT1
+echo "Exit status is $?" >> $OUT1
+
+# Run a second time
+EXP2=$test_dir/expect.2
+OUT2=$test_name.2.log
+
+$FSCK $FSCK_OPT $TMPFILE 2>&1 | head -n 1000 | tail -n +2 > $OUT2
+echo "Exit status is $?" >> $OUT2
+
+# Figure out what happened
+if cmp -s $EXP1 $OUT1 && cmp -s $EXP2 $OUT2; then
+	echo "$test_name: $test_description: ok"
+	touch $test_name.ok
+else
+	echo "$test_name: $test_description: failed"
+	diff -u $EXP1 $OUT1 >> $test_name.failed
+	diff -u $EXP2 $OUT2 >> $test_name.failed
+fi
+unset EXP1 OUT1 EXP2 OUT2 FSCK_OPT IMAGE

[PATCH 18/19] tests: add regression tests for group descriptors with bad checksums

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Add tests to examine how e2fsck deals with (a) the block bitmap being
corrupt; (b) the inode bitmap being corrupt; (c) the bitmap checksums
being incorrect (but the bitmaps are fine); and (d) the group
descriptor checksum itself is incorrect.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 tests/f_bad_bbitmap/expect.1   |   15 +++++++++++++++
 tests/f_bad_bbitmap/expect.2   |    7 +++++++
 tests/f_bad_bbitmap/image.gz   |  Bin
 tests/f_bad_bbitmap/name       |    1 +
 tests/f_bad_bmap_csum/expect.1 |   16 ++++++++++++++++
 tests/f_bad_bmap_csum/expect.2 |    7 +++++++
 tests/f_bad_bmap_csum/image.gz |  Bin
 tests/f_bad_bmap_csum/name     |    1 +
 tests/f_bad_gdt_csum/expect.1  |   10 ++++++++++
 tests/f_bad_gdt_csum/expect.2  |    7 +++++++
 tests/f_bad_gdt_csum/image.gz  |  Bin
 tests/f_bad_gdt_csum/name      |    1 +
 tests/f_bad_ibitmap/expect.1   |   15 +++++++++++++++
 tests/f_bad_ibitmap/expect.2   |    7 +++++++
 tests/f_bad_ibitmap/image.gz   |  Bin
 tests/f_bad_ibitmap/name       |    1 +
 16 files changed, 88 insertions(+)
 create mode 100644 tests/f_bad_bbitmap/expect.1
 create mode 100644 tests/f_bad_bbitmap/expect.2
 create mode 100644 tests/f_bad_bbitmap/image.gz
 create mode 100644 tests/f_bad_bbitmap/name
 create mode 100644 tests/f_bad_bmap_csum/expect.1
 create mode 100644 tests/f_bad_bmap_csum/expect.2
 create mode 100644 tests/f_bad_bmap_csum/image.gz
 create mode 100644 tests/f_bad_bmap_csum/name
 create mode 100644 tests/f_bad_gdt_csum/expect.1
 create mode 100644 tests/f_bad_gdt_csum/expect.2
 create mode 100644 tests/f_bad_gdt_csum/image.gz
 create mode 100644 tests/f_bad_gdt_csum/name
 create mode 100644 tests/f_bad_ibitmap/expect.1
 create mode 100644 tests/f_bad_ibitmap/expect.2
 create mode 100644 tests/f_bad_ibitmap/image.gz
 create mode 100644 tests/f_bad_ibitmap/name

diff --git a/tests/f_bad_bbitmap/expect.1 b/tests/f_bad_bbitmap/expect.1
new file mode 100644
index 0000000..71ad1bb
--- /dev/null
+++ b/tests/f_bad_bbitmap/expect.1
@@ -0,0 +1,15 @@
+One or more block group descriptor checksums are invalid.  Fix? yes
+
+Group descriptor 0 checksum is 0x49ff, should be 0x4972.  FIXED.
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+Block bitmap differences:  -(8--10) -(12--17) -(19--31)
+Fix? yes
+
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 11/128 files (0.0% non-contiguous), 18/512 blocks
+Exit status is 1
diff --git a/tests/f_bad_bbitmap/expect.2 b/tests/f_bad_bbitmap/expect.2
new file mode 100644
index 0000000..411e656
--- /dev/null
+++ b/tests/f_bad_bbitmap/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 11/128 files (0.0% non-contiguous), 18/512 blocks
+Exit status is 0
diff --git a/tests/f_bad_bbitmap/image.gz b/tests/f_bad_bbitmap/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..c488ecd365b99c51a304597c0944444e0552c57d
GIT binary patch
literal 2546
zcmb2|=3tPuydKQN{Pvb@MzEs{!-wijhs@@wyEMdfSk)E#woVp}J#uhiFnj4n-m6LN
zCJUln-|8s!@wvWG>gZ_Vi<)y}mqv!`QAfeuKh{1_|M=8-q5x}dX3o9$;_vjz_e|gO
z|McF+@1C|Ys9dek^lsgtrWfa?D6;D9$}FvXgSfkTW|xg`%R6nn@n4JU;`u7q5Z&9W
zrur5Z+WwpH_oYCT-Tj%fX5aW#_UUI==y|?%wsvMS<Zm0B*ci>QpAx?&qTj}L>h3+2
zw|B0re*JxJ<%dKCu3E*(zf9M)UX|Rx$m;FO9fiBsxi{P9+%3Hq$<Xjb)3@IG(UsVF
z|HU6w?YeVs_TInC1iJRmU3Sl=x@!4mb_NCpZ)d}ATT|<PGXvTGw_p1If2P3FO$$Hi
zIH)ZNx|#D-@}B$KwJRrH{Bxsi;l)FZd*4k3syh%gne*XCm+-vu=(E4-*X`Z(4`kA;
z<iGd#zB@AY((mtY&w&I?UjO<Z_I|SE>v|w(156D+kV6dcjxCJzl?AHIuzJ@(j0PNP
zKA5LfrTwm7a`e}^KH1*>-$$oeL`UlXo3>$3OxUMu<$)gmH^qnCOR8)0Z@VC=mY!YT
zzU0f!#;YgyJ=2TvF8g!8Pu2QguW_$^+sDI&W_QEW|8%cXzP~?v^-6csufNT`9>>26
z4m!SH-+l7k|N3#hWq)>F2daH}>Cf`@_x`Ah?)qo&-!uGjP0g99>;CVaKB?+2D4<8d
iXb6mkz-S1JhQMeDjD`R$LSVy(eath088aCe6c_+dh#I*7

literal 0
HcmV?d00001

diff --git a/tests/f_bad_bbitmap/name b/tests/f_bad_bbitmap/name
new file mode 100644
index 0000000..923ddcb
--- /dev/null
+++ b/tests/f_bad_bbitmap/name
@@ -0,0 +1 @@
+corrupt block bitmap (metadata_csum)
diff --git a/tests/f_bad_bmap_csum/expect.1 b/tests/f_bad_bmap_csum/expect.1
new file mode 100644
index 0000000..ca8f77f
--- /dev/null
+++ b/tests/f_bad_bmap_csum/expect.1
@@ -0,0 +1,16 @@
+One or more block group descriptor checksums are invalid.  Fix? yes
+
+Group descriptor 0 checksum is 0x4972, should be 0x7074.  FIXED.
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+Inode bitmap differences: Group 0 inode bitmap does not match checksum.
+FIXED.
+Block bitmap differences: Group 0 block bitmap does not match checksum.
+FIXED.
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 11/128 files (0.0% non-contiguous), 18/512 blocks
+Exit status is 1
diff --git a/tests/f_bad_bmap_csum/expect.2 b/tests/f_bad_bmap_csum/expect.2
new file mode 100644
index 0000000..411e656
--- /dev/null
+++ b/tests/f_bad_bmap_csum/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 11/128 files (0.0% non-contiguous), 18/512 blocks
+Exit status is 0
diff --git a/tests/f_bad_bmap_csum/image.gz b/tests/f_bad_bmap_csum/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..70a0d1812b9c030959651bd068f1331e36330578
GIT binary patch
literal 2546
zcmb2|=3pqYxE{>J{Pvc0hKQpC!-Jb=8x<{WI(w522y75al3d%9p)4l0GH6BbNkLvV
zAEsNbSFR`}WeT>KG<9fXEIjDdGj)NWD7UN6V`ljWlZ)RkY<VnVqL`ky|NV@avlGAP
z{oi{tF)iPj;ZoL~8Alb@_;y_n<Vc?SZO0@p>7MXy-e*eAe`^cS__D9l>C5UkvCvc3
zyi$vU?s(ZfNl<H9rvH7}Gqr8|XV>g3`r57h+OPLpf6qH<37J>&mR6fWHp<o4nbqgM
z?&}WbH<PjW{~|eFq{_)`p8WMkS^jZ>z2AH;?FhcU_?+DKH#?u`FgW}YS-wBl^Oero
z|Hmg)ExQuu@#N6M`+mXiV=T7czRAqM(C~EOg*lw}XNhgFXJBCXa9{i1|M|RucSKK}
zXG(FFDKDKm|6%Q<?9TQ!cQ<oBo_^U|@8dXu3U$nH3e58>dGdW**xLWki=KW3>AoQG
z`v1AF%h!wFuRmca4-#1M`v30ed1oX4gKUDSsRzms10vpWX|H+(ROxWIke!7X9oW@0
z>^Hn@d;7Ps?$z>bZ&%gdS-(y7=BlWV=B>|yBF{zNb5}IZ-@jtZ(L+4*I2YRboD2KU
zm-(`|Hv3ZT+1PzE-~HG>->3Y~?6g<)Jdcl0%GtI2*bnhgw|({3qeA;vz2eUoKfeFZ
z^DTY#@%~G8|Bv4}@!gNl`LFAFE+75r@4xn^zl_yCga0Q(E;-el5?}xSclhP1zre5<
k1*0J_8UmvsFd71*Aut*OGzozXKk671F0Px-z@WeY0F<&6$N&HU

literal 0
HcmV?d00001

diff --git a/tests/f_bad_bmap_csum/name b/tests/f_bad_bmap_csum/name
new file mode 100644
index 0000000..df19fe3
--- /dev/null
+++ b/tests/f_bad_bmap_csum/name
@@ -0,0 +1 @@
+bad block/inode bitmap csum (metadata_csum)
diff --git a/tests/f_bad_gdt_csum/expect.1 b/tests/f_bad_gdt_csum/expect.1
new file mode 100644
index 0000000..e14c897
--- /dev/null
+++ b/tests/f_bad_gdt_csum/expect.1
@@ -0,0 +1,10 @@
+One or more block group descriptor checksums are invalid.  Fix? yes
+
+Group descriptor 0 checksum is 0xffff, should be 0x4972.  FIXED.
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 11/128 files (0.0% non-contiguous), 18/512 blocks
+Exit status is 0
diff --git a/tests/f_bad_gdt_csum/expect.2 b/tests/f_bad_gdt_csum/expect.2
new file mode 100644
index 0000000..411e656
--- /dev/null
+++ b/tests/f_bad_gdt_csum/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 11/128 files (0.0% non-contiguous), 18/512 blocks
+Exit status is 0
diff --git a/tests/f_bad_gdt_csum/image.gz b/tests/f_bad_gdt_csum/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..c3fdafe6627561f7de16ea09a6f02d52f6265b00
GIT binary patch
literal 2548
zcmb2|=3uC|xE{>J{Pvb@MzEs{!-wk31DC|KO9OQxxcr=CvemVBbu>FK=X;eTz3M1m
zro;BGTahj@vRxNk1q4}Tw^($R243juYE~-y7=6(H(dqUeCy^~nH&*VC-?977$GA`b
z^uPD*o-WQbA>{E<9nnL#c2tPAPFTNXxz@@p2P;x{-|#t~Q_s=r^#8Sn%l=oXflG7N
zhL{~c+WW(qZ;5lpucGp-yrkQ^Pl{`Y+uLt>cjQJwUe5aqA5J8^E67`!Wc%w)$+uI}
z-acRcF8@aTw};0YHNLcNyYgp;Sa|xMuB<J~A0Lz5C0F`wMe29fbVi0r%Ps!C?FcT<
z{5QY<^~<2@{AcHG*Vvr@f46S?xw$u=zF}lwIPfVT!>>Kxm-~i10|Ud4_oDy*=W_>Y
z37<O8w52sfYqF;O;om#<s+t<jlD=(WGRuC)`Mp9wg%NqToGOeiPQ80MYU{uG+4}4M
z1I=nU7V*D)y?y1@AOD<pe+CLL^zQn%|L*USbH6}_uYsvy26Bi12a3WY0z=t>Dy90Y
z6^PJ)OUa+!ne%S`o1eLI-{$1>zmMy7nw|^0+O=QPWcsP1d!OvMURM5gU8*aV_9KL2
zZer24U*#TN^Q9vuzsY|0=xfUH|9>ksJ-%-e{6AU3UMT%?t?9A-D~vw<-F<CURY+)k
z!DfqpsrKrne|}f#-2D6h($<vY^J{@>XXu@)|CM#NK4{@<{?GGERCSLm&-wUkf4Sw#
o>-M<ZIVwIH0;3@?8UmvsFd71*AwX#ebiZdekeYCofkA-*0GSvb(f|Me

literal 0
HcmV?d00001

diff --git a/tests/f_bad_gdt_csum/name b/tests/f_bad_gdt_csum/name
new file mode 100644
index 0000000..fe2c601
--- /dev/null
+++ b/tests/f_bad_gdt_csum/name
@@ -0,0 +1 @@
+bad group descriptor csum (metadata_csum)
diff --git a/tests/f_bad_ibitmap/expect.1 b/tests/f_bad_ibitmap/expect.1
new file mode 100644
index 0000000..ea17523
--- /dev/null
+++ b/tests/f_bad_ibitmap/expect.1
@@ -0,0 +1,15 @@
+One or more block group descriptor checksums are invalid.  Fix? yes
+
+Group descriptor 0 checksum is 0xffff, should be 0x4972.  FIXED.
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+Inode bitmap differences:  -(12--32)
+Fix? yes
+
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 11/128 files (0.0% non-contiguous), 18/512 blocks
+Exit status is 1
diff --git a/tests/f_bad_ibitmap/expect.2 b/tests/f_bad_ibitmap/expect.2
new file mode 100644
index 0000000..411e656
--- /dev/null
+++ b/tests/f_bad_ibitmap/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 11/128 files (0.0% non-contiguous), 18/512 blocks
+Exit status is 0
diff --git a/tests/f_bad_ibitmap/image.gz b/tests/f_bad_ibitmap/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..3a5239802dc3927db009d83b951f487033e528d6
GIT binary patch
literal 2548
zcmb2|=3rp7ydKQN{Pvb@MzEs{!-wk3wo7c<rGYvTTz*b6+3MQ6I+~rA^Sw%vUUif&
z(_wqptw<Lc*{%z&0)nivTP!+D121%SH7k{Uj6Uf9=ybc1BG;`;H}>4uzZ3heLcj9=
z^y=exPjfSRtm+J!#+B$Bv!};NBjk4Q)sTA$i+084Y%9-GXh|x35Gt~0{@1P*QQN|`
zXFqyW^+)mdWyLKu`;2YvcYb|)<+JGOd9pFpH8mRc`_d~?N;K*<_J?egtE|#0ul&5N
z`11E_@2x*SIGiBz%USJfc1-tb?K;=eTbBzTm&Nw8Ro~e5de3GChLgdw{*@hDx!mTz
z{*kXGJNN2W|Mpd!_xyj}{@LmN?@PWhFfb%kYHV9}`1&-~H~c`}pYLA(|ED`mIn{P*
zGsDaYUa6a>rdP<9ZdvMf{L^FUw&Psv-*$yF0TrJ1Rckpu`R>lUZ%tqS|Jirympo7~
zqwj0|`CY={UhnUhTYv;Eta<%Ey4L^M+W(9U3<qFp?13`G0G;xq5xKHJl^J^P8i>(=
zL(K>CwCd+<bxW51I(JUCxBvIiX%^9u`v0a~h|<%pyuDjvN&QWIt^AD!%IeN9xPptf
z?spFQb?3pWl=x!tb*k3?@{doF{eSG{G5Nzs9$L(Px!(An>(z<x?{B?+W$~<Ef2Egx
z)c>xz^6~xYi%-7$FTP&Q`rn<`K(#)Z|1QVp|C`Kpw|>U|C95+P?VfpE|9{upbMHT3
mSd4<v5Eu=C(GVC7fzc2c4FQ^jKt#=b#-EO-moqRZFaQ7#Mj2iJ

literal 0
HcmV?d00001

diff --git a/tests/f_bad_ibitmap/name b/tests/f_bad_ibitmap/name
new file mode 100644
index 0000000..76ec12d
--- /dev/null
+++ b/tests/f_bad_ibitmap/name
@@ -0,0 +1 @@
+corrupt inode bitmap (metadata_csum)

[PATCH 19/19] tests: add regression tests for inodes with bad checksums

[Darrick J. Wong]

From: Darrick J. Wong <darrick.wong@oracle.com>

Add regression tests to e2fsck to examine how it deals with inode
table blocks which (a) have been zero'd; (b) have been one'd; (c) have
corrupt inodes with obvious problems; and (d) have inodes with
non-obvious problems.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 tests/f_bad_inode_csum/expect.1 |  126 +++++++++++++++++++++++++++++++++++++++
 tests/f_bad_inode_csum/expect.2 |    7 ++
 tests/f_bad_inode_csum/image.gz |  Bin
 tests/f_bad_inode_csum/name     |    1 
 4 files changed, 134 insertions(+)
 create mode 100644 tests/f_bad_inode_csum/expect.1
 create mode 100644 tests/f_bad_inode_csum/expect.2
 create mode 100644 tests/f_bad_inode_csum/image.gz
 create mode 100644 tests/f_bad_inode_csum/name

diff --git a/tests/f_bad_inode_csum/expect.1 b/tests/f_bad_inode_csum/expect.1
new file mode 100644
index 0000000..b3c628d
--- /dev/null
+++ b/tests/f_bad_inode_csum/expect.1
@@ -0,0 +1,126 @@
+Pass 1: Checking inodes, blocks, and sizes
+Inode 33 has a extra size (65535) which is invalid
+Fix? yes
+
+Inode 49 passes checks, but checksum does not match inode.  Fix? yes
+
+Inode 65 passes checks, but checksum does not match inode.  Fix? yes
+
+Inode 81 passes checks, but checksum does not match inode.  Fix? yes
+
+Inode 97 seems to contain garbage.  Clear? yes
+
+Inode 98 seems to contain garbage.  Clear? yes
+
+Inode 99 seems to contain garbage.  Clear? yes
+
+Inode 100 seems to contain garbage.  Clear? yes
+
+Inode 101 seems to contain garbage.  Clear? yes
+
+Inode 102 seems to contain garbage.  Clear? yes
+
+Inode 103 seems to contain garbage.  Clear? yes
+
+Inode 104 seems to contain garbage.  Clear? yes
+
+Inode 105 seems to contain garbage.  Clear? yes
+
+Inode 106 seems to contain garbage.  Clear? yes
+
+Inode 107 seems to contain garbage.  Clear? yes
+
+Inode 108 seems to contain garbage.  Clear? yes
+
+Inode 109 seems to contain garbage.  Clear? yes
+
+Inode 110 seems to contain garbage.  Clear? yes
+
+Inode 111 seems to contain garbage.  Clear? yes
+
+Inode 112 seems to contain garbage.  Clear? yes
+
+Pass 2: Checking directory structure
+Extended attribute block for inode 49 (/38) is invalid (4294967295).
+Clear? yes
+
+Entry '86' in / (2) has deleted/unused inode 97.  Clear? yes
+
+Entry '87' in / (2) has deleted/unused inode 98.  Clear? yes
+
+Entry '88' in / (2) has deleted/unused inode 99.  Clear? yes
+
+Entry '89' in / (2) has deleted/unused inode 100.  Clear? yes
+
+Entry '90' in / (2) has deleted/unused inode 101.  Clear? yes
+
+Entry '91' in / (2) has deleted/unused inode 102.  Clear? yes
+
+Entry '92' in / (2) has deleted/unused inode 103.  Clear? yes
+
+Entry '93' in / (2) has deleted/unused inode 104.  Clear? yes
+
+Entry '94' in / (2) has deleted/unused inode 105.  Clear? yes
+
+Entry '95' in / (2) has deleted/unused inode 106.  Clear? yes
+
+Entry '96' in / (2) has deleted/unused inode 107.  Clear? yes
+
+Entry '97' in / (2) has deleted/unused inode 108.  Clear? yes
+
+Entry '98' in / (2) has deleted/unused inode 109.  Clear? yes
+
+Entry '99' in / (2) has deleted/unused inode 110.  Clear? yes
+
+Entry '100' in / (2) has deleted/unused inode 111.  Clear? yes
+
+Entry '101' in / (2) has deleted/unused inode 112.  Clear? yes
+
+Entry '102' in / (2) has deleted/unused inode 113.  Clear? yes
+
+Entry '103' in / (2) has deleted/unused inode 114.  Clear? yes
+
+Entry '104' in / (2) has deleted/unused inode 115.  Clear? yes
+
+Entry '105' in / (2) has deleted/unused inode 116.  Clear? yes
+
+Entry '106' in / (2) has deleted/unused inode 117.  Clear? yes
+
+Entry '107' in / (2) has deleted/unused inode 118.  Clear? yes
+
+Entry '108' in / (2) has deleted/unused inode 119.  Clear? yes
+
+Entry '109' in / (2) has deleted/unused inode 120.  Clear? yes
+
+Entry '110' in / (2) has deleted/unused inode 121.  Clear? yes
+
+Entry '111' in / (2) has deleted/unused inode 122.  Clear? yes
+
+Entry '112' in / (2) has deleted/unused inode 123.  Clear? yes
+
+Entry '113' in / (2) has deleted/unused inode 124.  Clear? yes
+
+Entry '114' in / (2) has deleted/unused inode 125.  Clear? yes
+
+Entry '115' in / (2) has deleted/unused inode 126.  Clear? yes
+
+Entry '116' in / (2) has deleted/unused inode 127.  Clear? yes
+
+Entry '117' in / (2) has deleted/unused inode 128.  Clear? yes
+
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+Inode bitmap differences:  -(97--128)
+Fix? yes
+
+Free inodes count wrong for group #0 (0, counted=32).
+Fix? yes
+
+Free inodes count wrong (0, counted=32).
+Fix? yes
+
+
+test_filesys: ***** FILE SYSTEM WAS MODIFIED *****
+test_filesys: 96/128 files (0.0% non-contiguous), 18/512 blocks
+Exit status is 1
diff --git a/tests/f_bad_inode_csum/expect.2 b/tests/f_bad_inode_csum/expect.2
new file mode 100644
index 0000000..b97a902
--- /dev/null
+++ b/tests/f_bad_inode_csum/expect.2
@@ -0,0 +1,7 @@
+Pass 1: Checking inodes, blocks, and sizes
+Pass 2: Checking directory structure
+Pass 3: Checking directory connectivity
+Pass 4: Checking reference counts
+Pass 5: Checking group summary information
+test_filesys: 96/128 files (0.0% non-contiguous), 18/512 blocks
+Exit status is 0
diff --git a/tests/f_bad_inode_csum/image.gz b/tests/f_bad_inode_csum/image.gz
new file mode 100644
index 0000000000000000000000000000000000000000..221920b04ad0b18949bd75680159390e7b05586a
GIT binary patch
literal 4613
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
GIQ$Pa(@%{6

literal 0
HcmV?d00001

diff --git a/tests/f_bad_inode_csum/name b/tests/f_bad_inode_csum/name
new file mode 100644
index 0000000..68bf7ce
--- /dev/null
+++ b/tests/f_bad_inode_csum/name
@@ -0,0 +1 @@
+inode table corruption (metadata_csum)

Re: [PATCH 01/19] e2fuzz: fix fs handle cleanup when closing fails

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:11:46AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Fix the handling of 'fs' when closing the FS fails so that we don't
> dereference a NULL pointer.  Adapt to use ext2fs_close_free while
> we're at it.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> Fixes-Coverity-Bug: 1229241

Applied, thanks.

						- Ted

Re: [PATCH 02/19] e2fsck: never free critical metadata blocks in the block found map

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:11:53AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Don't allow critical metadata blocks to be marked free in the block
> found map.  This can theoretically happen on an FS where a first
> inode's ETB/indirect map block is in the inode table, the first inode
> is itself unclonable (and thus gets deleted) and there are enough
> crosslinked files before and after the first inode to use up all the
> free blocks during pass 1b.
> 
> (I do actually have a test FS image but it's 256M and it proved very
> difficult to craft a bite-sized test case that actually hit this bug.)
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

						- Ted

Re: [PATCH 03/19] e2fsck: use root dir for lost+found when really desperate

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:11:59AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> If we're totally unable to allocate a lost+found directory, ask the
> user if he would like to dump orphaned files in the root directory.
> Hopefully this enables the user to delete enough files so that a
> subsequent run of e2fsck will make more progress.  Better to cram lost
> files in the rootdir than the current behavior, which is to fail at
> linking them in, thereby leaving them as lost files.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, although I changed:

> +		printf("Delete some files and re-run e2fsck.\n\n");

to:

		printf(_("Delete some files and re-run e2fsck.\n\n"));

for proper internationalization support.  Usually, I like to run all
messages through problem.c, like this:

	fix_problem(ctx, PR_3_PASS_HEADER, &pctx);

	{ PR_3_PASS_HEADER,
	  N_("Pass 3: Checking @d connectivity\n"),
	    PROMPT_NONE, 0 },

and I may change this over at some point, but I'll leave it as a
printf for now.

Thanks!!

						- Ted

Re: [PATCH 04/19] dumpe2fs: complain when checksum verification fails

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:12:06AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Warn the user to run e2fsck if the superblock or bitmaps fails
> checksum verification.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

					- Ted

Re: [PATCH 05/19] libext2fs: check EA block headers when reading in the block

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:12:14AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> When reading an EA block in from disk, do a quick sanity check of the
> block header, and return an error if we think we have garbage.  Teach
> e2fsck to ignore the new error code in favor of doing its own
> checking, and remove the strict_csums bits while we're at it.
> 
> (Also document some assumptions in the new ext_attr code.)
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

					- Ted

Re: [PATCH 06/19] e2fsck: try to salvage extent blocks with bad checksums

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:12:21AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Remove the code that would zap an extent block immediately if the
> checksum failed (i.e. strict_csums).  Instead, we'll only do that if
> the extent block header shows obvious structural problems; if the
> header checks out, then we'll iterate the block and see if we can
> recover some extents.
> 
> Requires a minor modification to ext2fs_extent_get such that the
> extent block will be returned in the buffer even if the return code
> indicates a checksum error.  This brings its behavior in line with
> the rest of libext2fs.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

						- Ted

Re: [PATCH 07/19] e2fsck: try to salvage corrupt directory entry blocks

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:12:28AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Remove the code that would prompt the user to zap directory entry
> blocks with bad checksums (i.e. strict_csums).  Instead, we'll run the
> directory entries through the usual repair routines in an attempt to
> save whatever we can.  At the same time, refactor the code that
> schedules the repair of missing dirblock checksum entries.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

						- Ted

Re: [PATCH 08/19] e2fsck: offer to clear inode table blocks that are insane

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:12:34AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Add a new behavior flag to the inode scan functions; when specified,
> this flag will do some simple sanity checking of entire inode table
> blocks.  If all the checksums are ok, we can skip checksum
> verification on individual inodes later on.  If more than half of the
> inodes look "insane" (bad extent tree root or checksum failure) then
> ext2fs_get_next_inode_full() can return a special status code
> indicating that what's in the buffer is probably garbage.
> 
> When e2fsck' inode scan encounters the 'inode is garbage' return code
> it'll offer to zap the inode straightaway instead of trying to recover
> anything.  This replaces the previous behavior of asking to zap
> anything with a checksum error (strict_csum).
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@orale.com>

Applied, thanks!!

					- Ted

Re: [PATCH 09/19] e2fsck: correctly preserve fs flags when modifying ignore-csum-error flag

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:12:41AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> When we need to modify the "ignore checksum error" behavior flag to
> get us past a library call, it's possible that the library call can
> result in other flag bits being changed.  Therefore, it is not correct
> to restore unconditionally the previous flags value, since this will
> have unintended side effects on the other fs->flags; nor is it correct
> to assume that we can unconditionally set (or clear) the "ignore csum
> error" flag bit.  Therefore, we must merge the previous value of the
> "ignore csum error" flag with the value of flags after the call.
> 
> Note that we want to leave checksum verification on as much as
> possible because doing so exposes e2fsck bugs where two metadata
> blocks are "sharing" the same disk block, and attempting to fix one
> before relocating the other causes major filesystem damage.  The
> damage is much more obvious when a previously checked piece of
> metadata suddenly fails in a subsequent pass.
> 
> The modifications to the pass 2, 3, and 3A code are justified as
> follows: When e2fsck encounters a block of directory entries and
> cannot find the placeholder entry at the end that contains the
> checksum, it will try to insert the placeholder.  If that fails, it
> will schedule the directory for a pass 3A reconstruction.  Until that
> happens, we don't want directory block writing (pass 2), block
> iteration (pass 3), or block reading (pass 3A) to fail due to checksum
> errors, because failing to find the placeholder is itself a checksum
> verification error, which causes e2fsck to abort without fixing
> anything.
> 
> The e2fsck call to ext2fs_read_bitmaps must never fail due to a
> checksum error because e2fsck subsequently (a) verifies the bitmaps
> itself; or (b) decides that they don't match what has been observed,
> and rewrites them.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

						- Ted

Re: [PATCH 10/19] libext2fs: Don't cache inodes that fail checksum verification

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:12:47AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> If an inode fails checksum verification, don't stuff a copy of it in
> the inode cache, because this can cause the library to fail to return
> the "corrupt inode" error code.
> 
> In general, this happens if ext2fs_read_inode_full() is called twice
> on an inode with an incorrect checksum.  If fs->flags has
> EXT2_FLAG_IGNORE_CSUM_ERRORS set during the first call and *unset*
> during the second call, the cache hit during the second call fails to
> return EXT2_ET_INODE_CSUM_INVALID as you'd expect.  This happens
> during fsck because the first read_inode call happens as part of
> check_blocks and the second call happens during inode checksum
> revalidation.  A file system with a slightly corrupt non-extent inode
> will trigger this.
> 
> While we're at it, make the inode read function consistent with the
> rest of libext2fs -- copy the metadata object into the caller's buffer
> even if it fails checksum verification.  This will help e2fsck avoid a
> double re-read later on down the line.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

						- Ted

Re: [PATCH 11/19] e2fsck: disable checksum verification in a few select places

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:12:54AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Selectively disable checksum verification in a couple more places:
> 
> In check_blocks, disable checksum verification when iterating a block
> map because the block map iterator function (re)reads the inode, which
> could be unchanged since the scan found that the checksum fails.  We
> don't want to abort here; we want to keep evaluating the inode, and we
> already know if the inode checksum doesn't match.
> 
> Further down in check_blocks when we're trying to see if i_size
> matches the amount of data stored in the inode, don't allow checksum
> errors when we go looking for the size of inline data.  If the
> required attribute is at all find-able in the EA block, we'll fix any
> other problems with the EA block later.  In the meantime, we don't
> want to be truncating files unnecessarily.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

					- Ted

Re: [PATCH 12/19] e2fsck: always ask to fix an inode that fails checksum verification

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:13:00AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> If an inode fails checksum verification during pass 1 and the user
> doesn't fix or clear the inode as part of the regular inode checks,
> ensure that e2fsck remembers to ask the user if he simply wants to
> correct the checksum.
> 
> We weren't capturing all the ways out of an interation of the inode
> scanning loop, which means that not all errors were caught.  Also,
> we might as well clear the 'failed csum' flag if we write the inode
> directly from the inode scanning loop.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

						- Ted

Re: [PATCH 13/19] tests: add regression tests for EA blocks with bad checksums

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:13:07AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Add regression tests for e2fsck dealing with (a) EA block with a bad
> checksum; (b) EA block with a bad magic number; and (c) EA block with
> damage that isn't otherwise noticeable.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Thanks, applied.

						- Ted

Re: [PATCH 14/19] tests: add tests for handling of corrupt extents

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:13:14AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Add some regression tests to examine how e2fsck deals with (a) extent
> blocks with only a bad checksum; (b) extent blocks with a bad magic
> number; and (c) extent entries with corruption.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

						- Ted

Re: [PATCH 15/19] tests: add tests for directory entry blocks with checksum errors

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:13:23AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Add some regression tests to examine how e2fsck handles directory
> entry blocks and htree blocks with (a) malformed directory entries;
> (b) incorrect checksums; or (c) obviously garbage entries.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

					- Ted

Re: [PATCH 16/19] tests: add regression tests for MMP blocks with bad checksums

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:13:29AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Add regression tests to examine how e2fsck deals with MMP blocks with
> (a) a bad magic number; and (b) an incorrect checksum.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

					- Ted

Re: [PATCH 17/19] tests: add regression tests for superblocks with bad checksums

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:13:36AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Add regression tests to examine how e2fsck deals with random
> superblock corruption such as obviously wrong fields and the checksum
> itself being incorrect.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

					- Ted

Re: [PATCH 18/19] tests: add regression tests for group descriptors with bad checksums

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:13:42AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Add tests to examine how e2fsck deals with (a) the block bitmap being
> corrupt; (b) the inode bitmap being corrupt; (c) the bitmap checksums
> being incorrect (but the bitmaps are fine); and (d) the group
> descriptor checksum itself is incorrect.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

					- Ted

Re: [PATCH 19/19] tests: add regression tests for inodes with bad checksums

[Theodore Ts'o]

On Fri, Aug 01, 2014 at 11:13:49AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Add regression tests to e2fsck to examine how it deals with inode
> table blocks which (a) have been zero'd; (b) have been one'd; (c) have
> corrupt inodes with obvious problems; and (d) have inodes with
> non-obvious problems.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

Applied, thanks.

						- Ted

Re: [PATCH 03/19] e2fsck: use root dir for lost+found when really desperate

[Darrick J. Wong]

On Sat, Aug 02, 2014 at 10:25:53PM -0400, Theodore Ts'o wrote:
> On Fri, Aug 01, 2014 at 11:11:59AM -0700, Darrick J. Wong wrote:
> > From: Darrick J. Wong <darrick.wong@oracle.com>
> > 
> > If we're totally unable to allocate a lost+found directory, ask the
> > user if he would like to dump orphaned files in the root directory.
> > Hopefully this enables the user to delete enough files so that a
> > subsequent run of e2fsck will make more progress.  Better to cram lost
> > files in the rootdir than the current behavior, which is to fail at
> > linking them in, thereby leaving them as lost files.
> > 
> > Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Applied, although I changed:
> 
> > +		printf("Delete some files and re-run e2fsck.\n\n");
> 
> to:
> 
> 		printf(_("Delete some files and re-run e2fsck.\n\n"));

I don't see this in the tree on kernel.org, but I'm sending you a patch to
change it to a fix_problem anyway.

--D
> 
> for proper internationalization support.  Usually, I like to run all
> messages through problem.c, like this:
> 
> 	fix_problem(ctx, PR_3_PASS_HEADER, &pctx);
> 
> 	{ PR_3_PASS_HEADER,
> 	  N_("Pass 3: Checking @d connectivity\n"),
> 	    PROMPT_NONE, 0 },
> 
> and I may change this over at some point, but I'll leave it as a
> printf for now.
> 
> Thanks!!
> 
> 						- Ted
> --
> To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 03/19] e2fsck: use root dir for lost+found when really desperate

[Theodore Ts'o]

On Mon, Aug 04, 2014 at 05:58:58PM -0700, Darrick J. Wong wrote:
> 
> I don't see this in the tree on kernel.org, but I'm sending you a patch to
> change it to a fix_problem anyway.

It's there; on the next branch:

http://git.kernel.org/cgit/fs/ext2/e2fsprogs.git/commit/?h=next&id=0991896720917b467e573a5fae38539d950d0617

I hadn't bumped up the master branch just yet, since I usually like to
give a few days lag before master gets promoted:

http://git.kernel.org/cgit/fs/ext2/e2fsprogs.git/log/?h=next

Cheers,

						- Ted