Merge tag 'nfs-for-3.4-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs

Pull NFS client updates for Linux 3.4 from Trond Myklebust:
 "New features include:
   - Add NFS client support for containers.

     This should enable most of the necessary functionality, including
     lockd support, and support for rpc.statd, NFSv4 idmapper and
     RPCSEC_GSS upcalls into the correct network namespace from which
     the mount system call was issued.

   - NFSv4 idmapper scalability improvements

     Base the idmapper cache on the keyring interface to allow
     concurrent access to idmapper entries.  Start the process of
     migrating users from the single-threaded daemon-based approach to
     the multi-threaded request-key based approach.

   - NFSv4.1 implementation id.

     Allows the NFSv4.1 client and server to mutually identify each
     other for logging and debugging purposes.

   - Support the 'vers=4.1' mount option for mounting NFSv4.1 instead of
     having to use the more counterintuitive 'vers=4,minorversion=1'.

   - SUNRPC tracepoints.

     Start the process of adding tracepoints in order to improve
     debugging of the RPC layer.

   - pNFS object layout support for autologin.

  Important bugfixes include:

   - Fix a bug in rpc_wake_up/rpc_wake_up_status that caused them to
     fail to wake up all tasks when applied to priority waitqueues.

   - Ensure that we handle read delegations correctly, when we try to
     truncate a file.

   - A number of fixes for NFSv4 state manager loops (mostly to do with
     delegation recovery)."

* tag 'nfs-for-3.4-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs: (224 commits)
  NFS: fix sb->s_id in nfs debug prints
  xprtrdma: Remove assumption that each segment is <= PAGE_SIZE
  xprtrdma: The transport should not bug-check when a dup reply is received
  pnfs-obj: autologin: Add support for protocol autologin
  NFS: Remove nfs4_setup_sequence from generic rename code
  NFS: Remove nfs4_setup_sequence from generic unlink code
  NFS: Remove nfs4_setup_sequence from generic read code
  NFS: Remove nfs4_setup_sequence from generic write code
  NFS: Fix more NFS debug related build warnings
  SUNRPC/LOCKD: Fix build warnings when CONFIG_SUNRPC_DEBUG is undefined
  nfs: non void functions must return a value
  SUNRPC: Kill compiler warning when RPC_DEBUG is unset
  SUNRPC/NFS: Add Kbuild dependencies for NFS_DEBUG/RPC_DEBUG
  NFS: Use cond_resched_lock() to reduce latencies in the commit scans
  NFSv4: It is not safe to dereference lsp->ls_state in release_lockowner
  NFS: ncommit count is being double decremented
  SUNRPC: We must not use list_for_each_entry_safe() in rpc_wake_up()
  Try using machine credentials for RENEW calls
  NFSv4.1: Fix a few issues in filelayout_commit_pagelist
  NFSv4.1: Clean ups and bugfixes for the pNFS read/writeback/commit code
  ...

1 files changed, 200 insertions, 155 deletions

diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 45392032e7b..0f43414eb25 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -146,6 +146,11 @@ struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp)
         struct rpc_cred *cred = NULL;
         struct nfs_server *server;
 
+        /* Use machine credentials if available */
+        cred = nfs4_get_machine_cred_locked(clp);
+        if (cred != NULL)
+                goto out;
+
         rcu_read_lock();
         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
                 cred = nfs4_get_renew_cred_server_locked(server);
@@ -153,6 +158,8 @@ struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp)
                         break;
         }
         rcu_read_unlock();
+
+out:
         return cred;
 }
 
