nfsd: fix SETATTR updates for delegated timestamps

SETATTRs containing delegated timestamp updates are currently not being
vetted properly. Since we no longer need to compare the timestamps vs.
the current timestamps, move the vetting of delegated timestamps wholly
into nfsd.

Rename the set_cb_time() helper to nfsd4_vet_deleg_time(), and make it
non-static. Add a new vet_deleg_attrs() helper that is called from
nfsd4_setattr that uses nfsd4_vet_deleg_time() to properly validate the
all the timestamps. If the validation indicates that the update should
be skipped, unset the appropriate flags in ia_valid.

Fixes: 7e13f4f8d27d ("nfsd: handle delegated timestamps in SETATTR")
Signed-off-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>

diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index 7043fc475458d3b602010b47f489a3caba85e3ca..aacd912a5fbe29ba5ccac206d13243308f36b7fa 100644 (file)
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -1133,6 +1133,33 @@ nfsd4_secinfo_no_name_release(union nfsd4_op_u *u)
                exp_put(u->secinfo_no_name.sin_exp);
 }
 
+/*
+ * Validate that the requested timestamps are within the acceptable range. If
+ * timestamp appears to be in the future, then it will be clamped to
+ * current_time().
+ */
+static void
+vet_deleg_attrs(struct nfsd4_setattr *setattr, struct nfs4_delegation *dp)
+{
+       struct timespec64 now = current_time(dp->dl_stid.sc_file->fi_inode);
+       struct iattr *iattr = &setattr->sa_iattr;
+
+       if ((setattr->sa_bmval[2] & FATTR4_WORD2_TIME_DELEG_ACCESS) &&
+           !nfsd4_vet_deleg_time(&iattr->ia_atime, &dp->dl_atime, &now))
+               iattr->ia_valid &= ~(ATTR_ATIME | ATTR_ATIME_SET);
+
+       if (setattr->sa_bmval[2] & FATTR4_WORD2_TIME_DELEG_MODIFY) {
+               if (nfsd4_vet_deleg_time(&iattr->ia_mtime, &dp->dl_mtime, &now)) {
+                       iattr->ia_ctime = iattr->ia_mtime;
+                       if (!nfsd4_vet_deleg_time(&iattr->ia_ctime, &dp->dl_ctime, &now))
+                               iattr->ia_valid &= ~(ATTR_CTIME | ATTR_CTIME_SET);
+               } else {
+                       iattr->ia_valid &= ~(ATTR_CTIME | ATTR_CTIME_SET |
+                                            ATTR_MTIME | ATTR_MTIME_SET);
+               }
+       }
+}
+
 static __be32
 nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
              union nfsd4_op_u *u)
@@ -1170,8 +1197,10 @@ nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
                        struct nfs4_delegation *dp = delegstateid(st);
 
                        /* Only for *_ATTRS_DELEG flavors */
-                       if (deleg_attrs_deleg(dp->dl_type))
+                       if (deleg_attrs_deleg(dp->dl_type)) {
+                               vet_deleg_attrs(setattr, dp);
                                status = nfs_ok;
+                       }
                }
        }
        if (st)

diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 8737b721daf3433bab46065e751175a4dcdd1c89..f2fd0cbe256b9519eaa5cb0cc18872e08020edd3 100644 (file)
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -9135,25 +9135,25 @@ nfsd4_get_writestateid(struct nfsd4_compound_state *cstate,
 }
 
 /**
- * set_cb_time - vet and set the timespec for a cb_getattr update
- * @cb: timestamp from the CB_GETATTR response
+ * nfsd4_vet_deleg_time - vet and set the timespec for a delegated timestamp update
+ * @req: timestamp from the client
  * @orig: original timestamp in the inode
  * @now: current time
  *
- * Given a timestamp in a CB_GETATTR response, check it against the
+ * Given a timestamp from the client response, check it against the
  * current timestamp in the inode and the current time. Returns true
  * if the inode's timestamp needs to be updated, and false otherwise.
- * @cb may also be changed if the timestamp needs to be clamped.
+ * @req may also be changed if the timestamp needs to be clamped.
  */
-static bool set_cb_time(struct timespec64 *cb, const struct timespec64 *orig,
-                       const struct timespec64 *now)
+bool nfsd4_vet_deleg_time(struct timespec64 *req, const struct timespec64 *orig,
+                         const struct timespec64 *now)
 {
 
        /*
         * "When the time presented is before the original time, then the
         *  update is ignored." Also no need to update if there is no change.
         */
-       if (timespec64_compare(cb, orig) <= 0)
+       if (timespec64_compare(req, orig) <= 0)
                return false;
 
        /*
@@ -9161,10 +9161,8 @@ static bool set_cb_time(struct timespec64 *cb, const struct timespec64 *orig,
         *  clamp the new time to the current time, or it may
         *  return NFS4ERR_DELAY to the client, allowing it to retry."
         */
-       if (timespec64_compare(cb, now) > 0) {
-               /* clamp it */
-               *cb = *now;
-       }
+       if (timespec64_compare(req, now) > 0)
+               *req = *now;
 
        return true;
 }
@@ -9184,10 +9182,10 @@ static int cb_getattr_update_times(struct dentry *dentry, struct nfs4_delegation
                attrs.ia_atime = ncf->ncf_cb_atime;
                attrs.ia_mtime = ncf->ncf_cb_mtime;
 
-               if (set_cb_time(&attrs.ia_atime, &atime, &now))
+               if (nfsd4_vet_deleg_time(&attrs.ia_atime, &atime, &now))
                        attrs.ia_valid |= ATTR_ATIME | ATTR_ATIME_SET;
 
-               if (set_cb_time(&attrs.ia_mtime, &mtime, &now)) {
+               if (nfsd4_vet_deleg_time(&attrs.ia_mtime, &mtime, &now)) {
                        attrs.ia_valid |= ATTR_CTIME | ATTR_CTIME_SET |
                                          ATTR_MTIME | ATTR_MTIME_SET;
                        attrs.ia_ctime = attrs.ia_mtime;

diff --git a/fs/nfsd/state.h b/fs/nfsd/state.h
index ce7c0d129ba338e1269ed163266e1ee192cd02c5..bf9436cdb93c5dd5502ecf83433ea311e3678711 100644 (file)
--- a/fs/nfsd/state.h
+++ b/fs/nfsd/state.h
@@ -247,6 +247,9 @@ static inline bool deleg_attrs_deleg(u32 dl_type)
               dl_type == OPEN_DELEGATE_WRITE_ATTRS_DELEG;
 }
 
+bool nfsd4_vet_deleg_time(struct timespec64 *cb, const struct timespec64 *orig,
+                         const struct timespec64 *now);
+
 #define cb_to_delegation(cb) \
        container_of(cb, struct nfs4_delegation, dl_recall)