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