GFS2: Copy gfs2_trans_add_bh into new data/meta functions

This patch copies the body of gfs2_trans_add_bh into the two newly
added gfs2_trans_add_data and gfs2_trans_add_meta functions. We can
then move the .lo_add functions from lops.c into trans.c and call
them directly.

As a result of this, we no longer need to use the .lo_add functions
at all, so that is removed from the log operations structure.

Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>

diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index c373a24fedd9f50a66f5d0ace7a2a542d5d581dc..5d129ab89733f2bc29e8c639cff455fe372b6717 100644 (file)
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -52,7 +52,6 @@ struct gfs2_log_header_host {
  */
 
 struct gfs2_log_operations {
-       void (*lo_add) (struct gfs2_sbd *sdp, struct gfs2_bufdata *bd);
        void (*lo_before_commit) (struct gfs2_sbd *sdp);
        void (*lo_after_commit) (struct gfs2_sbd *sdp, struct gfs2_ail *ai);
        void (*lo_before_scan) (struct gfs2_jdesc *jd,

diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
index 9c8074223461eaec0463c97a8ba962f08aff3fe5..a5055977a214a1c99bff6e7f099a9fb4825e4f5f 100644 (file)
--- a/fs/gfs2/lops.c
+++ b/fs/gfs2/lops.c
@@ -37,7 +37,7 @@
  *
  * The log lock must be held when calling this function
  */
-static void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh)
+void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh)
 {
        struct gfs2_bufdata *bd;
 
@@ -388,32 +388,6 @@ static struct page *gfs2_get_log_desc(struct gfs2_sbd *sdp, u32 ld_type,
        return page;
 }
 
-static void buf_lo_add(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
-{
-       struct gfs2_meta_header *mh;
-       struct gfs2_trans *tr;
-
-       tr = current->journal_info;
-       tr->tr_touched = 1;
-       if (!list_empty(&bd->bd_list))
-               return;
-       set_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags);
-       set_bit(GLF_DIRTY, &bd->bd_gl->gl_flags);
-       mh = (struct gfs2_meta_header *)bd->bd_bh->b_data;
-       if (unlikely(mh->mh_magic != cpu_to_be32(GFS2_MAGIC))) {
-               printk(KERN_ERR
-                      "Attempting to add uninitialised block to journal (inplace block=%lld)\n",
-                      (unsigned long long)bd->bd_bh->b_blocknr);
-               BUG();
-       }
-       gfs2_pin(sdp, bd->bd_bh);
-       mh->__pad0 = cpu_to_be64(0);
-       mh->mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid);
-       sdp->sd_log_num_buf++;
-       list_add(&bd->bd_list, &sdp->sd_log_le_buf);
-       tr->tr_num_buf_new++;
-}
-
 static void gfs2_check_magic(struct buffer_head *bh)
 {
        void *kaddr;
@@ -734,44 +708,6 @@ static void revoke_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)
        gfs2_revoke_clean(sdp);
 }
 
