This fixes xfstests generic/451 (for both O_DIRECT and FOPEN_DIRECT_IO
direct write).

Commit b359af8275a9 ("fuse: Invalidate the page cache after
FOPEN_DIRECT_IO write") tries to fix the similar issue for
FOPEN_DIRECT_IO write, which can be reproduced by xfstests generic/209.
It only fixes the issue for synchronous direct write, while omitting
the case for asynchronous direct write (exactly targeted by
generic/451).

While for O_DIRECT direct write, it's somewhat more complicated.  For
synchronous direct write, generic_file_direct_write() will invalidate
the page cache after the write, and thus it can pass generic/209.  While
for asynchronous direct write, the invalidation in
generic_file_direct_write() is bypassed since the invalidation shall be
done when the asynchronous IO completes.  This is omitted in FUSE and
generic/451 fails whereby.

Fix this by conveying the invalidation for both synchronous and
asynchronous write.

- with FOPEN_DIRECT_IO
  - sync write,  invalidate in fuse_send_write()
  - async write, invalidate in fuse_aio_complete() with FUSE_ASYNC_DIO,
		 fuse_send_write() otherwise
- without FOPEN_DIRECT_IO
  - sync write,  invalidate in generic_file_direct_write()
  - async write, invalidate in fuse_aio_complete() with FUSE_ASYNC_DIO,
		 fuse_send_write() otherwise

Signed-off-by: Jingbo Xu <jefflexu@linux.alibaba.com>
---
changes since v1:
- remove the redundant invalidation for synchronous write without
  FOPEN_DIRECT_IO (Bernd)
v1: https://yhbt.net/lore/all/20260106075234.63364-1-jefflexu@linux.alibaba.com/
---
 fs/fuse/file.c | 40 +++++++++++++++++++++++++++++-----------
 1 file changed, 29 insertions(+), 11 deletions(-)

diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 01bc894e9c2b..9751482601ea 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -667,6 +667,18 @@ static void fuse_aio_complete(struct fuse_io_priv *io, int err, ssize_t pos)
 			struct inode *inode = file_inode(io->iocb->ki_filp);
 			struct fuse_conn *fc = get_fuse_conn(inode);
 			struct fuse_inode *fi = get_fuse_inode(inode);
+			struct address_space *mapping = io->iocb->ki_filp->f_mapping;
+
+			/*
+			 * As in generic_file_direct_write(), invalidate after the
+			 * write, to invalidate read-ahead cache that may have competed
+			 * with the write.
+			 */
+			if (io->write && res && mapping->nrpages) {
+				invalidate_inode_pages2_range(mapping,
+						io->offset >> PAGE_SHIFT,
+						(io->offset + res - 1) >> PAGE_SHIFT);
+			}
 
 			spin_lock(&fi->lock);
 			fi->attr_version = atomic64_inc_return(&fc->attr_version);
@@ -1144,9 +1156,11 @@ static ssize_t fuse_send_write(struct fuse_io_args *ia, loff_t pos,
 {
 	struct kiocb *iocb = ia->io->iocb;
 	struct file *file = iocb->ki_filp;
+	struct address_space *mapping = file->f_mapping;
 	struct fuse_file *ff = file->private_data;
 	struct fuse_mount *fm = ff->fm;
 	struct fuse_write_in *inarg = &ia->write.in;
+	ssize_t written;
 	ssize_t err;
 
 	fuse_write_args_fill(ia, ff, pos, count);
@@ -1160,10 +1174,23 @@ static ssize_t fuse_send_write(struct fuse_io_args *ia, loff_t pos,
 		return fuse_async_req_send(fm, ia, count);
 
 	err = fuse_simple_request(fm, &ia->ap.args);
-	if (!err && ia->write.out.size > count)
+	written = ia->write.out.size;
+	if (!err && written > count)
 		err = -EIO;
 
-	return err ?: ia->write.out.size;
+	/*
+	 * As in generic_file_direct_write(), invalidate after the write, to
+	 * invalidate read-ahead cache that may have competed with the write.
+	 * Without FOPEN_DIRECT_IO, generic_file_direct_write() does the
+	 * invalidation for synchronous write.
+	 */
+	if (!err && written && mapping->nrpages &&
+	    ((ff->open_flags & FOPEN_DIRECT_IO) || !ia->io->blocking)) {
+		invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT,
+					(pos + written - 1) >> PAGE_SHIFT);
+	}
+
+	return err ?: written;
 }
 
 bool fuse_write_update_attr(struct inode *inode, loff_t pos, ssize_t written)
@@ -1738,15 +1765,6 @@ ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter,
 	if (res > 0)
 		*ppos = pos;
 
-	if (res > 0 && write && fopen_direct_io) {
-		/*
-		 * As in generic_file_direct_write(), invalidate after the
-		 * write, to invalidate read-ahead cache that may have competed
-		 * with the write.
-		 */
-		invalidate_inode_pages2_range(mapping, idx_from, idx_to);
-	}
-
 	return res > 0 ? res : err;
 }
 EXPORT_SYMBOL_GPL(fuse_direct_io);
-- 
2.19.1.6.gb485710b

On 1/9/26 08:01, Jingbo Xu wrote:
> -	return err ?: ia->write.out.size;
> +	/*
> +	 * As in generic_file_direct_write(), invalidate after the write, to
> +	 * invalidate read-ahead cache that may have competed with the write.
> +	 * Without FOPEN_DIRECT_IO, generic_file_direct_write() does the
> +	 * invalidation for synchronous write.
> +	 */
> +	if (!err && written && mapping->nrpages &&
> +	    ((ff->open_flags & FOPEN_DIRECT_IO) || !ia->io->blocking)) {
> +		invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT,
> +					(pos + written - 1) >> PAGE_SHIFT);
> +	}
> +
> +	return err ?: written;
>  }

