Merge commit 'v2.6.32' into reiserfs/kill-bkl

Merge-reason: The tree was based 2.6.31. It's better to be up to date
with 2.6.32. Although no conflicting changes were made in between,
it gives benchmarking results closer to the lastest kernel behaviour.

4 files changed, 69 insertions, 224 deletions

diff --git a/fs/jbd2/checkpoint.c b/fs/jbd2/checkpoint.c
index 5d70b3e6d49b..ca0f5eb62b20 100644
--- a/fs/jbd2/checkpoint.c
+++ b/fs/jbd2/checkpoint.c
@@ -643,6 +643,7 @@ out:
 
 int __jbd2_journal_remove_checkpoint(struct journal_head *jh)
 {
+        struct transaction_chp_stats_s *stats;
         transaction_t *transaction;
         journal_t *journal;
         int ret = 0;
@@ -679,6 +680,12 @@ int __jbd2_journal_remove_checkpoint(struct journal_head *jh)
 
         /* OK, that was the last buffer for the transaction: we can now
            safely remove this transaction from the log */
+        stats = &transaction->t_chp_stats;
+        if (stats->cs_chp_time)
+                stats->cs_chp_time = jbd2_time_diff(stats->cs_chp_time,
+                                                    jiffies);
+        trace_jbd2_checkpoint_stats(journal->j_fs_dev->bd_dev,
+                                    transaction->t_tid, stats);
 
         __jbd2_journal_drop_transaction(journal, transaction);
         kfree(transaction);
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;
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index e378cb383979..fed85388ee86 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -136,10 +136,6 @@ static int kjournald2(void *arg)
         journal->j_task = current;
         wake_up(&journal->j_wait_done_commit);
 
-        printk(KERN_INFO "kjournald2 starting: pid %d, dev %s, "
-               "commit interval %ld seconds\n", current->pid,
-               journal->j_devname, journal->j_commit_interval / HZ);
-
         /*
          * And now, wait forever for commit wakeup events.
          */
@@ -223,7 +219,8 @@ static int jbd2_journal_start_thread(journal_t *journal)
 {
         struct task_struct *t;
 
-        t = kthread_run(kjournald2, journal, "kjournald2");
+        t = kthread_run(kjournald2, journal, "jbd2/%s",
+                        journal->j_devname);
         if (IS_ERR(t))
                 return PTR_ERR(t);
 
@@ -679,153 +676,6 @@ struct jbd2_stats_proc_session {
         int max;
 };
 
-static void *jbd2_history_skip_empty(struct jbd2_stats_proc_session *s,
-                                        struct transaction_stats_s *ts,
-                                        int first)
-{
-        if (ts == s->stats + s->max)
-                ts = s->stats;
-        if (!first && ts == s->stats + s->start)
-                return NULL;
-        while (ts->ts_type == 0) {
-                ts++;
-                if (ts == s->stats + s->max)
-                        ts = s->stats;
-                if (ts == s->stats + s->start)
-                        return NULL;
-        }
-        return ts;
-
-}
-
-static void *jbd2_seq_history_start(struct seq_file *seq, loff_t *pos)
-{
-        struct jbd2_stats_proc_session *s = seq->private;
-        struct transaction_stats_s *ts;
-        int l = *pos;
-
-        if (l == 0)
-                return SEQ_START_TOKEN;
-        ts = jbd2_history_skip_empty(s, s->stats + s->start, 1);
-        if (!ts)
-                return NULL;
-        l--;
-        while (l) {
-                ts = jbd2_history_skip_empty(s, ++ts, 0);
-                if (!ts)
-                        break;
-                l--;
-        }
-        return ts;
-}
-
-static void *jbd2_seq_history_next(struct seq_file *seq, void *v, loff_t *pos)
-{
-        struct jbd2_stats_proc_session *s = seq->private;
-        struct transaction_stats_s *ts = v;
-
-        ++*pos;
-        if (v == SEQ_START_TOKEN)
-                return jbd2_history_skip_empty(s, s->stats + s->start, 1);
-        else
-                return jbd2_history_skip_empty(s, ++ts, 0);
-}
-
-static int jbd2_seq_history_show(struct seq_file *seq, void *v)
-{
-        struct transaction_stats_s *ts = v;
-        if (v == SEQ_START_TOKEN) {
-                seq_printf(seq, "%-4s %-5s %-5s %-5s %-5s %-5s %-5s %-6s %-5s "
-                                "%-5s %-5s %-5s %-5s %-5s\n", "R/C", "tid",
-                                "wait", "run", "lock", "flush", "log", "hndls",
-                                "block", "inlog", "ctime", "write", "drop",
-                                "close");
-                return 0;
-        }
-        if (ts->ts_type == JBD2_STATS_RUN)
-                seq_printf(seq, "%-4s %-5lu %-5u %-5u %-5u %-5u %-5u "
-                                "%-6lu %-5lu %-5lu\n", "R", ts->ts_tid,
-                                jiffies_to_msecs(ts->u.run.rs_wait),
-                                jiffies_to_msecs(ts->u.run.rs_running),
-                                jiffies_to_msecs(ts->u.run.rs_locked),
-                                jiffies_to_msecs(ts->u.run.rs_flushing),
-                                jiffies_to_msecs(ts->u.run.rs_logging),
-                                ts->u.run.rs_handle_count,
-                                ts->u.run.rs_blocks,
-                                ts->u.run.rs_blocks_logged);
-        else if (ts->ts_type == JBD2_STATS_CHECKPOINT)
-                seq_printf(seq, "%-4s %-5lu %48s %-5u %-5lu %-5lu %-5lu\n",
-                                "C", ts->ts_tid, " ",
-                                jiffies_to_msecs(ts->u.chp.cs_chp_time),
-                                ts->u.chp.cs_written, ts->u.chp.cs_dropped,
-                                ts->u.chp.cs_forced_to_close);
-        else
-                J_ASSERT(0);
-        return 0;
-}
-
-static void jbd2_seq_history_stop(struct seq_file *seq, void *v)
-{
-}
-
-static struct seq_operations jbd2_seq_history_ops = {
-        .start  = jbd2_seq_history_start,
-        .next   = jbd2_seq_history_next,
-        .stop   = jbd2_seq_history_stop,
-        .show   = jbd2_seq_history_show,
-};
-
-static int jbd2_seq_history_open(struct inode *inode, struct file *file)
-{
-        journal_t *journal = PDE(inode)->data;
-        struct jbd2_stats_proc_session *s;
-        int rc, size;
-
-        s = kmalloc(sizeof(*s), GFP_KERNEL);
-        if (s == NULL)
-                return -ENOMEM;
-        size = sizeof(struct transaction_stats_s) * journal->j_history_max;
-        s->stats = kmalloc(size, GFP_KERNEL);
-        if (s->stats == NULL) {
-                kfree(s);
-                return -ENOMEM;
-        }
-        spin_lock(&journal->j_history_lock);
-        memcpy(s->stats, journal->j_history, size);
-        s->max = journal->j_history_max;
-        s->start = journal->j_history_cur % s->max;
-        spin_unlock(&journal->j_history_lock);
-
-        rc = seq_open(file, &jbd2_seq_history_ops);
-        if (rc == 0) {
-                struct seq_file *m = file->private_data;
-                m->private = s;
-        } else {
-                kfree(s->stats);
-                kfree(s);
-        }
-        return rc;
-
-}
-
-static int jbd2_seq_history_release(struct inode *inode, struct file *file)
-{
-        struct seq_file *seq = file->private_data;
-        struct jbd2_stats_proc_session *s = seq->private;
-
-        kfree(s->stats);
-        kfree(s);
-        return seq_release(inode, file);
-}
-
-static struct file_operations jbd2_seq_history_fops = {
-        .owner          = THIS_MODULE,
-        .open           = jbd2_seq_history_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = jbd2_seq_history_release,
-};
-
 static void *jbd2_seq_info_start(struct seq_file *seq, loff_t *pos)
 {
         return *pos ? NULL : SEQ_START_TOKEN;
@@ -842,29 +692,29 @@ static int jbd2_seq_info_show(struct seq_file *seq, void *v)
 
         if (v != SEQ_START_TOKEN)
                 return 0;
-        seq_printf(seq, "%lu transaction, each upto %u blocks\n",
+        seq_printf(seq, "%lu transaction, each up to %u blocks\n",
                         s->stats->ts_tid,
                         s->journal->j_max_transaction_buffers);
         if (s->stats->ts_tid == 0)
                 return 0;
         seq_printf(seq, "average: \n  %ums waiting for transaction\n",
-            jiffies_to_msecs(s->stats->u.run.rs_wait / s->stats->ts_tid));
+            jiffies_to_msecs(s->stats->run.rs_wait / s->stats->ts_tid));
         seq_printf(seq, "  %ums running transaction\n",
-            jiffies_to_msecs(s->stats->u.run.rs_running / s->stats->ts_tid));
+            jiffies_to_msecs(s->stats->run.rs_running / s->stats->ts_tid));
         seq_printf(seq, "  %ums transaction was being locked\n",
-            jiffies_to_msecs(s->stats->u.run.rs_locked / s->stats->ts_tid));
+            jiffies_to_msecs(s->stats->run.rs_locked / s->stats->ts_tid));
         seq_printf(seq, "  %ums flushing data (in ordered mode)\n",
-            jiffies_to_msecs(s->stats->u.run.rs_flushing / s->stats->ts_tid));
+            jiffies_to_msecs(s->stats->run.rs_flushing / s->stats->ts_tid));
         seq_printf(seq, "  %ums logging transaction\n",
-            jiffies_to_msecs(s->stats->u.run.rs_logging / s->stats->ts_tid));
+            jiffies_to_msecs(s->stats->run.rs_logging / s->stats->ts_tid));
         seq_printf(seq, "  %lluus average transaction commit time\n",
                    div_u64(s->journal->j_average_commit_time, 1000));
         seq_printf(seq, "  %lu handles per transaction\n",
-            s->stats->u.run.rs_handle_count / s->stats->ts_tid);
+            s->stats->run.rs_handle_count / s->stats->ts_tid);
         seq_printf(seq, "  %lu blocks per transaction\n",
-            s->stats->u.run.rs_blocks / s->stats->ts_tid);
+            s->stats->run.rs_blocks / s->stats->ts_tid);
         seq_printf(seq, "  %lu logged blocks per transaction\n",
-            s->stats->u.run.rs_blocks_logged / s->stats->ts_tid);
+            s->stats->run.rs_blocks_logged / s->stats->ts_tid);
         return 0;
 }
 
