1 files changed, 21 insertions, 11 deletions

diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index 62804e57a44c..7b4088b2364d 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -16,7 +16,6 @@
 #include <linux/time.h>
 #include <linux/fs.h>
 #include <linux/jbd2.h>
-#include <linux/marker.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/mm.h>
@@ -26,6 +25,7 @@
 #include <linux/writeback.h>
 #include <linux/backing-dev.h>
 #include <linux/bio.h>
+#include <trace/events/jbd2.h>
 
 /*
  * Default IO end handler for temporary BJ_IO buffer_heads.
@@ -138,7 +138,7 @@ static int journal_submit_commit_record(journal_t *journal,
                 set_buffer_ordered(bh);
                 barrier_done = 1;
         }
-        ret = submit_bh(WRITE_SYNC, bh);
+        ret = submit_bh(WRITE_SYNC_PLUG, bh);
         if (barrier_done)
                 clear_buffer_ordered(bh);
 
@@ -159,7 +159,7 @@ static int journal_submit_commit_record(journal_t *journal,
                 lock_buffer(bh);
                 set_buffer_uptodate(bh);
                 clear_buffer_dirty(bh);
-                ret = submit_bh(WRITE_SYNC, bh);
+                ret = submit_bh(WRITE_SYNC_PLUG, bh);
         }
         *cbh = bh;
         return ret;
@@ -190,7 +190,7 @@ retry:
                 set_buffer_uptodate(bh);
                 bh->b_end_io = journal_end_buffer_io_sync;
 
-                ret = submit_bh(WRITE_SYNC, bh);
+                ret = submit_bh(WRITE_SYNC_PLUG, bh);
                 if (ret) {
                         unlock_buffer(bh);
                         return ret;
@@ -253,6 +253,7 @@ static int journal_submit_data_buffers(journal_t *journal,
                  * block allocation  with delalloc. We need to write
                  * only allocated blocks here.
                  */
+                trace_jbd2_submit_inode_data(jinode->i_vfs_inode);
                 err = journal_submit_inode_data_buffers(mapping);
                 if (!ret)
                         ret = err;
@@ -367,6 +368,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         int tag_bytes = journal_tag_bytes(journal);
         struct buffer_head *cbh = NULL; /* For transactional checksums */
         __u32 crc32_sum = ~0;
+        int write_op = WRITE;
 
         /*
          * First job: lock down the current transaction and wait for
@@ -393,14 +395,21 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         commit_transaction = journal->j_running_transaction;
         J_ASSERT(commit_transaction->t_state == T_RUNNING);
 
-        trace_mark(jbd2_start_commit, "dev %s transaction %d",
-                   journal->j_devname, commit_transaction->t_tid);
+        trace_jbd2_start_commit(journal, commit_transaction);
         jbd_debug(1, "JBD: starting commit of transaction %d\n",
                         commit_transaction->t_tid);
 
         spin_lock(&journal->j_state_lock);
         commit_transaction->t_state = T_LOCKED;
 
+        /*
+         * Use plugged writes here, since we want to submit several before
+         * we unplug the device. We don't do explicit unplugging in here,
+         * instead we rely on sync_buffer() doing the unplug for us.
+         */
+        if (commit_transaction->t_synchronous_commit)
+                write_op = WRITE_SYNC_PLUG;
+        trace_jbd2_commit_locking(journal, commit_transaction);
         stats.u.run.rs_wait = commit_transaction->t_max_wait;
         stats.u.run.rs_locked = jiffies;
         stats.u.run.rs_running = jbd2_time_diff(commit_transaction->t_start,
@@ -476,6 +485,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
          */
         jbd2_journal_switch_revoke_table(journal);
 
+        trace_jbd2_commit_flushing(journal, commit_transaction);
         stats.u.run.rs_flushing = jiffies;
         stats.u.run.rs_locked = jbd2_time_diff(stats.u.run.rs_locked,
                                                stats.u.run.rs_flushing);
@@ -498,7 +508,8 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         if (err)
                 jbd2_journal_abort(journal, err);
 
-        jbd2_journal_write_revoke_records(journal, commit_transaction);
+        jbd2_journal_write_revoke_records(journal, commit_transaction,
+                                          write_op);
 
         jbd_debug(3, "JBD: commit phase 2\n");
 
@@ -511,6 +522,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         commit_transaction->t_state = T_COMMIT;
         spin_unlock(&journal->j_state_lock);
 
+        trace_jbd2_commit_logging(journal, commit_transaction);
         stats.u.run.rs_logging = jiffies;
         stats.u.run.rs_flushing = jbd2_time_diff(stats.u.run.rs_flushing,
                                                  stats.u.run.rs_logging);
@@ -680,7 +692,7 @@ start_journal_io:
                                 clear_buffer_dirty(bh);
                                 set_buffer_uptodate(bh);
                                 bh->b_end_io = journal_end_buffer_io_sync;
-                                submit_bh(WRITE, bh);
+                                submit_bh(write_op, bh);
                         }
                         cond_resched();
                         stats.u.run.rs_blocks_logged += bufs;
@@ -1045,9 +1057,7 @@ restart_loop:
         if (journal->j_commit_callback)
                 journal->j_commit_callback(journal, commit_transaction);
 
-        trace_mark(jbd2_end_commit, "dev %s transaction %d head %d",
-                   journal->j_devname, commit_transaction->t_tid,
-                   journal->j_tail_sequence);
+        trace_jbd2_end_commit(journal, commit_transaction);
         jbd_debug(1, "JBD: commit %d complete, head %d\n",
                   journal->j_commit_sequence, journal->j_tail_sequence);
         if (to_free)