~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
1	2	/*
2	3	* linux/fs/nfs/delegation.c
3	4	*
..	..	@@ -24,13 +25,44 @@
24	25	#include "internal.h"
25	26	#include "nfs4trace.h"
26	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	+
27	62	static void nfs_free_delegation(struct nfs_delegation *delegation)
28	63	{
29		- if (delegation->cred) {
30		- put_rpccred(delegation->cred);
31		- delegation->cred = NULL;
32		- }
33		- kfree_rcu(delegation, rcu);
	64	+ nfs_mark_delegation_revoked(delegation);
	65	+ nfs_put_delegation(delegation);
34	66	}
35	67
36	68	/**
..	..	@@ -41,6 +73,13 @@
41	73	void nfs_mark_delegation_referenced(struct nfs_delegation *delegation)
42	74	{
43	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);
44	83	}
45	84
46	85	static bool
..	..	@@ -146,8 +185,8 @@
146	185	int err;
147	186
148	187	again:
149		- spin_lock(&inode->i_lock);
150		- list_for_each_entry(ctx, &nfsi->open_files, list) {
	188	+ rcu_read_lock();
	189	+ list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
151	190	state = ctx->state;
152	191	if (state == NULL)
153	192	continue;
..	..	@@ -157,16 +196,17 @@
157	196	continue;
158	197	if (!nfs4_stateid_match(&state->stateid, stateid))
159	198	continue;
160		- get_nfs_open_context(ctx);
161		- spin_unlock(&inode->i_lock);
	199	+ if (!get_nfs_open_context(ctx))
	200	+ continue;
	201	+ rcu_read_unlock();
162	202	sp = state->owner;
163	203	/* Block nfs4_proc_unlck */
164	204	mutex_lock(&sp->so_delegreturn_mutex);
165		- seq = read_seqbegin(&sp->so_reclaim_seqlock);
	205	+ seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
166	206	err = nfs4_open_delegation_recall(ctx, state, stateid);
167	207	if (!err)
168	208	err = nfs_delegation_claim_locks(state, stateid);
169		- if (!err && read_seqretry(&sp->so_reclaim_seqlock, seq))
	209	+ if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
170	210	err = -EAGAIN;
171	211	mutex_unlock(&sp->so_delegreturn_mutex);
172	212	put_nfs_open_context(ctx);
..	..	@@ -174,7 +214,7 @@
174	214	return err;
175	215	goto again;
176	216	}
177		- spin_unlock(&inode->i_lock);
	217	+ rcu_read_unlock();
178	218	return 0;
179	219	}
180	220
..	..	@@ -187,49 +227,51 @@
187	227	* @pagemod_limit: write delegation "space_limit"
188	228	*
189	229	*/
190		-void nfs_inode_reclaim_delegation(struct inode inode, struct rpc_cred cred,
191		- fmode_t type,
192		- const nfs4_stateid *stateid,
	230	+void nfs_inode_reclaim_delegation(struct inode inode, const struct cred cred,
	231	+ fmode_t type, const nfs4_stateid *stateid,
193	232	unsigned long pagemod_limit)
194	233	{
195	234	struct nfs_delegation *delegation;
196		- struct rpc_cred *oldcred = NULL;
	235	+ const struct cred *oldcred = NULL;
197	236
198	237	rcu_read_lock();
199	238	delegation = rcu_dereference(NFS_I(inode)->delegation);
200	239	if (delegation != NULL) {
201	240	spin_lock(&delegation->lock);
202		- if (delegation->inode != NULL) {
203		- nfs4_stateid_copy(&delegation->stateid, stateid);
204		- delegation->type = type;
205		- delegation->pagemod_limit = pagemod_limit;
206		- oldcred = delegation->cred;
207		- delegation->cred = get_rpccred(cred);
208		- clear_bit(NFS_DELEGATION_NEED_RECLAIM,
209		- &delegation->flags);
210		- spin_unlock(&delegation->lock);
211		- rcu_read_unlock();
212		- put_rpccred(oldcred);
213		- trace_nfs4_reclaim_delegation(inode, type);
214		- return;
215		- }
216		- /* We appear to have raced with a delegation return. */
	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);
217	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);
218	258	}
219		- rcu_read_unlock();
220		- nfs_inode_set_delegation(inode, cred, type, stateid, pagemod_limit);
221	259	}
222	260
223	261	static int nfs_do_return_delegation(struct inode inode, struct nfs_delegation delegation, int issync)
224	262	{
	263	+ const struct cred *cred;
225	264	int res = 0;
226	265
227		- if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
228		- res = nfs4_proc_delegreturn(inode,
229		- delegation->cred,
	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,
230	271	&delegation->stateid,
231	272	issync);
232		- nfs_free_delegation(delegation);
	273	+ put_cred(cred);
	274	+ }
233	275	return res;
234	276	}
235	277
..	..	@@ -255,9 +297,14 @@
255	297	if (delegation == NULL)
256	298	goto out;
257	299	spin_lock(&delegation->lock);
258		- if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
259		- ret = delegation;
	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	+ }
260	305	spin_unlock(&delegation->lock);
	306	+ if (ret)
	307	+ nfs_clear_verifier_delegated(&nfsi->vfs_inode);
