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