nilfs2: remove own inode hash used for GC

[deliverable/linux.git] / fs / nilfs2 / segment.c

diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index c9201649cc49f65e92a42cb3cd1fbe6c81e9184d..9cf71389f369d0cb125cab8ce890a8d71b0a732c 100644 (file)
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -366,8 +366,7 @@ static int nilfs_segctor_reset_segment_buffer(struct nilfs_sc_info *sci)
 
        if (nilfs_doing_gc())
                flags = NILFS_SS_GC;
-       err = nilfs_segbuf_reset(segbuf, flags, sci->sc_seg_ctime,
-                                sci->sc_sbi->s_nilfs->ns_cno);
+       err = nilfs_segbuf_reset(segbuf, flags, sci->sc_seg_ctime, sci->sc_cno);
        if (unlikely(err))
                return err;
 
@@ -440,17 +439,26 @@ static void nilfs_segctor_end_finfo(struct nilfs_sc_info *sci,
        struct nilfs_finfo *finfo;
        struct nilfs_inode_info *ii;
        struct nilfs_segment_buffer *segbuf;
+       __u64 cno;
 
        if (sci->sc_blk_cnt == 0)
                return;
 
        ii = NILFS_I(inode);
+
+       if (test_bit(NILFS_I_GCINODE, &ii->i_state))
+               cno = ii->i_cno;
+       else if (NILFS_ROOT_METADATA_FILE(inode->i_ino))
+               cno = 0;
+       else
+               cno = sci->sc_cno;
+
        finfo = nilfs_segctor_map_segsum_entry(sci, &sci->sc_finfo_ptr,
                                                 sizeof(*finfo));
        finfo->fi_ino = cpu_to_le64(inode->i_ino);
        finfo->fi_nblocks = cpu_to_le32(sci->sc_blk_cnt);
        finfo->fi_ndatablk = cpu_to_le32(sci->sc_datablk_cnt);
-       finfo->fi_cno = cpu_to_le64(ii->i_cno);
+       finfo->fi_cno = cpu_to_le64(cno);
 
        segbuf = sci->sc_curseg;
        segbuf->sb_sum.sumbytes = sci->sc_binfo_ptr.offset +
@@ -1914,12 +1922,12 @@ static void nilfs_segctor_complete_write(struct nilfs_sc_info *sci)
                        }
                }
 
