1 /* 2 * linux/fs/nfs/delegation.c 3 * 4 * Copyright (C) 2004 Trond Myklebust 5 * 6 * NFS file delegation management 7 * 8 */ 9 #include <linux/completion.h> 10 #include <linux/kthread.h> 11 #include <linux/module.h> 12 #include <linux/sched.h> 13 #include <linux/slab.h> 14 #include <linux/spinlock.h> 15 16 #include <linux/nfs4.h> 17 #include <linux/nfs_fs.h> 18 #include <linux/nfs_xdr.h> 19 20 #include "nfs4_fs.h" 21 #include "delegation.h" 22 #include "internal.h" 23 24 static void nfs_free_delegation(struct nfs_delegation *delegation) 25 { 26 if (delegation->cred) { 27 put_rpccred(delegation->cred); 28 delegation->cred = NULL; 29 } 30 kfree_rcu(delegation, rcu); 31 } 32 33 /** 34 * nfs_mark_delegation_referenced - set delegation's REFERENCED flag 35 * @delegation: delegation to process 36 * 37 */ 38 void nfs_mark_delegation_referenced(struct nfs_delegation *delegation) 39 { 40 set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags); 41 } 42 43 /** 44 * nfs_have_delegation - check if inode has a delegation 45 * @inode: inode to check 46 * @flags: delegation types to check for 47 * 48 * Returns one if inode has the indicated delegation, otherwise zero. 49 */ 50 int nfs_have_delegation(struct inode *inode, fmode_t flags) 51 { 52 struct nfs_delegation *delegation; 53 int ret = 0; 54 55 flags &= FMODE_READ|FMODE_WRITE; 56 rcu_read_lock(); 57 delegation = rcu_dereference(NFS_I(inode)->delegation); 58 if (delegation != NULL && (delegation->type & flags) == flags) { 59 nfs_mark_delegation_referenced(delegation); 60 ret = 1; 61 } 62 rcu_read_unlock(); 63 return ret; 64 } 65 66 static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_state *state) 67 { 68 struct inode *inode = state->inode; 69 struct file_lock *fl; 70 int status = 0; 71 72 if (inode->i_flock == NULL) 73 goto out; 74 75 /* Protect inode->i_flock using the file locks lock */ 76 lock_flocks(); 77 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { 78 if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK))) 79 continue; 80 if (nfs_file_open_context(fl->fl_file) != ctx) 81 continue; 82 unlock_flocks(); 83 status = nfs4_lock_delegation_recall(state, fl); 84 if (status < 0) 85 goto out; 86 lock_flocks(); 87 } 88 unlock_flocks(); 89 out: 90 return status; 91 } 92 93 static int nfs_delegation_claim_opens(struct inode *inode, const nfs4_stateid *stateid) 94 { 95 struct nfs_inode *nfsi = NFS_I(inode); 96 struct nfs_open_context *ctx; 97 struct nfs4_state *state; 98 int err; 99 100 again: 101 spin_lock(&inode->i_lock); 102 list_for_each_entry(ctx, &nfsi->open_files, list) { 103 state = ctx->state; 104 if (state == NULL) 105 continue; 106 if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) 107 continue; 108 if (!nfs4_stateid_match(&state->stateid, stateid)) 109 continue; 110 get_nfs_open_context(ctx); 111 spin_unlock(&inode->i_lock); 112 err = nfs4_open_delegation_recall(ctx, state, stateid); 113 if (err >= 0) 114 err = nfs_delegation_claim_locks(ctx, state); 115 put_nfs_open_context(ctx); 116 if (err != 0) 117 return err; 118 goto again; 119 } 120 spin_unlock(&inode->i_lock); 121 return 0; 122 } 123 124 /** 125 * nfs_inode_reclaim_delegation - process a delegation reclaim request 126 * @inode: inode to process 127 * @cred: credential to use for request 128 * @res: new delegation state from server 129 * 130 */ 131 void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred, 132 struct nfs_openres *res) 133 { 134 struct nfs_delegation *delegation; 135 struct rpc_cred *oldcred = NULL; 136 137 rcu_read_lock(); 138 delegation = rcu_dereference(NFS_I(inode)->delegation); 139 if (delegation != NULL) { 140 spin_lock(&delegation->lock); 141 if (delegation->inode != NULL) { 142 nfs4_stateid_copy(&delegation->stateid, &res->delegation); 143 delegation->type = res->delegation_type; 144 delegation->maxsize = res->maxsize; 145 oldcred = delegation->cred; 146 delegation->cred = get_rpccred(cred); 147 clear_bit(NFS_DELEGATION_NEED_RECLAIM, 148 &delegation->flags); 149 NFS_I(inode)->delegation_state = delegation->type; 150 spin_unlock(&delegation->lock); 151 put_rpccred(oldcred); 152 rcu_read_unlock(); 153 } else { 154 /* We appear to have raced with a delegation return. */ 155 spin_unlock(&delegation->lock); 156 rcu_read_unlock(); 157 nfs_inode_set_delegation(inode, cred, res); 158 } 159 } else { 160 rcu_read_unlock(); 161 } 162 } 163 164 static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync) 165 { 166 int res = 0; 167 168 res = nfs4_proc_delegreturn(inode, delegation->cred, &delegation->stateid, issync); 169 nfs_free_delegation(delegation); 170 return res; 171 } 172 173 static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation) 174 { 175 struct inode *inode = NULL; 176 177 spin_lock(&delegation->lock); 178 if (delegation->inode != NULL) 179 inode = igrab(delegation->inode); 180 spin_unlock(&delegation->lock); 181 return inode; 182 } 183 184 static struct nfs_delegation * 185 nfs_detach_delegation_locked(struct nfs_inode *nfsi, 186 struct nfs_server *server) 187 { 188 struct nfs_delegation *delegation = 189 rcu_dereference_protected(nfsi->delegation, 190 lockdep_is_held(&server->nfs_client->cl_lock)); 191 192 if (delegation == NULL) 193 goto nomatch; 194 195 spin_lock(&delegation->lock); 196 list_del_rcu(&delegation->super_list); 197 delegation->inode = NULL; 198 nfsi->delegation_state = 0; 199 rcu_assign_pointer(nfsi->delegation, NULL); 200 spin_unlock(&delegation->lock); 201 return delegation; 202 nomatch: 203 return NULL; 204 } 205 206 static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi, 207 struct nfs_server *server) 208 { 209 struct nfs_client *clp = server->nfs_client; 210 struct nfs_delegation *delegation; 211 212 spin_lock(&clp->cl_lock); 213 delegation = nfs_detach_delegation_locked(nfsi, server); 214 spin_unlock(&clp->cl_lock); 215 return delegation; 216 } 217 218 /** 219 * nfs_inode_set_delegation - set up a delegation on an inode 220 * @inode: inode to which delegation applies 221 * @cred: cred to use for subsequent delegation processing 222 * @res: new delegation state from server 223 * 224 * Returns zero on success, or a negative errno value. 225 */ 226 int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res) 227 { 228 struct nfs_server *server = NFS_SERVER(inode); 229 struct nfs_client *clp = server->nfs_client; 230 struct nfs_inode *nfsi = NFS_I(inode); 231 struct nfs_delegation *delegation, *old_delegation; 232 struct nfs_delegation *freeme = NULL; 233 int status = 0; 234 235 delegation = kmalloc(sizeof(*delegation), GFP_NOFS); 236 if (delegation == NULL) 237 return -ENOMEM; 238 nfs4_stateid_copy(&delegation->stateid, &res->delegation); 239 delegation->type = res->delegation_type; 240 delegation->maxsize = res->maxsize; 241 delegation->change_attr = inode->i_version; 242 delegation->cred = get_rpccred(cred); 243 delegation->inode = inode; 244 delegation->flags = 1<<NFS_DELEGATION_REFERENCED; 245 spin_lock_init(&delegation->lock); 246 247 spin_lock(&clp->cl_lock); 248 old_delegation = rcu_dereference_protected(nfsi->delegation, 249 lockdep_is_held(&clp->cl_lock)); 250 if (old_delegation != NULL) { 251 if (nfs4_stateid_match(&delegation->stateid, 252 &old_delegation->stateid) && 253 delegation->type == old_delegation->type) { 254 goto out; 255 } 256 /* 257 * Deal with broken servers that hand out two 258 * delegations for the same file. 259 * Allow for upgrades to a WRITE delegation, but 260 * nothing else. 261 */ 262 dfprintk(FILE, "%s: server %s handed out " 263 "a duplicate delegation!\n", 264 __func__, clp->cl_hostname); 265 if (delegation->type == old_delegation->type || 266 !(delegation->type & FMODE_WRITE)) { 267 freeme = delegation; 268 delegation = NULL; 269 goto out; 270 } 271 freeme = nfs_detach_delegation_locked(nfsi, server); 272 } 273 list_add_rcu(&delegation->super_list, &server->delegations); 274 nfsi->delegation_state = delegation->type; 275 rcu_assign_pointer(nfsi->delegation, delegation); 276 delegation = NULL; 277 278 /* Ensure we revalidate the attributes and page cache! */ 279 spin_lock(&inode->i_lock); 280 nfsi->cache_validity |= NFS_INO_REVAL_FORCED; 281 spin_unlock(&inode->i_lock); 282 283 out: 284 spin_unlock(&clp->cl_lock); 285 if (delegation != NULL) 286 nfs_free_delegation(delegation); 287 if (freeme != NULL) 288 nfs_do_return_delegation(inode, freeme, 0); 289 return status; 290 } 291 292 /* 293 * Basic procedure for returning a delegation to the server 294 */ 295 static int __nfs_inode_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync) 296 { 297 struct nfs_inode *nfsi = NFS_I(inode); 298 int err; 299 300 /* 301 * Guard against new delegated open/lock/unlock calls and against 302 * state recovery 303 */ 304 down_write(&nfsi->rwsem); 305 err = nfs_delegation_claim_opens(inode, &delegation->stateid); 306 up_write(&nfsi->rwsem); 307 if (err) 308 goto out; 309 310 err = nfs_do_return_delegation(inode, delegation, issync); 311 out: 312 return err; 313 } 314 315 /** 316 * nfs_client_return_marked_delegations - return previously marked delegations 317 * @clp: nfs_client to process 318 * 319 * Returns zero on success, or a negative errno value. 320 */ 321 int nfs_client_return_marked_delegations(struct nfs_client *clp) 322 { 323 struct nfs_delegation *delegation; 324 struct nfs_server *server; 325 struct inode *inode; 326 int err = 0; 327 328 restart: 329 rcu_read_lock(); 330 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 331 list_for_each_entry_rcu(delegation, &server->delegations, 332 super_list) { 333 if (!test_and_clear_bit(NFS_DELEGATION_RETURN, 334 &delegation->flags)) 335 continue; 336 inode = nfs_delegation_grab_inode(delegation); 337 if (inode == NULL) 338 continue; 339 delegation = nfs_detach_delegation(NFS_I(inode), 340 server); 341 rcu_read_unlock(); 342 343 if (delegation != NULL) { 344 filemap_flush(inode->i_mapping); 345 err = __nfs_inode_return_delegation(inode, 346 delegation, 0); 347 } 348 iput(inode); 349 if (!err) 350 goto restart; 351 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state); 352 return err; 353 } 354 } 355 rcu_read_unlock(); 356 return 0; 357 } 358 359 /** 360 * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens 361 * @inode: inode to process 362 * 363 * Does not protect against delegation reclaims, therefore really only safe 364 * to be called from nfs4_clear_inode(). 365 */ 366 void nfs_inode_return_delegation_noreclaim(struct inode *inode) 367 { 368 struct nfs_server *server = NFS_SERVER(inode); 369 struct nfs_inode *nfsi = NFS_I(inode); 370 struct nfs_delegation *delegation; 371 372 if (rcu_access_pointer(nfsi->delegation) != NULL) { 373 delegation = nfs_detach_delegation(nfsi, server); 374 if (delegation != NULL) 375 nfs_do_return_delegation(inode, delegation, 0); 376 } 377 } 378 379 /** 380 * nfs_inode_return_delegation - synchronously return a delegation 381 * @inode: inode to process 382 * 383 * Returns zero on success, or a negative errno value. 384 */ 385 int nfs_inode_return_delegation(struct inode *inode) 386 { 387 struct nfs_server *server = NFS_SERVER(inode); 388 struct nfs_inode *nfsi = NFS_I(inode); 389 struct nfs_delegation *delegation; 390 int err = 0; 391 392 if (rcu_access_pointer(nfsi->delegation) != NULL) { 393 delegation = nfs_detach_delegation(nfsi, server); 394 if (delegation != NULL) { 395 nfs_wb_all(inode); 396 err = __nfs_inode_return_delegation(inode, delegation, 1); 397 } 398 } 399 return err; 400 } 401 402 static void nfs_mark_return_delegation(struct nfs_server *server, 403 struct nfs_delegation *delegation) 404 { 405 set_bit(NFS_DELEGATION_RETURN, &delegation->flags); 406 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state); 407 } 408 409 /** 410 * nfs_super_return_all_delegations - return delegations for one superblock 411 * @sb: sb to process 412 * 413 */ 414 void nfs_super_return_all_delegations(struct super_block *sb) 415 { 416 struct nfs_server *server = NFS_SB(sb); 417 struct nfs_client *clp = server->nfs_client; 418 struct nfs_delegation *delegation; 419 420 if (clp == NULL) 421 return; 422 423 rcu_read_lock(); 424 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 425 spin_lock(&delegation->lock); 426 set_bit(NFS_DELEGATION_RETURN, &delegation->flags); 427 spin_unlock(&delegation->lock); 428 } 429 rcu_read_unlock(); 430 431 if (nfs_client_return_marked_delegations(clp) != 0) 432 nfs4_schedule_state_manager(clp); 433 } 434 435 static void nfs_mark_return_all_delegation_types(struct nfs_server *server, 436 fmode_t flags) 437 { 438 struct nfs_delegation *delegation; 439 440 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 441 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE)) 442 continue; 443 if (delegation->type & flags) 444 nfs_mark_return_delegation(server, delegation); 445 } 446 } 447 448 static void nfs_client_mark_return_all_delegation_types(struct nfs_client *clp, 449 fmode_t flags) 450 { 451 struct nfs_server *server; 452 453 rcu_read_lock(); 454 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 455 nfs_mark_return_all_delegation_types(server, flags); 456 rcu_read_unlock(); 457 } 458 459 static void nfs_delegation_run_state_manager(struct nfs_client *clp) 460 { 461 if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) 462 nfs4_schedule_state_manager(clp); 463 } 464 465 void nfs_remove_bad_delegation(struct inode *inode) 466 { 467 struct nfs_delegation *delegation; 468 469 delegation = nfs_detach_delegation(NFS_I(inode), NFS_SERVER(inode)); 470 if (delegation) { 471 nfs_inode_find_state_and_recover(inode, &delegation->stateid); 472 nfs_free_delegation(delegation); 473 } 474 } 475 EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation); 476 477 /** 478 * nfs_expire_all_delegation_types 479 * @clp: client to process 480 * @flags: delegation types to expire 481 * 482 */ 483 void nfs_expire_all_delegation_types(struct nfs_client *clp, fmode_t flags) 484 { 485 nfs_client_mark_return_all_delegation_types(clp, flags); 486 nfs_delegation_run_state_manager(clp); 487 } 488 489 /** 490 * nfs_expire_all_delegations 491 * @clp: client to process 492 * 493 */ 494 void nfs_expire_all_delegations(struct nfs_client *clp) 495 { 496 nfs_expire_all_delegation_types(clp, FMODE_READ|FMODE_WRITE); 497 } 498 499 static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server) 500 { 501 struct nfs_delegation *delegation; 502 503 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 504 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags)) 505 continue; 506 nfs_mark_return_delegation(server, delegation); 507 } 508 } 509 510 /** 511 * nfs_expire_unreferenced_delegations - Eliminate unused delegations 512 * @clp: nfs_client to process 513 * 514 */ 515 void nfs_expire_unreferenced_delegations(struct nfs_client *clp) 516 { 517 struct nfs_server *server; 518 519 rcu_read_lock(); 520 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 521 nfs_mark_return_unreferenced_delegations(server); 522 rcu_read_unlock(); 523 524 nfs_delegation_run_state_manager(clp); 525 } 526 527 /** 528 * nfs_async_inode_return_delegation - asynchronously return a delegation 529 * @inode: inode to process 530 * @stateid: state ID information 531 * 532 * Returns zero on success, or a negative errno value. 533 */ 534 int nfs_async_inode_return_delegation(struct inode *inode, 535 const nfs4_stateid *stateid) 536 { 537 struct nfs_server *server = NFS_SERVER(inode); 538 struct nfs_client *clp = server->nfs_client; 539 struct nfs_delegation *delegation; 540 541 rcu_read_lock(); 542 delegation = rcu_dereference(NFS_I(inode)->delegation); 543 544 if (!clp->cl_mvops->match_stateid(&delegation->stateid, stateid)) { 545 rcu_read_unlock(); 546 return -ENOENT; 547 } 548 nfs_mark_return_delegation(server, delegation); 549 rcu_read_unlock(); 550 551 nfs_delegation_run_state_manager(clp); 552 return 0; 553 } 554 555 static struct inode * 556 nfs_delegation_find_inode_server(struct nfs_server *server, 557 const struct nfs_fh *fhandle) 558 { 559 struct nfs_delegation *delegation; 560 struct inode *res = NULL; 561 562 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { 563 spin_lock(&delegation->lock); 564 if (delegation->inode != NULL && 565 nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) { 566 res = igrab(delegation->inode); 567 } 568 spin_unlock(&delegation->lock); 569 if (res != NULL) 570 break; 571 } 572 return res; 573 } 574 575 /** 576 * nfs_delegation_find_inode - retrieve the inode associated with a delegation 577 * @clp: client state handle 578 * @fhandle: filehandle from a delegation recall 579 * 580 * Returns pointer to inode matching "fhandle," or NULL if a matching inode 581 * cannot be found. 582 */ 583 struct inode *nfs_delegation_find_inode(struct nfs_client *clp, 584 const struct nfs_fh *fhandle) 585 { 586 struct nfs_server *server; 587 struct inode *res = NULL; 588 589 rcu_read_lock(); 590 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 591 res = nfs_delegation_find_inode_server(server, fhandle); 592 if (res != NULL) 593 break; 594 } 595 rcu_read_unlock(); 596 return res; 597 } 598 599 static void nfs_delegation_mark_reclaim_server(struct nfs_server *server) 600 { 601 struct nfs_delegation *delegation; 602 603 list_for_each_entry_rcu(delegation, &server->delegations, super_list) 604 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags); 605 } 606 607 /** 608 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed 609 * @clp: nfs_client to process 610 * 611 */ 612 void nfs_delegation_mark_reclaim(struct nfs_client *clp) 613 { 614 struct nfs_server *server; 615 616 rcu_read_lock(); 617 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 618 nfs_delegation_mark_reclaim_server(server); 619 rcu_read_unlock(); 620 } 621 622 /** 623 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done 624 * @clp: nfs_client to process 625 * 626 */ 627 void nfs_delegation_reap_unclaimed(struct nfs_client *clp) 628 { 629 struct nfs_delegation *delegation; 630 struct nfs_server *server; 631 struct inode *inode; 632 633 restart: 634 rcu_read_lock(); 635 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 636 list_for_each_entry_rcu(delegation, &server->delegations, 637 super_list) { 638 if (test_bit(NFS_DELEGATION_NEED_RECLAIM, 639 &delegation->flags) == 0) 640 continue; 641 inode = nfs_delegation_grab_inode(delegation); 642 if (inode == NULL) 643 continue; 644 delegation = nfs_detach_delegation(NFS_I(inode), 645 server); 646 rcu_read_unlock(); 647 648 if (delegation != NULL) 649 nfs_free_delegation(delegation); 650 iput(inode); 651 goto restart; 652 } 653 } 654 rcu_read_unlock(); 655 } 656 657 /** 658 * nfs_delegations_present - check for existence of delegations 659 * @clp: client state handle 660 * 661 * Returns one if there are any nfs_delegation structures attached 662 * to this nfs_client. 663 */ 664 int nfs_delegations_present(struct nfs_client *clp) 665 { 666 struct nfs_server *server; 667 int ret = 0; 668 669 rcu_read_lock(); 670 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) 671 if (!list_empty(&server->delegations)) { 672 ret = 1; 673 break; 674 } 675 rcu_read_unlock(); 676 return ret; 677 } 678 679 /** 680 * nfs4_copy_delegation_stateid - Copy inode's state ID information 681 * @dst: stateid data structure to fill in 682 * @inode: inode to check 683 * @flags: delegation type requirement 684 * 685 * Returns "true" and fills in "dst->data" * if inode had a delegation, 686 * otherwise "false" is returned. 687 */ 688 bool nfs4_copy_delegation_stateid(nfs4_stateid *dst, struct inode *inode, 689 fmode_t flags) 690 { 691 struct nfs_inode *nfsi = NFS_I(inode); 692 struct nfs_delegation *delegation; 693 bool ret; 694 695 flags &= FMODE_READ|FMODE_WRITE; 696 rcu_read_lock(); 697 delegation = rcu_dereference(nfsi->delegation); 698 ret = (delegation != NULL && (delegation->type & flags) == flags); 699 if (ret) { 700 nfs4_stateid_copy(dst, &delegation->stateid); 701 nfs_mark_delegation_referenced(delegation); 702 } 703 rcu_read_unlock(); 704 return ret; 705 } 706