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

Pull ext4 updates for 3.4 from Ted Ts'o:
 "Ext4 commits for 3.3 merge window; mostly cleanups and bug fixes

  The changes to export dirty_writeback_interval are from Artem's s_dirt
  cleanup patch series.  The same is true of the change to remove the
  s_dirt helper functions which never got used by anyone in-tree.  I've
  run these changes by Al Viro, and am carrying them so that Artem can
  more easily fix up the rest of the file systems during the next merge
  window.  (Originally we had hopped to remove the use of s_dirt from
  ext4 during this merge window, but his patches had some bugs, so I
  ultimately ended dropping them from the ext4 tree.)"

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (66 commits)
  vfs: remove unused superblock helpers
  mm: export dirty_writeback_interval
  ext4: remove useless s_dirt assignment
  ext4: write superblock only once on unmount
  ext4: do not mark superblock as dirty unnecessarily
  ext4: correct ext4_punch_hole return codes
  ext4: remove restrictive checks for EOFBLOCKS_FL
  ext4: always set then trimmed blocks count into len
  ext4: fix trimmed block count accunting
  ext4: fix start and len arguments handling in ext4_trim_fs()
  ext4: update s_free_{inodes,blocks}_count during online resize
  ext4: change some printk() calls to use ext4_msg() instead
  ext4: avoid output message interleaving in ext4_error_<foo>()
  ext4: remove trailing newlines from ext4_msg() and ext4_error() messages
  ext4: add no_printk argument validation, fix fallout
  ext4: remove redundant "EXT4-fs: " from uses of ext4_msg
  ext4: give more helpful error message in ext4_ext_rm_leaf()
  ext4: remove unused code from ext4_ext_map_blocks()
  ext4: rewrite punch hole to use ext4_ext_remove_space()
  jbd2: cleanup journal tail after transaction commit
  ...

1 files changed, 229 insertions, 132 deletions

diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index 839377e3d624..98ed6dbfe381 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -71,7 +71,6 @@ EXPORT_SYMBOL(jbd2_journal_revoke);
 
 EXPORT_SYMBOL(jbd2_journal_init_dev);
 EXPORT_SYMBOL(jbd2_journal_init_inode);
-EXPORT_SYMBOL(jbd2_journal_update_format);
 EXPORT_SYMBOL(jbd2_journal_check_used_features);
 EXPORT_SYMBOL(jbd2_journal_check_available_features);
 EXPORT_SYMBOL(jbd2_journal_set_features);
@@ -96,7 +95,6 @@ EXPORT_SYMBOL(jbd2_journal_release_jbd_inode);
 EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate);
 EXPORT_SYMBOL(jbd2_inode_cache);
 
-static int journal_convert_superblock_v1(journal_t *, journal_superblock_t *);
 static void __journal_abort_soft (journal_t *journal, int errno);
 static int jbd2_journal_create_slab(size_t slab_size);
 
@@ -746,6 +744,98 @@ struct journal_head *jbd2_journal_get_descriptor_buffer(journal_t *journal)
         return jbd2_journal_add_journal_head(bh);
 }
 