261	308	out:
262	309	return ret;
263	310	}
..	..	@@ -273,16 +320,17 @@
273	320	return delegation;
274	321	}
275	322
276		-static void
277		-nfs_abort_delegation_return(struct nfs_delegation *delegation,
278		- struct nfs_client *clp)
	323	+static void nfs_abort_delegation_return(struct nfs_delegation *delegation,
	324	+ struct nfs_client *clp, int err)
279	325	{
280	326
281	327	spin_lock(&delegation->lock);
282	328	clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
283		- set_bit(NFS_DELEGATION_RETURN, &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	+ }
284	333	spin_unlock(&delegation->lock);
285		- set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
286	334	}
287	335
288	336	static struct nfs_delegation *
..	..	@@ -298,7 +346,10 @@
298	346	return NULL;
299	347
300	348	spin_lock(&delegation->lock);
301		- set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
	349	+ if (!delegation->inode) {
	350	+ spin_unlock(&delegation->lock);
	351	+ return NULL;
	352	+ }
302	353	list_del_rcu(&delegation->super_list);
303	354	delegation->inode = NULL;
304	355	rcu_assign_pointer(nfsi->delegation, NULL);
..	..	@@ -325,10 +376,24 @@
325	376	struct nfs_server *server = NFS_SERVER(inode);
326	377	struct nfs_delegation *delegation;
327	378
328		- delegation = nfs_start_delegation_return(nfsi);
329		- if (delegation == NULL)
330		- return NULL;
331		- return nfs_detach_delegation(nfsi, delegation, server);
	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	+ }
