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