@@ -872,7 +722,7 @@ static void jbd2_seq_info_stop(struct seq_file *seq, void *v)
 {
 }
 
-static struct seq_operations jbd2_seq_info_ops = {
+static const struct seq_operations jbd2_seq_info_ops = {
         .start  = jbd2_seq_info_start,
         .next   = jbd2_seq_info_next,
         .stop   = jbd2_seq_info_stop,
@@ -920,7 +770,7 @@ static int jbd2_seq_info_release(struct inode *inode, struct file *file)
         return seq_release(inode, file);
 }
 
-static struct file_operations jbd2_seq_info_fops = {
+static const struct file_operations jbd2_seq_info_fops = {
         .owner          = THIS_MODULE,
         .open           = jbd2_seq_info_open,
         .read           = seq_read,
@@ -934,8 +784,6 @@ static void jbd2_stats_proc_init(journal_t *journal)
 {
         journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);
         if (journal->j_proc_entry) {
-                proc_create_data("history", S_IRUGO, journal->j_proc_entry,
-                                 &jbd2_seq_history_fops, journal);
                 proc_create_data("info", S_IRUGO, journal->j_proc_entry,
                                  &jbd2_seq_info_fops, journal);
         }
@@ -944,27 +792,9 @@ static void jbd2_stats_proc_init(journal_t *journal)
 static void jbd2_stats_proc_exit(journal_t *journal)
 {
         remove_proc_entry("info", journal->j_proc_entry);
-        remove_proc_entry("history", journal->j_proc_entry);
         remove_proc_entry(journal->j_devname, proc_jbd2_stats);
 }
 
-static void journal_init_stats(journal_t *journal)
-{
-        int size;
-
-        if (!proc_jbd2_stats)
-                return;
-
-        journal->j_history_max = 100;
-        size = sizeof(struct transaction_stats_s) * journal->j_history_max;
-        journal->j_history = kzalloc(size, GFP_KERNEL);
-        if (!journal->j_history) {
-                journal->j_history_max = 0;
-                return;
-        }
-        spin_lock_init(&journal->j_history_lock);
-}
-
 /*
  * Management for journal control blocks: functions to create and
  * destroy journal_t structures, and to initialise and read existing
@@ -1009,7 +839,7 @@ static journal_t * journal_init_common (void)
                 goto fail;
         }
 
-        journal_init_stats(journal);
+        spin_lock_init(&journal->j_history_lock);
 
         return journal;
 fail:
@@ -1083,6 +913,7 @@ journal_t * jbd2_journal_init_dev(struct block_device *bdev,
 
         return journal;
 out_err:
+        kfree(journal->j_wbuf);
         jbd2_stats_proc_exit(journal);
         kfree(journal);
         return NULL;
@@ -1115,7 +946,7 @@ journal_t * jbd2_journal_init_inode (struct inode *inode)
         while ((p = strchr(p, '/')))
                 *p = '!';
         p = journal->j_devname + strlen(journal->j_devname);
-        sprintf(p, ":%lu", journal->j_inode->i_ino);
+        sprintf(p, "-%lu", journal->j_inode->i_ino);
         jbd_debug(1,
                   "journal %p: inode %s/%ld, size %Ld, bits %d, blksize %ld\n",
                   journal, inode->i_sb->s_id, inode->i_ino,
@@ -1156,6 +987,7 @@ journal_t * jbd2_journal_init_inode (struct inode *inode)
 
         return journal;
 out_err:
+        kfree(journal->j_wbuf);
         jbd2_stats_proc_exit(journal);
         kfree(journal);
         return NULL;
@@ -1187,6 +1019,12 @@ static int journal_reset(journal_t *journal)
 
         first = be32_to_cpu(sb->s_first);
         last = be32_to_cpu(sb->s_maxlen);
+        if (first + JBD2_MIN_JOURNAL_BLOCKS > last + 1) {
+                printk(KERN_ERR "JBD: Journal too short (blocks %llu-%llu).\n",
+                       first, last);
+                journal_fail_superblock(journal);
+                return -EINVAL;
+        }
 
         journal->j_first = first;
         journal->j_last = last;
diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
index 6213ac728f30..a0512700542f 100644
--- a/fs/jbd2/transaction.c
+++ b/fs/jbd2/transaction.c
@@ -57,7 +57,7 @@ jbd2_get_transaction(journal_t *journal, transaction_t *transaction)
         INIT_LIST_HEAD(&transaction->t_private_list);
 
         /* Set up the commit timer for the new transaction. */
-        journal->j_commit_timer.expires = round_jiffies(transaction->t_expires);
+        journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires);
         add_timer(&journal->j_commit_timer);
 
         J_ASSERT(journal->j_running_transaction == NULL);
@@ -238,6 +238,8 @@ repeat_locked:
                   __jbd2_log_space_left(journal));
         spin_unlock(&transaction->t_handle_lock);
         spin_unlock(&journal->j_state_lock);
+
+        lock_map_acquire(&handle->h_lockdep_map);
 out:
         if (unlikely(new_transaction))          /* It's usually NULL */
                 kfree(new_transaction);
@@ -303,8 +305,6 @@ handle_t *jbd2_journal_start(journal_t *journal, int nblocks)
                 handle = ERR_PTR(err);
                 goto out;
         }
-
-        lock_map_acquire(&handle->h_lockdep_map);
 out:
         return handle;
 }
@@ -426,6 +426,7 @@ int jbd2_journal_restart(handle_t *handle, int nblocks)
         __jbd2_log_start_commit(journal, transaction->t_tid);
         spin_unlock(&journal->j_state_lock);
 
+        lock_map_release(&handle->h_lockdep_map);
         handle->h_buffer_credits = nblocks;
         ret = start_this_handle(journal, handle);
         return ret;