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