@@ -190,30 +197,29 @@ static int nfs41_setup_state_renewal(struct nfs_client *clp)
 static void nfs4_end_drain_session(struct nfs_client *clp)
 {
         struct nfs4_session *ses = clp->cl_session;
+        struct nfs4_slot_table *tbl;
         int max_slots;
 
         if (ses == NULL)
                 return;
+        tbl = &ses->fc_slot_table;
         if (test_and_clear_bit(NFS4_SESSION_DRAINING, &ses->session_state)) {
-                spin_lock(&ses->fc_slot_table.slot_tbl_lock);
-                max_slots = ses->fc_slot_table.max_slots;
+                spin_lock(&tbl->slot_tbl_lock);
+                max_slots = tbl->max_slots;
                 while (max_slots--) {
-                        struct rpc_task *task;
-
-                        task = rpc_wake_up_next(&ses->fc_slot_table.
-                                                slot_tbl_waitq);
-                        if (!task)
+                        if (rpc_wake_up_first(&tbl->slot_tbl_waitq,
+                                                nfs4_set_task_privileged,
+                                                NULL) == NULL)
                                 break;
-                        rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);
                 }
-                spin_unlock(&ses->fc_slot_table.slot_tbl_lock);
+                spin_unlock(&tbl->slot_tbl_lock);
         }
 }
 
 static int nfs4_wait_on_slot_tbl(struct nfs4_slot_table *tbl)
 {
         spin_lock(&tbl->slot_tbl_lock);
-        if (tbl->highest_used_slotid != -1) {
+        if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
                 INIT_COMPLETION(tbl->complete);
                 spin_unlock(&tbl->slot_tbl_lock);
                 return wait_for_completion_interruptible(&tbl->complete);
@@ -317,62 +323,6 @@ out:
         return cred;
 }
 
-static void nfs_alloc_unique_id_locked(struct rb_root *root,
-                                       struct nfs_unique_id *new,
-                                       __u64 minval, int maxbits)
-{
-        struct rb_node **p, *parent;
-        struct nfs_unique_id *pos;
-        __u64 mask = ~0ULL;
-
-        if (maxbits < 64)
-                mask = (1ULL << maxbits) - 1ULL;
-
-        /* Ensure distribution is more or less flat */
-        get_random_bytes(&new->id, sizeof(new->id));
-        new->id &= mask;
-        if (new->id < minval)
-                new->id += minval;
-retry:
-        p = &root->rb_node;
-        parent = NULL;
-
-        while (*p != NULL) {
-                parent = *p;
-                pos = rb_entry(parent, struct nfs_unique_id, rb_node);
-
-                if (new->id < pos->id)
-                        p = &(*p)->rb_left;
-                else if (new->id > pos->id)
-                        p = &(*p)->rb_right;
-                else
-                        goto id_exists;
-        }
-        rb_link_node(&new->rb_node, parent, p);
-        rb_insert_color(&new->rb_node, root);
-        return;
-id_exists:
-        for (;;) {
-                new->id++;
-                if (new->id < minval || (new->id & mask) != new->id) {
-                        new->id = minval;
-                        break;
-                }
-                parent = rb_next(parent);
-                if (parent == NULL)
-                        break;
-                pos = rb_entry(parent, struct nfs_unique_id, rb_node);
-                if (new->id < pos->id)
-                        break;
-        }
-        goto retry;
-}
-
-static void nfs_free_unique_id(struct rb_root *root, struct nfs_unique_id *id)
-{
-        rb_erase(&id->rb_node, root);
-}
-
 static struct nfs4_state_owner *
 nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred)
 {
@@ -405,6 +355,7 @@ nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
         struct rb_node **p = &server->state_owners.rb_node,
                        *parent = NULL;
         struct nfs4_state_owner *sp;
+        int err;
 
         while (*p != NULL) {
                 parent = *p;
@@ -421,8 +372,9 @@ nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
                         return sp;
                 }
         }
-        nfs_alloc_unique_id_locked(&server->openowner_id,
-                                        &new->so_owner_id, 1, 64);
+        err = ida_get_new(&server->openowner_id, &new->so_seqid.owner_id);
+        if (err)
+                return ERR_PTR(err);
         rb_link_node(&new->so_server_node, parent, p);
         rb_insert_color(&new->so_server_node, &server->state_owners);
         return new;
@@ -435,7 +387,23 @@ nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
 
         if (!RB_EMPTY_NODE(&sp->so_server_node))
                 rb_erase(&sp->so_server_node, &server->state_owners);
-        nfs_free_unique_id(&server->openowner_id, &sp->so_owner_id);
+        ida_remove(&server->openowner_id, sp->so_seqid.owner_id);
+}
+
+static void
+nfs4_init_seqid_counter(struct nfs_seqid_counter *sc)
+{
+        sc->flags = 0;
+        sc->counter = 0;
+        spin_lock_init(&sc->lock);
+        INIT_LIST_HEAD(&sc->list);
+        rpc_init_wait_queue(&sc->wait, "Seqid_waitqueue");
+}
+
+static void
+nfs4_destroy_seqid_counter(struct nfs_seqid_counter *sc)
+{
+        rpc_destroy_wait_queue(&sc->wait);
 }
 
 /*
@@ -444,19 +412,20 @@ nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
  *
  */
 static struct nfs4_state_owner *
