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