lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

jbd2: Use atomic variables to avoid taking t_handle_lock in jbd2_journal_stop

Browse Source 
By using an atomic_t for t_updates and t_outstanding credits, this
should allow us to not need to take transaction t_handle_lock in
jbd2_journal_stop().

Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
This commit is contained in:
Theodore Ts'o
2010-08-02 08:43:25 -04:00
parent 8b67f04ab9
commit a51dca9cd3
4 changed files with 51 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
fs/jbd2/checkpoint.c
View File

@@ -775,7 +775,7 @@ void __jbd2_journal_drop_transaction(journal_t *journal, transaction_t *transact
J_ASSERT(transaction->t_log_list == NULL); J_ASSERT(transaction->t_log_list == NULL);
J_ASSERT(transaction->t_checkpoint_list == NULL); J_ASSERT(transaction->t_checkpoint_list == NULL);
J_ASSERT(transaction->t_checkpoint_io_list == NULL); J_ASSERT(transaction->t_checkpoint_io_list == NULL);
J_ASSERT(transaction->t_updates == 0); J_ASSERT(atomic_read(&transaction->t_updates) == 0);
J_ASSERT(journal->j_committing_transaction != transaction); J_ASSERT(journal->j_committing_transaction != transaction);
J_ASSERT(journal->j_running_transaction != transaction); J_ASSERT(journal->j_running_transaction != transaction);

13
fs/jbd2/commit.c
View File

@@ -417,12 +417,12 @@ void jbd2_journal_commit_transaction(journal_t *journal)
stats.run.rs_locked); stats.run.rs_locked);
spin_lock(&commit_transaction->t_handle_lock); spin_lock(&commit_transaction->t_handle_lock);
while (commit_transaction->t_updates) { while (atomic_read(&commit_transaction->t_updates)) {
DEFINE_WAIT(wait); DEFINE_WAIT(wait);
prepare_to_wait(&journal->j_wait_updates, &wait, prepare_to_wait(&journal->j_wait_updates, &wait,
TASK_UNINTERRUPTIBLE); TASK_UNINTERRUPTIBLE);
if (commit_transaction->t_updates) { if (atomic_read(&commit_transaction->t_updates)) {
spin_unlock(&commit_transaction->t_handle_lock); spin_unlock(&commit_transaction->t_handle_lock);
spin_unlock(&journal->j_state_lock); spin_unlock(&journal->j_state_lock);
schedule(); schedule();
@@ -433,7 +433,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
} }
spin_unlock(&commit_transaction->t_handle_lock); spin_unlock(&commit_transaction->t_handle_lock);
J_ASSERT (commit_transaction->t_outstanding_credits <= J_ASSERT (atomic_read(&commit_transaction->t_outstanding_credits) <=
journal->j_max_transaction_buffers); journal->j_max_transaction_buffers);
/* /*
@@ -527,11 +527,12 @@ void jbd2_journal_commit_transaction(journal_t *journal)
stats.run.rs_logging = jiffies; stats.run.rs_logging = jiffies;
stats.run.rs_flushing = jbd2_time_diff(stats.run.rs_flushing, stats.run.rs_flushing = jbd2_time_diff(stats.run.rs_flushing,
stats.run.rs_logging); stats.run.rs_logging);
stats.run.rs_blocks = commit_transaction->t_outstanding_credits; stats.run.rs_blocks =
atomic_read(&commit_transaction->t_outstanding_credits);
stats.run.rs_blocks_logged = 0; stats.run.rs_blocks_logged = 0;
J_ASSERT(commit_transaction->t_nr_buffers <= J_ASSERT(commit_transaction->t_nr_buffers <=
commit_transaction->t_outstanding_credits); atomic_read(&commit_transaction->t_outstanding_credits));
err = 0; err = 0;
descriptor = NULL; descriptor = NULL;
@@ -616,7 +617,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
* the free space in the log, but this counter is changed * the free space in the log, but this counter is changed
* by jbd2_journal_next_log_block() also. * by jbd2_journal_next_log_block() also.
*/ */
commit_transaction->t_outstanding_credits--; atomic_dec(&commit_transaction->t_outstanding_credits);
/* Bump b_count to prevent truncate from stumbling over /* Bump b_count to prevent truncate from stumbling over
the shadowed buffer! @@@ This can go if we ever get the shadowed buffer! @@@ This can go if we ever get

67
fs/jbd2/transaction.c
View File

@@ -55,6 +55,8 @@ jbd2_get_transaction(journal_t *journal, transaction_t *transaction)
transaction->t_tid = journal->j_transaction_sequence++; transaction->t_tid = journal->j_transaction_sequence++;
transaction->t_expires = jiffies + journal->j_commit_interval; transaction->t_expires = jiffies + journal->j_commit_interval;
spin_lock_init(&transaction->t_handle_lock); spin_lock_init(&transaction->t_handle_lock);
atomic_set(&transaction->t_updates, 0);
atomic_set(&transaction->t_outstanding_credits, 0);
INIT_LIST_HEAD(&transaction->t_inode_list); INIT_LIST_HEAD(&transaction->t_inode_list);
INIT_LIST_HEAD(&transaction->t_private_list); INIT_LIST_HEAD(&transaction->t_private_list);
@@ -177,7 +179,7 @@ repeat_locked:
* checkpoint to free some more log space. * checkpoint to free some more log space.
*/ */
spin_lock(&transaction->t_handle_lock); spin_lock(&transaction->t_handle_lock);
needed = transaction->t_outstanding_credits + nblocks; needed = atomic_read(&transaction->t_outstanding_credits) + nblocks;
if (needed > journal->j_max_transaction_buffers) { if (needed > journal->j_max_transaction_buffers) {
/* /*
@@ -240,11 +242,12 @@ repeat_locked:
} }
handle->h_transaction = transaction; handle->h_transaction = transaction;
transaction->t_outstanding_credits += nblocks; atomic_add(nblocks, &transaction->t_outstanding_credits);
transaction->t_updates++; atomic_inc(&transaction->t_updates);
transaction->t_handle_count++; transaction->t_handle_count++;
jbd_debug(4, "Handle %p given %d credits (total %d, free %d)\n", jbd_debug(4, "Handle %p given %d credits (total %d, free %d)\n",
handle, nblocks, transaction->t_outstanding_credits, handle, nblocks,
atomic_read(&transaction->t_outstanding_credits),
__jbd2_log_space_left(journal)); __jbd2_log_space_left(journal));
spin_unlock(&transaction->t_handle_lock); spin_unlock(&transaction->t_handle_lock);
spin_unlock(&journal->j_state_lock); spin_unlock(&journal->j_state_lock);
@@ -369,7 +372,7 @@ int jbd2_journal_extend(handle_t *handle, int nblocks)
} }
spin_lock(&transaction->t_handle_lock); spin_lock(&transaction->t_handle_lock);
wanted = transaction->t_outstanding_credits + nblocks; wanted = atomic_read(&transaction->t_outstanding_credits) + nblocks;
if (wanted > journal->j_max_transaction_buffers) { if (wanted > journal->j_max_transaction_buffers) {
jbd_debug(3, "denied handle %p %d blocks: " jbd_debug(3, "denied handle %p %d blocks: "
@@ -384,7 +387,7 @@ int jbd2_journal_extend(handle_t *handle, int nblocks)
} }
handle->h_buffer_credits += nblocks; handle->h_buffer_credits += nblocks;
transaction->t_outstanding_credits += nblocks; atomic_add(nblocks, &transaction->t_outstanding_credits);
result = 0; result = 0;
jbd_debug(3, "extended handle %p by %d\n", handle, nblocks); jbd_debug(3, "extended handle %p by %d\n", handle, nblocks);
@@ -426,15 +429,14 @@ int jbd2__journal_restart(handle_t *handle, int nblocks, int gfp_mask)
* First unlink the handle from its current transaction, and start the * First unlink the handle from its current transaction, and start the
* commit on that. * commit on that.
*/ */
J_ASSERT(transaction->t_updates > 0); J_ASSERT(atomic_read(&transaction->t_updates) > 0);
J_ASSERT(journal_current_handle() == handle); J_ASSERT(journal_current_handle() == handle);
spin_lock(&journal->j_state_lock); spin_lock(&journal->j_state_lock);
spin_lock(&transaction->t_handle_lock); spin_lock(&transaction->t_handle_lock);
transaction->t_outstanding_credits -= handle->h_buffer_credits; atomic_sub(handle->h_buffer_credits,
transaction->t_updates--; &transaction->t_outstanding_credits);
if (atomic_dec_and_test(&transaction->t_updates))
if (!transaction->t_updates)
wake_up(&journal->j_wait_updates); wake_up(&journal->j_wait_updates);
spin_unlock(&transaction->t_handle_lock); spin_unlock(&transaction->t_handle_lock);
@@ -481,7 +483,7 @@ void jbd2_journal_lock_updates(journal_t *journal)
break; break;
spin_lock(&transaction->t_handle_lock); spin_lock(&transaction->t_handle_lock);
if (!transaction->t_updates) { if (!atomic_read(&transaction->t_updates)) {
spin_unlock(&transaction->t_handle_lock); spin_unlock(&transaction->t_handle_lock);
break; break;
} }
@@ -1258,7 +1260,8 @@ int jbd2_journal_stop(handle_t *handle)
{ {
transaction_t *transaction = handle->h_transaction; transaction_t *transaction = handle->h_transaction;
journal_t *journal = transaction->t_journal; journal_t *journal = transaction->t_journal;
int err; int err, wait_for_commit = 0;
tid_t tid;
pid_t pid; pid_t pid;
J_ASSERT(journal_current_handle() == handle); J_ASSERT(journal_current_handle() == handle);
@@ -1266,7 +1269,7 @@ int jbd2_journal_stop(handle_t *handle)
if (is_handle_aborted(handle)) if (is_handle_aborted(handle))
err = -EIO; err = -EIO;
else { else {
J_ASSERT(transaction->t_updates > 0); J_ASSERT(atomic_read(&transaction->t_updates) > 0);
err = 0; err = 0;
} }
@@ -1334,14 +1337,8 @@ int jbd2_journal_stop(handle_t *handle)
if (handle->h_sync) if (handle->h_sync)
transaction->t_synchronous_commit = 1; transaction->t_synchronous_commit = 1;
current->journal_info = NULL; current->journal_info = NULL;
spin_lock(&transaction->t_handle_lock); atomic_sub(handle->h_buffer_credits,
transaction->t_outstanding_credits -= handle->h_buffer_credits; &transaction->t_outstanding_credits);
transaction->t_updates--;
if (!transaction->t_updates) {
wake_up(&journal->j_wait_updates);
if (journal->j_barrier_count)
wake_up(&journal->j_wait_transaction_locked);
}
/* /*
* If the handle is marked SYNC, we need to set another commit * If the handle is marked SYNC, we need to set another commit
@@ -1350,15 +1347,13 @@ int jbd2_journal_stop(handle_t *handle)
* transaction is too old now. * transaction is too old now.
*/ */
if (handle->h_sync || if (handle->h_sync ||
transaction->t_outstanding_credits > (atomic_read(&transaction->t_outstanding_credits) >
journal->j_max_transaction_buffers || journal->j_max_transaction_buffers) ||
time_after_eq(jiffies, transaction->t_expires)) { time_after_eq(jiffies, transaction->t_expires)) {
/* Do this even for aborted journals: an abort still /* Do this even for aborted journals: an abort still
* completes the commit thread, it just doesn't write * completes the commit thread, it just doesn't write
* anything to disk. */ * anything to disk. */
tid_t tid = transaction->t_tid;
spin_unlock(&transaction->t_handle_lock);
jbd_debug(2, "transaction too old, requesting commit for " jbd_debug(2, "transaction too old, requesting commit for "
"handle %p\n", handle); "handle %p\n", handle);
/* This is non-blocking */ /* This is non-blocking */
@@ -1369,11 +1364,25 @@ int jbd2_journal_stop(handle_t *handle)
* to wait for the commit to complete. * to wait for the commit to complete.
*/ */
if (handle->h_sync && !(current->flags & PF_MEMALLOC)) if (handle->h_sync && !(current->flags & PF_MEMALLOC))
err = jbd2_log_wait_commit(journal, tid); wait_for_commit = 1;
} else {
spin_unlock(&transaction->t_handle_lock);
} }
/*
* Once we drop t_updates, if it goes to zero the transaction
* could start commiting on us and eventually disappear. So
* 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)
wake_up(&journal->j_wait_transaction_locked);
}
if (wait_for_commit)
err = jbd2_log_wait_commit(journal, tid);
lock_map_release(&handle->h_lockdep_map); lock_map_release(&handle->h_lockdep_map);
jbd2_free_handle(handle); jbd2_free_handle(handle);

8
include/linux/jbd2.h
View File

@@ -601,13 +601,13 @@ struct transaction_s
* Number of outstanding updates running on this transaction * Number of outstanding updates running on this transaction
* [t_handle_lock] * [t_handle_lock]
*/ */
int t_updates; atomic_t t_updates;
/* /*
* Number of buffers reserved for use by all handles in this transaction * Number of buffers reserved for use by all handles in this transaction
* handle but not yet modified. [t_handle_lock] * handle but not yet modified. [t_handle_lock]
*/ */
int t_outstanding_credits; atomic_t t_outstanding_credits;
/* /*
* Forward and backward links for the circular list of all transactions * Forward and backward links for the circular list of all transactions
@@ -1258,8 +1258,8 @@ static inline int jbd_space_needed(journal_t *journal)
{ {
int nblocks = journal->j_max_transaction_buffers; int nblocks = journal->j_max_transaction_buffers;
if (journal->j_committing_transaction) if (journal->j_committing_transaction)
nblocks += journal->j_committing_transaction-> nblocks += atomic_read(&journal->j_committing_transaction->
t_outstanding_credits; t_outstanding_credits);
return nblocks; return nblocks;
} }