Re: [PATCH 2/2] f2fs: support data compression

From: Jaegeuk Kim
Date: Mon Nov 18 2019 - 15:58:26 EST

Next message: Auger Eric: "Re: [PATCH v2 05/10] iommu/vt-d: Avoid duplicated code for PASID setup"
Previous message: Qian Cai: "Re: [PATCH -next v2] mm/vmscan: fix some -Wenum-conversion warnings"
In reply to: Jaegeuk Kim: "Re: [PATCH 2/2] f2fs: support data compression"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

On 11/18, Jaegeuk Kim wrote:
> On 11/13, Chao Yu wrote:
> > Hi Jaegeuk,
> >
> > I've split workqueue for fsverity, please test compression based on last patch.
> >
> > I shutdown F2FS_FS_COMPRESSION config, it looks all verity testcases can pass, will
> > do more test for compress/encrypt/fsverity combination later.
>
> Thanks, I applied and start some tests.

I modified below to fix wrong compression check in read path.

--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -1007,6 +1007,7 @@ struct decompress_io_ctx *f2fs_alloc_dic(struct compress_ctx *cc)
if (!dic)
return ERR_PTR(-ENOMEM);

+ dic->magic = F2FS_COMPRESSED_PAGE_MAGIC;
dic->inode = cc->inode;
refcount_set(&dic->ref, 1);
dic->cluster_idx = cc->cluster_idx;
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 02a2e7261b457..399ba883632a0 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1255,6 +1255,7 @@ struct compress_io_ctx {

/* decompress io context for read IO path */
struct decompress_io_ctx {
+ u32 magic; /* magic number to indicate page is compressed */
struct inode *inode; /* inode the context belong to */
unsigned int cluster_idx; /* cluster index number */
unsigned int cluster_size; /* page count in cluster */

>
> >
> > The diff is as below, code base is last g-dev-test branch:
> >
> > >From 5b51682bc3013b8de6dee4906865181c3ded435f Mon Sep 17 00:00:00 2001
> > From: Chao Yu <yuchao0@xxxxxxxxxx>
> > Date: Tue, 12 Nov 2019 10:03:21 +0800
> > Subject: [PATCH INCREMENT] f2fs: compress: split workqueue for fsverity
> >
> > Signed-off-by: Chao Yu <yuchao0@xxxxxxxxxx>
> > ---
> > fs/f2fs/compress.c | 16 +++++---
> > fs/f2fs/data.c | 94 +++++++++++++++++++++++++++++++++++-----------
> > fs/f2fs/f2fs.h | 2 +-
> > 3 files changed, 84 insertions(+), 28 deletions(-)
> >
> > diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c
> > index f4ce825f12b4..254275325890 100644
> > --- a/fs/f2fs/compress.c
> > +++ b/fs/f2fs/compress.c
> > @@ -377,7 +377,7 @@ void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity)
> >
> > dec_page_count(sbi, F2FS_RD_DATA);
> >
> > - if (bio->bi_status)
> > + if (bio->bi_status || PageError(page))
> > dic->failed = true;
> >
> > if (refcount_dec_not_one(&dic->ref))
> > @@ -419,10 +419,14 @@ void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity)
> > out_vunmap_rbuf:
> > vunmap(dic->rbuf);
> > out_free_dic:
> > - f2fs_set_cluster_uptodate(dic->rpages, dic->cluster_size, ret, verity);
> > + if (!verity)
> > + f2fs_decompress_end_io(dic->rpages, dic->cluster_size,
> > + ret, false);
> > +
> > trace_f2fs_decompress_pages_end(dic->inode, dic->cluster_idx,
> > - dic->clen, ret);
> > - f2fs_free_dic(dic);
> > + dic->clen, ret);
> > + if (!verity)
> > + f2fs_free_dic(dic);
> > }
> >
> > static bool is_page_in_cluster(struct compress_ctx *cc, pgoff_t index)
> > @@ -1086,7 +1090,7 @@ void f2fs_free_dic(struct decompress_io_ctx *dic)
> > kfree(dic);
> > }
> >
> > -void f2fs_set_cluster_uptodate(struct page **rpages,
> > +void f2fs_decompress_end_io(struct page **rpages,
> > unsigned int cluster_size, bool err, bool verity)
> > {
> > int i;
> > @@ -1108,4 +1112,4 @@ void f2fs_set_cluster_uptodate(struct page **rpages,
> > }
> > unlock_page(rpage);
> > }
> > -}
> > +}
> > \ No newline at end of file
> > diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> > index c9362a53f8a1..2d64c6ffee84 100644
> > --- a/fs/f2fs/data.c
> > +++ b/fs/f2fs/data.c
> > @@ -98,7 +98,7 @@ static void __read_end_io(struct bio *bio, bool compr, bool verity)
> > page = bv->bv_page;
> >
> > #ifdef CONFIG_F2FS_FS_COMPRESSION
> > - if (compr && PagePrivate(page)) {
> > + if (compr && f2fs_is_compressed_page(page)) {
> > f2fs_decompress_pages(bio, page, verity);
> > continue;
> > }
> > @@ -115,9 +115,14 @@ static void __read_end_io(struct bio *bio, bool compr, bool verity)
> > dec_page_count(F2FS_P_SB(page), __read_io_type(page));
> > unlock_page(page);
> > }
> > - if (bio->bi_private)
> > - mempool_free(bio->bi_private, bio_post_read_ctx_pool);
> > - bio_put(bio);
> > +}
> > +
> > +static void f2fs_release_read_bio(struct bio *bio);
> > +static void __f2fs_read_end_io(struct bio *bio, bool compr, bool verity)
> > +{
> > + if (!compr)
> > + __read_end_io(bio, false, verity);
> > + f2fs_release_read_bio(bio);
> > }
> >
> > static void f2fs_decompress_bio(struct bio *bio, bool verity)
> > @@ -127,19 +132,50 @@ static void f2fs_decompress_bio(struct bio *bio, bool verity)
> >
> > static void bio_post_read_processing(struct bio_post_read_ctx *ctx);
> >
> > -static void decrypt_work(struct bio_post_read_ctx *ctx)
> > +static void f2fs_decrypt_work(struct bio_post_read_ctx *ctx)
> > {
> > fscrypt_decrypt_bio(ctx->bio);
> > }
> >
> > -static void decompress_work(struct bio_post_read_ctx *ctx, bool verity)
> > +static void f2fs_decompress_work(struct bio_post_read_ctx *ctx)
> > +{
> > + f2fs_decompress_bio(ctx->bio, ctx->enabled_steps & (1 << STEP_VERITY));
> > +}
> > +
> > +#ifdef CONFIG_F2FS_FS_COMPRESSION
> > +void f2fs_verify_pages(struct page **rpages, unsigned int cluster_size)
> > {
> > - f2fs_decompress_bio(ctx->bio, verity);
> > + f2fs_decompress_end_io(rpages, cluster_size, false, true);
> > }
> >
> > -static void verity_work(struct bio_post_read_ctx *ctx)
> > +static void f2fs_verify_bio(struct bio *bio)
> > {
> > + struct page *page = bio_first_page_all(bio);
> > + struct decompress_io_ctx *dic =
> > + (struct decompress_io_ctx *)page_private(page);
> > +
> > + f2fs_verify_pages(dic->rpages, dic->cluster_size);
> > + f2fs_free_dic(dic);
> > +}
> > +#endif
> > +
> > +static void f2fs_verity_work(struct work_struct *work)
> > +{
> > + struct bio_post_read_ctx *ctx =
> > + container_of(work, struct bio_post_read_ctx, work);
> > +
> > +#ifdef CONFIG_F2FS_FS_COMPRESSION
> > + /* previous step is decompression */
> > + if (ctx->enabled_steps & (1 << STEP_DECOMPRESS)) {
> > +
> > + f2fs_verify_bio(ctx->bio);
> > + f2fs_release_read_bio(ctx->bio);
> > + return;
> > + }
> > +#endif
> > +
> > fsverity_verify_bio(ctx->bio);
> > + __f2fs_read_end_io(ctx->bio, false, false);
> > }
> >
> > static void f2fs_post_read_work(struct work_struct *work)
> > @@ -148,18 +184,19 @@ static void f2fs_post_read_work(struct work_struct *work)
> > container_of(work, struct bio_post_read_ctx, work);
> >
> > if (ctx->enabled_steps & (1 << STEP_DECRYPT))
> > - decrypt_work(ctx);
> > + f2fs_decrypt_work(ctx);
> >
> > - if (ctx->enabled_steps & (1 << STEP_DECOMPRESS)) {
> > - decompress_work(ctx,
> > - ctx->enabled_steps & (1 << STEP_VERITY));
> > + if (ctx->enabled_steps & (1 << STEP_DECOMPRESS))
> > + f2fs_decompress_work(ctx);
> > +
> > + if (ctx->enabled_steps & (1 << STEP_VERITY)) {
> > + INIT_WORK(&ctx->work, f2fs_verity_work);
> > + fsverity_enqueue_verify_work(&ctx->work);
> > return;
> > }
> >
> > - if (ctx->enabled_steps & (1 << STEP_VERITY))
> > - verity_work(ctx);
> > -
> > - __read_end_io(ctx->bio, false, false);
> > + __f2fs_read_end_io(ctx->bio,
> > + ctx->enabled_steps & (1 << STEP_DECOMPRESS), false);
> > }
> >
> > static void f2fs_enqueue_post_read_work(struct f2fs_sb_info *sbi,
> > @@ -176,12 +213,20 @@ static void bio_post_read_processing(struct bio_post_read_ctx *ctx)
> > * we shouldn't recurse to the same workqueue.
> > */
> >
> > - if (ctx->enabled_steps) {
> > + if (ctx->enabled_steps & (1 << STEP_DECRYPT) ||
> > + ctx->enabled_steps & (1 << STEP_DECOMPRESS)) {
> > 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);
> > +
> > + if (ctx->enabled_steps & (1 << STEP_VERITY)) {
> > + INIT_WORK(&ctx->work, f2fs_verity_work);
> > + fsverity_enqueue_verify_work(&ctx->work);
> > + return;
> > + }
> > +
> > + __f2fs_read_end_io(ctx->bio, false, false);
> > }
> >
> > static bool f2fs_bio_post_read_required(struct bio *bio)
> > @@ -205,7 +250,7 @@ static void f2fs_read_end_io(struct bio *bio)
> > return;
> > }
> >
> > - __read_end_io(bio, false, false);
> > + __f2fs_read_end_io(bio, false, false);
> > }
> >
> > static void f2fs_write_end_io(struct bio *bio)
> > @@ -864,6 +909,13 @@ static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,
> > return bio;
> > }
> >
> > +static void f2fs_release_read_bio(struct bio *bio)
> > +{
> > + if (bio->bi_private)
> > + mempool_free(bio->bi_private, bio_post_read_ctx_pool);
> > + bio_put(bio);
> > +}
> > +
> > /* This can handle encryption stuffs */
> > static int f2fs_submit_page_read(struct inode *inode, struct page *page,
> > block_t blkaddr)
> > @@ -2023,7 +2075,7 @@ int f2fs_read_multi_pages(struct compress_ctx *cc, struct bio **bio_ret,
> > dic->failed = true;
> > if (refcount_sub_and_test(dic->nr_cpages - i,
> > &dic->ref))
> > - f2fs_set_cluster_uptodate(dic->rpages,
> > + f2fs_decompress_end_io(dic->rpages,
> > cc->cluster_size, true,
> > false);
> > f2fs_free_dic(dic);
> > @@ -2053,7 +2105,7 @@ int f2fs_read_multi_pages(struct compress_ctx *cc, struct bio **bio_ret,
> > out_put_dnode:
> > f2fs_put_dnode(&dn);
> > out:
> > - f2fs_set_cluster_uptodate(cc->rpages, cc->cluster_size, true, false);
> > + f2fs_decompress_end_io(cc->rpages, cc->cluster_size, true, false);
> > f2fs_destroy_compress_ctx(cc);
> > *bio_ret = bio;
> > return ret;
> > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> > index 8a3a35b42a37..20067fa3b035 100644
> > --- a/fs/f2fs/f2fs.h
> > +++ b/fs/f2fs/f2fs.h
> > @@ -3795,7 +3795,7 @@ int f2fs_read_multi_pages(struct compress_ctx *cc, struct bio **bio_ret,
> > 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,
> > +void f2fs_decompress_end_io(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);
> > --
> > 2.18.0.rc1
> >
> >
> >
> > On 2019/10/31 1:02, Eric Biggers wrote:
> > > On Wed, Oct 30, 2019 at 04:43:52PM +0800, Chao Yu wrote:
> > >>>>>> static void bio_post_read_processing(struct bio_post_read_ctx *ctx)
> > >>>>>> {
> > >>>>>> - /*
> > >>>>>> - * We use different work queues for decryption and for verity because
> > >>>>>> - * verity may require reading metadata pages that need decryption, and
> > >>>>>> - * we shouldn't recurse to the same workqueue.
> > >>>>>> - */
> > >>>>>
> > >>>>> Why is it okay (i.e., no deadlocks) to no longer use different work queues for
> > >>>>> decryption and for verity? See the comment above which is being deleted.
> > >>>>
> > >>>> Could you explain more about how deadlock happen? or share me a link address if
> > >>>> you have described that case somewhere?
> > >>>>
> > >>>
> > >>> The verity work can read pages from the file which require decryption. I'm
> > >>> concerned that it could deadlock if the work is scheduled on the same workqueue.
> > >>
> > >> I assume you've tried one workqueue, and suffered deadlock..
> > >>
> > >>> Granted, I'm not an expert in Linux workqueues, so if you've investigated this
> > >>> and determined that it's safe, can you explain why?
> > >>
> > >> I'm not familiar with workqueue... I guess it may not safe that if the work is
> > >> scheduled to the same cpu in where verity was waiting for data? if the work is
> > >> scheduled to other cpu, it may be safe.
> > >>
> > >> I can check that before splitting the workqueue for verity and decrypt/decompress.
> > >>
> > >
> > > Yes this is a real problem, try 'kvm-xfstests -c f2fs/encrypt generic/579'.
> > > The worker thread gets deadlocked in f2fs_read_merkle_tree_page() waiting for
> > > the Merkle tree page to be decrypted. This is with the v2 compression patch;
> > > it works fine on current mainline.
> > >
> > > INFO: task kworker/u5:0:61 blocked for more than 30 seconds.
> > > Not tainted 5.4.0-rc1-00119-g464e31ba60d0 #13
> > > "echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message.
> > > kworker/u5:0 D 0 61 2 0x80004000
> > > Workqueue: f2fs_post_read_wq f2fs_post_read_work
> > > Call Trace:
> > > context_switch kernel/sched/core.c:3384 [inline]
> > > __schedule+0x299/0x6c0 kernel/sched/core.c:4069
> > > schedule+0x44/0xd0 kernel/sched/core.c:4136
> > > io_schedule+0x11/0x40 kernel/sched/core.c:5780
> > > wait_on_page_bit_common mm/filemap.c:1174 [inline]
> > > wait_on_page_bit mm/filemap.c:1223 [inline]
> > > wait_on_page_locked include/linux/pagemap.h:527 [inline]
> > > wait_on_page_locked include/linux/pagemap.h:524 [inline]
> > > wait_on_page_read mm/filemap.c:2767 [inline]
> > > do_read_cache_page+0x407/0x660 mm/filemap.c:2810
> > > read_cache_page+0xd/0x10 mm/filemap.c:2894
> > > f2fs_read_merkle_tree_page+0x2e/0x30 include/linux/pagemap.h:396
> > > verify_page+0x110/0x560 fs/verity/verify.c:120
> > > fsverity_verify_bio+0xe6/0x1a0 fs/verity/verify.c:239
> > > verity_work fs/f2fs/data.c:142 [inline]
> > > f2fs_post_read_work+0x36/0x50 fs/f2fs/data.c:160
> > > process_one_work+0x225/0x550 kernel/workqueue.c:2269
> > > worker_thread+0x4b/0x3c0 kernel/workqueue.c:2415
> > > kthread+0x125/0x140 kernel/kthread.c:255
> > > ret_from_fork+0x24/0x30 arch/x86/entry/entry_64.S:352
> > > INFO: task kworker/u5:1:1140 blocked for more than 30 seconds.
> > > Not tainted 5.4.0-rc1-00119-g464e31ba60d0 #13
> > > "echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message.
> > > kworker/u5:1 D 0 1140 2 0x80004000
> > > Workqueue: f2fs_post_read_wq f2fs_post_read_work
> > > Call Trace:
> > > context_switch kernel/sched/core.c:3384 [inline]
> > > __schedule+0x299/0x6c0 kernel/sched/core.c:4069
> > > schedule+0x44/0xd0 kernel/sched/core.c:4136
> > > io_schedule+0x11/0x40 kernel/sched/core.c:5780
> > > wait_on_page_bit_common mm/filemap.c:1174 [inline]
> > > wait_on_page_bit mm/filemap.c:1223 [inline]
> > > wait_on_page_locked include/linux/pagemap.h:527 [inline]
> > > wait_on_page_locked include/linux/pagemap.h:524 [inline]
> > > wait_on_page_read mm/filemap.c:2767 [inline]
> > > do_read_cache_page+0x407/0x660 mm/filemap.c:2810
> > > read_cache_page+0xd/0x10 mm/filemap.c:2894
> > > f2fs_read_merkle_tree_page+0x2e/0x30 include/linux/pagemap.h:396
> > > verify_page+0x110/0x560 fs/verity/verify.c:120
> > > fsverity_verify_bio+0xe6/0x1a0 fs/verity/verify.c:239
> > > verity_work fs/f2fs/data.c:142 [inline]
> > > f2fs_post_read_work+0x36/0x50 fs/f2fs/data.c:160
> > > process_one_work+0x225/0x550 kernel/workqueue.c:2269
> > > worker_thread+0x4b/0x3c0 kernel/workqueue.c:2415
> > > kthread+0x125/0x140 kernel/kthread.c:255
> > > ret_from_fork+0x24/0x30 arch/x86/entry/entry_64.S:352
> > >
> > > Showing all locks held in the system:
> > > 1 lock held by khungtaskd/21:
> > > #0: ffffffff82250520 (rcu_read_lock){....}, at: rcu_lock_acquire.constprop.0+0x0/0x30 include/trace/events/lock.h:13
> > > 2 locks held by kworker/u5:0/61:
> > > #0: ffff88807b78eb28 ((wq_completion)f2fs_post_read_wq){+.+.}, at: set_work_data kernel/workqueue.c:619 [inline]
> > > #0: ffff88807b78eb28 ((wq_completion)f2fs_post_read_wq){+.+.}, at: set_work_pool_and_clear_pending kernel/workqueue.c:647 [inline]
> > > #0: ffff88807b78eb28 ((wq_completion)f2fs_post_read_wq){+.+.}, at: process_one_work+0x1ad/0x550 kernel/workqueue.c:2240
> > > #1: ffffc90000253e50 ((work_completion)(&ctx->work)){+.+.}, at: set_work_data kernel/workqueue.c:619 [inline]
> > > #1: ffffc90000253e50 ((work_completion)(&ctx->work)){+.+.}, at: set_work_pool_and_clear_pending kernel/workqueue.c:647 [inline]
> > > #1: ffffc90000253e50 ((work_completion)(&ctx->work)){+.+.}, at: process_one_work+0x1ad/0x550 kernel/workqueue.c:2240
> > > 2 locks held by kworker/u5:1/1140:
> > > #0: ffff88807b78eb28 ((wq_completion)f2fs_post_read_wq){+.+.}, at: set_work_data kernel/workqueue.c:619 [inline]
> > > #0: ffff88807b78eb28 ((wq_completion)f2fs_post_read_wq){+.+.}, at: set_work_pool_and_clear_pending kernel/workqueue.c:647 [inline]
> > > #0: ffff88807b78eb28 ((wq_completion)f2fs_post_read_wq){+.+.}, at: process_one_work+0x1ad/0x550 kernel/workqueue.c:2240
> > > #1: ffffc9000174be50 ((work_completion)(&ctx->work)){+.+.}, at: set_work_data kernel/workqueue.c:619 [inline]
> > > #1: ffffc9000174be50 ((work_completion)(&ctx->work)){+.+.}, at: set_work_pool_and_clear_pending kernel/workqueue.c:647 [inline]
> > > #1: ffffc9000174be50 ((work_completion)(&ctx->work)){+.+.}, at: process_one_work+0x1ad/0x550 kernel/workqueue.c:2240
> > > .
> > >

Next message: Auger Eric: "Re: [PATCH v2 05/10] iommu/vt-d: Avoid duplicated code for PASID setup"
Previous message: Qian Cai: "Re: [PATCH -next v2] mm/vmscan: fix some -Wenum-conversion warnings"
In reply to: Jaegeuk Kim: "Re: [PATCH 2/2] f2fs: support data compression"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]