-/**
- * databuf_lo_add - Add a databuf to the transaction.
- *
- * This is used in two distinct cases:
- * i) In ordered write mode
- *    We put the data buffer on a list so that we can ensure that its
- *    synced to disk at the right time
- * ii) In journaled data mode
- *    We need to journal the data block in the same way as metadata in
- *    the functions above. The difference is that here we have a tag
- *    which is two __be64's being the block number (as per meta data)
- *    and a flag which says whether the data block needs escaping or
- *    not. This means we need a new log entry for each 251 or so data
- *    blocks, which isn't an enormous overhead but twice as much as
- *    for normal metadata blocks.
- */
-static void databuf_lo_add(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
-{
-       struct gfs2_trans *tr = current->journal_info;
-       struct address_space *mapping = bd->bd_bh->b_page->mapping;
-       struct gfs2_inode *ip = GFS2_I(mapping->host);
-
-       if (tr)
-               tr->tr_touched = 1;
-       if (!list_empty(&bd->bd_list))
-               return;
-       set_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags);
-       set_bit(GLF_DIRTY, &bd->bd_gl->gl_flags);
-       if (gfs2_is_jdata(ip)) {
-               gfs2_pin(sdp, bd->bd_bh);
-               tr->tr_num_databuf_new++;
-               sdp->sd_log_num_databuf++;
-               list_add_tail(&bd->bd_list, &sdp->sd_log_le_databuf);
-       } else {
-               list_add_tail(&bd->bd_list, &sdp->sd_log_le_ordered);
-       }
-}
-
 /**
  * databuf_lo_before_commit - Scan the data buffers, writing as we go
  *
@@ -871,7 +807,6 @@ static void databuf_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
 
 
 const struct gfs2_log_operations gfs2_buf_lops = {
-       .lo_add = buf_lo_add,
        .lo_before_commit = buf_lo_before_commit,
        .lo_after_commit = buf_lo_after_commit,
        .lo_before_scan = buf_lo_before_scan,
@@ -894,7 +829,6 @@ const struct gfs2_log_operations gfs2_rg_lops = {
 };
 
 const struct gfs2_log_operations gfs2_databuf_lops = {
-       .lo_add = databuf_lo_add,
        .lo_before_commit = databuf_lo_before_commit,
        .lo_after_commit = databuf_lo_after_commit,
        .lo_scan_elements = databuf_lo_scan_elements,

diff --git a/fs/gfs2/lops.h b/fs/gfs2/lops.h
index 954a330585f4dcb69373e3cefcafa1d29c131d84..d85b3767ee088cfef4995f0deeaa7d58d33cf1c2 100644 (file)
--- a/fs/gfs2/lops.h
+++ b/fs/gfs2/lops.h
@@ -29,6 +29,7 @@ extern const struct gfs2_log_operations gfs2_databuf_lops;
 extern const struct gfs2_log_operations *gfs2_log_ops[];
 extern void gfs2_log_write_page(struct gfs2_sbd *sdp, struct page *page);
 extern void gfs2_log_flush_bio(struct gfs2_sbd *sdp, int rw);
+extern void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh);
 
 static inline unsigned int buf_limit(struct gfs2_sbd *sdp)
 {
@@ -53,12 +54,6 @@ static inline void lops_init_le(struct gfs2_bufdata *bd,
        bd->bd_ops = lops;
 }
 
-static inline void lops_add(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
-{
-       if (bd->bd_ops->lo_add)
-               bd->bd_ops->lo_add(sdp, bd);
-}
-
 static inline void lops_before_commit(struct gfs2_sbd *sdp)
 {
        int x;

diff --git a/fs/gfs2/trans.c b/fs/gfs2/trans.c
index cb795ac754eade6ea09cf88b1ab4dbf162502ead..1fbd57eafa48b6f2cd321c98980a0bffdf542a1a 100644 (file)
--- a/fs/gfs2/trans.c
+++ b/fs/gfs2/trans.c
@@ -18,6 +18,7 @@
 #include "gfs2.h"
 #include "incore.h"
 #include "glock.h"
+#include "inode.h"
 #include "log.h"
 #include "lops.h"
 #include "meta_io.h"
@@ -143,15 +144,46 @@ void gfs2_trans_end(struct gfs2_sbd *sdp)
 }
 
 /**
- * gfs2_trans_add_bh - Add a to-be-modified buffer to the current transaction
- * @gl: the glock the buffer belongs to
- * @bh: The buffer to add
- * @meta: True in the case of adding metadata
+ * databuf_lo_add - Add a databuf to the transaction.
  *
+ * This is used in two distinct cases:
+ * i) In ordered write mode
+ *    We put the data buffer on a list so that we can ensure that its
+ *    synced to disk at the right time
+ * ii) In journaled data mode
+ *    We need to journal the data block in the same way as metadata in
+ *    the functions above. The difference is that here we have a tag
+ *    which is two __be64's being the block number (as per meta data)
+ *    and a flag which says whether the data block needs escaping or
+ *    not. This means we need a new log entry for each 251 or so data
+ *    blocks, which isn't an enormous overhead but twice as much as
+ *    for normal metadata blocks.
  */
