[f2fs-dev] [RFC PATCH 0/2] f2fs: support uncached buffered I/O

[f2fs-dev] [RFC PATCH 0/2] f2fs: support uncached buffered I/O

[Wenjie Qi]

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

[RFC PATCH 0/2] f2fs: support uncached buffered I/O

[Wenjie Qi]

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

[f2fs-dev] [RFC PATCH 1/2] f2fs: keep dropbehind write bios task-context safe

[Wenjie Qi]

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

[RFC PATCH 1/2] f2fs: keep dropbehind write bios task-context safe

[Wenjie Qi]

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

[f2fs-dev] [RFC PATCH 2/2] f2fs: enable buffered RWF_DONTCACHE

[Wenjie Qi]

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

[RFC PATCH 2/2] f2fs: enable buffered RWF_DONTCACHE

[Wenjie Qi]

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

Re: [f2fs-dev] [RFC PATCH 0/2] f2fs: support uncached buffered I/O

[Chao Yu via 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

Re: [RFC PATCH 0/2] f2fs: support uncached buffered I/O

[Chao Yu]

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(-)
>