Skip to contentSkip to conversation

retries in ext3_prepare_write() violate ordering requirements

PATCH In review Kirill Korotaev 3 participants 5 messages Nov 10, 2006 – Nov 17, 2006

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 retries in ext3_prepare_write() violate ordering requirements

in journal=ordered or journal=data mode retry in ext3_prepare_write() breaks the requirements of journaling of data with respect to metadata. The fix is to call commit_write to commit allocated zero blocks before retry.

Author: Andrey Savochkin <[email protected]>

fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +62 -10
@@ -1148,37 +1148,89 @@ static int do_journal_get_write_access(h
 	return ext3_journal_get_write_access(handle, bh);
 }
 
+/*
+ * The idea of this helper function is following:
+ * if prepare_write has allocated some blocks, but not all of them, the
+ * transaction must include the content of the newly allocated blocks.
+ * This content is expected to be set to zeroes by block_prepare_write().
+ * 2006/10/14  SAW
+ */
+static int ext3_prepare_failure(struct file *file, struct page *page,
+				unsigned from, unsigned to)
+{
+	struct address_space *mapping;
+	struct buffer_head *bh, *head, *next;
+	unsigned block_start, block_end;
+	unsigned blocksize;
+
+	mapping = page->mapping;
+	if (ext3_should_writeback_data(mapping->host)) {
+		/* optimization: no constraints about data */
+skip:
+		ext3_journal_stop(ext3_journal_current_handle());
+		return 0;
+	}
+
+	head = page_buffers(page);
+	blocksize = head->b_size;
+	for (	bh = head, block_start = 0;
+		bh != head || !block_start;
+	    	block_start = block_end, bh = next)
+	{
+		next = bh->b_this_page;
+		block_end = block_start + blocksize;
+		if (block_end <= from)
+			continue;
+		if (block_start >= to) {
+			block_start = to;
+			break;
+		}
+		if (!buffer_mapped(bh))
+			break;
+	}
+	if (block_start <= from)
+		goto skip;
+
+	/* commit allocated and zeroed buffers */
+	return mapping->a_ops->commit_write(file, page, from, block_start);
+}
+
 static int ext3_prepare_write(struct file *file, struct page *page,
 			      unsigned from, unsigned to)
 {
 	struct inode *inode = page->mapping->host;
-	int ret, needed_blocks = ext3_writepage_trans_blocks(inode);
+	int ret, ret2;
+	int needed_blocks = ext3_writepage_trans_blocks(inode);
 	handle_t *handle;
 	int retries = 0;
 
 retry:
 	handle = ext3_journal_start(inode, needed_blocks);
-	if (IS_ERR(handle)) {
-		ret = PTR_ERR(handle);
-		goto out;
-	}
+	if (IS_ERR(handle))
+		return PTR_ERR(handle);
 	if (test_opt(inode->i_sb, NOBH) && ext3_should_writeback_data(inode))
 		ret = nobh_prepare_write(page, from, to, ext3_get_block);
 	else
 		ret = block_prepare_write(page, from, to, ext3_get_block);
 	if (ret)
-		goto prepare_write_failed;
+		goto failure;
 
 	if (ext3_should_journal_data(inode)) {
 		ret = walk_page_buffers(handle, page_buffers(page),
 				from, to, NULL, do_journal_get_write_access);
+		if (ret)
+			/* fatal error, just put the handle and return */
+			journal_stop(handle);
 	}
-prepare_write_failed:
-	if (ret)
-		ext3_journal_stop(handle);
+	return ret;
+
+failure:
+	ret2 = ext3_prepare_failure(file, page, from, to);
+	if (ret2 < 0)
+		return ret2;
 	if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
 		goto retry;
-out:
+	/* retry number exceeded, or other error like -EDQUOT */
 	return ret;
 }
 
#1 lore raw
Quoted 5 lines · On Fri, 10 Nov 2006 17:55:53 +0300 Kirill Korotaev <[email protected]> wrote:

in journal=ordered or journal=data mode retry in ext3_prepare_write() breaks the requirements of journaling of data with respect to metadata. The fix is to call commit_write to commit allocated zero blocks before retry.

How was this problem detected? (ie: why was block_prepare_write() failing?)

How was the patch tested?

Was nobh-mode also tested?

Quoted 18 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +11 -0
@@ -1148,37 +1148,89 @@ static int do_journal_get_write_access(h
 	return ext3_journal_get_write_access(handle, bh);
 }
 
