NFSD: Implement NFSD_IO_DIRECT for NFS WRITE

The client specifies with the stable parameter the method of how the data is to be processed by the server. If stable is FILE_SYNC4, the server MUST commit the data written plus all file system metadata to stable storage before returning results. This corresponds to the NFSv2 protocol semantics. Any other behavior constitutes a protocol violation. If stable is DATA_SYNC4, then the server MUST commit all of the data to stable storage and enough of the metadata to retrieve the data before returning.

Hi Chuck,

kernel test robot noticed the following build errors:

[auto build test ERROR on v6.18-rc3]
[also build test ERROR on linus/master next-20251028] [cannot apply to brauner-vfs/vfs.all]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]

url:    https://github.com/intel-lab-lkp/linux/commits/Chuck-Lever/NFSD-Make-FILE_SYNC-WRITEs-comply-with-spec/20251028-000506
base:   v6.18-rc3
patch link:    https://lore.kernel.org/r/20251027154630.1774-4-cel%40kernel.org
patch subject: [PATCH v8 03/12] NFSD: Implement NFSD_IO_DIRECT for NFS WRITE
config: x86_64-kexec (https://download.01.org/0day-ci/archive/20251029/[email protected]/config)
compiler: clang version 20.1.8 (https://github.com/llvm/llvm-project 87f0227cb60147a26a1eeb4fb06e3b505e9c7261)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20251029/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All errors (new ones prefixed by >>):

Quoted 1 line

Quoted 1 line

fs/nfsd/vfs.c:1455:7: error: use of undeclared identifier 'NFSD_IO_DIRECT'

1455 | case NFSD_IO_DIRECT:
| ^
1 error generated.
--

Quoted 1 line

Quoted 1 line

fs/nfsd/debugfs.c:109:7: error: use of undeclared identifier 'NFSD_IO_DIRECT'

109 | case NFSD_IO_DIRECT:
| ^
1 error generated.

vim +/NFSD_IO_DIRECT +1455 fs/nfsd/vfs.c

1374
1375 /**
1376 * nfsd_vfs_write - write data to an already-open file
1377 * @rqstp: RPC execution context
1378 * @fhp: File handle of file to write into
1379 * @nf: An open file matching @fhp
1380 * @offset: Byte offset of start
1381 * @payload: xdr_buf containing the write payload
1382 * @cnt: IN: number of bytes to write, OUT: number of bytes actually written
1383 * @stable_how: IN: Client's requested stable_how, OUT: Actual stable_how
1384 * @verf: NFS WRITE verifier
1385 *
1386 * Upon return, caller must invoke fh_put on @fhp.
1387 *
1388 * Return values:
1389 * An nfsstat value in network byte order.
1390 */
1391 __be32
1392 nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp,

  1393		       struct nfsd_file *nf, loff_t offset,
  1394		       const struct xdr_buf *payload, unsigned long *cnt,
  1395		       u32 *stable_how, __be32 *verf)

1396 {
1397 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1398 struct file *file = nf->nf_file;
1399 struct super_block *sb = file_inode(file)->i_sb;
1400 u32 stable = *stable_how;
1401 struct kiocb kiocb;
1402 struct svc_export *exp;
1403 errseq_t since;
1404 __be32 nfserr;
1405 int host_err;
1406 unsigned long exp_op_flags = 0;
1407 unsigned int pflags = current->flags;
1408 bool restore_flags = false;
1409 unsigned int nvecs;
1410
1411 trace_nfsd_write_opened(rqstp, fhp, offset, *cnt);
1412
1413 if (sb->s_export_op)
1414 exp_op_flags = sb->s_export_op->flags;
1415
1416 if (test_bit(RQ_LOCAL, &rqstp->rq_flags) &&
1417 !(exp_op_flags & EXPORT_OP_REMOTE_FS)) {
1418 /*
1419 * We want throttling in balance_dirty_pages()
1420 * and shrink_inactive_list() to only consider
1421 * the backingdev we are writing to, so that nfs to
1422 * localhost doesn't cause nfsd to lock up due to all
1423 * the client's dirty pages or its congested queue.
1424 */
1425 current->flags |= PF_LOCAL_THROTTLE;
1426 restore_flags = true;
1427 }
1428
1429 exp = fhp->fh_export;
1430
1431 if (!EX_ISSYNC(exp))
1432 stable = NFS_UNSTABLE;
1433 init_sync_kiocb(&kiocb, file);
1434 kiocb.ki_pos = offset;
1435 if (likely(!fhp->fh_use_wgather)) {
1436 switch (stable) {
1437 case NFS_FILE_SYNC:
1438 /* persist data and timestamps */
1439 kiocb.ki_flags |= IOCB_DSYNC | IOCB_SYNC;
1440 break;
1441 case NFS_DATA_SYNC:
1442 /* persist data only */
1443 kiocb.ki_flags |= IOCB_DSYNC;
1444 break;
1445 }
1446 }
1447
1448 nvecs = xdr_buf_to_bvec(rqstp->rq_bvec, rqstp->rq_maxpages, payload);
1449
1450 since = READ_ONCE(file->f_wb_err);
1451 if (verf)
1452 nfsd_copy_write_verifier(verf, nn);
1453
1454 switch (nfsd_io_cache_write) {

Quoted 1 line

1455 case NFSD_IO_DIRECT:

1456 host_err = nfsd_direct_write(rqstp, fhp, nf, stable_how,
1457 nvecs, cnt, &kiocb);
1458 stable = *stable_how;
1459 break;
1460 case NFSD_IO_DONTCACHE:
1461 if (file->f_op->fop_flags & FOP_DONTCACHE)
1462 kiocb.ki_flags |= IOCB_DONTCACHE;
1463 fallthrough; /* must call nfsd_buffered_write */
1464 case NFSD_IO_BUFFERED:
1465 host_err = nfsd_buffered_write(rqstp, file,
1466 nvecs, cnt, &kiocb);
1467 break;
1468 }
1469 if (host_err < 0) {
1470 commit_reset_write_verifier(nn, rqstp, host_err);
1471 goto out_nfserr;
1472 }
1473 nfsd_stats_io_write_add(nn, exp, *cnt);
1474 fsnotify_modify(file);
1475 host_err = filemap_check_wb_err(file->f_mapping, since);
1476 if (host_err < 0)
1477 goto out_nfserr;
1478
1479 if (stable && fhp->fh_use_wgather) {
1480 host_err = wait_for_concurrent_writes(file);
1481 if (host_err < 0)
1482 commit_reset_write_verifier(nn, rqstp, host_err);
1483 }
1484
1485 out_nfserr:
1486 if (host_err >= 0) {
1487 trace_nfsd_write_io_done(rqstp, fhp, offset, *cnt);
1488 nfserr = nfs_ok;
1489 } else {
1490 trace_nfsd_write_err(rqstp, fhp, offset, host_err);
1491 nfserr = nfserrno(host_err);
1492 }
1493 if (restore_flags)
1494 current_restore_flags(pflags, PF_LOCAL_THROTTLE);
1495 return nfserr;
1496 }
1497

Quoted 37 lines · kernel test robot

Hi Chuck,

kernel test robot noticed the following build errors:

[auto build test ERROR on v6.18-rc3]
[also build test ERROR on linus/master next-20251028] [cannot apply to brauner-vfs/vfs.all]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]

