NFS: avoid spurious warning of lost lock that is being unlocked.

When the NFSv4 state manager recovers state after a server restart, it
reports that locks have been lost if it finds any lock state for which
recovery hasn't been successful.  i.e. any for which
NFS_LOCK_INITIALIZED is not set.

However it only tries to recover locks that are still linked to
inode->i_flctx.  So if a lock has been removed from inode->i_flctx, but
the state for that lock has not yet been destroyed, then a spurious
warning results.

nfs4_proc_unlck() calls locks_lock_inode_wait() - which removes the lock
from ->i_flctx - before sending the unlock request to the server and
before the final nfs4_put_lock_state() is called.  This allows a window
in which a spurious warning can be produced.

So add a new flag NFS_LOCK_UNLOCKING which is set once the decision has
been made to unlock the lock.  This will prevent it from triggering any
warning.

Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: Trond Myklebust <trond.myklebust@hammerspace.com>

diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index cfef738d765e0d73c274acbc9835ec7c52ef288f..5edd1704f7359eb48c5fc769e977b891b10a9472 100644 (file)
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -149,6 +149,7 @@ struct nfs4_lock_state {
        struct nfs4_state *     ls_state;       /* Pointer to open state */
 #define NFS_LOCK_INITIALIZED 0
 #define NFS_LOCK_LOST        1
+#define NFS_LOCK_UNLOCKING   2
        unsigned long           ls_flags;
        struct nfs_seqid_counter        ls_seqid;
        nfs4_stateid            ls_stateid;

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 44f1dcb6020fb5a189bb534e5037d5092764f5a9..40d749f29ed3fe98de6c81f5bbd83eff9caa4a16 100644 (file)
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -7023,12 +7023,13 @@ static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *
                mutex_unlock(&sp->so_delegreturn_mutex);
                goto out;
        }
+       lsp = request->fl_u.nfs4_fl.owner;
+       set_bit(NFS_LOCK_UNLOCKING, &lsp->ls_flags);
        up_read(&nfsi->rwsem);
        mutex_unlock(&sp->so_delegreturn_mutex);
        if (status != 0)
                goto out;
        /* Is this a delegated lock? */
-       lsp = request->fl_u.nfs4_fl.owner;
        if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) == 0)
                goto out;
        alloc_seqid = NFS_SERVER(inode)->nfs_client->cl_mvops->alloc_seqid;

diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index a2d2d5d1b088895aba558358368d57d2ded0b13c..7c1f43507813fdf549645f5ec5dad7abb6a3807c 100644 (file)
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -1619,7 +1619,8 @@ static int __nfs4_reclaim_open_state(struct nfs4_state_owner *sp, struct nfs4_st
                spin_lock(&state->state_lock);
                list_for_each_entry(lock, &state->lock_states, ls_locks) {
                        trace_nfs4_state_lock_reclaim(state, lock);
-                       if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
+                       if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags) &&
+                           !test_bit(NFS_LOCK_UNLOCKING, &lock->ls_flags))
                                *lost_locks += 1;
                }
                spin_unlock(&state->state_lock);