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 write delegation is recalled. If the delegation is returned within
30ms then the GETATTR is serviced as normal otherwise the NFS4ERR_DELAY
error is returned for the GETATTR.

Add counter for write delegation recall due to conflict GETATTR. This is
used to evaluate the need to implement CB_GETATTR to adoid recalling the
delegation with conflit GETATTR.

Signed-off-by: Dai Ngo <dai.ngo@oracle.com>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>

diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index daf305d..b56ea72 100644 (file)
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -8341,3 +8341,68 @@ nfsd4_get_writestateid(struct nfsd4_compound_state *cstate,
 {
        get_stateid(cstate, &u->write.wr_stateid);
 }
+
+/**
+ * nfsd4_deleg_getattr_conflict - Recall if GETATTR causes conflict
+ * @rqstp: RPC transaction context
+ * @inode: file to be checked for a conflict
+ *
+ * This function is called when there is a conflict between a write
+ * delegation and a change/size GETATTR from another client. The server
+ * must either use the CB_GETATTR to get the current values of the
+ * attributes from the client that holds the delegation or recall the
+ * 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)
+{
+       __be32 status;
+       struct file_lock_context *ctx;
+       struct file_lock *fl;
+       struct nfs4_delegation *dp;
+
+       ctx = locks_inode_context(inode);
+       if (!ctx)
+               return 0;
+       spin_lock(&ctx->flc_lock);
+       list_for_each_entry(fl, &ctx->flc_lease, fl_list) {
+               if (fl->fl_flags == FL_LAYOUT)
+                       continue;
+               if (fl->fl_lmops != &nfsd_lease_mng_ops) {
+                       /*
+                        * non-nfs lease, if it's a lease with F_RDLCK then
+                        * we are done; there isn't any write delegation
+                        * on this inode
+                        */
+                       if (fl->fl_type == F_RDLCK)
+                               break;
+                       goto break_lease;
+               }
+               if (fl->fl_type == F_WRLCK) {
+                       dp = fl->fl_owner;
+                       if (dp->dl_recall.cb_clp == *(rqstp->rq_lease_breaker)) {
+                               spin_unlock(&ctx->flc_lock);
+                               return 0;
+                       }
+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;
+                       return 0;
+               }
+               break;
+       }
+       spin_unlock(&ctx->flc_lock);
+       return 0;
+}

diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index b30dca7..95aafe5 100644 (file)
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -2984,6 +2984,11 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
                if (status)
                        goto out;
        }
+       if (bmval0 & (FATTR4_WORD0_CHANGE | FATTR4_WORD0_SIZE)) {
+               status = nfsd4_deleg_getattr_conflict(rqstp, d_inode(dentry));
+               if (status)
+                       goto out;
+       }
 
        err = vfs_getattr(&path, &stat,
                          STATX_BASIC_STATS | STATX_BTIME | STATX_CHANGE_COOKIE,

diff --git a/fs/nfsd/state.h b/fs/nfsd/state.h
index d49d306..cbddcf4 100644 (file)
--- a/fs/nfsd/state.h
+++ b/fs/nfsd/state.h
@@ -732,4 +732,7 @@ static inline bool try_to_expire_client(struct nfs4_client *clp)
        cmpxchg(&clp->cl_state, NFSD4_COURTESY, NFSD4_EXPIRABLE);
        return clp->cl_state == NFSD4_EXPIRABLE;
 }
+
+extern __be32 nfsd4_deleg_getattr_conflict(struct svc_rqst *rqstp,
+                               struct inode *inode);
 #endif   /* NFSD4_STATE_H */

diff --git a/fs/nfsd/stats.c b/fs/nfsd/stats.c
index 777e24e..6379763 100644 (file)
--- a/fs/nfsd/stats.c
+++ b/fs/nfsd/stats.c
@@ -65,6 +65,8 @@ static int nfsd_show(struct seq_file *seq, void *v)
                seq_printf(seq, " %lld",
                           percpu_counter_sum_positive(&nfsdstats.counter[NFSD_STATS_NFS4_OP(i)]));
        }
+       seq_printf(seq, "\nwdeleg_getattr %lld",
+               percpu_counter_sum_positive(&nfsdstats.counter[NFSD_STATS_WDELEG_GETATTR]));
 
        seq_putc(seq, '\n');
 #endif

diff --git a/fs/nfsd/stats.h b/fs/nfsd/stats.h
index 9b43dc3..cf5524e 100644 (file)
--- a/fs/nfsd/stats.h
+++ b/fs/nfsd/stats.h
@@ -22,6 +22,7 @@ enum {
        NFSD_STATS_FIRST_NFS4_OP,       /* count of individual nfsv4 operations */
        NFSD_STATS_LAST_NFS4_OP = NFSD_STATS_FIRST_NFS4_OP + LAST_NFS4_OP,
 #define NFSD_STATS_NFS4_OP(op) (NFSD_STATS_FIRST_NFS4_OP + (op))
+       NFSD_STATS_WDELEG_GETATTR,      /* count of getattr conflict with wdeleg */
 #endif
        NFSD_STATS_COUNTERS_NUM
 };
@@ -93,4 +94,10 @@ static inline void nfsd_stats_drc_mem_usage_sub(struct nfsd_net *nn, s64 amount)
        percpu_counter_sub(&nn->counter[NFSD_NET_DRC_MEM_USAGE], amount);
 }
 
+#ifdef CONFIG_NFSD_V4
+static inline void nfsd_stats_wdeleg_getattr_inc(void)
+{
+       percpu_counter_inc(&nfsdstats.counter[NFSD_STATS_WDELEG_GETATTR]);
+}
+#endif
 #endif /* _NFSD_STATS_H */