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 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); 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 int err; 185 186 again: 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 */ 226 void 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 257 static 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 274 static 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 287 static struct nfs_delegation * 288 nfs_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); 304 out: 305 return ret; 306 } 307 308 static struct nfs_delegation * 309 nfs_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 319 static 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 332 static struct nfs_delegation * 333 nfs_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 356 static 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 368 static struct nfs_delegation * 369 nfs_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 383 static void 384 nfs_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 395 static void 396 nfs_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 */ 424 int 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; 487 add_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); 511 out: 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 */ 525 static 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); 558 out: 559 /* Refcount matched in nfs_start_delegation_return_locked() */ 560 nfs_put_delegation(delegation); 561 return err; 562 } 563 564 static 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 589 static 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 599 restart: 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(); 657 out: 658 iput(place_holder); 659 return err; 660 } 661 662 static 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 677 static 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(); 690 out: 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 */ 704 int 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 */ 724 void 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 */ 747 int 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 */ 770 void 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 } 795 out: 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 */ 808 int 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 824 static 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 831 static 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 843 static 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 853 static 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 */ 864 void 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 */ 875 void 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 893 static 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 906 static 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 917 static 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; 946 out: 947 rcu_read_unlock(); 948 if (ret) 949 nfs_inode_find_state_and_recover(inode, stateid); 950 } 951 952 void nfs_remove_bad_delegation(struct inode *inode, 953 const nfs4_stateid *stateid) 954 { 955 nfs_revoke_delegation(inode, stateid); 956 } 957 EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation); 958 959 void 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 985 out_clear_returning: 986 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags); 987 out_spin_unlock: 988 spin_unlock(&delegation->lock); 989 out_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 */ 1001 void 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 1007 static 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 */ 1023 void 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 */ 1042 int 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; 1064 out_enoent: 1065 rcu_read_unlock(); 1066 return -ENOENT; 1067 } 1068 1069 static struct inode * 1070 nfs_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 */ 1109 struct 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 1127 static 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 */ 1147 void 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 1157 static 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; 1162 restart: 1163 rcu_read_lock(); 1164 restart_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 */ 1198 void 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 1204 static 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 1211 static 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 1221 static 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 1234 static 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 */ 1249 void 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 */ 1265 void 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 1271 static void 1272 nfs_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 1287 static 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 1296 restart: 1297 rcu_read_lock(); 1298 restart_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 */ 1342 void 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 1348 void 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 */ 1375 int 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 */ 1398 bool 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(); 1415 out: 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 */ 1429 bool 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); 1450 out: 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 */ 1463 bool 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; 1475 out: 1476 rcu_read_unlock(); 1477 return ret; 1478 } 1479 1480 module_param_named(delegation_watermark, nfs_delegation_watermark, uint, 0644); 1481