nilfs2: move nilfs_bmap_write call out of nilfs_write_inode_common

Before converting the disk inode management metadata file ifile, the call
to nilfs_bmap_write(), the i_device_code setting, and the zero-fill code
for inodes on the super root block are moved from
nilfs_write_inode_common() to its callers.

This cleanup simplifies the role and arguments of
nilfs_write_inode_common() and collects calls to nilfs_bmap_write() to the
log writing code.

Also, add and use a new helper nilfs_write_root_mdt_inode() to avoid code
duplication in the data export routine nilfs_segctor_fill_in_super_root()
to the super root block's buffer.

Link: https://lkml.kernel.org/r/20240122140202.6950-9-konishi.ryusuke@gmail.com
Signed-off-by: Ryusuke Konishi <konishi.ryusuke@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index 9c334c722fc1c1b3885d977efc61cc92463cb083..b9d40f5e94d32aa37d6efda376e24b364e1c0ae6 100644 (file)
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -759,8 +759,18 @@ struct inode *nilfs_iget_for_shadow(struct inode *inode)
        return s_inode;
 }
 
+/**
+ * nilfs_write_inode_common - export common inode information to on-disk inode
+ * @inode:     inode object
+ * @raw_inode: on-disk inode
+ *
+ * This function writes standard information from the on-memory inode @inode
+ * to @raw_inode on ifile, cpfile or a super root block.  Since inode bmap
+ * data is not exported, nilfs_bmap_write() must be called separately during
+ * log writing.
+ */
 void nilfs_write_inode_common(struct inode *inode,
-                             struct nilfs_inode *raw_inode, int has_bmap)
+                             struct nilfs_inode *raw_inode)
 {
        struct nilfs_inode_info *ii = NILFS_I(inode);
 
@@ -778,21 +788,6 @@ void nilfs_write_inode_common(struct inode *inode,
        raw_inode->i_flags = cpu_to_le32(ii->i_flags);
        raw_inode->i_generation = cpu_to_le32(inode->i_generation);
 
-       if (NILFS_ROOT_METADATA_FILE(inode->i_ino)) {
-               struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
-
-               /* zero-fill unused portion in the case of super root block */
-               raw_inode->i_xattr = 0;
-               raw_inode->i_pad = 0;
-               memset((void *)raw_inode + sizeof(*raw_inode), 0,
-                      nilfs->ns_inode_size - sizeof(*raw_inode));
-       }
-
-       if (has_bmap)
-               nilfs_bmap_write(ii->i_bmap, raw_inode);
-       else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
-               raw_inode->i_device_code =
-                       cpu_to_le64(huge_encode_dev(inode->i_rdev));
        /*
         * When extending inode, nilfs->ns_inode_size should be checked
         * for substitutions of appended fields.
@@ -813,12 +808,11 @@ void nilfs_update_inode(struct inode *inode, struct buffer_head *ibh, int flags)
        if (flags & I_DIRTY_DATASYNC)
                set_bit(NILFS_I_INODE_SYNC, &ii->i_state);
 
-       nilfs_write_inode_common(inode, raw_inode, 0);
-               /*
-                * XXX: call with has_bmap = 0 is a workaround to avoid
-                * deadlock of bmap.  This delays update of i_bmap to just
-                * before writing.
-                */
+       nilfs_write_inode_common(inode, raw_inode);
+
+       if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
+               raw_inode->i_device_code =
+                       cpu_to_le64(huge_encode_dev(inode->i_rdev));
 
        nilfs_ifile_unmap_inode(ifile, ino, ibh);
 }

diff --git a/fs/nilfs2/nilfs.h b/fs/nilfs2/nilfs.h
index 98cffaf0ac127750a40801e2ced8df73aea7b625..2e29b98ba8bab21e230d4b15d8706332019fd8a4 100644 (file)
--- a/fs/nilfs2/nilfs.h
+++ b/fs/nilfs2/nilfs.h
@@ -256,7 +256,8 @@ extern struct inode *nilfs_new_inode(struct inode *, umode_t);
 extern int nilfs_get_block(struct inode *, sector_t, struct buffer_head *, int);
 extern void nilfs_set_inode_flags(struct inode *);
 extern int nilfs_read_inode_common(struct inode *, struct nilfs_inode *);
-extern void nilfs_write_inode_common(struct inode *, struct nilfs_inode *, int);
+void nilfs_write_inode_common(struct inode *inode,
+                             struct nilfs_inode *raw_inode);
 struct inode *nilfs_ilookup(struct super_block *sb, struct nilfs_root *root,
                            unsigned long ino);
 struct inode *nilfs_iget_locked(struct super_block *sb, struct nilfs_root *root,

diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index 2bfb08052d399972dee9fd49583b77b95104ac83..9044596813cc894fe5974950a0ffcc4c1245790e 100644 (file)
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -913,6 +913,7 @@ static int nilfs_segctor_fill_in_checkpoint(struct nilfs_sc_info *sci)
        struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
        struct buffer_head *bh_cp;
        struct nilfs_checkpoint *raw_cp;
+       struct inode *ifile;
        int err;
 
        err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, nilfs->ns_cno, 0,
@@ -941,8 +942,10 @@ static int nilfs_segctor_fill_in_checkpoint(struct nilfs_sc_info *sci)
        else
                nilfs_checkpoint_set_minor(raw_cp);
 
-       nilfs_write_inode_common(sci->sc_root->ifile,
-                                &raw_cp->cp_ifile_inode, 1);
+       ifile = sci->sc_root->ifile;
+       nilfs_write_inode_common(ifile, &raw_cp->cp_ifile_inode);
+       nilfs_bmap_write(NILFS_I(ifile)->i_bmap, &raw_cp->cp_ifile_inode);
+
        nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, nilfs->ns_cno, bh_cp);
        return 0;
 
@@ -977,6 +980,33 @@ static void nilfs_segctor_fill_in_file_bmap(struct nilfs_sc_info *sci)
        }
 }
 