332	397	}
333	398
334	399	static void
..	..	@@ -339,6 +404,14 @@
339	404	delegation->stateid.seqid = update->stateid.seqid;
340	405	smp_wmb();
341	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	+ }
342	415	}
343	416	}
344	417
..	..	@@ -352,7 +425,7 @@
352	425	*
353	426	* Returns zero on success, or a negative errno value.
354	427	*/
355		-int nfs_inode_set_delegation(struct inode inode, struct rpc_cred cred,
	428	+int nfs_inode_set_delegation(struct inode inode, const struct cred cred,
356	429	fmode_t type,
357	430	const nfs4_stateid *stateid,
358	431	unsigned long pagemod_limit)
..	..	@@ -368,10 +441,11 @@
368	441	if (delegation == NULL)
369	442	return -ENOMEM;
370	443	nfs4_stateid_copy(&delegation->stateid, stateid);
	444	+ refcount_set(&delegation->refcount, 1);
371	445	delegation->type = type;
372	446	delegation->pagemod_limit = pagemod_limit;
373	447	delegation->change_attr = inode_peek_iversion_raw(inode);
374		- delegation->cred = get_rpccred(cred);
	448	+ delegation->cred = get_cred(cred);
375	449	delegation->inode = inode;
376	450	delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
377	451	spin_lock_init(&delegation->lock);
..	..	@@ -379,14 +453,18 @@
379	453	spin_lock(&clp->cl_lock);
380	454	old_delegation = rcu_dereference_protected(nfsi->delegation,
381	455	lockdep_is_held(&clp->cl_lock));
382		- if (old_delegation != NULL) {
383		- /* Is this an update of the existing delegation? */
384		- if (nfs4_stateid_match_other(&old_delegation->stateid,
385		- &delegation->stateid)) {
386		- nfs_update_inplace_delegation(old_delegation,
387		- delegation);
388		- goto out;
389		- }
	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)) {
390	468	/*
391	469	* Deal with broken servers that hand out two
392	470	* delegations for the same file.
..	..	@@ -405,14 +483,16 @@
405	483	if (test_and_set_bit(NFS_DELEGATION_RETURNING,
406	484	&old_delegation->flags))
407	485	goto out;
408		- freeme = nfs_detach_delegation_locked(nfsi,
409		- old_delegation, clp);
410		- if (freeme == NULL)
411		- goto out;
412	486	}
	487	+ freeme = nfs_detach_delegation_locked(nfsi, old_delegation, clp);
	488	+ if (freeme == NULL)
	489	+ goto out;
	490	+add_new:
413	491	list_add_tail_rcu(&delegation->super_list, &server->delegations);
414	492	rcu_assign_pointer(nfsi->delegation, delegation);
415	493	delegation = NULL;
	494	+
	495	+ atomic_long_inc(&nfs_active_delegations);
416	496
417	497	trace_nfs4_set_delegation(inode, type);
418	498
..	..	@@ -423,9 +503,11 @@
423	503	out:
424	504	spin_unlock(&clp->cl_lock);
425	505	if (delegation != NULL)
426		- nfs_free_delegation(delegation);
427		- if (freeme != NULL)
	506	+ __nfs_free_delegation(delegation);
	507	+ if (freeme != NULL) {
428	508	nfs_do_return_delegation(inode, freeme, 0);
	509	+ nfs_free_delegation(freeme);
	510	+ }
429	511	return status;
430	512	}
431	513
..	..	@@ -435,7 +517,6 @@
435	517	static int nfs_end_delegation_return(struct inode inode, struct nfs_delegation delegation, int issync)
436	518	{
437	519	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
438		- struct nfs_inode *nfsi = NFS_I(inode);
439	520	int err = 0;
440	521
441	522	if (delegation == NULL)
..	..	@@ -454,14 +535,14 @@
454	535	} while (err == 0);
455	536
456	537	if (err) {
457		- nfs_abort_delegation_return(delegation, clp);
	538	+ nfs_abort_delegation_return(delegation, clp, err);
458	539	goto out;
459	540	}
460		- if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
461		- goto out;
462	541
463	542	err = nfs_do_return_delegation(inode, delegation, issync);
464	543	out:
	544	+ /* Refcount matched in nfs_start_delegation_return_locked() */
	545	+ nfs_put_delegation(delegation);
465	546	return err;
466	547	}
467	548
..	..	@@ -469,11 +550,9 @@
469	550	{
470	551	bool ret = false;
471	552
472		- if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
473		- goto out;
474	553	if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
475	554	ret = true;
476		- if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
	555	+ else if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags)) {
477	556	struct inode *inode;
478	557
479	558	spin_lock(&delegation->lock);
..	..	@@ -482,6 +561,117 @@
482	561	ret = true;
483	562	spin_unlock(&delegation->lock);
484	563	}
	564	+ if (ret)
	565	+ clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
	566	+ if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags) \|\|
	567	+ test_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags) \|\|
	568	+ test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
	569	+ ret = false;
	570	+
	571	+ return ret;
	572	+}
	573	+
	574	+static int nfs_server_return_marked_delegations(struct nfs_server *server,
	575	+ void __always_unused *data)
	576	+{
	577	+ struct nfs_delegation *delegation;
	578	+ struct nfs_delegation *prev;
	579	+ struct inode *inode;
	580	+ struct inode *place_holder = NULL;
	581	+ struct nfs_delegation *place_holder_deleg = NULL;
	582	+ int err = 0;
	583	+
	584	+restart:
	585	+ /*
	586	+ * To avoid quadratic looping we hold a reference
	587	+ * to an inode place_holder. Each time we restart, we
	588	+ * list delegation in the server from the delegations
	589	+ * of that inode.
	590	+ * prev is an RCU-protected pointer to a delegation which
	591	+ * wasn't marked for return and might be a good choice for
	592	+ * the next place_holder.
	593	+ */
	594	+ prev = NULL;
	595	+ delegation = NULL;
	596	+ rcu_read_lock();
	597	+ if (place_holder)
	598	+ delegation = rcu_dereference(NFS_I(place_holder)->delegation);
	599	+ if (!delegation \|\| delegation != place_holder_deleg)
	600	+ delegation = list_entry_rcu(server->delegations.next,
	601	+ struct nfs_delegation, super_list);
	602	+ list_for_each_entry_from_rcu(delegation, &server->delegations, super_list) {
	603	+ struct inode *to_put = NULL;
	604	+
	605	+ if (test_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags))
	606	+ continue;
	607	+ if (!nfs_delegation_need_return(delegation)) {
	608	+ if (nfs4_is_valid_delegation(delegation, 0))
	609	+ prev = delegation;
	610	+ continue;
	611	+ }
	612	+
	613	+ if (prev) {
	614	+ struct inode *tmp = nfs_delegation_grab_inode(prev);
	615	+ if (tmp) {
	616	+ to_put = place_holder;
	617	+ place_holder = tmp;
	618	+ place_holder_deleg = prev;
	619	+ }
	620	+ }
	621	+
	622	+ inode = nfs_delegation_grab_inode(delegation);
	623	+ if (inode == NULL) {
	624	+ rcu_read_unlock();
	625	+ iput(to_put);
	626	+ goto restart;
	627	+ }
	628	+ delegation = nfs_start_delegation_return_locked(NFS_I(inode));
	629	+ rcu_read_unlock();
	630	+
	631	+ iput(to_put);
	632	+
	633	+ err = nfs_end_delegation_return(inode, delegation, 0);
	634	+ iput(inode);
	635	+ cond_resched();
	636	+ if (!err)
	637	+ goto restart;
	638	+ set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
	639	+ goto out;
	640	+ }
	641	+ rcu_read_unlock();
	642	+out:
	643	+ iput(place_holder);
	644	+ return err;
	645	+}
	646	+
	647	+static bool nfs_server_clear_delayed_delegations(struct nfs_server *server)
	648	+{
	649	+ struct nfs_delegation *d;
	650	+ bool ret = false;
	651	+
	652	+ list_for_each_entry_rcu (d, &server->delegations, super_list) {
	653	+ if (!test_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags))
	654	+ continue;
	655	+ nfs_mark_return_delegation(server, d);
	656	+ clear_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags);
	657	+ ret = true;
	658	+ }
	659	+ return ret;
	660	+}
	661	+
	662	+static bool nfs_client_clear_delayed_delegations(struct nfs_client *clp)
	663	+{
	664	+ struct nfs_server *server;
	665	+ bool ret = false;
	666	+
	667	+ if (!test_and_clear_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state))
	668	+ goto out;
	669	+ rcu_read_lock();
	670	+ list_for_each_entry_rcu (server, &clp->cl_superblocks, client_link) {
	671	+ if (nfs_server_clear_delayed_delegations(server))
	672	+ ret = true;
	673	+ }
	674	+ rcu_read_unlock();
