f2fs: use blk_plug in all the possible paths

This patch reverts 19a5f5e2ef37 (f2fs: drop any block plugging),
and adds blk_plug in write paths additionally.

The main reason is that blk_start_plug can be used to wake up from low-power
mode before submitting further bios.

Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 8ea895389ae44a57c852b04956e1e6d5fb69e07b..be1c54b62388cf143da8b373c103d76b996f5f81 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -265,6 +265,7 @@ static int f2fs_write_meta_pages(struct address_space *mapping,
                                struct writeback_control *wbc)
 {
        struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
+       struct blk_plug plug;
        long diff, written;
 
        /* collect a number of dirty meta pages and write together */
@@ -277,7 +278,9 @@ static int f2fs_write_meta_pages(struct address_space *mapping,
        /* if mounting is failed, skip writing node pages */
        mutex_lock(&sbi->cp_mutex);
        diff = nr_pages_to_write(sbi, META, wbc);
+       blk_start_plug(&plug);
        written = sync_meta_pages(sbi, META, wbc->nr_to_write);
+       blk_finish_plug(&plug);
        mutex_unlock(&sbi->cp_mutex);
        wbc->nr_to_write = max((long)0, wbc->nr_to_write - written - diff);
        return 0;
@@ -899,8 +902,11 @@ static int block_operations(struct f2fs_sb_info *sbi)
                .nr_to_write = LONG_MAX,
                .for_reclaim = 0,
        };
+       struct blk_plug plug;
        int err = 0;
 
+       blk_start_plug(&plug);
+
 retry_flush_dents:
        f2fs_lock_all(sbi);
        /* write all the dirty dentry pages */
@@ -937,6 +943,7 @@ retry_flush_nodes:
                goto retry_flush_nodes;
        }
 out:
+       blk_finish_plug(&plug);
        return err;
 }
 

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index adfe47b21991de04fe5f0b073be765f35b268de1..87a458fb8afe6d7bc9c98cdedcbac48f9d58dd9b 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1438,6 +1438,7 @@ static int f2fs_write_data_pages(struct address_space *mapping,
 {
        struct inode *inode = mapping->host;
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+       struct blk_plug plug;
        int ret;
 
        /* deal with chardevs and other special file */
@@ -1463,7 +1464,9 @@ static int f2fs_write_data_pages(struct address_space *mapping,
 
        trace_f2fs_writepages(mapping->host, wbc, DATA);
 
+       blk_start_plug(&plug);
        ret = f2fs_write_cache_pages(mapping, wbc);
+       blk_finish_plug(&plug);
        /*
         * if some pages were truncated, we cannot guarantee its mapping->host
         * to detect pending bios.

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 72e52cd15b6041b6b57ec4b2358aa25aafa44aff..47f1f5e36d1c801a1b09181e0b7b16424c23917d 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -2102,6 +2102,7 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 {
        struct file *file = iocb->ki_filp;
        struct inode *inode = file_inode(file);
+       struct blk_plug plug;
        ssize_t ret;
 
        if (f2fs_encrypted_inode(inode) &&
@@ -2113,8 +2114,11 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        ret = generic_write_checks(iocb, from);
        if (ret > 0) {
                ret = f2fs_preallocate_blocks(iocb, from);
-               if (!ret)
+               if (!ret) {
+                       blk_start_plug(&plug);
                        ret = __generic_file_write_iter(iocb, from);
+                       blk_finish_plug(&plug);
+               }
        }
        inode_unlock(inode);
 

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 5c8acf754513fd11734894c335d816218f299e48..de6c41c32c6295c636e5ad1eeaf1c381560db48a 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -808,6 +808,7 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi,
 {
        struct page *sum_page;
        struct f2fs_summary_block *sum;
+       struct blk_plug plug;
        unsigned int segno = start_segno;
        unsigned int end_segno = start_segno + sbi->segs_per_sec;
        int seg_freed = 0;
@@ -825,6 +826,8 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi,
                unlock_page(sum_page);
        }
 
+       blk_start_plug(&plug);
+
        for (segno = start_segno; segno < end_segno; segno++) {
 
                if (get_valid_blocks(sbi, segno, 1) == 0)
@@ -862,6 +865,8 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi,
                f2fs_submit_merged_bio(sbi,
                                (type == SUM_TYPE_NODE) ? NODE : DATA, WRITE);
 
+       blk_finish_plug(&plug);
+
        if (gc_type == FG_GC) {
                while (start_segno < end_segno)
                        if (get_valid_blocks(sbi, start_segno++, 1) == 0)

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index d78f61d647c01d13c4a1c8cd0838b99724ddf125..79a93c6e632fe0edd24a3b046c8b27cdb01f5f57 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1618,6 +1618,7 @@ static int f2fs_write_node_pages(struct address_space *mapping,
                            struct writeback_control *wbc)
 {
        struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
+       struct blk_plug plug;
        long diff;
 
        /* balancing f2fs's metadata in background */
@@ -1631,7 +1632,9 @@ static int f2fs_write_node_pages(struct address_space *mapping,
 
        diff = nr_pages_to_write(sbi, NODE, wbc);
        wbc->sync_mode = WB_SYNC_NONE;
+       blk_start_plug(&plug);
        sync_node_pages(sbi, wbc);
+       blk_finish_plug(&plug);
        wbc->nr_to_write = max((long)0, wbc->nr_to_write - diff);
        return 0;
 

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index e87aa058f57a671e0fb5170329192e301ff17fa7..d45e6bbf84934332e1f975a95868137017844a17 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -381,8 +381,13 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi)
                        excess_prefree_segs(sbi) ||
                        excess_dirty_nats(sbi) ||
                        (is_idle(sbi) && f2fs_time_over(sbi, CP_TIME))) {
-               if (test_opt(sbi, DATA_FLUSH))
+               if (test_opt(sbi, DATA_FLUSH)) {
+                       struct blk_plug plug;
+
+                       blk_start_plug(&plug);
                        sync_dirty_inodes(sbi, FILE_INODE);
+                       blk_finish_plug(&plug);
+               }
                f2fs_sync_fs(sbi->sb, true);
                stat_inc_bg_cp_count(sbi->stat_info);
        }