Sorry, but I'm confused about "|| !ia->io->blocking". When we go into this
code path it either via generic_file_direct_write(), which then
already invalidates or directly and then 
(ff->open_flags & FOPEN_DIRECT_IO) is set?


Thanks,
Bernd

On 1/9/26 10:05 PM, Bernd Schubert wrote:
> 
> 
> On 1/9/26 08:01, Jingbo Xu wrote:
>> -	return err ?: ia->write.out.size;
>> +	/*
>> +	 * As in generic_file_direct_write(), invalidate after the write, to
>> +	 * invalidate read-ahead cache that may have competed with the write.
>> +	 * Without FOPEN_DIRECT_IO, generic_file_direct_write() does the
>> +	 * invalidation for synchronous write.
>> +	 */
>> +	if (!err && written && mapping->nrpages &&
>> +	    ((ff->open_flags & FOPEN_DIRECT_IO) || !ia->io->blocking)) {
>> +		invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT,
>> +					(pos + written - 1) >> PAGE_SHIFT);
>> +	}
>> +
>> +	return err ?: written;
>>  }
> 
> Sorry, but I'm confused about "|| !ia->io->blocking". When we go into this
> code path it either via generic_file_direct_write(), which then
> already invalidates or directly and then 
> (ff->open_flags & FOPEN_DIRECT_IO) is set?
> 

Alright. I mistakenly thought that generic_file_direct_write() will skip
the invalidation for async write (without FOPEN_DIRECT_IO) when
fc->async_dio is false, as the ->direct_IO() will return -EIOCBQUEUED
for async write.

But in fact when fc->async_dio is false, fuse_direct_IO() will wait for
the IO completion and return the number of bytes written on success.
Thus generic_file_direct_write() will do the invalidation in this case.

I will drop "|| !ia->io->blocking" in v3 and add your "Reviewed-by" tag
then.

Thank you for the reviewing!

-- 
Thanks,
Jingbo