485	675	out:
486	676	return ret;
487	677	}
..	..	@@ -498,106 +688,35 @@
498	688	*/
499	689	int nfs_client_return_marked_delegations(struct nfs_client *clp)
500	690	{
501		- struct nfs_delegation *delegation;
502		- struct nfs_delegation *prev;
503		- struct nfs_server *server;
504		- struct inode *inode;
505		- struct inode *place_holder = NULL;
506		- struct nfs_delegation *place_holder_deleg = NULL;
507		- int err = 0;
508		-
509		-restart:
510		- /*
511		- * To avoid quadratic looping we hold a reference
512		- * to an inode place_holder. Each time we restart, we
513		- * list nfs_servers from the server of that inode, and
514		- * delegation in the server from the delegations of that
515		- * inode.
516		- * prev is an RCU-protected pointer to a delegation which
517		- * wasn't marked for return and might be a good choice for
518		- * the next place_holder.
519		- */
520		- rcu_read_lock();
521		- prev = NULL;
522		- if (place_holder)
523		- server = NFS_SERVER(place_holder);
524		- else
525		- server = list_entry_rcu(clp->cl_superblocks.next,
526		- struct nfs_server, client_link);
527		- list_for_each_entry_from_rcu(server, &clp->cl_superblocks, client_link) {
528		- delegation = NULL;
529		- if (place_holder && server == NFS_SERVER(place_holder))
530		- delegation = rcu_dereference(NFS_I(place_holder)->delegation);
531		- if (!delegation \|\| delegation != place_holder_deleg)
532		- delegation = list_entry_rcu(server->delegations.next,
533		- struct nfs_delegation, super_list);
534		- list_for_each_entry_from_rcu(delegation, &server->delegations, super_list) {
535		- struct inode *to_put = NULL;
536		-
537		- if (!nfs_delegation_need_return(delegation)) {
538		- prev = delegation;
539		- continue;
540		- }
541		- if (!nfs_sb_active(server->super))
542		- break; /* continue in outer loop */
543		-
544		- if (prev) {
545		- struct inode *tmp;
546		-
547		- tmp = nfs_delegation_grab_inode(prev);
548		- if (tmp) {
549		- to_put = place_holder;
550		- place_holder = tmp;
551		- place_holder_deleg = prev;
552		- }
553		- }
554		-
555		- inode = nfs_delegation_grab_inode(delegation);
556		- if (inode == NULL) {
557		- rcu_read_unlock();
558		- if (to_put)
559		- iput(to_put);
560		- nfs_sb_deactive(server->super);
561		- goto restart;
562		- }
563		- delegation = nfs_start_delegation_return_locked(NFS_I(inode));
564		- rcu_read_unlock();
565		-
566		- if (to_put)
567		- iput(to_put);
568		-
569		- err = nfs_end_delegation_return(inode, delegation, 0);
570		- iput(inode);
571		- nfs_sb_deactive(server->super);
572		- cond_resched();
573		- if (!err)
574		- goto restart;
575		- set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
576		- if (place_holder)
577		- iput(place_holder);
578		- return err;
579		- }
580		- }
581		- rcu_read_unlock();
582		- if (place_holder)
583		- iput(place_holder);
	691	+ int err = nfs_client_for_each_server(
	692	+ clp, nfs_server_return_marked_delegations, NULL);
	693	+ if (err)
	694	+ return err;
	695	+ /* If a return was delayed, sleep to prevent hard looping */
	696	+ if (nfs_client_clear_delayed_delegations(clp))
	697	+ ssleep(1);
584	698	return 0;
585	699	}
586	700
587	701	/**
588		- * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
	702	+ * nfs_inode_evict_delegation - return delegation, don't reclaim opens
589	703	* @inode: inode to process
590	704	*
591	705	* Does not protect against delegation reclaims, therefore really only safe
592		- * to be called from nfs4_clear_inode().
	706	+ * to be called from nfs4_clear_inode(). Guaranteed to always free
	707	+ * the delegation structure.
593	708	*/
594		-void nfs_inode_return_delegation_noreclaim(struct inode *inode)
	709	+void nfs_inode_evict_delegation(struct inode *inode)
595	710	{
596	711	struct nfs_delegation *delegation;
597	712
598	713	delegation = nfs_inode_detach_delegation(inode);
599		- if (delegation != NULL)
	714	+ if (delegation != NULL) {
	715	+ set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
	716	+ set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags);
600	717	nfs_do_return_delegation(inode, delegation, 1);
	718	+ nfs_free_delegation(delegation);
	719	+ }