-nfs4_alloc_state_owner(void)
+nfs4_alloc_state_owner(struct nfs_server *server,
+                struct rpc_cred *cred,
+                gfp_t gfp_flags)
 {
         struct nfs4_state_owner *sp;
 
-        sp = kzalloc(sizeof(*sp),GFP_NOFS);
+        sp = kzalloc(sizeof(*sp), gfp_flags);
         if (!sp)
                 return NULL;
+        sp->so_server = server;
+        sp->so_cred = get_rpccred(cred);
         spin_lock_init(&sp->so_lock);
         INIT_LIST_HEAD(&sp->so_states);
-        rpc_init_wait_queue(&sp->so_sequence.wait, "Seqid_waitqueue");
-        sp->so_seqid.sequence = &sp->so_sequence;
-        spin_lock_init(&sp->so_sequence.lock);
-        INIT_LIST_HEAD(&sp->so_sequence.list);
+        nfs4_init_seqid_counter(&sp->so_seqid);
         atomic_set(&sp->so_count, 1);
         INIT_LIST_HEAD(&sp->so_lru);
         return sp;
@@ -478,7 +447,7 @@ nfs4_drop_state_owner(struct nfs4_state_owner *sp)
 
 static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
 {
-        rpc_destroy_wait_queue(&sp->so_sequence.wait);
+        nfs4_destroy_seqid_counter(&sp->so_seqid);
         put_rpccred(sp->so_cred);
         kfree(sp);
 }
@@ -516,7 +485,8 @@ static void nfs4_gc_state_owners(struct nfs_server *server)
  * Returns a pointer to an instantiated nfs4_state_owner struct, or NULL.
  */
 struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,
-                                              struct rpc_cred *cred)
+                                              struct rpc_cred *cred,
+                                              gfp_t gfp_flags)
 {
         struct nfs_client *clp = server->nfs_client;
         struct nfs4_state_owner *sp, *new;
@@ -526,20 +496,18 @@ struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,
         spin_unlock(&clp->cl_lock);
         if (sp != NULL)
                 goto out;
-        new = nfs4_alloc_state_owner();
+        new = nfs4_alloc_state_owner(server, cred, gfp_flags);
         if (new == NULL)
                 goto out;
-        new->so_server = server;
-        new->so_cred = cred;
-        spin_lock(&clp->cl_lock);
-        sp = nfs4_insert_state_owner_locked(new);
-        spin_unlock(&clp->cl_lock);
-        if (sp == new)
-                get_rpccred(cred);
-        else {
-                rpc_destroy_wait_queue(&new->so_sequence.wait);
-                kfree(new);
-        }
+        do {
+                if (ida_pre_get(&server->openowner_id, gfp_flags) == 0)
+                        break;
+                spin_lock(&clp->cl_lock);
+                sp = nfs4_insert_state_owner_locked(new);
+                spin_unlock(&clp->cl_lock);
+        } while (sp == ERR_PTR(-EAGAIN));
+        if (sp != new)
+                nfs4_free_state_owner(new);
 out:
         nfs4_gc_state_owners(server);
         return sp;
@@ -795,15 +763,11 @@ static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, f
 {
         struct nfs4_lock_state *lsp;
         struct nfs_server *server = state->owner->so_server;
-        struct nfs_client *clp = server->nfs_client;
 
         lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
         if (lsp == NULL)
                 return NULL;
-        rpc_init_wait_queue(&lsp->ls_sequence.wait, "lock_seqid_waitqueue");
-        spin_lock_init(&lsp->ls_sequence.lock);
-        INIT_LIST_HEAD(&lsp->ls_sequence.list);
-        lsp->ls_seqid.sequence = &lsp->ls_sequence;
+        nfs4_init_seqid_counter(&lsp->ls_seqid);
         atomic_set(&lsp->ls_count, 1);
         lsp->ls_state = state;
         lsp->ls_owner.lo_type = type;
@@ -815,25 +779,22 @@ static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, f
                 lsp->ls_owner.lo_u.posix_owner = fl_owner;
                 break;
         default:
-                kfree(lsp);
-                return NULL;
+                goto out_free;
         }
-        spin_lock(&clp->cl_lock);
-        nfs_alloc_unique_id_locked(&server->lockowner_id, &lsp->ls_id, 1, 64);
-        spin_unlock(&clp->cl_lock);
+        lsp->ls_seqid.owner_id = ida_simple_get(&server->lockowner_id, 0, 0, GFP_NOFS);
+        if (lsp->ls_seqid.owner_id < 0)
+                goto out_free;
         INIT_LIST_HEAD(&lsp->ls_locks);
         return lsp;
+out_free:
+        kfree(lsp);
+        return NULL;
 }
 
