NFSD: handle GETATTR conflict with write delegation

If the GETATTR request on a file that has write delegation in effect
and the request attributes include the change info and size attribute
then the request is handled as below:

Server sends CB_GETATTR to client to get the latest change info and file
size. If these values are the same as the server's cached values then
the GETATTR proceeds as normal.

If either the change info or file size is different from the server's
cached values, or the file was already marked as modified, then:

    . update time_modify and time_metadata into file's metadata
      with current time

    . encode GETATTR as normal except the file size is encoded with
      the value returned from CB_GETATTR

    . mark the file as modified

If the CB_GETATTR fails for any reasons, the delegation is recalled
and NFS4ERR_DELAY is returned for the GETATTR.

Signed-off-by: Dai Ngo <dai.ngo@oracle.com>
Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>

diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 7cabe882724efc7e46ac6d41c8a16bfbea560517..07840ee721ef734f21895b267cb2c0ca4db724f1 100644 (file)
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -127,6 +127,7 @@ static void free_session(struct nfsd4_session *);
 
 static const struct nfsd4_callback_ops nfsd4_cb_recall_ops;
 static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops;
+static const struct nfsd4_callback_ops nfsd4_cb_getattr_ops;
 
 static struct workqueue_struct *laundry_wq;
 
@@ -1187,6 +1188,10 @@ alloc_init_deleg(struct nfs4_client *clp, struct nfs4_file *fp,
        dp->dl_recalled = false;
        nfsd4_init_cb(&dp->dl_recall, dp->dl_stid.sc_client,
                      &nfsd4_cb_recall_ops, NFSPROC4_CLNT_CB_RECALL);
+       nfsd4_init_cb(&dp->dl_cb_fattr.ncf_getattr, dp->dl_stid.sc_client,
+                       &nfsd4_cb_getattr_ops, NFSPROC4_CLNT_CB_GETATTR);
+       dp->dl_cb_fattr.ncf_file_modified = false;
+       dp->dl_cb_fattr.ncf_cb_bmap[0] = FATTR4_WORD0_CHANGE | FATTR4_WORD0_SIZE;
        get_nfs4_file(fp);
        dp->dl_stid.sc_file = fp;
        return dp;
@@ -2894,11 +2899,56 @@ nfsd4_cb_recall_any_release(struct nfsd4_callback *cb)
        spin_unlock(&nn->client_lock);
 }
 
+static int
+nfsd4_cb_getattr_done(struct nfsd4_callback *cb, struct rpc_task *task)
+{
+       struct nfs4_cb_fattr *ncf =
+                       container_of(cb, struct nfs4_cb_fattr, ncf_getattr);
+
+       ncf->ncf_cb_status = task->tk_status;
+       switch (task->tk_status) {
+       case -NFS4ERR_DELAY:
+               rpc_delay(task, 2 * HZ);
+               return 0;
+       default:
+               return 1;
+       }
+}
+
+static void
+nfsd4_cb_getattr_release(struct nfsd4_callback *cb)
+{
+       struct nfs4_cb_fattr *ncf =
+                       container_of(cb, struct nfs4_cb_fattr, ncf_getattr);
+       struct nfs4_delegation *dp =
+                       container_of(ncf, struct nfs4_delegation, dl_cb_fattr);
+
+       nfs4_put_stid(&dp->dl_stid);
+       clear_bit(CB_GETATTR_BUSY, &ncf->ncf_cb_flags);
+       wake_up_bit(&ncf->ncf_cb_flags, CB_GETATTR_BUSY);
+}
+
 static const struct nfsd4_callback_ops nfsd4_cb_recall_any_ops = {
        .done           = nfsd4_cb_recall_any_done,
        .release        = nfsd4_cb_recall_any_release,
 };
 
