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 bool
  45 nfs4_is_valid_delegation(const struct nfs_delegation *delegation,
  46                 fmode_t flags)
  47 {
  48         if (delegation != NULL && (delegation->type & flags) == flags &&
  49             !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) &&
  50             !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
  51                 return true;
  52         return false;
  53 }
  54
  55 struct nfs_delegation *nfs4_get_valid_delegation(const struct inode *inode)
  56 {
  57         struct nfs_delegation *delegation;
  58
  59         delegation = rcu_dereference(NFS_I(inode)->delegation);
  60         if (nfs4_is_valid_delegation(delegation, 0))
  61                 return delegation;
  62         return NULL;
  63 }
  64
  65 static int
  66 nfs4_do_check_delegation(struct inode *inode, fmode_t flags, bool mark)
  67 {
  68         struct nfs_delegation *delegation;
  69         int ret = 0;
  70
  71         flags &= FMODE_READ|FMODE_WRITE;
  72         rcu_read_lock();
  73         delegation = rcu_dereference(NFS_I(inode)->delegation);
  74         if (nfs4_is_valid_delegation(delegation, flags)) {
  75                 if (mark)
  76                         nfs_mark_delegation_referenced(delegation);
  77                 ret = 1;
  78         }
  79         rcu_read_unlock();
  80         return ret;
  81 }
  82 /**
  83  * nfs_have_delegation - check if inode has a delegation, mark it
  84  * NFS_DELEGATION_REFERENCED if there is one.
  85  * @inode: inode to check
  86  * @flags: delegation types to check for
  87  *
  88  * Returns one if inode has the indicated delegation, otherwise zero.
  89  */
  90 int nfs4_have_delegation(struct inode *inode, fmode_t flags)
  91 {
  92         return nfs4_do_check_delegation(inode, flags, true);
  93 }
  94
  95 /*
  96  * nfs4_check_delegation - check if inode has a delegation, do not mark
  97  * NFS_DELEGATION_REFERENCED if it has one.
  98  */
  99 int nfs4_check_delegation(struct inode *inode, fmode_t flags)
 100 {
 101         return nfs4_do_check_delegation(inode, flags, false);
 102 }
 103
 104 static int nfs_delegation_claim_locks(struct nfs4_state *state, const nfs4_stateid *stateid)
 105 {
 106         struct inode *inode = state->inode;
 107         struct file_lock *fl;
 108         struct file_lock_context *flctx = inode->i_flctx;
 109         struct list_head *list;
 110         int status = 0;
 111
 112         if (flctx == NULL)
 113                 goto out;
 114
 115         list = &flctx->flc_posix;
 116         spin_lock(&flctx->flc_lock);
 117 restart:
 118         list_for_each_entry(fl, list, fl_list) {
 119                 if (nfs_file_open_context(fl->fl_file)->state != state)
 120                         continue;
 121                 spin_unlock(&flctx->flc_lock);
 122                 status = nfs4_lock_delegation_recall(fl, state, stateid);
 123                 if (status < 0)
 124                         goto out;
 125                 spin_lock(&flctx->flc_lock);
 126         }
 127         if (list == &flctx->flc_posix) {
 128                 list = &flctx->flc_flock;
 129                 goto restart;
 130         }
 131         spin_unlock(&flctx->flc_lock);
 132 out:
 133         return status;
 134 }
 135
 136 static int nfs_delegation_claim_opens(struct inode *inode,
 137                 const nfs4_stateid *stateid, fmode_t type)
 138 {
 139         struct nfs_inode *nfsi = NFS_I(inode);
 140         struct nfs_open_context *ctx;
 141         struct nfs4_state_owner *sp;
 142         struct nfs4_state *state;
 143         unsigned int seq;
 144         int err;
 145
 146 again:
 147         spin_lock(&inode->i_lock);
 148         list_for_each_entry(ctx, &nfsi->open_files, list) {
 149                 state = ctx->state;
 150                 if (state == NULL)
 151                         continue;
 152                 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
 153                         continue;
 154                 if (!nfs4_valid_open_stateid(state))
 155                         continue;
 156                 if (!nfs4_stateid_match(&state->stateid, stateid))
 157                         continue;
 158                 get_nfs_open_context(ctx);
 159                 spin_unlock(&inode->i_lock);
 160                 sp = state->owner;
 161                 /* Block nfs4_proc_unlck */
 162                 mutex_lock(&sp->so_delegreturn_mutex);
 163                 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
 164                 err = nfs4_open_delegation_recall(ctx, state, stateid, type);
 165                 if (!err)
 166                         err = nfs_delegation_claim_locks(state, stateid);
 167                 if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
 168                         err = -EAGAIN;
 169                 mutex_unlock(&sp->so_delegreturn_mutex);
 170                 put_nfs_open_context(ctx);
 171                 if (err != 0)
 172                         return err;
 173                 goto again;
 174         }
 175         spin_unlock(&inode->i_lock);
 176         return 0;
 177 }
 178
 179 /**
 180  * nfs_inode_reclaim_delegation - process a delegation reclaim request
 181  * @inode: inode to process
 182  * @cred: credential to use for request
 183  * @res: new delegation state from server
 184  *
 185  */
 186 void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
 187                                   struct nfs_openres *res)
 188 {
 189         struct nfs_delegation *delegation;
 190         struct rpc_cred *oldcred = NULL;
 191
 192         rcu_read_lock();
 193         delegation = rcu_dereference(NFS_I(inode)->delegation);
 194         if (delegation != NULL) {
 195                 spin_lock(&delegation->lock);
 196                 if (delegation->inode != NULL) {
 197                         nfs4_stateid_copy(&delegation->stateid, &res->delegation);
 198                         delegation->type = res->delegation_type;
 199                         delegation->pagemod_limit = res->pagemod_limit;
 200                         oldcred = delegation->cred;
 201                         delegation->cred = get_rpccred(cred);
 202                         clear_bit(NFS_DELEGATION_NEED_RECLAIM,
 203                                   &delegation->flags);
 204                         spin_unlock(&delegation->lock);
 205                         rcu_read_unlock();
 206                         put_rpccred(oldcred);
 207                         trace_nfs4_reclaim_delegation(inode, res->delegation_type);
 208                         return;
 209                 }
 210                 /* We appear to have raced with a delegation return. */
 211                 spin_unlock(&delegation->lock);
 212         }
 213         rcu_read_unlock();
 214         nfs_inode_set_delegation(inode, cred, res);
 215 }
 216
 217 static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
 218 {
 219         int res = 0;
 220
 221         if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
 222                 res = nfs4_proc_delegreturn(inode,
 223                                 delegation->cred,
 224                                 &delegation->stateid,
 225                                 issync);
 226         nfs_free_delegation(delegation);
 227         return res;
 228 }
 229
 230 static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
 231 {
 232         struct inode *inode = NULL;
 233
 234         spin_lock(&delegation->lock);
 235         if (delegation->inode != NULL)
 236                 inode = igrab(delegation->inode);
 237         if (!inode)
 238                 set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags);
 239         spin_unlock(&delegation->lock);
 240         return inode;
 241 }
 242
 243 static struct nfs_delegation *
 244 nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
 245 {
 246         struct nfs_delegation *ret = NULL;
 247         struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
 248
 249         if (delegation == NULL)
 250                 goto out;
 251         spin_lock(&delegation->lock);
 252         if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
 253                 ret = delegation;
 254         spin_unlock(&delegation->lock);
 255 out:
 256         return ret;
 257 }
 258
 259 static struct nfs_delegation *
 260 nfs_start_delegation_return(struct nfs_inode *nfsi)
 261 {
 262         struct nfs_delegation *delegation;
 263
 264         rcu_read_lock();
 265         delegation = nfs_start_delegation_return_locked(nfsi);
 266         rcu_read_unlock();
 267         return delegation;
 268 }
 269
 270 static void
 271 nfs_abort_delegation_return(struct nfs_delegation *delegation,
 272                 struct nfs_client *clp)
 273 {
 274
 275         spin_lock(&delegation->lock);
 276         clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
 277         set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
 278         spin_unlock(&delegation->lock);
 279         set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
 280 }
 281
 282 static struct nfs_delegation *
 283 nfs_detach_delegation_locked(struct nfs_inode *nfsi,
 284                 struct nfs_delegation *delegation,
 285                 struct nfs_client *clp)
 286 {
 287         struct nfs_delegation *deleg_cur =
 288                 rcu_dereference_protected(nfsi->delegation,
 289                                 lockdep_is_held(&clp->cl_lock));
 290
 291         if (deleg_cur == NULL || delegation != deleg_cur)
 292                 return NULL;
 293
 294         spin_lock(&delegation->lock);
 295         set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
 296         list_del_rcu(&delegation->super_list);
 297         delegation->inode = NULL;
 298         rcu_assign_pointer(nfsi->delegation, NULL);
 299         spin_unlock(&delegation->lock);
 300         return delegation;
 301 }
 302
 303 static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
 304                 struct nfs_delegation *delegation,
 305                 struct nfs_server *server)
 306 {
 307         struct nfs_client *clp = server->nfs_client;
 308
 309         spin_lock(&clp->cl_lock);
 310         delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
 311         spin_unlock(&clp->cl_lock);
 312         return delegation;
 313 }
 314
 315 static struct nfs_delegation *
 316 nfs_inode_detach_delegation(struct inode *inode)
 317 {
 318         struct nfs_inode *nfsi = NFS_I(inode);
 319         struct nfs_server *server = NFS_SERVER(inode);
 320         struct nfs_delegation *delegation;
 321
 322         delegation = nfs_start_delegation_return(nfsi);
 323         if (delegation == NULL)
 324                 return NULL;
 325         return nfs_detach_delegation(nfsi, delegation, server);
 326 }
 327
 328 static void
 329 nfs_update_inplace_delegation(struct nfs_delegation *delegation,
 330                 const struct nfs_delegation *update)
 331 {
 332         if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) {
 333                 delegation->stateid.seqid = update->stateid.seqid;
 334                 smp_wmb();
 335                 delegation->type = update->type;
 336         }
 337 }
 338
 339 /**
 340  * nfs_inode_set_delegation - set up a delegation on an inode
 341  * @inode: inode to which delegation applies
 342  * @cred: cred to use for subsequent delegation processing
 343  * @res: new delegation state from server
 344  *
 345  * Returns zero on success, or a negative errno value.
 346  */
 347 int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res)
 348 {
 349         struct nfs_server *server = NFS_SERVER(inode);
 350         struct nfs_client *clp = server->nfs_client;
 351         struct nfs_inode *nfsi = NFS_I(inode);
 352         struct nfs_delegation *delegation, *old_delegation;
 353         struct nfs_delegation *freeme = NULL;
 354         int status = 0;
 355
 356         delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
 357         if (delegation == NULL)
 358                 return -ENOMEM;
 359         nfs4_stateid_copy(&delegation->stateid, &res->delegation);
 360         delegation->type = res->delegation_type;
 361         delegation->pagemod_limit = res->pagemod_limit;
 362         delegation->change_attr = inode->i_version;
 363         delegation->cred = get_rpccred(cred);
 364         delegation->inode = inode;
 365         delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
 366         spin_lock_init(&delegation->lock);
 367
 368         spin_lock(&clp->cl_lock);
 369         old_delegation = rcu_dereference_protected(nfsi->delegation,
 370                                         lockdep_is_held(&clp->cl_lock));
 371         if (old_delegation != NULL) {
 372                 /* Is this an update of the existing delegation? */
 373                 if (nfs4_stateid_match_other(&old_delegation->stateid,
 374                                         &delegation->stateid)) {
 375                         nfs_update_inplace_delegation(old_delegation,
 376                                         delegation);
 377                         goto out;
 378                 }
 379                 /*
 380                  * Deal with broken servers that hand out two
 381                  * delegations for the same file.
 382                  * Allow for upgrades to a WRITE delegation, but
 383                  * nothing else.
 384                  */
 385                 dfprintk(FILE, "%s: server %s handed out "
 386                                 "a duplicate delegation!\n",
 387                                 __func__, clp->cl_hostname);
 388                 if (delegation->type == old_delegation->type ||
 389                     !(delegation->type & FMODE_WRITE)) {
 390                         freeme = delegation;
 391                         delegation = NULL;
 392                         goto out;
 393                 }
 394                 if (test_and_set_bit(NFS_DELEGATION_RETURNING,
 395                                         &old_delegation->flags))
 396                         goto out;
 397                 freeme = nfs_detach_delegation_locked(nfsi,
 398                                 old_delegation, clp);
 399                 if (freeme == NULL)
 400                         goto out;
 401         }
 402         list_add_tail_rcu(&delegation->super_list, &server->delegations);
 403         rcu_assign_pointer(nfsi->delegation, delegation);
 404         delegation = NULL;
 405
 406         trace_nfs4_set_delegation(inode, res->delegation_type);
 407
 408 out:
 409         spin_unlock(&clp->cl_lock);
 410         if (delegation != NULL)
 411                 nfs_free_delegation(delegation);
 412         if (freeme != NULL)
 413                 nfs_do_return_delegation(inode, freeme, 0);
 414         return status;
 415 }
 416
 417 /*
 418  * Basic procedure for returning a delegation to the server
 419  */
 420 static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
 421 {
 422         struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
 423         struct nfs_inode *nfsi = NFS_I(inode);
 424         int err = 0;
 425
 426         if (delegation == NULL)
 427                 return 0;
 428         do {
 429                 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
 430                         break;
 431                 err = nfs_delegation_claim_opens(inode, &delegation->stateid,
 432                                 delegation->type);
 433                 if (!issync || err != -EAGAIN)
 434                         break;
 435                 /*
 436                  * Guard against state recovery
 437                  */
 438                 err = nfs4_wait_clnt_recover(clp);
 439         } while (err == 0);
 440
 441         if (err) {
 442                 nfs_abort_delegation_return(delegation, clp);
 443                 goto out;
 444         }
 445         if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
 446                 goto out;
 447
 448         err = nfs_do_return_delegation(inode, delegation, issync);
 449 out:
 450         return err;
 451 }
 452
 453 static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
 454 {
 455         bool ret = false;
 456
 457         if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
 458                 goto out;
 459         if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
 460                 ret = true;
 461         if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
 462                 struct inode *inode;
 463
 464                 spin_lock(&delegation->lock);
 465                 inode = delegation->inode;
 466                 if (inode && list_empty(&NFS_I(inode)->open_files))
 467                         ret = true;
 468                 spin_unlock(&delegation->lock);
 469         }
 470 out:
 471         return ret;
 472 }
 473
 474 /**
 475  * nfs_client_return_marked_delegations - return previously marked delegations
 476  * @clp: nfs_client to process
 477  *
 478  * Note that this function is designed to be called by the state
 479  * manager thread. For this reason, it cannot flush the dirty data,
 480  * since that could deadlock in case of a state recovery error.
 481  *
 482  * Returns zero on success, or a negative errno value.
 483  */
 484 int nfs_client_return_marked_delegations(struct nfs_client *clp)
 485 {
 486         struct nfs_delegation *delegation;
 487         struct nfs_server *server;
 488         struct inode *inode;
 489         int err = 0;
 490
 491 restart:
 492         rcu_read_lock();
 493         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 494                 list_for_each_entry_rcu(delegation, &server->delegations,
 495                                                                 super_list) {
 496                         if (!nfs_delegation_need_return(delegation))
 497                                 continue;
 498                         if (!nfs_sb_active(server->super))
 499                                 continue;
 500                         inode = nfs_delegation_grab_inode(delegation);
 501                         if (inode == NULL) {
 502                                 rcu_read_unlock();
 503                                 nfs_sb_deactive(server->super);
 504                                 goto restart;
 505                         }
 506                         delegation = nfs_start_delegation_return_locked(NFS_I(inode));
 507                         rcu_read_unlock();
 508
 509                         err = nfs_end_delegation_return(inode, delegation, 0);
 510                         iput(inode);
 511                         nfs_sb_deactive(server->super);
 512                         if (!err)
 513                                 goto restart;
 514                         set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
 515                         return err;
 516                 }
 517         }
 518         rcu_read_unlock();
 519         return 0;
 520 }
 521
 522 /**
 523  * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
 524  * @inode: inode to process
 525  *
 526  * Does not protect against delegation reclaims, therefore really only safe
 527  * to be called from nfs4_clear_inode().
 528  */
 529 void nfs_inode_return_delegation_noreclaim(struct inode *inode)
 530 {
 531         struct nfs_delegation *delegation;
 532
 533         delegation = nfs_inode_detach_delegation(inode);
 534         if (delegation != NULL)
 535                 nfs_do_return_delegation(inode, delegation, 1);
 536 }
 537
 538 /**
 539  * nfs_inode_return_delegation - synchronously return a delegation
 540  * @inode: inode to process
 541  *
 542  * This routine will always flush any dirty data to disk on the
 543  * assumption that if we need to return the delegation, then
 544  * we should stop caching.
 545  *
 546  * Returns zero on success, or a negative errno value.
 547  */
 548 int nfs4_inode_return_delegation(struct inode *inode)
 549 {
 550         struct nfs_inode *nfsi = NFS_I(inode);
 551         struct nfs_delegation *delegation;
 552         int err = 0;
 553
 554         nfs_wb_all(inode);
 555         delegation = nfs_start_delegation_return(nfsi);
 556         if (delegation != NULL)
 557                 err = nfs_end_delegation_return(inode, delegation, 1);
 558         return err;
 559 }
 560
 561 static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
 562                 struct nfs_delegation *delegation)
 563 {
 564         set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
 565         set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
 566 }
 567
 568 static void nfs_mark_return_delegation(struct nfs_server *server,
 569                 struct nfs_delegation *delegation)
 570 {
 571         set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
 572         set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
 573 }
 574
 575 static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
 576 {
 577         struct nfs_delegation *delegation;
 578         bool ret = false;
 579
 580         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 581                 nfs_mark_return_delegation(server, delegation);
 582                 ret = true;
 583         }
 584         return ret;
 585 }
 586
 587 static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
 588 {
 589         struct nfs_server *server;
 590
 591         rcu_read_lock();
 592         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 593                 nfs_server_mark_return_all_delegations(server);
 594         rcu_read_unlock();
 595 }
 596
 597 static void nfs_delegation_run_state_manager(struct nfs_client *clp)
 598 {
 599         if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
 600                 nfs4_schedule_state_manager(clp);
 601 }
 602
 603 /**
 604  * nfs_expire_all_delegations
 605  * @clp: client to process
 606  *
 607  */
 608 void nfs_expire_all_delegations(struct nfs_client *clp)
 609 {
 610         nfs_client_mark_return_all_delegations(clp);
 611         nfs_delegation_run_state_manager(clp);
 612 }
 613
 614 /**
 615  * nfs_super_return_all_delegations - return delegations for one superblock
 616  * @sb: sb to process
 617  *
 618  */
 619 void nfs_server_return_all_delegations(struct nfs_server *server)
 620 {
 621         struct nfs_client *clp = server->nfs_client;
 622         bool need_wait;
 623
 624         if (clp == NULL)
 625                 return;
 626
 627         rcu_read_lock();
 628         need_wait = nfs_server_mark_return_all_delegations(server);
 629         rcu_read_unlock();
 630
 631         if (need_wait) {
 632                 nfs4_schedule_state_manager(clp);
 633                 nfs4_wait_clnt_recover(clp);
 634         }
 635 }
 636
 637 static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
 638                                                  fmode_t flags)
 639 {
 640         struct nfs_delegation *delegation;
 641
 642         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 643                 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
 644                         continue;
 645                 if (delegation->type & flags)
 646                         nfs_mark_return_if_closed_delegation(server, delegation);
 647         }
 648 }
 649
 650 static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
 651                                                         fmode_t flags)
 652 {
 653         struct nfs_server *server;
 654
 655         rcu_read_lock();
 656         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 657                 nfs_mark_return_unused_delegation_types(server, flags);
 658         rcu_read_unlock();
 659 }
 660
 661 static void nfs_mark_delegation_revoked(struct nfs_server *server,
 662                 struct nfs_delegation *delegation)
 663 {
 664         set_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
 665         delegation->stateid.type = NFS4_INVALID_STATEID_TYPE;
 666         nfs_mark_return_delegation(server, delegation);
 667 }
 668
 669 static bool nfs_revoke_delegation(struct inode *inode,
 670                 const nfs4_stateid *stateid)
 671 {
 672         struct nfs_delegation *delegation;
 673         nfs4_stateid tmp;
 674         bool ret = false;
 675
 676         rcu_read_lock();
 677         delegation = rcu_dereference(NFS_I(inode)->delegation);
 678         if (delegation == NULL)
 679                 goto out;
 680         if (stateid == NULL) {
 681                 nfs4_stateid_copy(&tmp, &delegation->stateid);
 682                 stateid = &tmp;
 683         } else if (!nfs4_stateid_match(stateid, &delegation->stateid))
 684                 goto out;
 685         nfs_mark_delegation_revoked(NFS_SERVER(inode), delegation);
 686         ret = true;
 687 out:
 688         rcu_read_unlock();
 689         if (ret)
 690                 nfs_inode_find_state_and_recover(inode, stateid);
 691         return ret;
 692 }
 693
 694 void nfs_remove_bad_delegation(struct inode *inode,
 695                 const nfs4_stateid *stateid)
 696 {
 697         struct nfs_delegation *delegation;
 698
 699         if (!nfs_revoke_delegation(inode, stateid))
 700                 return;
 701         delegation = nfs_inode_detach_delegation(inode);
 702         if (delegation)
 703                 nfs_free_delegation(delegation);
 704 }
 705 EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
 706
 707 /**
 708  * nfs_expire_unused_delegation_types
 709  * @clp: client to process
 710  * @flags: delegation types to expire
 711  *
 712  */
 713 void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
 714 {
 715         nfs_client_mark_return_unused_delegation_types(clp, flags);
 716         nfs_delegation_run_state_manager(clp);
 717 }
 718
 719 static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
 720 {
 721         struct nfs_delegation *delegation;
 722
 723         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 724                 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
 725                         continue;
 726                 nfs_mark_return_if_closed_delegation(server, delegation);
 727         }
 728 }
 729
 730 /**
 731  * nfs_expire_unreferenced_delegations - Eliminate unused delegations
 732  * @clp: nfs_client to process
 733  *
 734  */
 735 void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
 736 {
 737         struct nfs_server *server;
 738
 739         rcu_read_lock();
 740         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 741                 nfs_mark_return_unreferenced_delegations(server);
 742         rcu_read_unlock();
 743
 744         nfs_delegation_run_state_manager(clp);
 745 }
 746
 747 /**
 748  * nfs_async_inode_return_delegation - asynchronously return a delegation
 749  * @inode: inode to process
 750  * @stateid: state ID information
 751  *
 752  * Returns zero on success, or a negative errno value.
 753  */
 754 int nfs_async_inode_return_delegation(struct inode *inode,
 755                                       const nfs4_stateid *stateid)
 756 {
 757         struct nfs_server *server = NFS_SERVER(inode);
 758         struct nfs_client *clp = server->nfs_client;
 759         struct nfs_delegation *delegation;
 760
 761         rcu_read_lock();
 762         delegation = rcu_dereference(NFS_I(inode)->delegation);
 763         if (delegation == NULL)
 764                 goto out_enoent;
 765         if (stateid != NULL &&
 766             !clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
 767                 goto out_enoent;
 768         nfs_mark_return_delegation(server, delegation);
 769         rcu_read_unlock();
 770
 771         nfs_delegation_run_state_manager(clp);
 772         return 0;
 773 out_enoent:
 774         rcu_read_unlock();
 775         return -ENOENT;
 776 }
 777
 778 static struct inode *
 779 nfs_delegation_find_inode_server(struct nfs_server *server,
 780                                  const struct nfs_fh *fhandle)
 781 {
 782         struct nfs_delegation *delegation;
 783         struct inode *res = NULL;
 784
 785         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 786                 spin_lock(&delegation->lock);
 787                 if (delegation->inode != NULL &&
 788                     nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
 789                         res = igrab(delegation->inode);
 790                 }
 791                 spin_unlock(&delegation->lock);
 792                 if (res != NULL)
 793                         break;
 794         }
 795         return res;
 796 }
 797
 798 /**
 799  * nfs_delegation_find_inode - retrieve the inode associated with a delegation
 800  * @clp: client state handle
 801  * @fhandle: filehandle from a delegation recall
 802  *
 803  * Returns pointer to inode matching "fhandle," or NULL if a matching inode
 804  * cannot be found.
 805  */
 806 struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
 807                                         const struct nfs_fh *fhandle)
 808 {
 809         struct nfs_server *server;
 810         struct inode *res = NULL;
 811
 812         rcu_read_lock();
 813         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 814                 res = nfs_delegation_find_inode_server(server, fhandle);
 815                 if (res != NULL)
 816                         break;
 817         }
 818         rcu_read_unlock();
 819         return res;
 820 }
 821
 822 static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
 823 {
 824         struct nfs_delegation *delegation;
 825
 826         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 827                 /*
 828                  * If the delegation may have been admin revoked, then we
 829                  * cannot reclaim it.
 830                  */
 831                 if (test_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags))
 832                         continue;
 833                 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
 834         }
 835 }
 836
 837 /**
 838  * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
 839  * @clp: nfs_client to process
 840  *
 841  */
 842 void nfs_delegation_mark_reclaim(struct nfs_client *clp)
 843 {
 844         struct nfs_server *server;
 845
 846         rcu_read_lock();
 847         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 848                 nfs_delegation_mark_reclaim_server(server);
 849         rcu_read_unlock();
 850 }
 851
 852 /**
 853  * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
 854  * @clp: nfs_client to process
 855  *
 856  */
 857 void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
 858 {
 859         struct nfs_delegation *delegation;
 860         struct nfs_server *server;
 861         struct inode *inode;
 862
 863 restart:
 864         rcu_read_lock();
 865         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 866                 list_for_each_entry_rcu(delegation, &server->delegations,
 867                                                                 super_list) {
 868                         if (test_bit(NFS_DELEGATION_INODE_FREEING,
 869                                                 &delegation->flags) ||
 870                             test_bit(NFS_DELEGATION_RETURNING,
 871                                                 &delegation->flags) ||
 872                             test_bit(NFS_DELEGATION_NEED_RECLAIM,
 873                                                 &delegation->flags) == 0)
 874                                 continue;
 875                         if (!nfs_sb_active(server->super))
 876                                 continue;
 877                         inode = nfs_delegation_grab_inode(delegation);
 878                         if (inode == NULL) {
 879                                 rcu_read_unlock();
 880                                 nfs_sb_deactive(server->super);
 881                                 goto restart;
 882                         }
 883                         delegation = nfs_start_delegation_return_locked(NFS_I(inode));
 884                         rcu_read_unlock();
 885                         if (delegation != NULL) {
 886                                 delegation = nfs_detach_delegation(NFS_I(inode),
 887                                         delegation, server);
 888                                 if (delegation != NULL)
 889                                         nfs_free_delegation(delegation);
 890                         }
 891                         iput(inode);
 892                         nfs_sb_deactive(server->super);
 893                         goto restart;
 894                 }
 895         }
 896         rcu_read_unlock();
 897 }
 898
 899 static inline bool nfs4_server_rebooted(const struct nfs_client *clp)
 900 {
 901         return (clp->cl_state & (BIT(NFS4CLNT_CHECK_LEASE) |
 902                                 BIT(NFS4CLNT_LEASE_EXPIRED) |
 903                                 BIT(NFS4CLNT_SESSION_RESET))) != 0;
 904 }
 905
 906 static void nfs_mark_test_expired_delegation(struct nfs_server *server,
 907             struct nfs_delegation *delegation)
 908 {
 909         if (delegation->stateid.type == NFS4_INVALID_STATEID_TYPE)
 910                 return;
 911         clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
 912         set_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
 913         set_bit(NFS4CLNT_DELEGATION_EXPIRED, &server->nfs_client->cl_state);
 914 }
 915
 916 static void nfs_inode_mark_test_expired_delegation(struct nfs_server *server,
 917                 struct inode *inode)
 918 {
 919         struct nfs_delegation *delegation;
 920
 921         rcu_read_lock();
 922         delegation = rcu_dereference(NFS_I(inode)->delegation);
 923         if (delegation)
 924                 nfs_mark_test_expired_delegation(server, delegation);
 925         rcu_read_unlock();
 926
 927 }
 928
 929 static void nfs_delegation_mark_test_expired_server(struct nfs_server *server)
 930 {
 931         struct nfs_delegation *delegation;
 932
 933         list_for_each_entry_rcu(delegation, &server->delegations, super_list)
 934                 nfs_mark_test_expired_delegation(server, delegation);
 935 }
 936
 937 /**
 938  * nfs_mark_test_expired_all_delegations - mark all delegations for testing
 939  * @clp: nfs_client to process
 940  *
 941  * Iterates through all the delegations associated with this server and
 942  * marks them as needing to be checked for validity.
 943  */
 944 void nfs_mark_test_expired_all_delegations(struct nfs_client *clp)
 945 {
 946         struct nfs_server *server;
 947
 948         rcu_read_lock();
 949         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 950                 nfs_delegation_mark_test_expired_server(server);
 951         rcu_read_unlock();
 952 }
 953
 954 /**
 955  * nfs_reap_expired_delegations - reap expired delegations
 956  * @clp: nfs_client to process
 957  *
 958  * Iterates through all the delegations associated with this server and
 959  * checks if they have may have been revoked. This function is usually
 960  * expected to be called in cases where the server may have lost its
 961  * lease.
 962  */
 963 void nfs_reap_expired_delegations(struct nfs_client *clp)
 964 {
 965         const struct nfs4_minor_version_ops *ops = clp->cl_mvops;
 966         struct nfs_delegation *delegation;
 967         struct nfs_server *server;
 968         struct inode *inode;
 969         struct rpc_cred *cred;
 970         nfs4_stateid stateid;
 971
 972 restart:
 973         rcu_read_lock();
 974         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 975                 list_for_each_entry_rcu(delegation, &server->delegations,
 976                                                                 super_list) {
 977                         if (test_bit(NFS_DELEGATION_INODE_FREEING,
 978                                                 &delegation->flags) ||
 979                             test_bit(NFS_DELEGATION_RETURNING,
 980                                                 &delegation->flags) ||
 981                             test_bit(NFS_DELEGATION_TEST_EXPIRED,
 982                                                 &delegation->flags) == 0)
 983                                 continue;
 984                         if (!nfs_sb_active(server->super))
 985                                 continue;
 986                         inode = nfs_delegation_grab_inode(delegation);
 987                         if (inode == NULL) {
 988                                 rcu_read_unlock();
 989                                 nfs_sb_deactive(server->super);
 990                                 goto restart;
 991                         }
 992                         cred = get_rpccred_rcu(delegation->cred);
 993                         nfs4_stateid_copy(&stateid, &delegation->stateid);
 994                         clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
 995                         rcu_read_unlock();
 996                         if (cred != NULL &&
 997                             ops->test_and_free_expired(server, &stateid, cred) < 0) {
 998                                 nfs_revoke_delegation(inode, &stateid);
 999                                 nfs_inode_find_state_and_recover(inode, &stateid);
1000                         }
1001                         put_rpccred(cred);
1002                         if (nfs4_server_rebooted(clp)) {
1003                                 nfs_inode_mark_test_expired_delegation(server,inode);
1004                                 iput(inode);
1005                                 nfs_sb_deactive(server->super);
1006                                 return;
1007                         }
1008                         iput(inode);
1009                         nfs_sb_deactive(server->super);
1010                         goto restart;
1011                 }
1012         }
1013         rcu_read_unlock();
1014 }
1015
1016 void nfs_inode_find_delegation_state_and_recover(struct inode *inode,
1017                 const nfs4_stateid *stateid)
1018 {
1019         struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1020         struct nfs_delegation *delegation;
1021         bool found = false;
1022
1023         rcu_read_lock();
1024         delegation = rcu_dereference(NFS_I(inode)->delegation);
1025         if (delegation &&
1026             nfs4_stateid_match_other(&delegation->stateid, stateid)) {
1027                 nfs_mark_test_expired_delegation(NFS_SERVER(inode), delegation);
1028                 found = true;
1029         }
1030         rcu_read_unlock();
1031         if (found)
1032                 nfs4_schedule_state_manager(clp);
1033 }
1034
1035 /**
1036  * nfs_delegations_present - check for existence of delegations
1037  * @clp: client state handle
1038  *
1039  * Returns one if there are any nfs_delegation structures attached
1040  * to this nfs_client.
1041  */
1042 int nfs_delegations_present(struct nfs_client *clp)
1043 {
1044         struct nfs_server *server;
1045         int ret = 0;
1046
1047         rcu_read_lock();
1048         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1049                 if (!list_empty(&server->delegations)) {
1050                         ret = 1;
1051                         break;
1052                 }
1053         rcu_read_unlock();
1054         return ret;
1055 }
1056
1057 /**
1058  * nfs4_copy_delegation_stateid - Copy inode's state ID information
1059  * @inode: inode to check
1060  * @flags: delegation type requirement
1061  * @dst: stateid data structure to fill in
1062  * @cred: optional argument to retrieve credential
1063  *
1064  * Returns "true" and fills in "dst->data" * if inode had a delegation,
1065  * otherwise "false" is returned.
1066  */
1067 bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
1068                 nfs4_stateid *dst, struct rpc_cred **cred)
1069 {
1070         struct nfs_inode *nfsi = NFS_I(inode);
1071         struct nfs_delegation *delegation;
1072         bool ret;
1073
1074         flags &= FMODE_READ|FMODE_WRITE;
1075         rcu_read_lock();
1076         delegation = rcu_dereference(nfsi->delegation);
1077         ret = nfs4_is_valid_delegation(delegation, flags);
1078         if (ret) {
1079                 nfs4_stateid_copy(dst, &delegation->stateid);
1080                 nfs_mark_delegation_referenced(delegation);
1081                 if (cred)
1082                         *cred = get_rpccred(delegation->cred);
1083         }
1084         rcu_read_unlock();
1085         return ret;
1086 }
1087
1088 /**
1089  * nfs4_delegation_flush_on_close - Check if we must flush file on close
1090  * @inode: inode to check
1091  *
1092  * This function checks the number of outstanding writes to the file
1093  * against the delegation 'space_limit' field to see if
1094  * the spec requires us to flush the file on close.
1095  */
1096 bool nfs4_delegation_flush_on_close(const struct inode *inode)
1097 {
1098         struct nfs_inode *nfsi = NFS_I(inode);
1099         struct nfs_delegation *delegation;
1100         bool ret = true;
1101
1102         rcu_read_lock();
1103         delegation = rcu_dereference(nfsi->delegation);
1104         if (delegation == NULL || !(delegation->type & FMODE_WRITE))
1105                 goto out;
1106         if (atomic_long_read(&nfsi->nrequests) < delegation->pagemod_limit)
1107                 ret = false;
1108 out:
1109         rcu_read_unlock();
1110         return ret;
1111 }