1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * linux/fs/nfs/delegation.c
   4 *
   5 * Copyright (C) 2004 Trond Myklebust
   6 *
   7 * NFS file delegation management
   8 *
   9 */
  10#include <linux/completion.h>
  11#include <linux/kthread.h>
  12#include <linux/module.h>
  13#include <linux/sched.h>
  14#include <linux/slab.h>
  15#include <linux/spinlock.h>
  16#include <linux/iversion.h>
  17
  18#include <linux/nfs4.h>
  19#include <linux/nfs_fs.h>
  20#include <linux/nfs_xdr.h>
  21
  22#include "nfs4_fs.h"
  23#include "nfs4session.h"
  24#include "delegation.h"
  25#include "internal.h"
  26#include "nfs4trace.h"
  27
  28#define NFS_DEFAULT_DELEGATION_WATERMARK (5000U)
  29
  30static atomic_long_t nfs_active_delegations;
  31static unsigned nfs_delegation_watermark = NFS_DEFAULT_DELEGATION_WATERMARK;
  32
  33static void __nfs_free_delegation(struct nfs_delegation *delegation)
  34{
  35	put_cred(delegation->cred);
  36	delegation->cred = NULL;
  37	kfree_rcu(delegation, rcu);
  38}
  39
  40static void nfs_mark_delegation_revoked(struct nfs_delegation *delegation)
  41{
  42	if (!test_and_set_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
  43		delegation->stateid.type = NFS4_INVALID_STATEID_TYPE;
  44		atomic_long_dec(&nfs_active_delegations);
  45		if (!test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
  46			nfs_clear_verifier_delegated(delegation->inode);
  47	}
  48}
  49
  50static struct nfs_delegation *nfs_get_delegation(struct nfs_delegation *delegation)
  51{
  52	refcount_inc(&delegation->refcount);
  53	return delegation;
  54}
  55
  56static void nfs_put_delegation(struct nfs_delegation *delegation)
  57{
  58	if (refcount_dec_and_test(&delegation->refcount))
  59		__nfs_free_delegation(delegation);
  60}
  61
  62static void nfs_free_delegation(struct nfs_delegation *delegation)
  63{
  64	nfs_mark_delegation_revoked(delegation);
  65	nfs_put_delegation(delegation);
  66}
  67
  68/**
  69 * nfs_mark_delegation_referenced - set delegation's REFERENCED flag
  70 * @delegation: delegation to process
  71 *
  72 */
  73void nfs_mark_delegation_referenced(struct nfs_delegation *delegation)
  74{
  75	set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags);
  76}
  77
  78static void nfs_mark_return_delegation(struct nfs_server *server,
  79				       struct nfs_delegation *delegation)
  80{
  81	set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
  82	set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
  83}
  84
  85static bool
  86nfs4_is_valid_delegation(const struct nfs_delegation *delegation,
  87		fmode_t flags)
  88{
  89	if (delegation != NULL && (delegation->type & flags) == flags &&
  90	    !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) &&
  91	    !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
  92		return true;
  93	return false;
  94}
  95
  96struct nfs_delegation *nfs4_get_valid_delegation(const struct inode *inode)
  97{
  98	struct nfs_delegation *delegation;
  99
 100	delegation = rcu_dereference(NFS_I(inode)->delegation);
 101	if (nfs4_is_valid_delegation(delegation, 0))
 102		return delegation;
 103	return NULL;
 104}
 105
 106static int
 107nfs4_do_check_delegation(struct inode *inode, fmode_t flags, bool mark)
 108{
 109	struct nfs_delegation *delegation;
 110	int ret = 0;
 111
 112	flags &= FMODE_READ|FMODE_WRITE;
 113	rcu_read_lock();
 114	delegation = rcu_dereference(NFS_I(inode)->delegation);
 115	if (nfs4_is_valid_delegation(delegation, flags)) {
 116		if (mark)
 117			nfs_mark_delegation_referenced(delegation);
 118		ret = 1;
 119	}
 120	rcu_read_unlock();
 121	return ret;
 122}
 123/**
 124 * nfs4_have_delegation - check if inode has a delegation, mark it
 125 * NFS_DELEGATION_REFERENCED if there is one.
 126 * @inode: inode to check
 127 * @flags: delegation types to check for
 128 *
 129 * Returns one if inode has the indicated delegation, otherwise zero.
 130 */
 131int nfs4_have_delegation(struct inode *inode, fmode_t flags)
 132{
 133	return nfs4_do_check_delegation(inode, flags, true);
 134}
 135
 136/*
 137 * nfs4_check_delegation - check if inode has a delegation, do not mark
 138 * NFS_DELEGATION_REFERENCED if it has one.
 139 */
 140int nfs4_check_delegation(struct inode *inode, fmode_t flags)
 141{
 142	return nfs4_do_check_delegation(inode, flags, false);
 143}
 144
 145static int nfs_delegation_claim_locks(struct nfs4_state *state, const nfs4_stateid *stateid)
 146{
 147	struct inode *inode = state->inode;
 148	struct file_lock *fl;
 149	struct file_lock_context *flctx = inode->i_flctx;
 150	struct list_head *list;
 151	int status = 0;
 152
 153	if (flctx == NULL)
 154		goto out;
 155
 156	list = &flctx->flc_posix;
 157	spin_lock(&flctx->flc_lock);
 158restart:
 159	list_for_each_entry(fl, list, fl_list) {
 160		if (nfs_file_open_context(fl->fl_file)->state != state)
 161			continue;
 162		spin_unlock(&flctx->flc_lock);
 163		status = nfs4_lock_delegation_recall(fl, state, stateid);
 164		if (status < 0)
 165			goto out;
 166		spin_lock(&flctx->flc_lock);
 167	}
 168	if (list == &flctx->flc_posix) {
 169		list = &flctx->flc_flock;
 170		goto restart;
 171	}
 172	spin_unlock(&flctx->flc_lock);
 173out:
 174	return status;
 175}
 176
 177static int nfs_delegation_claim_opens(struct inode *inode,
 178		const nfs4_stateid *stateid, fmode_t type)
 179{
 180	struct nfs_inode *nfsi = NFS_I(inode);
 181	struct nfs_open_context *ctx;
 182	struct nfs4_state_owner *sp;
 183	struct nfs4_state *state;
 184	unsigned int seq;
 185	int err;
 186
 187again:
 188	rcu_read_lock();
 189	list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
 190		state = ctx->state;
 191		if (state == NULL)
 192			continue;
 193		if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
 194			continue;
 195		if (!nfs4_valid_open_stateid(state))
 196			continue;
 197		if (!nfs4_stateid_match(&state->stateid, stateid))
 198			continue;
 199		if (!get_nfs_open_context(ctx))
 200			continue;
 201		rcu_read_unlock();
 202		sp = state->owner;
 203		/* Block nfs4_proc_unlck */
 204		mutex_lock(&sp->so_delegreturn_mutex);
 205		seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
 206		err = nfs4_open_delegation_recall(ctx, state, stateid);
 207		if (!err)
 208			err = nfs_delegation_claim_locks(state, stateid);
 209		if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
 210			err = -EAGAIN;
 211		mutex_unlock(&sp->so_delegreturn_mutex);
 212		put_nfs_open_context(ctx);
 213		if (err != 0)
 214			return err;
 215		goto again;
 216	}
 217	rcu_read_unlock();
 218	return 0;
 219}
 220
 221/**
 222 * nfs_inode_reclaim_delegation - process a delegation reclaim request
 223 * @inode: inode to process
 224 * @cred: credential to use for request
 225 * @type: delegation type
 226 * @stateid: delegation stateid
 227 * @pagemod_limit: write delegation "space_limit"
 228 *
 229 */
 230void nfs_inode_reclaim_delegation(struct inode *inode, const struct cred *cred,
 231				  fmode_t type,
 232				  const nfs4_stateid *stateid,
 233				  unsigned long pagemod_limit)
 234{
 235	struct nfs_delegation *delegation;
 236	const struct cred *oldcred = NULL;
 237
 238	rcu_read_lock();
 239	delegation = rcu_dereference(NFS_I(inode)->delegation);
 240	if (delegation != NULL) {
 241		spin_lock(&delegation->lock);
 242		if (nfs4_is_valid_delegation(delegation, 0)) {
 243			nfs4_stateid_copy(&delegation->stateid, stateid);
 244			delegation->type = type;
 245			delegation->pagemod_limit = pagemod_limit;
 246			oldcred = delegation->cred;
 247			delegation->cred = get_cred(cred);
 248			clear_bit(NFS_DELEGATION_NEED_RECLAIM,
 249				  &delegation->flags);
 250			spin_unlock(&delegation->lock);
 251			rcu_read_unlock();
 252			put_cred(oldcred);
 253			trace_nfs4_reclaim_delegation(inode, type);
 254			return;
 255		}
 256		/* We appear to have raced with a delegation return. */
 257		spin_unlock(&delegation->lock);
 
 
 
 
 
 
 
 258	}
 259	rcu_read_unlock();
 260	nfs_inode_set_delegation(inode, cred, type, stateid, pagemod_limit);
 261}
 262
 263static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
 264{
 265	const struct cred *cred;
 266	int res = 0;
 267
 268	if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
 269		spin_lock(&delegation->lock);
 270		cred = get_cred(delegation->cred);
 271		spin_unlock(&delegation->lock);
 272		res = nfs4_proc_delegreturn(inode, cred,
 273				&delegation->stateid,
 274				issync);
 275		put_cred(cred);
 276	}
 277	return res;
 278}
 279
 280static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
 281{
 282	struct inode *inode = NULL;
 283
 284	spin_lock(&delegation->lock);
 285	if (delegation->inode != NULL)
 286		inode = igrab(delegation->inode);
 287	if (!inode)
 288		set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags);
 289	spin_unlock(&delegation->lock);
 290	return inode;
 291}
 292
 293static struct nfs_delegation *
 294nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
 295{
 296	struct nfs_delegation *ret = NULL;
 297	struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
 298
 299	if (delegation == NULL)
 300		goto out;
 301	spin_lock(&delegation->lock);
 302	if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
 303		clear_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags);
 304		/* Refcount matched in nfs_end_delegation_return() */
 305		ret = nfs_get_delegation(delegation);
 306	}
 307	spin_unlock(&delegation->lock);
 308	if (ret)
 309		nfs_clear_verifier_delegated(&nfsi->vfs_inode);
 310out:
 311	return ret;
 312}
 313
 314static struct nfs_delegation *
 315nfs_start_delegation_return(struct nfs_inode *nfsi)
 316{
 317	struct nfs_delegation *delegation;
 318
 319	rcu_read_lock();
 320	delegation = nfs_start_delegation_return_locked(nfsi);
 321	rcu_read_unlock();
 322	return delegation;
 323}
 324
 325static void nfs_abort_delegation_return(struct nfs_delegation *delegation,
 326					struct nfs_client *clp, int err)
 327{
 328
 329	spin_lock(&delegation->lock);
 330	clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
 331	if (err == -EAGAIN) {
 332		set_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags);
 333		set_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state);
 334	}
 335	spin_unlock(&delegation->lock);
 336}
 337
 338static struct nfs_delegation *
 339nfs_detach_delegation_locked(struct nfs_inode *nfsi,
 340		struct nfs_delegation *delegation,
 341		struct nfs_client *clp)
 342{
 343	struct nfs_delegation *deleg_cur =
 344		rcu_dereference_protected(nfsi->delegation,
 345				lockdep_is_held(&clp->cl_lock));
 346
 347	if (deleg_cur == NULL || delegation != deleg_cur)
 348		return NULL;
 349
 350	spin_lock(&delegation->lock);
 351	if (!delegation->inode) {
 352		spin_unlock(&delegation->lock);
 353		return NULL;
 354	}
 355	list_del_rcu(&delegation->super_list);
 356	delegation->inode = NULL;
 357	rcu_assign_pointer(nfsi->delegation, NULL);
 358	spin_unlock(&delegation->lock);
 359	return delegation;
 360}
 361
 362static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
 363		struct nfs_delegation *delegation,
 364		struct nfs_server *server)
 365{
 366	struct nfs_client *clp = server->nfs_client;
 367
 368	spin_lock(&clp->cl_lock);
 369	delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
 370	spin_unlock(&clp->cl_lock);
 371	return delegation;
 372}
 373
 374static struct nfs_delegation *
 375nfs_inode_detach_delegation(struct inode *inode)
 376{
 377	struct nfs_inode *nfsi = NFS_I(inode);
 378	struct nfs_server *server = NFS_SERVER(inode);
 379	struct nfs_delegation *delegation;
 380
 381	rcu_read_lock();
 382	delegation = rcu_dereference(nfsi->delegation);
 383	if (delegation != NULL)
 384		delegation = nfs_detach_delegation(nfsi, delegation, server);
 385	rcu_read_unlock();
 386	return delegation;
 387}
 388
 389static void
 390nfs_update_delegation_cred(struct nfs_delegation *delegation,
 391		const struct cred *cred)
 392{
 393	const struct cred *old;
 394
 395	if (cred_fscmp(delegation->cred, cred) != 0) {
 396		old = xchg(&delegation->cred, get_cred(cred));
 397		put_cred(old);
 398	}
 399}
 400
 401static void
 402nfs_update_inplace_delegation(struct nfs_delegation *delegation,
 403		const struct nfs_delegation *update)
 404{
 405	if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) {
 406		delegation->stateid.seqid = update->stateid.seqid;
 407		smp_wmb();
 408		delegation->type = update->type;
 409		delegation->pagemod_limit = update->pagemod_limit;
 410		if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
 411			delegation->change_attr = update->change_attr;
 412			nfs_update_delegation_cred(delegation, update->cred);
 413			/* smp_mb__before_atomic() is implicit due to xchg() */
 414			clear_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
 415			atomic_long_inc(&nfs_active_delegations);
 416		}
 417	}
 418}
 419
 420/**
 421 * nfs_inode_set_delegation - set up a delegation on an inode
 422 * @inode: inode to which delegation applies
 423 * @cred: cred to use for subsequent delegation processing
 424 * @type: delegation type
 425 * @stateid: delegation stateid
 426 * @pagemod_limit: write delegation "space_limit"
 427 *
 428 * Returns zero on success, or a negative errno value.
 429 */
 430int nfs_inode_set_delegation(struct inode *inode, const struct cred *cred,
 431				  fmode_t type,
 432				  const nfs4_stateid *stateid,
 433				  unsigned long pagemod_limit)
 434{
 435	struct nfs_server *server = NFS_SERVER(inode);
 436	struct nfs_client *clp = server->nfs_client;
 437	struct nfs_inode *nfsi = NFS_I(inode);
 438	struct nfs_delegation *delegation, *old_delegation;
 439	struct nfs_delegation *freeme = NULL;
 440	int status = 0;
 441
 442	delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
 443	if (delegation == NULL)
 444		return -ENOMEM;
 445	nfs4_stateid_copy(&delegation->stateid, stateid);
 446	refcount_set(&delegation->refcount, 1);
 447	delegation->type = type;
 448	delegation->pagemod_limit = pagemod_limit;
 449	delegation->change_attr = inode_peek_iversion_raw(inode);
 450	delegation->cred = get_cred(cred);
 451	delegation->inode = inode;
 452	delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
 453	spin_lock_init(&delegation->lock);
 454
 455	spin_lock(&clp->cl_lock);
 456	old_delegation = rcu_dereference_protected(nfsi->delegation,
 457					lockdep_is_held(&clp->cl_lock));
 458	if (old_delegation == NULL)
 459		goto add_new;
 460	/* Is this an update of the existing delegation? */
 461	if (nfs4_stateid_match_other(&old_delegation->stateid,
 462				&delegation->stateid)) {
 463		spin_lock(&old_delegation->lock);
 464		nfs_update_inplace_delegation(old_delegation,
 465				delegation);
 466		spin_unlock(&old_delegation->lock);
 467		goto out;
 468	}
 469	if (!test_bit(NFS_DELEGATION_REVOKED, &old_delegation->flags)) {
 470		/*
 471		 * Deal with broken servers that hand out two
 472		 * delegations for the same file.
 473		 * Allow for upgrades to a WRITE delegation, but
 474		 * nothing else.
 475		 */
 476		dfprintk(FILE, "%s: server %s handed out "
 477				"a duplicate delegation!\n",
 478				__func__, clp->cl_hostname);
 479		if (delegation->type == old_delegation->type ||
 480		    !(delegation->type & FMODE_WRITE)) {
 481			freeme = delegation;
 482			delegation = NULL;
 483			goto out;
 484		}
 485		if (test_and_set_bit(NFS_DELEGATION_RETURNING,
 486					&old_delegation->flags))
 487			goto out;
 488	}
 489	freeme = nfs_detach_delegation_locked(nfsi, old_delegation, clp);
 490	if (freeme == NULL)
 491		goto out;
 492add_new:
 493	/*
 494	 * If we didn't revalidate the change attribute before setting
 495	 * the delegation, then pre-emptively ask for a full attribute
 496	 * cache revalidation.
 497	 */
 498	spin_lock(&inode->i_lock);
 499	if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_CHANGE)
 500		nfs_set_cache_invalid(inode,
 501			NFS_INO_INVALID_ATIME | NFS_INO_INVALID_CTIME |
 502			NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE |
 503			NFS_INO_INVALID_BLOCKS | NFS_INO_INVALID_NLINK |
 504			NFS_INO_INVALID_OTHER | NFS_INO_INVALID_DATA |
 505			NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL |
 506			NFS_INO_INVALID_XATTR);
 507	spin_unlock(&inode->i_lock);
 508
 509	list_add_tail_rcu(&delegation->super_list, &server->delegations);
 510	rcu_assign_pointer(nfsi->delegation, delegation);
 511	delegation = NULL;
 512
 513	atomic_long_inc(&nfs_active_delegations);
 514
 515	trace_nfs4_set_delegation(inode, type);
 516out:
 517	spin_unlock(&clp->cl_lock);
 518	if (delegation != NULL)
 519		__nfs_free_delegation(delegation);
 520	if (freeme != NULL) {
 521		nfs_do_return_delegation(inode, freeme, 0);
 522		nfs_free_delegation(freeme);
 523	}
 524	return status;
 525}
 526
 527/*
 528 * Basic procedure for returning a delegation to the server
 529 */
 530static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
 531{
 532	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
 533	unsigned int mode = O_WRONLY | O_RDWR;
 534	int err = 0;
 535
 536	if (delegation == NULL)
 537		return 0;
 538
 539	if (!issync)
 540		mode |= O_NONBLOCK;
 541	/* Recall of any remaining application leases */
 542	err = break_lease(inode, mode);
 543
 544	while (err == 0) {
 545		if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
 546			break;
 547		err = nfs_delegation_claim_opens(inode, &delegation->stateid,
 548				delegation->type);
 549		if (!issync || err != -EAGAIN)
 550			break;
 551		/*
 552		 * Guard against state recovery
 553		 */
 554		err = nfs4_wait_clnt_recover(clp);
 555	}
 556
 557	if (err) {
 558		nfs_abort_delegation_return(delegation, clp, err);
 559		goto out;
 560	}
 561
 562	err = nfs_do_return_delegation(inode, delegation, issync);
 563out:
 564	/* Refcount matched in nfs_start_delegation_return_locked() */
 565	nfs_put_delegation(delegation);
 566	return err;
 567}
 568
 569static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
 570{
 571	bool ret = false;
 572
 573	if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
 574		ret = true;
 575	else if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags)) {
 576		struct inode *inode;
 577
 578		spin_lock(&delegation->lock);
 579		inode = delegation->inode;
 580		if (inode && list_empty(&NFS_I(inode)->open_files))
 581			ret = true;
 582		spin_unlock(&delegation->lock);
 583	}
 584	if (ret)
 585		clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
 586	if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags) ||
 587	    test_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags) ||
 588	    test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
 589		ret = false;
 590
 591	return ret;
 592}
 593
 594static int nfs_server_return_marked_delegations(struct nfs_server *server,
 595		void __always_unused *data)
 596{
 597	struct nfs_delegation *delegation;
 598	struct nfs_delegation *prev;
 599	struct inode *inode;
 600	struct inode *place_holder = NULL;
 601	struct nfs_delegation *place_holder_deleg = NULL;
 602	int err = 0;
 603
 604restart:
 605	/*
 606	 * To avoid quadratic looping we hold a reference
 607	 * to an inode place_holder.  Each time we restart, we
 608	 * list delegation in the server from the delegations
 609	 * of that inode.
 610	 * prev is an RCU-protected pointer to a delegation which
 611	 * wasn't marked for return and might be a good choice for
 612	 * the next place_holder.
 613	 */
 614	prev = NULL;
 615	delegation = NULL;
 616	rcu_read_lock();
 617	if (place_holder)
 618		delegation = rcu_dereference(NFS_I(place_holder)->delegation);
 619	if (!delegation || delegation != place_holder_deleg)
 620		delegation = list_entry_rcu(server->delegations.next,
 621					    struct nfs_delegation, super_list);
 622	list_for_each_entry_from_rcu(delegation, &server->delegations, super_list) {
 623		struct inode *to_put = NULL;
 624
 625		if (test_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags))
 626			continue;
 627		if (!nfs_delegation_need_return(delegation)) {
 628			if (nfs4_is_valid_delegation(delegation, 0))
 629				prev = delegation;
 630			continue;
 631		}
 632
 633		if (prev) {
 634			struct inode *tmp = nfs_delegation_grab_inode(prev);
 635			if (tmp) {
 636				to_put = place_holder;
 637				place_holder = tmp;
 638				place_holder_deleg = prev;
 639			}
 640		}
 641
 642		inode = nfs_delegation_grab_inode(delegation);
 643		if (inode == NULL) {
 644			rcu_read_unlock();
 645			iput(to_put);
 646			goto restart;
 647		}
 648		delegation = nfs_start_delegation_return_locked(NFS_I(inode));
 649		rcu_read_unlock();
 650
 651		iput(to_put);
 652
 653		err = nfs_end_delegation_return(inode, delegation, 0);
 654		iput(inode);
 655		cond_resched();
 656		if (!err)
 657			goto restart;
 658		set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
 659		goto out;
 660	}
 661	rcu_read_unlock();
 662out:
 663	iput(place_holder);
 664	return err;
 665}
 666
 667static bool nfs_server_clear_delayed_delegations(struct nfs_server *server)
 668{
 669	struct nfs_delegation *d;
 670	bool ret = false;
 671
 672	list_for_each_entry_rcu (d, &server->delegations, super_list) {
 673		if (!test_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags))
 674			continue;
 675		nfs_mark_return_delegation(server, d);
 676		clear_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags);
 677		ret = true;
 678	}
 679	return ret;
 680}
 681
 682static bool nfs_client_clear_delayed_delegations(struct nfs_client *clp)
 683{
 684	struct nfs_server *server;
 685	bool ret = false;
 686
 687	if (!test_and_clear_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state))
 688		goto out;
 689	rcu_read_lock();
 690	list_for_each_entry_rcu (server, &clp->cl_superblocks, client_link) {
 691		if (nfs_server_clear_delayed_delegations(server))
 692			ret = true;
 693	}
 694	rcu_read_unlock();
 695out:
 696	return ret;
 697}
 698
 699/**
 700 * nfs_client_return_marked_delegations - return previously marked delegations
 701 * @clp: nfs_client to process
 702 *
 703 * Note that this function is designed to be called by the state
 704 * manager thread. For this reason, it cannot flush the dirty data,
 705 * since that could deadlock in case of a state recovery error.
 706 *
 707 * Returns zero on success, or a negative errno value.
 708 */
 709int nfs_client_return_marked_delegations(struct nfs_client *clp)
 710{
 711	int err = nfs_client_for_each_server(
 712		clp, nfs_server_return_marked_delegations, NULL);
 713	if (err)
 714		return err;
 715	/* If a return was delayed, sleep to prevent hard looping */
 716	if (nfs_client_clear_delayed_delegations(clp))
 717		ssleep(1);
 718	return 0;
 719}
 720
 721/**
 722 * nfs_inode_evict_delegation - return delegation, don't reclaim opens
 723 * @inode: inode to process
 724 *
 725 * Does not protect against delegation reclaims, therefore really only safe
 726 * to be called from nfs4_clear_inode(). Guaranteed to always free
 727 * the delegation structure.
 728 */
 729void nfs_inode_evict_delegation(struct inode *inode)
 730{
 731	struct nfs_delegation *delegation;
 732
 733	delegation = nfs_inode_detach_delegation(inode);
 734	if (delegation != NULL) {
 735		set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
 736		set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags);
 737		nfs_do_return_delegation(inode, delegation, 1);
 738		nfs_free_delegation(delegation);
 739	}
 740}
 741
 742/**
 743 * nfs4_inode_return_delegation - synchronously return a delegation
 744 * @inode: inode to process
 745 *
 746 * This routine will always flush any dirty data to disk on the
 747 * assumption that if we need to return the delegation, then
 748 * we should stop caching.
 749 *
 750 * Returns zero on success, or a negative errno value.
 751 */
 752int nfs4_inode_return_delegation(struct inode *inode)
 753{
 754	struct nfs_inode *nfsi = NFS_I(inode);
 755	struct nfs_delegation *delegation;
 756
 757	delegation = nfs_start_delegation_return(nfsi);
 758	/* Synchronous recall of any application leases */
 759	break_lease(inode, O_WRONLY | O_RDWR);
 760	nfs_wb_all(inode);
 761	if (delegation != NULL)
 
 762		return nfs_end_delegation_return(inode, delegation, 1);
 
 763	return 0;
 764}
 765
 766/**
 767 * nfs4_inode_return_delegation_on_close - asynchronously return a delegation
 768 * @inode: inode to process
 769 *
 770 * This routine is called on file close in order to determine if the
 771 * inode delegation needs to be returned immediately.
 772 */
 773void nfs4_inode_return_delegation_on_close(struct inode *inode)
 774{
 775	struct nfs_delegation *delegation;
 776	struct nfs_delegation *ret = NULL;
 777
 778	if (!inode)
 779		return;
 780	rcu_read_lock();
 781	delegation = nfs4_get_valid_delegation(inode);
 782	if (!delegation)
 783		goto out;
 784	if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) ||
 785	    atomic_long_read(&nfs_active_delegations) >= nfs_delegation_watermark) {
 786		spin_lock(&delegation->lock);
 787		if (delegation->inode &&
 788		    list_empty(&NFS_I(inode)->open_files) &&
 789		    !test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
 790			clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
 791			/* Refcount matched in nfs_end_delegation_return() */
 792			ret = nfs_get_delegation(delegation);
 793		}
 794		spin_unlock(&delegation->lock);
 795		if (ret)
 796			nfs_clear_verifier_delegated(inode);
 797	}
 798out:
 799	rcu_read_unlock();
 800	nfs_end_delegation_return(inode, ret, 0);
 801}
 802
 803/**
 804 * nfs4_inode_make_writeable
 805 * @inode: pointer to inode
 806 *
 807 * Make the inode writeable by returning the delegation if necessary
 808 *
 809 * Returns zero on success, or a negative errno value.
 810 */
 811int nfs4_inode_make_writeable(struct inode *inode)
 812{
 813	struct nfs_delegation *delegation;
 814
 815	rcu_read_lock();
 816	delegation = nfs4_get_valid_delegation(inode);
 817	if (delegation == NULL ||
 818	    (nfs4_has_session(NFS_SERVER(inode)->nfs_client) &&
 819	     (delegation->type & FMODE_WRITE))) {
 820		rcu_read_unlock();
 821		return 0;
 822	}
 823	rcu_read_unlock();
 824	return nfs4_inode_return_delegation(inode);
 825}
 826
 827static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
 828		struct nfs_delegation *delegation)
 829{
 830	set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
 831	set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
 832}
 833
 834static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
 835{
 836	struct nfs_delegation *delegation;
 837	bool ret = false;
 838
 839	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 840		nfs_mark_return_delegation(server, delegation);
 841		ret = true;
 842	}
 843	return ret;
 844}
 845
 846static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
 847{
 848	struct nfs_server *server;
 849
 850	rcu_read_lock();
 851	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 852		nfs_server_mark_return_all_delegations(server);
 853	rcu_read_unlock();
 854}
 855
 856static void nfs_delegation_run_state_manager(struct nfs_client *clp)
 857{
 858	if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
 859		nfs4_schedule_state_manager(clp);
 860}
 861
 862/**
 863 * nfs_expire_all_delegations
 864 * @clp: client to process
 865 *
 866 */
 867void nfs_expire_all_delegations(struct nfs_client *clp)
 868{
 869	nfs_client_mark_return_all_delegations(clp);
 870	nfs_delegation_run_state_manager(clp);
 871}
 872
 873/**
 874 * nfs_server_return_all_delegations - return delegations for one superblock
 875 * @server: pointer to nfs_server to process
 876 *
 877 */
 878void nfs_server_return_all_delegations(struct nfs_server *server)
 879{
 880	struct nfs_client *clp = server->nfs_client;
 881	bool need_wait;
 882
 883	if (clp == NULL)
 884		return;
 885
 886	rcu_read_lock();
 887	need_wait = nfs_server_mark_return_all_delegations(server);
 888	rcu_read_unlock();
 889
 890	if (need_wait) {
 891		nfs4_schedule_state_manager(clp);
 892		nfs4_wait_clnt_recover(clp);
 893	}
 894}
 895
 896static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
 897						 fmode_t flags)
 898{
 899	struct nfs_delegation *delegation;
 900
 901	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 902		if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
 903			continue;
 904		if (delegation->type & flags)
 905			nfs_mark_return_if_closed_delegation(server, delegation);
 906	}
 907}
 908
 909static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
 910							fmode_t flags)
 911{
 912	struct nfs_server *server;
 913
 914	rcu_read_lock();
 915	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 916		nfs_mark_return_unused_delegation_types(server, flags);
 917	rcu_read_unlock();
 918}
 919
 920static void nfs_revoke_delegation(struct inode *inode,
 921		const nfs4_stateid *stateid)
 922{
 923	struct nfs_delegation *delegation;
 924	nfs4_stateid tmp;
 925	bool ret = false;
 926
 927	rcu_read_lock();
 928	delegation = rcu_dereference(NFS_I(inode)->delegation);
 929	if (delegation == NULL)
 930		goto out;
 931	if (stateid == NULL) {
 932		nfs4_stateid_copy(&tmp, &delegation->stateid);
 933		stateid = &tmp;
 934	} else {
 935		if (!nfs4_stateid_match_other(stateid, &delegation->stateid))
 936			goto out;
 937		spin_lock(&delegation->lock);
 938		if (stateid->seqid) {
 939			if (nfs4_stateid_is_newer(&delegation->stateid, stateid)) {
 940				spin_unlock(&delegation->lock);
 941				goto out;
 942			}
 943			delegation->stateid.seqid = stateid->seqid;
 944		}
 945		spin_unlock(&delegation->lock);
 946	}
 947	nfs_mark_delegation_revoked(delegation);
 948	ret = true;
 949out:
 950	rcu_read_unlock();
 951	if (ret)
 952		nfs_inode_find_state_and_recover(inode, stateid);
 953}
 954
 955void nfs_remove_bad_delegation(struct inode *inode,
 956		const nfs4_stateid *stateid)
 957{
 958	nfs_revoke_delegation(inode, stateid);
 959}
 960EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
 961
 962void nfs_delegation_mark_returned(struct inode *inode,
 963		const nfs4_stateid *stateid)
 964{
 965	struct nfs_delegation *delegation;
 966
 967	if (!inode)
 968		return;
 969
 970	rcu_read_lock();
 971	delegation = rcu_dereference(NFS_I(inode)->delegation);
 972	if (!delegation)
 973		goto out_rcu_unlock;
 974
 975	spin_lock(&delegation->lock);
 976	if (!nfs4_stateid_match_other(stateid, &delegation->stateid))
 977		goto out_spin_unlock;
 978	if (stateid->seqid) {
 979		/* If delegation->stateid is newer, dont mark as returned */
 980		if (nfs4_stateid_is_newer(&delegation->stateid, stateid))
 981			goto out_clear_returning;
 982		if (delegation->stateid.seqid != stateid->seqid)
 983			delegation->stateid.seqid = stateid->seqid;
 984	}
 985
 986	nfs_mark_delegation_revoked(delegation);
 987
 988out_clear_returning:
 989	clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
 990out_spin_unlock:
 991	spin_unlock(&delegation->lock);
 992out_rcu_unlock:
 993	rcu_read_unlock();
 994
 995	nfs_inode_find_state_and_recover(inode, stateid);
 996}
 997
 998/**
 999 * nfs_expire_unused_delegation_types
1000 * @clp: client to process
1001 * @flags: delegation types to expire
1002 *
1003 */
1004void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
1005{
1006	nfs_client_mark_return_unused_delegation_types(clp, flags);
1007	nfs_delegation_run_state_manager(clp);
1008}
1009
1010static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
1011{
1012	struct nfs_delegation *delegation;
1013
1014	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1015		if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
1016			continue;
1017		nfs_mark_return_if_closed_delegation(server, delegation);
1018	}
1019}
1020
1021/**
1022 * nfs_expire_unreferenced_delegations - Eliminate unused delegations
1023 * @clp: nfs_client to process
1024 *
1025 */
1026void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
1027{
1028	struct nfs_server *server;
1029
1030	rcu_read_lock();
1031	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1032		nfs_mark_return_unreferenced_delegations(server);
1033	rcu_read_unlock();
1034
1035	nfs_delegation_run_state_manager(clp);
1036}
1037
1038/**
1039 * nfs_async_inode_return_delegation - asynchronously return a delegation
1040 * @inode: inode to process
1041 * @stateid: state ID information
1042 *
1043 * Returns zero on success, or a negative errno value.
1044 */
1045int nfs_async_inode_return_delegation(struct inode *inode,
1046				      const nfs4_stateid *stateid)
1047{
1048	struct nfs_server *server = NFS_SERVER(inode);
1049	struct nfs_client *clp = server->nfs_client;
1050	struct nfs_delegation *delegation;
1051
1052	rcu_read_lock();
1053	delegation = nfs4_get_valid_delegation(inode);
1054	if (delegation == NULL)
1055		goto out_enoent;
1056	if (stateid != NULL &&
1057	    !clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
1058		goto out_enoent;
1059	nfs_mark_return_delegation(server, delegation);
1060	rcu_read_unlock();
1061
1062	/* If there are any application leases or delegations, recall them */
1063	break_lease(inode, O_WRONLY | O_RDWR | O_NONBLOCK);
1064
1065	nfs_delegation_run_state_manager(clp);
1066	return 0;
1067out_enoent:
1068	rcu_read_unlock();
1069	return -ENOENT;
1070}
1071
1072static struct inode *
1073nfs_delegation_find_inode_server(struct nfs_server *server,
1074				 const struct nfs_fh *fhandle)
1075{
1076	struct nfs_delegation *delegation;
1077	struct super_block *freeme = NULL;
1078	struct inode *res = NULL;
1079
1080	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1081		spin_lock(&delegation->lock);
1082		if (delegation->inode != NULL &&
1083		    !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) &&
1084		    nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
1085			if (nfs_sb_active(server->super)) {
1086				freeme = server->super;
1087				res = igrab(delegation->inode);
1088			}
1089			spin_unlock(&delegation->lock);
1090			if (res != NULL)
1091				return res;
1092			if (freeme) {
1093				rcu_read_unlock();
1094				nfs_sb_deactive(freeme);
1095				rcu_read_lock();
1096			}
1097			return ERR_PTR(-EAGAIN);
1098		}
1099		spin_unlock(&delegation->lock);
1100	}
1101	return ERR_PTR(-ENOENT);
1102}
1103
1104/**
1105 * nfs_delegation_find_inode - retrieve the inode associated with a delegation
1106 * @clp: client state handle
1107 * @fhandle: filehandle from a delegation recall
1108 *
1109 * Returns pointer to inode matching "fhandle," or NULL if a matching inode
1110 * cannot be found.
1111 */
1112struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
1113					const struct nfs_fh *fhandle)
1114{
1115	struct nfs_server *server;
1116	struct inode *res;
1117
1118	rcu_read_lock();
1119	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1120		res = nfs_delegation_find_inode_server(server, fhandle);
1121		if (res != ERR_PTR(-ENOENT)) {
1122			rcu_read_unlock();
1123			return res;
1124		}
1125	}
1126	rcu_read_unlock();
1127	return ERR_PTR(-ENOENT);
1128}
1129
1130static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
1131{
1132	struct nfs_delegation *delegation;
1133
1134	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1135		/*
1136		 * If the delegation may have been admin revoked, then we
1137		 * cannot reclaim it.
1138		 */
1139		if (test_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags))
1140			continue;
1141		set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
1142	}
1143}
1144
1145/**
1146 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
1147 * @clp: nfs_client to process
1148 *
1149 */
1150void nfs_delegation_mark_reclaim(struct nfs_client *clp)
1151{
1152	struct nfs_server *server;
1153
1154	rcu_read_lock();
1155	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1156		nfs_delegation_mark_reclaim_server(server);
1157	rcu_read_unlock();
1158}
1159
1160static int nfs_server_reap_unclaimed_delegations(struct nfs_server *server,
1161		void __always_unused *data)
1162{
1163	struct nfs_delegation *delegation;
1164	struct inode *inode;
1165restart:
1166	rcu_read_lock();
1167restart_locked:
1168	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1169		if (test_bit(NFS_DELEGATION_INODE_FREEING,
1170					&delegation->flags) ||
1171		    test_bit(NFS_DELEGATION_RETURNING,
1172					&delegation->flags) ||
1173		    test_bit(NFS_DELEGATION_NEED_RECLAIM,
1174					&delegation->flags) == 0)
1175			continue;
1176		inode = nfs_delegation_grab_inode(delegation);
1177		if (inode == NULL)
1178			goto restart_locked;
1179		delegation = nfs_start_delegation_return_locked(NFS_I(inode));
1180		rcu_read_unlock();
1181		if (delegation != NULL) {
1182			if (nfs_detach_delegation(NFS_I(inode), delegation,
1183						server) != NULL)
1184				nfs_free_delegation(delegation);
1185			/* Match nfs_start_delegation_return_locked */
1186			nfs_put_delegation(delegation);
1187		}
1188		iput(inode);
1189		cond_resched();
1190		goto restart;
1191	}
1192	rcu_read_unlock();
1193	return 0;
1194}
1195
1196/**
1197 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
1198 * @clp: nfs_client to process
1199 *
1200 */
1201void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
1202{
1203	nfs_client_for_each_server(clp, nfs_server_reap_unclaimed_delegations,
1204			NULL);
1205}
1206
1207static inline bool nfs4_server_rebooted(const struct nfs_client *clp)
1208{
1209	return (clp->cl_state & (BIT(NFS4CLNT_CHECK_LEASE) |
1210				BIT(NFS4CLNT_LEASE_EXPIRED) |
1211				BIT(NFS4CLNT_SESSION_RESET))) != 0;
1212}
1213
1214static void nfs_mark_test_expired_delegation(struct nfs_server *server,
1215	    struct nfs_delegation *delegation)
1216{
1217	if (delegation->stateid.type == NFS4_INVALID_STATEID_TYPE)
1218		return;
1219	clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
1220	set_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
1221	set_bit(NFS4CLNT_DELEGATION_EXPIRED, &server->nfs_client->cl_state);
1222}
1223
1224static void nfs_inode_mark_test_expired_delegation(struct nfs_server *server,
1225		struct inode *inode)
1226{
1227	struct nfs_delegation *delegation;
1228
1229	rcu_read_lock();
1230	delegation = rcu_dereference(NFS_I(inode)->delegation);
1231	if (delegation)
1232		nfs_mark_test_expired_delegation(server, delegation);
1233	rcu_read_unlock();
1234
1235}
1236
1237static void nfs_delegation_mark_test_expired_server(struct nfs_server *server)
1238{
1239	struct nfs_delegation *delegation;
1240
1241	list_for_each_entry_rcu(delegation, &server->delegations, super_list)
1242		nfs_mark_test_expired_delegation(server, delegation);
1243}
1244
1245/**
1246 * nfs_mark_test_expired_all_delegations - mark all delegations for testing
1247 * @clp: nfs_client to process
1248 *
1249 * Iterates through all the delegations associated with this server and
1250 * marks them as needing to be checked for validity.
1251 */
1252void nfs_mark_test_expired_all_delegations(struct nfs_client *clp)
1253{
1254	struct nfs_server *server;
1255
1256	rcu_read_lock();
1257	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1258		nfs_delegation_mark_test_expired_server(server);
1259	rcu_read_unlock();
1260}
1261
1262/**
1263 * nfs_test_expired_all_delegations - test all delegations for a client
1264 * @clp: nfs_client to process
1265 *
1266 * Helper for handling "recallable state revoked" status from server.
1267 */
1268void nfs_test_expired_all_delegations(struct nfs_client *clp)
1269{
1270	nfs_mark_test_expired_all_delegations(clp);
1271	nfs4_schedule_state_manager(clp);
1272}
1273
1274static void
1275nfs_delegation_test_free_expired(struct inode *inode,
1276		nfs4_stateid *stateid,
1277		const struct cred *cred)
1278{
1279	struct nfs_server *server = NFS_SERVER(inode);
1280	const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
1281	int status;
1282
1283	if (!cred)
1284		return;
1285	status = ops->test_and_free_expired(server, stateid, cred);
1286	if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
1287		nfs_remove_bad_delegation(inode, stateid);
1288}
1289
1290static int nfs_server_reap_expired_delegations(struct nfs_server *server,
1291		void __always_unused *data)
1292{
1293	struct nfs_delegation *delegation;
1294	struct inode *inode;
1295	const struct cred *cred;
1296	nfs4_stateid stateid;
1297restart:
1298	rcu_read_lock();
1299restart_locked:
1300	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1301		if (test_bit(NFS_DELEGATION_INODE_FREEING,
1302					&delegation->flags) ||
1303		    test_bit(NFS_DELEGATION_RETURNING,
1304					&delegation->flags) ||
1305		    test_bit(NFS_DELEGATION_TEST_EXPIRED,
1306					&delegation->flags) == 0)
1307			continue;
1308		inode = nfs_delegation_grab_inode(delegation);
1309		if (inode == NULL)
1310			goto restart_locked;
1311		spin_lock(&delegation->lock);
1312		cred = get_cred_rcu(delegation->cred);
1313		nfs4_stateid_copy(&stateid, &delegation->stateid);
1314		spin_unlock(&delegation->lock);
1315		clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
1316		rcu_read_unlock();
1317		nfs_delegation_test_free_expired(inode, &stateid, cred);
1318		put_cred(cred);
1319		if (!nfs4_server_rebooted(server->nfs_client)) {
1320			iput(inode);
1321			cond_resched();
1322			goto restart;
1323		}
1324		nfs_inode_mark_test_expired_delegation(server,inode);
1325		iput(inode);
1326		return -EAGAIN;
1327	}
1328	rcu_read_unlock();
1329	return 0;
1330}
1331
1332/**
1333 * nfs_reap_expired_delegations - reap expired delegations
1334 * @clp: nfs_client to process
1335 *
1336 * Iterates through all the delegations associated with this server and
1337 * checks if they have may have been revoked. This function is usually
1338 * expected to be called in cases where the server may have lost its
1339 * lease.
1340 */
1341void nfs_reap_expired_delegations(struct nfs_client *clp)
1342{
1343	nfs_client_for_each_server(clp, nfs_server_reap_expired_delegations,
1344			NULL);
1345}
1346
1347void nfs_inode_find_delegation_state_and_recover(struct inode *inode,
1348		const nfs4_stateid *stateid)
1349{
1350	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1351	struct nfs_delegation *delegation;
1352	bool found = false;
1353
1354	rcu_read_lock();
1355	delegation = rcu_dereference(NFS_I(inode)->delegation);
1356	if (delegation &&
1357	    nfs4_stateid_match_or_older(&delegation->stateid, stateid) &&
1358	    !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
1359		nfs_mark_test_expired_delegation(NFS_SERVER(inode), delegation);
1360		found = true;
1361	}
1362	rcu_read_unlock();
1363	if (found)
1364		nfs4_schedule_state_manager(clp);
1365}
1366
1367/**
1368 * nfs_delegations_present - check for existence of delegations
1369 * @clp: client state handle
1370 *
1371 * Returns one if there are any nfs_delegation structures attached
1372 * to this nfs_client.
1373 */
1374int nfs_delegations_present(struct nfs_client *clp)
1375{
1376	struct nfs_server *server;
1377	int ret = 0;
1378
1379	rcu_read_lock();
1380	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1381		if (!list_empty(&server->delegations)) {
1382			ret = 1;
1383			break;
1384		}
1385	rcu_read_unlock();
1386	return ret;
1387}
1388
1389/**
1390 * nfs4_refresh_delegation_stateid - Update delegation stateid seqid
1391 * @dst: stateid to refresh
1392 * @inode: inode to check
1393 *
1394 * Returns "true" and updates "dst->seqid" * if inode had a delegation
1395 * that matches our delegation stateid. Otherwise "false" is returned.
1396 */
1397bool nfs4_refresh_delegation_stateid(nfs4_stateid *dst, struct inode *inode)
1398{
1399	struct nfs_delegation *delegation;
1400	bool ret = false;
1401	if (!inode)
1402		goto out;
1403
1404	rcu_read_lock();
1405	delegation = rcu_dereference(NFS_I(inode)->delegation);
1406	if (delegation != NULL &&
1407	    nfs4_stateid_match_other(dst, &delegation->stateid) &&
1408	    nfs4_stateid_is_newer(&delegation->stateid, dst) &&
1409	    !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
1410		dst->seqid = delegation->stateid.seqid;
1411		ret = true;
1412	}
1413	rcu_read_unlock();
1414out:
1415	return ret;
1416}
1417
1418/**
1419 * nfs4_copy_delegation_stateid - Copy inode's state ID information
1420 * @inode: inode to check
1421 * @flags: delegation type requirement
1422 * @dst: stateid data structure to fill in
1423 * @cred: optional argument to retrieve credential
1424 *
1425 * Returns "true" and fills in "dst->data" * if inode had a delegation,
1426 * otherwise "false" is returned.
1427 */
1428bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
1429		nfs4_stateid *dst, const struct cred **cred)
1430{
1431	struct nfs_inode *nfsi = NFS_I(inode);
1432	struct nfs_delegation *delegation;
1433	bool ret = false;
1434
1435	flags &= FMODE_READ|FMODE_WRITE;
1436	rcu_read_lock();
1437	delegation = rcu_dereference(nfsi->delegation);
1438	if (!delegation)
1439		goto out;
1440	spin_lock(&delegation->lock);
1441	ret = nfs4_is_valid_delegation(delegation, flags);
1442	if (ret) {
1443		nfs4_stateid_copy(dst, &delegation->stateid);
1444		nfs_mark_delegation_referenced(delegation);
1445		if (cred)
1446			*cred = get_cred(delegation->cred);
1447	}
1448	spin_unlock(&delegation->lock);
1449out:
1450	rcu_read_unlock();
1451	return ret;
1452}
1453
1454/**
1455 * nfs4_delegation_flush_on_close - Check if we must flush file on close
1456 * @inode: inode to check
1457 *
1458 * This function checks the number of outstanding writes to the file
1459 * against the delegation 'space_limit' field to see if
1460 * the spec requires us to flush the file on close.
1461 */
1462bool nfs4_delegation_flush_on_close(const struct inode *inode)
1463{
1464	struct nfs_inode *nfsi = NFS_I(inode);
1465	struct nfs_delegation *delegation;
1466	bool ret = true;
1467
1468	rcu_read_lock();
1469	delegation = rcu_dereference(nfsi->delegation);
1470	if (delegation == NULL || !(delegation->type & FMODE_WRITE))
1471		goto out;
1472	if (atomic_long_read(&nfsi->nrequests) < delegation->pagemod_limit)
1473		ret = false;
1474out:
1475	rcu_read_unlock();
1476	return ret;
1477}
1478
1479module_param_named(delegation_watermark, nfs_delegation_watermark, uint, 0644);