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