url:    https://github.com/intel-lab-lkp/linux/commits/Chuck-Lever/NFSD-Make-FILE_SYNC-WRITEs-comply-with-spec/20251028-000506
base:   v6.18-rc3
patch link:    https://lore.kernel.org/r/20251027154630.1774-4-cel%40kernel.org
patch subject: [PATCH v8 03/12] NFSD: Implement NFSD_IO_DIRECT for NFS WRITE
config: x86_64-kexec (https://download.01.org/0day-ci/archive/20251029/[email protected]/config)
compiler: clang version 20.1.8 (https://github.com/llvm/llvm-project 87f0227cb60147a26a1eeb4fb06e3b505e9c7261)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20251029/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All errors (new ones prefixed by >>):

Quoted 1 line

Quoted 1 line

fs/nfsd/vfs.c:1455:7: error: use of undeclared identifier 'NFSD_IO_DIRECT'

1455 | case NFSD_IO_DIRECT:
| ^
1 error generated.
--

Quoted 1 line

Quoted 1 line

fs/nfsd/debugfs.c:109:7: error: use of undeclared identifier 'NFSD_IO_DIRECT'

109 | case NFSD_IO_DIRECT:
| ^
1 error generated.

Quoted 1 line

vim +/NFSD_IO_DIRECT +1455 fs/nfsd/vfs.c

I'm truly at a loss. Why is the robot attempting to apply this patch to a tree that does not also have 46c42fad83f5 ("NFSD: Implement NFSD_IO_DIRECT for NFS READ")? These patches are in the same branch.

Quoted 127 lines

1374
1375 /**
1376 * nfsd_vfs_write - write data to an already-open file
1377 * @rqstp: RPC execution context
1378 * @fhp: File handle of file to write into
1379 * @nf: An open file matching @fhp
1380 * @offset: Byte offset of start
1381 * @payload: xdr_buf containing the write payload
1382 * @cnt: IN: number of bytes to write, OUT: number of bytes actually written
1383 * @stable_how: IN: Client's requested stable_how, OUT: Actual stable_how
1384 * @verf: NFS WRITE verifier
1385 *
1386 * Upon return, caller must invoke fh_put on @fhp.
1387 *
1388 * Return values:
1389 * An nfsstat value in network byte order.
1390 */
1391 __be32
1392 nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp,

  1393		       struct nfsd_file *nf, loff_t offset,
  1394		       const struct xdr_buf *payload, unsigned long *cnt,
  1395		       u32 *stable_how, __be32 *verf)

1396 {
1397 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1398 struct file *file = nf->nf_file;
1399 struct super_block *sb = file_inode(file)->i_sb;
1400 u32 stable = *stable_how;
1401 struct kiocb kiocb;
1402 struct svc_export *exp;
1403 errseq_t since;
1404 __be32 nfserr;
1405 int host_err;
1406 unsigned long exp_op_flags = 0;
1407 unsigned int pflags = current->flags;
1408 bool restore_flags = false;
1409 unsigned int nvecs;
1410
1411 trace_nfsd_write_opened(rqstp, fhp, offset, *cnt);
1412
1413 if (sb->s_export_op)
1414 exp_op_flags = sb->s_export_op->flags;
1415
1416 if (test_bit(RQ_LOCAL, &rqstp->rq_flags) &&
1417 !(exp_op_flags & EXPORT_OP_REMOTE_FS)) {
1418 /*
1419 * We want throttling in balance_dirty_pages()
1420 * and shrink_inactive_list() to only consider
1421 * the backingdev we are writing to, so that nfs to
1422 * localhost doesn't cause nfsd to lock up due to all
1423 * the client's dirty pages or its congested queue.
1424 */
1425 current->flags |= PF_LOCAL_THROTTLE;
1426 restore_flags = true;
1427 }
1428
1429 exp = fhp->fh_export;
1430
1431 if (!EX_ISSYNC(exp))
1432 stable = NFS_UNSTABLE;
1433 init_sync_kiocb(&kiocb, file);
1434 kiocb.ki_pos = offset;
1435 if (likely(!fhp->fh_use_wgather)) {
1436 switch (stable) {
1437 case NFS_FILE_SYNC:
1438 /* persist data and timestamps */
1439 kiocb.ki_flags |= IOCB_DSYNC | IOCB_SYNC;
1440 break;
1441 case NFS_DATA_SYNC:
1442 /* persist data only */
1443 kiocb.ki_flags |= IOCB_DSYNC;
1444 break;
1445 }
1446 }
1447
1448 nvecs = xdr_buf_to_bvec(rqstp->rq_bvec, rqstp->rq_maxpages, payload);
1449
1450 since = READ_ONCE(file->f_wb_err);
1451 if (verf)
1452 nfsd_copy_write_verifier(verf, nn);
1453
1454 switch (nfsd_io_cache_write) {

Quoted 1 line

1455 case NFSD_IO_DIRECT:

1456 host_err = nfsd_direct_write(rqstp, fhp, nf, stable_how,
1457 nvecs, cnt, &kiocb);
1458 stable = *stable_how;
1459 break;
1460 case NFSD_IO_DONTCACHE:
1461 if (file->f_op->fop_flags & FOP_DONTCACHE)
1462 kiocb.ki_flags |= IOCB_DONTCACHE;
1463 fallthrough; /* must call nfsd_buffered_write */
1464 case NFSD_IO_BUFFERED:
1465 host_err = nfsd_buffered_write(rqstp, file,
1466 nvecs, cnt, &kiocb);
1467 break;
1468 }
1469 if (host_err < 0) {
1470 commit_reset_write_verifier(nn, rqstp, host_err);
1471 goto out_nfserr;
1472 }
1473 nfsd_stats_io_write_add(nn, exp, *cnt);
1474 fsnotify_modify(file);
1475 host_err = filemap_check_wb_err(file->f_mapping, since);
1476 if (host_err < 0)
1477 goto out_nfserr;
1478
1479 if (stable && fhp->fh_use_wgather) {
1480 host_err = wait_for_concurrent_writes(file);
1481 if (host_err < 0)
1482 commit_reset_write_verifier(nn, rqstp, host_err);
1483 }
1484
1485 out_nfserr:
1486 if (host_err >= 0) {
1487 trace_nfsd_write_io_done(rqstp, fhp, offset, *cnt);
1488 nfserr = nfs_ok;
1489 } else {
1490 trace_nfsd_write_err(rqstp, fhp, offset, host_err);
1491 nfserr = nfserrno(host_err);
1492 }
1493 if (restore_flags)
1494 current_restore_flags(pflags, PF_LOCAL_THROTTLE);
1495 return nfserr;
1496 }
1497

Signature · 1 line

Chuck Lever

From: Chuck Lever <[email protected]>

Pages in the RPC receive buffer are contiguous. Practically speaking, this means that, after the first bvec, the bv_offset field is always zero.

The loop in nfsd_iov_iter_aligned_bvec() also sets "skip" to zero after the first bvec is checked. Thus, for bvecs following the first one, bv_offset = 0 and skip = 0, and the check becomes:

(0 + 0) & addr_mask = 0

This always passes regardless of the alignment mask.

Since all bvecs after the first one start at bv_offset zero (page- aligned), they are inherently aligned for DIO. Therefore, only the first bvec needs to be checked for DIO alignment.

Note that for RDMA transports, the incoming payload always starts on page alignment, since svcrdma sets up the RDMA Read sink buffers that way. For RDMA, this loop visits every bvec in each payload, and never finds an unaligned bvec.

Signed-off-by Chuck Lever <[email protected]>

---
 fs/nfsd/vfs.c | 26 ++++++++------------------
 1 file changed, 8 insertions(+), 18 deletions(-)

fs/nfsd/vfs.c +7 -12

index 5d6efcceb8c9..37353fb48d58 100644
@@ -1288,30 +1288,20 @@ nfsd_is_write_dio_possible(loff_t offset, unsigned long len,
 	return true;
 }
 
+/*
+ * Check if the bvec iterator is aligned for direct I/O.
+ *
+ * bvecs generated from RPC receive buffers are contiguous: After the first
+ * bvec, all subsequent bvecs start at bv_offset zero (page-aligned).
+ * Therefore, only the first bvec is checked.
+ */
 static bool
 nfsd_iov_iter_aligned_bvec(const struct nfsd_file *nf, const struct iov_iter *i)
 {
-	unsigned int len_mask = nf->nf_dio_offset_align - 1;
 	unsigned int addr_mask = nf->nf_dio_mem_align - 1;
 	const struct bio_vec *bvec = i->bvec;
-	size_t skip = i->iov_offset;
-	size_t size = i->count;
 
-	if (size & len_mask)
-		return false;
-	do {
-		size_t len = bvec->bv_len;
-
-		if (len > size)
-			len = size;
-		if ((unsigned long)(bvec->bv_offset + skip) & addr_mask)
-			return false;

fs/nfsd/vfs.c +7 -0

+/*
+ * Check if the bvec iterator is aligned for direct I/O.
+ *
+ * bvecs generated from RPC receive buffers are contiguous: After the first
+ * bvec, all subsequent bvecs start at bv_offset zero (page-aligned).
+ * Therefore, only the first bvec is checked.
+ */

From: Chuck Lever <[email protected]>

Currently, nfsd_is_write_dio_possible() only considers file offset alignment (nf_dio_offset_align) when splitting an NFS WRITE request into segments. This leaves accounting for memory buffer alignment (nf_dio_mem_align) until nfsd_setup_write_dio_iters(). If this second check fails, the code falls back to cached I/O entirely, wasting the opportunity to use direct I/O for the bulk of the request.

Enhance the logic to find a beginning segment size that satisfies both alignment constraints simultaneously. The search algorithm starts with the file offset alignment requirement and steps through multiples of offset_align, checking memory alignment at each step. The search is bounded by lcm(offset_align, mem_align) to ensure that it always terminates.

Signed-off-by Chuck Lever <[email protected]>

---
 fs/nfsd/filecache.c |   5 ++
 fs/nfsd/filecache.h |   1 +
 fs/nfsd/vfs.c       | 119 +++++++++++++++++++++++++++++---------------
 3 files changed, 86 insertions(+), 39 deletions(-)

fs/nfsd/filecache.c +5 -0

index a238b6725008..89adc4ab5b24 100644
@@ -40,6 +40,7 @@
 #include <linux/seq_file.h>
 #include <linux/rhashtable.h>
 #include <linux/nfslocalio.h>
+#include <linux/lcm.h>
 
 #include "vfs.h"
 #include "nfsd.h"

@@ -234,6 +235,7 @@ nfsd_file_alloc(struct net *net, struct inode *inode, unsigned char need,
 	nf->nf_dio_mem_align = 0;
 	nf->nf_dio_offset_align = 0;
 	nf->nf_dio_read_offset_align = 0;
+	nf->nf_dio_align_lcm = 0;
 	return nf;
 }
 

@@ -1071,6 +1073,9 @@ nfsd_file_get_dio_attrs(const struct svc_fh *fhp, struct nfsd_file *nf)
 	if (stat.result_mask & STATX_DIOALIGN) {
 		nf->nf_dio_mem_align = stat.dio_mem_align;
 		nf->nf_dio_offset_align = stat.dio_offset_align;
+		if (stat.dio_mem_align && stat.dio_offset_align)
+			nf->nf_dio_align_lcm = lcm(stat.dio_mem_align,
+						   stat.dio_offset_align);
 	}
 	if (stat.result_mask & STATX_DIO_READ_ALIGN)
 		nf->nf_dio_read_offset_align = stat.dio_read_offset_align;

fs/nfsd/filecache.h +1 -0

index e3d6ca2b6030..2648aaab5a1b 100644
@@ -58,6 +58,7 @@ struct nfsd_file {
 	u32			nf_dio_mem_align;
 	u32			nf_dio_offset_align;
 	u32			nf_dio_read_offset_align;
+	unsigned long		nf_dio_align_lcm;
 };
 
 int nfsd_file_cache_init(void);

fs/nfsd/vfs.c +78 -38

index 37353fb48d58..a872be300c9f 100644
@@ -1261,49 +1261,73 @@ struct nfsd_write_dio_seg {
 
 struct nfsd_write_dio_args {
 	struct nfsd_file		*nf;
-	size_t				first, middle, last;
 	unsigned int			nsegs;
 	struct nfsd_write_dio_seg	segment[3];
 };
 
+/*
+ * Find the minimum offset within the write request that aligns both
+ * the file offset and memory buffer for direct I/O.
+ *
+ * Returns the size of the unaligned prefix, or SIZE_MAX if no alignment
+ * is possible within reasonable bounds.
+ */
+static size_t
+nfsd_find_dio_aligned_offset(struct nfsd_file *nf, loff_t file_offset,
+			     unsigned long mem_offset, size_t total_len)
+{
+	u32 offset_align = nf->nf_dio_offset_align;
+	u32 mem_align = nf->nf_dio_mem_align;
+	unsigned long search_limit;
+	size_t first;
+
+	/* Start with the file offset alignment requirement */
+	first = round_up(file_offset, offset_align) - file_offset;
+
+	/* Quick check: does this also satisfy memory alignment? */
+	if (((mem_offset + first) & (mem_align - 1)) == 0)
+		return first;
+
+	/*
+	 * Search for a value that satisfies both constraints by stepping
+	 * through multiples of offset_align. Limit search to one period
+	 * of the LCM. We need to check up through the search_limit to
+	 * cover all possible alignments within the LCM period.
+	 */
+	search_limit = min_t(unsigned long, nf->nf_dio_align_lcm, total_len);
+
+	for (; first <= search_limit && first < total_len; first += offset_align) {
+		if (((mem_offset + first) & (mem_align - 1)) == 0)
+			return first;
+	}
+
+	return SIZE_MAX;  /* No alignment found */
+}
+
+/*
+ * Check if the underlying file system implements direct I/O.
+ */
 static bool
 nfsd_is_write_dio_possible(loff_t offset, unsigned long len,
 			   struct nfsd_write_dio_args *args)
 {
-	u32 dio_blocksize = args->nf->nf_dio_offset_align;
-	loff_t first_end, orig_end, middle_end;
+	u32 offset_align = args->nf->nf_dio_offset_align;
+	u32 mem_align = args->nf->nf_dio_mem_align;
 
-	if (unlikely(!args->nf->nf_dio_mem_align || !dio_blocksize))
-		return false;
-	if (unlikely(len < dio_blocksize))
+	if (unlikely(!mem_align || !offset_align))
 		return false;
 
-	first_end = round_up(offset, dio_blocksize);
-	orig_end = offset + len;
-	middle_end = round_down(orig_end, dio_blocksize);
+	/*
+	 * Need enough data to potentially find an aligned segment.
+	 * In the worst case, we might need up to
+	 * lcm(offset_align, mem_align) bytes for the prefix.
+	 */
+	if (unlikely(len < max(offset_align, mem_align)))
+		return false;
 
-	args->first = first_end - offset;
-	args->middle = middle_end - first_end;
-	args->last = orig_end - middle_end;
 	return true;
 }
 
-/*
- * Check if the bvec iterator is aligned for direct I/O.
- *
- * bvecs generated from RPC receive buffers are contiguous: After the first
- * bvec, all subsequent bvecs start at bv_offset zero (page-aligned).
- * Therefore, only the first bvec is checked.
- */
-static bool
-nfsd_iov_iter_aligned_bvec(const struct nfsd_file *nf, const struct iov_iter *i)
-{
-	unsigned int addr_mask = nf->nf_dio_mem_align - 1;
-	const struct bio_vec *bvec = i->bvec;
-
-	return !((unsigned long)(bvec->bv_offset + i->iov_offset) & addr_mask);
-}
-
 static void
 nfsd_write_dio_seg_init(struct nfsd_write_dio_seg *segment,
 			struct bio_vec *bvec, unsigned int nvecs,

@@ -1318,29 +1342,45 @@ nfsd_write_dio_seg_init(struct nfsd_write_dio_seg *segment,
 
 static bool
 nfsd_setup_write_dio_iters(struct bio_vec *bvec, unsigned int nvecs,
-			   unsigned long total,
+			   loff_t offset, unsigned long total,
 			   struct nfsd_write_dio_args *args)
 {
+	u32 offset_align = args->nf->nf_dio_offset_align;
+	unsigned long mem_offset = bvec->bv_offset;
+	loff_t prefix_end, orig_end, middle_end;
+	size_t prefix, middle, suffix;
+
 	args->nsegs = 0;
 
-	if (args->first) {
+	prefix = nfsd_find_dio_aligned_offset(args->nf, offset, mem_offset,
+					     total);
+	if (prefix == SIZE_MAX)
+		return false;	/* No alignment possible */
+
+	prefix_end = offset + prefix;
+	orig_end = offset + total;
+	middle_end = round_down(orig_end, offset_align);
+
+	middle = middle_end - prefix_end;
+	suffix = orig_end - middle_end;
+
+	if (prefix) {
 		nfsd_write_dio_seg_init(&args->segment[args->nsegs], bvec,
-					nvecs, total, 0, args->first);
+					nvecs, total, 0, prefix);
 		++args->nsegs;
 	}
 
+	if (!middle)
+		return false;	/* No aligned region for DIO */
+
 	nfsd_write_dio_seg_init(&args->segment[args->nsegs], bvec, nvecs,
-				total, args->first, args->middle);
-	if (!nfsd_iov_iter_aligned_bvec(args->nf,
-					&args->segment[args->nsegs].iter))
-		return false;	/* no DIO-aligned IO possible */
+				total, prefix, middle);
 	args->segment[args->nsegs].use_dio = true;
 	++args->nsegs;
 
-	if (args->last) {
+	if (suffix) {
 		nfsd_write_dio_seg_init(&args->segment[args->nsegs], bvec,
-					nvecs, total, args->first +
-					args->middle, args->last);
+					nvecs, total, prefix + middle, suffix);
 		++args->nsegs;
 	}
 

Quoted 232 lines · Chuck Lever

From: Chuck Lever <[email protected]>

Currently, nfsd_is_write_dio_possible() only considers file offset alignment (nf_dio_offset_align) when splitting an NFS WRITE request into segments. This leaves accounting for memory buffer alignment (nf_dio_mem_align) until nfsd_setup_write_dio_iters(). If this second check fails, the code falls back to cached I/O entirely, wasting the opportunity to use direct I/O for the bulk of the request.

Enhance the logic to find a beginning segment size that satisfies both alignment constraints simultaneously. The search algorithm starts with the file offset alignment requirement and steps through multiples of offset_align, checking memory alignment at each step. The search is bounded by lcm(offset_align, mem_align) to ensure that it always terminates.

Signed-off-by Chuck Lever <[email protected]>

---
 fs/nfsd/filecache.c |   5 ++
 fs/nfsd/filecache.h |   1 +
 fs/nfsd/vfs.c       | 119 +++++++++++++++++++++++++++++---------------
 3 files changed, 86 insertions(+), 39 deletions(-)

fs/nfsd/filecache.c +5 -0

index a238b6725008..89adc4ab5b24 100644
@@ -40,6 +40,7 @@
 #include <linux/seq_file.h>
 #include <linux/rhashtable.h>
 #include <linux/nfslocalio.h>
+#include <linux/lcm.h>
 
 #include "vfs.h"
 #include "nfsd.h"

@@ -234,6 +235,7 @@ nfsd_file_alloc(struct net *net, struct inode *inode, unsigned char need,
 	nf->nf_dio_mem_align = 0;
 	nf->nf_dio_offset_align = 0;
 	nf->nf_dio_read_offset_align = 0;
+	nf->nf_dio_align_lcm = 0;
 	return nf;
 }
 

@@ -1071,6 +1073,9 @@ nfsd_file_get_dio_attrs(const struct svc_fh *fhp, struct nfsd_file *nf)
 	if (stat.result_mask & STATX_DIOALIGN) {
 		nf->nf_dio_mem_align = stat.dio_mem_align;
 		nf->nf_dio_offset_align = stat.dio_offset_align;
+		if (stat.dio_mem_align && stat.dio_offset_align)
+			nf->nf_dio_align_lcm = lcm(stat.dio_mem_align,
+						   stat.dio_offset_align);
 	}
 	if (stat.result_mask & STATX_DIO_READ_ALIGN)
 		nf->nf_dio_read_offset_align = stat.dio_read_offset_align;

fs/nfsd/filecache.h +1 -0

index e3d6ca2b6030..2648aaab5a1b 100644
@@ -58,6 +58,7 @@ struct nfsd_file {
 	u32			nf_dio_mem_align;
 	u32			nf_dio_offset_align;
 	u32			nf_dio_read_offset_align;
+	unsigned long		nf_dio_align_lcm;
 };
 
 int nfsd_file_cache_init(void);

fs/nfsd/vfs.c +78 -38

index 37353fb48d58..a872be300c9f 100644
@@ -1261,49 +1261,73 @@ struct nfsd_write_dio_seg {
 
 struct nfsd_write_dio_args {
 	struct nfsd_file		*nf;
-	size_t				first, middle, last;
 	unsigned int			nsegs;
 	struct nfsd_write_dio_seg	segment[3];
 };
 
+/*
+ * Find the minimum offset within the write request that aligns both
+ * the file offset and memory buffer for direct I/O.
+ *
+ * Returns the size of the unaligned prefix, or SIZE_MAX if no alignment
+ * is possible within reasonable bounds.
+ */
+static size_t
+nfsd_find_dio_aligned_offset(struct nfsd_file *nf, loff_t file_offset,
+			     unsigned long mem_offset, size_t total_len)
+{
+	u32 offset_align = nf->nf_dio_offset_align;
+	u32 mem_align = nf->nf_dio_mem_align;
+	unsigned long search_limit;
+	size_t first;
+
+	/* Start with the file offset alignment requirement */
+	first = round_up(file_offset, offset_align) - file_offset;
+
+	/* Quick check: does this also satisfy memory alignment? */
+	if (((mem_offset + first) & (mem_align - 1)) == 0)
+		return first;
+
+	/*
+	 * Search for a value that satisfies both constraints by stepping
+	 * through multiples of offset_align. Limit search to one period
+	 * of the LCM. We need to check up through the search_limit to
+	 * cover all possible alignments within the LCM period.
+	 */
+	search_limit = min_t(unsigned long, nf->nf_dio_align_lcm, total_len);
+
+	for (; first <= search_limit && first < total_len; first += offset_align) {
+		if (((mem_offset + first) & (mem_align - 1)) == 0)
+			return first;
+	}
+
+	return SIZE_MAX;  /* No alignment found */
+}
+
+/*
+ * Check if the underlying file system implements direct I/O.
+ */
 static bool
 nfsd_is_write_dio_possible(loff_t offset, unsigned long len,
 			   struct nfsd_write_dio_args *args)
 {
-	u32 dio_blocksize = args->nf->nf_dio_offset_align;
-	loff_t first_end, orig_end, middle_end;
+	u32 offset_align = args->nf->nf_dio_offset_align;
+	u32 mem_align = args->nf->nf_dio_mem_align;
 
-	if (unlikely(!args->nf->nf_dio_mem_align || !dio_blocksize))
-		return false;
-	if (unlikely(len < dio_blocksize))
+	if (unlikely(!mem_align || !offset_align))
 		return false;
 
-	first_end = round_up(offset, dio_blocksize);
-	orig_end = offset + len;
-	middle_end = round_down(orig_end, dio_blocksize);
+	/*
+	 * Need enough data to potentially find an aligned segment.
+	 * In the worst case, we might need up to
+	 * lcm(offset_align, mem_align) bytes for the prefix.
+	 */
+	if (unlikely(len < max(offset_align, mem_align)))
+		return false;
 
-	args->first = first_end - offset;
-	args->middle = middle_end - first_end;
-	args->last = orig_end - middle_end;
 	return true;
 }
 
-/*
- * Check if the bvec iterator is aligned for direct I/O.
- *
- * bvecs generated from RPC receive buffers are contiguous: After the first
- * bvec, all subsequent bvecs start at bv_offset zero (page-aligned).
- * Therefore, only the first bvec is checked.
- */
-static bool
-nfsd_iov_iter_aligned_bvec(const struct nfsd_file *nf, const struct iov_iter *i)
-{
-	unsigned int addr_mask = nf->nf_dio_mem_align - 1;
-	const struct bio_vec *bvec = i->bvec;
-
-	return !((unsigned long)(bvec->bv_offset + i->iov_offset) & addr_mask);
-}
-
 static void
 nfsd_write_dio_seg_init(struct nfsd_write_dio_seg *segment,
 			struct bio_vec *bvec, unsigned int nvecs,

@@ -1318,29 +1342,45 @@ nfsd_write_dio_seg_init(struct nfsd_write_dio_seg *segment,
 
 static bool
 nfsd_setup_write_dio_iters(struct bio_vec *bvec, unsigned int nvecs,
-			   unsigned long total,
+			   loff_t offset, unsigned long total,
 			   struct nfsd_write_dio_args *args)
 {
+	u32 offset_align = args->nf->nf_dio_offset_align;
+	unsigned long mem_offset = bvec->bv_offset;
+	loff_t prefix_end, orig_end, middle_end;
+	size_t prefix, middle, suffix;
+
 	args->nsegs = 0;
 
-	if (args->first) {
+	prefix = nfsd_find_dio_aligned_offset(args->nf, offset, mem_offset,
+					     total);
+	if (prefix == SIZE_MAX)
+		return false;	/* No alignment possible */
+
+	prefix_end = offset + prefix;
+	orig_end = offset + total;
+	middle_end = round_down(orig_end, offset_align);
+
+	middle = middle_end - prefix_end;
+	suffix = orig_end - middle_end;
+
+	if (prefix) {
 		nfsd_write_dio_seg_init(&args->segment[args->nsegs], bvec,
-					nvecs, total, 0, args->first);
+					nvecs, total, 0, prefix);
 		++args->nsegs;
 	}
 
+	if (!middle)
+		return false;	/* No aligned region for DIO */
+
 	nfsd_write_dio_seg_init(&args->segment[args->nsegs], bvec, nvecs,
-				total, args->first, args->middle);
-	if (!nfsd_iov_iter_aligned_bvec(args->nf,
-					&args->segment[args->nsegs].iter))
-		return false;	/* no DIO-aligned IO possible */
+				total, prefix, middle);
 	args->segment[args->nsegs].use_dio = true;
 	++args->nsegs;
 
-	if (args->last) {
+	if (suffix) {
 		nfsd_write_dio_seg_init(&args->segment[args->nsegs], bvec,
-					nvecs, total, args->first +
-					args->middle, args->last);
+					nvecs, total, prefix + middle, suffix);
 		++args->nsegs;
 	}
 

@@ -1373,7 +1413,8 @@ nfsd_issue_write_dio(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *stable_how
 	ssize_t host_err;
 	unsigned int i;
 

fs/nfsd/vfs.c nfsd_issue_write_dio(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *stable_how · line 1420

Quoted 6 lines

fs/nfsd/vfs.c +2 -1

-	if (!nfsd_setup_write_dio_iters(rqstp->rq_bvec, nvecs, *cnt, args))
+	if (!nfsd_setup_write_dio_iters(rqstp->rq_bvec, nvecs, kiocb->ki_pos,
+					*cnt, args))
 		return nfsd_buffered_write(rqstp, file, nvecs, cnt, kiocb);
 
 	/*

Not an easy patch to follow, but I think I get it.

Reviewed-by Jeff Layton <[email protected]>

From: Chuck Lever <[email protected]>

Currently, nfsd_is_write_dio_possible() only considers file offset alignment (nf_dio_offset_align) when splitting an NFS WRITE request into segments. This leaves accounting for memory buffer alignment (nf_dio_mem_align) until nfsd_setup_write_dio_iters(). If this second check fails, the code falls back to cached I/O entirely, wasting the opportunity to use direct I/O for the bulk of the request.

Enhance the logic to find a beginning segment size that satisfies both alignment constraints simultaneously. The search algorithm starts with the file offset alignment requirement and steps through multiples of offset_align, checking memory alignment at each step. The search is bounded by lcm(offset_align, mem_align) to ensure that it always terminates.

Quoted 10 lines · Chuck Lever

From: Chuck Lever <[email protected]>

Currently, nfsd_is_write_dio_possible() only considers file offset alignment (nf_dio_offset_align) when splitting an NFS WRITE request into segments. This leaves accounting for memory buffer alignment (nf_dio_mem_align) until nfsd_setup_write_dio_iters(). If this second check fails, the code falls back to cached I/O entirely, wasting the opportunity to use direct I/O for the bulk of the request.

Quoted 6 lines

Enhance the logic to find a beginning segment size that satisfies both alignment constraints simultaneously. The search algorithm starts with the file offset alignment requirement and steps through multiples of offset_align, checking memory alignment at each step. The search is bounded by lcm(offset_align, mem_align) to ensure that it always terminates.

How likely is that going to happen? After the first bvec the alignment constrains won't change, so how are we going to succeed then?

Quoted 4 lines

How likely is that going to happen? After the first bvec the alignment constrains won't change, so how are we going to succeed then?

I was hoping that this algorithm would improve the likelihood of finding a middle segment alignment for NFS WRITE on TCP. I'm not entirely sure it has been effective.

Quoted 18 lines · Christoph Hellwig

Quoted 10 lines · Chuck Lever

From: Chuck Lever <[email protected]>

Currently, nfsd_is_write_dio_possible() only considers file offset alignment (nf_dio_offset_align) when splitting an NFS WRITE request into segments. This leaves accounting for memory buffer alignment (nf_dio_mem_align) until nfsd_setup_write_dio_iters(). If this second check fails, the code falls back to cached I/O entirely, wasting the opportunity to use direct I/O for the bulk of the request.

Quoted 6 lines

Enhance the logic to find a beginning segment size that satisfies both alignment constraints simultaneously. The search algorithm starts with the file offset alignment requirement and steps through multiples of offset_align, checking memory alignment at each step. The search is bounded by lcm(offset_align, mem_align) to ensure that it always terminates.

Quoted 4 lines

How likely is that going to happen? After the first bvec the alignment constrains won't change, so how are we going to succeed then?

I was hoping that this algorithm would improve the likelihood of finding a middle segment alignment for NFS WRITE on TCP. I'm not entirely sure it has been effective.

Given the complexity, I'm wondering if I want to keep this one.

From: Chuck Lever <[email protected]>

When direct I/O is not feasible (due to missing alignment info, too-small writes, or no alignment possible), pack the entire write payload into a single non-DIO segment and follow the usual direct write I/O path.

This simplifies nfsd_direct_write() by eliminating the fallback path and the separate nfsd_buffered_write() call - all writes now go through nfsd_issue_write_dio() which handles both DIO and buffered segments.

Signed-off-by Chuck Lever <[email protected]>

---
 fs/nfsd/vfs.c | 69 +++++++++++++++++++++------------------------------
 1 file changed, 28 insertions(+), 41 deletions(-)

fs/nfsd/vfs.c +26 -36

index a872be300c9f..be0688f2ab3d 100644
@@ -1304,30 +1304,6 @@ nfsd_find_dio_aligned_offset(struct nfsd_file *nf, loff_t file_offset,
 	return SIZE_MAX;  /* No alignment found */
 }
 
-/*
- * Check if the underlying file system implements direct I/O.
- */
-static bool
-nfsd_is_write_dio_possible(loff_t offset, unsigned long len,
-			   struct nfsd_write_dio_args *args)
-{
-	u32 offset_align = args->nf->nf_dio_offset_align;
-	u32 mem_align = args->nf->nf_dio_mem_align;
-
-	if (unlikely(!mem_align || !offset_align))
-		return false;
-
-	/*
-	 * Need enough data to potentially find an aligned segment.
-	 * In the worst case, we might need up to
-	 * lcm(offset_align, mem_align) bytes for the prefix.
-	 */
-	if (unlikely(len < max(offset_align, mem_align)))
-		return false;
-
-	return true;
-}
-
 static void
 nfsd_write_dio_seg_init(struct nfsd_write_dio_seg *segment,
 			struct bio_vec *bvec, unsigned int nvecs,

@@ -1340,22 +1316,31 @@ nfsd_write_dio_seg_init(struct nfsd_write_dio_seg *segment,
 	segment->use_dio = false;
 }
 
-static bool
-nfsd_setup_write_dio_iters(struct bio_vec *bvec, unsigned int nvecs,
-			   loff_t offset, unsigned long total,
-			   struct nfsd_write_dio_args *args)
+static void
+nfsd_write_dio_iters_init(struct bio_vec *bvec, unsigned int nvecs,
+			  loff_t offset, unsigned long total,
+			  struct nfsd_write_dio_args *args)
 {
 	u32 offset_align = args->nf->nf_dio_offset_align;
+	u32 mem_align = args->nf->nf_dio_mem_align;
 	unsigned long mem_offset = bvec->bv_offset;
 	loff_t prefix_end, orig_end, middle_end;
 	size_t prefix, middle, suffix;
 
 	args->nsegs = 0;
 
+	/*
+	 * Check if direct I/O is feasible for this write request.
+	 * If alignments are not available, the write is too small,
+	 * or no alignment can be found, fall back to buffered I/O.
+	 */
+	if (unlikely(!mem_align || !offset_align) ||
+	    unlikely(total < max(offset_align, mem_align)))
+		goto no_dio;
 	prefix = nfsd_find_dio_aligned_offset(args->nf, offset, mem_offset,
 					     total);
 	if (prefix == SIZE_MAX)
-		return false;	/* No alignment possible */
+		goto no_dio;
 
 	prefix_end = offset + prefix;
 	orig_end = offset + total;

@@ -1371,7 +1356,7 @@ nfsd_setup_write_dio_iters(struct bio_vec *bvec, unsigned int nvecs,
 	}
 
 	if (!middle)
-		return false;	/* No aligned region for DIO */
+		goto no_dio;
 
 	nfsd_write_dio_seg_init(&args->segment[args->nsegs], bvec, nvecs,
 				total, prefix, middle);

@@ -1384,7 +1369,13 @@ nfsd_setup_write_dio_iters(struct bio_vec *bvec, unsigned int nvecs,
 		++args->nsegs;
 	}
 
-	return true;
+	return;
+
+no_dio:
+	/* No alignment possible - pack into single non-DIO segment */
+	nfsd_write_dio_seg_init(&args->segment[0], bvec, nvecs, total,
+				0, total);
+	args->nsegs = 1;
 }
 
 static int

@@ -1405,7 +1396,7 @@ nfsd_buffered_write(struct svc_rqst *rqstp, struct file *file,
 }
 
 static int
-nfsd_issue_write_dio(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *stable_how,
+nfsd_issue_dio_write(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *stable_how,
 		     struct kiocb *kiocb, unsigned int nvecs, unsigned long *cnt,
 		     struct nfsd_write_dio_args *args)
 {

@@ -1413,10 +1404,6 @@ nfsd_issue_write_dio(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *stable_how
 	ssize_t host_err;
 	unsigned int i;
 
-	if (!nfsd_setup_write_dio_iters(rqstp->rq_bvec, nvecs, kiocb->ki_pos,
-					*cnt, args))
-		return nfsd_buffered_write(rqstp, file, nvecs, cnt, kiocb);
-
 	/*
 	 * Any buffered IO issued here will be misaligned, use
 	 * sync IO to ensure it has completed before returning.

@@ -1425,6 +1412,9 @@ nfsd_issue_write_dio(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *stable_how
 	kiocb->ki_flags |= (IOCB_DSYNC|IOCB_SYNC);
 	*stable_how = NFS_FILE_SYNC;
 
+	nfsd_write_dio_iters_init(rqstp->rq_bvec, nvecs, kiocb->ki_pos,
+				  *cnt, args);
+
 	*cnt = 0;
 	for (i = 0; i < args->nsegs; i++) {
 		if (args->segment[i].use_dio) {

@@ -1463,11 +1453,8 @@ nfsd_direct_write(struct svc_rqst *rqstp, struct svc_fh *fhp,
 	if (args.nf->nf_file->f_op->fop_flags & FOP_DONTCACHE)
 		kiocb->ki_flags |= IOCB_DONTCACHE;
 

From: Chuck Lever <[email protected]>

When direct I/O is not feasible (due to missing alignment info, too-small writes, or no alignment possible), pack the entire write payload into a single non-DIO segment and follow the usual direct write I/O path.

This simplifies nfsd_direct_write() by eliminating the fallback path and the separate nfsd_buffered_write() call - all writes now go through nfsd_issue_write_dio() which handles both DIO and buffered segments.

Review

Quoted 2 lines

(quoted diff) +2 -0

+	if (file->f_op->fop_flags & FOP_DONTCACHE)
+		kiocb->ki_flags |= IOCB_DONTCACHE;

IOCB_DONTCACHE isn't defined for IOCB_DIRECT. So this should move into a branch just for buffered I/O.

Quoted 8 lines

Promoting all NFSD_IO_DIRECT writes to FILE_SYNC was my idea, based on the assumption that IOCB_DIRECT writes to local file systems left nothing to be done by a later commit. My assumption is based on the behavior of O_DIRECT on NFS files.

If that assumption is not true, then I agree there is no technical reason to promote NFSD_IO_DIRECT writes to FILE_SYNC, and I can remove that built-in assumption for v8 of this series.

It is not true, or rather only true for a tiny subset of use cases (which NFS can't even query a head of time).

From: Chuck Lever <[email protected]>

Christoph says:

Quoted 4 lines

Review

Quoted 2 lines

(quoted diff) +2 -0

+	if (file->f_op->fop_flags & FOP_DONTCACHE)
+		kiocb->ki_flags |= IOCB_DONTCACHE;

IOCB_DONTCACHE isn't defined for IOCB_DIRECT. So this should move into a branch just for buffered I/O.

and

Quoted 11 lines

Quoted 8 lines

Promoting all NFSD_IO_DIRECT writes to FILE_SYNC was my idea, based on the assumption that IOCB_DIRECT writes to local file systems left nothing to be done by a later commit. My assumption is based on the behavior of O_DIRECT on NFS files.

If that assumption is not true, then I agree there is no technical reason to promote NFSD_IO_DIRECT writes to FILE_SYNC, and I can remove that built-in assumption for v8 of this series.

It is not true, or rather only true for a tiny subset of use cases (which NFS can't even query a head of time).

So, observe the existing setting of ki_flags rather than forcing persistence unconditionally, and ensure that DONTCACHE is not set for IOCB_DIRECT writes.

Suggested-by Christoph Hellwig <[email protected]>

Signed-off-by Chuck Lever <[email protected]>

---
 fs/nfsd/vfs.c | 33 ++++++++++++++-------------------
 1 file changed, 14 insertions(+), 19 deletions(-)

fs/nfsd/vfs.c +10 -17

index be0688f2ab3d..3c78b3aeea4b 100644
@@ -1261,6 +1261,8 @@ struct nfsd_write_dio_seg {
 
 struct nfsd_write_dio_args {
 	struct nfsd_file		*nf;
+	int				flags_buffered;
+	int				flags_direct;
 	unsigned int			nsegs;
 	struct nfsd_write_dio_seg	segment[3];
 };

@@ -1396,33 +1398,25 @@ nfsd_buffered_write(struct svc_rqst *rqstp, struct file *file,
 }
 
 static int
-nfsd_issue_dio_write(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *stable_how,
-		     struct kiocb *kiocb, unsigned int nvecs, unsigned long *cnt,
-		     struct nfsd_write_dio_args *args)
+nfsd_issue_dio_write(struct svc_rqst *rqstp, struct svc_fh *fhp,
+		     struct kiocb *kiocb, unsigned int nvecs,
+		     unsigned long *cnt, struct nfsd_write_dio_args *args)
 {
 	struct file *file = args->nf->nf_file;
 	ssize_t host_err;
 	unsigned int i;
 
-	/*
-	 * Any buffered IO issued here will be misaligned, use
-	 * sync IO to ensure it has completed before returning.
-	 * Also update @stable_how to avoid need for COMMIT.
-	 */
-	kiocb->ki_flags |= (IOCB_DSYNC|IOCB_SYNC);
-	*stable_how = NFS_FILE_SYNC;
-
 	nfsd_write_dio_iters_init(rqstp->rq_bvec, nvecs, kiocb->ki_pos,
 				  *cnt, args);
 
 	*cnt = 0;
 	for (i = 0; i < args->nsegs; i++) {
 		if (args->segment[i].use_dio) {
-			kiocb->ki_flags |= IOCB_DIRECT;
+			kiocb->ki_flags = args->flags_direct;
 			trace_nfsd_write_direct(rqstp, fhp, kiocb->ki_pos,
 						args->segment[i].iter.count);
 		} else
-			kiocb->ki_flags &= ~IOCB_DIRECT;
+			kiocb->ki_flags = args->flags_buffered;
 
 		host_err = vfs_iocb_iter_write(file, kiocb,
 					       &args->segment[i].iter);

@@ -1446,15 +1440,16 @@ nfsd_direct_write(struct svc_rqst *rqstp, struct svc_fh *fhp,
 	args.nf = nf;
 
 	/*
-	 * Check if IOCB_DONTCACHE can be used when issuing buffered IO;
-	 * if so, set it to preserve intent of NFSD_IO_DIRECT (it will
-	 * be ignored for any DIO issued here).
+	 * IOCB_DONTCACHE preserves the intent of NFSD_IO_DIRECT when
+	 * writing unaligned segments or handling fallback I/O.
 	 */
+	args.flags_buffered = kiocb->ki_flags;
 	if (args.nf->nf_file->f_op->fop_flags & FOP_DONTCACHE)
-		kiocb->ki_flags |= IOCB_DONTCACHE;

From: Chuck Lever <[email protected]>

There is now only one caller of nfsd_buffered_write(), so it can be folded back into nfsd_vfs_write().

Signed-off-by Chuck Lever <[email protected]>

---
 fs/nfsd/vfs.c | 27 +++++++--------------------
 1 file changed, 7 insertions(+), 20 deletions(-)

fs/nfsd/vfs.c +2 -18

index 3c78b3aeea4b..934090e168c6 100644
@@ -1380,23 +1380,6 @@ nfsd_write_dio_iters_init(struct bio_vec *bvec, unsigned int nvecs,
 	args->nsegs = 1;
 }
 
-static int
-nfsd_buffered_write(struct svc_rqst *rqstp, struct file *file,
-		    unsigned int nvecs, unsigned long *cnt,
-		    struct kiocb *kiocb)
-{
-	struct iov_iter iter;
-	int host_err;
-
-	iov_iter_bvec(&iter, ITER_SOURCE, rqstp->rq_bvec, nvecs, *cnt);
-	host_err = vfs_iocb_iter_write(file, kiocb, &iter);
-	if (host_err < 0)
-		return host_err;
-	*cnt = host_err;
-
-	return 0;
-}
-
 static int
 nfsd_issue_dio_write(struct svc_rqst *rqstp, struct svc_fh *fhp,
 		     struct kiocb *kiocb, unsigned int nvecs,

@@ -1480,6 +1463,7 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp,
 	u32			stable = *stable_how;
 	struct kiocb		kiocb;
 	struct svc_export	*exp;
+	struct iov_iter		iter;
 	errseq_t		since;
 	__be32			nfserr;
 	int			host_err;

@@ -1540,10 +1524,13 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp,
 	case NFSD_IO_DONTCACHE:
 		if (file->f_op->fop_flags & FOP_DONTCACHE)
 			kiocb.ki_flags |= IOCB_DONTCACHE;
-		fallthrough; /* must call nfsd_buffered_write */
+		fallthrough;
 	case NFSD_IO_BUFFERED: