[PATCH 01/10] NFSD: interlock the use of NFSD_IO_DIRECT for NFS READ and WRITE

[Mike Snitzer <snitzer@hammerspace.com>]

Now that NFSD supports NFSD_IO_DIRECT for both READ and WRITE it is
much safer to avoid needless buffered vs direct contention if/when
only one of them has been configured to use NFSD_IO_DIRECT.

Mixing direct and buffered I/O to the same file causes needless page
cache invalidation and writeback, so although io_cache_read and
io_cache_write remain separate interfaces, writing either one adjusts
the other so that READ and WRITE are never left on opposite sides of
the buffered/direct divide:

 - Setting io_cache_read to NFSD_IO_DIRECT elevates a BUFFERED or
   DONTCACHE io_cache_write to NFSD_IO_DIRECT.  A WRITE mode that is
   already direct is left as it is.

 - Setting io_cache_write to any direct mode elevates a BUFFERED or
   DONTCACHE io_cache_read to NFSD_IO_DIRECT.

 - Setting io_cache_read to NFSD_IO_BUFFERED or NFSD_IO_DONTCACHE
   demotes a direct io_cache_write to that same mode.

 - Setting io_cache_write to NFSD_IO_BUFFERED or NFSD_IO_DONTCACHE
   demotes a direct io_cache_read to that same mode.

 - Enabling splice for READ, by writing 0 to disable-splice-read,
   forces io_cache_read to NFSD_IO_BUFFERED and demotes a direct
   io_cache_write along with it.

The demotion is factored into nfsd_io_cache_write_demote() so that its
three callers stay in sync.

Both DONTCACHE and DIRECT READ must copy into the RPC reply buffer, so
splice for READ is disabled whenever either interface leaves
nfsd_io_cache_read above NFSD_IO_BUFFERED, regardless of which one was
written.

Document the complete interlock in
Documentation/filesystems/nfs/nfsd-io-modes.rst.

Fixes: 06c5c97293e3 ("NFSD: Implement NFSD_IO_DIRECT for NFS WRITE")
Assisted-by: Claude:claude-opus-5[1m]
Signed-off-by: Mike Snitzer <snitzer@kernel.org>
---
 .../filesystems/nfs/nfsd-io-modes.rst         | 35 ++++++++++++
 fs/nfsd/debugfs.c                             | 54 ++++++++++++++++---
 2 files changed, 83 insertions(+), 6 deletions(-)

diff --git a/Documentation/filesystems/nfs/nfsd-io-modes.rst b/Documentation/filesystems/nfs/nfsd-io-modes.rst
index 0fd6e82478fe6..a8e277bcb08b1 100644
--- a/Documentation/filesystems/nfs/nfsd-io-modes.rst
+++ b/Documentation/filesystems/nfs/nfsd-io-modes.rst
@@ -41,6 +41,41 @@ corresponding IO operation's debugfs interface, e.g.::
 If you experiment with NFSD's IO modes on a recent kernel and have
 interesting results, please report them to linux-nfs@vger.kernel.org
 
+READ and WRITE IO mode interlock
+================================
+
+Although io_cache_read and io_cache_write are separate interfaces, NFSD
+keeps them from being configured such that one of READ or WRITE uses
+DIRECT IO while the other uses the page cache. Mixing DIRECT and
+buffered IO to the same file causes needless page cache invalidation and
+writeback (see the DIRECT IO discussion in the Linux open(2) manpage),
+so writing one interface may adjust the other:
+
+- Setting io_cache_read to NFSD_IO_DIRECT (2) elevates io_cache_write
+  to NFSD_IO_DIRECT (2) if it was BUFFERED or DONTCACHE. A WRITE mode
+  that is already DIRECT (2, 3 or 4) is left unchanged.
+- Setting io_cache_write to any DIRECT mode (2, 3 or 4) elevates
+  io_cache_read to NFSD_IO_DIRECT (2) if it was BUFFERED or DONTCACHE.
+- Setting io_cache_read to NFSD_IO_BUFFERED (0) or NFSD_IO_DONTCACHE (1)
+  while io_cache_write is a DIRECT mode demotes io_cache_write to that
+  same value (0 or 1). A WRITE mode that is already BUFFERED or
+  DONTCACHE is left unchanged.
+- Setting io_cache_write to NFSD_IO_BUFFERED (0) or NFSD_IO_DONTCACHE
+  (1) while io_cache_read is NFSD_IO_DIRECT demotes io_cache_read to
+  that same value (0 or 1).
+
+Setting either interface to a value other than NFSD_IO_BUFFERED also
+disables NFSD's use of splice for READ, because both DONTCACHE and
+DIRECT READ must copy into the RPC reply buffer. This is reflected in
+/sys/kernel/debug/nfsd/disable-splice-read reading as 1. Writing 0 to
+disable-splice-read re-enables splice, which requires buffered READ, so
+it forces io_cache_read back to NFSD_IO_BUFFERED (0) and, if
+io_cache_write was a DIRECT mode, demotes it to NFSD_IO_BUFFERED (0) as
+well.
+
+Always read both interfaces back after writing either of them to
+confirm the resulting configuration.
+
 NFSD DONTCACHE
 ==============
 