+/**
+ * nilfs_write_root_mdt_inode - export root metadata inode information to
+ *                              the on-disk inode
+ * @inode:     inode object of the root metadata file
+ * @raw_inode: on-disk inode
+ *
+ * nilfs_write_root_mdt_inode() writes inode information and bmap data of
+ * @inode to the inode area of the metadata file allocated on the super root
+ * block created to finalize the log.  Since super root blocks are configured
+ * each time, this function zero-fills the unused area of @raw_inode.
+ */
+static void nilfs_write_root_mdt_inode(struct inode *inode,
+                                      struct nilfs_inode *raw_inode)
+{
+       struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
+
+       nilfs_write_inode_common(inode, raw_inode);
+
+       /* zero-fill unused portion of raw_inode */
+       raw_inode->i_xattr = 0;
+       raw_inode->i_pad = 0;
+       memset((void *)raw_inode + sizeof(*raw_inode), 0,
+              nilfs->ns_inode_size - sizeof(*raw_inode));
+
+       nilfs_bmap_write(NILFS_I(inode)->i_bmap, raw_inode);
+}
+
 static void nilfs_segctor_fill_in_super_root(struct nilfs_sc_info *sci,
                                             struct the_nilfs *nilfs)
 {
@@ -998,12 +1028,13 @@ static void nilfs_segctor_fill_in_super_root(struct nilfs_sc_info *sci,
                              nilfs->ns_nongc_ctime : sci->sc_seg_ctime);
        raw_sr->sr_flags = 0;
 
-       nilfs_write_inode_common(nilfs->ns_dat, (void *)raw_sr +
-                                NILFS_SR_DAT_OFFSET(isz), 1);
-       nilfs_write_inode_common(nilfs->ns_cpfile, (void *)raw_sr +
-                                NILFS_SR_CPFILE_OFFSET(isz), 1);
-       nilfs_write_inode_common(nilfs->ns_sufile, (void *)raw_sr +
-                                NILFS_SR_SUFILE_OFFSET(isz), 1);
+       nilfs_write_root_mdt_inode(nilfs->ns_dat, (void *)raw_sr +
+                                  NILFS_SR_DAT_OFFSET(isz));
+       nilfs_write_root_mdt_inode(nilfs->ns_cpfile, (void *)raw_sr +
+                                  NILFS_SR_CPFILE_OFFSET(isz));
+       nilfs_write_root_mdt_inode(nilfs->ns_sufile, (void *)raw_sr +
+                                  NILFS_SR_SUFILE_OFFSET(isz));
+
        memset((void *)raw_sr + srsz, 0, nilfs->ns_blocksize - srsz);
        set_buffer_uptodate(bh_sr);
        unlock_buffer(bh_sr);