[PATCH 0/4] ext4: cleanup and bugfixes for grow/shrink logic

[PATCH 0/4] ext4: cleanup and bugfixes for grow/shrink logic

[Dmitry Monakhov]

Hi, finally have some time to run some tests on recent kernels.
And it appeared that fallocate interface is buggy
 - fallocate: result in fsck complain due to blocks beyond i_size
   without  EOFBLOCKS_FL
 - punch_hole: also provoke fsck complain and even EIO due to
   incorrect EOFBLOCKS_FL update

#LOG:
#Following two patches are mostly cleanup 
ext4-cleanup-ext4_ext_grow_indepth-code.patch
ext4-move-inode-indepth-shrink-logic-to-didicated-fu.patch
# Later patches are fixes for issues.
ext4-Do-not-clear-EOFBLOCKS_FL-too-soon.patch
ext4-fix-punch_hole-extend-handler.patch
I've also attached my temp testcase for both issues
Will submit generic xfstests based on it soon.

########### TESTCASE###################
#! /bin/bash
#############################################################################
# dmonakhov@openvz.org
# Trivial fsstress test  
# TODO: Add to xfstests
# Required patches
# kill fsstress reliably
#  Message-Id: <1316357699-22692-1-git-send-email-dmonakhov@openvz.org>
# In order unresvsp to work kernel should contain following patch
#  Message-Id: <1316528400-1797-1-git-send-email-dmonakhov@openvz.org>
#############################################################################
# FIXES FOR ext4.git:3.1.0-rc2+
#0001-ext4-cleanup-ext4_ext_grow_indepth-code.patch
#0002-ext4-move-inode-indepth-shrink-logic-to-didicated-fu.patch
#0003-ext4-Do-not-clear-EOFBLOCKS_FL-too-soon.patch
#0004-ext4-fix-punch_hole-extend-handler.patch
#############################################################################
IMG=/dev/sdc
MNT=./mnt
#MNT_EXTRA_OPS="-oloop"
## Create small image
#dd if=/dev/zero of=$IMG bs=1M count=1024000
mkfs.ext4 -F -b4096 $IMG 102400
mkdir -p $MNT
mount -text4 $IMG $MNT $MNT_EXTRA_OPS || exit
## Run stress
~/fsstress -p8 -f fsync=0 -f sync=0 -f fdatasync=0 -f setattr=0  -f unresvsp=2 -d $MNT/TEST -n99999999 &
PID=$!
## dd writers will do write/truncate =>  ENOSPC condition
for ((i=0;i < 10;i++))
do
    dd if=/dev/zero of=$MNT/FILE bs=1M
    sleep 2
done
kill $!
wait $!
umount $MNT
fsck.ext4 -f -n $IMG

[PATCH 1/4] ext4: cleanup ext4_ext_grow_indepth code

[Dmitry Monakhov]

Currently code make an impression what grow procedure is very complicated
and some mythical paths, blocks are involved. But in fact grow in depth
it relatively simple procedure:
 1) Just create new meta block and copy root data to that block.
 2) Convert root from extent to index if old depth == 0
 3) update root block pointer

This patch does:
 - Reorganize code to make it more self explanatory
 - Do not pass path parameter to new_meta_block() in order to
   provoke allocation from inode's group because top-level block
   should site closer to it's inode, but not to leaf data block.

Signed-off-by: Dmitry Monakhov <dmonakhov@openvz.org>
---
 fs/ext4/extents.c |   41 +++++++++++++++--------------------------
 1 files changed, 15 insertions(+), 26 deletions(-)

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 0ac5a63..b3a08f0 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -1042,16 +1042,14 @@ cleanup:
  */
 static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
 				 unsigned int flags,
