ext4: pass -ESHUTDOWN code to jbd2 layer

commit fb7c02445c497943e7296cd3deee04422b63acb8 upstream.

Previously the jbd2 layer assumed that a file system check would be
required after a journal abort.  In the case of the deliberate file
system shutdown, this should not be necessary.  Allow the jbd2 layer
to distinguish between these two cases by using the ESHUTDOWN errno.

Also add proper locking to __journal_abort_soft().

Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 7f889b1e4db0f62b7a590ea7de62a23d1f5cc9e7..1eb68e62693132a264005b6db50513497a2abe82 100644 (file)
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -493,13 +493,13 @@ static int ext4_shutdown(struct super_block *sb, unsigned long arg)
                set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
                if (sbi->s_journal && !is_journal_aborted(sbi->s_journal)) {
                        (void) ext4_force_commit(sb);
-                       jbd2_journal_abort(sbi->s_journal, 0);
+                       jbd2_journal_abort(sbi->s_journal, -ESHUTDOWN);
                }
                break;
        case EXT4_GOING_FLAGS_NOLOGFLUSH:
                set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
                if (sbi->s_journal && !is_journal_aborted(sbi->s_journal))
-                       jbd2_journal_abort(sbi->s_journal, 0);
+                       jbd2_journal_abort(sbi->s_journal, -ESHUTDOWN);
                break;
        default:
                return -EINVAL;

diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index aeaa993d4849f94afaee3955ec03267691a7342d..61d48f0c41a1251397cc09c82d6f93d9c9157bdc 100644 (file)
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -1473,12 +1473,15 @@ static void jbd2_mark_journal_empty(journal_t *journal, int write_op)
 void jbd2_journal_update_sb_errno(journal_t *journal)
 {
        journal_superblock_t *sb = journal->j_superblock;
+       int errcode;
 
        read_lock(&journal->j_state_lock);
-       jbd_debug(1, "JBD2: updating superblock error (errno %d)\n",
-                 journal->j_errno);
-       sb->s_errno    = cpu_to_be32(journal->j_errno);
+       errcode = journal->j_errno;
        read_unlock(&journal->j_state_lock);
+       if (errcode == -ESHUTDOWN)
+               errcode = 0;
+       jbd_debug(1, "JBD2: updating superblock error (errno %d)\n", errcode);
+       sb->s_errno    = cpu_to_be32(errcode);
 
        jbd2_write_superblock(journal, REQ_SYNC | REQ_FUA);
 }
@@ -2095,12 +2098,22 @@ void __jbd2_journal_abort_hard(journal_t *journal)
  * but don't do any other IO. */
 static void __journal_abort_soft (journal_t *journal, int errno)
 {
-       if (journal->j_flags & JBD2_ABORT)
-               return;
+       int old_errno;
 
-       if (!journal->j_errno)
+       write_lock(&journal->j_state_lock);
+       old_errno = journal->j_errno;
+       if (!journal->j_errno || errno == -ESHUTDOWN)
                journal->j_errno = errno;
 
+       if (journal->j_flags & JBD2_ABORT) {
+               write_unlock(&journal->j_state_lock);
+               if (!old_errno && old_errno != -ESHUTDOWN &&
+                   errno == -ESHUTDOWN)
+                       jbd2_journal_update_sb_errno(journal);
+               return;
+       }
+       write_unlock(&journal->j_state_lock);
+
        __jbd2_journal_abort_hard(journal);
 
        if (errno) {