ext4: Fix transaction overflow due to revoke descriptors
Subsystems (5)
Jan Kara
reviewercover ext4: Fix transaction overflow due to revoke descriptors
Hello,
I've recently got a bug report where JBD2 assertion failed due to transaction commit running out of journal space. After closer inspection of the crash dump it seems that the problem is that there were too many journal descriptor blocks (more that max_transaction_size >> 5 + 32 we estimate in jbd2_log_space_left()) due to descriptor blocks with revoke records. In fact the estimate on the number of descriptor blocks looks pretty arbitrary and there can be much more descriptor blocks needed for revoke records. We need one revoke record for every metadata block freed. So in the worst case (1k blocksize, 64-bit journal feature enabled, checksumming enabled) we fit 125 revoke record in one descriptor block. In common cases its about 500 revoke records per descriptor block. Now when we free large directories or large file with data journalling enabled, we can have *lots* of blocks to revoke - with extent mapped files easily millions in a single transaction which can mean 10k descriptor blocks - clearly more than the estimate of 128 descriptor blocks per transaction ;)
This patch series aims at fixing the problem by accounting descriptor blocks into transaction credits and reserving appropriate amount of credits for revoke descriptors on transaction handle start. Similar to normal transaction credits, the filesystem has to provide estimate for the number of blocks it is going to revoke using the transaction handle so that credits for revoke descriptors can be reserved.
The series has survived fstests in couple configurations and also the stress test of deleting large files in -o nodelalloc,data=journal configuration which reliably triggers the assertion failure in JBD2 on unpatched kernel.
Review and comments are welcome :).
Honza
Jan Kara
reviewerPATCH 1/15 jbd2: Fix possible overflow in jbd2_log_space_left()
When number of free space in the journal is very low, the arithmetic in jbd2_log_space_left() could underflow resulting in very high number of free blocks and thus triggering assertion failure in transaction commit code complaining there's not enough space in the journal:
J_ASSERT(journal->j_free > 1);
Properly check for the low number of free blocks.
--- include/linux/jbd2.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
include/linux/jbd2.h +2 -2
@@ -1584,7 +1584,7 @@ static inline int jbd2_space_needed(journal_t *journal) static inline unsigned long jbd2_log_space_left(journal_t *journal) { /* Allow for rounding errors */ - unsigned long free = journal->j_free - 32; + long free = journal->j_free - 32; if (journal->j_committing_transaction) { unsigned long committing = atomic_read(&journal->
@@ -1593,7 +1593,7 @@ static inline unsigned long jbd2_log_space_left(journal_t *journal)/* Transaction + control blocks */ free -= committing + (committing >>JBD2_CONTROL_BLOCKS_SHIFT ); } -return free; +return max_t (long, free,0 ); }/*
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 2/15 jbd2: Fixup stale comment in commit code
In reply to Jan Karajbd2_journal_next_log_block() does not look at transaction->t_outstanding_credits. Remove the misleading comment.
--- fs/jbd2/commit.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/jbd2/commit.c +1 -2
@@ -642,8 +642,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)/* * start_this_handle() uses t_outstanding_credits to determine -* the free space in the log, but this counter is changed -* by jbd2_journal_next_log_block() also. +* the free space in the log. */ atomic_dec (&commit_transaction->t_outstanding_credits);
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 3/15 ext4: Do not iput inode under running transaction in ext4_mkdir()
In reply to Jan KaraWhen ext4_mkdir() fails to add entry into directory, it ends up dropping freshly created inode under the running transaction and thus inode truncation happens under that transaction. That breaks assumptions that ext4_evict_inode() does not get called from a transaction context (although I'm not aware of any real issue) and is completely unnecessary. Just stop the transaction before dropping inode reference.
--- fs/ext4/namei.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
fs/ext4/namei.c +3 -1
@@ -2781,8 +2781,9 @@ static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)clear_nlink (inode);unlock_new_inode (inode);ext4_mark_inode_dirty (handle, inode); +ext4_journal_stop (handle);iput (inode); - goto out_stop; + goto out_retry; }ext4_inc_count (handle, dir);ext4_update_dx_flag (dir);
@@ -2796,6 +2797,7 @@ static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) out_stop:if (handle)ext4_journal_stop (handle); +out_retry:if (err == -ENOSPC &&ext4_should_retry_alloc (dir->i_sb, &retries)) goto retry;return err;
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 4/15 ext4: Use ext4_journal_extend() instead of jbd2_journal_extend()
In reply to Jan KaraUse ext4 helper ext4_journal_extend() instead of opencoding it in ext4_try_to_expand_extra_isize().
--- fs/ext4/inode.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/ext4/inode.c +1 -2
@@ -5989,8 +5989,7 @@ static int ext4_try_to_expand_extra_isize(struct inode *inode,* If this is felt to be critical, then e2fsck should be run to * force a large enough s_min_extra_isize. */ -if (ext4_handle_valid (handle) && -jbd2_journal_extend (handle, +if (ext4_journal_extend (handle,EXT4_DATA_TRANS_BLOCKS (inode->i_sb)) !=0 )return -ENOSPC ;
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 5/15 jbd2: Reorganize jbd2_journal_stop()
In reply to Jan KaraMove code in jbd2_journal_stop() around a bit. It removes some unnecessary code duplication and will make factoring out parts common with jbd2__journal_restart() easier.
--- fs/jbd2/transaction.c | 40 ++++++++++++++++------------------------ 1 file changed, 16 insertions(+), 24 deletions(-)
fs/jbd2/transaction.c +16 -24
@@ -1703,41 +1703,34 @@ int jbd2_journal_stop(handle_t *handle)tid_t tid;pid_t pid; +if (--handle->h_ref >0 ) { +jbd_debug (4 ,"h_ref %d -> %d\n" , handle->h_ref +1 , + handle->h_ref); +if (is_handle_aborted (handle)) +return -EIO ; +return 0 ; + }if (!transaction) {/* -* Handle is already detached from the transaction so -* there is nothing to do other than decrease a refcount, -* or free the handle if refcount drops to zero +* Handle is already detached from the transaction so there is +* nothing to do other than free the handle. */ -if (--handle->h_ref >0 ) { -jbd_debug (4 ,"h_ref %d -> %d\n" , handle->h_ref +1 , - handle->h_ref); -return err; - }else { -if (handle->h_rsv_handle) -jbd2_free_handle (handle->h_rsv_handle); - goto free_and_exit; - } +if (handle->h_rsv_handle) +jbd2_free_handle (handle->h_rsv_handle); + goto free_and_exit; } journal = transaction->t_journal; + tid = transaction->t_tid;J_ASSERT (journal_current_handle () == handle); +J_ASSERT (atomic_read (&transaction->t_updates) >0 );if (is_handle_aborted (handle)) err = -EIO ; -else -J_ASSERT (atomic_read (&transaction->t_updates) >0 ); - -if (--handle->h_ref >0 ) { -jbd_debug (4 ,"h_ref %d -> %d\n" , handle->h_ref +1 , - handle->h_ref); -return err; - }jbd_debug (4 ,"Handle %p going down\n" , handle); trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev, - transaction->t_tid, - handle->h_type, handle->h_line_no, + tid, handle->h_type, handle->h_line_no, jiffies - handle->h_start_jiffies, handle->h_sync, handle->h_requested_credits, (handle->h_requested_credits -
@@ -1822,7 +1815,7 @@ int jbd2_journal_stop(handle_t *handle)jbd_debug (2 ,"transaction too old, requesting commit for " "handle %p\n" , handle);/* This is non-blocking */ -jbd2_log_start_commit (journal, transaction->t_tid); +jbd2_log_start_commit (journal, tid);/* * Special case: JBD2_SYNC synchronous updates require us
@@ -1838,7 +1831,6 @@ int jbd2_journal_stop(handle_t *handle)* once we do this, we must not dereference transaction * pointer again. */ - tid = transaction->t_tid;if (atomic_dec_and_test (&transaction->t_updates)) {wake_up (&journal->j_wait_updates);if (journal->j_barrier_count)
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 6/15 jbd2: Drop pointless check from jbd2_journal_stop()
In reply to Jan KaraIf a transaction is larger than journal->j_max_transaction_buffers, that is a bug and not a trigger for transaction commit. Also the very next attempt to start new handle will start transaction commit anyway. So just remove the pointless check. Arguably, we could start transaction commit whenever the transaction size is *close* to journal->j_max_transaction_buffers. This has a potential to reduce latency of the next jbd2_journal_start() at the cost of somewhat smaller transactions. However for this to have any effect, it would mean that there isn't someone already waiting in jbd2_journal_start() which means metadata load for the fs is pretty light anyway so probably this optimization is not worth it.
--- fs/jbd2/transaction.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
fs/jbd2/transaction.c +2 -5
@@ -1800,13 +1800,10 @@ int jbd2_journal_stop(handle_t *handle)/* * If the handle is marked SYNC, we need to set another commit -* going! We also want to force a commit if the current -* transaction is occupying too much of the log, or if the -* transaction is too old now. +* going! We also want to force a commit if the transaction is too +* old now. */ if (handle->h_sync || - (atomic_read (&transaction->t_outstanding_credits) > - journal->j_max_transaction_buffers) ||time_after_eq (jiffies, transaction->t_expires)) {/* Do this even for aborted journals: an abort still * completes the commit thread, it just doesn't write
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 7/15 jbd2: Drop pointless wakeup from jbd2_journal_stop()
In reply to Jan KaraWhen we drop last handle from a transaction and journal->j_barrier_count
Quoted 1 line
0,
jbd2_journal_stop()wakes upjournal->j_wait_transaction_locked
wait queue. This looks pointless - wait for outstanding handles always happens on journal->j_wait_updates waitqueue. journal->j_wait_transaction_locked is used to wait for transaction state changes and by start_this_handle() for waiting until journal->j_barrier_count drops to 0. The first case is clearly irrelevant here since only jbd2 thread changes transaction state. The second case looks related but jbd2_journal_unlock_updates() is responsible for the wakeup in this case. So just drop the wakeup.
--- fs/jbd2/transaction.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-)
fs/jbd2/transaction.c +1 -4
@@ -1828,11 +1828,8 @@ int jbd2_journal_stop(handle_t *handle)* once we do this, we must not dereference transaction * pointer again. */ -if (atomic_dec_and_test (&transaction->t_updates)) { +if (atomic_dec_and_test (&transaction->t_updates))wake_up (&journal->j_wait_updates); -if (journal->j_barrier_count) -wake_up (&journal->j_wait_transaction_locked); - }rwsem_release (&journal->j_trans_commit_map,1 , _THIS_IP_);
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 8/15 jbd2: Factor out common parts of stopping and restarting a handle
In reply to Jan Karajbd2__journal_restart() has quite some code that is common with jbd2_journal_stop(). Factor this functionality into stop_this_handle() helper and use it from both functions. Note that this also drops t_handle_lock protection from jbd2__journal_restart() as jbd2_journal_stop() does the same thing without it.
--- fs/jbd2/transaction.c | 94 +++++++++++++++++++++++---------------------------- 1 file changed, 42 insertions(+), 52 deletions(-)
fs/jbd2/transaction.c +42 -52
@@ -512,12 +512,17 @@ handle_t *jbd2_journal_start(journal_t *journal, int nblocks) }EXPORT_SYMBOL (jbd2_journal_start); -void jbd2_journal_free_reserved (handle_t *handle) +static void __jbd2_journal_unreserve_handle (handle_t *handle) {journal_t *journal = handle->h_journal;WARN_ON (!handle->h_reserved);sub_reserved_credits (journal, handle->h_buffer_credits); +} + +void jbd2_journal_free_reserved (handle_t *handle) +{ +__jbd2_journal_unreserve_handle (handle);jbd2_free_handle (handle); }EXPORT_SYMBOL (jbd2_journal_free_reserved);
@@ -652,6 +657,28 @@ int jbd2_journal_extend(handle_t *handle, int nblocks)return result; } +static void stop_this_handle (handle_t *handle) +{ +transaction_t *transaction = handle->h_transaction; +journal_t *journal = transaction->t_journal; + +J_ASSERT (journal_current_handle () == handle); +J_ASSERT (atomic_read (&transaction->t_updates) >0 ); + current->journal_info =NULL ; +atomic_sub (handle->h_buffer_credits, + &transaction->t_outstanding_credits); +if (handle->h_rsv_handle) +__jbd2_journal_unreserve_handle (handle->h_rsv_handle); +if (atomic_dec_and_test (&transaction->t_updates)) +wake_up (&journal->j_wait_updates); + +rwsem_release (&journal->j_trans_commit_map,1 , _THIS_IP_); +/* +* Scope of the GFP_NOFS context is over here and so we can restore the +* original alloc context. +*/ +memalloc_nofs_restore (handle->saved_alloc_context); +}/** * int jbd2_journal_restart() - restart a handle .
@@ -674,52 +701,30 @@ int jbd2__journal_restart(handle_t *handle, int nblocks, gfp_t gfp_mask)transaction_t *transaction = handle->h_transaction;journal_t *journal;tid_t tid; -int need_to_start, ret; +int need_to_start;/* If we've had an abort of any type, don't even think about * actually doing the restart! */ if (is_handle_aborted (handle))return 0 ; journal = transaction->t_journal; + tid = transaction->t_tid;/* * First unlink the handle from its current transaction, and start the * commit on that. */ -J_ASSERT (atomic_read (&transaction->t_updates) >0 ); -J_ASSERT (journal_current_handle () == handle); - -read_lock (&journal->j_state_lock); -spin_lock (&transaction->t_handle_lock); -atomic_sub (handle->h_buffer_credits, - &transaction->t_outstanding_credits); -if (handle->h_rsv_handle) { -sub_reserved_credits (journal, - handle->h_rsv_handle->h_buffer_credits); - } -if (atomic_dec_and_test (&transaction->t_updates)) -wake_up (&journal->j_wait_updates); - tid = transaction->t_tid; -spin_unlock (&transaction->t_handle_lock); +jbd_debug (2 ,"restarting handle %p\n" , handle); +stop_this_handle (handle); handle->h_transaction =NULL ; - current->journal_info =NULL ; -jbd_debug (2 ,"restarting handle %p\n" , handle); +read_lock (&journal->j_state_lock); need_to_start = !tid_geq (journal->j_commit_request, tid);read_unlock (&journal->j_state_lock);if (need_to_start)jbd2_log_start_commit (journal, tid); - -rwsem_release (&journal->j_trans_commit_map,1 , _THIS_IP_); handle->h_buffer_credits = nblocks; -/* -* Restore the original nofs context because the journal restart -* is basically the same thing as journal stop and start. -* start_this_handle will start a new nofs context. -*/ -memalloc_nofs_restore (handle->saved_alloc_context); - ret =start_this_handle (journal, handle, gfp_mask); -return ret; +return start_this_handle (journal, handle, gfp_mask); }EXPORT_SYMBOL (jbd2__journal_restart);
@@ -1715,16 +1720,12 @@ int jbd2_journal_stop(handle_t *handle)* Handle is already detached from the transaction so there is * nothing to do other than free the handle. */ -if (handle->h_rsv_handle) -jbd2_free_handle (handle->h_rsv_handle); +memalloc_nofs_restore (handle->saved_alloc_context); goto free_and_exit; } journal = transaction->t_journal; tid = transaction->t_tid; -J_ASSERT (journal_current_handle () == handle); -J_ASSERT (atomic_read (&transaction->t_updates) >0 ); -if (is_handle_aborted (handle)) err = -EIO ;
@@ -1794,9 +1795,6 @@ int jbd2_journal_stop(handle_t *handle)if (handle->h_sync) transaction->t_synchronous_commit =1 ; - current->journal_info =NULL ; -atomic_sub (handle->h_buffer_credits, - &transaction->t_outstanding_credits);/* * If the handle is marked SYNC, we need to set another commit
@@ -1823,27 +1821,19 @@ int jbd2_journal_stop(handle_t *handle) }/* -* Once we drop t_updates, if it goes to zero the transaction -* could start committing on us and eventually disappear. So -* once we do this, we must not dereference transaction -* pointer again. +* Once stop_this_handle() drops t_updates, the transaction could start +* committing on us and eventually disappear. So we must not +* dereference transaction pointer again after calling +* stop_this_handle(). */ -if (atomic_dec_and_test (&transaction->t_updates)) -wake_up (&journal->j_wait_updates); - -rwsem_release (&journal->j_trans_commit_map,1 , _THIS_IP_); +stop_this_handle (handle);if (wait_for_commit) err =jbd2_log_wait_commit (journal, tid); -if (handle->h_rsv_handle) -jbd2_journal_free_reserved (handle->h_rsv_handle); free_and_exit: -/* -* Scope of the GFP_NOFS context is over here and so we can restore the -* original alloc context. -*/ -memalloc_nofs_restore (handle->saved_alloc_context); +if (handle->h_rsv_handle) +jbd2_free_handle (handle->h_rsv_handle);jbd2_free_handle (handle);return err; }
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 9/15 jbd2: Account descriptor blocks into t_outstanding_credits
In reply to Jan KaraCurrently, journal descriptor blocks were not accounted in transaction->t_outstanding_credits and we were just leaving some slack space in the journal for them (in jbd2_log_space_left() and jbd2_space_needed()). This is making proper accounting (and reservation we want to add) of descriptor blocks difficult so switch to accounting descriptor blocks in transaction->t_outstanding_credits and just reserve the same amount of credits in t_outstanding credits for journal descriptor blocks when creating transaction.
--- fs/jbd2/commit.c | 3 +++ fs/jbd2/journal.c | 1 + fs/jbd2/transaction.c | 20 ++++++++++++-------- include/linux/jbd2.h | 16 +++------------- 4 files changed, 19 insertions(+), 21 deletions(-)
fs/jbd2/commit.c +3 -0
@@ -887,6 +887,9 @@ void jbd2_journal_commit_transaction(journal_t *journal)if (err)jbd2_journal_abort (journal, err); +WARN_ON_ONCE ( +atomic_read (&commit_transaction->t_outstanding_credits) <0 ); +/* * Now disk caches for filesystem device are flushed so we are safe to * erase checkpointed transactions from the log by updating journal
fs/jbd2/journal.c +1 -0
@@ -842,6 +842,7 @@ jbd2_journal_get_descriptor_buffer(transaction_t *transaction, int type) bh =__getblk (journal->j_dev, blocknr, journal->j_blocksize);if (!bh)return NULL ; +atomic_dec (&transaction->t_outstanding_credits);lock_buffer (bh);memset (bh->b_data,0 , journal->j_blocksize); header = (journal_header_t *)bh->b_data;
fs/jbd2/transaction.c +12 -8
@@ -62,6 +62,17 @@ void jbd2_journal_free_transaction(transaction_t *transaction)kmem_cache_free (transaction_cache, transaction); } +/* +* We reserve t_outstanding_credits >> JBD2_CONTROL_BLOCKS_SHIFT for +* transaction descriptor blocks. +*/ +#define JBD2_CONTROL_BLOCKS_SHIFT 5 + +static int jbd2_descriptor_blocks_per_trans (journal_t *journal) +{ +return journal->j_max_transaction_buffers >>JBD2_CONTROL_BLOCKS_SHIFT ; +} +/* * jbd2_get_transaction: obtain a new transaction_t object. *
@@ -88,6 +99,7 @@ static void jbd2_get_transaction(journal_t *journal,spin_lock_init (&transaction->t_handle_lock);atomic_set (&transaction->t_updates,0 );atomic_set (&transaction->t_outstanding_credits, +jbd2_decriptor_blocks_per_trans (journal) +atomic_read (&journal->j_reserved_credits));atomic_set (&transaction->t_handle_count,0 );INIT_LIST_HEAD (&transaction->t_inode_list);
@@ -631,14 +643,6 @@ int jbd2_journal_extend(handle_t *handle, int nblocks) goto unlock; } -if (wanted + (wanted >>JBD2_CONTROL_BLOCKS_SHIFT ) > -jbd2_log_space_left (journal)) { -jbd_debug (3 ,"denied handle %p %d blocks: " -"insufficient log space\n" , handle, nblocks); -atomic_sub (nblocks, &transaction->t_outstanding_credits); - goto unlock; - } - trace_jbd2_handle_extend(journal->j_fs_dev->bd_dev, transaction->t_tid, handle->h_type, handle->h_line_no,
include/linux/jbd2.h +3 -13
@@ -1562,20 +1562,13 @@ static inline int jbd2_journal_has_csum_v2or3(journal_t *journal)return journal->j_chksum_driver !=NULL ; } -/* -* We reserve t_outstanding_credits >> JBD2_CONTROL_BLOCKS_SHIFT for -* transaction control blocks. -*/ -#define JBD2_CONTROL_BLOCKS_SHIFT 5 -/* * Return the minimum number of blocks which must be free in the journal * before a new transaction may be started. Must be called under j_state_lock. */ static inline int jbd2_space_needed (journal_t *journal) { -int nblocks = journal->j_max_transaction_buffers; -return nblocks + (nblocks >>JBD2_CONTROL_BLOCKS_SHIFT ); +return journal->j_max_transaction_buffers; }/*
@@ -1587,11 +1580,8 @@ static inline unsigned long jbd2_log_space_left(journal_t *journal)long free = journal->j_free -32 ;if (journal->j_committing_transaction) { -unsigned long committing =atomic_read (&journal-> - j_committing_transaction->t_outstanding_credits); - -/* Transaction + control blocks */ - free -= committing + (committing >>JBD2_CONTROL_BLOCKS_SHIFT ); + free -=atomic_read (&journal-> + j_committing_transaction->t_outstanding_credits); }return max_t (long, free,0 ); }
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 10/15 jbd2: Drop jbd2_space_needed()
In reply to Jan KaraThe function is now just a trivial wrapper returning journal->j_max_transaction_buffers. Drop it.
--- fs/jbd2/checkpoint.c | 2 +- fs/jbd2/transaction.c | 5 +++-- include/linux/jbd2.h | 9 --------- 3 files changed, 4 insertions(+), 12 deletions(-)
fs/jbd2/checkpoint.c +1 -1
@@ -110,7 +110,7 @@ void __jbd2_log_wait_for_space(journal_t *journal)int nblocks, space_left;/* assert_spin_locked(&journal->j_state_lock); */ - nblocks =jbd2_space_needed (journal); + nblocks = journal->j_max_transaction_buffers;while (jbd2_log_space_left (journal) < nblocks) {write_unlock (&journal->j_state_lock);mutex_lock_io (&journal->j_checkpoint_mutex);
fs/jbd2/transaction.c +3 -2
@@ -270,12 +270,13 @@ static int add_transaction_credits(journal_t *journal, int blocks,* *before* starting to dirty potentially checkpointed buffers * in the new transaction. */ -if (jbd2_log_space_left (journal) <jbd2_space_needed (journal)) { +if (jbd2_log_space_left (journal) < journal->j_max_transaction_buffers) {atomic_sub (total, &t->t_outstanding_credits);read_unlock (&journal->j_state_lock);jbd2_might_wait_for_commit (journal);write_lock (&journal->j_state_lock); -if (jbd2_log_space_left (journal) <jbd2_space_needed (journal)) +if (jbd2_log_space_left (journal) < + journal->j_max_transaction_buffers)__jbd2_log_wait_for_space (journal);write_unlock (&journal->j_state_lock);return 1 ;
include/linux/jbd2.h +0 -9
@@ -1562,15 +1562,6 @@ static inline int jbd2_journal_has_csum_v2or3(journal_t *journal)return journal->j_chksum_driver !=NULL ; } -/* -* Return the minimum number of blocks which must be free in the journal -* before a new transaction may be started. Must be called under j_state_lock. -*/ -static inline int jbd2_space_needed (journal_t *journal) -{ -return journal->j_max_transaction_buffers; -} -/* * Return number of free blocks in the log. Must be called under j_state_lock. */
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 11/15 jbd2: Reserve space for revoke descriptor blocks
In reply to Jan KaraExtend functions for starting, extending, and restarting transaction handles to take number of revoke records handle must be able to accommodate. These functions then make sure transaction has enough credits to be able to store resulting revoke descriptor blocks. Also revoke code tracks number of revoke records created by a handle to catch situation where some place didn't reserve enough space for revoke records. Similarly to standard transaction credits, space for unused reserved revoke records is released when the handle is stopped.
On the ext4 side we currently take a simplistic approach of reserving space for 1024 revoke records for any transaction. This grows amount of credits reserved for each handle only by a few and is enough for any normal workload so that we don't hit warnings in jbd2. We will refine the logic in following commits.
--- fs/ext4/ext4_jbd2.c | 2 +- fs/ext4/ext4_jbd2.h | 4 ++-- fs/jbd2/journal.c | 18 ++++++++++++++++++ fs/jbd2/revoke.c | 2 ++ fs/jbd2/transaction.c | 35 ++++++++++++++++++++++++++++------- fs/ocfs2/journal.c | 4 ++-- include/linux/jbd2.h | 20 ++++++++++++++++---- 7 files changed, 69 insertions(+), 16 deletions(-)
fs/ext4/ext4_jbd2.c +1 -1
@@ -78,7 +78,7 @@ handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line, journal =EXT4_SB (sb)->s_journal;if (!journal)return ext4_get_nojournal (); -return jbd2__journal_start (journal, blocks, rsv_blocks,GFP_NOFS , +return jbd2__journal_start (journal, blocks, rsv_blocks,1024 ,GFP_NOFS , type, line); }
fs/ext4/ext4_jbd2.h +2 -2
@@ -335,14 +335,14 @@ static inline handle_t *ext4_journal_current_handle(void)static inline int ext4_journal_extend (handle_t *handle,int nblocks) {if (ext4_handle_valid (handle)) -return jbd2_journal_extend (handle, nblocks); +return jbd2_journal_extend (handle, nblocks,1024 );return 0 ; }static inline int ext4_journal_restart (handle_t *handle,int nblocks) {if (ext4_handle_valid (handle)) -return jbd2_journal_restart (handle, nblocks); +return jbd2__journal_restart (handle, nblocks,1024 ,GFP_NOFS );return 0 ; }
fs/jbd2/journal.c +18 -0
@@ -1101,6 +1101,21 @@ static void jbd2_stats_proc_exit(journal_t *journal)remove_proc_entry (journal->j_devname, proc_jbd2_stats); } +static int journal_revoke_records_per_block (journal_t *journal) +{ +int record_size; +int space = journal->j_blocksize -sizeof (jbd2_journal_revoke_header_t); + +if (jbd2_has_feature_64bit (journal)) + record_size =8 ; +else + record_size =4 ; + +if (jbd2_journal_has_csum_v2or3 (journal)) + space -=sizeof (struct jbd2_journal_block_tail ); +return space / record_size; +} +/* * Management for journal control blocks: functions to create and * destroy journal_t structures, and to initialise and read existing
@@ -1175,6 +1190,9 @@ static journal_t *journal_init_common(struct block_device *bdev, journal->j_sb_buffer = bh; journal->j_superblock = (journal_superblock_t *)bh->b_data; + journal->j_revoke_records_per_block = +journal_revoke_records_per_block (journal); +return journal; err_cleanup:
fs/jbd2/revoke.c +2 -0
@@ -391,6 +391,8 @@ int jbd2_journal_revoke(handle_t *handle, unsigned long long blocknr,__brelse (bh); } } +WARN_ON_ONCE (handle->h_revoke_credits <=0 ); + handle->h_revoke_credits--;jbd_debug (2 ,"insert revoke for block %llu, bh_in=%p\n" ,blocknr, bh_in); err = insert_revoke_hash(journal, blocknr,
fs/jbd2/transaction.c +28 -7
@@ -99,7 +99,7 @@ static void jbd2_get_transaction(journal_t *journal,spin_lock_init (&transaction->t_handle_lock);atomic_set (&transaction->t_updates,0 );atomic_set (&transaction->t_outstanding_credits, -jbd2_decriptor_blocks_per_trans (journal) + +jbd2_descriptor_blocks_per_trans (journal) +atomic_read (&journal->j_reserved_credits));atomic_set (&transaction->t_handle_count,0 );INIT_LIST_HEAD (&transaction->t_inode_list);
@@ -418,6 +418,7 @@ static int start_this_handle(journal_t *journal, handle_t *handle,update_t_max_wait (transaction, ts); handle->h_transaction = transaction; handle->h_requested_credits = blocks; + handle->h_revoke_credits_requested = handle->h_revoke_credits; handle->h_start_jiffies = jiffies;atomic_inc (&transaction->t_updates);atomic_inc (&transaction->t_handle_count);
@@ -451,8 +452,8 @@ static handle_t *new_handle(int nblocks) }handle_t *jbd2__journal_start (journal_t *journal,int nblocks,int rsv_blocks, -gfp_t gfp_mask,unsigned int type, -unsigned int line_no) +int revoke_records,gfp_t gfp_mask, +unsigned int type,unsigned int line_no) {handle_t *handle =journal_current_handle ();int err;
@@ -466,6 +467,8 @@ handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks,return handle; } + nblocks +=DIV_ROUND_UP (revoke_records, + journal->j_revoke_records_per_block); handle =new_handle (nblocks);if (!handle)return ERR_PTR (-ENOMEM );
@@ -481,6 +484,7 @@ handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks, rsv_handle->h_journal = journal; handle->h_rsv_handle = rsv_handle; } + handle->h_revoke_credits = revoke_records; err =start_this_handle (journal, handle, gfp_mask);if (err <0 ) {
@@ -521,7 +525,7 @@ EXPORT_SYMBOL(jbd2__journal_start);*/ handle_t *jbd2_journal_start (journal_t *journal,int nblocks) { -return jbd2__journal_start (journal, nblocks,0 ,GFP_NOFS ,0 ,0 ); +return jbd2__journal_start (journal, nblocks,0 ,0 ,GFP_NOFS ,0 ,0 ); }EXPORT_SYMBOL (jbd2_journal_start);
@@ -611,7 +615,7 @@ EXPORT_SYMBOL(jbd2_journal_start_reserved);* return code < 0 implies an error * return code > 0 implies normal transaction-full status. */ -int jbd2_journal_extend (handle_t *handle,int nblocks) +int jbd2_journal_extend (handle_t *handle,int nblocks,int revoke_records) {transaction_t *transaction = handle->h_transaction;journal_t *journal;
@@ -633,6 +637,12 @@ int jbd2_journal_extend(handle_t *handle, int nblocks) goto error_out; } + nblocks +=DIV_ROUND_UP ( + handle->h_revoke_credits_requested + revoke_records, + journal->j_revoke_records_per_block) - +DIV_ROUND_UP ( + handle->h_revoke_credits_requested, + journal->j_revoke_records_per_block);spin_lock (&transaction->t_handle_lock); wanted =atomic_add_return (nblocks, &transaction->t_outstanding_credits);
@@ -652,6 +662,8 @@ int jbd2_journal_extend(handle_t *handle, int nblocks) handle->h_buffer_credits += nblocks; handle->h_requested_credits += nblocks; + handle->h_revoke_credits += revoke_records; + handle->h_revoke_credits_requested += revoke_records; result =0 ;jbd_debug (3 ,"extended handle %p by %d\n" , handle, nblocks);
@@ -666,10 +678,17 @@ static void stop_this_handle(handle_t *handle) {transaction_t *transaction = handle->h_transaction;journal_t *journal = transaction->t_journal; +int revoke_descriptors;J_ASSERT (journal_current_handle () == handle);J_ASSERT (atomic_read (&transaction->t_updates) >0 ); current->journal_info =NULL ; +/* Subtract necessary revoke descriptor blocks from handle credits */ + revoke_descriptors =DIV_ROUND_UP ( + handle->h_revoke_credits_requested - handle->h_revoke_credits, + journal->j_revoke_records_per_block); +WARN_ON_ONCE (revoke_descriptors > handle->h_buffer_credits); + handle->h_buffer_credits -= revoke_descriptors;atomic_sub (handle->h_buffer_credits, &transaction->t_outstanding_credits);if (handle->h_rsv_handle)
@@ -701,7 +720,8 @@ static void stop_this_handle(handle_t *handle)* credits. We preserve reserved handle if there's any attached to the * passed in handle. */ -int jbd2__journal_restart (handle_t *handle,int nblocks,gfp_t gfp_mask) +int jbd2__journal_restart (handle_t *handle,int nblocks,int revoke_records, +gfp_t gfp_mask) {transaction_t *transaction = handle->h_transaction;journal_t *journal;
@@ -729,6 +749,7 @@ int jbd2__journal_restart(handle_t *handle, int nblocks, gfp_t gfp_mask)if (need_to_start)jbd2_log_start_commit (journal, tid); handle->h_buffer_credits = nblocks; + handle->h_revoke_credits = revoke_records;return start_this_handle (journal, handle, gfp_mask); }EXPORT_SYMBOL (jbd2__journal_restart);
@@ -736,7 +757,7 @@ EXPORT_SYMBOL(jbd2__journal_restart);int jbd2_journal_restart (handle_t *handle,int nblocks) { -return jbd2__journal_restart (handle, nblocks,GFP_NOFS ); +return jbd2__journal_restart (handle, nblocks,0 ,GFP_NOFS ); }EXPORT_SYMBOL (jbd2_journal_restart);
fs/ocfs2/journal.c +2 -2
@@ -426,7 +426,7 @@ int ocfs2_extend_trans(handle_t *handle, int nblocks)#ifdef CONFIG_OCFS2_DEBUG_FS status =1 ;#else - status =jbd2_journal_extend (handle, nblocks); + status =jbd2_journal_extend (handle, nblocks,0 );if (status <0 ) {mlog_errno (status); goto bail;
@@ -466,7 +466,7 @@ int ocfs2_allocate_extend_trans(handle_t *handle, int thresh)if (old_nblks < thresh)return 0 ; - status =jbd2_journal_extend (handle,OCFS2_MAX_TRANS_DATA ); + status =jbd2_journal_extend (handle,OCFS2_MAX_TRANS_DATA ,0 );if (status <0 ) {mlog_errno (status); goto bail;
include/linux/jbd2.h +16 -4
@@ -478,6 +478,7 @@ struct jbd2_revoke_table_s;* @h_journal: Which journal handle belongs to - used iff h_reserved set. * @h_rsv_handle: Handle reserved for finishing the logical operation. * @h_buffer_credits: Number of remaining buffers we are allowed to dirty. +* @h_revoke_credits: Number of remaining revoke records available for handle * @h_ref: Reference count on this handle. * @h_err: Field for caller's use to track errors through large fs operations. * @h_sync: Flag for sync-on-close.
@@ -505,6 +506,8 @@ struct jbd2_journal_handlehandle_t *h_rsv_handle;int h_buffer_credits; +int h_revoke_credits; +int h_revoke_credits_requested;int h_ref;int h_err;
@@ -1024,6 +1027,13 @@ struct journal_s*/ int j_max_transaction_buffers; +/** +* @j_revoke_records_per_block: +* +* Number of revoke records that fit in one descriptor block. +*/ +int j_revoke_records_per_block; +/** * @j_commit_interval: *
@@ -1358,14 +1368,16 @@ static inline handle_t *journal_current_handle(void)extern handle_t *jbd2_journal_start (journal_t *,int nblocks);extern handle_t *jbd2__journal_start (journal_t *,int blocks,int rsv_blocks, -gfp_t gfp_mask,unsigned int type, -unsigned int line_no); +int revoke_records,gfp_t gfp_mask, +unsigned int type,unsigned int line_no);extern int jbd2_journal_restart (handle_t *,int nblocks); -extern int jbd2__journal_restart (handle_t *,int nblocks,gfp_t gfp_mask); +extern int jbd2__journal_restart (handle_t *,int nblocks, +int revoke_records,gfp_t gfp_mask);extern int jbd2_journal_start_reserved (handle_t *handle,unsigned int type,unsigned int line_no);extern void jbd2_journal_free_reserved (handle_t *handle); -extern int jbd2_journal_extend (handle_t *,int nblocks); +extern int jbd2_journal_extend (handle_t *handle,int nblocks, +int revoke_records);extern int jbd2_journal_get_write_access (handle_t *,struct buffer_head *);extern int jbd2_journal_get_create_access (handle_t *,struct buffer_head *);extern int jbd2_journal_get_undo_access (handle_t *,struct buffer_head *);
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 12/15 ext4: Avoid unnecessary revokes in ext4_alloc_branch()
In reply to Jan KaraError cleanup path in ext4_alloc_branch() calls ext4_forget() on freshly allocated indirect blocks with 'metadata' set to 1. This results in generating revoke records for these blocks. However this is unnecessary as the freed blocks are only allocated in the current transaction and thus they will never be journalled. Make this cleanup path similar to e.g. cleanup in ext4_splice_branch() and use ext4_free_blocks() to handle block forgetting by passing EXT4_FREE_BLOCKS_FORGET and not EXT4_FREE_BLOCKS_METADATA to ext4_free_blocks(). This also allows allocating transaction not to reserve any credits for revoke records.
--- fs/ext4/indirect.c | 28 +++++++++++++++++++--------- 1 file changed, 19 insertions(+), 9 deletions(-)
fs/ext4/indirect.c +19 -9
@@ -331,11 +331,14 @@ static int ext4_alloc_branch(handle_t *handle,for (i =0 ; i <= indirect_blks; i++) {if (i == indirect_blks) { new_blocks[i] =ext4_mb_new_blocks (handle, ar, &err); - }else + }else { ar->goal = new_blocks[i] =ext4_new_meta_blocks (handle, ar->inode, ar->goal, ar->flags &EXT4_MB_DELALLOC_RESERVED ,NULL , &err); +/* Simplify error cleanup... */ + branch[i+1 ].bh =NULL ; + }if (err) { i--; goto failed;
@@ -377,18 +380,25 @@ static int ext4_alloc_branch(handle_t *handle, }return 0 ; failed: +if (i == indirect_blks) { +/* Free data blocks */ +ext4_free_blocks (handle, ar->inode,NULL , new_blocks[i], + ar->len,0 ); + i--; + }for (; i >=0 ; i--) {/* * We want to ext4_forget() only freshly allocated indirect -* blocks. Buffer for new_blocks[i-1] is at branch[i].bh and -* buffer at branch[0].bh is indirect block / inode already -* existing before ext4_alloc_branch() was called. +* blocks. Buffer for new_blocks[i] is at branch[i+1].bh +* (buffer at branch[0].bh is indirect block / inode already +* existing before ext4_alloc_branch() was called). Also +* because blocks are freshly allocated, we don't need to +* revoke them which is why we don't set +* EXT4_FREE_BLOCKS_METADATA. */ -if (i >0 && i != indirect_blks && branch[i].bh) -ext4_forget (handle,1 , ar->inode, branch[i].bh, - branch[i].bh->b_blocknr); -ext4_free_blocks (handle, ar->inode,NULL , new_blocks[i], - (i == indirect_blks) ? ar->len :1 ,0 ); +ext4_free_blocks (handle, ar->inode, branch[i+1 ].bh, + new_blocks[i],1 , + branch[i+1 ].bh ?EXT4_FREE_BLOCKS_FORGET :0 ); }return err; }
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 13/15 jbd2: Fix statistics for the number of logged blocks
In reply to Jan Karajbd2 statistics counting number of blocks logged in a transaction was wrong. It didn't count the commit block and more importantly it didn't count revoke descriptor blocks. Make sure these get properly counted.
--- fs/jbd2/commit.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
fs/jbd2/commit.c +3 -1
@@ -726,7 +726,6 @@ void jbd2_journal_commit_transaction(journal_t *journal)submit_bh (REQ_OP_WRITE ,REQ_SYNC , bh); }cond_resched (); - stats.run.rs_blocks_logged += bufs;/* Force a new descriptor to be generated next time round the loop. */
@@ -813,6 +812,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)if (unlikely (!buffer_uptodate (bh))) err = -EIO ;jbd2_unfile_log_bh (bh); + stats.run.rs_blocks_logged++;/* * The list contains temporary buffer heads created by
@@ -858,6 +858,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)BUFFER_TRACE (bh,"ph5: control buffer writeout done: unfile" );clear_buffer_jwrite (bh);jbd2_unfile_log_bh (bh); + stats.run.rs_blocks_logged++;__brelse (bh);/* One for getblk */ /* AKPM: bforget here */ }
@@ -879,6 +880,7 @@ void jbd2_journal_commit_transaction(journal_t *journal) }if (cbh) err =journal_wait_on_commit_record (journal, cbh); + stats.run.rs_blocks_logged++;if (jbd2_has_feature_async_commit (journal) && journal->j_flags &JBD2_BARRIER ) {blkdev_issue_flush (journal->j_dev,GFP_NOFS ,NULL );
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 14/15 ext4: Provide function to handle transaction restarts
In reply to Jan KaraProvide ext4_journal_ensure_credits_fn() function to ensure transaction has given amount of credits and call helper function to prepare for restarting a transaction. This allows to remove some boilerplate code from various places, add proper error handling for the case where transaction extension or restart fails, and reduces following changes needed for proper revoke record reservation tracking.
--- fs/ext4/ext4.h | 4 ++- fs/ext4/ext4_jbd2.c | 11 +++++++ fs/ext4/ext4_jbd2.h | 48 +++++++++++++++++++++++++++ fs/ext4/extents.c | 68 ++++++++++++++++++++++---------------- fs/ext4/indirect.c | 93 +++++++++++++++++++++++++++++---------------------- fs/ext4/inode.c | 26 --------------- fs/ext4/migrate.c | 95 ++++++++++++++++++++--------------------------------- fs/ext4/resize.c | 38 ++++----------------- fs/ext4/xattr.c | 88 ++++++++++++++++++------------------------------- 9 files changed, 229 insertions(+), 242 deletions(-)
fs/ext4/ext4.h +3 -1
@@ -2566,7 +2566,6 @@ extern int ext4_can_truncate(struct inode *inode);extern int ext4_truncate (struct inode *);extern int ext4_break_layouts (struct inode *);extern int ext4_punch_hole (struct inode *inode,loff_t offset,loff_t length); -extern int ext4_truncate_restart_trans (handle_t *,struct inode *,int nblocks);extern void ext4_set_inode_flags (struct inode *);extern int ext4_alloc_da_blocks (struct inode *inode);extern void ext4_set_aops (struct inode *inode);
@@ -3253,6 +3252,9 @@ extern int ext4_swap_extents(handle_t *handle, struct inode *inode1, ext4_lblk_t lblk2, ext4_lblk_t count, int mark_unwritten,int *err);extern int ext4_clu_mapped (struct inode *inode,ext4_lblk_t lclu); +extern int ext4_datasem_ensure_credits (handle_t *handle,struct inode *inode, +int check_cred,int restart_cred); +/* move_extent.c */ extern void ext4_double_down_write_data_sem(struct inode *first,
fs/ext4/ext4_jbd2.c +11 -0
@@ -133,6 +133,17 @@ handle_t *__ext4_journal_start_reserved(handle_t *handle, unsigned int line,return handle; } +int __ext4_journal_ensure_credits (handle_t *handle,int check_cred, +int extend_cred) +{ +if (!ext4_handle_valid (handle)) +return 0 ; +if (handle->h_buffer_credits >= check_cred) +return 0 ; +return ext4_journal_extend (handle, + extend_cred - handle->h_buffer_credits); +} + static void ext4_journal_abort_handle(const char *caller, unsigned int line, const char *err_fn, struct buffer_head *bh,
fs/ext4/ext4_jbd2.h +48 -0
54 lines not on this page · raw message
fs/ext4/extents.c +40 -28
91 lines not on this page · raw message
fs/ext4/indirect.c +54 -39
119 lines not on this page · raw message
fs/ext4/inode.c +0 -26
@@ -163,32 +163,6 @@ int ext4_inode_is_fast_symlink(struct inode *inode) (inode->i_size <EXT4_N_BLOCKS *4 ); } -/* -* Restart the transaction associated with *handle. This does a commit, -* so before we call here everything must be consistently dirtied against -* this transaction. -*/ -int ext4_truncate_restart_trans (handle_t *handle,struct inode *inode, -int nblocks) -{ -int ret; - -/* -* Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this -* moment, get_block can be called only for blocks inside i_size since -* page cache has been already dropped and writes are blocked by -* i_mutex. So we can safely drop the i_data_sem here. -*/ -BUG_ON (EXT4_JOURNAL (inode) ==NULL ); -jbd_debug (2 ,"restarting handle %p\n" , handle); -up_write (&EXT4_I (inode)->i_data_sem); - ret =ext4_journal_restart (handle, nblocks); -down_write (&EXT4_I (inode)->i_data_sem); -ext4_discard_preallocations (inode); - -return ret; -} -/* * Called at the last iput() if i_nlink is zero. */
fs/ext4/migrate.c +35 -60
166 lines not on this page · raw message
fs/ext4/resize.c +6 -32
@@ -388,30 +388,6 @@ static struct buffer_head *bclean(handle_t *handle, struct super_block *sb,return bh; } -/* -* If we have fewer than thresh credits, extend by EXT4_MAX_TRANS_DATA. -* If that fails, restart the transaction & regain write access for the -* buffer head which is used for block_bitmap modifications. -*/ -static int extend_or_restart_transaction (handle_t *handle,int thresh) -{ -int err; - -if (ext4_handle_has_enough_credits (handle, thresh)) -return 0 ; - - err =ext4_journal_extend (handle,EXT4_MAX_TRANS_DATA ); -if (err <0 ) -return err; -if (err) { - err =ext4_journal_restart (handle,EXT4_MAX_TRANS_DATA ); -if (err) -return err; - } - -return 0 ; -} -/* * set_flexbg_block_bitmap() mark clusters [@first_cluster, @last_cluster] used. *
@@ -451,7 +427,7 @@ static int set_flexbg_block_bitmap(struct super_block *sb, handle_t *handle,continue ; } - err =extend_or_restart_transaction (handle,1 ); + err =ext4_journal_ensure_credits_batch (handle,1 );if (err)return err;
@@ -544,7 +520,7 @@ static int setup_new_flex_group_blocks(struct super_block *sb,struct buffer_head *gdb;ext4_debug ("update backup group %#04llx\n" , block); - err =extend_or_restart_transaction (handle,1 ); + err =ext4_journal_ensure_credits_batch (handle,1 );if (err) goto out;
@@ -602,7 +578,7 @@ static int setup_new_flex_group_blocks(struct super_block *sb,/* Initialize block bitmap of the @group */ block = group_data[i].block_bitmap; - err =extend_or_restart_transaction (handle,1 ); + err =ext4_journal_ensure_credits_batch (handle,1 );if (err) goto out;
@@ -631,7 +607,7 @@ static int setup_new_flex_group_blocks(struct super_block *sb,/* Initialize inode bitmap of the @group */ block = group_data[i].inode_bitmap; - err =extend_or_restart_transaction (handle,1 ); + err =ext4_journal_ensure_credits_batch (handle,1 );if (err) goto out;/* Mark unused entries in inode bitmap used */
@@ -1109,10 +1085,8 @@ static void update_backups(struct super_block *sb, sector_t blk_off, char *data,ext4_fsblk_t backup_block;/* Out of journal space, and can't get more - abort - so sad */ -if (ext4_handle_valid (handle) && - handle->h_buffer_credits ==0 && -ext4_journal_extend (handle,EXT4_MAX_TRANS_DATA ) && - (err =ext4_journal_restart (handle,EXT4_MAX_TRANS_DATA ))) + err =ext4_journal_ensure_credits_batch (handle,1 ); +if (err <0 )break ;if (meta_bg ==0 )
fs/ext4/xattr.c +32 -56
116 lines not on this page · raw message
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH 15/15 ext4: Reserve revoke credits for freed blocks
In reply to Jan KaraSo far we have reserved only relatively high fixed amount of revoke credits for each transaction. We over-reserved by large amount for most cases but when freeing large directories or files with data journalling, the fixed amount is not enough. In fact the worst case estimate is inconveniently large (maximum extent size) for freeing of one extent.
We fix this by doing proper estimate of the amount of blocks that need to be revoked when removing blocks from the inode due to truncate or hole punching and otherwise reserve just a small amount of revoke credits for each transaction to accommodate freeing of xattrs block or so.
--- fs/ext4/ext4.h | 3 +- fs/ext4/ext4_jbd2.c | 20 +++++++----- fs/ext4/ext4_jbd2.h | 79 +++++++++++++++++++++++++++++++-------------- fs/ext4/extents.c | 25 ++++++++++---- fs/ext4/ialloc.c | 2 +- fs/ext4/indirect.c | 12 ++++--- fs/ext4/inode.c | 2 +- fs/ext4/migrate.c | 24 ++++++++------ fs/ext4/resize.c | 16 ++++++--- fs/ext4/xattr.c | 4 ++- include/trace/events/ext4.h | 13 +++++--- 11 files changed, 133 insertions(+), 67 deletions(-)
fs/ext4/ext4.h +2 -1
@@ -3253,7 +3253,8 @@ extern int ext4_swap_extents(handle_t *handle, struct inode *inode1, int mark_unwritten,int *err);extern int ext4_clu_mapped (struct inode *inode,ext4_lblk_t lclu);extern int ext4_datasem_ensure_credits (handle_t *handle,struct inode *inode, -int check_cred,int restart_cred); +int check_cred,int restart_cred, +int revoke_cred);/* move_extent.c */
fs/ext4/ext4_jbd2.c +12 -8
@@ -65,12 +65,14 @@ static int ext4_journal_check_start(struct super_block *sb) }handle_t *__ext4_journal_start_sb (struct super_block *sb,unsigned int line, -int type,int blocks,int rsv_blocks) +int type,int blocks,int rsv_blocks, +int revoke_creds) {journal_t *journal;int err; -trace_ext4_journal_start (sb, blocks, rsv_blocks, _RET_IP_); +trace_ext4_journal_start (sb, blocks, rsv_blocks, revoke_creds, + _RET_IP_); err =ext4_journal_check_start (sb);if (err <0 )return ERR_PTR (err);
@@ -78,8 +80,8 @@ handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line, journal =EXT4_SB (sb)->s_journal;if (!journal)return ext4_get_nojournal (); -return jbd2__journal_start (journal, blocks, rsv_blocks,1024 ,GFP_NOFS , - type, line); +return jbd2__journal_start (journal, blocks, rsv_blocks, revoke_creds, +GFP_NOFS , type, line); }int __ext4_journal_stop (const char *where,unsigned int line,handle_t *handle)
@@ -134,14 +136,16 @@ handle_t *__ext4_journal_start_reserved(handle_t *handle, unsigned int line, }int __ext4_journal_ensure_credits (handle_t *handle,int check_cred, -int extend_cred) +int extend_cred,int revoke_cred) {if (!ext4_handle_valid (handle))return 0 ; -if (handle->h_buffer_credits >= check_cred) +if (handle->h_buffer_credits >= check_cred && + handle->h_revoke_credits >= revoke_cred)return 0 ; -return ext4_journal_extend (handle, - extend_cred - handle->h_buffer_credits); + extend_cred =max (0 , extend_cred - handle->h_buffer_credits); + revoke_cred =max (0 , revoke_cred - handle->h_revoke_credits); +return ext4_journal_extend (handle, extend_cred, revoke_cred); } static void ext4_journal_abort_handle(const char *caller, unsigned int line,
fs/ext4/ext4_jbd2.h +54 -25
146 lines not on this page · raw message
fs/ext4/extents.c +18 -7
@@ -124,13 +124,14 @@ static int ext4_ext_trunc_restart_fn(struct inode *inode, int *dropped)* and < 0 in case of fatal error. */ int ext4_datasem_ensure_credits (handle_t *handle,struct inode *inode, -int check_cred,int restart_cred) +int check_cred,int restart_cred, +int revoke_cred) {int ret;int dropped =0 ; ret =ext4_journal_ensure_credits_fn (handle, check_cred, restart_cred, -ext4_ext_trunc_restart_fn (inode, &dropped)); + revoke_cred,ext4_ext_trunc_restart_fn (inode, &dropped));if (dropped)down_write (&EXT4_I (inode)->i_data_sem);return ret;
@@ -1851,7 +1852,8 @@ static void ext4_ext_try_to_merge_up(handle_t *handle,* group descriptor to release the extent tree block. If we * can't get the journal credits, give up. */ -if (ext4_journal_extend (handle,2 )) +if (ext4_journal_extend (handle,2 , +ext4_free_metadata_revoke_credits (inode->i_sb,1 )))return ;/*
@@ -2692,7 +2694,7 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode, {struct ext4_sb_info *sbi =EXT4_SB (inode->i_sb);int err =0 , correct_index =0 ; -int depth =ext_depth (inode), credits; +int depth =ext_depth (inode), credits, revoke_credits;struct ext4_extent_header *eh;ext4_lblk_t a, b;unsigned num;
@@ -2784,9 +2786,16 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode, credits += (ext_depth (inode)) +1 ; } credits +=EXT4_MAXQUOTAS_TRANS_BLOCKS (inode->i_sb); +/* +* We may end up freeing some index blocks and data from the +* punched range. Note that partial clusters are accounted for +* by ext4_free_data_revoke_credits(). +*/ + revoke_credits =ext_depth (inode) + +ext4_free_data_revoke_credits (inode, b - a +1 ); err =ext4_datasem_ensure_credits (handle, inode, credits, - credits); + credits, revoke_credits);if (err) {if (err >0 ) err = -EAGAIN ;
@@ -2917,7 +2926,9 @@ int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,ext_debug ("truncate since %u to %u\n" , start, end);/* probably first extent we're gonna free will be last in block */ - handle =ext4_journal_start (inode,EXT4_HT_TRUNCATE , depth +1 ); + handle =ext4_journal_start_with_revoke (inode,EXT4_HT_TRUNCATE , + depth +1 , +ext4_free_metadata_revoke_credits (inode->i_sb, depth));if (IS_ERR (handle))return PTR_ERR (handle);
@@ -5144,7 +5155,7 @@ ext4_access_path(handle_t *handle, struct inode *inode,* groups */ credits =ext4_writepage_trans_blocks (inode); - err =ext4_datasem_ensure_credits (handle, inode,7 , credits); + err =ext4_datasem_ensure_credits (handle, inode,7 , credits,0 );if (err <0 )return err;
fs/ext4/ialloc.c +1 -1
@@ -927,7 +927,7 @@ struct inode *__ext4_new_inode(handle_t *handle, struct inode *dir,BUG_ON (nblocks <=0 ); handle =__ext4_journal_start_sb (dir->i_sb, line_no, handle_type, nblocks, -0 ); +0 ,0 );if (IS_ERR (handle)) { err =PTR_ERR (handle);ext4_std_error (sb, err);
fs/ext4/indirect.c +8 -4
@@ -736,13 +736,14 @@ static int ext4_ind_trunc_restart_fn(handle_t *handle, struct inode *inode,*/ static int ext4_ind_truncate_ensure_credits (handle_t *handle,struct inode *inode, -struct buffer_head *bh) +struct buffer_head *bh, +int revoke_creds) {int ret;int dropped =0 ; ret =ext4_journal_ensure_credits_fn (handle,EXT4_RESERVE_TRANS_BLOCKS , -ext4_blocks_for_truncate (inode), +ext4_blocks_for_truncate (inode), revoke_creds,ext4_ind_trunc_restart_fn (handle, inode, bh, &dropped));if (dropped)down_write (&EXT4_I (inode)->i_data_sem);
@@ -889,7 +890,8 @@ static int ext4_clear_blocks(handle_t *handle, struct inode *inode,return 1 ; } - err =ext4_ind_truncate_ensure_credits (handle, inode, bh); + err =ext4_ind_truncate_ensure_credits (handle, inode, bh, +ext4_free_data_revoke_credits (inode, count));if (err <0 ) goto out_err;
@@ -1075,7 +1077,9 @@ static void ext4_free_branches(handle_t *handle, struct inode *inode,if (ext4_handle_is_aborted (handle))return ;if (ext4_ind_truncate_ensure_credits (handle, inode, -NULL ) <0 ) +NULL , +ext4_free_metadata_revoke_credits ( + inode->i_sb,1 )) <0 )return ;/*
fs/ext4/inode.c +1 -1
@@ -5964,7 +5964,7 @@ static int ext4_try_to_expand_extra_isize(struct inode *inode,* force a large enough s_min_extra_isize. */ if (ext4_journal_extend (handle, -EXT4_DATA_TRANS_BLOCKS (inode->i_sb)) !=0 ) +EXT4_DATA_TRANS_BLOCKS (inode->i_sb),0 ) !=0 )return -ENOSPC ;if (ext4_write_trylock_xattr (inode, &no_expand) ==0 )
fs/ext4/migrate.c +15 -9
@@ -50,7 +50,7 @@ static int finish_range(handle_t *handle, struct inode *inode, needed =ext4_ext_calc_credits_for_single_extent (inode, lb->last_block - lb->first_block +1 , path); - retval =ext4_datasem_ensure_credits (handle, inode, needed, needed); + retval =ext4_datasem_ensure_credits (handle, inode, needed, needed,0 );if (retval <0 ) goto err_out; retval =ext4_ext_insert_extent (handle, inode, &path, &newext,0 );
@@ -182,10 +182,11 @@ static int free_dind_blocks(handle_t *handle,int i;__le32 *tmp_idata;struct buffer_head *bh; +struct super_block *sb = inode->i_sb;unsigned long max_entries = inode->i_sb->s_blocksize >>2 ;int err; - bh =ext4_sb_bread (inode->i_sb,le32_to_cpu (i_data),0 ); + bh =ext4_sb_bread (sb,le32_to_cpu (i_data),0 );if (IS_ERR (bh))return PTR_ERR (bh);
@@ -193,7 +194,8 @@ static int free_dind_blocks(handle_t *handle,for (i =0 ; i < max_entries; i++) {if (tmp_idata[i]) { err =ext4_journal_ensure_credits (handle, -EXT4_RESERVE_TRANS_BLOCKS ); +EXT4_RESERVE_TRANS_BLOCKS , +ext4_free_metadata_revoke_credits (sb,1 ));if (err <0 ) {put_bh (bh);return err;
@@ -205,7 +207,8 @@ static int free_dind_blocks(handle_t *handle, } }put_bh (bh); - err =ext4_journal_ensure_credits (handle,EXT4_RESERVE_TRANS_BLOCKS ); + err =ext4_journal_ensure_credits (handle,EXT4_RESERVE_TRANS_BLOCKS , +ext4_free_metadata_revoke_credits (sb,1 ));if (err <0 )return err; ext4_free_blocks(handle, inode, NULL, le32_to_cpu(i_data), 1,
@@ -238,7 +241,8 @@ static int free_tind_blocks(handle_t *handle, } }put_bh (bh); - retval =ext4_journal_ensure_credits (handle,EXT4_RESERVE_TRANS_BLOCKS ); + retval =ext4_journal_ensure_credits (handle,EXT4_RESERVE_TRANS_BLOCKS , +ext4_free_metadata_revoke_credits (inode->i_sb,1 ));if (retval <0 )return retval; ext4_free_blocks(handle, inode, NULL, le32_to_cpu(i_data), 1,
@@ -254,7 +258,8 @@ static int free_ind_block(handle_t *handle, struct inode *inode, __le32 *i_data)/* ei->i_data[EXT4_IND_BLOCK] */ if (i_data[0 ]) { retval =ext4_journal_ensure_credits (handle, -EXT4_RESERVE_TRANS_BLOCKS ); +EXT4_RESERVE_TRANS_BLOCKS , +ext4_free_metadata_revoke_credits (inode->i_sb,1 ));if (retval <0 )return retval; ext4_free_blocks(handle, inode, NULL,
@@ -291,7 +296,7 @@ static int ext4_ext_swap_inode_data(handle_t *handle, struct inode *inode,* One credit accounted for writing the * i_data field of the original inode */ - retval =ext4_journal_ensure_credits (handle,1 ); + retval =ext4_journal_ensure_credits (handle,1 ,0 );if (retval <0 ) goto err_out;
@@ -368,7 +373,8 @@ static int free_ext_idx(handle_t *handle, struct inode *inode, } }put_bh (bh); - retval =ext4_journal_ensure_credits (handle,EXT4_RESERVE_TRANS_BLOCKS ); + retval =ext4_journal_ensure_credits (handle,EXT4_RESERVE_TRANS_BLOCKS , +ext4_free_metadata_revoke_credits (inode->i_sb,1 ));if (retval <0 )return retval; ext4_free_blocks(handle, inode, NULL, block, 1,
@@ -548,7 +554,7 @@ int ext4_ext_migrate(struct inode *inode) }/* We mark the tmp_inode dirty via ext4_ext_tree_init. */ - retval =ext4_journal_ensure_credits (handle,1 ); + retval =ext4_journal_ensure_credits (handle,1 ,0 );if (retval <0 ) goto out_stop;/*
fs/ext4/resize.c +11 -5
@@ -388,6 +388,12 @@ static struct buffer_head *bclean(handle_t *handle, struct super_block *sb,return bh; } +static int ext4_resize_ensure_credits_batch (handle_t *handle,int credits) +{ +return ext4_journal_ensure_credits_fn (handle, credits, +EXT4_MAX_TRANS_DATA ,0 ,0 ); +} +/* * set_flexbg_block_bitmap() mark clusters [@first_cluster, @last_cluster] used. *
@@ -427,7 +433,7 @@ static int set_flexbg_block_bitmap(struct super_block *sb, handle_t *handle,continue ; } - err =ext4_journal_ensure_credits_batch (handle,1 ); + err =ext4_resize_ensure_credits_batch (handle,1 );if (err)return err;
@@ -520,7 +526,7 @@ static int setup_new_flex_group_blocks(struct super_block *sb,struct buffer_head *gdb;ext4_debug ("update backup group %#04llx\n" , block); - err =ext4_journal_ensure_credits_batch (handle,1 ); + err =ext4_resize_ensure_credits_batch (handle,1 );if (err) goto out;
@@ -578,7 +584,7 @@ static int setup_new_flex_group_blocks(struct super_block *sb,/* Initialize block bitmap of the @group */ block = group_data[i].block_bitmap; - err =ext4_journal_ensure_credits_batch (handle,1 ); + err =ext4_resize_ensure_credits_batch (handle,1 );if (err) goto out;
@@ -607,7 +613,7 @@ static int setup_new_flex_group_blocks(struct super_block *sb,/* Initialize inode bitmap of the @group */ block = group_data[i].inode_bitmap; - err =ext4_journal_ensure_credits_batch (handle,1 ); + err =ext4_resize_ensure_credits_batch (handle,1 );if (err) goto out;/* Mark unused entries in inode bitmap used */
@@ -1085,7 +1091,7 @@ static void update_backups(struct super_block *sb, sector_t blk_off, char *data,ext4_fsblk_t backup_block;/* Out of journal space, and can't get more - abort - so sad */ - err =ext4_journal_ensure_credits_batch (handle,1 ); + err =ext4_resize_ensure_credits_batch (handle,1 );if (err <0 )break ;
fs/ext4/xattr.c +3 -1
@@ -1155,6 +1155,7 @@ ext4_xattr_inode_dec_ref_all(handle_t *handle, struct inode *parent, } err =ext4_journal_ensure_credits_fn (handle, credits, credits, +ext4_free_metadata_revoke_credits (parent->i_sb,1 ),ext4_xattr_restart_fn (handle, parent, bh, block_csum, dirty));if (err <0 ) {
@@ -2841,7 +2842,8 @@ int ext4_xattr_delete_inode(handle_t *handle, struct inode *inode,struct inode *ea_inode;int error; - error =ext4_journal_ensure_credits (handle, extra_credits); + error =ext4_journal_ensure_credits (handle, extra_credits, +ext4_free_metadata_revoke_credits (inode->i_sb,1 ));if (error) {EXT4_ERROR_INODE (inode,"ensure credits (error %d)" , error); goto cleanup;
include/trace/events/ext4.h +8 -5
@@ -1746,15 +1746,16 @@ TRACE_EVENT(ext4_load_inode, TRACE_EVENT(ext4_journal_start, TP_PROTO(struct super_block *sb, int blocks, int rsv_blocks, - unsigned long IP), + int revoke_creds, unsigned long IP), - TP_ARGS(sb, blocks, rsv_blocks, IP), + TP_ARGS(sb, blocks, rsv_blocks, revoke_creds, IP), TP_STRUCT__entry( __field( dev_t, dev ) __field(unsigned long, ip ) __field( int, blocks ) __field( int, rsv_blocks ) + __field( int, revoke_creds ) ), TP_fast_assign(
@@ -1762,11 +1763,13 @@ TRACE_EVENT(ext4_journal_start, __entry->ip =IP ; __entry->blocks = blocks; __entry->rsv_blocks = rsv_blocks; + __entry->revoke_creds = revoke_creds; ), -TP_printk ("dev %d,%d blocks, %d rsv_blocks, %d caller %pS" , -MAJOR (__entry->dev),MINOR (__entry->dev), - __entry->blocks, __entry->rsv_blocks, (void *)__entry->ip) +TP_printk ("dev %d,%d blocks %d, rsv_blocks %d, revoke_creds %d, " +"caller %pS" ,MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->blocks, __entry->rsv_blocks, __entry->revoke_creds, + (void *)__entry->ip) ); TRACE_EVENT(ext4_journal_start_reserved,
Signature · 1 line
2.16.4