1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * linux/fs/nfs/delegation.c 4 * 5 * Copyright (C) 2004 Trond Myklebust 6 * 7 * NFS file delegation management 8 * 9 */ 10#include <linux/completion.h> 11#include <linux/kthread.h> 12#include <linux/module.h> 13#include <linux/sched.h> 14#include <linux/slab.h> 15#include <linux/spinlock.h> 16#include <linux/iversion.h> 17 18#include <linux/nfs4.h> 19#include <linux/nfs_fs.h> 20#include <linux/nfs_xdr.h> 21 22#include "nfs4_fs.h" 23#include "nfs4session.h" 24#include "delegation.h" 25#include "internal.h" 26#include "nfs4trace.h" 27 28#define NFS_DEFAULT_DELEGATION_WATERMARK (5000U) 29 30static atomic_long_t nfs_active_delegations; 31static unsigned nfs_delegation_watermark = NFS_DEFAULT_DELEGATION_WATERMARK; 32 33static void __nfs_free_delegation(struct nfs_delegation *delegation) 34{ 35 put_cred(delegation->cred); 36 delegation->cred = NULL; 37 kfree_rcu(delegation, rcu); 38} 39 40static void nfs_mark_delegation_revoked(struct nfs_delegation *delegation) 41{ 42 if (!test_and_set_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) { 43 delegation->stateid.type = NFS4_INVALID_STATEID_TYPE; 44 atomic_long_dec(&nfs_active_delegations); 45 if (!test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) 46 nfs_clear_verifier_delegated(delegation->inode); 47 } 48} 49 50static struct nfs_delegation *nfs_get_delegation(struct nfs_delegation *delegation) 51{ 52 refcount_inc(&delegation->refcount); 53 return delegation; 54} 55 56static void nfs_put_delegation(struct nfs_delegation *delegation) 57{ 58 if (refcount_dec_and_test(&delegation->refcount)) 59 __nfs_free_delegation(delegation); 60} 61 62static void nfs_free_delegation(struct nfs_delegation *delegation) 63{ 64 nfs_mark_delegation_revoked(delegation); 65 nfs_put_delegation(delegation); 66} 67 68/** 69 * nfs_mark_delegation_referenced - set delegation's REFERENCED flag 70 * @delegation: delegation to process 71 * 72 */ 73void nfs_mark_delegation_referenced(struct nfs_delegation *delegation) 74{ 75 set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags); 76} 77 78static void nfs_mark_return_delegation(struct nfs_server *server, 79 struct nfs_delegation *delegation) 80{ 81 set_bit(NFS_DELEGATION_RETURN, &delegation->flags); 82 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state); 83} 84 85static bool 86nfs4_is_valid_delegation(const struct nfs_delegation *delegation, 87 fmode_t flags) 88{ 89 if (delegation != NULL && (delegation->type & flags) == flags && 90 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) && 91 !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) 92 return true; 93 return false; 94} 95 96struct nfs_delegation *nfs4_get_valid_delegation(const struct inode *inode) 97{ 98 struct nfs_delegation *delegation; 99 100 delegation = rcu_dereference(NFS_I(inode)->delegation); 101 if (nfs4_is_valid_delegation(delegation, 0)) 102 return delegation; 103 return NULL; 104} 105 106static int 107nfs4_do_check_delegation(struct inode *inode, fmode_t flags, bool mark) 108{ 109 struct nfs_delegation *delegation; 110 int ret = 0; 111 112 flags &= FMODE_READ|FMODE_WRITE; 113 rcu_read_lock(); 114 delegation = rcu_dereference(NFS_I(inode)->delegation); 115 if (nfs4_is_valid_delegation(delegation, flags)) { 116 if (mark) 117 nfs_mark_delegation_referenced(delegation); 118 ret = 1; 119 } 120 rcu_read_unlock(); 121 return ret; 122} 123/** 124 * nfs4_have_delegation - check if inode has a delegation, mark it 125 * NFS_DELEGATION_REFERENCED if there is one. 126 * @inode: inode to check 127 * @flags: delegation types to check for 128 * 129 * Returns one if inode has the indicated delegation, otherwise zero. 130 */ 131int nfs4_have_delegation(struct inode *inode, fmode_t flags) 132{ 133 return nfs4_do_check_delegation(inode, flags, true); 134} 135 136/* 137 * nfs4_check_delegation - check if inode has a delegation, do not mark 138 * NFS_DELEGATION_REFERENCED if it has one. 139 */ 140int nfs4_check_delegation(struct inode *inode, fmode_t flags) 141{ 142 return nfs4_do_check_delegation(inode, flags, false); 143} 144 145static int nfs_delegation_claim_locks(struct nfs4_state *state, const nfs4_stateid *stateid) 146{ 147 struct inode *inode = state->inode; 148 struct file_lock *fl; 149 struct file_lock_context *flctx = locks_inode_context(inode); 150 struct list_head *list; 151 int status = 0; 152 153 if (flctx == NULL) 154 goto out; 155 156 list = &flctx->flc_posix; 157 spin_lock(&flctx->flc_lock); 158restart: 159 list_for_each_entry(fl, list, fl_list) { 160 if (nfs_file_open_context(fl->fl_file)->state != state) 161 continue; 162 spin_unlock(&flctx->flc_lock); 163 status = nfs4_lock_delegation_recall(fl, state, stateid); 164 if (status < 0) 165 goto out; 166 spin_lock(&flctx->flc_lock); 167 } 168 if (list == &flctx->flc_posix) { 169 list = &flctx->flc_flock; 170 goto restart; 171 } 172 spin_unlock(&flctx->flc_lock); 173out: 174 return status; 175} 176 177static int nfs_delegation_claim_opens(struct inode *inode, 178 const nfs4_stateid *stateid, fmode_t type) 179{ 180 struct nfs_inode *nfsi = NFS_I(inode); 181 struct nfs_open_context *ctx; 182 struct nfs4_state_owner *sp; 183 struct nfs4_state *state; 184 unsigned int seq; 185 int err; 186 187again: 188 rcu_read_lock(); 189 list_for_each_entry_rcu(ctx, &nfsi->open_files, list) { 190 state = ctx->state; 191 if (state == NULL) 192 continue; 193 if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) 194 continue; 195 if (!nfs4_valid_open_stateid(state)) 196 continue; 197 if (!nfs4_stateid_match(&state->stateid, stateid)) 198 continue; 199 if (!get_nfs_open_context(ctx)) 200 continue; 201 rcu_read_unlock(); 202 sp = state->owner; 203 /* Block nfs4_proc_unlck */ 204 mutex_lock(&sp->so_delegreturn_mutex); 205 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount); 206 err = nfs4_open_delegation_recall(ctx, state, stateid); 207 if (!err) 208 err = nfs_delegation_claim_locks(state, stateid); 209 if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) 210 err = -EAGAIN; 211 mutex_unlock(&sp->so_delegreturn_mutex); 212 put_nfs_open_context(ctx); 213 if (err != 0) 214 return err; 215 goto again; 216 } 217 rcu_read_unlock(); 218 return 0; 219} 220 221/** 222 * nfs_inode_reclaim_delegation - process a delegation reclaim request 223 * @inode: inode to process 224 * @cred: credential to use for request 225 * @type: delegation type 226 * @stateid: delegation stateid 227 * @pagemod_limit: write delegation "space_limit" 228 * 229 */ 230void nfs_inode_reclaim_delegation(struct inode *inode, const struct cred *cred, 231 fmode_t type, const nfs4_stateid *stateid, 232 unsigned long pagemod_limit) 233{ 234 struct nfs_delegation *delegation; 235 const struct cred *oldcred = NULL; 236 237 rcu_read_lock(); 238 delegation = rcu_dereference(NFS_I(inode)->delegation); 239 if (delegation != NULL) { 240 spin_lock(&delegation->lock); 241 nfs4_stateid_copy(&delegation->stateid, stateid); 242 delegation->type = type; 243 delegation->pagemod_limit = pagemod_limit; 244 oldcred = delegation->cred; 245 delegation->cred = get_cred(cred); 246 clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags); 247 if (test_and_clear_bit(NFS_DELEGATION_REVOKED, 248 &delegation->flags)) 249 atomic_long_inc(&nfs_active_delegations); 250 spin_unlock(&delegation->lock); 251 rcu_read_unlock(); 252 put_cred(oldcred); 253 trace_nfs4_reclaim_delegation(inode, type); 254 } else { 255 rcu_read_unlock(); 256 nfs_inode_set_delegation(inode, cred, type, stateid, 257 pagemod_limit); 258 } 259} 260 261static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync) 262{ 263 const struct cred *cred; 264 int res = 0; 265 266 if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) { 267 spin_lock(&delegation->lock); 268 cred = get_cred(delegation->cred); 269 spin_unlock(&delegation->lock); 270 res = nfs4_proc_delegreturn(inode, cred, 271 &delegation->stateid, 272 issync); 273 put_cred(cred); 274 } 275 return res; 276} 277 278static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation) 279{ 280 struct inode *inode = NULL; 281 282 spin_lock(&delegation->lock); 283 if (delegation->inode != NULL) 284 inode = igrab(delegation->inode); 285 if (!inode) 286 set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags); 287 spin_unlock(&delegation->lock); 288 return inode; 289} 290 291static struct nfs_delegation * 292nfs_start_delegation_return_locked(struct nfs_inode *nfsi) 293{ 294 struct nfs_delegation *ret = NULL; 295 struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation); 296 297 if (delegation == NULL) 298 goto out; 299 spin_lock(&delegation->lock); 300 if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) { 301 clear_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags); 302 /* Refcount matched in nfs_end_delegation_return() */ 303 ret = nfs_get_delegation(delegation); 304 } 305 spin_unlock(&delegation->lock); 306 if (ret) 307 nfs_clear_verifier_delegated(&nfsi->vfs_inode); 308out: 309 return ret; 310} 311 312static struct nfs_delegation * 313nfs_start_delegation_return(struct nfs_inode *nfsi) 314{ 315 struct nfs_delegation *delegation; 316 317 rcu_read_lock(); 318 delegation = nfs_start_delegation_return_locked(nfsi); 319 rcu_read_unlock(); 320 return delegation; 321} 322 323static void nfs_abort_delegation_return(struct nfs_delegation *delegation, 324 struct nfs_client *clp, int err) 325{ 326 327 spin_lock(&delegation->lock); 328 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags); 329 if (err == -EAGAIN) { 330 set_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags); 331 set_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state); 332 } 333 spin_unlock(&delegation->lock); 334} 335 336static struct nfs_delegation * 337nfs_detach_delegation_locked(struct nfs_inode *nfsi, 338 struct nfs_delegation *delegation, 339 struct nfs_client *clp) 340{ 341 struct nfs_delegation *deleg_cur = 342 rcu_dereference_protected(nfsi->delegation, 343 lockdep_is_held(&clp->cl_lock)); 344 345 if (deleg_cur == NULL || delegation != deleg_cur) 346 return NULL; 347 348 spin_lock(&delegation->lock); 349 if (!delegation->inode) { 350 spin_unlock(&delegation->lock); 351 return NULL; 352 } 353 list_del_rcu(&delegation->super_list); 354 delegation->inode = NULL; 355 rcu_assign_pointer(nfsi->delegation, NULL); 356 spin_unlock(&delegation->lock); 357 return delegation; 358} 359 360static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi, 361 struct nfs_delegation *delegation, 362 struct nfs_server *server) 363{ 364 struct nfs_client *clp = server->nfs_client; 365 366 spin_lock(&clp->cl_lock); 367 delegation = nfs_detach_delegation_locked(nfsi, delegation, clp); 368 spin_unlock(&clp->cl_lock); 369 return delegation; 370} 371 372static struct nfs_delegation * 373nfs_inode_detach_delegation(struct inode *inode) 374{ 375 struct nfs_inode *nfsi = NFS_I(inode); 376 struct nfs_server *server = NFS_SERVER(inode); 377 struct nfs_delegation *delegation; 378 379 rcu_read_lock(); 380 delegation = rcu_dereference(nfsi->delegation); 381 if (delegation != NULL) 382 delegation = nfs_detach_delegation(nfsi, delegation, server); 383 rcu_read_unlock(); 384 return delegation; 385} 386 387static void 388nfs_update_delegation_cred(struct nfs_delegation *delegation, 389 const struct cred *cred) 390{ 391 const struct cred *old; 392 393 if (cred_fscmp(delegation->cred, cred) != 0) { 394 old = xchg(&delegation->cred, get_cred(cred)); 395 put_cred(old); 396 } 397} 398 399static void 400nfs_update_inplace_delegation(struct nfs_delegation *delegation, 401 const struct nfs_delegation *update) 402{ 403 if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) { 404 delegation->stateid.seqid = update->stateid.seqid; 405 smp_wmb(); 406 delegation->type = update->type; 407 delegation->pagemod_limit = update->pagemod_limit; 408 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) { 409 delegation->change_attr = update->change_attr; 410 nfs_update_delegation_cred(delegation, update->cred); 411 /* smp_mb__before_atomic() is implicit due to xchg() */ 412 clear_bit(NFS_DELEGATION_REVOKED, &delegation->flags); 413 atomic_long_inc(&nfs_active_delegations); 414 } 415 } 416} 417 418/** 419 * nfs_inode_set_delegation - set up a delegation on an inode 420 * @inode: inode to which delegation applies 421 * @cred: cred to use for subsequent delegation processing 422 * @type: delegation type 423 * @stateid: delegation stateid 424 * @pagemod_limit: write delegation "space_limit" 425 * 426 * Returns zero on success, or a negative errno value. 427 */ 428int nfs_inode_set_delegation(struct inode *inode, const struct cred *cred, 429 fmode_t type, 430 const nfs4_stateid *stateid, 431 unsigned long pagemod_limit) 432{ 433 struct nfs_server *server = NFS_SERVER(inode); 434 struct nfs_client *clp = server->nfs_client; 435 struct nfs_inode *nfsi = NFS_I(inode); 436 struct nfs_delegation *delegation, *old_delegation; 437 struct nfs_delegation *freeme = NULL; 438 int status = 0; 439 440 delegation = kmalloc(sizeof(*delegation), GFP_KERNEL_ACCOUNT); 441 if (delegation == NULL) 442 return -ENOMEM; 443 nfs4_stateid_copy(&delegation->stateid, stateid); 444 refcount_set(&delegation->refcount, 1); 445 delegation->type = type; 446 delegation->pagemod_limit = pagemod_limit; 447 delegation->change_attr = inode_peek_iversion_raw(inode); 448 delegation->cred = get_cred(cred); 449 delegation->inode = inode; 450 delegation->flags = 1<<NFS_DELEGATION_REFERENCED; 451 spin_lock_init(&delegation->lock); 452 453 spin_lock(&clp->cl_lock); 454 old_delegation = rcu_dereference_protected(nfsi->delegation, 455 lockdep_is_held(&clp->cl_lock)); 456 if (old_delegation == NULL) 457 goto add_new; 458 /* Is this an update of the existing delegation? */ 459 if (nfs4_stateid_match_other(&old_delegation->stateid, 460 &delegation->stateid)) { 461 spin_lock(&old_delegation->lock); 462 nfs_update_inplace_delegation(old_delegation, 463 delegation); 464 spin_unlock(&old_delegation->lock); 465 goto out; 466 } 467 if (!test_bit(NFS_DELEGATION_REVOKED, &old_delegation->flags)) { 468 /* 469 * Deal with broken servers that hand out two 470 * delegations for the same file. 471 * Allow for upgrades to a WRITE delegation, but 472 * nothing else. 473 */ 474 dfprintk(FILE, "%s: server %s handed out " 475 "a duplicate delegation!\n", 476 __func__, clp->cl_hostname); 477 if (delegation->type == old_delegation->type || 478 !(delegation->type & FMODE_WRITE)) { 479 freeme = delegation; 480 delegation = NULL; 481 goto out; 482 } 483 if (test_and_set_bit(NFS_DELEGATION_RETURNING, 484 &old_delegation->flags)) 485 goto out; 486 } 487 freeme = nfs_detach_delegation_locked(nfsi, old_delegation, clp); 488 if (freeme == NULL) 489 goto out; 490add_new: 491 /* 492 * If we didn't revalidate the change attribute before setting 493 * the delegation, then pre-emptively ask for a full attribute 494 * cache revalidation. 495 */ 496 spin_lock(&inode->i_lock); 497 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_CHANGE) 498 nfs_set_cache_invalid(inode, 499 NFS_INO_INVALID_ATIME | NFS_INO_INVALID_CTIME | 500 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE | 501 NFS_INO_INVALID_BLOCKS | NFS_INO_INVALID_NLINK | 502 NFS_INO_INVALID_OTHER | NFS_INO_INVALID_DATA | 503 NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL | 504 NFS_INO_INVALID_XATTR); 505 spin_unlock(&inode->i_lock); 506 507 list_add_tail_rcu(&delegation->super_list, &server->delegations); 508 rcu_assign_pointer(nfsi->delegation, delegation); 509 delegation = NULL; 510 511 atomic_long_inc(&nfs_active_delegations); 512 513 trace_nfs4_set_delegation(inode, type); 514out: 515 spin_unlock(&clp->cl_lock); 516 if (delegation != NULL) 517 __nfs_free_delegation(delegation); 518 if (freeme != NULL) { 519 nfs_do_return_delegation(inode, freeme, 0); 520 nfs_free_delegation(freeme); 521 } 522 return status; 523} 524 525/* 526 * Basic procedure for returning a delegation to the server 527 */ 528static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync) 529{ 530 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; 531 unsigned int mode = O_WRONLY | O_RDWR; 532 int err = 0; 533 534 if (delegation == NULL) 535 return 0; 536 537 if (!issync) 538 mode |= O_NONBLOCK; 539 /* Recall of any remaining application leases */ 540 err = break_lease(inode, mode); 541 542 while (err == 0) { 543 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) 544 break; 545 err = nfs_delegation_claim_opens(inode, &delegation->stateid, 546 delegation->type); 547 if (!issync || err != -EAGAIN) 548 break; 549 /* 550 * Guard against state recovery 551 */ 552 err = nfs4_wait_clnt_recover(clp); 553 } 554 555 if (err) { 556 nfs_abort_delegation_return(delegation, clp, err); 557 goto out; 558 } 559 560 err = nfs_do_return_delegation(inode, delegation, issync); 561out: 562 /* Refcount matched in nfs_start_delegation_return_locked() */ 563 nfs_put_delegation(delegation); 564 return err; 565} 566 567static bool nfs_delegation_need_return(struct nfs_delegation *delegation) 568{ 569 bool ret = false; 570 571 if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags)) 572 ret = true; 573 else if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags)) { 574 struct inode *inode; 575 576 spin_lock(&delegation->lock); 577 inode = delegation->inode; 578 if (inode && list_empty(&NFS_I(inode)->open_files)) 579 ret = true; 580 spin_unlock(&delegation->lock); 581 } 582 if (ret) 583 clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags); 584 if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags) || 585 test_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags) || 586 test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) 587 ret = false; 588 589 return ret; 590} 591 592static int nfs_server_return_marked_delegations(struct nfs_server *server, 593 void __always_unused *data) 594{ 595 struct nfs_delegation *delegation; 596 struct nfs_delegation *prev; 597 struct inode *inode; 598 struct inode *place_holder = NULL; 599 struct nfs_delegation *place_holder_deleg = NULL; 600 int err = 0; 601 602restart: 603 /* 604 * To avoid quadratic looping we hold a reference 605 * to an inode place_holder. Each time we restart, we 606 * list delegation in the server from the delegations 607 * of that inode. 608 * prev is an RCU-protected pointer to a delegation which 609 * wasn't marked for return and might be a good choice for 610 * the next place_holder. 611 */ 612 prev = NULL; 613 delegation = NULL; 614 rcu_read_lock(); 615 if (place_holder) 616 delegation = rcu_dereference(NFS_I(place_holder)->delegation); 617 if (!delegation || delegation != place_holder_deleg) 618 delegation = list_entry_rcu(server->delegations.next, 619 struct nfs_delegation, super_list); 620 list_for_each_entry_from_rcu(delegation, &server->delegations, super_list) { 621 struct inode *to_put = NULL; 622 623 if (test_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags)) 624 continue; 625 if (!nfs_delegation_need_return(delegation)) { 626 if (nfs4_is_valid_delegation(delegation, 0)) 627 prev = delegation; 628 continue; 629 } 630 631 if (prev) { 632 struct inode *tmp = nfs_delegation_grab_inode(prev); 633 if (tmp) { 634 to_put = place_holder; 635 place_holder = tmp; 636 place_holder_deleg = prev; 637 } 638 } 639 640 inode = nfs_delegation_grab_inode(delegation); 641 if (inode == NULL) { 642 rcu_read_unlock(); 643 iput(to_put); 644 goto restart; 645 } 646 delegation = nfs_start_delegation_return_locked(NFS_I(inode)); 647 rcu_read_unlock(); 648 649 iput(to_put); 650 651 err = nfs_end_delegation_return(inode, delegation, 0); 652 iput(inode); 653 cond_resched(); 654 if (!err) 655 goto restart; 656 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state); 657 goto out; 658 } 659 rcu_read_unlock(); 660out: 661 iput(place_holder); 662 return err; 663} 664 665static bool nfs_server_clear_delayed_delegations(struct nfs_server *server) 666{ 667 struct nfs_delegation *d; 668 bool ret = false; 669 670 list_for_each_entry_rcu (d, &server->delegations, super_list) { 671 if (!test_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags)) 672 continue; 673 nfs_mark_return_delegation(server, d); 674 clear_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags); 675 ret = true; 676 } 677 return ret; 678} 679 680static bool nfs_client_clear_delayed_delegations(struct nfs_client *clp) 681{ 682 struct nfs_server *server; 683 bool ret = false; 684 685 if (!test_and_clear_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state)) 686 goto out; 687 rcu_read_lock(); 688 list_for_each_entry_rcu (server, &clp->cl_superblocks, client_link) { 689 if (nfs_server_clear_delayed_delegations(server)) 690 ret = true; 691 } 692 rcu_read_unlock(); 693out: 694 return ret; 695} 696 697/** 698 * nfs_client_return_marked_delegations - return previously marked delegations 699 * @clp: nfs_client to process 700 * 701 * Note that this function is designed to be called by the state 702 * manager thread. For this reason, it cannot flush the dirty data, 703 * since that could deadlock in case of a state recovery error. 704 * 705 * Returns zero on success, or a negative errno value. 706 */ 707int nfs_client_return_marked_delegations(struct nfs_client *clp) 708{ 709 int err = nfs_client_for_each_server( 710 clp, nfs_server_return_marked_delegations, NULL); 711 if (err) 712 return err; 713 /* If a return was delayed, sleep to prevent hard looping */ 714 if (nfs_client_clear_delayed_delegations(clp)) 715 ssleep(1); 716 return 0; 717} 718 719/** 720 * nfs_inode_evict_delegation - return delegation, don't reclaim opens 721 * @inode: inode to process 722 * 723 * Does not protect against delegation reclaims, therefore really only safe 724 * to be called from nfs4_clear_inode(). Guaranteed to always free 725 * the delegation structure. 726 */ 727void nfs_inode_evict_delegation(struct inode *inode) 728{ 729 struct nfs_delegation *delegation; 730 731 delegation = nfs_inode_detach_delegation(inode); 732 if (delegation != NULL) { 733 set_bit(NFS_DELEGATION_RETURNING, &delegation->flags); 734 set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags); 735 nfs_do_return_delegation(inode, delegation, 1); 736 nfs_free_delegation(delegation); 737 } 738} 739 740/** 741 * nfs4_inode_return_delegation - synchronously return a delegation 742 * @inode: inode to process 743 * 744 * This routine will always flush any dirty data to disk on the 745 * assumption that if we need to return the delegation, then 746 * we should stop caching. 747 * 748 * Returns zero on success, or a negative errno value. 749 */ 750int nfs4_inode_return_delegation(struct inode *inode) 751{ 752 struct nfs_inode *nfsi = NFS_I(inode); 753 struct nfs_delegation *delegation; 754 755 delegation = nfs_start_delegation_return(nfsi); 756 if (delegation != NULL) { 757 /* Synchronous recall of any application leases */ 758 break_lease(inode, O_WRONLY | O_RDWR); 759 if (S_ISREG(inode->i_mode)) 760 nfs_wb_all(inode); 761 return nfs_end_delegation_return(inode, delegation, 1); 762 } 763 return 0; 764} 765 766/** 767 * nfs4_inode_return_delegation_on_close - asynchronously return a delegation 768 * @inode: inode to process 769 * 770 * This routine is called on file close in order to determine if the 771 * inode delegation needs to be returned immediately. 772 */ 773void nfs4_inode_return_delegation_on_close(struct inode *inode) 774{ 775 struct nfs_delegation *delegation; 776 struct nfs_delegation *ret = NULL; 777 778 if (!inode) 779 return; 780 rcu_read_lock(); 781 delegation = nfs4_get_valid_delegation(inode); 782 if (!delegation) 783 goto out; 784 if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) || 785 atomic_long_read(&nfs_active_delegations) >= nfs_delegation_watermark) { 786 spin_lock(&delegation->lock); 787 if (delegation->inode && 788 list_empty(&NFS_I(inode)->open_files) && 789 !test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) { 790 clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags); 791 /* Refcount matched in nfs_end_delegation_return() */ 792 ret = nfs_get_delegation(delegation); 793 } 794 spin_unlock(&delegation->lock); 795 if (ret) 796 nfs_clear_verifier_delegated(inode); 797 } 798out: 799 rcu_read_unlock(); 800 nfs_end_delegation_return(inode, ret, 0); 801} 802 803/** 804 * nfs4_inode_make_writeable 805 * @inode: pointer to inode 806 * 807 * Make the inode writeable by returning the delegation if necessary 808 * 809 * Returns zero on success, or a negative errno value. 810 */ 811int nfs4_inode_make_writeable(struct inode *inode) 812{ 813 struct nfs_delegation *delegation; 814 815 rcu_read_lock(); 816 delegation = nfs4_get_valid_delegation(inode); 817 if (delegation == NULL || 818 (nfs4_has_session(NFS_SERVER(inode)->nfs_client) && 819 (delegation->type & FMODE_WRITE))) { 820 rcu_read_unlock(); 821 return 0; 822 } 823 rcu_read_unlock(); 824 return nfs4_inode_return_delegation(inode); 825} 826 827static void nfs_mark_return_if_closed_delegation(struct nfs_server *server, 828 struct nfs_delegation *delegation) 829{ 830 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags); 831 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state); 832} 833 834static bool nfs_server_mark_return_all_delegations(struct nfs_server *server) 835{ 836 struct nfs_delegation *delegation; 837 bool ret = false; 838 839 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 840 nfs_mark_return_delegation(server, delegation); 841 ret = true; 842 } 843 return ret; 844} 845 846static void nfs_client_mark_return_all_delegations(struct nfs_client *clp) 847{ 848 struct nfs_server *server; 849 850 rcu_read_lock(); 851 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 852 nfs_server_mark_return_all_delegations(server); 853 rcu_read_unlock(); 854} 855 856static void nfs_delegation_run_state_manager(struct nfs_client *clp) 857{ 858 if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) 859 nfs4_schedule_state_manager(clp); 860} 861 862/** 863 * nfs_expire_all_delegations 864 * @clp: client to process 865 * 866 */ 867void nfs_expire_all_delegations(struct nfs_client *clp) 868{ 869 nfs_client_mark_return_all_delegations(clp); 870 nfs_delegation_run_state_manager(clp); 871} 872 873/** 874 * nfs_server_return_all_delegations - return delegations for one superblock 875 * @server: pointer to nfs_server to process 876 * 877 */ 878void nfs_server_return_all_delegations(struct nfs_server *server) 879{ 880 struct nfs_client *clp = server->nfs_client; 881 bool need_wait; 882 883 if (clp == NULL) 884 return; 885 886 rcu_read_lock(); 887 need_wait = nfs_server_mark_return_all_delegations(server); 888 rcu_read_unlock(); 889 890 if (need_wait) { 891 nfs4_schedule_state_manager(clp); 892 nfs4_wait_clnt_recover(clp); 893 } 894} 895 896static void nfs_mark_return_unused_delegation_types(struct nfs_server *server, 897 fmode_t flags) 898{ 899 struct nfs_delegation *delegation; 900 901 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 902 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE)) 903 continue; 904 if (delegation->type & flags) 905 nfs_mark_return_if_closed_delegation(server, delegation); 906 } 907} 908 909static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp, 910 fmode_t flags) 911{ 912 struct nfs_server *server; 913 914 rcu_read_lock(); 915 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 916 nfs_mark_return_unused_delegation_types(server, flags); 917 rcu_read_unlock(); 918} 919 920static void nfs_revoke_delegation(struct inode *inode, 921 const nfs4_stateid *stateid) 922{ 923 struct nfs_delegation *delegation; 924 nfs4_stateid tmp; 925 bool ret = false; 926 927 rcu_read_lock(); 928 delegation = rcu_dereference(NFS_I(inode)->delegation); 929 if (delegation == NULL) 930 goto out; 931 if (stateid == NULL) { 932 nfs4_stateid_copy(&tmp, &delegation->stateid); 933 stateid = &tmp; 934 } else { 935 if (!nfs4_stateid_match_other(stateid, &delegation->stateid)) 936 goto out; 937 spin_lock(&delegation->lock); 938 if (stateid->seqid) { 939 if (nfs4_stateid_is_newer(&delegation->stateid, stateid)) { 940 spin_unlock(&delegation->lock); 941 goto out; 942 } 943 delegation->stateid.seqid = stateid->seqid; 944 } 945 spin_unlock(&delegation->lock); 946 } 947 nfs_mark_delegation_revoked(delegation); 948 ret = true; 949out: 950 rcu_read_unlock(); 951 if (ret) 952 nfs_inode_find_state_and_recover(inode, stateid); 953} 954 955void nfs_remove_bad_delegation(struct inode *inode, 956 const nfs4_stateid *stateid) 957{ 958 nfs_revoke_delegation(inode, stateid); 959} 960EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation); 961 962void nfs_delegation_mark_returned(struct inode *inode, 963 const nfs4_stateid *stateid) 964{ 965 struct nfs_delegation *delegation; 966 967 if (!inode) 968 return; 969 970 rcu_read_lock(); 971 delegation = rcu_dereference(NFS_I(inode)->delegation); 972 if (!delegation) 973 goto out_rcu_unlock; 974 975 spin_lock(&delegation->lock); 976 if (!nfs4_stateid_match_other(stateid, &delegation->stateid)) 977 goto out_spin_unlock; 978 if (stateid->seqid) { 979 /* If delegation->stateid is newer, dont mark as returned */ 980 if (nfs4_stateid_is_newer(&delegation->stateid, stateid)) 981 goto out_clear_returning; 982 if (delegation->stateid.seqid != stateid->seqid) 983 delegation->stateid.seqid = stateid->seqid; 984 } 985 986 nfs_mark_delegation_revoked(delegation); 987 988out_clear_returning: 989 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags); 990out_spin_unlock: 991 spin_unlock(&delegation->lock); 992out_rcu_unlock: 993 rcu_read_unlock(); 994 995 nfs_inode_find_state_and_recover(inode, stateid); 996} 997 998/** 999 * nfs_expire_unused_delegation_types 1000 * @clp: client to process 1001 * @flags: delegation types to expire 1002 * 1003 */ 1004void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags) 1005{ 1006 nfs_client_mark_return_unused_delegation_types(clp, flags); 1007 nfs_delegation_run_state_manager(clp); 1008} 1009 1010static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server) 1011{ 1012 struct nfs_delegation *delegation; 1013 1014 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 1015 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags)) 1016 continue; 1017 nfs_mark_return_if_closed_delegation(server, delegation); 1018 } 1019} 1020 1021/** 1022 * nfs_expire_unreferenced_delegations - Eliminate unused delegations 1023 * @clp: nfs_client to process 1024 * 1025 */ 1026void nfs_expire_unreferenced_delegations(struct nfs_client *clp) 1027{ 1028 struct nfs_server *server; 1029 1030 rcu_read_lock(); 1031 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1032 nfs_mark_return_unreferenced_delegations(server); 1033 rcu_read_unlock(); 1034 1035 nfs_delegation_run_state_manager(clp); 1036} 1037 1038/** 1039 * nfs_async_inode_return_delegation - asynchronously return a delegation 1040 * @inode: inode to process 1041 * @stateid: state ID information 1042 * 1043 * Returns zero on success, or a negative errno value. 1044 */ 1045int nfs_async_inode_return_delegation(struct inode *inode, 1046 const nfs4_stateid *stateid) 1047{ 1048 struct nfs_server *server = NFS_SERVER(inode); 1049 struct nfs_client *clp = server->nfs_client; 1050 struct nfs_delegation *delegation; 1051 1052 rcu_read_lock(); 1053 delegation = nfs4_get_valid_delegation(inode); 1054 if (delegation == NULL) 1055 goto out_enoent; 1056 if (stateid != NULL && 1057 !clp->cl_mvops->match_stateid(&delegation->stateid, stateid)) 1058 goto out_enoent; 1059 nfs_mark_return_delegation(server, delegation); 1060 rcu_read_unlock(); 1061 1062 /* If there are any application leases or delegations, recall them */ 1063 break_lease(inode, O_WRONLY | O_RDWR | O_NONBLOCK); 1064 1065 nfs_delegation_run_state_manager(clp); 1066 return 0; 1067out_enoent: 1068 rcu_read_unlock(); 1069 return -ENOENT; 1070} 1071 1072static struct inode * 1073nfs_delegation_find_inode_server(struct nfs_server *server, 1074 const struct nfs_fh *fhandle) 1075{ 1076 struct nfs_delegation *delegation; 1077 struct super_block *freeme = NULL; 1078 struct inode *res = NULL; 1079 1080 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 1081 spin_lock(&delegation->lock); 1082 if (delegation->inode != NULL && 1083 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) && 1084 nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) { 1085 if (nfs_sb_active(server->super)) { 1086 freeme = server->super; 1087 res = igrab(delegation->inode); 1088 } 1089 spin_unlock(&delegation->lock); 1090 if (res != NULL) 1091 return res; 1092 if (freeme) { 1093 rcu_read_unlock(); 1094 nfs_sb_deactive(freeme); 1095 rcu_read_lock(); 1096 } 1097 return ERR_PTR(-EAGAIN); 1098 } 1099 spin_unlock(&delegation->lock); 1100 } 1101 return ERR_PTR(-ENOENT); 1102} 1103 1104/** 1105 * nfs_delegation_find_inode - retrieve the inode associated with a delegation 1106 * @clp: client state handle 1107 * @fhandle: filehandle from a delegation recall 1108 * 1109 * Returns pointer to inode matching "fhandle," or NULL if a matching inode 1110 * cannot be found. 1111 */ 1112struct inode *nfs_delegation_find_inode(struct nfs_client *clp, 1113 const struct nfs_fh *fhandle) 1114{ 1115 struct nfs_server *server; 1116 struct inode *res; 1117 1118 rcu_read_lock(); 1119 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 1120 res = nfs_delegation_find_inode_server(server, fhandle); 1121 if (res != ERR_PTR(-ENOENT)) { 1122 rcu_read_unlock(); 1123 return res; 1124 } 1125 } 1126 rcu_read_unlock(); 1127 return ERR_PTR(-ENOENT); 1128} 1129 1130static void nfs_delegation_mark_reclaim_server(struct nfs_server *server) 1131{ 1132 struct nfs_delegation *delegation; 1133 1134 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 1135 /* 1136 * If the delegation may have been admin revoked, then we 1137 * cannot reclaim it. 1138 */ 1139 if (test_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags)) 1140 continue; 1141 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags); 1142 } 1143} 1144 1145/** 1146 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed 1147 * @clp: nfs_client to process 1148 * 1149 */ 1150void nfs_delegation_mark_reclaim(struct nfs_client *clp) 1151{ 1152 struct nfs_server *server; 1153 1154 rcu_read_lock(); 1155 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1156 nfs_delegation_mark_reclaim_server(server); 1157 rcu_read_unlock(); 1158} 1159 1160static int nfs_server_reap_unclaimed_delegations(struct nfs_server *server, 1161 void __always_unused *data) 1162{ 1163 struct nfs_delegation *delegation; 1164 struct inode *inode; 1165restart: 1166 rcu_read_lock(); 1167restart_locked: 1168 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 1169 if (test_bit(NFS_DELEGATION_INODE_FREEING, 1170 &delegation->flags) || 1171 test_bit(NFS_DELEGATION_RETURNING, 1172 &delegation->flags) || 1173 test_bit(NFS_DELEGATION_NEED_RECLAIM, 1174 &delegation->flags) == 0) 1175 continue; 1176 inode = nfs_delegation_grab_inode(delegation); 1177 if (inode == NULL) 1178 goto restart_locked; 1179 delegation = nfs_start_delegation_return_locked(NFS_I(inode)); 1180 rcu_read_unlock(); 1181 if (delegation != NULL) { 1182 if (nfs_detach_delegation(NFS_I(inode), delegation, 1183 server) != NULL) 1184 nfs_free_delegation(delegation); 1185 /* Match nfs_start_delegation_return_locked */ 1186 nfs_put_delegation(delegation); 1187 } 1188 iput(inode); 1189 cond_resched(); 1190 goto restart; 1191 } 1192 rcu_read_unlock(); 1193 return 0; 1194} 1195 1196/** 1197 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done 1198 * @clp: nfs_client to process 1199 * 1200 */ 1201void nfs_delegation_reap_unclaimed(struct nfs_client *clp) 1202{ 1203 nfs_client_for_each_server(clp, nfs_server_reap_unclaimed_delegations, 1204 NULL); 1205} 1206 1207static inline bool nfs4_server_rebooted(const struct nfs_client *clp) 1208{ 1209 return (clp->cl_state & (BIT(NFS4CLNT_CHECK_LEASE) | 1210 BIT(NFS4CLNT_LEASE_EXPIRED) | 1211 BIT(NFS4CLNT_SESSION_RESET))) != 0; 1212} 1213 1214static void nfs_mark_test_expired_delegation(struct nfs_server *server, 1215 struct nfs_delegation *delegation) 1216{ 1217 if (delegation->stateid.type == NFS4_INVALID_STATEID_TYPE) 1218 return; 1219 clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags); 1220 set_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags); 1221 set_bit(NFS4CLNT_DELEGATION_EXPIRED, &server->nfs_client->cl_state); 1222} 1223 1224static void nfs_inode_mark_test_expired_delegation(struct nfs_server *server, 1225 struct inode *inode) 1226{ 1227 struct nfs_delegation *delegation; 1228 1229 rcu_read_lock(); 1230 delegation = rcu_dereference(NFS_I(inode)->delegation); 1231 if (delegation) 1232 nfs_mark_test_expired_delegation(server, delegation); 1233 rcu_read_unlock(); 1234 1235} 1236 1237static void nfs_delegation_mark_test_expired_server(struct nfs_server *server) 1238{ 1239 struct nfs_delegation *delegation; 1240 1241 list_for_each_entry_rcu(delegation, &server->delegations, super_list) 1242 nfs_mark_test_expired_delegation(server, delegation); 1243} 1244 1245/** 1246 * nfs_mark_test_expired_all_delegations - mark all delegations for testing 1247 * @clp: nfs_client to process 1248 * 1249 * Iterates through all the delegations associated with this server and 1250 * marks them as needing to be checked for validity. 1251 */ 1252void nfs_mark_test_expired_all_delegations(struct nfs_client *clp) 1253{ 1254 struct nfs_server *server; 1255 1256 rcu_read_lock(); 1257 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1258 nfs_delegation_mark_test_expired_server(server); 1259 rcu_read_unlock(); 1260} 1261 1262/** 1263 * nfs_test_expired_all_delegations - test all delegations for a client 1264 * @clp: nfs_client to process 1265 * 1266 * Helper for handling "recallable state revoked" status from server. 1267 */ 1268void nfs_test_expired_all_delegations(struct nfs_client *clp) 1269{ 1270 nfs_mark_test_expired_all_delegations(clp); 1271 nfs4_schedule_state_manager(clp); 1272} 1273 1274static void 1275nfs_delegation_test_free_expired(struct inode *inode, 1276 nfs4_stateid *stateid, 1277 const struct cred *cred) 1278{ 1279 struct nfs_server *server = NFS_SERVER(inode); 1280 const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops; 1281 int status; 1282 1283 if (!cred) 1284 return; 1285 status = ops->test_and_free_expired(server, stateid, cred); 1286 if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID) 1287 nfs_remove_bad_delegation(inode, stateid); 1288} 1289 1290static int nfs_server_reap_expired_delegations(struct nfs_server *server, 1291 void __always_unused *data) 1292{ 1293 struct nfs_delegation *delegation; 1294 struct inode *inode; 1295 const struct cred *cred; 1296 nfs4_stateid stateid; 1297restart: 1298 rcu_read_lock(); 1299restart_locked: 1300 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 1301 if (test_bit(NFS_DELEGATION_INODE_FREEING, 1302 &delegation->flags) || 1303 test_bit(NFS_DELEGATION_RETURNING, 1304 &delegation->flags) || 1305 test_bit(NFS_DELEGATION_TEST_EXPIRED, 1306 &delegation->flags) == 0) 1307 continue; 1308 inode = nfs_delegation_grab_inode(delegation); 1309 if (inode == NULL) 1310 goto restart_locked; 1311 spin_lock(&delegation->lock); 1312 cred = get_cred_rcu(delegation->cred); 1313 nfs4_stateid_copy(&stateid, &delegation->stateid); 1314 spin_unlock(&delegation->lock); 1315 clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags); 1316 rcu_read_unlock(); 1317 nfs_delegation_test_free_expired(inode, &stateid, cred); 1318 put_cred(cred); 1319 if (!nfs4_server_rebooted(server->nfs_client)) { 1320 iput(inode); 1321 cond_resched(); 1322 goto restart; 1323 } 1324 nfs_inode_mark_test_expired_delegation(server,inode); 1325 iput(inode); 1326 return -EAGAIN; 1327 } 1328 rcu_read_unlock(); 1329 return 0; 1330} 1331 1332/** 1333 * nfs_reap_expired_delegations - reap expired delegations 1334 * @clp: nfs_client to process 1335 * 1336 * Iterates through all the delegations associated with this server and 1337 * checks if they have may have been revoked. This function is usually 1338 * expected to be called in cases where the server may have lost its 1339 * lease. 1340 */ 1341void nfs_reap_expired_delegations(struct nfs_client *clp) 1342{ 1343 nfs_client_for_each_server(clp, nfs_server_reap_expired_delegations, 1344 NULL); 1345} 1346 1347void nfs_inode_find_delegation_state_and_recover(struct inode *inode, 1348 const nfs4_stateid *stateid) 1349{ 1350 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; 1351 struct nfs_delegation *delegation; 1352 bool found = false; 1353 1354 rcu_read_lock(); 1355 delegation = rcu_dereference(NFS_I(inode)->delegation); 1356 if (delegation && 1357 nfs4_stateid_match_or_older(&delegation->stateid, stateid) && 1358 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) { 1359 nfs_mark_test_expired_delegation(NFS_SERVER(inode), delegation); 1360 found = true; 1361 } 1362 rcu_read_unlock(); 1363 if (found) 1364 nfs4_schedule_state_manager(clp); 1365} 1366 1367/** 1368 * nfs_delegations_present - check for existence of delegations 1369 * @clp: client state handle 1370 * 1371 * Returns one if there are any nfs_delegation structures attached 1372 * to this nfs_client. 1373 */ 1374int nfs_delegations_present(struct nfs_client *clp) 1375{ 1376 struct nfs_server *server; 1377 int ret = 0; 1378 1379 rcu_read_lock(); 1380 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 1381 if (!list_empty(&server->delegations)) { 1382 ret = 1; 1383 break; 1384 } 1385 rcu_read_unlock(); 1386 return ret; 1387} 1388 1389/** 1390 * nfs4_refresh_delegation_stateid - Update delegation stateid seqid 1391 * @dst: stateid to refresh 1392 * @inode: inode to check 1393 * 1394 * Returns "true" and updates "dst->seqid" * if inode had a delegation 1395 * that matches our delegation stateid. Otherwise "false" is returned. 1396 */ 1397bool nfs4_refresh_delegation_stateid(nfs4_stateid *dst, struct inode *inode) 1398{ 1399 struct nfs_delegation *delegation; 1400 bool ret = false; 1401 if (!inode) 1402 goto out; 1403 1404 rcu_read_lock(); 1405 delegation = rcu_dereference(NFS_I(inode)->delegation); 1406 if (delegation != NULL && 1407 nfs4_stateid_match_other(dst, &delegation->stateid) && 1408 nfs4_stateid_is_newer(&delegation->stateid, dst) && 1409 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) { 1410 dst->seqid = delegation->stateid.seqid; 1411 ret = true; 1412 } 1413 rcu_read_unlock(); 1414out: 1415 return ret; 1416} 1417 1418/** 1419 * nfs4_copy_delegation_stateid - Copy inode's state ID information 1420 * @inode: inode to check 1421 * @flags: delegation type requirement 1422 * @dst: stateid data structure to fill in 1423 * @cred: optional argument to retrieve credential 1424 * 1425 * Returns "true" and fills in "dst->data" * if inode had a delegation, 1426 * otherwise "false" is returned. 1427 */ 1428bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags, 1429 nfs4_stateid *dst, const struct cred **cred) 1430{ 1431 struct nfs_inode *nfsi = NFS_I(inode); 1432 struct nfs_delegation *delegation; 1433 bool ret = false; 1434 1435 flags &= FMODE_READ|FMODE_WRITE; 1436 rcu_read_lock(); 1437 delegation = rcu_dereference(nfsi->delegation); 1438 if (!delegation) 1439 goto out; 1440 spin_lock(&delegation->lock); 1441 ret = nfs4_is_valid_delegation(delegation, flags); 1442 if (ret) { 1443 nfs4_stateid_copy(dst, &delegation->stateid); 1444 nfs_mark_delegation_referenced(delegation); 1445 if (cred) 1446 *cred = get_cred(delegation->cred); 1447 } 1448 spin_unlock(&delegation->lock); 1449out: 1450 rcu_read_unlock(); 1451 return ret; 1452} 1453 1454/** 1455 * nfs4_delegation_flush_on_close - Check if we must flush file on close 1456 * @inode: inode to check 1457 * 1458 * This function checks the number of outstanding writes to the file 1459 * against the delegation 'space_limit' field to see if 1460 * the spec requires us to flush the file on close. 1461 */ 1462bool nfs4_delegation_flush_on_close(const struct inode *inode) 1463{ 1464 struct nfs_inode *nfsi = NFS_I(inode); 1465 struct nfs_delegation *delegation; 1466 bool ret = true; 1467 1468 rcu_read_lock(); 1469 delegation = rcu_dereference(nfsi->delegation); 1470 if (delegation == NULL || !(delegation->type & FMODE_WRITE)) 1471 goto out; 1472 if (atomic_long_read(&nfsi->nrequests) < delegation->pagemod_limit) 1473 ret = false; 1474out: 1475 rcu_read_unlock(); 1476 return ret; 1477} 1478 1479module_param_named(delegation_watermark, nfs_delegation_watermark, uint, 0644); 1480