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