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 30 static atomic_long_t nfs_active_delegations; 31 static unsigned nfs_delegation_watermark = NFS_DEFAULT_DELEGATION_WATERMARK; 32 33 static 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 40 static 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 50 static struct nfs_delegation *nfs_get_delegation(struct nfs_delegation *delegation) 51 { 52 refcount_inc(&delegation->refcount); 53 return delegation; 54 } 55 56 static void nfs_put_delegation(struct nfs_delegation *delegation) 57 { 58 if (refcount_dec_and_test(&delegation->refcount)) 59 __nfs_free_delegation(delegation); 60 } 61 62 static 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 */ 73 void nfs_mark_delegation_referenced(struct nfs_delegation *delegation) 74 { 75 set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags); 76 } 77 78 static 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 85 static bool 86 nfs4_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 96 struct 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 106 static int 107 nfs4_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 */ 131 int 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 */ 140 int nfs4_check_delegation(struct inode *inode, fmode_t flags) 141 { 142 return nfs4_do_check_delegation(inode, flags, false); 143 } 144 145 static 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); 158 restart: 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); 173 out: 174 return status; 175 } 176 177 static 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 187 again: 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 */ 230 void 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 261 static 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 278 static 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 291 static struct nfs_delegation * 292 nfs_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); 308 out: 309 return ret; 310 } 311 312 static struct nfs_delegation * 313 nfs_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 323 static 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 336 static struct nfs_delegation * 337 nfs_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 360 static 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 372 static struct nfs_delegation * 373 nfs_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 387 static void 388 nfs_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 399 static void 400 nfs_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 */ 428 int 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; 490 add_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); 514 out: 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 */ 528 static 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); 561 out: 562 /* Refcount matched in nfs_start_delegation_return_locked() */ 563 nfs_put_delegation(delegation); 564 return err; 565 } 566 567 static 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 592 static 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 602 restart: 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(); 660 out: 661 iput(place_holder); 662 return err; 663 } 664 665 static 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 680 static 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(); 693 out: 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 */ 707 int 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 */ 727 void 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 */ 750 int 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 */ 773 void 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 } 798 out: 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 */ 811 int 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 827 static 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 834 static 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 846 static 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 856 static 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 */ 867 void 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 */ 878 void 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 896 static 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 909 static 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 920 static 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; 949 out: 950 rcu_read_unlock(); 951 if (ret) 952 nfs_inode_find_state_and_recover(inode, stateid); 953 } 954 955 void nfs_remove_bad_delegation(struct inode *inode, 956 const nfs4_stateid *stateid) 957 { 958 nfs_revoke_delegation(inode, stateid); 959 } 960 EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation); 961 962 void 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 988 out_clear_returning: 989 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags); 990 out_spin_unlock: 991 spin_unlock(&delegation->lock); 992 out_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 */ 1004 void 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 1010 static 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 */ 1026 void 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 */ 1045 int 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; 1067 out_enoent: 1068 rcu_read_unlock(); 1069 return -ENOENT; 1070 } 1071 1072 static struct inode * 1073 nfs_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 */ 1112 struct 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 1130 static 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 */ 1150 void 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 1160 static 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; 1165 restart: 1166 rcu_read_lock(); 1167 restart_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 */ 1201 void 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 1207 static 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 1214 static 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 1224 static 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 1237 static 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 */ 1252 void 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 */ 1268 void 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 1274 static void 1275 nfs_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 1290 static 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; 1297 restart: 1298 rcu_read_lock(); 1299 restart_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 */ 1341 void 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 1347 void 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 */ 1374 int 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 */ 1397 bool 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(); 1414 out: 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 */ 1428 bool 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); 1449 out: 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 */ 1462 bool 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; 1474 out: 1475 rcu_read_unlock(); 1476 return ret; 1477 } 1478 1479 module_param_named(delegation_watermark, nfs_delegation_watermark, uint, 0644); 1480