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
 478 /**
 479  * nfs_expire_all_delegation_types
 480  * @clp: client to process
 481  * @flags: delegation types to expire
 482  *
 483  */
 484 void nfs_expire_all_delegation_types(struct nfs_client *clp, fmode_t flags)
 485 {
 486         nfs_client_mark_return_all_delegation_types(clp, flags);
 487         nfs_delegation_run_state_manager(clp);
 488 }
 489
 490 /**
 491  * nfs_expire_all_delegations
 492  * @clp: client to process
 493  *
 494  */
 495 void nfs_expire_all_delegations(struct nfs_client *clp)
 496 {
 497         nfs_expire_all_delegation_types(clp, FMODE_READ|FMODE_WRITE);
 498 }
 499
 500 /**
 501  * nfs_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN
 502  * @clp: client to process
 503  *
 504  */
 505 void nfs_handle_cb_pathdown(struct nfs_client *clp)
 506 {
 507         if (clp == NULL)
 508                 return;
 509         nfs_client_mark_return_all_delegations(clp);
 510 }
 511
 512 static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
 513 {
 514         struct nfs_delegation *delegation;
 515
 516         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 517                 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
 518                         continue;
 519                 nfs_mark_return_delegation(server, delegation);
 520         }
 521 }
 522
 523 /**
 524  * nfs_expire_unreferenced_delegations - Eliminate unused delegations
 525  * @clp: nfs_client to process
 526  *
 527  */
 528 void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
 529 {
 530         struct nfs_server *server;
 531
 532         rcu_read_lock();
 533         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 534                 nfs_mark_return_unreferenced_delegations(server);
 535         rcu_read_unlock();
 536
 537         nfs_delegation_run_state_manager(clp);
 538 }
 539
 540 /**
 541  * nfs_async_inode_return_delegation - asynchronously return a delegation
 542  * @inode: inode to process
 543  * @stateid: state ID information
 544  *
 545  * Returns zero on success, or a negative errno value.
 546  */
 547 int nfs_async_inode_return_delegation(struct inode *inode,
 548                                       const nfs4_stateid *stateid)
 549 {
 550         struct nfs_server *server = NFS_SERVER(inode);
 551         struct nfs_client *clp = server->nfs_client;
 552         struct nfs_delegation *delegation;
 553
 554         rcu_read_lock();
 555         delegation = rcu_dereference(NFS_I(inode)->delegation);
 556
 557         if (!clp->cl_mvops->match_stateid(&delegation->stateid, stateid)) {
 558                 rcu_read_unlock();
 559                 return -ENOENT;
 560         }
 561         nfs_mark_return_delegation(server, delegation);
 562         rcu_read_unlock();
 563
 564         nfs_delegation_run_state_manager(clp);
 565         return 0;
 566 }
 567
 568 static struct inode *
 569 nfs_delegation_find_inode_server(struct nfs_server *server,
 570                                  const struct nfs_fh *fhandle)
 571 {
 572         struct nfs_delegation *delegation;
 573         struct inode *res = NULL;
 574
 575         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 576                 spin_lock(&delegation->lock);
 577                 if (delegation->inode != NULL &&
 578                     nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
 579                         res = igrab(delegation->inode);
 580                 }
 581                 spin_unlock(&delegation->lock);
 582                 if (res != NULL)
 583                         break;
 584         }
 585         return res;
 586 }
 587
 588 /**
 589  * nfs_delegation_find_inode - retrieve the inode associated with a delegation
 590  * @clp: client state handle
 591  * @fhandle: filehandle from a delegation recall
 592  *
 593  * Returns pointer to inode matching "fhandle," or NULL if a matching inode
 594  * cannot be found.
 595  */
 596 struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
 597                                         const struct nfs_fh *fhandle)
 598 {
 599         struct nfs_server *server;
 600         struct inode *res = NULL;
 601
 602         rcu_read_lock();
 603         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 604                 res = nfs_delegation_find_inode_server(server, fhandle);
 605                 if (res != NULL)
 606                         break;
 607         }
 608         rcu_read_unlock();
 609         return res;
 610 }
 611
 612 static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
 613 {
 614         struct nfs_delegation *delegation;
 615
 616         list_for_each_entry_rcu(delegation, &server->delegations, super_list)
 617                 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
 618 }
 619
 620 /**
 621  * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
 622  * @clp: nfs_client to process
 623  *
 624  */
 625 void nfs_delegation_mark_reclaim(struct nfs_client *clp)
 626 {
 627         struct nfs_server *server;
 628
 629         rcu_read_lock();
 630         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 631                 nfs_delegation_mark_reclaim_server(server);
 632         rcu_read_unlock();
 633 }
 634
 635 /**
 636  * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
 637  * @clp: nfs_client to process
 638  *
 639  */
 640 void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
 641 {
 642         struct nfs_delegation *delegation;
 643         struct nfs_server *server;
 644         struct inode *inode;
 645
 646 restart:
 647         rcu_read_lock();
 648         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 649                 list_for_each_entry_rcu(delegation, &server->delegations,
 650                                                                 super_list) {
 651                         if (test_bit(NFS_DELEGATION_NEED_RECLAIM,
 652                                                 &delegation->flags) == 0)
 653                                 continue;
 654                         inode = nfs_delegation_grab_inode(delegation);
 655                         if (inode == NULL)
 656                                 continue;
 657                         delegation = nfs_detach_delegation(NFS_I(inode),
 658                                                                 server);
 659                         rcu_read_unlock();
 660
 661                         if (delegation != NULL)
 662                                 nfs_free_delegation(delegation);
 663                         iput(inode);
 664                         goto restart;
 665                 }
 666         }
 667         rcu_read_unlock();
 668 }
 669
 670 /**
 671  * nfs_delegations_present - check for existence of delegations
 672  * @clp: client state handle
 673  *
 674  * Returns one if there are any nfs_delegation structures attached
 675  * to this nfs_client.
 676  */
 677 int nfs_delegations_present(struct nfs_client *clp)
 678 {
 679         struct nfs_server *server;
 680         int ret = 0;
 681
 682         rcu_read_lock();
 683         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 684                 if (!list_empty(&server->delegations)) {
 685                         ret = 1;
 686                         break;
 687                 }
 688         rcu_read_unlock();
 689         return ret;
 690 }
 691
 692 /**
 693  * nfs4_copy_delegation_stateid - Copy inode's state ID information
 694  * @dst: stateid data structure to fill in
 695  * @inode: inode to check
 696  *
 697  * Returns one and fills in "dst->data" * if inode had a delegation,
 698  * otherwise zero is returned.
 699  */
 700 int nfs4_copy_delegation_stateid(nfs4_stateid *dst, struct inode *inode)
 701 {
 702         struct nfs_inode *nfsi = NFS_I(inode);
 703         struct nfs_delegation *delegation;
 704         int ret = 0;
 705
 706         rcu_read_lock();
 707         delegation = rcu_dereference(nfsi->delegation);
 708         if (delegation != NULL) {
 709                 nfs4_stateid_copy(dst, &delegation->stateid);
 710                 ret = 1;
 711         }
 712         rcu_read_unlock();
 713         return ret;
 714 }