1 files changed, 63 insertions, 40 deletions

diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index 8207a01c4edb..783de118de92 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -597,13 +597,9 @@ int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr,
                 if (ret)
                         *retp = ret;
                 else {
-                        char b[BDEVNAME_SIZE];
-
                         printk(KERN_ALERT "%s: journal block not found "
                                         "at offset %lu on %s\n",
-                                __func__,
-                                blocknr,
-                                bdevname(journal->j_dev, b));
+                               __func__, blocknr, journal->j_devname);
                         err = -EIO;
                         __journal_abort_soft(journal, err);
                 }
@@ -901,10 +897,7 @@ static struct proc_dir_entry *proc_jbd2_stats;
 
 static void jbd2_stats_proc_init(journal_t *journal)
 {
-        char name[BDEVNAME_SIZE];
-
-        bdevname(journal->j_dev, name);
-        journal->j_proc_entry = proc_mkdir(name, proc_jbd2_stats);
+        journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);
         if (journal->j_proc_entry) {
                 proc_create_data("history", S_IRUGO, journal->j_proc_entry,
                                  &jbd2_seq_history_fops, journal);
@@ -915,12 +908,9 @@ static void jbd2_stats_proc_init(journal_t *journal)
 
 static void jbd2_stats_proc_exit(journal_t *journal)
 {
-        char name[BDEVNAME_SIZE];
-
-        bdevname(journal->j_dev, name);
         remove_proc_entry("info", journal->j_proc_entry);
         remove_proc_entry("history", journal->j_proc_entry);
-        remove_proc_entry(name, proc_jbd2_stats);
+        remove_proc_entry(journal->j_devname, proc_jbd2_stats);
 }
 
 static void journal_init_stats(journal_t *journal)
@@ -1018,6 +1008,7 @@ journal_t * jbd2_journal_init_dev(struct block_device *bdev,
 {
         journal_t *journal = journal_init_common();
         struct buffer_head *bh;
+        char *p;
         int n;
 
         if (!journal)
@@ -1039,6 +1030,10 @@ journal_t * jbd2_journal_init_dev(struct block_device *bdev,
         journal->j_fs_dev = fs_dev;
         journal->j_blk_offset = start;
         journal->j_maxlen = len;
+        bdevname(journal->j_dev, journal->j_devname);
+        p = journal->j_devname;
+        while ((p = strchr(p, '/')))
+                *p = '!';
         jbd2_stats_proc_init(journal);
 
         bh = __getblk(journal->j_dev, start, journal->j_blocksize);
@@ -1061,6 +1056,7 @@ journal_t * jbd2_journal_init_inode (struct inode *inode)
 {
         struct buffer_head *bh;
         journal_t *journal = journal_init_common();
+        char *p;
         int err;
         int n;
         unsigned long long blocknr;
@@ -1070,6 +1066,12 @@ journal_t * jbd2_journal_init_inode (struct inode *inode)
 
         journal->j_dev = journal->j_fs_dev = inode->i_sb->s_bdev;
         journal->j_inode = inode;
+        bdevname(journal->j_dev, journal->j_devname);
+        p = journal->j_devname;
+        while ((p = strchr(p, '/')))
+                *p = '!';
+        p = journal->j_devname + strlen(journal->j_devname);
+        sprintf(p, ":%lu", journal->j_inode->i_ino);
         jbd_debug(1,
                   "journal %p: inode %s/%ld, size %Ld, bits %d, blksize %ld\n",
                   journal, inode->i_sb->s_id, inode->i_ino,
@@ -1253,6 +1255,22 @@ void jbd2_journal_update_superblock(journal_t *journal, int wait)
                 goto out;
         }
 
+        if (buffer_write_io_error(bh)) {
+                /*
+                 * Oh, dear.  A previous attempt to write the journal
+                 * superblock failed.  This could happen because the
+                 * USB device was yanked out.  Or it could happen to
+                 * be a transient write error and maybe the block will
+                 * be remapped.  Nothing we can do but to retry the
+                 * write and hope for the best.
+                 */
+                printk(KERN_ERR "JBD2: previous I/O error detected "
+                       "for journal superblock update for %s.\n",
+                       journal->j_devname);
+                clear_buffer_write_io_error(bh);
+                set_buffer_uptodate(bh);
+        }
+
         spin_lock(&journal->j_state_lock);
         jbd_debug(1,"JBD: updating superblock (start %ld, seq %d, errno %d)\n",
                   journal->j_tail, journal->j_tail_sequence, journal->j_errno);
@@ -1264,9 +1282,16 @@ void jbd2_journal_update_superblock(journal_t *journal, int wait)
 
         BUFFER_TRACE(bh, "marking dirty");
         mark_buffer_dirty(bh);
-        if (wait)
+        if (wait) {
                 sync_dirty_buffer(bh);
-        else
+                if (buffer_write_io_error(bh)) {
+                        printk(KERN_ERR "JBD2: I/O error detected "
+                               "when updating journal superblock for %s.\n",
+                               journal->j_devname);
+                        clear_buffer_write_io_error(bh);
+                        set_buffer_uptodate(bh);
+                }
+        } else
                 ll_rw_block(SWRITE, 1, &bh);
 
 out:
@@ -1426,9 +1451,12 @@ recovery_error:
  *
  * Release a journal_t structure once it is no longer in use by the
  * journaled object.
+ * Return <0 if we couldn't clean up the journal.
  */
-void jbd2_journal_destroy(journal_t *journal)
+int jbd2_journal_destroy(journal_t *journal)
 {
+        int err = 0;
+
         /* Wait for the commit thread to wake up and die. */
         journal_kill_thread(journal);
 
@@ -1451,11 +1479,16 @@ void jbd2_journal_destroy(journal_t *journal)
         J_ASSERT(journal->j_checkpoint_transactions == NULL);
         spin_unlock(&journal->j_list_lock);
 
-        /* We can now mark the journal as empty. */
-        journal->j_tail = 0;
-        journal->j_tail_sequence = ++journal->j_transaction_sequence;
         if (journal->j_sb_buffer) {
-                jbd2_journal_update_superblock(journal, 1);
+                if (!is_journal_aborted(journal)) {
+                        /* We can now mark the journal as empty. */
+                        journal->j_tail = 0;
+                        journal->j_tail_sequence =
+                                ++journal->j_transaction_sequence;
+                        jbd2_journal_update_superblock(journal, 1);
+                } else {
+                        err = -EIO;
+                }
                 brelse(journal->j_sb_buffer);
         }
 
@@ -1467,6 +1500,8 @@ void jbd2_journal_destroy(journal_t *journal)
                 jbd2_journal_destroy_revoke(journal);
         kfree(journal->j_wbuf);
         kfree(journal);
+
+        return err;
 }
 
 
@@ -1692,10 +1727,16 @@ int jbd2_journal_flush(journal_t *journal)
         spin_lock(&journal->j_list_lock);
         while (!err && journal->j_checkpoint_transactions != NULL) {
                 spin_unlock(&journal->j_list_lock);
+                mutex_lock(&journal->j_checkpoint_mutex);
                 err = jbd2_log_do_checkpoint(journal);
+                mutex_unlock(&journal->j_checkpoint_mutex);
                 spin_lock(&journal->j_list_lock);
         }
         spin_unlock(&journal->j_list_lock);
+
+        if (is_journal_aborted(journal))
+                return -EIO;
+
         jbd2_cleanup_journal_tail(journal);
 
         /* Finally, mark the journal as really needing no recovery.
@@ -1717,7 +1758,7 @@ int jbd2_journal_flush(journal_t *journal)
         J_ASSERT(journal->j_head == journal->j_tail);
         J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);
         spin_unlock(&journal->j_state_lock);
-        return err;
+        return 0;
 }
 
 /**
@@ -1761,23 +1802,6 @@ int jbd2_journal_wipe(journal_t *journal, int write)
 }
 
 /*
- * journal_dev_name: format a character string to describe on what
- * device this journal is present.
- */
-
-static const char *journal_dev_name(journal_t *journal, char *buffer)
-{
-        struct block_device *bdev;
-
-        if (journal->j_inode)
-                bdev = journal->j_inode->i_sb->s_bdev;
-        else
-                bdev = journal->j_dev;
-
-        return bdevname(bdev, buffer);
-}
-
-/*
  * Journal abort has very specific semantics, which we describe
  * for journal abort.
  *
@@ -1793,13 +1817,12 @@ static const char *journal_dev_name(journal_t *journal, char *buffer)
 void __jbd2_journal_abort_hard(journal_t *journal)
 {
         transaction_t *transaction;
-        char b[BDEVNAME_SIZE];
 
         if (journal->j_flags & JBD2_ABORT)
                 return;
 
         printk(KERN_ERR "Aborting journal on device %s.\n",
-                journal_dev_name(journal, b));
+               journal->j_devname);
 
         spin_lock(&journal->j_state_lock);
         journal->j_flags |= JBD2_ABORT;