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