f2fs: fix to account FS_CP_DATA_IO correctly

[ Upstream commit d80afefb17e01aa0c46a8eebc01882e0ebd8b0f6 ]

f2fs_inode_info.cp_task was introduced for FS_CP_DATA_IO accounting
since commit b0af6d491a6b ("f2fs: add app/fs io stat").

However, cp_task usage coverage has been increased due to below
commits:
commit 040d2bb318d1 ("f2fs: fix to avoid deadloop if data_flush is on")
commit 186857c5a14a ("f2fs: fix potential recursive call when enabling data_flush")

So that, if data_flush mountoption is on, when data flush was
triggered from background, the IO from data flush will be accounted
as checkpoint IO type incorrectly.

In order to fix this issue, this patch splits cp_task into two:
a) cp_task: used for IO accounting
b) wb_task: used to avoid deadlock

Fixes: 040d2bb318d1 ("f2fs: fix to avoid deadloop if data_flush is on")
Fixes: 186857c5a14a ("f2fs: fix potential recursive call when enabling data_flush")
Signed-off-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 2917299d45c000bd83863887688bdb5a31d1a31d..02840dadde5d4595be3071e7d6bb067bf4613380 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -1062,7 +1062,8 @@ void f2fs_remove_dirty_inode(struct inode *inode)
        spin_unlock(&sbi->inode_lock[type]);
 }
 
-int f2fs_sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type)
+int f2fs_sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type,
+                                               bool from_cp)
 {
        struct list_head *head;
        struct inode *inode;
@@ -1097,11 +1098,15 @@ retry:
        if (inode) {
                unsigned long cur_ino = inode->i_ino;
 
-               F2FS_I(inode)->cp_task = current;
+               if (from_cp)
+                       F2FS_I(inode)->cp_task = current;
+               F2FS_I(inode)->wb_task = current;
 
                filemap_fdatawrite(inode->i_mapping);
 
-               F2FS_I(inode)->cp_task = NULL;
+               F2FS_I(inode)->wb_task = NULL;
+               if (from_cp)
+                       F2FS_I(inode)->cp_task = NULL;
 
                iput(inode);
                /* We need to give cpu to another writers. */
@@ -1230,7 +1235,7 @@ retry_flush_dents:
        /* write all the dirty dentry pages */
        if (get_pages(sbi, F2FS_DIRTY_DENTS)) {
                f2fs_unlock_all(sbi);
-               err = f2fs_sync_dirty_inodes(sbi, DIR_INODE);
+               err = f2fs_sync_dirty_inodes(sbi, DIR_INODE, true);
                if (err)
                        return err;
                cond_resched();

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 4cf522120cb1adf9ad2bb0b950d5f6b0c0ee6dd6..cfa6e1322e46f840952cd0cde307389599e8a3a4 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2862,7 +2862,7 @@ out:
        }
        unlock_page(page);
        if (!S_ISDIR(inode->i_mode) && !IS_NOQUOTA(inode) &&
-                       !F2FS_I(inode)->cp_task && allow_balance)
+                       !F2FS_I(inode)->wb_task && allow_balance)
                f2fs_balance_fs(sbi, need_balance_fs);
 
        if (unlikely(f2fs_cp_error(sbi))) {
@@ -3160,7 +3160,7 @@ static inline bool __should_serialize_io(struct inode *inode,
                                        struct writeback_control *wbc)
 {
        /* to avoid deadlock in path of data flush */
-       if (F2FS_I(inode)->cp_task)
+       if (F2FS_I(inode)->wb_task)
                return false;
 
        if (!S_ISREG(inode->i_mode))

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 4caac78e2034701c9e033af803fba645c7fafb90..a144471c53166e8e82dcdba10cd50bba51b0861b 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -749,6 +749,7 @@ struct f2fs_inode_info {
        unsigned int clevel;            /* maximum level of given file name */
        struct task_struct *task;       /* lookup and create consistency */
        struct task_struct *cp_task;    /* separate cp/wb IO stats*/
+       struct task_struct *wb_task;    /* indicate inode is in context of writeback */
        nid_t i_xattr_nid;              /* node id that contains xattrs */
        loff_t  last_disk_size;         /* lastly written file size */
        spinlock_t i_size_lock;         /* protect last_disk_size */
@@ -3573,7 +3574,8 @@ int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi);
 int f2fs_get_valid_checkpoint(struct f2fs_sb_info *sbi);
 void f2fs_update_dirty_page(struct inode *inode, struct page *page);
 void f2fs_remove_dirty_inode(struct inode *inode);
-int f2fs_sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type);
+int f2fs_sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type,
+                                                               bool from_cp);
 void f2fs_wait_on_all_pages(struct f2fs_sb_info *sbi, int type);
 u64 f2fs_get_sectors_written(struct f2fs_sb_info *sbi);
 int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc);

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index e98c90bd8ef6d1c6cd642507fac81b3742211a89..af810b2d5d904e07baf504191f931fee112904db 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -575,7 +575,7 @@ do_sync:
                mutex_lock(&sbi->flush_lock);
 
                blk_start_plug(&plug);
-               f2fs_sync_dirty_inodes(sbi, FILE_INODE);
+               f2fs_sync_dirty_inodes(sbi, FILE_INODE, false);
                blk_finish_plug(&plug);
 
                mutex_unlock(&sbi->flush_lock);