Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4

Pull ext4 updates from Ted Ts'o:
 "All cleanups and bug fixes; most notably, fix some problems discovered
  in ext4's NFS support, and fix an ioctl (EXT4_IOC_GROUP_ADD) used by
  old versions of e2fsprogs which we accidentally broke a while back.

  Also fixed some error paths in ext4's quota and inline data support.

  Finally, improve tail latency in jbd2's commit code"

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4:
  ext4: check for shutdown and r/o file system in ext4_write_inode()
  ext4: force inode writes when nfsd calls commit_metadata()
  ext4: avoid declaring fs inconsistent due to invalid file handles
  ext4: include terminating u32 in size of xattr entries when expanding inodes
  ext4: compare old and new mode before setting update_mode flag
  ext4: fix EXT4_IOC_GROUP_ADD ioctl
  ext4: hard fail dax mount on unsupported devices
  jbd2: update locking documentation for transaction_t
  ext4: remove redundant condition check
  jbd2: clean up indentation issue, replace spaces with tab
  ext4: clean up indentation issues, remove extraneous tabs
  ext4: missing unlock/put_page() in ext4_try_to_write_inline_data()
  ext4: fix possible use after free in ext4_quota_enable
  jbd2: avoid long hold times of j_state_lock while committing a transaction
  ext4: add ext4_sb_bread() to disambiguate ENOMEM cases

2 files changed, 42 insertions, 6 deletions

diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index 150cc030b4d7..2eb55c3361a8 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -439,6 +439,8 @@ void jbd2_journal_commit_transaction(journal_t *journal)
                 finish_wait(&journal->j_wait_updates, &wait);
         }
         spin_unlock(&commit_transaction->t_handle_lock);
+        commit_transaction->t_state = T_SWITCH;
+        write_unlock(&journal->j_state_lock);
 
         J_ASSERT (atomic_read(&commit_transaction->t_outstanding_credits) <=
                         journal->j_max_transaction_buffers);
@@ -505,6 +507,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         atomic_sub(atomic_read(&journal->j_reserved_credits),
                    &commit_transaction->t_outstanding_credits);
 
+        write_lock(&journal->j_state_lock);
         trace_jbd2_commit_flushing(journal, commit_transaction);
         stats.run.rs_flushing = jiffies;
         stats.run.rs_locked = jbd2_time_diff(stats.run.rs_locked,
diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
index c0b66a7a795b..cc35537232f2 100644
--- a/fs/jbd2/transaction.c
+++ b/fs/jbd2/transaction.c
@@ -138,9 +138,9 @@ static inline void update_t_max_wait(transaction_t *transaction,
 }
 
 /*
- * Wait until running transaction passes T_LOCKED state. Also starts the commit
- * if needed. The function expects running transaction to exist and releases
- * j_state_lock.
+ * Wait until running transaction passes to T_FLUSH state and new transaction
+ * can thus be started. Also starts the commit if needed. The function expects
+ * running transaction to exist and releases j_state_lock.
  */
 static void wait_transaction_locked(journal_t *journal)
         __releases(journal->j_state_lock)
@@ -160,6 +160,32 @@ static void wait_transaction_locked(journal_t *journal)
         finish_wait(&journal->j_wait_transaction_locked, &wait);
 }
 
+/*
+ * Wait until running transaction transitions from T_SWITCH to T_FLUSH
+ * state and new transaction can thus be started. The function releases
+ * j_state_lock.
+ */
+static void wait_transaction_switching(journal_t *journal)
+        __releases(journal->j_state_lock)
+{
+        DEFINE_WAIT(wait);
+
+        if (WARN_ON(!journal->j_running_transaction ||
+                    journal->j_running_transaction->t_state != T_SWITCH))
+                return;
+        prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
+                        TASK_UNINTERRUPTIBLE);
+        read_unlock(&journal->j_state_lock);
+        /*
+         * We don't call jbd2_might_wait_for_commit() here as there's no
+         * waiting for outstanding handles happening anymore in T_SWITCH state
+         * and handling of reserved handles actually relies on that for
+         * correctness.
+         */
+        schedule();
+        finish_wait(&journal->j_wait_transaction_locked, &wait);
+}
+
 static void sub_reserved_credits(journal_t *journal, int blocks)
 {
         atomic_sub(blocks, &journal->j_reserved_credits);
@@ -183,7 +209,8 @@ static int add_transaction_credits(journal_t *journal, int blocks,
          * If the current transaction is locked down for commit, wait
          * for the lock to be released.
          */
-        if (t->t_state == T_LOCKED) {
+        if (t->t_state != T_RUNNING) {
+                WARN_ON_ONCE(t->t_state >= T_FLUSH);
                 wait_transaction_locked(journal);
                 return 1;
         }
@@ -360,8 +387,14 @@ repeat:
                 /*
                  * We have handle reserved so we are allowed to join T_LOCKED
                  * transaction and we don't have to check for transaction size
-                 * and journal space.
+                 * and journal space. But we still have to wait while running
+                 * transaction is being switched to a committing one as it
+                 * won't wait for any handles anymore.
                  */
+                if (transaction->t_state == T_SWITCH) {
+                        wait_transaction_switching(journal);
+                        goto repeat;
+                }
                 sub_reserved_credits(journal, blocks);
                 handle->h_reserved = 0;
         }
@@ -910,7 +943,7 @@ repeat:
          * this is the first time this transaction is touching this buffer,
          * reset the modified flag
          */
-       jh->b_modified = 0;
+        jh->b_modified = 0;
 
         /*
          * If the buffer is not journaled right now, we need to make sure it