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