fs/nfs/nfs4state.c

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