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