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 68 const nfs4_stateid zero_stateid = { 69 { .data = { 0 } }, 70 .type = NFS4_SPECIAL_STATEID_TYPE, 71 }; 72 static DEFINE_MUTEX(nfs_clid_init_mutex); 73 74 int nfs4_init_clientid(struct nfs_client *clp, struct rpc_cred *cred) 75 { 76 struct nfs4_setclientid_res clid = { 77 .clientid = clp->cl_clientid, 78 .confirm = clp->cl_confirm, 79 }; 80 unsigned short port; 81 int status; 82 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); 83 84 if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state)) 85 goto do_confirm; 86 port = nn->nfs_callback_tcpport; 87 if (clp->cl_addr.ss_family == AF_INET6) 88 port = nn->nfs_callback_tcpport6; 89 90 status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid); 91 if (status != 0) 92 goto out; 93 clp->cl_clientid = clid.clientid; 94 clp->cl_confirm = clid.confirm; 95 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 96 do_confirm: 97 status = nfs4_proc_setclientid_confirm(clp, &clid, cred); 98 if (status != 0) 99 goto out; 100 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 101 nfs4_schedule_state_renewal(clp); 102 out: 103 return status; 104 } 105 106 /** 107 * nfs40_discover_server_trunking - Detect server IP address trunking (mv0) 108 * 109 * @clp: nfs_client under test 110 * @result: OUT: found nfs_client, or clp 111 * @cred: credential to use for trunking test 112 * 113 * Returns zero, a negative errno, or a negative NFS4ERR status. 114 * If zero is returned, an nfs_client pointer is planted in 115 * "result". 116 * 117 * Note: The returned client may not yet be marked ready. 118 */ 119 int nfs40_discover_server_trunking(struct nfs_client *clp, 120 struct nfs_client **result, 121 struct rpc_cred *cred) 122 { 123 struct nfs4_setclientid_res clid = { 124 .clientid = clp->cl_clientid, 125 .confirm = clp->cl_confirm, 126 }; 127 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); 128 unsigned short port; 129 int status; 130 131 port = nn->nfs_callback_tcpport; 132 if (clp->cl_addr.ss_family == AF_INET6) 133 port = nn->nfs_callback_tcpport6; 134 135 status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid); 136 if (status != 0) 137 goto out; 138 clp->cl_clientid = clid.clientid; 139 clp->cl_confirm = clid.confirm; 140 141 status = nfs40_walk_client_list(clp, result, cred); 142 if (status == 0) { 143 /* Sustain the lease, even if it's empty. If the clientid4 144 * goes stale it's of no use for trunking discovery. */ 145 nfs4_schedule_state_renewal(*result); 146 } 147 out: 148 return status; 149 } 150 151 struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp) 152 { 153 struct rpc_cred *cred = NULL; 154 155 if (clp->cl_machine_cred != NULL) 156 cred = get_rpccred(clp->cl_machine_cred); 157 return cred; 158 } 159 160 static void nfs4_root_machine_cred(struct nfs_client *clp) 161 { 162 struct rpc_cred *cred, *new; 163 164 new = rpc_lookup_machine_cred(NULL); 165 spin_lock(&clp->cl_lock); 166 cred = clp->cl_machine_cred; 167 clp->cl_machine_cred = new; 168 spin_unlock(&clp->cl_lock); 169 if (cred != NULL) 170 put_rpccred(cred); 171 } 172 173 static struct rpc_cred * 174 nfs4_get_renew_cred_server_locked(struct nfs_server *server) 175 { 176 struct rpc_cred *cred = NULL; 177 struct nfs4_state_owner *sp; 178 struct rb_node *pos; 179 180 for (pos = rb_first(&server->state_owners); 181 pos != NULL; 182 pos = rb_next(pos)) { 183 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node); 184 if (list_empty(&sp->so_states)) 185 continue; 186 cred = get_rpccred(sp->so_cred); 187 break; 188 } 189 return cred; 190 } 191 192 /** 193 * nfs4_get_renew_cred_locked - Acquire credential for a renew operation 194 * @clp: client state handle 195 * 196 * Returns an rpc_cred with reference count bumped, or NULL. 197 * Caller must hold clp->cl_lock. 198 */ 199 struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp) 200 { 201 struct rpc_cred *cred = NULL; 202 struct nfs_server *server; 203 204 /* Use machine credentials if available */ 205 cred = nfs4_get_machine_cred_locked(clp); 206 if (cred != NULL) 207 goto out; 208 209 rcu_read_lock(); 210 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 211 cred = nfs4_get_renew_cred_server_locked(server); 212 if (cred != NULL) 213 break; 214 } 215 rcu_read_unlock(); 216 217 out: 218 return cred; 219 } 220 221 static void nfs4_end_drain_slot_table(struct nfs4_slot_table *tbl) 222 { 223 if (test_and_clear_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) { 224 spin_lock(&tbl->slot_tbl_lock); 225 nfs41_wake_slot_table(tbl); 226 spin_unlock(&tbl->slot_tbl_lock); 227 } 228 } 229 230 static void nfs4_end_drain_session(struct nfs_client *clp) 231 { 232 struct nfs4_session *ses = clp->cl_session; 233 234 if (clp->cl_slot_tbl) { 235 nfs4_end_drain_slot_table(clp->cl_slot_tbl); 236 return; 237 } 238 239 if (ses != NULL) { 240 nfs4_end_drain_slot_table(&ses->bc_slot_table); 241 nfs4_end_drain_slot_table(&ses->fc_slot_table); 242 } 243 } 244 245 static int nfs4_drain_slot_tbl(struct nfs4_slot_table *tbl) 246 { 247 set_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state); 248 spin_lock(&tbl->slot_tbl_lock); 249 if (tbl->highest_used_slotid != NFS4_NO_SLOT) { 250 reinit_completion(&tbl->complete); 251 spin_unlock(&tbl->slot_tbl_lock); 252 return wait_for_completion_interruptible(&tbl->complete); 253 } 254 spin_unlock(&tbl->slot_tbl_lock); 255 return 0; 256 } 257 258 static int nfs4_begin_drain_session(struct nfs_client *clp) 259 { 260 struct nfs4_session *ses = clp->cl_session; 261 int ret = 0; 262 263 if (clp->cl_slot_tbl) 264 return nfs4_drain_slot_tbl(clp->cl_slot_tbl); 265 266 /* back channel */ 267 ret = nfs4_drain_slot_tbl(&ses->bc_slot_table); 268 if (ret) 269 return ret; 270 /* fore channel */ 271 return nfs4_drain_slot_tbl(&ses->fc_slot_table); 272 } 273 274 #if defined(CONFIG_NFS_V4_1) 275 276 static int nfs41_setup_state_renewal(struct nfs_client *clp) 277 { 278 int status; 279 struct nfs_fsinfo fsinfo; 280 unsigned long now; 281 282 if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) { 283 nfs4_schedule_state_renewal(clp); 284 return 0; 285 } 286 287 now = jiffies; 288 status = nfs4_proc_get_lease_time(clp, &fsinfo); 289 if (status == 0) { 290 nfs4_set_lease_period(clp, fsinfo.lease_time * HZ, now); 291 nfs4_schedule_state_renewal(clp); 292 } 293 294 return status; 295 } 296 297 static 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 306 int 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); 316 do_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); 322 out: 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 */ 339 int 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 */ 375 struct 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 385 static struct nfs4_state_owner * 386 nfs4_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 410 static struct nfs4_state_owner * 411 nfs4_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 442 static void 443 nfs4_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 452 static void 453 nfs4_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 463 static void 464 nfs4_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 */ 474 static struct nfs4_state_owner * 475 nfs4_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 496 static void 497 nfs4_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 514 static 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 521 static 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 */ 553 struct 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); 577 out: 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 */ 594 void 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 */ 614 void 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 633 static struct nfs4_state * 634 nfs4_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 648 void 649 nfs4_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 663 static 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 680 static void 681 nfs4_free_open_state(struct nfs4_state *state) 682 { 683 kfree(state); 684 } 685 686 struct nfs4_state * 687 nfs4_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 } 719 out: 720 return state; 721 } 722 723 void 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 */ 743 static 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 788 void nfs4_close_state(struct nfs4_state *state, fmode_t fmode) 789 { 790 __nfs4_close(state, fmode, GFP_NOFS, 0); 791 } 792 793 void 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 */ 802 static 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 */ 820 static 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; 837 out_free: 838 kfree(lsp); 839 return NULL; 840 } 841 842 void 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 */ 854 static 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 */ 885 void 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 908 static 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 916 static void nfs4_fl_release_lock(struct file_lock *fl) 917 { 918 nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner); 919 } 920 921 static 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 926 int 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 940 static 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); 966 out: 967 return ret; 968 } 969 970 static 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 */ 988 int nfs4_select_rw_stateid(struct nfs4_state *state, 989 fmode_t fmode, const struct nfs_lockowner *lockowner, 990 nfs4_stateid *dst, struct rpc_cred **cred) 991 { 992 int ret; 993 994 if (!nfs4_valid_open_stateid(state)) 995 return -EIO; 996 if (cred != NULL) 997 *cred = NULL; 998 ret = nfs4_copy_lock_stateid(dst, state, lockowner); 999 if (ret == -EIO) 1000 /* A lost lock - don't even consider delegations */ 1001 goto out; 1002 /* returns true if delegation stateid found and copied */ 1003 if (nfs4_copy_delegation_stateid(state->inode, fmode, dst, cred)) { 1004 ret = 0; 1005 goto out; 1006 } 1007 if (ret != -ENOENT) 1008 /* nfs4_copy_delegation_stateid() didn't over-write 1009 * dst, so it still has the lock stateid which we now 1010 * choose to use. 1011 */ 1012 goto out; 1013 nfs4_copy_open_stateid(dst, state); 1014 ret = 0; 1015 out: 1016 if (nfs_server_capable(state->inode, NFS_CAP_STATEID_NFSV41)) 1017 dst->seqid = 0; 1018 return ret; 1019 } 1020 1021 struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask) 1022 { 1023 struct nfs_seqid *new; 1024 1025 new = kmalloc(sizeof(*new), gfp_mask); 1026 if (new == NULL) 1027 return ERR_PTR(-ENOMEM); 1028 new->sequence = counter; 1029 INIT_LIST_HEAD(&new->list); 1030 new->task = NULL; 1031 return new; 1032 } 1033 1034 void nfs_release_seqid(struct nfs_seqid *seqid) 1035 { 1036 struct nfs_seqid_counter *sequence; 1037 1038 if (seqid == NULL || list_empty(&seqid->list)) 1039 return; 1040 sequence = seqid->sequence; 1041 spin_lock(&sequence->lock); 1042 list_del_init(&seqid->list); 1043 if (!list_empty(&sequence->list)) { 1044 struct nfs_seqid *next; 1045 1046 next = list_first_entry(&sequence->list, 1047 struct nfs_seqid, list); 1048 rpc_wake_up_queued_task(&sequence->wait, next->task); 1049 } 1050 spin_unlock(&sequence->lock); 1051 } 1052 1053 void nfs_free_seqid(struct nfs_seqid *seqid) 1054 { 1055 nfs_release_seqid(seqid); 1056 kfree(seqid); 1057 } 1058 1059 /* 1060 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or 1061 * failed with a seqid incrementing error - 1062 * see comments nfs4.h:seqid_mutating_error() 1063 */ 1064 static void nfs_increment_seqid(int status, struct nfs_seqid *seqid) 1065 { 1066 switch (status) { 1067 case 0: 1068 break; 1069 case -NFS4ERR_BAD_SEQID: 1070 if (seqid->sequence->flags & NFS_SEQID_CONFIRMED) 1071 return; 1072 pr_warn_ratelimited("NFS: v4 server returned a bad" 1073 " sequence-id error on an" 1074 " unconfirmed sequence %p!\n", 1075 seqid->sequence); 1076 case -NFS4ERR_STALE_CLIENTID: 1077 case -NFS4ERR_STALE_STATEID: 1078 case -NFS4ERR_BAD_STATEID: 1079 case -NFS4ERR_BADXDR: 1080 case -NFS4ERR_RESOURCE: 1081 case -NFS4ERR_NOFILEHANDLE: 1082 /* Non-seqid mutating errors */ 1083 return; 1084 }; 1085 /* 1086 * Note: no locking needed as we are guaranteed to be first 1087 * on the sequence list 1088 */ 1089 seqid->sequence->counter++; 1090 } 1091 1092 void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid) 1093 { 1094 struct nfs4_state_owner *sp; 1095 1096 if (seqid == NULL) 1097 return; 1098 1099 sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid); 1100 if (status == -NFS4ERR_BAD_SEQID) 1101 nfs4_drop_state_owner(sp); 1102 if (!nfs4_has_session(sp->so_server->nfs_client)) 1103 nfs_increment_seqid(status, seqid); 1104 } 1105 1106 /* 1107 * Increment the seqid if the LOCK/LOCKU succeeded, or 1108 * failed with a seqid incrementing error - 1109 * see comments nfs4.h:seqid_mutating_error() 1110 */ 1111 void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid) 1112 { 1113 if (seqid != NULL) 1114 nfs_increment_seqid(status, seqid); 1115 } 1116 1117 int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task) 1118 { 1119 struct nfs_seqid_counter *sequence; 1120 int status = 0; 1121 1122 if (seqid == NULL) 1123 goto out; 1124 sequence = seqid->sequence; 1125 spin_lock(&sequence->lock); 1126 seqid->task = task; 1127 if (list_empty(&seqid->list)) 1128 list_add_tail(&seqid->list, &sequence->list); 1129 if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid) 1130 goto unlock; 1131 rpc_sleep_on(&sequence->wait, task, NULL); 1132 status = -EAGAIN; 1133 unlock: 1134 spin_unlock(&sequence->lock); 1135 out: 1136 return status; 1137 } 1138 1139 static int nfs4_run_state_manager(void *); 1140 1141 static void nfs4_clear_state_manager_bit(struct nfs_client *clp) 1142 { 1143 smp_mb__before_atomic(); 1144 clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state); 1145 smp_mb__after_atomic(); 1146 wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING); 1147 rpc_wake_up(&clp->cl_rpcwaitq); 1148 } 1149 1150 /* 1151 * Schedule the nfs_client asynchronous state management routine 1152 */ 1153 void nfs4_schedule_state_manager(struct nfs_client *clp) 1154 { 1155 struct task_struct *task; 1156 char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1]; 1157 1158 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) 1159 return; 1160 __module_get(THIS_MODULE); 1161 atomic_inc(&clp->cl_count); 1162 1163 /* The rcu_read_lock() is not strictly necessary, as the state 1164 * manager is the only thread that ever changes the rpc_xprt 1165 * after it's initialized. At this point, we're single threaded. */ 1166 rcu_read_lock(); 1167 snprintf(buf, sizeof(buf), "%s-manager", 1168 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)); 1169 rcu_read_unlock(); 1170 task = kthread_run(nfs4_run_state_manager, clp, "%s", buf); 1171 if (IS_ERR(task)) { 1172 printk(KERN_ERR "%s: kthread_run: %ld\n", 1173 __func__, PTR_ERR(task)); 1174 nfs4_clear_state_manager_bit(clp); 1175 nfs_put_client(clp); 1176 module_put(THIS_MODULE); 1177 } 1178 } 1179 1180 /* 1181 * Schedule a lease recovery attempt 1182 */ 1183 void nfs4_schedule_lease_recovery(struct nfs_client *clp) 1184 { 1185 if (!clp) 1186 return; 1187 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 1188 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 1189 dprintk("%s: scheduling lease recovery for server %s\n", __func__, 1190 clp->cl_hostname); 1191 nfs4_schedule_state_manager(clp); 1192 } 1193 EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery); 1194 1195 /** 1196 * nfs4_schedule_migration_recovery - trigger migration recovery 1197 * 1198 * @server: FSID that is migrating 1199 * 1200 * Returns zero if recovery has started, otherwise a negative NFS4ERR 1201 * value is returned. 1202 */ 1203 int nfs4_schedule_migration_recovery(const struct nfs_server *server) 1204 { 1205 struct nfs_client *clp = server->nfs_client; 1206 1207 if (server->fh_expire_type != NFS4_FH_PERSISTENT) { 1208 pr_err("NFS: volatile file handles not supported (server %s)\n", 1209 clp->cl_hostname); 1210 return -NFS4ERR_IO; 1211 } 1212 1213 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) 1214 return -NFS4ERR_IO; 1215 1216 dprintk("%s: scheduling migration recovery for (%llx:%llx) on %s\n", 1217 __func__, 1218 (unsigned long long)server->fsid.major, 1219 (unsigned long long)server->fsid.minor, 1220 clp->cl_hostname); 1221 1222 set_bit(NFS_MIG_IN_TRANSITION, 1223 &((struct nfs_server *)server)->mig_status); 1224 set_bit(NFS4CLNT_MOVED, &clp->cl_state); 1225 1226 nfs4_schedule_state_manager(clp); 1227 return 0; 1228 } 1229 EXPORT_SYMBOL_GPL(nfs4_schedule_migration_recovery); 1230 1231 /** 1232 * nfs4_schedule_lease_moved_recovery - start lease-moved recovery 1233 * 1234 * @clp: server to check for moved leases 1235 * 1236 */ 1237 void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp) 1238 { 1239 dprintk("%s: scheduling lease-moved recovery for client ID %llx on %s\n", 1240 __func__, clp->cl_clientid, clp->cl_hostname); 1241 1242 set_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state); 1243 nfs4_schedule_state_manager(clp); 1244 } 1245 EXPORT_SYMBOL_GPL(nfs4_schedule_lease_moved_recovery); 1246 1247 int nfs4_wait_clnt_recover(struct nfs_client *clp) 1248 { 1249 int res; 1250 1251 might_sleep(); 1252 1253 atomic_inc(&clp->cl_count); 1254 res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING, 1255 nfs_wait_bit_killable, TASK_KILLABLE); 1256 if (res) 1257 goto out; 1258 if (clp->cl_cons_state < 0) 1259 res = clp->cl_cons_state; 1260 out: 1261 nfs_put_client(clp); 1262 return res; 1263 } 1264 1265 int nfs4_client_recover_expired_lease(struct nfs_client *clp) 1266 { 1267 unsigned int loop; 1268 int ret; 1269 1270 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) { 1271 ret = nfs4_wait_clnt_recover(clp); 1272 if (ret != 0) 1273 break; 1274 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) && 1275 !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state)) 1276 break; 1277 nfs4_schedule_state_manager(clp); 1278 ret = -EIO; 1279 } 1280 return ret; 1281 } 1282 1283 /* 1284 * nfs40_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN 1285 * @clp: client to process 1286 * 1287 * Set the NFS4CLNT_LEASE_EXPIRED state in order to force a 1288 * resend of the SETCLIENTID and hence re-establish the 1289 * callback channel. Then return all existing delegations. 1290 */ 1291 static void nfs40_handle_cb_pathdown(struct nfs_client *clp) 1292 { 1293 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1294 nfs_expire_all_delegations(clp); 1295 dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__, 1296 clp->cl_hostname); 1297 } 1298 1299 void nfs4_schedule_path_down_recovery(struct nfs_client *clp) 1300 { 1301 nfs40_handle_cb_pathdown(clp); 1302 nfs4_schedule_state_manager(clp); 1303 } 1304 1305 static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state) 1306 { 1307 1308 if (!nfs4_valid_open_stateid(state)) 1309 return 0; 1310 set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); 1311 /* Don't recover state that expired before the reboot */ 1312 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) { 1313 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); 1314 return 0; 1315 } 1316 set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags); 1317 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); 1318 return 1; 1319 } 1320 1321 int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state) 1322 { 1323 if (!nfs4_valid_open_stateid(state)) 1324 return 0; 1325 set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags); 1326 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); 1327 set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags); 1328 set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state); 1329 return 1; 1330 } 1331 1332 int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state) 1333 { 1334 struct nfs_client *clp = server->nfs_client; 1335 1336 if (!nfs4_state_mark_reclaim_nograce(clp, state)) 1337 return -EBADF; 1338 dprintk("%s: scheduling stateid recovery for server %s\n", __func__, 1339 clp->cl_hostname); 1340 nfs4_schedule_state_manager(clp); 1341 return 0; 1342 } 1343 EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery); 1344 1345 static struct nfs4_lock_state * 1346 nfs_state_find_lock_state_by_stateid(struct nfs4_state *state, 1347 const nfs4_stateid *stateid) 1348 { 1349 struct nfs4_lock_state *pos; 1350 1351 list_for_each_entry(pos, &state->lock_states, ls_locks) { 1352 if (!test_bit(NFS_LOCK_INITIALIZED, &pos->ls_flags)) 1353 continue; 1354 if (nfs4_stateid_match_other(&pos->ls_stateid, stateid)) 1355 return pos; 1356 } 1357 return NULL; 1358 } 1359 1360 static bool nfs_state_lock_state_matches_stateid(struct nfs4_state *state, 1361 const nfs4_stateid *stateid) 1362 { 1363 bool found = false; 1364 1365 if (test_bit(LK_STATE_IN_USE, &state->flags)) { 1366 spin_lock(&state->state_lock); 1367 if (nfs_state_find_lock_state_by_stateid(state, stateid)) 1368 found = true; 1369 spin_unlock(&state->state_lock); 1370 } 1371 return found; 1372 } 1373 1374 void nfs_inode_find_state_and_recover(struct inode *inode, 1375 const nfs4_stateid *stateid) 1376 { 1377 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; 1378 struct nfs_inode *nfsi = NFS_I(inode); 1379 struct nfs_open_context *ctx; 1380 struct nfs4_state *state; 1381 bool found = false; 1382 1383 spin_lock(&inode->i_lock); 1384 list_for_each_entry(ctx, &nfsi->open_files, list) { 1385 state = ctx->state; 1386 if (state == NULL) 1387 continue; 1388 if (nfs4_stateid_match_other(&state->stateid, stateid) && 1389 nfs4_state_mark_reclaim_nograce(clp, state)) { 1390 found = true; 1391 continue; 1392 } 1393 if (nfs_state_lock_state_matches_stateid(state, stateid) && 1394 nfs4_state_mark_reclaim_nograce(clp, state)) 1395 found = true; 1396 } 1397 spin_unlock(&inode->i_lock); 1398 1399 nfs_inode_find_delegation_state_and_recover(inode, stateid); 1400 if (found) 1401 nfs4_schedule_state_manager(clp); 1402 } 1403 1404 static void nfs4_state_mark_open_context_bad(struct nfs4_state *state) 1405 { 1406 struct inode *inode = state->inode; 1407 struct nfs_inode *nfsi = NFS_I(inode); 1408 struct nfs_open_context *ctx; 1409 1410 spin_lock(&inode->i_lock); 1411 list_for_each_entry(ctx, &nfsi->open_files, list) { 1412 if (ctx->state != state) 1413 continue; 1414 set_bit(NFS_CONTEXT_BAD, &ctx->flags); 1415 } 1416 spin_unlock(&inode->i_lock); 1417 } 1418 1419 static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error) 1420 { 1421 set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags); 1422 nfs4_state_mark_open_context_bad(state); 1423 } 1424 1425 1426 static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops) 1427 { 1428 struct inode *inode = state->inode; 1429 struct nfs_inode *nfsi = NFS_I(inode); 1430 struct file_lock *fl; 1431 int status = 0; 1432 struct file_lock_context *flctx = inode->i_flctx; 1433 struct list_head *list; 1434 1435 if (flctx == NULL) 1436 return 0; 1437 1438 list = &flctx->flc_posix; 1439 1440 /* Guard against delegation returns and new lock/unlock calls */ 1441 down_write(&nfsi->rwsem); 1442 spin_lock(&flctx->flc_lock); 1443 restart: 1444 list_for_each_entry(fl, list, fl_list) { 1445 if (nfs_file_open_context(fl->fl_file)->state != state) 1446 continue; 1447 spin_unlock(&flctx->flc_lock); 1448 status = ops->recover_lock(state, fl); 1449 switch (status) { 1450 case 0: 1451 break; 1452 case -ESTALE: 1453 case -NFS4ERR_ADMIN_REVOKED: 1454 case -NFS4ERR_STALE_STATEID: 1455 case -NFS4ERR_BAD_STATEID: 1456 case -NFS4ERR_EXPIRED: 1457 case -NFS4ERR_NO_GRACE: 1458 case -NFS4ERR_STALE_CLIENTID: 1459 case -NFS4ERR_BADSESSION: 1460 case -NFS4ERR_BADSLOT: 1461 case -NFS4ERR_BAD_HIGH_SLOT: 1462 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1463 goto out; 1464 default: 1465 pr_err("NFS: %s: unhandled error %d\n", 1466 __func__, status); 1467 case -ENOMEM: 1468 case -NFS4ERR_DENIED: 1469 case -NFS4ERR_RECLAIM_BAD: 1470 case -NFS4ERR_RECLAIM_CONFLICT: 1471 /* kill_proc(fl->fl_pid, SIGLOST, 1); */ 1472 status = 0; 1473 } 1474 spin_lock(&flctx->flc_lock); 1475 } 1476 if (list == &flctx->flc_posix) { 1477 list = &flctx->flc_flock; 1478 goto restart; 1479 } 1480 spin_unlock(&flctx->flc_lock); 1481 out: 1482 up_write(&nfsi->rwsem); 1483 return status; 1484 } 1485 1486 static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops) 1487 { 1488 struct nfs4_state *state; 1489 struct nfs4_lock_state *lock; 1490 int status = 0; 1491 1492 /* Note: we rely on the sp->so_states list being ordered 1493 * so that we always reclaim open(O_RDWR) and/or open(O_WRITE) 1494 * states first. 1495 * This is needed to ensure that the server won't give us any 1496 * read delegations that we have to return if, say, we are 1497 * recovering after a network partition or a reboot from a 1498 * server that doesn't support a grace period. 1499 */ 1500 spin_lock(&sp->so_lock); 1501 raw_write_seqcount_begin(&sp->so_reclaim_seqcount); 1502 restart: 1503 list_for_each_entry(state, &sp->so_states, open_states) { 1504 if (!test_and_clear_bit(ops->state_flag_bit, &state->flags)) 1505 continue; 1506 if (!nfs4_valid_open_stateid(state)) 1507 continue; 1508 if (state->state == 0) 1509 continue; 1510 atomic_inc(&state->count); 1511 spin_unlock(&sp->so_lock); 1512 status = ops->recover_open(sp, state); 1513 if (status >= 0) { 1514 status = nfs4_reclaim_locks(state, ops); 1515 if (status >= 0) { 1516 if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) { 1517 spin_lock(&state->state_lock); 1518 list_for_each_entry(lock, &state->lock_states, ls_locks) { 1519 if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags)) 1520 pr_warn_ratelimited("NFS: " 1521 "%s: Lock reclaim " 1522 "failed!\n", __func__); 1523 } 1524 spin_unlock(&state->state_lock); 1525 } 1526 clear_bit(NFS_STATE_RECLAIM_NOGRACE, 1527 &state->flags); 1528 nfs4_put_open_state(state); 1529 spin_lock(&sp->so_lock); 1530 goto restart; 1531 } 1532 } 1533 switch (status) { 1534 default: 1535 printk(KERN_ERR "NFS: %s: unhandled error %d\n", 1536 __func__, status); 1537 case -ENOENT: 1538 case -ENOMEM: 1539 case -EACCES: 1540 case -EROFS: 1541 case -EIO: 1542 case -ESTALE: 1543 /* Open state on this file cannot be recovered */ 1544 nfs4_state_mark_recovery_failed(state, status); 1545 break; 1546 case -EAGAIN: 1547 ssleep(1); 1548 case -NFS4ERR_ADMIN_REVOKED: 1549 case -NFS4ERR_STALE_STATEID: 1550 case -NFS4ERR_BAD_STATEID: 1551 case -NFS4ERR_RECLAIM_BAD: 1552 case -NFS4ERR_RECLAIM_CONFLICT: 1553 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state); 1554 break; 1555 case -NFS4ERR_EXPIRED: 1556 case -NFS4ERR_NO_GRACE: 1557 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state); 1558 case -NFS4ERR_STALE_CLIENTID: 1559 case -NFS4ERR_BADSESSION: 1560 case -NFS4ERR_BADSLOT: 1561 case -NFS4ERR_BAD_HIGH_SLOT: 1562 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1563 goto out_err; 1564 } 1565 nfs4_put_open_state(state); 1566 spin_lock(&sp->so_lock); 1567 goto restart; 1568 } 1569 raw_write_seqcount_end(&sp->so_reclaim_seqcount); 1570 spin_unlock(&sp->so_lock); 1571 return 0; 1572 out_err: 1573 nfs4_put_open_state(state); 1574 spin_lock(&sp->so_lock); 1575 raw_write_seqcount_end(&sp->so_reclaim_seqcount); 1576 spin_unlock(&sp->so_lock); 1577 return status; 1578 } 1579 1580 static void nfs4_clear_open_state(struct nfs4_state *state) 1581 { 1582 struct nfs4_lock_state *lock; 1583 1584 clear_bit(NFS_DELEGATED_STATE, &state->flags); 1585 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1586 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1587 clear_bit(NFS_O_RDWR_STATE, &state->flags); 1588 spin_lock(&state->state_lock); 1589 list_for_each_entry(lock, &state->lock_states, ls_locks) { 1590 lock->ls_seqid.flags = 0; 1591 clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags); 1592 } 1593 spin_unlock(&state->state_lock); 1594 } 1595 1596 static void nfs4_reset_seqids(struct nfs_server *server, 1597 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state)) 1598 { 1599 struct nfs_client *clp = server->nfs_client; 1600 struct nfs4_state_owner *sp; 1601 struct rb_node *pos; 1602 struct nfs4_state *state; 1603 1604 spin_lock(&clp->cl_lock); 1605 for (pos = rb_first(&server->state_owners); 1606 pos != NULL; 1607 pos = rb_next(pos)) { 1608 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node); 1609 sp->so_seqid.flags = 0; 1610 spin_lock(&sp->so_lock); 1611 list_for_each_entry(state, &sp->so_states, open_states) { 1612 if (mark_reclaim(clp, state)) 1613 nfs4_clear_open_state(state); 1614 } 1615 spin_unlock(&sp->so_lock); 1616 } 1617 spin_unlock(&clp->cl_lock); 1618 } 1619 1620 static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp, 1621 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state)) 1622 { 1623 struct nfs_server *server; 1624 1625 rcu_read_lock(); 1626 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1627 nfs4_reset_seqids(server, mark_reclaim); 1628 rcu_read_unlock(); 1629 } 1630 1631 static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp) 1632 { 1633 /* Mark all delegations for reclaim */ 1634 nfs_delegation_mark_reclaim(clp); 1635 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot); 1636 } 1637 1638 static void nfs4_reclaim_complete(struct nfs_client *clp, 1639 const struct nfs4_state_recovery_ops *ops, 1640 struct rpc_cred *cred) 1641 { 1642 /* Notify the server we're done reclaiming our state */ 1643 if (ops->reclaim_complete) 1644 (void)ops->reclaim_complete(clp, cred); 1645 } 1646 1647 static void nfs4_clear_reclaim_server(struct nfs_server *server) 1648 { 1649 struct nfs_client *clp = server->nfs_client; 1650 struct nfs4_state_owner *sp; 1651 struct rb_node *pos; 1652 struct nfs4_state *state; 1653 1654 spin_lock(&clp->cl_lock); 1655 for (pos = rb_first(&server->state_owners); 1656 pos != NULL; 1657 pos = rb_next(pos)) { 1658 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node); 1659 spin_lock(&sp->so_lock); 1660 list_for_each_entry(state, &sp->so_states, open_states) { 1661 if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT, 1662 &state->flags)) 1663 continue; 1664 nfs4_state_mark_reclaim_nograce(clp, state); 1665 } 1666 spin_unlock(&sp->so_lock); 1667 } 1668 spin_unlock(&clp->cl_lock); 1669 } 1670 1671 static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp) 1672 { 1673 struct nfs_server *server; 1674 1675 if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) 1676 return 0; 1677 1678 rcu_read_lock(); 1679 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1680 nfs4_clear_reclaim_server(server); 1681 rcu_read_unlock(); 1682 1683 nfs_delegation_reap_unclaimed(clp); 1684 return 1; 1685 } 1686 1687 static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp) 1688 { 1689 const struct nfs4_state_recovery_ops *ops; 1690 struct rpc_cred *cred; 1691 1692 if (!nfs4_state_clear_reclaim_reboot(clp)) 1693 return; 1694 ops = clp->cl_mvops->reboot_recovery_ops; 1695 cred = nfs4_get_clid_cred(clp); 1696 nfs4_reclaim_complete(clp, ops, cred); 1697 put_rpccred(cred); 1698 } 1699 1700 static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp) 1701 { 1702 nfs_mark_test_expired_all_delegations(clp); 1703 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce); 1704 } 1705 1706 static int nfs4_recovery_handle_error(struct nfs_client *clp, int error) 1707 { 1708 switch (error) { 1709 case 0: 1710 break; 1711 case -NFS4ERR_CB_PATH_DOWN: 1712 nfs40_handle_cb_pathdown(clp); 1713 break; 1714 case -NFS4ERR_NO_GRACE: 1715 nfs4_state_end_reclaim_reboot(clp); 1716 break; 1717 case -NFS4ERR_STALE_CLIENTID: 1718 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1719 nfs4_state_clear_reclaim_reboot(clp); 1720 nfs4_state_start_reclaim_reboot(clp); 1721 break; 1722 case -NFS4ERR_EXPIRED: 1723 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1724 nfs4_state_start_reclaim_nograce(clp); 1725 break; 1726 case -NFS4ERR_BADSESSION: 1727 case -NFS4ERR_BADSLOT: 1728 case -NFS4ERR_BAD_HIGH_SLOT: 1729 case -NFS4ERR_DEADSESSION: 1730 case -NFS4ERR_SEQ_FALSE_RETRY: 1731 case -NFS4ERR_SEQ_MISORDERED: 1732 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 1733 /* Zero session reset errors */ 1734 break; 1735 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1736 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); 1737 break; 1738 default: 1739 dprintk("%s: failed to handle error %d for server %s\n", 1740 __func__, error, clp->cl_hostname); 1741 return error; 1742 } 1743 dprintk("%s: handled error %d for server %s\n", __func__, error, 1744 clp->cl_hostname); 1745 return 0; 1746 } 1747 1748 static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops) 1749 { 1750 struct nfs4_state_owner *sp; 1751 struct nfs_server *server; 1752 struct rb_node *pos; 1753 int status = 0; 1754 1755 restart: 1756 rcu_read_lock(); 1757 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 1758 nfs4_purge_state_owners(server); 1759 spin_lock(&clp->cl_lock); 1760 for (pos = rb_first(&server->state_owners); 1761 pos != NULL; 1762 pos = rb_next(pos)) { 1763 sp = rb_entry(pos, 1764 struct nfs4_state_owner, so_server_node); 1765 if (!test_and_clear_bit(ops->owner_flag_bit, 1766 &sp->so_flags)) 1767 continue; 1768 if (!atomic_inc_not_zero(&sp->so_count)) 1769 continue; 1770 spin_unlock(&clp->cl_lock); 1771 rcu_read_unlock(); 1772 1773 status = nfs4_reclaim_open_state(sp, ops); 1774 if (status < 0) { 1775 set_bit(ops->owner_flag_bit, &sp->so_flags); 1776 nfs4_put_state_owner(sp); 1777 status = nfs4_recovery_handle_error(clp, status); 1778 return (status != 0) ? status : -EAGAIN; 1779 } 1780 1781 nfs4_put_state_owner(sp); 1782 goto restart; 1783 } 1784 spin_unlock(&clp->cl_lock); 1785 } 1786 rcu_read_unlock(); 1787 return 0; 1788 } 1789 1790 static int nfs4_check_lease(struct nfs_client *clp) 1791 { 1792 struct rpc_cred *cred; 1793 const struct nfs4_state_maintenance_ops *ops = 1794 clp->cl_mvops->state_renewal_ops; 1795 int status; 1796 1797 /* Is the client already known to have an expired lease? */ 1798 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 1799 return 0; 1800 spin_lock(&clp->cl_lock); 1801 cred = ops->get_state_renewal_cred_locked(clp); 1802 spin_unlock(&clp->cl_lock); 1803 if (cred == NULL) { 1804 cred = nfs4_get_clid_cred(clp); 1805 status = -ENOKEY; 1806 if (cred == NULL) 1807 goto out; 1808 } 1809 status = ops->renew_lease(clp, cred); 1810 put_rpccred(cred); 1811 if (status == -ETIMEDOUT) { 1812 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 1813 return 0; 1814 } 1815 out: 1816 return nfs4_recovery_handle_error(clp, status); 1817 } 1818 1819 /* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors 1820 * and for recoverable errors on EXCHANGE_ID for v4.1 1821 */ 1822 static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status) 1823 { 1824 switch (status) { 1825 case -NFS4ERR_SEQ_MISORDERED: 1826 if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) 1827 return -ESERVERFAULT; 1828 /* Lease confirmation error: retry after purging the lease */ 1829 ssleep(1); 1830 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 1831 break; 1832 case -NFS4ERR_STALE_CLIENTID: 1833 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 1834 nfs4_state_start_reclaim_reboot(clp); 1835 break; 1836 case -NFS4ERR_CLID_INUSE: 1837 pr_err("NFS: Server %s reports our clientid is in use\n", 1838 clp->cl_hostname); 1839 nfs_mark_client_ready(clp, -EPERM); 1840 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 1841 return -EPERM; 1842 case -EACCES: 1843 case -NFS4ERR_DELAY: 1844 case -ETIMEDOUT: 1845 case -EAGAIN: 1846 ssleep(1); 1847 break; 1848 1849 case -NFS4ERR_MINOR_VERS_MISMATCH: 1850 if (clp->cl_cons_state == NFS_CS_SESSION_INITING) 1851 nfs_mark_client_ready(clp, -EPROTONOSUPPORT); 1852 dprintk("%s: exit with error %d for server %s\n", 1853 __func__, -EPROTONOSUPPORT, clp->cl_hostname); 1854 return -EPROTONOSUPPORT; 1855 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery 1856 * in nfs4_exchange_id */ 1857 default: 1858 dprintk("%s: exit with error %d for server %s\n", __func__, 1859 status, clp->cl_hostname); 1860 return status; 1861 } 1862 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1863 dprintk("%s: handled error %d for server %s\n", __func__, status, 1864 clp->cl_hostname); 1865 return 0; 1866 } 1867 1868 static int nfs4_establish_lease(struct nfs_client *clp) 1869 { 1870 struct rpc_cred *cred; 1871 const struct nfs4_state_recovery_ops *ops = 1872 clp->cl_mvops->reboot_recovery_ops; 1873 int status; 1874 1875 nfs4_begin_drain_session(clp); 1876 cred = nfs4_get_clid_cred(clp); 1877 if (cred == NULL) 1878 return -ENOENT; 1879 status = ops->establish_clid(clp, cred); 1880 put_rpccred(cred); 1881 if (status != 0) 1882 return status; 1883 pnfs_destroy_all_layouts(clp); 1884 return 0; 1885 } 1886 1887 /* 1888 * Returns zero or a negative errno. NFS4ERR values are converted 1889 * to local errno values. 1890 */ 1891 static int nfs4_reclaim_lease(struct nfs_client *clp) 1892 { 1893 int status; 1894 1895 status = nfs4_establish_lease(clp); 1896 if (status < 0) 1897 return nfs4_handle_reclaim_lease_error(clp, status); 1898 if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state)) 1899 nfs4_state_start_reclaim_nograce(clp); 1900 if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) 1901 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); 1902 clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 1903 clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1904 return 0; 1905 } 1906 1907 static int nfs4_purge_lease(struct nfs_client *clp) 1908 { 1909 int status; 1910 1911 status = nfs4_establish_lease(clp); 1912 if (status < 0) 1913 return nfs4_handle_reclaim_lease_error(clp, status); 1914 clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state); 1915 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1916 nfs4_state_start_reclaim_nograce(clp); 1917 return 0; 1918 } 1919 1920 /* 1921 * Try remote migration of one FSID from a source server to a 1922 * destination server. The source server provides a list of 1923 * potential destinations. 1924 * 1925 * Returns zero or a negative NFS4ERR status code. 1926 */ 1927 static int nfs4_try_migration(struct nfs_server *server, struct rpc_cred *cred) 1928 { 1929 struct nfs_client *clp = server->nfs_client; 1930 struct nfs4_fs_locations *locations = NULL; 1931 struct inode *inode; 1932 struct page *page; 1933 int status, result; 1934 1935 dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__, 1936 (unsigned long long)server->fsid.major, 1937 (unsigned long long)server->fsid.minor, 1938 clp->cl_hostname); 1939 1940 result = 0; 1941 page = alloc_page(GFP_KERNEL); 1942 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL); 1943 if (page == NULL || locations == NULL) { 1944 dprintk("<-- %s: no memory\n", __func__); 1945 goto out; 1946 } 1947 1948 inode = d_inode(server->super->s_root); 1949 result = nfs4_proc_get_locations(inode, locations, page, cred); 1950 if (result) { 1951 dprintk("<-- %s: failed to retrieve fs_locations: %d\n", 1952 __func__, result); 1953 goto out; 1954 } 1955 1956 result = -NFS4ERR_NXIO; 1957 if (!(locations->fattr.valid & NFS_ATTR_FATTR_V4_LOCATIONS)) { 1958 dprintk("<-- %s: No fs_locations data, migration skipped\n", 1959 __func__); 1960 goto out; 1961 } 1962 1963 nfs4_begin_drain_session(clp); 1964 1965 status = nfs4_replace_transport(server, locations); 1966 if (status != 0) { 1967 dprintk("<-- %s: failed to replace transport: %d\n", 1968 __func__, status); 1969 goto out; 1970 } 1971 1972 result = 0; 1973 dprintk("<-- %s: migration succeeded\n", __func__); 1974 1975 out: 1976 if (page != NULL) 1977 __free_page(page); 1978 kfree(locations); 1979 if (result) { 1980 pr_err("NFS: migration recovery failed (server %s)\n", 1981 clp->cl_hostname); 1982 set_bit(NFS_MIG_FAILED, &server->mig_status); 1983 } 1984 return result; 1985 } 1986 1987 /* 1988 * Returns zero or a negative NFS4ERR status code. 1989 */ 1990 static int nfs4_handle_migration(struct nfs_client *clp) 1991 { 1992 const struct nfs4_state_maintenance_ops *ops = 1993 clp->cl_mvops->state_renewal_ops; 1994 struct nfs_server *server; 1995 struct rpc_cred *cred; 1996 1997 dprintk("%s: migration reported on \"%s\"\n", __func__, 1998 clp->cl_hostname); 1999 2000 spin_lock(&clp->cl_lock); 2001 cred = ops->get_state_renewal_cred_locked(clp); 2002 spin_unlock(&clp->cl_lock); 2003 if (cred == NULL) 2004 return -NFS4ERR_NOENT; 2005 2006 clp->cl_mig_gen++; 2007 restart: 2008 rcu_read_lock(); 2009 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 2010 int status; 2011 2012 if (server->mig_gen == clp->cl_mig_gen) 2013 continue; 2014 server->mig_gen = clp->cl_mig_gen; 2015 2016 if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION, 2017 &server->mig_status)) 2018 continue; 2019 2020 rcu_read_unlock(); 2021 status = nfs4_try_migration(server, cred); 2022 if (status < 0) { 2023 put_rpccred(cred); 2024 return status; 2025 } 2026 goto restart; 2027 } 2028 rcu_read_unlock(); 2029 put_rpccred(cred); 2030 return 0; 2031 } 2032 2033 /* 2034 * Test each nfs_server on the clp's cl_superblocks list to see 2035 * if it's moved to another server. Stop when the server no longer 2036 * returns NFS4ERR_LEASE_MOVED. 2037 */ 2038 static int nfs4_handle_lease_moved(struct nfs_client *clp) 2039 { 2040 const struct nfs4_state_maintenance_ops *ops = 2041 clp->cl_mvops->state_renewal_ops; 2042 struct nfs_server *server; 2043 struct rpc_cred *cred; 2044 2045 dprintk("%s: lease moved reported on \"%s\"\n", __func__, 2046 clp->cl_hostname); 2047 2048 spin_lock(&clp->cl_lock); 2049 cred = ops->get_state_renewal_cred_locked(clp); 2050 spin_unlock(&clp->cl_lock); 2051 if (cred == NULL) 2052 return -NFS4ERR_NOENT; 2053 2054 clp->cl_mig_gen++; 2055 restart: 2056 rcu_read_lock(); 2057 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 2058 struct inode *inode; 2059 int status; 2060 2061 if (server->mig_gen == clp->cl_mig_gen) 2062 continue; 2063 server->mig_gen = clp->cl_mig_gen; 2064 2065 rcu_read_unlock(); 2066 2067 inode = d_inode(server->super->s_root); 2068 status = nfs4_proc_fsid_present(inode, cred); 2069 if (status != -NFS4ERR_MOVED) 2070 goto restart; /* wasn't this one */ 2071 if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED) 2072 goto restart; /* there are more */ 2073 goto out; 2074 } 2075 rcu_read_unlock(); 2076 2077 out: 2078 put_rpccred(cred); 2079 return 0; 2080 } 2081 2082 /** 2083 * nfs4_discover_server_trunking - Detect server IP address trunking 2084 * 2085 * @clp: nfs_client under test 2086 * @result: OUT: found nfs_client, or clp 2087 * 2088 * Returns zero or a negative errno. If zero is returned, 2089 * an nfs_client pointer is planted in "result". 2090 * 2091 * Note: since we are invoked in process context, and 2092 * not from inside the state manager, we cannot use 2093 * nfs4_handle_reclaim_lease_error(). 2094 */ 2095 int nfs4_discover_server_trunking(struct nfs_client *clp, 2096 struct nfs_client **result) 2097 { 2098 const struct nfs4_state_recovery_ops *ops = 2099 clp->cl_mvops->reboot_recovery_ops; 2100 struct rpc_clnt *clnt; 2101 struct rpc_cred *cred; 2102 int i, status; 2103 2104 dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname); 2105 2106 clnt = clp->cl_rpcclient; 2107 i = 0; 2108 2109 mutex_lock(&nfs_clid_init_mutex); 2110 again: 2111 status = -ENOENT; 2112 cred = nfs4_get_clid_cred(clp); 2113 if (cred == NULL) 2114 goto out_unlock; 2115 2116 status = ops->detect_trunking(clp, result, cred); 2117 put_rpccred(cred); 2118 switch (status) { 2119 case 0: 2120 break; 2121 case -ETIMEDOUT: 2122 if (clnt->cl_softrtry) 2123 break; 2124 case -NFS4ERR_DELAY: 2125 case -EAGAIN: 2126 ssleep(1); 2127 case -NFS4ERR_STALE_CLIENTID: 2128 dprintk("NFS: %s after status %d, retrying\n", 2129 __func__, status); 2130 goto again; 2131 case -EACCES: 2132 if (i++ == 0) { 2133 nfs4_root_machine_cred(clp); 2134 goto again; 2135 } 2136 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) 2137 break; 2138 case -NFS4ERR_CLID_INUSE: 2139 case -NFS4ERR_WRONGSEC: 2140 /* No point in retrying if we already used RPC_AUTH_UNIX */ 2141 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) { 2142 status = -EPERM; 2143 break; 2144 } 2145 clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX); 2146 if (IS_ERR(clnt)) { 2147 status = PTR_ERR(clnt); 2148 break; 2149 } 2150 /* Note: this is safe because we haven't yet marked the 2151 * client as ready, so we are the only user of 2152 * clp->cl_rpcclient 2153 */ 2154 clnt = xchg(&clp->cl_rpcclient, clnt); 2155 rpc_shutdown_client(clnt); 2156 clnt = clp->cl_rpcclient; 2157 goto again; 2158 2159 case -NFS4ERR_MINOR_VERS_MISMATCH: 2160 status = -EPROTONOSUPPORT; 2161 break; 2162 2163 case -EKEYEXPIRED: 2164 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery 2165 * in nfs4_exchange_id */ 2166 status = -EKEYEXPIRED; 2167 break; 2168 default: 2169 pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n", 2170 __func__, status); 2171 status = -EIO; 2172 } 2173 2174 out_unlock: 2175 mutex_unlock(&nfs_clid_init_mutex); 2176 dprintk("NFS: %s: status = %d\n", __func__, status); 2177 return status; 2178 } 2179 2180 #ifdef CONFIG_NFS_V4_1 2181 void nfs4_schedule_session_recovery(struct nfs4_session *session, int err) 2182 { 2183 struct nfs_client *clp = session->clp; 2184 2185 switch (err) { 2186 default: 2187 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 2188 break; 2189 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 2190 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); 2191 } 2192 nfs4_schedule_lease_recovery(clp); 2193 } 2194 EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery); 2195 2196 void nfs41_notify_server(struct nfs_client *clp) 2197 { 2198 /* Use CHECK_LEASE to ping the server with a SEQUENCE */ 2199 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 2200 nfs4_schedule_state_manager(clp); 2201 } 2202 2203 static void nfs4_reset_all_state(struct nfs_client *clp) 2204 { 2205 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) { 2206 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state); 2207 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 2208 nfs4_state_start_reclaim_nograce(clp); 2209 dprintk("%s: scheduling reset of all state for server %s!\n", 2210 __func__, clp->cl_hostname); 2211 nfs4_schedule_state_manager(clp); 2212 } 2213 } 2214 2215 static void nfs41_handle_server_reboot(struct nfs_client *clp) 2216 { 2217 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) { 2218 nfs4_state_start_reclaim_reboot(clp); 2219 dprintk("%s: server %s rebooted!\n", __func__, 2220 clp->cl_hostname); 2221 nfs4_schedule_state_manager(clp); 2222 } 2223 } 2224 2225 static void nfs41_handle_all_state_revoked(struct nfs_client *clp) 2226 { 2227 nfs4_reset_all_state(clp); 2228 dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname); 2229 } 2230 2231 static void nfs41_handle_some_state_revoked(struct nfs_client *clp) 2232 { 2233 nfs4_state_start_reclaim_nograce(clp); 2234 nfs4_schedule_state_manager(clp); 2235 2236 dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname); 2237 } 2238 2239 static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp) 2240 { 2241 /* FIXME: For now, we destroy all layouts. */ 2242 pnfs_destroy_all_layouts(clp); 2243 /* FIXME: For now, we test all delegations+open state+locks. */ 2244 nfs41_handle_some_state_revoked(clp); 2245 dprintk("%s: Recallable state revoked on server %s!\n", __func__, 2246 clp->cl_hostname); 2247 } 2248 2249 static void nfs41_handle_backchannel_fault(struct nfs_client *clp) 2250 { 2251 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 2252 nfs4_schedule_state_manager(clp); 2253 2254 dprintk("%s: server %s declared a backchannel fault\n", __func__, 2255 clp->cl_hostname); 2256 } 2257 2258 static void nfs41_handle_cb_path_down(struct nfs_client *clp) 2259 { 2260 if (test_and_set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, 2261 &clp->cl_state) == 0) 2262 nfs4_schedule_state_manager(clp); 2263 } 2264 2265 void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags, 2266 bool recovery) 2267 { 2268 if (!flags) 2269 return; 2270 2271 dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n", 2272 __func__, clp->cl_hostname, clp->cl_clientid, flags); 2273 /* 2274 * If we're called from the state manager thread, then assume we're 2275 * already handling the RECLAIM_NEEDED and/or STATE_REVOKED. 2276 * Those flags are expected to remain set until we're done 2277 * recovering (see RFC5661, section 18.46.3). 2278 */ 2279 if (recovery) 2280 goto out_recovery; 2281 2282 if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED) 2283 nfs41_handle_server_reboot(clp); 2284 if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED)) 2285 nfs41_handle_all_state_revoked(clp); 2286 if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED | 2287 SEQ4_STATUS_ADMIN_STATE_REVOKED)) 2288 nfs41_handle_some_state_revoked(clp); 2289 if (flags & SEQ4_STATUS_LEASE_MOVED) 2290 nfs4_schedule_lease_moved_recovery(clp); 2291 if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED) 2292 nfs41_handle_recallable_state_revoked(clp); 2293 out_recovery: 2294 if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT) 2295 nfs41_handle_backchannel_fault(clp); 2296 else if (flags & (SEQ4_STATUS_CB_PATH_DOWN | 2297 SEQ4_STATUS_CB_PATH_DOWN_SESSION)) 2298 nfs41_handle_cb_path_down(clp); 2299 } 2300 2301 static int nfs4_reset_session(struct nfs_client *clp) 2302 { 2303 struct rpc_cred *cred; 2304 int status; 2305 2306 if (!nfs4_has_session(clp)) 2307 return 0; 2308 nfs4_begin_drain_session(clp); 2309 cred = nfs4_get_clid_cred(clp); 2310 status = nfs4_proc_destroy_session(clp->cl_session, cred); 2311 switch (status) { 2312 case 0: 2313 case -NFS4ERR_BADSESSION: 2314 case -NFS4ERR_DEADSESSION: 2315 break; 2316 case -NFS4ERR_BACK_CHAN_BUSY: 2317 case -NFS4ERR_DELAY: 2318 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 2319 status = 0; 2320 ssleep(1); 2321 goto out; 2322 default: 2323 status = nfs4_recovery_handle_error(clp, status); 2324 goto out; 2325 } 2326 2327 memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN); 2328 status = nfs4_proc_create_session(clp, cred); 2329 if (status) { 2330 dprintk("%s: session reset failed with status %d for server %s!\n", 2331 __func__, status, clp->cl_hostname); 2332 status = nfs4_handle_reclaim_lease_error(clp, status); 2333 goto out; 2334 } 2335 nfs41_finish_session_reset(clp); 2336 dprintk("%s: session reset was successful for server %s!\n", 2337 __func__, clp->cl_hostname); 2338 out: 2339 if (cred) 2340 put_rpccred(cred); 2341 return status; 2342 } 2343 2344 static int nfs4_bind_conn_to_session(struct nfs_client *clp) 2345 { 2346 struct rpc_cred *cred; 2347 int ret; 2348 2349 if (!nfs4_has_session(clp)) 2350 return 0; 2351 nfs4_begin_drain_session(clp); 2352 cred = nfs4_get_clid_cred(clp); 2353 ret = nfs4_proc_bind_conn_to_session(clp, cred); 2354 if (cred) 2355 put_rpccred(cred); 2356 clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); 2357 switch (ret) { 2358 case 0: 2359 dprintk("%s: bind_conn_to_session was successful for server %s!\n", 2360 __func__, clp->cl_hostname); 2361 break; 2362 case -NFS4ERR_DELAY: 2363 ssleep(1); 2364 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); 2365 break; 2366 default: 2367 return nfs4_recovery_handle_error(clp, ret); 2368 } 2369 return 0; 2370 } 2371 #else /* CONFIG_NFS_V4_1 */ 2372 static int nfs4_reset_session(struct nfs_client *clp) { return 0; } 2373 2374 static int nfs4_bind_conn_to_session(struct nfs_client *clp) 2375 { 2376 return 0; 2377 } 2378 #endif /* CONFIG_NFS_V4_1 */ 2379 2380 static void nfs4_state_manager(struct nfs_client *clp) 2381 { 2382 int status = 0; 2383 const char *section = "", *section_sep = ""; 2384 2385 /* Ensure exclusive access to NFSv4 state */ 2386 do { 2387 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) { 2388 section = "purge state"; 2389 status = nfs4_purge_lease(clp); 2390 if (status < 0) 2391 goto out_error; 2392 continue; 2393 } 2394 2395 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) { 2396 section = "lease expired"; 2397 /* We're going to have to re-establish a clientid */ 2398 status = nfs4_reclaim_lease(clp); 2399 if (status < 0) 2400 goto out_error; 2401 continue; 2402 } 2403 2404 /* Initialize or reset the session */ 2405 if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) { 2406 section = "reset session"; 2407 status = nfs4_reset_session(clp); 2408 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 2409 continue; 2410 if (status < 0) 2411 goto out_error; 2412 } 2413 2414 /* Send BIND_CONN_TO_SESSION */ 2415 if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, 2416 &clp->cl_state)) { 2417 section = "bind conn to session"; 2418 status = nfs4_bind_conn_to_session(clp); 2419 if (status < 0) 2420 goto out_error; 2421 continue; 2422 } 2423 2424 if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) { 2425 section = "check lease"; 2426 status = nfs4_check_lease(clp); 2427 if (status < 0) 2428 goto out_error; 2429 continue; 2430 } 2431 2432 if (test_and_clear_bit(NFS4CLNT_MOVED, &clp->cl_state)) { 2433 section = "migration"; 2434 status = nfs4_handle_migration(clp); 2435 if (status < 0) 2436 goto out_error; 2437 } 2438 2439 if (test_and_clear_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state)) { 2440 section = "lease moved"; 2441 status = nfs4_handle_lease_moved(clp); 2442 if (status < 0) 2443 goto out_error; 2444 } 2445 2446 /* First recover reboot state... */ 2447 if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) { 2448 section = "reclaim reboot"; 2449 status = nfs4_do_reclaim(clp, 2450 clp->cl_mvops->reboot_recovery_ops); 2451 if (status == -EAGAIN) 2452 continue; 2453 if (status < 0) 2454 goto out_error; 2455 nfs4_state_end_reclaim_reboot(clp); 2456 } 2457 2458 /* Detect expired delegations... */ 2459 if (test_and_clear_bit(NFS4CLNT_DELEGATION_EXPIRED, &clp->cl_state)) { 2460 section = "detect expired delegations"; 2461 nfs_reap_expired_delegations(clp); 2462 continue; 2463 } 2464 2465 /* Now recover expired state... */ 2466 if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) { 2467 section = "reclaim nograce"; 2468 status = nfs4_do_reclaim(clp, 2469 clp->cl_mvops->nograce_recovery_ops); 2470 if (status == -EAGAIN) 2471 continue; 2472 if (status < 0) 2473 goto out_error; 2474 } 2475 2476 nfs4_end_drain_session(clp); 2477 if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) { 2478 nfs_client_return_marked_delegations(clp); 2479 continue; 2480 } 2481 2482 nfs4_clear_state_manager_bit(clp); 2483 /* Did we race with an attempt to give us more work? */ 2484 if (clp->cl_state == 0) 2485 break; 2486 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) 2487 break; 2488 } while (atomic_read(&clp->cl_count) > 1); 2489 return; 2490 out_error: 2491 if (strlen(section)) 2492 section_sep = ": "; 2493 pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s" 2494 " with error %d\n", section_sep, section, 2495 clp->cl_hostname, -status); 2496 ssleep(1); 2497 nfs4_end_drain_session(clp); 2498 nfs4_clear_state_manager_bit(clp); 2499 } 2500 2501 static int nfs4_run_state_manager(void *ptr) 2502 { 2503 struct nfs_client *clp = ptr; 2504 2505 allow_signal(SIGKILL); 2506 nfs4_state_manager(clp); 2507 nfs_put_client(clp); 2508 module_put_and_exit(0); 2509 return 0; 2510 } 2511 2512 /* 2513 * Local variables: 2514 * c-basic-offset: 8 2515 * End: 2516 */ 2517