xref: /openbmc/linux/fs/nfs/delegation.c (revision 987abe82)
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  
30  static atomic_long_t nfs_active_delegations;
31  static unsigned nfs_delegation_watermark = NFS_DEFAULT_DELEGATION_WATERMARK;
32  
33  static 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  
40  static 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  
50  static struct nfs_delegation *nfs_get_delegation(struct nfs_delegation *delegation)
51  {
52  	refcount_inc(&delegation->refcount);
53  	return delegation;
54  }
55  
56  static void nfs_put_delegation(struct nfs_delegation *delegation)
57  {
58  	if (refcount_dec_and_test(&delegation->refcount))
59  		__nfs_free_delegation(delegation);
60  }
61  
62  static 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   */
73  void nfs_mark_delegation_referenced(struct nfs_delegation *delegation)
74  {
75  	set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags);
76  }
77  
78  static 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  
85  static bool
86  nfs4_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  
96  struct 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  
106  static int
107  nfs4_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   */
131  int 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   */
140  int nfs4_check_delegation(struct inode *inode, fmode_t flags)
141  {
142  	return nfs4_do_check_delegation(inode, flags, false);
143  }
144  
145  static 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 = locks_inode_context(inode);
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);
158  restart:
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);
173  out:
174  	return status;
175  }
176  
177  static 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  
187  again:
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   */
230  void nfs_inode_reclaim_delegation(struct inode *inode, const struct cred *cred,
231  				  fmode_t type, const nfs4_stateid *stateid,
232  				  unsigned long pagemod_limit)
233  {
234  	struct nfs_delegation *delegation;
235  	const struct cred *oldcred = NULL;
236  
237  	rcu_read_lock();
238  	delegation = rcu_dereference(NFS_I(inode)->delegation);
239  	if (delegation != NULL) {
240  		spin_lock(&delegation->lock);
241  		nfs4_stateid_copy(&delegation->stateid, stateid);
242  		delegation->type = type;
243  		delegation->pagemod_limit = pagemod_limit;
244  		oldcred = delegation->cred;
245  		delegation->cred = get_cred(cred);
246  		clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
247  		if (test_and_clear_bit(NFS_DELEGATION_REVOKED,
248  				       &delegation->flags))
249  			atomic_long_inc(&nfs_active_delegations);
250  		spin_unlock(&delegation->lock);
251  		rcu_read_unlock();
252  		put_cred(oldcred);
253  		trace_nfs4_reclaim_delegation(inode, type);
254  	} else {
255  		rcu_read_unlock();
256  		nfs_inode_set_delegation(inode, cred, type, stateid,
257  					 pagemod_limit);
258  	}
259  }
260  
261  static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
262  {
263  	const struct cred *cred;
264  	int res = 0;
265  
266  	if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
267  		spin_lock(&delegation->lock);
268  		cred = get_cred(delegation->cred);
269  		spin_unlock(&delegation->lock);
270  		res = nfs4_proc_delegreturn(inode, cred,
271  				&delegation->stateid,
272  				issync);
273  		put_cred(cred);
274  	}
275  	return res;
276  }
277  
278  static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
279  {
280  	struct inode *inode = NULL;
281  
282  	spin_lock(&delegation->lock);
283  	if (delegation->inode != NULL)
284  		inode = igrab(delegation->inode);
285  	if (!inode)
286  		set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags);
287  	spin_unlock(&delegation->lock);
288  	return inode;
289  }
290  
291  static struct nfs_delegation *
292  nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
293  {
294  	struct nfs_delegation *ret = NULL;
295  	struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
296  
297  	if (delegation == NULL)
298  		goto out;
299  	spin_lock(&delegation->lock);
300  	if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
301  		clear_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags);
302  		/* Refcount matched in nfs_end_delegation_return() */
303  		ret = nfs_get_delegation(delegation);
304  	}
305  	spin_unlock(&delegation->lock);
306  	if (ret)
307  		nfs_clear_verifier_delegated(&nfsi->vfs_inode);
308  out:
309  	return ret;
310  }
311  
312  static struct nfs_delegation *
313  nfs_start_delegation_return(struct nfs_inode *nfsi)
314  {
315  	struct nfs_delegation *delegation;
316  
317  	rcu_read_lock();
318  	delegation = nfs_start_delegation_return_locked(nfsi);
319  	rcu_read_unlock();
320  	return delegation;
321  }
322  
323  static void nfs_abort_delegation_return(struct nfs_delegation *delegation,
324  					struct nfs_client *clp, int err)
325  {
326  
327  	spin_lock(&delegation->lock);
328  	clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
329  	if (err == -EAGAIN) {
330  		set_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags);
331  		set_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state);
332  	}
333  	spin_unlock(&delegation->lock);
334  }
335  
336  static struct nfs_delegation *
337  nfs_detach_delegation_locked(struct nfs_inode *nfsi,
338  		struct nfs_delegation *delegation,
339  		struct nfs_client *clp)
340  {
341  	struct nfs_delegation *deleg_cur =
342  		rcu_dereference_protected(nfsi->delegation,
343  				lockdep_is_held(&clp->cl_lock));
344  
345  	if (deleg_cur == NULL || delegation != deleg_cur)
346  		return NULL;
347  
348  	spin_lock(&delegation->lock);
349  	if (!delegation->inode) {
350  		spin_unlock(&delegation->lock);
351  		return NULL;
352  	}
353  	list_del_rcu(&delegation->super_list);
354  	delegation->inode = NULL;
355  	rcu_assign_pointer(nfsi->delegation, NULL);
356  	spin_unlock(&delegation->lock);
357  	return delegation;
358  }
359  
360  static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
361  		struct nfs_delegation *delegation,
362  		struct nfs_server *server)
363  {
364  	struct nfs_client *clp = server->nfs_client;
365  
366  	spin_lock(&clp->cl_lock);
367  	delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
368  	spin_unlock(&clp->cl_lock);
369  	return delegation;
370  }
371  
372  static struct nfs_delegation *
373  nfs_inode_detach_delegation(struct inode *inode)
374  {
375  	struct nfs_inode *nfsi = NFS_I(inode);
376  	struct nfs_server *server = NFS_SERVER(inode);
377  	struct nfs_delegation *delegation;
378  
379  	rcu_read_lock();
380  	delegation = rcu_dereference(nfsi->delegation);
381  	if (delegation != NULL)
382  		delegation = nfs_detach_delegation(nfsi, delegation, server);
383  	rcu_read_unlock();
384  	return delegation;
385  }
386  
387  static void
388  nfs_update_delegation_cred(struct nfs_delegation *delegation,
389  		const struct cred *cred)
390  {
391  	const struct cred *old;
392  
393  	if (cred_fscmp(delegation->cred, cred) != 0) {
394  		old = xchg(&delegation->cred, get_cred(cred));
395  		put_cred(old);
396  	}
397  }
398  
399  static void
400  nfs_update_inplace_delegation(struct nfs_delegation *delegation,
401  		const struct nfs_delegation *update)
402  {
403  	if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) {
404  		delegation->stateid.seqid = update->stateid.seqid;
405  		smp_wmb();
406  		delegation->type = update->type;
407  		delegation->pagemod_limit = update->pagemod_limit;
408  		if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
409  			delegation->change_attr = update->change_attr;
410  			nfs_update_delegation_cred(delegation, update->cred);
411  			/* smp_mb__before_atomic() is implicit due to xchg() */
412  			clear_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
413  			atomic_long_inc(&nfs_active_delegations);
414  		}
415  	}
416  }
417  
418  /**
419   * nfs_inode_set_delegation - set up a delegation on an inode
420   * @inode: inode to which delegation applies
421   * @cred: cred to use for subsequent delegation processing
422   * @type: delegation type
423   * @stateid: delegation stateid
424   * @pagemod_limit: write delegation "space_limit"
425   *
426   * Returns zero on success, or a negative errno value.
427   */
428  int nfs_inode_set_delegation(struct inode *inode, const struct cred *cred,
429  				  fmode_t type,
430  				  const nfs4_stateid *stateid,
431  				  unsigned long pagemod_limit)
432  {
433  	struct nfs_server *server = NFS_SERVER(inode);
434  	struct nfs_client *clp = server->nfs_client;
435  	struct nfs_inode *nfsi = NFS_I(inode);
436  	struct nfs_delegation *delegation, *old_delegation;
437  	struct nfs_delegation *freeme = NULL;
438  	int status = 0;
439  
440  	delegation = kmalloc(sizeof(*delegation), GFP_KERNEL_ACCOUNT);
441  	if (delegation == NULL)
442  		return -ENOMEM;
443  	nfs4_stateid_copy(&delegation->stateid, stateid);
444  	refcount_set(&delegation->refcount, 1);
445  	delegation->type = type;
446  	delegation->pagemod_limit = pagemod_limit;
447  	delegation->change_attr = inode_peek_iversion_raw(inode);
448  	delegation->cred = get_cred(cred);
449  	delegation->inode = inode;
450  	delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
451  	spin_lock_init(&delegation->lock);
452  
453  	spin_lock(&clp->cl_lock);
454  	old_delegation = rcu_dereference_protected(nfsi->delegation,
455  					lockdep_is_held(&clp->cl_lock));
456  	if (old_delegation == NULL)
457  		goto add_new;
458  	/* Is this an update of the existing delegation? */
459  	if (nfs4_stateid_match_other(&old_delegation->stateid,
460  				&delegation->stateid)) {
461  		spin_lock(&old_delegation->lock);
462  		nfs_update_inplace_delegation(old_delegation,
463  				delegation);
464  		spin_unlock(&old_delegation->lock);
465  		goto out;
466  	}
467  	if (!test_bit(NFS_DELEGATION_REVOKED, &old_delegation->flags)) {
468  		/*
469  		 * Deal with broken servers that hand out two
470  		 * delegations for the same file.
471  		 * Allow for upgrades to a WRITE delegation, but
472  		 * nothing else.
473  		 */
474  		dfprintk(FILE, "%s: server %s handed out "
475  				"a duplicate delegation!\n",
476  				__func__, clp->cl_hostname);
477  		if (delegation->type == old_delegation->type ||
478  		    !(delegation->type & FMODE_WRITE)) {
479  			freeme = delegation;
480  			delegation = NULL;
481  			goto out;
482  		}
483  		if (test_and_set_bit(NFS_DELEGATION_RETURNING,
484  					&old_delegation->flags))
485  			goto out;
486  	}
487  	freeme = nfs_detach_delegation_locked(nfsi, old_delegation, clp);
488  	if (freeme == NULL)
489  		goto out;
490  add_new:
491  	/*
492  	 * If we didn't revalidate the change attribute before setting
493  	 * the delegation, then pre-emptively ask for a full attribute
494  	 * cache revalidation.
495  	 */
496  	spin_lock(&inode->i_lock);
497  	if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_CHANGE)
498  		nfs_set_cache_invalid(inode,
499  			NFS_INO_INVALID_ATIME | NFS_INO_INVALID_CTIME |
500  			NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE |
501  			NFS_INO_INVALID_BLOCKS | NFS_INO_INVALID_NLINK |
502  			NFS_INO_INVALID_OTHER | NFS_INO_INVALID_DATA |
503  			NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL |
504  			NFS_INO_INVALID_XATTR);
505  	spin_unlock(&inode->i_lock);
506  
507  	list_add_tail_rcu(&delegation->super_list, &server->delegations);
508  	rcu_assign_pointer(nfsi->delegation, delegation);
509  	delegation = NULL;
510  
511  	atomic_long_inc(&nfs_active_delegations);
512  
513  	trace_nfs4_set_delegation(inode, type);
514  out:
515  	spin_unlock(&clp->cl_lock);
516  	if (delegation != NULL)
517  		__nfs_free_delegation(delegation);
518  	if (freeme != NULL) {
519  		nfs_do_return_delegation(inode, freeme, 0);
520  		nfs_free_delegation(freeme);
521  	}
522  	return status;
523  }
524  
525  /*
526   * Basic procedure for returning a delegation to the server
527   */
528  static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
529  {
530  	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
531  	unsigned int mode = O_WRONLY | O_RDWR;
532  	int err = 0;
533  
534  	if (delegation == NULL)
535  		return 0;
536  
537  	if (!issync)
538  		mode |= O_NONBLOCK;
539  	/* Recall of any remaining application leases */
540  	err = break_lease(inode, mode);
541  
542  	while (err == 0) {
543  		if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
544  			break;
545  		err = nfs_delegation_claim_opens(inode, &delegation->stateid,
546  				delegation->type);
547  		if (!issync || err != -EAGAIN)
548  			break;
549  		/*
550  		 * Guard against state recovery
551  		 */
552  		err = nfs4_wait_clnt_recover(clp);
553  	}
554  
555  	if (err) {
556  		nfs_abort_delegation_return(delegation, clp, err);
557  		goto out;
558  	}
559  
560  	err = nfs_do_return_delegation(inode, delegation, issync);
561  out:
562  	/* Refcount matched in nfs_start_delegation_return_locked() */
563  	nfs_put_delegation(delegation);
564  	return err;
565  }
566  
567  static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
568  {
569  	bool ret = false;
570  
571  	if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
572  		ret = true;
573  	else if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags)) {
574  		struct inode *inode;
575  
576  		spin_lock(&delegation->lock);
577  		inode = delegation->inode;
578  		if (inode && list_empty(&NFS_I(inode)->open_files))
579  			ret = true;
580  		spin_unlock(&delegation->lock);
581  	}
582  	if (ret)
583  		clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
584  	if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags) ||
585  	    test_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags) ||
586  	    test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
587  		ret = false;
588  
589  	return ret;
590  }
591  
592  static int nfs_server_return_marked_delegations(struct nfs_server *server,
593  		void __always_unused *data)
594  {
595  	struct nfs_delegation *delegation;
596  	struct nfs_delegation *prev;
597  	struct inode *inode;
598  	struct inode *place_holder = NULL;
599  	struct nfs_delegation *place_holder_deleg = NULL;
600  	int err = 0;
601  
602  restart:
603  	/*
604  	 * To avoid quadratic looping we hold a reference
605  	 * to an inode place_holder.  Each time we restart, we
606  	 * list delegation in the server from the delegations
607  	 * of that inode.
608  	 * prev is an RCU-protected pointer to a delegation which
609  	 * wasn't marked for return and might be a good choice for
610  	 * the next place_holder.
611  	 */
612  	prev = NULL;
613  	delegation = NULL;
614  	rcu_read_lock();
615  	if (place_holder)
616  		delegation = rcu_dereference(NFS_I(place_holder)->delegation);
617  	if (!delegation || delegation != place_holder_deleg)
618  		delegation = list_entry_rcu(server->delegations.next,
619  					    struct nfs_delegation, super_list);
620  	list_for_each_entry_from_rcu(delegation, &server->delegations, super_list) {
621  		struct inode *to_put = NULL;
622  
623  		if (test_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags))
624  			continue;
625  		if (!nfs_delegation_need_return(delegation)) {
626  			if (nfs4_is_valid_delegation(delegation, 0))
627  				prev = delegation;
628  			continue;
629  		}
630  		inode = nfs_delegation_grab_inode(delegation);
631  		if (inode == NULL)
632  			continue;
633  
634  		if (prev) {
635  			struct inode *tmp = nfs_delegation_grab_inode(prev);
636  			if (tmp) {
637  				to_put = place_holder;
638  				place_holder = tmp;
639  				place_holder_deleg = prev;
640  			}
641  		}
642  
643  		delegation = nfs_start_delegation_return_locked(NFS_I(inode));
644  		rcu_read_unlock();
645  
646  		iput(to_put);
647  
648  		err = nfs_end_delegation_return(inode, delegation, 0);
649  		iput(inode);
650  		cond_resched();
651  		if (!err)
652  			goto restart;
653  		set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
654  		goto out;
655  	}
656  	rcu_read_unlock();
657  out:
658  	iput(place_holder);
659  	return err;
660  }
661  
662  static bool nfs_server_clear_delayed_delegations(struct nfs_server *server)
663  {
664  	struct nfs_delegation *d;
665  	bool ret = false;
666  
667  	list_for_each_entry_rcu (d, &server->delegations, super_list) {
668  		if (!test_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags))
669  			continue;
670  		nfs_mark_return_delegation(server, d);
671  		clear_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags);
672  		ret = true;
673  	}
674  	return ret;
675  }
676  
677  static bool nfs_client_clear_delayed_delegations(struct nfs_client *clp)
678  {
679  	struct nfs_server *server;
680  	bool ret = false;
681  
682  	if (!test_and_clear_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state))
683  		goto out;
684  	rcu_read_lock();
685  	list_for_each_entry_rcu (server, &clp->cl_superblocks, client_link) {
686  		if (nfs_server_clear_delayed_delegations(server))
687  			ret = true;
688  	}
689  	rcu_read_unlock();
690  out:
691  	return ret;
692  }
693  
694  /**
695   * nfs_client_return_marked_delegations - return previously marked delegations
696   * @clp: nfs_client to process
697   *
698   * Note that this function is designed to be called by the state
699   * manager thread. For this reason, it cannot flush the dirty data,
700   * since that could deadlock in case of a state recovery error.
701   *
702   * Returns zero on success, or a negative errno value.
703   */
704  int nfs_client_return_marked_delegations(struct nfs_client *clp)
705  {
706  	int err = nfs_client_for_each_server(
707  		clp, nfs_server_return_marked_delegations, NULL);
708  	if (err)
709  		return err;
710  	/* If a return was delayed, sleep to prevent hard looping */
711  	if (nfs_client_clear_delayed_delegations(clp))
712  		ssleep(1);
713  	return 0;
714  }
715  
716  /**
717   * nfs_inode_evict_delegation - return delegation, don't reclaim opens
718   * @inode: inode to process
719   *
720   * Does not protect against delegation reclaims, therefore really only safe
721   * to be called from nfs4_clear_inode(). Guaranteed to always free
722   * the delegation structure.
723   */
724  void nfs_inode_evict_delegation(struct inode *inode)
725  {
726  	struct nfs_delegation *delegation;
727  
728  	delegation = nfs_inode_detach_delegation(inode);
729  	if (delegation != NULL) {
730  		set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
731  		set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags);
732  		nfs_do_return_delegation(inode, delegation, 1);
733  		nfs_free_delegation(delegation);
734  	}
735  }
736  
737  /**
738   * nfs4_inode_return_delegation - synchronously return a delegation
739   * @inode: inode to process
740   *
741   * This routine will always flush any dirty data to disk on the
742   * assumption that if we need to return the delegation, then
743   * we should stop caching.
744   *
745   * Returns zero on success, or a negative errno value.
746   */
747  int nfs4_inode_return_delegation(struct inode *inode)
748  {
749  	struct nfs_inode *nfsi = NFS_I(inode);
750  	struct nfs_delegation *delegation;
751  
752  	delegation = nfs_start_delegation_return(nfsi);
753  	if (delegation != NULL) {
754  		/* Synchronous recall of any application leases */
755  		break_lease(inode, O_WRONLY | O_RDWR);
756  		if (S_ISREG(inode->i_mode))
757  			nfs_wb_all(inode);
758  		return nfs_end_delegation_return(inode, delegation, 1);
759  	}
760  	return 0;
761  }
762  
763  /**
764   * nfs4_inode_return_delegation_on_close - asynchronously return a delegation
765   * @inode: inode to process
766   *
767   * This routine is called on file close in order to determine if the
768   * inode delegation needs to be returned immediately.
769   */
770  void nfs4_inode_return_delegation_on_close(struct inode *inode)
771  {
772  	struct nfs_delegation *delegation;
773  	struct nfs_delegation *ret = NULL;
774  
775  	if (!inode)
776  		return;
777  	rcu_read_lock();
778  	delegation = nfs4_get_valid_delegation(inode);
779  	if (!delegation)
780  		goto out;
781  	if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) ||
782  	    atomic_long_read(&nfs_active_delegations) >= nfs_delegation_watermark) {
783  		spin_lock(&delegation->lock);
784  		if (delegation->inode &&
785  		    list_empty(&NFS_I(inode)->open_files) &&
786  		    !test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
787  			clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
788  			/* Refcount matched in nfs_end_delegation_return() */
789  			ret = nfs_get_delegation(delegation);
790  		}
791  		spin_unlock(&delegation->lock);
792  		if (ret)
793  			nfs_clear_verifier_delegated(inode);
794  	}
795  out:
796  	rcu_read_unlock();
797  	nfs_end_delegation_return(inode, ret, 0);
798  }
799  
800  /**
801   * nfs4_inode_make_writeable
802   * @inode: pointer to inode
803   *
804   * Make the inode writeable by returning the delegation if necessary
805   *
806   * Returns zero on success, or a negative errno value.
807   */
808  int nfs4_inode_make_writeable(struct inode *inode)
809  {
810  	struct nfs_delegation *delegation;
811  
812  	rcu_read_lock();
813  	delegation = nfs4_get_valid_delegation(inode);
814  	if (delegation == NULL ||
815  	    (nfs4_has_session(NFS_SERVER(inode)->nfs_client) &&
816  	     (delegation->type & FMODE_WRITE))) {
817  		rcu_read_unlock();
818  		return 0;
819  	}
820  	rcu_read_unlock();
821  	return nfs4_inode_return_delegation(inode);
822  }
823  
824  static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
825  		struct nfs_delegation *delegation)
826  {
827  	set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
828  	set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
829  }
830  
831  static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
832  {
833  	struct nfs_delegation *delegation;
834  	bool ret = false;
835  
836  	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
837  		nfs_mark_return_delegation(server, delegation);
838  		ret = true;
839  	}
840  	return ret;
841  }
842  
843  static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
844  {
845  	struct nfs_server *server;
846  
847  	rcu_read_lock();
848  	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
849  		nfs_server_mark_return_all_delegations(server);
850  	rcu_read_unlock();
851  }
852  
853  static void nfs_delegation_run_state_manager(struct nfs_client *clp)
854  {
855  	if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
856  		nfs4_schedule_state_manager(clp);
857  }
858  
859  /**
860   * nfs_expire_all_delegations
861   * @clp: client to process
862   *
863   */
864  void nfs_expire_all_delegations(struct nfs_client *clp)
865  {
866  	nfs_client_mark_return_all_delegations(clp);
867  	nfs_delegation_run_state_manager(clp);
868  }
869  
870  /**
871   * nfs_server_return_all_delegations - return delegations for one superblock
872   * @server: pointer to nfs_server to process
873   *
874   */
875  void nfs_server_return_all_delegations(struct nfs_server *server)
876  {
877  	struct nfs_client *clp = server->nfs_client;
878  	bool need_wait;
879  
880  	if (clp == NULL)
881  		return;
882  
883  	rcu_read_lock();
884  	need_wait = nfs_server_mark_return_all_delegations(server);
885  	rcu_read_unlock();
886  
887  	if (need_wait) {
888  		nfs4_schedule_state_manager(clp);
889  		nfs4_wait_clnt_recover(clp);
890  	}
891  }
892  
893  static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
894  						 fmode_t flags)
895  {
896  	struct nfs_delegation *delegation;
897  
898  	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
899  		if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
900  			continue;
901  		if (delegation->type & flags)
902  			nfs_mark_return_if_closed_delegation(server, delegation);
903  	}
904  }
905  
906  static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
907  							fmode_t flags)
908  {
909  	struct nfs_server *server;
910  
911  	rcu_read_lock();
912  	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
913  		nfs_mark_return_unused_delegation_types(server, flags);
914  	rcu_read_unlock();
915  }
916  
917  static void nfs_revoke_delegation(struct inode *inode,
918  		const nfs4_stateid *stateid)
919  {
920  	struct nfs_delegation *delegation;
921  	nfs4_stateid tmp;
922  	bool ret = false;
923  
924  	rcu_read_lock();
925  	delegation = rcu_dereference(NFS_I(inode)->delegation);
926  	if (delegation == NULL)
927  		goto out;
928  	if (stateid == NULL) {
929  		nfs4_stateid_copy(&tmp, &delegation->stateid);
930  		stateid = &tmp;
931  	} else {
932  		if (!nfs4_stateid_match_other(stateid, &delegation->stateid))
933  			goto out;
934  		spin_lock(&delegation->lock);
935  		if (stateid->seqid) {
936  			if (nfs4_stateid_is_newer(&delegation->stateid, stateid)) {
937  				spin_unlock(&delegation->lock);
938  				goto out;
939  			}
940  			delegation->stateid.seqid = stateid->seqid;
941  		}
942  		spin_unlock(&delegation->lock);
943  	}
944  	nfs_mark_delegation_revoked(delegation);
945  	ret = true;
946  out:
947  	rcu_read_unlock();
948  	if (ret)
949  		nfs_inode_find_state_and_recover(inode, stateid);
950  }
951  
952  void nfs_remove_bad_delegation(struct inode *inode,
953  		const nfs4_stateid *stateid)
954  {
955  	nfs_revoke_delegation(inode, stateid);
956  }
957  EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
958  
959  void nfs_delegation_mark_returned(struct inode *inode,
960  		const nfs4_stateid *stateid)
961  {
962  	struct nfs_delegation *delegation;
963  
964  	if (!inode)
965  		return;
966  
967  	rcu_read_lock();
968  	delegation = rcu_dereference(NFS_I(inode)->delegation);
969  	if (!delegation)
970  		goto out_rcu_unlock;
971  
972  	spin_lock(&delegation->lock);
973  	if (!nfs4_stateid_match_other(stateid, &delegation->stateid))
974  		goto out_spin_unlock;
975  	if (stateid->seqid) {
976  		/* If delegation->stateid is newer, dont mark as returned */
977  		if (nfs4_stateid_is_newer(&delegation->stateid, stateid))
978  			goto out_clear_returning;
979  		if (delegation->stateid.seqid != stateid->seqid)
980  			delegation->stateid.seqid = stateid->seqid;
981  	}
982  
983  	nfs_mark_delegation_revoked(delegation);
984  	clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
985  	spin_unlock(&delegation->lock);
986  	if (nfs_detach_delegation(NFS_I(inode), delegation, NFS_SERVER(inode)))
987  		nfs_put_delegation(delegation);
988  	goto out_rcu_unlock;
989  
990  out_clear_returning:
991  	clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
992  out_spin_unlock:
993  	spin_unlock(&delegation->lock);
994  out_rcu_unlock:
995  	rcu_read_unlock();
996  
997  	nfs_inode_find_state_and_recover(inode, stateid);
998  }
999  
1000  /**
1001   * nfs_expire_unused_delegation_types
1002   * @clp: client to process
1003   * @flags: delegation types to expire
1004   *
1005   */
1006  void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
1007  {
1008  	nfs_client_mark_return_unused_delegation_types(clp, flags);
1009  	nfs_delegation_run_state_manager(clp);
1010  }
1011  
1012  static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
1013  {
1014  	struct nfs_delegation *delegation;
1015  
1016  	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1017  		if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
1018  			continue;
1019  		nfs_mark_return_if_closed_delegation(server, delegation);
1020  	}
1021  }
1022  
1023  /**
1024   * nfs_expire_unreferenced_delegations - Eliminate unused delegations
1025   * @clp: nfs_client to process
1026   *
1027   */
1028  void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
1029  {
1030  	struct nfs_server *server;
1031  
1032  	rcu_read_lock();
1033  	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1034  		nfs_mark_return_unreferenced_delegations(server);
1035  	rcu_read_unlock();
1036  
1037  	nfs_delegation_run_state_manager(clp);
1038  }
1039  
1040  /**
1041   * nfs_async_inode_return_delegation - asynchronously return a delegation
1042   * @inode: inode to process
1043   * @stateid: state ID information
1044   *
1045   * Returns zero on success, or a negative errno value.
1046   */
1047  int nfs_async_inode_return_delegation(struct inode *inode,
1048  				      const nfs4_stateid *stateid)
1049  {
1050  	struct nfs_server *server = NFS_SERVER(inode);
1051  	struct nfs_client *clp = server->nfs_client;
1052  	struct nfs_delegation *delegation;
1053  
1054  	rcu_read_lock();
1055  	delegation = nfs4_get_valid_delegation(inode);
1056  	if (delegation == NULL)
1057  		goto out_enoent;
1058  	if (stateid != NULL &&
1059  	    !clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
1060  		goto out_enoent;
1061  	nfs_mark_return_delegation(server, delegation);
1062  	rcu_read_unlock();
1063  
1064  	/* If there are any application leases or delegations, recall them */
1065  	break_lease(inode, O_WRONLY | O_RDWR | O_NONBLOCK);
1066  
1067  	nfs_delegation_run_state_manager(clp);
1068  	return 0;
1069  out_enoent:
1070  	rcu_read_unlock();
1071  	return -ENOENT;
1072  }
1073  
1074  static struct inode *
1075  nfs_delegation_find_inode_server(struct nfs_server *server,
1076  				 const struct nfs_fh *fhandle)
1077  {
1078  	struct nfs_delegation *delegation;
1079  	struct super_block *freeme = NULL;
1080  	struct inode *res = NULL;
1081  
1082  	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1083  		spin_lock(&delegation->lock);
1084  		if (delegation->inode != NULL &&
1085  		    !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) &&
1086  		    nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
1087  			if (nfs_sb_active(server->super)) {
1088  				freeme = server->super;
1089  				res = igrab(delegation->inode);
1090  			}
1091  			spin_unlock(&delegation->lock);
1092  			if (res != NULL)
1093  				return res;
1094  			if (freeme) {
1095  				rcu_read_unlock();
1096  				nfs_sb_deactive(freeme);
1097  				rcu_read_lock();
1098  			}
1099  			return ERR_PTR(-EAGAIN);
1100  		}
1101  		spin_unlock(&delegation->lock);
1102  	}
1103  	return ERR_PTR(-ENOENT);
1104  }
1105  
1106  /**
1107   * nfs_delegation_find_inode - retrieve the inode associated with a delegation
1108   * @clp: client state handle
1109   * @fhandle: filehandle from a delegation recall
1110   *
1111   * Returns pointer to inode matching "fhandle," or NULL if a matching inode
1112   * cannot be found.
1113   */
1114  struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
1115  					const struct nfs_fh *fhandle)
1116  {
1117  	struct nfs_server *server;
1118  	struct inode *res;
1119  
1120  	rcu_read_lock();
1121  	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1122  		res = nfs_delegation_find_inode_server(server, fhandle);
1123  		if (res != ERR_PTR(-ENOENT)) {
1124  			rcu_read_unlock();
1125  			return res;
1126  		}
1127  	}
1128  	rcu_read_unlock();
1129  	return ERR_PTR(-ENOENT);
1130  }
1131  
1132  static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
1133  {
1134  	struct nfs_delegation *delegation;
1135  
1136  	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1137  		/*
1138  		 * If the delegation may have been admin revoked, then we
1139  		 * cannot reclaim it.
1140  		 */
1141  		if (test_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags))
1142  			continue;
1143  		set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
1144  	}
1145  }
1146  
1147  /**
1148   * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
1149   * @clp: nfs_client to process
1150   *
1151   */
1152  void nfs_delegation_mark_reclaim(struct nfs_client *clp)
1153  {
1154  	struct nfs_server *server;
1155  
1156  	rcu_read_lock();
1157  	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1158  		nfs_delegation_mark_reclaim_server(server);
1159  	rcu_read_unlock();
1160  }
1161  
1162  static int nfs_server_reap_unclaimed_delegations(struct nfs_server *server,
1163  		void __always_unused *data)
1164  {
1165  	struct nfs_delegation *delegation;
1166  	struct inode *inode;
1167  restart:
1168  	rcu_read_lock();
1169  	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1170  		if (test_bit(NFS_DELEGATION_INODE_FREEING,
1171  					&delegation->flags) ||
1172  		    test_bit(NFS_DELEGATION_RETURNING,
1173  					&delegation->flags) ||
1174  		    test_bit(NFS_DELEGATION_NEED_RECLAIM,
1175  					&delegation->flags) == 0)
1176  			continue;
1177  		inode = nfs_delegation_grab_inode(delegation);
1178  		if (inode == NULL)
1179  			continue;
1180  		delegation = nfs_start_delegation_return_locked(NFS_I(inode));
1181  		rcu_read_unlock();
1182  		if (delegation != NULL) {
1183  			if (nfs_detach_delegation(NFS_I(inode), delegation,
1184  						server) != NULL)
1185  				nfs_free_delegation(delegation);
1186  			/* Match nfs_start_delegation_return_locked */
1187  			nfs_put_delegation(delegation);
1188  		}
1189  		iput(inode);
1190  		cond_resched();
1191  		goto restart;
1192  	}
1193  	rcu_read_unlock();
1194  	return 0;
1195  }
1196  
1197  /**
1198   * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
1199   * @clp: nfs_client to process
1200   *
1201   */
1202  void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
1203  {
1204  	nfs_client_for_each_server(clp, nfs_server_reap_unclaimed_delegations,
1205  			NULL);
1206  }
1207  
1208  static inline bool nfs4_server_rebooted(const struct nfs_client *clp)
1209  {
1210  	return (clp->cl_state & (BIT(NFS4CLNT_CHECK_LEASE) |
1211  				BIT(NFS4CLNT_LEASE_EXPIRED) |
1212  				BIT(NFS4CLNT_SESSION_RESET))) != 0;
1213  }
1214  
1215  static void nfs_mark_test_expired_delegation(struct nfs_server *server,
1216  	    struct nfs_delegation *delegation)
1217  {
1218  	if (delegation->stateid.type == NFS4_INVALID_STATEID_TYPE)
1219  		return;
1220  	clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
1221  	set_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
1222  	set_bit(NFS4CLNT_DELEGATION_EXPIRED, &server->nfs_client->cl_state);
1223  }
1224  
1225  static void nfs_inode_mark_test_expired_delegation(struct nfs_server *server,
1226  		struct inode *inode)
1227  {
1228  	struct nfs_delegation *delegation;
1229  
1230  	rcu_read_lock();
1231  	delegation = rcu_dereference(NFS_I(inode)->delegation);
1232  	if (delegation)
1233  		nfs_mark_test_expired_delegation(server, delegation);
1234  	rcu_read_unlock();
1235  
1236  }
1237  
1238  static void nfs_delegation_mark_test_expired_server(struct nfs_server *server)
1239  {
1240  	struct nfs_delegation *delegation;
1241  
1242  	list_for_each_entry_rcu(delegation, &server->delegations, super_list)
1243  		nfs_mark_test_expired_delegation(server, delegation);
1244  }
1245  
1246  /**
1247   * nfs_mark_test_expired_all_delegations - mark all delegations for testing
1248   * @clp: nfs_client to process
1249   *
1250   * Iterates through all the delegations associated with this server and
1251   * marks them as needing to be checked for validity.
1252   */
1253  void nfs_mark_test_expired_all_delegations(struct nfs_client *clp)
1254  {
1255  	struct nfs_server *server;
1256  
1257  	rcu_read_lock();
1258  	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1259  		nfs_delegation_mark_test_expired_server(server);
1260  	rcu_read_unlock();
1261  }
1262  
1263  /**
1264   * nfs_test_expired_all_delegations - test all delegations for a client
1265   * @clp: nfs_client to process
1266   *
1267   * Helper for handling "recallable state revoked" status from server.
1268   */
1269  void nfs_test_expired_all_delegations(struct nfs_client *clp)
1270  {
1271  	nfs_mark_test_expired_all_delegations(clp);
1272  	nfs4_schedule_state_manager(clp);
1273  }
1274  
1275  static void
1276  nfs_delegation_test_free_expired(struct inode *inode,
1277  		nfs4_stateid *stateid,
1278  		const struct cred *cred)
1279  {
1280  	struct nfs_server *server = NFS_SERVER(inode);
1281  	const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
1282  	int status;
1283  
1284  	if (!cred)
1285  		return;
1286  	status = ops->test_and_free_expired(server, stateid, cred);
1287  	if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
1288  		nfs_remove_bad_delegation(inode, stateid);
1289  }
1290  
1291  static int nfs_server_reap_expired_delegations(struct nfs_server *server,
1292  		void __always_unused *data)
1293  {
1294  	struct nfs_delegation *delegation;
1295  	struct inode *inode;
1296  	const struct cred *cred;
1297  	nfs4_stateid stateid;
1298  restart:
1299  	rcu_read_lock();
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  			continue;
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   */
1341  void 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  
1347  void 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   */
1374  int 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   */
1397  bool 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();
1414  out:
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   */
1428  bool 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);
1449  out:
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   */
1462  bool 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;
1474  out:
1475  	rcu_read_unlock();
1476  	return ret;
1477  }
1478  
1479  module_param_named(delegation_watermark, nfs_delegation_watermark, uint, 0644);
1480