fs/nfs/nfs4state.c

   1 /*
   2  *  fs/nfs/nfs4state.c
   3  *
   4  *  Client-side XDR for NFSv4.
   5  *
   6  *  Copyright (c) 2002 The Regents of the University of Michigan.
   7  *  All rights reserved.
   8  *
   9  *  Kendrick Smith <kmsmith@umich.edu>
  10  *
  11  *  Redistribution and use in source and binary forms, with or without
  12  *  modification, are permitted provided that the following conditions
  13  *  are met:
  14  *
  15  *  1. Redistributions of source code must retain the above copyright
  16  *     notice, this list of conditions and the following disclaimer.
  17  *  2. Redistributions in binary form must reproduce the above copyright
  18  *     notice, this list of conditions and the following disclaimer in the
  19  *     documentation and/or other materials provided with the distribution.
  20  *  3. Neither the name of the University nor the names of its
  21  *     contributors may be used to endorse or promote products derived
  22  *     from this software without specific prior written permission.
  23  *
  24  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  25  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  26  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  27  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  31  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  32  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  33  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  34  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  * Implementation of the NFSv4 state model.  For the time being,
  37  * this is minimal, but will be made much more complex in a
  38  * subsequent patch.
  39  */
  40
  41 #include <linux/kernel.h>
  42 #include <linux/slab.h>
  43 #include <linux/fs.h>
  44 #include <linux/nfs_fs.h>
  45 #include <linux/kthread.h>
  46 #include <linux/module.h>
  47 #include <linux/random.h>
  48 #include <linux/ratelimit.h>
  49 #include <linux/workqueue.h>
  50 #include <linux/bitops.h>
  51 #include <linux/jiffies.h>
  52
  53 #include <linux/sunrpc/clnt.h>
  54
  55 #include "nfs4_fs.h"
  56 #include "callback.h"
  57 #include "delegation.h"
  58 #include "internal.h"
  59 #include "nfs4idmap.h"
  60 #include "nfs4session.h"
  61 #include "pnfs.h"
  62 #include "netns.h"
  63
  64 #define NFSDBG_FACILITY         NFSDBG_STATE
  65
  66 #define OPENOWNER_POOL_SIZE     8
  67
  68 const nfs4_stateid zero_stateid = {
  69         { .data = { 0 } },
  70         .type = NFS4_SPECIAL_STATEID_TYPE,
  71 };
  72 static DEFINE_MUTEX(nfs_clid_init_mutex);
  73
  74 int nfs4_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
  75 {
  76         struct nfs4_setclientid_res clid = {
  77                 .clientid = clp->cl_clientid,
  78                 .confirm = clp->cl_confirm,
  79         };
  80         unsigned short port;
  81         int status;
  82         struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
  83
  84         if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
  85                 goto do_confirm;
  86         port = nn->nfs_callback_tcpport;
  87         if (clp->cl_addr.ss_family == AF_INET6)
  88                 port = nn->nfs_callback_tcpport6;
  89
  90         status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
  91         if (status != 0)
  92                 goto out;
  93         clp->cl_clientid = clid.clientid;
  94         clp->cl_confirm = clid.confirm;
  95         set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
  96 do_confirm:
  97         status = nfs4_proc_setclientid_confirm(clp, &clid, cred);
  98         if (status != 0)
  99                 goto out;
 100         clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
 101         nfs4_schedule_state_renewal(clp);
 102 out:
 103         return status;
 104 }
 105
 106 /**
 107  * nfs40_discover_server_trunking - Detect server IP address trunking (mv0)
 108  *
 109  * @clp: nfs_client under test
 110  * @result: OUT: found nfs_client, or clp
 111  * @cred: credential to use for trunking test
 112  *
 113  * Returns zero, a negative errno, or a negative NFS4ERR status.
 114  * If zero is returned, an nfs_client pointer is planted in
 115  * "result".
 116  *
 117  * Note: The returned client may not yet be marked ready.
 118  */
 119 int nfs40_discover_server_trunking(struct nfs_client *clp,
 120                                    struct nfs_client **result,
 121                                    struct rpc_cred *cred)
 122 {
 123         struct nfs4_setclientid_res clid = {
 124                 .clientid = clp->cl_clientid,
 125                 .confirm = clp->cl_confirm,
 126         };
 127         struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
 128         unsigned short port;
 129         int status;
 130
 131         port = nn->nfs_callback_tcpport;
 132         if (clp->cl_addr.ss_family == AF_INET6)
 133                 port = nn->nfs_callback_tcpport6;
 134
 135         status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
 136         if (status != 0)
 137                 goto out;
 138         clp->cl_clientid = clid.clientid;
 139         clp->cl_confirm = clid.confirm;
 140
 141         status = nfs40_walk_client_list(clp, result, cred);
 142         if (status == 0) {
 143                 /* Sustain the lease, even if it's empty.  If the clientid4
 144                  * goes stale it's of no use for trunking discovery. */
 145                 nfs4_schedule_state_renewal(*result);
 146         }
 147 out:
 148         return status;
 149 }
 150
 151 struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp)
 152 {
 153         struct rpc_cred *cred = NULL;
 154
 155         if (clp->cl_machine_cred != NULL)
 156                 cred = get_rpccred(clp->cl_machine_cred);
 157         return cred;
 158 }
 159
 160 static void nfs4_root_machine_cred(struct nfs_client *clp)
 161 {
 162         struct rpc_cred *cred, *new;
 163
 164         new = rpc_lookup_machine_cred(NULL);
 165         spin_lock(&clp->cl_lock);
 166         cred = clp->cl_machine_cred;
 167         clp->cl_machine_cred = new;
 168         spin_unlock(&clp->cl_lock);
 169         if (cred != NULL)
 170                 put_rpccred(cred);
 171 }
 172
 173 static struct rpc_cred *
 174 nfs4_get_renew_cred_server_locked(struct nfs_server *server)
 175 {
 176         struct rpc_cred *cred = NULL;
 177         struct nfs4_state_owner *sp;
 178         struct rb_node *pos;
 179
 180         for (pos = rb_first(&server->state_owners);
 181              pos != NULL;
 182              pos = rb_next(pos)) {
 183                 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
 184                 if (list_empty(&sp->so_states))
 185                         continue;
 186                 cred = get_rpccred(sp->so_cred);
 187                 break;
 188         }
 189         return cred;
 190 }
 191
 192 /**
 193  * nfs4_get_renew_cred_locked - Acquire credential for a renew operation
 194  * @clp: client state handle
 195  *
 196  * Returns an rpc_cred with reference count bumped, or NULL.
 197  * Caller must hold clp->cl_lock.
 198  */
 199 struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp)
 200 {
 201         struct rpc_cred *cred = NULL;
 202         struct nfs_server *server;
 203
 204         /* Use machine credentials if available */
 205         cred = nfs4_get_machine_cred_locked(clp);
 206         if (cred != NULL)
 207                 goto out;
 208
 209         rcu_read_lock();
 210         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 211                 cred = nfs4_get_renew_cred_server_locked(server);
 212                 if (cred != NULL)
 213                         break;
 214         }
 215         rcu_read_unlock();
 216
 217 out:
 218         return cred;
 219 }
 220
 221 static void nfs4_end_drain_slot_table(struct nfs4_slot_table *tbl)
 222 {
 223         if (test_and_clear_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
 224                 spin_lock(&tbl->slot_tbl_lock);
 225                 nfs41_wake_slot_table(tbl);
 226                 spin_unlock(&tbl->slot_tbl_lock);
 227         }
 228 }
 229
 230 static void nfs4_end_drain_session(struct nfs_client *clp)
 231 {
 232         struct nfs4_session *ses = clp->cl_session;
 233
 234         if (clp->cl_slot_tbl) {
 235                 nfs4_end_drain_slot_table(clp->cl_slot_tbl);
 236                 return;
 237         }
 238
 239         if (ses != NULL) {
 240                 nfs4_end_drain_slot_table(&ses->bc_slot_table);
 241                 nfs4_end_drain_slot_table(&ses->fc_slot_table);
 242         }
 243 }
 244
 245 static int nfs4_drain_slot_tbl(struct nfs4_slot_table *tbl)
 246 {
 247         set_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state);
 248         spin_lock(&tbl->slot_tbl_lock);
 249         if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
 250                 reinit_completion(&tbl->complete);
 251                 spin_unlock(&tbl->slot_tbl_lock);
 252                 return wait_for_completion_interruptible(&tbl->complete);
 253         }
 254         spin_unlock(&tbl->slot_tbl_lock);
 255         return 0;
 256 }
 257
 258 static int nfs4_begin_drain_session(struct nfs_client *clp)
 259 {
 260         struct nfs4_session *ses = clp->cl_session;
 261         int ret = 0;
 262
 263         if (clp->cl_slot_tbl)
 264                 return nfs4_drain_slot_tbl(clp->cl_slot_tbl);
 265
 266         /* back channel */
 267         ret = nfs4_drain_slot_tbl(&ses->bc_slot_table);
 268         if (ret)
 269                 return ret;
 270         /* fore channel */
 271         return nfs4_drain_slot_tbl(&ses->fc_slot_table);
 272 }
 273
 274 #if defined(CONFIG_NFS_V4_1)
 275
 276 static int nfs41_setup_state_renewal(struct nfs_client *clp)
 277 {
 278         int status;
 279         struct nfs_fsinfo fsinfo;
 280         unsigned long now;
 281
 282         if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
 283                 nfs4_schedule_state_renewal(clp);
 284                 return 0;
 285         }
 286
 287         now = jiffies;
 288         status = nfs4_proc_get_lease_time(clp, &fsinfo);
 289         if (status == 0) {
 290                 nfs4_set_lease_period(clp, fsinfo.lease_time * HZ, now);
 291                 nfs4_schedule_state_renewal(clp);
 292         }
 293
 294         return status;
 295 }
 296
 297 static void nfs41_finish_session_reset(struct nfs_client *clp)
 298 {
 299         clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
 300         clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
 301         /* create_session negotiated new slot table */
 302         clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
 303         nfs41_setup_state_renewal(clp);
 304 }
 305
 306 int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
 307 {
 308         int status;
 309
 310         if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
 311                 goto do_confirm;
 312         status = nfs4_proc_exchange_id(clp, cred);
 313         if (status != 0)
 314                 goto out;
 315         set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
 316 do_confirm:
 317         status = nfs4_proc_create_session(clp, cred);
 318         if (status != 0)
 319                 goto out;
 320         nfs41_finish_session_reset(clp);
 321         nfs_mark_client_ready(clp, NFS_CS_READY);
 322 out:
 323         return status;
 324 }
 325
 326 /**
 327  * nfs41_discover_server_trunking - Detect server IP address trunking (mv1)
 328  *
 329  * @clp: nfs_client under test
 330  * @result: OUT: found nfs_client, or clp
 331  * @cred: credential to use for trunking test
 332  *
 333  * Returns NFS4_OK, a negative errno, or a negative NFS4ERR status.
 334  * If NFS4_OK is returned, an nfs_client pointer is planted in
 335  * "result".
 336  *
 337  * Note: The returned client may not yet be marked ready.
 338  */
 339 int nfs41_discover_server_trunking(struct nfs_client *clp,
 340                                    struct nfs_client **result,
 341                                    struct rpc_cred *cred)
 342 {
 343         int status;
 344
 345         status = nfs4_proc_exchange_id(clp, cred);
 346         if (status != NFS4_OK)
 347                 return status;
 348
 349         status = nfs41_walk_client_list(clp, result, cred);
 350         if (status < 0)
 351                 return status;
 352         if (clp != *result)
 353                 return 0;
 354
 355         /* Purge state if the client id was established in a prior instance */
 356         if (clp->cl_exchange_flags & EXCHGID4_FLAG_CONFIRMED_R)
 357                 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
 358         else
 359                 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
 360         nfs4_schedule_state_manager(clp);
 361         status = nfs_wait_client_init_complete(clp);
 362         if (status < 0)
 363                 nfs_put_client(clp);
 364         return status;
 365 }
 366
 367 #endif /* CONFIG_NFS_V4_1 */
 368
 369 /**
 370  * nfs4_get_clid_cred - Acquire credential for a setclientid operation
 371  * @clp: client state handle
 372  *
 373  * Returns an rpc_cred with reference count bumped, or NULL.
 374  */
 375 struct rpc_cred *nfs4_get_clid_cred(struct nfs_client *clp)
 376 {
 377         struct rpc_cred *cred;
 378
 379         spin_lock(&clp->cl_lock);
 380         cred = nfs4_get_machine_cred_locked(clp);
 381         spin_unlock(&clp->cl_lock);
 382         return cred;
 383 }
 384
 385 static struct nfs4_state_owner *
 386 nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred)
 387 {
 388         struct rb_node **p = &server->state_owners.rb_node,
 389                        *parent = NULL;
 390         struct nfs4_state_owner *sp;
 391
 392         while (*p != NULL) {
 393                 parent = *p;
 394                 sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
 395
 396                 if (cred < sp->so_cred)
 397                         p = &parent->rb_left;
 398                 else if (cred > sp->so_cred)
 399                         p = &parent->rb_right;
 400                 else {
 401                         if (!list_empty(&sp->so_lru))
 402                                 list_del_init(&sp->so_lru);
 403                         atomic_inc(&sp->so_count);
 404                         return sp;
 405                 }
 406         }
 407         return NULL;
 408 }
 409
 410 static struct nfs4_state_owner *
 411 nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
 412 {
 413         struct nfs_server *server = new->so_server;
 414         struct rb_node **p = &server->state_owners.rb_node,
 415                        *parent = NULL;
 416         struct nfs4_state_owner *sp;
 417         int err;
 418
 419         while (*p != NULL) {
 420                 parent = *p;
 421                 sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
 422
 423                 if (new->so_cred < sp->so_cred)
 424                         p = &parent->rb_left;
 425                 else if (new->so_cred > sp->so_cred)
 426                         p = &parent->rb_right;
 427                 else {
 428                         if (!list_empty(&sp->so_lru))
 429                                 list_del_init(&sp->so_lru);
 430                         atomic_inc(&sp->so_count);
 431                         return sp;
 432                 }
 433         }
 434         err = ida_get_new(&server->openowner_id, &new->so_seqid.owner_id);
 435         if (err)
 436                 return ERR_PTR(err);
 437         rb_link_node(&new->so_server_node, parent, p);
 438         rb_insert_color(&new->so_server_node, &server->state_owners);
 439         return new;
 440 }
 441
 442 static void
 443 nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
 444 {
 445         struct nfs_server *server = sp->so_server;
 446
 447         if (!RB_EMPTY_NODE(&sp->so_server_node))
 448                 rb_erase(&sp->so_server_node, &server->state_owners);
 449         ida_remove(&server->openowner_id, sp->so_seqid.owner_id);
 450 }
 451
 452 static void
 453 nfs4_init_seqid_counter(struct nfs_seqid_counter *sc)
 454 {
 455         sc->create_time = ktime_get();
 456         sc->flags = 0;
 457         sc->counter = 0;
 458         spin_lock_init(&sc->lock);
 459         INIT_LIST_HEAD(&sc->list);
 460         rpc_init_wait_queue(&sc->wait, "Seqid_waitqueue");
 461 }
 462
 463 static void
 464 nfs4_destroy_seqid_counter(struct nfs_seqid_counter *sc)
 465 {
 466         rpc_destroy_wait_queue(&sc->wait);
 467 }
 468
 469 /*
 470  * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
 471  * create a new state_owner.
 472  *
 473  */
 474 static struct nfs4_state_owner *
 475 nfs4_alloc_state_owner(struct nfs_server *server,
 476                 struct rpc_cred *cred,
 477                 gfp_t gfp_flags)
 478 {
 479         struct nfs4_state_owner *sp;
 480
 481         sp = kzalloc(sizeof(*sp), gfp_flags);
 482         if (!sp)
 483                 return NULL;
 484         sp->so_server = server;
 485         sp->so_cred = get_rpccred(cred);
 486         spin_lock_init(&sp->so_lock);
 487         INIT_LIST_HEAD(&sp->so_states);
 488         nfs4_init_seqid_counter(&sp->so_seqid);
 489         atomic_set(&sp->so_count, 1);
 490         INIT_LIST_HEAD(&sp->so_lru);
 491         seqcount_init(&sp->so_reclaim_seqcount);
 492         mutex_init(&sp->so_delegreturn_mutex);
 493         return sp;
 494 }
 495
 496 static void
 497 nfs4_reset_state_owner(struct nfs4_state_owner *sp)
 498 {
 499         /* This state_owner is no longer usable, but must
 500          * remain in place so that state recovery can find it
 501          * and the opens associated with it.
 502          * It may also be used for new 'open' request to
 503          * return a delegation to the server.
 504          * So update the 'create_time' so that it looks like
 505          * a new state_owner.  This will cause the server to
 506          * request an OPEN_CONFIRM to start a new sequence.
 507          */
 508         sp->so_seqid.create_time = ktime_get();
 509 }
 510
 511 static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
 512 {
 513         nfs4_destroy_seqid_counter(&sp->so_seqid);
 514         put_rpccred(sp->so_cred);
 515         kfree(sp);
 516 }
 517
 518 static void nfs4_gc_state_owners(struct nfs_server *server)
 519 {
 520         struct nfs_client *clp = server->nfs_client;
 521         struct nfs4_state_owner *sp, *tmp;
 522         unsigned long time_min, time_max;
 523         LIST_HEAD(doomed);
 524
 525         spin_lock(&clp->cl_lock);
 526         time_max = jiffies;
 527         time_min = (long)time_max - (long)clp->cl_lease_time;
 528         list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
 529                 /* NB: LRU is sorted so that oldest is at the head */
 530                 if (time_in_range(sp->so_expires, time_min, time_max))
 531                         break;
 532                 list_move(&sp->so_lru, &doomed);
 533                 nfs4_remove_state_owner_locked(sp);
 534         }
 535         spin_unlock(&clp->cl_lock);
 536
 537         list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
 538                 list_del(&sp->so_lru);
 539                 nfs4_free_state_owner(sp);
 540         }
 541 }
 542
 543 /**
 544  * nfs4_get_state_owner - Look up a state owner given a credential
 545  * @server: nfs_server to search
 546  * @cred: RPC credential to match
 547  *
 548  * Returns a pointer to an instantiated nfs4_state_owner struct, or NULL.
 549  */
 550 struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,
 551                                               struct rpc_cred *cred,
 552                                               gfp_t gfp_flags)
 553 {
 554         struct nfs_client *clp = server->nfs_client;
 555         struct nfs4_state_owner *sp, *new;
 556
 557         spin_lock(&clp->cl_lock);
 558         sp = nfs4_find_state_owner_locked(server, cred);
 559         spin_unlock(&clp->cl_lock);
 560         if (sp != NULL)
 561                 goto out;
 562         new = nfs4_alloc_state_owner(server, cred, gfp_flags);
 563         if (new == NULL)
 564                 goto out;
 565         do {
 566                 if (ida_pre_get(&server->openowner_id, gfp_flags) == 0)
 567                         break;
 568                 spin_lock(&clp->cl_lock);
 569                 sp = nfs4_insert_state_owner_locked(new);
 570                 spin_unlock(&clp->cl_lock);
 571         } while (sp == ERR_PTR(-EAGAIN));
 572         if (sp != new)
 573                 nfs4_free_state_owner(new);
 574 out:
 575         nfs4_gc_state_owners(server);
 576         return sp;
 577 }
 578
 579 /**
 580  * nfs4_put_state_owner - Release a nfs4_state_owner
 581  * @sp: state owner data to release
 582  *
 583  * Note that we keep released state owners on an LRU
 584  * list.
 585  * This caches valid state owners so that they can be
 586  * reused, to avoid the OPEN_CONFIRM on minor version 0.
 587  * It also pins the uniquifier of dropped state owners for
 588  * a while, to ensure that those state owner names are
 589  * never reused.
 590  */
 591 void nfs4_put_state_owner(struct nfs4_state_owner *sp)
 592 {
 593         struct nfs_server *server = sp->so_server;
 594         struct nfs_client *clp = server->nfs_client;
 595
 596         if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
 597                 return;
 598
 599         sp->so_expires = jiffies;
 600         list_add_tail(&sp->so_lru, &server->state_owners_lru);
 601         spin_unlock(&clp->cl_lock);
 602 }
 603
 604 /**
 605  * nfs4_purge_state_owners - Release all cached state owners
 606  * @server: nfs_server with cached state owners to release
 607  *
 608  * Called at umount time.  Remaining state owners will be on
 609  * the LRU with ref count of zero.
 610  */
 611 void nfs4_purge_state_owners(struct nfs_server *server)
 612 {
 613         struct nfs_client *clp = server->nfs_client;
 614         struct nfs4_state_owner *sp, *tmp;
 615         LIST_HEAD(doomed);
 616
 617         spin_lock(&clp->cl_lock);
 618         list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
 619                 list_move(&sp->so_lru, &doomed);
 620                 nfs4_remove_state_owner_locked(sp);
 621         }
 622         spin_unlock(&clp->cl_lock);
 623
 624         list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
 625                 list_del(&sp->so_lru);
 626                 nfs4_free_state_owner(sp);
 627         }
 628 }
 629
 630 static struct nfs4_state *
 631 nfs4_alloc_open_state(void)
 632 {
 633         struct nfs4_state *state;
 634
 635         state = kzalloc(sizeof(*state), GFP_NOFS);
 636         if (!state)
 637                 return NULL;
 638         atomic_set(&state->count, 1);
 639         INIT_LIST_HEAD(&state->lock_states);
 640         spin_lock_init(&state->state_lock);
 641         seqlock_init(&state->seqlock);
 642         return state;
 643 }
 644
 645 void
 646 nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
 647 {
 648         if (state->state == fmode)
 649                 return;
 650         /* NB! List reordering - see the reclaim code for why.  */
 651         if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
 652                 if (fmode & FMODE_WRITE)
 653                         list_move(&state->open_states, &state->owner->so_states);
 654                 else
 655                         list_move_tail(&state->open_states, &state->owner->so_states);
 656         }
 657         state->state = fmode;
 658 }
 659
 660 static struct nfs4_state *
 661 __nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
 662 {
 663         struct nfs_inode *nfsi = NFS_I(inode);
 664         struct nfs4_state *state;
 665
 666         list_for_each_entry(state, &nfsi->open_states, inode_states) {
 667                 if (state->owner != owner)
 668                         continue;
 669                 if (!nfs4_valid_open_stateid(state))
 670                         continue;
 671                 if (atomic_inc_not_zero(&state->count))
 672                         return state;
 673         }
 674         return NULL;
 675 }
 676
 677 static void
 678 nfs4_free_open_state(struct nfs4_state *state)
 679 {
 680         kfree(state);
 681 }
 682
 683 struct nfs4_state *
 684 nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner)
 685 {
 686         struct nfs4_state *state, *new;
 687         struct nfs_inode *nfsi = NFS_I(inode);
 688
 689         spin_lock(&inode->i_lock);
 690         state = __nfs4_find_state_byowner(inode, owner);
 691         spin_unlock(&inode->i_lock);
 692         if (state)
 693                 goto out;
 694         new = nfs4_alloc_open_state();
 695         spin_lock(&owner->so_lock);
 696         spin_lock(&inode->i_lock);
 697         state = __nfs4_find_state_byowner(inode, owner);
 698         if (state == NULL && new != NULL) {
 699                 state = new;
 700                 state->owner = owner;
 701                 atomic_inc(&owner->so_count);
 702                 list_add(&state->inode_states, &nfsi->open_states);
 703                 ihold(inode);
 704                 state->inode = inode;
 705                 spin_unlock(&inode->i_lock);
 706                 /* Note: The reclaim code dictates that we add stateless
 707                  * and read-only stateids to the end of the list */
 708                 list_add_tail(&state->open_states, &owner->so_states);
 709                 spin_unlock(&owner->so_lock);
 710         } else {
 711                 spin_unlock(&inode->i_lock);
 712                 spin_unlock(&owner->so_lock);
 713                 if (new)
 714                         nfs4_free_open_state(new);
 715         }
 716 out:
 717         return state;
 718 }
 719
 720 void nfs4_put_open_state(struct nfs4_state *state)
 721 {
 722         struct inode *inode = state->inode;
 723         struct nfs4_state_owner *owner = state->owner;
 724
 725         if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
 726                 return;
 727         spin_lock(&inode->i_lock);
 728         list_del(&state->inode_states);
 729         list_del(&state->open_states);
 730         spin_unlock(&inode->i_lock);
 731         spin_unlock(&owner->so_lock);
 732         iput(inode);
 733         nfs4_free_open_state(state);
 734         nfs4_put_state_owner(owner);
 735 }
 736
 737 /*
 738  * Close the current file.
 739  */
 740 static void __nfs4_close(struct nfs4_state *state,
 741                 fmode_t fmode, gfp_t gfp_mask, int wait)
 742 {
 743         struct nfs4_state_owner *owner = state->owner;
 744         int call_close = 0;
 745         fmode_t newstate;
 746
 747         atomic_inc(&owner->so_count);
 748         /* Protect against nfs4_find_state() */
 749         spin_lock(&owner->so_lock);
 750         switch (fmode & (FMODE_READ | FMODE_WRITE)) {
 751                 case FMODE_READ:
 752                         state->n_rdonly--;
 753                         break;
 754                 case FMODE_WRITE:
 755                         state->n_wronly--;
 756                         break;
 757                 case FMODE_READ|FMODE_WRITE:
 758                         state->n_rdwr--;
 759         }
 760         newstate = FMODE_READ|FMODE_WRITE;
 761         if (state->n_rdwr == 0) {
 762                 if (state->n_rdonly == 0) {
 763                         newstate &= ~FMODE_READ;
 764                         call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
 765                         call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
 766                 }
 767                 if (state->n_wronly == 0) {
 768                         newstate &= ~FMODE_WRITE;
 769                         call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
 770                         call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
 771                 }
 772                 if (newstate == 0)
 773                         clear_bit(NFS_DELEGATED_STATE, &state->flags);
 774         }
 775         nfs4_state_set_mode_locked(state, newstate);
 776         spin_unlock(&owner->so_lock);
 777
 778         if (!call_close) {
 779                 nfs4_put_open_state(state);
 780                 nfs4_put_state_owner(owner);
 781         } else
 782                 nfs4_do_close(state, gfp_mask, wait);
 783 }
 784
 785 void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
 786 {
 787         __nfs4_close(state, fmode, GFP_NOFS, 0);
 788 }
 789
 790 void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
 791 {
 792         __nfs4_close(state, fmode, GFP_KERNEL, 1);
 793 }
 794
 795 /*
 796  * Search the state->lock_states for an existing lock_owner
 797  * that is compatible with either of the given owners.
 798  * If the second is non-zero, then the first refers to a Posix-lock
 799  * owner (current->files) and the second refers to a flock/OFD
 800  * owner (struct file*).  In that case, prefer a match for the first
 801  * owner.
 802  * If both sorts of locks are held on the one file we cannot know
 803  * which stateid was intended to be used, so a "correct" choice cannot
 804  * be made.  Failing that, a "consistent" choice is preferable.  The
 805  * consistent choice we make is to prefer the first owner, that of a
 806  * Posix lock.
 807  */
 808 static struct nfs4_lock_state *
 809 __nfs4_find_lock_state(struct nfs4_state *state,
 810                        fl_owner_t fl_owner, fl_owner_t fl_owner2)
 811 {
 812         struct nfs4_lock_state *pos, *ret = NULL;
 813         list_for_each_entry(pos, &state->lock_states, ls_locks) {
 814                 if (pos->ls_owner == fl_owner) {
 815                         ret = pos;
 816                         break;
 817                 }
 818                 if (pos->ls_owner == fl_owner2)
 819                         ret = pos;
 820         }
 821         if (ret)
 822                 atomic_inc(&ret->ls_count);
 823         return ret;
 824 }
 825
 826 /*
 827  * Return a compatible lock_state. If no initialized lock_state structure
 828  * exists, return an uninitialized one.
 829  *
 830  */
 831 static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
 832 {
 833         struct nfs4_lock_state *lsp;
 834         struct nfs_server *server = state->owner->so_server;
 835
 836         lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
 837         if (lsp == NULL)
 838                 return NULL;
 839         nfs4_init_seqid_counter(&lsp->ls_seqid);
 840         atomic_set(&lsp->ls_count, 1);
 841         lsp->ls_state = state;
 842         lsp->ls_owner = fl_owner;
 843         lsp->ls_seqid.owner_id = ida_simple_get(&server->lockowner_id, 0, 0, GFP_NOFS);
 844         if (lsp->ls_seqid.owner_id < 0)
 845                 goto out_free;
 846         INIT_LIST_HEAD(&lsp->ls_locks);
 847         return lsp;
 848 out_free:
 849         kfree(lsp);
 850         return NULL;
 851 }
 852
 853 void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
 854 {
 855         ida_simple_remove(&server->lockowner_id, lsp->ls_seqid.owner_id);
 856         nfs4_destroy_seqid_counter(&lsp->ls_seqid);
 857         kfree(lsp);
 858 }
 859
 860 /*
 861  * Return a compatible lock_state. If no initialized lock_state structure
 862  * exists, return an uninitialized one.
 863  *
 864  */
 865 static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner)
 866 {
 867         struct nfs4_lock_state *lsp, *new = NULL;
 868
 869         for(;;) {
 870                 spin_lock(&state->state_lock);
 871                 lsp = __nfs4_find_lock_state(state, owner, NULL);
 872                 if (lsp != NULL)
 873                         break;
 874                 if (new != NULL) {
 875                         list_add(&new->ls_locks, &state->lock_states);
 876                         set_bit(LK_STATE_IN_USE, &state->flags);
 877                         lsp = new;
 878                         new = NULL;
 879                         break;
 880                 }
 881                 spin_unlock(&state->state_lock);
 882                 new = nfs4_alloc_lock_state(state, owner);
 883                 if (new == NULL)
 884                         return NULL;
 885         }
 886         spin_unlock(&state->state_lock);
 887         if (new != NULL)
 888                 nfs4_free_lock_state(state->owner->so_server, new);
 889         return lsp;
 890 }
 891
 892 /*
 893  * Release reference to lock_state, and free it if we see that
 894  * it is no longer in use
 895  */
 896 void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
 897 {
 898         struct nfs_server *server;
 899         struct nfs4_state *state;
 900
 901         if (lsp == NULL)
 902                 return;
 903         state = lsp->ls_state;
 904         if (!atomic_dec_and_lock(&lsp->ls_count, &state->state_lock))
 905                 return;
 906         list_del(&lsp->ls_locks);
 907         if (list_empty(&state->lock_states))
 908                 clear_bit(LK_STATE_IN_USE, &state->flags);
 909         spin_unlock(&state->state_lock);
 910         server = state->owner->so_server;
 911         if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
 912                 struct nfs_client *clp = server->nfs_client;
 913
 914                 clp->cl_mvops->free_lock_state(server, lsp);
 915         } else
 916                 nfs4_free_lock_state(server, lsp);
 917 }
 918
 919 static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
 920 {
 921         struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
 922
 923         dst->fl_u.nfs4_fl.owner = lsp;
 924         atomic_inc(&lsp->ls_count);
 925 }
 926
 927 static void nfs4_fl_release_lock(struct file_lock *fl)
 928 {
 929         nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
 930 }
 931
 932 static const struct file_lock_operations nfs4_fl_lock_ops = {
 933         .fl_copy_lock = nfs4_fl_copy_lock,
 934         .fl_release_private = nfs4_fl_release_lock,
 935 };
 936
 937 int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
 938 {
 939         struct nfs4_lock_state *lsp;
 940
 941         if (fl->fl_ops != NULL)
 942                 return 0;
 943         lsp = nfs4_get_lock_state(state, fl->fl_owner);
 944         if (lsp == NULL)
 945                 return -ENOMEM;
 946         fl->fl_u.nfs4_fl.owner = lsp;
 947         fl->fl_ops = &nfs4_fl_lock_ops;
 948         return 0;
 949 }
 950
 951 static int nfs4_copy_lock_stateid(nfs4_stateid *dst,
 952                 struct nfs4_state *state,
 953                 const struct nfs_lock_context *l_ctx)
 954 {
 955         struct nfs4_lock_state *lsp;
 956         fl_owner_t fl_owner, fl_flock_owner;
 957         int ret = -ENOENT;
 958
 959         if (l_ctx == NULL)
 960                 goto out;
 961
 962         if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
 963                 goto out;
 964
 965         fl_owner = l_ctx->lockowner;
 966         fl_flock_owner = l_ctx->open_context->flock_owner;
 967
 968         spin_lock(&state->state_lock);
 969         lsp = __nfs4_find_lock_state(state, fl_owner, fl_flock_owner);
 970         if (lsp && test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
 971                 ret = -EIO;
 972         else if (lsp != NULL && test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) {
 973                 nfs4_stateid_copy(dst, &lsp->ls_stateid);
 974                 ret = 0;
 975         }
 976         spin_unlock(&state->state_lock);
 977         nfs4_put_lock_state(lsp);
 978 out:
 979         return ret;
 980 }
 981
 982 static void nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
 983 {
 984         const nfs4_stateid *src;
 985         int seq;
 986
 987         do {
 988                 src = &zero_stateid;
 989                 seq = read_seqbegin(&state->seqlock);
 990                 if (test_bit(NFS_OPEN_STATE, &state->flags))
 991                         src = &state->open_stateid;
 992                 nfs4_stateid_copy(dst, src);
 993         } while (read_seqretry(&state->seqlock, seq));
 994 }
 995
 996 /*
 997  * Byte-range lock aware utility to initialize the stateid of read/write
 998  * requests.
 999  */
1000 int nfs4_select_rw_stateid(struct nfs4_state *state,
1001                 fmode_t fmode, const struct nfs_lock_context *l_ctx,
1002                 nfs4_stateid *dst, struct rpc_cred **cred)
1003 {
1004         int ret;
1005
1006         if (!nfs4_valid_open_stateid(state))
1007                 return -EIO;
1008         if (cred != NULL)
1009                 *cred = NULL;
1010         ret = nfs4_copy_lock_stateid(dst, state, l_ctx);
1011         if (ret == -EIO)
1012                 /* A lost lock - don't even consider delegations */
1013                 goto out;
1014         /* returns true if delegation stateid found and copied */
1015         if (nfs4_copy_delegation_stateid(state->inode, fmode, dst, cred)) {
1016                 ret = 0;
1017                 goto out;
1018         }
1019         if (ret != -ENOENT)
1020                 /* nfs4_copy_delegation_stateid() didn't over-write
1021                  * dst, so it still has the lock stateid which we now
1022                  * choose to use.
1023                  */
1024                 goto out;
1025         nfs4_copy_open_stateid(dst, state);
1026         ret = 0;
1027 out:
1028         if (nfs_server_capable(state->inode, NFS_CAP_STATEID_NFSV41))
1029                 dst->seqid = 0;
1030         return ret;
1031 }
1032
1033 struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
1034 {
1035         struct nfs_seqid *new;
1036
1037         new = kmalloc(sizeof(*new), gfp_mask);
1038         if (new == NULL)
1039                 return ERR_PTR(-ENOMEM);
1040         new->sequence = counter;
1041         INIT_LIST_HEAD(&new->list);
1042         new->task = NULL;
1043         return new;
1044 }
1045
1046 void nfs_release_seqid(struct nfs_seqid *seqid)
1047 {
1048         struct nfs_seqid_counter *sequence;
1049
1050         if (seqid == NULL || list_empty(&seqid->list))
1051                 return;
1052         sequence = seqid->sequence;
1053         spin_lock(&sequence->lock);
1054         list_del_init(&seqid->list);
1055         if (!list_empty(&sequence->list)) {
1056                 struct nfs_seqid *next;
1057
1058                 next = list_first_entry(&sequence->list,
1059                                 struct nfs_seqid, list);
1060                 rpc_wake_up_queued_task(&sequence->wait, next->task);
1061         }
1062         spin_unlock(&sequence->lock);
1063 }
1064
1065 void nfs_free_seqid(struct nfs_seqid *seqid)
1066 {
1067         nfs_release_seqid(seqid);
1068         kfree(seqid);
1069 }
1070
1071 /*
1072  * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
1073  * failed with a seqid incrementing error -
1074  * see comments nfs4.h:seqid_mutating_error()
1075  */
1076 static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
1077 {
1078         switch (status) {
1079                 case 0:
1080                         break;
1081                 case -NFS4ERR_BAD_SEQID:
1082                         if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
1083                                 return;
1084                         pr_warn_ratelimited("NFS: v4 server returned a bad"
1085                                         " sequence-id error on an"
1086                                         " unconfirmed sequence %p!\n",
1087                                         seqid->sequence);
1088                 case -NFS4ERR_STALE_CLIENTID:
1089                 case -NFS4ERR_STALE_STATEID:
1090                 case -NFS4ERR_BAD_STATEID:
1091                 case -NFS4ERR_BADXDR:
1092                 case -NFS4ERR_RESOURCE:
1093                 case -NFS4ERR_NOFILEHANDLE:
1094                 case -NFS4ERR_MOVED:
1095                         /* Non-seqid mutating errors */
1096                         return;
1097         };
1098         /*
1099          * Note: no locking needed as we are guaranteed to be first
1100          * on the sequence list
1101          */
1102         seqid->sequence->counter++;
1103 }
1104
1105 void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
1106 {
1107         struct nfs4_state_owner *sp;
1108
1109         if (seqid == NULL)
1110                 return;
1111
1112         sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid);
1113         if (status == -NFS4ERR_BAD_SEQID)
1114                 nfs4_reset_state_owner(sp);
1115         if (!nfs4_has_session(sp->so_server->nfs_client))
1116                 nfs_increment_seqid(status, seqid);
1117 }
1118
1119 /*
1120  * Increment the seqid if the LOCK/LOCKU succeeded, or
1121  * failed with a seqid incrementing error -
1122  * see comments nfs4.h:seqid_mutating_error()
1123  */
1124 void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
1125 {
1126         if (seqid != NULL)
1127                 nfs_increment_seqid(status, seqid);
1128 }
1129
1130 int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
1131 {
1132         struct nfs_seqid_counter *sequence;
1133         int status = 0;
1134
1135         if (seqid == NULL)
1136                 goto out;
1137         sequence = seqid->sequence;
1138         spin_lock(&sequence->lock);
1139         seqid->task = task;
1140         if (list_empty(&seqid->list))
1141                 list_add_tail(&seqid->list, &sequence->list);
1142         if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid)
1143                 goto unlock;
1144         rpc_sleep_on(&sequence->wait, task, NULL);
1145         status = -EAGAIN;
1146 unlock:
1147         spin_unlock(&sequence->lock);
1148 out:
1149         return status;
1150 }
1151
1152 static int nfs4_run_state_manager(void *);
1153
1154 static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
1155 {
1156         smp_mb__before_atomic();
1157         clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
1158         smp_mb__after_atomic();
1159         wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
1160         rpc_wake_up(&clp->cl_rpcwaitq);
1161 }
1162
1163 /*
1164  * Schedule the nfs_client asynchronous state management routine
1165  */
1166 void nfs4_schedule_state_manager(struct nfs_client *clp)
1167 {
1168         struct task_struct *task;
1169         char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
1170
1171         if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
1172                 return;
1173         __module_get(THIS_MODULE);
1174         atomic_inc(&clp->cl_count);
1175
1176         /* The rcu_read_lock() is not strictly necessary, as the state
1177          * manager is the only thread that ever changes the rpc_xprt
1178          * after it's initialized.  At this point, we're single threaded. */
1179         rcu_read_lock();
1180         snprintf(buf, sizeof(buf), "%s-manager",
1181                         rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
1182         rcu_read_unlock();
1183         task = kthread_run(nfs4_run_state_manager, clp, "%s", buf);
1184         if (IS_ERR(task)) {
1185                 printk(KERN_ERR "%s: kthread_run: %ld\n",
1186                         __func__, PTR_ERR(task));
1187                 nfs4_clear_state_manager_bit(clp);
1188                 nfs_put_client(clp);
1189                 module_put(THIS_MODULE);
1190         }
1191 }
1192
1193 /*
1194  * Schedule a lease recovery attempt
1195  */
1196 void nfs4_schedule_lease_recovery(struct nfs_client *clp)
1197 {
1198         if (!clp)
1199                 return;
1200         if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1201                 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1202         dprintk("%s: scheduling lease recovery for server %s\n", __func__,
1203                         clp->cl_hostname);
1204         nfs4_schedule_state_manager(clp);
1205 }
1206 EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
1207
1208 /**
1209  * nfs4_schedule_migration_recovery - trigger migration recovery
1210  *
1211  * @server: FSID that is migrating
1212  *
1213  * Returns zero if recovery has started, otherwise a negative NFS4ERR
1214  * value is returned.
1215  */
1216 int nfs4_schedule_migration_recovery(const struct nfs_server *server)
1217 {
1218         struct nfs_client *clp = server->nfs_client;
1219
1220         if (server->fh_expire_type != NFS4_FH_PERSISTENT) {
1221                 pr_err("NFS: volatile file handles not supported (server %s)\n",
1222                                 clp->cl_hostname);
1223                 return -NFS4ERR_IO;
1224         }
1225
1226         if (test_bit(NFS_MIG_FAILED, &server->mig_status))
1227                 return -NFS4ERR_IO;
1228
1229         dprintk("%s: scheduling migration recovery for (%llx:%llx) on %s\n",
1230                         __func__,
1231                         (unsigned long long)server->fsid.major,
1232                         (unsigned long long)server->fsid.minor,
1233                         clp->cl_hostname);
1234
1235         set_bit(NFS_MIG_IN_TRANSITION,
1236                         &((struct nfs_server *)server)->mig_status);
1237         set_bit(NFS4CLNT_MOVED, &clp->cl_state);
1238
1239         nfs4_schedule_state_manager(clp);
1240         return 0;
1241 }
1242 EXPORT_SYMBOL_GPL(nfs4_schedule_migration_recovery);
1243
1244 /**
1245  * nfs4_schedule_lease_moved_recovery - start lease-moved recovery
1246  *
1247  * @clp: server to check for moved leases
1248  *
1249  */
1250 void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp)
1251 {
1252         dprintk("%s: scheduling lease-moved recovery for client ID %llx on %s\n",
1253                 __func__, clp->cl_clientid, clp->cl_hostname);
1254
1255         set_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state);
1256         nfs4_schedule_state_manager(clp);
1257 }
1258 EXPORT_SYMBOL_GPL(nfs4_schedule_lease_moved_recovery);
1259
1260 int nfs4_wait_clnt_recover(struct nfs_client *clp)
1261 {
1262         int res;
1263
1264         might_sleep();
1265
1266         atomic_inc(&clp->cl_count);
1267         res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
1268                                  nfs_wait_bit_killable, TASK_KILLABLE);
1269         if (res)
1270                 goto out;
1271         if (clp->cl_cons_state < 0)
1272                 res = clp->cl_cons_state;
1273 out:
1274         nfs_put_client(clp);
1275         return res;
1276 }
1277
1278 int nfs4_client_recover_expired_lease(struct nfs_client *clp)
1279 {
1280         unsigned int loop;
1281         int ret;
1282
1283         for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
1284                 ret = nfs4_wait_clnt_recover(clp);
1285                 if (ret != 0)
1286                         break;
1287                 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&
1288                     !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state))
1289                         break;
1290                 nfs4_schedule_state_manager(clp);
1291                 ret = -EIO;
1292         }
1293         return ret;
1294 }
1295
1296 /*
1297  * nfs40_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN
1298  * @clp: client to process
1299  *
1300  * Set the NFS4CLNT_LEASE_EXPIRED state in order to force a
1301  * resend of the SETCLIENTID and hence re-establish the
1302  * callback channel. Then return all existing delegations.
1303  */
1304 static void nfs40_handle_cb_pathdown(struct nfs_client *clp)
1305 {
1306         set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1307         nfs_expire_all_delegations(clp);
1308         dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
1309                         clp->cl_hostname);
1310 }
1311
1312 void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
1313 {
1314         nfs40_handle_cb_pathdown(clp);
1315         nfs4_schedule_state_manager(clp);
1316 }
1317
1318 static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1319 {
1320
1321         if (!nfs4_valid_open_stateid(state))
1322                 return 0;
1323         set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1324         /* Don't recover state that expired before the reboot */
1325         if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) {
1326                 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1327                 return 0;
1328         }
1329         set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
1330         set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1331         return 1;
1332 }
1333
1334 int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1335 {
1336         if (!nfs4_valid_open_stateid(state))
1337                 return 0;
1338         set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
1339         clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1340         set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
1341         set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
1342         return 1;
1343 }
1344
1345 int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
1346 {
1347         struct nfs_client *clp = server->nfs_client;
1348
1349         if (!nfs4_state_mark_reclaim_nograce(clp, state))
1350                 return -EBADF;
1351         dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
1352                         clp->cl_hostname);
1353         nfs4_schedule_state_manager(clp);
1354         return 0;
1355 }
1356 EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1357
1358 static struct nfs4_lock_state *
1359 nfs_state_find_lock_state_by_stateid(struct nfs4_state *state,
1360                 const nfs4_stateid *stateid)
1361 {
1362         struct nfs4_lock_state *pos;
1363
1364         list_for_each_entry(pos, &state->lock_states, ls_locks) {
1365                 if (!test_bit(NFS_LOCK_INITIALIZED, &pos->ls_flags))
1366                         continue;
1367                 if (nfs4_stateid_match_other(&pos->ls_stateid, stateid))
1368                         return pos;
1369         }
1370         return NULL;
1371 }
1372
1373 static bool nfs_state_lock_state_matches_stateid(struct nfs4_state *state,
1374                 const nfs4_stateid *stateid)
1375 {
1376         bool found = false;
1377
1378         if (test_bit(LK_STATE_IN_USE, &state->flags)) {
1379                 spin_lock(&state->state_lock);
1380                 if (nfs_state_find_lock_state_by_stateid(state, stateid))
1381                         found = true;
1382                 spin_unlock(&state->state_lock);
1383         }
1384         return found;
1385 }
1386
1387 void nfs_inode_find_state_and_recover(struct inode *inode,
1388                 const nfs4_stateid *stateid)
1389 {
1390         struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1391         struct nfs_inode *nfsi = NFS_I(inode);
1392         struct nfs_open_context *ctx;
1393         struct nfs4_state *state;
1394         bool found = false;
1395
1396         spin_lock(&inode->i_lock);
1397         list_for_each_entry(ctx, &nfsi->open_files, list) {
1398                 state = ctx->state;
1399                 if (state == NULL)
1400                         continue;
1401                 if (nfs4_stateid_match_other(&state->stateid, stateid) &&
1402                     nfs4_state_mark_reclaim_nograce(clp, state)) {
1403                         found = true;
1404                         continue;
1405                 }
1406                 if (nfs_state_lock_state_matches_stateid(state, stateid) &&
1407                     nfs4_state_mark_reclaim_nograce(clp, state))
1408                         found = true;
1409         }
1410         spin_unlock(&inode->i_lock);
1411
1412         nfs_inode_find_delegation_state_and_recover(inode, stateid);
1413         if (found)
1414                 nfs4_schedule_state_manager(clp);
1415 }
1416
1417 static void nfs4_state_mark_open_context_bad(struct nfs4_state *state)
1418 {
1419         struct inode *inode = state->inode;
1420         struct nfs_inode *nfsi = NFS_I(inode);
1421         struct nfs_open_context *ctx;
1422
1423         spin_lock(&inode->i_lock);
1424         list_for_each_entry(ctx, &nfsi->open_files, list) {
1425                 if (ctx->state != state)
1426                         continue;
1427                 set_bit(NFS_CONTEXT_BAD, &ctx->flags);
1428         }
1429         spin_unlock(&inode->i_lock);
1430 }
1431
1432 static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
1433 {
1434         set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags);
1435         nfs4_state_mark_open_context_bad(state);
1436 }
1437
1438
1439 static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
1440 {
1441         struct inode *inode = state->inode;
1442         struct nfs_inode *nfsi = NFS_I(inode);
1443         struct file_lock *fl;
1444         int status = 0;
1445         struct file_lock_context *flctx = inode->i_flctx;
1446         struct list_head *list;
1447
1448         if (flctx == NULL)
1449                 return 0;
1450
1451         list = &flctx->flc_posix;
1452
1453         /* Guard against delegation returns and new lock/unlock calls */
1454         down_write(&nfsi->rwsem);
1455         spin_lock(&flctx->flc_lock);
1456 restart:
1457         list_for_each_entry(fl, list, fl_list) {
1458                 if (nfs_file_open_context(fl->fl_file)->state != state)
1459                         continue;
1460                 spin_unlock(&flctx->flc_lock);
1461                 status = ops->recover_lock(state, fl);
1462                 switch (status) {
1463                 case 0:
1464                         break;
1465                 case -ESTALE:
1466                 case -NFS4ERR_ADMIN_REVOKED:
1467                 case -NFS4ERR_STALE_STATEID:
1468                 case -NFS4ERR_BAD_STATEID:
1469                 case -NFS4ERR_EXPIRED:
1470                 case -NFS4ERR_NO_GRACE:
1471                 case -NFS4ERR_STALE_CLIENTID:
1472                 case -NFS4ERR_BADSESSION:
1473                 case -NFS4ERR_BADSLOT:
1474                 case -NFS4ERR_BAD_HIGH_SLOT:
1475                 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1476                         goto out;
1477                 default:
1478                         pr_err("NFS: %s: unhandled error %d\n",
1479                                         __func__, status);
1480                 case -ENOMEM:
1481                 case -NFS4ERR_DENIED:
1482                 case -NFS4ERR_RECLAIM_BAD:
1483                 case -NFS4ERR_RECLAIM_CONFLICT:
1484                         /* kill_proc(fl->fl_pid, SIGLOST, 1); */
1485                         status = 0;
1486                 }
1487                 spin_lock(&flctx->flc_lock);
1488         }
1489         if (list == &flctx->flc_posix) {
1490                 list = &flctx->flc_flock;
1491                 goto restart;
1492         }
1493         spin_unlock(&flctx->flc_lock);
1494 out:
1495         up_write(&nfsi->rwsem);
1496         return status;
1497 }
1498
1499 static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
1500 {
1501         struct nfs4_state *state;
1502         struct nfs4_lock_state *lock;
1503         int status = 0;
1504
1505         /* Note: we rely on the sp->so_states list being ordered
1506          * so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
1507          * states first.
1508          * This is needed to ensure that the server won't give us any
1509          * read delegations that we have to return if, say, we are
1510          * recovering after a network partition or a reboot from a
1511          * server that doesn't support a grace period.
1512          */
1513         spin_lock(&sp->so_lock);
1514         raw_write_seqcount_begin(&sp->so_reclaim_seqcount);
1515 restart:
1516         list_for_each_entry(state, &sp->so_states, open_states) {
1517                 if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
1518                         continue;
1519                 if (!nfs4_valid_open_stateid(state))
1520                         continue;
1521                 if (state->state == 0)
1522                         continue;
1523                 atomic_inc(&state->count);
1524                 spin_unlock(&sp->so_lock);
1525                 status = ops->recover_open(sp, state);
1526                 if (status >= 0) {
1527                         status = nfs4_reclaim_locks(state, ops);
1528                         if (status >= 0) {
1529                                 if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
1530                                         spin_lock(&state->state_lock);
1531                                         list_for_each_entry(lock, &state->lock_states, ls_locks) {
1532                                                 if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
1533                                                         pr_warn_ratelimited("NFS: "
1534                                                                             "%s: Lock reclaim "
1535                                                                             "failed!\n", __func__);
1536                                         }
1537                                         spin_unlock(&state->state_lock);
1538                                 }
1539                                 clear_bit(NFS_STATE_RECLAIM_NOGRACE,
1540                                         &state->flags);
1541                                 nfs4_put_open_state(state);
1542                                 spin_lock(&sp->so_lock);
1543                                 goto restart;
1544                         }
1545                 }
1546                 switch (status) {
1547                         default:
1548                                 printk(KERN_ERR "NFS: %s: unhandled error %d\n",
1549                                         __func__, status);
1550                         case -ENOENT:
1551                         case -ENOMEM:
1552                         case -EACCES:
1553                         case -EROFS:
1554                         case -EIO:
1555                         case -ESTALE:
1556                                 /* Open state on this file cannot be recovered */
1557                                 nfs4_state_mark_recovery_failed(state, status);
1558                                 break;
1559                         case -EAGAIN:
1560                                 ssleep(1);
1561                         case -NFS4ERR_ADMIN_REVOKED:
1562                         case -NFS4ERR_STALE_STATEID:
1563                         case -NFS4ERR_OLD_STATEID:
1564                         case -NFS4ERR_BAD_STATEID:
1565                         case -NFS4ERR_RECLAIM_BAD:
1566                         case -NFS4ERR_RECLAIM_CONFLICT:
1567                                 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1568                                 break;
1569                         case -NFS4ERR_EXPIRED:
1570                         case -NFS4ERR_NO_GRACE:
1571                                 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1572                         case -NFS4ERR_STALE_CLIENTID:
1573                         case -NFS4ERR_BADSESSION:
1574                         case -NFS4ERR_BADSLOT:
1575                         case -NFS4ERR_BAD_HIGH_SLOT:
1576                         case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1577                                 goto out_err;
1578                 }
1579                 nfs4_put_open_state(state);
1580                 spin_lock(&sp->so_lock);
1581                 goto restart;
1582         }
1583         raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1584         spin_unlock(&sp->so_lock);
1585         return 0;
1586 out_err:
1587         nfs4_put_open_state(state);
1588         spin_lock(&sp->so_lock);
1589         raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1590         spin_unlock(&sp->so_lock);
1591         return status;
1592 }
1593
1594 static void nfs4_clear_open_state(struct nfs4_state *state)
1595 {
1596         struct nfs4_lock_state *lock;
1597
1598         clear_bit(NFS_DELEGATED_STATE, &state->flags);
1599         clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1600         clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1601         clear_bit(NFS_O_RDWR_STATE, &state->flags);
1602         spin_lock(&state->state_lock);
1603         list_for_each_entry(lock, &state->lock_states, ls_locks) {
1604                 lock->ls_seqid.flags = 0;
1605                 clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags);
1606         }
1607         spin_unlock(&state->state_lock);
1608 }
1609
1610 static void nfs4_reset_seqids(struct nfs_server *server,
1611         int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1612 {
1613         struct nfs_client *clp = server->nfs_client;
1614         struct nfs4_state_owner *sp;
1615         struct rb_node *pos;
1616         struct nfs4_state *state;
1617
1618         spin_lock(&clp->cl_lock);
1619         for (pos = rb_first(&server->state_owners);
1620              pos != NULL;
1621              pos = rb_next(pos)) {
1622                 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1623                 sp->so_seqid.flags = 0;
1624                 spin_lock(&sp->so_lock);
1625                 list_for_each_entry(state, &sp->so_states, open_states) {
1626                         if (mark_reclaim(clp, state))
1627                                 nfs4_clear_open_state(state);
1628                 }
1629                 spin_unlock(&sp->so_lock);
1630         }
1631         spin_unlock(&clp->cl_lock);
1632 }
1633
1634 static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
1635         int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1636 {
1637         struct nfs_server *server;
1638
1639         rcu_read_lock();
1640         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1641                 nfs4_reset_seqids(server, mark_reclaim);
1642         rcu_read_unlock();
1643 }
1644
1645 static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1646 {
1647         /* Mark all delegations for reclaim */
1648         nfs_delegation_mark_reclaim(clp);
1649         nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot);
1650 }
1651
1652 static int nfs4_reclaim_complete(struct nfs_client *clp,
1653                                  const struct nfs4_state_recovery_ops *ops,
1654                                  struct rpc_cred *cred)
1655 {
1656         /* Notify the server we're done reclaiming our state */
1657         if (ops->reclaim_complete)
1658                 return ops->reclaim_complete(clp, cred);
1659         return 0;
1660 }
1661
1662 static void nfs4_clear_reclaim_server(struct nfs_server *server)
1663 {
1664         struct nfs_client *clp = server->nfs_client;
1665         struct nfs4_state_owner *sp;
1666         struct rb_node *pos;
1667         struct nfs4_state *state;
1668
1669         spin_lock(&clp->cl_lock);
1670         for (pos = rb_first(&server->state_owners);
1671              pos != NULL;
1672              pos = rb_next(pos)) {
1673                 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1674                 spin_lock(&sp->so_lock);
1675                 list_for_each_entry(state, &sp->so_states, open_states) {
1676                         if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
1677                                                 &state->flags))
1678                                 continue;
1679                         nfs4_state_mark_reclaim_nograce(clp, state);
1680                 }
1681                 spin_unlock(&sp->so_lock);
1682         }
1683         spin_unlock(&clp->cl_lock);
1684 }
1685
1686 static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
1687 {
1688         struct nfs_server *server;
1689
1690         if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
1691                 return 0;
1692
1693         rcu_read_lock();
1694         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1695                 nfs4_clear_reclaim_server(server);
1696         rcu_read_unlock();
1697
1698         nfs_delegation_reap_unclaimed(clp);
1699         return 1;
1700 }
1701
1702 static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1703 {
1704         const struct nfs4_state_recovery_ops *ops;
1705         struct rpc_cred *cred;
1706         int err;
1707
1708         if (!nfs4_state_clear_reclaim_reboot(clp))
1709                 return;
1710         ops = clp->cl_mvops->reboot_recovery_ops;
1711         cred = nfs4_get_clid_cred(clp);
1712         err = nfs4_reclaim_complete(clp, ops, cred);
1713         put_rpccred(cred);
1714         if (err == -NFS4ERR_CONN_NOT_BOUND_TO_SESSION)
1715                 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1716 }
1717
1718 static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
1719 {
1720         nfs_mark_test_expired_all_delegations(clp);
1721         nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
1722 }
1723
1724 static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1725 {
1726         switch (error) {
1727                 case 0:
1728                         break;
1729                 case -NFS4ERR_CB_PATH_DOWN:
1730                         nfs40_handle_cb_pathdown(clp);
1731                         break;
1732                 case -NFS4ERR_NO_GRACE:
1733                         nfs4_state_end_reclaim_reboot(clp);
1734                         break;
1735                 case -NFS4ERR_STALE_CLIENTID:
1736                         set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1737                         nfs4_state_start_reclaim_reboot(clp);
1738                         break;
1739                 case -NFS4ERR_EXPIRED:
1740                         set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1741                         nfs4_state_start_reclaim_nograce(clp);
1742                         break;
1743                 case -NFS4ERR_BADSESSION:
1744                 case -NFS4ERR_BADSLOT:
1745                 case -NFS4ERR_BAD_HIGH_SLOT:
1746                 case -NFS4ERR_DEADSESSION:
1747                 case -NFS4ERR_SEQ_FALSE_RETRY:
1748                 case -NFS4ERR_SEQ_MISORDERED:
1749                         set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1750                         /* Zero session reset errors */
1751                         break;
1752                 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1753                         set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1754                         break;
1755                 default:
1756                         dprintk("%s: failed to handle error %d for server %s\n",
1757                                         __func__, error, clp->cl_hostname);
1758                         return error;
1759         }
1760         dprintk("%s: handled error %d for server %s\n", __func__, error,
1761                         clp->cl_hostname);
1762         return 0;
1763 }
1764
1765 static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
1766 {
1767         struct nfs4_state_owner *sp;
1768         struct nfs_server *server;
1769         struct rb_node *pos;
1770         int status = 0;
1771
1772 restart:
1773         rcu_read_lock();
1774         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1775                 nfs4_purge_state_owners(server);
1776                 spin_lock(&clp->cl_lock);
1777                 for (pos = rb_first(&server->state_owners);
1778                      pos != NULL;
1779                      pos = rb_next(pos)) {
1780                         sp = rb_entry(pos,
1781                                 struct nfs4_state_owner, so_server_node);
1782                         if (!test_and_clear_bit(ops->owner_flag_bit,
1783                                                         &sp->so_flags))
1784                                 continue;
1785                         if (!atomic_inc_not_zero(&sp->so_count))
1786                                 continue;
1787                         spin_unlock(&clp->cl_lock);
1788                         rcu_read_unlock();
1789
1790                         status = nfs4_reclaim_open_state(sp, ops);
1791                         if (status < 0) {
1792                                 set_bit(ops->owner_flag_bit, &sp->so_flags);
1793                                 nfs4_put_state_owner(sp);
1794                                 status = nfs4_recovery_handle_error(clp, status);
1795                                 return (status != 0) ? status : -EAGAIN;
1796                         }
1797
1798                         nfs4_put_state_owner(sp);
1799                         goto restart;
1800                 }
1801                 spin_unlock(&clp->cl_lock);
1802         }
1803         rcu_read_unlock();
1804         return 0;
1805 }
1806
1807 static int nfs4_check_lease(struct nfs_client *clp)
1808 {
1809         struct rpc_cred *cred;
1810         const struct nfs4_state_maintenance_ops *ops =
1811                 clp->cl_mvops->state_renewal_ops;
1812         int status;
1813
1814         /* Is the client already known to have an expired lease? */
1815         if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1816                 return 0;
1817         spin_lock(&clp->cl_lock);
1818         cred = ops->get_state_renewal_cred_locked(clp);
1819         spin_unlock(&clp->cl_lock);
1820         if (cred == NULL) {
1821                 cred = nfs4_get_clid_cred(clp);
1822                 status = -ENOKEY;
1823                 if (cred == NULL)
1824                         goto out;
1825         }
1826         status = ops->renew_lease(clp, cred);
1827         put_rpccred(cred);
1828         if (status == -ETIMEDOUT) {
1829                 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1830                 return 0;
1831         }
1832 out:
1833         return nfs4_recovery_handle_error(clp, status);
1834 }
1835
1836 /* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
1837  * and for recoverable errors on EXCHANGE_ID for v4.1
1838  */
1839 static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
1840 {
1841         switch (status) {
1842         case -NFS4ERR_SEQ_MISORDERED:
1843                 if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state))
1844                         return -ESERVERFAULT;
1845                 /* Lease confirmation error: retry after purging the lease */
1846                 ssleep(1);
1847                 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1848                 break;
1849         case -NFS4ERR_STALE_CLIENTID:
1850                 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1851                 nfs4_state_start_reclaim_reboot(clp);
1852                 break;
1853         case -NFS4ERR_CLID_INUSE:
1854                 pr_err("NFS: Server %s reports our clientid is in use\n",
1855                         clp->cl_hostname);
1856                 nfs_mark_client_ready(clp, -EPERM);
1857                 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1858                 return -EPERM;
1859         case -EACCES:
1860         case -NFS4ERR_DELAY:
1861         case -ETIMEDOUT:
1862         case -EAGAIN:
1863                 ssleep(1);
1864                 break;
1865
1866         case -NFS4ERR_MINOR_VERS_MISMATCH:
1867                 if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
1868                         nfs_mark_client_ready(clp, -EPROTONOSUPPORT);
1869                 dprintk("%s: exit with error %d for server %s\n",
1870                                 __func__, -EPROTONOSUPPORT, clp->cl_hostname);
1871                 return -EPROTONOSUPPORT;
1872         case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
1873                                  * in nfs4_exchange_id */
1874         default:
1875                 dprintk("%s: exit with error %d for server %s\n", __func__,
1876                                 status, clp->cl_hostname);
1877                 return status;
1878         }
1879         set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1880         dprintk("%s: handled error %d for server %s\n", __func__, status,
1881                         clp->cl_hostname);
1882         return 0;
1883 }
1884
1885 static int nfs4_establish_lease(struct nfs_client *clp)
1886 {
1887         struct rpc_cred *cred;
1888         const struct nfs4_state_recovery_ops *ops =
1889                 clp->cl_mvops->reboot_recovery_ops;
1890         int status;
1891
1892         nfs4_begin_drain_session(clp);
1893         cred = nfs4_get_clid_cred(clp);
1894         if (cred == NULL)
1895                 return -ENOENT;
1896         status = ops->establish_clid(clp, cred);
1897         put_rpccred(cred);
1898         if (status != 0)
1899                 return status;
1900         pnfs_destroy_all_layouts(clp);
1901         return 0;
1902 }
1903
1904 /*
1905  * Returns zero or a negative errno.  NFS4ERR values are converted
1906  * to local errno values.
1907  */
1908 static int nfs4_reclaim_lease(struct nfs_client *clp)
1909 {
1910         int status;
1911
1912         status = nfs4_establish_lease(clp);
1913         if (status < 0)
1914                 return nfs4_handle_reclaim_lease_error(clp, status);
1915         if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state))
1916                 nfs4_state_start_reclaim_nograce(clp);
1917         if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
1918                 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1919         clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1920         clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1921         return 0;
1922 }
1923
1924 static int nfs4_purge_lease(struct nfs_client *clp)
1925 {
1926         int status;
1927
1928         status = nfs4_establish_lease(clp);
1929         if (status < 0)
1930                 return nfs4_handle_reclaim_lease_error(clp, status);
1931         clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
1932         set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1933         nfs4_state_start_reclaim_nograce(clp);
1934         return 0;
1935 }
1936
1937 /*
1938  * Try remote migration of one FSID from a source server to a
1939  * destination server.  The source server provides a list of
1940  * potential destinations.
1941  *
1942  * Returns zero or a negative NFS4ERR status code.
1943  */
1944 static int nfs4_try_migration(struct nfs_server *server, struct rpc_cred *cred)
1945 {
1946         struct nfs_client *clp = server->nfs_client;
1947         struct nfs4_fs_locations *locations = NULL;
1948         struct inode *inode;
1949         struct page *page;
1950         int status, result;
1951
1952         dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__,
1953                         (unsigned long long)server->fsid.major,
1954                         (unsigned long long)server->fsid.minor,
1955                         clp->cl_hostname);
1956
1957         result = 0;
1958         page = alloc_page(GFP_KERNEL);
1959         locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
1960         if (page == NULL || locations == NULL) {
1961                 dprintk("<-- %s: no memory\n", __func__);
1962                 goto out;
1963         }
1964
1965         inode = d_inode(server->super->s_root);
1966         result = nfs4_proc_get_locations(inode, locations, page, cred);
1967         if (result) {
1968                 dprintk("<-- %s: failed to retrieve fs_locations: %d\n",
1969                         __func__, result);
1970                 goto out;
1971         }
1972
1973         result = -NFS4ERR_NXIO;
1974         if (!(locations->fattr.valid & NFS_ATTR_FATTR_V4_LOCATIONS)) {
1975                 dprintk("<-- %s: No fs_locations data, migration skipped\n",
1976                         __func__);
1977                 goto out;
1978         }
1979
1980         nfs4_begin_drain_session(clp);
1981
1982         status = nfs4_replace_transport(server, locations);
1983         if (status != 0) {
1984                 dprintk("<-- %s: failed to replace transport: %d\n",
1985                         __func__, status);
1986                 goto out;
1987         }
1988
1989         result = 0;
1990         dprintk("<-- %s: migration succeeded\n", __func__);
1991
1992 out:
1993         if (page != NULL)
1994                 __free_page(page);
1995         kfree(locations);
1996         if (result) {
1997                 pr_err("NFS: migration recovery failed (server %s)\n",
1998                                 clp->cl_hostname);
1999                 set_bit(NFS_MIG_FAILED, &server->mig_status);
2000         }
2001         return result;
2002 }
2003
2004 /*
2005  * Returns zero or a negative NFS4ERR status code.
2006  */
2007 static int nfs4_handle_migration(struct nfs_client *clp)
2008 {
2009         const struct nfs4_state_maintenance_ops *ops =
2010                                 clp->cl_mvops->state_renewal_ops;
2011         struct nfs_server *server;
2012         struct rpc_cred *cred;
2013
2014         dprintk("%s: migration reported on \"%s\"\n", __func__,
2015                         clp->cl_hostname);
2016
2017         spin_lock(&clp->cl_lock);
2018         cred = ops->get_state_renewal_cred_locked(clp);
2019         spin_unlock(&clp->cl_lock);
2020         if (cred == NULL)
2021                 return -NFS4ERR_NOENT;
2022
2023         clp->cl_mig_gen++;
2024 restart:
2025         rcu_read_lock();
2026         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2027                 int status;
2028
2029                 if (server->mig_gen == clp->cl_mig_gen)
2030                         continue;
2031                 server->mig_gen = clp->cl_mig_gen;
2032
2033                 if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION,
2034                                                 &server->mig_status))
2035                         continue;
2036
2037                 rcu_read_unlock();
2038                 status = nfs4_try_migration(server, cred);
2039                 if (status < 0) {
2040                         put_rpccred(cred);
2041                         return status;
2042                 }
2043                 goto restart;
2044         }
2045         rcu_read_unlock();
2046         put_rpccred(cred);
2047         return 0;
2048 }
2049
2050 /*
2051  * Test each nfs_server on the clp's cl_superblocks list to see
2052  * if it's moved to another server.  Stop when the server no longer
2053  * returns NFS4ERR_LEASE_MOVED.
2054  */
2055 static int nfs4_handle_lease_moved(struct nfs_client *clp)
2056 {
2057         const struct nfs4_state_maintenance_ops *ops =
2058                                 clp->cl_mvops->state_renewal_ops;
2059         struct nfs_server *server;
2060         struct rpc_cred *cred;
2061
2062         dprintk("%s: lease moved reported on \"%s\"\n", __func__,
2063                         clp->cl_hostname);
2064
2065         spin_lock(&clp->cl_lock);
2066         cred = ops->get_state_renewal_cred_locked(clp);
2067         spin_unlock(&clp->cl_lock);
2068         if (cred == NULL)
2069                 return -NFS4ERR_NOENT;
2070
2071         clp->cl_mig_gen++;
2072 restart:
2073         rcu_read_lock();
2074         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2075                 struct inode *inode;
2076                 int status;
2077
2078                 if (server->mig_gen == clp->cl_mig_gen)
2079                         continue;
2080                 server->mig_gen = clp->cl_mig_gen;
2081
2082                 rcu_read_unlock();
2083
2084                 inode = d_inode(server->super->s_root);
2085                 status = nfs4_proc_fsid_present(inode, cred);
2086                 if (status != -NFS4ERR_MOVED)
2087                         goto restart;   /* wasn't this one */
2088                 if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED)
2089                         goto restart;   /* there are more */
2090                 goto out;
2091         }
2092         rcu_read_unlock();
2093
2094 out:
2095         put_rpccred(cred);
2096         return 0;
2097 }
2098
2099 /**
2100  * nfs4_discover_server_trunking - Detect server IP address trunking
2101  *
2102  * @clp: nfs_client under test
2103  * @result: OUT: found nfs_client, or clp
2104  *
2105  * Returns zero or a negative errno.  If zero is returned,
2106  * an nfs_client pointer is planted in "result".
2107  *
2108  * Note: since we are invoked in process context, and
2109  * not from inside the state manager, we cannot use
2110  * nfs4_handle_reclaim_lease_error().
2111  */
2112 int nfs4_discover_server_trunking(struct nfs_client *clp,
2113                                   struct nfs_client **result)
2114 {
2115         const struct nfs4_state_recovery_ops *ops =
2116                                 clp->cl_mvops->reboot_recovery_ops;
2117         struct rpc_clnt *clnt;
2118         struct rpc_cred *cred;
2119         int i, status;
2120
2121         dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);
2122
2123         clnt = clp->cl_rpcclient;
2124         i = 0;
2125
2126         mutex_lock(&nfs_clid_init_mutex);
2127 again:
2128         status  = -ENOENT;
2129         cred = nfs4_get_clid_cred(clp);
2130         if (cred == NULL)
2131                 goto out_unlock;
2132
2133         status = ops->detect_trunking(clp, result, cred);
2134         put_rpccred(cred);
2135         switch (status) {
2136         case 0:
2137         case -EINTR:
2138         case -ERESTARTSYS:
2139                 break;
2140         case -ETIMEDOUT:
2141                 if (clnt->cl_softrtry)
2142                         break;
2143         case -NFS4ERR_DELAY:
2144         case -EAGAIN:
2145                 ssleep(1);
2146         case -NFS4ERR_STALE_CLIENTID:
2147                 dprintk("NFS: %s after status %d, retrying\n",
2148                         __func__, status);
2149                 goto again;
2150         case -EACCES:
2151                 if (i++ == 0) {
2152                         nfs4_root_machine_cred(clp);
2153                         goto again;
2154                 }
2155                 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX)
2156                         break;
2157         case -NFS4ERR_CLID_INUSE:
2158         case -NFS4ERR_WRONGSEC:
2159                 /* No point in retrying if we already used RPC_AUTH_UNIX */
2160                 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) {
2161                         status = -EPERM;
2162                         break;
2163                 }
2164                 clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX);
2165                 if (IS_ERR(clnt)) {
2166                         status = PTR_ERR(clnt);
2167                         break;
2168                 }
2169                 /* Note: this is safe because we haven't yet marked the
2170                  * client as ready, so we are the only user of
2171                  * clp->cl_rpcclient
2172                  */
2173                 clnt = xchg(&clp->cl_rpcclient, clnt);
2174                 rpc_shutdown_client(clnt);
2175                 clnt = clp->cl_rpcclient;
2176                 goto again;
2177
2178         case -NFS4ERR_MINOR_VERS_MISMATCH:
2179                 status = -EPROTONOSUPPORT;
2180                 break;
2181
2182         case -EKEYEXPIRED:
2183         case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2184                                  * in nfs4_exchange_id */
2185                 status = -EKEYEXPIRED;
2186                 break;
2187         default:
2188                 pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
2189                                 __func__, status);
2190                 status = -EIO;
2191         }
2192
2193 out_unlock:
2194         mutex_unlock(&nfs_clid_init_mutex);
2195         dprintk("NFS: %s: status = %d\n", __func__, status);
2196         return status;
2197 }
2198
2199 #ifdef CONFIG_NFS_V4_1
2200 void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
2201 {
2202         struct nfs_client *clp = session->clp;
2203
2204         switch (err) {
2205         default:
2206                 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2207                 break;
2208         case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
2209                 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2210         }
2211         nfs4_schedule_state_manager(clp);
2212 }
2213 EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
2214
2215 void nfs41_notify_server(struct nfs_client *clp)
2216 {
2217         /* Use CHECK_LEASE to ping the server with a SEQUENCE */
2218         set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
2219         nfs4_schedule_state_manager(clp);
2220 }
2221
2222 static void nfs4_reset_all_state(struct nfs_client *clp)
2223 {
2224         if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2225                 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
2226                 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
2227                 nfs4_state_start_reclaim_nograce(clp);
2228                 dprintk("%s: scheduling reset of all state for server %s!\n",
2229                                 __func__, clp->cl_hostname);
2230                 nfs4_schedule_state_manager(clp);
2231         }
2232 }
2233
2234 static void nfs41_handle_server_reboot(struct nfs_client *clp)
2235 {
2236         if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2237                 nfs4_state_start_reclaim_reboot(clp);
2238                 dprintk("%s: server %s rebooted!\n", __func__,
2239                                 clp->cl_hostname);
2240                 nfs4_schedule_state_manager(clp);
2241         }
2242 }
2243
2244 static void nfs41_handle_all_state_revoked(struct nfs_client *clp)
2245 {
2246         nfs4_reset_all_state(clp);
2247         dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2248 }
2249
2250 static void nfs41_handle_some_state_revoked(struct nfs_client *clp)
2251 {
2252         nfs4_state_start_reclaim_nograce(clp);
2253         nfs4_schedule_state_manager(clp);
2254
2255         dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2256 }
2257
2258 static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
2259 {
2260         /* FIXME: For now, we destroy all layouts. */
2261         pnfs_destroy_all_layouts(clp);
2262         /* FIXME: For now, we test all delegations+open state+locks. */
2263         nfs41_handle_some_state_revoked(clp);
2264         dprintk("%s: Recallable state revoked on server %s!\n", __func__,
2265                         clp->cl_hostname);
2266 }
2267
2268 static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
2269 {
2270         set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2271         nfs4_schedule_state_manager(clp);
2272
2273         dprintk("%s: server %s declared a backchannel fault\n", __func__,
2274                         clp->cl_hostname);
2275 }
2276
2277 static void nfs41_handle_cb_path_down(struct nfs_client *clp)
2278 {
2279         if (test_and_set_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2280                 &clp->cl_state) == 0)
2281                 nfs4_schedule_state_manager(clp);
2282 }
2283
2284 void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags,
2285                 bool recovery)
2286 {
2287         if (!flags)
2288                 return;
2289
2290         dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
2291                 __func__, clp->cl_hostname, clp->cl_clientid, flags);
2292         /*
2293          * If we're called from the state manager thread, then assume we're
2294          * already handling the RECLAIM_NEEDED and/or STATE_REVOKED.
2295          * Those flags are expected to remain set until we're done
2296          * recovering (see RFC5661, section 18.46.3).
2297          */
2298         if (recovery)
2299                 goto out_recovery;
2300
2301         if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
2302                 nfs41_handle_server_reboot(clp);
2303         if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED))
2304                 nfs41_handle_all_state_revoked(clp);
2305         if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
2306                             SEQ4_STATUS_ADMIN_STATE_REVOKED))
2307                 nfs41_handle_some_state_revoked(clp);
2308         if (flags & SEQ4_STATUS_LEASE_MOVED)
2309                 nfs4_schedule_lease_moved_recovery(clp);
2310         if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
2311                 nfs41_handle_recallable_state_revoked(clp);
2312 out_recovery:
2313         if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT)
2314                 nfs41_handle_backchannel_fault(clp);
2315         else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
2316                                 SEQ4_STATUS_CB_PATH_DOWN_SESSION))
2317                 nfs41_handle_cb_path_down(clp);
2318 }
2319
2320 static int nfs4_reset_session(struct nfs_client *clp)
2321 {
2322         struct rpc_cred *cred;
2323         int status;
2324
2325         if (!nfs4_has_session(clp))
2326                 return 0;
2327         nfs4_begin_drain_session(clp);
2328         cred = nfs4_get_clid_cred(clp);
2329         status = nfs4_proc_destroy_session(clp->cl_session, cred);
2330         switch (status) {
2331         case 0:
2332         case -NFS4ERR_BADSESSION:
2333         case -NFS4ERR_DEADSESSION:
2334                 break;
2335         case -NFS4ERR_BACK_CHAN_BUSY:
2336         case -NFS4ERR_DELAY:
2337                 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2338                 status = 0;
2339                 ssleep(1);
2340                 goto out;
2341         default:
2342                 status = nfs4_recovery_handle_error(clp, status);
2343                 goto out;
2344         }
2345
2346         memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
2347         status = nfs4_proc_create_session(clp, cred);
2348         if (status) {
2349                 dprintk("%s: session reset failed with status %d for server %s!\n",
2350                         __func__, status, clp->cl_hostname);
2351                 status = nfs4_handle_reclaim_lease_error(clp, status);
2352                 goto out;
2353         }
2354         nfs41_finish_session_reset(clp);
2355         dprintk("%s: session reset was successful for server %s!\n",
2356                         __func__, clp->cl_hostname);
2357 out:
2358         if (cred)
2359                 put_rpccred(cred);
2360         return status;
2361 }
2362
2363 static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2364 {
2365         struct rpc_cred *cred;
2366         int ret;
2367
2368         if (!nfs4_has_session(clp))
2369                 return 0;
2370         nfs4_begin_drain_session(clp);
2371         cred = nfs4_get_clid_cred(clp);
2372         ret = nfs4_proc_bind_conn_to_session(clp, cred);
2373         if (cred)
2374                 put_rpccred(cred);
2375         clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2376         switch (ret) {
2377         case 0:
2378                 dprintk("%s: bind_conn_to_session was successful for server %s!\n",
2379                         __func__, clp->cl_hostname);
2380                 break;
2381         case -NFS4ERR_DELAY:
2382                 ssleep(1);
2383                 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2384                 break;
2385         default:
2386                 return nfs4_recovery_handle_error(clp, ret);
2387         }
2388         return 0;
2389 }
2390 #else /* CONFIG_NFS_V4_1 */
2391 static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
2392
2393 static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2394 {
2395         return 0;
2396 }
2397 #endif /* CONFIG_NFS_V4_1 */
2398
2399 static void nfs4_state_manager(struct nfs_client *clp)
2400 {
2401         int status = 0;
2402         const char *section = "", *section_sep = "";
2403
2404         /* Ensure exclusive access to NFSv4 state */
2405         do {
2406                 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2407                         section = "purge state";
2408                         status = nfs4_purge_lease(clp);
2409                         if (status < 0)
2410                                 goto out_error;
2411                         continue;
2412                 }
2413
2414                 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
2415                         section = "lease expired";
2416                         /* We're going to have to re-establish a clientid */
2417                         status = nfs4_reclaim_lease(clp);
2418                         if (status < 0)
2419                                 goto out_error;
2420                         continue;
2421                 }
2422
2423                 /* Initialize or reset the session */
2424                 if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) {
2425                         section = "reset session";
2426                         status = nfs4_reset_session(clp);
2427                         if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
2428                                 continue;
2429                         if (status < 0)
2430                                 goto out_error;
2431                 }
2432
2433                 /* Send BIND_CONN_TO_SESSION */
2434                 if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2435                                 &clp->cl_state)) {
2436                         section = "bind conn to session";
2437                         status = nfs4_bind_conn_to_session(clp);
2438                         if (status < 0)
2439                                 goto out_error;
2440                         continue;
2441                 }
2442
2443                 if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
2444                         section = "check lease";
2445                         status = nfs4_check_lease(clp);
2446                         if (status < 0)
2447                                 goto out_error;
2448                         continue;
2449                 }
2450
2451                 if (test_and_clear_bit(NFS4CLNT_MOVED, &clp->cl_state)) {
2452                         section = "migration";
2453                         status = nfs4_handle_migration(clp);
2454                         if (status < 0)
2455                                 goto out_error;
2456                 }
2457
2458                 if (test_and_clear_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state)) {
2459                         section = "lease moved";
2460                         status = nfs4_handle_lease_moved(clp);
2461                         if (status < 0)
2462                                 goto out_error;
2463                 }
2464
2465                 /* First recover reboot state... */
2466                 if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
2467                         section = "reclaim reboot";
2468                         status = nfs4_do_reclaim(clp,
2469                                 clp->cl_mvops->reboot_recovery_ops);
2470                         if (status == -EAGAIN)
2471                                 continue;
2472                         if (status < 0)
2473                                 goto out_error;
2474                         nfs4_state_end_reclaim_reboot(clp);
2475                 }
2476
2477                 /* Detect expired delegations... */
2478                 if (test_and_clear_bit(NFS4CLNT_DELEGATION_EXPIRED, &clp->cl_state)) {
2479                         section = "detect expired delegations";
2480                         nfs_reap_expired_delegations(clp);
2481                         continue;
2482                 }
2483
2484                 /* Now recover expired state... */
2485                 if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
2486                         section = "reclaim nograce";
2487                         status = nfs4_do_reclaim(clp,
2488                                 clp->cl_mvops->nograce_recovery_ops);
2489                         if (status == -EAGAIN)
2490                                 continue;
2491                         if (status < 0)
2492                                 goto out_error;
2493                 }
2494
2495                 nfs4_end_drain_session(clp);
2496                 if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
2497                         nfs_client_return_marked_delegations(clp);
2498                         continue;
2499                 }
2500
2501                 nfs4_clear_state_manager_bit(clp);
2502                 /* Did we race with an attempt to give us more work? */
2503                 if (clp->cl_state == 0)
2504                         break;
2505                 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
2506                         break;
2507         } while (atomic_read(&clp->cl_count) > 1);
2508         return;
2509 out_error:
2510         if (strlen(section))
2511                 section_sep = ": ";
2512         pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
2513                         " with error %d\n", section_sep, section,
2514                         clp->cl_hostname, -status);
2515         ssleep(1);
2516         nfs4_end_drain_session(clp);
2517         nfs4_clear_state_manager_bit(clp);
2518 }
2519
2520 static int nfs4_run_state_manager(void *ptr)
2521 {
2522         struct nfs_client *clp = ptr;
2523
2524         allow_signal(SIGKILL);
2525         nfs4_state_manager(clp);
2526         nfs_put_client(clp);
2527         module_put_and_exit(0);
2528         return 0;
2529 }
2530
2531 /*
2532  * Local variables:
2533  *  c-basic-offset: 8
2534  * End:
2535  */