linux/fs/nfs/nfs4state.c
<<
>>
Prefs
   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/nfs_idmap.h>
  46#include <linux/kthread.h>
  47#include <linux/module.h>
  48#include <linux/random.h>
  49#include <linux/ratelimit.h>
  50#include <linux/workqueue.h>
  51#include <linux/bitops.h>
  52#include <linux/jiffies.h>
  53
  54#include "nfs4_fs.h"
  55#include "callback.h"
  56#include "delegation.h"
  57#include "internal.h"
  58#include "pnfs.h"
  59
  60#define NFSDBG_FACILITY         NFSDBG_STATE
  61
  62#define OPENOWNER_POOL_SIZE     8
  63
  64const nfs4_stateid zero_stateid;
  65
  66static LIST_HEAD(nfs4_clientid_list);
  67
  68int nfs4_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
  69{
  70        struct nfs4_setclientid_res clid = {
  71                .clientid = clp->cl_clientid,
  72                .confirm = clp->cl_confirm,
  73        };
  74        unsigned short port;
  75        int status;
  76
  77        if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
  78                goto do_confirm;
  79        port = nfs_callback_tcpport;
  80        if (clp->cl_addr.ss_family == AF_INET6)
  81                port = nfs_callback_tcpport6;
  82
  83        status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
  84        if (status != 0)
  85                goto out;
  86        clp->cl_clientid = clid.clientid;
  87        clp->cl_confirm = clid.confirm;
  88        set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
  89do_confirm:
  90        status = nfs4_proc_setclientid_confirm(clp, &clid, cred);
  91        if (status != 0)
  92                goto out;
  93        clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
  94        nfs4_schedule_state_renewal(clp);
  95out:
  96        return status;
  97}
  98
  99struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp)
 100{
 101        struct rpc_cred *cred = NULL;
 102
 103        if (clp->cl_machine_cred != NULL)
 104                cred = get_rpccred(clp->cl_machine_cred);
 105        return cred;
 106}
 107
 108static void nfs4_clear_machine_cred(struct nfs_client *clp)
 109{
 110        struct rpc_cred *cred;
 111
 112        spin_lock(&clp->cl_lock);
 113        cred = clp->cl_machine_cred;
 114        clp->cl_machine_cred = NULL;
 115        spin_unlock(&clp->cl_lock);
 116        if (cred != NULL)
 117                put_rpccred(cred);
 118}
 119
 120static struct rpc_cred *
 121nfs4_get_renew_cred_server_locked(struct nfs_server *server)
 122{
 123        struct rpc_cred *cred = NULL;
 124        struct nfs4_state_owner *sp;
 125        struct rb_node *pos;
 126
 127        for (pos = rb_first(&server->state_owners);
 128             pos != NULL;
 129             pos = rb_next(pos)) {
 130                sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
 131                if (list_empty(&sp->so_states))
 132                        continue;
 133                cred = get_rpccred(sp->so_cred);
 134                break;
 135        }
 136        return cred;
 137}
 138
 139/**
 140 * nfs4_get_renew_cred_locked - Acquire credential for a renew operation
 141 * @clp: client state handle
 142 *
 143 * Returns an rpc_cred with reference count bumped, or NULL.
 144 * Caller must hold clp->cl_lock.
 145 */
 146struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp)
 147{
 148        struct rpc_cred *cred = NULL;
 149        struct nfs_server *server;
 150
 151        /* Use machine credentials if available */
 152        cred = nfs4_get_machine_cred_locked(clp);
 153        if (cred != NULL)
 154                goto out;
 155
 156        rcu_read_lock();
 157        list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 158                cred = nfs4_get_renew_cred_server_locked(server);
 159                if (cred != NULL)
 160                        break;
 161        }
 162        rcu_read_unlock();
 163
 164out:
 165        return cred;
 166}
 167
 168#if defined(CONFIG_NFS_V4_1)
 169
 170static int nfs41_setup_state_renewal(struct nfs_client *clp)
 171{
 172        int status;
 173        struct nfs_fsinfo fsinfo;
 174
 175        if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
 176                nfs4_schedule_state_renewal(clp);
 177                return 0;
 178        }
 179
 180        status = nfs4_proc_get_lease_time(clp, &fsinfo);
 181        if (status == 0) {
 182                /* Update lease time and schedule renewal */
 183                spin_lock(&clp->cl_lock);
 184                clp->cl_lease_time = fsinfo.lease_time * HZ;
 185                clp->cl_last_renewal = jiffies;
 186                spin_unlock(&clp->cl_lock);
 187
 188                nfs4_schedule_state_renewal(clp);
 189        }
 190
 191        return status;
 192}
 193
 194/*
 195 * Back channel returns NFS4ERR_DELAY for new requests when
 196 * NFS4_SESSION_DRAINING is set so there is no work to be done when draining
 197 * is ended.
 198 */
 199static void nfs4_end_drain_session(struct nfs_client *clp)
 200{
 201        struct nfs4_session *ses = clp->cl_session;
 202        struct nfs4_slot_table *tbl;
 203        int max_slots;
 204
 205        if (ses == NULL)
 206                return;
 207        tbl = &ses->fc_slot_table;
 208        if (test_and_clear_bit(NFS4_SESSION_DRAINING, &ses->session_state)) {
 209                spin_lock(&tbl->slot_tbl_lock);
 210                max_slots = tbl->max_slots;
 211                while (max_slots--) {
 212                        if (rpc_wake_up_first(&tbl->slot_tbl_waitq,
 213                                                nfs4_set_task_privileged,
 214                                                NULL) == NULL)
 215                                break;
 216                }
 217                spin_unlock(&tbl->slot_tbl_lock);
 218        }
 219}
 220
 221static int nfs4_wait_on_slot_tbl(struct nfs4_slot_table *tbl)
 222{
 223        spin_lock(&tbl->slot_tbl_lock);
 224        if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
 225                INIT_COMPLETION(tbl->complete);
 226                spin_unlock(&tbl->slot_tbl_lock);
 227                return wait_for_completion_interruptible(&tbl->complete);
 228        }
 229        spin_unlock(&tbl->slot_tbl_lock);
 230        return 0;
 231}
 232
 233static int nfs4_begin_drain_session(struct nfs_client *clp)
 234{
 235        struct nfs4_session *ses = clp->cl_session;
 236        int ret = 0;
 237
 238        set_bit(NFS4_SESSION_DRAINING, &ses->session_state);
 239        /* back channel */
 240        ret = nfs4_wait_on_slot_tbl(&ses->bc_slot_table);
 241        if (ret)
 242                return ret;
 243        /* fore channel */
 244        return nfs4_wait_on_slot_tbl(&ses->fc_slot_table);
 245}
 246
 247static void nfs41_finish_session_reset(struct nfs_client *clp)
 248{
 249        clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
 250        clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
 251        /* create_session negotiated new slot table */
 252        clear_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state);
 253        clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
 254        nfs41_setup_state_renewal(clp);
 255}
 256
 257int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
 258{
 259        int status;
 260
 261        if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
 262                goto do_confirm;
 263        nfs4_begin_drain_session(clp);
 264        status = nfs4_proc_exchange_id(clp, cred);
 265        if (status != 0)
 266                goto out;
 267        set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
 268do_confirm:
 269        status = nfs4_proc_create_session(clp, cred);
 270        if (status != 0)
 271                goto out;
 272        nfs41_finish_session_reset(clp);
 273        nfs_mark_client_ready(clp, NFS_CS_READY);
 274out:
 275        return status;
 276}
 277
 278struct rpc_cred *nfs4_get_exchange_id_cred(struct nfs_client *clp)
 279{
 280        struct rpc_cred *cred;
 281
 282        spin_lock(&clp->cl_lock);
 283        cred = nfs4_get_machine_cred_locked(clp);
 284        spin_unlock(&clp->cl_lock);
 285        return cred;
 286}
 287
 288#endif /* CONFIG_NFS_V4_1 */
 289
 290static struct rpc_cred *
 291nfs4_get_setclientid_cred_server(struct nfs_server *server)
 292{
 293        struct nfs_client *clp = server->nfs_client;
 294        struct rpc_cred *cred = NULL;
 295        struct nfs4_state_owner *sp;
 296        struct rb_node *pos;
 297
 298        spin_lock(&clp->cl_lock);
 299        pos = rb_first(&server->state_owners);
 300        if (pos != NULL) {
 301                sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
 302                cred = get_rpccred(sp->so_cred);
 303        }
 304        spin_unlock(&clp->cl_lock);
 305        return cred;
 306}
 307
 308/**
 309 * nfs4_get_setclientid_cred - Acquire credential for a setclientid operation
 310 * @clp: client state handle
 311 *
 312 * Returns an rpc_cred with reference count bumped, or NULL.
 313 */
 314struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp)
 315{
 316        struct nfs_server *server;
 317        struct rpc_cred *cred;
 318
 319        spin_lock(&clp->cl_lock);
 320        cred = nfs4_get_machine_cred_locked(clp);
 321        spin_unlock(&clp->cl_lock);
 322        if (cred != NULL)
 323                goto out;
 324
 325        rcu_read_lock();
 326        list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 327                cred = nfs4_get_setclientid_cred_server(server);
 328                if (cred != NULL)
 329                        break;
 330        }
 331        rcu_read_unlock();
 332
 333out:
 334        return cred;
 335}
 336
 337static struct nfs4_state_owner *
 338nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred)
 339{
 340        struct rb_node **p = &server->state_owners.rb_node,
 341                       *parent = NULL;
 342        struct nfs4_state_owner *sp;
 343
 344        while (*p != NULL) {
 345                parent = *p;
 346                sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
 347
 348                if (cred < sp->so_cred)
 349                        p = &parent->rb_left;
 350                else if (cred > sp->so_cred)
 351                        p = &parent->rb_right;
 352                else {
 353                        if (!list_empty(&sp->so_lru))
 354                                list_del_init(&sp->so_lru);
 355                        atomic_inc(&sp->so_count);
 356                        return sp;
 357                }
 358        }
 359        return NULL;
 360}
 361
 362static struct nfs4_state_owner *
 363nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
 364{
 365        struct nfs_server *server = new->so_server;
 366        struct rb_node **p = &server->state_owners.rb_node,
 367                       *parent = NULL;
 368        struct nfs4_state_owner *sp;
 369        int err;
 370
 371        while (*p != NULL) {
 372                parent = *p;
 373                sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
 374
 375                if (new->so_cred < sp->so_cred)
 376                        p = &parent->rb_left;
 377                else if (new->so_cred > sp->so_cred)
 378                        p = &parent->rb_right;
 379                else {
 380                        if (!list_empty(&sp->so_lru))
 381                                list_del_init(&sp->so_lru);
 382                        atomic_inc(&sp->so_count);
 383                        return sp;
 384                }
 385        }
 386        err = ida_get_new(&server->openowner_id, &new->so_seqid.owner_id);
 387        if (err)
 388                return ERR_PTR(err);
 389        rb_link_node(&new->so_server_node, parent, p);
 390        rb_insert_color(&new->so_server_node, &server->state_owners);
 391        return new;
 392}
 393
 394static void
 395nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
 396{
 397        struct nfs_server *server = sp->so_server;
 398
 399        if (!RB_EMPTY_NODE(&sp->so_server_node))
 400                rb_erase(&sp->so_server_node, &server->state_owners);
 401        ida_remove(&server->openowner_id, sp->so_seqid.owner_id);
 402}
 403
 404static void
 405nfs4_init_seqid_counter(struct nfs_seqid_counter *sc)
 406{
 407        sc->create_time = ktime_get();
 408        sc->flags = 0;
 409        sc->counter = 0;
 410        spin_lock_init(&sc->lock);
 411        INIT_LIST_HEAD(&sc->list);
 412        rpc_init_wait_queue(&sc->wait, "Seqid_waitqueue");
 413}
 414
 415static void
 416nfs4_destroy_seqid_counter(struct nfs_seqid_counter *sc)
 417{
 418        rpc_destroy_wait_queue(&sc->wait);
 419}
 420
 421/*
 422 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
 423 * create a new state_owner.
 424 *
 425 */
 426static struct nfs4_state_owner *
 427nfs4_alloc_state_owner(struct nfs_server *server,
 428                struct rpc_cred *cred,
 429                gfp_t gfp_flags)
 430{
 431        struct nfs4_state_owner *sp;
 432
 433        sp = kzalloc(sizeof(*sp), gfp_flags);
 434        if (!sp)
 435                return NULL;
 436        sp->so_server = server;
 437        sp->so_cred = get_rpccred(cred);
 438        spin_lock_init(&sp->so_lock);
 439        INIT_LIST_HEAD(&sp->so_states);
 440        nfs4_init_seqid_counter(&sp->so_seqid);
 441        atomic_set(&sp->so_count, 1);
 442        INIT_LIST_HEAD(&sp->so_lru);
 443        return sp;
 444}
 445
 446static void
 447nfs4_drop_state_owner(struct nfs4_state_owner *sp)
 448{
 449        struct rb_node *rb_node = &sp->so_server_node;
 450
 451        if (!RB_EMPTY_NODE(rb_node)) {
 452                struct nfs_server *server = sp->so_server;
 453                struct nfs_client *clp = server->nfs_client;
 454
 455                spin_lock(&clp->cl_lock);
 456                if (!RB_EMPTY_NODE(rb_node)) {
 457                        rb_erase(rb_node, &server->state_owners);
 458                        RB_CLEAR_NODE(rb_node);
 459                }
 460                spin_unlock(&clp->cl_lock);
 461        }
 462}
 463
 464static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
 465{
 466        nfs4_destroy_seqid_counter(&sp->so_seqid);
 467        put_rpccred(sp->so_cred);
 468        kfree(sp);
 469}
 470
 471static void nfs4_gc_state_owners(struct nfs_server *server)
 472{
 473        struct nfs_client *clp = server->nfs_client;
 474        struct nfs4_state_owner *sp, *tmp;
 475        unsigned long time_min, time_max;
 476        LIST_HEAD(doomed);
 477
 478        spin_lock(&clp->cl_lock);
 479        time_max = jiffies;
 480        time_min = (long)time_max - (long)clp->cl_lease_time;
 481        list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
 482                /* NB: LRU is sorted so that oldest is at the head */
 483                if (time_in_range(sp->so_expires, time_min, time_max))
 484                        break;
 485                list_move(&sp->so_lru, &doomed);
 486                nfs4_remove_state_owner_locked(sp);
 487        }
 488        spin_unlock(&clp->cl_lock);
 489
 490        list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
 491                list_del(&sp->so_lru);
 492                nfs4_free_state_owner(sp);
 493        }
 494}
 495
 496/**
 497 * nfs4_get_state_owner - Look up a state owner given a credential
 498 * @server: nfs_server to search
 499 * @cred: RPC credential to match
 500 *
 501 * Returns a pointer to an instantiated nfs4_state_owner struct, or NULL.
 502 */
 503struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,
 504                                              struct rpc_cred *cred,
 505                                              gfp_t gfp_flags)
 506{
 507        struct nfs_client *clp = server->nfs_client;
 508        struct nfs4_state_owner *sp, *new;
 509
 510        spin_lock(&clp->cl_lock);
 511        sp = nfs4_find_state_owner_locked(server, cred);
 512        spin_unlock(&clp->cl_lock);
 513        if (sp != NULL)
 514                goto out;
 515        new = nfs4_alloc_state_owner(server, cred, gfp_flags);
 516        if (new == NULL)
 517                goto out;
 518        do {
 519                if (ida_pre_get(&server->openowner_id, gfp_flags) == 0)
 520                        break;
 521                spin_lock(&clp->cl_lock);
 522                sp = nfs4_insert_state_owner_locked(new);
 523                spin_unlock(&clp->cl_lock);
 524        } while (sp == ERR_PTR(-EAGAIN));
 525        if (sp != new)
 526                nfs4_free_state_owner(new);
 527out:
 528        nfs4_gc_state_owners(server);
 529        return sp;
 530}
 531
 532/**
 533 * nfs4_put_state_owner - Release a nfs4_state_owner
 534 * @sp: state owner data to release
 535 *
 536 * Note that we keep released state owners on an LRU
 537 * list.
 538 * This caches valid state owners so that they can be
 539 * reused, to avoid the OPEN_CONFIRM on minor version 0.
 540 * It also pins the uniquifier of dropped state owners for
 541 * a while, to ensure that those state owner names are
 542 * never reused.
 543 */
 544void nfs4_put_state_owner(struct nfs4_state_owner *sp)
 545{
 546        struct nfs_server *server = sp->so_server;
 547        struct nfs_client *clp = server->nfs_client;
 548
 549        if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
 550                return;
 551
 552        sp->so_expires = jiffies;
 553        list_add_tail(&sp->so_lru, &server->state_owners_lru);
 554        spin_unlock(&clp->cl_lock);
 555}
 556
 557/**
 558 * nfs4_purge_state_owners - Release all cached state owners
 559 * @server: nfs_server with cached state owners to release
 560 *
 561 * Called at umount time.  Remaining state owners will be on
 562 * the LRU with ref count of zero.
 563 */
 564void nfs4_purge_state_owners(struct nfs_server *server)
 565{
 566        struct nfs_client *clp = server->nfs_client;
 567        struct nfs4_state_owner *sp, *tmp;
 568        LIST_HEAD(doomed);
 569
 570        spin_lock(&clp->cl_lock);
 571        list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
 572                list_move(&sp->so_lru, &doomed);
 573                nfs4_remove_state_owner_locked(sp);
 574        }
 575        spin_unlock(&clp->cl_lock);
 576
 577        list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
 578                list_del(&sp->so_lru);
 579                nfs4_free_state_owner(sp);
 580        }
 581}
 582
 583static struct nfs4_state *
 584nfs4_alloc_open_state(void)
 585{
 586        struct nfs4_state *state;
 587
 588        state = kzalloc(sizeof(*state), GFP_NOFS);
 589        if (!state)
 590                return NULL;
 591        atomic_set(&state->count, 1);
 592        INIT_LIST_HEAD(&state->lock_states);
 593        spin_lock_init(&state->state_lock);
 594        seqlock_init(&state->seqlock);
 595        return state;
 596}
 597
 598void
 599nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
 600{
 601        if (state->state == fmode)
 602                return;
 603        /* NB! List reordering - see the reclaim code for why.  */
 604        if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
 605                if (fmode & FMODE_WRITE)
 606                        list_move(&state->open_states, &state->owner->so_states);
 607                else
 608                        list_move_tail(&state->open_states, &state->owner->so_states);
 609        }
 610        state->state = fmode;
 611}
 612
 613static struct nfs4_state *
 614__nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
 615{
 616        struct nfs_inode *nfsi = NFS_I(inode);
 617        struct nfs4_state *state;
 618
 619        list_for_each_entry(state, &nfsi->open_states, inode_states) {
 620                if (state->owner != owner)
 621                        continue;
 622                if (atomic_inc_not_zero(&state->count))
 623                        return state;
 624        }
 625        return NULL;
 626}
 627
 628static void
 629nfs4_free_open_state(struct nfs4_state *state)
 630{
 631        kfree(state);
 632}
 633
 634struct nfs4_state *
 635nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner)
 636{
 637        struct nfs4_state *state, *new;
 638        struct nfs_inode *nfsi = NFS_I(inode);
 639
 640        spin_lock(&inode->i_lock);
 641        state = __nfs4_find_state_byowner(inode, owner);
 642        spin_unlock(&inode->i_lock);
 643        if (state)
 644                goto out;
 645        new = nfs4_alloc_open_state();
 646        spin_lock(&owner->so_lock);
 647        spin_lock(&inode->i_lock);
 648        state = __nfs4_find_state_byowner(inode, owner);
 649        if (state == NULL && new != NULL) {
 650                state = new;
 651                state->owner = owner;
 652                atomic_inc(&owner->so_count);
 653                list_add(&state->inode_states, &nfsi->open_states);
 654                ihold(inode);
 655                state->inode = inode;
 656                spin_unlock(&inode->i_lock);
 657                /* Note: The reclaim code dictates that we add stateless
 658                 * and read-only stateids to the end of the list */
 659                list_add_tail(&state->open_states, &owner->so_states);
 660                spin_unlock(&owner->so_lock);
 661        } else {
 662                spin_unlock(&inode->i_lock);
 663                spin_unlock(&owner->so_lock);
 664                if (new)
 665                        nfs4_free_open_state(new);
 666        }
 667out:
 668        return state;
 669}
 670
 671void nfs4_put_open_state(struct nfs4_state *state)
 672{
 673        struct inode *inode = state->inode;
 674        struct nfs4_state_owner *owner = state->owner;
 675
 676        if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
 677                return;
 678        spin_lock(&inode->i_lock);
 679        list_del(&state->inode_states);
 680        list_del(&state->open_states);
 681        spin_unlock(&inode->i_lock);
 682        spin_unlock(&owner->so_lock);
 683        iput(inode);
 684        nfs4_free_open_state(state);
 685        nfs4_put_state_owner(owner);
 686}
 687
 688/*
 689 * Close the current file.
 690 */
 691static void __nfs4_close(struct nfs4_state *state,
 692                fmode_t fmode, gfp_t gfp_mask, int wait)
 693{
 694        struct nfs4_state_owner *owner = state->owner;
 695        int call_close = 0;
 696        fmode_t newstate;
 697
 698        atomic_inc(&owner->so_count);
 699        /* Protect against nfs4_find_state() */
 700        spin_lock(&owner->so_lock);
 701        switch (fmode & (FMODE_READ | FMODE_WRITE)) {
 702                case FMODE_READ:
 703                        state->n_rdonly--;
 704                        break;
 705                case FMODE_WRITE:
 706                        state->n_wronly--;
 707                        break;
 708                case FMODE_READ|FMODE_WRITE:
 709                        state->n_rdwr--;
 710        }
 711        newstate = FMODE_READ|FMODE_WRITE;
 712        if (state->n_rdwr == 0) {
 713                if (state->n_rdonly == 0) {
 714                        newstate &= ~FMODE_READ;
 715                        call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
 716                        call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
 717                }
 718                if (state->n_wronly == 0) {
 719                        newstate &= ~FMODE_WRITE;
 720                        call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
 721                        call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
 722                }
 723                if (newstate == 0)
 724                        clear_bit(NFS_DELEGATED_STATE, &state->flags);
 725        }
 726        nfs4_state_set_mode_locked(state, newstate);
 727        spin_unlock(&owner->so_lock);
 728
 729        if (!call_close) {
 730                nfs4_put_open_state(state);
 731                nfs4_put_state_owner(owner);
 732        } else {
 733                bool roc = pnfs_roc(state->inode);
 734
 735                nfs4_do_close(state, gfp_mask, wait, roc);
 736        }
 737}
 738
 739void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
 740{
 741        __nfs4_close(state, fmode, GFP_NOFS, 0);
 742}
 743
 744void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
 745{
 746        __nfs4_close(state, fmode, GFP_KERNEL, 1);
 747}
 748
 749/*
 750 * Search the state->lock_states for an existing lock_owner
 751 * that is compatible with current->files
 752 */
 753static struct nfs4_lock_state *
 754__nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type)
 755{
 756        struct nfs4_lock_state *pos;
 757        list_for_each_entry(pos, &state->lock_states, ls_locks) {
 758                if (type != NFS4_ANY_LOCK_TYPE && pos->ls_owner.lo_type != type)
 759                        continue;
 760                switch (pos->ls_owner.lo_type) {
 761                case NFS4_POSIX_LOCK_TYPE:
 762                        if (pos->ls_owner.lo_u.posix_owner != fl_owner)
 763                                continue;
 764                        break;
 765                case NFS4_FLOCK_LOCK_TYPE:
 766                        if (pos->ls_owner.lo_u.flock_owner != fl_pid)
 767                                continue;
 768                }
 769                atomic_inc(&pos->ls_count);
 770                return pos;
 771        }
 772        return NULL;
 773}
 774
 775/*
 776 * Return a compatible lock_state. If no initialized lock_state structure
 777 * exists, return an uninitialized one.
 778 *
 779 */
 780static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type)
 781{
 782        struct nfs4_lock_state *lsp;
 783        struct nfs_server *server = state->owner->so_server;
 784
 785        lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
 786        if (lsp == NULL)
 787                return NULL;
 788        nfs4_init_seqid_counter(&lsp->ls_seqid);
 789        atomic_set(&lsp->ls_count, 1);
 790        lsp->ls_state = state;
 791        lsp->ls_owner.lo_type = type;
 792        switch (lsp->ls_owner.lo_type) {
 793        case NFS4_FLOCK_LOCK_TYPE:
 794                lsp->ls_owner.lo_u.flock_owner = fl_pid;
 795                break;
 796        case NFS4_POSIX_LOCK_TYPE:
 797                lsp->ls_owner.lo_u.posix_owner = fl_owner;
 798                break;
 799        default:
 800                goto out_free;
 801        }
 802        lsp->ls_seqid.owner_id = ida_simple_get(&server->lockowner_id, 0, 0, GFP_NOFS);
 803        if (lsp->ls_seqid.owner_id < 0)
 804                goto out_free;
 805        INIT_LIST_HEAD(&lsp->ls_locks);
 806        return lsp;
 807out_free:
 808        kfree(lsp);
 809        return NULL;
 810}
 811
 812void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
 813{
 814        ida_simple_remove(&server->lockowner_id, lsp->ls_seqid.owner_id);
 815        nfs4_destroy_seqid_counter(&lsp->ls_seqid);
 816        kfree(lsp);
 817}
 818
 819/*
 820 * Return a compatible lock_state. If no initialized lock_state structure
 821 * exists, return an uninitialized one.
 822 *
 823 */
 824static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner, pid_t pid, unsigned int type)
 825{
 826        struct nfs4_lock_state *lsp, *new = NULL;
 827        
 828        for(;;) {
 829                spin_lock(&state->state_lock);
 830                lsp = __nfs4_find_lock_state(state, owner, pid, type);
 831                if (lsp != NULL)
 832                        break;
 833                if (new != NULL) {
 834                        list_add(&new->ls_locks, &state->lock_states);
 835                        set_bit(LK_STATE_IN_USE, &state->flags);
 836                        lsp = new;
 837                        new = NULL;
 838                        break;
 839                }
 840                spin_unlock(&state->state_lock);
 841                new = nfs4_alloc_lock_state(state, owner, pid, type);
 842                if (new == NULL)
 843                        return NULL;
 844        }
 845        spin_unlock(&state->state_lock);
 846        if (new != NULL)
 847                nfs4_free_lock_state(state->owner->so_server, new);
 848        return lsp;
 849}
 850
 851/*
 852 * Release reference to lock_state, and free it if we see that
 853 * it is no longer in use
 854 */
 855void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
 856{
 857        struct nfs4_state *state;
 858
 859        if (lsp == NULL)
 860                return;
 861        state = lsp->ls_state;
 862        if (!atomic_dec_and_lock(&lsp->ls_count, &state->state_lock))
 863                return;
 864        list_del(&lsp->ls_locks);
 865        if (list_empty(&state->lock_states))
 866                clear_bit(LK_STATE_IN_USE, &state->flags);
 867        spin_unlock(&state->state_lock);
 868        if (lsp->ls_flags & NFS_LOCK_INITIALIZED) {
 869                if (nfs4_release_lockowner(lsp) == 0)
 870                        return;
 871        }
 872        nfs4_free_lock_state(lsp->ls_state->owner->so_server, lsp);
 873}
 874
 875static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
 876{
 877        struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
 878
 879        dst->fl_u.nfs4_fl.owner = lsp;
 880        atomic_inc(&lsp->ls_count);
 881}
 882
 883static void nfs4_fl_release_lock(struct file_lock *fl)
 884{
 885        nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
 886}
 887
 888static const struct file_lock_operations nfs4_fl_lock_ops = {
 889        .fl_copy_lock = nfs4_fl_copy_lock,
 890        .fl_release_private = nfs4_fl_release_lock,
 891};
 892
 893int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
 894{
 895        struct nfs4_lock_state *lsp;
 896
 897        if (fl->fl_ops != NULL)
 898                return 0;
 899        if (fl->fl_flags & FL_POSIX)
 900                lsp = nfs4_get_lock_state(state, fl->fl_owner, 0, NFS4_POSIX_LOCK_TYPE);
 901        else if (fl->fl_flags & FL_FLOCK)
 902                lsp = nfs4_get_lock_state(state, NULL, fl->fl_pid,
 903                                NFS4_FLOCK_LOCK_TYPE);
 904        else
 905                return -EINVAL;
 906        if (lsp == NULL)
 907                return -ENOMEM;
 908        fl->fl_u.nfs4_fl.owner = lsp;
 909        fl->fl_ops = &nfs4_fl_lock_ops;
 910        return 0;
 911}
 912
 913static bool nfs4_copy_lock_stateid(nfs4_stateid *dst, struct nfs4_state *state,
 914                fl_owner_t fl_owner, pid_t fl_pid)
 915{
 916        struct nfs4_lock_state *lsp;
 917        bool ret = false;
 918
 919        if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
 920                goto out;
 921
 922        spin_lock(&state->state_lock);
 923        lsp = __nfs4_find_lock_state(state, fl_owner, fl_pid, NFS4_ANY_LOCK_TYPE);
 924        if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0) {
 925                nfs4_stateid_copy(dst, &lsp->ls_stateid);
 926                ret = true;
 927        }
 928        spin_unlock(&state->state_lock);
 929        nfs4_put_lock_state(lsp);
 930out:
 931        return ret;
 932}
 933
 934static void nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
 935{
 936        int seq;
 937
 938        do {
 939                seq = read_seqbegin(&state->seqlock);
 940                nfs4_stateid_copy(dst, &state->stateid);
 941        } while (read_seqretry(&state->seqlock, seq));
 942}
 943
 944/*
 945 * Byte-range lock aware utility to initialize the stateid of read/write
 946 * requests.
 947 */
 948void nfs4_select_rw_stateid(nfs4_stateid *dst, struct nfs4_state *state,
 949                fmode_t fmode, fl_owner_t fl_owner, pid_t fl_pid)
 950{
 951        if (nfs4_copy_delegation_stateid(dst, state->inode, fmode))
 952                return;
 953        if (nfs4_copy_lock_stateid(dst, state, fl_owner, fl_pid))
 954                return;
 955        nfs4_copy_open_stateid(dst, state);
 956}
 957
 958struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
 959{
 960        struct nfs_seqid *new;
 961
 962        new = kmalloc(sizeof(*new), gfp_mask);
 963        if (new != NULL) {
 964                new->sequence = counter;
 965                INIT_LIST_HEAD(&new->list);
 966                new->task = NULL;
 967        }
 968        return new;
 969}
 970
 971void nfs_release_seqid(struct nfs_seqid *seqid)
 972{
 973        struct nfs_seqid_counter *sequence;
 974
 975        if (list_empty(&seqid->list))
 976                return;
 977        sequence = seqid->sequence;
 978        spin_lock(&sequence->lock);
 979        list_del_init(&seqid->list);
 980        if (!list_empty(&sequence->list)) {
 981                struct nfs_seqid *next;
 982
 983                next = list_first_entry(&sequence->list,
 984                                struct nfs_seqid, list);
 985                rpc_wake_up_queued_task(&sequence->wait, next->task);
 986        }
 987        spin_unlock(&sequence->lock);
 988}
 989
 990void nfs_free_seqid(struct nfs_seqid *seqid)
 991{
 992        nfs_release_seqid(seqid);
 993        kfree(seqid);
 994}
 995
 996/*
 997 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
 998 * failed with a seqid incrementing error -
 999 * see comments nfs_fs.h:seqid_mutating_error()
1000 */
1001static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
1002{
1003        BUG_ON(list_first_entry(&seqid->sequence->list, struct nfs_seqid, list) != seqid);
1004        switch (status) {
1005                case 0:
1006                        break;
1007                case -NFS4ERR_BAD_SEQID:
1008                        if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
1009                                return;
1010                        pr_warn_ratelimited("NFS: v4 server returned a bad"
1011                                        " sequence-id error on an"
1012                                        " unconfirmed sequence %p!\n",
1013                                        seqid->sequence);
1014                case -NFS4ERR_STALE_CLIENTID:
1015                case -NFS4ERR_STALE_STATEID:
1016                case -NFS4ERR_BAD_STATEID:
1017                case -NFS4ERR_BADXDR:
1018                case -NFS4ERR_RESOURCE:
1019                case -NFS4ERR_NOFILEHANDLE:
1020                        /* Non-seqid mutating errors */
1021                        return;
1022        };
1023        /*
1024         * Note: no locking needed as we are guaranteed to be first
1025         * on the sequence list
1026         */
1027        seqid->sequence->counter++;
1028}
1029
1030void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
1031{
1032        struct nfs4_state_owner *sp = container_of(seqid->sequence,
1033                                        struct nfs4_state_owner, so_seqid);
1034        struct nfs_server *server = sp->so_server;
1035
1036        if (status == -NFS4ERR_BAD_SEQID)
1037                nfs4_drop_state_owner(sp);
1038        if (!nfs4_has_session(server->nfs_client))
1039                nfs_increment_seqid(status, seqid);
1040}
1041
1042/*
1043 * Increment the seqid if the LOCK/LOCKU succeeded, or
1044 * failed with a seqid incrementing error -
1045 * see comments nfs_fs.h:seqid_mutating_error()
1046 */
1047void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
1048{
1049        nfs_increment_seqid(status, seqid);
1050}
1051
1052int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
1053{
1054        struct nfs_seqid_counter *sequence = seqid->sequence;
1055        int status = 0;
1056
1057        spin_lock(&sequence->lock);
1058        seqid->task = task;
1059        if (list_empty(&seqid->list))
1060                list_add_tail(&seqid->list, &sequence->list);
1061        if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid)
1062                goto unlock;
1063        rpc_sleep_on(&sequence->wait, task, NULL);
1064        status = -EAGAIN;
1065unlock:
1066        spin_unlock(&sequence->lock);
1067        return status;
1068}
1069
1070static int nfs4_run_state_manager(void *);
1071
1072static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
1073{
1074        smp_mb__before_clear_bit();
1075        clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
1076        smp_mb__after_clear_bit();
1077        wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
1078        rpc_wake_up(&clp->cl_rpcwaitq);
1079}
1080
1081/*
1082 * Schedule the nfs_client asynchronous state management routine
1083 */
1084void nfs4_schedule_state_manager(struct nfs_client *clp)
1085{
1086        struct task_struct *task;
1087        char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
1088
1089        if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
1090                return;
1091        __module_get(THIS_MODULE);
1092        atomic_inc(&clp->cl_count);
1093
1094        /* The rcu_read_lock() is not strictly necessary, as the state
1095         * manager is the only thread that ever changes the rpc_xprt
1096         * after it's initialized.  At this point, we're single threaded. */
1097        rcu_read_lock();
1098        snprintf(buf, sizeof(buf), "%s-manager",
1099                        rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
1100        rcu_read_unlock();
1101        task = kthread_run(nfs4_run_state_manager, clp, buf);
1102        if (IS_ERR(task)) {
1103                printk(KERN_ERR "%s: kthread_run: %ld\n",
1104                        __func__, PTR_ERR(task));
1105                nfs4_clear_state_manager_bit(clp);
1106                nfs_put_client(clp);
1107                module_put(THIS_MODULE);
1108        }
1109}
1110
1111/*
1112 * Schedule a lease recovery attempt
1113 */
1114void nfs4_schedule_lease_recovery(struct nfs_client *clp)
1115{
1116        if (!clp)
1117                return;
1118        if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1119                set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1120        dprintk("%s: scheduling lease recovery for server %s\n", __func__,
1121                        clp->cl_hostname);
1122        nfs4_schedule_state_manager(clp);
1123}
1124EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
1125
1126/*
1127 * nfs40_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN
1128 * @clp: client to process
1129 *
1130 * Set the NFS4CLNT_LEASE_EXPIRED state in order to force a
1131 * resend of the SETCLIENTID and hence re-establish the
1132 * callback channel. Then return all existing delegations.
1133 */
1134static void nfs40_handle_cb_pathdown(struct nfs_client *clp)
1135{
1136        set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1137        nfs_expire_all_delegations(clp);
1138        dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
1139                        clp->cl_hostname);
1140}
1141
1142void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
1143{
1144        nfs40_handle_cb_pathdown(clp);
1145        nfs4_schedule_state_manager(clp);
1146}
1147
1148static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1149{
1150
1151        set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1152        /* Don't recover state that expired before the reboot */
1153        if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) {
1154                clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1155                return 0;
1156        }
1157        set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
1158        set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1159        return 1;
1160}
1161
1162static int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1163{
1164        set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
1165        clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1166        set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
1167        set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
1168        return 1;
1169}
1170
1171void nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
1172{
1173        struct nfs_client *clp = server->nfs_client;
1174
1175        nfs4_state_mark_reclaim_nograce(clp, state);
1176        dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
1177                        clp->cl_hostname);
1178        nfs4_schedule_state_manager(clp);
1179}
1180EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1181
1182void nfs_inode_find_state_and_recover(struct inode *inode,
1183                const nfs4_stateid *stateid)
1184{
1185        struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1186        struct nfs_inode *nfsi = NFS_I(inode);
1187        struct nfs_open_context *ctx;
1188        struct nfs4_state *state;
1189        bool found = false;
1190
1191        spin_lock(&inode->i_lock);
1192        list_for_each_entry(ctx, &nfsi->open_files, list) {
1193                state = ctx->state;
1194                if (state == NULL)
1195                        continue;
1196                if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
1197                        continue;
1198                if (!nfs4_stateid_match(&state->stateid, stateid))
1199                        continue;
1200                nfs4_state_mark_reclaim_nograce(clp, state);
1201                found = true;
1202        }
1203        spin_unlock(&inode->i_lock);
1204        if (found)
1205                nfs4_schedule_state_manager(clp);
1206}
1207
1208
1209static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
1210{
1211        struct inode *inode = state->inode;
1212        struct nfs_inode *nfsi = NFS_I(inode);
1213        struct file_lock *fl;
1214        int status = 0;
1215
1216        if (inode->i_flock == NULL)
1217                return 0;
1218
1219        /* Guard against delegation returns and new lock/unlock calls */
1220        down_write(&nfsi->rwsem);
1221        /* Protect inode->i_flock using the BKL */
1222        lock_flocks();
1223        for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
1224                if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
1225                        continue;
1226                if (nfs_file_open_context(fl->fl_file)->state != state)
1227                        continue;
1228                unlock_flocks();
1229                status = ops->recover_lock(state, fl);
1230                switch (status) {
1231                        case 0:
1232                                break;
1233                        case -ESTALE:
1234                        case -NFS4ERR_ADMIN_REVOKED:
1235                        case -NFS4ERR_STALE_STATEID:
1236                        case -NFS4ERR_BAD_STATEID:
1237                        case -NFS4ERR_EXPIRED:
1238                        case -NFS4ERR_NO_GRACE:
1239                        case -NFS4ERR_STALE_CLIENTID:
1240                        case -NFS4ERR_BADSESSION:
1241                        case -NFS4ERR_BADSLOT:
1242                        case -NFS4ERR_BAD_HIGH_SLOT:
1243                        case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1244                                goto out;
1245                        default:
1246                                printk(KERN_ERR "NFS: %s: unhandled error %d. "
1247                                        "Zeroing state\n", __func__, status);
1248                        case -ENOMEM:
1249                        case -NFS4ERR_DENIED:
1250                        case -NFS4ERR_RECLAIM_BAD:
1251                        case -NFS4ERR_RECLAIM_CONFLICT:
1252                                /* kill_proc(fl->fl_pid, SIGLOST, 1); */
1253                                status = 0;
1254                }
1255                lock_flocks();
1256        }
1257        unlock_flocks();
1258out:
1259        up_write(&nfsi->rwsem);
1260        return status;
1261}
1262
1263static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
1264{
1265        struct nfs4_state *state;
1266        struct nfs4_lock_state *lock;
1267        int status = 0;
1268
1269        /* Note: we rely on the sp->so_states list being ordered 
1270         * so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
1271         * states first.
1272         * This is needed to ensure that the server won't give us any
1273         * read delegations that we have to return if, say, we are
1274         * recovering after a network partition or a reboot from a
1275         * server that doesn't support a grace period.
1276         */
1277restart:
1278        spin_lock(&sp->so_lock);
1279        list_for_each_entry(state, &sp->so_states, open_states) {
1280                if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
1281                        continue;
1282                if (state->state == 0)
1283                        continue;
1284                atomic_inc(&state->count);
1285                spin_unlock(&sp->so_lock);
1286                status = ops->recover_open(sp, state);
1287                if (status >= 0) {
1288                        status = nfs4_reclaim_locks(state, ops);
1289                        if (status >= 0) {
1290                                spin_lock(&state->state_lock);
1291                                list_for_each_entry(lock, &state->lock_states, ls_locks) {
1292                                        if (!(lock->ls_flags & NFS_LOCK_INITIALIZED))
1293                                                pr_warn_ratelimited("NFS: "
1294                                                        "%s: Lock reclaim "
1295                                                        "failed!\n", __func__);
1296                                }
1297                                spin_unlock(&state->state_lock);
1298                                nfs4_put_open_state(state);
1299                                goto restart;
1300                        }
1301                }
1302                switch (status) {
1303                        default:
1304                                printk(KERN_ERR "NFS: %s: unhandled error %d. "
1305                                        "Zeroing state\n", __func__, status);
1306                        case -ENOENT:
1307                        case -ENOMEM:
1308                        case -ESTALE:
1309                                /*
1310                                 * Open state on this file cannot be recovered
1311                                 * All we can do is revert to using the zero stateid.
1312                                 */
1313                                memset(&state->stateid, 0,
1314                                        sizeof(state->stateid));
1315                                /* Mark the file as being 'closed' */
1316                                state->state = 0;
1317                                break;
1318                        case -EKEYEXPIRED:
1319                                /*
1320                                 * User RPCSEC_GSS context has expired.
1321                                 * We cannot recover this stateid now, so
1322                                 * skip it and allow recovery thread to
1323                                 * proceed.
1324                                 */
1325                                break;
1326                        case -NFS4ERR_ADMIN_REVOKED:
1327                        case -NFS4ERR_STALE_STATEID:
1328                        case -NFS4ERR_BAD_STATEID:
1329                        case -NFS4ERR_RECLAIM_BAD:
1330                        case -NFS4ERR_RECLAIM_CONFLICT:
1331                                nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1332                                break;
1333                        case -NFS4ERR_EXPIRED:
1334                        case -NFS4ERR_NO_GRACE:
1335                                nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1336                        case -NFS4ERR_STALE_CLIENTID:
1337                        case -NFS4ERR_BADSESSION:
1338                        case -NFS4ERR_BADSLOT:
1339                        case -NFS4ERR_BAD_HIGH_SLOT:
1340                        case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1341                                goto out_err;
1342                }
1343                nfs4_put_open_state(state);
1344                goto restart;
1345        }
1346        spin_unlock(&sp->so_lock);
1347        return 0;
1348out_err:
1349        nfs4_put_open_state(state);
1350        return status;
1351}
1352
1353static void nfs4_clear_open_state(struct nfs4_state *state)
1354{
1355        struct nfs4_lock_state *lock;
1356
1357        clear_bit(NFS_DELEGATED_STATE, &state->flags);
1358        clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1359        clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1360        clear_bit(NFS_O_RDWR_STATE, &state->flags);
1361        spin_lock(&state->state_lock);
1362        list_for_each_entry(lock, &state->lock_states, ls_locks) {
1363                lock->ls_seqid.flags = 0;
1364                lock->ls_flags &= ~NFS_LOCK_INITIALIZED;
1365        }
1366        spin_unlock(&state->state_lock);
1367}
1368
1369static void nfs4_reset_seqids(struct nfs_server *server,
1370        int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1371{
1372        struct nfs_client *clp = server->nfs_client;
1373        struct nfs4_state_owner *sp;
1374        struct rb_node *pos;
1375        struct nfs4_state *state;
1376
1377        spin_lock(&clp->cl_lock);
1378        for (pos = rb_first(&server->state_owners);
1379             pos != NULL;
1380             pos = rb_next(pos)) {
1381                sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1382                sp->so_seqid.flags = 0;
1383                spin_lock(&sp->so_lock);
1384                list_for_each_entry(state, &sp->so_states, open_states) {
1385                        if (mark_reclaim(clp, state))
1386                                nfs4_clear_open_state(state);
1387                }
1388                spin_unlock(&sp->so_lock);
1389        }
1390        spin_unlock(&clp->cl_lock);
1391}
1392
1393static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
1394        int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1395{
1396        struct nfs_server *server;
1397
1398        rcu_read_lock();
1399        list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1400                nfs4_reset_seqids(server, mark_reclaim);
1401        rcu_read_unlock();
1402}
1403
1404static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1405{
1406        /* Mark all delegations for reclaim */
1407        nfs_delegation_mark_reclaim(clp);
1408        nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot);
1409}
1410
1411static void nfs4_reclaim_complete(struct nfs_client *clp,
1412                                 const struct nfs4_state_recovery_ops *ops)
1413{
1414        /* Notify the server we're done reclaiming our state */
1415        if (ops->reclaim_complete)
1416                (void)ops->reclaim_complete(clp);
1417}
1418
1419static void nfs4_clear_reclaim_server(struct nfs_server *server)
1420{
1421        struct nfs_client *clp = server->nfs_client;
1422        struct nfs4_state_owner *sp;
1423        struct rb_node *pos;
1424        struct nfs4_state *state;
1425
1426        spin_lock(&clp->cl_lock);
1427        for (pos = rb_first(&server->state_owners);
1428             pos != NULL;
1429             pos = rb_next(pos)) {
1430                sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1431                spin_lock(&sp->so_lock);
1432                list_for_each_entry(state, &sp->so_states, open_states) {
1433                        if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
1434                                                &state->flags))
1435                                continue;
1436                        nfs4_state_mark_reclaim_nograce(clp, state);
1437                }
1438                spin_unlock(&sp->so_lock);
1439        }
1440        spin_unlock(&clp->cl_lock);
1441}
1442
1443static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
1444{
1445        struct nfs_server *server;
1446
1447        if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
1448                return 0;
1449
1450        rcu_read_lock();
1451        list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1452                nfs4_clear_reclaim_server(server);
1453        rcu_read_unlock();
1454
1455        nfs_delegation_reap_unclaimed(clp);
1456        return 1;
1457}
1458
1459static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1460{
1461        if (!nfs4_state_clear_reclaim_reboot(clp))
1462                return;
1463        nfs4_reclaim_complete(clp, clp->cl_mvops->reboot_recovery_ops);
1464}
1465
1466static void nfs_delegation_clear_all(struct nfs_client *clp)
1467{
1468        nfs_delegation_mark_reclaim(clp);
1469        nfs_delegation_reap_unclaimed(clp);
1470}
1471
1472static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
1473{
1474        nfs_delegation_clear_all(clp);
1475        nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
1476}
1477
1478static void nfs4_warn_keyexpired(const char *s)
1479{
1480        printk_ratelimited(KERN_WARNING "Error: state manager"
1481                        " encountered RPCSEC_GSS session"
1482                        " expired against NFSv4 server %s.\n",
1483                        s);
1484}
1485
1486static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1487{
1488        switch (error) {
1489                case 0:
1490                        break;
1491                case -NFS4ERR_CB_PATH_DOWN:
1492                        nfs40_handle_cb_pathdown(clp);
1493                        break;
1494                case -NFS4ERR_NO_GRACE:
1495                        nfs4_state_end_reclaim_reboot(clp);
1496                        break;
1497                case -NFS4ERR_STALE_CLIENTID:
1498                case -NFS4ERR_LEASE_MOVED:
1499                        set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1500                        nfs4_state_clear_reclaim_reboot(clp);
1501                        nfs4_state_start_reclaim_reboot(clp);
1502                        break;
1503                case -NFS4ERR_EXPIRED:
1504                        set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1505                        nfs4_state_start_reclaim_nograce(clp);
1506                        break;
1507                case -NFS4ERR_BADSESSION:
1508                case -NFS4ERR_BADSLOT:
1509                case -NFS4ERR_BAD_HIGH_SLOT:
1510                case -NFS4ERR_DEADSESSION:
1511                case -NFS4ERR_SEQ_FALSE_RETRY:
1512                case -NFS4ERR_SEQ_MISORDERED:
1513                        set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1514                        /* Zero session reset errors */
1515                        break;
1516                case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1517                        set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1518                        break;
1519                case -EKEYEXPIRED:
1520                        /* Nothing we can do */
1521                        nfs4_warn_keyexpired(clp->cl_hostname);
1522                        break;
1523                default:
1524                        dprintk("%s: failed to handle error %d for server %s\n",
1525                                        __func__, error, clp->cl_hostname);
1526                        return error;
1527        }
1528        dprintk("%s: handled error %d for server %s\n", __func__, error,
1529                        clp->cl_hostname);
1530        return 0;
1531}
1532
1533static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
1534{
1535        struct nfs4_state_owner *sp;
1536        struct nfs_server *server;
1537        struct rb_node *pos;
1538        int status = 0;
1539
1540restart:
1541        rcu_read_lock();
1542        list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1543                nfs4_purge_state_owners(server);
1544                spin_lock(&clp->cl_lock);
1545                for (pos = rb_first(&server->state_owners);
1546                     pos != NULL;
1547                     pos = rb_next(pos)) {
1548                        sp = rb_entry(pos,
1549                                struct nfs4_state_owner, so_server_node);
1550                        if (!test_and_clear_bit(ops->owner_flag_bit,
1551                                                        &sp->so_flags))
1552                                continue;
1553                        atomic_inc(&sp->so_count);
1554                        spin_unlock(&clp->cl_lock);
1555                        rcu_read_unlock();
1556
1557                        status = nfs4_reclaim_open_state(sp, ops);
1558                        if (status < 0) {
1559                                set_bit(ops->owner_flag_bit, &sp->so_flags);
1560                                nfs4_put_state_owner(sp);
1561                                return nfs4_recovery_handle_error(clp, status);
1562                        }
1563
1564                        nfs4_put_state_owner(sp);
1565                        goto restart;
1566                }
1567                spin_unlock(&clp->cl_lock);
1568        }
1569        rcu_read_unlock();
1570        return status;
1571}
1572
1573static int nfs4_check_lease(struct nfs_client *clp)
1574{
1575        struct rpc_cred *cred;
1576        const struct nfs4_state_maintenance_ops *ops =
1577                clp->cl_mvops->state_renewal_ops;
1578        int status;
1579
1580        /* Is the client already known to have an expired lease? */
1581        if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1582                return 0;
1583        spin_lock(&clp->cl_lock);
1584        cred = ops->get_state_renewal_cred_locked(clp);
1585        spin_unlock(&clp->cl_lock);
1586        if (cred == NULL) {
1587                cred = nfs4_get_setclientid_cred(clp);
1588                status = -ENOKEY;
1589                if (cred == NULL)
1590                        goto out;
1591        }
1592        status = ops->renew_lease(clp, cred);
1593        put_rpccred(cred);
1594out:
1595        return nfs4_recovery_handle_error(clp, status);
1596}
1597
1598/* Set NFS4CLNT_LEASE_EXPIRED for all v4.0 errors and for recoverable errors
1599 * on EXCHANGE_ID for v4.1
1600 */
1601static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
1602{
1603        switch (status) {
1604        case -NFS4ERR_SEQ_MISORDERED:
1605                if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state))
1606                        return -ESERVERFAULT;
1607                /* Lease confirmation error: retry after purging the lease */
1608                ssleep(1);
1609        case -NFS4ERR_STALE_CLIENTID:
1610                clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1611                break;
1612        case -NFS4ERR_CLID_INUSE:
1613                pr_err("NFS: Server %s reports our clientid is in use\n",
1614                        clp->cl_hostname);
1615                nfs_mark_client_ready(clp, -EPERM);
1616                clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1617                return -EPERM;
1618        case -EACCES:
1619                if (clp->cl_machine_cred == NULL)
1620                        return -EACCES;
1621                /* Handle case where the user hasn't set up machine creds */
1622                nfs4_clear_machine_cred(clp);
1623        case -NFS4ERR_DELAY:
1624        case -ETIMEDOUT:
1625        case -EAGAIN:
1626                ssleep(1);
1627                break;
1628
1629        case -NFS4ERR_MINOR_VERS_MISMATCH:
1630                if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
1631                        nfs_mark_client_ready(clp, -EPROTONOSUPPORT);
1632                dprintk("%s: exit with error %d for server %s\n",
1633                                __func__, -EPROTONOSUPPORT, clp->cl_hostname);
1634                return -EPROTONOSUPPORT;
1635        case -EKEYEXPIRED:
1636                nfs4_warn_keyexpired(clp->cl_hostname);
1637        case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
1638                                 * in nfs4_exchange_id */
1639        default:
1640                dprintk("%s: exit with error %d for server %s\n", __func__,
1641                                status, clp->cl_hostname);
1642                return status;
1643        }
1644        set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1645        dprintk("%s: handled error %d for server %s\n", __func__, status,
1646                        clp->cl_hostname);
1647        return 0;
1648}
1649
1650static int nfs4_establish_lease(struct nfs_client *clp)
1651{
1652        struct rpc_cred *cred;
1653        const struct nfs4_state_recovery_ops *ops =
1654                clp->cl_mvops->reboot_recovery_ops;
1655        int status;
1656
1657        cred = ops->get_clid_cred(clp);
1658        if (cred == NULL)
1659                return -ENOENT;
1660        status = ops->establish_clid(clp, cred);
1661        put_rpccred(cred);
1662        if (status != 0)
1663                return status;
1664        pnfs_destroy_all_layouts(clp);
1665        return 0;
1666}
1667
1668/*
1669 * Returns zero or a negative errno.  NFS4ERR values are converted
1670 * to local errno values.
1671 */
1672static int nfs4_reclaim_lease(struct nfs_client *clp)
1673{
1674        int status;
1675
1676        status = nfs4_establish_lease(clp);
1677        if (status < 0)
1678                return nfs4_handle_reclaim_lease_error(clp, status);
1679        if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state))
1680                nfs4_state_start_reclaim_nograce(clp);
1681        if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
1682                set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1683        clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1684        clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1685        return 0;
1686}
1687
1688static int nfs4_purge_lease(struct nfs_client *clp)
1689{
1690        int status;
1691
1692        status = nfs4_establish_lease(clp);
1693        if (status < 0)
1694                return nfs4_handle_reclaim_lease_error(clp, status);
1695        clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
1696        set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1697        nfs4_state_start_reclaim_nograce(clp);
1698        return 0;
1699}
1700
1701#ifdef CONFIG_NFS_V4_1
1702void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
1703{
1704        struct nfs_client *clp = session->clp;
1705
1706        switch (err) {
1707        default:
1708                set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1709                break;
1710        case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1711                set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1712        }
1713        nfs4_schedule_lease_recovery(clp);
1714}
1715EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
1716
1717void nfs41_handle_recall_slot(struct nfs_client *clp)
1718{
1719        set_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state);
1720        dprintk("%s: scheduling slot recall for server %s\n", __func__,
1721                        clp->cl_hostname);
1722        nfs4_schedule_state_manager(clp);
1723}
1724
1725static void nfs4_reset_all_state(struct nfs_client *clp)
1726{
1727        if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
1728                set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
1729                clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1730                nfs4_state_start_reclaim_nograce(clp);
1731                dprintk("%s: scheduling reset of all state for server %s!\n",
1732                                __func__, clp->cl_hostname);
1733                nfs4_schedule_state_manager(clp);
1734        }
1735}
1736
1737static void nfs41_handle_server_reboot(struct nfs_client *clp)
1738{
1739        if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
1740                nfs4_state_start_reclaim_reboot(clp);
1741                dprintk("%s: server %s rebooted!\n", __func__,
1742                                clp->cl_hostname);
1743                nfs4_schedule_state_manager(clp);
1744        }
1745}
1746
1747static void nfs41_handle_state_revoked(struct nfs_client *clp)
1748{
1749        nfs4_reset_all_state(clp);
1750        dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
1751}
1752
1753static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
1754{
1755        /* This will need to handle layouts too */
1756        nfs_expire_all_delegations(clp);
1757        dprintk("%s: Recallable state revoked on server %s!\n", __func__,
1758                        clp->cl_hostname);
1759}
1760
1761static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
1762{
1763        nfs_expire_all_delegations(clp);
1764        if (test_and_set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) == 0)
1765                nfs4_schedule_state_manager(clp);
1766        dprintk("%s: server %s declared a backchannel fault\n", __func__,
1767                        clp->cl_hostname);
1768}
1769
1770static void nfs41_handle_cb_path_down(struct nfs_client *clp)
1771{
1772        if (test_and_set_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
1773                &clp->cl_state) == 0)
1774                nfs4_schedule_state_manager(clp);
1775}
1776
1777void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)
1778{
1779        if (!flags)
1780                return;
1781
1782        dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
1783                __func__, clp->cl_hostname, clp->cl_clientid, flags);
1784
1785        if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
1786                nfs41_handle_server_reboot(clp);
1787        if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED |
1788                            SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
1789                            SEQ4_STATUS_ADMIN_STATE_REVOKED |
1790                            SEQ4_STATUS_LEASE_MOVED))
1791                nfs41_handle_state_revoked(clp);
1792        if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
1793                nfs41_handle_recallable_state_revoked(clp);
1794        if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT)
1795                nfs41_handle_backchannel_fault(clp);
1796        else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
1797                                SEQ4_STATUS_CB_PATH_DOWN_SESSION))
1798                nfs41_handle_cb_path_down(clp);
1799}
1800
1801static int nfs4_reset_session(struct nfs_client *clp)
1802{
1803        struct rpc_cred *cred;
1804        int status;
1805
1806        if (!nfs4_has_session(clp))
1807                return 0;
1808        nfs4_begin_drain_session(clp);
1809        cred = nfs4_get_exchange_id_cred(clp);
1810        status = nfs4_proc_destroy_session(clp->cl_session, cred);
1811        if (status && status != -NFS4ERR_BADSESSION &&
1812            status != -NFS4ERR_DEADSESSION) {
1813                status = nfs4_recovery_handle_error(clp, status);
1814                goto out;
1815        }
1816
1817        memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
1818        status = nfs4_proc_create_session(clp, cred);
1819        if (status) {
1820                dprintk("%s: session reset failed with status %d for server %s!\n",
1821                        __func__, status, clp->cl_hostname);
1822                status = nfs4_handle_reclaim_lease_error(clp, status);
1823                goto out;
1824        }
1825        nfs41_finish_session_reset(clp);
1826        dprintk("%s: session reset was successful for server %s!\n",
1827                        __func__, clp->cl_hostname);
1828out:
1829        if (cred)
1830                put_rpccred(cred);
1831        return status;
1832}
1833
1834static int nfs4_recall_slot(struct nfs_client *clp)
1835{
1836        struct nfs4_slot_table *fc_tbl;
1837        struct nfs4_slot *new, *old;
1838        int i;
1839
1840        if (!nfs4_has_session(clp))
1841                return 0;
1842        nfs4_begin_drain_session(clp);
1843        fc_tbl = &clp->cl_session->fc_slot_table;
1844        new = kmalloc(fc_tbl->target_max_slots * sizeof(struct nfs4_slot),
1845                      GFP_NOFS);
1846        if (!new)
1847                return -ENOMEM;
1848
1849        spin_lock(&fc_tbl->slot_tbl_lock);
1850        for (i = 0; i < fc_tbl->target_max_slots; i++)
1851                new[i].seq_nr = fc_tbl->slots[i].seq_nr;
1852        old = fc_tbl->slots;
1853        fc_tbl->slots = new;
1854        fc_tbl->max_slots = fc_tbl->target_max_slots;
1855        fc_tbl->target_max_slots = 0;
1856        clp->cl_session->fc_attrs.max_reqs = fc_tbl->max_slots;
1857        spin_unlock(&fc_tbl->slot_tbl_lock);
1858
1859        kfree(old);
1860        return 0;
1861}
1862
1863static int nfs4_bind_conn_to_session(struct nfs_client *clp)
1864{
1865        struct rpc_cred *cred;
1866        int ret;
1867
1868        if (!nfs4_has_session(clp))
1869                return 0;
1870        nfs4_begin_drain_session(clp);
1871        cred = nfs4_get_exchange_id_cred(clp);
1872        ret = nfs4_proc_bind_conn_to_session(clp, cred);
1873        if (cred)
1874                put_rpccred(cred);
1875        clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1876        switch (ret) {
1877        case 0:
1878                dprintk("%s: bind_conn_to_session was successful for server %s!\n",
1879                        __func__, clp->cl_hostname);
1880                break;
1881        case -NFS4ERR_DELAY:
1882                ssleep(1);
1883                set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1884                break;
1885        default:
1886                return nfs4_recovery_handle_error(clp, ret);
1887        }
1888        return 0;
1889}
1890#else /* CONFIG_NFS_V4_1 */
1891static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
1892static int nfs4_end_drain_session(struct nfs_client *clp) { return 0; }
1893static int nfs4_recall_slot(struct nfs_client *clp) { return 0; }
1894
1895static int nfs4_bind_conn_to_session(struct nfs_client *clp)
1896{
1897        return 0;
1898}
1899#endif /* CONFIG_NFS_V4_1 */
1900
1901static void nfs4_state_manager(struct nfs_client *clp)
1902{
1903        int status = 0;
1904        const char *section = "", *section_sep = "";
1905
1906        /* Ensure exclusive access to NFSv4 state */
1907        do {
1908                if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
1909                        section = "purge state";
1910                        status = nfs4_purge_lease(clp);
1911                        if (status < 0)
1912                                goto out_error;
1913                        continue;
1914                }
1915
1916                if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
1917                        section = "lease expired";
1918                        /* We're going to have to re-establish a clientid */
1919                        status = nfs4_reclaim_lease(clp);
1920                        if (status < 0)
1921                                goto out_error;
1922                        continue;
1923                }
1924
1925                if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
1926                        section = "check lease";
1927                        status = nfs4_check_lease(clp);
1928                        if (status < 0)
1929                                goto out_error;
1930                        if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1931                                continue;
1932                }
1933
1934                /* Initialize or reset the session */
1935                if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) {
1936                        section = "reset session";
1937                        status = nfs4_reset_session(clp);
1938                        if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1939                                continue;
1940                        if (status < 0)
1941                                goto out_error;
1942                }
1943
1944                /* Send BIND_CONN_TO_SESSION */
1945                if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
1946                                &clp->cl_state)) {
1947                        section = "bind conn to session";
1948                        status = nfs4_bind_conn_to_session(clp);
1949                        if (status < 0)
1950                                goto out_error;
1951                        continue;
1952                }
1953
1954                /* Recall session slots */
1955                if (test_and_clear_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state)) {
1956                        section = "recall slot";
1957                        status = nfs4_recall_slot(clp);
1958                        if (status < 0)
1959                                goto out_error;
1960                        continue;
1961                }
1962
1963                /* First recover reboot state... */
1964                if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
1965                        section = "reclaim reboot";
1966                        status = nfs4_do_reclaim(clp,
1967                                clp->cl_mvops->reboot_recovery_ops);
1968                        if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
1969                            test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state))
1970                                continue;
1971                        nfs4_state_end_reclaim_reboot(clp);
1972                        if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
1973                                continue;
1974                        if (status < 0)
1975                                goto out_error;
1976                }
1977
1978                /* Now recover expired state... */
1979                if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
1980                        section = "reclaim nograce";
1981                        status = nfs4_do_reclaim(clp,
1982                                clp->cl_mvops->nograce_recovery_ops);
1983                        if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
1984                            test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) ||
1985                            test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
1986                                continue;
1987                        if (status < 0)
1988                                goto out_error;
1989                }
1990
1991                nfs4_end_drain_session(clp);
1992                if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
1993                        nfs_client_return_marked_delegations(clp);
1994                        continue;
1995                }
1996
1997                nfs4_clear_state_manager_bit(clp);
1998                /* Did we race with an attempt to give us more work? */
1999                if (clp->cl_state == 0)
2000                        break;
2001                if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
2002                        break;
2003        } while (atomic_read(&clp->cl_count) > 1);
2004        return;
2005out_error:
2006        if (strlen(section))
2007                section_sep = ": ";
2008        pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
2009                        " with error %d\n", section_sep, section,
2010                        clp->cl_hostname, -status);
2011        nfs4_end_drain_session(clp);
2012        nfs4_clear_state_manager_bit(clp);
2013}
2014
2015static int nfs4_run_state_manager(void *ptr)
2016{
2017        struct nfs_client *clp = ptr;
2018
2019        allow_signal(SIGKILL);
2020        nfs4_state_manager(clp);
2021        nfs_put_client(clp);
2022        module_put_and_exit(0);
2023        return 0;
2024}
2025
2026/*
2027 * Local variables:
2028 *  c-basic-offset: 8
2029 * End:
2030 */
2031
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.