NFSD: add support for lock conflict to courteous server

This patch allows expired client with lock state to be in COURTESY
state. Lock conflict with COURTESY client is resolved by the fs/lock
code using the lm_lock_expirable and lm_expire_lock callback in the
struct lock_manager_operations.

If conflict client is in COURTESY state, set it to EXPIRABLE and
schedule the laundromat to run immediately to expire the client. The
callback lm_expire_lock waits for the laundromat to flush its work
queue before returning to caller.

Reviewed-by: J. Bruce Fields <bfields@fieldses.org>
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 76c98ab..2bcdc6e 100644 (file)
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -5714,39 +5714,51 @@ static void nfsd4_ssc_expire_umount(struct nfsd_net *nn)
 }
 #endif
 
+/* Check if any lock belonging to this lockowner has any blockers */
 static bool
-nfs4_has_any_locks(struct nfs4_client *clp)
+nfs4_lockowner_has_blockers(struct nfs4_lockowner *lo)
+{
+       struct file_lock_context *ctx;
+       struct nfs4_ol_stateid *stp;
+       struct nfs4_file *nf;
+
+       list_for_each_entry(stp, &lo->lo_owner.so_stateids, st_perstateowner) {
+               nf = stp->st_stid.sc_file;
+               ctx = nf->fi_inode->i_flctx;
+               if (!ctx)
+                       continue;
+               if (locks_owner_has_blockers(ctx, lo))
+                       return true;
+       }
+       return false;
+}
+
+static bool
+nfs4_anylock_blockers(struct nfs4_client *clp)
 {
        int i;
        struct nfs4_stateowner *so;
+       struct nfs4_lockowner *lo;
 
+       if (atomic_read(&clp->cl_delegs_in_recall))
+               return true;
        spin_lock(&clp->cl_lock);
        for (i = 0; i < OWNER_HASH_SIZE; i++) {
                list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[i],
                                so_strhash) {
                        if (so->so_is_open_owner)
                                continue;
-                       spin_unlock(&clp->cl_lock);
-                       return true;
+                       lo = lockowner(so);
+                       if (nfs4_lockowner_has_blockers(lo)) {
+                               spin_unlock(&clp->cl_lock);
+                               return true;
+                       }
                }
        }
        spin_unlock(&clp->cl_lock);
        return false;
 }
 
-/*
- * place holder for now, no check for lock blockers yet
- */
-static bool
-nfs4_anylock_blockers(struct nfs4_client *clp)
-{
-       if (atomic_read(&clp->cl_delegs_in_recall) ||
-                       !list_empty(&clp->async_copies) ||
-                       nfs4_has_any_locks(clp))
-               return true;
-       return false;
-}
-
 static void
 nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist,
                                struct laundry_time *lt)
@@ -6711,6 +6723,29 @@ nfsd4_lm_put_owner(fl_owner_t owner)
                nfs4_put_stateowner(&lo->lo_owner);
 }
 
+/* return pointer to struct nfs4_client if client is expirable */
+static bool
+nfsd4_lm_lock_expirable(struct file_lock *cfl)
+{
+       struct nfs4_lockowner *lo = (struct nfs4_lockowner *)cfl->fl_owner;
+       struct nfs4_client *clp = lo->lo_owner.so_client;
+       struct nfsd_net *nn;
+
+       if (try_to_expire_client(clp)) {
+               nn = net_generic(clp->net, nfsd_net_id);
+               mod_delayed_work(laundry_wq, &nn->laundromat_work, 0);
+               return true;
+       }
+       return false;
+}
+
+/* schedule laundromat to run immediately and wait for it to complete */
+static void
+nfsd4_lm_expire_lock(void)
+{
+       flush_workqueue(laundry_wq);
+}
+
 static void
 nfsd4_lm_notify(struct file_lock *fl)
 {
@@ -6737,9 +6772,12 @@ nfsd4_lm_notify(struct file_lock *fl)
 }
 
 static const struct lock_manager_operations nfsd_posix_mng_ops  = {
+       .lm_mod_owner = THIS_MODULE,
        .lm_notify = nfsd4_lm_notify,
        .lm_get_owner = nfsd4_lm_get_owner,
        .lm_put_owner = nfsd4_lm_put_owner,
+       .lm_lock_expirable = nfsd4_lm_lock_expirable,
+       .lm_expire_lock = nfsd4_lm_expire_lock,
 };
 
 static inline void