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 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                  */
 260                 dfprintk(FILE, "%s: server %s handed out "
 261                                 "a duplicate delegation!\n",
 262                                 __func__, clp->cl_hostname);
 263                 if (delegation->type <= old_delegation->type) {
 264                         freeme = delegation;
 265                         delegation = NULL;
 266                         goto out;
 267                 }
 268                 freeme = nfs_detach_delegation_locked(nfsi, server);
 269         }
 270         list_add_rcu(&delegation->super_list, &server->delegations);
 271         nfsi->delegation_state = delegation->type;
 272         rcu_assign_pointer(nfsi->delegation, delegation);
 273         delegation = NULL;
 274
 275         /* Ensure we revalidate the attributes and page cache! */
 276         spin_lock(&inode->i_lock);
 277         nfsi->cache_validity |= NFS_INO_REVAL_FORCED;
 278         spin_unlock(&inode->i_lock);
 279
 280 out:
 281         spin_unlock(&clp->cl_lock);
 282         if (delegation != NULL)
 283                 nfs_free_delegation(delegation);
 284         if (freeme != NULL)
 285                 nfs_do_return_delegation(inode, freeme, 0);
 286         return status;
 287 }
 288
 289 /*
 290  * Basic procedure for returning a delegation to the server
 291  */
 292 static int __nfs_inode_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
 293 {
 294         struct nfs_inode *nfsi = NFS_I(inode);
 295         int err;
 296
 297         /*
 298          * Guard against new delegated open/lock/unlock calls and against
 299          * state recovery
 300          */
 301         down_write(&nfsi->rwsem);
 302         err = nfs_delegation_claim_opens(inode, &delegation->stateid);
 303         up_write(&nfsi->rwsem);
 304         if (err)
 305                 goto out;
 306
 307         err = nfs_do_return_delegation(inode, delegation, issync);
 308 out:
 309         return err;
 310 }
 311
 312 /**
 313  * nfs_client_return_marked_delegations - return previously marked delegations
 314  * @clp: nfs_client to process
 315  *
 316  * Returns zero on success, or a negative errno value.
 317  */
 318 int nfs_client_return_marked_delegations(struct nfs_client *clp)
 319 {
 320         struct nfs_delegation *delegation;
 321         struct nfs_server *server;
 322         struct inode *inode;
 323         int err = 0;
 324
 325 restart:
 326         rcu_read_lock();
 327         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 328                 list_for_each_entry_rcu(delegation, &server->delegations,
 329                                                                 super_list) {
 330                         if (!test_and_clear_bit(NFS_DELEGATION_RETURN,
 331                                                         &delegation->flags))
 332                                 continue;
 333                         inode = nfs_delegation_grab_inode(delegation);
 334                         if (inode == NULL)
 335                                 continue;
 336                         delegation = nfs_detach_delegation(NFS_I(inode),
 337                                                                 server);
 338                         rcu_read_unlock();
 339
 340                         if (delegation != NULL) {
 341                                 filemap_flush(inode->i_mapping);
 342                                 err = __nfs_inode_return_delegation(inode,
 343                                                                 delegation, 0);
 344                         }
 345                         iput(inode);
 346                         if (!err)
 347                                 goto restart;
 348                         set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
 349                         return err;
 350                 }
 351         }
 352         rcu_read_unlock();
 353         return 0;
 354 }
 355
 356 /**
 357  * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
 358  * @inode: inode to process
 359  *
 360  * Does not protect against delegation reclaims, therefore really only safe
 361  * to be called from nfs4_clear_inode().
 362  */
 363 void nfs_inode_return_delegation_noreclaim(struct inode *inode)
 364 {
 365         struct nfs_server *server = NFS_SERVER(inode);
 366         struct nfs_inode *nfsi = NFS_I(inode);
 367         struct nfs_delegation *delegation;
 368
 369         if (rcu_access_pointer(nfsi->delegation) != NULL) {
 370                 delegation = nfs_detach_delegation(nfsi, server);
 371                 if (delegation != NULL)
 372                         nfs_do_return_delegation(inode, delegation, 0);
 373         }
 374 }
 375
 376 /**
 377  * nfs_inode_return_delegation - synchronously return a delegation
 378  * @inode: inode to process
 379  *
 380  * Returns zero on success, or a negative errno value.
 381  */
 382 int nfs_inode_return_delegation(struct inode *inode)
 383 {
 384         struct nfs_server *server = NFS_SERVER(inode);
 385         struct nfs_inode *nfsi = NFS_I(inode);
 386         struct nfs_delegation *delegation;
 387         int err = 0;
 388
 389         if (rcu_access_pointer(nfsi->delegation) != NULL) {
 390                 delegation = nfs_detach_delegation(nfsi, server);
 391                 if (delegation != NULL) {
 392                         nfs_wb_all(inode);
 393                         err = __nfs_inode_return_delegation(inode, delegation, 1);
 394                 }
 395         }
 396         return err;
 397 }
 398
 399 static void nfs_mark_return_delegation(struct nfs_server *server,
 400                 struct nfs_delegation *delegation)
 401 {
 402         set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
 403         set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
 404 }
 405
 406 /**
 407  * nfs_super_return_all_delegations - return delegations for one superblock
 408  * @sb: sb to process
 409  *
 410  */
 411 void nfs_super_return_all_delegations(struct super_block *sb)
 412 {
 413         struct nfs_server *server = NFS_SB(sb);
 414         struct nfs_client *clp = server->nfs_client;
 415         struct nfs_delegation *delegation;
 416
 417         if (clp == NULL)
 418                 return;
 419
 420         rcu_read_lock();
 421         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 422                 spin_lock(&delegation->lock);
 423                 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
 424                 spin_unlock(&delegation->lock);
 425         }
 426         rcu_read_unlock();
 427
 428         if (nfs_client_return_marked_delegations(clp) != 0)
 429                 nfs4_schedule_state_manager(clp);
 430 }
 431
 432 static void nfs_mark_return_all_delegation_types(struct nfs_server *server,
 433                                                  fmode_t flags)
 434 {
 435         struct nfs_delegation *delegation;
 436
 437         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 438                 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
 439                         continue;
 440                 if (delegation->type & flags)
 441                         nfs_mark_return_delegation(server, delegation);
 442         }
 443 }
 444
 445 static void nfs_client_mark_return_all_delegation_types(struct nfs_client *clp,
 446                                                         fmode_t flags)
 447 {
 448         struct nfs_server *server;
 449
 450         rcu_read_lock();
 451         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 452                 nfs_mark_return_all_delegation_types(server, flags);
 453         rcu_read_unlock();
 454 }
 455
 456 static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
 457 {
 458         nfs_client_mark_return_all_delegation_types(clp, FMODE_READ|FMODE_WRITE);
 459 }
 460
 461 static void nfs_delegation_run_state_manager(struct nfs_client *clp)
 462 {
 463         if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
 464                 nfs4_schedule_state_manager(clp);
 465 }
 466
 467 void nfs_remove_bad_delegation(struct inode *inode)
 468 {
 469         struct nfs_delegation *delegation;
 470
 471         delegation = nfs_detach_delegation(NFS_I(inode), NFS_SERVER(inode));
 472         if (delegation) {
 473                 nfs_inode_find_state_and_recover(inode, &delegation->stateid);
 474                 nfs_free_delegation(delegation);
 475         }
 476 }
 477 EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
 478
 479 /**
 480  * nfs_expire_all_delegation_types
 481  * @clp: client to process
 482  * @flags: delegation types to expire
 483  *
 484  */
 485 void nfs_expire_all_delegation_types(struct nfs_client *clp, fmode_t flags)
 486 {
 487         nfs_client_mark_return_all_delegation_types(clp, flags);
 488         nfs_delegation_run_state_manager(clp);
 489 }
 490
 491 /**
 492  * nfs_expire_all_delegations
 493  * @clp: client to process
 494  *
 495  */
 496 void nfs_expire_all_delegations(struct nfs_client *clp)
 497 {
 498         nfs_expire_all_delegation_types(clp, FMODE_READ|FMODE_WRITE);
 499 }
 500
 501 /**
 502  * nfs_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN
 503  * @clp: client to process
 504  *
 505  */
 506 void nfs_handle_cb_pathdown(struct nfs_client *clp)
 507 {
 508         if (clp == NULL)
 509                 return;
 510         nfs_client_mark_return_all_delegations(clp);
 511 }
 512
 513 static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
 514 {
 515         struct nfs_delegation *delegation;
 516
 517         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 518                 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
 519                         continue;
 520                 nfs_mark_return_delegation(server, delegation);
 521         }
 522 }
 523
 524 /**
 525  * nfs_expire_unreferenced_delegations - Eliminate unused delegations
 526  * @clp: nfs_client to process
 527  *
 528  */
 529 void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
 530 {
 531         struct nfs_server *server;
 532
 533         rcu_read_lock();
 534         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 535                 nfs_mark_return_unreferenced_delegations(server);
 536         rcu_read_unlock();
 537
 538         nfs_delegation_run_state_manager(clp);
 539 }
 540
 541 /**
 542  * nfs_async_inode_return_delegation - asynchronously return a delegation
 543  * @inode: inode to process
 544  * @stateid: state ID information
 545  *
 546  * Returns zero on success, or a negative errno value.
 547  */
 548 int nfs_async_inode_return_delegation(struct inode *inode,
 549                                       const nfs4_stateid *stateid)
 550 {
 551         struct nfs_server *server = NFS_SERVER(inode);
 552         struct nfs_client *clp = server->nfs_client;
 553         struct nfs_delegation *delegation;
 554
 555         rcu_read_lock();
 556         delegation = rcu_dereference(NFS_I(inode)->delegation);
 557
 558         if (!clp->cl_mvops->match_stateid(&delegation->stateid, stateid)) {
 559                 rcu_read_unlock();
 560                 return -ENOENT;
 561         }
 562         nfs_mark_return_delegation(server, delegation);
 563         rcu_read_unlock();
 564
 565         nfs_delegation_run_state_manager(clp);
 566         return 0;
 567 }
 568
 569 static struct inode *
 570 nfs_delegation_find_inode_server(struct nfs_server *server,
 571                                  const struct nfs_fh *fhandle)
 572 {
 573         struct nfs_delegation *delegation;
 574         struct inode *res = NULL;
 575
 576         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 577                 spin_lock(&delegation->lock);
 578                 if (delegation->inode != NULL &&
 579                     nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
 580                         res = igrab(delegation->inode);
 581                 }
 582                 spin_unlock(&delegation->lock);
 583                 if (res != NULL)
 584                         break;
 585         }
 586         return res;
 587 }
 588
 589 /**
 590  * nfs_delegation_find_inode - retrieve the inode associated with a delegation
 591  * @clp: client state handle
 592  * @fhandle: filehandle from a delegation recall
 593  *
 594  * Returns pointer to inode matching "fhandle," or NULL if a matching inode
 595  * cannot be found.
 596  */
 597 struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
 598                                         const struct nfs_fh *fhandle)
 599 {
 600         struct nfs_server *server;
 601         struct inode *res = NULL;
 602
 603         rcu_read_lock();
 604         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 605                 res = nfs_delegation_find_inode_server(server, fhandle);
 606                 if (res != NULL)
 607                         break;
 608         }
 609         rcu_read_unlock();
 610         return res;
 611 }
 612
 613 static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
 614 {
 615         struct nfs_delegation *delegation;
 616
 617         list_for_each_entry_rcu(delegation, &server->delegations, super_list)
 618                 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
 619 }
 620
 621 /**
 622  * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
 623  * @clp: nfs_client to process
 624  *
 625  */
 626 void nfs_delegation_mark_reclaim(struct nfs_client *clp)
 627 {
 628         struct nfs_server *server;
 629
 630         rcu_read_lock();
 631         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 632                 nfs_delegation_mark_reclaim_server(server);
 633         rcu_read_unlock();
 634 }
 635
 636 /**
 637  * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
 638  * @clp: nfs_client to process
 639  *
 640  */
 641 void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
 642 {
 643         struct nfs_delegation *delegation;
 644         struct nfs_server *server;
 645         struct inode *inode;
 646
 647 restart:
 648         rcu_read_lock();
 649         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 650                 list_for_each_entry_rcu(delegation, &server->delegations,
 651                                                                 super_list) {
 652                         if (test_bit(NFS_DELEGATION_NEED_RECLAIM,
 653                                                 &delegation->flags) == 0)
 654                                 continue;
 655                         inode = nfs_delegation_grab_inode(delegation);
 656                         if (inode == NULL)
 657                                 continue;
 658                         delegation = nfs_detach_delegation(NFS_I(inode),
 659                                                                 server);
 660                         rcu_read_unlock();
 661
 662                         if (delegation != NULL)
 663                                 nfs_free_delegation(delegation);
 664                         iput(inode);
 665                         goto restart;
 666                 }
 667         }
 668         rcu_read_unlock();
 669 }
 670
 671 /**
 672  * nfs_delegations_present - check for existence of delegations
 673  * @clp: client state handle
 674  *
 675  * Returns one if there are any nfs_delegation structures attached
 676  * to this nfs_client.
 677  */
 678 int nfs_delegations_present(struct nfs_client *clp)
 679 {
 680         struct nfs_server *server;
 681         int ret = 0;
 682
 683         rcu_read_lock();
 684         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 685                 if (!list_empty(&server->delegations)) {
 686                         ret = 1;
 687                         break;
 688                 }
 689         rcu_read_unlock();
 690         return ret;
 691 }
 692
 693 /**
 694  * nfs4_copy_delegation_stateid - Copy inode's state ID information
 695  * @dst: stateid data structure to fill in
 696  * @inode: inode to check
 697  *
 698  * Returns one and fills in "dst->data" * if inode had a delegation,
 699  * otherwise zero is returned.
 700  */
 701 int nfs4_copy_delegation_stateid(nfs4_stateid *dst, struct inode *inode)
 702 {
 703         struct nfs_inode *nfsi = NFS_I(inode);
 704         struct nfs_delegation *delegation;
 705         int ret = 0;
 706
 707         rcu_read_lock();
 708         delegation = rcu_dereference(nfsi->delegation);
 709         if (delegation != NULL) {
 710                 nfs4_stateid_copy(dst, &delegation->stateid);
 711                 ret = 1;
 712         }
 713         rcu_read_unlock();
 714         return ret;
 715 }