jbd2: Unify log messages in jbd2 code

Some jbd2 code prints out kernel messages with "JBD2: " prefix, at the
same time other jbd2 code prints with "JBD: " prefix. Unify the prefix
to "JBD2: ".

Signed-off-by: Eryu Guan <guaneryu@gmail.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

4 files changed, 47 insertions, 47 deletions

diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index eef6979821a4..68d704db787f 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -352,7 +352,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         J_ASSERT(commit_transaction->t_state == T_RUNNING);
 
         trace_jbd2_start_commit(journal, commit_transaction);
-        jbd_debug(1, "JBD: starting commit of transaction %d\n",
+        jbd_debug(1, "JBD2: starting commit of transaction %d\n",
                         commit_transaction->t_tid);
 
         write_lock(&journal->j_state_lock);
@@ -427,7 +427,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         __jbd2_journal_clean_checkpoint_list(journal);
         spin_unlock(&journal->j_list_lock);
 
-        jbd_debug (3, "JBD: commit phase 1\n");
+        jbd_debug(3, "JBD2: commit phase 1\n");
 
         /*
          * Switch to a new revoke table.
@@ -447,7 +447,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         wake_up(&journal->j_wait_transaction_locked);
         write_unlock(&journal->j_state_lock);
 
-        jbd_debug (3, "JBD: commit phase 2\n");
+        jbd_debug(3, "JBD2: commit phase 2\n");
 
         /*
          * Now start flushing things to disk, in the order they appear
@@ -462,7 +462,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
                                           WRITE_SYNC);
         blk_finish_plug(&plug);
 
-        jbd_debug(3, "JBD: commit phase 2\n");
+        jbd_debug(3, "JBD2: commit phase 2\n");
 
         /*
          * Way to go: we have now written out all of the data for a
@@ -522,7 +522,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
 
                         J_ASSERT (bufs == 0);
 
-                        jbd_debug(4, "JBD: get descriptor\n");
+                        jbd_debug(4, "JBD2: get descriptor\n");
 
                         descriptor = jbd2_journal_get_descriptor_buffer(journal);
                         if (!descriptor) {
@@ -531,7 +531,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
                         }
 
                         bh = jh2bh(descriptor);
-                        jbd_debug(4, "JBD: got buffer %llu (%p)\n",
+                        jbd_debug(4, "JBD2: got buffer %llu (%p)\n",
                                 (unsigned long long)bh->b_blocknr, bh->b_data);
                         header = (journal_header_t *)&bh->b_data[0];
                         header->h_magic     = cpu_to_be32(JBD2_MAGIC_NUMBER);
@@ -625,7 +625,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
                     commit_transaction->t_buffers == NULL ||
                     space_left < tag_bytes + 16) {
 
-                        jbd_debug(4, "JBD: Submit %d IOs\n", bufs);
+                        jbd_debug(4, "JBD2: Submit %d IOs\n", bufs);
 
                         /* Write an end-of-descriptor marker before
                            submitting the IOs.  "tag" still points to
@@ -707,7 +707,7 @@ start_journal_io:
            so we incur less scheduling load.
         */
 
-        jbd_debug(3, "JBD: commit phase 3\n");
+        jbd_debug(3, "JBD2: commit phase 3\n");
 
         /*
          * akpm: these are BJ_IO, and j_list_lock is not needed.
@@ -771,7 +771,7 @@ wait_for_iobuf:
 
         J_ASSERT (commit_transaction->t_shadow_list == NULL);
 
-        jbd_debug(3, "JBD: commit phase 4\n");
+        jbd_debug(3, "JBD2: commit phase 4\n");
 
         /* Here we wait for the revoke record and descriptor record buffers */
  wait_for_ctlbuf:
@@ -801,7 +801,7 @@ wait_for_iobuf:
         if (err)
                 jbd2_journal_abort(journal, err);
 
-        jbd_debug(3, "JBD: commit phase 5\n");
+        jbd_debug(3, "JBD2: commit phase 5\n");
         write_lock(&journal->j_state_lock);
         J_ASSERT(commit_transaction->t_state == T_COMMIT_DFLUSH);
         commit_transaction->t_state = T_COMMIT_JFLUSH;
@@ -830,7 +830,7 @@ wait_for_iobuf:
            transaction can be removed from any checkpoint list it was on
            before. */
 
-        jbd_debug(3, "JBD: commit phase 6\n");
+        jbd_debug(3, "JBD2: commit phase 6\n");
 
         J_ASSERT(list_empty(&commit_transaction->t_inode_list));
         J_ASSERT(commit_transaction->t_buffers == NULL);
@@ -964,7 +964,7 @@ restart_loop:
 
         /* Done with this transaction! */
 
-        jbd_debug(3, "JBD: commit phase 7\n");
+        jbd_debug(3, "JBD2: commit phase 7\n");
 
         J_ASSERT(commit_transaction->t_state == T_COMMIT_JFLUSH);
 
@@ -1039,7 +1039,7 @@ restart_loop:
                 journal->j_commit_callback(journal, commit_transaction);
 
         trace_jbd2_end_commit(journal, commit_transaction);
-        jbd_debug(1, "JBD: commit %d complete, head %d\n",
+        jbd_debug(1, "JBD2: commit %d complete, head %d\n",
                   journal->j_commit_sequence, journal->j_tail_sequence);
         if (to_free)
                 kfree(commit_transaction);
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index d6e93d00833e..0fa0123151d3 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -491,7 +491,7 @@ int __jbd2_log_start_commit(journal_t *journal, tid_t target)
                  */
 
                 journal->j_commit_request = target;
-                jbd_debug(1, "JBD: requesting commit %d/%d\n",
+                jbd_debug(1, "JBD2: requesting commit %d/%d\n",
                           journal->j_commit_request,
                           journal->j_commit_sequence);
                 wake_up(&journal->j_wait_commit);
@@ -500,7 +500,7 @@ int __jbd2_log_start_commit(journal_t *journal, tid_t target)
                 /* This should never happen, but if it does, preserve
                    the evidence before kjournald goes into a loop and
                    increments j_commit_sequence beyond all recognition. */
-                WARN_ONCE(1, "jbd: bad log_start_commit: %u %u %u %u\n",
+                WARN_ONCE(1, "JBD2: bad log_start_commit: %u %u %u %u\n",
                           journal->j_commit_request,
                           journal->j_commit_sequence,
                           target, journal->j_running_transaction ? 
@@ -645,7 +645,7 @@ int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
         }
 #endif
         while (tid_gt(tid, journal->j_commit_sequence)) {
-                jbd_debug(1, "JBD: want %d, j_commit_sequence=%d\n",
+                jbd_debug(1, "JBD2: want %d, j_commit_sequence=%d\n",
                                   tid, journal->j_commit_sequence);
                 wake_up(&journal->j_wait_commit);
                 read_unlock(&journal->j_state_lock);
@@ -1093,7 +1093,7 @@ static int journal_reset(journal_t *journal)
         first = be32_to_cpu(sb->s_first);
         last = be32_to_cpu(sb->s_maxlen);
         if (first + JBD2_MIN_JOURNAL_BLOCKS > last + 1) {
-                printk(KERN_ERR "JBD: Journal too short (blocks %llu-%llu).\n",
+                printk(KERN_ERR "JBD2: Journal too short (blocks %llu-%llu).\n",
                        first, last);
                 journal_fail_superblock(journal);
                 return -EINVAL;
@@ -1139,7 +1139,7 @@ void jbd2_journal_update_superblock(journal_t *journal, int wait)
          */
         if (sb->s_start == 0 && journal->j_tail_sequence ==
                                 journal->j_transaction_sequence) {
-                jbd_debug(1,"JBD: Skipping superblock update on recovered sb "
+                jbd_debug(1, "JBD2: Skipping superblock update on recovered sb "
                         "(start %ld, seq %d, errno %d)\n",
                         journal->j_tail, journal->j_tail_sequence,
                         journal->j_errno);
@@ -1163,7 +1163,7 @@ void jbd2_journal_update_superblock(journal_t *journal, int wait)
         }
 
         read_lock(&journal->j_state_lock);
-        jbd_debug(1,"JBD: updating superblock (start %ld, seq %d, errno %d)\n",
+        jbd_debug(1, "JBD2: updating superblock (start %ld, seq %d, errno %d)\n",
                   journal->j_tail, journal->j_tail_sequence, journal->j_errno);
 
         sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
@@ -1216,8 +1216,8 @@ static int journal_get_superblock(journal_t *journal)
                 ll_rw_block(READ, 1, &bh);
                 wait_on_buffer(bh);
                 if (!buffer_uptodate(bh)) {
-                        printk (KERN_ERR
-                                "JBD: IO error reading journal superblock\n");
+                        printk(KERN_ERR
+                                "JBD2: IO error reading journal superblock\n");
                         goto out;
                 }
         }
@@ -1228,7 +1228,7 @@ static int journal_get_superblock(journal_t *journal)
 
         if (sb->s_header.h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER) ||
             sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
-                printk(KERN_WARNING "JBD: no valid journal superblock found\n");
+                printk(KERN_WARNING "JBD2: no valid journal superblock found\n");
                 goto out;
         }
 
@@ -1240,14 +1240,14 @@ static int journal_get_superblock(journal_t *journal)
                 journal->j_format_version = 2;
                 break;
         default:
-                printk(KERN_WARNING "JBD: unrecognised superblock format ID\n");
+                printk(KERN_WARNING "JBD2: unrecognised superblock format ID\n");
                 goto out;
         }
 
         if (be32_to_cpu(sb->s_maxlen) < journal->j_maxlen)
                 journal->j_maxlen = be32_to_cpu(sb->s_maxlen);
         else if (be32_to_cpu(sb->s_maxlen) > journal->j_maxlen) {
-                printk (KERN_WARNING "JBD: journal file too short\n");
+                printk(KERN_WARNING "JBD2: journal file too short\n");
                 goto out;
         }
 
@@ -1318,8 +1318,8 @@ int jbd2_journal_load(journal_t *journal)
                      ~cpu_to_be32(JBD2_KNOWN_ROCOMPAT_FEATURES)) ||
                     (sb->s_feature_incompat &
                      ~cpu_to_be32(JBD2_KNOWN_INCOMPAT_FEATURES))) {
-                        printk (KERN_WARNING
-                                "JBD: Unrecognised features on journal\n");
+                        printk(KERN_WARNING
+                                "JBD2: Unrecognised features on journal\n");
                         return -EINVAL;
                 }
         }
@@ -1354,7 +1354,7 @@ int jbd2_journal_load(journal_t *journal)
         return 0;
 
 recovery_error:
-        printk (KERN_WARNING "JBD: recovery failed\n");
+        printk(KERN_WARNING "JBD2: recovery failed\n");
         return -EIO;
 }
 
@@ -1585,7 +1585,7 @@ static int journal_convert_superblock_v1(journal_t *journal,
         struct buffer_head *bh;
 
         printk(KERN_WARNING
-                "JBD: Converting superblock from version 1 to 2.\n");
+                "JBD2: Converting superblock from version 1 to 2.\n");
 
         /* Pre-initialise new fields to zero */
         offset = ((char *) &(sb->s_feature_compat)) - ((char *) sb);
@@ -1702,7 +1702,7 @@ int jbd2_journal_wipe(journal_t *journal, int write)
         if (!journal->j_tail)
                 goto no_recovery;
 
-        printk (KERN_WARNING "JBD: %s recovery information on journal\n",
+        printk(KERN_WARNING "JBD2: %s recovery information on journal\n",
                 write ? "Clearing" : "Ignoring");
 
         err = jbd2_journal_skip_recovery(journal);
@@ -2028,7 +2028,7 @@ static int journal_init_jbd2_journal_head_cache(void)
         retval = 0;
         if (!jbd2_journal_head_cache) {
                 retval = -ENOMEM;
-                printk(KERN_EMERG "JBD: no memory for journal_head cache\n");
+                printk(KERN_EMERG "JBD2: no memory for journal_head cache\n");
         }
         return retval;
 }
@@ -2391,7 +2391,7 @@ static void __exit journal_exit(void)
 #ifdef CONFIG_JBD2_DEBUG
         int n = atomic_read(&nr_journal_heads);
         if (n)
-                printk(KERN_EMERG "JBD: leaked %d journal_heads!\n", n);
+                printk(KERN_EMERG "JBD2: leaked %d journal_heads!\n", n);
 #endif
         jbd2_remove_debugfs_entry();
         jbd2_remove_jbd_stats_proc_entry();
diff --git a/fs/jbd2/recovery.c b/fs/jbd2/recovery.c
index 1cad869494f0..da6d7baf1390 100644
--- a/fs/jbd2/recovery.c
+++ b/fs/jbd2/recovery.c
@@ -89,7 +89,7 @@ static int do_readahead(journal_t *journal, unsigned int start)
                 err = jbd2_journal_bmap(journal, next, &blocknr);
 
                 if (err) {
-                        printk (KERN_ERR "JBD: bad block at offset %u\n",
+                        printk(KERN_ERR "JBD2: bad block at offset %u\n",
                                 next);
                         goto failed;
                 }
@@ -138,14 +138,14 @@ static int jread(struct buffer_head **bhp, journal_t *journal,
         *bhp = NULL;
 
         if (offset >= journal->j_maxlen) {
-                printk(KERN_ERR "JBD: corrupted journal superblock\n");
+                printk(KERN_ERR "JBD2: corrupted journal superblock\n");
                 return -EIO;
         }
 
         err = jbd2_journal_bmap(journal, offset, &blocknr);
 
         if (err) {
-                printk (KERN_ERR "JBD: bad block at offset %u\n",
+                printk(KERN_ERR "JBD2: bad block at offset %u\n",
                         offset);
                 return err;
         }
@@ -163,7 +163,7 @@ static int jread(struct buffer_head **bhp, journal_t *journal,
         }
 
         if (!buffer_uptodate(bh)) {
-                printk (KERN_ERR "JBD: Failed to read block at offset %u\n",
+                printk(KERN_ERR "JBD2: Failed to read block at offset %u\n",
                         offset);
                 brelse(bh);
                 return -EIO;
@@ -251,10 +251,10 @@ int jbd2_journal_recover(journal_t *journal)
         if (!err)
                 err = do_one_pass(journal, &info, PASS_REPLAY);
 
-        jbd_debug(1, "JBD: recovery, exit status %d, "
+        jbd_debug(1, "JBD2: recovery, exit status %d, "
                   "recovered transactions %u to %u\n",
                   err, info.start_transaction, info.end_transaction);
-        jbd_debug(1, "JBD: Replayed %d and revoked %d/%d blocks\n",
+        jbd_debug(1, "JBD2: Replayed %d and revoked %d/%d blocks\n",
                   info.nr_replays, info.nr_revoke_hits, info.nr_revokes);
 
         /* Restart the log at the next transaction ID, thus invalidating
@@ -293,14 +293,14 @@ int jbd2_journal_skip_recovery(journal_t *journal)
         err = do_one_pass(journal, &info, PASS_SCAN);
 
         if (err) {
-                printk(KERN_ERR "JBD: error %d scanning journal\n", err);
+                printk(KERN_ERR "JBD2: error %d scanning journal\n", err);
                 ++journal->j_transaction_sequence;
         } else {
 #ifdef CONFIG_JBD2_DEBUG
                 int dropped = info.end_transaction - 
                         be32_to_cpu(journal->j_superblock->s_sequence);
                 jbd_debug(1,
-                          "JBD: ignoring %d transaction%s from the journal.\n",
+                          "JBD2: ignoring %d transaction%s from the journal.\n",
                           dropped, (dropped == 1) ? "" : "s");
 #endif
                 journal->j_transaction_sequence = ++info.end_transaction;
@@ -338,7 +338,7 @@ static int calc_chksums(journal_t *journal, struct buffer_head *bh,
                 wrap(journal, *next_log_block);
                 err = jread(&obh, journal, io_block);
                 if (err) {
-                        printk(KERN_ERR "JBD: IO error %d recovering block "
+                        printk(KERN_ERR "JBD2: IO error %d recovering block "
                                 "%lu in log\n", err, io_block);
                         return 1;
                 } else {
@@ -411,7 +411,7 @@ static int do_one_pass(journal_t *journal,
                  * either the next descriptor block or the final commit
                  * record. */
 
-                jbd_debug(3, "JBD: checking block %ld\n", next_log_block);
+                jbd_debug(3, "JBD2: checking block %ld\n", next_log_block);
                 err = jread(&bh, journal, next_log_block);
                 if (err)
                         goto failed;
@@ -491,8 +491,8 @@ static int do_one_pass(journal_t *journal,
                                         /* Recover what we can, but
                                          * report failure at the end. */
                                         success = err;
-                                        printk (KERN_ERR
-                                                "JBD: IO error %d recovering "
+                                        printk(KERN_ERR
+                                                "JBD2: IO error %d recovering "
                                                 "block %ld in log\n",
                                                 err, io_block);
                                 } else {
@@ -520,7 +520,7 @@ static int do_one_pass(journal_t *journal,
                                                         journal->j_blocksize);
                                         if (nbh == NULL) {
                                                 printk(KERN_ERR
-                                                       "JBD: Out of memory "
+                                                       "JBD2: Out of memory "
                                                        "during recovery.\n");
                                                 err = -ENOMEM;
                                                 brelse(bh);
@@ -689,7 +689,7 @@ static int do_one_pass(journal_t *journal,
                 /* It's really bad news if different passes end up at
                  * different places (but possible due to IO errors). */
                 if (info->end_transaction != next_commit_ID) {
-                        printk (KERN_ERR "JBD: recovery pass %d ended at "
+                        printk(KERN_ERR "JBD2: recovery pass %d ended at "
                                 "transaction %u, expected %u\n",
                                 pass, next_commit_ID, info->end_transaction);
                         if (!success)
diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
index 1e5c5ead5b0d..a0e41a4c080e 100644
--- a/fs/jbd2/transaction.c
+++ b/fs/jbd2/transaction.c
@@ -125,7 +125,7 @@ static int start_this_handle(journal_t *journal, handle_t *handle,
         unsigned long ts = jiffies;
 
         if (nblocks > journal->j_max_transaction_buffers) {
-                printk(KERN_ERR "JBD: %s wants too many credits (%d > %d)\n",
+                printk(KERN_ERR "JBD2: %s wants too many credits (%d > %d)\n",
                        current->comm, nblocks,
                        journal->j_max_transaction_buffers);
                 return -ENOSPC;
@@ -564,7 +564,7 @@ static void warn_dirty_buffer(struct buffer_head *bh)
         char b[BDEVNAME_SIZE];
 
         printk(KERN_WARNING
-               "JBD: Spotted dirty metadata buffer (dev = %s, blocknr = %llu). "
+               "JBD2: Spotted dirty metadata buffer (dev = %s, blocknr = %llu). "
                "There's a risk of filesystem corruption in case of system "
                "crash.\n",
                bdevname(bh->b_bdev, b), (unsigned long long)bh->b_blocknr);