+static const struct nfsd4_callback_ops nfsd4_cb_getattr_ops = {
+       .done           = nfsd4_cb_getattr_done,
+       .release        = nfsd4_cb_getattr_release,
+};
+
+void nfs4_cb_getattr(struct nfs4_cb_fattr *ncf)
+{
+       struct nfs4_delegation *dp =
+                       container_of(ncf, struct nfs4_delegation, dl_cb_fattr);
+
+       if (test_and_set_bit(CB_GETATTR_BUSY, &ncf->ncf_cb_flags))
+               return;
+       refcount_inc(&dp->dl_stid.sc_count);
+       nfsd4_run_cb(&ncf->ncf_getattr);
+}
+
 static struct nfs4_client *create_client(struct xdr_netobj name,
                struct svc_rqst *rqstp, nfs4_verifier *verf)
 {
@@ -5634,6 +5684,8 @@ nfs4_open_delegation(struct nfsd4_open *open, struct nfs4_ol_stateid *stp,
        struct svc_fh *parent = NULL;
        int cb_up;
        int status = 0;
+       struct kstat stat;
+       struct path path;
 
        cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
        open->op_recall = 0;
@@ -5671,6 +5723,18 @@ nfs4_open_delegation(struct nfsd4_open *open, struct nfs4_ol_stateid *stp,
        if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) {
                open->op_delegate_type = NFS4_OPEN_DELEGATE_WRITE;
                trace_nfsd_deleg_write(&dp->dl_stid.sc_stateid);
+               path.mnt = currentfh->fh_export->ex_path.mnt;
+               path.dentry = currentfh->fh_dentry;
+               if (vfs_getattr(&path, &stat,
+                               (STATX_SIZE | STATX_CTIME | STATX_CHANGE_COOKIE),
+                               AT_STATX_SYNC_AS_STAT)) {
+                       nfs4_put_stid(&dp->dl_stid);
+                       destroy_delegation(dp);
+                       goto out_no_deleg;
+               }
+               dp->dl_cb_fattr.ncf_cur_fsize = stat.size;
+               dp->dl_cb_fattr.ncf_initial_cinfo =
+                       nfsd4_change_attribute(&stat, d_inode(currentfh->fh_dentry));
        } else {
                open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
                trace_nfsd_deleg_read(&dp->dl_stid.sc_stateid);
@@ -8407,6 +8471,8 @@ nfsd4_get_writestateid(struct nfsd4_compound_state *cstate,
  * nfsd4_deleg_getattr_conflict - Recall if GETATTR causes conflict
  * @rqstp: RPC transaction context
  * @inode: file to be checked for a conflict
+ * @modified: return true if file was modified
+ * @size: new size of file if modified is true
  *
  * This function is called when there is a conflict between a write
  * delegation and a change/size GETATTR from another client. The server
@@ -8415,21 +8481,23 @@ nfsd4_get_writestateid(struct nfsd4_compound_state *cstate,
  * delegation before replying to the GETATTR. See RFC 8881 section
  * 18.7.4.
  *
- * The current implementation does not support CB_GETATTR yet. However
- * this can avoid recalling the delegation could be added in follow up
- * work.
- *
  * Returns 0 if there is no conflict; otherwise an nfs_stat
  * code is returned.
  */
 __be32
-nfsd4_deleg_getattr_conflict(struct svc_rqst *rqstp, struct inode *inode)
+nfsd4_deleg_getattr_conflict(struct svc_rqst *rqstp, struct inode *inode,
+                            bool *modified, u64 *size)
 {
-       __be32 status;
        struct file_lock_context *ctx;
-       struct file_lock *fl;
        struct nfs4_delegation *dp;
+       struct nfs4_cb_fattr *ncf;
+       struct file_lock *fl;
+       struct iattr attrs;
+       __be32 status;
+
+       might_sleep();
 
+       *modified = false;
        ctx = locks_inode_context(inode);
        if (!ctx)
                return 0;
@@ -8456,10 +8524,34 @@ nfsd4_deleg_getattr_conflict(struct svc_rqst *rqstp, struct inode *inode)
 break_lease:
                        spin_unlock(&ctx->flc_lock);
                        nfsd_stats_wdeleg_getattr_inc();
-                       status = nfserrno(nfsd_open_break_lease(inode, NFSD_MAY_READ));
-                       if (status != nfserr_jukebox ||
-                                       !nfsd_wait_for_delegreturn(rqstp, inode))
-                               return status;
+
+                       dp = fl->fl_owner;
+                       ncf = &dp->dl_cb_fattr;
+                       nfs4_cb_getattr(&dp->dl_cb_fattr);
+                       wait_on_bit(&ncf->ncf_cb_flags, CB_GETATTR_BUSY, TASK_INTERRUPTIBLE);
+                       if (ncf->ncf_cb_status) {
+                               status = nfserrno(nfsd_open_break_lease(inode, NFSD_MAY_READ));
+                               if (status != nfserr_jukebox ||
+                                               !nfsd_wait_for_delegreturn(rqstp, inode))
+                                       return status;
+                       }
+                       if (!ncf->ncf_file_modified &&
+                                       (ncf->ncf_initial_cinfo != ncf->ncf_cb_change ||
+                                       ncf->ncf_cur_fsize != ncf->ncf_cb_fsize))
+                               ncf->ncf_file_modified = true;
+                       if (ncf->ncf_file_modified) {
+                               /*
+                                * The server would not update the file's metadata
+                                * with the client's modified size.
+                                */
+                               attrs.ia_mtime = attrs.ia_ctime = current_time(inode);
+                               attrs.ia_valid = ATTR_MTIME | ATTR_CTIME;
+                               setattr_copy(&nop_mnt_idmap, inode, &attrs);
+                               mark_inode_dirty(inode);
+                               ncf->ncf_cur_fsize = ncf->ncf_cb_fsize;
+                               *size = ncf->ncf_cur_fsize;
+                               *modified = true;
+                       }
                        return 0;
                }
                break;

diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 92c7dde148a4d81f3e29a4efbd480c9cffa03e3a..0027c247a4819d6328fd74236cc55db2434556a2 100644 (file)
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -2975,6 +2975,8 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
                .dentry = dentry,
        };
        struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
+       bool file_modified;
+       u64 size = 0;
 
        BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1);
        BUG_ON(!nfsd_attrs_supported(minorversion, bmval));
@@ -2985,7 +2987,8 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
                        goto out;
        }
        if (bmval0 & (FATTR4_WORD0_CHANGE | FATTR4_WORD0_SIZE)) {
-               status = nfsd4_deleg_getattr_conflict(rqstp, d_inode(dentry));
+               status = nfsd4_deleg_getattr_conflict(rqstp, d_inode(dentry),
+                                                     &file_modified, &size);
                if (status)
                        goto out;
        }
@@ -3112,7 +3115,10 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
                p = xdr_reserve_space(xdr, 8);
                if (!p)
                        goto out_resource;
-               p = xdr_encode_hyper(p, stat.size);
+               if (file_modified)
+                       p = xdr_encode_hyper(p, size);
+               else
+                       p = xdr_encode_hyper(p, stat.size);
        }
        if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) {
                p = xdr_reserve_space(xdr, 4);

diff --git a/fs/nfsd/state.h b/fs/nfsd/state.h
index 82718d42f3b277ce8d2b80b76cbe0f3b29d0a9c5..6bbb1d0276b4f2245779e914323a6176628df804 100644 (file)
--- a/fs/nfsd/state.h
+++ b/fs/nfsd/state.h
@@ -125,8 +125,16 @@ struct nfs4_cb_fattr {
        /* from CB_GETATTR reply */
        u64 ncf_cb_change;
        u64 ncf_cb_fsize;
+
+       unsigned long ncf_cb_flags;
+       bool ncf_file_modified;
+       u64 ncf_initial_cinfo;
+       u64 ncf_cur_fsize;
 };
 
+/* bits for ncf_cb_flags */
+#define        CB_GETATTR_BUSY         0
+
 /*
  * Represents a delegation stateid. The nfs4_client holds references to these
  * and they are put when it is being destroyed or when the delegation is
@@ -748,5 +756,6 @@ static inline bool try_to_expire_client(struct nfs4_client *clp)
 }
 
 extern __be32 nfsd4_deleg_getattr_conflict(struct svc_rqst *rqstp,
-                               struct inode *inode);
+               struct inode *inode, bool *file_modified, u64 *size);
+extern void nfs4_cb_getattr(struct nfs4_cb_fattr *ncf);
 #endif   /* NFSD4_STATE_H */