-				 struct ext4_ext_path *path,
 				 struct ext4_extent *newext)
 {
-	struct ext4_ext_path *curp = path;
 	struct ext4_extent_header *neh;
 	struct buffer_head *bh;
 	ext4_fsblk_t newblock;
 	int err = 0;
 
-	newblock = ext4_ext_new_meta_block(handle, inode, path,
+	newblock = ext4_ext_new_meta_block(handle, inode, NULL,
 		newext, &err, flags);
 	if (newblock == 0)
 		return err;
@@ -1071,7 +1069,8 @@ static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
 	}
 
 	/* move top-level index/leaf into new block */
-	memmove(bh->b_data, curp->p_hdr, sizeof(EXT4_I(inode)->i_data));
+	memmove(bh->b_data, EXT4_I(inode)->i_data,
+		sizeof(EXT4_I(inode)->i_data));
 
 	/* set size of new block */
 	neh = ext_block_hdr(bh);
@@ -1089,32 +1088,23 @@ static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
 	if (err)
 		goto out;
 
-	/* create index in new top-level index: num,max,pointer */
-	err = ext4_ext_get_access(handle, inode, curp);
-	if (err)
-		goto out;
-
-	curp->p_hdr->eh_magic = EXT4_EXT_MAGIC;
-	curp->p_hdr->eh_max = cpu_to_le16(ext4_ext_space_root_idx(inode, 0));
-	curp->p_hdr->eh_entries = cpu_to_le16(1);
-	curp->p_idx = EXT_FIRST_INDEX(curp->p_hdr);
-
-	if (path[0].p_hdr->eh_depth)
-		curp->p_idx->ei_block =
-			EXT_FIRST_INDEX(path[0].p_hdr)->ei_block;
-	else
-		curp->p_idx->ei_block =
-			EXT_FIRST_EXTENT(path[0].p_hdr)->ee_block;
-	ext4_idx_store_pblock(curp->p_idx, newblock);
-
+	/* Update top-level index: num,max,pointer */
 	neh = ext_inode_hdr(inode);
+	neh->eh_entries = cpu_to_le16(1);
+	ext4_idx_store_pblock(EXT_FIRST_INDEX(neh), newblock);
+	if (neh->eh_depth == 0) {
+		/* Root extent block becomes index block */
+		neh->eh_max = cpu_to_le16(ext4_ext_space_root_idx(inode, 0));
+		EXT_FIRST_INDEX(neh)->ei_block =
+			EXT_FIRST_EXTENT(neh)->ee_block;
+	}
 	ext_debug("new root: num %d(%d), lblock %d, ptr %llu\n",
 		  le16_to_cpu(neh->eh_entries), le16_to_cpu(neh->eh_max),
 		  le32_to_cpu(EXT_FIRST_INDEX(neh)->ei_block),
 		  ext4_idx_pblock(EXT_FIRST_INDEX(neh)));
 
-	neh->eh_depth = cpu_to_le16(path->p_depth + 1);
-	err = ext4_ext_dirty(handle, inode, curp);
+	neh->eh_depth = cpu_to_le16(neh->eh_depth + 1);
+	ext4_mark_inode_dirty(handle, inode);
 out:
 	brelse(bh);
 
@@ -1162,8 +1152,7 @@ repeat:
 			err = PTR_ERR(path);
 	} else {
 		/* tree is full, time to grow in depth */
-		err = ext4_ext_grow_indepth(handle, inode, flags,
-					    path, newext);
+		err = ext4_ext_grow_indepth(handle, inode, flags, newext);
 		if (err)
 			goto out;
 
-- 
1.7.2.3

[PATCH 2/4] ext4: move inode indepth shrink logic to didicated function

[Dmitry Monakhov]

- Add ext4_ext_try_shrink() helper
- ext4_mark_inode_dirty() called externally in order to allow
  caller to butch several inode updates in to one mark_dirty call.

Signed-off-by: Dmitry Monakhov <dmonakhov@openvz.org>
---
 fs/ext4/extents.c |   62 +++++++++++++++++++++-------------------------------
 1 files changed, 25 insertions(+), 37 deletions(-)

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index b3a08f0..9032214 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -2497,13 +2497,29 @@ ext4_ext_more_to_rm(struct ext4_ext_path *path)
 	return 1;
 }
 
+static int ext4_ext_try_shrink(handle_t *handle, struct inode *inode)
+{
+	/* TODO: flexible tree reduction should be here */
+	if (ext_depth(inode) && ext_inode_hdr(inode)->eh_entries == 0) {
+		/*
+		 * truncate to zero freed all the tree,
+		 * so we need to correct eh_depth
+		 */
+		ext_inode_hdr(inode)->eh_depth = 0;
+		ext_inode_hdr(inode)->eh_max =
+			cpu_to_le16(ext4_ext_space_root(inode, 0));
+		return 1;
+	}
+	return 0;
+}
+
 static int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start)
 {
 	struct super_block *sb = inode->i_sb;
 	int depth = ext_depth(inode);
 	struct ext4_ext_path *path;
 	handle_t *handle;
-	int i, err;
+	int i, err, err2;
 
 	ext_debug("truncate since %u\n", start);
 
@@ -2608,29 +2624,18 @@ again:
 			ext_debug("return to level %d\n", i);
 		}
 	}