601	720	}
602	721
603	722	/**
..	..	@@ -624,6 +743,43 @@
624	743	}
625	744
626	745	/**
	746	+ * nfs_inode_return_delegation_on_close - asynchronously return a delegation
	747	+ * @inode: inode to process
	748	+ *
	749	+ * This routine is called on file close in order to determine if the
	750	+ * inode delegation needs to be returned immediately.
	751	+ */
	752	+void nfs4_inode_return_delegation_on_close(struct inode *inode)
	753	+{
	754	+ struct nfs_delegation *delegation;
	755	+ struct nfs_delegation *ret = NULL;
	756	+
	757	+ if (!inode)
	758	+ return;
	759	+ rcu_read_lock();
	760	+ delegation = nfs4_get_valid_delegation(inode);
	761	+ if (!delegation)
	762	+ goto out;
	763	+ if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) \|\|
	764	+ atomic_long_read(&nfs_active_delegations) >= nfs_delegation_watermark) {
	765	+ spin_lock(&delegation->lock);
	766	+ if (delegation->inode &&
	767	+ list_empty(&NFS_I(inode)->open_files) &&
	768	+ !test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
	769	+ clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
	770	+ /* Refcount matched in nfs_end_delegation_return() */
	771	+ ret = nfs_get_delegation(delegation);
	772	+ }
	773	+ spin_unlock(&delegation->lock);
	774	+ if (ret)
	775	+ nfs_clear_verifier_delegated(inode);
	776	+ }
	777	+out:
	778	+ rcu_read_unlock();
	779	+ nfs_end_delegation_return(inode, ret, 0);
	780	+}
	781	+
	782	+/**
627	783	* nfs4_inode_make_writeable
628	784	* @inode: pointer to inode
629	785	*
..	..	@@ -633,23 +789,24 @@
633	789	*/
634	790	int nfs4_inode_make_writeable(struct inode *inode)
635	791	{
636		- if (!nfs4_has_session(NFS_SERVER(inode)->nfs_client) \|\|
637		- !nfs4_check_delegation(inode, FMODE_WRITE))
638		- return nfs4_inode_return_delegation(inode);
639		- return 0;
	792	+ struct nfs_delegation *delegation;
	793	+
	794	+ rcu_read_lock();
	795	+ delegation = nfs4_get_valid_delegation(inode);
	796	+ if (delegation == NULL \|\|
	797	+ (nfs4_has_session(NFS_SERVER(inode)->nfs_client) &&
	798	+ (delegation->type & FMODE_WRITE))) {
	799	+ rcu_read_unlock();
	800	+ return 0;
	801	+ }
	802	+ rcu_read_unlock();
	803	+ return nfs4_inode_return_delegation(inode);
640	804	}
641	805
642	806	static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
643	807	struct nfs_delegation *delegation)
644	808	{
645	809	set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
646		- set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
647		-}
648		-
649		-static void nfs_mark_return_delegation(struct nfs_server *server,
650		- struct nfs_delegation *delegation)
651		-{
652		- set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
653	810	set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
654	811	}
655	812
..	..	@@ -694,7 +851,7 @@
694	851
695	852	/**
696	853	* nfs_super_return_all_delegations - return delegations for one superblock
697		- * @sb: sb to process
	854	+ * @server: pointer to nfs_server to process
698	855	*
699	856	*/
700	857	void nfs_server_return_all_delegations(struct nfs_server *server)
..	..	@@ -739,15 +896,7 @@
739	896	rcu_read_unlock();
740	897	}
741	898
742		-static void nfs_mark_delegation_revoked(struct nfs_server *server,
743		- struct nfs_delegation *delegation)
744		-{
745		- set_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
746		- delegation->stateid.type = NFS4_INVALID_STATEID_TYPE;
747		- nfs_mark_return_delegation(server, delegation);
748		-}
749		-
750		-static bool nfs_revoke_delegation(struct inode *inode,
	899	+static void nfs_revoke_delegation(struct inode *inode,
751	900	const nfs4_stateid *stateid)
752	901	{
753	902	struct nfs_delegation *delegation;
..	..	@@ -761,29 +910,69 @@
761	910	if (stateid == NULL) {
762	911	nfs4_stateid_copy(&tmp, &delegation->stateid);
763	912	stateid = &tmp;
764		- } else if (!nfs4_stateid_match(stateid, &delegation->stateid))
765		- goto out;
766		- nfs_mark_delegation_revoked(NFS_SERVER(inode), delegation);
	913	+ } else {
	914	+ if (!nfs4_stateid_match_other(stateid, &delegation->stateid))
	915	+ goto out;
	916	+ spin_lock(&delegation->lock);
	917	+ if (stateid->seqid) {
	918	+ if (nfs4_stateid_is_newer(&delegation->stateid, stateid)) {
	919	+ spin_unlock(&delegation->lock);
	920	+ goto out;
	921	+ }
	922	+ delegation->stateid.seqid = stateid->seqid;
	923	+ }
	924	+ spin_unlock(&delegation->lock);
	925	+ }
	926	+ nfs_mark_delegation_revoked(delegation);
767	927	ret = true;
768	928	out:
769	929	rcu_read_unlock();
770	930	if (ret)
771	931	nfs_inode_find_state_and_recover(inode, stateid);
772		- return ret;
773	932	}
774	933
775	934	void nfs_remove_bad_delegation(struct inode *inode,
776	935	const nfs4_stateid *stateid)
777	936	{
778		- struct nfs_delegation *delegation;
779		-
780		- if (!nfs_revoke_delegation(inode, stateid))
781		- return;
782		- delegation = nfs_inode_detach_delegation(inode);
783		- if (delegation)
784		- nfs_free_delegation(delegation);
	937	+ nfs_revoke_delegation(inode, stateid);
785	938	}
786	939	EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
	940	+
	941	+void nfs_delegation_mark_returned(struct inode *inode,
	942	+ const nfs4_stateid *stateid)
	943	+{
	944	+ struct nfs_delegation *delegation;
	945	+
	946	+ if (!inode)
	947	+ return;
	948	+
	949	+ rcu_read_lock();
	950	+ delegation = rcu_dereference(NFS_I(inode)->delegation);
	951	+ if (!delegation)
	952	+ goto out_rcu_unlock;
	953	+
	954	+ spin_lock(&delegation->lock);
	955	+ if (!nfs4_stateid_match_other(stateid, &delegation->stateid))
	956	+ goto out_spin_unlock;
	957	+ if (stateid->seqid) {
	958	+ /* If delegation->stateid is newer, dont mark as returned */
	959	+ if (nfs4_stateid_is_newer(&delegation->stateid, stateid))
	960	+ goto out_clear_returning;
	961	+ if (delegation->stateid.seqid != stateid->seqid)
	962	+ delegation->stateid.seqid = stateid->seqid;
	963	+ }
	964	+
	965	+ nfs_mark_delegation_revoked(delegation);
	966	+
	967	+out_clear_returning:
	968	+ clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
	969	+out_spin_unlock:
	970	+ spin_unlock(&delegation->lock);
	971	+out_rcu_unlock:
	972	+ rcu_read_unlock();
	973	+
	974	+ nfs_inode_find_state_and_recover(inode, stateid);
	975	+}
