mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
* [PATCH RFC] NFS: don't wait for writeback on close() with a write delegation
@ 2026-11-16 20:55 Jeff Layton
  2026-11-20 18:04 ` Trond Myklebust
  0 siblings, 1 reply; 2+ messages in thread
From: Jeff Layton @ 2026-11-16 20:55 UTC (permalink / raw)
  To: Trond Myklebust, Anna Schumaker
  Cc: Chuck Lever, linux-nfs, linux-kernel, Jeff Layton

Commit 5445b1fbd123 ("NFSv4: Respect the server imposed limit on how
many changes we may cache") made close() write back, COMMIT and wait
whenever outstanding requests exceed the write delegation's
space_limit. Servers that send a limit of 0, knfsd included, therefore
get no close() benefit from write delegations, which knfsd now grants
even on write-only opens.

That flush buys nothing:

- CTO: no other client can open the file until the delegation is
  recalled, and the recall writes back our dirty data first.
- Error reporting is all that's left, and it's pointless. close() is
  not required to flush, and most filesystems don't, so checking for
  writeback errors there is unreliable at best: the failing writeback
  may not have happened yet. Applications that care must fsync(),
  which this doesn't change; errors are still recorded in the mapping
  and reported there.
- RFC 8881 says only that the client "should" abide by space_limit;
  exceeding it leaves the server's behavior undefined, and knfsd just
  returns NFS4ERR_NOSPC/NFS4ERR_DQUOT on WRITE or COMMIT.

Go back to just starting writeback on close() whenever we hold a write
delegation. In testing against a knfsd patched to send a nonzero
space_limit, single-threaded create/write/close went from ~92 to
~1,500 files/s.

User-visible change: ENOSPC/EDQUOT for data written just before close()
now shows up only via fsync(), not close().

For now, the pagemod_limit is still decoded but unused.

Signed-off-by: Jeff Layton <jlayton@kernel.org>
---
I started looking at wiring up space_limit for nfsd's write delegations,
but afrer looking at how the client uses it, I think we're best off just
not bothering to respect it at all. Thoughts?
---
 fs/nfs/delegation.c | 25 -------------------------
 fs/nfs/delegation.h |  1 -
 fs/nfs/nfs4file.c   |  7 ++++---
 3 files changed, 4 insertions(+), 29 deletions(-)

diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index ad774316f716..3a141d5ee0bd 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -1587,31 +1587,6 @@ bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
 	return ret;
 }
 
-/**
- * nfs4_delegation_flush_on_close - Check if we must flush file on close
- * @inode: inode to check
- *
- * This function checks the number of outstanding writes to the file
- * against the delegation 'space_limit' field to see if
- * the spec requires us to flush the file on close.
- */
-bool nfs4_delegation_flush_on_close(const struct inode *inode)
-{
-	struct nfs_inode *nfsi = NFS_I(inode);
-	struct nfs_delegation *delegation;
-	bool ret = true;
-
-	rcu_read_lock();
-	delegation = rcu_dereference(nfsi->delegation);
-	if (delegation == NULL || !(delegation->type & FMODE_WRITE))
-		goto out;
-	if (atomic_long_read(&nfsi->nrequests) < delegation->pagemod_limit)
-		ret = false;
-out:
-	rcu_read_unlock();
-	return ret;
-}
-
 int nfs4_delegation_hash_alloc(struct nfs_server *server)
 {
 	int delegation_buckets, i;
diff --git a/fs/nfs/delegation.h b/fs/nfs/delegation.h
index fba4699952b8..75f0edde65ea 100644
--- a/fs/nfs/delegation.h
+++ b/fs/nfs/delegation.h
@@ -83,7 +83,6 @@ void nfs_put_delegation(struct nfs_delegation *delegation);
 void nfs_mark_delegation_referenced(struct nfs_delegation *delegation);
 int nfs4_have_delegation(struct inode *inode, fmode_t type, int flags);
 int nfs4_check_delegation(struct inode *inode, fmode_t type);
-bool nfs4_delegation_flush_on_close(const struct inode *inode);
 void nfs_inode_find_delegation_state_and_recover(struct inode *inode,
 		const nfs4_stateid *stateid);
 void nfs4_inode_make_writeable(struct inode *inode);
diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c
index 9a434f5dda8d..04f4d8967e5b 100644
--- a/fs/nfs/nfs4file.c
+++ b/fs/nfs/nfs4file.c
@@ -122,10 +122,11 @@ nfs4_file_flush(struct file *file, fl_owner_t id)
 		return 0;
 
 	/*
-	 * If we're holding a write delegation, then check if we're required
-	 * to flush the i/o on close. If not, then just start the i/o now.
+	 * A write delegation already provides close-to-open consistency:
+	 * no other client can open the file until it is recalled, and the
+	 * recall writes back our dirty data. Just start the i/o.
 	 */
-	if (!nfs4_delegation_flush_on_close(inode))
+	if (nfs_have_write_delegation(inode))
 		return filemap_fdatawrite(file->f_mapping);
 
 	/* Flush writes to the server and return any errors */

---
base-commit: 9d66f26fefacebfeed15de31c1123451a17ff119
change-id: 20261113-nfs-space-limit-025199334e52

Best regards,
-- 
Jeff Layton <jlayton@kernel.org>


^ permalink raw reply	[flat|nested] 2+ messages in thread

* Re: [PATCH RFC] NFS: don't wait for writeback on close() with a write delegation
  2026-11-16 20:55 [PATCH RFC] NFS: don't wait for writeback on close() with a write delegation Jeff Layton
@ 2026-11-20 18:04 ` Trond Myklebust
  0 siblings, 0 replies; 2+ messages in thread