-
-	/* TODO: flexible tree reduction should be here */
-	if (path->p_hdr->eh_entries == 0) {
-		/*
-		 * truncate to zero freed all the tree,
-		 * so we need to correct eh_depth
-		 */
-		err = ext4_ext_get_access(handle, inode, path);
-		if (err == 0) {
-			ext_inode_hdr(inode)->eh_depth = 0;
-			ext_inode_hdr(inode)->eh_max =
-				cpu_to_le16(ext4_ext_space_root(inode, 0));
-			err = ext4_ext_dirty(handle, inode, path);
-		}
-	}
+	if(ext4_ext_try_shrink(handle, inode))
+		err2 = ext4_mark_inode_dirty(handle, inode);
+	if (!err)
+		err = err2;
 out:
 	ext4_ext_drop_refs(path);
 	kfree(path);
 	if (err == -EAGAIN)
 		goto again;
-	ext4_journal_stop(handle);
+	err2 = ext4_journal_stop(handle);
 
-	return err;
+	return err ? err : err2;
 }
 
 /*
@@ -3456,28 +3461,11 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
 			}
 
 			ext4_ext_mark_uninitialized(ex);
-
 			ext4_ext_invalidate_cache(inode);
-
 			err = ext4_ext_rm_leaf(handle, inode, path,
 				map->m_lblk, map->m_lblk + punched_out);
-
-			if (!err && path->p_hdr->eh_entries == 0) {
-				/*
-				 * Punch hole freed all of this sub tree,
-				 * so we need to correct eh_depth
-				 */
-				err = ext4_ext_get_access(handle, inode, path);
-				if (err == 0) {
-					ext_inode_hdr(inode)->eh_depth = 0;
-					ext_inode_hdr(inode)->eh_max =
-					cpu_to_le16(ext4_ext_space_root(
-						inode, 0));

[PATCH 3/4] ext4: Do not clear EOFBLOCKS_FL too soon

[Dmitry Monakhov]

ext4_ext_insert_extent() may fail due to number of reasons (ENOSPC)
so let's update eof flag only after extent was successfully inserted.

Signed-off-by: Dmitry Monakhov <dmonakhov@openvz.org>
---
 fs/ext4/extents.c |   10 ++++++----
 1 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 9032214..098bf6a 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -3562,10 +3562,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
 			map->m_flags |= EXT4_MAP_UNINIT;
 	}
 
-	err = check_eofblocks_fl(handle, inode, map->m_lblk, path, ar.len);
-	if (!err)
-		err = ext4_ext_insert_extent(handle, inode, path,
-					     &newex, flags);
+	err = ext4_ext_insert_extent(handle, inode, path, &newex, flags);
 	if (err) {
 		int fb_flags = flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE ?
 			EXT4_FREE_BLOCKS_NO_QUOT_UPDATE : 0;
@@ -3577,6 +3574,11 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
 				 ext4_ext_get_actual_len(&newex), fb_flags);
 		goto out2;
 	}
+	err = check_eofblocks_fl(handle, inode, map->m_lblk, path, ar.len);
+	if (err) {
+		ext4_discard_preallocations(inode);
+		goto out2;
+	}
 
 	/* previous routine could use block we allocated */
 	newblock = ext4_ext_pblock(&newex);
-- 
1.7.2.3

[PATCH 4/4] ext4: fix punch_hole extend handler

[Dmitry Monakhov]

Current implementation has following issues:
 - EOFBLOCK does not changed if necessery
 - ext4_ext_rm_leaf() may return -EAGAIN due to transaction restart
 - punched extent converted to uninitialized incorrectly
 - fsync() logic is bloken because ei->i_sync_tid was not updated
 - Last but not the least all: punch hole logic is sited directly
   in ext4_ext_map_blocks() on 3rd controll level, IMHO one can
   easily screw-up his eyes while invastigating that code. We have
   nothing to hide aren't we?

This patch performs following changes:
 - Move punch hole logic to didicated function similar to uninitialized
   extent handlers.
 - Clear EOFBLOCK if necessery, unfortunately we can not reuse
   check_eofblock_fl() function because it purpose to handle file
   expansion, but in our case we have to recheck base invariant that:
      clear_eof_flag = (eof_block >= last_allocated_block)
 - Repeat punch hole after transaction restart.
 - Update inode sync transaction id on exit.

Signed-off-by: Dmitry Monakhov <dmonakhov@openvz.org>
---
 fs/ext4/extents.c |  202 +++++++++++++++++++++++++++++++++-------------------
 1 files changed, 128 insertions(+), 74 deletions(-)

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 098bf6a..3d17652 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -3285,6 +3285,125 @@ out2:
 	return err ? err : allocated;
 }
 
+static int
+ext4_ext_handle_punched_extent(handle_t *handle, struct inode *inode,
+			struct ext4_map_blocks *map,
+			struct ext4_ext_path *path)
+{
+	struct ext4_extent *ex = path[path->p_depth].p_ext;
+	ext4_lblk_t ee_block =  ext4_ext_get_actual_len(ex);
+	unsigned short ee_len = le32_to_cpu(ex->ee_block);
+	struct ext4_map_blocks punch_map;
+	unsigned int punched_out = 0;
+	int err, inode_dirty = 0;
+
+	/* Punch out the map length, but only to the end of the extent */
+	punched_out = ee_len - (map->m_lblk - ee_block);
+	if (punched_out > map->m_len)
+		punched_out = map->m_len;
+	/*
+	 * Sense extents need to be converted to uninitialized, they must
+	 * fit in an uninitialized extent
+	 */
+	if (punched_out > EXT_UNINIT_MAX_LEN)
+		punched_out = EXT_UNINIT_MAX_LEN;
+
+	punch_map.m_lblk = map->m_lblk;
+	punch_map.m_pblk = map->m_lblk - ee_block + ext4_ext_pblock(ex);;
+	punch_map.m_len = punched_out;
+	punch_map.m_flags = 0;
+
+	/* Check to see if the extent needs to be split */
+	if (punch_map.m_len != ee_len || punch_map.m_lblk != ee_block) {
+		err = ext4_split_extent(handle, inode,	path, &punch_map, 0,
+					EXT4_GET_BLOCKS_PUNCH_OUT_EXT |
+					EXT4_GET_BLOCKS_PRE_IO);
+		if (err < 0) {
+			goto out;
+		}
+		/* find extent for the block at the start of the hole */
+		ext4_ext_drop_refs(path);
+		kfree(path);
+
+		path = ext4_ext_find_extent(inode, map->m_lblk, NULL);
+		if (IS_ERR(path)) {
+			err = PTR_ERR(path);
+			path = NULL;
+			goto out;
+		}
+		ex = path[path->p_depth].p_ext;
+		ee_len = ext4_ext_get_actual_len(ex);
+		ee_block = le32_to_cpu(ex->ee_block);
+	}
+
+	err = ext4_ext_get_access(handle, inode, path + path->p_depth);
+	if (err)
+		return err;
+	ext4_ext_mark_uninitialized(ex);
+	err = ext4_ext_dirty(handle, inode, path + path->p_depth);
+	if (err)
+		goto out;
+	ext4_ext_invalidate_cache(inode);
+	err = ext4_ext_rm_leaf(handle, inode, path, map->m_lblk,
+			map->m_lblk + punched_out);
+	if (err)
+		goto out;
+
+	inode_dirty = ext4_ext_try_shrink(handle, inode);
+	/* We have punched out an extent, if it was the only extent beyond
+	 * i_size  eofblocks flag should be cleared.*/
+	if (ext4_test_inode_flag(inode, EXT4_INODE_EOFBLOCKS)) {
+		ext4_fsblk_t eof_block =
+			(inode->i_size + (1 << inode->i_blkbits) - 1) >>
+				inode->i_blkbits;
+		/* find the latest extent */
+		ext4_ext_drop_refs(path);
+		kfree(path);
+		path = ext4_ext_find_extent(inode, EXT_MAX_BLOCKS -1, NULL);
+		if (IS_ERR(path)) {
+			err = PTR_ERR(path);
+			path = NULL;
+			goto out;
+		}
+		ex = path[path->p_depth].p_ext;
+		if (ex) {
+			ee_len = ext4_ext_get_actual_len(ex);
+			ee_block = le32_to_cpu(ex->ee_block);
+		} else {
+			/* Inode is empty */
+			ee_block = ee_len = 0;
+		}
+		if (eof_block >= ee_block + ee_len) {
+			ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
+			inode_dirty = 1;
+		} else if (!ext4_ext_is_uninitialized(ex)) {
+			EXT4_ERROR_INODE(inode, "initialized extent beyond "
+					"EOF i_size: %lld, ex[%u:%u] "
+					"depth: %d pblock %lld",
+					inode->i_size, ee_block, ee_len,
+					path->p_depth,
+					path[path->p_depth].p_block);
+			err = -EIO;
+			/* Continue, because inode shrink should be
+			 * accomplished regardless to staled eof blocks */
+		}
+	}
+	if (inode_dirty) {
+		int err2 = ext4_mark_inode_dirty(handle, inode);
+		if (!err)
+			err = err2;
+	}
+out:
+	ext4_update_inode_fsync_trans(handle, inode, 0);
+	if (path) {
+		ext4_ext_drop_refs(path);
+		kfree(path);
+	}
+	return err ? err : punched_out;
+}
+
+
+
 /*
  * Block allocation/map/preallocation routine for extents based files
  *
@@ -3306,21 +3425,19 @@ out2:
 int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
 			struct ext4_map_blocks *map, int flags)
 {
-	struct ext4_ext_path *path = NULL;
+	struct ext4_ext_path *path;
 	struct ext4_extent newex, *ex;
 	ext4_fsblk_t newblock = 0;
 	int err = 0, depth, ret;
 	unsigned int allocated = 0;
-	unsigned int punched_out = 0;
-	unsigned int result = 0;
 	struct ext4_allocation_request ar;
 	ext4_io_end_t *io = EXT4_I(inode)->cur_aio_dio;
-	struct ext4_map_blocks punch_map;
 
 	ext_debug("blocks %u/%u requested for inode %lu\n",
 		  map->m_lblk, map->m_len, inode->i_ino);
 	trace_ext4_ext_map_blocks_enter(inode, map->m_lblk, map->m_len, flags);
-
+again:
+	path = NULL;
 	/* check in cache */
 	if (!(flags & EXT4_GET_BLOCKS_PUNCH_OUT_EXT) &&
 		ext4_ext_in_cache(inode, map->m_lblk, &newex)) {
@@ -3403,71 +3520,11 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
 					allocated, newblock);
 				return ret;
 			}
