[PATCH 11/11] nfsd: take the write delegation grant stat before hashing

From: Jeff Layton

Date: Fri Nov 20 2026 - 11:41:15 EST


nfs4_open_delegation() sets ncf_initial_cinfo and dl_[amc]time from a
stat taken after nfs4_set_delegation() has hashed the delegation. The
window isn't reachable today: a CB_GETATTR sent in it carries no
referring call, so the client answers NFS4ERR_BADHANDLE and the waiter
never compares the zero ncf_initial_cinfo. But an upcoming per-
delegation timestamp record must be initialized before anything can
reach the delegation.

- Pass the current filehandle into nfs4_set_delegation() for the stat's
export, and move nfs4_delegation_stat() above it.
- Take the grant stat after kernel_setlease() and the conflict checks,
just before hashing. Grant no delegation if it fails.
- The stat can sleep, which widens the window between the unlocked
fi_had_conflict check and hashing. The check under deleg_lock that
the previous patch added still catches a break in it.
- Stat again after hashing, and decline the delegation if the change
attribute moved. The holder's WRITE through an earlier open doesn't
break its own lease and can land between the stats, as can a foreign
write whose break raced past the fi_had_conflict check. A plain write
delegation synthesizes change as ncf_initial_cinfo + 1, so a stale
value could go below one clients already saw. Compare with the grant
stat's change attribute, which nfs4_set_delegation() returns, not
ncf_initial_cinfo: once the delegation is hashed, a GETATTR whose
CB_GETATTR reports a modified file can advance ncf_initial_cinfo.

Signed-off-by: Jeff Layton <jlayton@xxxxxxxxxx>
---
fs/nfsd/nfs4state.c | 91 +++++++++++++++++++++++++++++++++++------------------
1 file changed, 61 insertions(+), 30 deletions(-)

diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index ea940d8759b0..2e1abc6b3af4 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -7276,11 +7276,35 @@ nfs4_delegation_record_grant_slot(struct nfs4_delegation *dp,
dp->dl_recall_grant.valid = true;
}

+static bool
+nfs4_delegation_stat(struct nfs4_delegation *dp, struct svc_fh *currentfh,
+ struct kstat *stat)
+{
+ struct nfsd_file *nf = find_writeable_file(dp->dl_stid.sc_file);
+ struct path path;
+ int rc;
+
+ if (!nf)
+ return false;
+
+ path.mnt = currentfh->fh_export->ex_path.mnt;
+ path.dentry = file_dentry(nf->nf_file);
+
+ rc = vfs_getattr(&path, stat,
+ STATX_MODE | STATX_SIZE | STATX_ATIME |
+ STATX_MTIME | STATX_CTIME | STATX_CHANGE_COOKIE,
+ AT_STATX_SYNC_AS_STAT);
+
+ nfsd_file_put(nf);
+ return rc == 0;
+}
+
static struct nfs4_delegation *
nfs4_set_delegation(struct nfsd4_open *open,
const struct nfsd4_compound_state *cstate,
struct nfs4_ol_stateid *stp, struct svc_fh *parent,
- u32 *held_type)
+ struct svc_fh *currentfh, u32 *held_type,
+ u64 *grant_change)
{
bool deleg_ts = nfsd4_want_deleg_timestamps(open);
struct nfs4_client *clp = stp->st_stid.sc_client;
@@ -7424,6 +7448,24 @@ nfs4_set_delegation(struct nfsd4_open *open,
if (fp->fi_had_conflict)
goto out_unlock;

+ /*
+ * Anything that can reach the delegation once it is hashed may
+ * read these, so set them first. nfs4_open_delegation() stats
+ * again after hashing to catch a write that lands in between.
+ */
+ if (deleg_is_write(dl_type)) {
+ struct kstat stat;
+
+ status = -EIO;
+ if (!nfs4_delegation_stat(dp, currentfh, &stat))
+ goto out_unlock;
+ *grant_change = nfsd4_change_attribute(&stat);
+ dp->dl_cb_fattr.ncf_initial_cinfo = *grant_change;
+ dp->dl_atime = stat.atime;
+ dp->dl_ctime = stat.ctime;
+ dp->dl_mtime = stat.mtime;
+ }
+
spin_lock(&nn->deleg_lock);
spin_lock(&clp->cl_lock);
spin_lock(&fp->fi_lock);
@@ -7487,29 +7529,6 @@ static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status,
}
}

-static bool
-nfs4_delegation_stat(struct nfs4_delegation *dp, struct svc_fh *currentfh,
- struct kstat *stat)
-{
- struct nfsd_file *nf = find_writeable_file(dp->dl_stid.sc_file);
- struct path path;
- int rc;
-
- if (!nf)
- return false;
-
- path.mnt = currentfh->fh_export->ex_path.mnt;
- path.dentry = file_dentry(nf->nf_file);
-
- rc = vfs_getattr(&path, stat,
- STATX_MODE | STATX_SIZE | STATX_ATIME |
- STATX_MTIME | STATX_CTIME | STATX_CHANGE_COOKIE,
- AT_STATX_SYNC_AS_STAT);
-
- nfsd_file_put(nf);
- return rc == 0;
-}
-
/*
* Add NFS4_SHARE_ACCESS_READ to the write delegation granted on OPEN
* with NFS4_SHARE_ACCESS_WRITE by allocating separate nfsd_file and
@@ -7578,6 +7597,7 @@ nfs4_open_delegation(struct svc_rqst *rqstp, struct nfsd4_open *open,
struct svc_fh *parent = NULL;
struct nfs4_delegation *dp;
u32 held_type = OPEN_DELEGATE_NONE;
+ u64 grant_change = 0;
struct kstat stat;
int status = 0;
int cb_up;
@@ -7612,8 +7632,8 @@ nfs4_open_delegation(struct svc_rqst *rqstp, struct nfsd4_open *open,
default:
goto out_no_deleg;
}
- dp = nfs4_set_delegation(open, &resp->cstate, stp, parent,
- &held_type);
+ dp = nfs4_set_delegation(open, &resp->cstate, stp, parent, currentfh,
+ &held_type, &grant_change);
if (IS_ERR(dp)) {
status = PTR_ERR(dp);
goto out_no_deleg;
@@ -7631,12 +7651,23 @@ nfs4_open_delegation(struct svc_rqst *rqstp, struct nfsd4_open *open,
nfs4_put_stid(&dp->dl_stid);
goto out_no_deleg;
}
+ /*
+ * The holder's own WRITE through an earlier open doesn't
+ * break the lease and can land after the grant stat, as can
+ * a foreign write whose break raced past the fi_had_conflict
+ * check. A plain write delegation synthesizes change from
+ * ncf_initial_cinfo, so it must not be stale. Compare with
+ * the grant stat itself: a GETATTR can already have moved
+ * ncf_initial_cinfo past it.
+ */
+ if (nfsd4_change_attribute(&stat) != grant_change) {
+ destroy_delegation(dp);
+ nfs4_put_stid(&dp->dl_stid);
+ status = -EAGAIN;
+ goto out_no_deleg;
+ }
open->op_delegate_type = deleg_ts ? OPEN_DELEGATE_WRITE_ATTRS_DELEG :
OPEN_DELEGATE_WRITE;
- dp->dl_cb_fattr.ncf_initial_cinfo = nfsd4_change_attribute(&stat);
- dp->dl_atime = stat.atime;
- dp->dl_ctime = stat.ctime;
- dp->dl_mtime = stat.mtime;
spin_lock(&f->f_lock);
if (deleg_ts)
f->f_mode |= FMODE_NOCMTIME;

--
2.56.1