Try to support compressed file write and amplifiction accounting.
Signed-off-by: Fengnan Chang <[email protected]>
---
fs/f2fs/compress.c | 7 +++++--
fs/f2fs/data.c | 44 ++++++++++++++++++++++++++++++++++++--------
fs/f2fs/debug.c | 7 +++++--
fs/f2fs/f2fs.h | 36 +++++++++++++++++++++++++++++++++++-
4 files changed, 81 insertions(+), 13 deletions(-)
diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c
index 0eca4e060deb..374d4a73ab2c 100644
--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -1125,7 +1125,7 @@ static int prepare_compress_overwrite(struct compress_ctx
*cc,
sector_t last_block_in_bio;
unsigned fgp_flag = FGP_LOCK | FGP_WRITE | FGP_CREAT;
pgoff_t start_idx = start_idx_of_cluster(cc);
- int i, ret;
+ int i, ret, once_read = 0;
retry:
ret = f2fs_is_compressed_cluster(cc->inode, start_idx);
@@ -1155,13 +1155,16 @@ static int prepare_compress_overwrite(struct
compress_ctx *cc,
struct bio *bio = NULL;
ret = f2fs_read_multi_pages(cc, &bio, cc->cluster_size,
- &last_block_in_bio, false, true);
+ &last_block_in_bio, false, true,
&once_read);
f2fs_put_rpages(cc);
f2fs_destroy_compress_ctx(cc, true);
if (ret)
goto out;
if (bio)
f2fs_submit_bio(sbi, bio, DATA);
+ /* All need read page in here is read amplification */
+ if (once_read)
+ f2fs_i_compr_ra_blocks_update(cc->inode, once_read,
true);
ret = f2fs_init_compress_ctx(cc);
if (ret)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 0b159c555069..9bedcea189eb 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2133,7 +2133,7 @@ static int f2fs_read_single_page(struct inode *inode,
struct page *page,
#ifdef CONFIG_F2FS_FS_COMPRESSION
int f2fs_read_multi_pages(struct compress_ctx *cc, struct bio **bio_ret,
unsigned nr_pages, sector_t *last_block_in_bio,
- bool is_readahead, bool for_write)
+ bool is_readahead, bool for_write, int
*nr_need_read)
{
struct dnode_of_data dn;
struct inode *inode = cc->inode;
@@ -2146,7 +2146,10 @@ int f2fs_read_multi_pages(struct compress_ctx *cc,
struct bio **bio_ret,
struct extent_info ei = {0, };
bool from_dnode = true;
int i;
- int ret = 0;
+ int ret = 0, nr_cache_hit = 0;
+
+ if (nr_need_read)
+ *nr_need_read = 0;
f2fs_bug_on(sbi, f2fs_cluster_is_empty(cc));
@@ -2237,6 +2240,7 @@ int f2fs_read_multi_pages(struct compress_ctx *cc, struct
bio **bio_ret,
if (f2fs_load_compressed_page(sbi, page, blkaddr)) {
if (atomic_dec_and_test(&dic->remaining_pages))
f2fs_decompress_cluster(dic, true);
+ nr_cache_hit++;
continue;
}
@@ -2275,6 +2279,10 @@ int f2fs_read_multi_pages(struct compress_ctx *cc,
struct bio **bio_ret,
*last_block_in_bio = blkaddr;
}
+ /* we need read whole cluster when nr_cache_hit less than nr_cpages */
+ if (nr_need_read && nr_cache_hit < cc->nr_cpages)
+ *nr_need_read = cc->nr_cpages;
+
if (from_dnode)
f2fs_put_dnode(&dn);
@@ -2322,7 +2330,7 @@ static int f2fs_mpage_readpages(struct inode *inode,
#endif
unsigned nr_pages = rac ? readahead_count(rac) : 1;
unsigned max_nr_pages = nr_pages;
- int ret = 0;
+ int ret = 0, once_read = 0, total_read = 0, single_read = 0;
map.m_pblk = 0;
map.m_lblk = 0;
@@ -2346,10 +2354,11 @@ static int f2fs_mpage_readpages(struct inode *inode,
ret = f2fs_read_multi_pages(&cc, &bio,
max_nr_pages,
&last_block_in_bio,
- rac != NULL, false);
+ rac != NULL, false,
&once_read);
f2fs_destroy_compress_ctx(&cc, false);
if (ret)
goto set_error_page;
+ total_read += once_read;
}
if (cc.cluster_idx == NULL_CLUSTER) {
if (nc_cluster_idx ==
@@ -2389,6 +2398,7 @@ static int f2fs_mpage_readpages(struct inode *inode,
zero_user_segment(page, 0, PAGE_SIZE);
unlock_page(page);
}
+ single_read++;
#ifdef CONFIG_F2FS_FS_COMPRESSION
next_page:
#endif
@@ -2402,12 +2412,23 @@ static int f2fs_mpage_readpages(struct inode *inode,
ret = f2fs_read_multi_pages(&cc, &bio,
max_nr_pages,
&last_block_in_bio,
- rac != NULL, false);
+ rac != NULL, false,
&once_read);
f2fs_destroy_compress_ctx(&cc, false);
+ if (!ret)
+ total_read += once_read;
}
}
#endif
}
+ max_nr_pages -= single_read;
+ if (total_read > max_nr_pages)
+ f2fs_i_compr_ra_blocks_update(inode,
+ total_read - max_nr_pages,
+ true);
+ else
+ f2fs_i_compr_ra_blocks_update(inode,
+ max_nr_pages - total_read,
+ false);
if (bio)
__submit_bio(F2FS_I_SB(inode), bio, DATA);
return ret;
@@ -2944,11 +2965,11 @@ static int f2fs_write_cache_pages(struct address_space
*mapping,
int range_whole = 0;
xa_mark_t tag;
int nwritten = 0;
- int submitted = 0;
+ int submitted = 0, raw_dirty_pages = 0;
int i;
- if (get_dirty_pages(mapping->host) <=
- SM_I(F2FS_M_SB(mapping))->min_hot_blocks)
+ raw_dirty_pages = get_dirty_pages(mapping->host);
+ if (raw_dirty_pages <= SM_I(F2FS_M_SB(mapping))->min_hot_blocks)
set_inode_flag(mapping->host, FI_HOT_DATA);
else
clear_inode_flag(mapping->host, FI_HOT_DATA);
@@ -3148,6 +3169,12 @@ static int f2fs_write_cache_pages(struct address_space
*mapping,
if (bio)
f2fs_submit_merged_ipu_write(sbi, &bio, NULL);
+ if (f2fs_compressed_file(inode)) {
+ if (nwritten > raw_dirty_pages)
+ f2fs_i_compr_wa_blocks_update(inode, nwritten -
raw_dirty_pages, true);
+ else
+ f2fs_i_compr_wa_blocks_update(inode, raw_dirty_pages -
nwritten, false);
+ }
return ret;
}
@@ -3498,6 +3525,7 @@ static int f2fs_write_begin(struct file *file, struct
address_space *mapping,
err = ret;
goto fail;
} else if (ret) {
+ f2fs_i_compr_wa_blocks_update(inode, ret - 1, true);
return 0;
}
}
diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index c01471573977..e6b943edba91 100644
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -136,6 +136,8 @@ static void update_general_status(struct f2fs_sb_info *sbi)
si->inline_dir = atomic_read(&sbi->inline_dir);
si->compr_inode = atomic_read(&sbi->compr_inode);
si->compr_blocks = atomic64_read(&sbi->compr_blocks);
+ si->compr_wa_blocks = atomic64_read(&sbi->compr_wa_blocks);
+ si->compr_ra_blocks = atomic64_read(&sbi->compr_ra_blocks);
si->append = sbi->im[APPEND_INO].ino_num;
si->update = sbi->im[UPDATE_INO].ino_num;
si->orphans = sbi->im[ORPHAN_INO].ino_num;
@@ -383,8 +385,9 @@ static int stat_show(struct seq_file *s, void *v)
si->inline_inode);
seq_printf(s, " - Inline_dentry Inode: %u\n",
si->inline_dir);
- seq_printf(s, " - Compressed Inode: %u, Blocks: %llu\n",
- si->compr_inode, si->compr_blocks);
+ seq_printf(s, " - Compressed Inode: %u, Blocks: %llu, WA
Blocks: %lld, RA Blocks %lld\n",
+ si->compr_inode, si->compr_blocks,
+ si->compr_wa_blocks, si->compr_ra_blocks);
seq_printf(s, " - Orphan/Append/Update Inode: %u, %u, %u\n",
si->orphans, si->append, si->update);
seq_printf(s, "\nMain area: %d segs, %d secs %d zones\n",
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 955dbf4f83ad..c549be2e75af 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1761,6 +1761,8 @@ struct f2fs_sb_info {
atomic_t inline_dir; /* # of inline_dentry inodes */
atomic_t compr_inode; /* # of compressed inodes */
atomic64_t compr_blocks; /* # of compressed blocks */
+ atomic64_t compr_wa_blocks; /* # of compressed WA blocks */
+ atomic64_t compr_ra_blocks; /* # of compressed RA blocks */
atomic_t max_aw_cnt; /* max # of atomic writes */
unsigned int io_skip_bggc; /* skip background gc for
in-flight IO */
unsigned int other_skip_bggc; /* skip background gc for other
reasons */
@@ -3859,6 +3861,8 @@ struct f2fs_stat_info {
int inline_xattr, inline_inode, inline_dir, append, update, orphans;
int compr_inode;
unsigned long long compr_blocks;
+ long long compr_wa_blocks;
+ long long compr_ra_blocks;
int aw_cnt, max_aw_cnt;
unsigned int valid_count, valid_node_count, valid_inode_count,
discard_blks;
unsigned int bimodal, avg_vblocks;
@@ -3946,6 +3950,14 @@ static inline struct f2fs_stat_info *F2FS_STAT(struct
f2fs_sb_info *sbi)
(atomic64_add(blocks, &F2FS_I_SB(inode)->compr_blocks))
#define stat_sub_compr_blocks(inode, blocks) \
(atomic64_sub(blocks, &F2FS_I_SB(inode)->compr_blocks))
+#define stat_add_compr_wa_blocks(inode, blocks)
\
+ (atomic64_add(blocks, &F2FS_I_SB(inode)->compr_wa_blocks))
+#define stat_sub_compr_wa_blocks(inode, blocks)
\
+ (atomic64_sub(blocks, &F2FS_I_SB(inode)->compr_wa_blocks))
+#define stat_add_compr_ra_blocks(inode, blocks)
\
+ (atomic64_add(blocks, &F2FS_I_SB(inode)->compr_ra_blocks))
+#define stat_sub_compr_ra_blocks(inode, blocks)
\
+ (atomic64_sub(blocks, &F2FS_I_SB(inode)->compr_ra_blocks))
#define stat_inc_meta_count(sbi, blkaddr) \
do { \
if (blkaddr < SIT_I(sbi)->sit_base_addr) \
@@ -4030,6 +4042,10 @@ void f2fs_update_sit_info(struct f2fs_sb_info *sbi);
#define stat_dec_compr_inode(inode) do { } while (0)
#define stat_add_compr_blocks(inode, blocks) do { } while (0)
#define stat_sub_compr_blocks(inode, blocks) do { } while (0)
+#define stat_add_compr_wa_blocks(inode, blocks) do { } while (0)
+#define stat_sub_compr_wa_blocks(inode, blocks) do { } while (0)
+#define stat_add_compr_ra_blocks(inode, blocks) do { } while (0)
+#define stat_sub_compr_ra_blocks(inode, blocks) do { } while (0)
#define stat_update_max_atomic_write(inode) do { } while (0)
#define stat_inc_meta_count(sbi, blkaddr) do { } while (0)
#define stat_inc_seg_type(sbi, curseg) do { } while (0)
@@ -4209,7 +4225,7 @@ void f2fs_update_extent_tree_range_compressed(struct
inode *inode,
unsigned int c_len);
int f2fs_read_multi_pages(struct compress_ctx *cc, struct bio **bio_ret,
unsigned nr_pages, sector_t *last_block_in_bio,
- bool is_readahead, bool for_write);
+ bool is_readahead, bool for_write, int
*nr_need_read);
struct decompress_io_ctx *f2fs_alloc_dic(struct compress_ctx *cc);
void f2fs_decompress_end_io(struct decompress_io_ctx *dic, bool failed,
bool in_task);
@@ -4465,6 +4481,24 @@ static inline void f2fs_i_compr_blocks_update(struct
inode *inode,
f2fs_mark_inode_dirty_sync(inode, true);
}
+static inline void f2fs_i_compr_wa_blocks_update(struct inode *inode,
+ u64 blocks, bool add)
+{
+ if (add)
+ stat_add_compr_wa_blocks(inode, blocks);
+ else
+ stat_sub_compr_wa_blocks(inode, blocks);
+}
+
+static inline void f2fs_i_compr_ra_blocks_update(struct inode *inode,
+ u64 blocks, bool add)
+{
+ if (add)
+ stat_add_compr_ra_blocks(inode, blocks);
+ else
+ stat_sub_compr_ra_blocks(inode, blocks);
+}
+
static inline int block_unaligned_IO(struct inode *inode,
struct kiocb *iocb, struct iov_iter *iter)
{
--
2.25.1
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