-
-			/*
-			 * Punch out the map length, but only to the
-			 * end of the extent
-			 */
-			punched_out = allocated < map->m_len ?
-				allocated : map->m_len;
-
-			/*
-			 * Sense extents need to be converted to
-			 * uninitialized, they must fit in an
-			 * uninitialized extent
-			 */
-			if (punched_out > EXT_UNINIT_MAX_LEN)
-				punched_out = EXT_UNINIT_MAX_LEN;
-
-			punch_map.m_lblk = map->m_lblk;
-			punch_map.m_pblk = newblock;
-			punch_map.m_len = punched_out;
-			punch_map.m_flags = 0;
-
-			/* Check to see if the extent needs to be split */
-			if (punch_map.m_len != ee_len ||
-				punch_map.m_lblk != ee_block) {
-
-				ret = ext4_split_extent(handle, inode,
-				path, &punch_map, 0,
-				EXT4_GET_BLOCKS_PUNCH_OUT_EXT |
-				EXT4_GET_BLOCKS_PRE_IO);
-
-				if (ret < 0) {
-					err = ret;
-					goto out2;
-				}
-				/*
-				 * find extent for the block at
-				 * the start of the hole
-				 */
-				ext4_ext_drop_refs(path);
-				kfree(path);
-
-				path = ext4_ext_find_extent(inode,
-				map->m_lblk, NULL);
-				if (IS_ERR(path)) {
-					err = PTR_ERR(path);
-					path = NULL;
-					goto out2;
-				}
-
-				depth = ext_depth(inode);
-				ex = path[depth].p_ext;
-				ee_len = ext4_ext_get_actual_len(ex);
-				ee_block = le32_to_cpu(ex->ee_block);
-				ee_start = ext4_ext_pblock(ex);
-
-			}
-
-			ext4_ext_mark_uninitialized(ex);
-			ext4_ext_invalidate_cache(inode);
-			err = ext4_ext_rm_leaf(handle, inode, path,
-				map->m_lblk, map->m_lblk + punched_out);
-			if (!err && ext4_ext_try_shrink(handle, inode))
-				err = ext4_mark_inode_dirty(handle, inode);
-
-			goto out2;
+			ret = ext4_ext_handle_punched_extent(handle, inode,
+							map, path);
+			if (ret == -EAGAIN)
+				goto again;
+			return ret;
 		}
 	}
 
