aboutsummaryrefslogtreecommitdiffstats
path: root/fs/jbd
diff options
context:
space:
mode:
authorakpm@osdl.org <akpm@osdl.org>2005-04-16 18:26:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:26:36 -0400
commitd13df84ff7f3f3e26a9643c1d3cbf94cef9b5b59 (patch)
tree9531a56973381aa48a10fbc7073d1109f380d550 /fs/jbd
parent19272d4385126c2ac369c9f6137a27a08aee50d1 (diff)
[PATCH] jbd dirty buffer leak fix
This fixes the lots-of-fsx-linux-instances-cause-a-slow-leak bug. It's been there since 2.6.6, caused by: ftp://ftp.kernel.org/pub/linux/kernel/people/akpm/patches/2.6/2.6.5/2.6.5-mm4/broken-out/jbd-move-locked-buffers.patch That patch moves under-writeout ordered-data buffers onto a separate journal list during commit. It took out the old code which was based on a single list. The old code (necessarily) had logic which would restart I/O against buffers which had been redirtied while they were on the committing transaction's t_sync_datalist list. The new code only writes buffers once, ignoring redirtyings by a later transaction, which is good. But over on the truncate side of things, in journal_unmap_buffer(), we're treating buffers on the t_locked_list as inviolable things which belong to the committing transaction, and we just leave them alone during concurrent truncate-vs-commit. The net effect is that when truncate tries to invalidate a page whose buffers are on t_locked_list and have been redirtied, journal_unmap_buffer() just leaves those buffers alone. truncate will remove the page from its mapping and we end up with an anonymous clean page with dirty buffers, which is an illegal state for a page. The JBD commit will not clean those buffers as they are removed from t_locked_list. The VM (try_to_free_buffers) cannot reclaim these pages. The patch teaches journal_unmap_buffer() about buffers which are on the committing transaction's t_locked_list. These buffers have been written and I/O has completed. We can take them off the transaction and undirty them within the context of journal_invalidatepage()->journal_unmap_buffer(). Acked-by: "Stephen C. Tweedie" <sct@redhat.com> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Diffstat (limited to 'fs/jbd')
-rw-r--r--fs/jbd/transaction.c13
1 files changed, 11 insertions, 2 deletions
diff --git a/fs/jbd/transaction.c b/fs/jbd/transaction.c
index 932e7c1ef4a1..77b7662b840b 100644
--- a/fs/jbd/transaction.c
+++ b/fs/jbd/transaction.c
@@ -1812,7 +1812,17 @@ static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh)
1812 } 1812 }
1813 } 1813 }
1814 } else if (transaction == journal->j_committing_transaction) { 1814 } else if (transaction == journal->j_committing_transaction) {
1815 /* If it is committing, we simply cannot touch it. We 1815 if (jh->b_jlist == BJ_Locked) {
1816 /*
1817 * The buffer is on the committing transaction's locked
1818 * list. We have the buffer locked, so I/O has
1819 * completed. So we can nail the buffer now.
1820 */
1821 may_free = __dispose_buffer(jh, transaction);
1822 goto zap_buffer;
1823 }
1824 /*
1825 * If it is committing, we simply cannot touch it. We
1816 * can remove it's next_transaction pointer from the 1826 * can remove it's next_transaction pointer from the
1817 * running transaction if that is set, but nothing 1827 * running transaction if that is set, but nothing
1818 * else. */ 1828 * else. */
@@ -1887,7 +1897,6 @@ int journal_invalidatepage(journal_t *journal,
1887 unsigned int next_off = curr_off + bh->b_size; 1897 unsigned int next_off = curr_off + bh->b_size;
1888 next = bh->b_this_page; 1898 next = bh->b_this_page;
1889 1899
1890 /* AKPM: doing lock_buffer here may be overly paranoid */
1891 if (offset <= curr_off) { 1900 if (offset <= curr_off) {
1892 /* This block is wholly outside the truncation point */ 1901 /* This block is wholly outside the truncation point */
1893 lock_buffer(bh); 1902 lock_buffer(bh);