f2fs: use meta inode for GC of atomic file

The page cache of the atomic file keeps new data pages which will be
stored in the COW file. It can also keep old data pages when GCing the
atomic file. In this case, new data can be overwritten by old data if a
GC thread sets the old data page as dirty after new data page was
evicted.

Also, since all writes to the atomic file are redirected to COW inodes,
GC for the atomic file is not working well as below.

f2fs_gc(gc_type=FG_GC)
  - select A as a victim segment
  do_garbage_collect
    - iget atomic file's inode for block B
    move_data_page
      f2fs_do_write_data_page
        - use dn of cow inode
        - set fio->old_blkaddr from cow inode
    - seg_freed is 0 since block B is still valid
  - goto gc_more and A is selected as victim again

To solve the problem, let's separate GC writes and updates in the atomic
file by using the meta inode for GC writes.

Fixes: 3db1de0e582c ("f2fs: change the current atomic write way")
Cc: stable@vger.kernel.org #v5.19+
Reviewed-by: Sungjong Seo <sj1557.seo@samsung.com>
Reviewed-by: Yeongjin Gil <youngjin.gil@samsung.com>
Signed-off-by: Sunmin Jeong <s_min.jeong@samsung.com>
Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 1aa7eefa659cbe998548aaca45ad1c5bc084919a..1e4937af50f362aa5441247e135b6475d4df0ca4 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2695,7 +2695,7 @@ got_it:
        }
 
        /* wait for GCed page writeback via META_MAPPING */
-       if (fio->post_read)
+       if (fio->meta_gc)
                f2fs_wait_on_block_writeback(inode, fio->old_blkaddr);
 
        /*
@@ -2790,7 +2790,7 @@ int f2fs_write_single_data_page(struct page *page, int *submitted,
                .submitted = 0,
                .compr_blocks = compr_blocks,
                .need_lock = compr_blocks ? LOCK_DONE : LOCK_RETRY,
-               .post_read = f2fs_post_read_required(inode) ? 1 : 0,
+               .meta_gc = f2fs_meta_inode_gc_required(inode) ? 1 : 0,
                .io_type = io_type,
                .io_wbc = wbc,
                .bio = bio,

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index f7ee6c5e371e5d370f091f4d746d744123dd62f9..796ae11c0fa3680df52e091dfd6ba43c5ce1e969 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1211,7 +1211,7 @@ struct f2fs_io_info {
        unsigned int in_list:1;         /* indicate fio is in io_list */
        unsigned int is_por:1;          /* indicate IO is from recovery or not */
        unsigned int encrypted:1;       /* indicate file is encrypted */
-       unsigned int post_read:1;       /* require post read */
+       unsigned int meta_gc:1;         /* require meta inode GC */
        enum iostat_type io_type;       /* io type */
        struct writeback_control *io_wbc; /* writeback control */
        struct bio **bio;               /* bio for ipu */
@@ -4263,6 +4263,11 @@ static inline bool f2fs_post_read_required(struct inode *inode)
                f2fs_compressed_file(inode);
 }
 
+static inline bool f2fs_meta_inode_gc_required(struct inode *inode)
+{
+       return f2fs_post_read_required(inode) || f2fs_is_atomic_file(inode);
+}
+
 /*
  * compress.c
  */

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index ef667fec9a125767089d88259d023c9e4924de12..cb3006551ab55ef98e81c0eb8685004a3e9d5df6 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1589,7 +1589,7 @@ next_step:
                        start_bidx = f2fs_start_bidx_of_node(nofs, inode) +
                                                                ofs_in_node;
 
-                       if (f2fs_post_read_required(inode)) {
+                       if (f2fs_meta_inode_gc_required(inode)) {
                                int err = ra_data_block(inode, start_bidx);
 
                                f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
@@ -1640,7 +1640,7 @@ next_step:
 
                        start_bidx = f2fs_start_bidx_of_node(nofs, inode)
                                                                + ofs_in_node;
-                       if (f2fs_post_read_required(inode))
+                       if (f2fs_meta_inode_gc_required(inode))
                                err = move_data_block(inode, start_bidx,
                                                        gc_type, segno, off);
                        else
@@ -1648,7 +1648,7 @@ next_step:
                                                                segno, off);
 
                        if (!err && (gc_type == FG_GC ||
-                                       f2fs_post_read_required(inode)))
+                                       f2fs_meta_inode_gc_required(inode)))
                                submitted++;
 
                        if (locked) {

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 64b11d88a21c38bb2f12c6c4d616745dae423750..78c3198a6308f528594254995473c15feede7d9d 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -3859,7 +3859,7 @@ int f2fs_inplace_write_data(struct f2fs_io_info *fio)
                goto drop_bio;
        }
 
-       if (fio->post_read)
+       if (fio->meta_gc)
                f2fs_truncate_meta_inode_pages(sbi, fio->new_blkaddr, 1);
 
        stat_inc_inplace_blocks(fio->sbi);
@@ -4029,7 +4029,7 @@ void f2fs_wait_on_block_writeback(struct inode *inode, block_t blkaddr)
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct page *cpage;
 
-       if (!f2fs_post_read_required(inode))
+       if (!f2fs_meta_inode_gc_required(inode))
                return;
 
        if (!__is_valid_data_blkaddr(blkaddr))
@@ -4048,7 +4048,7 @@ void f2fs_wait_on_block_writeback_range(struct inode *inode, block_t blkaddr,
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        block_t i;
 
-       if (!f2fs_post_read_required(inode))
+       if (!f2fs_meta_inode_gc_required(inode))
                return;
 
        for (i = 0; i < len; i++)