diff --git a/fs/nfsd/debugfs.c b/fs/nfsd/debugfs.c
index 386fd1c54f527..995872a1a7f87 100644
--- a/fs/nfsd/debugfs.c
+++ b/fs/nfsd/debugfs.c
@@ -24,6 +24,17 @@ static int nfsd_dsr_get(void *data, u64 *val)
 	return 0;
 }
 
+/*
+ * NFS READ is no longer using direct I/O: demote NFS WRITE from direct
+ * I/O to the same buffered mode, to avoid needless buffered vs direct
+ * contention.
+ */
+static void nfsd_io_cache_write_demote(u64 io_mode)
+{
+	if (nfsd_io_cache_write >= NFSD_IO_DIRECT)
+		nfsd_io_cache_write = io_mode;
+}
+
 static int nfsd_dsr_set(void *data, u64 val)
 {
 	nfsd_disable_splice_read = (val > 0);
@@ -32,6 +43,7 @@ static int nfsd_dsr_set(void *data, u64 val)
 		 * Must use buffered I/O if splice_read is enabled.
 		 */
 		nfsd_io_cache_read = NFSD_IO_BUFFERED;
+		nfsd_io_cache_write_demote(NFSD_IO_BUFFERED);
 	}
 	return 0;
 }
@@ -62,22 +74,33 @@ static int nfsd_io_cache_read_set(void *data, u64 val)
 
 	switch (val) {
 	case NFSD_IO_BUFFERED:
-		nfsd_io_cache_read = NFSD_IO_BUFFERED;
-		break;
 	case NFSD_IO_DONTCACHE:
+		nfsd_io_cache_read = val;
+		nfsd_io_cache_write_demote(val);
+		break;
 	case NFSD_IO_DIRECT:
+		nfsd_io_cache_read = val;
 		/*
-		 * Must disable splice_read when enabling
-		 * NFSD_IO_DONTCACHE.
+		 * Elevate nfsd_io_cache_write if not already
+		 * configured to use NFSD_IO_DIRECT.
 		 */
-		nfsd_disable_splice_read = true;
-		nfsd_io_cache_read = val;
+		if (nfsd_io_cache_write < NFSD_IO_DIRECT)
+			nfsd_io_cache_write = NFSD_IO_DIRECT;
 		break;
 	default:
 		ret = -EINVAL;
 		break;
 	}
 
+	if (ret == 0) {
+		/*
+		 * Must disable splice_read when enabling
+		 * NFSD_IO_DONTCACHE and NFSD_IO_DIRECT.
+		 */
+		if (nfsd_io_cache_read > NFSD_IO_BUFFERED)
+			nfsd_disable_splice_read = true;
+	}
+
 	return ret;
 }
 
@@ -110,12 +133,31 @@ static int nfsd_io_cache_write_set(void *data, u64 val)
 	case NFSD_IO_DONTCACHE:
 	case NFSD_IO_DIRECT:
 		nfsd_io_cache_write = val;
+		/*
+		 * Adjust nfsd_io_cache_{read,write} to avoid
+		 * needless buffered vs direct contention.
+		 */
+		if (nfsd_io_cache_write >= NFSD_IO_DIRECT &&
+		    nfsd_io_cache_read < NFSD_IO_DIRECT)
+			nfsd_io_cache_read = NFSD_IO_DIRECT;
+		else if (nfsd_io_cache_write < NFSD_IO_DIRECT &&
+			 nfsd_io_cache_read == NFSD_IO_DIRECT)
+			nfsd_io_cache_read = nfsd_io_cache_write;
 		break;
 	default:
 		ret = -EINVAL;
 		break;
 	}
 
+	if (ret == 0) {
+		/*
+		 * Must disable splice_read when enabling
+		 * NFSD_IO_DONTCACHE and NFSD_IO_DIRECT.
+		 */
+		if (nfsd_io_cache_read > NFSD_IO_BUFFERED)
+			nfsd_disable_splice_read = true;
+	}
+
 	return ret;
 }
 
-- 
2.52.0