jbd2: remove journal_head from descriptor buffers

Similarly as for metadata buffers, also log descriptor buffers don't
really need the journal head. So strip it and remove BJ_LogCtl list.

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>

1 files changed, 24 insertions, 25 deletions

diff --git a/fs/jbd2/revoke.c b/fs/jbd2/revoke.c
index f30b80b4ce8b..198c9c10276d 100644
--- a/fs/jbd2/revoke.c
+++ b/fs/jbd2/revoke.c
@@ -122,9 +122,10 @@ struct jbd2_revoke_table_s
 
 #ifdef __KERNEL__
 static void write_one_revoke_record(journal_t *, transaction_t *,
-                                    struct journal_head **, int *,
+                                    struct list_head *,
+                                    struct buffer_head **, int *,
                                     struct jbd2_revoke_record_s *, int);
-static void flush_descriptor(journal_t *, struct journal_head *, int, int);
+static void flush_descriptor(journal_t *, struct buffer_head *, int, int);
 #endif
 
 /* Utility functions to maintain the revoke table */
@@ -531,9 +532,10 @@ void jbd2_journal_switch_revoke_table(journal_t *journal)
  */
 void jbd2_journal_write_revoke_records(journal_t *journal,
                                        transaction_t *transaction,
+                                       struct list_head *log_bufs,
                                        int write_op)
 {
-        struct journal_head *descriptor;
+        struct buffer_head *descriptor;
         struct jbd2_revoke_record_s *record;
         struct jbd2_revoke_table_s *revoke;
         struct list_head *hash_list;
@@ -553,7 +555,7 @@ void jbd2_journal_write_revoke_records(journal_t *journal,
                 while (!list_empty(hash_list)) {
                         record = (struct jbd2_revoke_record_s *)
                                 hash_list->next;
-                        write_one_revoke_record(journal, transaction,
+                        write_one_revoke_record(journal, transaction, log_bufs,
                                                 &descriptor, &offset,
                                                 record, write_op);
                         count++;
@@ -573,13 +575,14 @@ void jbd2_journal_write_revoke_records(journal_t *journal,
 
 static void write_one_revoke_record(journal_t *journal,
                                     transaction_t *transaction,
-                                    struct journal_head **descriptorp,
+                                    struct list_head *log_bufs,
+                                    struct buffer_head **descriptorp,
                                     int *offsetp,
                                     struct jbd2_revoke_record_s *record,
                                     int write_op)
 {
         int csum_size = 0;
-        struct journal_head *descriptor;
+        struct buffer_head *descriptor;
         int offset;
         journal_header_t *header;
 
@@ -609,26 +612,26 @@ static void write_one_revoke_record(journal_t *journal,
                 descriptor = jbd2_journal_get_descriptor_buffer(journal);
                 if (!descriptor)
                         return;
-                header = (journal_header_t *) &jh2bh(descriptor)->b_data[0];
+                header = (journal_header_t *)descriptor->b_data;
                 header->h_magic     = cpu_to_be32(JBD2_MAGIC_NUMBER);
                 header->h_blocktype = cpu_to_be32(JBD2_REVOKE_BLOCK);
                 header->h_sequence  = cpu_to_be32(transaction->t_tid);
 
                 /* Record it so that we can wait for IO completion later */
-                JBUFFER_TRACE(descriptor, "file as BJ_LogCtl");
-                jbd2_journal_file_buffer(descriptor, transaction, BJ_LogCtl);
+                BUFFER_TRACE(descriptor, "file in log_bufs");
+                jbd2_file_log_bh(log_bufs, descriptor);
 
                 offset = sizeof(jbd2_journal_revoke_header_t);
                 *descriptorp = descriptor;
         }
 
         if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT)) {
-                * ((__be64 *)(&jh2bh(descriptor)->b_data[offset])) =
+                * ((__be64 *)(&descriptor->b_data[offset])) =
                         cpu_to_be64(record->blocknr);
                 offset += 8;
 
         } else {
-                * ((__be32 *)(&jh2bh(descriptor)->b_data[offset])) =
+                * ((__be32 *)(&descriptor->b_data[offset])) =
                         cpu_to_be32(record->blocknr);
                 offset += 4;
         }
@@ -636,8 +639,7 @@ static void write_one_revoke_record(journal_t *journal,
         *offsetp = offset;
 }
 
-static void jbd2_revoke_csum_set(journal_t *j,
-                                 struct journal_head *descriptor)
+static void jbd2_revoke_csum_set(journal_t *j, struct buffer_head *bh)
 {
         struct jbd2_journal_revoke_tail *tail;
         __u32 csum;
@@ -645,12 +647,10 @@ static void jbd2_revoke_csum_set(journal_t *j,
         if (!JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2))
                 return;
 
-        tail = (struct jbd2_journal_revoke_tail *)
-                        (jh2bh(descriptor)->b_data + j->j_blocksize -
+        tail = (struct jbd2_journal_revoke_tail *)(bh->b_data + j->j_blocksize -
                         sizeof(struct jbd2_journal_revoke_tail));
         tail->r_checksum = 0;
-        csum = jbd2_chksum(j, j->j_csum_seed, jh2bh(descriptor)->b_data,
-                           j->j_blocksize);
+        csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
         tail->r_checksum = cpu_to_be32(csum);
 }
 
@@ -662,25 +662,24 @@ static void jbd2_revoke_csum_set(journal_t *j,
  */
 
 static void flush_descriptor(journal_t *journal,
-                             struct journal_head *descriptor,
+                             struct buffer_head *descriptor,
                              int offset, int write_op)
 {
         jbd2_journal_revoke_header_t *header;
-        struct buffer_head *bh = jh2bh(descriptor);
 
         if (is_journal_aborted(journal)) {
-                put_bh(bh);
+                put_bh(descriptor);
                 return;
         }
 
-        header = (jbd2_journal_revoke_header_t *) jh2bh(descriptor)->b_data;
+        header = (jbd2_journal_revoke_header_t *)descriptor->b_data;
         header->r_count = cpu_to_be32(offset);
         jbd2_revoke_csum_set(journal, descriptor);
 
-        set_buffer_jwrite(bh);
-        BUFFER_TRACE(bh, "write");
-        set_buffer_dirty(bh);
-        write_dirty_buffer(bh, write_op);
+        set_buffer_jwrite(descriptor);
+        BUFFER_TRACE(descriptor, "write");
+        set_buffer_dirty(descriptor);
+        write_dirty_buffer(descriptor, write_op);
 }
 #endif