+/*
+ * The idea of this helper function is following:
+ * if prepare_write has allocated some blocks, but not all of them, the
+ * transaction must include the content of the newly allocated blocks.
+ * This content is expected to be set to zeroes by block_prepare_write().
+ * 2006/10/14  SAW
+ */
+static int ext3_prepare_failure(struct file *file, struct page *page,
+				unsigned from, unsigned to)
+{
+	struct address_space *mapping;

fs/ext3/inode.c static int do_journal_get_write_access(h · line 1171

Quoted 10 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +10 -0
+	struct buffer_head *bh, *head, *next;
+	unsigned block_start, block_end;
+	unsigned blocksize;
+
+	mapping = page->mapping;
+	if (ext3_should_writeback_data(mapping->host)) {
+		/* optimization: no constraints about data */
+skip:
+		ext3_journal_stop(ext3_journal_current_handle());
+		return 0;

Should this be `return ext3_journal_stop(...);'?

Quoted 8 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +8 -0
+	}
+
+	head = page_buffers(page);
+	blocksize = head->b_size;
+	for (	bh = head, block_start = 0;
+		bh != head || !block_start;
+	    	block_start = block_end, bh = next)
+	{

fs/ext3/inode.c static int do_journal_get_write_access(h · line 1189

Quoted 10 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +10 -0
+		next = bh->b_this_page;
+		block_end = block_start + blocksize;
+		if (block_end <= from)
+			continue;
+		if (block_start >= to) {
+			block_start = to;
+			break;
+		}
+		if (!buffer_mapped(bh))
+			break;

What is the significance of buffer_mapped() here? Outside EOF or into a hole? If so, then block_start >= to, and we can't get here??

Quoted 57 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +23 -10
+	}
+	if (block_start <= from)
+		goto skip;
+
+	/* commit allocated and zeroed buffers */
+	return mapping->a_ops->commit_write(file, page, from, block_start);
+}
+
 static int ext3_prepare_write(struct file *file, struct page *page,
 			      unsigned from, unsigned to)
 {
 	struct inode *inode = page->mapping->host;
-	int ret, needed_blocks = ext3_writepage_trans_blocks(inode);
+	int ret, ret2;
+	int needed_blocks = ext3_writepage_trans_blocks(inode);
 	handle_t *handle;
 	int retries = 0;
 
 retry:
 	handle = ext3_journal_start(inode, needed_blocks);
-	if (IS_ERR(handle)) {
-		ret = PTR_ERR(handle);
-		goto out;
-	}
+	if (IS_ERR(handle))
+		return PTR_ERR(handle);
 	if (test_opt(inode->i_sb, NOBH) && ext3_should_writeback_data(inode))
 		ret = nobh_prepare_write(page, from, to, ext3_get_block);
 	else
 		ret = block_prepare_write(page, from, to, ext3_get_block);
 	if (ret)
-		goto prepare_write_failed;
+		goto failure;
 
 	if (ext3_should_journal_data(inode)) {
 		ret = walk_page_buffers(handle, page_buffers(page),
 				from, to, NULL, do_journal_get_write_access);
+		if (ret)
+			/* fatal error, just put the handle and return */
+			journal_stop(handle);
 	}
-prepare_write_failed:
-	if (ret)
-		ext3_journal_stop(handle);
+	return ret;
+
+failure:
+	ret2 = ext3_prepare_failure(file, page, from, to);
+	if (ret2 < 0)
+		return ret2;
 	if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
 		goto retry;
-out:
+	/* retry number exceeded, or other error like -EDQUOT */
 	return ret;
 }
 
#2 lore raw

Andrew,

Quoted 8 lines
Quoted 5 lines

in journal=ordered or journal=data mode retry in ext3_prepare_write() breaks the requirements of journaling of data with respect to metadata. The fix is to call commit_write to commit allocated zero blocks before retry.

How was this problem detected? (ie: why was block_prepare_write() failing?)

purely theoretically while hunting for other bugs related to ext3 and quota. block_prepare_write() can fail e.g. if quota returns -EDQUOT in ext3_alloc_blocks().

Quoted 1 line

How was the patch tested?

1. it was tested as part of OpenVZ kernel
2. there were ext3 stress test done with lots of disk activity by Dmitry Monakhov.

Quoted 1 line

Was nobh-mode also tested?

I will ask to perform some more tests 100% triggering ext3_prepare_failure() and with NOBH mode.

Thanks,
Kirill

Quoted 115 lines
Quoted 17 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +11 -0
@@ -1148,37 +1148,89 @@ static int do_journal_get_write_access(h
 	return ext3_journal_get_write_access(handle, bh);
 }
 
+/*
+ * The idea of this helper function is following:
+ * if prepare_write has allocated some blocks, but not all of them, the
+ * transaction must include the content of the newly allocated blocks.
+ * This content is expected to be set to zeroes by block_prepare_write().
+ * 2006/10/14  SAW
+ */
+static int ext3_prepare_failure(struct file *file, struct page *page,
+				unsigned from, unsigned to)
+{
+	struct address_space *mapping;

fs/ext3/inode.c static int do_journal_get_write_access(h · line 1171

Quoted 10 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +10 -0
+	struct buffer_head *bh, *head, *next;
+	unsigned block_start, block_end;
+	unsigned blocksize;
+
+	mapping = page->mapping;
+	if (ext3_should_writeback_data(mapping->host)) {
+		/* optimization: no constraints about data */
+skip:
+		ext3_journal_stop(ext3_journal_current_handle());
+		return 0;

Should this be `return ext3_journal_stop(...);'?

Quoted 8 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +8 -0
+	}
+
+	head = page_buffers(page);
+	blocksize = head->b_size;
+	for (	bh = head, block_start = 0;
+		bh != head || !block_start;
+	    	block_start = block_end, bh = next)
+	{

fs/ext3/inode.c static int do_journal_get_write_access(h · line 1189

Quoted 10 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +10 -0
+		next = bh->b_this_page;
+		block_end = block_start + blocksize;
+		if (block_end <= from)
+			continue;
+		if (block_start >= to) {
+			block_start = to;
+			break;
+		}
+		if (!buffer_mapped(bh))
+			break;

What is the significance of buffer_mapped() here? Outside EOF or into a hole? If so, then block_start >= to, and we can't get here??

Quoted 57 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +10 -1
+	}
+	if (block_start <= from)
+		goto skip;
+
+	/* commit allocated and zeroed buffers */
+	return mapping->a_ops->commit_write(file, page, from, block_start);
+}
+
 static int ext3_prepare_write(struct file *file, struct page *page,
 			      unsigned from, unsigned to)
 {
 	struct inode *inode = page->mapping->host;
-	int ret, needed_blocks = ext3_writepage_trans_blocks(inode);
+	int ret, ret2;
+	int needed_blocks = ext3_writepage_trans_blocks(inode);
 	handle_t *handle;
 	int retries = 0;
 

retry:

	handle = ext3_journal_start(inode, needed_blocks);
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +2 -4
-	if (IS_ERR(handle)) {
-		ret = PTR_ERR(handle);
-		goto out;
-	}
+	if (IS_ERR(handle))
+		return PTR_ERR(handle);
	if (test_opt(inode->i_sb, NOBH) && ext3_should_writeback_data(inode))
		ret = nobh_prepare_write(page, from, to, ext3_get_block);
	else
		ret = block_prepare_write(page, from, to, ext3_get_block);
	if (ret)
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +1 -1
-		goto prepare_write_failed;
+		goto failure;
	if (ext3_should_journal_data(inode)) {
		ret = walk_page_buffers(handle, page_buffers(page),
				from, to, NULL, do_journal_get_write_access);
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +3 -0
+		if (ret)
+			/* fatal error, just put the handle and return */
+			journal_stop(handle);
	}
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +6 -3
-prepare_write_failed:
-	if (ret)
-		ext3_journal_stop(handle);
+	return ret;
+
+failure:
+	ret2 = ext3_prepare_failure(file, page, from, to);
+	if (ret2 < 0)
+		return ret2;
	if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
		goto retry;
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +1 -1
-out:
+	/* retry number exceeded, or other error like -EDQUOT */
	return ret;
}
#3 lore raw

Andrew,

Dmitry confirmed that it works in NOBH mode as well and when quota limit is hit.

Thanks,
Kirill

Quoted 156 lines

Andrew,

Quoted 8 lines
Quoted 5 lines

in journal=ordered or journal=data mode retry in ext3_prepare_write() breaks the requirements of journaling of data with respect to metadata. The fix is to call commit_write to commit allocated zero blocks before retry.

How was this problem detected? (ie: why was block_prepare_write() failing?)

purely theoretically while hunting for other bugs related to ext3 and quota. block_prepare_write() can fail e.g. if quota returns -EDQUOT in ext3_alloc_blocks().

Quoted 1 line

How was the patch tested?

1. it was tested as part of OpenVZ kernel
2. there were ext3 stress test done with lots of disk activity by Dmitry Monakhov.

Quoted 1 line

Was nobh-mode also tested?

I will ask to perform some more tests 100% triggering ext3_prepare_failure() and with NOBH mode.

Thanks,
Kirill

Quoted 107 lines
Quoted 17 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +11 -0
@@ -1148,37 +1148,89 @@ static int do_journal_get_write_access(h
 	return ext3_journal_get_write_access(handle, bh);
 }
 
+/*
+ * The idea of this helper function is following:
+ * if prepare_write has allocated some blocks, but not all of them, the
+ * transaction must include the content of the newly allocated blocks.
+ * This content is expected to be set to zeroes by block_prepare_write().
+ * 2006/10/14  SAW
+ */
+static int ext3_prepare_failure(struct file *file, struct page *page,
+				unsigned from, unsigned to)
+{
+	struct address_space *mapping;

fs/ext3/inode.c static int do_journal_get_write_access(h · line 1171

Quoted 10 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +10 -0
+	struct buffer_head *bh, *head, *next;
+	unsigned block_start, block_end;
+	unsigned blocksize;
+
+	mapping = page->mapping;
+	if (ext3_should_writeback_data(mapping->host)) {
+		/* optimization: no constraints about data */
+skip:
+		ext3_journal_stop(ext3_journal_current_handle());
+		return 0;

Should this be `return ext3_journal_stop(...);'?

Quoted 8 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +8 -0
+	}
+
+	head = page_buffers(page);
+	blocksize = head->b_size;
+	for (	bh = head, block_start = 0;
+		bh != head || !block_start;
+	    	block_start = block_end, bh = next)
+	{

fs/ext3/inode.c static int do_journal_get_write_access(h · line 1189

Quoted 10 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +10 -0
+		next = bh->b_this_page;
+		block_end = block_start + blocksize;
+		if (block_end <= from)
+			continue;
+		if (block_start >= to) {
+			block_start = to;
+			break;
+		}
+		if (!buffer_mapped(bh))
+			break;

What is the significance of buffer_mapped() here? Outside EOF or into a hole? If so, then block_start >= to, and we can't get here??

Quoted 49 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +10 -1
+	}
+	if (block_start <= from)
+		goto skip;
+
+	/* commit allocated and zeroed buffers */
+	return mapping->a_ops->commit_write(file, page, from, block_start);
+}
+
 static int ext3_prepare_write(struct file *file, struct page *page,
 			      unsigned from, unsigned to)
 {
 	struct inode *inode = page->mapping->host;
-	int ret, needed_blocks = ext3_writepage_trans_blocks(inode);
+	int ret, ret2;
+	int needed_blocks = ext3_writepage_trans_blocks(inode);
 	handle_t *handle;
 	int retries = 0;
 

retry:

	handle = ext3_journal_start(inode, needed_blocks);
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +2 -4
-	if (IS_ERR(handle)) {
-		ret = PTR_ERR(handle);
-		goto out;
-	}
+	if (IS_ERR(handle))
+		return PTR_ERR(handle);
	if (test_opt(inode->i_sb, NOBH) && ext3_should_writeback_data(inode))
		ret = nobh_prepare_write(page, from, to, ext3_get_block);
	else
		ret = block_prepare_write(page, from, to, ext3_get_block);
	if (ret)
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +1 -1
-		goto prepare_write_failed;
+		goto failure;
	if (ext3_should_journal_data(inode)) {
		ret = walk_page_buffers(handle, page_buffers(page),
				from, to, NULL, do_journal_get_write_access);
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +3 -0
+		if (ret)
+			/* fatal error, just put the handle and return */
+			journal_stop(handle);
	}
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +5 -3
-prepare_write_failed:
-	if (ret)
-		ext3_journal_stop(handle);
+	return ret;
+
+failure:
+	ret2 = ext3_prepare_failure(file, page, from, to);
+	if (ret2 < 0)
Quoted 10 lines
Quoted 8 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +1 -0
+		return ret2;
	if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
		goto retry;
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +1 -1
-out:
+	/* retry number exceeded, or other error like -EDQUOT */
	return ret;
}

-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/

#4 lore raw
In reply to Andrew Morton

Andrew,

answers on your questions.

Quoted 7 lines
Quoted 5 lines

in journal=ordered or journal=data mode retry in ext3_prepare_write() breaks the requirements of journaling of data with respect to metadata. The fix is to call commit_write to commit allocated zero blocks before retry.

Quoted 5 lines

How was this problem detected? (ie: why was block_prepare_write() failing?)

How was the patch tested?

Was nobh-mode also tested?

with nobh block size can't be less than page size, so all the problems with retries disappear and our code will be a no-op.

Quoted 22 lines
Quoted 22 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +16 -0
@@ -1148,37 +1148,89 @@ static int do_journal_get_write_access(h
 	return ext3_journal_get_write_access(handle, bh);
 }
 
+/*
+ * The idea of this helper function is following:
+ * if prepare_write has allocated some blocks, but not all of them, the
+ * transaction must include the content of the newly allocated blocks.
+ * This content is expected to be set to zeroes by block_prepare_write().
+ * 2006/10/14  SAW
+ */
+static int ext3_prepare_failure(struct file *file, struct page *page,
+				unsigned from, unsigned to)
+{
+	struct address_space *mapping;
+	struct buffer_head *bh, *head, *next;
+	unsigned block_start, block_end;
+	unsigned blocksize;
+
+	mapping = page->mapping;
Quoted 8 lines

fs/ext3/inode.c static int do_journal_get_write_access(h · line 1171

Quoted 5 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +5 -0
+	if (ext3_should_writeback_data(mapping->host)) {
+		/* optimization: no constraints about data */
+skip:
+		ext3_journal_stop(ext3_journal_current_handle());
+		return 0;

Should this be `return ext3_journal_stop(...);'?

will fix and send an incremental patch to you.

Quoted 9 lines
Quoted 9 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +9 -0
+	}
+
+	head = page_buffers(page);
+	blocksize = head->b_size;
+	for (	bh = head, block_start = 0;
+		bh != head || !block_start;
+	    	block_start = block_end, bh = next)
+	{
+		next = bh->b_this_page;
Quoted 8 lines

fs/ext3/inode.c static int do_journal_get_write_access(h · line 1188

Quoted 8 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +8 -0
+		block_end = block_start + blocksize;
+		if (block_end <= from)
+			continue;
+		if (block_start >= to) {
+			block_start = to;
+			break;
+		}
+		if (!buffer_mapped(bh))

<<<< /* prepare_write failed on this bh */

Quoted 1 line

fs/ext3/inode.c static int do_journal_get_write_access(h · line 1189

Quoted 1 line
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +1 -0
+			break;

<<<< lost here:

	if (ext3_should_journal_data(inode)) {
		ret = do_journal_get_write_access(XXX);
		if (ret) {
			journal_stop(handle);
			return ret;
		}
	}
Quoted 3 lines

What is the significance of buffer_mapped() here? Outside EOF or into a hole? If so, then block_start >= to, and we can't get here??

/*
* block_start here becomes the first block where the current iteration
* of prepare_write failed.
*/

Quoted 49 lines
Quoted 49 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +10 -1
+	}
+	if (block_start <= from)
+		goto skip;
+
+	/* commit allocated and zeroed buffers */
+	return mapping->a_ops->commit_write(file, page, from, block_start);
+}
+
 static int ext3_prepare_write(struct file *file, struct page *page,
 			      unsigned from, unsigned to)
 {
 	struct inode *inode = page->mapping->host;
-	int ret, needed_blocks = ext3_writepage_trans_blocks(inode);
+	int ret, ret2;
+	int needed_blocks = ext3_writepage_trans_blocks(inode);
 	handle_t *handle;
 	int retries = 0;
 

retry:

	handle = ext3_journal_start(inode, needed_blocks);
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +2 -4
-	if (IS_ERR(handle)) {
-		ret = PTR_ERR(handle);
-		goto out;
-	}
+	if (IS_ERR(handle))
+		return PTR_ERR(handle);
	if (test_opt(inode->i_sb, NOBH) && ext3_should_writeback_data(inode))
		ret = nobh_prepare_write(page, from, to, ext3_get_block);
	else
		ret = block_prepare_write(page, from, to, ext3_get_block);
	if (ret)
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +1 -1
-		goto prepare_write_failed;
+		goto failure;
	if (ext3_should_journal_data(inode)) {
		ret = walk_page_buffers(handle, page_buffers(page),
				from, to, NULL, do_journal_get_write_access);
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +3 -0
+		if (ret)
+			/* fatal error, just put the handle and return */
+			journal_stop(handle);
	}
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +5 -3
-prepare_write_failed:
-	if (ret)
-		ext3_journal_stop(handle);
+	return ret;
+
+failure:
+	ret2 = ext3_prepare_failure(file, page, from, to);
+	if (ret2 < 0)
Quoted 8 lines
Quoted 8 lines
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +1 -0
+		return ret2;
	if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
		goto retry;
fs/ext3/inode.c renamed from fs/ext3/inode.c.ext3pw +1 -1
-out:
+	/* retry number exceeded, or other error like -EDQUOT */
	return ret;
}

Kirill