jbd2: don't create journal_head for temporary journal buffers

When writing metadata to the journal, we create temporary buffer heads
for that task.  We also attach journal heads to these buffer heads but
the only purpose of the journal heads is to keep buffers linked in
transaction's BJ_IO list.  We remove the need for journal heads by
reusing buffer_head's b_assoc_buffers list for that purpose.  Also
since BJ_IO list is just a temporary list for transaction commit, we
use a private list in jbd2_journal_commit_transaction() for that thus
removing BJ_IO list from transaction completely.

Reviewed-by: Zheng Liu <wenqing.lz@taobao.com>
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

4 files changed, 40 insertions, 76 deletions

diff --git a/fs/jbd2/checkpoint.c b/fs/jbd2/checkpoint.c
index c78841ee81cf..2735fef6e55e 100644
--- a/fs/jbd2/checkpoint.c
+++ b/fs/jbd2/checkpoint.c
@@ -690,7 +690,6 @@ void __jbd2_journal_drop_transaction(journal_t *journal, transaction_t *transact
         J_ASSERT(transaction->t_state == T_FINISHED);
         J_ASSERT(transaction->t_buffers == NULL);
         J_ASSERT(transaction->t_forget == NULL);
-        J_ASSERT(transaction->t_iobuf_list == NULL);
         J_ASSERT(transaction->t_shadow_list == NULL);
         J_ASSERT(transaction->t_log_list == NULL);
         J_ASSERT(transaction->t_checkpoint_list == NULL);
diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index e61d7224a729..57bd2ff97888 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -369,7 +369,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
 {
         struct transaction_stats_s stats;
         transaction_t *commit_transaction;
-        struct journal_head *jh, *new_jh, *descriptor;
+        struct journal_head *jh, *descriptor;
         struct buffer_head **wbuf = journal->j_wbuf;
         int bufs;
         int flags;
@@ -393,6 +393,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         tid_t first_tid;
         int update_tail;
         int csum_size = 0;
+        LIST_HEAD(io_bufs);
 
         if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2))
                 csum_size = sizeof(struct jbd2_journal_block_tail);
@@ -659,29 +660,22 @@ void jbd2_journal_commit_transaction(journal_t *journal)
 
                 /* Bump b_count to prevent truncate from stumbling over
                    the shadowed buffer!  @@@ This can go if we ever get
-                   rid of the BJ_IO/BJ_Shadow pairing of buffers. */
+                   rid of the shadow pairing of buffers. */
                 atomic_inc(&jh2bh(jh)->b_count);
 
-                /* Make a temporary IO buffer with which to write it out
-                   (this will requeue both the metadata buffer and the
-                   temporary IO buffer). new_bh goes on BJ_IO*/
-
-                set_bit(BH_JWrite, &jh2bh(jh)->b_state);
                 /*
-                 * akpm: jbd2_journal_write_metadata_buffer() sets
-                 * new_bh->b_transaction to commit_transaction.
-                 * We need to clean this up before we release new_bh
-                 * (which is of type BJ_IO)
+                 * Make a temporary IO buffer with which to write it out
+                 * (this will requeue the metadata buffer to BJ_Shadow).
                  */
+                set_bit(BH_JWrite, &jh2bh(jh)->b_state);
                 JBUFFER_TRACE(jh, "ph3: write metadata");
                 flags = jbd2_journal_write_metadata_buffer(commit_transaction,
-                                                      jh, &new_jh, blocknr);
+                                                jh, &wbuf[bufs], blocknr);
                 if (flags < 0) {
                         jbd2_journal_abort(journal, flags);
                         continue;
                 }
-                set_bit(BH_JWrite, &jh2bh(new_jh)->b_state);
-                wbuf[bufs++] = jh2bh(new_jh);
+                jbd2_file_log_bh(&io_bufs, wbuf[bufs]);
 
                 /* Record the new block's tag in the current descriptor
                    buffer */
@@ -695,10 +689,11 @@ void jbd2_journal_commit_transaction(journal_t *journal)
                 tag = (journal_block_tag_t *) tagp;
                 write_tag_block(tag_bytes, tag, jh2bh(jh)->b_blocknr);
                 tag->t_flags = cpu_to_be16(tag_flag);
