1 /* 2 * linux/fs/nfs/delegation.c 3 * 4 * Copyright (C) 2004 Trond Myklebust 5 * 6 * NFS file delegation management 7 * 8 */ 9 #include <linux/completion.h> 10 #include <linux/kthread.h> 11 #include <linux/module.h> 12 #include <linux/sched.h> 13 #include <linux/slab.h> 14 #include <linux/spinlock.h> 15 #include <linux/iversion.h> 16 17 #include <linux/nfs4.h> 18 #include <linux/nfs_fs.h> 19 #include <linux/nfs_xdr.h> 20 21 #include "nfs4_fs.h" 22 #include "nfs4session.h" 23 #include "delegation.h" 24 #include "internal.h" 25 #include "nfs4trace.h" 26 27 static void nfs_free_delegation(struct nfs_delegation *delegation) 28 { 29 if (delegation->cred) { 30 put_rpccred(delegation->cred); 31 delegation->cred = NULL; 32 } 33 kfree_rcu(delegation, rcu); 34 } 35 36 /** 37 * nfs_mark_delegation_referenced - set delegation's REFERENCED flag 38 * @delegation: delegation to process 39 * 40 */ 41 void nfs_mark_delegation_referenced(struct nfs_delegation *delegation) 42 { 43 set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags); 44 } 45 46 static bool 47 nfs4_is_valid_delegation(const struct nfs_delegation *delegation, 48 fmode_t flags) 49 { 50 if (delegation != NULL && (delegation->type & flags) == flags && 51 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) && 52 !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) 53 return true; 54 return false; 55 } 56 57 static int 58 nfs4_do_check_delegation(struct inode *inode, fmode_t flags, bool mark) 59 { 60 struct nfs_delegation *delegation; 61 int ret = 0; 62 63 flags &= FMODE_READ|FMODE_WRITE; 64 rcu_read_lock(); 65 delegation = rcu_dereference(NFS_I(inode)->delegation); 66 if (nfs4_is_valid_delegation(delegation, flags)) { 67 if (mark) 68 nfs_mark_delegation_referenced(delegation); 69 ret = 1; 70 } 71 rcu_read_unlock(); 72 return ret; 73 } 74 /** 75 * nfs_have_delegation - check if inode has a delegation, mark it 76 * NFS_DELEGATION_REFERENCED if there is one. 77 * @inode: inode to check 78 * @flags: delegation types to check for 79 * 80 * Returns one if inode has the indicated delegation, otherwise zero. 81 */ 82 int nfs4_have_delegation(struct inode *inode, fmode_t flags) 83 { 84 return nfs4_do_check_delegation(inode, flags, true); 85 } 86 87 /* 88 * nfs4_check_delegation - check if inode has a delegation, do not mark 89 * NFS_DELEGATION_REFERENCED if it has one. 90 */ 91 int nfs4_check_delegation(struct inode *inode, fmode_t flags) 92 { 93 return nfs4_do_check_delegation(inode, flags, false); 94 } 95 96 static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) 97 { 98 struct inode *inode = state->inode; 99 struct file_lock *fl; 100 struct file_lock_context *flctx = inode->i_flctx; 101 struct list_head *list; 102 int status = 0; 103 104 if (flctx == NULL) 105 goto out; 106 107 list = &flctx->flc_posix; 108 spin_lock(&flctx->flc_lock); 109 restart: 110 list_for_each_entry(fl, list, fl_list) { 111 if (nfs_file_open_context(fl->fl_file) != ctx) 112 continue; 113 spin_unlock(&flctx->flc_lock); 114 status = nfs4_lock_delegation_recall(fl, state, stateid); 115 if (status < 0) 116 goto out; 117 spin_lock(&flctx->flc_lock); 118 } 119 if (list == &flctx->flc_posix) { 120 list = &flctx->flc_flock; 121 goto restart; 122 } 123 spin_unlock(&flctx->flc_lock); 124 out: 125 return status; 126 } 127 128 static int nfs_delegation_claim_opens(struct inode *inode, 129 const nfs4_stateid *stateid, fmode_t type) 130 { 131 struct nfs_inode *nfsi = NFS_I(inode); 132 struct nfs_open_context *ctx; 133 struct nfs4_state_owner *sp; 134 struct nfs4_state *state; 135 unsigned int seq; 136 int err; 137 138 again: 139 spin_lock(&inode->i_lock); 140 list_for_each_entry(ctx, &nfsi->open_files, list) { 141 state = ctx->state; 142 if (state == NULL) 143 continue; 144 if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) 145 continue; 146 if (!nfs4_valid_open_stateid(state)) 147 continue; 148 if (!nfs4_stateid_match(&state->stateid, stateid)) 149 continue; 150 get_nfs_open_context(ctx); 151 spin_unlock(&inode->i_lock); 152 sp = state->owner; 153 /* Block nfs4_proc_unlck */ 154 mutex_lock(&sp->so_delegreturn_mutex); 155 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount); 156 err = nfs4_open_delegation_recall(ctx, state, stateid, type); 157 if (!err) 158 err = nfs_delegation_claim_locks(ctx, state, stateid); 159 if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) 160 err = -EAGAIN; 161 mutex_unlock(&sp->so_delegreturn_mutex); 162 put_nfs_open_context(ctx); 163 if (err != 0) 164 return err; 165 goto again; 166 } 167 spin_unlock(&inode->i_lock); 168 return 0; 169 } 170 171 /** 172 * nfs_inode_reclaim_delegation - process a delegation reclaim request 173 * @inode: inode to process 174 * @cred: credential to use for request 175 * @type: delegation type 176 * @stateid: delegation stateid 177 * @pagemod_limit: write delegation "space_limit" 178 * 179 */ 180 void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred, 181 fmode_t type, 182 const nfs4_stateid *stateid, 183 unsigned long pagemod_limit) 184 { 185 struct nfs_delegation *delegation; 186 struct rpc_cred *oldcred = NULL; 187 188 rcu_read_lock(); 189 delegation = rcu_dereference(NFS_I(inode)->delegation); 190 if (delegation != NULL) { 191 spin_lock(&delegation->lock); 192 if (delegation->inode != NULL) { 193 nfs4_stateid_copy(&delegation->stateid, stateid); 194 delegation->type = type; 195 delegation->pagemod_limit = pagemod_limit; 196 oldcred = delegation->cred; 197 delegation->cred = get_rpccred(cred); 198 clear_bit(NFS_DELEGATION_NEED_RECLAIM, 199 &delegation->flags); 200 spin_unlock(&delegation->lock); 201 rcu_read_unlock(); 202 put_rpccred(oldcred); 203 trace_nfs4_reclaim_delegation(inode, type); 204 return; 205 } 206 /* We appear to have raced with a delegation return. */ 207 spin_unlock(&delegation->lock); 208 } 209 rcu_read_unlock(); 210 nfs_inode_set_delegation(inode, cred, type, stateid, pagemod_limit); 211 } 212 213 static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync) 214 { 215 int res = 0; 216 217 if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) 218 res = nfs4_proc_delegreturn(inode, 219 delegation->cred, 220 &delegation->stateid, 221 issync); 222 nfs_free_delegation(delegation); 223 return res; 224 } 225 226 static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation) 227 { 228 struct inode *inode = NULL; 229 230 spin_lock(&delegation->lock); 231 if (delegation->inode != NULL) 232 inode = igrab(delegation->inode); 233 spin_unlock(&delegation->lock); 234 return inode; 235 } 236 237 static struct nfs_delegation * 238 nfs_start_delegation_return_locked(struct nfs_inode *nfsi) 239 { 240 struct nfs_delegation *ret = NULL; 241 struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation); 242 243 if (delegation == NULL) 244 goto out; 245 spin_lock(&delegation->lock); 246 if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) 247 ret = delegation; 248 spin_unlock(&delegation->lock); 249 out: 250 return ret; 251 } 252 253 static struct nfs_delegation * 254 nfs_start_delegation_return(struct nfs_inode *nfsi) 255 { 256 struct nfs_delegation *delegation; 257 258 rcu_read_lock(); 259 delegation = nfs_start_delegation_return_locked(nfsi); 260 rcu_read_unlock(); 261 return delegation; 262 } 263 264 static void 265 nfs_abort_delegation_return(struct nfs_delegation *delegation, 266 struct nfs_client *clp) 267 { 268 269 spin_lock(&delegation->lock); 270 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags); 271 set_bit(NFS_DELEGATION_RETURN, &delegation->flags); 272 spin_unlock(&delegation->lock); 273 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state); 274 } 275 276 static struct nfs_delegation * 277 nfs_detach_delegation_locked(struct nfs_inode *nfsi, 278 struct nfs_delegation *delegation, 279 struct nfs_client *clp) 280 { 281 struct nfs_delegation *deleg_cur = 282 rcu_dereference_protected(nfsi->delegation, 283 lockdep_is_held(&clp->cl_lock)); 284 285 if (deleg_cur == NULL || delegation != deleg_cur) 286 return NULL; 287 288 spin_lock(&delegation->lock); 289 set_bit(NFS_DELEGATION_RETURNING, &delegation->flags); 290 list_del_rcu(&delegation->super_list); 291 delegation->inode = NULL; 292 rcu_assign_pointer(nfsi->delegation, NULL); 293 spin_unlock(&delegation->lock); 294 return delegation; 295 } 296 297 static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi, 298 struct nfs_delegation *delegation, 299 struct nfs_server *server) 300 { 301 struct nfs_client *clp = server->nfs_client; 302 303 spin_lock(&clp->cl_lock); 304 delegation = nfs_detach_delegation_locked(nfsi, delegation, clp); 305 spin_unlock(&clp->cl_lock); 306 return delegation; 307 } 308 309 static struct nfs_delegation * 310 nfs_inode_detach_delegation(struct inode *inode) 311 { 312 struct nfs_inode *nfsi = NFS_I(inode); 313 struct nfs_server *server = NFS_SERVER(inode); 314 struct nfs_delegation *delegation; 315 316 delegation = nfs_start_delegation_return(nfsi); 317 if (delegation == NULL) 318 return NULL; 319 return nfs_detach_delegation(nfsi, delegation, server); 320 } 321 322 static void 323 nfs_update_inplace_delegation(struct nfs_delegation *delegation, 324 const struct nfs_delegation *update) 325 { 326 if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) { 327 delegation->stateid.seqid = update->stateid.seqid; 328 smp_wmb(); 329 delegation->type = update->type; 330 } 331 } 332 333 /** 334 * nfs_inode_set_delegation - set up a delegation on an inode 335 * @inode: inode to which delegation applies 336 * @cred: cred to use for subsequent delegation processing 337 * @type: delegation type 338 * @stateid: delegation stateid 339 * @pagemod_limit: write delegation "space_limit" 340 * 341 * Returns zero on success, or a negative errno value. 342 */ 343 int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, 344 fmode_t type, 345 const nfs4_stateid *stateid, 346 unsigned long pagemod_limit) 347 { 348 struct nfs_server *server = NFS_SERVER(inode); 349 struct nfs_client *clp = server->nfs_client; 350 struct nfs_inode *nfsi = NFS_I(inode); 351 struct nfs_delegation *delegation, *old_delegation; 352 struct nfs_delegation *freeme = NULL; 353 int status = 0; 354 355 delegation = kmalloc(sizeof(*delegation), GFP_NOFS); 356 if (delegation == NULL) 357 return -ENOMEM; 358 nfs4_stateid_copy(&delegation->stateid, stateid); 359 delegation->type = type; 360 delegation->pagemod_limit = pagemod_limit; 361 delegation->change_attr = inode_peek_iversion_raw(inode); 362 delegation->cred = get_rpccred(cred); 363 delegation->inode = inode; 364 delegation->flags = 1<<NFS_DELEGATION_REFERENCED; 365 spin_lock_init(&delegation->lock); 366 367 spin_lock(&clp->cl_lock); 368 old_delegation = rcu_dereference_protected(nfsi->delegation, 369 lockdep_is_held(&clp->cl_lock)); 370 if (old_delegation != NULL) { 371 /* Is this an update of the existing delegation? */ 372 if (nfs4_stateid_match_other(&old_delegation->stateid, 373 &delegation->stateid)) { 374 nfs_update_inplace_delegation(old_delegation, 375 delegation); 376 goto out; 377 } 378 /* 379 * Deal with broken servers that hand out two 380 * delegations for the same file. 381 * Allow for upgrades to a WRITE delegation, but 382 * nothing else. 383 */ 384 dfprintk(FILE, "%s: server %s handed out " 385 "a duplicate delegation!\n", 386 __func__, clp->cl_hostname); 387 if (delegation->type == old_delegation->type || 388 !(delegation->type & FMODE_WRITE)) { 389 freeme = delegation; 390 delegation = NULL; 391 goto out; 392 } 393 if (test_and_set_bit(NFS_DELEGATION_RETURNING, 394 &old_delegation->flags)) 395 goto out; 396 freeme = nfs_detach_delegation_locked(nfsi, 397 old_delegation, clp); 398 if (freeme == NULL) 399 goto out; 400 } 401 list_add_tail_rcu(&delegation->super_list, &server->delegations); 402 rcu_assign_pointer(nfsi->delegation, delegation); 403 delegation = NULL; 404 405 trace_nfs4_set_delegation(inode, type); 406 407 out: 408 spin_unlock(&clp->cl_lock); 409 if (delegation != NULL) 410 nfs_free_delegation(delegation); 411 if (freeme != NULL) 412 nfs_do_return_delegation(inode, freeme, 0); 413 return status; 414 } 415 416 /* 417 * Basic procedure for returning a delegation to the server 418 */ 419 static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync) 420 { 421 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; 422 struct nfs_inode *nfsi = NFS_I(inode); 423 int err = 0; 424 425 if (delegation == NULL) 426 return 0; 427 do { 428 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) 429 break; 430 err = nfs_delegation_claim_opens(inode, &delegation->stateid, 431 delegation->type); 432 if (!issync || err != -EAGAIN) 433 break; 434 /* 435 * Guard against state recovery 436 */ 437 err = nfs4_wait_clnt_recover(clp); 438 } while (err == 0); 439 440 if (err) { 441 nfs_abort_delegation_return(delegation, clp); 442 goto out; 443 } 444 if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode))) 445 goto out; 446 447 err = nfs_do_return_delegation(inode, delegation, issync); 448 out: 449 return err; 450 } 451 452 static bool nfs_delegation_need_return(struct nfs_delegation *delegation) 453 { 454 bool ret = false; 455 456 if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) 457 goto out; 458 if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags)) 459 ret = true; 460 if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) { 461 struct inode *inode; 462 463 spin_lock(&delegation->lock); 464 inode = delegation->inode; 465 if (inode && list_empty(&NFS_I(inode)->open_files)) 466 ret = true; 467 spin_unlock(&delegation->lock); 468 } 469 out: 470 return ret; 471 } 472 473 /** 474 * nfs_client_return_marked_delegations - return previously marked delegations 475 * @clp: nfs_client to process 476 * 477 * Note that this function is designed to be called by the state 478 * manager thread. For this reason, it cannot flush the dirty data, 479 * since that could deadlock in case of a state recovery error. 480 * 481 * Returns zero on success, or a negative errno value. 482 */ 483 int nfs_client_return_marked_delegations(struct nfs_client *clp) 484 { 485 struct nfs_delegation *delegation; 486 struct nfs_server *server; 487 struct inode *inode; 488 int err = 0; 489 490 restart: 491 rcu_read_lock(); 492 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 493 list_for_each_entry_rcu(delegation, &server->delegations, 494 super_list) { 495 if (!nfs_delegation_need_return(delegation)) 496 continue; 497 if (!nfs_sb_active(server->super)) 498 continue; 499 inode = nfs_delegation_grab_inode(delegation); 500 if (inode == NULL) { 501 rcu_read_unlock(); 502 nfs_sb_deactive(server->super); 503 goto restart; 504 } 505 delegation = nfs_start_delegation_return_locked(NFS_I(inode)); 506 rcu_read_unlock(); 507 508 err = nfs_end_delegation_return(inode, delegation, 0); 509 iput(inode); 510 nfs_sb_deactive(server->super); 511 if (!err) 512 goto restart; 513 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state); 514 return err; 515 } 516 } 517 rcu_read_unlock(); 518 return 0; 519 } 520 521 /** 522 * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens 523 * @inode: inode to process 524 * 525 * Does not protect against delegation reclaims, therefore really only safe 526 * to be called from nfs4_clear_inode(). 527 */ 528 void nfs_inode_return_delegation_noreclaim(struct inode *inode) 529 { 530 struct nfs_delegation *delegation; 531 532 delegation = nfs_inode_detach_delegation(inode); 533 if (delegation != NULL) 534 nfs_do_return_delegation(inode, delegation, 1); 535 } 536 537 /** 538 * nfs_inode_return_delegation - synchronously return a delegation 539 * @inode: inode to process 540 * 541 * This routine will always flush any dirty data to disk on the 542 * assumption that if we need to return the delegation, then 543 * we should stop caching. 544 * 545 * Returns zero on success, or a negative errno value. 546 */ 547 int nfs4_inode_return_delegation(struct inode *inode) 548 { 549 struct nfs_inode *nfsi = NFS_I(inode); 550 struct nfs_delegation *delegation; 551 int err = 0; 552 553 nfs_wb_all(inode); 554 delegation = nfs_start_delegation_return(nfsi); 555 if (delegation != NULL) 556 err = nfs_end_delegation_return(inode, delegation, 1); 557 return err; 558 } 559 560 /** 561 * nfs4_inode_make_writeable 562 * @inode: pointer to inode 563 * 564 * Make the inode writeable by returning the delegation if necessary 565 * 566 * Returns zero on success, or a negative errno value. 567 */ 568 int nfs4_inode_make_writeable(struct inode *inode) 569 { 570 if (!nfs4_has_session(NFS_SERVER(inode)->nfs_client) || 571 !nfs4_check_delegation(inode, FMODE_WRITE)) 572 return nfs4_inode_return_delegation(inode); 573 return 0; 574 } 575 576 static void nfs_mark_return_if_closed_delegation(struct nfs_server *server, 577 struct nfs_delegation *delegation) 578 { 579 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags); 580 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state); 581 } 582 583 static void nfs_mark_return_delegation(struct nfs_server *server, 584 struct nfs_delegation *delegation) 585 { 586 set_bit(NFS_DELEGATION_RETURN, &delegation->flags); 587 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state); 588 } 589 590 static bool nfs_server_mark_return_all_delegations(struct nfs_server *server) 591 { 592 struct nfs_delegation *delegation; 593 bool ret = false; 594 595 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 596 nfs_mark_return_delegation(server, delegation); 597 ret = true; 598 } 599 return ret; 600 } 601 602 static void nfs_client_mark_return_all_delegations(struct nfs_client *clp) 603 { 604 struct nfs_server *server; 605 606 rcu_read_lock(); 607 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 608 nfs_server_mark_return_all_delegations(server); 609 rcu_read_unlock(); 610 } 611 612 static void nfs_delegation_run_state_manager(struct nfs_client *clp) 613 { 614 if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) 615 nfs4_schedule_state_manager(clp); 616 } 617 618 /** 619 * nfs_expire_all_delegations 620 * @clp: client to process 621 * 622 */ 623 void nfs_expire_all_delegations(struct nfs_client *clp) 624 { 625 nfs_client_mark_return_all_delegations(clp); 626 nfs_delegation_run_state_manager(clp); 627 } 628 629 /** 630 * nfs_super_return_all_delegations - return delegations for one superblock 631 * @sb: sb to process 632 * 633 */ 634 void nfs_server_return_all_delegations(struct nfs_server *server) 635 { 636 struct nfs_client *clp = server->nfs_client; 637 bool need_wait; 638 639 if (clp == NULL) 640 return; 641 642 rcu_read_lock(); 643 need_wait = nfs_server_mark_return_all_delegations(server); 644 rcu_read_unlock(); 645 646 if (need_wait) { 647 nfs4_schedule_state_manager(clp); 648 nfs4_wait_clnt_recover(clp); 649 } 650 } 651 652 static void nfs_mark_return_unused_delegation_types(struct nfs_server *server, 653 fmode_t flags) 654 { 655 struct nfs_delegation *delegation; 656 657 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 658 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE)) 659 continue; 660 if (delegation->type & flags) 661 nfs_mark_return_if_closed_delegation(server, delegation); 662 } 663 } 664 665 static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp, 666 fmode_t flags) 667 { 668 struct nfs_server *server; 669 670 rcu_read_lock(); 671 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 672 nfs_mark_return_unused_delegation_types(server, flags); 673 rcu_read_unlock(); 674 } 675 676 static void nfs_mark_delegation_revoked(struct nfs_server *server, 677 struct nfs_delegation *delegation) 678 { 679 set_bit(NFS_DELEGATION_REVOKED, &delegation->flags); 680 delegation->stateid.type = NFS4_INVALID_STATEID_TYPE; 681 nfs_mark_return_delegation(server, delegation); 682 } 683 684 static bool nfs_revoke_delegation(struct inode *inode, 685 const nfs4_stateid *stateid) 686 { 687 struct nfs_delegation *delegation; 688 nfs4_stateid tmp; 689 bool ret = false; 690 691 rcu_read_lock(); 692 delegation = rcu_dereference(NFS_I(inode)->delegation); 693 if (delegation == NULL) 694 goto out; 695 if (stateid == NULL) { 696 nfs4_stateid_copy(&tmp, &delegation->stateid); 697 stateid = &tmp; 698 } else if (!nfs4_stateid_match(stateid, &delegation->stateid)) 699 goto out; 700 nfs_mark_delegation_revoked(NFS_SERVER(inode), delegation); 701 ret = true; 702 out: 703 rcu_read_unlock(); 704 if (ret) 705 nfs_inode_find_state_and_recover(inode, stateid); 706 return ret; 707 } 708 709 void nfs_remove_bad_delegation(struct inode *inode, 710 const nfs4_stateid *stateid) 711 { 712 struct nfs_delegation *delegation; 713 714 if (!nfs_revoke_delegation(inode, stateid)) 715 return; 716 delegation = nfs_inode_detach_delegation(inode); 717 if (delegation) 718 nfs_free_delegation(delegation); 719 } 720 EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation); 721 722 /** 723 * nfs_expire_unused_delegation_types 724 * @clp: client to process 725 * @flags: delegation types to expire 726 * 727 */ 728 void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags) 729 { 730 nfs_client_mark_return_unused_delegation_types(clp, flags); 731 nfs_delegation_run_state_manager(clp); 732 } 733 734 static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server) 735 { 736 struct nfs_delegation *delegation; 737 738 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 739 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags)) 740 continue; 741 nfs_mark_return_if_closed_delegation(server, delegation); 742 } 743 } 744 745 /** 746 * nfs_expire_unreferenced_delegations - Eliminate unused delegations 747 * @clp: nfs_client to process 748 * 749 */ 750 void nfs_expire_unreferenced_delegations(struct nfs_client *clp) 751 { 752 struct nfs_server *server; 753 754 rcu_read_lock(); 755 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 756 nfs_mark_return_unreferenced_delegations(server); 757 rcu_read_unlock(); 758 759 nfs_delegation_run_state_manager(clp); 760 } 761 762 /** 763 * nfs_async_inode_return_delegation - asynchronously return a delegation 764 * @inode: inode to process 765 * @stateid: state ID information 766 * 767 * Returns zero on success, or a negative errno value. 768 */ 769 int nfs_async_inode_return_delegation(struct inode *inode, 770 const nfs4_stateid *stateid) 771 { 772 struct nfs_server *server = NFS_SERVER(inode); 773 struct nfs_client *clp = server->nfs_client; 774 struct nfs_delegation *delegation; 775 776 rcu_read_lock(); 777 delegation = rcu_dereference(NFS_I(inode)->delegation); 778 if (delegation == NULL) 779 goto out_enoent; 780 if (stateid != NULL && 781 !clp->cl_mvops->match_stateid(&delegation->stateid, stateid)) 782 goto out_enoent; 783 nfs_mark_return_delegation(server, delegation); 784 rcu_read_unlock(); 785 786 nfs_delegation_run_state_manager(clp); 787 return 0; 788 out_enoent: 789 rcu_read_unlock(); 790 return -ENOENT; 791 } 792 793 static struct inode * 794 nfs_delegation_find_inode_server(struct nfs_server *server, 795 const struct nfs_fh *fhandle) 796 { 797 struct nfs_delegation *delegation; 798 struct inode *res = NULL; 799 800 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 801 spin_lock(&delegation->lock); 802 if (delegation->inode != NULL && 803 nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) { 804 res = igrab(delegation->inode); 805 } 806 spin_unlock(&delegation->lock); 807 if (res != NULL) 808 break; 809 } 810 return res; 811 } 812 813 /** 814 * nfs_delegation_find_inode - retrieve the inode associated with a delegation 815 * @clp: client state handle 816 * @fhandle: filehandle from a delegation recall 817 * 818 * Returns pointer to inode matching "fhandle," or NULL if a matching inode 819 * cannot be found. 820 */ 821 struct inode *nfs_delegation_find_inode(struct nfs_client *clp, 822 const struct nfs_fh *fhandle) 823 { 824 struct nfs_server *server; 825 struct inode *res = NULL; 826 827 rcu_read_lock(); 828 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 829 res = nfs_delegation_find_inode_server(server, fhandle); 830 if (res != NULL) 831 break; 832 } 833 rcu_read_unlock(); 834 return res; 835 } 836 837 static void nfs_delegation_mark_reclaim_server(struct nfs_server *server) 838 { 839 struct nfs_delegation *delegation; 840 841 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 842 /* 843 * If the delegation may have been admin revoked, then we 844 * cannot reclaim it. 845 */ 846 if (test_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags)) 847 continue; 848 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags); 849 } 850 } 851 852 /** 853 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed 854 * @clp: nfs_client to process 855 * 856 */ 857 void nfs_delegation_mark_reclaim(struct nfs_client *clp) 858 { 859 struct nfs_server *server; 860 861 rcu_read_lock(); 862 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 863 nfs_delegation_mark_reclaim_server(server); 864 rcu_read_unlock(); 865 } 866 867 /** 868 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done 869 * @clp: nfs_client to process 870 * 871 */ 872 void nfs_delegation_reap_unclaimed(struct nfs_client *clp) 873 { 874 struct nfs_delegation *delegation; 875 struct nfs_server *server; 876 struct inode *inode; 877 878 restart: 879 rcu_read_lock(); 880 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 881 list_for_each_entry_rcu(delegation, &server->delegations, 882 super_list) { 883 if (test_bit(NFS_DELEGATION_RETURNING, 884 &delegation->flags)) 885 continue; 886 if (test_bit(NFS_DELEGATION_NEED_RECLAIM, 887 &delegation->flags) == 0) 888 continue; 889 if (!nfs_sb_active(server->super)) 890 continue; 891 inode = nfs_delegation_grab_inode(delegation); 892 if (inode == NULL) { 893 rcu_read_unlock(); 894 nfs_sb_deactive(server->super); 895 goto restart; 896 } 897 delegation = nfs_start_delegation_return_locked(NFS_I(inode)); 898 rcu_read_unlock(); 899 if (delegation != NULL) { 900 delegation = nfs_detach_delegation(NFS_I(inode), 901 delegation, server); 902 if (delegation != NULL) 903 nfs_free_delegation(delegation); 904 } 905 iput(inode); 906 nfs_sb_deactive(server->super); 907 goto restart; 908 } 909 } 910 rcu_read_unlock(); 911 } 912 913 static inline bool nfs4_server_rebooted(const struct nfs_client *clp) 914 { 915 return (clp->cl_state & (BIT(NFS4CLNT_CHECK_LEASE) | 916 BIT(NFS4CLNT_LEASE_EXPIRED) | 917 BIT(NFS4CLNT_SESSION_RESET))) != 0; 918 } 919 920 static void nfs_mark_test_expired_delegation(struct nfs_server *server, 921 struct nfs_delegation *delegation) 922 { 923 if (delegation->stateid.type == NFS4_INVALID_STATEID_TYPE) 924 return; 925 clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags); 926 set_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags); 927 set_bit(NFS4CLNT_DELEGATION_EXPIRED, &server->nfs_client->cl_state); 928 } 929 930 static void nfs_inode_mark_test_expired_delegation(struct nfs_server *server, 931 struct inode *inode) 932 { 933 struct nfs_delegation *delegation; 934 935 rcu_read_lock(); 936 delegation = rcu_dereference(NFS_I(inode)->delegation); 937 if (delegation) 938 nfs_mark_test_expired_delegation(server, delegation); 939 rcu_read_unlock(); 940 941 } 942 943 static void nfs_delegation_mark_test_expired_server(struct nfs_server *server) 944 { 945 struct nfs_delegation *delegation; 946 947 list_for_each_entry_rcu(delegation, &server->delegations, super_list) 948 nfs_mark_test_expired_delegation(server, delegation); 949 } 950 951 /** 952 * nfs_mark_test_expired_all_delegations - mark all delegations for testing 953 * @clp: nfs_client to process 954 * 955 * Iterates through all the delegations associated with this server and 956 * marks them as needing to be checked for validity. 957 */ 958 void nfs_mark_test_expired_all_delegations(struct nfs_client *clp) 959 { 960 struct nfs_server *server; 961 962 rcu_read_lock(); 963 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 964 nfs_delegation_mark_test_expired_server(server); 965 rcu_read_unlock(); 966 } 967 968 /** 969 * nfs_reap_expired_delegations - reap expired delegations 970 * @clp: nfs_client to process 971 * 972 * Iterates through all the delegations associated with this server and 973 * checks if they have may have been revoked. This function is usually 974 * expected to be called in cases where the server may have lost its 975 * lease. 976 */ 977 void nfs_reap_expired_delegations(struct nfs_client *clp) 978 { 979 const struct nfs4_minor_version_ops *ops = clp->cl_mvops; 980 struct nfs_delegation *delegation; 981 struct nfs_server *server; 982 struct inode *inode; 983 struct rpc_cred *cred; 984 nfs4_stateid stateid; 985 986 restart: 987 rcu_read_lock(); 988 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 989 list_for_each_entry_rcu(delegation, &server->delegations, 990 super_list) { 991 if (test_bit(NFS_DELEGATION_RETURNING, 992 &delegation->flags)) 993 continue; 994 if (test_bit(NFS_DELEGATION_TEST_EXPIRED, 995 &delegation->flags) == 0) 996 continue; 997 if (!nfs_sb_active(server->super)) 998 continue; 999 inode = nfs_delegation_grab_inode(delegation); 1000 if (inode == NULL) { 1001 rcu_read_unlock(); 1002 nfs_sb_deactive(server->super); 1003 goto restart; 1004 } 1005 cred = get_rpccred_rcu(delegation->cred); 1006 nfs4_stateid_copy(&stateid, &delegation->stateid); 1007 clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags); 1008 rcu_read_unlock(); 1009 if (cred != NULL && 1010 ops->test_and_free_expired(server, &stateid, cred) < 0) { 1011 nfs_revoke_delegation(inode, &stateid); 1012 nfs_inode_find_state_and_recover(inode, &stateid); 1013 } 1014 put_rpccred(cred); 1015 if (nfs4_server_rebooted(clp)) { 1016 nfs_inode_mark_test_expired_delegation(server,inode); 1017 iput(inode); 1018 nfs_sb_deactive(server->super); 1019 return; 1020 } 1021 iput(inode); 1022 nfs_sb_deactive(server->super); 1023 goto restart; 1024 } 1025 } 1026 rcu_read_unlock(); 1027 } 1028 1029 void nfs_inode_find_delegation_state_and_recover(struct inode *inode, 1030 const nfs4_stateid *stateid) 1031 { 1032 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; 1033 struct nfs_delegation *delegation; 1034 bool found = false; 1035 1036 rcu_read_lock(); 1037 delegation = rcu_dereference(NFS_I(inode)->delegation); 1038 if (delegation && 1039 nfs4_stateid_match_other(&delegation->stateid, stateid)) { 1040 nfs_mark_test_expired_delegation(NFS_SERVER(inode), delegation); 1041 found = true; 1042 } 1043 rcu_read_unlock(); 1044 if (found) 1045 nfs4_schedule_state_manager(clp); 1046 } 1047 1048 /** 1049 * nfs_delegations_present - check for existence of delegations 1050 * @clp: client state handle 1051 * 1052 * Returns one if there are any nfs_delegation structures attached 1053 * to this nfs_client. 1054 */ 1055 int nfs_delegations_present(struct nfs_client *clp) 1056 { 1057 struct nfs_server *server; 1058 int ret = 0; 1059 1060 rcu_read_lock(); 1061 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1062 if (!list_empty(&server->delegations)) { 1063 ret = 1; 1064 break; 1065 } 1066 rcu_read_unlock(); 1067 return ret; 1068 } 1069 1070 /** 1071 * nfs4_refresh_delegation_stateid - Update delegation stateid seqid 1072 * @dst: stateid to refresh 1073 * @inode: inode to check 1074 * 1075 * Returns "true" and updates "dst->seqid" * if inode had a delegation 1076 * that matches our delegation stateid. Otherwise "false" is returned. 1077 */ 1078 bool nfs4_refresh_delegation_stateid(nfs4_stateid *dst, struct inode *inode) 1079 { 1080 struct nfs_delegation *delegation; 1081 bool ret = false; 1082 if (!inode) 1083 goto out; 1084 1085 rcu_read_lock(); 1086 delegation = rcu_dereference(NFS_I(inode)->delegation); 1087 if (delegation != NULL && 1088 nfs4_stateid_match_other(dst, &delegation->stateid)) { 1089 dst->seqid = delegation->stateid.seqid; 1090 return ret; 1091 } 1092 rcu_read_unlock(); 1093 out: 1094 return ret; 1095 } 1096 1097 /** 1098 * nfs4_copy_delegation_stateid - Copy inode's state ID information 1099 * @inode: inode to check 1100 * @flags: delegation type requirement 1101 * @dst: stateid data structure to fill in 1102 * @cred: optional argument to retrieve credential 1103 * 1104 * Returns "true" and fills in "dst->data" * if inode had a delegation, 1105 * otherwise "false" is returned. 1106 */ 1107 bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags, 1108 nfs4_stateid *dst, struct rpc_cred **cred) 1109 { 1110 struct nfs_inode *nfsi = NFS_I(inode); 1111 struct nfs_delegation *delegation; 1112 bool ret; 1113 1114 flags &= FMODE_READ|FMODE_WRITE; 1115 rcu_read_lock(); 1116 delegation = rcu_dereference(nfsi->delegation); 1117 ret = nfs4_is_valid_delegation(delegation, flags); 1118 if (ret) { 1119 nfs4_stateid_copy(dst, &delegation->stateid); 1120 nfs_mark_delegation_referenced(delegation); 1121 if (cred) 1122 *cred = get_rpccred(delegation->cred); 1123 } 1124 rcu_read_unlock(); 1125 return ret; 1126 } 1127 1128 /** 1129 * nfs4_delegation_flush_on_close - Check if we must flush file on close 1130 * @inode: inode to check 1131 * 1132 * This function checks the number of outstanding writes to the file 1133 * against the delegation 'space_limit' field to see if 1134 * the spec requires us to flush the file on close. 1135 */ 1136 bool nfs4_delegation_flush_on_close(const struct inode *inode) 1137 { 1138 struct nfs_inode *nfsi = NFS_I(inode); 1139 struct nfs_delegation *delegation; 1140 bool ret = true; 1141 1142 rcu_read_lock(); 1143 delegation = rcu_dereference(nfsi->delegation); 1144 if (delegation == NULL || !(delegation->type & FMODE_WRITE)) 1145 goto out; 1146 if (atomic_long_read(&nfsi->nrequests) < delegation->pagemod_limit) 1147 ret = false; 1148 out: 1149 rcu_read_unlock(); 1150 return ret; 1151 } 1152