+/*
+ * Return tid of the oldest transaction in the journal and block in the journal
+ * where the transaction starts.
+ *
+ * If the journal is now empty, return which will be the next transaction ID
+ * we will write and where will that transaction start.
+ *
+ * The return value is 0 if journal tail cannot be pushed any further, 1 if
+ * it can.
+ */
+int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
+                              unsigned long *block)
+{
+        transaction_t *transaction;
+        int ret;
+
+        read_lock(&journal->j_state_lock);
+        spin_lock(&journal->j_list_lock);
+        transaction = journal->j_checkpoint_transactions;
+        if (transaction) {
+                *tid = transaction->t_tid;
+                *block = transaction->t_log_start;
+        } else if ((transaction = journal->j_committing_transaction) != NULL) {
+                *tid = transaction->t_tid;
+                *block = transaction->t_log_start;
+        } else if ((transaction = journal->j_running_transaction) != NULL) {
+                *tid = transaction->t_tid;
+                *block = journal->j_head;
+        } else {
+                *tid = journal->j_transaction_sequence;
+                *block = journal->j_head;
+        }
+        ret = tid_gt(*tid, journal->j_tail_sequence);
+        spin_unlock(&journal->j_list_lock);
+        read_unlock(&journal->j_state_lock);
+
+        return ret;
+}
+
+/*
+ * Update information in journal structure and in on disk journal superblock
+ * about log tail. This function does not check whether information passed in
+ * really pushes log tail further. It's responsibility of the caller to make
+ * sure provided log tail information is valid (e.g. by holding
+ * j_checkpoint_mutex all the time between computing log tail and calling this
+ * function as is the case with jbd2_cleanup_journal_tail()).
+ *
+ * Requires j_checkpoint_mutex
+ */
+void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
+{
+        unsigned long freed;
+
+        BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
+
+        /*
+         * We cannot afford for write to remain in drive's caches since as
+         * soon as we update j_tail, next transaction can start reusing journal
+         * space and if we lose sb update during power failure we'd replay
+         * old transaction with possibly newly overwritten data.
+         */
+        jbd2_journal_update_sb_log_tail(journal, tid, block, WRITE_FUA);
+        write_lock(&journal->j_state_lock);
+        freed = block - journal->j_tail;
+        if (block < journal->j_tail)
+                freed += journal->j_last - journal->j_first;
+
+        trace_jbd2_update_log_tail(journal, tid, block, freed);
+        jbd_debug(1,
+                  "Cleaning journal tail from %d to %d (offset %lu), "
+                  "freeing %lu\n",
+                  journal->j_tail_sequence, tid, block, freed);
+
+        journal->j_free += freed;
+        journal->j_tail_sequence = tid;
+        journal->j_tail = block;
+        write_unlock(&journal->j_state_lock);
+}
+
+/*
+ * This is a variaon of __jbd2_update_log_tail which checks for validity of
+ * provided log tail and locks j_checkpoint_mutex. So it is safe against races
+ * with other threads updating log tail.
+ */
+void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
+{
+        mutex_lock(&journal->j_checkpoint_mutex);
+        if (tid_gt(tid, journal->j_tail_sequence))
+                __jbd2_update_log_tail(journal, tid, block);
+        mutex_unlock(&journal->j_checkpoint_mutex);
+}
+
 struct jbd2_stats_proc_session {
         journal_t *journal;
         struct transaction_stats_s *stats;
@@ -1114,40 +1204,45 @@ static int journal_reset(journal_t *journal)
 
         journal->j_max_transaction_buffers = journal->j_maxlen / 4;
 
-        /* Add the dynamic fields and write it to disk. */
-        jbd2_journal_update_superblock(journal, 1);
-        return jbd2_journal_start_thread(journal);
-}
-
-/**
- * void jbd2_journal_update_superblock() - Update journal sb on disk.
- * @journal: The journal to update.
- * @wait: Set to '0' if you don't want to wait for IO completion.
- *
- * Update a journal's dynamic superblock fields and write it to disk,
- * optionally waiting for the IO to complete.
- */
-void jbd2_journal_update_superblock(journal_t *journal, int wait)
-{
-        journal_superblock_t *sb = journal->j_superblock;
-        struct buffer_head *bh = journal->j_sb_buffer;
-
         /*
          * As a special case, if the on-disk copy is already marked as needing
-         * no recovery (s_start == 0) and there are no outstanding transactions
-         * in the filesystem, then we can safely defer the superblock update
-         * until the next commit by setting JBD2_FLUSHED.  This avoids
+         * no recovery (s_start == 0), then we can safely defer the superblock
+         * update until the next commit by setting JBD2_FLUSHED.  This avoids
          * attempting a write to a potential-readonly device.
          */
-        if (sb->s_start == 0 && journal->j_tail_sequence ==
-                                journal->j_transaction_sequence) {
+        if (sb->s_start == 0) {
                 jbd_debug(1, "JBD2: Skipping superblock update on recovered sb "
                         "(start %ld, seq %d, errno %d)\n",
                         journal->j_tail, journal->j_tail_sequence,
                         journal->j_errno);
-                goto out;
+                journal->j_flags |= JBD2_FLUSHED;
+        } else {
+                /* Lock here to make assertions happy... */
+                mutex_lock(&journal->j_checkpoint_mutex);
+                /*
+                 * Update log tail information. We use WRITE_FUA since new
+                 * transaction will start reusing journal space and so we
+                 * must make sure information about current log tail is on
+                 * disk before that.
+                 */
+                jbd2_journal_update_sb_log_tail(journal,
+                                                journal->j_tail_sequence,
+                                                journal->j_tail,
+                                                WRITE_FUA);
+                mutex_unlock(&journal->j_checkpoint_mutex);
         }
+        return jbd2_journal_start_thread(journal);
+}
 
+static void jbd2_write_superblock(journal_t *journal, int write_op)
+{
+        struct buffer_head *bh = journal->j_sb_buffer;
+        int ret;
+
+        trace_jbd2_write_superblock(journal, write_op);
+        if (!(journal->j_flags & JBD2_BARRIER))
+                write_op &= ~(REQ_FUA | REQ_FLUSH);
+        lock_buffer(bh);
         if (buffer_write_io_error(bh)) {
                 /*
                  * Oh, dear.  A previous attempt to write the journal
@@ -1163,48 +1258,106 @@ void jbd2_journal_update_superblock(journal_t *journal, int wait)
                 clear_buffer_write_io_error(bh);
                 set_buffer_uptodate(bh);
         }
+        get_bh(bh);
+        bh->b_end_io = end_buffer_write_sync;
+        ret = submit_bh(write_op, bh);
+        wait_on_buffer(bh);
+        if (buffer_write_io_error(bh)) {
+                clear_buffer_write_io_error(bh);
+                set_buffer_uptodate(bh);
+                ret = -EIO;
+        }
+        if (ret) {
+                printk(KERN_ERR "JBD2: Error %d detected when updating "
+                       "journal superblock for %s.\n", ret,
+                       journal->j_devname);
+        }
+}
+
+/**
+ * jbd2_journal_update_sb_log_tail() - Update log tail in journal sb on disk.
+ * @journal: The journal to update.
+ * @tail_tid: TID of the new transaction at the tail of the log
+ * @tail_block: The first block of the transaction at the tail of the log
+ * @write_op: With which operation should we write the journal sb
+ *
+ * Update a journal's superblock information about log tail and write it to
+ * disk, waiting for the IO to complete.
+ */
+void jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,
+                                     unsigned long tail_block, int write_op)
+{
+        journal_superblock_t *sb = journal->j_superblock;
+
+        BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
+        jbd_debug(1, "JBD2: updating superblock (start %lu, seq %u)\n",
+                  tail_block, tail_tid);
+
+        sb->s_sequence = cpu_to_be32(tail_tid);
+        sb->s_start    = cpu_to_be32(tail_block);
+
+        jbd2_write_superblock(journal, write_op);
+
+        /* Log is no longer empty */
+        write_lock(&journal->j_state_lock);
+        WARN_ON(!sb->s_sequence);
+        journal->j_flags &= ~JBD2_FLUSHED;
+        write_unlock(&journal->j_state_lock);
+}
+
+/**
+ * jbd2_mark_journal_empty() - Mark on disk journal as empty.
+ * @journal: The journal to update.
+ *
+ * Update a journal's dynamic superblock fields to show that journal is empty.
+ * Write updated superblock to disk waiting for IO to complete.
+ */
+static void jbd2_mark_journal_empty(journal_t *journal)
+{
+        journal_superblock_t *sb = journal->j_superblock;
 
+        BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
         read_lock(&journal->j_state_lock);
-        jbd_debug(1, "JBD2: updating superblock (start %ld, seq %d, errno %d)\n",
-                  journal->j_tail, journal->j_tail_sequence, journal->j_errno);
+        jbd_debug(1, "JBD2: Marking journal as empty (seq %d)\n",
+                  journal->j_tail_sequence);
 
         sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
-        sb->s_start    = cpu_to_be32(journal->j_tail);
-        sb->s_errno    = cpu_to_be32(journal->j_errno);
+        sb->s_start    = cpu_to_be32(0);
         read_unlock(&journal->j_state_lock);
 
-        BUFFER_TRACE(bh, "marking dirty");
-        mark_buffer_dirty(bh);
-        if (wait) {
-                sync_dirty_buffer(bh);
-                if (buffer_write_io_error(bh)) {
-                        printk(KERN_ERR "JBD2: I/O error detected "
-                               "when updating journal superblock for %s.\n",
-                               journal->j_devname);
-                        clear_buffer_write_io_error(bh);
-                        set_buffer_uptodate(bh);
-                }
-        } else
-                write_dirty_buffer(bh, WRITE);
-
-out:
-        /* If we have just flushed the log (by marking s_start==0), then
-         * any future commit will have to be careful to update the
-         * superblock again to re-record the true start of the log. */
+        jbd2_write_superblock(journal, WRITE_FUA);
 
+        /* Log is no longer empty */
         write_lock(&journal->j_state_lock);
-        if (sb->s_start)
-                journal->j_flags &= ~JBD2_FLUSHED;
-        else
-                journal->j_flags |= JBD2_FLUSHED;
+        journal->j_flags |= JBD2_FLUSHED;
         write_unlock(&journal->j_state_lock);
 }
 
+
+/**
+ * jbd2_journal_update_sb_errno() - Update error in the journal.
+ * @journal: The journal to update.
+ *
+ * Update a journal's errno.  Write updated superblock to disk waiting for IO
+ * to complete.
+ */
+static void jbd2_journal_update_sb_errno(journal_t *journal)
+{
+        journal_superblock_t *sb = journal->j_superblock;
+
+        read_lock(&journal->j_state_lock);
+        jbd_debug(1, "JBD2: updating superblock error (errno %d)\n",
+                  journal->j_errno);
+        sb->s_errno    = cpu_to_be32(journal->j_errno);
+        read_unlock(&journal->j_state_lock);
+
+        jbd2_write_superblock(journal, WRITE_SYNC);
+}
+
 /*
  * Read the superblock for a given journal, performing initial
  * validation of the format.
  */
-
 static int journal_get_superblock(journal_t *journal)
 {
         struct buffer_head *bh;
@@ -1398,14 +1551,11 @@ int jbd2_journal_destroy(journal_t *journal)
 
         if (journal->j_sb_buffer) {
                 if (!is_journal_aborted(journal)) {
-                        /* We can now mark the journal as empty. */
-                        journal->j_tail = 0;
-                        journal->j_tail_sequence =
-                                ++journal->j_transaction_sequence;
-                        jbd2_journal_update_superblock(journal, 1);
-                } else {
+                        mutex_lock(&journal->j_checkpoint_mutex);
+                        jbd2_mark_journal_empty(journal);
+                        mutex_unlock(&journal->j_checkpoint_mutex);
+                } else
                         err = -EIO;
-                }
                 brelse(journal->j_sb_buffer);
         }
 
@@ -1552,61 +1702,6 @@ void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,
 EXPORT_SYMBOL(jbd2_journal_clear_features);
 
 /**
- * int jbd2_journal_update_format () - Update on-disk journal structure.
- * @journal: Journal to act on.
- *
- * Given an initialised but unloaded journal struct, poke about in the
- * on-disk structure to update it to the most recent supported version.
- */
-int jbd2_journal_update_format (journal_t *journal)
-{
-        journal_superblock_t *sb;
-        int err;
-
-        err = journal_get_superblock(journal);
-        if (err)
-                return err;
-
-        sb = journal->j_superblock;
-
-        switch (be32_to_cpu(sb->s_header.h_blocktype)) {
-        case JBD2_SUPERBLOCK_V2:
-                return 0;
-        case JBD2_SUPERBLOCK_V1:
-                return journal_convert_superblock_v1(journal, sb);
-        default:
-                break;
-        }
-        return -EINVAL;
-}
-
-static int journal_convert_superblock_v1(journal_t *journal,
-                                         journal_superblock_t *sb)
-{
-        int offset, blocksize;
-        struct buffer_head *bh;
-
-        printk(KERN_WARNING
-                "JBD2: Converting superblock from version 1 to 2.\n");
-
-        /* Pre-initialise new fields to zero */
-        offset = ((char *) &(sb->s_feature_compat)) - ((char *) sb);
-        blocksize = be32_to_cpu(sb->s_blocksize);
-        memset(&sb->s_feature_compat, 0, blocksize-offset);
-
-        sb->s_nr_users = cpu_to_be32(1);
-        sb->s_header.h_blocktype = cpu_to_be32(JBD2_SUPERBLOCK_V2);
-        journal->j_format_version = 2;
-
-        bh = journal->j_sb_buffer;
-        BUFFER_TRACE(bh, "marking dirty");
-        mark_buffer_dirty(bh);
-        sync_dirty_buffer(bh);
-        return 0;
-}
-
-
-/**
  * int jbd2_journal_flush () - Flush journal
  * @journal: Journal to act on.
  *
@@ -1619,7 +1714,6 @@ int jbd2_journal_flush(journal_t *journal)
 {
         int err = 0;
         transaction_t *transaction = NULL;
-        unsigned long old_tail;
 
         write_lock(&journal->j_state_lock);
 
@@ -1654,6 +1748,7 @@ int jbd2_journal_flush(journal_t *journal)
         if (is_journal_aborted(journal))
                 return -EIO;
 
+        mutex_lock(&journal->j_checkpoint_mutex);
         jbd2_cleanup_journal_tail(journal);
 
         /* Finally, mark the journal as really needing no recovery.
@@ -1661,14 +1756,9 @@ int jbd2_journal_flush(journal_t *journal)
          * the magic code for a fully-recovered superblock.  Any future
          * commits of data to the journal will restore the current
          * s_start value. */
+        jbd2_mark_journal_empty(journal);
+        mutex_unlock(&journal->j_checkpoint_mutex);
         write_lock(&journal->j_state_lock);
-        old_tail = journal->j_tail;
-        journal->j_tail = 0;
-        write_unlock(&journal->j_state_lock);
-        jbd2_journal_update_superblock(journal, 1);
-        write_lock(&journal->j_state_lock);
-        journal->j_tail = old_tail;
-
         J_ASSERT(!journal->j_running_transaction);
         J_ASSERT(!journal->j_committing_transaction);
         J_ASSERT(!journal->j_checkpoint_transactions);
@@ -1708,8 +1798,12 @@ int jbd2_journal_wipe(journal_t *journal, int write)
                 write ? "Clearing" : "Ignoring");
 
         err = jbd2_journal_skip_recovery(journal);
-        if (write)
-                jbd2_journal_update_superblock(journal, 1);
+        if (write) {
+                /* Lock to make assertions happy... */
+                mutex_lock(&journal->j_checkpoint_mutex);
+                jbd2_mark_journal_empty(journal);
+                mutex_unlock(&journal->j_checkpoint_mutex);
+        }
 
  no_recovery:
         return err;
@@ -1759,7 +1853,7 @@ static void __journal_abort_soft (journal_t *journal, int errno)
         __jbd2_journal_abort_hard(journal);
 
         if (errno)
-                jbd2_journal_update_superblock(journal, 1);
+                jbd2_journal_update_sb_errno(journal);
 }
 
 /**
@@ -2017,7 +2111,7 @@ static struct kmem_cache *jbd2_journal_head_cache;
 static atomic_t nr_journal_heads = ATOMIC_INIT(0);
 #endif
 
-static int journal_init_jbd2_journal_head_cache(void)
+static int jbd2_journal_init_journal_head_cache(void)
 {
         int retval;
 
@@ -2035,7 +2129,7 @@ static int journal_init_jbd2_journal_head_cache(void)
         return retval;
 }
 
-static void jbd2_journal_destroy_jbd2_journal_head_cache(void)
+static void jbd2_journal_destroy_journal_head_cache(void)
 {
         if (jbd2_journal_head_cache) {
                 kmem_cache_destroy(jbd2_journal_head_cache);
@@ -2323,7 +2417,7 @@ static void __exit jbd2_remove_jbd_stats_proc_entry(void)
 
 struct kmem_cache *jbd2_handle_cache, *jbd2_inode_cache;
 
-static int __init journal_init_handle_cache(void)
+static int __init jbd2_journal_init_handle_cache(void)
 {
         jbd2_handle_cache = KMEM_CACHE(jbd2_journal_handle, SLAB_TEMPORARY);
         if (jbd2_handle_cache == NULL) {
@@ -2358,17 +2452,20 @@ static int __init journal_init_caches(void)
 
         ret = jbd2_journal_init_revoke_caches();
         if (ret == 0)
-                ret = journal_init_jbd2_journal_head_cache();
+                ret = jbd2_journal_init_journal_head_cache();
+        if (ret == 0)
+                ret = jbd2_journal_init_handle_cache();
         if (ret == 0)
-                ret = journal_init_handle_cache();
+                ret = jbd2_journal_init_transaction_cache();
         return ret;
 }
 
 static void jbd2_journal_destroy_caches(void)
 {
         jbd2_journal_destroy_revoke_caches();
-        jbd2_journal_destroy_jbd2_journal_head_cache();
+        jbd2_journal_destroy_journal_head_cache();
         jbd2_journal_destroy_handle_cache();
+        jbd2_journal_destroy_transaction_cache();
         jbd2_journal_destroy_slabs();
 }