mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-11-01 00:48:50 +00:00
Code Issues Releases Wiki Activity

jbd2: rename jbd_debug() to jbd2_debug()

Browse source 
The name of jbd_debug() is confusing as all functions inside jbd2 have
jbd2_ prefix. Rename jbd_debug() to jbd2_debug(). No functional changes.

Signed-off-by: Jan Kara <jack@suse.cz>
Reviewed-by: Lukas Czerner <lczerner@redhat.com>
Link: https://lore.kernel.org/r/20220608112355.4397-2-jack@suse.cz
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
This commit is contained in:
Jan Kara 2022-06-08 13:23:48 +02:00 committed by Theodore Ts'o
parent 4978c659e7
commit cb3b3bf22c
7 changed files with 69 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
fs/jbd2/checkpoint.c
View file

@ -203,7 +203,7 @@ int jbd2_log_do_checkpoint(journal_t *journal)
tid_t this_tid; tid_t this_tid;
int result, batch_count = 0; int result, batch_count = 0;
jbd_debug(1, "Start checkpoint\n"); jbd2_debug(1, "Start checkpoint\n");
/* /*
* First thing: if there are any transactions in the log which * First thing: if there are any transactions in the log which
@ -212,7 +212,7 @@ int jbd2_log_do_checkpoint(journal_t *journal)
*/ */
result = jbd2_cleanup_journal_tail(journal); result = jbd2_cleanup_journal_tail(journal);
trace_jbd2_checkpoint(journal, result); trace_jbd2_checkpoint(journal, result);
jbd_debug(1, "cleanup_journal_tail returned %d\n", result); jbd2_debug(1, "cleanup_journal_tail returned %d\n", result);
if (result <= 0) if (result <= 0)
return result; return result;
@ -804,5 +804,5 @@ void __jbd2_journal_drop_transaction(journal_t *journal, transaction_t *transact
trace_jbd2_drop_transaction(journal, transaction); trace_jbd2_drop_transaction(journal, transaction);
jbd_debug(1, "Dropping transaction %d, all done\n", transaction->t_tid); jbd2_debug(1, "Dropping transaction %d, all done\n", transaction->t_tid);
} }

30
fs/jbd2/commit.c
View file

