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