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

Pull ext4 updates from Ted Ts'o:
 "Mostly performance and bug fixes, plus some cleanups.  The one new
  feature this merge window is a new ioctl EXT4_IOC_SWAP_BOOT which
  allows installation of a hidden inode designed for boot loaders."

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (50 commits)
  ext4: fix type-widening bug in inode table readahead code
  ext4: add check for inodes_count overflow in new resize ioctl
  ext4: fix Kconfig documentation for CONFIG_EXT4_DEBUG
  ext4: fix online resizing for ext3-compat file systems
  jbd2: trace when lock_buffer in do_get_write_access takes a long time
  ext4: mark metadata blocks using bh flags
  buffer: add BH_Prio and BH_Meta flags
  ext4: mark all metadata I/O with REQ_META
  ext4: fix readdir error in case inline_data+^dir_index.
  ext4: fix readdir error in the case of inline_data+dir_index
  jbd2: use kmem_cache_zalloc instead of kmem_cache_alloc/memset
  ext4: mext_insert_extents should update extent block checksum
  ext4: move quota initialization out of inode allocation transaction
  ext4: reserve xattr index for Rich ACL support
  jbd2: reduce journal_head size
  ext4: clear buffer_uninit flag when submitting IO
  ext4: use io_end for multiple bios
  ext4: make ext4_bio_write_page() use BH_Async_Write flags
  ext4: Use kstrtoul() instead of parse_strtoul()
  ext4: defragmentation code cleanup
  ...

3 files changed, 67 insertions, 23 deletions

diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index 750c70148eff..0f53946f13c1 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -382,7 +382,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         int space_left = 0;
         int first_tag = 0;
         int tag_flag;
-        int i, to_free = 0;
+        int i;
         int tag_bytes = journal_tag_bytes(journal);
         struct buffer_head *cbh = NULL; /* For transactional checksums */
         __u32 crc32_sum = ~0;
@@ -1134,7 +1134,7 @@ restart_loop:
         journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged;
         spin_unlock(&journal->j_history_lock);
 
-        commit_transaction->t_state = T_FINISHED;
+        commit_transaction->t_state = T_COMMIT_CALLBACK;
         J_ASSERT(commit_transaction == journal->j_committing_transaction);
         journal->j_commit_sequence = commit_transaction->t_tid;
         journal->j_committing_transaction = NULL;
@@ -1149,38 +1149,44 @@ restart_loop:
                                 journal->j_average_commit_time*3) / 4;
         else
                 journal->j_average_commit_time = commit_time;
+
         write_unlock(&journal->j_state_lock);
 
