fs/nfs/delegation.c

   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 #include "nfs4trace.h"
  24
  25 static void nfs_free_delegation(struct nfs_delegation *delegation)
  26 {
  27         if (delegation->cred) {
  28                 put_rpccred(delegation->cred);
  29                 delegation->cred = NULL;
  30         }
  31         kfree_rcu(delegation, rcu);
  32 }
  33
  34 /**
  35  * nfs_mark_delegation_referenced - set delegation's REFERENCED flag
  36  * @delegation: delegation to process
  37  *
  38  */
  39 void nfs_mark_delegation_referenced(struct nfs_delegation *delegation)
  40 {
  41         set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags);
  42 }
  43
  44 static int
  45 nfs4_do_check_delegation(struct inode *inode, fmode_t flags, bool mark)
  46 {
  47         struct nfs_delegation *delegation;
  48         int ret = 0;
  49
  50         flags &= FMODE_READ|FMODE_WRITE;
  51         rcu_read_lock();
  52         delegation = rcu_dereference(NFS_I(inode)->delegation);
  53         if (delegation != NULL && (delegation->type & flags) == flags &&
  54             !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
  55                 if (mark)
  56                         nfs_mark_delegation_referenced(delegation);
  57                 ret = 1;
  58         }
  59         rcu_read_unlock();
  60         return ret;
  61 }
  62 /**
  63  * nfs_have_delegation - check if inode has a delegation, mark it
  64  * NFS_DELEGATION_REFERENCED if there is one.
  65  * @inode: inode to check
  66  * @flags: delegation types to check for
  67  *
  68  * Returns one if inode has the indicated delegation, otherwise zero.
  69  */
  70 int nfs4_have_delegation(struct inode *inode, fmode_t flags)
  71 {
  72         return nfs4_do_check_delegation(inode, flags, true);
  73 }
  74
  75 /*
  76  * nfs4_check_delegation - check if inode has a delegation, do not mark
  77  * NFS_DELEGATION_REFERENCED if it has one.
  78  */
  79 int nfs4_check_delegation(struct inode *inode, fmode_t flags)
  80 {
  81         return nfs4_do_check_delegation(inode, flags, false);
  82 }
  83
  84 static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
  85 {
  86         struct inode *inode = state->inode;
  87         struct file_lock *fl;
  88         int status = 0;
  89
  90         if (inode->i_flock == NULL)
  91                 goto out;
  92
  93         /* Protect inode->i_flock using the i_lock */
  94         spin_lock(&inode->i_lock);
  95         for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
  96                 if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
  97                         continue;
  98                 if (nfs_file_open_context(fl->fl_file) != ctx)
  99                         continue;
 100                 spin_unlock(&inode->i_lock);
 101                 status = nfs4_lock_delegation_recall(fl, state, stateid);
 102                 if (status < 0)
 103                         goto out;
 104                 spin_lock(&inode->i_lock);
 105         }
 106         spin_unlock(&inode->i_lock);
 107 out:
 108         return status;
 109 }
 110
 111 static int nfs_delegation_claim_opens(struct inode *inode, const nfs4_stateid *stateid)
 112 {
 113         struct nfs_inode *nfsi = NFS_I(inode);
 114         struct nfs_open_context *ctx;
 115         struct nfs4_state_owner *sp;
 116         struct nfs4_state *state;
 117         unsigned int seq;
 118         int err;
 119
 120 again:
 121         spin_lock(&inode->i_lock);
 122         list_for_each_entry(ctx, &nfsi->open_files, list) {
 123                 state = ctx->state;
 124                 if (state == NULL)
 125                         continue;
 126                 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
 127                         continue;
 128                 if (!nfs4_stateid_match(&state->stateid, stateid))
 129                         continue;
 130                 get_nfs_open_context(ctx);
 131                 spin_unlock(&inode->i_lock);
 132                 sp = state->owner;
 133                 /* Block nfs4_proc_unlck */
 134                 mutex_lock(&sp->so_delegreturn_mutex);
 135                 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
 136                 err = nfs4_open_delegation_recall(ctx, state, stateid);
 137                 if (!err)
 138                         err = nfs_delegation_claim_locks(ctx, state, stateid);
 139                 if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
 140                         err = -EAGAIN;
 141                 mutex_unlock(&sp->so_delegreturn_mutex);
 142                 put_nfs_open_context(ctx);
 143                 if (err != 0)
 144                         return err;
 145                 goto again;
 146         }
 147         spin_unlock(&inode->i_lock);
 148         return 0;
 149 }
 150
 151 /**
 152  * nfs_inode_reclaim_delegation - process a delegation reclaim request
 153  * @inode: inode to process
 154  * @cred: credential to use for request
 155  * @res: new delegation state from server
 156  *
 157  */
 158 void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
 159                                   struct nfs_openres *res)
 160 {
 161         struct nfs_delegation *delegation;
 162         struct rpc_cred *oldcred = NULL;
 163
 164         rcu_read_lock();
 165         delegation = rcu_dereference(NFS_I(inode)->delegation);
 166         if (delegation != NULL) {
 167                 spin_lock(&delegation->lock);
 168                 if (delegation->inode != NULL) {
 169                         nfs4_stateid_copy(&delegation->stateid, &res->delegation);
 170                         delegation->type = res->delegation_type;
 171                         delegation->maxsize = res->maxsize;
 172                         oldcred = delegation->cred;
 173                         delegation->cred = get_rpccred(cred);
 174                         clear_bit(NFS_DELEGATION_NEED_RECLAIM,
 175                                   &delegation->flags);
 176                         NFS_I(inode)->delegation_state = delegation->type;
 177                         spin_unlock(&delegation->lock);
 178                         put_rpccred(oldcred);
 179                         rcu_read_unlock();
 180                         trace_nfs4_reclaim_delegation(inode, res->delegation_type);
 181                 } else {
 182                         /* We appear to have raced with a delegation return. */
 183                         spin_unlock(&delegation->lock);
 184                         rcu_read_unlock();
 185                         nfs_inode_set_delegation(inode, cred, res);
 186                 }
 187         } else {
 188                 rcu_read_unlock();
 189         }
 190 }
 191
 192 static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
 193 {
 194         int res = 0;
 195
 196         if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
 197                 res = nfs4_proc_delegreturn(inode,
 198                                 delegation->cred,
 199                                 &delegation->stateid,
 200                                 issync);
 201         nfs_free_delegation(delegation);
 202         return res;
 203 }
 204
 205 static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
 206 {
 207         struct inode *inode = NULL;
 208
 209         spin_lock(&delegation->lock);
 210         if (delegation->inode != NULL)
 211                 inode = igrab(delegation->inode);
 212         spin_unlock(&delegation->lock);
 213         return inode;
 214 }
 215
 216 static struct nfs_delegation *
 217 nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
 218 {
 219         struct nfs_delegation *ret = NULL;
 220         struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
 221
 222         if (delegation == NULL)
 223                 goto out;
 224         spin_lock(&delegation->lock);
 225         if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
 226                 ret = delegation;
 227         spin_unlock(&delegation->lock);
 228 out:
 229         return ret;
 230 }
 231
 232 static struct nfs_delegation *
 233 nfs_start_delegation_return(struct nfs_inode *nfsi)
 234 {
 235         struct nfs_delegation *delegation;
 236
 237         rcu_read_lock();
 238         delegation = nfs_start_delegation_return_locked(nfsi);
 239         rcu_read_unlock();
 240         return delegation;
 241 }
 242
 243 static void
 244 nfs_abort_delegation_return(struct nfs_delegation *delegation,
 245                 struct nfs_client *clp)
 246 {
 247
 248         spin_lock(&delegation->lock);
 249         clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
 250         set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
 251         spin_unlock(&delegation->lock);
 252         set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
 253 }
 254
 255 static struct nfs_delegation *
 256 nfs_detach_delegation_locked(struct nfs_inode *nfsi,
 257                 struct nfs_delegation *delegation,
 258                 struct nfs_client *clp)
 259 {
 260         struct nfs_delegation *deleg_cur =
 261                 rcu_dereference_protected(nfsi->delegation,
 262                                 lockdep_is_held(&clp->cl_lock));
 263
 264         if (deleg_cur == NULL || delegation != deleg_cur)
 265                 return NULL;
 266
 267         spin_lock(&delegation->lock);
 268         set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
 269         list_del_rcu(&delegation->super_list);
 270         delegation->inode = NULL;
 271         nfsi->delegation_state = 0;
 272         rcu_assign_pointer(nfsi->delegation, NULL);
 273         spin_unlock(&delegation->lock);
 274         return delegation;
 275 }
 276
 277 static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
 278                 struct nfs_delegation *delegation,
 279                 struct nfs_server *server)
 280 {
 281         struct nfs_client *clp = server->nfs_client;
 282
 283         spin_lock(&clp->cl_lock);
 284         delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
 285         spin_unlock(&clp->cl_lock);
 286         return delegation;
 287 }
 288
 289 static struct nfs_delegation *
 290 nfs_inode_detach_delegation(struct inode *inode)
 291 {
 292         struct nfs_inode *nfsi = NFS_I(inode);
 293         struct nfs_server *server = NFS_SERVER(inode);
 294         struct nfs_delegation *delegation;
 295
 296         delegation = nfs_start_delegation_return(nfsi);
 297         if (delegation == NULL)
 298                 return NULL;
 299         return nfs_detach_delegation(nfsi, delegation, server);
 300 }
 301
 302 /**
 303  * nfs_inode_set_delegation - set up a delegation on an inode
 304  * @inode: inode to which delegation applies
 305  * @cred: cred to use for subsequent delegation processing
 306  * @res: new delegation state from server
 307  *
 308  * Returns zero on success, or a negative errno value.
 309  */
 310 int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res)
 311 {
 312         struct nfs_server *server = NFS_SERVER(inode);
 313         struct nfs_client *clp = server->nfs_client;
 314         struct nfs_inode *nfsi = NFS_I(inode);
 315         struct nfs_delegation *delegation, *old_delegation;
 316         struct nfs_delegation *freeme = NULL;
 317         int status = 0;
 318
 319         delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
 320         if (delegation == NULL)
 321                 return -ENOMEM;
 322         nfs4_stateid_copy(&delegation->stateid, &res->delegation);
 323         delegation->type = res->delegation_type;
 324         delegation->maxsize = res->maxsize;
 325         delegation->change_attr = inode->i_version;
 326         delegation->cred = get_rpccred(cred);
 327         delegation->inode = inode;
 328         delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
 329         spin_lock_init(&delegation->lock);
 330
 331         spin_lock(&clp->cl_lock);
 332         old_delegation = rcu_dereference_protected(nfsi->delegation,
 333                                         lockdep_is_held(&clp->cl_lock));
 334         if (old_delegation != NULL) {
 335                 if (nfs4_stateid_match(&delegation->stateid,
 336                                         &old_delegation->stateid) &&
 337                                 delegation->type == old_delegation->type) {
 338                         goto out;
 339                 }
 340                 /*
 341                  * Deal with broken servers that hand out two
 342                  * delegations for the same file.
 343                  * Allow for upgrades to a WRITE delegation, but
 344                  * nothing else.
 345                  */
 346                 dfprintk(FILE, "%s: server %s handed out "
 347                                 "a duplicate delegation!\n",
 348                                 __func__, clp->cl_hostname);
 349                 if (delegation->type == old_delegation->type ||
 350                     !(delegation->type & FMODE_WRITE)) {
 351                         freeme = delegation;
 352                         delegation = NULL;
 353                         goto out;
 354                 }
 355                 freeme = nfs_detach_delegation_locked(nfsi,
 356                                 old_delegation, clp);
 357                 if (freeme == NULL)
 358                         goto out;
 359         }
 360         list_add_rcu(&delegation->super_list, &server->delegations);
 361         nfsi->delegation_state = delegation->type;
 362         rcu_assign_pointer(nfsi->delegation, delegation);
 363         delegation = NULL;
 364
 365         /* Ensure we revalidate the attributes and page cache! */
 366         spin_lock(&inode->i_lock);
 367         nfsi->cache_validity |= NFS_INO_REVAL_FORCED;
 368         spin_unlock(&inode->i_lock);
 369         trace_nfs4_set_delegation(inode, res->delegation_type);
 370
 371 out:
 372         spin_unlock(&clp->cl_lock);
 373         if (delegation != NULL)
 374                 nfs_free_delegation(delegation);
 375         if (freeme != NULL)
 376                 nfs_do_return_delegation(inode, freeme, 0);
 377         return status;
 378 }
 379
 380 /*
 381  * Basic procedure for returning a delegation to the server
 382  */
 383 static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
 384 {
 385         struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
 386         struct nfs_inode *nfsi = NFS_I(inode);
 387         int err = 0;
 388
 389         if (delegation == NULL)
 390                 return 0;
 391         do {
 392                 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
 393                         break;
 394                 err = nfs_delegation_claim_opens(inode, &delegation->stateid);
 395                 if (!issync || err != -EAGAIN)
 396                         break;
 397                 /*
 398                  * Guard against state recovery
 399                  */
 400                 err = nfs4_wait_clnt_recover(clp);
 401         } while (err == 0);
 402
 403         if (err) {
 404                 nfs_abort_delegation_return(delegation, clp);
 405                 goto out;
 406         }
 407         if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
 408                 goto out;
 409
 410         err = nfs_do_return_delegation(inode, delegation, issync);
 411 out:
 412         return err;
 413 }
 414
 415 static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
 416 {
 417         bool ret = false;
 418
 419         if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
 420                 ret = true;
 421         if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
 422                 struct inode *inode;
 423
 424                 spin_lock(&delegation->lock);
 425                 inode = delegation->inode;
 426                 if (inode && list_empty(&NFS_I(inode)->open_files))
 427                         ret = true;
 428                 spin_unlock(&delegation->lock);
 429         }
 430         return ret;
 431 }
 432
 433 /**
 434  * nfs_client_return_marked_delegations - return previously marked delegations
 435  * @clp: nfs_client to process
 436  *
 437  * Note that this function is designed to be called by the state
 438  * manager thread. For this reason, it cannot flush the dirty data,
 439  * since that could deadlock in case of a state recovery error.
 440  *
 441  * Returns zero on success, or a negative errno value.
 442  */
 443 int nfs_client_return_marked_delegations(struct nfs_client *clp)
 444 {
 445         struct nfs_delegation *delegation;
 446         struct nfs_server *server;
 447         struct inode *inode;
 448         int err = 0;
 449
 450 restart:
 451         rcu_read_lock();
 452         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 453                 list_for_each_entry_rcu(delegation, &server->delegations,
 454                                                                 super_list) {
 455                         if (!nfs_delegation_need_return(delegation))
 456                                 continue;
 457                         inode = nfs_delegation_grab_inode(delegation);
 458                         if (inode == NULL)
 459                                 continue;
 460                         delegation = nfs_start_delegation_return_locked(NFS_I(inode));
 461                         rcu_read_unlock();
 462
 463                         err = nfs_end_delegation_return(inode, delegation, 0);
 464                         iput(inode);
 465                         if (!err)
 466                                 goto restart;
 467                         set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
 468                         return err;
 469                 }
 470         }
 471         rcu_read_unlock();
 472         return 0;
 473 }
 474
 475 /**
 476  * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
 477  * @inode: inode to process
 478  *
 479  * Does not protect against delegation reclaims, therefore really only safe
 480  * to be called from nfs4_clear_inode().
 481  */
 482 void nfs_inode_return_delegation_noreclaim(struct inode *inode)
 483 {
 484         struct nfs_delegation *delegation;
 485
 486         delegation = nfs_inode_detach_delegation(inode);
 487         if (delegation != NULL)
 488                 nfs_do_return_delegation(inode, delegation, 0);
 489 }
 490
 491 /**
 492  * nfs_inode_return_delegation - synchronously return a delegation
 493  * @inode: inode to process
 494  *
 495  * This routine will always flush any dirty data to disk on the
 496  * assumption that if we need to return the delegation, then
 497  * we should stop caching.
 498  *
 499  * Returns zero on success, or a negative errno value.
 500  */
 501 int nfs4_inode_return_delegation(struct inode *inode)
 502 {
 503         struct nfs_inode *nfsi = NFS_I(inode);
 504         struct nfs_delegation *delegation;
 505         int err = 0;
 506
 507         nfs_wb_all(inode);
 508         delegation = nfs_start_delegation_return(nfsi);
 509         if (delegation != NULL)
 510                 err = nfs_end_delegation_return(inode, delegation, 1);
 511         return err;
 512 }
 513
 514 static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
 515                 struct nfs_delegation *delegation)
 516 {
 517         set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
 518         set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
 519 }
 520
 521 static void nfs_mark_return_delegation(struct nfs_server *server,
 522                 struct nfs_delegation *delegation)
 523 {
 524         set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
 525         set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
 526 }
 527
 528 static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
 529 {
 530         struct nfs_delegation *delegation;
 531         bool ret = false;
 532
 533         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 534                 nfs_mark_return_delegation(server, delegation);
 535                 ret = true;
 536         }
 537         return ret;
 538 }
 539
 540 static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
 541 {
 542         struct nfs_server *server;
 543
 544         rcu_read_lock();
 545         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 546                 nfs_server_mark_return_all_delegations(server);
 547         rcu_read_unlock();
 548 }
 549
 550 static void nfs_delegation_run_state_manager(struct nfs_client *clp)
 551 {
 552         if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
 553                 nfs4_schedule_state_manager(clp);
 554 }
 555
 556 /**
 557  * nfs_expire_all_delegations
 558  * @clp: client to process
 559  *
 560  */
 561 void nfs_expire_all_delegations(struct nfs_client *clp)
 562 {
 563         nfs_client_mark_return_all_delegations(clp);
 564         nfs_delegation_run_state_manager(clp);
 565 }
 566
 567 /**
 568  * nfs_super_return_all_delegations - return delegations for one superblock
 569  * @sb: sb to process
 570  *
 571  */
 572 void nfs_server_return_all_delegations(struct nfs_server *server)
 573 {
 574         struct nfs_client *clp = server->nfs_client;
 575         bool need_wait;
 576
 577         if (clp == NULL)
 578                 return;
 579
 580         rcu_read_lock();
 581         need_wait = nfs_server_mark_return_all_delegations(server);
 582         rcu_read_unlock();
 583
 584         if (need_wait) {
 585                 nfs4_schedule_state_manager(clp);
 586                 nfs4_wait_clnt_recover(clp);
 587         }
 588 }
 589
 590 static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
 591                                                  fmode_t flags)
 592 {
 593         struct nfs_delegation *delegation;
 594
 595         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 596                 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
 597                         continue;
 598                 if (delegation->type & flags)
 599                         nfs_mark_return_if_closed_delegation(server, delegation);
 600         }
 601 }
 602
 603 static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
 604                                                         fmode_t flags)
 605 {
 606         struct nfs_server *server;
 607
 608         rcu_read_lock();
 609         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 610                 nfs_mark_return_unused_delegation_types(server, flags);
 611         rcu_read_unlock();
 612 }
 613
 614 static void nfs_revoke_delegation(struct inode *inode)
 615 {
 616         struct nfs_delegation *delegation;
 617         rcu_read_lock();
 618         delegation = rcu_dereference(NFS_I(inode)->delegation);
 619         if (delegation != NULL) {
 620                 set_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
 621                 nfs_mark_return_delegation(NFS_SERVER(inode), delegation);
 622         }
 623         rcu_read_unlock();
 624 }
 625
 626 void nfs_remove_bad_delegation(struct inode *inode)
 627 {
 628         struct nfs_delegation *delegation;
 629
 630         nfs_revoke_delegation(inode);
 631         delegation = nfs_inode_detach_delegation(inode);
 632         if (delegation) {
 633                 nfs_inode_find_state_and_recover(inode, &delegation->stateid);
 634                 nfs_free_delegation(delegation);
 635         }
 636 }
 637 EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
 638
 639 /**
 640  * nfs_expire_unused_delegation_types
 641  * @clp: client to process
 642  * @flags: delegation types to expire
 643  *
 644  */
 645 void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
 646 {
 647         nfs_client_mark_return_unused_delegation_types(clp, flags);
 648         nfs_delegation_run_state_manager(clp);
 649 }
 650
 651 static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
 652 {
 653         struct nfs_delegation *delegation;
 654
 655         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 656                 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
 657                         continue;
 658                 nfs_mark_return_if_closed_delegation(server, delegation);
 659         }
 660 }
 661
 662 /**
 663  * nfs_expire_unreferenced_delegations - Eliminate unused delegations
 664  * @clp: nfs_client to process
 665  *
 666  */
 667 void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
 668 {
 669         struct nfs_server *server;
 670
 671         rcu_read_lock();
 672         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 673                 nfs_mark_return_unreferenced_delegations(server);
 674         rcu_read_unlock();
 675
 676         nfs_delegation_run_state_manager(clp);
 677 }
 678
 679 /**
 680  * nfs_async_inode_return_delegation - asynchronously return a delegation
 681  * @inode: inode to process
 682  * @stateid: state ID information
 683  *
 684  * Returns zero on success, or a negative errno value.
 685  */
 686 int nfs_async_inode_return_delegation(struct inode *inode,
 687                                       const nfs4_stateid *stateid)
 688 {
 689         struct nfs_server *server = NFS_SERVER(inode);
 690         struct nfs_client *clp = server->nfs_client;
 691         struct nfs_delegation *delegation;
 692
 693         filemap_flush(inode->i_mapping);
 694
 695         rcu_read_lock();
 696         delegation = rcu_dereference(NFS_I(inode)->delegation);
 697         if (delegation == NULL)
 698                 goto out_enoent;
 699
 700         if (!clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
 701                 goto out_enoent;
 702         nfs_mark_return_delegation(server, delegation);
 703         rcu_read_unlock();
 704
 705         nfs_delegation_run_state_manager(clp);
 706         return 0;
 707 out_enoent:
 708         rcu_read_unlock();
 709         return -ENOENT;
 710 }
 711
 712 static struct inode *
 713 nfs_delegation_find_inode_server(struct nfs_server *server,
 714                                  const struct nfs_fh *fhandle)
 715 {
 716         struct nfs_delegation *delegation;
 717         struct inode *res = NULL;
 718
 719         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 720                 spin_lock(&delegation->lock);
 721                 if (delegation->inode != NULL &&
 722                     nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
 723                         res = igrab(delegation->inode);
 724                 }
 725                 spin_unlock(&delegation->lock);
 726                 if (res != NULL)
 727                         break;
 728         }
 729         return res;
 730 }
 731
 732 /**
 733  * nfs_delegation_find_inode - retrieve the inode associated with a delegation
 734  * @clp: client state handle
 735  * @fhandle: filehandle from a delegation recall
 736  *
 737  * Returns pointer to inode matching "fhandle," or NULL if a matching inode
 738  * cannot be found.
 739  */
 740 struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
 741                                         const struct nfs_fh *fhandle)
 742 {
 743         struct nfs_server *server;
 744         struct inode *res = NULL;
 745
 746         rcu_read_lock();
 747         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 748                 res = nfs_delegation_find_inode_server(server, fhandle);
 749                 if (res != NULL)
 750                         break;
 751         }
 752         rcu_read_unlock();
 753         return res;
 754 }
 755
 756 static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
 757 {
 758         struct nfs_delegation *delegation;
 759
 760         list_for_each_entry_rcu(delegation, &server->delegations, super_list)
 761                 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
 762 }
 763
 764 /**
 765  * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
 766  * @clp: nfs_client to process
 767  *
 768  */
 769 void nfs_delegation_mark_reclaim(struct nfs_client *clp)
 770 {
 771         struct nfs_server *server;
 772
 773         rcu_read_lock();
 774         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 775                 nfs_delegation_mark_reclaim_server(server);
 776         rcu_read_unlock();
 777 }
 778
 779 /**
 780  * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
 781  * @clp: nfs_client to process
 782  *
 783  */
 784 void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
 785 {
 786         struct nfs_delegation *delegation;
 787         struct nfs_server *server;
 788         struct inode *inode;
 789
 790 restart:
 791         rcu_read_lock();
 792         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 793                 list_for_each_entry_rcu(delegation, &server->delegations,
 794                                                                 super_list) {
 795                         if (test_bit(NFS_DELEGATION_NEED_RECLAIM,
 796                                                 &delegation->flags) == 0)
 797                                 continue;
 798                         inode = nfs_delegation_grab_inode(delegation);
 799                         if (inode == NULL)
 800                                 continue;
 801                         delegation = nfs_detach_delegation(NFS_I(inode),
 802                                         delegation, server);
 803                         rcu_read_unlock();
 804
 805                         if (delegation != NULL)
 806                                 nfs_free_delegation(delegation);
 807                         iput(inode);
 808                         goto restart;
 809                 }
 810         }
 811         rcu_read_unlock();
 812 }
 813
 814 /**
 815  * nfs_delegations_present - check for existence of delegations
 816  * @clp: client state handle
 817  *
 818  * Returns one if there are any nfs_delegation structures attached
 819  * to this nfs_client.
 820  */
 821 int nfs_delegations_present(struct nfs_client *clp)
 822 {
 823         struct nfs_server *server;
 824         int ret = 0;
 825
 826         rcu_read_lock();
 827         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 828                 if (!list_empty(&server->delegations)) {
 829                         ret = 1;
 830                         break;
 831                 }
 832         rcu_read_unlock();
 833         return ret;
 834 }
 835
 836 /**
 837  * nfs4_copy_delegation_stateid - Copy inode's state ID information
 838  * @dst: stateid data structure to fill in
 839  * @inode: inode to check
 840  * @flags: delegation type requirement
 841  *
 842  * Returns "true" and fills in "dst->data" * if inode had a delegation,
 843  * otherwise "false" is returned.
 844  */
 845 bool nfs4_copy_delegation_stateid(nfs4_stateid *dst, struct inode *inode,
 846                 fmode_t flags)
 847 {
 848         struct nfs_inode *nfsi = NFS_I(inode);
 849         struct nfs_delegation *delegation;
 850         bool ret;
 851
 852         flags &= FMODE_READ|FMODE_WRITE;
 853         rcu_read_lock();
 854         delegation = rcu_dereference(nfsi->delegation);
 855         ret = (delegation != NULL && (delegation->type & flags) == flags);
 856         if (ret) {
 857                 nfs4_stateid_copy(dst, &delegation->stateid);
 858                 nfs_mark_delegation_referenced(delegation);
 859         }
 860         rcu_read_unlock();
 861         return ret;
 862 }