fs/nfs/delegation.c

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