-        if (commit_transaction->t_checkpoint_list == NULL &&
-            commit_transaction->t_checkpoint_io_list == NULL) {
-                __jbd2_journal_drop_transaction(journal, commit_transaction);
-                to_free = 1;
+        if (journal->j_checkpoint_transactions == NULL) {
+                journal->j_checkpoint_transactions = commit_transaction;
+                commit_transaction->t_cpnext = commit_transaction;
+                commit_transaction->t_cpprev = commit_transaction;
         } else {
-                if (journal->j_checkpoint_transactions == NULL) {
-                        journal->j_checkpoint_transactions = commit_transaction;
-                        commit_transaction->t_cpnext = commit_transaction;
-                        commit_transaction->t_cpprev = commit_transaction;
-                } else {
-                        commit_transaction->t_cpnext =
-                                journal->j_checkpoint_transactions;
-                        commit_transaction->t_cpprev =
-                                commit_transaction->t_cpnext->t_cpprev;
-                        commit_transaction->t_cpnext->t_cpprev =
-                                commit_transaction;
-                        commit_transaction->t_cpprev->t_cpnext =
+                commit_transaction->t_cpnext =
+                        journal->j_checkpoint_transactions;
+                commit_transaction->t_cpprev =
+                        commit_transaction->t_cpnext->t_cpprev;
+                commit_transaction->t_cpnext->t_cpprev =
+                        commit_transaction;
+                commit_transaction->t_cpprev->t_cpnext =
                                 commit_transaction;
-                }
         }
         spin_unlock(&journal->j_list_lock);
-
+        /* Drop all spin_locks because commit_callback may be block.
+         * __journal_remove_checkpoint() can not destroy transaction
+         * under us because it is not marked as T_FINISHED yet */
         if (journal->j_commit_callback)
                 journal->j_commit_callback(journal, commit_transaction);
 
         trace_jbd2_end_commit(journal, commit_transaction);
         jbd_debug(1, "JBD2: commit %d complete, head %d\n",
                   journal->j_commit_sequence, journal->j_tail_sequence);
-        if (to_free)
-                jbd2_journal_free_transaction(commit_transaction);
 
+        write_lock(&journal->j_state_lock);
+        spin_lock(&journal->j_list_lock);
+        commit_transaction->t_state = T_FINISHED;
+        /* Recheck checkpoint lists after j_list_lock was dropped */
+        if (commit_transaction->t_checkpoint_list == NULL &&
+            commit_transaction->t_checkpoint_io_list == NULL) {
+                __jbd2_journal_drop_transaction(journal, commit_transaction);
+                jbd2_journal_free_transaction(commit_transaction);
+        }
+        spin_unlock(&journal->j_list_lock);
+        write_unlock(&journal->j_state_lock);
         wake_up(&journal->j_wait_done_commit);
 }
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index 8b220f1ab54f..f6c5ba027f4f 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -708,6 +708,37 @@ int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
 }
 
 /*
+ * When this function returns the transaction corresponding to tid
+ * will be completed.  If the transaction has currently running, start
+ * committing that transaction before waiting for it to complete.  If
+ * the transaction id is stale, it is by definition already completed,
+ * so just return SUCCESS.
+ */
+int jbd2_complete_transaction(journal_t *journal, tid_t tid)
+{
+        int     need_to_wait = 1;
+
+        read_lock(&journal->j_state_lock);
+        if (journal->j_running_transaction &&
+            journal->j_running_transaction->t_tid == tid) {
+                if (journal->j_commit_request != tid) {
+                        /* transaction not yet started, so request it */
+                        read_unlock(&journal->j_state_lock);
+                        jbd2_log_start_commit(journal, tid);
+                        goto wait_commit;
+                }
+        } else if (!(journal->j_committing_transaction &&
+                     journal->j_committing_transaction->t_tid == tid))
+                need_to_wait = 0;
+        read_unlock(&journal->j_state_lock);
+        if (!need_to_wait)
+                return 0;
+wait_commit:
+        return jbd2_log_wait_commit(journal, tid);
+}
+EXPORT_SYMBOL(jbd2_complete_transaction);
+
+/*
  * Log buffer allocation routines:
  */
 
diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
index 325bc019ed88..10f524c59ea8 100644
--- a/fs/jbd2/transaction.c
+++ b/fs/jbd2/transaction.c
@@ -332,7 +332,6 @@ static handle_t *new_handle(int nblocks)
         handle_t *handle = jbd2_alloc_handle(GFP_NOFS);
         if (!handle)
                 return NULL;
-        memset(handle, 0, sizeof(*handle));
         handle->h_buffer_credits = nblocks;
         handle->h_ref = 1;
 
@@ -640,6 +639,7 @@ do_get_write_access(handle_t *handle, struct journal_head *jh,
         int error;
         char *frozen_buffer = NULL;
         int need_copy = 0;
+        unsigned long start_lock, time_lock;
 
         if (is_handle_aborted(handle))
                 return -EROFS;
@@ -655,9 +655,16 @@ repeat:
 
         /* @@@ Need to check for errors here at some point. */
 
+        start_lock = jiffies;
         lock_buffer(bh);
         jbd_lock_bh_state(bh);
 
+        /* If it takes too long to lock the buffer, trace it */
+        time_lock = jbd2_time_diff(start_lock, jiffies);
+        if (time_lock > HZ/10)
+                trace_jbd2_lock_buffer_stall(bh->b_bdev->bd_dev,
+                        jiffies_to_msecs(time_lock));
+
         /* We now hold the buffer lock so it is safe to query the buffer
          * state.  Is the buffer dirty?
          *