-static void nfs4_free_lock_state(struct nfs4_lock_state *lsp)
+void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
 {
-        struct nfs_server *server = lsp->ls_state->owner->so_server;
-        struct nfs_client *clp = server->nfs_client;
-
-        spin_lock(&clp->cl_lock);
-        nfs_free_unique_id(&server->lockowner_id, &lsp->ls_id);
-        spin_unlock(&clp->cl_lock);
-        rpc_destroy_wait_queue(&lsp->ls_sequence.wait);
+        ida_simple_remove(&server->lockowner_id, lsp->ls_seqid.owner_id);
+        nfs4_destroy_seqid_counter(&lsp->ls_seqid);
         kfree(lsp);
 }
 
@@ -865,7 +826,7 @@ static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_
         }
         spin_unlock(&state->state_lock);
         if (new != NULL)
-                nfs4_free_lock_state(new);
+                nfs4_free_lock_state(state->owner->so_server, new);
         return lsp;
 }
 
@@ -886,9 +847,11 @@ void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
         if (list_empty(&state->lock_states))
                 clear_bit(LK_STATE_IN_USE, &state->flags);
         spin_unlock(&state->state_lock);
-        if (lsp->ls_flags & NFS_LOCK_INITIALIZED)
-                nfs4_release_lockowner(lsp);
-        nfs4_free_lock_state(lsp);
+        if (lsp->ls_flags & NFS_LOCK_INITIALIZED) {
+                if (nfs4_release_lockowner(lsp) == 0)
+                        return;
+        }
+        nfs4_free_lock_state(lsp->ls_state->owner->so_server, lsp);
 }
 
 static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
@@ -918,7 +881,8 @@ int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
         if (fl->fl_flags & FL_POSIX)
                 lsp = nfs4_get_lock_state(state, fl->fl_owner, 0, NFS4_POSIX_LOCK_TYPE);
         else if (fl->fl_flags & FL_FLOCK)
-                lsp = nfs4_get_lock_state(state, 0, fl->fl_pid, NFS4_FLOCK_LOCK_TYPE);
+                lsp = nfs4_get_lock_state(state, NULL, fl->fl_pid,
+                                NFS4_FLOCK_LOCK_TYPE);
         else
                 return -EINVAL;
         if (lsp == NULL)
@@ -928,28 +892,49 @@ int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
         return 0;
 }
 
-/*
- * Byte-range lock aware utility to initialize the stateid of read/write
- * requests.
- */
-void nfs4_copy_stateid(nfs4_stateid *dst, struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid)
+static bool nfs4_copy_lock_stateid(nfs4_stateid *dst, struct nfs4_state *state,
+                fl_owner_t fl_owner, pid_t fl_pid)
 {
         struct nfs4_lock_state *lsp;
-        int seq;
+        bool ret = false;
 
-        do {
-                seq = read_seqbegin(&state->seqlock);
-                memcpy(dst, &state->stateid, sizeof(*dst));
-        } while (read_seqretry(&state->seqlock, seq));
         if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
-                return;
+                goto out;
 
         spin_lock(&state->state_lock);
         lsp = __nfs4_find_lock_state(state, fl_owner, fl_pid, NFS4_ANY_LOCK_TYPE);
-        if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0)
-                memcpy(dst, &lsp->ls_stateid, sizeof(*dst));
+        if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0) {
+                nfs4_stateid_copy(dst, &lsp->ls_stateid);
+                ret = true;
+        }
         spin_unlock(&state->state_lock);
         nfs4_put_lock_state(lsp);
+out:
+        return ret;
+}
+
+static void nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
+{
+        int seq;
+
+        do {
+                seq = read_seqbegin(&state->seqlock);
+                nfs4_stateid_copy(dst, &state->stateid);
+        } while (read_seqretry(&state->seqlock, seq));
+}
+
+/*
+ * Byte-range lock aware utility to initialize the stateid of read/write
+ * requests.
+ */
+void nfs4_select_rw_stateid(nfs4_stateid *dst, struct nfs4_state *state,
+                fmode_t fmode, fl_owner_t fl_owner, pid_t fl_pid)
+{
+        if (nfs4_copy_delegation_stateid(dst, state->inode, fmode))
+                return;
+        if (nfs4_copy_lock_stateid(dst, state, fl_owner, fl_pid))
+                return;
+        nfs4_copy_open_stateid(dst, state);
 }
 
 struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
