f2fs: introduce F2FS_IPU_HONOR_OPU_WRITE ipu policy

[ Upstream commit 1018a5463a063715365784704c4e8cdf2eec4b04 ]

Once F2FS_IPU_FORCE policy is enabled in some cases:
a) f2fs forces to use F2FS_IPU_FORCE in a small-sized volume
b) user sets F2FS_IPU_FORCE policy via sysfs

Then we may fail to defragment file due to IPU policy check, it doesn't
make sense, let's introduce a new IPU policy to allow OPU during file
defragmentation.

In small-sized volume, let's enable F2FS_IPU_HONOR_OPU_WRITE policy
by default.

Signed-off-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
Stable-dep-of: 884ee6dc85b9 ("f2fs: get rid of online repaire on corrupted directory")
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/Documentation/ABI/testing/sysfs-fs-f2fs b/Documentation/ABI/testing/sysfs-fs-f2fs
index 48d41b6696270e3515883157cfb1a6ed8b14fda6..89dec1f3ea6d986ab7ae0a80e7d8d02dafe2103d 100644 (file)
--- a/Documentation/ABI/testing/sysfs-fs-f2fs
+++ b/Documentation/ABI/testing/sysfs-fs-f2fs
@@ -55,8 +55,9 @@ Description:  Controls the in-place-update policy.
                0x04  F2FS_IPU_UTIL
                0x08  F2FS_IPU_SSR_UTIL
                0x10  F2FS_IPU_FSYNC
-               0x20  F2FS_IPU_ASYNC,
+               0x20  F2FS_IPU_ASYNC
                0x40  F2FS_IPU_NOCACHE
+               0x80  F2FS_IPU_HONOR_OPU_WRITE
                ====  =================
 
                Refer segment.h for details.

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index fa86eaf1d6393b5ff6a96bb09c55eea48949c4cb..3f8dae229d422aa9fa854c2c567ba7754b9a02ff 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2567,6 +2567,9 @@ static inline bool check_inplace_update_policy(struct inode *inode,
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        unsigned int policy = SM_I(sbi)->ipu_policy;
 
+       if (policy & (0x1 << F2FS_IPU_HONOR_OPU_WRITE) &&
+                       is_inode_flag_set(inode, FI_OPU_WRITE))
+               return false;
        if (policy & (0x1 << F2FS_IPU_FORCE))
                return true;
        if (policy & (0x1 << F2FS_IPU_SSR) && f2fs_need_SSR(sbi))
@@ -2637,6 +2640,9 @@ bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio)
        if (is_inode_flag_set(inode, FI_ALIGNED_WRITE))
                return true;
 
