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_simple_get(&server->openowner_id, 0, 0, 505 gfp_flags); 506 if (sp->so_seqid.owner_id < 0) { 507 kfree(sp); 508 return NULL; 509 } 510 sp->so_server = server; 511 sp->so_cred = get_cred(cred); 512 spin_lock_init(&sp->so_lock); 513 INIT_LIST_HEAD(&sp->so_states); 514 nfs4_init_seqid_counter(&sp->so_seqid); 515 atomic_set(&sp->so_count, 1); 516 INIT_LIST_HEAD(&sp->so_lru); 517 seqcount_spinlock_init(&sp->so_reclaim_seqcount, &sp->so_lock); 518 mutex_init(&sp->so_delegreturn_mutex); 519 return sp; 520} 521 522static void 523nfs4_reset_state_owner(struct nfs4_state_owner *sp) 524{ 525 /* This state_owner is no longer usable, but must 526 * remain in place so that state recovery can find it 527 * and the opens associated with it. 528 * It may also be used for new 'open' request to 529 * return a delegation to the server. 530 * So update the 'create_time' so that it looks like 531 * a new state_owner. This will cause the server to 532 * request an OPEN_CONFIRM to start a new sequence. 533 */ 534 sp->so_seqid.create_time = ktime_get(); 535} 536 537static void nfs4_free_state_owner(struct nfs4_state_owner *sp) 538{ 539 nfs4_destroy_seqid_counter(&sp->so_seqid); 540 put_cred(sp->so_cred); 541 ida_simple_remove(&sp->so_server->openowner_id, sp->so_seqid.owner_id); 542 kfree(sp); 543} 544 545static void nfs4_gc_state_owners(struct nfs_server *server) 546{ 547 struct nfs_client *clp = server->nfs_client; 548 struct nfs4_state_owner *sp, *tmp; 549 unsigned long time_min, time_max; 550 LIST_HEAD(doomed); 551 552 spin_lock(&clp->cl_lock); 553 time_max = jiffies; 554 time_min = (long)time_max - (long)clp->cl_lease_time; 555 list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) { 556 /* NB: LRU is sorted so that oldest is at the head */ 557 if (time_in_range(sp->so_expires, time_min, time_max)) 558 break; 559 list_move(&sp->so_lru, &doomed); 560 nfs4_remove_state_owner_locked(sp); 561 } 562 spin_unlock(&clp->cl_lock); 563 564 list_for_each_entry_safe(sp, tmp, &doomed, so_lru) { 565 list_del(&sp->so_lru); 566 nfs4_free_state_owner(sp); 567 } 568} 569 570/** 571 * nfs4_get_state_owner - Look up a state owner given a credential 572 * @server: nfs_server to search 573 * @cred: RPC credential to match 574 * @gfp_flags: allocation mode 575 * 576 * Returns a pointer to an instantiated nfs4_state_owner struct, or NULL. 577 */ 578struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server, 579 const struct cred *cred, 580 gfp_t gfp_flags) 581{ 582 struct nfs_client *clp = server->nfs_client; 583 struct nfs4_state_owner *sp, *new; 584 585 spin_lock(&clp->cl_lock); 586 sp = nfs4_find_state_owner_locked(server, cred); 587 spin_unlock(&clp->cl_lock); 588 if (sp != NULL) 589 goto out; 590 new = nfs4_alloc_state_owner(server, cred, gfp_flags); 591 if (new == NULL) 592 goto out; 593 spin_lock(&clp->cl_lock); 594 sp = nfs4_insert_state_owner_locked(new); 595 spin_unlock(&clp->cl_lock); 596 if (sp != new) 597 nfs4_free_state_owner(new); 598out: 599 nfs4_gc_state_owners(server); 600 return sp; 601} 602 603/** 604 * nfs4_put_state_owner - Release a nfs4_state_owner 605 * @sp: state owner data to release 606 * 607 * Note that we keep released state owners on an LRU 608 * list. 609 * This caches valid state owners so that they can be 610 * reused, to avoid the OPEN_CONFIRM on minor version 0. 611 * It also pins the uniquifier of dropped state owners for 612 * a while, to ensure that those state owner names are 613 * never reused. 614 */ 615void nfs4_put_state_owner(struct nfs4_state_owner *sp) 616{ 617 struct nfs_server *server = sp->so_server; 618 struct nfs_client *clp = server->nfs_client; 619 620 if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock)) 621 return; 622 623 sp->so_expires = jiffies; 624 list_add_tail(&sp->so_lru, &server->state_owners_lru); 625 spin_unlock(&clp->cl_lock); 626} 627 628/** 629 * nfs4_purge_state_owners - Release all cached state owners 630 * @server: nfs_server with cached state owners to release 631 * @head: resulting list of state owners 632 * 633 * Called at umount time. Remaining state owners will be on 634 * the LRU with ref count of zero. 635 * Note that the state owners are not freed, but are added 636 * to the list @head, which can later be used as an argument 637 * to nfs4_free_state_owners. 638 */ 639void nfs4_purge_state_owners(struct nfs_server *server, struct list_head *head) 640{ 641 struct nfs_client *clp = server->nfs_client; 642 struct nfs4_state_owner *sp, *tmp; 643 644 spin_lock(&clp->cl_lock); 645 list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) { 646 list_move(&sp->so_lru, head); 647 nfs4_remove_state_owner_locked(sp); 648 } 649 spin_unlock(&clp->cl_lock); 650} 651 652/** 653 * nfs4_purge_state_owners - Release all cached state owners 654 * @head: resulting list of state owners 655 * 656 * Frees a list of state owners that was generated by 657 * nfs4_purge_state_owners 658 */ 659void nfs4_free_state_owners(struct list_head *head) 660{ 661 struct nfs4_state_owner *sp, *tmp; 662 663 list_for_each_entry_safe(sp, tmp, head, so_lru) { 664 list_del(&sp->so_lru); 665 nfs4_free_state_owner(sp); 666 } 667} 668 669static struct nfs4_state * 670nfs4_alloc_open_state(void) 671{ 672 struct nfs4_state *state; 673 674 state = kzalloc(sizeof(*state), GFP_NOFS); 675 if (!state) 676 return NULL; 677 refcount_set(&state->count, 1); 678 INIT_LIST_HEAD(&state->lock_states); 679 spin_lock_init(&state->state_lock); 680 seqlock_init(&state->seqlock); 681 init_waitqueue_head(&state->waitq); 682 return state; 683} 684 685void 686nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode) 687{ 688 if (state->state == fmode) 689 return; 690 /* NB! List reordering - see the reclaim code for why. */ 691 if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { 692 if (fmode & FMODE_WRITE) 693 list_move(&state->open_states, &state->owner->so_states); 694 else 695 list_move_tail(&state->open_states, &state->owner->so_states); 696 } 697 state->state = fmode; 698} 699 700static struct nfs4_state * 701__nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner) 702{ 703 struct nfs_inode *nfsi = NFS_I(inode); 704 struct nfs4_state *state; 705 706 list_for_each_entry_rcu(state, &nfsi->open_states, inode_states) { 707 if (state->owner != owner) 708 continue; 709 if (!nfs4_valid_open_stateid(state)) 710 continue; 711 if (refcount_inc_not_zero(&state->count)) 712 return state; 713 } 714 return NULL; 715} 716 717static void 718nfs4_free_open_state(struct nfs4_state *state) 719{ 720 kfree_rcu(state, rcu_head); 721} 722 723struct nfs4_state * 724nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner) 725{ 726 struct nfs4_state *state, *new; 727 struct nfs_inode *nfsi = NFS_I(inode); 728 729 rcu_read_lock(); 730 state = __nfs4_find_state_byowner(inode, owner); 731 rcu_read_unlock(); 732 if (state) 733 goto out; 734 new = nfs4_alloc_open_state(); 735 spin_lock(&owner->so_lock); 736 spin_lock(&inode->i_lock); 737 state = __nfs4_find_state_byowner(inode, owner); 738 if (state == NULL && new != NULL) { 739 state = new; 740 state->owner = owner; 741 atomic_inc(&owner->so_count); 742 ihold(inode); 743 state->inode = inode; 744 list_add_rcu(&state->inode_states, &nfsi->open_states); 745 spin_unlock(&inode->i_lock); 746 /* Note: The reclaim code dictates that we add stateless 747 * and read-only stateids to the end of the list */ 748 list_add_tail(&state->open_states, &owner->so_states); 749 spin_unlock(&owner->so_lock); 750 } else { 751 spin_unlock(&inode->i_lock); 752 spin_unlock(&owner->so_lock); 753 if (new) 754 nfs4_free_open_state(new); 755 } 756out: 757 return state; 758} 759 760void nfs4_put_open_state(struct nfs4_state *state) 761{ 762 struct inode *inode = state->inode; 763 struct nfs4_state_owner *owner = state->owner; 764 765 if (!refcount_dec_and_lock(&state->count, &owner->so_lock)) 766 return; 767 spin_lock(&inode->i_lock); 768 list_del_rcu(&state->inode_states); 769 list_del(&state->open_states); 770 spin_unlock(&inode->i_lock); 771 spin_unlock(&owner->so_lock); 772 nfs4_inode_return_delegation_on_close(inode); 773 iput(inode); 774 nfs4_free_open_state(state); 775 nfs4_put_state_owner(owner); 776} 777 778/* 779 * Close the current file. 780 */ 781static void __nfs4_close(struct nfs4_state *state, 782 fmode_t fmode, gfp_t gfp_mask, int wait) 783{ 784 struct nfs4_state_owner *owner = state->owner; 785 int call_close = 0; 786 fmode_t newstate; 787 788 atomic_inc(&owner->so_count); 789 /* Protect against nfs4_find_state() */ 790 spin_lock(&owner->so_lock); 791 switch (fmode & (FMODE_READ | FMODE_WRITE)) { 792 case FMODE_READ: 793 state->n_rdonly--; 794 break; 795 case FMODE_WRITE: 796 state->n_wronly--; 797 break; 798 case FMODE_READ|FMODE_WRITE: 799 state->n_rdwr--; 800 } 801 newstate = FMODE_READ|FMODE_WRITE; 802 if (state->n_rdwr == 0) { 803 if (state->n_rdonly == 0) { 804 newstate &= ~FMODE_READ; 805 call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags); 806 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags); 807 } 808 if (state->n_wronly == 0) { 809 newstate &= ~FMODE_WRITE; 810 call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags); 811 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags); 812 } 813 if (newstate == 0) 814 clear_bit(NFS_DELEGATED_STATE, &state->flags); 815 } 816 nfs4_state_set_mode_locked(state, newstate); 817 spin_unlock(&owner->so_lock); 818 819 if (!call_close) { 820 nfs4_put_open_state(state); 821 nfs4_put_state_owner(owner); 822 } else 823 nfs4_do_close(state, gfp_mask, wait); 824} 825 826void nfs4_close_state(struct nfs4_state *state, fmode_t fmode) 827{ 828 __nfs4_close(state, fmode, GFP_NOFS, 0); 829} 830 831void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode) 832{ 833 __nfs4_close(state, fmode, GFP_KERNEL, 1); 834} 835 836/* 837 * Search the state->lock_states for an existing lock_owner 838 * that is compatible with either of the given owners. 839 * If the second is non-zero, then the first refers to a Posix-lock 840 * owner (current->files) and the second refers to a flock/OFD 841 * owner (struct file*). In that case, prefer a match for the first 842 * owner. 843 * If both sorts of locks are held on the one file we cannot know 844 * which stateid was intended to be used, so a "correct" choice cannot 845 * be made. Failing that, a "consistent" choice is preferable. The 846 * consistent choice we make is to prefer the first owner, that of a 847 * Posix lock. 848 */ 849static struct nfs4_lock_state * 850__nfs4_find_lock_state(struct nfs4_state *state, 851 fl_owner_t fl_owner, fl_owner_t fl_owner2) 852{ 853 struct nfs4_lock_state *pos, *ret = NULL; 854 list_for_each_entry(pos, &state->lock_states, ls_locks) { 855 if (pos->ls_owner == fl_owner) { 856 ret = pos; 857 break; 858 } 859 if (pos->ls_owner == fl_owner2) 860 ret = pos; 861 } 862 if (ret) 863 refcount_inc(&ret->ls_count); 864 return ret; 865} 866 867/* 868 * Return a compatible lock_state. If no initialized lock_state structure 869 * exists, return an uninitialized one. 870 * 871 */ 872static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner) 873{ 874 struct nfs4_lock_state *lsp; 875 struct nfs_server *server = state->owner->so_server; 876 877 lsp = kzalloc(sizeof(*lsp), GFP_NOFS); 878 if (lsp == NULL) 879 return NULL; 880 nfs4_init_seqid_counter(&lsp->ls_seqid); 881 refcount_set(&lsp->ls_count, 1); 882 lsp->ls_state = state; 883 lsp->ls_owner = fl_owner; 884 lsp->ls_seqid.owner_id = ida_simple_get(&server->lockowner_id, 0, 0, GFP_NOFS); 885 if (lsp->ls_seqid.owner_id < 0) 886 goto out_free; 887 INIT_LIST_HEAD(&lsp->ls_locks); 888 return lsp; 889out_free: 890 kfree(lsp); 891 return NULL; 892} 893 894void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp) 895{ 896 ida_simple_remove(&server->lockowner_id, lsp->ls_seqid.owner_id); 897 nfs4_destroy_seqid_counter(&lsp->ls_seqid); 898 kfree(lsp); 899} 900 901/* 902 * Return a compatible lock_state. If no initialized lock_state structure 903 * exists, return an uninitialized one. 904 * 905 */ 906static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner) 907{ 908 struct nfs4_lock_state *lsp, *new = NULL; 909 910 for(;;) { 911 spin_lock(&state->state_lock); 912 lsp = __nfs4_find_lock_state(state, owner, NULL); 913 if (lsp != NULL) 914 break; 915 if (new != NULL) { 916 list_add(&new->ls_locks, &state->lock_states); 917 set_bit(LK_STATE_IN_USE, &state->flags); 918 lsp = new; 919 new = NULL; 920 break; 921 } 922 spin_unlock(&state->state_lock); 923 new = nfs4_alloc_lock_state(state, owner); 924 if (new == NULL) 925 return NULL; 926 } 927 spin_unlock(&state->state_lock); 928 if (new != NULL) 929 nfs4_free_lock_state(state->owner->so_server, new); 930 return lsp; 931} 932 933/* 934 * Release reference to lock_state, and free it if we see that 935 * it is no longer in use 936 */ 937void nfs4_put_lock_state(struct nfs4_lock_state *lsp) 938{ 939 struct nfs_server *server; 940 struct nfs4_state *state; 941 942 if (lsp == NULL) 943 return; 944 state = lsp->ls_state; 945 if (!refcount_dec_and_lock(&lsp->ls_count, &state->state_lock)) 946 return; 947 list_del(&lsp->ls_locks); 948 if (list_empty(&state->lock_states)) 949 clear_bit(LK_STATE_IN_USE, &state->flags); 950 spin_unlock(&state->state_lock); 951 server = state->owner->so_server; 952 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) { 953 struct nfs_client *clp = server->nfs_client; 954 955 clp->cl_mvops->free_lock_state(server, lsp); 956 } else 957 nfs4_free_lock_state(server, lsp); 958} 959 960static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src) 961{ 962 struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner; 963 964 dst->fl_u.nfs4_fl.owner = lsp; 965 refcount_inc(&lsp->ls_count); 966} 967 968static void nfs4_fl_release_lock(struct file_lock *fl) 969{ 970 nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner); 971} 972 973static const struct file_lock_operations nfs4_fl_lock_ops = { 974 .fl_copy_lock = nfs4_fl_copy_lock, 975 .fl_release_private = nfs4_fl_release_lock, 976}; 977 978int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl) 979{ 980 struct nfs4_lock_state *lsp; 981 982 if (fl->fl_ops != NULL) 983 return 0; 984 lsp = nfs4_get_lock_state(state, fl->fl_owner); 985 if (lsp == NULL) 986 return -ENOMEM; 987 fl->fl_u.nfs4_fl.owner = lsp; 988 fl->fl_ops = &nfs4_fl_lock_ops; 989 return 0; 990} 991 992static int nfs4_copy_lock_stateid(nfs4_stateid *dst, 993 struct nfs4_state *state, 994 const struct nfs_lock_context *l_ctx) 995{ 996 struct nfs4_lock_state *lsp; 997 fl_owner_t fl_owner, fl_flock_owner; 998 int ret = -ENOENT; 999 1000 if (l_ctx == NULL) 1001 goto out; 1002 1003 if (test_bit(LK_STATE_IN_USE, &state->flags) == 0) 1004 goto out; 1005 1006 fl_owner = l_ctx->lockowner; 1007 fl_flock_owner = l_ctx->open_context->flock_owner; 1008 1009 spin_lock(&state->state_lock); 1010 lsp = __nfs4_find_lock_state(state, fl_owner, fl_flock_owner); 1011 if (lsp && test_bit(NFS_LOCK_LOST, &lsp->ls_flags)) 1012 ret = -EIO; 1013 else if (lsp != NULL && test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) { 1014 nfs4_stateid_copy(dst, &lsp->ls_stateid); 1015 ret = 0; 1016 } 1017 spin_unlock(&state->state_lock); 1018 nfs4_put_lock_state(lsp); 1019out: 1020 return ret; 1021} 1022 1023bool nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state) 1024{ 1025 bool ret; 1026 const nfs4_stateid *src; 1027 int seq; 1028 1029 do { 1030 ret = false; 1031 src = &zero_stateid; 1032 seq = read_seqbegin(&state->seqlock); 1033 if (test_bit(NFS_OPEN_STATE, &state->flags)) { 1034 src = &state->open_stateid; 1035 ret = true; 1036 } 1037 nfs4_stateid_copy(dst, src); 1038 } while (read_seqretry(&state->seqlock, seq)); 1039 return ret; 1040} 1041 1042/* 1043 * Byte-range lock aware utility to initialize the stateid of read/write 1044 * requests. 1045 */ 1046int nfs4_select_rw_stateid(struct nfs4_state *state, 1047 fmode_t fmode, const struct nfs_lock_context *l_ctx, 1048 nfs4_stateid *dst, const struct cred **cred) 1049{ 1050 int ret; 1051 1052 if (!nfs4_valid_open_stateid(state)) 1053 return -EIO; 1054 if (cred != NULL) 1055 *cred = NULL; 1056 ret = nfs4_copy_lock_stateid(dst, state, l_ctx); 1057 if (ret == -EIO) 1058 /* A lost lock - don't even consider delegations */ 1059 goto out; 1060 /* returns true if delegation stateid found and copied */ 1061 if (nfs4_copy_delegation_stateid(state->inode, fmode, dst, cred)) { 1062 ret = 0; 1063 goto out; 1064 } 1065 if (ret != -ENOENT) 1066 /* nfs4_copy_delegation_stateid() didn't over-write 1067 * dst, so it still has the lock stateid which we now 1068 * choose to use. 1069 */ 1070 goto out; 1071 ret = nfs4_copy_open_stateid(dst, state) ? 0 : -EAGAIN; 1072out: 1073 if (nfs_server_capable(state->inode, NFS_CAP_STATEID_NFSV41)) 1074 dst->seqid = 0; 1075 return ret; 1076} 1077 1078struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask) 1079{ 1080 struct nfs_seqid *new; 1081 1082 new = kmalloc(sizeof(*new), gfp_mask); 1083 if (new == NULL) 1084 return ERR_PTR(-ENOMEM); 1085 new->sequence = counter; 1086 INIT_LIST_HEAD(&new->list); 1087 new->task = NULL; 1088 return new; 1089} 1090 1091void nfs_release_seqid(struct nfs_seqid *seqid) 1092{ 1093 struct nfs_seqid_counter *sequence; 1094 1095 if (seqid == NULL || list_empty(&seqid->list)) 1096 return; 1097 sequence = seqid->sequence; 1098 spin_lock(&sequence->lock); 1099 list_del_init(&seqid->list); 1100 if (!list_empty(&sequence->list)) { 1101 struct nfs_seqid *next; 1102 1103 next = list_first_entry(&sequence->list, 1104 struct nfs_seqid, list); 1105 rpc_wake_up_queued_task(&sequence->wait, next->task); 1106 } 1107 spin_unlock(&sequence->lock); 1108} 1109 1110void nfs_free_seqid(struct nfs_seqid *seqid) 1111{ 1112 nfs_release_seqid(seqid); 1113 kfree(seqid); 1114} 1115 1116/* 1117 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or 1118 * failed with a seqid incrementing error - 1119 * see comments nfs4.h:seqid_mutating_error() 1120 */ 1121static void nfs_increment_seqid(int status, struct nfs_seqid *seqid) 1122{ 1123 switch (status) { 1124 case 0: 1125 break; 1126 case -NFS4ERR_BAD_SEQID: 1127 if (seqid->sequence->flags & NFS_SEQID_CONFIRMED) 1128 return; 1129 pr_warn_ratelimited("NFS: v4 server returned a bad" 1130 " sequence-id error on an" 1131 " unconfirmed sequence %p!\n", 1132 seqid->sequence); 1133 case -NFS4ERR_STALE_CLIENTID: 1134 case -NFS4ERR_STALE_STATEID: 1135 case -NFS4ERR_BAD_STATEID: 1136 case -NFS4ERR_BADXDR: 1137 case -NFS4ERR_RESOURCE: 1138 case -NFS4ERR_NOFILEHANDLE: 1139 case -NFS4ERR_MOVED: 1140 /* Non-seqid mutating errors */ 1141 return; 1142 } 1143 /* 1144 * Note: no locking needed as we are guaranteed to be first 1145 * on the sequence list 1146 */ 1147 seqid->sequence->counter++; 1148} 1149 1150void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid) 1151{ 1152 struct nfs4_state_owner *sp; 1153 1154 if (seqid == NULL) 1155 return; 1156 1157 sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid); 1158 if (status == -NFS4ERR_BAD_SEQID) 1159 nfs4_reset_state_owner(sp); 1160 if (!nfs4_has_session(sp->so_server->nfs_client)) 1161 nfs_increment_seqid(status, seqid); 1162} 1163 1164/* 1165 * Increment the seqid if the LOCK/LOCKU succeeded, or 1166 * failed with a seqid incrementing error - 1167 * see comments nfs4.h:seqid_mutating_error() 1168 */ 1169void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid) 1170{ 1171 if (seqid != NULL) 1172 nfs_increment_seqid(status, seqid); 1173} 1174 1175int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task) 1176{ 1177 struct nfs_seqid_counter *sequence; 1178 int status = 0; 1179 1180 if (seqid == NULL) 1181 goto out; 1182 sequence = seqid->sequence; 1183 spin_lock(&sequence->lock); 1184 seqid->task = task; 1185 if (list_empty(&seqid->list)) 1186 list_add_tail(&seqid->list, &sequence->list); 1187 if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid) 1188 goto unlock; 1189 rpc_sleep_on(&sequence->wait, task, NULL); 1190 status = -EAGAIN; 1191unlock: 1192 spin_unlock(&sequence->lock); 1193out: 1194 return status; 1195} 1196 1197static int nfs4_run_state_manager(void *); 1198 1199static void nfs4_clear_state_manager_bit(struct nfs_client *clp) 1200{ 1201 smp_mb__before_atomic(); 1202 clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state); 1203 smp_mb__after_atomic(); 1204 wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING); 1205 rpc_wake_up(&clp->cl_rpcwaitq); 1206} 1207 1208/* 1209 * Schedule the nfs_client asynchronous state management routine 1210 */ 1211void nfs4_schedule_state_manager(struct nfs_client *clp) 1212{ 1213 struct task_struct *task; 1214 char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1]; 1215 struct rpc_clnt *clnt = clp->cl_rpcclient; 1216 bool swapon = false; 1217 1218 set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state); 1219 1220 if (atomic_read(&clnt->cl_swapper)) { 1221 swapon = !test_and_set_bit(NFS4CLNT_MANAGER_AVAILABLE, 1222 &clp->cl_state); 1223 if (!swapon) { 1224 wake_up_var(&clp->cl_state); 1225 return; 1226 } 1227 } 1228 1229 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) 1230 return; 1231 1232 __module_get(THIS_MODULE); 1233 refcount_inc(&clp->cl_count); 1234 1235 /* The rcu_read_lock() is not strictly necessary, as the state 1236 * manager is the only thread that ever changes the rpc_xprt 1237 * after it's initialized. At this point, we're single threaded. */ 1238 rcu_read_lock(); 1239 snprintf(buf, sizeof(buf), "%s-manager", 1240 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)); 1241 rcu_read_unlock(); 1242 task = kthread_run(nfs4_run_state_manager, clp, "%s", buf); 1243 if (IS_ERR(task)) { 1244 printk(KERN_ERR "%s: kthread_run: %ld\n", 1245 __func__, PTR_ERR(task)); 1246 if (!nfs_client_init_is_complete(clp)) 1247 nfs_mark_client_ready(clp, PTR_ERR(task)); 1248 if (swapon) 1249 clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state); 1250 nfs4_clear_state_manager_bit(clp); 1251 nfs_put_client(clp); 1252 module_put(THIS_MODULE); 1253 } 1254} 1255 1256/* 1257 * Schedule a lease recovery attempt 1258 */ 1259void nfs4_schedule_lease_recovery(struct nfs_client *clp) 1260{ 1261 if (!clp) 1262 return; 1263 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 1264 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 1265 dprintk("%s: scheduling lease recovery for server %s\n", __func__, 1266 clp->cl_hostname); 1267 nfs4_schedule_state_manager(clp); 1268} 1269EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery); 1270 1271/** 1272 * nfs4_schedule_migration_recovery - trigger migration recovery 1273 * 1274 * @server: FSID that is migrating 1275 * 1276 * Returns zero if recovery has started, otherwise a negative NFS4ERR 1277 * value is returned. 1278 */ 1279int nfs4_schedule_migration_recovery(const struct nfs_server *server) 1280{ 1281 struct nfs_client *clp = server->nfs_client; 1282 1283 if (server->fh_expire_type != NFS4_FH_PERSISTENT) { 1284 pr_err("NFS: volatile file handles not supported (server %s)\n", 1285 clp->cl_hostname); 1286 return -NFS4ERR_IO; 1287 } 1288 1289 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) 1290 return -NFS4ERR_IO; 1291 1292 dprintk("%s: scheduling migration recovery for (%llx:%llx) on %s\n", 1293 __func__, 1294 (unsigned long long)server->fsid.major, 1295 (unsigned long long)server->fsid.minor, 1296 clp->cl_hostname); 1297 1298 set_bit(NFS_MIG_IN_TRANSITION, 1299 &((struct nfs_server *)server)->mig_status); 1300 set_bit(NFS4CLNT_MOVED, &clp->cl_state); 1301 1302 nfs4_schedule_state_manager(clp); 1303 return 0; 1304} 1305EXPORT_SYMBOL_GPL(nfs4_schedule_migration_recovery); 1306 1307/** 1308 * nfs4_schedule_lease_moved_recovery - start lease-moved recovery 1309 * 1310 * @clp: server to check for moved leases 1311 * 1312 */ 1313void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp) 1314{ 1315 dprintk("%s: scheduling lease-moved recovery for client ID %llx on %s\n", 1316 __func__, clp->cl_clientid, clp->cl_hostname); 1317 1318 set_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state); 1319 nfs4_schedule_state_manager(clp); 1320} 1321EXPORT_SYMBOL_GPL(nfs4_schedule_lease_moved_recovery); 1322 1323int nfs4_wait_clnt_recover(struct nfs_client *clp) 1324{ 1325 int res; 1326 1327 might_sleep(); 1328 1329 refcount_inc(&clp->cl_count); 1330 res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING, 1331 nfs_wait_bit_killable, TASK_KILLABLE); 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 = inode->i_flctx; 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 list_for_each_entry(fl, list, fl_list) { 1532 if (nfs_file_open_context(fl->fl_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{ 1621 struct nfs4_lock_state *lock; 1622 int status; 1623 1624 status = ops->recover_open(sp, state); 1625 if (status < 0) 1626 return status; 1627 1628 status = nfs4_reclaim_locks(state, ops); 1629 if (status < 0) 1630 return status; 1631 1632 if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) { 1633 spin_lock(&state->state_lock); 1634 list_for_each_entry(lock, &state->lock_states, ls_locks) { 1635 trace_nfs4_state_lock_reclaim(state, lock); 1636 if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags)) 1637 pr_warn_ratelimited("NFS: %s: Lock reclaim failed!\n", __func__); 1638 } 1639 spin_unlock(&state->state_lock); 1640 } 1641 1642 nfs42_complete_copies(sp, state); 1643 clear_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags); 1644 return status; 1645} 1646 1647static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops) 1648{ 1649 struct nfs4_state *state; 1650 unsigned int loop = 0; 1651 int status = 0; 1652#ifdef CONFIG_NFS_V4_2 1653 bool found_ssc_copy_state = false; 1654#endif /* CONFIG_NFS_V4_2 */ 1655 1656 /* Note: we rely on the sp->so_states list being ordered 1657 * so that we always reclaim open(O_RDWR) and/or open(O_WRITE) 1658 * states first. 1659 * This is needed to ensure that the server won't give us any 1660 * read delegations that we have to return if, say, we are 1661 * recovering after a network partition or a reboot from a 1662 * server that doesn't support a grace period. 1663 */ 1664 spin_lock(&sp->so_lock); 1665 raw_write_seqcount_begin(&sp->so_reclaim_seqcount); 1666restart: 1667 list_for_each_entry(state, &sp->so_states, open_states) { 1668 if (!test_and_clear_bit(ops->state_flag_bit, &state->flags)) 1669 continue; 1670 if (!nfs4_valid_open_stateid(state)) 1671 continue; 1672 if (state->state == 0) 1673 continue; 1674#ifdef CONFIG_NFS_V4_2 1675 if (test_bit(NFS_SRV_SSC_COPY_STATE, &state->flags)) { 1676 nfs4_state_mark_recovery_failed(state, -EIO); 1677 found_ssc_copy_state = true; 1678 continue; 1679 } 1680#endif /* CONFIG_NFS_V4_2 */ 1681 refcount_inc(&state->count); 1682 spin_unlock(&sp->so_lock); 1683 status = __nfs4_reclaim_open_state(sp, state, ops); 1684 1685 switch (status) { 1686 default: 1687 if (status >= 0) { 1688 loop = 0; 1689 break; 1690 } 1691 printk(KERN_ERR "NFS: %s: unhandled error %d\n", __func__, status); 1692 fallthrough; 1693 case -ENOENT: 1694 case -ENOMEM: 1695 case -EACCES: 1696 case -EROFS: 1697 case -EIO: 1698 case -ESTALE: 1699 /* Open state on this file cannot be recovered */ 1700 nfs4_state_mark_recovery_failed(state, status); 1701 break; 1702 case -EAGAIN: 1703 ssleep(1); 1704 if (loop++ < 10) { 1705 set_bit(ops->state_flag_bit, &state->flags); 1706 break; 1707 } 1708 fallthrough; 1709 case -NFS4ERR_ADMIN_REVOKED: 1710 case -NFS4ERR_STALE_STATEID: 1711 case -NFS4ERR_OLD_STATEID: 1712 case -NFS4ERR_BAD_STATEID: 1713 case -NFS4ERR_RECLAIM_BAD: 1714 case -NFS4ERR_RECLAIM_CONFLICT: 1715 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state); 1716 break; 1717 case -NFS4ERR_EXPIRED: 1718 case -NFS4ERR_NO_GRACE: 1719 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state); 1720 fallthrough; 1721 case -NFS4ERR_STALE_CLIENTID: 1722 case -NFS4ERR_BADSESSION: 1723 case -NFS4ERR_BADSLOT: 1724 case -NFS4ERR_BAD_HIGH_SLOT: 1725 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1726 case -ETIMEDOUT: 1727 goto out_err; 1728 } 1729 nfs4_put_open_state(state); 1730 spin_lock(&sp->so_lock); 1731 goto restart; 1732 } 1733 raw_write_seqcount_end(&sp->so_reclaim_seqcount); 1734 spin_unlock(&sp->so_lock); 1735#ifdef CONFIG_NFS_V4_2 1736 if (found_ssc_copy_state) 1737 return -EIO; 1738#endif /* CONFIG_NFS_V4_2 */ 1739 return 0; 1740out_err: 1741 nfs4_put_open_state(state); 1742 spin_lock(&sp->so_lock); 1743 raw_write_seqcount_end(&sp->so_reclaim_seqcount); 1744 spin_unlock(&sp->so_lock); 1745 return status; 1746} 1747 1748static void nfs4_clear_open_state(struct nfs4_state *state) 1749{ 1750 struct nfs4_lock_state *lock; 1751 1752 clear_bit(NFS_DELEGATED_STATE, &state->flags); 1753 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1754 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1755 clear_bit(NFS_O_RDWR_STATE, &state->flags); 1756 spin_lock(&state->state_lock); 1757 list_for_each_entry(lock, &state->lock_states, ls_locks) { 1758 lock->ls_seqid.flags = 0; 1759 clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags); 1760 } 1761 spin_unlock(&state->state_lock); 1762} 1763 1764static void nfs4_reset_seqids(struct nfs_server *server, 1765 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state)) 1766{ 1767 struct nfs_client *clp = server->nfs_client; 1768 struct nfs4_state_owner *sp; 1769 struct rb_node *pos; 1770 struct nfs4_state *state; 1771 1772 spin_lock(&clp->cl_lock); 1773 for (pos = rb_first(&server->state_owners); 1774 pos != NULL; 1775 pos = rb_next(pos)) { 1776 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node); 1777 sp->so_seqid.flags = 0; 1778 spin_lock(&sp->so_lock); 1779 list_for_each_entry(state, &sp->so_states, open_states) { 1780 if (mark_reclaim(clp, state)) 1781 nfs4_clear_open_state(state); 1782 } 1783 spin_unlock(&sp->so_lock); 1784 } 1785 spin_unlock(&clp->cl_lock); 1786} 1787 1788static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp, 1789 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state)) 1790{ 1791 struct nfs_server *server; 1792 1793 rcu_read_lock(); 1794 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1795 nfs4_reset_seqids(server, mark_reclaim); 1796 rcu_read_unlock(); 1797} 1798 1799static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp) 1800{ 1801 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); 1802 /* Mark all delegations for reclaim */ 1803 nfs_delegation_mark_reclaim(clp); 1804 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot); 1805} 1806 1807static int nfs4_reclaim_complete(struct nfs_client *clp, 1808 const struct nfs4_state_recovery_ops *ops, 1809 const struct cred *cred) 1810{ 1811 /* Notify the server we're done reclaiming our state */ 1812 if (ops->reclaim_complete) 1813 return ops->reclaim_complete(clp, cred); 1814 return 0; 1815} 1816 1817static void nfs4_clear_reclaim_server(struct nfs_server *server) 1818{ 1819 struct nfs_client *clp = server->nfs_client; 1820 struct nfs4_state_owner *sp; 1821 struct rb_node *pos; 1822 struct nfs4_state *state; 1823 1824 spin_lock(&clp->cl_lock); 1825 for (pos = rb_first(&server->state_owners); 1826 pos != NULL; 1827 pos = rb_next(pos)) { 1828 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node); 1829 spin_lock(&sp->so_lock); 1830 list_for_each_entry(state, &sp->so_states, open_states) { 1831 if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT, 1832 &state->flags)) 1833 continue; 1834 nfs4_state_mark_reclaim_nograce(clp, state); 1835 } 1836 spin_unlock(&sp->so_lock); 1837 } 1838 spin_unlock(&clp->cl_lock); 1839} 1840 1841static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp) 1842{ 1843 struct nfs_server *server; 1844 1845 if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) 1846 return 0; 1847 1848 rcu_read_lock(); 1849 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1850 nfs4_clear_reclaim_server(server); 1851 rcu_read_unlock(); 1852 1853 nfs_delegation_reap_unclaimed(clp); 1854 return 1; 1855} 1856 1857static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp) 1858{ 1859 const struct nfs4_state_recovery_ops *ops; 1860 const struct cred *cred; 1861 int err; 1862 1863 if (!nfs4_state_clear_reclaim_reboot(clp)) 1864 return; 1865 ops = clp->cl_mvops->reboot_recovery_ops; 1866 cred = nfs4_get_clid_cred(clp); 1867 err = nfs4_reclaim_complete(clp, ops, cred); 1868 put_cred(cred); 1869 if (err == -NFS4ERR_CONN_NOT_BOUND_TO_SESSION) 1870 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); 1871} 1872 1873static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp) 1874{ 1875 nfs_mark_test_expired_all_delegations(clp); 1876 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce); 1877} 1878 1879static int nfs4_recovery_handle_error(struct nfs_client *clp, int error) 1880{ 1881 switch (error) { 1882 case 0: 1883 break; 1884 case -NFS4ERR_CB_PATH_DOWN: 1885 nfs40_handle_cb_pathdown(clp); 1886 break; 1887 case -NFS4ERR_NO_GRACE: 1888 nfs4_state_end_reclaim_reboot(clp); 1889 break; 1890 case -NFS4ERR_STALE_CLIENTID: 1891 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1892 nfs4_state_start_reclaim_reboot(clp); 1893 break; 1894 case -NFS4ERR_EXPIRED: 1895 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1896 nfs4_state_start_reclaim_nograce(clp); 1897 break; 1898 case -NFS4ERR_BADSESSION: 1899 case -NFS4ERR_BADSLOT: 1900 case -NFS4ERR_BAD_HIGH_SLOT: 1901 case -NFS4ERR_DEADSESSION: 1902 case -NFS4ERR_SEQ_FALSE_RETRY: 1903 case -NFS4ERR_SEQ_MISORDERED: 1904 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 1905 /* Zero session reset errors */ 1906 break; 1907 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1908 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); 1909 break; 1910 default: 1911 dprintk("%s: failed to handle error %d for server %s\n", 1912 __func__, error, clp->cl_hostname); 1913 return error; 1914 } 1915 dprintk("%s: handled error %d for server %s\n", __func__, error, 1916 clp->cl_hostname); 1917 return 0; 1918} 1919 1920static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops) 1921{ 1922 struct nfs4_state_owner *sp; 1923 struct nfs_server *server; 1924 struct rb_node *pos; 1925 LIST_HEAD(freeme); 1926 int status = 0; 1927 1928restart: 1929 rcu_read_lock(); 1930 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 1931 nfs4_purge_state_owners(server, &freeme); 1932 spin_lock(&clp->cl_lock); 1933 for (pos = rb_first(&server->state_owners); 1934 pos != NULL; 1935 pos = rb_next(pos)) { 1936 sp = rb_entry(pos, 1937 struct nfs4_state_owner, so_server_node); 1938 if (!test_and_clear_bit(ops->owner_flag_bit, 1939 &sp->so_flags)) 1940 continue; 1941 if (!atomic_inc_not_zero(&sp->so_count)) 1942 continue; 1943 spin_unlock(&clp->cl_lock); 1944 rcu_read_unlock(); 1945 1946 status = nfs4_reclaim_open_state(sp, ops); 1947 if (status < 0) { 1948 set_bit(ops->owner_flag_bit, &sp->so_flags); 1949 nfs4_put_state_owner(sp); 1950 status = nfs4_recovery_handle_error(clp, status); 1951 return (status != 0) ? status : -EAGAIN; 1952 } 1953 1954 nfs4_put_state_owner(sp); 1955 goto restart; 1956 } 1957 spin_unlock(&clp->cl_lock); 1958 } 1959 rcu_read_unlock(); 1960 nfs4_free_state_owners(&freeme); 1961 return 0; 1962} 1963 1964static int nfs4_check_lease(struct nfs_client *clp) 1965{ 1966 const struct cred *cred; 1967 const struct nfs4_state_maintenance_ops *ops = 1968 clp->cl_mvops->state_renewal_ops; 1969 int status; 1970 1971 /* Is the client already known to have an expired lease? */ 1972 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 1973 return 0; 1974 cred = ops->get_state_renewal_cred(clp); 1975 if (cred == NULL) { 1976 cred = nfs4_get_clid_cred(clp); 1977 status = -ENOKEY; 1978 if (cred == NULL) 1979 goto out; 1980 } 1981 status = ops->renew_lease(clp, cred); 1982 put_cred(cred); 1983 if (status == -ETIMEDOUT) { 1984 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 1985 return 0; 1986 } 1987out: 1988 return nfs4_recovery_handle_error(clp, status); 1989} 1990 1991/* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors 1992 * and for recoverable errors on EXCHANGE_ID for v4.1 1993 */ 1994static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status) 1995{ 1996 switch (status) { 1997 case -NFS4ERR_SEQ_MISORDERED: 1998 if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) 1999 return -ESERVERFAULT; 2000 /* Lease confirmation error: retry after purging the lease */ 2001 ssleep(1); 2002 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 2003 break; 2004 case -NFS4ERR_STALE_CLIENTID: 2005 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 2006 nfs4_state_start_reclaim_reboot(clp); 2007 break; 2008 case -NFS4ERR_CLID_INUSE: 2009 pr_err("NFS: Server %s reports our clientid is in use\n", 2010 clp->cl_hostname); 2011 nfs_mark_client_ready(clp, -EPERM); 2012 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 2013 return -EPERM; 2014 case -EACCES: 2015 case -NFS4ERR_DELAY: 2016 case -EAGAIN: 2017 ssleep(1); 2018 break; 2019 2020 case -NFS4ERR_MINOR_VERS_MISMATCH: 2021 if (clp->cl_cons_state == NFS_CS_SESSION_INITING) 2022 nfs_mark_client_ready(clp, -EPROTONOSUPPORT); 2023 dprintk("%s: exit with error %d for server %s\n", 2024 __func__, -EPROTONOSUPPORT, clp->cl_hostname); 2025 return -EPROTONOSUPPORT; 2026 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery 2027 * in nfs4_exchange_id */ 2028 default: 2029 dprintk("%s: exit with error %d for server %s\n", __func__, 2030 status, clp->cl_hostname); 2031 return status; 2032 } 2033 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 2034 dprintk("%s: handled error %d for server %s\n", __func__, status, 2035 clp->cl_hostname); 2036 return 0; 2037} 2038 2039static int nfs4_establish_lease(struct nfs_client *clp) 2040{ 2041 const struct cred *cred; 2042 const struct nfs4_state_recovery_ops *ops = 2043 clp->cl_mvops->reboot_recovery_ops; 2044 int status; 2045 2046 status = nfs4_begin_drain_session(clp); 2047 if (status != 0) 2048 return status; 2049 cred = nfs4_get_clid_cred(clp); 2050 if (cred == NULL) 2051 return -ENOENT; 2052 status = ops->establish_clid(clp, cred); 2053 put_cred(cred); 2054 if (status != 0) 2055 return status; 2056 pnfs_destroy_all_layouts(clp); 2057 return 0; 2058} 2059 2060/* 2061 * Returns zero or a negative errno. NFS4ERR values are converted 2062 * to local errno values. 2063 */ 2064static int nfs4_reclaim_lease(struct nfs_client *clp) 2065{ 2066 int status; 2067 2068 status = nfs4_establish_lease(clp); 2069 if (status < 0) 2070 return nfs4_handle_reclaim_lease_error(clp, status); 2071 if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state)) 2072 nfs4_state_start_reclaim_nograce(clp); 2073 if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) 2074 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); 2075 clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 2076 clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 2077 return 0; 2078} 2079 2080static int nfs4_purge_lease(struct nfs_client *clp) 2081{ 2082 int status; 2083 2084 status = nfs4_establish_lease(clp); 2085 if (status < 0) 2086 return nfs4_handle_reclaim_lease_error(clp, status); 2087 clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state); 2088 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 2089 nfs4_state_start_reclaim_nograce(clp); 2090 return 0; 2091} 2092 2093/* 2094 * Try remote migration of one FSID from a source server to a 2095 * destination server. The source server provides a list of 2096 * potential destinations. 2097 * 2098 * Returns zero or a negative NFS4ERR status code. 2099 */ 2100static int nfs4_try_migration(struct nfs_server *server, const struct cred *cred) 2101{ 2102 struct nfs_client *clp = server->nfs_client; 2103 struct nfs4_fs_locations *locations = NULL; 2104 struct inode *inode; 2105 struct page *page; 2106 int status, result; 2107 2108 dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__, 2109 (unsigned long long)server->fsid.major, 2110 (unsigned long long)server->fsid.minor, 2111 clp->cl_hostname); 2112 2113 result = 0; 2114 page = alloc_page(GFP_KERNEL); 2115 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL); 2116 if (page == NULL || locations == NULL) { 2117 dprintk("<-- %s: no memory\n", __func__); 2118 goto out; 2119 } 2120 2121 inode = d_inode(server->super->s_root); 2122 result = nfs4_proc_get_locations(inode, locations, page, cred); 2123 if (result) { 2124 dprintk("<-- %s: failed to retrieve fs_locations: %d\n", 2125 __func__, result); 2126 goto out; 2127 } 2128 2129 result = -NFS4ERR_NXIO; 2130 if (!locations->nlocations) 2131 goto out; 2132 2133 if (!(locations->fattr.valid & NFS_ATTR_FATTR_V4_LOCATIONS)) { 2134 dprintk("<-- %s: No fs_locations data, migration skipped\n", 2135 __func__); 2136 goto out; 2137 } 2138 2139 status = nfs4_begin_drain_session(clp); 2140 if (status != 0) { 2141 result = status; 2142 goto out; 2143 } 2144 2145 status = nfs4_replace_transport(server, locations); 2146 if (status != 0) { 2147 dprintk("<-- %s: failed to replace transport: %d\n", 2148 __func__, status); 2149 goto out; 2150 } 2151 2152 result = 0; 2153 dprintk("<-- %s: migration succeeded\n", __func__); 2154 2155out: 2156 if (page != NULL) 2157 __free_page(page); 2158 kfree(locations); 2159 if (result) { 2160 pr_err("NFS: migration recovery failed (server %s)\n", 2161 clp->cl_hostname); 2162 set_bit(NFS_MIG_FAILED, &server->mig_status); 2163 } 2164 return result; 2165} 2166 2167/* 2168 * Returns zero or a negative NFS4ERR status code. 2169 */ 2170static int nfs4_handle_migration(struct nfs_client *clp) 2171{ 2172 const struct nfs4_state_maintenance_ops *ops = 2173 clp->cl_mvops->state_renewal_ops; 2174 struct nfs_server *server; 2175 const struct cred *cred; 2176 2177 dprintk("%s: migration reported on \"%s\"\n", __func__, 2178 clp->cl_hostname); 2179 2180 cred = ops->get_state_renewal_cred(clp); 2181 if (cred == NULL) 2182 return -NFS4ERR_NOENT; 2183 2184 clp->cl_mig_gen++; 2185restart: 2186 rcu_read_lock(); 2187 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 2188 int status; 2189 2190 if (server->mig_gen == clp->cl_mig_gen) 2191 continue; 2192 server->mig_gen = clp->cl_mig_gen; 2193 2194 if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION, 2195 &server->mig_status)) 2196 continue; 2197 2198 rcu_read_unlock(); 2199 status = nfs4_try_migration(server, cred); 2200 if (status < 0) { 2201 put_cred(cred); 2202 return status; 2203 } 2204 goto restart; 2205 } 2206 rcu_read_unlock(); 2207 put_cred(cred); 2208 return 0; 2209} 2210 2211/* 2212 * Test each nfs_server on the clp's cl_superblocks list to see 2213 * if it's moved to another server. Stop when the server no longer 2214 * returns NFS4ERR_LEASE_MOVED. 2215 */ 2216static int nfs4_handle_lease_moved(struct nfs_client *clp) 2217{ 2218 const struct nfs4_state_maintenance_ops *ops = 2219 clp->cl_mvops->state_renewal_ops; 2220 struct nfs_server *server; 2221 const struct cred *cred; 2222 2223 dprintk("%s: lease moved reported on \"%s\"\n", __func__, 2224 clp->cl_hostname); 2225 2226 cred = ops->get_state_renewal_cred(clp); 2227 if (cred == NULL) 2228 return -NFS4ERR_NOENT; 2229 2230 clp->cl_mig_gen++; 2231restart: 2232 rcu_read_lock(); 2233 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 2234 struct inode *inode; 2235 int status; 2236 2237 if (server->mig_gen == clp->cl_mig_gen) 2238 continue; 2239 server->mig_gen = clp->cl_mig_gen; 2240 2241 rcu_read_unlock(); 2242 2243 inode = d_inode(server->super->s_root); 2244 status = nfs4_proc_fsid_present(inode, cred); 2245 if (status != -NFS4ERR_MOVED) 2246 goto restart; /* wasn't this one */ 2247 if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED) 2248 goto restart; /* there are more */ 2249 goto out; 2250 } 2251 rcu_read_unlock(); 2252 2253out: 2254 put_cred(cred); 2255 return 0; 2256} 2257 2258/** 2259 * nfs4_discover_server_trunking - Detect server IP address trunking 2260 * 2261 * @clp: nfs_client under test 2262 * @result: OUT: found nfs_client, or clp 2263 * 2264 * Returns zero or a negative errno. If zero is returned, 2265 * an nfs_client pointer is planted in "result". 2266 * 2267 * Note: since we are invoked in process context, and 2268 * not from inside the state manager, we cannot use 2269 * nfs4_handle_reclaim_lease_error(). 2270 */ 2271int nfs4_discover_server_trunking(struct nfs_client *clp, 2272 struct nfs_client **result) 2273{ 2274 const struct nfs4_state_recovery_ops *ops = 2275 clp->cl_mvops->reboot_recovery_ops; 2276 struct rpc_clnt *clnt; 2277 const struct cred *cred; 2278 int i, status; 2279 2280 dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname); 2281 2282 clnt = clp->cl_rpcclient; 2283 i = 0; 2284 2285 mutex_lock(&nfs_clid_init_mutex); 2286again: 2287 status = -ENOENT; 2288 cred = nfs4_get_clid_cred(clp); 2289 if (cred == NULL) 2290 goto out_unlock; 2291 2292 status = ops->detect_trunking(clp, result, cred); 2293 put_cred(cred); 2294 switch (status) { 2295 case 0: 2296 case -EINTR: 2297 case -ERESTARTSYS: 2298 break; 2299 case -ETIMEDOUT: 2300 if (clnt->cl_softrtry) 2301 break; 2302 fallthrough; 2303 case -NFS4ERR_DELAY: 2304 case -EAGAIN: 2305 ssleep(1); 2306 fallthrough; 2307 case -NFS4ERR_STALE_CLIENTID: 2308 dprintk("NFS: %s after status %d, retrying\n", 2309 __func__, status); 2310 goto again; 2311 case -EACCES: 2312 if (i++ == 0) { 2313 nfs4_root_machine_cred(clp); 2314 goto again; 2315 } 2316 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) 2317 break; 2318 fallthrough; 2319 case -NFS4ERR_CLID_INUSE: 2320 case -NFS4ERR_WRONGSEC: 2321 /* No point in retrying if we already used RPC_AUTH_UNIX */ 2322 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) { 2323 status = -EPERM; 2324 break; 2325 } 2326 clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX); 2327 if (IS_ERR(clnt)) { 2328 status = PTR_ERR(clnt); 2329 break; 2330 } 2331 /* Note: this is safe because we haven't yet marked the 2332 * client as ready, so we are the only user of 2333 * clp->cl_rpcclient 2334 */ 2335 clnt = xchg(&clp->cl_rpcclient, clnt); 2336 rpc_shutdown_client(clnt); 2337 clnt = clp->cl_rpcclient; 2338 goto again; 2339 2340 case -NFS4ERR_MINOR_VERS_MISMATCH: 2341 status = -EPROTONOSUPPORT; 2342 break; 2343 2344 case -EKEYEXPIRED: 2345 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery 2346 * in nfs4_exchange_id */ 2347 status = -EKEYEXPIRED; 2348 break; 2349 default: 2350 pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n", 2351 __func__, status); 2352 status = -EIO; 2353 } 2354 2355out_unlock: 2356 mutex_unlock(&nfs_clid_init_mutex); 2357 dprintk("NFS: %s: status = %d\n", __func__, status); 2358 return status; 2359} 2360 2361#ifdef CONFIG_NFS_V4_1 2362void nfs4_schedule_session_recovery(struct nfs4_session *session, int err) 2363{ 2364 struct nfs_client *clp = session->clp; 2365 2366 switch (err) { 2367 default: 2368 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 2369 break; 2370 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 2371 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); 2372 } 2373 nfs4_schedule_state_manager(clp); 2374} 2375EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery); 2376 2377void nfs41_notify_server(struct nfs_client *clp) 2378{ 2379 /* Use CHECK_LEASE to ping the server with a SEQUENCE */ 2380 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 2381 nfs4_schedule_state_manager(clp); 2382} 2383 2384static void nfs4_reset_all_state(struct nfs_client *clp) 2385{ 2386 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) { 2387 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state); 2388 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 2389 nfs4_state_start_reclaim_nograce(clp); 2390 dprintk("%s: scheduling reset of all state for server %s!\n", 2391 __func__, clp->cl_hostname); 2392 nfs4_schedule_state_manager(clp); 2393 } 2394} 2395 2396static void nfs41_handle_server_reboot(struct nfs_client *clp) 2397{ 2398 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) { 2399 nfs4_state_start_reclaim_reboot(clp); 2400 dprintk("%s: server %s rebooted!\n", __func__, 2401 clp->cl_hostname); 2402 nfs4_schedule_state_manager(clp); 2403 } 2404} 2405 2406static void nfs41_handle_all_state_revoked(struct nfs_client *clp) 2407{ 2408 nfs4_reset_all_state(clp); 2409 dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname); 2410} 2411 2412static void nfs41_handle_some_state_revoked(struct nfs_client *clp) 2413{ 2414 nfs4_state_start_reclaim_nograce(clp); 2415 nfs4_schedule_state_manager(clp); 2416 2417 dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname); 2418} 2419 2420static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp) 2421{ 2422 /* FIXME: For now, we destroy all layouts. */ 2423 pnfs_destroy_all_layouts(clp); 2424 nfs_test_expired_all_delegations(clp); 2425 dprintk("%s: Recallable state revoked on server %s!\n", __func__, 2426 clp->cl_hostname); 2427} 2428 2429static void nfs41_handle_backchannel_fault(struct nfs_client *clp) 2430{ 2431 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 2432 nfs4_schedule_state_manager(clp); 2433 2434 dprintk("%s: server %s declared a backchannel fault\n", __func__, 2435 clp->cl_hostname); 2436} 2437 2438static void nfs41_handle_cb_path_down(struct nfs_client *clp) 2439{ 2440 if (test_and_set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, 2441 &clp->cl_state) == 0) 2442 nfs4_schedule_state_manager(clp); 2443} 2444 2445void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags, 2446 bool recovery) 2447{ 2448 if (!flags) 2449 return; 2450 2451 dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n", 2452 __func__, clp->cl_hostname, clp->cl_clientid, flags); 2453 /* 2454 * If we're called from the state manager thread, then assume we're 2455 * already handling the RECLAIM_NEEDED and/or STATE_REVOKED. 2456 * Those flags are expected to remain set until we're done 2457 * recovering (see RFC5661, section 18.46.3). 2458 */ 2459 if (recovery) 2460 goto out_recovery; 2461 2462 if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED) 2463 nfs41_handle_server_reboot(clp); 2464 if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED)) 2465 nfs41_handle_all_state_revoked(clp); 2466 if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED | 2467 SEQ4_STATUS_ADMIN_STATE_REVOKED)) 2468 nfs41_handle_some_state_revoked(clp); 2469 if (flags & SEQ4_STATUS_LEASE_MOVED) 2470 nfs4_schedule_lease_moved_recovery(clp); 2471 if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED) 2472 nfs41_handle_recallable_state_revoked(clp); 2473out_recovery: 2474 if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT) 2475 nfs41_handle_backchannel_fault(clp); 2476 else if (flags & (SEQ4_STATUS_CB_PATH_DOWN | 2477 SEQ4_STATUS_CB_PATH_DOWN_SESSION)) 2478 nfs41_handle_cb_path_down(clp); 2479} 2480 2481static int nfs4_reset_session(struct nfs_client *clp) 2482{ 2483 const struct cred *cred; 2484 int status; 2485 2486 if (!nfs4_has_session(clp)) 2487 return 0; 2488 status = nfs4_begin_drain_session(clp); 2489 if (status != 0) 2490 return status; 2491 cred = nfs4_get_clid_cred(clp); 2492 status = nfs4_proc_destroy_session(clp->cl_session, cred); 2493 switch (status) { 2494 case 0: 2495 case -NFS4ERR_BADSESSION: 2496 case -NFS4ERR_DEADSESSION: 2497 break; 2498 case -NFS4ERR_BACK_CHAN_BUSY: 2499 case -NFS4ERR_DELAY: 2500 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 2501 status = 0; 2502 ssleep(1); 2503 goto out; 2504 default: 2505 status = nfs4_recovery_handle_error(clp, status); 2506 goto out; 2507 } 2508 2509 memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN); 2510 status = nfs4_proc_create_session(clp, cred); 2511 if (status) { 2512 dprintk("%s: session reset failed with status %d for server %s!\n", 2513 __func__, status, clp->cl_hostname); 2514 status = nfs4_handle_reclaim_lease_error(clp, status); 2515 goto out; 2516 } 2517 nfs41_finish_session_reset(clp); 2518 dprintk("%s: session reset was successful for server %s!\n", 2519 __func__, clp->cl_hostname); 2520out: 2521 put_cred(cred); 2522 return status; 2523} 2524 2525static int nfs4_bind_conn_to_session(struct nfs_client *clp) 2526{ 2527 const struct cred *cred; 2528 int ret; 2529 2530 if (!nfs4_has_session(clp)) 2531 return 0; 2532 ret = nfs4_begin_drain_session(clp); 2533 if (ret != 0) 2534 return ret; 2535 cred = nfs4_get_clid_cred(clp); 2536 ret = nfs4_proc_bind_conn_to_session(clp, cred); 2537 put_cred(cred); 2538 clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); 2539 switch (ret) { 2540 case 0: 2541 dprintk("%s: bind_conn_to_session was successful for server %s!\n", 2542 __func__, clp->cl_hostname); 2543 break; 2544 case -NFS4ERR_DELAY: 2545 ssleep(1); 2546 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); 2547 break; 2548 default: 2549 return nfs4_recovery_handle_error(clp, ret); 2550 } 2551 return 0; 2552} 2553 2554static void nfs4_layoutreturn_any_run(struct nfs_client *clp) 2555{ 2556 int iomode = 0; 2557 2558 if (test_and_clear_bit(NFS4CLNT_RECALL_ANY_LAYOUT_READ, &clp->cl_state)) 2559 iomode += IOMODE_READ; 2560 if (test_and_clear_bit(NFS4CLNT_RECALL_ANY_LAYOUT_RW, &clp->cl_state)) 2561 iomode += IOMODE_RW; 2562 /* Note: IOMODE_READ + IOMODE_RW == IOMODE_ANY */ 2563 if (iomode) { 2564 pnfs_layout_return_unused_byclid(clp, iomode); 2565 set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state); 2566 } 2567} 2568#else /* CONFIG_NFS_V4_1 */ 2569static int nfs4_reset_session(struct nfs_client *clp) { return 0; } 2570 2571static int nfs4_bind_conn_to_session(struct nfs_client *clp) 2572{ 2573 return 0; 2574} 2575 2576static void nfs4_layoutreturn_any_run(struct nfs_client *clp) 2577{ 2578} 2579#endif /* CONFIG_NFS_V4_1 */ 2580 2581static void nfs4_state_manager(struct nfs_client *clp) 2582{ 2583 unsigned int memflags; 2584 int status = 0; 2585 const char *section = "", *section_sep = ""; 2586 2587 /* 2588 * State recovery can deadlock if the direct reclaim code tries 2589 * start NFS writeback. So ensure memory allocations are all 2590 * GFP_NOFS. 2591 */ 2592 memflags = memalloc_nofs_save(); 2593 2594 /* Ensure exclusive access to NFSv4 state */ 2595 do { 2596 trace_nfs4_state_mgr(clp); 2597 clear_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state); 2598 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) { 2599 section = "purge state"; 2600 status = nfs4_purge_lease(clp); 2601 if (status < 0) 2602 goto out_error; 2603 continue; 2604 } 2605 2606 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) { 2607 section = "lease expired"; 2608 /* We're going to have to re-establish a clientid */ 2609 status = nfs4_reclaim_lease(clp); 2610 if (status < 0) 2611 goto out_error; 2612 continue; 2613 } 2614 2615 /* Initialize or reset the session */ 2616 if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) { 2617 section = "reset session"; 2618 status = nfs4_reset_session(clp); 2619 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 2620 continue; 2621 if (status < 0) 2622 goto out_error; 2623 } 2624 2625 /* Send BIND_CONN_TO_SESSION */ 2626 if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, 2627 &clp->cl_state)) { 2628 section = "bind conn to session"; 2629 status = nfs4_bind_conn_to_session(clp); 2630 if (status < 0) 2631 goto out_error; 2632 continue; 2633 } 2634 2635 if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) { 2636 section = "check lease"; 2637 status = nfs4_check_lease(clp); 2638 if (status < 0) 2639 goto out_error; 2640 continue; 2641 } 2642 2643 if (test_and_clear_bit(NFS4CLNT_MOVED, &clp->cl_state)) { 2644 section = "migration"; 2645 status = nfs4_handle_migration(clp); 2646 if (status < 0) 2647 goto out_error; 2648 } 2649 2650 if (test_and_clear_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state)) { 2651 section = "lease moved"; 2652 status = nfs4_handle_lease_moved(clp); 2653 if (status < 0) 2654 goto out_error; 2655 } 2656 2657 /* First recover reboot state... */ 2658 if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) { 2659 section = "reclaim reboot"; 2660 status = nfs4_do_reclaim(clp, 2661 clp->cl_mvops->reboot_recovery_ops); 2662 if (status == -EAGAIN) 2663 continue; 2664 if (status < 0) 2665 goto out_error; 2666 nfs4_state_end_reclaim_reboot(clp); 2667 continue; 2668 } 2669 2670 /* Detect expired delegations... */ 2671 if (test_and_clear_bit(NFS4CLNT_DELEGATION_EXPIRED, &clp->cl_state)) { 2672 section = "detect expired delegations"; 2673 nfs_reap_expired_delegations(clp); 2674 continue; 2675 } 2676 2677 /* Now recover expired state... */ 2678 if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) { 2679 section = "reclaim nograce"; 2680 status = nfs4_do_reclaim(clp, 2681 clp->cl_mvops->nograce_recovery_ops); 2682 if (status == -EAGAIN) 2683 continue; 2684 if (status < 0) 2685 goto out_error; 2686 clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state); 2687 } 2688 2689 memalloc_nofs_restore(memflags); 2690 nfs4_end_drain_session(clp); 2691 nfs4_clear_state_manager_bit(clp); 2692 2693 if (test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) && 2694 !test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, 2695 &clp->cl_state)) { 2696 memflags = memalloc_nofs_save(); 2697 continue; 2698 } 2699 2700 if (!test_and_set_bit(NFS4CLNT_RECALL_RUNNING, &clp->cl_state)) { 2701 if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) { 2702 nfs_client_return_marked_delegations(clp); 2703 set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state); 2704 } 2705 nfs4_layoutreturn_any_run(clp); 2706 clear_bit(NFS4CLNT_RECALL_RUNNING, &clp->cl_state); 2707 } 2708 2709 return; 2710 2711 } while (refcount_read(&clp->cl_count) > 1 && !signalled()); 2712 goto out_drain; 2713 2714out_error: 2715 if (strlen(section)) 2716 section_sep = ": "; 2717 trace_nfs4_state_mgr_failed(clp, section, status); 2718 pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s" 2719 " with error %d\n", section_sep, section, 2720 clp->cl_hostname, -status); 2721 ssleep(1); 2722out_drain: 2723 memalloc_nofs_restore(memflags); 2724 nfs4_end_drain_session(clp); 2725 nfs4_clear_state_manager_bit(clp); 2726} 2727 2728static int nfs4_run_state_manager(void *ptr) 2729{ 2730 struct nfs_client *clp = ptr; 2731 struct rpc_clnt *cl = clp->cl_rpcclient; 2732 2733 while (cl != cl->cl_parent) 2734 cl = cl->cl_parent; 2735 2736 allow_signal(SIGKILL); 2737again: 2738 nfs4_state_manager(clp); 2739 2740 if (test_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state) && 2741 !test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state)) { 2742 wait_var_event_interruptible(&clp->cl_state, 2743 test_bit(NFS4CLNT_RUN_MANAGER, 2744 &clp->cl_state)); 2745 if (!atomic_read(&cl->cl_swapper)) 2746 clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state); 2747 if (refcount_read(&clp->cl_count) > 1 && !signalled() && 2748 !test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state)) 2749 goto again; 2750 /* Either no longer a swapper, or were signalled */ 2751 clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state); 2752 } 2753 2754 if (refcount_read(&clp->cl_count) > 1 && !signalled() && 2755 test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) && 2756 !test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state)) 2757 goto again; 2758 2759 nfs_put_client(clp); 2760 module_put_and_exit(0); 2761 return 0; 2762} 2763 2764/* 2765 * Local variables: 2766 * c-basic-offset: 8 2767 * End: 2768 */ 2769