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, 0);
 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                         /* Non-seqid mutating errors */
1095                         return;
1096         };
1097         /*
1098          * Note: no locking needed as we are guaranteed to be first
1099          * on the sequence list
1100          */
1101         seqid->sequence->counter++;
1102 }
1103
1104 void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
1105 {
1106         struct nfs4_state_owner *sp;
1107
1108         if (seqid == NULL)
1109                 return;
1110
1111         sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid);
1112         if (status == -NFS4ERR_BAD_SEQID)
1113                 nfs4_reset_state_owner(sp);
1114         if (!nfs4_has_session(sp->so_server->nfs_client))
1115                 nfs_increment_seqid(status, seqid);
1116 }
1117
1118 /*
1119  * Increment the seqid if the LOCK/LOCKU succeeded, or
1120  * failed with a seqid incrementing error -
1121  * see comments nfs4.h:seqid_mutating_error()
1122  */
1123 void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
1124 {
1125         if (seqid != NULL)
1126                 nfs_increment_seqid(status, seqid);
1127 }
1128
1129 int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
1130 {
1131         struct nfs_seqid_counter *sequence;
1132         int status = 0;
1133
1134         if (seqid == NULL)
1135                 goto out;
1136         sequence = seqid->sequence;
1137         spin_lock(&sequence->lock);
1138         seqid->task = task;
1139         if (list_empty(&seqid->list))
1140                 list_add_tail(&seqid->list, &sequence->list);
1141         if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid)
1142                 goto unlock;
1143         rpc_sleep_on(&sequence->wait, task, NULL);
1144         status = -EAGAIN;
1145 unlock:
1146         spin_unlock(&sequence->lock);
1147 out:
1148         return status;
1149 }
1150
1151 static int nfs4_run_state_manager(void *);
1152
1153 static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
1154 {
1155         smp_mb__before_atomic();
1156         clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
1157         smp_mb__after_atomic();
1158         wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
1159         rpc_wake_up(&clp->cl_rpcwaitq);
1160 }
1161
1162 /*
1163  * Schedule the nfs_client asynchronous state management routine
1164  */
1165 void nfs4_schedule_state_manager(struct nfs_client *clp)
1166 {
1167         struct task_struct *task;
1168         char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
1169
1170         if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
1171                 return;
1172         __module_get(THIS_MODULE);
1173         atomic_inc(&clp->cl_count);
1174
1175         /* The rcu_read_lock() is not strictly necessary, as the state
1176          * manager is the only thread that ever changes the rpc_xprt
1177          * after it's initialized.  At this point, we're single threaded. */
1178         rcu_read_lock();
1179         snprintf(buf, sizeof(buf), "%s-manager",
1180                         rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
1181         rcu_read_unlock();
1182         task = kthread_run(nfs4_run_state_manager, clp, "%s", buf);
1183         if (IS_ERR(task)) {
1184                 printk(KERN_ERR "%s: kthread_run: %ld\n",
1185                         __func__, PTR_ERR(task));
1186                 nfs4_clear_state_manager_bit(clp);
1187                 nfs_put_client(clp);
1188                 module_put(THIS_MODULE);
1189         }
1190 }
1191
1192 /*
1193  * Schedule a lease recovery attempt
1194  */
1195 void nfs4_schedule_lease_recovery(struct nfs_client *clp)
1196 {
1197         if (!clp)
1198                 return;
1199         if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1200                 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1201         dprintk("%s: scheduling lease recovery for server %s\n", __func__,
1202                         clp->cl_hostname);
1203         nfs4_schedule_state_manager(clp);
1204 }
1205 EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
1206
1207 /**
1208  * nfs4_schedule_migration_recovery - trigger migration recovery
1209  *
1210  * @server: FSID that is migrating
1211  *
1212  * Returns zero if recovery has started, otherwise a negative NFS4ERR
1213  * value is returned.
1214  */
1215 int nfs4_schedule_migration_recovery(const struct nfs_server *server)
1216 {
1217         struct nfs_client *clp = server->nfs_client;
1218
1219         if (server->fh_expire_type != NFS4_FH_PERSISTENT) {
1220                 pr_err("NFS: volatile file handles not supported (server %s)\n",
1221                                 clp->cl_hostname);
1222                 return -NFS4ERR_IO;
1223         }
1224
1225         if (test_bit(NFS_MIG_FAILED, &server->mig_status))
1226                 return -NFS4ERR_IO;
1227
1228         dprintk("%s: scheduling migration recovery for (%llx:%llx) on %s\n",
1229                         __func__,
1230                         (unsigned long long)server->fsid.major,
1231                         (unsigned long long)server->fsid.minor,
1232                         clp->cl_hostname);
1233
1234         set_bit(NFS_MIG_IN_TRANSITION,
1235                         &((struct nfs_server *)server)->mig_status);
1236         set_bit(NFS4CLNT_MOVED, &clp->cl_state);
1237
1238         nfs4_schedule_state_manager(clp);
1239         return 0;
1240 }
1241 EXPORT_SYMBOL_GPL(nfs4_schedule_migration_recovery);
1242
1243 /**
1244  * nfs4_schedule_lease_moved_recovery - start lease-moved recovery
1245  *
1246  * @clp: server to check for moved leases
1247  *
1248  */
1249 void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp)
1250 {
1251         dprintk("%s: scheduling lease-moved recovery for client ID %llx on %s\n",
1252                 __func__, clp->cl_clientid, clp->cl_hostname);
1253
1254         set_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state);
1255         nfs4_schedule_state_manager(clp);
1256 }
1257 EXPORT_SYMBOL_GPL(nfs4_schedule_lease_moved_recovery);
1258
1259 int nfs4_wait_clnt_recover(struct nfs_client *clp)
1260 {
1261         int res;
1262
1263         might_sleep();
1264
1265         atomic_inc(&clp->cl_count);
1266         res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
1267                                  nfs_wait_bit_killable, TASK_KILLABLE);
1268         if (res)
1269                 goto out;
1270         if (clp->cl_cons_state < 0)
1271                 res = clp->cl_cons_state;
1272 out:
1273         nfs_put_client(clp);
1274         return res;
1275 }
1276
1277 int nfs4_client_recover_expired_lease(struct nfs_client *clp)
1278 {
1279         unsigned int loop;
1280         int ret;
1281
1282         for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
1283                 ret = nfs4_wait_clnt_recover(clp);
1284                 if (ret != 0)
1285                         break;
1286                 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&
1287                     !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state))
1288                         break;
1289                 nfs4_schedule_state_manager(clp);
1290                 ret = -EIO;
1291         }
1292         return ret;
1293 }
1294
1295 /*
1296  * nfs40_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN
1297  * @clp: client to process
1298  *
1299  * Set the NFS4CLNT_LEASE_EXPIRED state in order to force a
1300  * resend of the SETCLIENTID and hence re-establish the
1301  * callback channel. Then return all existing delegations.
1302  */
1303 static void nfs40_handle_cb_pathdown(struct nfs_client *clp)
1304 {
1305         set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1306         nfs_expire_all_delegations(clp);
1307         dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
1308                         clp->cl_hostname);
1309 }
1310
1311 void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
1312 {
1313         nfs40_handle_cb_pathdown(clp);
1314         nfs4_schedule_state_manager(clp);
1315 }
1316
1317 static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1318 {
1319
1320         if (!nfs4_valid_open_stateid(state))
1321                 return 0;
1322         set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1323         /* Don't recover state that expired before the reboot */
1324         if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) {
1325                 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1326                 return 0;
1327         }
1328         set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
1329         set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1330         return 1;
1331 }
1332
1333 int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1334 {
1335         if (!nfs4_valid_open_stateid(state))
1336                 return 0;
1337         set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
1338         clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1339         set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
1340         set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
1341         return 1;
1342 }
1343
1344 int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
1345 {
1346         struct nfs_client *clp = server->nfs_client;
1347
1348         if (!nfs4_state_mark_reclaim_nograce(clp, state))
1349                 return -EBADF;
1350         dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
1351                         clp->cl_hostname);
1352         nfs4_schedule_state_manager(clp);
1353         return 0;
1354 }
1355 EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1356
1357 static struct nfs4_lock_state *
1358 nfs_state_find_lock_state_by_stateid(struct nfs4_state *state,
1359                 const nfs4_stateid *stateid)
1360 {
1361         struct nfs4_lock_state *pos;
1362
1363         list_for_each_entry(pos, &state->lock_states, ls_locks) {
1364                 if (!test_bit(NFS_LOCK_INITIALIZED, &pos->ls_flags))
1365                         continue;
1366                 if (nfs4_stateid_match_other(&pos->ls_stateid, stateid))
1367                         return pos;
1368         }
1369         return NULL;
1370 }
1371
1372 static bool nfs_state_lock_state_matches_stateid(struct nfs4_state *state,
1373                 const nfs4_stateid *stateid)
1374 {
1375         bool found = false;
1376
1377         if (test_bit(LK_STATE_IN_USE, &state->flags)) {
1378                 spin_lock(&state->state_lock);
1379                 if (nfs_state_find_lock_state_by_stateid(state, stateid))
1380                         found = true;
1381                 spin_unlock(&state->state_lock);
1382         }
1383         return found;
1384 }
1385
1386 void nfs_inode_find_state_and_recover(struct inode *inode,
1387                 const nfs4_stateid *stateid)
1388 {
1389         struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1390         struct nfs_inode *nfsi = NFS_I(inode);
1391         struct nfs_open_context *ctx;
1392         struct nfs4_state *state;
1393         bool found = false;
1394
1395         spin_lock(&inode->i_lock);
1396         list_for_each_entry(ctx, &nfsi->open_files, list) {
1397                 state = ctx->state;
1398                 if (state == NULL)
1399                         continue;
1400                 if (nfs4_stateid_match_other(&state->stateid, stateid) &&
1401                     nfs4_state_mark_reclaim_nograce(clp, state)) {
1402                         found = true;
1403                         continue;
1404                 }
1405                 if (nfs_state_lock_state_matches_stateid(state, stateid) &&
1406                     nfs4_state_mark_reclaim_nograce(clp, state))
1407                         found = true;
1408         }
1409         spin_unlock(&inode->i_lock);
1410
1411         nfs_inode_find_delegation_state_and_recover(inode, stateid);
1412         if (found)
1413                 nfs4_schedule_state_manager(clp);
1414 }
1415
1416 static void nfs4_state_mark_open_context_bad(struct nfs4_state *state)
1417 {
1418         struct inode *inode = state->inode;
1419         struct nfs_inode *nfsi = NFS_I(inode);
1420         struct nfs_open_context *ctx;
1421
1422         spin_lock(&inode->i_lock);
1423         list_for_each_entry(ctx, &nfsi->open_files, list) {
1424                 if (ctx->state != state)
1425                         continue;
1426                 set_bit(NFS_CONTEXT_BAD, &ctx->flags);
1427         }
1428         spin_unlock(&inode->i_lock);
1429 }
1430
1431 static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
1432 {
1433         set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags);
1434         nfs4_state_mark_open_context_bad(state);
1435 }
1436
1437
1438 static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
1439 {
1440         struct inode *inode = state->inode;
1441         struct nfs_inode *nfsi = NFS_I(inode);
1442         struct file_lock *fl;
1443         int status = 0;
1444         struct file_lock_context *flctx = inode->i_flctx;
1445         struct list_head *list;
1446
1447         if (flctx == NULL)
1448                 return 0;
1449
1450         list = &flctx->flc_posix;
1451
1452         /* Guard against delegation returns and new lock/unlock calls */
1453         down_write(&nfsi->rwsem);
1454         spin_lock(&flctx->flc_lock);
1455 restart:
1456         list_for_each_entry(fl, list, fl_list) {
1457                 if (nfs_file_open_context(fl->fl_file)->state != state)
1458                         continue;
1459                 spin_unlock(&flctx->flc_lock);
1460                 status = ops->recover_lock(state, fl);
1461                 switch (status) {
1462                 case 0:
1463                         break;
1464                 case -ESTALE:
1465                 case -NFS4ERR_ADMIN_REVOKED:
1466                 case -NFS4ERR_STALE_STATEID:
1467                 case -NFS4ERR_BAD_STATEID:
1468                 case -NFS4ERR_EXPIRED:
1469                 case -NFS4ERR_NO_GRACE:
1470                 case -NFS4ERR_STALE_CLIENTID:
1471                 case -NFS4ERR_BADSESSION:
1472                 case -NFS4ERR_BADSLOT:
1473                 case -NFS4ERR_BAD_HIGH_SLOT:
1474                 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1475                         goto out;
1476                 default:
1477                         pr_err("NFS: %s: unhandled error %d\n",
1478                                         __func__, status);
1479                 case -ENOMEM:
1480                 case -NFS4ERR_DENIED:
1481                 case -NFS4ERR_RECLAIM_BAD:
1482                 case -NFS4ERR_RECLAIM_CONFLICT:
1483                         /* kill_proc(fl->fl_pid, SIGLOST, 1); */
1484                         status = 0;
1485                 }
1486                 spin_lock(&flctx->flc_lock);
1487         }
1488         if (list == &flctx->flc_posix) {
1489                 list = &flctx->flc_flock;
1490                 goto restart;
1491         }
1492         spin_unlock(&flctx->flc_lock);
1493 out:
1494         up_write(&nfsi->rwsem);
1495         return status;
1496 }
1497
1498 static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
1499 {
1500         struct nfs4_state *state;
1501         struct nfs4_lock_state *lock;
1502         int status = 0;
1503
1504         /* Note: we rely on the sp->so_states list being ordered
1505          * so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
1506          * states first.
1507          * This is needed to ensure that the server won't give us any
1508          * read delegations that we have to return if, say, we are
1509          * recovering after a network partition or a reboot from a
1510          * server that doesn't support a grace period.
1511          */
1512         spin_lock(&sp->so_lock);
1513         raw_write_seqcount_begin(&sp->so_reclaim_seqcount);
1514 restart:
1515         list_for_each_entry(state, &sp->so_states, open_states) {
1516                 if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
1517                         continue;
1518                 if (!nfs4_valid_open_stateid(state))
1519                         continue;
1520                 if (state->state == 0)
1521                         continue;
1522                 atomic_inc(&state->count);
1523                 spin_unlock(&sp->so_lock);
1524                 status = ops->recover_open(sp, state);
1525                 if (status >= 0) {
1526                         status = nfs4_reclaim_locks(state, ops);
1527                         if (status >= 0) {
1528                                 if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
1529                                         spin_lock(&state->state_lock);
1530                                         list_for_each_entry(lock, &state->lock_states, ls_locks) {
1531                                                 if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
1532                                                         pr_warn_ratelimited("NFS: "
1533                                                                             "%s: Lock reclaim "
1534                                                                             "failed!\n", __func__);
1535                                         }
1536                                         spin_unlock(&state->state_lock);
1537                                 }
1538                                 clear_bit(NFS_STATE_RECLAIM_NOGRACE,
1539                                         &state->flags);
1540                                 nfs4_put_open_state(state);
1541                                 spin_lock(&sp->so_lock);
1542                                 goto restart;
1543                         }
1544                 }
1545                 switch (status) {
1546                         default:
1547                                 printk(KERN_ERR "NFS: %s: unhandled error %d\n",
1548                                         __func__, status);
1549                         case -ENOENT:
1550                         case -ENOMEM:
1551                         case -EACCES:
1552                         case -EROFS:
1553                         case -EIO:
1554                         case -ESTALE:
1555                                 /* Open state on this file cannot be recovered */
1556                                 nfs4_state_mark_recovery_failed(state, status);
1557                                 break;
1558                         case -EAGAIN:
1559                                 ssleep(1);
1560                         case -NFS4ERR_ADMIN_REVOKED:
1561                         case -NFS4ERR_STALE_STATEID:
1562                         case -NFS4ERR_OLD_STATEID:
1563                         case -NFS4ERR_BAD_STATEID:
1564                         case -NFS4ERR_RECLAIM_BAD:
1565                         case -NFS4ERR_RECLAIM_CONFLICT:
1566                                 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1567                                 break;
1568                         case -NFS4ERR_EXPIRED:
1569                         case -NFS4ERR_NO_GRACE:
1570                                 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1571                         case -NFS4ERR_STALE_CLIENTID:
1572                         case -NFS4ERR_BADSESSION:
1573                         case -NFS4ERR_BADSLOT:
1574                         case -NFS4ERR_BAD_HIGH_SLOT:
1575                         case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1576                                 goto out_err;
1577                 }
1578                 nfs4_put_open_state(state);
1579                 spin_lock(&sp->so_lock);
1580                 goto restart;
1581         }
1582         raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1583         spin_unlock(&sp->so_lock);
1584         return 0;
1585 out_err:
1586         nfs4_put_open_state(state);
1587         spin_lock(&sp->so_lock);
1588         raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1589         spin_unlock(&sp->so_lock);
1590         return status;
1591 }
1592
1593 static void nfs4_clear_open_state(struct nfs4_state *state)
1594 {
1595         struct nfs4_lock_state *lock;
1596
1597         clear_bit(NFS_DELEGATED_STATE, &state->flags);
1598         clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1599         clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1600         clear_bit(NFS_O_RDWR_STATE, &state->flags);
1601         spin_lock(&state->state_lock);
1602         list_for_each_entry(lock, &state->lock_states, ls_locks) {
1603                 lock->ls_seqid.flags = 0;
1604                 clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags);
1605         }
1606         spin_unlock(&state->state_lock);
1607 }
1608
1609 static void nfs4_reset_seqids(struct nfs_server *server,
1610         int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1611 {
1612         struct nfs_client *clp = server->nfs_client;
1613         struct nfs4_state_owner *sp;
1614         struct rb_node *pos;
1615         struct nfs4_state *state;
1616
1617         spin_lock(&clp->cl_lock);
1618         for (pos = rb_first(&server->state_owners);
1619              pos != NULL;
1620              pos = rb_next(pos)) {
1621                 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1622                 sp->so_seqid.flags = 0;
1623                 spin_lock(&sp->so_lock);
1624                 list_for_each_entry(state, &sp->so_states, open_states) {
1625                         if (mark_reclaim(clp, state))
1626                                 nfs4_clear_open_state(state);
1627                 }
1628                 spin_unlock(&sp->so_lock);
1629         }
1630         spin_unlock(&clp->cl_lock);
1631 }
1632
1633 static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
1634         int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1635 {
1636         struct nfs_server *server;
1637
1638         rcu_read_lock();
1639         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1640                 nfs4_reset_seqids(server, mark_reclaim);
1641         rcu_read_unlock();
1642 }
1643
1644 static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1645 {
1646         /* Mark all delegations for reclaim */
1647         nfs_delegation_mark_reclaim(clp);
1648         nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot);
1649 }
1650
1651 static void nfs4_reclaim_complete(struct nfs_client *clp,
1652                                  const struct nfs4_state_recovery_ops *ops,
1653                                  struct rpc_cred *cred)
1654 {
1655         /* Notify the server we're done reclaiming our state */
1656         if (ops->reclaim_complete)
1657                 (void)ops->reclaim_complete(clp, cred);
1658 }
1659
1660 static void nfs4_clear_reclaim_server(struct nfs_server *server)
1661 {
1662         struct nfs_client *clp = server->nfs_client;
1663         struct nfs4_state_owner *sp;
1664         struct rb_node *pos;
1665         struct nfs4_state *state;
1666
1667         spin_lock(&clp->cl_lock);
1668         for (pos = rb_first(&server->state_owners);
1669              pos != NULL;
1670              pos = rb_next(pos)) {
1671                 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1672                 spin_lock(&sp->so_lock);
1673                 list_for_each_entry(state, &sp->so_states, open_states) {
1674                         if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
1675                                                 &state->flags))
1676                                 continue;
1677                         nfs4_state_mark_reclaim_nograce(clp, state);
1678                 }
1679                 spin_unlock(&sp->so_lock);
1680         }
1681         spin_unlock(&clp->cl_lock);
1682 }
1683
1684 static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
1685 {
1686         struct nfs_server *server;
1687
1688         if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
1689                 return 0;
1690
1691         rcu_read_lock();
1692         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1693                 nfs4_clear_reclaim_server(server);
1694         rcu_read_unlock();
1695
1696         nfs_delegation_reap_unclaimed(clp);
1697         return 1;
1698 }
1699
1700 static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1701 {
1702         const struct nfs4_state_recovery_ops *ops;
1703         struct rpc_cred *cred;
1704
1705         if (!nfs4_state_clear_reclaim_reboot(clp))
1706                 return;
1707         ops = clp->cl_mvops->reboot_recovery_ops;
1708         cred = nfs4_get_clid_cred(clp);
1709         nfs4_reclaim_complete(clp, ops, cred);
1710         put_rpccred(cred);
1711 }
1712
1713 static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
1714 {
1715         nfs_mark_test_expired_all_delegations(clp);
1716         nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
1717 }
1718
1719 static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1720 {
1721         switch (error) {
1722                 case 0:
1723                         break;
1724                 case -NFS4ERR_CB_PATH_DOWN:
1725                         nfs40_handle_cb_pathdown(clp);
1726                         break;
1727                 case -NFS4ERR_NO_GRACE:
1728                         nfs4_state_end_reclaim_reboot(clp);
1729                         break;
1730                 case -NFS4ERR_STALE_CLIENTID:
1731                         set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1732                         nfs4_state_start_reclaim_reboot(clp);
1733                         break;
1734                 case -NFS4ERR_EXPIRED:
1735                         set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1736                         nfs4_state_start_reclaim_nograce(clp);
1737                         break;
1738                 case -NFS4ERR_BADSESSION:
1739                 case -NFS4ERR_BADSLOT:
1740                 case -NFS4ERR_BAD_HIGH_SLOT:
1741                 case -NFS4ERR_DEADSESSION:
1742                 case -NFS4ERR_SEQ_FALSE_RETRY:
1743                 case -NFS4ERR_SEQ_MISORDERED:
1744                         set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1745                         /* Zero session reset errors */
1746                         break;
1747                 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1748                         set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1749                         break;
1750                 default:
1751                         dprintk("%s: failed to handle error %d for server %s\n",
1752                                         __func__, error, clp->cl_hostname);
1753                         return error;
1754         }
1755         dprintk("%s: handled error %d for server %s\n", __func__, error,
1756                         clp->cl_hostname);
1757         return 0;
1758 }
1759
1760 static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
1761 {
1762         struct nfs4_state_owner *sp;
1763         struct nfs_server *server;
1764         struct rb_node *pos;
1765         int status = 0;
1766
1767 restart:
1768         rcu_read_lock();
1769         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1770                 nfs4_purge_state_owners(server);
1771                 spin_lock(&clp->cl_lock);
1772                 for (pos = rb_first(&server->state_owners);
1773                      pos != NULL;
1774                      pos = rb_next(pos)) {
1775                         sp = rb_entry(pos,
1776                                 struct nfs4_state_owner, so_server_node);
1777                         if (!test_and_clear_bit(ops->owner_flag_bit,
1778                                                         &sp->so_flags))
1779                                 continue;
1780                         if (!atomic_inc_not_zero(&sp->so_count))
1781                                 continue;
1782                         spin_unlock(&clp->cl_lock);
1783                         rcu_read_unlock();
1784
1785                         status = nfs4_reclaim_open_state(sp, ops);
1786                         if (status < 0) {
1787                                 set_bit(ops->owner_flag_bit, &sp->so_flags);
1788                                 nfs4_put_state_owner(sp);
1789                                 status = nfs4_recovery_handle_error(clp, status);
1790                                 return (status != 0) ? status : -EAGAIN;
1791                         }
1792
1793                         nfs4_put_state_owner(sp);
1794                         goto restart;
1795                 }
1796                 spin_unlock(&clp->cl_lock);
1797         }
1798         rcu_read_unlock();
1799         return 0;
1800 }
1801
1802 static int nfs4_check_lease(struct nfs_client *clp)
1803 {
1804         struct rpc_cred *cred;
1805         const struct nfs4_state_maintenance_ops *ops =
1806                 clp->cl_mvops->state_renewal_ops;
1807         int status;
1808
1809         /* Is the client already known to have an expired lease? */
1810         if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1811                 return 0;
1812         spin_lock(&clp->cl_lock);
1813         cred = ops->get_state_renewal_cred_locked(clp);
1814         spin_unlock(&clp->cl_lock);
1815         if (cred == NULL) {
1816                 cred = nfs4_get_clid_cred(clp);
1817                 status = -ENOKEY;
1818                 if (cred == NULL)
1819                         goto out;
1820         }
1821         status = ops->renew_lease(clp, cred);
1822         put_rpccred(cred);
1823         if (status == -ETIMEDOUT) {
1824                 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1825                 return 0;
1826         }
1827 out:
1828         return nfs4_recovery_handle_error(clp, status);
1829 }
1830
1831 /* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
1832  * and for recoverable errors on EXCHANGE_ID for v4.1
1833  */
1834 static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
1835 {
1836         switch (status) {
1837         case -NFS4ERR_SEQ_MISORDERED:
1838                 if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state))
1839                         return -ESERVERFAULT;
1840                 /* Lease confirmation error: retry after purging the lease */
1841                 ssleep(1);
1842                 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1843                 break;
1844         case -NFS4ERR_STALE_CLIENTID:
1845                 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1846                 nfs4_state_start_reclaim_reboot(clp);
1847                 break;
1848         case -NFS4ERR_CLID_INUSE:
1849                 pr_err("NFS: Server %s reports our clientid is in use\n",
1850                         clp->cl_hostname);
1851                 nfs_mark_client_ready(clp, -EPERM);
1852                 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1853                 return -EPERM;
1854         case -EACCES:
1855         case -NFS4ERR_DELAY:
1856         case -ETIMEDOUT:
1857         case -EAGAIN:
1858                 ssleep(1);
1859                 break;
1860
1861         case -NFS4ERR_MINOR_VERS_MISMATCH:
1862                 if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
1863                         nfs_mark_client_ready(clp, -EPROTONOSUPPORT);
1864                 dprintk("%s: exit with error %d for server %s\n",
1865                                 __func__, -EPROTONOSUPPORT, clp->cl_hostname);
1866                 return -EPROTONOSUPPORT;
1867         case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
1868                                  * in nfs4_exchange_id */
1869         default:
1870                 dprintk("%s: exit with error %d for server %s\n", __func__,
1871                                 status, clp->cl_hostname);
1872                 return status;
1873         }
1874         set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1875         dprintk("%s: handled error %d for server %s\n", __func__, status,
1876                         clp->cl_hostname);
1877         return 0;
1878 }
1879
1880 static int nfs4_establish_lease(struct nfs_client *clp)
1881 {
1882         struct rpc_cred *cred;
1883         const struct nfs4_state_recovery_ops *ops =
1884                 clp->cl_mvops->reboot_recovery_ops;
1885         int status;
1886
1887         nfs4_begin_drain_session(clp);
1888         cred = nfs4_get_clid_cred(clp);
1889         if (cred == NULL)
1890                 return -ENOENT;
1891         status = ops->establish_clid(clp, cred);
1892         put_rpccred(cred);
1893         if (status != 0)
1894                 return status;
1895         pnfs_destroy_all_layouts(clp);
1896         return 0;
1897 }
1898
1899 /*
1900  * Returns zero or a negative errno.  NFS4ERR values are converted
1901  * to local errno values.
1902  */
1903 static int nfs4_reclaim_lease(struct nfs_client *clp)
1904 {
1905         int status;
1906
1907         status = nfs4_establish_lease(clp);
1908         if (status < 0)
1909                 return nfs4_handle_reclaim_lease_error(clp, status);
1910         if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state))
1911                 nfs4_state_start_reclaim_nograce(clp);
1912         if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
1913                 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1914         clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1915         clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1916         return 0;
1917 }
1918
1919 static int nfs4_purge_lease(struct nfs_client *clp)
1920 {
1921         int status;
1922
1923         status = nfs4_establish_lease(clp);
1924         if (status < 0)
1925                 return nfs4_handle_reclaim_lease_error(clp, status);
1926         clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
1927         set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1928         nfs4_state_start_reclaim_nograce(clp);
1929         return 0;
1930 }
1931
1932 /*
1933  * Try remote migration of one FSID from a source server to a
1934  * destination server.  The source server provides a list of
1935  * potential destinations.
1936  *
1937  * Returns zero or a negative NFS4ERR status code.
1938  */
1939 static int nfs4_try_migration(struct nfs_server *server, struct rpc_cred *cred)
1940 {
1941         struct nfs_client *clp = server->nfs_client;
1942         struct nfs4_fs_locations *locations = NULL;
1943         struct inode *inode;
1944         struct page *page;
1945         int status, result;
1946
1947         dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__,
1948                         (unsigned long long)server->fsid.major,
1949                         (unsigned long long)server->fsid.minor,
1950                         clp->cl_hostname);
1951
1952         result = 0;
1953         page = alloc_page(GFP_KERNEL);
1954         locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
1955         if (page == NULL || locations == NULL) {
1956                 dprintk("<-- %s: no memory\n", __func__);
1957                 goto out;
1958         }
1959
1960         inode = d_inode(server->super->s_root);
1961         result = nfs4_proc_get_locations(inode, locations, page, cred);
1962         if (result) {
1963                 dprintk("<-- %s: failed to retrieve fs_locations: %d\n",
1964                         __func__, result);
1965                 goto out;
1966         }
1967
1968         result = -NFS4ERR_NXIO;
1969         if (!(locations->fattr.valid & NFS_ATTR_FATTR_V4_LOCATIONS)) {
1970                 dprintk("<-- %s: No fs_locations data, migration skipped\n",
1971                         __func__);
1972                 goto out;
1973         }
1974
1975         nfs4_begin_drain_session(clp);
1976
1977         status = nfs4_replace_transport(server, locations);
1978         if (status != 0) {
1979                 dprintk("<-- %s: failed to replace transport: %d\n",
1980                         __func__, status);
1981                 goto out;
1982         }
1983
1984         result = 0;
1985         dprintk("<-- %s: migration succeeded\n", __func__);
1986
1987 out:
1988         if (page != NULL)
1989                 __free_page(page);
1990         kfree(locations);
1991         if (result) {
1992                 pr_err("NFS: migration recovery failed (server %s)\n",
1993                                 clp->cl_hostname);
1994                 set_bit(NFS_MIG_FAILED, &server->mig_status);
1995         }
1996         return result;
1997 }
1998
1999 /*
2000  * Returns zero or a negative NFS4ERR status code.
2001  */
2002 static int nfs4_handle_migration(struct nfs_client *clp)
2003 {
2004         const struct nfs4_state_maintenance_ops *ops =
2005                                 clp->cl_mvops->state_renewal_ops;
2006         struct nfs_server *server;
2007         struct rpc_cred *cred;
2008
2009         dprintk("%s: migration reported on \"%s\"\n", __func__,
2010                         clp->cl_hostname);
2011
2012         spin_lock(&clp->cl_lock);
2013         cred = ops->get_state_renewal_cred_locked(clp);
2014         spin_unlock(&clp->cl_lock);
2015         if (cred == NULL)
2016                 return -NFS4ERR_NOENT;
2017
2018         clp->cl_mig_gen++;
2019 restart:
2020         rcu_read_lock();
2021         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2022                 int status;
2023
2024                 if (server->mig_gen == clp->cl_mig_gen)
2025                         continue;
2026                 server->mig_gen = clp->cl_mig_gen;
2027
2028                 if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION,
2029                                                 &server->mig_status))
2030                         continue;
2031
2032                 rcu_read_unlock();
2033                 status = nfs4_try_migration(server, cred);
2034                 if (status < 0) {
2035                         put_rpccred(cred);
2036                         return status;
2037                 }
2038                 goto restart;
2039         }
2040         rcu_read_unlock();
2041         put_rpccred(cred);
2042         return 0;
2043 }
2044
2045 /*
2046  * Test each nfs_server on the clp's cl_superblocks list to see
2047  * if it's moved to another server.  Stop when the server no longer
2048  * returns NFS4ERR_LEASE_MOVED.
2049  */
2050 static int nfs4_handle_lease_moved(struct nfs_client *clp)
2051 {
2052         const struct nfs4_state_maintenance_ops *ops =
2053                                 clp->cl_mvops->state_renewal_ops;
2054         struct nfs_server *server;
2055         struct rpc_cred *cred;
2056
2057         dprintk("%s: lease moved reported on \"%s\"\n", __func__,
2058                         clp->cl_hostname);
2059
2060         spin_lock(&clp->cl_lock);
2061         cred = ops->get_state_renewal_cred_locked(clp);
2062         spin_unlock(&clp->cl_lock);
2063         if (cred == NULL)
2064                 return -NFS4ERR_NOENT;
2065
2066         clp->cl_mig_gen++;
2067 restart:
2068         rcu_read_lock();
2069         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2070                 struct inode *inode;
2071                 int status;
2072
2073                 if (server->mig_gen == clp->cl_mig_gen)
2074                         continue;
2075                 server->mig_gen = clp->cl_mig_gen;
2076
2077                 rcu_read_unlock();
2078
2079                 inode = d_inode(server->super->s_root);
2080                 status = nfs4_proc_fsid_present(inode, cred);
2081                 if (status != -NFS4ERR_MOVED)
2082                         goto restart;   /* wasn't this one */
2083                 if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED)
2084                         goto restart;   /* there are more */
2085                 goto out;
2086         }
2087         rcu_read_unlock();
2088
2089 out:
2090         put_rpccred(cred);
2091         return 0;
2092 }
2093
2094 /**
2095  * nfs4_discover_server_trunking - Detect server IP address trunking
2096  *
2097  * @clp: nfs_client under test
2098  * @result: OUT: found nfs_client, or clp
2099  *
2100  * Returns zero or a negative errno.  If zero is returned,
2101  * an nfs_client pointer is planted in "result".
2102  *
2103  * Note: since we are invoked in process context, and
2104  * not from inside the state manager, we cannot use
2105  * nfs4_handle_reclaim_lease_error().
2106  */
2107 int nfs4_discover_server_trunking(struct nfs_client *clp,
2108                                   struct nfs_client **result)
2109 {
2110         const struct nfs4_state_recovery_ops *ops =
2111                                 clp->cl_mvops->reboot_recovery_ops;
2112         struct rpc_clnt *clnt;
2113         struct rpc_cred *cred;
2114         int i, status;
2115
2116         dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);
2117
2118         clnt = clp->cl_rpcclient;
2119         i = 0;
2120
2121         mutex_lock(&nfs_clid_init_mutex);
2122 again:
2123         status  = -ENOENT;
2124         cred = nfs4_get_clid_cred(clp);
2125         if (cred == NULL)
2126                 goto out_unlock;
2127
2128         status = ops->detect_trunking(clp, result, cred);
2129         put_rpccred(cred);
2130         switch (status) {
2131         case 0:
2132                 break;
2133         case -ETIMEDOUT:
2134                 if (clnt->cl_softrtry)
2135                         break;
2136         case -NFS4ERR_DELAY:
2137         case -EAGAIN:
2138                 ssleep(1);
2139         case -NFS4ERR_STALE_CLIENTID:
2140                 dprintk("NFS: %s after status %d, retrying\n",
2141                         __func__, status);
2142                 goto again;
2143         case -EACCES:
2144                 if (i++ == 0) {
2145                         nfs4_root_machine_cred(clp);
2146                         goto again;
2147                 }
2148                 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX)
2149                         break;
2150         case -NFS4ERR_CLID_INUSE:
2151         case -NFS4ERR_WRONGSEC:
2152                 /* No point in retrying if we already used RPC_AUTH_UNIX */
2153                 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) {
2154                         status = -EPERM;
2155                         break;
2156                 }
2157                 clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX);
2158                 if (IS_ERR(clnt)) {
2159                         status = PTR_ERR(clnt);
2160                         break;
2161                 }
2162                 /* Note: this is safe because we haven't yet marked the
2163                  * client as ready, so we are the only user of
2164                  * clp->cl_rpcclient
2165                  */
2166                 clnt = xchg(&clp->cl_rpcclient, clnt);
2167                 rpc_shutdown_client(clnt);
2168                 clnt = clp->cl_rpcclient;
2169                 goto again;
2170
2171         case -NFS4ERR_MINOR_VERS_MISMATCH:
2172                 status = -EPROTONOSUPPORT;
2173                 break;
2174
2175         case -EKEYEXPIRED:
2176         case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2177                                  * in nfs4_exchange_id */
2178                 status = -EKEYEXPIRED;
2179                 break;
2180         default:
2181                 pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
2182                                 __func__, status);
2183                 status = -EIO;
2184         }
2185
2186 out_unlock:
2187         mutex_unlock(&nfs_clid_init_mutex);
2188         dprintk("NFS: %s: status = %d\n", __func__, status);
2189         return status;
2190 }
2191
2192 #ifdef CONFIG_NFS_V4_1
2193 void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
2194 {
2195         struct nfs_client *clp = session->clp;
2196
2197         switch (err) {
2198         default:
2199                 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2200                 break;
2201         case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
2202                 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2203         }
2204         nfs4_schedule_state_manager(clp);
2205 }
2206 EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
2207
2208 void nfs41_notify_server(struct nfs_client *clp)
2209 {
2210         /* Use CHECK_LEASE to ping the server with a SEQUENCE */
2211         set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
2212         nfs4_schedule_state_manager(clp);
2213 }
2214
2215 static void nfs4_reset_all_state(struct nfs_client *clp)
2216 {
2217         if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2218                 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
2219                 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
2220                 nfs4_state_start_reclaim_nograce(clp);
2221                 dprintk("%s: scheduling reset of all state for server %s!\n",
2222                                 __func__, clp->cl_hostname);
2223                 nfs4_schedule_state_manager(clp);
2224         }
2225 }
2226
2227 static void nfs41_handle_server_reboot(struct nfs_client *clp)
2228 {
2229         if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2230                 nfs4_state_start_reclaim_reboot(clp);
2231                 dprintk("%s: server %s rebooted!\n", __func__,
2232                                 clp->cl_hostname);
2233                 nfs4_schedule_state_manager(clp);
2234         }
2235 }
2236
2237 static void nfs41_handle_all_state_revoked(struct nfs_client *clp)
2238 {
2239         nfs4_reset_all_state(clp);
2240         dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2241 }
2242
2243 static void nfs41_handle_some_state_revoked(struct nfs_client *clp)
2244 {
2245         nfs4_state_start_reclaim_nograce(clp);
2246         nfs4_schedule_state_manager(clp);
2247
2248         dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2249 }
2250
2251 static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
2252 {
2253         /* FIXME: For now, we destroy all layouts. */
2254         pnfs_destroy_all_layouts(clp);
2255         /* FIXME: For now, we test all delegations+open state+locks. */
2256         nfs41_handle_some_state_revoked(clp);
2257         dprintk("%s: Recallable state revoked on server %s!\n", __func__,
2258                         clp->cl_hostname);
2259 }
2260
2261 static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
2262 {
2263         set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2264         nfs4_schedule_state_manager(clp);
2265
2266         dprintk("%s: server %s declared a backchannel fault\n", __func__,
2267                         clp->cl_hostname);
2268 }
2269
2270 static void nfs41_handle_cb_path_down(struct nfs_client *clp)
2271 {
2272         if (test_and_set_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2273                 &clp->cl_state) == 0)
2274                 nfs4_schedule_state_manager(clp);
2275 }
2276
2277 void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags,
2278                 bool recovery)
2279 {
2280         if (!flags)
2281                 return;
2282
2283         dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
2284                 __func__, clp->cl_hostname, clp->cl_clientid, flags);
2285         /*
2286          * If we're called from the state manager thread, then assume we're
2287          * already handling the RECLAIM_NEEDED and/or STATE_REVOKED.
2288          * Those flags are expected to remain set until we're done
2289          * recovering (see RFC5661, section 18.46.3).
2290          */
2291         if (recovery)
2292                 goto out_recovery;
2293
2294         if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
2295                 nfs41_handle_server_reboot(clp);
2296         if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED))
2297                 nfs41_handle_all_state_revoked(clp);
2298         if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
2299                             SEQ4_STATUS_ADMIN_STATE_REVOKED))
2300                 nfs41_handle_some_state_revoked(clp);
2301         if (flags & SEQ4_STATUS_LEASE_MOVED)
2302                 nfs4_schedule_lease_moved_recovery(clp);
2303         if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
2304                 nfs41_handle_recallable_state_revoked(clp);
2305 out_recovery:
2306         if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT)
2307                 nfs41_handle_backchannel_fault(clp);
2308         else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
2309                                 SEQ4_STATUS_CB_PATH_DOWN_SESSION))
2310                 nfs41_handle_cb_path_down(clp);
2311 }
2312
2313 static int nfs4_reset_session(struct nfs_client *clp)
2314 {
2315         struct rpc_cred *cred;
2316         int status;
2317
2318         if (!nfs4_has_session(clp))
2319                 return 0;
2320         nfs4_begin_drain_session(clp);
2321         cred = nfs4_get_clid_cred(clp);
2322         status = nfs4_proc_destroy_session(clp->cl_session, cred);
2323         switch (status) {
2324         case 0:
2325         case -NFS4ERR_BADSESSION:
2326         case -NFS4ERR_DEADSESSION:
2327                 break;
2328         case -NFS4ERR_BACK_CHAN_BUSY:
2329         case -NFS4ERR_DELAY:
2330                 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2331                 status = 0;
2332                 ssleep(1);
2333                 goto out;
2334         default:
2335                 status = nfs4_recovery_handle_error(clp, status);
2336                 goto out;
2337         }
2338
2339         memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
2340         status = nfs4_proc_create_session(clp, cred);
2341         if (status) {
2342                 dprintk("%s: session reset failed with status %d for server %s!\n",
2343                         __func__, status, clp->cl_hostname);
2344                 status = nfs4_handle_reclaim_lease_error(clp, status);
2345                 goto out;
2346         }
2347         nfs41_finish_session_reset(clp);
2348         dprintk("%s: session reset was successful for server %s!\n",
2349                         __func__, clp->cl_hostname);
2350 out:
2351         if (cred)
2352                 put_rpccred(cred);
2353         return status;
2354 }
2355
2356 static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2357 {
2358         struct rpc_cred *cred;
2359         int ret;
2360
2361         if (!nfs4_has_session(clp))
2362                 return 0;
2363         nfs4_begin_drain_session(clp);
2364         cred = nfs4_get_clid_cred(clp);
2365         ret = nfs4_proc_bind_conn_to_session(clp, cred);
2366         if (cred)
2367                 put_rpccred(cred);
2368         clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2369         switch (ret) {
2370         case 0:
2371                 dprintk("%s: bind_conn_to_session was successful for server %s!\n",
2372                         __func__, clp->cl_hostname);
2373                 break;
2374         case -NFS4ERR_DELAY:
2375                 ssleep(1);
2376                 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2377                 break;
2378         default:
2379                 return nfs4_recovery_handle_error(clp, ret);
2380         }
2381         return 0;
2382 }
2383 #else /* CONFIG_NFS_V4_1 */
2384 static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
2385
2386 static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2387 {
2388         return 0;
2389 }
2390 #endif /* CONFIG_NFS_V4_1 */
2391
2392 static void nfs4_state_manager(struct nfs_client *clp)
2393 {
2394         int status = 0;
2395         const char *section = "", *section_sep = "";
2396
2397         /* Ensure exclusive access to NFSv4 state */
2398         do {
2399                 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2400                         section = "purge state";
2401                         status = nfs4_purge_lease(clp);
2402                         if (status < 0)
2403                                 goto out_error;
2404                         continue;
2405                 }
2406
2407                 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
2408                         section = "lease expired";
2409                         /* We're going to have to re-establish a clientid */
2410                         status = nfs4_reclaim_lease(clp);
2411                         if (status < 0)
2412                                 goto out_error;
2413                         continue;
2414                 }
2415
2416                 /* Initialize or reset the session */
2417                 if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) {
2418                         section = "reset session";
2419                         status = nfs4_reset_session(clp);
2420                         if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
2421                                 continue;
2422                         if (status < 0)
2423                                 goto out_error;
2424                 }
2425
2426                 /* Send BIND_CONN_TO_SESSION */
2427                 if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2428                                 &clp->cl_state)) {
2429                         section = "bind conn to session";
2430                         status = nfs4_bind_conn_to_session(clp);
2431                         if (status < 0)
2432                                 goto out_error;
2433                         continue;
2434                 }
2435
2436                 if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
2437                         section = "check lease";
2438                         status = nfs4_check_lease(clp);
2439                         if (status < 0)
2440                                 goto out_error;
2441                         continue;
2442                 }
2443
2444                 if (test_and_clear_bit(NFS4CLNT_MOVED, &clp->cl_state)) {
2445                         section = "migration";
2446                         status = nfs4_handle_migration(clp);
2447                         if (status < 0)
2448                                 goto out_error;
2449                 }
2450
2451                 if (test_and_clear_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state)) {
2452                         section = "lease moved";
2453                         status = nfs4_handle_lease_moved(clp);
2454                         if (status < 0)
2455                                 goto out_error;
2456                 }
2457
2458                 /* First recover reboot state... */
2459                 if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
2460                         section = "reclaim reboot";
2461                         status = nfs4_do_reclaim(clp,
2462                                 clp->cl_mvops->reboot_recovery_ops);
2463                         if (status == -EAGAIN)
2464                                 continue;
2465                         if (status < 0)
2466                                 goto out_error;
2467                         nfs4_state_end_reclaim_reboot(clp);
2468                 }
2469
2470                 /* Detect expired delegations... */
2471                 if (test_and_clear_bit(NFS4CLNT_DELEGATION_EXPIRED, &clp->cl_state)) {
2472                         section = "detect expired delegations";
2473                         nfs_reap_expired_delegations(clp);
2474                         continue;
2475                 }
2476
2477                 /* Now recover expired state... */
2478                 if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
2479                         section = "reclaim nograce";
2480                         status = nfs4_do_reclaim(clp,
2481                                 clp->cl_mvops->nograce_recovery_ops);
2482                         if (status == -EAGAIN)
2483                                 continue;
2484                         if (status < 0)
2485                                 goto out_error;
2486                 }
2487
2488                 nfs4_end_drain_session(clp);
2489                 if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
2490                         nfs_client_return_marked_delegations(clp);
2491                         continue;
2492                 }
2493
2494                 nfs4_clear_state_manager_bit(clp);
2495                 /* Did we race with an attempt to give us more work? */
2496                 if (clp->cl_state == 0)
2497                         break;
2498                 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
2499                         break;
2500         } while (atomic_read(&clp->cl_count) > 1);
2501         return;
2502 out_error:
2503         if (strlen(section))
2504                 section_sep = ": ";
2505         pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
2506                         " with error %d\n", section_sep, section,
2507                         clp->cl_hostname, -status);
2508         ssleep(1);
2509         nfs4_end_drain_session(clp);
2510         nfs4_clear_state_manager_bit(clp);
2511 }
2512
2513 static int nfs4_run_state_manager(void *ptr)
2514 {
2515         struct nfs_client *clp = ptr;
2516
2517         allow_signal(SIGKILL);
2518         nfs4_state_manager(clp);
2519         nfs_put_client(clp);
2520         module_put_and_exit(0);
2521         return 0;
2522 }
2523
2524 /*
2525  * Local variables:
2526  *  c-basic-offset: 8
2527  * End:
2528  */