@@ -960,20 +945,28 @@ struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_m
         if (new != NULL) {
                 new->sequence = counter;
                 INIT_LIST_HEAD(&new->list);
+                new->task = NULL;
         }
         return new;
 }
 
 void nfs_release_seqid(struct nfs_seqid *seqid)
 {
-        if (!list_empty(&seqid->list)) {
-                struct rpc_sequence *sequence = seqid->sequence->sequence;
+        struct nfs_seqid_counter *sequence;
 
-                spin_lock(&sequence->lock);
-                list_del_init(&seqid->list);
-                spin_unlock(&sequence->lock);
-                rpc_wake_up(&sequence->wait);
+        if (list_empty(&seqid->list))
+                return;
+        sequence = seqid->sequence;
+        spin_lock(&sequence->lock);
+        list_del_init(&seqid->list);
+        if (!list_empty(&sequence->list)) {
+                struct nfs_seqid *next;
+
+                next = list_first_entry(&sequence->list,
+                                struct nfs_seqid, list);
+                rpc_wake_up_queued_task(&sequence->wait, next->task);
         }
+        spin_unlock(&sequence->lock);
 }
 
 void nfs_free_seqid(struct nfs_seqid *seqid)
@@ -989,14 +982,14 @@ void nfs_free_seqid(struct nfs_seqid *seqid)
  */
 static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
 {
-        BUG_ON(list_first_entry(&seqid->sequence->sequence->list, struct nfs_seqid, list) != seqid);
+        BUG_ON(list_first_entry(&seqid->sequence->list, struct nfs_seqid, list) != seqid);
         switch (status) {
                 case 0:
                         break;
                 case -NFS4ERR_BAD_SEQID:
                         if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
                                 return;
-                        printk(KERN_WARNING "NFS: v4 server returned a bad"
+                        pr_warn_ratelimited("NFS: v4 server returned a bad"
                                         " sequence-id error on an"
                                         " unconfirmed sequence %p!\n",
                                         seqid->sequence);
@@ -1040,10 +1033,11 @@ void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
 
 int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
 {
-        struct rpc_sequence *sequence = seqid->sequence->sequence;
+        struct nfs_seqid_counter *sequence = seqid->sequence;
         int status = 0;
 
         spin_lock(&sequence->lock);
+        seqid->task = task;
         if (list_empty(&seqid->list))
                 list_add_tail(&seqid->list, &sequence->list);
         if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid)
@@ -1072,19 +1066,28 @@ static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
 void nfs4_schedule_state_manager(struct nfs_client *clp)
 {
         struct task_struct *task;
+        char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
 
         if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
                 return;
         __module_get(THIS_MODULE);
         atomic_inc(&clp->cl_count);
-        task = kthread_run(nfs4_run_state_manager, clp, "%s-manager",
-                                rpc_peeraddr2str(clp->cl_rpcclient,
-                                                        RPC_DISPLAY_ADDR));
-        if (!IS_ERR(task))
-                return;
-        nfs4_clear_state_manager_bit(clp);
-        nfs_put_client(clp);
-        module_put(THIS_MODULE);
+
+        /* The rcu_read_lock() is not strictly necessary, as the state
+         * manager is the only thread that ever changes the rpc_xprt
+         * after it's initialized.  At this point, we're single threaded. */
+        rcu_read_lock();
+        snprintf(buf, sizeof(buf), "%s-manager",
+                        rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
+        rcu_read_unlock();
+        task = kthread_run(nfs4_run_state_manager, clp, buf);
+        if (IS_ERR(task)) {
+                printk(KERN_ERR "%s: kthread_run: %ld\n",
+                        __func__, PTR_ERR(task));
+                nfs4_clear_state_manager_bit(clp);
+                nfs_put_client(clp);
+                module_put(THIS_MODULE);
+        }
 }
 
 /*
@@ -1098,10 +1101,25 @@ void nfs4_schedule_lease_recovery(struct nfs_client *clp)
                 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
         nfs4_schedule_state_manager(clp);
 }
+EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
+
+/*
+ * nfs40_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN
+ * @clp: client to process
+ *
+ * Set the NFS4CLNT_LEASE_EXPIRED state in order to force a
+ * resend of the SETCLIENTID and hence re-establish the
+ * callback channel. Then return all existing delegations.
+ */
+static void nfs40_handle_cb_pathdown(struct nfs_client *clp)
+{
+        set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
+        nfs_expire_all_delegations(clp);
+}
 
 void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
 {
-        nfs_handle_cb_pathdown(clp);
+        nfs40_handle_cb_pathdown(clp);
         nfs4_schedule_state_manager(clp);
 }
 
@@ -1132,11 +1150,37 @@ void nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4
 {
         struct nfs_client *clp = server->nfs_client;
 
-        if (test_and_clear_bit(NFS_DELEGATED_STATE, &state->flags))
-                nfs_async_inode_return_delegation(state->inode, &state->stateid);
         nfs4_state_mark_reclaim_nograce(clp, state);
         nfs4_schedule_state_manager(clp);
 }
+EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
+
+void nfs_inode_find_state_and_recover(struct inode *inode,
+                const nfs4_stateid *stateid)
+{
+        struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
+        struct nfs_inode *nfsi = NFS_I(inode);
+        struct nfs_open_context *ctx;
+        struct nfs4_state *state;
+        bool found = false;
+
+        spin_lock(&inode->i_lock);
+        list_for_each_entry(ctx, &nfsi->open_files, list) {
+                state = ctx->state;
+                if (state == NULL)
+                        continue;
+                if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
+                        continue;
+                if (!nfs4_stateid_match(&state->stateid, stateid))
+                        continue;
+                nfs4_state_mark_reclaim_nograce(clp, state);
+                found = true;
+        }
+        spin_unlock(&inode->i_lock);
+        if (found)
+                nfs4_schedule_state_manager(clp);
+}
+
 
 static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
 {
@@ -1175,8 +1219,8 @@ static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_
                         case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
                                 goto out;
                         default:
-                                printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n",
-                                                __func__, status);
+                                printk(KERN_ERR "NFS: %s: unhandled error %d. "
+                                        "Zeroing state\n", __func__, status);
                         case -ENOMEM:
                         case -NFS4ERR_DENIED:
                         case -NFS4ERR_RECLAIM_BAD:
@@ -1222,8 +1266,9 @@ restart:
                                 spin_lock(&state->state_lock);
                                 list_for_each_entry(lock, &state->lock_states, ls_locks) {
                                         if (!(lock->ls_flags & NFS_LOCK_INITIALIZED))
-                                                printk("%s: Lock reclaim failed!\n",
-                                                        __func__);
+                                                pr_warn_ratelimited("NFS: "
+                                                        "%s: Lock reclaim "
+                                                        "failed!\n", __func__);
                                 }
                                 spin_unlock(&state->state_lock);
                                 nfs4_put_open_state(state);
@@ -1232,8 +1277,8 @@ restart:
                 }
                 switch (status) {
                         default:
-                                printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n",
-                                                __func__, status);
+                                printk(KERN_ERR "NFS: %s: unhandled error %d. "
+                                        "Zeroing state\n", __func__, status);
                         case -ENOENT:
                         case -ENOMEM:
                         case -ESTALE:
@@ -1241,8 +1286,8 @@ restart:
                                  * Open state on this file cannot be recovered
                                  * All we can do is revert to using the zero stateid.
                                  */
-                                memset(state->stateid.data, 0,
-                                        sizeof(state->stateid.data));
+                                memset(&state->stateid, 0,
+                                        sizeof(state->stateid));
                                 /* Mark the file as being 'closed' */
                                 state->state = 0;
                                 break;
@@ -1420,7 +1465,7 @@ static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
                 case 0:
                         break;
                 case -NFS4ERR_CB_PATH_DOWN:
-                        nfs_handle_cb_pathdown(clp);
+                        nfs40_handle_cb_pathdown(clp);
                         break;
                 case -NFS4ERR_NO_GRACE:
                         nfs4_state_end_reclaim_reboot(clp);
@@ -1801,7 +1846,7 @@ static void nfs4_state_manager(struct nfs_client *clp)
         } while (atomic_read(&clp->cl_count) > 1);
         return;
 out_error:
-        printk(KERN_WARNING "Error: state manager failed on NFSv4 server %s"
+        pr_warn_ratelimited("NFS: state manager failed on NFSv4 server %s"
                         " with error %d\n", clp->cl_hostname, -status);
         nfs4_end_drain_session(clp);
         nfs4_clear_state_manager_bit(clp);