f2fs: compress: fix to guarantee persisting compressed blocks by CP

[ Upstream commit 8a430dd49e9cb021372b0ad91e60aeef9c6ced00 ]

If data block in compressed cluster is not persisted with metadata
during checkpoint, after SPOR, the data may be corrupted, let's
guarantee to write compressed page by checkpoint.

Fixes: 4c8ff7095bef ("f2fs: support data compression")
Reviewed-by: Daeho Jeong <daehojeong@google.com>
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/compress.c b/fs/f2fs/compress.c
index 7d85db7208e14d43c994b9019c64db1e8fc9fef4..459bf10f297a2be4477f7c2a3510c5d4673a0434 100644 (file)
--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -1437,6 +1437,8 @@ void f2fs_compress_write_end_io(struct bio *bio, struct page *page)
        struct f2fs_sb_info *sbi = bio->bi_private;
        struct compress_io_ctx *cic =
                        (struct compress_io_ctx *)page_private(page);
+       enum count_type type = WB_DATA_TYPE(page,
+                               f2fs_is_compressed_page(page));
        int i;
 
        if (unlikely(bio->bi_status))
@@ -1444,7 +1446,7 @@ void f2fs_compress_write_end_io(struct bio *bio, struct page *page)
 
        f2fs_compress_free_page(page);
 
-       dec_page_count(sbi, F2FS_WB_DATA);
+       dec_page_count(sbi, type);
 
        if (atomic_dec_return(&cic->pending_pages))
                return;

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 7b3eb192f9c031597ea0453f448342fddcd2e7cd..6f649a60859fcd31d4d85c0cb431b99769d77c31 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -50,7 +50,7 @@ void f2fs_destroy_bioset(void)
        bioset_exit(&f2fs_bioset);
 }
 
-static bool __is_cp_guaranteed(struct page *page)
+bool f2fs_is_cp_guaranteed(struct page *page)
 {
        struct address_space *mapping = page->mapping;
        struct inode *inode;
@@ -67,8 +67,6 @@ static bool __is_cp_guaranteed(struct page *page)
                        S_ISDIR(inode->i_mode))
                return true;
 
-       if (f2fs_is_compressed_page(page))
-               return false;
        if ((S_ISREG(inode->i_mode) && IS_NOQUOTA(inode)) ||
                        page_private_gcing(page))
                return true;
@@ -327,7 +325,7 @@ static void f2fs_write_end_io(struct bio *bio)
 
        bio_for_each_segment_all(bvec, bio, iter_all) {
                struct page *page = bvec->bv_page;
-               enum count_type type = WB_DATA_TYPE(page);
+               enum count_type type = WB_DATA_TYPE(page, false);
 
                if (page_private_dummy(page)) {
                        clear_page_private_dummy(page);
@@ -733,7 +731,7 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio)
                wbc_account_cgroup_owner(fio->io_wbc, fio->page, PAGE_SIZE);
 
        inc_page_count(fio->sbi, is_read_io(fio->op) ?
-                       __read_io_type(page) : WB_DATA_TYPE(fio->page));
+                       __read_io_type(page) : WB_DATA_TYPE(fio->page, false));
 
        __submit_bio(fio->sbi, bio, fio->type);
        return 0;
@@ -941,7 +939,7 @@ int f2fs_merge_page_bio(struct f2fs_io_info *fio)
        if (fio->io_wbc)
                wbc_account_cgroup_owner(fio->io_wbc, fio->page, PAGE_SIZE);
 
-       inc_page_count(fio->sbi, WB_DATA_TYPE(page));
+       inc_page_count(fio->sbi, WB_DATA_TYPE(page, false));
 
        *fio->last_block = fio->new_blkaddr;
        *fio->bio = bio;
@@ -955,6 +953,7 @@ void f2fs_submit_page_write(struct f2fs_io_info *fio)
        enum page_type btype = PAGE_TYPE_OF_BIO(fio->type);
        struct f2fs_bio_info *io = sbi->write_io[btype] + fio->temp;
        struct page *bio_page;
+       enum count_type type;
 
        f2fs_bug_on(sbi, is_read_io(fio->op));
 
@@ -984,7 +983,8 @@ void f2fs_submit_page_write(struct f2fs_io_info *fio)
        /* set submitted = true as a return value */
        fio->submitted = 1;
 
-       inc_page_count(sbi, WB_DATA_TYPE(bio_page));
+       type = WB_DATA_TYPE(bio_page, fio->compressed_page);
+       inc_page_count(sbi, type);
 
        if (io->bio &&
            (!io_is_mergeable(sbi, io->bio, io, fio, io->last_block_in_bio,
@@ -997,7 +997,8 @@ void f2fs_submit_page_write(struct f2fs_io_info *fio)
                if (F2FS_IO_ALIGNED(sbi) &&
                                (fio->type == DATA || fio->type == NODE) &&
                                fio->new_blkaddr & F2FS_IO_SIZE_MASK(sbi)) {
-                       dec_page_count(sbi, WB_DATA_TYPE(bio_page));
+                       dec_page_count(sbi, WB_DATA_TYPE(bio_page,
+                                               fio->compressed_page));
                        fio->retry = 1;
                        goto skip;
                }

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 1d78bca5037f49910226cb8ab59b4b6d99a4d8ac..16dacf811481cac4b499c3a43cf96e358dd944c1 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1067,7 +1067,8 @@ struct f2fs_sm_info {
  * f2fs monitors the number of several block types such as on-writeback,
  * dirty dentry blocks, dirty node blocks, and dirty meta blocks.
  */
-#define WB_DATA_TYPE(p)        (__is_cp_guaranteed(p) ? F2FS_WB_CP_DATA : F2FS_WB_DATA)
+#define WB_DATA_TYPE(p, f)                     \
+       (f || f2fs_is_cp_guaranteed(p) ? F2FS_WB_CP_DATA : F2FS_WB_DATA)
 enum count_type {
        F2FS_DIRTY_DENTS,
        F2FS_DIRTY_DATA,
@@ -3761,6 +3762,7 @@ void f2fs_init_ckpt_req_control(struct f2fs_sb_info *sbi);
  */
 int __init f2fs_init_bioset(void);
 void f2fs_destroy_bioset(void);
+bool f2fs_is_cp_guaranteed(struct page *page);
 int f2fs_init_bio_entry_cache(void);
 void f2fs_destroy_bio_entry_cache(void);
 void f2fs_submit_bio(struct f2fs_sb_info *sbi,