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