Re: [RFC PATCH v3] f2fs: support data compression
From: Jaegeuk Kim
Date: Fri Nov 01 2019 - 12:28:59 EST
On 11/01, Chao Yu wrote:
> This patch tries to support compression in f2fs.
>
> - New term named cluster is defined as basic unit of compression, file can
> be divided into multiple clusters logically. One cluster includes 4 << n
> (n >= 0) logical pages, compression size is also cluster size, each of
> cluster can be compressed or not.
>
> - In cluster metadata layout, one special flag is used to indicate cluster
> is compressed one or normal one, for compressed cluster, following metadata
> maps cluster to [1, 4 << n - 1] physical blocks, in where f2fs stores
> data including compress header and compressed data.
>
> - In order to eliminate write amplification during overwrite, F2FS only
> support compression on write-once file, data can be compressed only when
> all logical blocks in file are valid and cluster compress ratio is lower
> than specified threshold.
>
> - To enable compression on regular inode, there are three ways:
> * chattr +c file
> * chattr +c dir; touch dir/file
> * mount w/ -o compress_extension=ext; touch file.ext
>
> Compress metadata layout:
> [Dnode Structure]
> +-----------------------------------------------+
> | cluster 1 | cluster 2 | ......... | cluster N |
> +-----------------------------------------------+
> . . . .
> . . . .
> . Compressed Cluster . . Normal Cluster .
> +----------+---------+---------+---------+ +---------+---------+---------+---------+
> |compr flag| block 1 | block 2 | block 3 | | block 1 | block 2 | block 3 | block 4 |
> +----------+---------+---------+---------+ +---------+---------+---------+---------+
> . .
> . .
> . .
> +-------------+-------------+----------+----------------------------+
> | data length | data chksum | reserved | compressed data |
> +-------------+-------------+----------+----------------------------+
>
> Changelog:
>
> 20190326:
> - fix error handling of read_end_io().
> - remove unneeded comments in f2fs_encrypt_one_page().
>
> 20190327:
> - fix wrong use of f2fs_cluster_is_full() in f2fs_mpage_readpages().
> - don't jump into loop directly to avoid uninitialized variables.
> - add TODO tag in error path of f2fs_write_cache_pages().
>
> 20190328:
> - fix wrong merge condition in f2fs_read_multi_pages().
> - check compressed file in f2fs_post_read_required().
>
> 20190401
> - allow overwrite on non-compressed cluster.
> - check cluster meta before writing compressed data.
>
> 20190402
> - don't preallocate blocks for compressed file.
>
> - add lz4 compress algorithm
> - process multiple post read works in one workqueue
> Now f2fs supports processing post read work in multiple workqueue,
> it shows low performance due to schedule overhead of multiple
> workqueue executing orderly.
>
> 20190921
> - compress: support buffered overwrite
> C: compress cluster flag
> V: valid block address
> N: NEW_ADDR
>
> One cluster contain 4 blocks
>
> before overwrite after overwrite
>
> - VVVV -> CVNN
> - CVNN -> VVVV
>
> - CVNN -> CVNN
> - CVNN -> CVVV
>
> - CVVV -> CVNN
> - CVVV -> CVVV
>
> 20191029
> - add kconfig F2FS_FS_COMPRESSION to isolate compression related
> codes, add kconfig F2FS_FS_{LZO,LZ4} to cover backend algorithm.
> note that: will remove lzo backend if Jaegeuk agreed that too.
> - update codes according to Eric's comments.
>
> 20191101
> - apply fixes from Jaegeuk
>
> [Jaegeuk Kim]
> - add tracepoint for f2fs_{,de}compress_pages()
> - fix many bugs and add some compression stats
>
> Signed-off-by: Chao Yu <yuchao0@xxxxxxxxxx>
> Signed-off-by: Jaegeuk Kim <jaegeuk@xxxxxxxxxx>
> ---
> Documentation/filesystems/f2fs.txt | 52 ++
> fs/f2fs/Kconfig | 23 +
> fs/f2fs/Makefile | 1 +
> fs/f2fs/compress.c | 1098 ++++++++++++++++++++++++++++
> fs/f2fs/data.c | 549 ++++++++++++--
> fs/f2fs/debug.c | 6 +
> fs/f2fs/f2fs.h | 245 ++++++-
> fs/f2fs/file.c | 191 ++++-
> fs/f2fs/inode.c | 43 ++
> fs/f2fs/namei.c | 59 ++
> fs/f2fs/segment.c | 5 +-
> fs/f2fs/segment.h | 12 -
> fs/f2fs/super.c | 112 ++-
> fs/f2fs/sysfs.c | 7 +
> include/linux/f2fs_fs.h | 11 +
> include/trace/events/f2fs.h | 99 +++
> 16 files changed, 2397 insertions(+), 116 deletions(-)
> create mode 100644 fs/f2fs/compress.c
>
> diff --git a/Documentation/filesystems/f2fs.txt b/Documentation/filesystems/f2fs.txt
> index 29020af0cff9..228af93f850b 100644
> --- a/Documentation/filesystems/f2fs.txt
> +++ b/Documentation/filesystems/f2fs.txt
> @@ -235,6 +235,17 @@ checkpoint=%s[:%u[%]] Set to "disable" to turn off checkpointing. Set to "en
> hide up to all remaining free space. The actual space that
> would be unusable can be viewed at /sys/fs/f2fs/<disk>/unusable
> This space is reclaimed once checkpoint=enable.
> +compress_algorithm=%s Control compress algorithm, currently f2fs supports "lzo"
> + and "lz4" algorithm.
> +compress_log_size=%u Support configuring compress cluster size, the size will
> + be 4KB * (1 << %u), 16KB is minimum size, also it's
> + default size.
> +compress_extension=%s Support adding specified extension, so that f2fs can enable
> + compression on those corresponding files, e.g. if all files
> + with '.ext' has high compression rate, we can set the '.ext'
> + on compression extension list and enable compression on
> + these file by default rather than to enable it via ioctl.
> + For other files, we can still enable compression via ioctl.
>
> ================================================================================
> DEBUGFS ENTRIES
> @@ -837,3 +848,44 @@ zero or random data, which is useful to the below scenario where:
> 4. address = fibmap(fd, offset)
> 5. open(blkdev)
> 6. write(blkdev, address)
> +
> +Compression implementation
> +--------------------------
> +
> +- New term named cluster is defined as basic unit of compression, file can
> +be divided into multiple clusters logically. One cluster includes 4 << n
> +(n >= 0) logical pages, compression size is also cluster size, each of
> +cluster can be compressed or not.
> +
> +- In cluster metadata layout, one special block address is used to indicate
> +cluster is compressed one or normal one, for compressed cluster, following
> +metadata maps cluster to [1, 4 << n - 1] physical blocks, in where f2fs
> +stores data including compress header and compressed data.
> +
> +- In order to eliminate write amplification during overwrite, F2FS only
> +support compression on write-once file, data can be compressed only when
> +all logical blocks in file are valid and cluster compress ratio is lower
> +than specified threshold.
> +
> +- To enable compression on regular inode, there are three ways:
> +* chattr +c file
> +* chattr +c dir; touch dir/file
> +* mount w/ -o compress_extension=ext; touch file.ext
> +
> +Compress metadata layout:
> + [Dnode Structure]
> + +-----------------------------------------------+
> + | cluster 1 | cluster 2 | ......... | cluster N |
> + +-----------------------------------------------+
> + . . . .
> + . . . .
> + . Compressed Cluster . . Normal Cluster .
> ++----------+---------+---------+---------+ +---------+---------+---------+---------+
> +|compr flag| block 1 | block 2 | block 3 | | block 1 | block 2 | block 3 | block 4 |
> ++----------+---------+---------+---------+ +---------+---------+---------+---------+
> + . .
> + . .
> + . .
> + +-------------+-------------+----------+----------------------------+
> + | data length | data chksum | reserved | compressed data |
> + +-------------+-------------+----------+----------------------------+
> diff --git a/fs/f2fs/Kconfig b/fs/f2fs/Kconfig
> index 652fd2e2b23d..6087a5577613 100644
> --- a/fs/f2fs/Kconfig
> +++ b/fs/f2fs/Kconfig
> @@ -92,3 +92,26 @@ config F2FS_FAULT_INJECTION
> Test F2FS to inject faults such as ENOMEM, ENOSPC, and so on.
>
> If unsure, say N.
> +
> +config F2FS_FS_COMPRESSION
> + bool "F2FS compression feature"
> + depends on F2FS_FS
> + help
> + Enable filesystem-level compression on f2fs regular files,
> + multiple back-end compression algorithms are supported.
> +
> +config F2FS_FS_LZO
> + bool "LZO compression support" if F2FS_FS_COMPRESSION
> + select LZO_COMPRESS
> + select LZO_DECOMPRESS
> + default y
> + help
> + Support LZO compress algorithm, if unsure, say Y.
> +
> +config F2FS_FS_LZ4
> + bool "LZ4 compression support" if F2FS_FS_COMPRESSION
> + select LZ4_COMPRESS
> + select LZ4_DECOMPRESS
> + default y
> + help
> + Support LZ4 compress algorithm, if unsure, say Y.
> diff --git a/fs/f2fs/Makefile b/fs/f2fs/Makefile
> index 2aaecc63834f..ee7316b42f69 100644
> --- a/fs/f2fs/Makefile
> +++ b/fs/f2fs/Makefile
> @@ -9,3 +9,4 @@ f2fs-$(CONFIG_F2FS_FS_XATTR) += xattr.o
> f2fs-$(CONFIG_F2FS_FS_POSIX_ACL) += acl.o
> f2fs-$(CONFIG_F2FS_IO_TRACE) += trace.o
> f2fs-$(CONFIG_FS_VERITY) += verity.o
> +f2fs-$(CONFIG_F2FS_FS_COMPRESSION) += compress.o
> diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c
> new file mode 100644
> index 000000000000..5e65aef72c46
> --- /dev/null
> +++ b/fs/f2fs/compress.c
> @@ -0,0 +1,1098 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * f2fs compress support
> + *
> + * Copyright (c) 2019 Chao Yu <chao@xxxxxxxxxx>
> + */
> +
> +#include <linux/fs.h>
> +#include <linux/f2fs_fs.h>
> +#include <linux/writeback.h>
> +#include <linux/lzo.h>
> +#include <linux/lz4.h>
> +
> +#include "f2fs.h"
> +#include "node.h"
> +#include <trace/events/f2fs.h>
> +
> +struct f2fs_compress_ops {
> + int (*init_compress_ctx)(struct compress_ctx *cc);
> + void (*destroy_compress_ctx)(struct compress_ctx *cc);
> + int (*compress_pages)(struct compress_ctx *cc);
> + int (*decompress_pages)(struct decompress_io_ctx *dic);
> +};
> +
> +static unsigned int offset_in_cluster(struct compress_ctx *cc, pgoff_t index)
> +{
> + return index & (cc->cluster_size - 1);
> +}
> +
> +static unsigned int cluster_idx(struct compress_ctx *cc, pgoff_t index)
> +{
> + return index >> cc->log_cluster_size;
> +}
> +
> +static unsigned int start_idx_of_cluster(struct compress_ctx *cc)
> +{
> + return cc->cluster_idx << cc->log_cluster_size;
> +}
> +
> +bool f2fs_is_compressed_page(struct page *page)
> +{
> + if (!PagePrivate(page))
> + return false;
> + if (!page_private(page))
> + return false;
> + if (IS_ATOMIC_WRITTEN_PAGE(page) || IS_DUMMY_WRITTEN_PAGE(page))
> + return false;
> + f2fs_bug_on(F2FS_M_SB(page->i_mapping),
> + *((u32 *)page_private(page)) == F2FS_COMPRESSED_PAGE_MAGIC);
> + return true;
> +}
> +
> +static void f2fs_set_compressed_page(struct page *page,
> + struct inode *inode, pgoff_t index, void *data, refcount_t *r)
> +{
> + SetPagePrivate(page);
> + set_page_private(page, (unsigned long)data);
> +
> + /* i_crypto_info and iv index */
> + page->index = index;
> + page->mapping = inode->i_mapping;
> + if (r)
> + refcount_inc(r);
> +}
> +
> +static void f2fs_put_compressed_page(struct page *page)
> +{
> + set_page_private(page, (unsigned long)NULL);
> + ClearPagePrivate(page);
> + page->mapping = NULL;
> + unlock_page(page);
> + put_page(page);
> +}
> +
> +struct page *f2fs_compress_control_page(struct page *page)
> +{
> + return ((struct compress_io_ctx *)page_private(page))->rpages[0];
> +}
> +
> +int f2fs_init_compress_ctx(struct compress_ctx *cc)
> +{
> + struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode);
> +
> + if (cc->nr_rpages)
> + return 0;
> +
> + cc->rpages = f2fs_kzalloc(sbi, sizeof(struct page *) <<
> + cc->log_cluster_size, GFP_NOFS);
> + if (!cc->rpages)
> + return -ENOMEM;
> + return 0;
> +}
> +
> +void f2fs_destroy_compress_ctx(struct compress_ctx *cc)
> +{
> + f2fs_reset_compress_ctx(cc);
> + kfree(cc->rpages);
> +}
> +
> +void f2fs_compress_ctx_add_page(struct compress_ctx *cc, struct page *page)
> +{
> + unsigned int cluster_ofs;
> +
> + if (!f2fs_cluster_can_merge_page(cc, page->index))
> + f2fs_bug_on(F2FS_I(cc->inode), 1);
> +
> + cluster_ofs = offset_in_cluster(cc, page->index);
> + cc->rpages[cluster_ofs] = page;
> + cc->nr_rpages++;
> + cc->cluster_idx = cluster_idx(cc, page->index);
> +}
> +
> +#ifdef CONFIG_F2FS_FS_LZO
> +static int lzo_init_compress_ctx(struct compress_ctx *cc)
> +{
> + cc->private = f2fs_kvmalloc(F2FS_I_SB(cc->inode),
> + LZO1X_MEM_COMPRESS, GFP_NOFS);
> + if (!cc->private)
> + return -ENOMEM;
> +
> + cc->clen = lzo1x_worst_compress(PAGE_SIZE << cc->log_cluster_size);
> + return 0;
> +}
> +
> +static void lzo_destroy_compress_ctx(struct compress_ctx *cc)
> +{
> + kvfree(cc->private);
> + cc->private = NULL;
> +}
> +
> +static int lzo_compress_pages(struct compress_ctx *cc)
> +{
> + int ret;
> +
> + ret = lzo1x_1_compress(cc->rbuf, cc->rlen, cc->cbuf->cdata,
> + &cc->clen, cc->private);
> + if (ret != LZO_E_OK) {
> + printk_ratelimited("%sF2FS-fs (%s): lzo compress failed, ret:%d\n",
> + KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, ret);
> + return -EIO;
> + }
> + return 0;
> +}
> +
> +static int lzo_decompress_pages(struct decompress_io_ctx *dic)
> +{
> + int ret;
> +
> + ret = lzo1x_decompress_safe(dic->cbuf->cdata, dic->clen,
> + dic->rbuf, &dic->rlen);
> + if (ret != LZO_E_OK) {
> + printk_ratelimited("%sF2FS-fs (%s): lzo decompress failed, ret:%d\n",
> + KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, ret);
> + return -EIO;
> + }
> +
> + if (dic->rlen != PAGE_SIZE << dic->log_cluster_size) {
> + printk_ratelimited("%sF2FS-fs (%s): lzo invalid rlen:%zu, "
> + "expected:%lu\n", KERN_ERR,
> + F2FS_I_SB(dic->inode)->sb->s_id,
> + dic->rlen,
> + PAGE_SIZE << dic->log_cluster_size);
> + return -EIO;
> + }
> + return 0;
> +}
> +
> +static const struct f2fs_compress_ops f2fs_lzo_ops = {
> + .init_compress_ctx = lzo_init_compress_ctx,
> + .destroy_compress_ctx = lzo_destroy_compress_ctx,
> + .compress_pages = lzo_compress_pages,
> + .decompress_pages = lzo_decompress_pages,
> +};
> +#endif
> +
> +#ifdef CONFIG_F2FS_FS_LZ4
> +static int lz4_init_compress_ctx(struct compress_ctx *cc)
> +{
> + cc->private = f2fs_kvmalloc(F2FS_I_SB(cc->inode),
> + LZ4_MEM_COMPRESS, GFP_NOFS);
> + if (!cc->private)
> + return -ENOMEM;
> +
> + cc->clen = LZ4_compressBound(PAGE_SIZE << cc->log_cluster_size);
> + return 0;
> +}
> +
> +static void lz4_destroy_compress_ctx(struct compress_ctx *cc)
> +{
> + kvfree(cc->private);
> + cc->private = NULL;
> +}
> +
> +static int lz4_compress_pages(struct compress_ctx *cc)
> +{
> + int len;
> +
> + len = LZ4_compress_default(cc->rbuf, cc->cbuf->cdata, cc->rlen,
> + cc->clen, cc->private);
> + if (!len) {
> + printk_ratelimited("%sF2FS-fs (%s): lz4 compress failed\n",
> + KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id);
> + return -EIO;
> + }
> + cc->clen = len;
> + return 0;
> +}
> +
> +static int lz4_decompress_pages(struct decompress_io_ctx *dic)
> +{
> + int ret;
> +
> + ret = LZ4_decompress_safe(dic->cbuf->cdata, dic->rbuf,
> + dic->clen, dic->rlen);
> + if (ret < 0) {
> + printk_ratelimited("%sF2FS-fs (%s): lz4 decompress failed, ret:%d\n",
> + KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, ret);
> + return -EIO;
> + }
> +
> + if (ret != PAGE_SIZE << dic->log_cluster_size) {
> + printk_ratelimited("%sF2FS-fs (%s): lz4 invalid rlen:%zu, "
> + "expected:%lu\n", KERN_ERR,
> + F2FS_I_SB(dic->inode)->sb->s_id,
> + dic->rlen,
> + PAGE_SIZE << dic->log_cluster_size);
> + return -EIO;
> + }
> + return 0;
> +}
> +
> +static const struct f2fs_compress_ops f2fs_lz4_ops = {
> + .init_compress_ctx = lz4_init_compress_ctx,
> + .destroy_compress_ctx = lz4_destroy_compress_ctx,
> + .compress_pages = lz4_compress_pages,
> + .decompress_pages = lz4_decompress_pages,
> +};
> +#endif
> +
> +static const struct f2fs_compress_ops *f2fs_cops[COMPRESS_MAX] = {
> +#ifdef CONFIG_F2FS_FS_LZO
> + &f2fs_lzo_ops,
> +#else
> + NULL,
> +#endif
> +#ifdef CONFIG_F2FS_FS_LZ4
> + &f2fs_lz4_ops,
> +#else
> + NULL,
> +#endif
> +};
> +
> +bool f2fs_is_compress_backend_ready(struct inode *inode)
> +{
> + if (!f2fs_compressed_file(inode))
> + return true;
> + return f2fs_cops[F2FS_I(inode)->i_compress_algorithm];
> +}
> +
> +static struct page *f2fs_grab_page(void)
> +{
> + struct page *page;
> +
> + page = alloc_page(GFP_NOFS);
> + if (!page)
> + return NULL;
> + lock_page(page);
> + return page;
> +}
> +
> +static int f2fs_compress_pages(struct compress_ctx *cc)
> +{
> + struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode);
> + struct f2fs_inode_info *fi = F2FS_I(cc->inode);
> + const struct f2fs_compress_ops *cops =
> + f2fs_cops[fi->i_compress_algorithm];
> + unsigned int max_len, nr_cpages;
> + int i, ret;
> +
> + trace_f2fs_compress_pages_start(cc->inode, cc->cluster_idx,
> + cc->cluster_size, fi->i_compress_algorithm);
> +
> + ret = cops->init_compress_ctx(cc);
> + if (ret)
> + goto out;
> +
> + max_len = COMPRESS_HEADER_SIZE + cc->clen;
> + cc->nr_cpages = DIV_ROUND_UP(max_len, PAGE_SIZE);
> +
> + cc->cpages = f2fs_kzalloc(sbi, sizeof(struct page *) *
> + cc->nr_cpages, GFP_NOFS);
> + if (!cc->cpages) {
> + ret = -ENOMEM;
> + goto destroy_compress_ctx;
> + }
> +
> + for (i = 0; i < cc->nr_cpages; i++) {
> + cc->cpages[i] = f2fs_grab_page();
> + if (!cc->cpages[i]) {
> + ret = -ENOMEM;
> + goto out_free_cpages;
> + }
> + }
> +
> + cc->rbuf = vmap(cc->rpages, cc->cluster_size, VM_MAP, PAGE_KERNEL_RO);
> + if (!cc->rbuf) {
> + ret = -ENOMEM;
> + goto out_free_cpages;
> + }
> +
> + cc->cbuf = vmap(cc->cpages, cc->nr_cpages, VM_MAP, PAGE_KERNEL);
> + if (!cc->cbuf) {
> + ret = -ENOMEM;
> + goto out_vunmap_rbuf;
> + }
> +
> + ret = cops->compress_pages(cc);
> + if (ret)
> + goto out_vunmap_cbuf;
> +
> + max_len = PAGE_SIZE * (cc->cluster_size - 1) - COMPRESS_HEADER_SIZE;
> +
> + if (cc->clen > max_len) {
> + ret = -EAGAIN;
> + goto out_vunmap_cbuf;
> + }
> +
> + cc->cbuf->clen = cpu_to_le32(cc->clen);
> + cc->cbuf->chksum = cpu_to_le32(0);
> +
> + for (i = 0; i < COMPRESS_DATA_RESERVED_SIZE; i++)
> + cc->cbuf->reserved[i] = cpu_to_le32(0);
> +
> + vunmap(cc->cbuf);
> + vunmap(cc->rbuf);
> +
> + nr_cpages = DIV_ROUND_UP(cc->clen + COMPRESS_HEADER_SIZE, PAGE_SIZE);
> +
> + for (i = nr_cpages; i < cc->nr_cpages; i++) {
> + f2fs_put_compressed_page(cc->cpages[i]);
> + cc->cpages[i] = NULL;
> + }
> +
> + cc->nr_cpages = nr_cpages;
> +
> + trace_f2fs_compress_pages_end(cc->inode, cc->cluster_idx,
> + cc->clen, ret);
> + return 0;
> +
> +out_vunmap_cbuf:
> + vunmap(cc->cbuf);
> +out_vunmap_rbuf:
> + vunmap(cc->rbuf);
> +out_free_cpages:
> + for (i = 0; i < cc->nr_cpages; i++) {
> + if (cc->cpages[i])
> + f2fs_put_compressed_page(cc->cpages[i]);
> + }
> + kfree(cc->cpages);
> + cc->cpages = NULL;
> +destroy_compress_ctx:
> + cops->destroy_compress_ctx(cc);
> +out:
> + trace_f2fs_compress_pages_end(cc->inode, cc->cluster_idx,
> + cc->clen, ret);
> + return ret;
> +}
> +
> +void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity)
> +{
> + struct decompress_io_ctx *dic =
> + (struct decompress_io_ctx *)page_private(page);
> + struct f2fs_sb_info *sbi = F2FS_I_SB(dic->inode);
> + struct f2fs_inode_info *fi= F2FS_I(dic->inode);
> + const struct f2fs_compress_ops *cops =
> + f2fs_cops[fi->i_compress_algorithm];
> + int ret;
> +
> + dec_page_count(sbi, F2FS_RD_DATA);
> +
> + if (bio->bi_status)
> + dic->failed = true;
> +
> + if (refcount_dec_not_one(&dic->ref))
> + return;
> +
> + trace_f2fs_decompress_pages_start(dic->inode, dic->cluster_idx,
> + dic->cluster_size, fi->i_compress_algorithm);
> +
> + /* submit partial compressed pages */
> + if (dic->failed) {
> + ret = -EIO;
> + goto out_free_dic;
> + }
> +
> + dic->rbuf = vmap(dic->tpages, dic->cluster_size, VM_MAP, PAGE_KERNEL);
> + if (!dic->rbuf) {
> + ret = -ENOMEM;
> + goto out_free_dic;
> + }
> +
> + dic->cbuf = vmap(dic->cpages, dic->nr_cpages, VM_MAP, PAGE_KERNEL_RO);
> + if (!dic->cbuf) {
> + ret = -ENOMEM;
> + goto out_vunmap_rbuf;
> + }
> +
> + dic->clen = le32_to_cpu(dic->cbuf->clen);
> + dic->rlen = PAGE_SIZE << dic->log_cluster_size;
> +
> + if (dic->clen > PAGE_SIZE * dic->nr_cpages - COMPRESS_HEADER_SIZE) {
> + ret = -EFSCORRUPTED;
> + goto out_vunmap_cbuf;
> + }
> +
> + ret = cops->decompress_pages(dic);
> +
> +out_vunmap_cbuf:
> + vunmap(dic->cbuf);
> +out_vunmap_rbuf:
> + vunmap(dic->rbuf);
> +out_free_dic:
> + f2fs_set_cluster_uptodate(dic->rpages, dic->cluster_size, ret, verity);
> + trace_f2fs_decompress_pages_end(dic->inode, dic->cluster_idx,
> + dic->clen, ret);
> + f2fs_free_dic(dic);
> +}
> +
> +static bool is_page_in_cluster(struct compress_ctx *cc, pgoff_t index)
> +{
> + if (cc->cluster_idx == NULL_CLUSTER)
> + return true;
> + return cc->cluster_idx == cluster_idx(cc, index);
> +}
> +
> +bool f2fs_cluster_is_empty(struct compress_ctx *cc)
> +{
> + return cc->nr_rpages == 0;
> +}
> +
> +static bool f2fs_cluster_is_full(struct compress_ctx *cc)
> +{
> + return cc->cluster_size == cc->nr_rpages;
> +}
> +
> +bool f2fs_cluster_can_merge_page(struct compress_ctx *cc, pgoff_t index)
> +{
> + if (f2fs_cluster_is_empty(cc))
> + return true;
> + return is_page_in_cluster(cc, index);
> +}
> +
> +static bool __cluster_may_compress(struct compress_ctx *cc)
> +{
> + struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode);
> + loff_t i_size = i_size_read(cc->inode);
> + unsigned nr_pages = DIV_ROUND_UP(i_size, PAGE_SIZE);
> + int i;
> +
> + for (i = 0; i < cc->cluster_size; i++) {
> + struct page *page = cc->rpages[i];
> +
> + f2fs_bug_on(sbi, !page);
> +
> + if (unlikely(f2fs_cp_error(sbi)))
> + return false;
> + if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
> + return false;
> +
> + /* beyond EOF */
> + if (page->index >= nr_pages)
> + return false;
> + if (page->index != start_idx_of_cluster(cc) + i)
> + return false;
> + }
> + return true;
> +}
> +
> +int is_compressed_cluster(struct compress_ctx *cc, pgoff_t index)
> +{
> + struct dnode_of_data dn;
> + unsigned int start_idx = cluster_idx(cc, index) <<
> + cc->log_cluster_size;
> + int ret;
> + int i;
> +
> + set_new_dnode(&dn, cc->inode, NULL, NULL, 0);
> + ret = f2fs_get_dnode_of_data(&dn, start_idx, LOOKUP_NODE);
> + if (ret) {
> + if (ret == -ENOENT)
> + ret = 0;
> + goto fail;
Removed a space.
> + }
> +
> + if (dn.data_blkaddr == COMPRESS_ADDR) {
> + ret = CLUSTER_IS_FULL;
> + for (i = 1; i < cc->cluster_size; i++) {
> + block_t blkaddr;
> +
> + blkaddr = datablock_addr(dn.inode,
> + dn.node_page, dn.ofs_in_node + i);
> + if (blkaddr == NULL_ADDR) {
> + ret = CLUSTER_HAS_SPACE;
> + break;
> + }
> + }
> + }
> +fail:
> + f2fs_put_dnode(&dn);
> + return ret;
> +}
> +
> +int f2fs_is_compressed_cluster(struct inode *inode, pgoff_t index)
> +{
> + struct compress_ctx cc = {
> + .inode = inode,
> + .log_cluster_size = F2FS_I(inode)->i_log_cluster_size,
> + .cluster_size = F2FS_I(inode)->i_cluster_size,
> + };
> +
> + return is_compressed_cluster(&cc, index);
> +}
> +
> +static bool cluster_may_compress(struct compress_ctx *cc)
> +{
> + if (!f2fs_compressed_file(cc->inode))
> + return false;
> + if (f2fs_is_atomic_file(cc->inode))
> + return false;
> + if (f2fs_is_mmap_file(cc->inode))
> + return false;
> + if (!f2fs_cluster_is_full(cc))
> + return false;
> + return __cluster_may_compress(cc);
> +}
> +
> +void f2fs_reset_compress_ctx(struct compress_ctx *cc)
> +{
> + cc->nr_rpages = 0;
> + cc->nr_cpages = 0;
> + cc->cluster_idx = NULL_CLUSTER;
> +}
> +
> +static void set_cluster_writeback(struct compress_ctx *cc)
> +{
> + int i;
> +
> + for (i = 0; i < cc->cluster_size; i++) {
> + if (cc->rpages[i])
> + set_page_writeback(cc->rpages[i]);
> + }
> +}
> +
> +static void set_cluster_dirty(struct compress_ctx *cc)
> +{
> + int i;
> +
> + for (i = 0; i < cc->cluster_size; i++)
> + if (cc->rpages[i])
> + set_page_dirty(cc->rpages[i]);
> +}
> +
> +static int prepare_compress_overwrite(struct compress_ctx *cc,
> + struct page **pagep, pgoff_t index, void **fsdata,
> + bool prealloc)
> +{
> + struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode);
> + struct bio *bio = NULL;
> + struct address_space *mapping = cc->inode->i_mapping;
> + struct page *page;
> + struct dnode_of_data dn;
> + sector_t last_block_in_bio;
> + unsigned fgp_flag = FGP_LOCK | FGP_WRITE | FGP_CREAT;
> + unsigned int start_idx = cluster_idx(cc, index) << cc->log_cluster_size;
> + int i, idx;
> + int ret;
> +
> + ret = f2fs_init_compress_ctx(cc);
> + if (ret)
> + goto out;
> +retry:
> + /* keep page reference to avoid page reclaim */
> + for (i = 0; i < cc->cluster_size; i++) {
> + page = f2fs_pagecache_get_page(mapping, start_idx + i,
> + fgp_flag, GFP_NOFS);
> + if (!page) {
> + ret = -ENOMEM;
> + goto unlock_pages;
> + }
> +
> + if (PageUptodate(page)) {
> + unlock_page(page);
> + continue;
> + }
> +
> + f2fs_compress_ctx_add_page(cc, page);
> + }
> +
> + if (!f2fs_cluster_is_empty(cc)) {
> + ret = f2fs_read_multi_pages(cc, &bio, cc->cluster_size,
> + &last_block_in_bio, false);
> + if (ret)
> + goto out;
> +
> + if (bio)
> + f2fs_submit_bio(sbi, bio, DATA);
> +
> + ret = f2fs_init_compress_ctx(cc);
> + if (ret)
> + goto out;
> + }
> +
> + for (i = 0; i < cc->cluster_size; i++) {
> + page = find_lock_page(mapping, start_idx + i);
> + f2fs_bug_on(sbi, !page);
> +
> + f2fs_wait_on_page_writeback(page, DATA, true, true);
> +
> + cc->rpages[i] = page;
> + f2fs_put_page(page, 0);
> +
> + if (!PageUptodate(page)) {
> + for (idx = i; idx >= 0; idx--) {
> + f2fs_put_page(cc->rpages[idx], 0);
> + f2fs_put_page(cc->rpages[idx], 1);
> + }
> + goto retry;
> + }
> + }
> +
> + if (prealloc) {
> + __do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, true);
> +
> + set_new_dnode(&dn, cc->inode, NULL, NULL, 0);
> +
> + for (i = cc->cluster_size - 1; i > 0; i--) {
> + ret = f2fs_get_block(&dn, start_idx + i);
> + if (ret)
> + /* TODO: release preallocate blocks */
> + goto release_pages;
> +
> + if (dn.data_blkaddr != NEW_ADDR)
> + break;
> + }
> +
> + __do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, false);
> + }
> +
> + *fsdata = cc->rpages;
> + *pagep = cc->rpages[offset_in_cluster(cc, index)];
> + return CLUSTER_IS_FULL;
> +
> +unlock_pages:
> + for (idx = 0; idx < i; idx++) {
> + if (cc->rpages[idx])
> + unlock_page(cc->rpages[idx]);
> + }
> +release_pages:
> + for (idx = 0; idx < i; idx++) {
> + page = find_lock_page(mapping, start_idx + idx);
> + f2fs_put_page(page, 0);
> + f2fs_put_page(page, 1);
> + }
> + f2fs_destroy_compress_ctx(cc);
> +out:
> + return ret;
> +}
> +
> +int f2fs_prepare_compress_overwrite(struct inode *inode,
> + struct page **pagep, pgoff_t index, void **fsdata)
> +{
> + struct compress_ctx cc = {
> + .inode = inode,
> + .cluster_size = F2FS_I(inode)->i_cluster_size,
> + .cluster_idx = NULL_CLUSTER,
> + .rpages = NULL,
> + .nr_rpages = 0,
> + };
> + int ret = is_compressed_cluster(&cc, index);
> +
> + if (ret <= 0)
> + return ret;
> +
> + /* compressed case */
> + return prepare_compress_overwrite(&cc, pagep, index,
> + fsdata, ret == CLUSTER_HAS_SPACE);
> +}
> +
> +bool f2fs_compress_write_end(struct inode *inode, void *fsdata,
> + pgoff_t index, bool written)
> +
> +{
> + struct compress_ctx cc = {
> + .log_cluster_size = F2FS_I(inode)->i_log_cluster_size,
> + .cluster_size = F2FS_I(inode)->i_cluster_size,
> + .rpages = fsdata,
> + };
> + bool first_index = (index == cc.rpages[0]->index);
> + int i;
> +
> + if (written)
> + set_cluster_dirty(&cc);
> +
> + for (i = 0; i < cc.cluster_size; i++)
> + f2fs_put_page(cc.rpages[i], 1);
> +
> + f2fs_destroy_compress_ctx(&cc);
> +
> + return first_index;
> +
> +}
> +
> +static int f2fs_write_compressed_pages(struct compress_ctx *cc,
> + int *submitted,
> + struct writeback_control *wbc,
> + enum iostat_type io_type)
> +{
> + struct inode *inode = cc->inode;
> + struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> + struct f2fs_inode_info *fi = F2FS_I(inode);
> + struct f2fs_io_info fio = {
> + .sbi = sbi,
> + .ino = cc->inode->i_ino,
> + .type = DATA,
> + .op = REQ_OP_WRITE,
> + .op_flags = wbc_to_write_flags(wbc),
> + .old_blkaddr = NEW_ADDR,
> + .page = NULL,
> + .encrypted_page = NULL,
> + .compressed_page = NULL,
> + .submitted = false,
> + .need_lock = LOCK_RETRY,
> + .io_type = io_type,
> + .io_wbc = wbc,
> + .compressed = true,
> + .encrypted = f2fs_encrypted_file(cc->inode),
> + };
> + struct dnode_of_data dn;
> + struct node_info ni;
> + struct compress_io_ctx *cic;
> + unsigned int start_idx = start_idx_of_cluster(cc);
> + unsigned int last_index = cc->cluster_size - 1;
> + loff_t psize;
> + int pre_compressed_blocks = 0;
> + int i, err;
> +
> + set_new_dnode(&dn, cc->inode, NULL, NULL, 0);
> +
> + f2fs_lock_op(sbi);
> +
> + err = f2fs_get_dnode_of_data(&dn, start_idx, LOOKUP_NODE);
> + if (err)
> + goto out_unlock_op;
> +
> + psize = (cc->rpages[last_index]->index + 1) << PAGE_SHIFT;
> +
> + err = f2fs_get_node_info(fio.sbi, dn.nid, &ni);
> + if (err)
> + goto out_put_dnode;
> +
> + fio.version = ni.version;
> +
> + cic = f2fs_kzalloc(sbi, sizeof(struct compress_io_ctx), GFP_NOFS);
> + if (!cic)
> + goto out_put_dnode;
> +
> + cic->magic = F2FS_COMPRESSED_PAGE_MAGIC;
> + cic->inode = inode;
> + refcount_set(&cic->ref, 1);
> + cic->rpages = cc->rpages;
> + cic->nr_rpages = cc->cluster_size;
> +
> + for (i = 0; i < cc->nr_cpages; i++) {
> + f2fs_set_compressed_page(cc->cpages[i], inode,
> + cc->rpages[i + 1]->index,
> + cic, i ? &cic->ref : NULL);
> + fio.compressed_page = cc->cpages[i];
> + if (fio.encrypted) {
> + fio.page = cc->rpages[i + 1];
> + err = f2fs_encrypt_one_page(&fio);
> + if (err)
> + goto out_destroy_crypt;
> + cc->cpages[i] = fio.encrypted_page;
> + }
> + }
> +
> + set_cluster_writeback(cc);
> +
> + for (i = 0; i < cc->cluster_size; i++, dn.ofs_in_node++) {
> + block_t blkaddr;
> +
> + blkaddr = datablock_addr(dn.inode, dn.node_page,
> + dn.ofs_in_node);
> + fio.page = cc->rpages[i];
> + fio.old_blkaddr = blkaddr;
> +
> + /* cluster header */
> + if (i == 0) {
> + if (blkaddr == COMPRESS_ADDR)
> + pre_compressed_blocks++;
> + if (__is_valid_data_blkaddr(blkaddr))
> + f2fs_invalidate_blocks(sbi, blkaddr);
> + f2fs_update_data_blkaddr(&dn, COMPRESS_ADDR);
> + goto unlock_continue;
> + }
> +
> + if (pre_compressed_blocks && __is_valid_data_blkaddr(blkaddr))
> + pre_compressed_blocks++;
> +
> + if (i > cc->nr_cpages) {
> + if (__is_valid_data_blkaddr(blkaddr)) {
> + f2fs_invalidate_blocks(sbi, blkaddr);
> + f2fs_update_data_blkaddr(&dn, NEW_ADDR);
> + }
> + goto unlock_continue;
> + }
> +
> + f2fs_bug_on(fio.sbi, blkaddr == NULL_ADDR);
> +
> +
> + if (fio.encrypted)
> + fio.encrypted_page = cc->cpages[i - 1];
> + else if (fio.compressed)
> + fio.compressed_page = cc->cpages[i - 1];
> + else
> + f2fs_bug_on(sbi, 1);
> + cc->cpages[i - 1] = NULL;
> + f2fs_outplace_write_data(&dn, &fio);
> + (*submitted)++;
> +unlock_continue:
> + inode_dec_dirty_pages(cc->inode);
> + unlock_page(fio.page);
> + }
> +
> + if (pre_compressed_blocks) {
> + stat_sub_compr_blocks(inode,
> + cc->cluster_size - pre_compressed_blocks + 1);
> + F2FS_I(inode)->i_compressed_blocks -=
> + (cc->cluster_size - pre_compressed_blocks + 1);
> + }
> + stat_add_compr_blocks(inode, cc->cluster_size - cc->nr_cpages);
> + F2FS_I(inode)->i_compressed_blocks += cc->cluster_size - cc->nr_cpages;
> + f2fs_mark_inode_dirty_sync(inode, true);
> +
> + set_inode_flag(cc->inode, FI_APPEND_WRITE);
> + if (cc->cluster_idx == 0)
> + set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN);
> +
> + f2fs_put_dnode(&dn);
> + f2fs_unlock_op(sbi);
> +
> + if (err) {
> + file_set_keep_isize(inode);
> + } else {
> + down_write(&fi->i_sem);
> + if (fi->last_disk_size < psize)
> + fi->last_disk_size = psize;
> + up_write(&fi->i_sem);
> + }
> + return 0;
> +
> +out_destroy_crypt:
> + for (i -= 1; i >= 0; i--)
> + fscrypt_finalize_bounce_page(&cc->cpages[i]);
> + for (i = 0; i < cc->nr_cpages; i++) {
> + if (!cc->cpages[i])
> + continue;
> + f2fs_put_page(cc->cpages[i], 1);
> + }
> +out_put_dnode:
> + f2fs_put_dnode(&dn);
> +out_unlock_op:
> + f2fs_unlock_op(sbi);
> + return -EAGAIN;
> +}
> +
> +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);
> + int i;
> +
> + if (unlikely(bio->bi_status))
> + mapping_set_error(cic->inode->i_mapping, -EIO);
> +
> + f2fs_put_compressed_page(page);
> +
> + dec_page_count(sbi, F2FS_WB_DATA);
> +
> + if (refcount_dec_not_one(&cic->ref))
> + return;
> +
> + for (i = 0; i < cic->nr_rpages; i++) {
> + WARN_ON(!cic->rpages[i]);
> + clear_cold_data(cic->rpages[i]);
> + end_page_writeback(cic->rpages[i]);
> + }
> +
> + kfree(cic->rpages);
> + kfree(cic);
> +}
> +
> +static int f2fs_write_raw_pages(struct compress_ctx *cc,
> + int *submitted,
> + struct writeback_control *wbc,
> + enum iostat_type io_type)
> +{
> + int i, _submitted;
> + int ret, err = 0;
> +
> + for (i = 0; i < cc->cluster_size; i++) {
> + if (!cc->rpages[i])
> + continue;
> + BUG_ON(!PageLocked(cc->rpages[i]));
> + ret = f2fs_write_single_data_page(cc->rpages[i], &_submitted,
> + NULL, NULL, wbc, io_type);
> + if (ret) {
> + if (ret == AOP_WRITEPAGE_ACTIVATE)
> + unlock_page(cc->rpages[i]);
> + err = ret;
> + goto out_fail;
> + }
> +
> + *submitted += _submitted;
> + }
> + return 0;
> +
> +out_fail:
> + /* TODO: revoke partially updated block addresses */
> + for (++i; i < cc->cluster_size; i++) {
> + if (!cc->rpages[i])
> + continue;
> + redirty_page_for_writepage(wbc, cc->rpages[i]);
> + unlock_page(cc->rpages[i]);
> + }
> + return err;
> +}
> +
> +int f2fs_write_multi_pages(struct compress_ctx *cc,
> + int *submitted,
> + struct writeback_control *wbc,
> + enum iostat_type io_type)
> +{
> + struct f2fs_inode_info *fi = F2FS_I(cc->inode);
> + const struct f2fs_compress_ops *cops =
> + f2fs_cops[fi->i_compress_algorithm];
> + int err = -EAGAIN;
> +
> + *submitted = 0;
> +
> + if (cluster_may_compress(cc)) {
> + err = f2fs_compress_pages(cc);
> + if (err) {
> + err = -EAGAIN;
> + goto write;
> + }
> + err = f2fs_write_compressed_pages(cc, submitted,
> + wbc, io_type);
> + cops->destroy_compress_ctx(cc);
> + }
> +write:
> + if (err == -EAGAIN) {
> + bool compressed = false;
> +
> + f2fs_bug_on(F2FS_I_SB(cc->inode), *submitted);
> + if (is_compressed_cluster(cc, start_idx_of_cluster(cc)))
> + compressed = true;
> +
> + err = f2fs_write_raw_pages(cc, submitted, wbc, io_type);
> + if (compressed) {
> + stat_sub_compr_blocks(cc->inode, *submitted);
> + F2FS_I(cc->inode)->i_compressed_blocks -= *submitted;
> + f2fs_mark_inode_dirty_sync(cc->inode, true);
> + }
> + }
> +
> + f2fs_reset_compress_ctx(cc);
> + return err;
> +}
> +
> +struct decompress_io_ctx *f2fs_alloc_dic(struct compress_ctx *cc)
> +{
> + struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode);
> + struct decompress_io_ctx *dic;
> + unsigned int start_idx = start_idx_of_cluster(cc);
> + int i;
> +
> + dic = f2fs_kzalloc(sbi, sizeof(struct decompress_io_ctx), GFP_NOFS);
> + if (!dic)
> + goto out;
> +
> + dic->inode = cc->inode;
> + refcount_set(&dic->ref, 1);
> + dic->cluster_idx = cc->cluster_idx;
> + dic->cluster_size = cc->cluster_size;
> + dic->log_cluster_size = cc->log_cluster_size;
> + dic->nr_cpages = cc->nr_cpages;
> + dic->failed = false;
> +
> + dic->cpages = f2fs_kzalloc(sbi, sizeof(struct page *) *
> + dic->nr_cpages, GFP_NOFS);
> + if (!dic->cpages)
> + goto out_free;
> +
> + for (i = 0; i < dic->nr_cpages; i++) {
> + struct page *page;
> +
> + page = f2fs_grab_page();
> + if (!page)
> + goto out_free;
> +
> + f2fs_set_compressed_page(page, cc->inode,
> + start_idx + i + 1,
> + dic, i ? &dic->ref : NULL);
> + dic->cpages[i] = page;
> + }
> +
> + dic->tpages = f2fs_kzalloc(sbi, sizeof(struct page *) *
> + dic->cluster_size, GFP_NOFS);
> + if (!dic->tpages)
> + goto out_free;
> +
> + for (i = 0; i < dic->cluster_size; i++) {
> + if (cc->rpages[i])
> + continue;
> +
> + dic->tpages[i] = f2fs_grab_page();
> + if (!dic->tpages[i])
> + goto out_free;
> + }
> +
> + for (i = 0; i < dic->cluster_size; i++) {
> + if (dic->tpages[i])
> + continue;
> + dic->tpages[i] = cc->rpages[i];
> + }
> +
> + dic->rpages = cc->rpages;
> + dic->nr_rpages = cc->cluster_size;
> + return dic;
> +
> +out_free:
> + f2fs_free_dic(dic);
> +out:
> + return ERR_PTR(-ENOMEM);
> +}
> +
> +void f2fs_free_dic(struct decompress_io_ctx *dic)
> +{
> + int i;
> +
> + if (dic->tpages) {
> + for (i = 0; i < dic->cluster_size; i++) {
> + if (dic->rpages[i])
> + continue;
> + unlock_page(dic->tpages[i]);
> + put_page(dic->tpages[i]);
> + }
> + kfree(dic->tpages);
> + }
> +
> + if (dic->cpages) {
> + for (i = 0; i < dic->nr_cpages; i++) {
> + if (!dic->cpages[i])
> + continue;
> + f2fs_put_compressed_page(dic->cpages[i]);
> + }
> + kfree(dic->cpages);
> + }
> +
> + kfree(dic->rpages);
> + kfree(dic);
> +}
> +
> +void f2fs_set_cluster_uptodate(struct page **rpages,
> + unsigned int cluster_size, bool err, bool verity)
> +{
> + int i;
> +
> + for (i = 0; i < cluster_size; i++) {
> + struct page *rpage = rpages[i];
> +
> + if (!rpage)
> + continue;
> +
> + if (err || PageError(rpage)) {
> + ClearPageUptodate(rpage);
> + ClearPageError(rpage);
> + } else {
> + if (!verity || fsverity_verify_page(rpage))
> + SetPageUptodate(rpage);
> + else
> + SetPageError(rpage);
> + }
> + unlock_page(rpage);
> + }
> +}
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index 58f4bade6c2b..0bfd1b36141b 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -41,6 +41,9 @@ static bool __is_cp_guaranteed(struct page *page)
> if (!mapping)
> return false;
>
> + if (f2fs_is_compressed_page(page))
> + return false;
> +
> inode = mapping->host;
> sbi = F2FS_I_SB(inode);
>
> @@ -73,19 +76,19 @@ static enum count_type __read_io_type(struct page *page)
>
> /* postprocessing steps for read bios */
> enum bio_post_read_step {
> - STEP_INITIAL = 0,
> STEP_DECRYPT,
> + STEP_DECOMPRESS,
> STEP_VERITY,
> };
>
> struct bio_post_read_ctx {
> struct bio *bio;
> + struct f2fs_sb_info *sbi;
> struct work_struct work;
> - unsigned int cur_step;
> unsigned int enabled_steps;
> };
>
> -static void __read_end_io(struct bio *bio)
> +static void __read_end_io(struct bio *bio, bool compr, bool verity)
> {
> struct page *page;
> struct bio_vec *bv;
> @@ -94,6 +97,13 @@ static void __read_end_io(struct bio *bio)
> bio_for_each_segment_all(bv, bio, iter_all) {
> page = bv->bv_page;
>
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + if (compr && PagePrivate(page)) {
> + f2fs_decompress_pages(bio, page, verity);
> + continue;
> + }
> +#endif
> +
> /* PG_error was set if any post_read step failed */
> if (bio->bi_status || PageError(page)) {
> ClearPageUptodate(page);
> @@ -110,26 +120,52 @@ static void __read_end_io(struct bio *bio)
> bio_put(bio);
> }
>
> +static void f2fs_decompress_bio(struct bio *bio, bool verity)
> +{
> + __read_end_io(bio, true, verity);
> +}
> +
> static void bio_post_read_processing(struct bio_post_read_ctx *ctx);
>
> -static void decrypt_work(struct work_struct *work)
> +static void decrypt_work(struct bio_post_read_ctx *ctx)
> {
> - struct bio_post_read_ctx *ctx =
> - container_of(work, struct bio_post_read_ctx, work);
> -
> fscrypt_decrypt_bio(ctx->bio);
> +}
> +
> +static void decompress_work(struct bio_post_read_ctx *ctx, bool verity)
> +{
> + f2fs_decompress_bio(ctx->bio, verity);
> +}
>
> - bio_post_read_processing(ctx);
> +static void verity_work(struct bio_post_read_ctx *ctx)
> +{
> + fsverity_verify_bio(ctx->bio);
> }
>
> -static void verity_work(struct work_struct *work)
> +static void f2fs_post_read_work(struct work_struct *work)
> {
> struct bio_post_read_ctx *ctx =
> container_of(work, struct bio_post_read_ctx, work);
>
> - fsverity_verify_bio(ctx->bio);
> + if (ctx->enabled_steps & (1 << STEP_DECRYPT))
> + decrypt_work(ctx);
> +
> + if (ctx->enabled_steps & (1 << STEP_DECOMPRESS)) {
> + decompress_work(ctx,
> + ctx->enabled_steps & (1 << STEP_VERITY));
> + return;
> + }
> +
> + if (ctx->enabled_steps & (1 << STEP_VERITY))
> + verity_work(ctx);
>
> - bio_post_read_processing(ctx);
> + __read_end_io(ctx->bio, false, false);
> +}
> +
> +static void f2fs_enqueue_post_read_work(struct f2fs_sb_info *sbi,
> + struct work_struct *work)
> +{
> + queue_work(sbi->post_read_wq, work);
> }
>
> static void bio_post_read_processing(struct bio_post_read_ctx *ctx)
> @@ -139,31 +175,18 @@ static void bio_post_read_processing(struct bio_post_read_ctx *ctx)
> * verity may require reading metadata pages that need decryption, and
> * we shouldn't recurse to the same workqueue.
> */
> - switch (++ctx->cur_step) {
> - case STEP_DECRYPT:
> - if (ctx->enabled_steps & (1 << STEP_DECRYPT)) {
> - INIT_WORK(&ctx->work, decrypt_work);
> - fscrypt_enqueue_decrypt_work(&ctx->work);
> - return;
> - }
> - ctx->cur_step++;
> - /* fall-through */
> - case STEP_VERITY:
> - if (ctx->enabled_steps & (1 << STEP_VERITY)) {
> - INIT_WORK(&ctx->work, verity_work);
> - fsverity_enqueue_verify_work(&ctx->work);
> - return;
> - }
> - ctx->cur_step++;
> - /* fall-through */
> - default:
> - __read_end_io(ctx->bio);
> +
> + if (ctx->enabled_steps) {
> + INIT_WORK(&ctx->work, f2fs_post_read_work);
> + f2fs_enqueue_post_read_work(ctx->sbi, &ctx->work);
> + return;
> }
> + __read_end_io(ctx->bio, false, false);
> }
>
> static bool f2fs_bio_post_read_required(struct bio *bio)
> {
> - return bio->bi_private && !bio->bi_status;
> + return bio->bi_private;
> }
>
> static void f2fs_read_end_io(struct bio *bio)
> @@ -178,12 +201,11 @@ static void f2fs_read_end_io(struct bio *bio)
> if (f2fs_bio_post_read_required(bio)) {
> struct bio_post_read_ctx *ctx = bio->bi_private;
>
> - ctx->cur_step = STEP_INITIAL;
> bio_post_read_processing(ctx);
> return;
> }
>
> - __read_end_io(bio);
> + __read_end_io(bio, false, false);
> }
>
> static void f2fs_write_end_io(struct bio *bio)
> @@ -214,6 +236,13 @@ static void f2fs_write_end_io(struct bio *bio)
>
> fscrypt_finalize_bounce_page(&page);
>
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + if (f2fs_is_compressed_page(page)) {
> + f2fs_compress_write_end_io(bio, page);
> + continue;
> + }
> +#endif
> +
> if (unlikely(bio->bi_status)) {
> mapping_set_error(page->mapping, -EIO);
> if (type == F2FS_WB_CP_DATA)
> @@ -358,6 +387,12 @@ static inline void __submit_bio(struct f2fs_sb_info *sbi,
> submit_bio(bio);
> }
>
> +void f2fs_submit_bio(struct f2fs_sb_info *sbi,
> + struct bio *bio, enum page_type type)
> +{
> + __submit_bio(sbi, bio, type);
> +}
> +
> static void __submit_merged_bio(struct f2fs_bio_info *io)
> {
> struct f2fs_io_info *fio = &io->fio;
> @@ -380,7 +415,6 @@ static bool __has_merged_page(struct bio *bio, struct inode *inode,
> struct page *page, nid_t ino)
> {
> struct bio_vec *bvec;
> - struct page *target;
> struct bvec_iter_all iter_all;
>
> if (!bio)
> @@ -390,10 +424,12 @@ static bool __has_merged_page(struct bio *bio, struct inode *inode,
> return true;
>
> bio_for_each_segment_all(bvec, bio, iter_all) {
> + struct page *target = bvec->bv_page;
>
> - target = bvec->bv_page;
> if (fscrypt_is_bounce_page(target))
> target = fscrypt_pagecache_page(target);
> + if (f2fs_is_compressed_page(target))
> + target = f2fs_compress_control_page(target);
>
> if (inode && inode == target->mapping->host)
> return true;
> @@ -728,7 +764,12 @@ void f2fs_submit_page_write(struct f2fs_io_info *fio)
>
> verify_fio_blkaddr(fio);
>
> - bio_page = fio->encrypted_page ? fio->encrypted_page : fio->page;
> + if (fio->encrypted_page)
> + bio_page = fio->encrypted_page;
> + else if (fio->compressed_page)
> + bio_page = fio->compressed_page;
> + else
> + bio_page = fio->page;
>
> /* set submitted = true as a return value */
> fio->submitted = true;
> @@ -797,7 +838,8 @@ static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,
>
> if (f2fs_encrypted_file(inode))
> post_read_steps |= 1 << STEP_DECRYPT;
> -
> + if (f2fs_compressed_file(inode))
> + post_read_steps |= 1 << STEP_DECOMPRESS;
> if (f2fs_need_verity(inode, first_idx))
> post_read_steps |= 1 << STEP_VERITY;
>
> @@ -808,6 +850,7 @@ static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,
> return ERR_PTR(-ENOMEM);
> }
> ctx->bio = bio;
> + ctx->sbi = sbi;
> ctx->enabled_steps = post_read_steps;
> bio->bi_private = ctx;
> }
> @@ -1872,6 +1915,145 @@ static int f2fs_read_single_page(struct inode *inode, struct page *page,
> return ret;
> }
>
> +#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)
> +{
> + struct dnode_of_data dn;
> + struct inode *inode = cc->inode;
> + struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> + struct bio *bio = *bio_ret;
> + unsigned int start_idx = cc->cluster_idx << cc->log_cluster_size;
> + sector_t last_block_in_file;
> + const unsigned blkbits = inode->i_blkbits;
> + const unsigned blocksize = 1 << blkbits;
> + struct decompress_io_ctx *dic = NULL;
> + int i;
> + int ret = 0;
> +
> + f2fs_bug_on(sbi, f2fs_cluster_is_empty(cc));
> +
> + last_block_in_file = (i_size_read(inode) + blocksize - 1) >> blkbits;
> +
> + /* get rid of pages beyond EOF */
> + for (i = 0; i < cc->cluster_size; i++) {
> + struct page *page = cc->rpages[i];
> +
> + if (!page)
> + continue;
> + if ((sector_t)page->index >= last_block_in_file) {
> + zero_user_segment(page, 0, PAGE_SIZE);
> + if (!PageUptodate(page))
> + SetPageUptodate(page);
> + } else if (!PageUptodate(page)) {
> + continue;
> + }
> + unlock_page(page);
> + cc->rpages[i] = NULL;
> + cc->nr_rpages--;
> + }
> +
> + /* we are done since all pages are beyond EOF */
> + if (f2fs_cluster_is_empty(cc))
> + goto out;
> +
> + set_new_dnode(&dn, inode, NULL, NULL, 0);
> + ret = f2fs_get_dnode_of_data(&dn, start_idx, LOOKUP_NODE);
> + if (ret)
> + goto out;
> +
> + f2fs_bug_on(sbi, dn.data_blkaddr != COMPRESS_ADDR);
> +
> + for (i = 1; i < cc->cluster_size; i++) {
> + block_t blkaddr;
> +
> + blkaddr = datablock_addr(dn.inode, dn.node_page,
> + dn.ofs_in_node + i);
> +
> + if (!__is_valid_data_blkaddr(blkaddr))
> + break;
> +
> + if (!f2fs_is_valid_blkaddr(sbi, blkaddr, DATA_GENERIC)) {
> + ret = -EFAULT;
> + goto out_put_dnode;
> + }
> + cc->nr_cpages++;
> + }
> +
> + /* nothing to decompress */
> + if (cc->nr_cpages == 0) {
> + ret = 0;
> + goto out_put_dnode;
> + }
> +
> + dic = f2fs_alloc_dic(cc);
> + if (IS_ERR(dic)) {
> + ret = PTR_ERR(dic);
> + goto out_put_dnode;
> + }
> +
> + for (i = 0; i < dic->nr_cpages; i++) {
> + struct page *page = dic->cpages[i];
> + block_t blkaddr;
> +
> + blkaddr = datablock_addr(dn.inode, dn.node_page,
> + dn.ofs_in_node + i + 1);
> +
> + if (bio && !page_is_mergeable(sbi, bio,
> + *last_block_in_bio, blkaddr)) {
> +submit_and_realloc:
> + __submit_bio(sbi, bio, DATA);
> + bio = NULL;
> + }
> +
> + if (!bio) {
> + bio = f2fs_grab_read_bio(inode, blkaddr, nr_pages,
> + is_readahead ? REQ_RAHEAD : 0,
> + page->index);
> + if (IS_ERR(bio)) {
> + ret = PTR_ERR(bio);
> + bio = NULL;
> + dic->failed = true;
> + if (refcount_sub_and_test(dic->nr_cpages - i,
> + &dic->ref))
> + f2fs_set_cluster_uptodate(dic->rpages,
> + cc->cluster_size, true,
> + false);
> + f2fs_free_dic(dic);
> + f2fs_put_dnode(&dn);
> + f2fs_reset_compress_ctx(cc);
> + *bio_ret = bio;
> + return ret;
> + }
> + }
> +
> + f2fs_wait_on_block_writeback(inode, blkaddr);
> +
> + if (bio_add_page(bio, page, blocksize, 0) < blocksize)
> + goto submit_and_realloc;
> +
> + inc_page_count(sbi, F2FS_RD_DATA);
> + ClearPageError(page);
> + *last_block_in_bio = blkaddr;
> + }
> +
> + f2fs_put_dnode(&dn);
> +
> + f2fs_reset_compress_ctx(cc);
> + *bio_ret = bio;
> + return 0;
> +
> +out_put_dnode:
> + f2fs_put_dnode(&dn);
> +out:
> + f2fs_set_cluster_uptodate(cc->rpages, cc->cluster_size, true, false);
> + f2fs_reset_compress_ctx(cc);
> + *bio_ret = bio;
> + return ret;
> +}
> +#endif
> +
> /*
> * This function was originally taken from fs/mpage.c, and customized for f2fs.
> * Major change was from block_size == page_size in f2fs by default.
> @@ -1881,7 +2063,7 @@ static int f2fs_read_single_page(struct inode *inode, struct page *page,
> * use ->readpage() or do the necessary surgery to decouple ->readpages()
> * from read-ahead.
> */
> -static int f2fs_mpage_readpages(struct address_space *mapping,
> +int f2fs_mpage_readpages(struct address_space *mapping,
> struct list_head *pages, struct page *page,
> unsigned nr_pages, bool is_readahead)
> {
> @@ -1889,6 +2071,19 @@ static int f2fs_mpage_readpages(struct address_space *mapping,
> sector_t last_block_in_bio = 0;
> struct inode *inode = mapping->host;
> struct f2fs_map_blocks map;
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + struct compress_ctx cc = {
> + .inode = inode,
> + .log_cluster_size = F2FS_I(inode)->i_log_cluster_size,
> + .cluster_size = F2FS_I(inode)->i_cluster_size,
> + .cluster_idx = NULL_CLUSTER,
> + .rpages = NULL,
> + .cpages = NULL,
> + .nr_rpages = 0,
> + .nr_cpages = 0,
> + };
> +#endif
> + unsigned max_nr_pages = nr_pages;
> int ret = 0;
>
> map.m_pblk = 0;
> @@ -1912,9 +2107,40 @@ static int f2fs_mpage_readpages(struct address_space *mapping,
> goto next_page;
> }
>
> - ret = f2fs_read_single_page(inode, page, nr_pages, &map, &bio,
> - &last_block_in_bio, is_readahead);
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + if (f2fs_compressed_file(inode)) {
> + /* there are remained comressed pages, submit them */
> + if (!f2fs_cluster_can_merge_page(&cc, page->index)) {
> + ret = f2fs_read_multi_pages(&cc, &bio,
> + max_nr_pages,
> + &last_block_in_bio,
> + is_readahead);
> + if (ret)
> + goto set_error_page;
> + }
> + ret = f2fs_is_compressed_cluster(inode, page->index);
> + if (ret < 0)
> + goto set_error_page;
> + else if (!ret)
> + goto read_single_page;
> +
> + ret = f2fs_init_compress_ctx(&cc);
> + if (ret)
> + goto set_error_page;
> +
> + f2fs_compress_ctx_add_page(&cc, page);
> +
> + goto next_page;
> + }
> +read_single_page:
> +#endif
> +
> + ret = f2fs_read_single_page(inode, page, max_nr_pages, &map,
> + &bio, &last_block_in_bio, is_readahead);
> if (ret) {
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> +set_error_page:
> +#endif
> SetPageError(page);
> zero_user_segment(page, 0, PAGE_SIZE);
> unlock_page(page);
> @@ -1922,6 +2148,17 @@ static int f2fs_mpage_readpages(struct address_space *mapping,
> next_page:
> if (pages)
> put_page(page);
> +
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + if (f2fs_compressed_file(inode)) {
> + /* last page */
> + if (nr_pages == 1 && !f2fs_cluster_is_empty(&cc))
> + ret = f2fs_read_multi_pages(&cc, &bio,
> + max_nr_pages,
> + &last_block_in_bio,
> + is_readahead);
> + }
> +#endif
> }
> BUG_ON(pages && !list_empty(pages));
> if (bio)
> @@ -1936,6 +2173,11 @@ static int f2fs_read_data_page(struct file *file, struct page *page)
>
> trace_f2fs_readpage(page, DATA);
>
> + if (!f2fs_is_compress_backend_ready(inode)) {
> + unlock_page(page);
> + return -EOPNOTSUPP;
> + }
> +
> /* If the file has inline data, try to read it directly */
> if (f2fs_has_inline_data(inode))
> ret = f2fs_read_inline_data(inode, page);
> @@ -1954,6 +2196,9 @@ static int f2fs_read_data_pages(struct file *file,
>
> trace_f2fs_readpages(inode, page, nr_pages);
>
> + if (!f2fs_is_compress_backend_ready(inode))
> + return 0;
> +
> /* If the file has inline data, skip readpages */
> if (f2fs_has_inline_data(inode))
> return 0;
> @@ -1961,22 +2206,23 @@ static int f2fs_read_data_pages(struct file *file,
> return f2fs_mpage_readpages(mapping, pages, NULL, nr_pages, true);
> }
>
> -static int encrypt_one_page(struct f2fs_io_info *fio)
> +int f2fs_encrypt_one_page(struct f2fs_io_info *fio)
> {
> struct inode *inode = fio->page->mapping->host;
> - struct page *mpage;
> + struct page *mpage, *page;
> gfp_t gfp_flags = GFP_NOFS;
>
> if (!f2fs_encrypted_file(inode))
> return 0;
>
> + page = fio->compressed_page ? fio->compressed_page : fio->page;
> +
> /* wait for GCed page writeback via META_MAPPING */
> f2fs_wait_on_block_writeback(inode, fio->old_blkaddr);
>
> retry_encrypt:
> - fio->encrypted_page = fscrypt_encrypt_pagecache_blocks(fio->page,
> - PAGE_SIZE, 0,
> - gfp_flags);
> + fio->encrypted_page = fscrypt_encrypt_pagecache_blocks(page,
> + PAGE_SIZE, 0, gfp_flags);
> if (IS_ERR(fio->encrypted_page)) {
> /* flush pending IOs and wait for a while in the ENOMEM case */
> if (PTR_ERR(fio->encrypted_page) == -ENOMEM) {
> @@ -2136,7 +2382,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> if (ipu_force ||
> (__is_valid_data_blkaddr(fio->old_blkaddr) &&
> need_inplace_update(fio))) {
> - err = encrypt_one_page(fio);
> + err = f2fs_encrypt_one_page(fio);
> if (err)
> goto out_writepage;
>
> @@ -2172,7 +2418,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>
> fio->version = ni.version;
>
> - err = encrypt_one_page(fio);
> + err = f2fs_encrypt_one_page(fio);
> if (err)
> goto out_writepage;
>
> @@ -2193,7 +2439,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> return err;
> }
>
> -static int __write_data_page(struct page *page, bool *submitted,
> +int f2fs_write_single_data_page(struct page *page, int *submitted,
> struct bio **bio,
> sector_t *last_block,
> struct writeback_control *wbc,
> @@ -2202,7 +2448,7 @@ static int __write_data_page(struct page *page, bool *submitted,
> struct inode *inode = page->mapping->host;
> struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> loff_t i_size = i_size_read(inode);
> - const pgoff_t end_index = ((unsigned long long) i_size)
> + const pgoff_t end_index = ((unsigned long long)i_size)
> >> PAGE_SHIFT;
> loff_t psize = (page->index + 1) << PAGE_SHIFT;
> unsigned nr_pages = DIV_ROUND_UP(i_size, PAGE_SIZE);
> @@ -2243,7 +2489,8 @@ static int __write_data_page(struct page *page, bool *submitted,
> if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
> goto redirty_out;
>
> - if (page->index < end_index || f2fs_verity_in_progress(inode))
> + if (f2fs_compressed_file(inode) ||
> + page->index < end_index || f2fs_verity_in_progress(inode))
> goto write;
>
> /*
> @@ -2318,7 +2565,6 @@ static int __write_data_page(struct page *page, bool *submitted,
> f2fs_remove_dirty_inode(inode);
> submitted = NULL;
> }
> -
> unlock_page(page);
> if (!S_ISDIR(inode->i_mode) && !IS_NOQUOTA(inode) &&
> !F2FS_I(inode)->cp_task)
> @@ -2331,7 +2577,7 @@ static int __write_data_page(struct page *page, bool *submitted,
> }
>
> if (submitted)
> - *submitted = fio.submitted;
> + *submitted = fio.submitted ? 1 : 0;
>
> return 0;
>
> @@ -2352,7 +2598,19 @@ static int __write_data_page(struct page *page, bool *submitted,
> static int f2fs_write_data_page(struct page *page,
> struct writeback_control *wbc)
> {
> - return __write_data_page(page, NULL, NULL, NULL, wbc, FS_DATA_IO);
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + struct inode *inode = page->mapping->host;
> +
> + if (f2fs_compressed_file(inode)) {
> + if (f2fs_is_compressed_cluster(inode, page->index)) {
> + redirty_page_for_writepage(wbc, page);
> + return AOP_WRITEPAGE_ACTIVATE;
> + }
> + }
> +#endif
> +
> + return f2fs_write_single_data_page(page, NULL, NULL, NULL,
> + wbc, FS_DATA_IO);
> }
>
> /*
> @@ -2365,11 +2623,27 @@ static int f2fs_write_cache_pages(struct address_space *mapping,
> enum iostat_type io_type)
> {
> int ret = 0;
> - int done = 0;
> + int done = 0, retry = 0;
> struct pagevec pvec;
> struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
> struct bio *bio = NULL;
> sector_t last_block;
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + struct inode *inode = mapping->host;
> + struct compress_ctx cc = {
> + .inode = inode,
> + .log_cluster_size = F2FS_I(inode)->i_log_cluster_size,
> + .cluster_size = F2FS_I(inode)->i_cluster_size,
> + .cluster_idx = NULL_CLUSTER,
> + .rpages = NULL,
> + .nr_rpages = 0,
> + .cpages = NULL,
> + .rbuf = NULL,
> + .cbuf = NULL,
> + .rlen = PAGE_SIZE * F2FS_I(inode)->i_cluster_size,
> + .private = NULL,
> + };
> +#endif
> int nr_pages;
> pgoff_t uninitialized_var(writeback_index);
> pgoff_t index;
> @@ -2379,6 +2653,8 @@ 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 i;
>
> pagevec_init(&pvec);
>
> @@ -2408,12 +2684,11 @@ static int f2fs_write_cache_pages(struct address_space *mapping,
> else
> tag = PAGECACHE_TAG_DIRTY;
> retry:
> + retry = 0;
> if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
> tag_pages_for_writeback(mapping, index, end);
> done_index = index;
> - while (!done && (index <= end)) {
> - int i;
> -
> + while (!done && !retry && (index <= end)) {
> nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end,
> tag);
> if (nr_pages == 0)
> @@ -2421,7 +2696,51 @@ static int f2fs_write_cache_pages(struct address_space *mapping,
>
> for (i = 0; i < nr_pages; i++) {
> struct page *page = pvec.pages[i];
> - bool submitted = false;
> + bool need_readd = false;
> +
> +readd:
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + need_readd = false;
> +
> + if (f2fs_compressed_file(inode)) {
> + void *fsdata = NULL;
> + struct page *pagep;
> + int ret2;
> +
> + ret = f2fs_init_compress_ctx(&cc);
> + if (ret) {
> + done = 1;
> + break;
> + }
> +
> + if (!f2fs_cluster_can_merge_page(&cc,
> + page->index)) {
> +
> + ret = f2fs_write_multi_pages(&cc,
> + &submitted, wbc, io_type);
> + if (!ret)
> + need_readd = true;
> + goto result;
> + }
> +
> + if (f2fs_cluster_is_empty(&cc)) {
> + ret2 = f2fs_prepare_compress_overwrite(
> + inode, &pagep,
> + page->index, &fsdata);
> + if (ret2 < 0) {
> + ret = ret2;
> + done = 1;
> + break;
> + } else if (ret2 &&
> + !f2fs_compress_write_end(inode,
> + fsdata, page->index,
> + true)) {
> + retry = 1;
> + break;
> + }
> + }
> + }
> +#endif
>
> /* give a priority to WB_SYNC threads */
> if (atomic_read(&sbi->wb_sync_req[DATA]) &&
> @@ -2431,7 +2750,7 @@ static int f2fs_write_cache_pages(struct address_space *mapping,
> }
>
> done_index = page->index;
> -retry_write:
> +
> lock_page(page);
>
> if (unlikely(page->mapping != mapping)) {
> @@ -2456,45 +2775,64 @@ static int f2fs_write_cache_pages(struct address_space *mapping,
> if (!clear_page_dirty_for_io(page))
> goto continue_unlock;
>
> - ret = __write_data_page(page, &submitted, &bio,
> - &last_block, wbc, io_type);
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + if (f2fs_compressed_file(inode)) {
> + f2fs_compress_ctx_add_page(&cc, page);
> + continue;
> + }
> +#endif
> + ret = f2fs_write_single_data_page(page, &submitted,
> + &bio, &last_block, wbc, io_type);
> + if (ret == AOP_WRITEPAGE_ACTIVATE)
> + unlock_page(page);
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> +result:
> +#endif
> + nwritten += submitted;
> + wbc->nr_to_write -= submitted;
> +
> if (unlikely(ret)) {
> /*
> * keep nr_to_write, since vfs uses this to
> * get # of written pages.
> */
> if (ret == AOP_WRITEPAGE_ACTIVATE) {
> - unlock_page(page);
> ret = 0;
> - continue;
> + goto next;
> } else if (ret == -EAGAIN) {
> ret = 0;
> - if (wbc->sync_mode == WB_SYNC_ALL) {
> - cond_resched();
> - congestion_wait(BLK_RW_ASYNC,
> - HZ/50);
> - goto retry_write;
> - }
> - continue;
> + goto next;
> }
> done_index = page->index + 1;
> done = 1;
> break;
> - } else if (submitted) {
> - nwritten++;
> }
>
> - if (--wbc->nr_to_write <= 0 &&
> + if (wbc->nr_to_write <= 0 &&
> wbc->sync_mode == WB_SYNC_NONE) {
> done = 1;
> break;
> }
> +next:
> + if (need_readd)
> + goto readd;
> }
> +
> pagevec_release(&pvec);
> cond_resched();
> }
>
> - if (!cycled && !done) {
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + /* flush remained pages in compress cluster */
> + if (f2fs_compressed_file(inode) && !f2fs_cluster_is_empty(&cc)) {
> + ret = f2fs_write_multi_pages(&cc, &submitted, wbc, io_type);
> + nwritten += submitted;
> + wbc->nr_to_write -= submitted;
> + /* TODO: error handling */
> + }
> +#endif
> +
> + if ((!cycled && !done) || retry) {
> cycled = 1;
> index = 0;
> end = writeback_index - 1;
> @@ -2518,6 +2856,8 @@ static inline bool __should_serialize_io(struct inode *inode,
> {
> if (!S_ISREG(inode->i_mode))
> return false;
> + if (f2fs_compressed_file(inode))
> + return true;
> if (IS_NOQUOTA(inode))
> return false;
> /* to avoid deadlock in path of data flush */
> @@ -2660,6 +3000,7 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
> __do_map_lock(sbi, flag, true);
> locked = true;
> }
> +
> restart:
> /* check inline_data */
> ipage = f2fs_get_node_page(sbi, inode->i_ino);
> @@ -2750,6 +3091,24 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
> if (err)
> goto fail;
> }
> +
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + if (f2fs_compressed_file(inode)) {
> + int ret;
> +
> + *fsdata = NULL;
> +
> + ret = f2fs_prepare_compress_overwrite(inode, pagep,
> + index, fsdata);
> + if (ret < 0) {
> + err = ret;
> + goto fail;
> + } else if (ret) {
> + return 0;
> + }
> + }
> +#endif
> +
> repeat:
> /*
> * Do not use grab_cache_page_write_begin() to avoid deadlock due to
> @@ -2762,6 +3121,8 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
> goto fail;
> }
>
> + /* TODO: cluster can be compressed due to race with .writepage */
> +
> *pagep = page;
>
> err = prepare_write_begin(sbi, page, pos, len,
> @@ -2845,6 +3206,16 @@ static int f2fs_write_end(struct file *file,
> else
> SetPageUptodate(page);
> }
> +
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + /* overwrite compressed file */
> + if (f2fs_compressed_file(inode) && fsdata) {
> + f2fs_compress_write_end(inode, fsdata, page->index, copied);
> + f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
> + return copied;
> + }
> +#endif
> +
> if (!copied)
> goto unlock_out;
>
> @@ -3235,6 +3606,15 @@ static int f2fs_swap_activate(struct swap_info_struct *sis, struct file *file,
> if (ret)
> return ret;
>
> + if (f2fs_compressed_file(inode)) {
> + if (F2FS_I(inode)->i_compressed_blocks)
> + return -EINVAL;
> +
> + F2FS_I(inode)->i_flags &= ~FS_COMPR_FL;
> + clear_inode_flag(inode, FI_COMPRESSED_FILE);
> + stat_dec_compr_inode(inode);
> + }
> +
> ret = check_swap_activate(file, sis->max);
> if (ret)
> return ret;
> @@ -3319,6 +3699,27 @@ void f2fs_destroy_post_read_processing(void)
> kmem_cache_destroy(bio_post_read_ctx_cache);
> }
>
> +int f2fs_init_post_read_wq(struct f2fs_sb_info *sbi)
> +{
> + if (!f2fs_sb_has_encrypt(sbi) &&
> + !f2fs_sb_has_verity(sbi) &&
> + !f2fs_sb_has_compression(sbi))
> + return 0;
> +
> + sbi->post_read_wq = alloc_workqueue("f2fs_post_read_wq",
> + WQ_UNBOUND | WQ_HIGHPRI,
> + num_online_cpus());
> + if (!sbi->post_read_wq)
> + return -ENOMEM;
> + return 0;
> +}
> +
> +void f2fs_destroy_post_read_wq(struct f2fs_sb_info *sbi)
> +{
> + if (sbi->post_read_wq)
> + destroy_workqueue(sbi->post_read_wq);
> +}
> +
> int __init f2fs_init_bio_entry_cache(void)
> {
> bio_entry_slab = f2fs_kmem_cache_create("bio_entry_slab",
> diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
> index 5abd1d67d8b2..4f3ef1a892f0 100644
> --- a/fs/f2fs/debug.c
> +++ b/fs/f2fs/debug.c
> @@ -94,6 +94,8 @@ static void update_general_status(struct f2fs_sb_info *sbi)
> si->inline_xattr = atomic_read(&sbi->inline_xattr);
> si->inline_inode = atomic_read(&sbi->inline_inode);
> si->inline_dir = atomic_read(&sbi->inline_dir);
> + si->compr_inode = atomic_read(&sbi->compr_inode);
> + si->compr_blocks = atomic_read(&sbi->compr_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;
> @@ -315,6 +317,8 @@ 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: %u\n",
> + si->compr_inode, si->compr_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",
> @@ -491,6 +495,8 @@ int f2fs_build_stats(struct f2fs_sb_info *sbi)
> atomic_set(&sbi->inline_xattr, 0);
> atomic_set(&sbi->inline_inode, 0);
> atomic_set(&sbi->inline_dir, 0);
> + atomic_set(&sbi->compr_inode, 0);
> + atomic_set(&sbi->compr_blocks, 0);
> atomic_set(&sbi->inplace_count, 0);
> for (i = META_CP; i < META_MAX; i++)
> atomic_set(&sbi->meta_count[i], 0);
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index 8833e9d32f9d..74250d9f5cef 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -116,6 +116,8 @@ typedef u32 block_t; /*
> */
> typedef u32 nid_t;
>
> +#define COMPRESS_EXT_NUM 16
> +
> struct f2fs_mount_info {
> unsigned int opt;
> int write_io_size_bits; /* Write IO size bits */
> @@ -140,6 +142,12 @@ struct f2fs_mount_info {
> block_t unusable_cap; /* Amount of space allowed to be
> * unusable when disabling checkpoint
> */
> +
> + /* For compression */
> + unsigned char compress_algorithm; /* algorithm type */
> + unsigned compress_log_size; /* cluster log size */
> + unsigned char compress_ext_cnt; /* extension count */
> + unsigned char extensions[COMPRESS_EXT_NUM][F2FS_EXTENSION_LEN]; /* extensions */
> };
>
> #define F2FS_FEATURE_ENCRYPT 0x0001
> @@ -155,6 +163,7 @@ struct f2fs_mount_info {
> #define F2FS_FEATURE_VERITY 0x0400
> #define F2FS_FEATURE_SB_CHKSUM 0x0800
> #define F2FS_FEATURE_CASEFOLD 0x1000
> +#define F2FS_FEATURE_COMPRESSION 0x2000
>
> #define __F2FS_HAS_FEATURE(raw_super, mask) \
> ((raw_super->feature & cpu_to_le32(mask)) != 0)
> @@ -712,6 +721,12 @@ struct f2fs_inode_info {
> int i_inline_xattr_size; /* inline xattr size */
> struct timespec64 i_crtime; /* inode creation time */
> struct timespec64 i_disk_time[4];/* inode disk times */
> +
> + /* for file compress */
> + u64 i_compressed_blocks; /* # of compressed blocks */
> + unsigned char i_compress_algorithm; /* algorithm type */
> + unsigned char i_log_cluster_size; /* log of cluster size */
> + unsigned int i_cluster_size; /* cluster size */
> };
>
> static inline void get_extent_info(struct extent_info *ext,
> @@ -1056,12 +1071,15 @@ struct f2fs_io_info {
> block_t old_blkaddr; /* old block address before Cow */
> struct page *page; /* page to be written */
> struct page *encrypted_page; /* encrypted page */
> + struct page *compressed_page; /* compressed page */
> struct list_head list; /* serialize IOs */
> bool submitted; /* indicate IO submission */
> int need_lock; /* indicate we need to lock cp_rwsem */
> bool in_list; /* indicate fio is in io_list */
> bool is_por; /* indicate IO is from recovery or not */
> bool retry; /* need to reallocate block address */
> + bool compressed; /* indicate cluster is compressed */
> + bool encrypted; /* indicate file is encrypted */
> enum iostat_type io_type; /* io type */
> struct writeback_control *io_wbc; /* writeback control */
> struct bio **bio; /* bio for ipu */
> @@ -1169,6 +1187,18 @@ enum fsync_mode {
> FSYNC_MODE_NOBARRIER, /* fsync behaves nobarrier based on posix */
> };
>
> +/*
> + * this value is set in page as a private data which indicate that
> + * the page is atomically written, and it is in inmem_pages list.
> + */
> +#define ATOMIC_WRITTEN_PAGE ((unsigned long)-1)
> +#define DUMMY_WRITTEN_PAGE ((unsigned long)-2)
> +
> +#define IS_ATOMIC_WRITTEN_PAGE(page) \
> + (page_private(page) == (unsigned long)ATOMIC_WRITTEN_PAGE)
> +#define IS_DUMMY_WRITTEN_PAGE(page) \
> + (page_private(page) == (unsigned long)DUMMY_WRITTEN_PAGE)
> +
> #ifdef CONFIG_FS_ENCRYPTION
> #define DUMMY_ENCRYPTION_ENABLED(sbi) \
> (unlikely(F2FS_OPTION(sbi).test_dummy_encryption))
> @@ -1176,6 +1206,74 @@ enum fsync_mode {
> #define DUMMY_ENCRYPTION_ENABLED(sbi) (0)
> #endif
>
> +/* For compression */
> +enum compress_algorithm_type {
> + COMPRESS_LZO,
> + COMPRESS_LZ4,
> + COMPRESS_MAX,
> +};
> +
> +#define COMPRESS_DATA_RESERVED_SIZE 4
> +struct compress_data {
> + __le32 clen; /* compressed data size */
> + __le32 chksum; /* checksum of compressed data */
> + __le32 reserved[COMPRESS_DATA_RESERVED_SIZE]; /* reserved */
> + u8 cdata[]; /* compressed data */
> +};
> +
> +#define COMPRESS_HEADER_SIZE (sizeof(struct compress_data))
> +
> +#define F2FS_COMPRESSED_PAGE_MAGIC 0xF5F2C000
> +
> +/* compress context */
> +struct compress_ctx {
> + struct inode *inode; /* inode the context belong to */
> + unsigned int cluster_idx; /* cluster index number */
> + unsigned int cluster_size; /* page count in cluster */
> + unsigned int log_cluster_size; /* log of cluster size */
> + struct page **rpages; /* pages store raw data in cluster */
> + unsigned int nr_rpages; /* total page number in rpages */
> + struct page **cpages; /* pages store compressed data in cluster */
> + unsigned int nr_cpages; /* total page number in cpages */
> + void *rbuf; /* virtual mapped address on rpages */
> + struct compress_data *cbuf; /* virtual mapped address on cpages */
> + size_t rlen; /* valid data length in rbuf */
> + size_t clen; /* valid data length in cbuf */
> + void *private; /* payload buffer for specified compression algorithm */
> +};
> +
> +/* compress context for write IO path */
> +struct compress_io_ctx {
> + struct inode *inode; /* inode the context belong to */
> + struct page **rpages; /* pages store raw data in cluster */
> + unsigned int nr_rpages; /* total page number in rpages */
> + refcount_t ref; /* referrence count of raw page */
> + u32 magic; /* magic number to indicate page is compressed */
> +};
> +
> +/* decompress io context for read IO path */
> +struct decompress_io_ctx {
> + struct inode *inode; /* inode the context belong to */
> + unsigned int cluster_idx; /* cluster index number */
> + unsigned int cluster_size; /* page count in cluster */
> + unsigned int log_cluster_size; /* log of cluster size */
> + struct page **rpages; /* pages store raw data in cluster */
> + unsigned int nr_rpages; /* total page number in rpages */
> + struct page **cpages; /* pages store compressed data in cluster */
> + unsigned int nr_cpages; /* total page number in cpages */
> + struct page **tpages; /* temp pages to pad holes in cluster */
> + void *rbuf; /* virtual mapped address on rpages */
> + struct compress_data *cbuf; /* virtual mapped address on cpages */
> + size_t rlen; /* valid data length in rbuf */
> + size_t clen; /* valid data length in cbuf */
> + refcount_t ref; /* referrence count of compressed page */
> + bool failed; /* indicate IO error during decompression */
> +};
> +
> +#define NULL_CLUSTER ((unsigned int)(~0))
> +#define MIN_COMPRESS_LOG_SIZE 2
> +#define MAX_COMPRESS_LOG_SIZE 8
> +
> struct f2fs_sb_info {
> struct super_block *sb; /* pointer to VFS super block */
> struct proc_dir_entry *s_proc; /* proc entry */
> @@ -1326,6 +1424,8 @@ struct f2fs_sb_info {
> atomic_t inline_xattr; /* # of inline_xattr inodes */
> atomic_t inline_inode; /* # of inline_data inodes */
> atomic_t inline_dir; /* # of inline_dentry inodes */
> + atomic_t compr_inode; /* # of compressed inodes */
> + atomic_t compr_blocks; /* # of compressed blocks */
> atomic_t aw_cnt; /* # of atomic writes */
> atomic_t vw_cnt; /* # of volatile writes */
> atomic_t max_aw_cnt; /* max # of atomic writes */
> @@ -1364,6 +1464,8 @@ struct f2fs_sb_info {
>
> /* Precomputed FS UUID checksum for seeding other checksums */
> __u32 s_chksum_seed;
> +
> + struct workqueue_struct *post_read_wq; /* post read workqueue */
> };
>
> struct f2fs_private_dio {
> @@ -2377,11 +2479,13 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
> /*
> * On-disk inode flags (f2fs_inode::i_flags)
> */
> +#define F2FS_COMPR_FL 0x00000004 /* Compress file */
> #define F2FS_SYNC_FL 0x00000008 /* Synchronous updates */
> #define F2FS_IMMUTABLE_FL 0x00000010 /* Immutable file */
> #define F2FS_APPEND_FL 0x00000020 /* writes to file may only append */
> #define F2FS_NODUMP_FL 0x00000040 /* do not dump file */
> #define F2FS_NOATIME_FL 0x00000080 /* do not update atime */
> +#define F2FS_NOCOMP_FL 0x00000400 /* Don't compress */
> #define F2FS_INDEX_FL 0x00001000 /* hash-indexed directory */
> #define F2FS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
> #define F2FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
> @@ -2390,7 +2494,7 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
> /* Flags that should be inherited by new inodes from their parent. */
> #define F2FS_FL_INHERITED (F2FS_SYNC_FL | F2FS_NODUMP_FL | F2FS_NOATIME_FL | \
> F2FS_DIRSYNC_FL | F2FS_PROJINHERIT_FL | \
> - F2FS_CASEFOLD_FL)
> + F2FS_CASEFOLD_FL | F2FS_COMPR_FL | F2FS_NOCOMP_FL)
>
> /* Flags that are appropriate for regular files (all but dir-specific ones). */
> #define F2FS_REG_FLMASK (~(F2FS_DIRSYNC_FL | F2FS_PROJINHERIT_FL | \
> @@ -2442,6 +2546,8 @@ enum {
> FI_PIN_FILE, /* indicate file should not be gced */
> FI_ATOMIC_REVOKE_REQUEST, /* request to drop atomic data */
> FI_VERITY_IN_PROGRESS, /* building fs-verity Merkle tree */
> + FI_COMPRESSED_FILE, /* indicate file's data can be compressed */
> + FI_MMAP_FILE, /* indicate file was mmapped */
> };
>
> static inline void __mark_inode_dirty_flag(struct inode *inode,
> @@ -2458,6 +2564,7 @@ static inline void __mark_inode_dirty_flag(struct inode *inode,
> case FI_DATA_EXIST:
> case FI_INLINE_DOTS:
> case FI_PIN_FILE:
> + case FI_COMPRESSED_FILE:
> f2fs_mark_inode_dirty_sync(inode, true);
> }
> }
> @@ -2613,16 +2720,39 @@ static inline int f2fs_has_inline_xattr(struct inode *inode)
> return is_inode_flag_set(inode, FI_INLINE_XATTR);
> }
>
> +static inline int f2fs_compressed_file(struct inode *inode)
> +{
> + return S_ISREG(inode->i_mode) &&
> + is_inode_flag_set(inode, FI_COMPRESSED_FILE);
> +}
> +
> +static inline void set_compress_context(struct inode *inode)
> +{
> + struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> +
> + F2FS_I(inode)->i_compress_algorithm =
> + F2FS_OPTION(sbi).compress_algorithm;
> + F2FS_I(inode)->i_log_cluster_size =
> + F2FS_OPTION(sbi).compress_log_size;
> + F2FS_I(inode)->i_cluster_size =
> + 1 << F2FS_I(inode)->i_log_cluster_size;
> +}
> +
> static inline unsigned int addrs_per_inode(struct inode *inode)
> {
> unsigned int addrs = CUR_ADDRS_PER_INODE(inode) -
> get_inline_xattr_addrs(inode);
> - return ALIGN_DOWN(addrs, 1);
> +
> + if (!f2fs_compressed_file(inode))
> + return addrs;
> + return ALIGN_DOWN(addrs, F2FS_I(inode)->i_cluster_size);
> }
>
> static inline unsigned int addrs_per_block(struct inode *inode)
> {
> - return ALIGN_DOWN(DEF_ADDRS_PER_BLOCK, 1);
> + if (!f2fs_compressed_file(inode))
> + return DEF_ADDRS_PER_BLOCK;
> + return ALIGN_DOWN(DEF_ADDRS_PER_BLOCK, F2FS_I(inode)->i_cluster_size);
> }
>
> static inline void *inline_xattr_addr(struct inode *inode, struct page *page)
> @@ -2655,6 +2785,11 @@ static inline int f2fs_has_inline_dots(struct inode *inode)
> return is_inode_flag_set(inode, FI_INLINE_DOTS);
> }
>
> +static inline int f2fs_is_mmap_file(struct inode *inode)
> +{
> + return is_inode_flag_set(inode, FI_MMAP_FILE);
> +}
> +
> static inline bool f2fs_is_pinned_file(struct inode *inode)
> {
> return is_inode_flag_set(inode, FI_PIN_FILE);
> @@ -2782,7 +2917,8 @@ static inline bool f2fs_may_extent_tree(struct inode *inode)
> struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
>
> if (!test_opt(sbi, EXTENT_CACHE) ||
> - is_inode_flag_set(inode, FI_NO_EXTENT))
> + is_inode_flag_set(inode, FI_NO_EXTENT) ||
> + is_inode_flag_set(inode, FI_COMPRESSED_FILE))
> return false;
>
> /*
> @@ -2896,7 +3032,8 @@ static inline void verify_blkaddr(struct f2fs_sb_info *sbi,
>
> static inline bool __is_valid_data_blkaddr(block_t blkaddr)
> {
> - if (blkaddr == NEW_ADDR || blkaddr == NULL_ADDR)
> + if (blkaddr == NEW_ADDR || blkaddr == NULL_ADDR ||
> + blkaddr == COMPRESS_ADDR)
> return false;
> return true;
> }
> @@ -3198,10 +3335,10 @@ void f2fs_destroy_checkpoint_caches(void);
> /*
> * data.c
> */
> -int f2fs_init_post_read_processing(void);
> -void f2fs_destroy_post_read_processing(void);
> int f2fs_init_bio_entry_cache(void);
> void f2fs_destroy_bio_entry_cache(void);
> +void f2fs_submit_bio(struct f2fs_sb_info *sbi,
> + struct bio *bio, enum page_type type);
> void f2fs_submit_merged_write(struct f2fs_sb_info *sbi, enum page_type type);
> void f2fs_submit_merged_write_cond(struct f2fs_sb_info *sbi,
> struct inode *inode, struct page *page,
> @@ -3222,6 +3359,9 @@ int f2fs_reserve_new_block(struct dnode_of_data *dn);
> int f2fs_get_block(struct dnode_of_data *dn, pgoff_t index);
> int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from);
> int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index);
> +int f2fs_mpage_readpages(struct address_space *mapping,
> + struct list_head *pages, struct page *page,
> + unsigned nr_pages, bool is_readahead);
> struct page *f2fs_get_read_data_page(struct inode *inode, pgoff_t index,
> int op_flags, bool for_write);
> struct page *f2fs_find_data_page(struct inode *inode, pgoff_t index);
> @@ -3235,8 +3375,13 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
> int create, int flag);
> int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
> u64 start, u64 len);
> +int f2fs_encrypt_one_page(struct f2fs_io_info *fio);
> bool f2fs_should_update_inplace(struct inode *inode, struct f2fs_io_info *fio);
> bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio);
> +int f2fs_write_single_data_page(struct page *page, int *submitted,
> + struct bio **bio, sector_t *last_block,
> + struct writeback_control *wbc,
> + enum iostat_type io_type);
> void f2fs_invalidate_page(struct page *page, unsigned int offset,
> unsigned int length);
> int f2fs_release_page(struct page *page, gfp_t wait);
> @@ -3246,6 +3391,10 @@ int f2fs_migrate_page(struct address_space *mapping, struct page *newpage,
> #endif
> bool f2fs_overwrite_io(struct inode *inode, loff_t pos, size_t len);
> void f2fs_clear_page_cache_dirty_tag(struct page *page);
> +int f2fs_init_post_read_processing(void);
> +void f2fs_destroy_post_read_processing(void);
> +int f2fs_init_post_read_wq(struct f2fs_sb_info *sbi);
> +void f2fs_destroy_post_read_wq(struct f2fs_sb_info *sbi);
>
> /*
> * gc.c
> @@ -3292,6 +3441,7 @@ struct f2fs_stat_info {
> int nr_discard_cmd;
> unsigned int undiscard_blks;
> int inline_xattr, inline_inode, inline_dir, append, update, orphans;
> + int compr_inode, compr_blocks;
> int aw_cnt, max_aw_cnt, vw_cnt, max_vw_cnt;
> unsigned int valid_count, valid_node_count, valid_inode_count, discard_blks;
> unsigned int bimodal, avg_vblocks;
> @@ -3362,6 +3512,20 @@ static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)
> if (f2fs_has_inline_dentry(inode)) \
> (atomic_dec(&F2FS_I_SB(inode)->inline_dir)); \
> } while (0)
> +#define stat_inc_compr_inode(inode) \
> + do { \
> + if (f2fs_compressed_file(inode)) \
> + (atomic_inc(&F2FS_I_SB(inode)->compr_inode)); \
> + } while (0)
> +#define stat_dec_compr_inode(inode) \
> + do { \
> + if (f2fs_compressed_file(inode)) \
> + (atomic_dec(&F2FS_I_SB(inode)->compr_inode)); \
> + } while (0)
> +#define stat_add_compr_blocks(inode, blocks) \
> + (atomic_add(blocks, &F2FS_I_SB(inode)->compr_blocks))
> +#define stat_sub_compr_blocks(inode, blocks) \
> + (atomic_sub(blocks, &F2FS_I_SB(inode)->compr_blocks))
> #define stat_inc_meta_count(sbi, blkaddr) \
> do { \
> if (blkaddr < SIT_I(sbi)->sit_base_addr) \
> @@ -3456,6 +3620,10 @@ void f2fs_destroy_root_stats(void);
> #define stat_dec_inline_inode(inode) do { } while (0)
> #define stat_inc_inline_dir(inode) do { } while (0)
> #define stat_dec_inline_dir(inode) do { } while (0)
> +#define stat_inc_compr_inode(inode) do { } while (0)
> +#define stat_dec_compr_inode(inode) do { } while (0)
> +#define stat_add_compr_blocks(inode) do { } while (0)
> +#define stat_sub_compr_blocks(inode) do { } while (0)
> #define stat_inc_atomic_write(inode) do { } while (0)
> #define stat_dec_atomic_write(inode) do { } while (0)
> #define stat_update_max_atomic_write(inode) do { } while (0)
> @@ -3595,8 +3763,57 @@ static inline void f2fs_set_encrypted_inode(struct inode *inode)
> */
> static inline bool f2fs_post_read_required(struct inode *inode)
> {
> - return f2fs_encrypted_file(inode) || fsverity_active(inode);
> + return f2fs_encrypted_file(inode) || fsverity_active(inode) ||
> + f2fs_compressed_file(inode);
> +}
> +
> +/*
> + * compress.c
> + */
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> +bool f2fs_is_compressed_page(struct page *page);
> +struct page *f2fs_compress_control_page(struct page *page);
> +void f2fs_reset_compress_ctx(struct compress_ctx *cc);
> +int f2fs_prepare_compress_overwrite(struct inode *inode,
> + struct page **pagep, pgoff_t index, void **fsdata);
> +bool f2fs_compress_write_end(struct inode *inode, void *fsdata,
> + pgoff_t index, bool written);
> +void f2fs_compress_write_end_io(struct bio *bio, struct page *page);
> +bool f2fs_is_compress_backend_ready(struct inode *inode);
> +void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity);
> +bool f2fs_cluster_is_empty(struct compress_ctx *cc);
> +bool f2fs_cluster_can_merge_page(struct compress_ctx *cc, pgoff_t index);
> +void f2fs_compress_ctx_add_page(struct compress_ctx *cc, struct page *page);
> +int f2fs_write_multi_pages(struct compress_ctx *cc,
> + int *submitted,
> + struct writeback_control *wbc,
> + enum iostat_type io_type);
> +int f2fs_is_compressed_cluster(struct inode *inode, pgoff_t index);
> +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);
> +struct decompress_io_ctx *f2fs_alloc_dic(struct compress_ctx *cc);
> +void f2fs_free_dic(struct decompress_io_ctx *dic);
> +void f2fs_set_cluster_uptodate(struct page **rpages,
> + unsigned int cluster_size, bool err, bool verity);
> +int f2fs_init_compress_ctx(struct compress_ctx *cc);
> +void f2fs_destroy_compress_ctx(struct compress_ctx *cc);
> +void f2fs_init_compress_info(struct f2fs_sb_info *sbi);
> +#else
> +static inline bool f2fs_is_compressed_page(struct page *page) { return false; }
> +static inline bool f2fs_is_compress_backend_ready(struct inode *inode)
> +{
> + if (!f2fs_compressed_file(inode))
> + return true;
> + /* not support compression */
> + return false;
> +}
> +static inline struct page *f2fs_compress_control_page(struct page *page)
> +{
> + WARN_ON_ONCE(1);
> + return ERR_PTR(-EINVAL);
> }
> +#endif
>
> #define F2FS_FEATURE_FUNCS(name, flagname) \
> static inline int f2fs_sb_has_##name(struct f2fs_sb_info *sbi) \
> @@ -3616,6 +3833,7 @@ F2FS_FEATURE_FUNCS(lost_found, LOST_FOUND);
> F2FS_FEATURE_FUNCS(verity, VERITY);
> F2FS_FEATURE_FUNCS(sb_chksum, SB_CHKSUM);
> F2FS_FEATURE_FUNCS(casefold, CASEFOLD);
> +F2FS_FEATURE_FUNCS(compression, COMPRESSION);
>
> #ifdef CONFIG_BLK_DEV_ZONED
> static inline bool f2fs_blkz_is_seq(struct f2fs_sb_info *sbi, int devi,
> @@ -3697,6 +3915,15 @@ static inline bool f2fs_may_encrypt(struct inode *inode)
> #endif
> }
>
> +static inline bool f2fs_may_compress(struct inode *inode)
> +{
> + if (IS_SWAPFILE(inode) || f2fs_is_pinned_file(inode) ||
> + f2fs_is_atomic_file(inode) ||
> + f2fs_is_volatile_file(inode))
> + return false;
> + return S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode);
> +}
> +
> static inline int block_unaligned_IO(struct inode *inode,
> struct kiocb *iocb, struct iov_iter *iter)
> {
> @@ -3728,6 +3955,8 @@ static inline bool f2fs_force_buffered_io(struct inode *inode,
> return true;
> if (f2fs_is_multi_device(sbi))
> return true;
> + if (f2fs_compressed_file(inode))
> + return true;
> /*
> * for blkzoned device, fallback direct IO to buffered IO, so
> * all IOs can be serialized by log-structured write.
> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
> index a7d855efc294..15a7c5f1bc9f 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
> @@ -51,7 +51,8 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
> struct inode *inode = file_inode(vmf->vma->vm_file);
> struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> struct dnode_of_data dn = { .node_changed = false };
> - int err;
> + bool need_alloc = true;
> + int err = 0;
>
> if (unlikely(f2fs_cp_error(sbi))) {
> err = -EIO;
> @@ -63,6 +64,20 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
> goto err;
> }
>
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> + if (f2fs_compressed_file(inode)) {
> + int ret = f2fs_is_compressed_cluster(inode, page->index);
> +
> + if (ret < 0) {
> + err = ret;
> + goto err;
> + } else if (ret) {
> + f2fs_bug_on(sbi, ret == CLUSTER_HAS_SPACE);
> + need_alloc = false;
> + }
> + }
> +#endif
> +
> sb_start_pagefault(inode->i_sb);
>
> f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
> @@ -78,15 +93,17 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
> goto out_sem;
> }
>
> - /* block allocation */
> - __do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, true);
> - set_new_dnode(&dn, inode, NULL, NULL, 0);
> - err = f2fs_get_block(&dn, page->index);
> - f2fs_put_dnode(&dn);
> - __do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, false);
> - if (err) {
> - unlock_page(page);
> - goto out_sem;
> + if (need_alloc) {
> + /* block allocation */
> + __do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, true);
> + set_new_dnode(&dn, inode, NULL, NULL, 0);
> + err = f2fs_get_block(&dn, page->index);
> + f2fs_put_dnode(&dn);
> + __do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, false);
> + if (err) {
> + unlock_page(page);
> + goto out_sem;
> + }
> }
>
> /* fill the page */
> @@ -485,6 +502,9 @@ static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
> if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
> return -EIO;
>
> + if (!f2fs_is_compress_backend_ready(inode))
> + return -EOPNOTSUPP;
> +
> /* we don't need to use inline_data strictly */
> err = f2fs_convert_inline_inode(inode);
> if (err)
> @@ -492,6 +512,7 @@ static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
>
> file_accessed(file);
> vma->vm_ops = &f2fs_file_vm_ops;
> + set_inode_flag(inode, FI_MMAP_FILE);
> return 0;
> }
>
> @@ -518,6 +539,9 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
> int nr_free = 0, ofs = dn->ofs_in_node, len = count;
> __le32 *addr;
> int base = 0;
> + bool compressed_cluster = false;
> + int cluster_index = 0, valid_blocks = 0;
> + int cluster_size = F2FS_I(dn->inode)->i_cluster_size;
>
> if (IS_INODE(dn->node_page) && f2fs_has_extra_attr(dn->inode))
> base = get_extra_isize(dn->inode);
> @@ -525,26 +549,51 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
> raw_node = F2FS_NODE(dn->node_page);
> addr = blkaddr_in_node(raw_node) + base + ofs;
>
> - for (; count > 0; count--, addr++, dn->ofs_in_node++) {
> + /* Assumption: truncateion starts with cluster */
> + for (; count > 0; count--, addr++, dn->ofs_in_node++, cluster_index++) {
> block_t blkaddr = le32_to_cpu(*addr);
>
> + if (f2fs_compressed_file(dn->inode) &&
> + !(cluster_index & (cluster_size - 1))) {
> + if (compressed_cluster) {
> + int compr_blocks = cluster_size - valid_blocks;
> +
> + stat_sub_compr_blocks(dn->inode, compr_blocks);
> + F2FS_I(dn->inode)->i_compressed_blocks -=
> + compr_blocks;
> + }
> + compressed_cluster = (blkaddr == COMPRESS_ADDR);
> + valid_blocks = 0;
> + }
> +
> if (blkaddr == NULL_ADDR)
> continue;
>
> dn->data_blkaddr = NULL_ADDR;
> f2fs_set_data_blkaddr(dn);
>
> - if (__is_valid_data_blkaddr(blkaddr) &&
> - !f2fs_is_valid_blkaddr(sbi, blkaddr,
> + if (__is_valid_data_blkaddr(blkaddr)) {
> + if (!f2fs_is_valid_blkaddr(sbi, blkaddr,
> DATA_GENERIC_ENHANCE))
> - continue;
> + continue;
> + if (compressed_cluster)
> + valid_blocks++;
> + }
>
> - f2fs_invalidate_blocks(sbi, blkaddr);
> if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
> clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN);
> +
> + f2fs_invalidate_blocks(sbi, blkaddr);
> nr_free++;
> }
>
> + if (compressed_cluster) {
> + int compr_blocks = cluster_size - valid_blocks;
> +
> + stat_sub_compr_blocks(dn->inode, compr_blocks);
> + F2FS_I(dn->inode)->i_compressed_blocks -= compr_blocks;
> + }
> +
> if (nr_free) {
> pgoff_t fofs;
> /*
> @@ -587,6 +636,9 @@ static int truncate_partial_data_page(struct inode *inode, u64 from,
> return 0;
> }
>
> + if (f2fs_compressed_file(inode))
> + return 0;
> +
> page = f2fs_get_lock_data_page(inode, index, true);
> if (IS_ERR(page))
> return PTR_ERR(page) == -ENOENT ? 0 : PTR_ERR(page);
> @@ -602,7 +654,7 @@ static int truncate_partial_data_page(struct inode *inode, u64 from,
> return 0;
> }
>
> -int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock)
> +static int do_truncate_blocks(struct inode *inode, u64 from, bool lock)
> {
> struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> struct dnode_of_data dn;
> @@ -667,6 +719,24 @@ int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock)
> return err;
> }
>
> +int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock)
> +{
> + u64 free_from = from;
> +
> + /*
> + * for compressed file, only support cluster size
> + * aligned truncation.
> + */
> + if (f2fs_compressed_file(inode)) {
> + size_t cluster_size = PAGE_SIZE <<
> + F2FS_I(inode)->i_log_cluster_size;
> +
> + free_from = roundup(from, cluster_size);
> + }
> +
> + return do_truncate_blocks(inode, free_from, lock);
> +}
> +
> int f2fs_truncate(struct inode *inode)
> {
> int err;
> @@ -783,6 +853,10 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
> if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
> return -EIO;
>
> + if ((attr->ia_valid & ATTR_SIZE) &&
> + !f2fs_is_compress_backend_ready(inode))
> + return -EOPNOTSUPP;
> +
> err = setattr_prepare(dentry, attr);
> if (err)
> return err;
> @@ -1023,8 +1097,8 @@ static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr,
> } else if (ret == -ENOENT) {
> if (dn.max_level == 0)
> return -ENOENT;
> - done = min((pgoff_t)ADDRS_PER_BLOCK(inode) - dn.ofs_in_node,
> - len);
> + done = min((pgoff_t)ADDRS_PER_BLOCK(inode) -
> + dn.ofs_in_node, len);
> blkaddr += done;
> do_replace += done;
> goto next;
> @@ -1615,6 +1689,8 @@ static long f2fs_fallocate(struct file *file, int mode,
> return -EIO;
> if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
> return -ENOSPC;
> + if (!f2fs_is_compress_backend_ready(inode))
> + return -EOPNOTSUPP;
>
> /* f2fs only support ->fallocate for regular file */
> if (!S_ISREG(inode->i_mode))
> @@ -1624,6 +1700,11 @@ static long f2fs_fallocate(struct file *file, int mode,
> (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)))
> return -EOPNOTSUPP;
>
> + if (f2fs_compressed_file(inode) &&
> + (mode & (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_COLLAPSE_RANGE |
> + FALLOC_FL_ZERO_RANGE | FALLOC_FL_INSERT_RANGE)))
> + return -EOPNOTSUPP;
> +
> if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
> FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |
> FALLOC_FL_INSERT_RANGE))
> @@ -1713,7 +1794,42 @@ static int f2fs_setflags_common(struct inode *inode, u32 iflags, u32 mask)
> return -ENOTEMPTY;
> }
>
> + if (iflags & (F2FS_COMPR_FL | F2FS_NOCOMP_FL)) {
> + if (!f2fs_sb_has_compression(F2FS_I_SB(inode)))
> + return -EOPNOTSUPP;
> + if ((iflags & F2FS_COMPR_FL) && (iflags & F2FS_NOCOMP_FL))
> + return -EINVAL;
> + }
> +
> + if ((iflags ^ fi->i_flags) & F2FS_COMPR_FL) {
> + if (S_ISREG(inode->i_mode) &&
> + (fi->i_flags & F2FS_COMPR_FL || i_size_read(inode) ||
> + F2FS_HAS_BLOCKS(inode)))
> + return -EINVAL;
> + if (iflags & F2FS_NOCOMP_FL)
> + return -EINVAL;
> + if (iflags & F2FS_COMPR_FL) {
> + int err = f2fs_convert_inline_inode(inode);
> +
> + if (err)
> + return err;
> +
> + if (!f2fs_may_compress(inode))
> + return -EINVAL;
> +
> + set_compress_context(inode);
> + set_inode_flag(inode, FI_COMPRESSED_FILE);
> + stat_inc_compr_inode(inode);
> + }
> + }
> + if ((iflags ^ fi->i_flags) & F2FS_NOCOMP_FL) {
> + if (fi->i_flags & F2FS_COMPR_FL)
> + return -EINVAL;
> + }
> +
> fi->i_flags = iflags | (fi->i_flags & ~mask);
> + f2fs_bug_on(F2FS_I_SB(inode), (fi->i_flags & F2FS_COMPR_FL) &&
> + (fi->i_flags & F2FS_NOCOMP_FL));
>
> if (fi->i_flags & F2FS_PROJINHERIT_FL)
> set_inode_flag(inode, FI_PROJ_INHERIT);
> @@ -1739,11 +1855,13 @@ static const struct {
> u32 iflag;
> u32 fsflag;
> } f2fs_fsflags_map[] = {
> + { F2FS_COMPR_FL, FS_COMPR_FL },
> { F2FS_SYNC_FL, FS_SYNC_FL },
> { F2FS_IMMUTABLE_FL, FS_IMMUTABLE_FL },
> { F2FS_APPEND_FL, FS_APPEND_FL },
> { F2FS_NODUMP_FL, FS_NODUMP_FL },
> { F2FS_NOATIME_FL, FS_NOATIME_FL },
> + { F2FS_NOCOMP_FL, FS_NOCOMP_FL },
> { F2FS_INDEX_FL, FS_INDEX_FL },
> { F2FS_DIRSYNC_FL, FS_DIRSYNC_FL },
> { F2FS_PROJINHERIT_FL, FS_PROJINHERIT_FL },
> @@ -1751,11 +1869,13 @@ static const struct {
> };
>
> #define F2FS_GETTABLE_FS_FL ( \
> + FS_COMPR_FL | \
> FS_SYNC_FL | \
> FS_IMMUTABLE_FL | \
> FS_APPEND_FL | \
> FS_NODUMP_FL | \
> FS_NOATIME_FL | \
> + FS_NOCOMP_FL | \
> FS_INDEX_FL | \
> FS_DIRSYNC_FL | \
> FS_PROJINHERIT_FL | \
> @@ -1766,11 +1886,13 @@ static const struct {
> FS_CASEFOLD_FL)
>
> #define F2FS_SETTABLE_FS_FL ( \
> + FS_COMPR_FL | \
> FS_SYNC_FL | \
> FS_IMMUTABLE_FL | \
> FS_APPEND_FL | \
> FS_NODUMP_FL | \
> FS_NOATIME_FL | \
> + FS_NOCOMP_FL | \
> FS_DIRSYNC_FL | \
> FS_PROJINHERIT_FL | \
> FS_CASEFOLD_FL)
> @@ -1891,6 +2013,12 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
>
> inode_lock(inode);
>
> + if (f2fs_compressed_file(inode) && !fi->i_compressed_blocks) {
> + fi->i_flags &= ~F2FS_COMPR_FL;
> + clear_inode_flag(inode, FI_COMPRESSED_FILE);
> + stat_dec_compr_inode(inode);
> + }
> +
> if (f2fs_is_atomic_file(inode)) {
> if (is_inode_flag_set(inode, FI_ATOMIC_REVOKE_REQUEST))
> ret = -EINVAL;
> @@ -3091,6 +3219,17 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
> ret = -EAGAIN;
> goto out;
> }
> +
> + if (f2fs_compressed_file(inode)) {
> + if (F2FS_I(inode)->i_compressed_blocks) {
> + ret = -EOPNOTSUPP;
> + goto out;
> + }
> + F2FS_I(inode)->i_flags &= ~F2FS_COMPR_FL;
> + clear_inode_flag(inode, FI_COMPRESSED_FILE);
> + stat_dec_compr_inode(inode);
> + }
> +
> ret = f2fs_convert_inline_inode(inode);
> if (ret)
> goto out;
> @@ -3343,6 +3482,17 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
> }
> }
>
> +static ssize_t f2fs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
> +{
> + struct file *file = iocb->ki_filp;
> + struct inode *inode = file_inode(file);
> +
> + if (!f2fs_is_compress_backend_ready(inode))
> + return -EOPNOTSUPP;
> +
> + return generic_file_read_iter(iocb, iter);
> +}
> +
> static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> {
> struct file *file = iocb->ki_filp;
> @@ -3354,6 +3504,9 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> goto out;
> }
>
> + if (!f2fs_is_compress_backend_ready(inode))
> + return -EOPNOTSUPP;
> +
> if (iocb->ki_flags & IOCB_NOWAIT) {
> if (!inode_trylock(inode)) {
> ret = -EAGAIN;
> @@ -3467,7 +3620,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
>
> const struct file_operations f2fs_file_operations = {
> .llseek = f2fs_llseek,
> - .read_iter = generic_file_read_iter,
> + .read_iter = f2fs_file_read_iter,
> .write_iter = f2fs_file_write_iter,
> .open = f2fs_file_open,
> .release = f2fs_release_file,
> diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
> index 502bd491336a..7a85060adad5 100644
> --- a/fs/f2fs/inode.c
> +++ b/fs/f2fs/inode.c
> @@ -200,6 +200,7 @@ static bool sanity_check_inode(struct inode *inode, struct page *node_page)
> {
> struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> struct f2fs_inode_info *fi = F2FS_I(inode);
> + struct f2fs_inode *ri = F2FS_INODE(node_page);
> unsigned long long iblocks;
>
> iblocks = le64_to_cpu(F2FS_INODE(node_page)->i_blocks);
> @@ -286,6 +287,19 @@ static bool sanity_check_inode(struct inode *inode, struct page *node_page)
> return false;
> }
>
> + if (f2fs_has_extra_attr(inode) && f2fs_sb_has_compression(sbi) &&
> + fi->i_flags & F2FS_COMPR_FL &&
> + F2FS_FITS_IN_INODE(ri, fi->i_extra_isize,
> + i_log_cluster_size)) {
> + if (ri->i_compress_algorithm >= COMPRESS_MAX)
> + return false;
> + if (le64_to_cpu(ri->i_compressed_blocks) > inode->i_blocks)
> + return false;
> + if (ri->i_log_cluster_size < MIN_COMPRESS_LOG_SIZE ||
> + ri->i_log_cluster_size > MAX_COMPRESS_LOG_SIZE)
> + return false;
> + }
> +
> return true;
> }
>
> @@ -407,6 +421,20 @@ static int do_read_inode(struct inode *inode)
> fi->i_crtime.tv_nsec = le32_to_cpu(ri->i_crtime_nsec);
> }
>
> + if (f2fs_has_extra_attr(inode) && f2fs_sb_has_compression(sbi)) {
> + if (F2FS_FITS_IN_INODE(ri, fi->i_extra_isize,
> + i_log_cluster_size)) {
> + fi->i_compressed_blocks =
> + le64_to_cpu(ri->i_compressed_blocks);
> + fi->i_compress_algorithm = ri->i_compress_algorithm;
> + fi->i_log_cluster_size = ri->i_log_cluster_size;
> + fi->i_cluster_size = 1 << fi->i_log_cluster_size;
> + }
> +
> + if ((fi->i_flags & F2FS_COMPR_FL) && f2fs_may_compress(inode))
> + set_inode_flag(inode, FI_COMPRESSED_FILE);
> + }
> +
> F2FS_I(inode)->i_disk_time[0] = inode->i_atime;
> F2FS_I(inode)->i_disk_time[1] = inode->i_ctime;
> F2FS_I(inode)->i_disk_time[2] = inode->i_mtime;
> @@ -416,6 +444,8 @@ static int do_read_inode(struct inode *inode)
> stat_inc_inline_xattr(inode);
> stat_inc_inline_inode(inode);
> stat_inc_inline_dir(inode);
> + stat_inc_compr_inode(inode);
> + stat_add_compr_blocks(inode, F2FS_I(inode)->i_compressed_blocks);
>
> return 0;
> }
> @@ -569,6 +599,17 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page)
> ri->i_crtime_nsec =
> cpu_to_le32(F2FS_I(inode)->i_crtime.tv_nsec);
> }
> +
> + if (f2fs_sb_has_compression(F2FS_I_SB(inode)) &&
> + F2FS_FITS_IN_INODE(ri, F2FS_I(inode)->i_extra_isize,
> + i_log_cluster_size)) {
> + ri->i_compressed_blocks =
> + cpu_to_le64(F2FS_I(inode)->i_compressed_blocks);
> + ri->i_compress_algorithm =
> + F2FS_I(inode)->i_compress_algorithm;
> + ri->i_log_cluster_size =
> + F2FS_I(inode)->i_log_cluster_size;
> + }
> }
>
> __set_inode_rdev(inode, ri);
> @@ -711,6 +752,8 @@ void f2fs_evict_inode(struct inode *inode)
> stat_dec_inline_xattr(inode);
> stat_dec_inline_dir(inode);
> stat_dec_inline_inode(inode);
> + stat_dec_compr_inode(inode);
> + stat_sub_compr_blocks(inode, F2FS_I(inode)->i_compressed_blocks);
>
> if (likely(!f2fs_cp_error(sbi) &&
> !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
> diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
> index d8ca896e109b..5490348bcc6a 100644
> --- a/fs/f2fs/namei.c
> +++ b/fs/f2fs/namei.c
> @@ -119,6 +119,17 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
> if (F2FS_I(inode)->i_flags & F2FS_PROJINHERIT_FL)
> set_inode_flag(inode, FI_PROJ_INHERIT);
>
> + if (f2fs_sb_has_compression(sbi)) {
> + /* Inherit the compression flag in directory */
> + if ((F2FS_I(dir)->i_flags & F2FS_COMPR_FL) &&
> + f2fs_may_compress(inode)) {
> + set_compress_context(inode);
> + F2FS_I(inode)->i_flags |= F2FS_COMPR_FL;
> + set_inode_flag(inode, FI_COMPRESSED_FILE);
> + stat_inc_compr_inode(inode);
> + }
> + }
> +
> f2fs_set_inode_flags(inode);
>
> trace_f2fs_new_inode(inode, 0);
> @@ -149,6 +160,9 @@ static inline int is_extension_exist(const unsigned char *s, const char *sub)
> size_t sublen = strlen(sub);
> int i;
>
> + if (sublen == 1 && *sub == '*')
> + return 1;
> +
> /*
> * filename format of multimedia file should be defined as:
> * "filename + '.' + extension + (optional: '.' + temp extension)".
> @@ -262,6 +276,48 @@ int f2fs_update_extension_list(struct f2fs_sb_info *sbi, const char *name,
> return 0;
> }
>
> +static void set_compress_inode(struct f2fs_sb_info *sbi, struct inode *inode,
> + const unsigned char *name)
> +{
> + __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
> + unsigned char (*ext)[F2FS_EXTENSION_LEN];
> + unsigned int ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
> + int i, cold_count, hot_count;
> +
> + if (!f2fs_sb_has_compression(sbi) ||
> + is_inode_flag_set(inode, FI_COMPRESSED_FILE) ||
> + F2FS_I(inode)->i_flags & F2FS_NOCOMP_FL ||
> + !f2fs_may_compress(inode))
> + return;
> +
> + down_read(&sbi->sb_lock);
> +
> + cold_count = le32_to_cpu(sbi->raw_super->extension_count);
> + hot_count = sbi->raw_super->hot_ext_count;
> +
> + for (i = cold_count; i < cold_count + hot_count; i++) {
> + if (is_extension_exist(name, extlist[i])) {
> + up_read(&sbi->sb_lock);
> + return;
> + }
> + }
> +
> + up_read(&sbi->sb_lock);
> +
> + ext = F2FS_OPTION(sbi).extensions;
> +
> + for (i = 0; i < ext_cnt; i++) {
> + if (!is_extension_exist(name, ext[i]))
> + continue;
> +
> + F2FS_I(inode)->i_flags |= F2FS_COMPR_FL;
> + set_compress_context(inode);
> + set_inode_flag(inode, FI_COMPRESSED_FILE);
> + stat_inc_compr_inode(inode);
> + return;
> + }
> +}
> +
> static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
> bool excl)
> {
> @@ -286,6 +342,8 @@ static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
> if (!test_opt(sbi, DISABLE_EXT_IDENTIFY))
> set_file_temperature(sbi, inode, dentry->d_name.name);
>
> + set_compress_inode(sbi, inode, dentry->d_name.name);
> +
> inode->i_op = &f2fs_file_inode_operations;
> inode->i_fop = &f2fs_file_operations;
> inode->i_mapping->a_ops = &f2fs_dblock_aops;
> @@ -297,6 +355,7 @@ static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
> goto out;
> f2fs_unlock_op(sbi);
>
> + stat_inc_compr_inode(inode);
> f2fs_alloc_nid_done(sbi, ino);
>
> d_instantiate_new(dentry, inode);
> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
> index 8c96d6008e20..8b977bbd6822 100644
> --- a/fs/f2fs/segment.c
> +++ b/fs/f2fs/segment.c
> @@ -2215,7 +2215,7 @@ void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr)
> struct sit_info *sit_i = SIT_I(sbi);
>
> f2fs_bug_on(sbi, addr == NULL_ADDR);
> - if (addr == NEW_ADDR)
> + if (addr == NEW_ADDR || addr == COMPRESS_ADDR)
> return;
>
> invalidate_mapping_pages(META_MAPPING(sbi), addr, addr);
> @@ -3022,7 +3022,8 @@ static int __get_segment_type_6(struct f2fs_io_info *fio)
> if (fio->type == DATA) {
> struct inode *inode = fio->page->mapping->host;
>
> - if (is_cold_data(fio->page) || file_is_cold(inode))
> + if (is_cold_data(fio->page) || file_is_cold(inode) ||
> + f2fs_compressed_file(inode))
> return CURSEG_COLD_DATA;
> if (file_is_hot(inode) ||
> is_inode_flag_set(inode, FI_HOT_DATA) ||
> diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
> index a95467b202ea..a1b3951367cd 100644
> --- a/fs/f2fs/segment.h
> +++ b/fs/f2fs/segment.h
> @@ -200,18 +200,6 @@ struct segment_allocation {
> void (*allocate_segment)(struct f2fs_sb_info *, int, bool);
> };
>
> -/*
> - * this value is set in page as a private data which indicate that
> - * the page is atomically written, and it is in inmem_pages list.
> - */
> -#define ATOMIC_WRITTEN_PAGE ((unsigned long)-1)
> -#define DUMMY_WRITTEN_PAGE ((unsigned long)-2)
> -
> -#define IS_ATOMIC_WRITTEN_PAGE(page) \
> - (page_private(page) == (unsigned long)ATOMIC_WRITTEN_PAGE)
> -#define IS_DUMMY_WRITTEN_PAGE(page) \
> - (page_private(page) == (unsigned long)DUMMY_WRITTEN_PAGE)
> -
> #define MAX_SKIP_GC_COUNT 16
>
> struct inmem_pages {
> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> index b72d071aedd8..a543ee6b898c 100644
> --- a/fs/f2fs/super.c
> +++ b/fs/f2fs/super.c
> @@ -141,6 +141,9 @@ enum {
> Opt_checkpoint_disable_cap,
> Opt_checkpoint_disable_cap_perc,
> Opt_checkpoint_enable,
> + Opt_compress_algorithm,
> + Opt_compress_log_size,
> + Opt_compress_extension,
> Opt_err,
> };
>
> @@ -203,6 +206,9 @@ static match_table_t f2fs_tokens = {
> {Opt_checkpoint_disable_cap, "checkpoint=disable:%u"},
> {Opt_checkpoint_disable_cap_perc, "checkpoint=disable:%u%%"},
> {Opt_checkpoint_enable, "checkpoint=enable"},
> + {Opt_compress_algorithm, "compress_algorithm=%s"},
> + {Opt_compress_log_size, "compress_log_size=%u"},
> + {Opt_compress_extension, "compress_extension=%s"},
> {Opt_err, NULL},
> };
>
> @@ -391,8 +397,9 @@ static int parse_options(struct super_block *sb, char *options)
> {
> struct f2fs_sb_info *sbi = F2FS_SB(sb);
> substring_t args[MAX_OPT_ARGS];
> + unsigned char (*ext)[F2FS_EXTENSION_LEN];
> char *p, *name;
> - int arg = 0;
> + int arg = 0, ext_cnt;
> kuid_t uid;
> kgid_t gid;
> #ifdef CONFIG_QUOTA
> @@ -810,6 +817,66 @@ static int parse_options(struct super_block *sb, char *options)
> case Opt_checkpoint_enable:
> clear_opt(sbi, DISABLE_CHECKPOINT);
> break;
> + case Opt_compress_algorithm:
> + if (!f2fs_sb_has_compression(sbi)) {
> + f2fs_err(sbi, "Compression feature if off");
> + return -EINVAL;
> + }
> + name = match_strdup(&args[0]);
> + if (!name)
> + return -ENOMEM;
> + if (strlen(name) == 3 && !strcmp(name, "lzo")) {
> + F2FS_OPTION(sbi).compress_algorithm =
> + COMPRESS_LZO;
> + } else if (strlen(name) == 3 &&
> + !strcmp(name, "lz4")) {
> + F2FS_OPTION(sbi).compress_algorithm =
> + COMPRESS_LZ4;
> + } else {
> + kfree(name);
> + return -EINVAL;
> + }
> + kfree(name);
> + break;
> + case Opt_compress_log_size:
> + if (!f2fs_sb_has_compression(sbi)) {
> + f2fs_err(sbi, "Compression feature is off");
> + return -EINVAL;
> + }
> + if (args->from && match_int(args, &arg))
> + return -EINVAL;
> + if (arg < MIN_COMPRESS_LOG_SIZE ||
> + arg > MAX_COMPRESS_LOG_SIZE) {
> + f2fs_err(sbi,
> + "Compress cluster log size is out of range");
> + return -EINVAL;
> + }
> + F2FS_OPTION(sbi).compress_log_size = arg;
> + break;
> + case Opt_compress_extension:
> + if (!f2fs_sb_has_compression(sbi)) {
> + f2fs_err(sbi, "Compression feature is off");
> + return -EINVAL;
> + }
> + name = match_strdup(&args[0]);
> + if (!name)
> + return -ENOMEM;
> +
> + ext = F2FS_OPTION(sbi).extensions;
> + ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
> +
> + if (strlen(name) >= F2FS_EXTENSION_LEN ||
> + ext_cnt >= COMPRESS_EXT_NUM) {
> + f2fs_err(sbi,
> + "invalid extension length/number");
> + kfree(name);
> + return -EINVAL;
> + }
> +
> + strcpy(ext[ext_cnt], name);
> + F2FS_OPTION(sbi).compress_ext_cnt++;
> + kfree(name);
> + break;
> default:
> f2fs_err(sbi, "Unrecognized mount option \"%s\" or missing value",
> p);
> @@ -1125,6 +1192,8 @@ static void f2fs_put_super(struct super_block *sb)
> f2fs_destroy_node_manager(sbi);
> f2fs_destroy_segment_manager(sbi);
>
> + f2fs_destroy_post_read_wq(sbi);
> +
> kfree(sbi->ckpt);
>
> f2fs_unregister_sysfs(sbi);
> @@ -1332,6 +1401,35 @@ static inline void f2fs_show_quota_options(struct seq_file *seq,
> #endif
> }
>
> +static inline void f2fs_show_compress_options(struct seq_file *seq,
> + struct super_block *sb)
> +{
> + struct f2fs_sb_info *sbi = F2FS_SB(sb);
> + char *algtype = "";
> + int i;
> +
> + if (!f2fs_sb_has_compression(sbi))
> + return;
> +
> + switch (F2FS_OPTION(sbi).compress_algorithm) {
> + case COMPRESS_LZO:
> + algtype = "lzo";
> + break;
> + case COMPRESS_LZ4:
> + algtype = "lz4";
> + break;
> + }
> + seq_printf(seq, ",compress_algorithm=%s", algtype);
> +
> + seq_printf(seq, ",compress_log_size=%u",
> + F2FS_OPTION(sbi).compress_log_size);
> +
> + for (i = 0; i < F2FS_OPTION(sbi).compress_ext_cnt; i++) {
> + seq_printf(seq, ",compress_extension=%s",
> + F2FS_OPTION(sbi).extensions[i]);
> + }
> +}
> +
> static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
> {
> struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb);
> @@ -1454,6 +1552,8 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
> seq_printf(seq, ",fsync_mode=%s", "strict");
> else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_NOBARRIER)
> seq_printf(seq, ",fsync_mode=%s", "nobarrier");
> +
> + f2fs_show_compress_options(seq, sbi->sb);
> return 0;
> }
>
> @@ -1468,6 +1568,9 @@ static void default_options(struct f2fs_sb_info *sbi)
> F2FS_OPTION(sbi).test_dummy_encryption = false;
> F2FS_OPTION(sbi).s_resuid = make_kuid(&init_user_ns, F2FS_DEF_RESUID);
> F2FS_OPTION(sbi).s_resgid = make_kgid(&init_user_ns, F2FS_DEF_RESGID);
> + F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZO;
> + F2FS_OPTION(sbi).compress_log_size = MIN_COMPRESS_LOG_SIZE;
> + F2FS_OPTION(sbi).compress_ext_cnt = 0;
>
> set_opt(sbi, BG_GC);
> set_opt(sbi, INLINE_XATTR);
> @@ -3397,6 +3500,12 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
> goto free_devices;
> }
>
> + err = f2fs_init_post_read_wq(sbi);
> + if (err) {
> + f2fs_err(sbi, "Failed to initialize post read workqueue");
> + goto free_devices;
> + }
> +
> sbi->total_valid_node_count =
> le32_to_cpu(sbi->ckpt->valid_node_count);
> percpu_counter_set(&sbi->total_valid_inode_count,
> @@ -3618,6 +3727,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
> f2fs_destroy_node_manager(sbi);
> free_sm:
> f2fs_destroy_segment_manager(sbi);
> + f2fs_destroy_post_read_wq(sbi);
> free_devices:
> destroy_device_list(sbi);
> kfree(sbi->ckpt);
> diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
> index f164959e4224..612a2b16d55c 100644
> --- a/fs/f2fs/sysfs.c
> +++ b/fs/f2fs/sysfs.c
> @@ -154,6 +154,9 @@ static ssize_t features_show(struct f2fs_attr *a,
> if (f2fs_sb_has_casefold(sbi))
> len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
> len ? ", " : "", "casefold");
> + if (f2fs_sb_has_compression(sbi))
> + len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
> + len ? ", " : "", "compression");
> len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
> len ? ", " : "", "pin_file");
> len += snprintf(buf + len, PAGE_SIZE - len, "\n");
> @@ -389,6 +392,7 @@ enum feat_id {
> FEAT_VERITY,
> FEAT_SB_CHECKSUM,
> FEAT_CASEFOLD,
> + FEAT_COMPRESSION,
> };
>
> static ssize_t f2fs_feature_show(struct f2fs_attr *a,
> @@ -408,6 +412,7 @@ static ssize_t f2fs_feature_show(struct f2fs_attr *a,
> case FEAT_VERITY:
> case FEAT_SB_CHECKSUM:
> case FEAT_CASEFOLD:
> + case FEAT_COMPRESSION:
> return snprintf(buf, PAGE_SIZE, "supported\n");
> }
> return 0;
> @@ -502,6 +507,7 @@ F2FS_FEATURE_RO_ATTR(verity, FEAT_VERITY);
> #endif
> F2FS_FEATURE_RO_ATTR(sb_checksum, FEAT_SB_CHECKSUM);
> F2FS_FEATURE_RO_ATTR(casefold, FEAT_CASEFOLD);
> +F2FS_FEATURE_RO_ATTR(compression, FEAT_COMPRESSION);
>
> #define ATTR_LIST(name) (&f2fs_attr_##name.attr)
> static struct attribute *f2fs_attrs[] = {
> @@ -571,6 +577,7 @@ static struct attribute *f2fs_feat_attrs[] = {
> #endif
> ATTR_LIST(sb_checksum),
> ATTR_LIST(casefold),
> + ATTR_LIST(compression),
> NULL,
> };
> ATTRIBUTE_GROUPS(f2fs_feat);
> diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
> index 284738996028..cc203883b31d 100644
> --- a/include/linux/f2fs_fs.h
> +++ b/include/linux/f2fs_fs.h
> @@ -21,8 +21,15 @@
> #define F2FS_EXTENSION_LEN 8 /* max size of extension */
> #define F2FS_BLK_ALIGN(x) (((x) + F2FS_BLKSIZE - 1) >> F2FS_BLKSIZE_BITS)
>
> +#define CLUSTER_IS_FULL 1
> +#define CLUSTER_HAS_SPACE 2
> +
> +#define COMPRESSED_CLUSTER 1
> +#define NORMAL_CLUSTER 2
I removed the above defs.
> +
> #define NULL_ADDR ((block_t)0) /* used as block_t addresses */
> #define NEW_ADDR ((block_t)-1) /* used as block_t addresses */
> +#define COMPRESS_ADDR ((block_t)-2) /* used as compressed data flag */
>
> #define F2FS_BYTES_TO_BLK(bytes) ((bytes) >> F2FS_BLKSIZE_BITS)
> #define F2FS_BLK_TO_BYTES(blk) ((blk) << F2FS_BLKSIZE_BITS)
> @@ -271,6 +278,10 @@ struct f2fs_inode {
> __le32 i_inode_checksum;/* inode meta checksum */
> __le64 i_crtime; /* creation time */
> __le32 i_crtime_nsec; /* creation time in nano scale */
> + __le64 i_compressed_blocks; /* # of compressed blocks */
> + __u8 i_compress_algorithm; /* compress algorithm */
> + __u8 i_log_cluster_size; /* log of cluster size */
> + __le16 i_padding; /* padding */
> __le32 i_extra_end[0]; /* for attribute size calculation */
> } __packed;
> __le32 i_addr[DEF_ADDRS_PER_INODE]; /* Pointers to data blocks */
> diff --git a/include/trace/events/f2fs.h b/include/trace/events/f2fs.h
> index 1796ff99c3e9..cb51ea00dbc7 100644
> --- a/include/trace/events/f2fs.h
> +++ b/include/trace/events/f2fs.h
> @@ -148,6 +148,11 @@ TRACE_DEFINE_ENUM(CP_TRIMMED);
> { F2FS_GOING_DOWN_METAFLUSH, "meta flush" }, \
> { F2FS_GOING_DOWN_NEED_FSCK, "need fsck" })
>
> +#define show_compress_algorithm(type) \
> + __print_symbolic(type, \
> + { COMPRESS_LZO, "LZO" }, \
> + { COMPRESS_LZ4, "LZ4" })
> +
> struct f2fs_sb_info;
> struct f2fs_io_info;
> struct extent_info;
> @@ -1710,6 +1715,100 @@ TRACE_EVENT(f2fs_shutdown,
> __entry->ret)
> );
>
> +DECLARE_EVENT_CLASS(f2fs_zip_start,
> +
> + TP_PROTO(struct inode *inode, unsigned int cluster_idx,
> + unsigned int cluster_size, unsigned char algtype),
> +
> + TP_ARGS(inode, cluster_idx, cluster_size, algtype),
> +
> + TP_STRUCT__entry(
> + __field(dev_t, dev)
> + __field(ino_t, ino)
> + __field(unsigned int, idx)
> + __field(unsigned int, size)
> + __field(unsigned int, algtype)
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->idx = cluster_idx;
> + __entry->size = cluster_size;
> + __entry->algtype = algtype;
> + ),
> +
> + TP_printk("dev = (%d,%d), ino = %lu, cluster_idx:%u, "
> + "cluster_size = %u, algorithm = %s",
> + show_dev_ino(__entry),
> + __entry->idx,
> + __entry->size,
> + show_compress_algorithm(__entry->algtype))
> +);
> +
> +DECLARE_EVENT_CLASS(f2fs_zip_end,
> +
> + TP_PROTO(struct inode *inode, unsigned int cluster_idx,
> + unsigned int compressed_size, int ret),
> +
> + TP_ARGS(inode, cluster_idx, compressed_size, ret),
> +
> + TP_STRUCT__entry(
> + __field(dev_t, dev)
> + __field(ino_t, ino)
> + __field(unsigned int, idx)
> + __field(unsigned int, size)
> + __field(unsigned int, ret)
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->idx = cluster_idx;
> + __entry->size = compressed_size;
> + __entry->ret = ret;
> + ),
> +
> + TP_printk("dev = (%d,%d), ino = %lu, cluster_idx:%u, "
> + "compressed_size = %u, ret = %d",
> + show_dev_ino(__entry),
> + __entry->idx,
> + __entry->size,
> + __entry->ret)
> +);
> +
> +DEFINE_EVENT(f2fs_zip_start, f2fs_compress_pages_start,
> +
> + TP_PROTO(struct inode *inode, unsigned int cluster_idx,
> + unsigned int cluster_size, unsigned char algtype),
> +
> + TP_ARGS(inode, cluster_idx, cluster_size, algtype)
> +);
> +
> +DEFINE_EVENT(f2fs_zip_start, f2fs_decompress_pages_start,
> +
> + TP_PROTO(struct inode *inode, unsigned int cluster_idx,
> + unsigned int cluster_size, unsigned char algtype),
> +
> + TP_ARGS(inode, cluster_idx, cluster_size, algtype)
> +);
> +
> +DEFINE_EVENT(f2fs_zip_end, f2fs_compress_pages_end,
> +
> + TP_PROTO(struct inode *inode, unsigned int cluster_idx,
> + unsigned int compressed_size, int ret),
> +
> + TP_ARGS(inode, cluster_idx, compressed_size, ret)
> +);
> +
> +DEFINE_EVENT(f2fs_zip_end, f2fs_decompress_pages_end,
> +
> + TP_PROTO(struct inode *inode, unsigned int cluster_idx,
> + unsigned int compressed_size, int ret),
> +
> + TP_ARGS(inode, cluster_idx, compressed_size, ret)
> +);
> +
> #endif /* _TRACE_F2FS_H */
>
> /* This part must be outside protection */
> --
> 2.18.0.rc1