@ -421,7 +421,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
/* Do we need to erase the effects of a prior jbd2_journal_flush? */ /* Do we need to erase the effects of a prior jbd2_journal_flush? */
if (journal->j_flags & JBD2_FLUSHED) { if (journal->j_flags & JBD2_FLUSHED) {
jbd_debug(3, "super block updated\n"); jbd2_debug(3, "super block updated\n");
mutex_lock_io(&journal->j_checkpoint_mutex); mutex_lock_io(&journal->j_checkpoint_mutex);
/* /*
* We hold j_checkpoint_mutex so tail cannot change under us. * We hold j_checkpoint_mutex so tail cannot change under us.
@ -435,7 +435,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
REQ_SYNC); REQ_SYNC);
mutex_unlock(&journal->j_checkpoint_mutex); mutex_unlock(&journal->j_checkpoint_mutex);
} else { } else {
jbd_debug(3, "superblock not updated\n"); jbd2_debug(3, "superblock not updated\n");
} }
J_ASSERT(journal->j_running_transaction != NULL); J_ASSERT(journal->j_running_transaction != NULL);
@ -467,7 +467,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
commit_transaction = journal->j_running_transaction; commit_transaction = journal->j_running_transaction;
trace_jbd2_start_commit(journal, commit_transaction); trace_jbd2_start_commit(journal, commit_transaction);
jbd_debug(1, "JBD2: starting commit of transaction %d\n", jbd2_debug(1, "JBD2: starting commit of transaction %d\n",
commit_transaction->t_tid); commit_transaction->t_tid);
write_lock(&journal->j_state_lock); write_lock(&journal->j_state_lock);
@ -540,7 +540,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
__jbd2_journal_clean_checkpoint_list(journal, false); __jbd2_journal_clean_checkpoint_list(journal, false);
spin_unlock(&journal->j_list_lock); spin_unlock(&journal->j_list_lock);
jbd_debug(3, "JBD2: commit phase 1\n"); jbd2_debug(3, "JBD2: commit phase 1\n");
/* /*
* Clear revoked flag to reflect there is no revoked buffers * Clear revoked flag to reflect there is no revoked buffers
@ -573,7 +573,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
wake_up(&journal->j_wait_transaction_locked); wake_up(&journal->j_wait_transaction_locked);
write_unlock(&journal->j_state_lock); write_unlock(&journal->j_state_lock);
jbd_debug(3, "JBD2: commit phase 2a\n"); jbd2_debug(3, "JBD2: commit phase 2a\n");
/* /*
* Now start flushing things to disk, in the order they appear * Now start flushing things to disk, in the order they appear
@ -586,7 +586,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
blk_start_plug(&plug); blk_start_plug(&plug);
jbd2_journal_write_revoke_records(commit_transaction, &log_bufs); jbd2_journal_write_revoke_records(commit_transaction, &log_bufs);
jbd_debug(3, "JBD2: commit phase 2b\n"); jbd2_debug(3, "JBD2: commit phase 2b\n");
/* /*
* Way to go: we have now written out all of the data for a * Way to go: we have now written out all of the data for a
@ -642,7 +642,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
if (!descriptor) { if (!descriptor) {
J_ASSERT (bufs == 0); J_ASSERT (bufs == 0);
jbd_debug(4, "JBD2: get descriptor\n"); jbd2_debug(4, "JBD2: get descriptor\n");
descriptor = jbd2_journal_get_descriptor_buffer( descriptor = jbd2_journal_get_descriptor_buffer(
commit_transaction, commit_transaction,
@ -652,7 +652,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
continue; continue;
} }
jbd_debug(4, "JBD2: got buffer %llu (%p)\n", jbd2_debug(4, "JBD2: got buffer %llu (%p)\n",
(unsigned long long)descriptor->b_blocknr, (unsigned long long)descriptor->b_blocknr,
descriptor->b_data); descriptor->b_data);
tagp = &descriptor->b_data[sizeof(journal_header_t)]; tagp = &descriptor->b_data[sizeof(journal_header_t)];
@ -737,7 +737,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
commit_transaction->t_buffers == NULL || commit_transaction->t_buffers == NULL ||
space_left < tag_bytes + 16 + csum_size) { space_left < tag_bytes + 16 + csum_size) {
jbd_debug(4, "JBD2: Submit %d IOs\n", bufs); jbd2_debug(4, "JBD2: Submit %d IOs\n", bufs);
/* Write an end-of-descriptor marker before /* Write an end-of-descriptor marker before
submitting the IOs. "tag" still points to submitting the IOs. "tag" still points to
@ -839,7 +839,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
so we incur less scheduling load. so we incur less scheduling load.
*/ */
jbd_debug(3, "JBD2: commit phase 3\n"); jbd2_debug(3, "JBD2: commit phase 3\n");
while (!list_empty(&io_bufs)) { while (!list_empty(&io_bufs)) {
struct buffer_head *bh = list_entry(io_bufs.prev, struct buffer_head *bh = list_entry(io_bufs.prev,
@ -882,7 +882,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
J_ASSERT (commit_transaction->t_shadow_list == NULL); J_ASSERT (commit_transaction->t_shadow_list == NULL);
jbd_debug(3, "JBD2: commit phase 4\n"); jbd2_debug(3, "JBD2: commit phase 4\n");
/* Here we wait for the revoke record and descriptor record buffers */ /* Here we wait for the revoke record and descriptor record buffers */
while (!list_empty(&log_bufs)) { while (!list_empty(&log_bufs)) {
@ -906,7 +906,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
if (err) if (err)
jbd2_journal_abort(journal, err); jbd2_journal_abort(journal, err);
jbd_debug(3, "JBD2: commit phase 5\n"); jbd2_debug(3, "JBD2: commit phase 5\n");
write_lock(&journal->j_state_lock); write_lock(&journal->j_state_lock);
J_ASSERT(commit_transaction->t_state == T_COMMIT_DFLUSH); J_ASSERT(commit_transaction->t_state == T_COMMIT_DFLUSH);
commit_transaction->t_state = T_COMMIT_JFLUSH; commit_transaction->t_state = T_COMMIT_JFLUSH;
@ -945,7 +945,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
transaction can be removed from any checkpoint list it was on transaction can be removed from any checkpoint list it was on
before. */ before. */
jbd_debug(3, "JBD2: commit phase 6\n"); jbd2_debug(3, "JBD2: commit phase 6\n");
J_ASSERT(list_empty(&commit_transaction->t_inode_list)); J_ASSERT(list_empty(&commit_transaction->t_inode_list));
J_ASSERT(commit_transaction->t_buffers == NULL); J_ASSERT(commit_transaction->t_buffers == NULL);
@ -1122,7 +1122,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
/* Done with this transaction! */ /* Done with this transaction! */
jbd_debug(3, "JBD2: commit phase 7\n"); jbd2_debug(3, "JBD2: commit phase 7\n");
J_ASSERT(commit_transaction->t_state == T_COMMIT_JFLUSH); J_ASSERT(commit_transaction->t_state == T_COMMIT_JFLUSH);
@ -1164,7 +1164,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
journal->j_fc_cleanup_callback(journal, 1, commit_transaction->t_tid); journal->j_fc_cleanup_callback(journal, 1, commit_transaction->t_tid);
trace_jbd2_end_commit(journal, commit_transaction); trace_jbd2_end_commit(journal, commit_transaction);
jbd_debug(1, "JBD2: commit %d complete, head %d\n", jbd2_debug(1, "JBD2: commit %d complete, head %d\n",
journal->j_commit_sequence, journal->j_tail_sequence); journal->j_commit_sequence, journal->j_tail_sequence);
write_lock(&journal->j_state_lock); write_lock(&journal->j_state_lock);

34
fs/jbd2/journal.c
View file

@ -203,11 +203,11 @@ static int kjournald2(void *arg)
if (journal->j_flags & JBD2_UNMOUNT) if (journal->j_flags & JBD2_UNMOUNT)
goto end_loop; goto end_loop;
jbd_debug(1, "commit_sequence=%u, commit_request=%u\n", jbd2_debug(1, "commit_sequence=%u, commit_request=%u\n",
journal->j_commit_sequence, journal->j_commit_request); journal->j_commit_sequence, journal->j_commit_request);
if (journal->j_commit_sequence != journal->j_commit_request) { if (journal->j_commit_sequence != journal->j_commit_request) {
jbd_debug(1, "OK, requests differ\n"); jbd2_debug(1, "OK, requests differ\n");
write_unlock(&journal->j_state_lock); write_unlock(&journal->j_state_lock);
del_timer_sync(&journal->j_commit_timer); del_timer_sync(&journal->j_commit_timer);
jbd2_journal_commit_transaction(journal); jbd2_journal_commit_transaction(journal);
@ -222,7 +222,7 @@ static int kjournald2(void *arg)
* good idea, because that depends on threads that may * good idea, because that depends on threads that may
* be already stopped. * be already stopped.
*/ */
jbd_debug(1, "Now suspending kjournald2\n"); jbd2_debug(1, "Now suspending kjournald2\n");
write_unlock(&journal->j_state_lock); write_unlock(&journal->j_state_lock);
try_to_freeze(); try_to_freeze();
write_lock(&journal->j_state_lock); write_lock(&journal->j_state_lock);
@ -252,7 +252,7 @@ static int kjournald2(void *arg)
finish_wait(&journal->j_wait_commit, &wait); finish_wait(&journal->j_wait_commit, &wait);
} }
jbd_debug(1, "kjournald2 wakes\n"); jbd2_debug(1, "kjournald2 wakes\n");
/* /*
* Were we woken up by a commit wakeup event? * Were we woken up by a commit wakeup event?
@ -260,7 +260,7 @@ static int kjournald2(void *arg)
transaction = journal->j_running_transaction; transaction = journal->j_running_transaction;
if (transaction && time_after_eq(jiffies, transaction->t_expires)) { if (transaction && time_after_eq(jiffies, transaction->t_expires)) {
journal->j_commit_request = transaction->t_tid; journal->j_commit_request = transaction->t_tid;
jbd_debug(1, "woke because of timeout\n"); jbd2_debug(1, "woke because of timeout\n");
} }
goto loop; goto loop;
@ -268,7 +268,7 @@ static int kjournald2(void *arg)
del_timer_sync(&journal->j_commit_timer); del_timer_sync(&journal->j_commit_timer);
journal->j_task = NULL; journal->j_task = NULL;
wake_up(&journal->j_wait_done_commit); wake_up(&journal->j_wait_done_commit);
jbd_debug(1, "Journal thread exiting.\n"); jbd2_debug(1, "Journal thread exiting.\n");
write_unlock(&journal->j_state_lock); write_unlock(&journal->j_state_lock);
return 0; return 0;
} }
@ -500,7 +500,7 @@ int __jbd2_log_start_commit(journal_t *journal, tid_t target)
*/ */
journal->j_commit_request = target; journal->j_commit_request = target;
jbd_debug(1, "JBD2: requesting commit %u/%u\n", jbd2_debug(1, "JBD2: requesting commit %u/%u\n",
journal->j_commit_request, journal->j_commit_request,
journal->j_commit_sequence); journal->j_commit_sequence);
journal->j_running_transaction->t_requested = jiffies; journal->j_running_transaction->t_requested = jiffies;
@ -705,7 +705,7 @@ int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
} }
#endif #endif
while (tid_gt(tid, journal->j_commit_sequence)) { while (tid_gt(tid, journal->j_commit_sequence)) {
jbd_debug(1, "JBD2: want %u, j_commit_sequence=%u\n", jbd2_debug(1, "JBD2: want %u, j_commit_sequence=%u\n",
tid, journal->j_commit_sequence); tid, journal->j_commit_sequence);
read_unlock(&journal->j_state_lock); read_unlock(&journal->j_state_lock);
wake_up(&journal->j_wait_commit); wake_up(&journal->j_wait_commit);
@ -1117,7 +1117,7 @@ int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
freed += journal->j_last - journal->j_first; freed += journal->j_last - journal->j_first;
trace_jbd2_update_log_tail(journal, tid, block, freed); trace_jbd2_update_log_tail(journal, tid, block, freed);
jbd_debug(1, jbd2_debug(1,
"Cleaning journal tail from %u to %u (offset %lu), " "Cleaning journal tail from %u to %u (offset %lu), "
"freeing %lu\n", "freeing %lu\n",
journal->j_tail_sequence, tid, block, freed); journal->j_tail_sequence, tid, block, freed);
@ -1496,7 +1496,7 @@ journal_t *jbd2_journal_init_inode(struct inode *inode)
return NULL; return NULL;
} }
jbd_debug(1, "JBD2: inode %s/%ld, size %lld, bits %d, blksize %ld\n", jbd2_debug(1, "JBD2: inode %s/%ld, size %lld, bits %d, blksize %ld\n",
inode->i_sb->s_id, inode->i_ino, (long long) inode->i_size, inode->i_sb->s_id, inode->i_ino, (long long) inode->i_size,
inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize); inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
@ -1575,7 +1575,7 @@ static int journal_reset(journal_t *journal)
* attempting a write to a potential-readonly device. * attempting a write to a potential-readonly device.
*/ */
if (sb->s_start == 0) { if (sb->s_start == 0) {
jbd_debug(1, "JBD2: Skipping superblock update on recovered sb " jbd2_debug(1, "JBD2: Skipping superblock update on recovered sb "
"(start %ld, seq %u, errno %d)\n", "(start %ld, seq %u, errno %d)\n",
journal->j_tail, journal->j_tail_sequence, journal->j_tail, journal->j_tail_sequence,
journal->j_errno); journal->j_errno);
@ -1678,7 +1678,7 @@ int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,
} }
BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex)); BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
jbd_debug(1, "JBD2: updating superblock (start %lu, seq %u)\n", jbd2_debug(1, "JBD2: updating superblock (start %lu, seq %u)\n",
tail_block, tail_tid); tail_block, tail_tid);
lock_buffer(journal->j_sb_buffer); lock_buffer(journal->j_sb_buffer);
@ -1719,7 +1719,7 @@ static void jbd2_mark_journal_empty(journal_t *journal, int write_op)
return; return;
} }
jbd_debug(1, "JBD2: Marking journal as empty (seq %u)\n", jbd2_debug(1, "JBD2: Marking journal as empty (seq %u)\n",
journal->j_tail_sequence); journal->j_tail_sequence);
sb->s_sequence = cpu_to_be32(journal->j_tail_sequence); sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
@ -1862,7 +1862,7 @@ void jbd2_journal_update_sb_errno(journal_t *journal)
errcode = journal->j_errno; errcode = journal->j_errno;
if (errcode == -ESHUTDOWN) if (errcode == -ESHUTDOWN)
errcode = 0; errcode = 0;
jbd_debug(1, "JBD2: updating superblock error (errno %d)\n", errcode); jbd2_debug(1, "JBD2: updating superblock error (errno %d)\n", errcode);
sb->s_errno = cpu_to_be32(errcode); sb->s_errno = cpu_to_be32(errcode);
jbd2_write_superblock(journal, REQ_SYNC | REQ_FUA); jbd2_write_superblock(journal, REQ_SYNC | REQ_FUA);
@ -2334,7 +2334,7 @@ int jbd2_journal_set_features(journal_t *journal, unsigned long compat,
compat & JBD2_FEATURE_COMPAT_CHECKSUM) compat & JBD2_FEATURE_COMPAT_CHECKSUM)
compat &= ~JBD2_FEATURE_COMPAT_CHECKSUM; compat &= ~JBD2_FEATURE_COMPAT_CHECKSUM;
jbd_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n", jbd2_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n",
compat, ro, incompat); compat, ro, incompat);
sb = journal->j_superblock; sb = journal->j_superblock;
@ -2403,7 +2403,7 @@ void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,
{ {
journal_superblock_t *sb; journal_superblock_t *sb;
jbd_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n", jbd2_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n",
compat, ro, incompat); compat, ro, incompat);
sb = journal->j_superblock; sb = journal->j_superblock;
@ -2860,7 +2860,7 @@ static struct journal_head *journal_alloc_journal_head(void)
#endif #endif
ret = kmem_cache_zalloc(jbd2_journal_head_cache, GFP_NOFS); ret = kmem_cache_zalloc(jbd2_journal_head_cache, GFP_NOFS);
if (!ret) { if (!ret) {
jbd_debug(1, "out of memory for journal_head\n"); jbd2_debug(1, "out of memory for journal_head\n");
pr_notice_ratelimited("ENOMEM in %s, retrying.\n", __func__); pr_notice_ratelimited("ENOMEM in %s, retrying.\n", __func__);
ret = kmem_cache_zalloc(jbd2_journal_head_cache, ret = kmem_cache_zalloc(jbd2_journal_head_cache,
GFP_NOFS | __GFP_NOFAIL); GFP_NOFS | __GFP_NOFAIL);

30
fs/jbd2/recovery.c
View file

@ -245,11 +245,11 @@ static int fc_do_one_pass(journal_t *journal,
return 0; return 0;
while (next_fc_block <= journal->j_fc_last) { while (next_fc_block <= journal->j_fc_last) {
jbd_debug(3, "Fast commit replay: next block %ld\n", jbd2_debug(3, "Fast commit replay: next block %ld\n",
next_fc_block); next_fc_block);
err = jread(&bh, journal, next_fc_block); err = jread(&bh, journal, next_fc_block);
if (err) { if (err) {
jbd_debug(3, "Fast commit replay: read error\n"); jbd2_debug(3, "Fast commit replay: read error\n");
break; break;
} }
@ -263,7 +263,7 @@ static int fc_do_one_pass(journal_t *journal,
} }
if (err) if (err)
jbd_debug(3, "Fast commit replay failed, err = %d\n", err); jbd2_debug(3, "Fast commit replay failed, err = %d\n", err);
return err; return err;
} }
@ -297,7 +297,7 @@ int jbd2_journal_recover(journal_t *journal)
*/ */
if (!sb->s_start) { if (!sb->s_start) {
jbd_debug(1, "No recovery required, last transaction %d\n", jbd2_debug(1, "No recovery required, last transaction %d\n",
be32_to_cpu(sb->s_sequence)); be32_to_cpu(sb->s_sequence));
journal->j_transaction_sequence = be32_to_cpu(sb->s_sequence) + 1; journal->j_transaction_sequence = be32_to_cpu(sb->s_sequence) + 1;
return 0; return 0;
@ -309,10 +309,10 @@ int jbd2_journal_recover(journal_t *journal)
if (!err) if (!err)
err = do_one_pass(journal, &info, PASS_REPLAY); err = do_one_pass(journal, &info, PASS_REPLAY);
jbd_debug(1, "JBD2: recovery, exit status %d, " jbd2_debug(1, "JBD2: recovery, exit status %d, "
"recovered transactions %u to %u\n", "recovered transactions %u to %u\n",
err, info.start_transaction, info.end_transaction); err, info.start_transaction, info.end_transaction);
jbd_debug(1, "JBD2: Replayed %d and revoked %d/%d blocks\n", jbd2_debug(1, "JBD2: Replayed %d and revoked %d/%d blocks\n",
info.nr_replays, info.nr_revoke_hits, info.nr_revokes); info.nr_replays, info.nr_revoke_hits, info.nr_revokes);
/* Restart the log at the next transaction ID, thus invalidating /* Restart the log at the next transaction ID, thus invalidating
@ -362,7 +362,7 @@ int jbd2_journal_skip_recovery(journal_t *journal)
#ifdef CONFIG_JBD2_DEBUG #ifdef CONFIG_JBD2_DEBUG
int dropped = info.end_transaction - int dropped = info.end_transaction -
be32_to_cpu(journal->j_superblock->s_sequence); be32_to_cpu(journal->j_superblock->s_sequence);
jbd_debug(1, jbd2_debug(1,
"JBD2: ignoring %d transaction%s from the journal.\n", "JBD2: ignoring %d transaction%s from the journal.\n",
dropped, (dropped == 1) ? "" : "s"); dropped, (dropped == 1) ? "" : "s");
#endif #endif
@ -484,7 +484,7 @@ static int do_one_pass(journal_t *journal,
if (pass == PASS_SCAN) if (pass == PASS_SCAN)
info->start_transaction = first_commit_ID; info->start_transaction = first_commit_ID;
jbd_debug(1, "Starting recovery pass %d\n", pass); jbd2_debug(1, "Starting recovery pass %d\n", pass);
/* /*
* Now we walk through the log, transaction by transaction, * Now we walk through the log, transaction by transaction,
@ -510,7 +510,7 @@ static int do_one_pass(journal_t *journal,
if (tid_geq(next_commit_ID, info->end_transaction)) if (tid_geq(next_commit_ID, info->end_transaction))
break; break;
jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n", jbd2_debug(2, "Scanning for sequence ID %u at %lu/%lu\n",
next_commit_ID, next_log_block, next_commit_ID, next_log_block,
jbd2_has_feature_fast_commit(journal) ? jbd2_has_feature_fast_commit(journal) ?
journal->j_fc_last : journal->j_last); journal->j_fc_last : journal->j_last);
@ -519,7 +519,7 @@ static int do_one_pass(journal_t *journal,
* either the next descriptor block or the final commit * either the next descriptor block or the final commit
* record. */ * record. */
jbd_debug(3, "JBD2: checking block %ld\n", next_log_block); jbd2_debug(3, "JBD2: checking block %ld\n", next_log_block);
err = jread(&bh, journal, next_log_block); err = jread(&bh, journal, next_log_block);
if (err) if (err)
goto failed; goto failed;
@ -542,7 +542,7 @@ static int do_one_pass(journal_t *journal,
blocktype = be32_to_cpu(tmp->h_blocktype); blocktype = be32_to_cpu(tmp->h_blocktype);
sequence = be32_to_cpu(tmp->h_sequence); sequence = be32_to_cpu(tmp->h_sequence);
jbd_debug(3, "Found magic %d, sequence %d\n", jbd2_debug(3, "Found magic %d, sequence %d\n",
blocktype, sequence); blocktype, sequence);
if (sequence != next_commit_ID) { if (sequence != next_commit_ID) {
@ -575,7 +575,7 @@ static int do_one_pass(journal_t *journal,
goto failed; goto failed;
} }
need_check_commit_time = true; need_check_commit_time = true;
jbd_debug(1, jbd2_debug(1,
"invalid descriptor block found in %lu\n", "invalid descriptor block found in %lu\n",
next_log_block); next_log_block);
} }
@ -758,7 +758,7 @@ static int do_one_pass(journal_t *journal,
* It likely does not belong to same journal, * It likely does not belong to same journal,
* just end this recovery with success. * just end this recovery with success.
*/ */
jbd_debug(1, "JBD2: Invalid checksum ignored in transaction %u, likely stale data\n", jbd2_debug(1, "JBD2: Invalid checksum ignored in transaction %u, likely stale data\n",
next_commit_ID); next_commit_ID);
brelse(bh); brelse(bh);
goto done; goto done;
@ -826,7 +826,7 @@ static int do_one_pass(journal_t *journal,
if (pass == PASS_SCAN && if (pass == PASS_SCAN &&
!jbd2_descriptor_block_csum_verify(journal, !jbd2_descriptor_block_csum_verify(journal,
bh->b_data)) { bh->b_data)) {
jbd_debug(1, "JBD2: invalid revoke block found in %lu\n", jbd2_debug(1, "JBD2: invalid revoke block found in %lu\n",
next_log_block); next_log_block);
need_check_commit_time = true; need_check_commit_time = true;
} }
@ -845,7 +845,7 @@ static int do_one_pass(journal_t *journal,
continue; continue;
default: default:
jbd_debug(3, "Unrecognised magic %d, end of scan.\n", jbd2_debug(3, "Unrecognised magic %d, end of scan.\n",
blocktype); blocktype);
brelse(bh); brelse(bh);
goto done; goto done;

8
fs/jbd2/revoke.c
View file

@ -398,7 +398,7 @@ int jbd2_journal_revoke(handle_t *handle, unsigned long long blocknr,
} }
handle->h_revoke_credits--; handle->h_revoke_credits--;
jbd_debug(2, "insert revoke for block %llu, bh_in=%p\n",blocknr, bh_in); jbd2_debug(2, "insert revoke for block %llu, bh_in=%p\n",blocknr, bh_in);
err = insert_revoke_hash(journal, blocknr, err = insert_revoke_hash(journal, blocknr,
handle->h_transaction->t_tid); handle->h_transaction->t_tid);
BUFFER_TRACE(bh_in, "exit"); BUFFER_TRACE(bh_in, "exit");
@ -428,7 +428,7 @@ int jbd2_journal_cancel_revoke(handle_t *handle, struct journal_head *jh)
int did_revoke = 0; /* akpm: debug */ int did_revoke = 0; /* akpm: debug */
struct buffer_head *bh = jh2bh(jh); struct buffer_head *bh = jh2bh(jh);
jbd_debug(4, "journal_head %p, cancelling revoke\n", jh); jbd2_debug(4, "journal_head %p, cancelling revoke\n", jh);
/* Is the existing Revoke bit valid? If so, we trust it, and /* Is the existing Revoke bit valid? If so, we trust it, and
* only perform the full cancel if the revoke bit is set. If * only perform the full cancel if the revoke bit is set. If
@ -444,7 +444,7 @@ int jbd2_journal_cancel_revoke(handle_t *handle, struct journal_head *jh)
if (need_cancel) { if (need_cancel) {
record = find_revoke_record(journal, bh->b_blocknr); record = find_revoke_record(journal, bh->b_blocknr);
if (record) { if (record) {
jbd_debug(4, "cancelled existing revoke on " jbd2_debug(4, "cancelled existing revoke on "
"blocknr %llu\n", (unsigned long long)bh->b_blocknr); "blocknr %llu\n", (unsigned long long)bh->b_blocknr);
spin_lock(&journal->j_revoke_lock); spin_lock(&journal->j_revoke_lock);
list_del(&record->hash); list_del(&record->hash);
@ -560,7 +560,7 @@ void jbd2_journal_write_revoke_records(transaction_t *transaction,
} }
if (descriptor) if (descriptor)
flush_descriptor(journal, descriptor, offset); flush_descriptor(journal, descriptor, offset);
jbd_debug(1, "Wrote %d revoke records\n", count); jbd2_debug(1, "Wrote %d revoke records\n", count);
} }
/* /*

26
fs/jbd2/transaction.c
View file

@ -373,7 +373,7 @@ static int start_this_handle(journal_t *journal, handle_t *handle,
return -ENOMEM; return -ENOMEM;
} }
jbd_debug(3, "New handle %p going live.\n", handle); jbd2_debug(3, "New handle %p going live.\n", handle);
/* /*
* We need to hold j_state_lock until t_updates has been incremented, * We need to hold j_state_lock until t_updates has been incremented,
@ -453,7 +453,7 @@ static int start_this_handle(journal_t *journal, handle_t *handle,
handle->h_start_jiffies = jiffies; handle->h_start_jiffies = jiffies;
atomic_inc(&transaction->t_updates); atomic_inc(&transaction->t_updates);
atomic_inc(&transaction->t_handle_count); atomic_inc(&transaction->t_handle_count);
jbd_debug(4, "Handle %p given %d credits (total %d, free %lu)\n", jbd2_debug(4, "Handle %p given %d credits (total %d, free %lu)\n",
handle, blocks, handle, blocks,
atomic_read(&transaction->t_outstanding_credits), atomic_read(&transaction->t_outstanding_credits),
jbd2_log_space_left(journal)); jbd2_log_space_left(journal));
@ -674,7 +674,7 @@ int jbd2_journal_extend(handle_t *handle, int nblocks, int revoke_records)
/* Don't extend a locked-down transaction! */ /* Don't extend a locked-down transaction! */
if (transaction->t_state != T_RUNNING) { if (transaction->t_state != T_RUNNING) {
jbd_debug(3, "denied handle %p %d blocks: " jbd2_debug(3, "denied handle %p %d blocks: "
"transaction not running\n", handle, nblocks); "transaction not running\n", handle, nblocks);
goto error_out; goto error_out;
} }
@ -689,7 +689,7 @@ int jbd2_journal_extend(handle_t *handle, int nblocks, int revoke_records)
&transaction->t_outstanding_credits); &transaction->t_outstanding_credits);
if (wanted > journal->j_max_transaction_buffers) { if (wanted > journal->j_max_transaction_buffers) {
jbd_debug(3, "denied handle %p %d blocks: " jbd2_debug(3, "denied handle %p %d blocks: "
"transaction too large\n", handle, nblocks); "transaction too large\n", handle, nblocks);
atomic_sub(nblocks, &transaction->t_outstanding_credits); atomic_sub(nblocks, &transaction->t_outstanding_credits);
goto error_out; goto error_out;
@ -707,7 +707,7 @@ int jbd2_journal_extend(handle_t *handle, int nblocks, int revoke_records)
handle->h_revoke_credits_requested += revoke_records; handle->h_revoke_credits_requested += revoke_records;
result = 0; result = 0;
jbd_debug(3, "extended handle %p by %d\n", handle, nblocks); jbd2_debug(3, "extended handle %p by %d\n", handle, nblocks);
error_out: error_out:
read_unlock(&journal->j_state_lock); read_unlock(&journal->j_state_lock);
return result; return result;
@ -795,7 +795,7 @@ int jbd2__journal_restart(handle_t *handle, int nblocks, int revoke_records,
* 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.
*/ */
jbd_debug(2, "restarting handle %p\n", handle); jbd2_debug(2, "restarting handle %p\n", handle);
stop_this_handle(handle); stop_this_handle(handle);
handle->h_transaction = NULL; handle->h_transaction = NULL;
@ -979,7 +979,7 @@ do_get_write_access(handle_t *handle, struct journal_head *jh,
journal = transaction->t_journal; journal = transaction->t_journal;
jbd_debug(5, "journal_head %p, force_copy %d\n", jh, force_copy); jbd2_debug(5, "journal_head %p, force_copy %d\n", jh, force_copy);
JBUFFER_TRACE(jh, "entry"); JBUFFER_TRACE(jh, "entry");
repeat: repeat:
@ -1271,7 +1271,7 @@ int jbd2_journal_get_create_access(handle_t *handle, struct buffer_head *bh)
struct journal_head *jh = jbd2_journal_add_journal_head(bh); struct journal_head *jh = jbd2_journal_add_journal_head(bh);
int err; int err;
jbd_debug(5, "journal_head %p\n", jh); jbd2_debug(5, "journal_head %p\n", jh);
err = -EROFS; err = -EROFS;
if (is_handle_aborted(handle)) if (is_handle_aborted(handle))
goto out; goto out;
@ -1496,7 +1496,7 @@ int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
* of the running transaction. * of the running transaction.
*/ */
jh = bh2jh(bh); jh = bh2jh(bh);
jbd_debug(5, "journal_head %p\n", jh); jbd2_debug(5, "journal_head %p\n", jh);
JBUFFER_TRACE(jh, "entry"); JBUFFER_TRACE(jh, "entry");
/* /*
@ -1818,7 +1818,7 @@ int jbd2_journal_stop(handle_t *handle)
pid_t pid; pid_t pid;
if (--handle->h_ref > 0) { if (--handle->h_ref > 0) {
jbd_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1, jbd2_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1,
handle->h_ref); handle->h_ref);
if (is_handle_aborted(handle)) if (is_handle_aborted(handle))
return -EIO; return -EIO;
@ -1838,7 +1838,7 @@ int jbd2_journal_stop(handle_t *handle)
if (is_handle_aborted(handle)) if (is_handle_aborted(handle))
err = -EIO; err = -EIO;
jbd_debug(4, "Handle %p going down\n", handle); jbd2_debug(4, "Handle %p going down\n", handle);
trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev, trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev,
tid, handle->h_type, handle->h_line_no, tid, handle->h_type, handle->h_line_no,
jiffies - handle->h_start_jiffies, jiffies - handle->h_start_jiffies,
@ -1916,7 +1916,7 @@ int jbd2_journal_stop(handle_t *handle)
* completes the commit thread, it just doesn't write * completes the commit thread, it just doesn't write
* anything to disk. */ * anything to disk. */
jbd_debug(2, "transaction too old, requesting commit for " jbd2_debug(2, "transaction too old, requesting commit for "
"handle %p\n", handle); "handle %p\n", handle);
/* This is non-blocking */ /* This is non-blocking */
jbd2_log_start_commit(journal, tid); jbd2_log_start_commit(journal, tid);
@ -2662,7 +2662,7 @@ static int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *jinode,
return -EROFS; return -EROFS;
journal = transaction->t_journal; journal = transaction->t_journal;
jbd_debug(4, "Adding inode %lu, tid:%d\n", jinode->i_vfs_inode->i_ino, jbd2_debug(4, "Adding inode %lu, tid:%d\n", jinode->i_vfs_inode->i_ino,
transaction->t_tid); transaction->t_tid);
spin_lock(&journal->j_list_lock); spin_lock(&journal->j_list_lock);

4
include/linux/jbd2.h
View file

@ -58,10 +58,10 @@ extern ushort jbd2_journal_enable_debug;
void __jbd2_debug(int level, const char *file, const char *func, void __jbd2_debug(int level, const char *file, const char *func,
unsigned int line, const char *fmt, ...); unsigned int line, const char *fmt, ...);
#define jbd_debug(n, fmt, a...) \ #define jbd2_debug(n, fmt, a...) \
__jbd2_debug((n), __FILE__, __func__, __LINE__, (fmt), ##a) __jbd2_debug((n), __FILE__, __func__, __LINE__, (fmt), ##a)
#else #else
#define jbd_debug(n, fmt, a...) no_printk(fmt, ##a) #define jbd2_debug(n, fmt, a...) no_printk(fmt, ##a)
#endif #endif
extern void *jbd2_alloc(size_t size, gfp_t flags); extern void *jbd2_alloc(size_t size, gfp_t flags);