787	976
788	977	/**
789	978	* nfs_expire_unused_delegation_types
..	..	@@ -840,7 +1029,7 @@
840	1029	struct nfs_delegation *delegation;
841	1030
842	1031	rcu_read_lock();
843		- delegation = rcu_dereference(NFS_I(inode)->delegation);
	1032	+ delegation = nfs4_get_valid_delegation(inode);
844	1033	if (delegation == NULL)
845	1034	goto out_enoent;
846	1035	if (stateid != NULL &&
..	..	@@ -861,21 +1050,24 @@
861	1050	const struct nfs_fh *fhandle)
862	1051	{
863	1052	struct nfs_delegation *delegation;
864		- struct inode freeme, res = NULL;
	1053	+ struct super_block *freeme = NULL;
	1054	+ struct inode *res = NULL;
865	1055
866	1056	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
867	1057	spin_lock(&delegation->lock);
868	1058	if (delegation->inode != NULL &&
	1059	+ !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) &&
869	1060	nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
870		- freeme = igrab(delegation->inode);
871		- if (freeme && nfs_sb_active(freeme->i_sb))
872		- res = freeme;
	1061	+ if (nfs_sb_active(server->super)) {
	1062	+ freeme = server->super;
	1063	+ res = igrab(delegation->inode);
	1064	+ }
873	1065	spin_unlock(&delegation->lock);
874	1066	if (res != NULL)
875	1067	return res;
876	1068	if (freeme) {
877	1069	rcu_read_unlock();
878		- iput(freeme);
	1070	+ nfs_sb_deactive(freeme);
879	1071	rcu_read_lock();
880	1072	}
881	1073	return ERR_PTR(-EAGAIN);
..	..	@@ -941,6 +1133,42 @@
941	1133	rcu_read_unlock();
942	1134	}
943	1135
	1136	+static int nfs_server_reap_unclaimed_delegations(struct nfs_server *server,
	1137	+ void __always_unused *data)
	1138	+{
	1139	+ struct nfs_delegation *delegation;
	1140	+ struct inode *inode;
	1141	+restart:
	1142	+ rcu_read_lock();
	1143	+restart_locked:
	1144	+ list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
	1145	+ if (test_bit(NFS_DELEGATION_INODE_FREEING,
	1146	+ &delegation->flags) \|\|
	1147	+ test_bit(NFS_DELEGATION_RETURNING,
	1148	+ &delegation->flags) \|\|
	1149	+ test_bit(NFS_DELEGATION_NEED_RECLAIM,
	1150	+ &delegation->flags) == 0)
	1151	+ continue;
	1152	+ inode = nfs_delegation_grab_inode(delegation);
	1153	+ if (inode == NULL)
	1154	+ goto restart_locked;
	1155	+ delegation = nfs_start_delegation_return_locked(NFS_I(inode));
	1156	+ rcu_read_unlock();
	1157	+ if (delegation != NULL) {
	1158	+ if (nfs_detach_delegation(NFS_I(inode), delegation,
	1159	+ server) != NULL)
	1160	+ nfs_free_delegation(delegation);
	1161	+ /* Match nfs_start_delegation_return_locked */
	1162	+ nfs_put_delegation(delegation);
	1163	+ }
	1164	+ iput(inode);
	1165	+ cond_resched();
	1166	+ goto restart;
	1167	+ }
	1168	+ rcu_read_unlock();
	1169	+ return 0;
	1170	+}
	1171	+
