Received-SPF: pass (google.com: domain of linux-kernel+bounces-185538-linux.lists.archive=gmail.com@vger.kernel.org designates 2604:1380:45e3:2400::1 as permitted sender) client-ip=2604:1380:45e3:2400::1;
Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley
	Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United
	Kingdom.
	Registered in England and Wales under Company Registration No. 3798903
From: David Howells <dhowells@redhat.com>
To: Steve French <stfrench@microsoft.com>
cc: dhowells@redhat.com, Jeff Layton <jlayton@kernel.org>,
    Enzo Matsumiya <ematsumiya@suse.de>,
    Christian Brauner <brauner@kernel.org>, netfs@lists.linux.dev,
    v9fs@lists.linux.dev, linux-afs@lists.infradead.org,
    linux-cifs@vger.kernel.org, linux-fsdevel@vger.kernel.org,
    linux-kernel@vger.kernel.org
Subject: [PATCH v2] netfs: Fix io_uring based write-through
Precedence: bulk
MIME-Version: 1.0
Content-Type: text/plain; charset="us-ascii"
Content-ID: <351481.1716336150.1@warthog.procyon.org.uk>
Content-Transfer-Encoding: quoted-printable
Date: Wed, 22 May 2024 01:02:30 +0100
Message-ID: <351482.1716336150@warthog.procyon.org.uk>

This can be triggered by mounting a cifs filesystem with a cache=3Dstrict
mount option and then, using the fsx program from xfstests, doing:

        ltp/fsx -A -d -N 1000 -S 11463 -P /tmp /cifs-mount/foo \
          --replay-ops=3Dgen112-fsxops

Where gen112-fsxops holds:

        fallocate 0x6be7 0x8fc5 0x377d3
        copy_range 0x9c71 0x77e8 0x2edaf 0x377d3
        write 0x2776d 0x8f65 0x377d3

The problem is that netfs_io_request::len is being used for two purposes
and ends up getting set to the amount of data we transferred, not the
amount of data the caller asked to be transferred (for various reasons,
such as mmap'd writes, we might end up rounding out the data written to th=
e
server to include the entire folio at each end).

Fix this by keeping the amount we were asked to write in ->len and using
->submitted to track what we issued ops for.  Then, when we come to callin=
g
->ki_complete(), ->len is the right size.

This also required netfs_cleanup_dio_write() to change since we're no
longer advancing wreq->len.  Use wreq->transferred instead as we might hav=
e
done a short read and wreq->len must be set when setting up a direct write=
.

With this, the generic/112 xfstest passes if cifs is forced to put all
non-DIO opens into write-through mode.

Fixes: 288ace2f57c9 ("netfs: New writeback implementation")
Signed-off-by: David Howells <dhowells@redhat.com>
cc: Jeff Layton <jlayton@kernel.org>
cc: Steve French <stfrench@microsoft.com>
cc: Enzo Matsumiya <ematsumiya@suse.de>
cc: netfs@lists.linux.dev
cc: v9fs@lists.linux.dev
cc: linux-afs@lists.infradead.org
cc: linux-cifs@vger.kernel.org
cc: linux-fsdevel@vger.kernel.org
Link: https://lore.kernel.org/r/295086.1716298663@warthog.procyon.org.uk/ =
# v1
---
 Changes
 =3D=3D=3D=3D=3D=3D=3D
 ver #2)
  - Set wreq->len when doing direct writes.

 fs/netfs/direct_write.c  |    5 +++--
 fs/netfs/write_collect.c |    7 ++++---
 fs/netfs/write_issue.c   |    2 +-
 3 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/fs/netfs/direct_write.c b/fs/netfs/direct_write.c
index 608ba6416919..93b41e121042 100644
--- a/fs/netfs/direct_write.c
+++ b/fs/netfs/direct_write.c
@@ -12,7 +12,7 @@
 static void netfs_cleanup_dio_write(struct netfs_io_request *wreq)
 {
 	struct inode *inode =3D wreq->inode;
-	unsigned long long end =3D wreq->start + wreq->len;
+	unsigned long long end =3D wreq->start + wreq->transferred;
 =

 	if (!wreq->error &&
 	    i_size_read(inode) < end) {
@@ -92,8 +92,9 @@ static ssize_t netfs_unbuffered_write_iter_locked(struct=
 kiocb *iocb, struct iov
 	__set_bit(NETFS_RREQ_UPLOAD_TO_SERVER, &wreq->flags);
 	if (async)
 		wreq->iocb =3D iocb;
+	wreq->len =3D iov_iter_count(&wreq->io_iter);
 	wreq->cleanup =3D netfs_cleanup_dio_write;
-	ret =3D netfs_unbuffered_write(wreq, is_sync_kiocb(iocb), iov_iter_count=
(&wreq->io_iter));
+	ret =3D netfs_unbuffered_write(wreq, is_sync_kiocb(iocb), wreq->len);
 	if (ret < 0) {
 		_debug("begin =3D %zd", ret);
 		goto out;
diff --git a/fs/netfs/write_collect.c b/fs/netfs/write_collect.c
index 60112e4b2c5e..426cf87aaf2e 100644
--- a/fs/netfs/write_collect.c
+++ b/fs/netfs/write_collect.c
@@ -510,7 +510,7 @@ static void netfs_collect_write_results(struct netfs_i=
o_request *wreq)
 	 * stream has a gap that can be jumped.
 	 */
 	if (notes & SOME_EMPTY) {
-		unsigned long long jump_to =3D wreq->start + wreq->len;
+		unsigned long long jump_to =3D wreq->start + READ_ONCE(wreq->submitted)=
;
 =

 		for (s =3D 0; s < NR_IO_STREAMS; s++) {
 			stream =3D &wreq->io_streams[s];
@@ -690,10 +690,11 @@ void netfs_write_collection_worker(struct work_struc=
t *work)
 	wake_up_bit(&wreq->flags, NETFS_RREQ_IN_PROGRESS);
 =

 	if (wreq->iocb) {
-		wreq->iocb->ki_pos +=3D wreq->transferred;
+		size_t written =3D min(wreq->transferred, wreq->len);
+		wreq->iocb->ki_pos +=3D written;
 		if (wreq->iocb->ki_complete)
 			wreq->iocb->ki_complete(
-				wreq->iocb, wreq->error ? wreq->error : wreq->transferred);
+				wreq->iocb, wreq->error ? wreq->error : written);
 		wreq->iocb =3D VFS_PTR_POISON;
 	}
 =

diff --git a/fs/netfs/write_issue.c b/fs/netfs/write_issue.c
index acbfd1f5ee9d..3aa86e268f40 100644
--- a/fs/netfs/write_issue.c
+++ b/fs/netfs/write_issue.c
@@ -254,7 +254,7 @@ static void netfs_issue_write(struct netfs_io_request =
*wreq,
 	stream->construct =3D NULL;
 =

 	if (subreq->start + subreq->len > wreq->start + wreq->submitted)
-		wreq->len =3D wreq->submitted =3D subreq->start + subreq->len - wreq->s=
tart;
+		WRITE_ONCE(wreq->submitted, subreq->start + subreq->len - wreq->start);
 	netfs_do_issue_write(stream, subreq);
 }
 =