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