944	1172	/**
945	1173	* nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
946	1174	* @clp: nfs_client to process
..	..	@@ -948,45 +1176,8 @@
948	1176	*/
949	1177	void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
950	1178	{
951		- struct nfs_delegation *delegation;
952		- struct nfs_server *server;
953		- struct inode *inode;
954		-
955		-restart:
956		- rcu_read_lock();
957		- list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
958		- list_for_each_entry_rcu(delegation, &server->delegations,
959		- super_list) {
960		- if (test_bit(NFS_DELEGATION_INODE_FREEING,
961		- &delegation->flags) \|\|
962		- test_bit(NFS_DELEGATION_RETURNING,
963		- &delegation->flags) \|\|
964		- test_bit(NFS_DELEGATION_NEED_RECLAIM,
965		- &delegation->flags) == 0)
966		- continue;
967		- if (!nfs_sb_active(server->super))
968		- break; /* continue in outer loop */
969		- inode = nfs_delegation_grab_inode(delegation);
970		- if (inode == NULL) {
971		- rcu_read_unlock();
972		- nfs_sb_deactive(server->super);
973		- goto restart;
974		- }
975		- delegation = nfs_start_delegation_return_locked(NFS_I(inode));
976		- rcu_read_unlock();
977		- if (delegation != NULL) {
978		- delegation = nfs_detach_delegation(NFS_I(inode),
979		- delegation, server);
980		- if (delegation != NULL)
981		- nfs_free_delegation(delegation);
982		- }
983		- iput(inode);
984		- nfs_sb_deactive(server->super);
985		- cond_resched();
986		- goto restart;
987		- }
988		- }
989		- rcu_read_unlock();
	1179	+ nfs_client_for_each_server(clp, nfs_server_reap_unclaimed_delegations,
	1180	+ NULL);
990	1181	}
991	1182
992	1183	static inline bool nfs4_server_rebooted(const struct nfs_client *clp)
..	..	@@ -1045,6 +1236,76 @@
1045	1236	}
1046	1237
1047	1238	/**
	1239	+ * nfs_test_expired_all_delegations - test all delegations for a client
	1240	+ * @clp: nfs_client to process
	1241	+ *
	1242	+ * Helper for handling "recallable state revoked" status from server.
	1243	+ */
	1244	+void nfs_test_expired_all_delegations(struct nfs_client *clp)
	1245	+{
	1246	+ nfs_mark_test_expired_all_delegations(clp);
	1247	+ nfs4_schedule_state_manager(clp);
	1248	+}
	1249	+
	1250	+static void
	1251	+nfs_delegation_test_free_expired(struct inode *inode,
	1252	+ nfs4_stateid *stateid,
	1253	+ const struct cred *cred)
	1254	+{
	1255	+ struct nfs_server *server = NFS_SERVER(inode);
	1256	+ const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
	1257	+ int status;
	1258	+
	1259	+ if (!cred)
	1260	+ return;
	1261	+ status = ops->test_and_free_expired(server, stateid, cred);
	1262	+ if (status == -NFS4ERR_EXPIRED \|\| status == -NFS4ERR_BAD_STATEID)
	1263	+ nfs_remove_bad_delegation(inode, stateid);
	1264	+}
	1265	+
	1266	+static int nfs_server_reap_expired_delegations(struct nfs_server *server,
	1267	+ void __always_unused *data)
	1268	+{
	1269	+ struct nfs_delegation *delegation;
	1270	+ struct inode *inode;
	1271	+ const struct cred *cred;
	1272	+ nfs4_stateid stateid;
	1273	+restart:
	1274	+ rcu_read_lock();
	1275	+restart_locked:
	1276	+ list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
	1277	+ if (test_bit(NFS_DELEGATION_INODE_FREEING,
	1278	+ &delegation->flags) \|\|
	1279	+ test_bit(NFS_DELEGATION_RETURNING,
	1280	+ &delegation->flags) \|\|
	1281	+ test_bit(NFS_DELEGATION_TEST_EXPIRED,
	1282	+ &delegation->flags) == 0)
	1283	+ continue;
	1284	+ inode = nfs_delegation_grab_inode(delegation);
	1285	+ if (inode == NULL)
	1286	+ goto restart_locked;
	1287	+ spin_lock(&delegation->lock);
	1288	+ cred = get_cred_rcu(delegation->cred);
	1289	+ nfs4_stateid_copy(&stateid, &delegation->stateid);
	1290	+ spin_unlock(&delegation->lock);
	1291	+ clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
	1292	+ rcu_read_unlock();
	1293	+ nfs_delegation_test_free_expired(inode, &stateid, cred);
	1294	+ put_cred(cred);
	1295	+ if (!nfs4_server_rebooted(server->nfs_client)) {
	1296	+ iput(inode);
	1297	+ cond_resched();
	1298	+ goto restart;
	1299	+ }
	1300	+ nfs_inode_mark_test_expired_delegation(server,inode);
	1301	+ iput(inode);
	1302	+ return -EAGAIN;
	1303	+ }
	1304	+ rcu_read_unlock();
	1305	+ return 0;
	1306	+}
	1307	+
	1308	+/**
1048	1309	* nfs_reap_expired_delegations - reap expired delegations
1049	1310	* @clp: nfs_client to process
1050	1311	*
..	..	@@ -1055,56 +1316,8 @@
1055	1316	*/
1056	1317	void nfs_reap_expired_delegations(struct nfs_client *clp)
1057	1318	{
1058		- const struct nfs4_minor_version_ops *ops = clp->cl_mvops;
1059		- struct nfs_delegation *delegation;
1060		- struct nfs_server *server;
1061		- struct inode *inode;
1062		- struct rpc_cred *cred;
1063		- nfs4_stateid stateid;
1064		-
1065		-restart:
1066		- rcu_read_lock();
1067		- list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1068		- list_for_each_entry_rcu(delegation, &server->delegations,
1069		- super_list) {
1070		- if (test_bit(NFS_DELEGATION_INODE_FREEING,
1071		- &delegation->flags) \|\|
1072		- test_bit(NFS_DELEGATION_RETURNING,
1073		- &delegation->flags) \|\|
1074		- test_bit(NFS_DELEGATION_TEST_EXPIRED,
1075		- &delegation->flags) == 0)
1076		- continue;
1077		- if (!nfs_sb_active(server->super))
1078		- break; /* continue in outer loop */
1079		- inode = nfs_delegation_grab_inode(delegation);
1080		- if (inode == NULL) {
1081		- rcu_read_unlock();
1082		- nfs_sb_deactive(server->super);
1083		- goto restart;
1084		- }
1085		- cred = get_rpccred_rcu(delegation->cred);
1086		- nfs4_stateid_copy(&stateid, &delegation->stateid);
1087		- clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
1088		- rcu_read_unlock();
1089		- if (cred != NULL &&
1090		- ops->test_and_free_expired(server, &stateid, cred) < 0) {
1091		- nfs_revoke_delegation(inode, &stateid);
1092		- nfs_inode_find_state_and_recover(inode, &stateid);
1093		- }
1094		- put_rpccred(cred);
1095		- if (nfs4_server_rebooted(clp)) {
1096		- nfs_inode_mark_test_expired_delegation(server,inode);
1097		- iput(inode);
1098		- nfs_sb_deactive(server->super);
1099		- return;
1100		- }
1101		- iput(inode);
1102		- nfs_sb_deactive(server->super);
1103		- cond_resched();
1104		- goto restart;
1105		- }
1106		- }
1107		- rcu_read_unlock();
	1319	+ nfs_client_for_each_server(clp, nfs_server_reap_expired_delegations,
	1320	+ NULL);
