* [f2fs-dev] [RFC PATCH 0/2] f2fs: support uncached buffered I/O @ 2026-08-06 15:07 ` Wenjie Qi 0 siblings, 0 replies; 8+ messages in thread From: Wenjie Qi @ 2026-08-06 15:07 UTC (permalink / raw) To: jaegeuk, chao; +Cc: qwjhust, qiwenjie, linux-kernel, linux-f2fs-devel This RFC series enables buffered RWF_DONTCACHE on F2FS. The first patch keeps dropbehind folios in dropbehind-only write bios and defers their completion to task context when completion happens outside in_task(). The second patch then exposes FOP_DONTCACHE and propagates IOCB_DONTCACHE to write_begin folio allocation so buffered RWF_DONTCACHE can reach the F2FS write path. The split keeps the write-side semantics in place before enabling the user-visible API. Wenjie Qi (2): f2fs: keep dropbehind write bios task-context safe f2fs: enable buffered RWF_DONTCACHE fs/f2fs/data.c | 63 +++++++++++++++++++++++++++++++++++++++----------- fs/f2fs/file.c | 2 +- 2 files changed, 51 insertions(+), 14 deletions(-) -- 2.43.0 _______________________________________________ Linux-f2fs-devel mailing list Linux-f2fs-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel ^ permalink raw reply [flat|nested] 8+ messages in thread
* [RFC PATCH 0/2] f2fs: support uncached buffered I/O @ 2026-08-06 15:07 ` Wenjie Qi 0 siblings, 0 replies; 8+ messages in thread From: Wenjie Qi @ 2026-08-06 15:07 UTC (permalink / raw) To: jaegeuk, chao; +Cc: linux-f2fs-devel, linux-kernel, qiwenjie, qwjhust This RFC series enables buffered RWF_DONTCACHE on F2FS. The first patch keeps dropbehind folios in dropbehind-only write bios and defers their completion to task context when completion happens outside in_task(). The second patch then exposes FOP_DONTCACHE and propagates IOCB_DONTCACHE to write_begin folio allocation so buffered RWF_DONTCACHE can reach the F2FS write path. The split keeps the write-side semantics in place before enabling the user-visible API. Wenjie Qi (2): f2fs: keep dropbehind write bios task-context safe f2fs: enable buffered RWF_DONTCACHE fs/f2fs/data.c | 63 +++++++++++++++++++++++++++++++++++++++----------- fs/f2fs/file.c | 2 +- 2 files changed, 51 insertions(+), 14 deletions(-) -- 2.43.0 ^ permalink raw reply [flat|nested] 8+ messages in thread
* [f2fs-dev] [RFC PATCH 1/2] f2fs: keep dropbehind write bios task-context safe 2026-08-06 15:07 ` Wenjie Qi @ 2026-08-06 15:07 ` Wenjie Qi -1 siblings, 0 replies; 8+ messages in thread From: Wenjie Qi @ 2026-08-06 15:07 UTC (permalink / raw) To: jaegeuk, chao; +Cc: qwjhust, qiwenjie, linux-kernel, linux-f2fs-devel Keep dropbehind folios in dropbehind-only write bios so ordinary and dropbehind writes do not share the same completion policy. If a dropbehind bio completes outside task context, defer its completion to the existing sbi->wq worker before folio_end_writeback() runs. Other bios keep the existing completion path. Signed-off-by: Wenjie Qi <qiwenjie@xiaomi.com> --- fs/f2fs/data.c | 54 ++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 44 insertions(+), 10 deletions(-) diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index 30e8084..8a1e407 100644 --- a/fs/f2fs/data.c +++ b/fs/f2fs/data.c @@ -43,9 +43,20 @@ struct f2fs_folio_state { struct f2fs_bio { struct work_struct work; + bool dropbehind; struct bio bio; }; +static inline struct f2fs_bio *f2fs_bio_to_f2bio(struct bio *bio) +{ + return container_of(bio, struct f2fs_bio, bio); +} + +static inline bool f2fs_write_folio_is_dropbehind(const struct f2fs_io_info *fio) +{ + return fio->folio && folio_test_dropbehind(fio->folio); +} + #define F2FS_BIO_POOL_SIZE NR_CURSEG_TYPE int __init f2fs_init_bioset(void) @@ -418,6 +429,15 @@ static void f2fs_write_end_io_work(struct work_struct *work) f2fs_write_end_bio(bio); } +static void f2fs_queue_write_end_io(struct f2fs_sb_info *sbi, struct bio *bio) +{ + struct work_struct *work = &container_of(bio, struct f2fs_bio, + bio)->work; + + INIT_WORK(work, f2fs_write_end_io_work); + queue_work(sbi->wq, work); +} + static void f2fs_write_end_io(struct bio *bio) { struct f2fs_sb_info *sbi; @@ -426,15 +446,15 @@ static void f2fs_write_end_io(struct bio *bio) sbi = bio->bi_private; - if (in_atomic() && bio->bi_iter.bi_size > sbi->max_atc_write_bio_size) { - struct work_struct *w; + if (f2fs_bio_to_f2bio(bio)->dropbehind && !in_task()) { + f2fs_queue_write_end_io(sbi, bio); + return; + } - w = &container_of(bio, struct f2fs_bio, bio)->work; - INIT_WORK(w, f2fs_write_end_io_work); - queue_work(sbi->wq, w); - } else { + if (in_atomic() && bio->bi_iter.bi_size > sbi->max_atc_write_bio_size) + f2fs_queue_write_end_io(sbi, bio); + else f2fs_write_end_bio(bio); - } } #ifdef CONFIG_BLK_DEV_ZONED @@ -530,6 +550,7 @@ static struct bio *__bio_alloc(struct f2fs_io_info *fio, int npages) bio = bio_alloc_bioset(bdev, npages, fio->op | fio->op_flags | f2fs_io_flags(fio), GFP_NOIO, &f2fs_bioset); + f2fs_bio_to_f2bio(bio)->dropbehind = false; bio->bi_iter.bi_sector = sector; if (is_read_io(fio->op)) { bio->bi_end_io = f2fs_read_end_io; @@ -796,6 +817,7 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio) /* Allocate a new bio */ bio = __bio_alloc(fio, 1); + f2fs_bio_to_f2bio(bio)->dropbehind = f2fs_write_folio_is_dropbehind(fio); f2fs_set_bio_crypt_ctx(bio, fio_folio->mapping->host, fio_folio->index, fio, GFP_NOIO); @@ -1010,6 +1032,7 @@ int f2fs_merge_page_bio(struct f2fs_io_info *fio) struct folio *data_folio = fio->encrypted_page ? page_folio(fio->encrypted_page) : fio->folio; struct folio *folio = fio->folio; + bool is_dropbehind = f2fs_write_folio_is_dropbehind(fio); if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr, __is_meta_io(fio) ? META_GENERIC : DATA_GENERIC)) @@ -1017,17 +1040,24 @@ int f2fs_merge_page_bio(struct f2fs_io_info *fio) trace_f2fs_submit_folio_bio(data_folio, fio); - if (bio && !page_is_mergeable(fio->sbi, bio, *fio->last_block, - fio->new_blkaddr)) + if (bio && (f2fs_bio_to_f2bio(bio)->dropbehind != is_dropbehind || + !page_is_mergeable(fio->sbi, bio, *fio->last_block, + fio->new_blkaddr))) f2fs_submit_merged_ipu_write(fio->sbi, &bio, NULL); alloc_new: if (!bio) { bio = __bio_alloc(fio, BIO_MAX_VECS); + f2fs_bio_to_f2bio(bio)->dropbehind = is_dropbehind; f2fs_set_bio_crypt_ctx(bio, folio->mapping->host, folio->index, fio, GFP_NOIO); add_bio_entry(fio->sbi, bio, data_folio, fio->temp); } else { + if (f2fs_bio_to_f2bio(bio)->dropbehind != is_dropbehind) { + f2fs_submit_merged_ipu_write(fio->sbi, &bio, NULL); + goto alloc_new; + } + if (add_ipu_page(fio, &bio, data_folio)) goto alloc_new; } @@ -1073,6 +1103,7 @@ void f2fs_submit_page_write(struct f2fs_io_info *fio) struct folio *bio_folio; struct f2fs_lock_context lc; enum count_type type; + bool is_dropbehind; f2fs_bug_on(sbi, is_read_io(fio->op)); @@ -1100,6 +1131,7 @@ next: } verify_fio_blkaddr(fio); + is_dropbehind = f2fs_write_folio_is_dropbehind(fio); if (fio->encrypted_page) bio_folio = page_folio(fio->encrypted_page); @@ -1115,7 +1147,8 @@ next: inc_page_count(sbi, type); if (io->bio && - (!io_is_mergeable(sbi, io->bio, io, fio, io->last_block_in_bio, + (f2fs_bio_to_f2bio(io->bio)->dropbehind != is_dropbehind || + !io_is_mergeable(sbi, io->bio, io, fio, io->last_block_in_bio, fio->new_blkaddr) || !f2fs_crypt_mergeable_bio(io->bio, fio_inode(fio), bio_folio->index, fio))) @@ -1123,6 +1156,7 @@ next: alloc_new: if (io->bio == NULL) { io->bio = __bio_alloc(fio, BIO_MAX_VECS); + f2fs_bio_to_f2bio(io->bio)->dropbehind = is_dropbehind; f2fs_set_bio_crypt_ctx(io->bio, fio_inode(fio), bio_folio->index, fio, GFP_NOIO); io->fio = *fio; -- 2.43.0 _______________________________________________ Linux-f2fs-devel mailing list Linux-f2fs-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel ^ permalink raw reply related [flat|nested] 8+ messages in thread
* [RFC PATCH 1/2] f2fs: keep dropbehind write bios task-context safe @ 2026-08-06 15:07 ` Wenjie Qi 0 siblings, 0 replies; 8+ messages in thread From: Wenjie Qi @ 2026-08-06 15:07 UTC (permalink / raw) To: jaegeuk, chao; +Cc: linux-f2fs-devel, linux-kernel, qiwenjie, qwjhust Keep dropbehind folios in dropbehind-only write bios so ordinary and dropbehind writes do not share the same completion policy. If a dropbehind bio completes outside task context, defer its completion to the existing sbi->wq worker before folio_end_writeback() runs. Other bios keep the existing completion path. Signed-off-by: Wenjie Qi <qiwenjie@xiaomi.com> --- fs/f2fs/data.c | 54 ++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 44 insertions(+), 10 deletions(-) diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index 30e8084..8a1e407 100644 --- a/fs/f2fs/data.c +++ b/fs/f2fs/data.c @@ -43,9 +43,20 @@ struct f2fs_folio_state { struct f2fs_bio { struct work_struct work; + bool dropbehind; struct bio bio; }; +static inline struct f2fs_bio *f2fs_bio_to_f2bio(struct bio *bio) +{ + return container_of(bio, struct f2fs_bio, bio); +} + +static inline bool f2fs_write_folio_is_dropbehind(const struct f2fs_io_info *fio) +{ + return fio->folio && folio_test_dropbehind(fio->folio); +} + #define F2FS_BIO_POOL_SIZE NR_CURSEG_TYPE int __init f2fs_init_bioset(void) @@ -418,6 +429,15 @@ static void f2fs_write_end_io_work(struct work_struct *work) f2fs_write_end_bio(bio); } +static void f2fs_queue_write_end_io(struct f2fs_sb_info *sbi, struct bio *bio) +{ + struct work_struct *work = &container_of(bio, struct f2fs_bio, + bio)->work; + + INIT_WORK(work, f2fs_write_end_io_work); + queue_work(sbi->wq, work); +} + static void f2fs_write_end_io(struct bio *bio) { struct f2fs_sb_info *sbi; @@ -426,15 +446,15 @@ static void f2fs_write_end_io(struct bio *bio) sbi = bio->bi_private; - if (in_atomic() && bio->bi_iter.bi_size > sbi->max_atc_write_bio_size) { - struct work_struct *w; + if (f2fs_bio_to_f2bio(bio)->dropbehind && !in_task()) { + f2fs_queue_write_end_io(sbi, bio); + return; + } - w = &container_of(bio, struct f2fs_bio, bio)->work; - INIT_WORK(w, f2fs_write_end_io_work); - queue_work(sbi->wq, w); - } else { + if (in_atomic() && bio->bi_iter.bi_size > sbi->max_atc_write_bio_size) + f2fs_queue_write_end_io(sbi, bio); + else f2fs_write_end_bio(bio); - } } #ifdef CONFIG_BLK_DEV_ZONED @@ -530,6 +550,7 @@ static struct bio *__bio_alloc(struct f2fs_io_info *fio, int npages) bio = bio_alloc_bioset(bdev, npages, fio->op | fio->op_flags | f2fs_io_flags(fio), GFP_NOIO, &f2fs_bioset); + f2fs_bio_to_f2bio(bio)->dropbehind = false; bio->bi_iter.bi_sector = sector; if (is_read_io(fio->op)) { bio->bi_end_io = f2fs_read_end_io; @@ -796,6 +817,7 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio) /* Allocate a new bio */ bio = __bio_alloc(fio, 1); + f2fs_bio_to_f2bio(bio)->dropbehind = f2fs_write_folio_is_dropbehind(fio); f2fs_set_bio_crypt_ctx(bio, fio_folio->mapping->host, fio_folio->index, fio, GFP_NOIO); @@ -1010,6 +1032,7 @@ int f2fs_merge_page_bio(struct f2fs_io_info *fio) struct folio *data_folio = fio->encrypted_page ? page_folio(fio->encrypted_page) : fio->folio; struct folio *folio = fio->folio; + bool is_dropbehind = f2fs_write_folio_is_dropbehind(fio); if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr, __is_meta_io(fio) ? META_GENERIC : DATA_GENERIC)) @@ -1017,17 +1040,24 @@ int f2fs_merge_page_bio(struct f2fs_io_info *fio) trace_f2fs_submit_folio_bio(data_folio, fio); - if (bio && !page_is_mergeable(fio->sbi, bio, *fio->last_block, - fio->new_blkaddr)) + if (bio && (f2fs_bio_to_f2bio(bio)->dropbehind != is_dropbehind || + !page_is_mergeable(fio->sbi, bio, *fio->last_block, + fio->new_blkaddr))) f2fs_submit_merged_ipu_write(fio->sbi, &bio, NULL); alloc_new: if (!bio) { bio = __bio_alloc(fio, BIO_MAX_VECS); + f2fs_bio_to_f2bio(bio)->dropbehind = is_dropbehind; f2fs_set_bio_crypt_ctx(bio, folio->mapping->host, folio->index, fio, GFP_NOIO); add_bio_entry(fio->sbi, bio, data_folio, fio->temp); } else { + if (f2fs_bio_to_f2bio(bio)->dropbehind != is_dropbehind) { + f2fs_submit_merged_ipu_write(fio->sbi, &bio, NULL); + goto alloc_new; + } + if (add_ipu_page(fio, &bio, data_folio)) goto alloc_new; } @@ -1073,6 +1103,7 @@ void f2fs_submit_page_write(struct f2fs_io_info *fio) struct folio *bio_folio; struct f2fs_lock_context lc; enum count_type type; + bool is_dropbehind; f2fs_bug_on(sbi, is_read_io(fio->op)); @@ -1100,6 +1131,7 @@ next: } verify_fio_blkaddr(fio); + is_dropbehind = f2fs_write_folio_is_dropbehind(fio); if (fio->encrypted_page) bio_folio = page_folio(fio->encrypted_page); @@ -1115,7 +1147,8 @@ next: inc_page_count(sbi, type); if (io->bio && - (!io_is_mergeable(sbi, io->bio, io, fio, io->last_block_in_bio, + (f2fs_bio_to_f2bio(io->bio)->dropbehind != is_dropbehind || + !io_is_mergeable(sbi, io->bio, io, fio, io->last_block_in_bio, fio->new_blkaddr) || !f2fs_crypt_mergeable_bio(io->bio, fio_inode(fio), bio_folio->index, fio))) @@ -1123,6 +1156,7 @@ next: alloc_new: if (io->bio == NULL) { io->bio = __bio_alloc(fio, BIO_MAX_VECS); + f2fs_bio_to_f2bio(io->bio)->dropbehind = is_dropbehind; f2fs_set_bio_crypt_ctx(io->bio, fio_inode(fio), bio_folio->index, fio, GFP_NOIO); io->fio = *fio; -- 2.43.0 ^ permalink raw reply related [flat|nested] 8+ messages in thread
* [f2fs-dev] [RFC PATCH 2/2] f2fs: enable buffered RWF_DONTCACHE 2026-08-06 15:07 ` Wenjie Qi @ 2026-08-06 15:07 ` Wenjie Qi -1 siblings, 0 replies; 8+ messages in thread From: Wenjie Qi @ 2026-08-06 15:07 UTC (permalink / raw) To: jaegeuk, chao; +Cc: qwjhust, qiwenjie, linux-kernel, linux-f2fs-devel Expose FOP_DONTCACHE and propagate IOCB_DONTCACHE to write_begin folio allocation so buffered RWF_DONTCACHE can reach the F2FS write path. The write-side completion and bio-isolation semantics are prepared by the previous patch in this RFC series. Signed-off-by: Wenjie Qi <qiwenjie@xiaomi.com> --- fs/f2fs/data.c | 9 ++++++--- fs/f2fs/file.c | 2 +- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index 8a1e407..40c8f7a 100644 --- a/fs/f2fs/data.c +++ b/fs/f2fs/data.c @@ -3982,6 +3982,7 @@ static int f2fs_write_begin(const struct kiocb *iocb, struct f2fs_sb_info *sbi = F2FS_I_SB(inode); struct folio *folio; pgoff_t index = pos >> PAGE_SHIFT; + fgf_t fgp_flags = FGP_LOCK | FGP_WRITE | FGP_CREAT; bool need_balance = false; block_t blkaddr = NULL_ADDR; int err = 0; @@ -4031,9 +4032,11 @@ repeat: * Do not use FGP_STABLE to avoid deadlock. * Will wait that below with our IO control. */ - folio = f2fs_filemap_get_folio(mapping, index, - FGP_LOCK | FGP_WRITE | FGP_CREAT, - mapping_gfp_mask(mapping)); + if (iocb && (iocb->ki_flags & IOCB_DONTCACHE)) + fgp_flags |= FGP_DONTCACHE; + + folio = f2fs_filemap_get_folio(mapping, index, fgp_flags, + mapping_gfp_mask(mapping)); if (IS_ERR(folio)) { err = PTR_ERR(folio); goto fail; diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c index b99d9cd..b3d1684 100644 --- a/fs/f2fs/file.c +++ b/fs/f2fs/file.c @@ -5578,6 +5578,6 @@ const struct file_operations f2fs_file_operations = { .splice_read = f2fs_file_splice_read, .splice_write = iter_file_splice_write, .fadvise = f2fs_file_fadvise, - .fop_flags = FOP_BUFFER_RASYNC, + .fop_flags = FOP_BUFFER_RASYNC | FOP_DONTCACHE, .setlease = generic_setlease, }; -- 2.43.0 _______________________________________________ Linux-f2fs-devel mailing list Linux-f2fs-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel ^ permalink raw reply related [flat|nested] 8+ messages in thread
* [RFC PATCH 2/2] f2fs: enable buffered RWF_DONTCACHE @ 2026-08-06 15:07 ` Wenjie Qi 0 siblings, 0 replies; 8+ messages in thread From: Wenjie Qi @ 2026-08-06 15:07 UTC (permalink / raw) To: jaegeuk, chao; +Cc: linux-f2fs-devel, linux-kernel, qiwenjie, qwjhust Expose FOP_DONTCACHE and propagate IOCB_DONTCACHE to write_begin folio allocation so buffered RWF_DONTCACHE can reach the F2FS write path. The write-side completion and bio-isolation semantics are prepared by the previous patch in this RFC series. Signed-off-by: Wenjie Qi <qiwenjie@xiaomi.com> --- fs/f2fs/data.c | 9 ++++++--- fs/f2fs/file.c | 2 +- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index 8a1e407..40c8f7a 100644 --- a/fs/f2fs/data.c +++ b/fs/f2fs/data.c @@ -3982,6 +3982,7 @@ static int f2fs_write_begin(const struct kiocb *iocb, struct f2fs_sb_info *sbi = F2FS_I_SB(inode); struct folio *folio; pgoff_t index = pos >> PAGE_SHIFT; + fgf_t fgp_flags = FGP_LOCK | FGP_WRITE | FGP_CREAT; bool need_balance = false; block_t blkaddr = NULL_ADDR; int err = 0; @@ -4031,9 +4032,11 @@ repeat: * Do not use FGP_STABLE to avoid deadlock. * Will wait that below with our IO control. */ - folio = f2fs_filemap_get_folio(mapping, index, - FGP_LOCK | FGP_WRITE | FGP_CREAT, - mapping_gfp_mask(mapping)); + if (iocb && (iocb->ki_flags & IOCB_DONTCACHE)) + fgp_flags |= FGP_DONTCACHE; + + folio = f2fs_filemap_get_folio(mapping, index, fgp_flags, + mapping_gfp_mask(mapping)); if (IS_ERR(folio)) { err = PTR_ERR(folio); goto fail; diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c index b99d9cd..b3d1684 100644 --- a/fs/f2fs/file.c +++ b/fs/f2fs/file.c @@ -5578,6 +5578,6 @@ const struct file_operations f2fs_file_operations = { .splice_read = f2fs_file_splice_read, .splice_write = iter_file_splice_write, .fadvise = f2fs_file_fadvise, - .fop_flags = FOP_BUFFER_RASYNC, + .fop_flags = FOP_BUFFER_RASYNC | FOP_DONTCACHE, .setlease = generic_setlease, }; -- 2.43.0 ^ permalink raw reply related [flat|nested] 8+ messages in thread
* Re: [f2fs-dev] [RFC PATCH 0/2] f2fs: support uncached buffered I/O 2026-08-06 15:07 ` Wenjie Qi @ 2026-08-17 9:16 ` Chao Yu -1 siblings, 0 replies; 8+ messages in thread From: Chao Yu via Linux-f2fs-devel @ 2026-08-17 9:16 UTC (permalink / raw) To: Wenjie Qi, jaegeuk; +Cc: qiwenjie, linux-kernel, linux-f2fs-devel On 8/6/26 23:07, Wenjie Qi wrote: > This RFC series enables buffered RWF_DONTCACHE on F2FS. > > The first patch keeps dropbehind folios in dropbehind-only write bios and > defers their completion to task context when completion happens outside > in_task(). > > The second patch then exposes FOP_DONTCACHE and propagates > IOCB_DONTCACHE to write_begin folio allocation so buffered > RWF_DONTCACHE can reach the F2FS write path. > > The split keeps the write-side semantics in place before enabling the > user-visible API. Thanks for the patchset. Do you have some numbers in device? maybe something like Han Qi did in https://lore.kernel.org/linux-f2fs-devel/20250828121131.3694154-1-hanqi@vivo.com? Thanks, > > Wenjie Qi (2): > f2fs: keep dropbehind write bios task-context safe > f2fs: enable buffered RWF_DONTCACHE > > fs/f2fs/data.c | 63 +++++++++++++++++++++++++++++++++++++++----------- > fs/f2fs/file.c | 2 +- > 2 files changed, 51 insertions(+), 14 deletions(-) > _______________________________________________ Linux-f2fs-devel mailing list Linux-f2fs-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel ^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [RFC PATCH 0/2] f2fs: support uncached buffered I/O @ 2026-08-17 9:16 ` Chao Yu 0 siblings, 0 replies; 8+ messages in thread From: Chao Yu @ 2026-08-17 9:16 UTC (permalink / raw) To: Wenjie Qi, jaegeuk; +Cc: chao, linux-f2fs-devel, linux-kernel, qiwenjie On 8/6/26 23:07, Wenjie Qi wrote: > This RFC series enables buffered RWF_DONTCACHE on F2FS. > > The first patch keeps dropbehind folios in dropbehind-only write bios and > defers their completion to task context when completion happens outside > in_task(). > > The second patch then exposes FOP_DONTCACHE and propagates > IOCB_DONTCACHE to write_begin folio allocation so buffered > RWF_DONTCACHE can reach the F2FS write path. > > The split keeps the write-side semantics in place before enabling the > user-visible API. Thanks for the patchset. Do you have some numbers in device? maybe something like Han Qi did in https://lore.kernel.org/linux-f2fs-devel/20250828121131.3694154-1-hanqi@vivo.com? Thanks, > > Wenjie Qi (2): > f2fs: keep dropbehind write bios task-context safe > f2fs: enable buffered RWF_DONTCACHE > > fs/f2fs/data.c | 63 +++++++++++++++++++++++++++++++++++++++----------- > fs/f2fs/file.c | 2 +- > 2 files changed, 51 insertions(+), 14 deletions(-) > ^ permalink raw reply [flat|nested] 8+ messages in thread
end of thread, other threads:[~2026-08-17 9:16 UTC | newest] Thread overview: 8+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2026-08-06 15:07 [f2fs-dev] [RFC PATCH 0/2] f2fs: support uncached buffered I/O Wenjie Qi 2026-08-06 15:07 ` Wenjie Qi 2026-08-06 15:07 ` [f2fs-dev] [RFC PATCH 1/2] f2fs: keep dropbehind write bios task-context safe Wenjie Qi 2026-08-06 15:07 ` Wenjie Qi 2026-08-06 15:07 ` [f2fs-dev] [RFC PATCH 2/2] f2fs: enable buffered RWF_DONTCACHE Wenjie Qi 2026-08-06 15:07 ` Wenjie Qi 2026-08-17 9:16 ` [f2fs-dev] [RFC PATCH 0/2] f2fs: support uncached buffered I/O Chao Yu via Linux-f2fs-devel 2026-08-17 9:16 ` Chao Yu
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.