+       if (is_inode_flag_set(inode, FI_OPU_WRITE))
+               return true;
+
        if (fio) {
                if (page_private_gcing(fio->page))
                        return true;
@@ -3263,8 +3269,8 @@ static int __f2fs_write_data_pages(struct address_space *mapping,
                        f2fs_available_free_memory(sbi, DIRTY_DENTS))
                goto skip_write;
 
-       /* skip writing during file defragment */
-       if (is_inode_flag_set(inode, FI_DO_DEFRAG))
+       /* skip writing in file defragment preparing stage */
+       if (is_inode_flag_set(inode, FI_SKIP_WRITES))
                goto skip_write;
 
        trace_f2fs_writepages(mapping->host, wbc, DATA);
@@ -3998,6 +4004,7 @@ static int f2fs_migrate_blocks(struct inode *inode, block_t start_blk,
        filemap_invalidate_lock(inode->i_mapping);
 
        set_inode_flag(inode, FI_ALIGNED_WRITE);
+       set_inode_flag(inode, FI_OPU_WRITE);
 
        for (; secidx < end_sec; secidx++) {
                down_write(&sbi->pin_sem);
@@ -4006,7 +4013,7 @@ static int f2fs_migrate_blocks(struct inode *inode, block_t start_blk,
                f2fs_allocate_new_section(sbi, CURSEG_COLD_DATA_PINNED, false);
                f2fs_unlock_op(sbi);
 
-               set_inode_flag(inode, FI_DO_DEFRAG);
+               set_inode_flag(inode, FI_SKIP_WRITES);
 
                for (blkofs = 0; blkofs < blk_per_sec; blkofs++) {
                        struct page *page;
@@ -4023,7 +4030,7 @@ static int f2fs_migrate_blocks(struct inode *inode, block_t start_blk,
                        f2fs_put_page(page, 1);
                }
 
-               clear_inode_flag(inode, FI_DO_DEFRAG);
+               clear_inode_flag(inode, FI_SKIP_WRITES);
 
                ret = filemap_fdatawrite(inode->i_mapping);
 
@@ -4034,7 +4041,8 @@ static int f2fs_migrate_blocks(struct inode *inode, block_t start_blk,
        }
 
 done:
-       clear_inode_flag(inode, FI_DO_DEFRAG);
+       clear_inode_flag(inode, FI_SKIP_WRITES);
+       clear_inode_flag(inode, FI_OPU_WRITE);
        clear_inode_flag(inode, FI_ALIGNED_WRITE);
 
        filemap_invalidate_unlock(inode->i_mapping);

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index cd3439ea6d727dd8fdd632158fb7760ca3b40101..f2c55a5afe67baee8407cf43a1c596ff9735f597 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -715,7 +715,8 @@ enum {
        FI_DROP_CACHE,          /* drop dirty page cache */
        FI_DATA_EXIST,          /* indicate data exists */
        FI_INLINE_DOTS,         /* indicate inline dot dentries */
-       FI_DO_DEFRAG,           /* indicate defragment is running */
+       FI_SKIP_WRITES,         /* should skip data page writeback */
+       FI_OPU_WRITE,           /* used for opu per file */
        FI_DIRTY_FILE,          /* indicate regular/symlink has dirty pages */
        FI_NO_PREALLOC,         /* indicate skipped preallocated blocks */
        FI_HOT_DATA,            /* indicate file is hot */

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 0427994c9b50a6c6030a655a21a1a1cb6fbc25e0..ee20d79bd93e44ceb8ac7164c0b894085cb6b994 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -2579,10 +2579,6 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
        bool fragmented = false;
        int err;
 
-       /* if in-place-update policy is enabled, don't waste time here */
-       if (f2fs_should_update_inplace(inode, NULL))
-               return -EINVAL;
-
        pg_start = range->start >> PAGE_SHIFT;
        pg_end = (range->start + range->len) >> PAGE_SHIFT;
 
@@ -2590,6 +2586,13 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
 
        inode_lock(inode);
 
+       /* if in-place-update policy is enabled, don't waste time here */
+       set_inode_flag(inode, FI_OPU_WRITE);
+       if (f2fs_should_update_inplace(inode, NULL)) {
+               err = -EINVAL;
+               goto out;
+       }
+
        /* writeback all dirty pages in the range */
        err = filemap_write_and_wait_range(inode->i_mapping, range->start,
                                                range->start + range->len - 1);
@@ -2671,7 +2674,7 @@ do_map:
                        goto check;
                }
 
-               set_inode_flag(inode, FI_DO_DEFRAG);
+               set_inode_flag(inode, FI_SKIP_WRITES);
 
                idx = map.m_lblk;
                while (idx < map.m_lblk + map.m_len && cnt < blk_per_seg) {
@@ -2699,15 +2702,16 @@ check:
                if (map.m_lblk < pg_end && cnt < blk_per_seg)
                        goto do_map;
 
-               clear_inode_flag(inode, FI_DO_DEFRAG);
+               clear_inode_flag(inode, FI_SKIP_WRITES);
 
                err = filemap_fdatawrite(inode->i_mapping);
                if (err)
                        goto out;
        }
 clear_out:
-       clear_inode_flag(inode, FI_DO_DEFRAG);
+       clear_inode_flag(inode, FI_SKIP_WRITES);
 out:
+       clear_inode_flag(inode, FI_OPU_WRITE);
        inode_unlock(inode);
        if (!err)
                range->len = (u64)total << PAGE_SHIFT;

diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index 04f448ddf49ea884eb21b490f82d626cbaa06354..2c1165e8f12835d2e24be04e8045d7c2ee8fc0df 100644 (file)
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -665,7 +665,9 @@ static inline int utilization(struct f2fs_sb_info *sbi)
  *                     pages over min_fsync_blocks. (=default option)
  * F2FS_IPU_ASYNC - do IPU given by asynchronous write requests.
  * F2FS_IPU_NOCACHE - disable IPU bio cache.
- * F2FS_IPUT_DISABLE - disable IPU. (=default option in LFS mode)
+ * F2FS_IPU_HONOR_OPU_WRITE - use OPU write prior to IPU write if inode has
+ *                            FI_OPU_WRITE flag.
+ * F2FS_IPU_DISABLE - disable IPU. (=default option in LFS mode)
  */
 #define DEF_MIN_IPU_UTIL       70
 #define DEF_MIN_FSYNC_BLOCKS   8
@@ -681,6 +683,7 @@ enum {
        F2FS_IPU_FSYNC,
        F2FS_IPU_ASYNC,
        F2FS_IPU_NOCACHE,
+       F2FS_IPU_HONOR_OPU_WRITE,
 };
 
 static inline unsigned int curseg_segno(struct f2fs_sb_info *sbi,

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 706d7adda3b22b22ba7cd3ef257efacf96c5f2f4..17615eb833e0c8ce2d7691b9290dc52b4696c7a8 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -3971,7 +3971,8 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
                F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
                if (f2fs_block_unit_discard(sbi))
                        sm_i->dcc_info->discard_granularity = 1;
-               sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
+               sm_i->ipu_policy = 1 << F2FS_IPU_FORCE |
+                                       1 << F2FS_IPU_HONOR_OPU_WRITE;
        }
 
        sbi->readdir_ra = 1;