-               if (!NILFS_SEG_SIMPLEX(&segbuf->sb_sum)) {
-                       if (NILFS_SEG_LOGBGN(&segbuf->sb_sum)) {
+               if (!nilfs_segbuf_simplex(segbuf)) {
+                       if (segbuf->sb_sum.flags & NILFS_SS_LOGBGN) {
                                set_bit(NILFS_SC_UNCLOSED, &sci->sc_flags);
                                sci->sc_lseg_stime = jiffies;
                        }
-                       if (NILFS_SEG_LOGEND(&segbuf->sb_sum))
+                       if (segbuf->sb_sum.flags & NILFS_SS_LOGEND)
                                clear_bit(NILFS_SC_UNCLOSED, &sci->sc_flags);
                }
        }
@@ -1951,7 +1959,6 @@ static void nilfs_segctor_complete_write(struct nilfs_sc_info *sci)
        if (update_sr) {
                nilfs_set_last_segment(nilfs, segbuf->sb_pseg_start,
                                       segbuf->sb_sum.seg_seq, nilfs->ns_cno++);
-               set_nilfs_sb_dirty(nilfs);
 
                clear_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags);
                clear_bit(NILFS_SC_DIRTY, &sci->sc_flags);
@@ -1977,7 +1984,6 @@ static int nilfs_segctor_check_in_files(struct nilfs_sc_info *sci,
                                        struct nilfs_sb_info *sbi)
 {
        struct nilfs_inode_info *ii, *n;
-       __u64 cno = sbi->s_nilfs->ns_cno;
 
        spin_lock(&sbi->s_inode_lock);
  retry:
@@ -2003,7 +2009,6 @@ static int nilfs_segctor_check_in_files(struct nilfs_sc_info *sci,
                                brelse(ibh);
                        goto retry;
                }
-               ii->i_cno = cno;
 
                clear_bit(NILFS_I_QUEUED, &ii->i_state);
                set_bit(NILFS_I_BUSY, &ii->i_state);
@@ -2012,8 +2017,6 @@ static int nilfs_segctor_check_in_files(struct nilfs_sc_info *sci,
        }
        spin_unlock(&sbi->s_inode_lock);
 
-       NILFS_I(sbi->s_ifile)->i_cno = cno;
-
        return 0;
 }
 
@@ -2022,19 +2025,13 @@ static void nilfs_segctor_check_out_files(struct nilfs_sc_info *sci,
 {
        struct nilfs_transaction_info *ti = current->journal_info;
        struct nilfs_inode_info *ii, *n;
-       __u64 cno = sbi->s_nilfs->ns_cno;
 
        spin_lock(&sbi->s_inode_lock);
        list_for_each_entry_safe(ii, n, &sci->sc_dirty_files, i_dirty) {
                if (!test_and_clear_bit(NILFS_I_UPDATED, &ii->i_state) ||
-                   test_bit(NILFS_I_DIRTY, &ii->i_state)) {
-                       /* The current checkpoint number (=nilfs->ns_cno) is
-                          changed between check-in and check-out only if the
-                          super root is written out.  So, we can update i_cno
-                          for the inodes that remain in the dirty list. */
-                       ii->i_cno = cno;
+                   test_bit(NILFS_I_DIRTY, &ii->i_state))
                        continue;
-               }
+
                clear_bit(NILFS_I_BUSY, &ii->i_state);
                brelse(ii->i_bh);
                ii->i_bh = NULL;
@@ -2055,6 +2052,7 @@ static int nilfs_segctor_do_construct(struct nilfs_sc_info *sci, int mode)
        int err;
 
        sci->sc_stage.scnt = NILFS_ST_INIT;
+       sci->sc_cno = nilfs->ns_cno;
 
        err = nilfs_segctor_check_in_files(sci, sbi);
        if (unlikely(err))
@@ -2082,7 +2080,7 @@ static int nilfs_segctor_do_construct(struct nilfs_sc_info *sci, int mode)
 
                /* Avoid empty segment */
                if (sci->sc_stage.scnt == NILFS_ST_DONE &&
-                   NILFS_SEG_EMPTY(&sci->sc_curseg->sb_sum)) {
+                   nilfs_segbuf_empty(sci->sc_curseg)) {
                        nilfs_segctor_abort_construction(sci, nilfs, 1);
                        goto out;
                }
@@ -2408,6 +2406,7 @@ static int nilfs_segctor_construct(struct nilfs_sc_info *sci, int mode)
 {
        struct nilfs_sb_info *sbi = sci->sc_sbi;
        struct the_nilfs *nilfs = sbi->s_nilfs;
+       struct nilfs_super_block **sbp;
        int err = 0;
 
        nilfs_segctor_accept(sci);
@@ -2423,8 +2422,13 @@ static int nilfs_segctor_construct(struct nilfs_sc_info *sci, int mode)
                if (test_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags) &&
                    nilfs_discontinued(nilfs)) {
                        down_write(&nilfs->ns_sem);
-                       err = nilfs_commit_super(
-                               sbi, nilfs_altsb_need_update(nilfs));
+                       err = -EIO;
+                       sbp = nilfs_prepare_super(sbi,
+                                                 nilfs_sb_will_flip(nilfs));
+                       if (likely(sbp)) {
+                               nilfs_set_log_cursor(sbp[0], nilfs);
+                               err = nilfs_commit_super(sbi, NILFS_SB_COMMIT);
+                       }
                        up_write(&nilfs->ns_sem);
                }
        }
@@ -2447,9 +2451,8 @@ nilfs_remove_written_gcinodes(struct the_nilfs *nilfs, struct list_head *head)
        list_for_each_entry_safe(ii, n, head, i_dirty) {
                if (!test_bit(NILFS_I_UPDATED, &ii->i_state))
                        continue;
-               hlist_del_init(&ii->vfs_inode.i_hash);
                list_del_init(&ii->i_dirty);
-               nilfs_clear_gcinode(&ii->vfs_inode);
+               iput(&ii->vfs_inode);
        }
 }