@@ -3618,10 +3675,7 @@ out2:
 	trace_ext4_ext_map_blocks_exit(inode, map->m_lblk,
 		newblock, map->m_len, err ? err : allocated);
 
-	result = (flags & EXT4_GET_BLOCKS_PUNCH_OUT_EXT) ?
-			punched_out : allocated;

Re: [PATCH 0/4] ext4: cleanup and bugfixes for grow/shrink logic

[Dmitry Monakhov]

On Tue, 20 Sep 2011 18:49:26 +0400, Dmitry Monakhov <dmonakhov@openvz.org> wrote:
> Hi, finally have some time to run some tests on recent kernels.
> # Trivial fsstress test  
BTW current test but with fsstress with ext_ioc_{set/get}_flags support
(Message-Id: <1316357699-22692-2-git-send-email-dmonakhov@openvz.org>)
result in following oops almost immediately.
BUG happens due to delayed block appeared in journal checkpoint list
and was submitted to IO layer. Right i'm working on that issue.
------------[ cut here ]------------
kernel BUG at fs/buffer.c:2917!
invalid opcode: 0000 [#1] SMP 
CPU 1 
Modules linked in: ext4 quota_v2 quota_tree jbd2 iTCO_wdt
iTCO_vendor_support virtio_balloon shpchp virtio_pci virtio_ring virtio
[last unloaded: ext4]

Pid: 15935, comm: fsstress Not tainted 3.1.0-rc2+ #6 Parallels Software
International Inc. Parallels Virtual Platform/Parallels Virtual Platform
RIP: 0010:[<ffffffff81153daa>]  [<ffffffff81153daa>]
submit_bh+0x41/0x10d
RSP: 0018:ffff880009ce5c48  EFLAGS: 00010202
RAX: 000000000004c225 RBX: ffff880027029410 RCX: ffff880009ce5c68
RDX: 0000000000000000 RSI: ffff880027029410 RDI: 0000000000000111
RBP: ffff880009ce5c68 R08: ffff880009ce5ab8 R09: 0000000000000000
R10: 0000000000000000 R11: 0000000000000000 R12: 0000000000000111
R13: 000000000000002c R14: ffff88002657a160 R15: ffff880009ce4000
FS:  00007f19f8aa4700(0000) GS:ffff88003c800000(0000)
knlGS:0000000000000000
CS:  0010 DS: 0000 ES: 0000 CR0: 000000008005003b
CR2: 00007f19f8a82008 CR3: 00000000056d4000 CR4: 00000000000006e0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400
Process fsstress (pid: 15935, threadinfo ffff880009ce4000, task
ffff88003ba82360)
Stack:
 ffff880009ce5c68 ffff880027029410 0000000000000111 000000000000002c
 ffff880009ce5c88 ffffffff811563fc ffff88002657a000 ffff880009ce5d44
 ffff880009ce5ce8 ffffffffa002ce0e 0000000091827364 ffff8800129469b0
Call Trace:
 [<ffffffff811563fc>] write_dirty_buffer+0x43/0x48
 [<ffffffffa002ce0e>] __flush_batch+0x3f/0x8a [jbd2]
 [<ffffffffa002d7b8>] jbd2_log_do_checkpoint+0x3ab/0x6ff [jbd2]
 [<ffffffffa00310a6>] jbd2_journal_flush+0x98/0x183 [jbd2]
 [<ffffffffa04811f5>] ext4_change_inode_journal_flag+0x53/0xf0 [ext4]
 [<ffffffffa0485855>] ext4_ioctl+0x309/0x80f [ext4]
 [<ffffffff811308f5>] ? cp_new_stat+0xf7/0x10d
 [<ffffffff8113b93c>] do_vfs_ioctl+0x473/0x4f8
 [<ffffffff8112d669>] ? fcheck_files+0x88/0xe1
 [<ffffffff8113ba17>] sys_ioctl+0x56/0x79
 [<ffffffff81444102>] system_call_fastpath+0x16/0x1b
Code: 89 fc 48 89 f3 a8 04 75 04 0f 0b eb fe 48 8b 06 a8 20 75 04 0f 0b
eb fe 48 83 7e 38 00 75 04 0f 0b eb fe 48 8b 06 f6 c4 02 74 04 <0f> 0b
eb fe 48 8b 06 f6 c4 10 74 04 0f 0b eb fe f0 0f ba 2e 03 
RIP  [<ffffffff81153daa>] submit_bh+0x41/0x10d
 RSP <ffff880009ce5c48>
---[ end trace 3ad6c82780724b7c ]---

Re: [PATCH 0/4] ext4: Ping.

[Dmitry Monakhov]

On Tue, 20 Sep 2011 18:49:26 +0400, Dmitry Monakhov <dmonakhov@openvz.org> wrote:
> Hi, finally have some time to run some tests on recent kernels.
> And it appeared that fallocate interface is buggy
>  - fallocate: result in fsck complain due to blocks beyond i_size
>    without  EOFBLOCKS_FL
>  - punch_hole: also provoke fsck complain and even EIO due to
>    incorrect EOFBLOCKS_FL update
> 
Ping.. Tomorrow will be a month since patches was submitted,
Ted, any news, do you have plans to merge it?
PS: testcases was updated and avalable here:
   http://article.gmane.org/gmane.comp.file-systems.ext4/28602
> #LOG:
> #Following two patches are mostly cleanup 
> ext4-cleanup-ext4_ext_grow_indepth-code.patch
> ext4-move-inode-indepth-shrink-logic-to-didicated-fu.patch
> # Later patches are fixes for issues.
> ext4-Do-not-clear-EOFBLOCKS_FL-too-soon.patch
> ext4-fix-punch_hole-extend-handler.patch
> I've also attached my temp testcase for both issues
> Will submit generic xfstests based on it soon.
> 
> ########### TESTCASE###################
> #! /bin/bash
> #############################################################################
> # dmonakhov@openvz.org
> # Trivial fsstress test  
> # TODO: Add to xfstests
> # Required patches
> # kill fsstress reliably
> #  Message-Id: <1316357699-22692-1-git-send-email-dmonakhov@openvz.org>
> # In order unresvsp to work kernel should contain following patch
> #  Message-Id: <1316528400-1797-1-git-send-email-dmonakhov@openvz.org>
> #############################################################################
> # FIXES FOR ext4.git:3.1.0-rc2+
> #0001-ext4-cleanup-ext4_ext_grow_indepth-code.patch
> #0002-ext4-move-inode-indepth-shrink-logic-to-didicated-fu.patch
> #0003-ext4-Do-not-clear-EOFBLOCKS_FL-too-soon.patch
> #0004-ext4-fix-punch_hole-extend-handler.patch
> #############################################################################
> IMG=/dev/sdc
> MNT=./mnt
> #MNT_EXTRA_OPS="-oloop"
> ## Create small image
> #dd if=/dev/zero of=$IMG bs=1M count=1024000
> mkfs.ext4 -F -b4096 $IMG 102400
> mkdir -p $MNT
> mount -text4 $IMG $MNT $MNT_EXTRA_OPS || exit
> ## Run stress
> ~/fsstress -p8 -f fsync=0 -f sync=0 -f fdatasync=0 -f setattr=0  -f unresvsp=2 -d $MNT/TEST -n99999999 &
> PID=$!
> ## dd writers will do write/truncate =>  ENOSPC condition
> for ((i=0;i < 10;i++))
> do
>     dd if=/dev/zero of=$MNT/FILE bs=1M
>     sleep 2
> done
> kill $!
> wait $!
> umount $MNT
> fsck.ext4 -f -n $IMG
>