Merge commit 'v2.6.32-rc5' into for-linus

1 files changed, 35 insertions, 36 deletions

diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index 7b4088b2364d..d4cfd6d2779e 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -25,6 +25,7 @@
 #include <linux/writeback.h>
 #include <linux/backing-dev.h>
 #include <linux/bio.h>
+#include <linux/blkdev.h>
 #include <trace/events/jbd2.h>
 
 /*
@@ -133,8 +134,8 @@ static int journal_submit_commit_record(journal_t *journal,
         bh->b_end_io = journal_end_buffer_io_sync;
 
         if (journal->j_flags & JBD2_BARRIER &&
-                !JBD2_HAS_INCOMPAT_FEATURE(journal,
-                                         JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
+            !JBD2_HAS_INCOMPAT_FEATURE(journal,
+                                       JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
                 set_buffer_ordered(bh);
                 barrier_done = 1;
         }
@@ -220,7 +221,6 @@ static int journal_submit_inode_data_buffers(struct address_space *mapping)
                 .nr_to_write = mapping->nrpages * 2,
                 .range_start = 0,
                 .range_end = i_size_read(mapping->host),
-                .for_writepages = 1,
         };
 
         ret = generic_writepages(mapping, &wbc);
@@ -410,10 +410,10 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         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,
-                                                stats.u.run.rs_locked);
+        stats.run.rs_wait = commit_transaction->t_max_wait;
+        stats.run.rs_locked = jiffies;
+        stats.run.rs_running = jbd2_time_diff(commit_transaction->t_start,
+                                              stats.run.rs_locked);
 
         spin_lock(&commit_transaction->t_handle_lock);
         while (commit_transaction->t_updates) {
@@ -486,9 +486,9 @@ 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);
+        stats.run.rs_flushing = jiffies;
+        stats.run.rs_locked = jbd2_time_diff(stats.run.rs_locked,
+                                             stats.run.rs_flushing);
 
         commit_transaction->t_state = T_FLUSH;
         journal->j_committing_transaction = commit_transaction;
@@ -523,11 +523,11 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         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);
-        stats.u.run.rs_blocks = commit_transaction->t_outstanding_credits;
-        stats.u.run.rs_blocks_logged = 0;
+        stats.run.rs_logging = jiffies;
+        stats.run.rs_flushing = jbd2_time_diff(stats.run.rs_flushing,
+                                               stats.run.rs_logging);
+        stats.run.rs_blocks = commit_transaction->t_outstanding_credits;
+        stats.run.rs_blocks_logged = 0;
 
         J_ASSERT(commit_transaction->t_nr_buffers <=
                  commit_transaction->t_outstanding_credits);
@@ -695,7 +695,7 @@ start_journal_io:
                                 submit_bh(write_op, bh);
                         }
                         cond_resched();
-                        stats.u.run.rs_blocks_logged += bufs;
+                        stats.run.rs_blocks_logged += bufs;
 
                         /* Force a new descriptor to be generated next
                            time round the loop. */
@@ -707,11 +707,13 @@ start_journal_io:
         /* Done it all: now write the commit record asynchronously. */
 
         if (JBD2_HAS_INCOMPAT_FEATURE(journal,
-                JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
+                                      JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
                 err = journal_submit_commit_record(journal, commit_transaction,
                                                  &cbh, crc32_sum);
                 if (err)
                         __jbd2_journal_abort_hard(journal);
+                if (journal->j_flags & JBD2_BARRIER)
+                        blkdev_issue_flush(journal->j_dev, NULL);
         }
 
         /*
@@ -834,7 +836,7 @@ wait_for_iobuf:
         jbd_debug(3, "JBD: commit phase 5\n");
 
         if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
-                JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
+                                       JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
                 err = journal_submit_commit_record(journal, commit_transaction,
                                                 &cbh, crc32_sum);
                 if (err)
@@ -986,33 +988,30 @@ restart_loop:
         J_ASSERT(commit_transaction->t_state == T_COMMIT);
 
         commit_transaction->t_start = jiffies;
-        stats.u.run.rs_logging = jbd2_time_diff(stats.u.run.rs_logging,
-                                                commit_transaction->t_start);
+        stats.run.rs_logging = jbd2_time_diff(stats.run.rs_logging,
+                                              commit_transaction->t_start);
 
         /*
-         * File the transaction for history
+         * File the transaction statistics
          */
-        stats.ts_type = JBD2_STATS_RUN;
         stats.ts_tid = commit_transaction->t_tid;
-        stats.u.run.rs_handle_count = commit_transaction->t_handle_count;
-        spin_lock(&journal->j_history_lock);
-        memcpy(journal->j_history + journal->j_history_cur, &stats,
-                        sizeof(stats));
-        if (++journal->j_history_cur == journal->j_history_max)
-                journal->j_history_cur = 0;
+        stats.run.rs_handle_count = commit_transaction->t_handle_count;
+        trace_jbd2_run_stats(journal->j_fs_dev->bd_dev,
+                             commit_transaction->t_tid, &stats.run);
 
         /*
          * Calculate overall stats
          */
+        spin_lock(&journal->j_history_lock);
         journal->j_stats.ts_tid++;
-        journal->j_stats.u.run.rs_wait += stats.u.run.rs_wait;
-        journal->j_stats.u.run.rs_running += stats.u.run.rs_running;
-        journal->j_stats.u.run.rs_locked += stats.u.run.rs_locked;
-        journal->j_stats.u.run.rs_flushing += stats.u.run.rs_flushing;
-        journal->j_stats.u.run.rs_logging += stats.u.run.rs_logging;
-        journal->j_stats.u.run.rs_handle_count += stats.u.run.rs_handle_count;
-        journal->j_stats.u.run.rs_blocks += stats.u.run.rs_blocks;
-        journal->j_stats.u.run.rs_blocks_logged += stats.u.run.rs_blocks_logged;
+        journal->j_stats.run.rs_wait += stats.run.rs_wait;
+        journal->j_stats.run.rs_running += stats.run.rs_running;
+        journal->j_stats.run.rs_locked += stats.run.rs_locked;
+        journal->j_stats.run.rs_flushing += stats.run.rs_flushing;
+        journal->j_stats.run.rs_logging += stats.run.rs_logging;
+        journal->j_stats.run.rs_handle_count += stats.run.rs_handle_count;
+        journal->j_stats.run.rs_blocks += stats.run.rs_blocks;
+        journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged;
         spin_unlock(&journal->j_history_lock);
 
         commit_transaction->t_state = T_FINISHED;