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