1108	1321	}
1109	1322
1110	1323	void nfs_inode_find_delegation_state_and_recover(struct inode *inode,
..	..	@@ -1117,7 +1330,8 @@
1117	1330	rcu_read_lock();
1118	1331	delegation = rcu_dereference(NFS_I(inode)->delegation);
1119	1332	if (delegation &&
1120		- nfs4_stateid_match_other(&delegation->stateid, stateid)) {
	1333	+ nfs4_stateid_match_or_older(&delegation->stateid, stateid) &&
	1334	+ !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
1121	1335	nfs_mark_test_expired_delegation(NFS_SERVER(inode), delegation);
1122	1336	found = true;
1123	1337	}
..	..	@@ -1166,7 +1380,9 @@
1166	1380	rcu_read_lock();
1167	1381	delegation = rcu_dereference(NFS_I(inode)->delegation);
1168	1382	if (delegation != NULL &&
1169		- nfs4_stateid_match_other(dst, &delegation->stateid)) {
	1383	+ nfs4_stateid_match_other(dst, &delegation->stateid) &&
	1384	+ nfs4_stateid_is_newer(&delegation->stateid, dst) &&
	1385	+ !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
1170	1386	dst->seqid = delegation->stateid.seqid;
1171	1387	ret = true;
1172	1388	}
..	..	@@ -1186,22 +1402,27 @@
1186	1402	* otherwise "false" is returned.
1187	1403	*/
1188	1404	bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
1189		- nfs4_stateid dst, struct rpc_cred *cred)
	1405	+ nfs4_stateid dst, const struct cred *cred)
1190	1406	{
1191	1407	struct nfs_inode *nfsi = NFS_I(inode);
1192	1408	struct nfs_delegation *delegation;
1193		- bool ret;
	1409	+ bool ret = false;
1194	1410
1195	1411	flags &= FMODE_READ\|FMODE_WRITE;
1196	1412	rcu_read_lock();
1197	1413	delegation = rcu_dereference(nfsi->delegation);
	1414	+ if (!delegation)
	1415	+ goto out;
	1416	+ spin_lock(&delegation->lock);
1198	1417	ret = nfs4_is_valid_delegation(delegation, flags);
1199	1418	if (ret) {
1200	1419	nfs4_stateid_copy(dst, &delegation->stateid);
1201	1420	nfs_mark_delegation_referenced(delegation);
1202	1421	if (cred)
1203		- *cred = get_rpccred(delegation->cred);
	1422	+ *cred = get_cred(delegation->cred);
1204	1423	}
	1424	+ spin_unlock(&delegation->lock);
	1425	+out:
1205	1426	rcu_read_unlock();
1206	1427	return ret;
1207	1428	}
..	..	@@ -1230,3 +1451,5 @@
1230	1451	rcu_read_unlock();
1231	1452	return ret;
1232	1453	}
	1454	+
	1455	+module_param_named(delegation_watermark, nfs_delegation_watermark, uint, 0644);