From: Trond Myklebust @ 2026-11-20 18:04 UTC (permalink / raw)
  To: Jeff Layton, Anna Schumaker; +Cc: Chuck Lever, linux-nfs, linux-kernel

On Mon, 2026-11-16 at 15:55 -0500, Jeff Layton wrote:
> Commit 5445b1fbd123 ("NFSv4: Respect the server imposed limit on how
> many changes we may cache") made close() write back, COMMIT and wait
> whenever outstanding requests exceed the write delegation's
> space_limit. Servers that send a limit of 0, knfsd included,
> therefore
> get no close() benefit from write delegations, which knfsd now grants
> even on write-only opens.
> 
> That flush buys nothing:
> 
> - CTO: no other client can open the file until the delegation is
>   recalled, and the recall writes back our dirty data first.
> - Error reporting is all that's left, and it's pointless. close() is
>   not required to flush, and most filesystems don't, so checking for
>   writeback errors there is unreliable at best: the failing writeback
>   may not have happened yet. Applications that care must fsync(),
>   which this doesn't change; errors are still recorded in the mapping
>   and reported there.
> - RFC 8881 says only that the client "should" abide by space_limit;
>   exceeding it leaves the server's behavior undefined, and knfsd just
>   returns NFS4ERR_NOSPC/NFS4ERR_DQUOT on WRITE or COMMIT.
> 
> Go back to just starting writeback on close() whenever we hold a
> write
> delegation. In testing against a knfsd patched to send a nonzero
> space_limit, single-threaded create/write/close went from ~92 to
> ~1,500 files/s.
> 
> User-visible change: ENOSPC/EDQUOT for data written just before
> close()
> now shows up only via fsync(), not close().
> 
> For now, the pagemod_limit is still decoded but unused.
> 
> Signed-off-by: Jeff Layton <jlayton@kernel.org>
> ---
> I started looking at wiring up space_limit for nfsd's write
> delegations,
> but afrer looking at how the client uses it, I think we're best off
> just
> not bothering to respect it at all. Thoughts?
> ---
>  fs/nfs/delegation.c | 25 -------------------------
>  fs/nfs/delegation.h |  1 -
>  fs/nfs/nfs4file.c   |  7 ++++---
>  3 files changed, 4 insertions(+), 29 deletions(-)
> 
> diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
> index ad774316f716..3a141d5ee0bd 100644
> --- a/fs/nfs/delegation.c
> +++ b/fs/nfs/delegation.c
> @@ -1587,31 +1587,6 @@ bool nfs4_copy_delegation_stateid(struct inode
> *inode, fmode_t flags,
>  	return ret;
>  }
>  
> -/**
> - * nfs4_delegation_flush_on_close - Check if we must flush file on
> close
> - * @inode: inode to check
> - *
> - * This function checks the number of outstanding writes to the file
> - * against the delegation 'space_limit' field to see if
> - * the spec requires us to flush the file on close.
> - */
> -bool nfs4_delegation_flush_on_close(const struct inode *inode)
> -{
> -	struct nfs_inode *nfsi = NFS_I(inode);
> -	struct nfs_delegation *delegation;
> -	bool ret = true;
> -
> -	rcu_read_lock();
> -	delegation = rcu_dereference(nfsi->delegation);
> -	if (delegation == NULL || !(delegation->type & FMODE_WRITE))
> -		goto out;
> -	if (atomic_long_read(&nfsi->nrequests) < delegation-
> >pagemod_limit)
> -		ret = false;
> -out:
> -	rcu_read_unlock();
> -	return ret;
> -}
> -
>  int nfs4_delegation_hash_alloc(struct nfs_server *server)
>  {
>  	int delegation_buckets, i;
> diff --git a/fs/nfs/delegation.h b/fs/nfs/delegation.h
> index fba4699952b8..75f0edde65ea 100644
> --- a/fs/nfs/delegation.h
> +++ b/fs/nfs/delegation.h
> @@ -83,7 +83,6 @@ void nfs_put_delegation(struct nfs_delegation
> *delegation);
>  void nfs_mark_delegation_referenced(struct nfs_delegation
> *delegation);
>  int nfs4_have_delegation(struct inode *inode, fmode_t type, int
> flags);
>  int nfs4_check_delegation(struct inode *inode, fmode_t type);
> -bool nfs4_delegation_flush_on_close(const struct inode *inode);
>  void nfs_inode_find_delegation_state_and_recover(struct inode
> *inode,
>  		const nfs4_stateid *stateid);
>  void nfs4_inode_make_writeable(struct inode *inode);
> diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c
> index 9a434f5dda8d..04f4d8967e5b 100644
> --- a/fs/nfs/nfs4file.c
> +++ b/fs/nfs/nfs4file.c
> @@ -122,10 +122,11 @@ nfs4_file_flush(struct file *file, fl_owner_t
> id)
>  		return 0;
>  
>  	/*
> -	 * If we're holding a write delegation, then check if we're
> required
> -	 * to flush the i/o on close. If not, then just start the
> i/o now.
> +	 * A write delegation already provides close-to-open
> consistency:
> +	 * no other client can open the file until it is recalled,
> and the
> +	 * recall writes back our dirty data. Just start the i/o.
>  	 */
> -	if (!nfs4_delegation_flush_on_close(inode))
> +	if (nfs_have_write_delegation(inode))
>  		return filemap_fdatawrite(file->f_mapping);
>  
>  	/* Flush writes to the server and return any errors */
> 
> ---
> base-commit: 9d66f26fefacebfeed15de31c1123451a17ff119
> change-id: 20261113-nfs-space-limit-025199334e52
> 
> Best regards,

Maybe we can call filemap_flush() in order to kick off non-blocking
writes in this situation?

-- 
Trond Myklebust
Linux NFS client maintainer, Hammerspace
trondmy@kernel.org, trond.myklebust@hammerspace.com

^ permalink raw reply	[flat|nested] 2+ messages in thread

end of thread, other threads:[~2026-11-20 18:04 UTC | newest]

Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-16 20:55 [PATCH RFC] NFS: don't wait for writeback on close() with a write delegation Jeff Layton
2026-11-20 18:04 ` Trond Myklebust

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®