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 53 #include "nfs4_fs.h" 54 #include "callback.h" 55 #include "delegation.h" 56 #include "internal.h" 57 #include "pnfs.h" 58 59 #define OPENOWNER_POOL_SIZE 8 60 61 const nfs4_stateid zero_stateid; 62 63 static LIST_HEAD(nfs4_clientid_list); 64 65 int nfs4_init_clientid(struct nfs_client *clp, struct rpc_cred *cred) 66 { 67 struct nfs4_setclientid_res clid = { 68 .clientid = clp->cl_clientid, 69 .confirm = clp->cl_confirm, 70 }; 71 unsigned short port; 72 int status; 73 74 if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state)) 75 goto do_confirm; 76 port = nfs_callback_tcpport; 77 if (clp->cl_addr.ss_family == AF_INET6) 78 port = nfs_callback_tcpport6; 79 80 status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid); 81 if (status != 0) 82 goto out; 83 clp->cl_clientid = clid.clientid; 84 clp->cl_confirm = clid.confirm; 85 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 86 do_confirm: 87 status = nfs4_proc_setclientid_confirm(clp, &clid, cred); 88 if (status != 0) 89 goto out; 90 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 91 nfs4_schedule_state_renewal(clp); 92 out: 93 return status; 94 } 95 96 struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp) 97 { 98 struct rpc_cred *cred = NULL; 99 100 if (clp->cl_machine_cred != NULL) 101 cred = get_rpccred(clp->cl_machine_cred); 102 return cred; 103 } 104 105 static void nfs4_clear_machine_cred(struct nfs_client *clp) 106 { 107 struct rpc_cred *cred; 108 109 spin_lock(&clp->cl_lock); 110 cred = clp->cl_machine_cred; 111 clp->cl_machine_cred = NULL; 112 spin_unlock(&clp->cl_lock); 113 if (cred != NULL) 114 put_rpccred(cred); 115 } 116 117 static struct rpc_cred * 118 nfs4_get_renew_cred_server_locked(struct nfs_server *server) 119 { 120 struct rpc_cred *cred = NULL; 121 struct nfs4_state_owner *sp; 122 struct rb_node *pos; 123 124 for (pos = rb_first(&server->state_owners); 125 pos != NULL; 126 pos = rb_next(pos)) { 127 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node); 128 if (list_empty(&sp->so_states)) 129 continue; 130 cred = get_rpccred(sp->so_cred); 131 break; 132 } 133 return cred; 134 } 135 136 /** 137 * nfs4_get_renew_cred_locked - Acquire credential for a renew operation 138 * @clp: client state handle 139 * 140 * Returns an rpc_cred with reference count bumped, or NULL. 141 * Caller must hold clp->cl_lock. 142 */ 143 struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp) 144 { 145 struct rpc_cred *cred = NULL; 146 struct nfs_server *server; 147 148 rcu_read_lock(); 149 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 150 cred = nfs4_get_renew_cred_server_locked(server); 151 if (cred != NULL) 152 break; 153 } 154 rcu_read_unlock(); 155 return cred; 156 } 157 158 #if defined(CONFIG_NFS_V4_1) 159 160 static int nfs41_setup_state_renewal(struct nfs_client *clp) 161 { 162 int status; 163 struct nfs_fsinfo fsinfo; 164 165 if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) { 166 nfs4_schedule_state_renewal(clp); 167 return 0; 168 } 169 170 status = nfs4_proc_get_lease_time(clp, &fsinfo); 171 if (status == 0) { 172 /* Update lease time and schedule renewal */ 173 spin_lock(&clp->cl_lock); 174 clp->cl_lease_time = fsinfo.lease_time * HZ; 175 clp->cl_last_renewal = jiffies; 176 spin_unlock(&clp->cl_lock); 177 178 nfs4_schedule_state_renewal(clp); 179 } 180 181 return status; 182 } 183 184 /* 185 * Back channel returns NFS4ERR_DELAY for new requests when 186 * NFS4_SESSION_DRAINING is set so there is no work to be done when draining 187 * is ended. 188 */ 189 static void nfs4_end_drain_session(struct nfs_client *clp) 190 { 191 struct nfs4_session *ses = clp->cl_session; 192 int max_slots; 193 194 if (ses == NULL) 195 return; 196 if (test_and_clear_bit(NFS4_SESSION_DRAINING, &ses->session_state)) { 197 spin_lock(&ses->fc_slot_table.slot_tbl_lock); 198 max_slots = ses->fc_slot_table.max_slots; 199 while (max_slots--) { 200 struct rpc_task *task; 201 202 task = rpc_wake_up_next(&ses->fc_slot_table. 203 slot_tbl_waitq); 204 if (!task) 205 break; 206 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 207 } 208 spin_unlock(&ses->fc_slot_table.slot_tbl_lock); 209 } 210 } 211 212 static int nfs4_wait_on_slot_tbl(struct nfs4_slot_table *tbl) 213 { 214 spin_lock(&tbl->slot_tbl_lock); 215 if (tbl->highest_used_slotid != -1) { 216 INIT_COMPLETION(tbl->complete); 217 spin_unlock(&tbl->slot_tbl_lock); 218 return wait_for_completion_interruptible(&tbl->complete); 219 } 220 spin_unlock(&tbl->slot_tbl_lock); 221 return 0; 222 } 223 224 static int nfs4_begin_drain_session(struct nfs_client *clp) 225 { 226 struct nfs4_session *ses = clp->cl_session; 227 int ret = 0; 228 229 set_bit(NFS4_SESSION_DRAINING, &ses->session_state); 230 /* back channel */ 231 ret = nfs4_wait_on_slot_tbl(&ses->bc_slot_table); 232 if (ret) 233 return ret; 234 /* fore channel */ 235 return nfs4_wait_on_slot_tbl(&ses->fc_slot_table); 236 } 237 238 int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred) 239 { 240 int status; 241 242 if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state)) 243 goto do_confirm; 244 nfs4_begin_drain_session(clp); 245 status = nfs4_proc_exchange_id(clp, cred); 246 if (status != 0) 247 goto out; 248 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 249 do_confirm: 250 status = nfs4_proc_create_session(clp); 251 if (status != 0) 252 goto out; 253 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 254 nfs41_setup_state_renewal(clp); 255 nfs_mark_client_ready(clp, NFS_CS_READY); 256 out: 257 return status; 258 } 259 260 struct rpc_cred *nfs4_get_exchange_id_cred(struct nfs_client *clp) 261 { 262 struct rpc_cred *cred; 263 264 spin_lock(&clp->cl_lock); 265 cred = nfs4_get_machine_cred_locked(clp); 266 spin_unlock(&clp->cl_lock); 267 return cred; 268 } 269 270 #endif /* CONFIG_NFS_V4_1 */ 271 272 static struct rpc_cred * 273 nfs4_get_setclientid_cred_server(struct nfs_server *server) 274 { 275 struct nfs_client *clp = server->nfs_client; 276 struct rpc_cred *cred = NULL; 277 struct nfs4_state_owner *sp; 278 struct rb_node *pos; 279 280 spin_lock(&clp->cl_lock); 281 pos = rb_first(&server->state_owners); 282 if (pos != NULL) { 283 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node); 284 cred = get_rpccred(sp->so_cred); 285 } 286 spin_unlock(&clp->cl_lock); 287 return cred; 288 } 289 290 /** 291 * nfs4_get_setclientid_cred - Acquire credential for a setclientid operation 292 * @clp: client state handle 293 * 294 * Returns an rpc_cred with reference count bumped, or NULL. 295 */ 296 struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp) 297 { 298 struct nfs_server *server; 299 struct rpc_cred *cred; 300 301 spin_lock(&clp->cl_lock); 302 cred = nfs4_get_machine_cred_locked(clp); 303 spin_unlock(&clp->cl_lock); 304 if (cred != NULL) 305 goto out; 306 307 rcu_read_lock(); 308 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 309 cred = nfs4_get_setclientid_cred_server(server); 310 if (cred != NULL) 311 break; 312 } 313 rcu_read_unlock(); 314 315 out: 316 return cred; 317 } 318 319 static void nfs_alloc_unique_id_locked(struct rb_root *root, 320 struct nfs_unique_id *new, 321 __u64 minval, int maxbits) 322 { 323 struct rb_node **p, *parent; 324 struct nfs_unique_id *pos; 325 __u64 mask = ~0ULL; 326 327 if (maxbits < 64) 328 mask = (1ULL << maxbits) - 1ULL; 329 330 /* Ensure distribution is more or less flat */ 331 get_random_bytes(&new->id, sizeof(new->id)); 332 new->id &= mask; 333 if (new->id < minval) 334 new->id += minval; 335 retry: 336 p = &root->rb_node; 337 parent = NULL; 338 339 while (*p != NULL) { 340 parent = *p; 341 pos = rb_entry(parent, struct nfs_unique_id, rb_node); 342 343 if (new->id < pos->id) 344 p = &(*p)->rb_left; 345 else if (new->id > pos->id) 346 p = &(*p)->rb_right; 347 else 348 goto id_exists; 349 } 350 rb_link_node(&new->rb_node, parent, p); 351 rb_insert_color(&new->rb_node, root); 352 return; 353 id_exists: 354 for (;;) { 355 new->id++; 356 if (new->id < minval || (new->id & mask) != new->id) { 357 new->id = minval; 358 break; 359 } 360 parent = rb_next(parent); 361 if (parent == NULL) 362 break; 363 pos = rb_entry(parent, struct nfs_unique_id, rb_node); 364 if (new->id < pos->id) 365 break; 366 } 367 goto retry; 368 } 369 370 static void nfs_free_unique_id(struct rb_root *root, struct nfs_unique_id *id) 371 { 372 rb_erase(&id->rb_node, root); 373 } 374 375 static struct nfs4_state_owner * 376 nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred) 377 { 378 struct rb_node **p = &server->state_owners.rb_node, 379 *parent = NULL; 380 struct nfs4_state_owner *sp, *res = NULL; 381 382 while (*p != NULL) { 383 parent = *p; 384 sp = rb_entry(parent, struct nfs4_state_owner, so_server_node); 385 386 if (server < sp->so_server) { 387 p = &parent->rb_left; 388 continue; 389 } 390 if (server > sp->so_server) { 391 p = &parent->rb_right; 392 continue; 393 } 394 if (cred < sp->so_cred) 395 p = &parent->rb_left; 396 else if (cred > sp->so_cred) 397 p = &parent->rb_right; 398 else { 399 atomic_inc(&sp->so_count); 400 res = sp; 401 break; 402 } 403 } 404 return res; 405 } 406 407 static struct nfs4_state_owner * 408 nfs4_insert_state_owner_locked(struct nfs4_state_owner *new) 409 { 410 struct nfs_server *server = new->so_server; 411 struct rb_node **p = &server->state_owners.rb_node, 412 *parent = NULL; 413 struct nfs4_state_owner *sp; 414 415 while (*p != NULL) { 416 parent = *p; 417 sp = rb_entry(parent, struct nfs4_state_owner, so_server_node); 418 419 if (new->so_cred < sp->so_cred) 420 p = &parent->rb_left; 421 else if (new->so_cred > sp->so_cred) 422 p = &parent->rb_right; 423 else { 424 atomic_inc(&sp->so_count); 425 return sp; 426 } 427 } 428 nfs_alloc_unique_id_locked(&server->openowner_id, 429 &new->so_owner_id, 1, 64); 430 rb_link_node(&new->so_server_node, parent, p); 431 rb_insert_color(&new->so_server_node, &server->state_owners); 432 return new; 433 } 434 435 static void 436 nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp) 437 { 438 struct nfs_server *server = sp->so_server; 439 440 if (!RB_EMPTY_NODE(&sp->so_server_node)) 441 rb_erase(&sp->so_server_node, &server->state_owners); 442 nfs_free_unique_id(&server->openowner_id, &sp->so_owner_id); 443 } 444 445 /* 446 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to 447 * create a new state_owner. 448 * 449 */ 450 static struct nfs4_state_owner * 451 nfs4_alloc_state_owner(void) 452 { 453 struct nfs4_state_owner *sp; 454 455 sp = kzalloc(sizeof(*sp),GFP_NOFS); 456 if (!sp) 457 return NULL; 458 spin_lock_init(&sp->so_lock); 459 INIT_LIST_HEAD(&sp->so_states); 460 rpc_init_wait_queue(&sp->so_sequence.wait, "Seqid_waitqueue"); 461 sp->so_seqid.sequence = &sp->so_sequence; 462 spin_lock_init(&sp->so_sequence.lock); 463 INIT_LIST_HEAD(&sp->so_sequence.list); 464 atomic_set(&sp->so_count, 1); 465 return sp; 466 } 467 468 static void 469 nfs4_drop_state_owner(struct nfs4_state_owner *sp) 470 { 471 if (!RB_EMPTY_NODE(&sp->so_server_node)) { 472 struct nfs_server *server = sp->so_server; 473 struct nfs_client *clp = server->nfs_client; 474 475 spin_lock(&clp->cl_lock); 476 rb_erase(&sp->so_server_node, &server->state_owners); 477 RB_CLEAR_NODE(&sp->so_server_node); 478 spin_unlock(&clp->cl_lock); 479 } 480 } 481 482 /** 483 * nfs4_get_state_owner - Look up a state owner given a credential 484 * @server: nfs_server to search 485 * @cred: RPC credential to match 486 * 487 * Returns a pointer to an instantiated nfs4_state_owner struct, or NULL. 488 */ 489 struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server, 490 struct rpc_cred *cred) 491 { 492 struct nfs_client *clp = server->nfs_client; 493 struct nfs4_state_owner *sp, *new; 494 495 spin_lock(&clp->cl_lock); 496 sp = nfs4_find_state_owner_locked(server, cred); 497 spin_unlock(&clp->cl_lock); 498 if (sp != NULL) 499 return sp; 500 new = nfs4_alloc_state_owner(); 501 if (new == NULL) 502 return NULL; 503 new->so_server = server; 504 new->so_cred = cred; 505 spin_lock(&clp->cl_lock); 506 sp = nfs4_insert_state_owner_locked(new); 507 spin_unlock(&clp->cl_lock); 508 if (sp == new) 509 get_rpccred(cred); 510 else { 511 rpc_destroy_wait_queue(&new->so_sequence.wait); 512 kfree(new); 513 } 514 return sp; 515 } 516 517 /** 518 * nfs4_put_state_owner - Release a nfs4_state_owner 519 * @sp: state owner data to release 520 * 521 */ 522 void nfs4_put_state_owner(struct nfs4_state_owner *sp) 523 { 524 struct nfs_client *clp = sp->so_server->nfs_client; 525 struct rpc_cred *cred = sp->so_cred; 526 527 if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock)) 528 return; 529 nfs4_remove_state_owner_locked(sp); 530 spin_unlock(&clp->cl_lock); 531 rpc_destroy_wait_queue(&sp->so_sequence.wait); 532 put_rpccred(cred); 533 kfree(sp); 534 } 535 536 static struct nfs4_state * 537 nfs4_alloc_open_state(void) 538 { 539 struct nfs4_state *state; 540 541 state = kzalloc(sizeof(*state), GFP_NOFS); 542 if (!state) 543 return NULL; 544 atomic_set(&state->count, 1); 545 INIT_LIST_HEAD(&state->lock_states); 546 spin_lock_init(&state->state_lock); 547 seqlock_init(&state->seqlock); 548 return state; 549 } 550 551 void 552 nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode) 553 { 554 if (state->state == fmode) 555 return; 556 /* NB! List reordering - see the reclaim code for why. */ 557 if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { 558 if (fmode & FMODE_WRITE) 559 list_move(&state->open_states, &state->owner->so_states); 560 else 561 list_move_tail(&state->open_states, &state->owner->so_states); 562 } 563 state->state = fmode; 564 } 565 566 static struct nfs4_state * 567 __nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner) 568 { 569 struct nfs_inode *nfsi = NFS_I(inode); 570 struct nfs4_state *state; 571 572 list_for_each_entry(state, &nfsi->open_states, inode_states) { 573 if (state->owner != owner) 574 continue; 575 if (atomic_inc_not_zero(&state->count)) 576 return state; 577 } 578 return NULL; 579 } 580 581 static void 582 nfs4_free_open_state(struct nfs4_state *state) 583 { 584 kfree(state); 585 } 586 587 struct nfs4_state * 588 nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner) 589 { 590 struct nfs4_state *state, *new; 591 struct nfs_inode *nfsi = NFS_I(inode); 592 593 spin_lock(&inode->i_lock); 594 state = __nfs4_find_state_byowner(inode, owner); 595 spin_unlock(&inode->i_lock); 596 if (state) 597 goto out; 598 new = nfs4_alloc_open_state(); 599 spin_lock(&owner->so_lock); 600 spin_lock(&inode->i_lock); 601 state = __nfs4_find_state_byowner(inode, owner); 602 if (state == NULL && new != NULL) { 603 state = new; 604 state->owner = owner; 605 atomic_inc(&owner->so_count); 606 list_add(&state->inode_states, &nfsi->open_states); 607 ihold(inode); 608 state->inode = inode; 609 spin_unlock(&inode->i_lock); 610 /* Note: The reclaim code dictates that we add stateless 611 * and read-only stateids to the end of the list */ 612 list_add_tail(&state->open_states, &owner->so_states); 613 spin_unlock(&owner->so_lock); 614 } else { 615 spin_unlock(&inode->i_lock); 616 spin_unlock(&owner->so_lock); 617 if (new) 618 nfs4_free_open_state(new); 619 } 620 out: 621 return state; 622 } 623 624 void nfs4_put_open_state(struct nfs4_state *state) 625 { 626 struct inode *inode = state->inode; 627 struct nfs4_state_owner *owner = state->owner; 628 629 if (!atomic_dec_and_lock(&state->count, &owner->so_lock)) 630 return; 631 spin_lock(&inode->i_lock); 632 list_del(&state->inode_states); 633 list_del(&state->open_states); 634 spin_unlock(&inode->i_lock); 635 spin_unlock(&owner->so_lock); 636 iput(inode); 637 nfs4_free_open_state(state); 638 nfs4_put_state_owner(owner); 639 } 640 641 /* 642 * Close the current file. 643 */ 644 static void __nfs4_close(struct path *path, struct nfs4_state *state, 645 fmode_t fmode, gfp_t gfp_mask, int wait) 646 { 647 struct nfs4_state_owner *owner = state->owner; 648 int call_close = 0; 649 fmode_t newstate; 650 651 atomic_inc(&owner->so_count); 652 /* Protect against nfs4_find_state() */ 653 spin_lock(&owner->so_lock); 654 switch (fmode & (FMODE_READ | FMODE_WRITE)) { 655 case FMODE_READ: 656 state->n_rdonly--; 657 break; 658 case FMODE_WRITE: 659 state->n_wronly--; 660 break; 661 case FMODE_READ|FMODE_WRITE: 662 state->n_rdwr--; 663 } 664 newstate = FMODE_READ|FMODE_WRITE; 665 if (state->n_rdwr == 0) { 666 if (state->n_rdonly == 0) { 667 newstate &= ~FMODE_READ; 668 call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags); 669 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags); 670 } 671 if (state->n_wronly == 0) { 672 newstate &= ~FMODE_WRITE; 673 call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags); 674 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags); 675 } 676 if (newstate == 0) 677 clear_bit(NFS_DELEGATED_STATE, &state->flags); 678 } 679 nfs4_state_set_mode_locked(state, newstate); 680 spin_unlock(&owner->so_lock); 681 682 if (!call_close) { 683 nfs4_put_open_state(state); 684 nfs4_put_state_owner(owner); 685 } else { 686 bool roc = pnfs_roc(state->inode); 687 688 nfs4_do_close(path, state, gfp_mask, wait, roc); 689 } 690 } 691 692 void nfs4_close_state(struct path *path, struct nfs4_state *state, fmode_t fmode) 693 { 694 __nfs4_close(path, state, fmode, GFP_NOFS, 0); 695 } 696 697 void nfs4_close_sync(struct path *path, struct nfs4_state *state, fmode_t fmode) 698 { 699 __nfs4_close(path, state, fmode, GFP_KERNEL, 1); 700 } 701 702 /* 703 * Search the state->lock_states for an existing lock_owner 704 * that is compatible with current->files 705 */ 706 static struct nfs4_lock_state * 707 __nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type) 708 { 709 struct nfs4_lock_state *pos; 710 list_for_each_entry(pos, &state->lock_states, ls_locks) { 711 if (type != NFS4_ANY_LOCK_TYPE && pos->ls_owner.lo_type != type) 712 continue; 713 switch (pos->ls_owner.lo_type) { 714 case NFS4_POSIX_LOCK_TYPE: 715 if (pos->ls_owner.lo_u.posix_owner != fl_owner) 716 continue; 717 break; 718 case NFS4_FLOCK_LOCK_TYPE: 719 if (pos->ls_owner.lo_u.flock_owner != fl_pid) 720 continue; 721 } 722 atomic_inc(&pos->ls_count); 723 return pos; 724 } 725 return NULL; 726 } 727 728 /* 729 * Return a compatible lock_state. If no initialized lock_state structure 730 * exists, return an uninitialized one. 731 * 732 */ 733 static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type) 734 { 735 struct nfs4_lock_state *lsp; 736 struct nfs_server *server = state->owner->so_server; 737 struct nfs_client *clp = server->nfs_client; 738 739 lsp = kzalloc(sizeof(*lsp), GFP_NOFS); 740 if (lsp == NULL) 741 return NULL; 742 rpc_init_wait_queue(&lsp->ls_sequence.wait, "lock_seqid_waitqueue"); 743 spin_lock_init(&lsp->ls_sequence.lock); 744 INIT_LIST_HEAD(&lsp->ls_sequence.list); 745 lsp->ls_seqid.sequence = &lsp->ls_sequence; 746 atomic_set(&lsp->ls_count, 1); 747 lsp->ls_state = state; 748 lsp->ls_owner.lo_type = type; 749 switch (lsp->ls_owner.lo_type) { 750 case NFS4_FLOCK_LOCK_TYPE: 751 lsp->ls_owner.lo_u.flock_owner = fl_pid; 752 break; 753 case NFS4_POSIX_LOCK_TYPE: 754 lsp->ls_owner.lo_u.posix_owner = fl_owner; 755 break; 756 default: 757 kfree(lsp); 758 return NULL; 759 } 760 spin_lock(&clp->cl_lock); 761 nfs_alloc_unique_id_locked(&server->lockowner_id, &lsp->ls_id, 1, 64); 762 spin_unlock(&clp->cl_lock); 763 INIT_LIST_HEAD(&lsp->ls_locks); 764 return lsp; 765 } 766 767 static void nfs4_free_lock_state(struct nfs4_lock_state *lsp) 768 { 769 struct nfs_server *server = lsp->ls_state->owner->so_server; 770 struct nfs_client *clp = server->nfs_client; 771 772 spin_lock(&clp->cl_lock); 773 nfs_free_unique_id(&server->lockowner_id, &lsp->ls_id); 774 spin_unlock(&clp->cl_lock); 775 rpc_destroy_wait_queue(&lsp->ls_sequence.wait); 776 kfree(lsp); 777 } 778 779 /* 780 * Return a compatible lock_state. If no initialized lock_state structure 781 * exists, return an uninitialized one. 782 * 783 */ 784 static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner, pid_t pid, unsigned int type) 785 { 786 struct nfs4_lock_state *lsp, *new = NULL; 787 788 for(;;) { 789 spin_lock(&state->state_lock); 790 lsp = __nfs4_find_lock_state(state, owner, pid, type); 791 if (lsp != NULL) 792 break; 793 if (new != NULL) { 794 list_add(&new->ls_locks, &state->lock_states); 795 set_bit(LK_STATE_IN_USE, &state->flags); 796 lsp = new; 797 new = NULL; 798 break; 799 } 800 spin_unlock(&state->state_lock); 801 new = nfs4_alloc_lock_state(state, owner, pid, type); 802 if (new == NULL) 803 return NULL; 804 } 805 spin_unlock(&state->state_lock); 806 if (new != NULL) 807 nfs4_free_lock_state(new); 808 return lsp; 809 } 810 811 /* 812 * Release reference to lock_state, and free it if we see that 813 * it is no longer in use 814 */ 815 void nfs4_put_lock_state(struct nfs4_lock_state *lsp) 816 { 817 struct nfs4_state *state; 818 819 if (lsp == NULL) 820 return; 821 state = lsp->ls_state; 822 if (!atomic_dec_and_lock(&lsp->ls_count, &state->state_lock)) 823 return; 824 list_del(&lsp->ls_locks); 825 if (list_empty(&state->lock_states)) 826 clear_bit(LK_STATE_IN_USE, &state->flags); 827 spin_unlock(&state->state_lock); 828 if (lsp->ls_flags & NFS_LOCK_INITIALIZED) 829 nfs4_release_lockowner(lsp); 830 nfs4_free_lock_state(lsp); 831 } 832 833 static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src) 834 { 835 struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner; 836 837 dst->fl_u.nfs4_fl.owner = lsp; 838 atomic_inc(&lsp->ls_count); 839 } 840 841 static void nfs4_fl_release_lock(struct file_lock *fl) 842 { 843 nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner); 844 } 845 846 static const struct file_lock_operations nfs4_fl_lock_ops = { 847 .fl_copy_lock = nfs4_fl_copy_lock, 848 .fl_release_private = nfs4_fl_release_lock, 849 }; 850 851 int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl) 852 { 853 struct nfs4_lock_state *lsp; 854 855 if (fl->fl_ops != NULL) 856 return 0; 857 if (fl->fl_flags & FL_POSIX) 858 lsp = nfs4_get_lock_state(state, fl->fl_owner, 0, NFS4_POSIX_LOCK_TYPE); 859 else if (fl->fl_flags & FL_FLOCK) 860 lsp = nfs4_get_lock_state(state, 0, fl->fl_pid, NFS4_FLOCK_LOCK_TYPE); 861 else 862 return -EINVAL; 863 if (lsp == NULL) 864 return -ENOMEM; 865 fl->fl_u.nfs4_fl.owner = lsp; 866 fl->fl_ops = &nfs4_fl_lock_ops; 867 return 0; 868 } 869 870 /* 871 * Byte-range lock aware utility to initialize the stateid of read/write 872 * requests. 873 */ 874 void nfs4_copy_stateid(nfs4_stateid *dst, struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid) 875 { 876 struct nfs4_lock_state *lsp; 877 int seq; 878 879 do { 880 seq = read_seqbegin(&state->seqlock); 881 memcpy(dst, &state->stateid, sizeof(*dst)); 882 } while (read_seqretry(&state->seqlock, seq)); 883 if (test_bit(LK_STATE_IN_USE, &state->flags) == 0) 884 return; 885 886 spin_lock(&state->state_lock); 887 lsp = __nfs4_find_lock_state(state, fl_owner, fl_pid, NFS4_ANY_LOCK_TYPE); 888 if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0) 889 memcpy(dst, &lsp->ls_stateid, sizeof(*dst)); 890 spin_unlock(&state->state_lock); 891 nfs4_put_lock_state(lsp); 892 } 893 894 struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask) 895 { 896 struct nfs_seqid *new; 897 898 new = kmalloc(sizeof(*new), gfp_mask); 899 if (new != NULL) { 900 new->sequence = counter; 901 INIT_LIST_HEAD(&new->list); 902 } 903 return new; 904 } 905 906 void nfs_release_seqid(struct nfs_seqid *seqid) 907 { 908 if (!list_empty(&seqid->list)) { 909 struct rpc_sequence *sequence = seqid->sequence->sequence; 910 911 spin_lock(&sequence->lock); 912 list_del_init(&seqid->list); 913 spin_unlock(&sequence->lock); 914 rpc_wake_up(&sequence->wait); 915 } 916 } 917 918 void nfs_free_seqid(struct nfs_seqid *seqid) 919 { 920 nfs_release_seqid(seqid); 921 kfree(seqid); 922 } 923 924 /* 925 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or 926 * failed with a seqid incrementing error - 927 * see comments nfs_fs.h:seqid_mutating_error() 928 */ 929 static void nfs_increment_seqid(int status, struct nfs_seqid *seqid) 930 { 931 BUG_ON(list_first_entry(&seqid->sequence->sequence->list, struct nfs_seqid, list) != seqid); 932 switch (status) { 933 case 0: 934 break; 935 case -NFS4ERR_BAD_SEQID: 936 if (seqid->sequence->flags & NFS_SEQID_CONFIRMED) 937 return; 938 printk(KERN_WARNING "NFS: v4 server returned a bad" 939 " sequence-id error on an" 940 " unconfirmed sequence %p!\n", 941 seqid->sequence); 942 case -NFS4ERR_STALE_CLIENTID: 943 case -NFS4ERR_STALE_STATEID: 944 case -NFS4ERR_BAD_STATEID: 945 case -NFS4ERR_BADXDR: 946 case -NFS4ERR_RESOURCE: 947 case -NFS4ERR_NOFILEHANDLE: 948 /* Non-seqid mutating errors */ 949 return; 950 }; 951 /* 952 * Note: no locking needed as we are guaranteed to be first 953 * on the sequence list 954 */ 955 seqid->sequence->counter++; 956 } 957 958 void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid) 959 { 960 struct nfs4_state_owner *sp = container_of(seqid->sequence, 961 struct nfs4_state_owner, so_seqid); 962 struct nfs_server *server = sp->so_server; 963 964 if (status == -NFS4ERR_BAD_SEQID) 965 nfs4_drop_state_owner(sp); 966 if (!nfs4_has_session(server->nfs_client)) 967 nfs_increment_seqid(status, seqid); 968 } 969 970 /* 971 * Increment the seqid if the LOCK/LOCKU succeeded, or 972 * failed with a seqid incrementing error - 973 * see comments nfs_fs.h:seqid_mutating_error() 974 */ 975 void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid) 976 { 977 nfs_increment_seqid(status, seqid); 978 } 979 980 int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task) 981 { 982 struct rpc_sequence *sequence = seqid->sequence->sequence; 983 int status = 0; 984 985 spin_lock(&sequence->lock); 986 if (list_empty(&seqid->list)) 987 list_add_tail(&seqid->list, &sequence->list); 988 if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid) 989 goto unlock; 990 rpc_sleep_on(&sequence->wait, task, NULL); 991 status = -EAGAIN; 992 unlock: 993 spin_unlock(&sequence->lock); 994 return status; 995 } 996 997 static int nfs4_run_state_manager(void *); 998 999 static void nfs4_clear_state_manager_bit(struct nfs_client *clp) 1000 { 1001 smp_mb__before_clear_bit(); 1002 clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state); 1003 smp_mb__after_clear_bit(); 1004 wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING); 1005 rpc_wake_up(&clp->cl_rpcwaitq); 1006 } 1007 1008 /* 1009 * Schedule the nfs_client asynchronous state management routine 1010 */ 1011 void nfs4_schedule_state_manager(struct nfs_client *clp) 1012 { 1013 struct task_struct *task; 1014 1015 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) 1016 return; 1017 __module_get(THIS_MODULE); 1018 atomic_inc(&clp->cl_count); 1019 task = kthread_run(nfs4_run_state_manager, clp, "%s-manager", 1020 rpc_peeraddr2str(clp->cl_rpcclient, 1021 RPC_DISPLAY_ADDR)); 1022 if (!IS_ERR(task)) 1023 return; 1024 nfs4_clear_state_manager_bit(clp); 1025 nfs_put_client(clp); 1026 module_put(THIS_MODULE); 1027 } 1028 1029 /* 1030 * Schedule a lease recovery attempt 1031 */ 1032 void nfs4_schedule_lease_recovery(struct nfs_client *clp) 1033 { 1034 if (!clp) 1035 return; 1036 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 1037 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 1038 nfs4_schedule_state_manager(clp); 1039 } 1040 1041 static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state) 1042 { 1043 1044 set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); 1045 /* Don't recover state that expired before the reboot */ 1046 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) { 1047 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); 1048 return 0; 1049 } 1050 set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags); 1051 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); 1052 return 1; 1053 } 1054 1055 static int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state) 1056 { 1057 set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags); 1058 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); 1059 set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags); 1060 set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state); 1061 return 1; 1062 } 1063 1064 void nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state) 1065 { 1066 struct nfs_client *clp = server->nfs_client; 1067 1068 nfs4_state_mark_reclaim_nograce(clp, state); 1069 nfs4_schedule_state_manager(clp); 1070 } 1071 1072 static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops) 1073 { 1074 struct inode *inode = state->inode; 1075 struct nfs_inode *nfsi = NFS_I(inode); 1076 struct file_lock *fl; 1077 int status = 0; 1078 1079 if (inode->i_flock == NULL) 1080 return 0; 1081 1082 /* Guard against delegation returns and new lock/unlock calls */ 1083 down_write(&nfsi->rwsem); 1084 /* Protect inode->i_flock using the BKL */ 1085 lock_flocks(); 1086 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 1087 if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK))) 1088 continue; 1089 if (nfs_file_open_context(fl->fl_file)->state != state) 1090 continue; 1091 unlock_flocks(); 1092 status = ops->recover_lock(state, fl); 1093 switch (status) { 1094 case 0: 1095 break; 1096 case -ESTALE: 1097 case -NFS4ERR_ADMIN_REVOKED: 1098 case -NFS4ERR_STALE_STATEID: 1099 case -NFS4ERR_BAD_STATEID: 1100 case -NFS4ERR_EXPIRED: 1101 case -NFS4ERR_NO_GRACE: 1102 case -NFS4ERR_STALE_CLIENTID: 1103 case -NFS4ERR_BADSESSION: 1104 case -NFS4ERR_BADSLOT: 1105 case -NFS4ERR_BAD_HIGH_SLOT: 1106 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1107 goto out; 1108 default: 1109 printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n", 1110 __func__, status); 1111 case -ENOMEM: 1112 case -NFS4ERR_DENIED: 1113 case -NFS4ERR_RECLAIM_BAD: 1114 case -NFS4ERR_RECLAIM_CONFLICT: 1115 /* kill_proc(fl->fl_pid, SIGLOST, 1); */ 1116 status = 0; 1117 } 1118 lock_flocks(); 1119 } 1120 unlock_flocks(); 1121 out: 1122 up_write(&nfsi->rwsem); 1123 return status; 1124 } 1125 1126 static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops) 1127 { 1128 struct nfs4_state *state; 1129 struct nfs4_lock_state *lock; 1130 int status = 0; 1131 1132 /* Note: we rely on the sp->so_states list being ordered 1133 * so that we always reclaim open(O_RDWR) and/or open(O_WRITE) 1134 * states first. 1135 * This is needed to ensure that the server won't give us any 1136 * read delegations that we have to return if, say, we are 1137 * recovering after a network partition or a reboot from a 1138 * server that doesn't support a grace period. 1139 */ 1140 restart: 1141 spin_lock(&sp->so_lock); 1142 list_for_each_entry(state, &sp->so_states, open_states) { 1143 if (!test_and_clear_bit(ops->state_flag_bit, &state->flags)) 1144 continue; 1145 if (state->state == 0) 1146 continue; 1147 atomic_inc(&state->count); 1148 spin_unlock(&sp->so_lock); 1149 status = ops->recover_open(sp, state); 1150 if (status >= 0) { 1151 status = nfs4_reclaim_locks(state, ops); 1152 if (status >= 0) { 1153 list_for_each_entry(lock, &state->lock_states, ls_locks) { 1154 if (!(lock->ls_flags & NFS_LOCK_INITIALIZED)) 1155 printk("%s: Lock reclaim failed!\n", 1156 __func__); 1157 } 1158 nfs4_put_open_state(state); 1159 goto restart; 1160 } 1161 } 1162 switch (status) { 1163 default: 1164 printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n", 1165 __func__, status); 1166 case -ENOENT: 1167 case -ENOMEM: 1168 case -ESTALE: 1169 /* 1170 * Open state on this file cannot be recovered 1171 * All we can do is revert to using the zero stateid. 1172 */ 1173 memset(state->stateid.data, 0, 1174 sizeof(state->stateid.data)); 1175 /* Mark the file as being 'closed' */ 1176 state->state = 0; 1177 break; 1178 case -EKEYEXPIRED: 1179 /* 1180 * User RPCSEC_GSS context has expired. 1181 * We cannot recover this stateid now, so 1182 * skip it and allow recovery thread to 1183 * proceed. 1184 */ 1185 break; 1186 case -NFS4ERR_ADMIN_REVOKED: 1187 case -NFS4ERR_STALE_STATEID: 1188 case -NFS4ERR_BAD_STATEID: 1189 case -NFS4ERR_RECLAIM_BAD: 1190 case -NFS4ERR_RECLAIM_CONFLICT: 1191 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state); 1192 break; 1193 case -NFS4ERR_EXPIRED: 1194 case -NFS4ERR_NO_GRACE: 1195 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state); 1196 case -NFS4ERR_STALE_CLIENTID: 1197 case -NFS4ERR_BADSESSION: 1198 case -NFS4ERR_BADSLOT: 1199 case -NFS4ERR_BAD_HIGH_SLOT: 1200 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1201 goto out_err; 1202 } 1203 nfs4_put_open_state(state); 1204 goto restart; 1205 } 1206 spin_unlock(&sp->so_lock); 1207 return 0; 1208 out_err: 1209 nfs4_put_open_state(state); 1210 return status; 1211 } 1212 1213 static void nfs4_clear_open_state(struct nfs4_state *state) 1214 { 1215 struct nfs4_lock_state *lock; 1216 1217 clear_bit(NFS_DELEGATED_STATE, &state->flags); 1218 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1219 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1220 clear_bit(NFS_O_RDWR_STATE, &state->flags); 1221 list_for_each_entry(lock, &state->lock_states, ls_locks) { 1222 lock->ls_seqid.flags = 0; 1223 lock->ls_flags &= ~NFS_LOCK_INITIALIZED; 1224 } 1225 } 1226 1227 static void nfs4_reset_seqids(struct nfs_server *server, 1228 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state)) 1229 { 1230 struct nfs_client *clp = server->nfs_client; 1231 struct nfs4_state_owner *sp; 1232 struct rb_node *pos; 1233 struct nfs4_state *state; 1234 1235 spin_lock(&clp->cl_lock); 1236 for (pos = rb_first(&server->state_owners); 1237 pos != NULL; 1238 pos = rb_next(pos)) { 1239 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node); 1240 sp->so_seqid.flags = 0; 1241 spin_lock(&sp->so_lock); 1242 list_for_each_entry(state, &sp->so_states, open_states) { 1243 if (mark_reclaim(clp, state)) 1244 nfs4_clear_open_state(state); 1245 } 1246 spin_unlock(&sp->so_lock); 1247 } 1248 spin_unlock(&clp->cl_lock); 1249 } 1250 1251 static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp, 1252 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state)) 1253 { 1254 struct nfs_server *server; 1255 1256 rcu_read_lock(); 1257 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1258 nfs4_reset_seqids(server, mark_reclaim); 1259 rcu_read_unlock(); 1260 } 1261 1262 static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp) 1263 { 1264 /* Mark all delegations for reclaim */ 1265 nfs_delegation_mark_reclaim(clp); 1266 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot); 1267 } 1268 1269 static void nfs4_reclaim_complete(struct nfs_client *clp, 1270 const struct nfs4_state_recovery_ops *ops) 1271 { 1272 /* Notify the server we're done reclaiming our state */ 1273 if (ops->reclaim_complete) 1274 (void)ops->reclaim_complete(clp); 1275 } 1276 1277 static void nfs4_clear_reclaim_server(struct nfs_server *server) 1278 { 1279 struct nfs_client *clp = server->nfs_client; 1280 struct nfs4_state_owner *sp; 1281 struct rb_node *pos; 1282 struct nfs4_state *state; 1283 1284 spin_lock(&clp->cl_lock); 1285 for (pos = rb_first(&server->state_owners); 1286 pos != NULL; 1287 pos = rb_next(pos)) { 1288 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node); 1289 spin_lock(&sp->so_lock); 1290 list_for_each_entry(state, &sp->so_states, open_states) { 1291 if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT, 1292 &state->flags)) 1293 continue; 1294 nfs4_state_mark_reclaim_nograce(clp, state); 1295 } 1296 spin_unlock(&sp->so_lock); 1297 } 1298 spin_unlock(&clp->cl_lock); 1299 } 1300 1301 static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp) 1302 { 1303 struct nfs_server *server; 1304 1305 if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) 1306 return 0; 1307 1308 rcu_read_lock(); 1309 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1310 nfs4_clear_reclaim_server(server); 1311 rcu_read_unlock(); 1312 1313 nfs_delegation_reap_unclaimed(clp); 1314 return 1; 1315 } 1316 1317 static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp) 1318 { 1319 if (!nfs4_state_clear_reclaim_reboot(clp)) 1320 return; 1321 nfs4_reclaim_complete(clp, clp->cl_mvops->reboot_recovery_ops); 1322 } 1323 1324 static void nfs_delegation_clear_all(struct nfs_client *clp) 1325 { 1326 nfs_delegation_mark_reclaim(clp); 1327 nfs_delegation_reap_unclaimed(clp); 1328 } 1329 1330 static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp) 1331 { 1332 nfs_delegation_clear_all(clp); 1333 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce); 1334 } 1335 1336 static void nfs4_warn_keyexpired(const char *s) 1337 { 1338 printk_ratelimited(KERN_WARNING "Error: state manager" 1339 " encountered RPCSEC_GSS session" 1340 " expired against NFSv4 server %s.\n", 1341 s); 1342 } 1343 1344 static int nfs4_recovery_handle_error(struct nfs_client *clp, int error) 1345 { 1346 switch (error) { 1347 case -NFS4ERR_CB_PATH_DOWN: 1348 nfs_handle_cb_pathdown(clp); 1349 return 0; 1350 case -NFS4ERR_NO_GRACE: 1351 nfs4_state_end_reclaim_reboot(clp); 1352 return 0; 1353 case -NFS4ERR_STALE_CLIENTID: 1354 case -NFS4ERR_LEASE_MOVED: 1355 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1356 nfs4_state_clear_reclaim_reboot(clp); 1357 nfs4_state_start_reclaim_reboot(clp); 1358 break; 1359 case -NFS4ERR_EXPIRED: 1360 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1361 nfs4_state_start_reclaim_nograce(clp); 1362 break; 1363 case -NFS4ERR_BADSESSION: 1364 case -NFS4ERR_BADSLOT: 1365 case -NFS4ERR_BAD_HIGH_SLOT: 1366 case -NFS4ERR_DEADSESSION: 1367 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1368 case -NFS4ERR_SEQ_FALSE_RETRY: 1369 case -NFS4ERR_SEQ_MISORDERED: 1370 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 1371 /* Zero session reset errors */ 1372 return 0; 1373 case -EKEYEXPIRED: 1374 /* Nothing we can do */ 1375 nfs4_warn_keyexpired(clp->cl_hostname); 1376 return 0; 1377 } 1378 return error; 1379 } 1380 1381 static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops) 1382 { 1383 struct nfs4_state_owner *sp; 1384 struct nfs_server *server; 1385 struct rb_node *pos; 1386 int status = 0; 1387 1388 restart: 1389 rcu_read_lock(); 1390 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 1391 spin_lock(&clp->cl_lock); 1392 for (pos = rb_first(&server->state_owners); 1393 pos != NULL; 1394 pos = rb_next(pos)) { 1395 sp = rb_entry(pos, 1396 struct nfs4_state_owner, so_server_node); 1397 if (!test_and_clear_bit(ops->owner_flag_bit, 1398 &sp->so_flags)) 1399 continue; 1400 atomic_inc(&sp->so_count); 1401 spin_unlock(&clp->cl_lock); 1402 rcu_read_unlock(); 1403 1404 status = nfs4_reclaim_open_state(sp, ops); 1405 if (status < 0) { 1406 set_bit(ops->owner_flag_bit, &sp->so_flags); 1407 nfs4_put_state_owner(sp); 1408 return nfs4_recovery_handle_error(clp, status); 1409 } 1410 1411 nfs4_put_state_owner(sp); 1412 goto restart; 1413 } 1414 spin_unlock(&clp->cl_lock); 1415 } 1416 rcu_read_unlock(); 1417 return status; 1418 } 1419 1420 static int nfs4_check_lease(struct nfs_client *clp) 1421 { 1422 struct rpc_cred *cred; 1423 const struct nfs4_state_maintenance_ops *ops = 1424 clp->cl_mvops->state_renewal_ops; 1425 int status = -NFS4ERR_EXPIRED; 1426 1427 /* Is the client already known to have an expired lease? */ 1428 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 1429 return 0; 1430 spin_lock(&clp->cl_lock); 1431 cred = ops->get_state_renewal_cred_locked(clp); 1432 spin_unlock(&clp->cl_lock); 1433 if (cred == NULL) { 1434 cred = nfs4_get_setclientid_cred(clp); 1435 if (cred == NULL) 1436 goto out; 1437 } 1438 status = ops->renew_lease(clp, cred); 1439 put_rpccred(cred); 1440 out: 1441 return nfs4_recovery_handle_error(clp, status); 1442 } 1443 1444 static int nfs4_reclaim_lease(struct nfs_client *clp) 1445 { 1446 struct rpc_cred *cred; 1447 const struct nfs4_state_recovery_ops *ops = 1448 clp->cl_mvops->reboot_recovery_ops; 1449 int status = -ENOENT; 1450 1451 cred = ops->get_clid_cred(clp); 1452 if (cred != NULL) { 1453 status = ops->establish_clid(clp, cred); 1454 put_rpccred(cred); 1455 /* Handle case where the user hasn't set up machine creds */ 1456 if (status == -EACCES && cred == clp->cl_machine_cred) { 1457 nfs4_clear_machine_cred(clp); 1458 status = -EAGAIN; 1459 } 1460 if (status == -NFS4ERR_MINOR_VERS_MISMATCH) 1461 status = -EPROTONOSUPPORT; 1462 } 1463 return status; 1464 } 1465 1466 #ifdef CONFIG_NFS_V4_1 1467 void nfs4_schedule_session_recovery(struct nfs4_session *session) 1468 { 1469 struct nfs_client *clp = session->clp; 1470 1471 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 1472 nfs4_schedule_lease_recovery(clp); 1473 } 1474 EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery); 1475 1476 void nfs41_handle_recall_slot(struct nfs_client *clp) 1477 { 1478 set_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state); 1479 nfs4_schedule_state_manager(clp); 1480 } 1481 1482 static void nfs4_reset_all_state(struct nfs_client *clp) 1483 { 1484 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) { 1485 clp->cl_boot_time = CURRENT_TIME; 1486 nfs4_state_start_reclaim_nograce(clp); 1487 nfs4_schedule_state_manager(clp); 1488 } 1489 } 1490 1491 static void nfs41_handle_server_reboot(struct nfs_client *clp) 1492 { 1493 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) { 1494 nfs4_state_start_reclaim_reboot(clp); 1495 nfs4_schedule_state_manager(clp); 1496 } 1497 } 1498 1499 static void nfs41_handle_state_revoked(struct nfs_client *clp) 1500 { 1501 /* Temporary */ 1502 nfs4_reset_all_state(clp); 1503 } 1504 1505 static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp) 1506 { 1507 /* This will need to handle layouts too */ 1508 nfs_expire_all_delegations(clp); 1509 } 1510 1511 static void nfs41_handle_cb_path_down(struct nfs_client *clp) 1512 { 1513 nfs_expire_all_delegations(clp); 1514 if (test_and_set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) == 0) 1515 nfs4_schedule_state_manager(clp); 1516 } 1517 1518 void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags) 1519 { 1520 if (!flags) 1521 return; 1522 else if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED) 1523 nfs41_handle_server_reboot(clp); 1524 else if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED | 1525 SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED | 1526 SEQ4_STATUS_ADMIN_STATE_REVOKED | 1527 SEQ4_STATUS_LEASE_MOVED)) 1528 nfs41_handle_state_revoked(clp); 1529 else if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED) 1530 nfs41_handle_recallable_state_revoked(clp); 1531 else if (flags & (SEQ4_STATUS_CB_PATH_DOWN | 1532 SEQ4_STATUS_BACKCHANNEL_FAULT | 1533 SEQ4_STATUS_CB_PATH_DOWN_SESSION)) 1534 nfs41_handle_cb_path_down(clp); 1535 } 1536 1537 static int nfs4_reset_session(struct nfs_client *clp) 1538 { 1539 int status; 1540 1541 nfs4_begin_drain_session(clp); 1542 status = nfs4_proc_destroy_session(clp->cl_session); 1543 if (status && status != -NFS4ERR_BADSESSION && 1544 status != -NFS4ERR_DEADSESSION) { 1545 status = nfs4_recovery_handle_error(clp, status); 1546 goto out; 1547 } 1548 1549 memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN); 1550 status = nfs4_proc_create_session(clp); 1551 if (status) { 1552 status = nfs4_recovery_handle_error(clp, status); 1553 goto out; 1554 } 1555 clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 1556 /* create_session negotiated new slot table */ 1557 clear_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state); 1558 1559 /* Let the state manager reestablish state */ 1560 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 1561 nfs41_setup_state_renewal(clp); 1562 out: 1563 return status; 1564 } 1565 1566 static int nfs4_recall_slot(struct nfs_client *clp) 1567 { 1568 struct nfs4_slot_table *fc_tbl = &clp->cl_session->fc_slot_table; 1569 struct nfs4_channel_attrs *fc_attrs = &clp->cl_session->fc_attrs; 1570 struct nfs4_slot *new, *old; 1571 int i; 1572 1573 nfs4_begin_drain_session(clp); 1574 new = kmalloc(fc_tbl->target_max_slots * sizeof(struct nfs4_slot), 1575 GFP_NOFS); 1576 if (!new) 1577 return -ENOMEM; 1578 1579 spin_lock(&fc_tbl->slot_tbl_lock); 1580 for (i = 0; i < fc_tbl->target_max_slots; i++) 1581 new[i].seq_nr = fc_tbl->slots[i].seq_nr; 1582 old = fc_tbl->slots; 1583 fc_tbl->slots = new; 1584 fc_tbl->max_slots = fc_tbl->target_max_slots; 1585 fc_tbl->target_max_slots = 0; 1586 fc_attrs->max_reqs = fc_tbl->max_slots; 1587 spin_unlock(&fc_tbl->slot_tbl_lock); 1588 1589 kfree(old); 1590 nfs4_end_drain_session(clp); 1591 return 0; 1592 } 1593 1594 #else /* CONFIG_NFS_V4_1 */ 1595 static int nfs4_reset_session(struct nfs_client *clp) { return 0; } 1596 static int nfs4_end_drain_session(struct nfs_client *clp) { return 0; } 1597 static int nfs4_recall_slot(struct nfs_client *clp) { return 0; } 1598 #endif /* CONFIG_NFS_V4_1 */ 1599 1600 /* Set NFS4CLNT_LEASE_EXPIRED for all v4.0 errors and for recoverable errors 1601 * on EXCHANGE_ID for v4.1 1602 */ 1603 static void nfs4_set_lease_expired(struct nfs_client *clp, int status) 1604 { 1605 switch (status) { 1606 case -NFS4ERR_CLID_INUSE: 1607 case -NFS4ERR_STALE_CLIENTID: 1608 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); 1609 break; 1610 case -NFS4ERR_DELAY: 1611 case -ETIMEDOUT: 1612 case -EAGAIN: 1613 ssleep(1); 1614 break; 1615 1616 case -EKEYEXPIRED: 1617 nfs4_warn_keyexpired(clp->cl_hostname); 1618 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery 1619 * in nfs4_exchange_id */ 1620 default: 1621 return; 1622 } 1623 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 1624 } 1625 1626 static void nfs4_state_manager(struct nfs_client *clp) 1627 { 1628 int status = 0; 1629 1630 /* Ensure exclusive access to NFSv4 state */ 1631 do { 1632 if (test_and_clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) { 1633 /* We're going to have to re-establish a clientid */ 1634 status = nfs4_reclaim_lease(clp); 1635 if (status) { 1636 nfs4_set_lease_expired(clp, status); 1637 if (test_bit(NFS4CLNT_LEASE_EXPIRED, 1638 &clp->cl_state)) 1639 continue; 1640 if (clp->cl_cons_state == 1641 NFS_CS_SESSION_INITING) 1642 nfs_mark_client_ready(clp, status); 1643 goto out_error; 1644 } 1645 clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); 1646 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); 1647 pnfs_destroy_all_layouts(clp); 1648 } 1649 1650 if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) { 1651 status = nfs4_check_lease(clp); 1652 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 1653 continue; 1654 if (status < 0 && status != -NFS4ERR_CB_PATH_DOWN) 1655 goto out_error; 1656 } 1657 1658 /* Initialize or reset the session */ 1659 if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) 1660 && nfs4_has_session(clp)) { 1661 status = nfs4_reset_session(clp); 1662 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) 1663 continue; 1664 if (status < 0) 1665 goto out_error; 1666 } 1667 1668 /* First recover reboot state... */ 1669 if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) { 1670 status = nfs4_do_reclaim(clp, 1671 clp->cl_mvops->reboot_recovery_ops); 1672 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) || 1673 test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) 1674 continue; 1675 nfs4_state_end_reclaim_reboot(clp); 1676 if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) 1677 continue; 1678 if (status < 0) 1679 goto out_error; 1680 } 1681 1682 /* Now recover expired state... */ 1683 if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) { 1684 status = nfs4_do_reclaim(clp, 1685 clp->cl_mvops->nograce_recovery_ops); 1686 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) || 1687 test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) || 1688 test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) 1689 continue; 1690 if (status < 0) 1691 goto out_error; 1692 } 1693 1694 nfs4_end_drain_session(clp); 1695 if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) { 1696 nfs_client_return_marked_delegations(clp); 1697 continue; 1698 } 1699 /* Recall session slots */ 1700 if (test_and_clear_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state) 1701 && nfs4_has_session(clp)) { 1702 status = nfs4_recall_slot(clp); 1703 if (status < 0) 1704 goto out_error; 1705 continue; 1706 } 1707 1708 1709 nfs4_clear_state_manager_bit(clp); 1710 /* Did we race with an attempt to give us more work? */ 1711 if (clp->cl_state == 0) 1712 break; 1713 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) 1714 break; 1715 } while (atomic_read(&clp->cl_count) > 1); 1716 return; 1717 out_error: 1718 printk(KERN_WARNING "Error: state manager failed on NFSv4 server %s" 1719 " with error %d\n", clp->cl_hostname, -status); 1720 nfs4_end_drain_session(clp); 1721 nfs4_clear_state_manager_bit(clp); 1722 } 1723 1724 static int nfs4_run_state_manager(void *ptr) 1725 { 1726 struct nfs_client *clp = ptr; 1727 1728 allow_signal(SIGKILL); 1729 nfs4_state_manager(clp); 1730 nfs_put_client(clp); 1731 module_put_and_exit(0); 1732 return 0; 1733 } 1734 1735 /* 1736 * Local variables: 1737 * c-basic-offset: 8 1738 * End: 1739 */ 1740