nilfs2: get rid of nilfs_sb_info structure

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

diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index e3d1785faf1bd9aa5cb48d5cc9c1ece18d160bc5..afe4f2183454d49a4be19b902c200b1922ebcc4e 100644 (file)
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -181,7 +181,6 @@ int nilfs_transaction_begin(struct super_block *sb,
                            struct nilfs_transaction_info *ti,
                            int vacancy_check)
 {
-       struct nilfs_sb_info *sbi;
        struct the_nilfs *nilfs;
        int ret = nilfs_prepare_segment_lock(ti);
 
@@ -192,8 +191,7 @@ int nilfs_transaction_begin(struct super_block *sb,
 
        vfs_check_frozen(sb, SB_FREEZE_WRITE);
 
-       sbi = NILFS_SB(sb);
-       nilfs = sbi->s_nilfs;
+       nilfs = sb->s_fs_info;
        down_read(&nilfs->ns_segctor_sem);
        if (vacancy_check && nilfs_near_disk_full(nilfs)) {
                up_read(&nilfs->ns_segctor_sem);
@@ -224,7 +222,7 @@ int nilfs_transaction_begin(struct super_block *sb,
 int nilfs_transaction_commit(struct super_block *sb)
 {
        struct nilfs_transaction_info *ti = current->journal_info;
-       struct the_nilfs *nilfs = NILFS_SB(sb)->s_nilfs;
+       struct the_nilfs *nilfs = sb->s_fs_info;
        int err = 0;
 
        BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC);
@@ -254,13 +252,14 @@ int nilfs_transaction_commit(struct super_block *sb)
 void nilfs_transaction_abort(struct super_block *sb)
 {
        struct nilfs_transaction_info *ti = current->journal_info;
+       struct the_nilfs *nilfs = sb->s_fs_info;
 
        BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC);
        if (ti->ti_count > 0) {
                ti->ti_count--;
                return;
        }
-       up_read(&NILFS_SB(sb)->s_nilfs->ns_segctor_sem);
+       up_read(&nilfs->ns_segctor_sem);
 
        current->journal_info = ti->ti_save;
        if (ti->ti_flags & NILFS_TI_DYNAMIC_ALLOC)
@@ -269,7 +268,7 @@ void nilfs_transaction_abort(struct super_block *sb)
 
 void nilfs_relax_pressure_in_lock(struct super_block *sb)
 {
-       struct the_nilfs *nilfs = NILFS_SB(sb)->s_nilfs;
+       struct the_nilfs *nilfs = sb->s_fs_info;
        struct nilfs_sc_info *sci = nilfs->ns_writer;
 
        if (!sci || !sci->sc_flush_request)
@@ -290,12 +289,12 @@ void nilfs_relax_pressure_in_lock(struct super_block *sb)
        downgrade_write(&nilfs->ns_segctor_sem);
 }
 
-static void nilfs_transaction_lock(struct nilfs_sb_info *sbi,
+static void nilfs_transaction_lock(struct super_block *sb,
                                   struct nilfs_transaction_info *ti,
                                   int gcflag)
 {
        struct nilfs_transaction_info *cur_ti = current->journal_info;
-       struct the_nilfs *nilfs = sbi->s_nilfs;
+       struct the_nilfs *nilfs = sb->s_fs_info;
        struct nilfs_sc_info *sci = nilfs->ns_writer;
 
        WARN_ON(cur_ti);
@@ -313,17 +312,17 @@ static void nilfs_transaction_lock(struct nilfs_sb_info *sbi,
 
                nilfs_segctor_do_immediate_flush(sci);
 
-               up_write(&sbi->s_nilfs->ns_segctor_sem);
+               up_write(&nilfs->ns_segctor_sem);
                yield();
        }
        if (gcflag)
                ti->ti_flags |= NILFS_TI_GC;
 }
 
-static void nilfs_transaction_unlock(struct nilfs_sb_info *sbi)
+static void nilfs_transaction_unlock(struct super_block *sb)
 {
        struct nilfs_transaction_info *ti = current->journal_info;
-       struct the_nilfs *nilfs = sbi->s_nilfs;
+       struct the_nilfs *nilfs = sb->s_fs_info;
 
        BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC);
        BUG_ON(ti->ti_count > 0);
@@ -772,7 +771,7 @@ static int nilfs_segctor_clean(struct nilfs_sc_info *sci)
 
 static int nilfs_segctor_confirm(struct nilfs_sc_info *sci)
 {
-       struct the_nilfs *nilfs = sci->sc_sbi->s_nilfs;
+       struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
        int ret = 0;
 
        if (nilfs_test_metadata_dirty(nilfs, sci->sc_root))
@@ -788,8 +787,7 @@ static int nilfs_segctor_confirm(struct nilfs_sc_info *sci)
 
 static void nilfs_segctor_clear_metadata_dirty(struct nilfs_sc_info *sci)
 {
-       struct nilfs_sb_info *sbi = sci->sc_sbi;
-       struct the_nilfs *nilfs = sbi->s_nilfs;
+       struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
 
        nilfs_mdt_clear_dirty(sci->sc_root->ifile);
        nilfs_mdt_clear_dirty(nilfs->ns_cpfile);
@@ -799,7 +797,7 @@ static void nilfs_segctor_clear_metadata_dirty(struct nilfs_sc_info *sci)
 
 static int nilfs_segctor_create_checkpoint(struct nilfs_sc_info *sci)
 {
-       struct the_nilfs *nilfs = sci->sc_sbi->s_nilfs;
+       struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
        struct buffer_head *bh_cp;
        struct nilfs_checkpoint *raw_cp;
        int err;
@@ -823,8 +821,7 @@ static int nilfs_segctor_create_checkpoint(struct nilfs_sc_info *sci)
 
 static int nilfs_segctor_fill_in_checkpoint(struct nilfs_sc_info *sci)
 {
-       struct nilfs_sb_info *sbi = sci->sc_sbi;
-       struct the_nilfs *nilfs = sbi->s_nilfs;
+       struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
        struct buffer_head *bh_cp;
        struct nilfs_checkpoint *raw_cp;
        int err;
@@ -1048,8 +1045,7 @@ static int nilfs_segctor_scan_file_dsync(struct nilfs_sc_info *sci,
 
 static int nilfs_segctor_collect_blocks(struct nilfs_sc_info *sci, int mode)
 {
-       struct nilfs_sb_info *sbi = sci->sc_sbi;
-       struct the_nilfs *nilfs = sbi->s_nilfs;
+       struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
        struct list_head *head;
        struct nilfs_inode_info *ii;
        size_t ndone;
@@ -1858,7 +1854,7 @@ static void nilfs_segctor_complete_write(struct nilfs_sc_info *sci)
 {
        struct nilfs_segment_buffer *segbuf;
        struct page *bd_page = NULL, *fs_page = NULL;
-       struct the_nilfs *nilfs = sci->sc_sbi->s_nilfs;
+       struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
        int update_sr = false;
 
        list_for_each_entry(segbuf, &sci->sc_write_logs, sb_list) {
@@ -2029,8 +2025,7 @@ static void nilfs_segctor_drop_written_files(struct nilfs_sc_info *sci,
  */
 static int nilfs_segctor_do_construct(struct nilfs_sc_info *sci, int mode)
 {
-       struct nilfs_sb_info *sbi = sci->sc_sbi;
-       struct the_nilfs *nilfs = sbi->s_nilfs;
+       struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
        struct page *failed_page;
        int err;
 
@@ -2168,7 +2163,7 @@ static void nilfs_segctor_do_flush(struct nilfs_sc_info *sci, int bn)
  */
 void nilfs_flush_segment(struct super_block *sb, ino_t ino)
 {
-       struct the_nilfs *nilfs = NILFS_SB(sb)->s_nilfs;
+       struct the_nilfs *nilfs = sb->s_fs_info;
        struct nilfs_sc_info *sci = nilfs->ns_writer;
 
        if (!sci || nilfs_doing_construction())
@@ -2258,7 +2253,7 @@ static void nilfs_segctor_wakeup(struct nilfs_sc_info *sci, int err)
  */
 int nilfs_construct_segment(struct super_block *sb)
 {
-       struct the_nilfs *nilfs = NILFS_SB(sb)->s_nilfs;
+       struct the_nilfs *nilfs = sb->s_fs_info;
        struct nilfs_sc_info *sci = nilfs->ns_writer;
        struct nilfs_transaction_info *ti;
        int err;
@@ -2296,8 +2291,7 @@ int nilfs_construct_segment(struct super_block *sb)
 int nilfs_construct_dsync_segment(struct super_block *sb, struct inode *inode,
                                  loff_t start, loff_t end)
 {
-       struct nilfs_sb_info *sbi = NILFS_SB(sb);
-       struct the_nilfs *nilfs = sbi->s_nilfs;
+       struct the_nilfs *nilfs = sb->s_fs_info;
        struct nilfs_sc_info *sci = nilfs->ns_writer;
        struct nilfs_inode_info *ii;
        struct nilfs_transaction_info ti;
@@ -2306,14 +2300,14 @@ int nilfs_construct_dsync_segment(struct super_block *sb, struct inode *inode,
        if (!sci)
                return -EROFS;
 
-       nilfs_transaction_lock(sbi, &ti, 0);
+       nilfs_transaction_lock(sb, &ti, 0);
 
        ii = NILFS_I(inode);
        if (test_bit(NILFS_I_INODE_DIRTY, &ii->i_state) ||
            nilfs_test_opt(nilfs, STRICT_ORDER) ||
            test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags) ||
            nilfs_discontinued(nilfs)) {
-               nilfs_transaction_unlock(sbi);
+               nilfs_transaction_unlock(sb);
                err = nilfs_segctor_sync(sci);
                return err;
        }
@@ -2322,7 +2316,7 @@ int nilfs_construct_dsync_segment(struct super_block *sb, struct inode *inode,
        if (!test_bit(NILFS_I_QUEUED, &ii->i_state) &&
            !test_bit(NILFS_I_BUSY, &ii->i_state)) {
                spin_unlock(&nilfs->ns_inode_lock);
-               nilfs_transaction_unlock(sbi);
+               nilfs_transaction_unlock(sb);
                return 0;
        }
        spin_unlock(&nilfs->ns_inode_lock);
@@ -2332,7 +2326,7 @@ int nilfs_construct_dsync_segment(struct super_block *sb, struct inode *inode,
 
        err = nilfs_segctor_do_construct(sci, SC_LSEG_DSYNC);
 
-       nilfs_transaction_unlock(sbi);
+       nilfs_transaction_unlock(sb);
        return err;
 }
 
@@ -2388,8 +2382,7 @@ static void nilfs_segctor_notify(struct nilfs_sc_info *sci, int mode, int err)
  */
 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 the_nilfs *nilfs = sci->sc_super->s_fs_info;
        struct nilfs_super_block **sbp;
        int err = 0;
 
@@ -2407,11 +2400,12 @@ static int nilfs_segctor_construct(struct nilfs_sc_info *sci, int mode)
                    nilfs_discontinued(nilfs)) {
                        down_write(&nilfs->ns_sem);
                        err = -EIO;
-                       sbp = nilfs_prepare_super(sbi,
+                       sbp = nilfs_prepare_super(sci->sc_super,
                                                  nilfs_sb_will_flip(nilfs));
                        if (likely(sbp)) {
                                nilfs_set_log_cursor(sbp[0], nilfs);
-                               err = nilfs_commit_super(sbi, NILFS_SB_COMMIT);
+                               err = nilfs_commit_super(sci->sc_super,
+                                                        NILFS_SB_COMMIT);
                        }
                        up_write(&nilfs->ns_sem);
                }
@@ -2443,8 +2437,7 @@ nilfs_remove_written_gcinodes(struct the_nilfs *nilfs, struct list_head *head)
 int nilfs_clean_segments(struct super_block *sb, struct nilfs_argv *argv,
                         void **kbufs)
 {
-       struct nilfs_sb_info *sbi = NILFS_SB(sb);
-       struct the_nilfs *nilfs = sbi->s_nilfs;
+       struct the_nilfs *nilfs = sb->s_fs_info;
        struct nilfs_sc_info *sci = nilfs->ns_writer;
        struct nilfs_transaction_info ti;
        int err;
@@ -2452,7 +2445,7 @@ int nilfs_clean_segments(struct super_block *sb, struct nilfs_argv *argv,
        if (unlikely(!sci))
                return -EROFS;
 
-       nilfs_transaction_lock(sbi, &ti, 1);
+       nilfs_transaction_lock(sb, &ti, 1);
 
        err = nilfs_mdt_save_to_shadow_map(nilfs->ns_dat);
        if (unlikely(err))
@@ -2495,16 +2488,15 @@ int nilfs_clean_segments(struct super_block *sb, struct nilfs_argv *argv,
        sci->sc_freesegs = NULL;
        sci->sc_nfreesegs = 0;
        nilfs_mdt_clear_shadow_map(nilfs->ns_dat);
-       nilfs_transaction_unlock(sbi);
+       nilfs_transaction_unlock(sb);
        return err;
 }
 
 static void nilfs_segctor_thread_construct(struct nilfs_sc_info *sci, int mode)
 {
-       struct nilfs_sb_info *sbi = sci->sc_sbi;
        struct nilfs_transaction_info ti;
 
-       nilfs_transaction_lock(sbi, &ti, 0);
+       nilfs_transaction_lock(sci->sc_super, &ti, 0);
        nilfs_segctor_construct(sci, mode);
 
        /*
@@ -2515,7 +2507,7 @@ static void nilfs_segctor_thread_construct(struct nilfs_sc_info *sci, int mode)
        if (test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags))
                nilfs_segctor_start_timer(sci);
 
-       nilfs_transaction_unlock(sbi);
+       nilfs_transaction_unlock(sci->sc_super);
 }
 
 static void nilfs_segctor_do_immediate_flush(struct nilfs_sc_info *sci)
@@ -2561,7 +2553,7 @@ static int nilfs_segctor_flush_mode(struct nilfs_sc_info *sci)
 static int nilfs_segctor_thread(void *arg)
 {
        struct nilfs_sc_info *sci = (struct nilfs_sc_info *)arg;
-       struct the_nilfs *nilfs = sci->sc_sbi->s_nilfs;
+       struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
        int timeout = 0;
 
        sci->sc_timer.data = (unsigned long)current;
@@ -2672,18 +2664,17 @@ static void nilfs_segctor_kill_thread(struct nilfs_sc_info *sci)
 /*
  * Setup & clean-up functions
  */
-static struct nilfs_sc_info *nilfs_segctor_new(struct nilfs_sb_info *sbi,
+static struct nilfs_sc_info *nilfs_segctor_new(struct super_block *sb,
                                               struct nilfs_root *root)
 {
-       struct the_nilfs *nilfs = sbi->s_nilfs;
+       struct the_nilfs *nilfs = sb->s_fs_info;
        struct nilfs_sc_info *sci;
 
        sci = kzalloc(sizeof(*sci), GFP_KERNEL);
        if (!sci)
                return NULL;
 
-       sci->sc_sbi = sbi;
-       sci->sc_super = sbi->s_super;
+       sci->sc_super = sb;
 
        nilfs_get_root(root);
        sci->sc_root = root;
@@ -2717,12 +2708,11 @@ static void nilfs_segctor_write_out(struct nilfs_sc_info *sci)
        /* The segctord thread was stopped and its timer was removed.
           But some tasks remain. */
        do {
-               struct nilfs_sb_info *sbi = sci->sc_sbi;
                struct nilfs_transaction_info ti;
 
-               nilfs_transaction_lock(sbi, &ti, 0);
+               nilfs_transaction_lock(sci->sc_super, &ti, 0);
                ret = nilfs_segctor_construct(sci, SC_LSEG_SR);
-               nilfs_transaction_unlock(sbi);
+               nilfs_transaction_unlock(sci->sc_super);
 
        } while (ret && retrycount-- > 0);
 }
@@ -2737,7 +2727,7 @@ static void nilfs_segctor_write_out(struct nilfs_sc_info *sci)
  */
 static void nilfs_segctor_destroy(struct nilfs_sc_info *sci)
 {
-       struct the_nilfs *nilfs = sci->sc_sbi->s_nilfs;
+       struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
        int flag;
 
        up_write(&nilfs->ns_segctor_sem);
@@ -2771,22 +2761,21 @@ static void nilfs_segctor_destroy(struct nilfs_sc_info *sci)
 }
 
 /**
- * nilfs_attach_segment_constructor - attach a segment constructor
- * @sbi: nilfs_sb_info
+ * nilfs_attach_log_writer - attach log writer
+ * @sb: super block instance
  * @root: root object of the current filesystem tree
  *
- * nilfs_attach_segment_constructor() allocates a struct nilfs_sc_info,
- * initializes it, and starts the segment constructor.
+ * This allocates a log writer object, initializes it, and starts the
+ * log writer.
  *
  * Return Value: On success, 0 is returned. On error, one of the following
  * negative error code is returned.
  *
  * %-ENOMEM - Insufficient memory available.
  */
-int nilfs_attach_segment_constructor(struct nilfs_sb_info *sbi,
-                                    struct nilfs_root *root)
+int nilfs_attach_log_writer(struct super_block *sb, struct nilfs_root *root)
 {
-       struct the_nilfs *nilfs = sbi->s_nilfs;
+       struct the_nilfs *nilfs = sb->s_fs_info;
        int err;
 
        if (nilfs->ns_writer) {
@@ -2795,10 +2784,10 @@ int nilfs_attach_segment_constructor(struct nilfs_sb_info *sbi,
                 * read/write after nilfs_error degenerated it into a
                 * read-only mount.
                 */
-               nilfs_detach_segment_constructor(sbi);
+               nilfs_detach_log_writer(sb);
        }
 
-       nilfs->ns_writer = nilfs_segctor_new(sbi, root);
+       nilfs->ns_writer = nilfs_segctor_new(sb, root);
        if (!nilfs->ns_writer)
                return -ENOMEM;
 
@@ -2811,15 +2800,15 @@ int nilfs_attach_segment_constructor(struct nilfs_sb_info *sbi,
 }
 
 /**
- * nilfs_detach_segment_constructor - destroy the segment constructor
- * @sbi: nilfs_sb_info
+ * nilfs_detach_log_writer - destroy log writer
+ * @sb: super block instance
  *
- * nilfs_detach_segment_constructor() kills the segment constructor daemon,
- * frees the struct nilfs_sc_info, and destroy the dirty file list.
+ * This kills log writer daemon, frees the log writer object, and
+ * destroys list of dirty files.
  */
-void nilfs_detach_segment_constructor(struct nilfs_sb_info *sbi)
+void nilfs_detach_log_writer(struct super_block *sb)
 {
-       struct the_nilfs *nilfs = sbi->s_nilfs;
+       struct the_nilfs *nilfs = sb->s_fs_info;
        LIST_HEAD(garbage_list);
 
        down_write(&nilfs->ns_segctor_sem);
@@ -2832,9 +2821,8 @@ void nilfs_detach_segment_constructor(struct nilfs_sb_info *sbi)
        spin_lock(&nilfs->ns_inode_lock);
        if (!list_empty(&nilfs->ns_dirty_files)) {
                list_splice_init(&nilfs->ns_dirty_files, &garbage_list);
-               nilfs_warning(sbi->s_super, __func__,
-                             "Non empty dirty list after the last "
-                             "segment construction\n");
+               nilfs_warning(sb, __func__,
+                             "Hit dirty file after stopped log writer\n");
        }
        spin_unlock(&nilfs->ns_inode_lock);
        up_write(&nilfs->ns_segctor_sem);