f2fs: introduce F2FS_IPU_HONOR_OPU_WRITE ipu policy

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>

diff --git a/Documentation/ABI/testing/sysfs-fs-f2fs b/Documentation/ABI/testing/sysfs-fs-f2fs
index 87d3884c90ea668d34945cda2d29ac2673693f5b..7b50bf82f14dd044ede405f1d64c37200f4c2fe8 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 0f124e8de1d4e09ac78b4612bd988a459fdf195a..6b5f389ba998b5217b8eec01fc5b1a2a2172f561 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2460,6 +2460,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))
@@ -2530,6 +2533,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;
@@ -3154,8 +3160,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);
@@ -3725,6 +3731,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++) {
                f2fs_down_write(&sbi->pin_sem);
@@ -3733,7 +3740,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;
@@ -3750,7 +3757,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);
 
@@ -3761,7 +3768,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 51c1392708e6e0b2d1feb6786b90102e5da14ffd..3b4bf1c3f1ed64fa2fbee09ffe9f03f2857d4431 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -740,7 +740,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_PREALLOCATED_ALL,    /* all blocks for write were preallocated */
        FI_HOT_DATA,            /* indicate file is hot */

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 6ccdd6e347e2cbb04a91362deee22419febce4d9..42fbdcf0ccc9bfc6a92e2fb2ab932f3cb78c80d0 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -2559,10 +2559,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;
 
@@ -2570,6 +2566,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);
@@ -2651,7 +2654,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) {
@@ -2676,15 +2679,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 0291cd55cf09b314610c9ccef89f8d53e77492e2..5c94caf0c0a1d7ea871bf1bcb7b768a2bb5621a3 100644 (file)
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -651,7 +651,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
@@ -667,6 +669,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 9af6c20532eced7e120b2b4211cd728dfc9a7187..806836184ebc9b2e80ec18ec1fa02dd3a960d161 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -3957,7 +3957,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;