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 atomic_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(state, &nfsi->open_states, inode_states) { 688 if (state->owner != owner) 689 continue; 690 if (!nfs4_valid_open_stateid(state)) 691 continue; 692 if (atomic_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(state); 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 spin_lock(&inode->i_lock); 711 state = __nfs4_find_state_byowner(inode, owner); 712 spin_unlock(&inode->i_lock); 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(&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 (!atomic_dec_and_lock(&state->count, &owner->so_lock)) 747 return; 748 spin_lock(&inode->i_lock); 749 list_del(&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 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) 1214 return; 1215 __module_get(THIS_MODULE); 1216 refcount_inc(&clp->cl_count); 1217 1218 /* The rcu_read_lock() is not strictly necessary, as the state 1219 * manager is the only thread that ever changes the rpc_xprt 1220 * after it's initialized. At this point, we're single threaded. */ 1221 rcu_read_lock(); 1222 snprintf(buf, sizeof(buf), "%s-manager", 1223 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)); 1224 rcu_read_unlock(); 1225 task = kthread_run(nfs4_run_state_manager, clp, "%s", buf); 1226 if (IS_ERR(task)) { 1227 printk(KERN_ERR "%s: kthread_run: %ld\n", 1228 __func__, PTR_ERR(task)); 1229 nfs4_clear_state_manager_bit(clp); 1230 nfs_put_client(clp); 1231 module_put(THIS_MODULE); 1232 } 1233 } 1234 1235 /* 1236 * Schedule a lease recovery attempt 1237 */ 1238 void nfs4_schedule_lease_recovery(struct nfs_client *clp) 1239 { 1240 if (!clp) 1241 return; 1242 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 1243 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 1244 dprintk("%s: scheduling lease recovery for server %s\n", __func__, 1245 clp->cl_hostname); 1246 nfs4_schedule_state_manager(clp); 1247 } 1248 EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery); 1249 1250 /** 1251 * nfs4_schedule_migration_recovery - trigger migration recovery 1252 * 1253 * @server: FSID that is migrating 1254 * 1255 * Returns zero if recovery has started, otherwise a negative NFS4ERR 1256 * value is returned. 1257 */ 1258 int nfs4_schedule_migration_recovery(const struct nfs_server *server) 1259 { 1260 struct nfs_client *clp = server->nfs_client; 1261 1262 if (server->fh_expire_type != NFS4_FH_PERSISTENT) { 1263 pr_err("NFS: volatile file handles not supported (server %s)\n", 1264 clp->cl_hostname); 1265 return -NFS4ERR_IO; 1266 } 1267 1268 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) 1269 return -NFS4ERR_IO; 1270 1271 dprintk("%s: scheduling migration recovery for (%llx:%llx) on %s\n", 1272 __func__, 1273 (unsigned long long)server->fsid.major, 1274 (unsigned long long)server->fsid.minor, 1275 clp->cl_hostname); 1276 1277 set_bit(NFS_MIG_IN_TRANSITION, 1278 &((struct nfs_server *)server)->mig_status); 1279 set_bit(NFS4CLNT_MOVED, &clp->cl_state); 1280 1281 nfs4_schedule_state_manager(clp); 1282 return 0; 1283 } 1284 EXPORT_SYMBOL_GPL(nfs4_schedule_migration_recovery); 1285 1286 /** 1287 * nfs4_schedule_lease_moved_recovery - start lease-moved recovery 1288 * 1289 * @clp: server to check for moved leases 1290 * 1291 */ 1292 void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp) 1293 { 1294 dprintk("%s: scheduling lease-moved recovery for client ID %llx on %s\n", 1295 __func__, clp->cl_clientid, clp->cl_hostname); 1296 1297 set_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state); 1298 nfs4_schedule_state_manager(clp); 1299 } 1300 EXPORT_SYMBOL_GPL(nfs4_schedule_lease_moved_recovery); 1301 1302 int nfs4_wait_clnt_recover(struct nfs_client *clp) 1303 { 1304 int res; 1305 1306 might_sleep(); 1307 1308 refcount_inc(&clp->cl_count); 1309 res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING, 1310 nfs_wait_bit_killable, TASK_KILLABLE); 1311 if (res) 1312 goto out; 1313 if (clp->cl_cons_state < 0) 1314 res = clp->cl_cons_state; 1315 out: 1316 nfs_put_client(clp); 1317 return res; 1318 } 1319 1320 int nfs4_client_recover_expired_lease(struct nfs_client *clp) 1321 { 1322 unsigned int loop; 1323 int ret; 1324 1325 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) { 1326 ret = nfs4_wait_clnt_recover(clp); 1327 if (ret != 0) 1328 break; 1329 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) && 1330 !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state)) 1331 break; 1332 nfs4_schedule_state_manager(clp); 1333 ret = -EIO; 1334 } 1335 return ret; 1336 } 1337 1338 /* 1339 * nfs40_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN 1340 * @clp: client to process 1341 * 1342 * Set the NFS4CLNT_LEASE_EXPIRED state in order to force a 1343 * resend of the SETCLIENTID and hence re-establish the 1344 * callback channel. Then return all existing delegations. 1345 */ 1346 static void nfs40_handle_cb_pathdown(struct nfs_client *clp) 1347 { 1348 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1349 nfs_expire_all_delegations(clp); 1350 dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__, 1351 clp->cl_hostname); 1352 } 1353 1354 void nfs4_schedule_path_down_recovery(struct nfs_client *clp) 1355 { 1356 nfs40_handle_cb_pathdown(clp); 1357 nfs4_schedule_state_manager(clp); 1358 } 1359 1360 static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state) 1361 { 1362 1363 if (!nfs4_valid_open_stateid(state)) 1364 return 0; 1365 set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); 1366 /* Don't recover state that expired before the reboot */ 1367 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) { 1368 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); 1369 return 0; 1370 } 1371 set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags); 1372 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); 1373 return 1; 1374 } 1375 1376 int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state) 1377 { 1378 if (!nfs4_valid_open_stateid(state)) 1379 return 0; 1380 set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags); 1381 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); 1382 set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags); 1383 set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state); 1384 return 1; 1385 } 1386 1387 int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state) 1388 { 1389 struct nfs_client *clp = server->nfs_client; 1390 1391 if (!nfs4_state_mark_reclaim_nograce(clp, state)) 1392 return -EBADF; 1393 nfs_inode_find_delegation_state_and_recover(state->inode, 1394 &state->stateid); 1395 dprintk("%s: scheduling stateid recovery for server %s\n", __func__, 1396 clp->cl_hostname); 1397 nfs4_schedule_state_manager(clp); 1398 return 0; 1399 } 1400 EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery); 1401 1402 static struct nfs4_lock_state * 1403 nfs_state_find_lock_state_by_stateid(struct nfs4_state *state, 1404 const nfs4_stateid *stateid) 1405 { 1406 struct nfs4_lock_state *pos; 1407 1408 list_for_each_entry(pos, &state->lock_states, ls_locks) { 1409 if (!test_bit(NFS_LOCK_INITIALIZED, &pos->ls_flags)) 1410 continue; 1411 if (nfs4_stateid_match_other(&pos->ls_stateid, stateid)) 1412 return pos; 1413 } 1414 return NULL; 1415 } 1416 1417 static bool nfs_state_lock_state_matches_stateid(struct nfs4_state *state, 1418 const nfs4_stateid *stateid) 1419 { 1420 bool found = false; 1421 1422 if (test_bit(LK_STATE_IN_USE, &state->flags)) { 1423 spin_lock(&state->state_lock); 1424 if (nfs_state_find_lock_state_by_stateid(state, stateid)) 1425 found = true; 1426 spin_unlock(&state->state_lock); 1427 } 1428 return found; 1429 } 1430 1431 void nfs_inode_find_state_and_recover(struct inode *inode, 1432 const nfs4_stateid *stateid) 1433 { 1434 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; 1435 struct nfs_inode *nfsi = NFS_I(inode); 1436 struct nfs_open_context *ctx; 1437 struct nfs4_state *state; 1438 bool found = false; 1439 1440 spin_lock(&inode->i_lock); 1441 list_for_each_entry(ctx, &nfsi->open_files, list) { 1442 state = ctx->state; 1443 if (state == NULL) 1444 continue; 1445 if (nfs4_stateid_match_other(&state->stateid, stateid) && 1446 nfs4_state_mark_reclaim_nograce(clp, state)) { 1447 found = true; 1448 continue; 1449 } 1450 if (nfs4_stateid_match_other(&state->open_stateid, stateid) && 1451 nfs4_state_mark_reclaim_nograce(clp, state)) { 1452 found = true; 1453 continue; 1454 } 1455 if (nfs_state_lock_state_matches_stateid(state, stateid) && 1456 nfs4_state_mark_reclaim_nograce(clp, state)) 1457 found = true; 1458 } 1459 spin_unlock(&inode->i_lock); 1460 1461 nfs_inode_find_delegation_state_and_recover(inode, stateid); 1462 if (found) 1463 nfs4_schedule_state_manager(clp); 1464 } 1465 1466 static void nfs4_state_mark_open_context_bad(struct nfs4_state *state) 1467 { 1468 struct inode *inode = state->inode; 1469 struct nfs_inode *nfsi = NFS_I(inode); 1470 struct nfs_open_context *ctx; 1471 1472 spin_lock(&inode->i_lock); 1473 list_for_each_entry(ctx, &nfsi->open_files, list) { 1474 if (ctx->state != state) 1475 continue; 1476 set_bit(NFS_CONTEXT_BAD, &ctx->flags); 1477 } 1478 spin_unlock(&inode->i_lock); 1479 } 1480 1481 static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error) 1482 { 1483 set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags); 1484 nfs4_state_mark_open_context_bad(state); 1485 } 1486 1487 1488 static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops) 1489 { 1490 struct inode *inode = state->inode; 1491 struct nfs_inode *nfsi = NFS_I(inode); 1492 struct file_lock *fl; 1493 struct nfs4_lock_state *lsp; 1494 int status = 0; 1495 struct file_lock_context *flctx = inode->i_flctx; 1496 struct list_head *list; 1497 1498 if (flctx == NULL) 1499 return 0; 1500 1501 list = &flctx->flc_posix; 1502 1503 /* Guard against delegation returns and new lock/unlock calls */ 1504 down_write(&nfsi->rwsem); 1505 spin_lock(&flctx->flc_lock); 1506 restart: 1507 list_for_each_entry(fl, list, fl_list) { 1508 if (nfs_file_open_context(fl->fl_file)->state != state) 1509 continue; 1510 spin_unlock(&flctx->flc_lock); 1511 status = ops->recover_lock(state, fl); 1512 switch (status) { 1513 case 0: 1514 break; 1515 case -ESTALE: 1516 case -NFS4ERR_ADMIN_REVOKED: 1517 case -NFS4ERR_STALE_STATEID: 1518 case -NFS4ERR_BAD_STATEID: 1519 case -NFS4ERR_EXPIRED: 1520 case -NFS4ERR_NO_GRACE: 1521 case -NFS4ERR_STALE_CLIENTID: 1522 case -NFS4ERR_BADSESSION: 1523 case -NFS4ERR_BADSLOT: 1524 case -NFS4ERR_BAD_HIGH_SLOT: 1525 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1526 goto out; 1527 default: 1528 pr_err("NFS: %s: unhandled error %d\n", 1529 __func__, status); 1530 /* Fall through */ 1531 case -ENOMEM: 1532 case -NFS4ERR_DENIED: 1533 case -NFS4ERR_RECLAIM_BAD: 1534 case -NFS4ERR_RECLAIM_CONFLICT: 1535 lsp = fl->fl_u.nfs4_fl.owner; 1536 if (lsp) 1537 set_bit(NFS_LOCK_LOST, &lsp->ls_flags); 1538 status = 0; 1539 } 1540 spin_lock(&flctx->flc_lock); 1541 } 1542 if (list == &flctx->flc_posix) { 1543 list = &flctx->flc_flock; 1544 goto restart; 1545 } 1546 spin_unlock(&flctx->flc_lock); 1547 out: 1548 up_write(&nfsi->rwsem); 1549 return status; 1550 } 1551 1552 static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops) 1553 { 1554 struct nfs4_state *state; 1555 struct nfs4_lock_state *lock; 1556 int status = 0; 1557 1558 /* Note: we rely on the sp->so_states list being ordered 1559 * so that we always reclaim open(O_RDWR) and/or open(O_WRITE) 1560 * states first. 1561 * This is needed to ensure that the server won't give us any 1562 * read delegations that we have to return if, say, we are 1563 * recovering after a network partition or a reboot from a 1564 * server that doesn't support a grace period. 1565 */ 1566 spin_lock(&sp->so_lock); 1567 raw_write_seqcount_begin(&sp->so_reclaim_seqcount); 1568 restart: 1569 list_for_each_entry(state, &sp->so_states, open_states) { 1570 if (!test_and_clear_bit(ops->state_flag_bit, &state->flags)) 1571 continue; 1572 if (!nfs4_valid_open_stateid(state)) 1573 continue; 1574 if (state->state == 0) 1575 continue; 1576 atomic_inc(&state->count); 1577 spin_unlock(&sp->so_lock); 1578 status = ops->recover_open(sp, state); 1579 if (status >= 0) { 1580 status = nfs4_reclaim_locks(state, ops); 1581 if (status >= 0) { 1582 if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) { 1583 spin_lock(&state->state_lock); 1584 list_for_each_entry(lock, &state->lock_states, ls_locks) { 1585 if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags)) 1586 pr_warn_ratelimited("NFS: " 1587 "%s: Lock reclaim " 1588 "failed!\n", __func__); 1589 } 1590 spin_unlock(&state->state_lock); 1591 } 1592 clear_bit(NFS_STATE_RECLAIM_NOGRACE, 1593 &state->flags); 1594 #ifdef CONFIG_NFS_V4_2 1595 if (test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags)) { 1596 struct nfs4_copy_state *copy; 1597 1598 spin_lock(&sp->so_server->nfs_client->cl_lock); 1599 list_for_each_entry(copy, &sp->so_server->ss_copies, copies) { 1600 if (memcmp(&state->stateid.other, ©->parent_state->stateid.other, NFS4_STATEID_SIZE)) 1601 continue; 1602 copy->flags = 1; 1603 complete(©->completion); 1604 printk("AGLO: server rebooted waking up the copy\n"); 1605 break; 1606 } 1607 spin_unlock(&sp->so_server->nfs_client->cl_lock); 1608 } 1609 #endif /* CONFIG_NFS_V4_2 */ 1610 nfs4_put_open_state(state); 1611 spin_lock(&sp->so_lock); 1612 goto restart; 1613 } 1614 } 1615 switch (status) { 1616 default: 1617 printk(KERN_ERR "NFS: %s: unhandled error %d\n", 1618 __func__, status); 1619 /* Fall through */ 1620 case -ENOENT: 1621 case -ENOMEM: 1622 case -EACCES: 1623 case -EROFS: 1624 case -EIO: 1625 case -ESTALE: 1626 /* Open state on this file cannot be recovered */ 1627 nfs4_state_mark_recovery_failed(state, status); 1628 break; 1629 case -EAGAIN: 1630 ssleep(1); 1631 /* Fall through */ 1632 case -NFS4ERR_ADMIN_REVOKED: 1633 case -NFS4ERR_STALE_STATEID: 1634 case -NFS4ERR_OLD_STATEID: 1635 case -NFS4ERR_BAD_STATEID: 1636 case -NFS4ERR_RECLAIM_BAD: 1637 case -NFS4ERR_RECLAIM_CONFLICT: 1638 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state); 1639 break; 1640 case -NFS4ERR_EXPIRED: 1641 case -NFS4ERR_NO_GRACE: 1642 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state); 1643 case -NFS4ERR_STALE_CLIENTID: 1644 case -NFS4ERR_BADSESSION: 1645 case -NFS4ERR_BADSLOT: 1646 case -NFS4ERR_BAD_HIGH_SLOT: 1647 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1648 goto out_err; 1649 } 1650 nfs4_put_open_state(state); 1651 spin_lock(&sp->so_lock); 1652 goto restart; 1653 } 1654 raw_write_seqcount_end(&sp->so_reclaim_seqcount); 1655 spin_unlock(&sp->so_lock); 1656 return 0; 1657 out_err: 1658 nfs4_put_open_state(state); 1659 spin_lock(&sp->so_lock); 1660 raw_write_seqcount_end(&sp->so_reclaim_seqcount); 1661 spin_unlock(&sp->so_lock); 1662 return status; 1663 } 1664 1665 static void nfs4_clear_open_state(struct nfs4_state *state) 1666 { 1667 struct nfs4_lock_state *lock; 1668 1669 clear_bit(NFS_DELEGATED_STATE, &state->flags); 1670 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1671 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1672 clear_bit(NFS_O_RDWR_STATE, &state->flags); 1673 spin_lock(&state->state_lock); 1674 list_for_each_entry(lock, &state->lock_states, ls_locks) { 1675 lock->ls_seqid.flags = 0; 1676 clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags); 1677 } 1678 spin_unlock(&state->state_lock); 1679 } 1680 1681 static void nfs4_reset_seqids(struct nfs_server *server, 1682 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state)) 1683 { 1684 struct nfs_client *clp = server->nfs_client; 1685 struct nfs4_state_owner *sp; 1686 struct rb_node *pos; 1687 struct nfs4_state *state; 1688 1689 spin_lock(&clp->cl_lock); 1690 for (pos = rb_first(&server->state_owners); 1691 pos != NULL; 1692 pos = rb_next(pos)) { 1693 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node); 1694 sp->so_seqid.flags = 0; 1695 spin_lock(&sp->so_lock); 1696 list_for_each_entry(state, &sp->so_states, open_states) { 1697 if (mark_reclaim(clp, state)) 1698 nfs4_clear_open_state(state); 1699 } 1700 spin_unlock(&sp->so_lock); 1701 } 1702 spin_unlock(&clp->cl_lock); 1703 } 1704 1705 static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp, 1706 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state)) 1707 { 1708 struct nfs_server *server; 1709 1710 rcu_read_lock(); 1711 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1712 nfs4_reset_seqids(server, mark_reclaim); 1713 rcu_read_unlock(); 1714 } 1715 1716 static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp) 1717 { 1718 /* Mark all delegations for reclaim */ 1719 nfs_delegation_mark_reclaim(clp); 1720 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot); 1721 } 1722 1723 static int nfs4_reclaim_complete(struct nfs_client *clp, 1724 const struct nfs4_state_recovery_ops *ops, 1725 struct rpc_cred *cred) 1726 { 1727 /* Notify the server we're done reclaiming our state */ 1728 if (ops->reclaim_complete) 1729 return ops->reclaim_complete(clp, cred); 1730 return 0; 1731 } 1732 1733 static void nfs4_clear_reclaim_server(struct nfs_server *server) 1734 { 1735 struct nfs_client *clp = server->nfs_client; 1736 struct nfs4_state_owner *sp; 1737 struct rb_node *pos; 1738 struct nfs4_state *state; 1739 1740 spin_lock(&clp->cl_lock); 1741 for (pos = rb_first(&server->state_owners); 1742 pos != NULL; 1743 pos = rb_next(pos)) { 1744 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node); 1745 spin_lock(&sp->so_lock); 1746 list_for_each_entry(state, &sp->so_states, open_states) { 1747 if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT, 1748 &state->flags)) 1749 continue; 1750 nfs4_state_mark_reclaim_nograce(clp, state); 1751 } 1752 spin_unlock(&sp->so_lock); 1753 } 1754 spin_unlock(&clp->cl_lock); 1755 } 1756 1757 static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp) 1758 { 1759 struct nfs_server *server; 1760 1761 if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) 1762 return 0; 1763 1764 rcu_read_lock(); 1765 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1766 nfs4_clear_reclaim_server(server); 1767 rcu_read_unlock(); 1768 1769 nfs_delegation_reap_unclaimed(clp); 1770 return 1; 1771 } 1772 1773 static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp) 1774 { 1775 const struct nfs4_state_recovery_ops *ops; 1776 struct rpc_cred *cred; 1777 int err; 1778 1779 if (!nfs4_state_clear_reclaim_reboot(clp)) 1780 return; 1781 ops = clp->cl_mvops->reboot_recovery_ops; 1782 cred = nfs4_get_clid_cred(clp); 1783 err = nfs4_reclaim_complete(clp, ops, cred); 1784 put_rpccred(cred); 1785 if (err == -NFS4ERR_CONN_NOT_BOUND_TO_SESSION) 1786 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); 1787 } 1788 1789 static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp) 1790 { 1791 nfs_mark_test_expired_all_delegations(clp); 1792 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce); 1793 } 1794 1795 static int nfs4_recovery_handle_error(struct nfs_client *clp, int error) 1796 { 1797 switch (error) { 1798 case 0: 1799 break; 1800 case -NFS4ERR_CB_PATH_DOWN: 1801 nfs40_handle_cb_pathdown(clp); 1802 break; 1803 case -NFS4ERR_NO_GRACE: 1804 nfs4_state_end_reclaim_reboot(clp); 1805 break; 1806 case -NFS4ERR_STALE_CLIENTID: 1807 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1808 nfs4_state_start_reclaim_reboot(clp); 1809 break; 1810 case -NFS4ERR_EXPIRED: 1811 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1812 nfs4_state_start_reclaim_nograce(clp); 1813 break; 1814 case -NFS4ERR_BADSESSION: 1815 case -NFS4ERR_BADSLOT: 1816 case -NFS4ERR_BAD_HIGH_SLOT: 1817 case -NFS4ERR_DEADSESSION: 1818 case -NFS4ERR_SEQ_FALSE_RETRY: 1819 case -NFS4ERR_SEQ_MISORDERED: 1820 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 1821 /* Zero session reset errors */ 1822 break; 1823 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1824 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); 1825 break; 1826 default: 1827 dprintk("%s: failed to handle error %d for server %s\n", 1828 __func__, error, clp->cl_hostname); 1829 return error; 1830 } 1831 dprintk("%s: handled error %d for server %s\n", __func__, error, 1832 clp->cl_hostname); 1833 return 0; 1834 } 1835 1836 static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops) 1837 { 1838 struct nfs4_state_owner *sp; 1839 struct nfs_server *server; 1840 struct rb_node *pos; 1841 int status = 0; 1842 1843 restart: 1844 rcu_read_lock(); 1845 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 1846 nfs4_purge_state_owners(server); 1847 spin_lock(&clp->cl_lock); 1848 for (pos = rb_first(&server->state_owners); 1849 pos != NULL; 1850 pos = rb_next(pos)) { 1851 sp = rb_entry(pos, 1852 struct nfs4_state_owner, so_server_node); 1853 if (!test_and_clear_bit(ops->owner_flag_bit, 1854 &sp->so_flags)) 1855 continue; 1856 if (!atomic_inc_not_zero(&sp->so_count)) 1857 continue; 1858 spin_unlock(&clp->cl_lock); 1859 rcu_read_unlock(); 1860 1861 status = nfs4_reclaim_open_state(sp, ops); 1862 if (status < 0) { 1863 set_bit(ops->owner_flag_bit, &sp->so_flags); 1864 nfs4_put_state_owner(sp); 1865 status = nfs4_recovery_handle_error(clp, status); 1866 return (status != 0) ? status : -EAGAIN; 1867 } 1868 1869 nfs4_put_state_owner(sp); 1870 goto restart; 1871 } 1872 spin_unlock(&clp->cl_lock); 1873 } 1874 rcu_read_unlock(); 1875 return 0; 1876 } 1877 1878 static int nfs4_check_lease(struct nfs_client *clp) 1879 { 1880 struct rpc_cred *cred; 1881 const struct nfs4_state_maintenance_ops *ops = 1882 clp->cl_mvops->state_renewal_ops; 1883 int status; 1884 1885 /* Is the client already known to have an expired lease? */ 1886 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 1887 return 0; 1888 spin_lock(&clp->cl_lock); 1889 cred = ops->get_state_renewal_cred_locked(clp); 1890 spin_unlock(&clp->cl_lock); 1891 if (cred == NULL) { 1892 cred = nfs4_get_clid_cred(clp); 1893 status = -ENOKEY; 1894 if (cred == NULL) 1895 goto out; 1896 } 1897 status = ops->renew_lease(clp, cred); 1898 put_rpccred(cred); 1899 if (status == -ETIMEDOUT) { 1900 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 1901 return 0; 1902 } 1903 out: 1904 return nfs4_recovery_handle_error(clp, status); 1905 } 1906 1907 /* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors 1908 * and for recoverable errors on EXCHANGE_ID for v4.1 1909 */ 1910 static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status) 1911 { 1912 switch (status) { 1913 case -NFS4ERR_SEQ_MISORDERED: 1914 if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) 1915 return -ESERVERFAULT; 1916 /* Lease confirmation error: retry after purging the lease */ 1917 ssleep(1); 1918 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 1919 break; 1920 case -NFS4ERR_STALE_CLIENTID: 1921 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 1922 nfs4_state_start_reclaim_reboot(clp); 1923 break; 1924 case -NFS4ERR_CLID_INUSE: 1925 pr_err("NFS: Server %s reports our clientid is in use\n", 1926 clp->cl_hostname); 1927 nfs_mark_client_ready(clp, -EPERM); 1928 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 1929 return -EPERM; 1930 case -EACCES: 1931 case -NFS4ERR_DELAY: 1932 case -ETIMEDOUT: 1933 case -EAGAIN: 1934 ssleep(1); 1935 break; 1936 1937 case -NFS4ERR_MINOR_VERS_MISMATCH: 1938 if (clp->cl_cons_state == NFS_CS_SESSION_INITING) 1939 nfs_mark_client_ready(clp, -EPROTONOSUPPORT); 1940 dprintk("%s: exit with error %d for server %s\n", 1941 __func__, -EPROTONOSUPPORT, clp->cl_hostname); 1942 return -EPROTONOSUPPORT; 1943 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery 1944 * in nfs4_exchange_id */ 1945 default: 1946 dprintk("%s: exit with error %d for server %s\n", __func__, 1947 status, clp->cl_hostname); 1948 return status; 1949 } 1950 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1951 dprintk("%s: handled error %d for server %s\n", __func__, status, 1952 clp->cl_hostname); 1953 return 0; 1954 } 1955 1956 static int nfs4_establish_lease(struct nfs_client *clp) 1957 { 1958 struct rpc_cred *cred; 1959 const struct nfs4_state_recovery_ops *ops = 1960 clp->cl_mvops->reboot_recovery_ops; 1961 int status; 1962 1963 status = nfs4_begin_drain_session(clp); 1964 if (status != 0) 1965 return status; 1966 cred = nfs4_get_clid_cred(clp); 1967 if (cred == NULL) 1968 return -ENOENT; 1969 status = ops->establish_clid(clp, cred); 1970 put_rpccred(cred); 1971 if (status != 0) 1972 return status; 1973 pnfs_destroy_all_layouts(clp); 1974 return 0; 1975 } 1976 1977 /* 1978 * Returns zero or a negative errno. NFS4ERR values are converted 1979 * to local errno values. 1980 */ 1981 static int nfs4_reclaim_lease(struct nfs_client *clp) 1982 { 1983 int status; 1984 1985 status = nfs4_establish_lease(clp); 1986 if (status < 0) 1987 return nfs4_handle_reclaim_lease_error(clp, status); 1988 if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state)) 1989 nfs4_state_start_reclaim_nograce(clp); 1990 if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) 1991 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); 1992 clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 1993 clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1994 return 0; 1995 } 1996 1997 static int nfs4_purge_lease(struct nfs_client *clp) 1998 { 1999 int status; 2000 2001 status = nfs4_establish_lease(clp); 2002 if (status < 0) 2003 return nfs4_handle_reclaim_lease_error(clp, status); 2004 clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state); 2005 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 2006 nfs4_state_start_reclaim_nograce(clp); 2007 return 0; 2008 } 2009 2010 /* 2011 * Try remote migration of one FSID from a source server to a 2012 * destination server. The source server provides a list of 2013 * potential destinations. 2014 * 2015 * Returns zero or a negative NFS4ERR status code. 2016 */ 2017 static int nfs4_try_migration(struct nfs_server *server, struct rpc_cred *cred) 2018 { 2019 struct nfs_client *clp = server->nfs_client; 2020 struct nfs4_fs_locations *locations = NULL; 2021 struct inode *inode; 2022 struct page *page; 2023 int status, result; 2024 2025 dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__, 2026 (unsigned long long)server->fsid.major, 2027 (unsigned long long)server->fsid.minor, 2028 clp->cl_hostname); 2029 2030 result = 0; 2031 page = alloc_page(GFP_KERNEL); 2032 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL); 2033 if (page == NULL || locations == NULL) { 2034 dprintk("<-- %s: no memory\n", __func__); 2035 goto out; 2036 } 2037 2038 inode = d_inode(server->super->s_root); 2039 result = nfs4_proc_get_locations(inode, locations, page, cred); 2040 if (result) { 2041 dprintk("<-- %s: failed to retrieve fs_locations: %d\n", 2042 __func__, result); 2043 goto out; 2044 } 2045 2046 result = -NFS4ERR_NXIO; 2047 if (!(locations->fattr.valid & NFS_ATTR_FATTR_V4_LOCATIONS)) { 2048 dprintk("<-- %s: No fs_locations data, migration skipped\n", 2049 __func__); 2050 goto out; 2051 } 2052 2053 status = nfs4_begin_drain_session(clp); 2054 if (status != 0) 2055 return status; 2056 2057 status = nfs4_replace_transport(server, locations); 2058 if (status != 0) { 2059 dprintk("<-- %s: failed to replace transport: %d\n", 2060 __func__, status); 2061 goto out; 2062 } 2063 2064 result = 0; 2065 dprintk("<-- %s: migration succeeded\n", __func__); 2066 2067 out: 2068 if (page != NULL) 2069 __free_page(page); 2070 kfree(locations); 2071 if (result) { 2072 pr_err("NFS: migration recovery failed (server %s)\n", 2073 clp->cl_hostname); 2074 set_bit(NFS_MIG_FAILED, &server->mig_status); 2075 } 2076 return result; 2077 } 2078 2079 /* 2080 * Returns zero or a negative NFS4ERR status code. 2081 */ 2082 static int nfs4_handle_migration(struct nfs_client *clp) 2083 { 2084 const struct nfs4_state_maintenance_ops *ops = 2085 clp->cl_mvops->state_renewal_ops; 2086 struct nfs_server *server; 2087 struct rpc_cred *cred; 2088 2089 dprintk("%s: migration reported on \"%s\"\n", __func__, 2090 clp->cl_hostname); 2091 2092 spin_lock(&clp->cl_lock); 2093 cred = ops->get_state_renewal_cred_locked(clp); 2094 spin_unlock(&clp->cl_lock); 2095 if (cred == NULL) 2096 return -NFS4ERR_NOENT; 2097 2098 clp->cl_mig_gen++; 2099 restart: 2100 rcu_read_lock(); 2101 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 2102 int status; 2103 2104 if (server->mig_gen == clp->cl_mig_gen) 2105 continue; 2106 server->mig_gen = clp->cl_mig_gen; 2107 2108 if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION, 2109 &server->mig_status)) 2110 continue; 2111 2112 rcu_read_unlock(); 2113 status = nfs4_try_migration(server, cred); 2114 if (status < 0) { 2115 put_rpccred(cred); 2116 return status; 2117 } 2118 goto restart; 2119 } 2120 rcu_read_unlock(); 2121 put_rpccred(cred); 2122 return 0; 2123 } 2124 2125 /* 2126 * Test each nfs_server on the clp's cl_superblocks list to see 2127 * if it's moved to another server. Stop when the server no longer 2128 * returns NFS4ERR_LEASE_MOVED. 2129 */ 2130 static int nfs4_handle_lease_moved(struct nfs_client *clp) 2131 { 2132 const struct nfs4_state_maintenance_ops *ops = 2133 clp->cl_mvops->state_renewal_ops; 2134 struct nfs_server *server; 2135 struct rpc_cred *cred; 2136 2137 dprintk("%s: lease moved reported on \"%s\"\n", __func__, 2138 clp->cl_hostname); 2139 2140 spin_lock(&clp->cl_lock); 2141 cred = ops->get_state_renewal_cred_locked(clp); 2142 spin_unlock(&clp->cl_lock); 2143 if (cred == NULL) 2144 return -NFS4ERR_NOENT; 2145 2146 clp->cl_mig_gen++; 2147 restart: 2148 rcu_read_lock(); 2149 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 2150 struct inode *inode; 2151 int status; 2152 2153 if (server->mig_gen == clp->cl_mig_gen) 2154 continue; 2155 server->mig_gen = clp->cl_mig_gen; 2156 2157 rcu_read_unlock(); 2158 2159 inode = d_inode(server->super->s_root); 2160 status = nfs4_proc_fsid_present(inode, cred); 2161 if (status != -NFS4ERR_MOVED) 2162 goto restart; /* wasn't this one */ 2163 if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED) 2164 goto restart; /* there are more */ 2165 goto out; 2166 } 2167 rcu_read_unlock(); 2168 2169 out: 2170 put_rpccred(cred); 2171 return 0; 2172 } 2173 2174 /** 2175 * nfs4_discover_server_trunking - Detect server IP address trunking 2176 * 2177 * @clp: nfs_client under test 2178 * @result: OUT: found nfs_client, or clp 2179 * 2180 * Returns zero or a negative errno. If zero is returned, 2181 * an nfs_client pointer is planted in "result". 2182 * 2183 * Note: since we are invoked in process context, and 2184 * not from inside the state manager, we cannot use 2185 * nfs4_handle_reclaim_lease_error(). 2186 */ 2187 int nfs4_discover_server_trunking(struct nfs_client *clp, 2188 struct nfs_client **result) 2189 { 2190 const struct nfs4_state_recovery_ops *ops = 2191 clp->cl_mvops->reboot_recovery_ops; 2192 struct rpc_clnt *clnt; 2193 struct rpc_cred *cred; 2194 int i, status; 2195 2196 dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname); 2197 2198 clnt = clp->cl_rpcclient; 2199 i = 0; 2200 2201 mutex_lock(&nfs_clid_init_mutex); 2202 again: 2203 status = -ENOENT; 2204 cred = nfs4_get_clid_cred(clp); 2205 if (cred == NULL) 2206 goto out_unlock; 2207 2208 status = ops->detect_trunking(clp, result, cred); 2209 put_rpccred(cred); 2210 switch (status) { 2211 case 0: 2212 case -EINTR: 2213 case -ERESTARTSYS: 2214 break; 2215 case -ETIMEDOUT: 2216 if (clnt->cl_softrtry) 2217 break; 2218 /* Fall through */ 2219 case -NFS4ERR_DELAY: 2220 case -EAGAIN: 2221 ssleep(1); 2222 /* Fall through */ 2223 case -NFS4ERR_STALE_CLIENTID: 2224 dprintk("NFS: %s after status %d, retrying\n", 2225 __func__, status); 2226 goto again; 2227 case -EACCES: 2228 if (i++ == 0) { 2229 nfs4_root_machine_cred(clp); 2230 goto again; 2231 } 2232 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) 2233 break; 2234 /* Fall through */ 2235 case -NFS4ERR_CLID_INUSE: 2236 case -NFS4ERR_WRONGSEC: 2237 /* No point in retrying if we already used RPC_AUTH_UNIX */ 2238 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) { 2239 status = -EPERM; 2240 break; 2241 } 2242 clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX); 2243 if (IS_ERR(clnt)) { 2244 status = PTR_ERR(clnt); 2245 break; 2246 } 2247 /* Note: this is safe because we haven't yet marked the 2248 * client as ready, so we are the only user of 2249 * clp->cl_rpcclient 2250 */ 2251 clnt = xchg(&clp->cl_rpcclient, clnt); 2252 rpc_shutdown_client(clnt); 2253 clnt = clp->cl_rpcclient; 2254 goto again; 2255 2256 case -NFS4ERR_MINOR_VERS_MISMATCH: 2257 status = -EPROTONOSUPPORT; 2258 break; 2259 2260 case -EKEYEXPIRED: 2261 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery 2262 * in nfs4_exchange_id */ 2263 status = -EKEYEXPIRED; 2264 break; 2265 default: 2266 pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n", 2267 __func__, status); 2268 status = -EIO; 2269 } 2270 2271 out_unlock: 2272 mutex_unlock(&nfs_clid_init_mutex); 2273 dprintk("NFS: %s: status = %d\n", __func__, status); 2274 return status; 2275 } 2276 2277 #ifdef CONFIG_NFS_V4_1 2278 void nfs4_schedule_session_recovery(struct nfs4_session *session, int err) 2279 { 2280 struct nfs_client *clp = session->clp; 2281 2282 switch (err) { 2283 default: 2284 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 2285 break; 2286 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 2287 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); 2288 } 2289 nfs4_schedule_state_manager(clp); 2290 } 2291 EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery); 2292 2293 void nfs41_notify_server(struct nfs_client *clp) 2294 { 2295 /* Use CHECK_LEASE to ping the server with a SEQUENCE */ 2296 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 2297 nfs4_schedule_state_manager(clp); 2298 } 2299 2300 static void nfs4_reset_all_state(struct nfs_client *clp) 2301 { 2302 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) { 2303 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state); 2304 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 2305 nfs4_state_start_reclaim_nograce(clp); 2306 dprintk("%s: scheduling reset of all state for server %s!\n", 2307 __func__, clp->cl_hostname); 2308 nfs4_schedule_state_manager(clp); 2309 } 2310 } 2311 2312 static void nfs41_handle_server_reboot(struct nfs_client *clp) 2313 { 2314 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) { 2315 nfs4_state_start_reclaim_reboot(clp); 2316 dprintk("%s: server %s rebooted!\n", __func__, 2317 clp->cl_hostname); 2318 nfs4_schedule_state_manager(clp); 2319 } 2320 } 2321 2322 static void nfs41_handle_all_state_revoked(struct nfs_client *clp) 2323 { 2324 nfs4_reset_all_state(clp); 2325 dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname); 2326 } 2327 2328 static void nfs41_handle_some_state_revoked(struct nfs_client *clp) 2329 { 2330 nfs4_state_start_reclaim_nograce(clp); 2331 nfs4_schedule_state_manager(clp); 2332 2333 dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname); 2334 } 2335 2336 static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp) 2337 { 2338 /* FIXME: For now, we destroy all layouts. */ 2339 pnfs_destroy_all_layouts(clp); 2340 /* FIXME: For now, we test all delegations+open state+locks. */ 2341 nfs41_handle_some_state_revoked(clp); 2342 dprintk("%s: Recallable state revoked on server %s!\n", __func__, 2343 clp->cl_hostname); 2344 } 2345 2346 static void nfs41_handle_backchannel_fault(struct nfs_client *clp) 2347 { 2348 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 2349 nfs4_schedule_state_manager(clp); 2350 2351 dprintk("%s: server %s declared a backchannel fault\n", __func__, 2352 clp->cl_hostname); 2353 } 2354 2355 static void nfs41_handle_cb_path_down(struct nfs_client *clp) 2356 { 2357 if (test_and_set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, 2358 &clp->cl_state) == 0) 2359 nfs4_schedule_state_manager(clp); 2360 } 2361 2362 void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags, 2363 bool recovery) 2364 { 2365 if (!flags) 2366 return; 2367 2368 dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n", 2369 __func__, clp->cl_hostname, clp->cl_clientid, flags); 2370 /* 2371 * If we're called from the state manager thread, then assume we're 2372 * already handling the RECLAIM_NEEDED and/or STATE_REVOKED. 2373 * Those flags are expected to remain set until we're done 2374 * recovering (see RFC5661, section 18.46.3). 2375 */ 2376 if (recovery) 2377 goto out_recovery; 2378 2379 if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED) 2380 nfs41_handle_server_reboot(clp); 2381 if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED)) 2382 nfs41_handle_all_state_revoked(clp); 2383 if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED | 2384 SEQ4_STATUS_ADMIN_STATE_REVOKED)) 2385 nfs41_handle_some_state_revoked(clp); 2386 if (flags & SEQ4_STATUS_LEASE_MOVED) 2387 nfs4_schedule_lease_moved_recovery(clp); 2388 if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED) 2389 nfs41_handle_recallable_state_revoked(clp); 2390 out_recovery: 2391 if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT) 2392 nfs41_handle_backchannel_fault(clp); 2393 else if (flags & (SEQ4_STATUS_CB_PATH_DOWN | 2394 SEQ4_STATUS_CB_PATH_DOWN_SESSION)) 2395 nfs41_handle_cb_path_down(clp); 2396 } 2397 2398 static int nfs4_reset_session(struct nfs_client *clp) 2399 { 2400 struct rpc_cred *cred; 2401 int status; 2402 2403 if (!nfs4_has_session(clp)) 2404 return 0; 2405 status = nfs4_begin_drain_session(clp); 2406 if (status != 0) 2407 return status; 2408 cred = nfs4_get_clid_cred(clp); 2409 status = nfs4_proc_destroy_session(clp->cl_session, cred); 2410 switch (status) { 2411 case 0: 2412 case -NFS4ERR_BADSESSION: 2413 case -NFS4ERR_DEADSESSION: 2414 break; 2415 case -NFS4ERR_BACK_CHAN_BUSY: 2416 case -NFS4ERR_DELAY: 2417 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 2418 status = 0; 2419 ssleep(1); 2420 goto out; 2421 default: 2422 status = nfs4_recovery_handle_error(clp, status); 2423 goto out; 2424 } 2425 2426 memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN); 2427 status = nfs4_proc_create_session(clp, cred); 2428 if (status) { 2429 dprintk("%s: session reset failed with status %d for server %s!\n", 2430 __func__, status, clp->cl_hostname); 2431 status = nfs4_handle_reclaim_lease_error(clp, status); 2432 goto out; 2433 } 2434 nfs41_finish_session_reset(clp); 2435 dprintk("%s: session reset was successful for server %s!\n", 2436 __func__, clp->cl_hostname); 2437 out: 2438 if (cred) 2439 put_rpccred(cred); 2440 return status; 2441 } 2442 2443 static int nfs4_bind_conn_to_session(struct nfs_client *clp) 2444 { 2445 struct rpc_cred *cred; 2446 int ret; 2447 2448 if (!nfs4_has_session(clp)) 2449 return 0; 2450 ret = nfs4_begin_drain_session(clp); 2451 if (ret != 0) 2452 return ret; 2453 cred = nfs4_get_clid_cred(clp); 2454 ret = nfs4_proc_bind_conn_to_session(clp, cred); 2455 if (cred) 2456 put_rpccred(cred); 2457 clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); 2458 switch (ret) { 2459 case 0: 2460 dprintk("%s: bind_conn_to_session was successful for server %s!\n", 2461 __func__, clp->cl_hostname); 2462 break; 2463 case -NFS4ERR_DELAY: 2464 ssleep(1); 2465 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); 2466 break; 2467 default: 2468 return nfs4_recovery_handle_error(clp, ret); 2469 } 2470 return 0; 2471 } 2472 #else /* CONFIG_NFS_V4_1 */ 2473 static int nfs4_reset_session(struct nfs_client *clp) { return 0; } 2474 2475 static int nfs4_bind_conn_to_session(struct nfs_client *clp) 2476 { 2477 return 0; 2478 } 2479 #endif /* CONFIG_NFS_V4_1 */ 2480 2481 static void nfs4_state_manager(struct nfs_client *clp) 2482 { 2483 int status = 0; 2484 const char *section = "", *section_sep = ""; 2485 2486 /* Ensure exclusive access to NFSv4 state */ 2487 do { 2488 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) { 2489 section = "purge state"; 2490 status = nfs4_purge_lease(clp); 2491 if (status < 0) 2492 goto out_error; 2493 continue; 2494 } 2495 2496 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) { 2497 section = "lease expired"; 2498 /* We're going to have to re-establish a clientid */ 2499 status = nfs4_reclaim_lease(clp); 2500 if (status < 0) 2501 goto out_error; 2502 continue; 2503 } 2504 2505 /* Initialize or reset the session */ 2506 if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) { 2507 section = "reset session"; 2508 status = nfs4_reset_session(clp); 2509 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 2510 continue; 2511 if (status < 0) 2512 goto out_error; 2513 } 2514 2515 /* Send BIND_CONN_TO_SESSION */ 2516 if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, 2517 &clp->cl_state)) { 2518 section = "bind conn to session"; 2519 status = nfs4_bind_conn_to_session(clp); 2520 if (status < 0) 2521 goto out_error; 2522 continue; 2523 } 2524 2525 if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) { 2526 section = "check lease"; 2527 status = nfs4_check_lease(clp); 2528 if (status < 0) 2529 goto out_error; 2530 continue; 2531 } 2532 2533 if (test_and_clear_bit(NFS4CLNT_MOVED, &clp->cl_state)) { 2534 section = "migration"; 2535 status = nfs4_handle_migration(clp); 2536 if (status < 0) 2537 goto out_error; 2538 } 2539 2540 if (test_and_clear_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state)) { 2541 section = "lease moved"; 2542 status = nfs4_handle_lease_moved(clp); 2543 if (status < 0) 2544 goto out_error; 2545 } 2546 2547 /* First recover reboot state... */ 2548 if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) { 2549 section = "reclaim reboot"; 2550 status = nfs4_do_reclaim(clp, 2551 clp->cl_mvops->reboot_recovery_ops); 2552 if (status == -EAGAIN) 2553 continue; 2554 if (status < 0) 2555 goto out_error; 2556 nfs4_state_end_reclaim_reboot(clp); 2557 } 2558 2559 /* Detect expired delegations... */ 2560 if (test_and_clear_bit(NFS4CLNT_DELEGATION_EXPIRED, &clp->cl_state)) { 2561 section = "detect expired delegations"; 2562 nfs_reap_expired_delegations(clp); 2563 continue; 2564 } 2565 2566 /* Now recover expired state... */ 2567 if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) { 2568 section = "reclaim nograce"; 2569 status = nfs4_do_reclaim(clp, 2570 clp->cl_mvops->nograce_recovery_ops); 2571 if (status == -EAGAIN) 2572 continue; 2573 if (status < 0) 2574 goto out_error; 2575 } 2576 2577 nfs4_end_drain_session(clp); 2578 if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) { 2579 nfs_client_return_marked_delegations(clp); 2580 continue; 2581 } 2582 2583 nfs4_clear_state_manager_bit(clp); 2584 /* Did we race with an attempt to give us more work? */ 2585 if (clp->cl_state == 0) 2586 break; 2587 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) 2588 break; 2589 } while (refcount_read(&clp->cl_count) > 1); 2590 return; 2591 out_error: 2592 if (strlen(section)) 2593 section_sep = ": "; 2594 pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s" 2595 " with error %d\n", section_sep, section, 2596 clp->cl_hostname, -status); 2597 ssleep(1); 2598 nfs4_end_drain_session(clp); 2599 nfs4_clear_state_manager_bit(clp); 2600 } 2601 2602 static int nfs4_run_state_manager(void *ptr) 2603 { 2604 struct nfs_client *clp = ptr; 2605 2606 allow_signal(SIGKILL); 2607 nfs4_state_manager(clp); 2608 nfs_put_client(clp); 2609 module_put_and_exit(0); 2610 return 0; 2611 } 2612 2613 /* 2614 * Local variables: 2615 * c-basic-offset: 8 2616 * End: 2617 */ 2618