-                jbd2_block_tag_csum_set(journal, tag, jh2bh(new_jh),
+                jbd2_block_tag_csum_set(journal, tag, wbuf[bufs],
                                         commit_transaction->t_tid);
                 tagp += tag_bytes;
                 space_left -= tag_bytes;
+                bufs++;
 
                 if (first_tag) {
                         memcpy (tagp, journal->j_uuid, 16);
@@ -810,7 +805,7 @@ start_journal_io:
            the log.  Before we can commit it, wait for the IO so far to
            complete.  Control buffers being written are on the
            transaction's t_log_list queue, and metadata buffers are on
-           the t_iobuf_list queue.
+           the io_bufs list.
 
            Wait for the buffers in reverse order.  That way we are
            less likely to be woken up until all IOs have completed, and
@@ -819,46 +814,31 @@ start_journal_io:
 
         jbd_debug(3, "JBD2: commit phase 3\n");
 
-        /*
-         * akpm: these are BJ_IO, and j_list_lock is not needed.
-         * See __journal_try_to_free_buffer.
-         */
-wait_for_iobuf:
-        while (commit_transaction->t_iobuf_list != NULL) {
-                struct buffer_head *bh;
+        while (!list_empty(&io_bufs)) {
+                struct buffer_head *bh = list_entry(io_bufs.prev,
+                                                    struct buffer_head,
+                                                    b_assoc_buffers);
 
-                jh = commit_transaction->t_iobuf_list->b_tprev;
-                bh = jh2bh(jh);
-                if (buffer_locked(bh)) {
-                        wait_on_buffer(bh);
-                        goto wait_for_iobuf;
-                }
-                if (cond_resched())
-                        goto wait_for_iobuf;
+                wait_on_buffer(bh);
+                cond_resched();
 
                 if (unlikely(!buffer_uptodate(bh)))
                         err = -EIO;
-
-                clear_buffer_jwrite(bh);
-
-                JBUFFER_TRACE(jh, "ph4: unfile after journal write");
-                jbd2_journal_unfile_buffer(journal, jh);
+                jbd2_unfile_log_bh(bh);
 
                 /*
-                 * ->t_iobuf_list should contain only dummy buffer_heads
-                 * which were created by jbd2_journal_write_metadata_buffer().
+                 * The list contains temporary buffer heads created by
+                 * jbd2_journal_write_metadata_buffer().
                  */
                 BUFFER_TRACE(bh, "dumping temporary bh");
-                jbd2_journal_put_journal_head(jh);
                 __brelse(bh);
                 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
                 free_buffer_head(bh);
 
-                /* We also have to unlock and free the corresponding
-                   shadowed buffer */
+                /* We also have to refile the corresponding shadowed buffer */
                 jh = commit_transaction->t_shadow_list->b_tprev;
                 bh = jh2bh(jh);
-                clear_bit(BH_JWrite, &bh->b_state);
+                clear_buffer_jwrite(bh);
                 J_ASSERT_BH(bh, buffer_jbddirty(bh));
 
                 /* The metadata is now released for reuse, but we need
@@ -953,7 +933,6 @@ wait_for_iobuf:
         J_ASSERT(list_empty(&commit_transaction->t_inode_list));
         J_ASSERT(commit_transaction->t_buffers == NULL);
         J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
-        J_ASSERT(commit_transaction->t_iobuf_list == NULL);
         J_ASSERT(commit_transaction->t_shadow_list == NULL);
         J_ASSERT(commit_transaction->t_log_list == NULL);
 
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index 3cdd285df204..45cdc080e466 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -310,14 +310,12 @@ static void journal_kill_thread(journal_t *journal)
  *
  * If the source buffer has already been modified by a new transaction
  * since we took the last commit snapshot, we use the frozen copy of
- * that data for IO.  If we end up using the existing buffer_head's data
- * for the write, then we *have* to lock the buffer to prevent anyone
- * else from using and possibly modifying it while the IO is in
- * progress.
+ * that data for IO. If we end up using the existing buffer_head's data
+ * for the write, then we have to make sure nobody modifies it while the
+ * IO is in progress. do_get_write_access() handles this.
  *
- * The function returns a pointer to the buffer_heads to be used for IO.
- *
- * We assume that the journal has already been locked in this function.
+ * The function returns a pointer to the buffer_head to be used for IO.
+ * 
  *
  * Return value:
  *  <0: Error
@@ -330,15 +328,14 @@ static void journal_kill_thread(journal_t *journal)
 
 int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
                                   struct journal_head  *jh_in,
-                                  struct journal_head **jh_out,
-                                  unsigned long long blocknr)
+                                  struct buffer_head **bh_out,
+                                  sector_t blocknr)
 {
         int need_copy_out = 0;
         int done_copy_out = 0;
         int do_escape = 0;
         char *mapped_data;
         struct buffer_head *new_bh;
-        struct journal_head *new_jh;
         struct page *new_page;
         unsigned int new_offset;
         struct buffer_head *bh_in = jh2bh(jh_in);
@@ -368,14 +365,13 @@ retry_alloc:
 
         /* keep subsequent assertions sane */
         atomic_set(&new_bh->b_count, 1);
-        new_jh = jbd2_journal_add_journal_head(new_bh); /* This sleeps */
 
+        jbd_lock_bh_state(bh_in);
+repeat:
         /*
          * If a new transaction has already done a buffer copy-out, then
          * we use that version of the data for the commit.
          */
-        jbd_lock_bh_state(bh_in);
-repeat:
         if (jh_in->b_frozen_data) {
                 done_copy_out = 1;
                 new_page = virt_to_page(jh_in->b_frozen_data);
@@ -415,7 +411,7 @@ repeat:
                 jbd_unlock_bh_state(bh_in);
                 tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS);
                 if (!tmp) {
-                        jbd2_journal_put_journal_head(new_jh);
+                        brelse(new_bh);
                         return -ENOMEM;
                 }
                 jbd_lock_bh_state(bh_in);
@@ -426,7 +422,7 @@ repeat:
 
                 jh_in->b_frozen_data = tmp;
                 mapped_data = kmap_atomic(new_page);
-                memcpy(tmp, mapped_data + new_offset, jh2bh(jh_in)->b_size);
+                memcpy(tmp, mapped_data + new_offset, bh_in->b_size);
                 kunmap_atomic(mapped_data);
 
                 new_page = virt_to_page(tmp);
@@ -452,14 +448,13 @@ repeat:
         }
 
         set_bh_page(new_bh, new_page, new_offset);
-        new_jh->b_transaction = NULL;
-        new_bh->b_size = jh2bh(jh_in)->b_size;
-        new_bh->b_bdev = transaction->t_journal->j_dev;
+        new_bh->b_size = bh_in->b_size;
+        new_bh->b_bdev = journal->j_dev;
         new_bh->b_blocknr = blocknr;
         set_buffer_mapped(new_bh);
         set_buffer_dirty(new_bh);
 
-        *jh_out = new_jh;
+        *bh_out = new_bh;
 
         /*
          * The to-be-written buffer needs to get moved to the io queue,
@@ -472,9 +467,6 @@ repeat:
         spin_unlock(&journal->j_list_lock);
         jbd_unlock_bh_state(bh_in);
 
-        JBUFFER_TRACE(new_jh, "file as BJ_IO");
-        jbd2_journal_file_buffer(new_jh, transaction, BJ_IO);
-
         return do_escape | (done_copy_out << 1);
 }
 
diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
index 5d8268ad364a..983010900258 100644
--- a/fs/jbd2/transaction.c
+++ b/fs/jbd2/transaction.c
@@ -1601,10 +1601,10 @@ __blist_del_buffer(struct journal_head **list, struct journal_head *jh)
  * Remove a buffer from the appropriate transaction list.
  *
  * Note that this function can *change* the value of
- * bh->b_transaction->t_buffers, t_forget, t_iobuf_list, t_shadow_list,
- * t_log_list or t_reserved_list.  If the caller is holding onto a copy of one
- * of these pointers, it could go bad.  Generally the caller needs to re-read
- * the pointer from the transaction_t.
+ * bh->b_transaction->t_buffers, t_forget, t_shadow_list, t_log_list or
+ * t_reserved_list.  If the caller is holding onto a copy of one of these
+ * pointers, it could go bad.  Generally the caller needs to re-read the
+ * pointer from the transaction_t.
  *
  * Called under j_list_lock.
  */
@@ -1634,9 +1634,6 @@ static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh)
         case BJ_Forget:
                 list = &transaction->t_forget;
                 break;
-        case BJ_IO:
-                list = &transaction->t_iobuf_list;
-                break;
         case BJ_Shadow:
                 list = &transaction->t_shadow_list;
                 break;
@@ -2148,9 +2145,6 @@ void __jbd2_journal_file_buffer(struct journal_head *jh,
         case BJ_Forget:
                 list = &transaction->t_forget;
                 break;
-        case BJ_IO:
-                list = &transaction->t_iobuf_list;
-                break;
         case BJ_Shadow:
                 list = &transaction->t_shadow_list;
                 break;