+static void databuf_lo_add(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
+{
+       struct gfs2_trans *tr = current->journal_info;
+       struct address_space *mapping = bd->bd_bh->b_page->mapping;
+       struct gfs2_inode *ip = GFS2_I(mapping->host);
+
+       if (tr)
+               tr->tr_touched = 1;
+       if (!list_empty(&bd->bd_list))
+               return;
+       set_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags);
+       set_bit(GLF_DIRTY, &bd->bd_gl->gl_flags);
+       if (gfs2_is_jdata(ip)) {
+               gfs2_pin(sdp, bd->bd_bh);
+               tr->tr_num_databuf_new++;
+               sdp->sd_log_num_databuf++;
+               list_add_tail(&bd->bd_list, &sdp->sd_log_le_databuf);
+       } else {
+               list_add_tail(&bd->bd_list, &sdp->sd_log_le_ordered);
+       }
+}
 
-static void gfs2_trans_add_bh(struct gfs2_glock *gl, struct buffer_head *bh, int meta)
+void gfs2_trans_add_data(struct gfs2_glock *gl, struct buffer_head *bh)
 {
+
        struct gfs2_sbd *sdp = gl->gl_sbd;
        struct gfs2_bufdata *bd;
 
@@ -163,24 +195,64 @@ static void gfs2_trans_add_bh(struct gfs2_glock *gl, struct buffer_head *bh, int
        else {
                gfs2_log_unlock(sdp);
                unlock_buffer(bh);
-               gfs2_attach_bufdata(gl, bh, meta);
+               gfs2_attach_bufdata(gl, bh, 0);
                bd = bh->b_private;
                lock_buffer(bh);
                gfs2_log_lock(sdp);
        }
-       lops_add(sdp, bd);
+       databuf_lo_add(sdp, bd);
        gfs2_log_unlock(sdp);
        unlock_buffer(bh);
 }
 
-void gfs2_trans_add_data(struct gfs2_glock *gl, struct buffer_head *bh)
+static void meta_lo_add(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
 {
-       return gfs2_trans_add_bh(gl, bh, 0);
+       struct gfs2_meta_header *mh;
+       struct gfs2_trans *tr;
+
+       tr = current->journal_info;
+       tr->tr_touched = 1;
+       if (!list_empty(&bd->bd_list))
+               return;
+       set_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags);
+       set_bit(GLF_DIRTY, &bd->bd_gl->gl_flags);
+       mh = (struct gfs2_meta_header *)bd->bd_bh->b_data;
+       if (unlikely(mh->mh_magic != cpu_to_be32(GFS2_MAGIC))) {
+               printk(KERN_ERR
+                      "Attempting to add uninitialised block to journal (inplace block=%lld)\n",
+                      (unsigned long long)bd->bd_bh->b_blocknr);
+               BUG();
+       }
+       gfs2_pin(sdp, bd->bd_bh);
+       mh->__pad0 = cpu_to_be64(0);
+       mh->mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid);
+       sdp->sd_log_num_buf++;
+       list_add(&bd->bd_list, &sdp->sd_log_le_buf);
+       tr->tr_num_buf_new++;
 }
 
 void gfs2_trans_add_meta(struct gfs2_glock *gl, struct buffer_head *bh)
 {
-       return gfs2_trans_add_bh(gl, bh, 1);
+
+       struct gfs2_sbd *sdp = gl->gl_sbd;
+       struct gfs2_bufdata *bd;
+
+       lock_buffer(bh);
+       gfs2_log_lock(sdp);
+       bd = bh->b_private;
+       if (bd)
+               gfs2_assert(sdp, bd->bd_gl == gl);
+       else {
+               gfs2_log_unlock(sdp);
+               unlock_buffer(bh);
+               gfs2_attach_bufdata(gl, bh, 1);
+               bd = bh->b_private;
+               lock_buffer(bh);
+               gfs2_log_lock(sdp);
+       }
+       meta_lo_add(sdp, bd);
+       gfs2_log_unlock(sdp);
+       unlock_buffer(bh);
 }
 
 void gfs2_trans_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)