~hc/RK356X_SDK_RELEASE.git

..	..	@@ -49,6 +49,7 @@
49	49	#include <linux/workqueue.h>
50	50	#include <linux/bitops.h>
51	51	#include <linux/jiffies.h>
	52	+#include <linux/sched/mm.h>
52	53
53	54	#include <linux/sunrpc/clnt.h>
54	55
..	..	@@ -60,6 +61,7 @@
60	61	#include "nfs4session.h"
61	62	#include "pnfs.h"
62	63	#include "netns.h"
	64	+#include "nfs4trace.h"
63	65
64	66	#define NFSDBG_FACILITY NFSDBG_STATE
65	67
..	..	@@ -87,7 +89,26 @@
87	89
88	90	static DEFINE_MUTEX(nfs_clid_init_mutex);
89	91
90		-int nfs4_init_clientid(struct nfs_client clp, struct rpc_cred cred)
	92	+static int nfs4_setup_state_renewal(struct nfs_client *clp)
	93	+{
	94	+ int status;
	95	+ struct nfs_fsinfo fsinfo;
	96	+
	97	+ if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
	98	+ nfs4_schedule_state_renewal(clp);
	99	+ return 0;
	100	+ }
	101	+
	102	+ status = nfs4_proc_get_lease_time(clp, &fsinfo);
	103	+ if (status == 0) {
	104	+ nfs4_set_lease_period(clp, fsinfo.lease_time * HZ);
	105	+ nfs4_schedule_state_renewal(clp);
	106	+ }
	107	+
	108	+ return status;
	109	+}
	110	+
	111	+int nfs4_init_clientid(struct nfs_client clp, const struct cred cred)
91	112	{
92	113	struct nfs4_setclientid_res clid = {
93	114	.clientid = clp->cl_clientid,
..	..	@@ -114,7 +135,7 @@
114	135	if (status != 0)
115	136	goto out;
116	137	clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
117		- nfs4_schedule_state_renewal(clp);
	138	+ nfs4_setup_state_renewal(clp);
118	139	out:
119	140	return status;
120	141	}
..	..	@@ -134,7 +155,7 @@
134	155	*/
135	156	int nfs40_discover_server_trunking(struct nfs_client *clp,
136	157	struct nfs_client **result,
137		- struct rpc_cred *cred)
	158	+ const struct cred *cred)
138	159	{
139	160	struct nfs4_setclientid_res clid = {
140	161	.clientid = clp->cl_clientid,
..	..	@@ -168,32 +189,23 @@
168	189	return status;
169	190	}
170	191
171		-struct rpc_cred nfs4_get_machine_cred_locked(struct nfs_client clp)
	192	+const struct cred nfs4_get_machine_cred(struct nfs_client clp)
172	193	{
173		- struct rpc_cred *cred = NULL;
174		-
175		- if (clp->cl_machine_cred != NULL)
176		- cred = get_rpccred(clp->cl_machine_cred);
177		- return cred;
	194	+ return get_cred(rpc_machine_cred());
178	195	}
179	196
180	197	static void nfs4_root_machine_cred(struct nfs_client *clp)
181	198	{
182		- struct rpc_cred cred, new;
183	199
184		- new = rpc_lookup_machine_cred(NULL);
185		- spin_lock(&clp->cl_lock);
186		- cred = clp->cl_machine_cred;
187		- clp->cl_machine_cred = new;
188		- spin_unlock(&clp->cl_lock);
189		- if (cred != NULL)
190		- put_rpccred(cred);
	200	+ /* Force root creds instead of machine */
	201	+ clp->cl_principal = NULL;
	202	+ clp->cl_rpcclient->cl_principal = NULL;
191	203	}
192	204
193		-static struct rpc_cred *
	205	+static const struct cred *
194	206	nfs4_get_renew_cred_server_locked(struct nfs_server *server)
195	207	{
196		- struct rpc_cred *cred = NULL;
	208	+ const struct cred *cred = NULL;
197	209	struct nfs4_state_owner *sp;
198	210	struct rb_node *pos;
199	211
..	..	@@ -203,29 +215,30 @@
203	215	sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
204	216	if (list_empty(&sp->so_states))
205	217	continue;
206		- cred = get_rpccred(sp->so_cred);
	218	+ cred = get_cred(sp->so_cred);
207	219	break;
208	220	}
209	221	return cred;
210	222	}
211	223
212	224	/**
213		- * nfs4_get_renew_cred_locked - Acquire credential for a renew operation
	225	+ * nfs4_get_renew_cred - Acquire credential for a renew operation
214	226	* @clp: client state handle
215	227	*
216	228	* Returns an rpc_cred with reference count bumped, or NULL.
217	229	* Caller must hold clp->cl_lock.
218	230	*/
219		-struct rpc_cred nfs4_get_renew_cred_locked(struct nfs_client clp)
	231	+const struct cred nfs4_get_renew_cred(struct nfs_client clp)
220	232	{
221		- struct rpc_cred *cred = NULL;
	233	+ const struct cred *cred = NULL;
222	234	struct nfs_server *server;
223	235
224	236	/* Use machine credentials if available */
225		- cred = nfs4_get_machine_cred_locked(clp);
	237	+ cred = nfs4_get_machine_cred(clp);
226	238	if (cred != NULL)
227	239	goto out;
228	240
	241	+ spin_lock(&clp->cl_lock);
229	242	rcu_read_lock();
230	243	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
231	244	cred = nfs4_get_renew_cred_server_locked(server);
..	..	@@ -233,6 +246,7 @@
233	246	break;
234	247	}
235	248	rcu_read_unlock();
	249	+ spin_unlock(&clp->cl_lock);
236	250
237	251	out:
238	252	return cred;
..	..	@@ -293,37 +307,16 @@
293	307
294	308	#if defined(CONFIG_NFS_V4_1)
295	309
296		-static int nfs41_setup_state_renewal(struct nfs_client *clp)
297		-{
298		- int status;
299		- struct nfs_fsinfo fsinfo;
300		- unsigned long now;
301		-
302		- if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
303		- nfs4_schedule_state_renewal(clp);
304		- return 0;
305		- }
306		-
307		- now = jiffies;
308		- status = nfs4_proc_get_lease_time(clp, &fsinfo);
309		- if (status == 0) {
310		- nfs4_set_lease_period(clp, fsinfo.lease_time * HZ, now);
311		- nfs4_schedule_state_renewal(clp);
312		- }
313		-
314		- return status;
315		-}
316		-
317	310	static void nfs41_finish_session_reset(struct nfs_client *clp)
318	311	{
319	312	clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
320	313	clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
321	314	/* create_session negotiated new slot table */
322	315	clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
323		- nfs41_setup_state_renewal(clp);
	316	+ nfs4_setup_state_renewal(clp);
324	317	}
325	318
326		-int nfs41_init_clientid(struct nfs_client clp, struct rpc_cred cred)
	319	+int nfs41_init_clientid(struct nfs_client clp, const struct cred cred)
327	320	{
328	321	int status;
329	322
..	..	@@ -358,7 +351,7 @@
358	351	*/
359	352	int nfs41_discover_server_trunking(struct nfs_client *clp,
360	353	struct nfs_client **result,
361		- struct rpc_cred *cred)
	354	+ const struct cred *cred)
362	355	{
363	356	int status;
364	357
..	..	@@ -396,32 +389,32 @@
396	389	* nfs4_get_clid_cred - Acquire credential for a setclientid operation
397	390	* @clp: client state handle
398	391	*
399		- * Returns an rpc_cred with reference count bumped, or NULL.
	392	+ * Returns a cred with reference count bumped, or NULL.
400	393	*/
401		-struct rpc_cred nfs4_get_clid_cred(struct nfs_client clp)
	394	+const struct cred nfs4_get_clid_cred(struct nfs_client clp)
402	395	{
403		- struct rpc_cred *cred;
	396	+ const struct cred *cred;
404	397
405		- spin_lock(&clp->cl_lock);
406		- cred = nfs4_get_machine_cred_locked(clp);
407		- spin_unlock(&clp->cl_lock);
	398	+ cred = nfs4_get_machine_cred(clp);
408	399	return cred;
409	400	}
410	401
411	402	static struct nfs4_state_owner *
412		-nfs4_find_state_owner_locked(struct nfs_server server, struct rpc_cred cred)
	403	+nfs4_find_state_owner_locked(struct nfs_server server, const struct cred cred)
413	404	{
414	405	struct rb_node **p = &server->state_owners.rb_node,
415	406	*parent = NULL;
416	407	struct nfs4_state_owner *sp;
	408	+ int cmp;
417	409
418	410	while (*p != NULL) {
419	411	parent = *p;
420	412	sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
	413	+ cmp = cred_fscmp(cred, sp->so_cred);
421	414
422		- if (cred < sp->so_cred)
	415	+ if (cmp < 0)
423	416	p = &parent->rb_left;
424		- else if (cred > sp->so_cred)
	417	+ else if (cmp > 0)
425	418	p = &parent->rb_right;
426	419	else {
427	420	if (!list_empty(&sp->so_lru))
..	..	@@ -440,14 +433,16 @@
440	433	struct rb_node **p = &server->state_owners.rb_node,
441	434	*parent = NULL;
442	435	struct nfs4_state_owner *sp;
	436	+ int cmp;
443	437
444	438	while (*p != NULL) {
445	439	parent = *p;
446	440	sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
	441	+ cmp = cred_fscmp(new->so_cred, sp->so_cred);
447	442
448		- if (new->so_cred < sp->so_cred)
	443	+ if (cmp < 0)
449	444	p = &parent->rb_left;
450		- else if (new->so_cred > sp->so_cred)
	445	+ else if (cmp > 0)
451	446	p = &parent->rb_right;
452	447	else {
453	448	if (!list_empty(&sp->so_lru))
..	..	@@ -494,7 +489,7 @@
494	489	*/
495	490	static struct nfs4_state_owner *
496	491	nfs4_alloc_state_owner(struct nfs_server *server,
497		- struct rpc_cred *cred,
	492	+ const struct cred *cred,
498	493	gfp_t gfp_flags)
499	494	{
500	495	struct nfs4_state_owner *sp;
..	..	@@ -509,13 +504,13 @@
509	504	return NULL;
510	505	}
511	506	sp->so_server = server;
512		- sp->so_cred = get_rpccred(cred);
	507	+ sp->so_cred = get_cred(cred);
513	508	spin_lock_init(&sp->so_lock);
514	509	INIT_LIST_HEAD(&sp->so_states);
515	510	nfs4_init_seqid_counter(&sp->so_seqid);
516	511	atomic_set(&sp->so_count, 1);
517	512	INIT_LIST_HEAD(&sp->so_lru);
518		- seqcount_init(&sp->so_reclaim_seqcount);
	513	+ seqcount_spinlock_init(&sp->so_reclaim_seqcount, &sp->so_lock);
519	514	mutex_init(&sp->so_delegreturn_mutex);
520	515	return sp;
521	516	}
..	..	@@ -538,7 +533,7 @@
538	533	static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
539	534	{
540	535	nfs4_destroy_seqid_counter(&sp->so_seqid);
541		- put_rpccred(sp->so_cred);
	536	+ put_cred(sp->so_cred);
542	537	ida_simple_remove(&sp->so_server->openowner_id, sp->so_seqid.owner_id);
543	538	kfree(sp);
544	539	}
..	..	@@ -572,11 +567,12 @@
572	567	* nfs4_get_state_owner - Look up a state owner given a credential
573	568	* @server: nfs_server to search
574	569	* @cred: RPC credential to match
	570	+ * @gfp_flags: allocation mode
575	571	*
576	572	* Returns a pointer to an instantiated nfs4_state_owner struct, or NULL.
577	573	*/
578	574	struct nfs4_state_owner nfs4_get_state_owner(struct nfs_server server,
579		- struct rpc_cred *cred,
	575	+ const struct cred *cred,
580	576	gfp_t gfp_flags)
581	577	{
582	578	struct nfs_client *clp = server->nfs_client;
..	..	@@ -674,7 +670,7 @@
674	670	state = kzalloc(sizeof(*state), GFP_NOFS);
675	671	if (!state)
676	672	return NULL;
677		- atomic_set(&state->count, 1);
	673	+ refcount_set(&state->count, 1);
678	674	INIT_LIST_HEAD(&state->lock_states);
679	675	spin_lock_init(&state->state_lock);
680	676	seqlock_init(&state->seqlock);
..	..	@@ -703,12 +699,12 @@
703	699	struct nfs_inode *nfsi = NFS_I(inode);
704	700	struct nfs4_state *state;
705	701
706		- list_for_each_entry(state, &nfsi->open_states, inode_states) {
	702	+ list_for_each_entry_rcu(state, &nfsi->open_states, inode_states) {
707	703	if (state->owner != owner)
708	704	continue;
709	705	if (!nfs4_valid_open_stateid(state))
710	706	continue;
711		- if (atomic_inc_not_zero(&state->count))
	707	+ if (refcount_inc_not_zero(&state->count))
712	708	return state;
713	709	}
714	710	return NULL;
..	..	@@ -717,7 +713,7 @@
717	713	static void
718	714	nfs4_free_open_state(struct nfs4_state *state)
719	715	{
720		- kfree(state);
	716	+ kfree_rcu(state, rcu_head);
721	717	}
722	718
723	719	struct nfs4_state *
..	..	@@ -726,9 +722,9 @@
726	722	struct nfs4_state state, new;
727	723	struct nfs_inode *nfsi = NFS_I(inode);
728	724
729		- spin_lock(&inode->i_lock);
	725	+ rcu_read_lock();
730	726	state = __nfs4_find_state_byowner(inode, owner);
731		- spin_unlock(&inode->i_lock);
	727	+ rcu_read_unlock();
732	728	if (state)
733	729	goto out;
734	730	new = nfs4_alloc_open_state();
..	..	@@ -739,9 +735,9 @@
739	735	state = new;
740	736	state->owner = owner;
741	737	atomic_inc(&owner->so_count);
742		- list_add(&state->inode_states, &nfsi->open_states);
743	738	ihold(inode);
744	739	state->inode = inode;
	740	+ list_add_rcu(&state->inode_states, &nfsi->open_states);
745	741	spin_unlock(&inode->i_lock);
746	742	/* Note: The reclaim code dictates that we add stateless
747	743	* and read-only stateids to the end of the list */
..	..	@@ -762,13 +758,14 @@
762	758	struct inode *inode = state->inode;
763	759	struct nfs4_state_owner *owner = state->owner;
764	760
765		- if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
	761	+ if (!refcount_dec_and_lock(&state->count, &owner->so_lock))
766	762	return;
767	763	spin_lock(&inode->i_lock);
768		- list_del(&state->inode_states);
	764	+ list_del_rcu(&state->inode_states);
769	765	list_del(&state->open_states);
770	766	spin_unlock(&inode->i_lock);
771	767	spin_unlock(&owner->so_lock);
	768	+ nfs4_inode_return_delegation_on_close(inode);
772	769	iput(inode);
773	770	nfs4_free_open_state(state);
774	771	nfs4_put_state_owner(owner);
..	..	@@ -1019,22 +1016,6 @@
1019	1016	return ret;
1020	1017	}
1021	1018
1022		-bool nfs4_refresh_open_stateid(nfs4_stateid dst, struct nfs4_state state)
1023		-{
1024		- bool ret;
1025		- int seq;
1026		-
1027		- do {
1028		- ret = false;
1029		- seq = read_seqbegin(&state->seqlock);
1030		- if (nfs4_state_match_open_stateid_other(state, dst)) {
1031		- dst->seqid = state->open_stateid.seqid;
1032		- ret = true;
1033		- }
1034		- } while (read_seqretry(&state->seqlock, seq));
1035		- return ret;
1036		-}
1037		-
1038	1019	bool nfs4_copy_open_stateid(nfs4_stateid dst, struct nfs4_state state)
1039	1020	{
1040	1021	bool ret;
..	..	@@ -1060,7 +1041,7 @@
1060	1041	*/
1061	1042	int nfs4_select_rw_stateid(struct nfs4_state *state,
1062	1043	fmode_t fmode, const struct nfs_lock_context *l_ctx,
1063		- nfs4_stateid dst, struct rpc_cred *cred)
	1044	+ nfs4_stateid dst, const struct cred *cred)
1064	1045	{
1065	1046	int ret;
1066	1047
..	..	@@ -1083,8 +1064,7 @@
1083	1064	* choose to use.
1084	1065	*/
1085	1066	goto out;
1086		- nfs4_copy_open_stateid(dst, state);
1087		- ret = 0;
	1067	+ ret = nfs4_copy_open_stateid(dst, state) ? 0 : -EAGAIN;
1088	1068	out:
1089	1069	if (nfs_server_capable(state->inode, NFS_CAP_STATEID_NFSV41))
1090	1070	dst->seqid = 0;
..	..	@@ -1155,7 +1135,7 @@
1155	1135	case -NFS4ERR_MOVED:
1156	1136	/* Non-seqid mutating errors */
1157	1137	return;
1158		- };
	1138	+ }
1159	1139	/*
1160	1140	* Note: no locking needed as we are guaranteed to be first
1161	1141	* on the sequence list
..	..	@@ -1428,7 +1408,7 @@
1428	1408	list_for_each_entry(pos, &state->lock_states, ls_locks) {
1429	1409	if (!test_bit(NFS_LOCK_INITIALIZED, &pos->ls_flags))
1430	1410	continue;
1431		- if (nfs4_stateid_match_other(&pos->ls_stateid, stateid))
	1411	+ if (nfs4_stateid_match_or_older(&pos->ls_stateid, stateid))
1432	1412	return pos;
1433	1413	}
1434	1414	return NULL;
..	..	@@ -1457,17 +1437,18 @@
1457	1437	struct nfs4_state *state;
1458	1438	bool found = false;
1459	1439
1460		- spin_lock(&inode->i_lock);
1461		- list_for_each_entry(ctx, &nfsi->open_files, list) {
	1440	+ rcu_read_lock();
	1441	+ list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
1462	1442	state = ctx->state;
1463	1443	if (state == NULL)
1464	1444	continue;
1465		- if (nfs4_stateid_match_other(&state->stateid, stateid) &&
	1445	+ if (nfs4_stateid_match_or_older(&state->stateid, stateid) &&
1466	1446	nfs4_state_mark_reclaim_nograce(clp, state)) {
1467	1447	found = true;
1468	1448	continue;
1469	1449	}
1470		- if (nfs4_stateid_match_other(&state->open_stateid, stateid) &&
	1450	+ if (test_bit(NFS_OPEN_STATE, &state->flags) &&
	1451	+ nfs4_stateid_match_or_older(&state->open_stateid, stateid) &&
1471	1452	nfs4_state_mark_reclaim_nograce(clp, state)) {
1472	1453	found = true;
1473	1454	continue;
..	..	@@ -1476,32 +1457,34 @@
1476	1457	nfs4_state_mark_reclaim_nograce(clp, state))
1477	1458	found = true;
1478	1459	}
1479		- spin_unlock(&inode->i_lock);
	1460	+ rcu_read_unlock();
1480	1461
1481	1462	nfs_inode_find_delegation_state_and_recover(inode, stateid);
1482	1463	if (found)
1483	1464	nfs4_schedule_state_manager(clp);
1484	1465	}
1485	1466
1486		-static void nfs4_state_mark_open_context_bad(struct nfs4_state *state)
	1467	+static void nfs4_state_mark_open_context_bad(struct nfs4_state *state, int err)
1487	1468	{
1488	1469	struct inode *inode = state->inode;
1489	1470	struct nfs_inode *nfsi = NFS_I(inode);
1490	1471	struct nfs_open_context *ctx;
1491	1472
1492		- spin_lock(&inode->i_lock);
1493		- list_for_each_entry(ctx, &nfsi->open_files, list) {
	1473	+ rcu_read_lock();
	1474	+ list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
1494	1475	if (ctx->state != state)
1495	1476	continue;
1496	1477	set_bit(NFS_CONTEXT_BAD, &ctx->flags);
	1478	+ pr_warn("NFSv4: state recovery failed for open file %pd2, "
	1479	+ "error = %d\n", ctx->dentry, err);
1497	1480	}
1498		- spin_unlock(&inode->i_lock);
	1481	+ rcu_read_unlock();
1499	1482	}
1500	1483
1501	1484	static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
1502	1485	{
1503	1486	set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags);
1504		- nfs4_state_mark_open_context_bad(state);
	1487	+ nfs4_state_mark_open_context_bad(state, error);
1505	1488	}
1506	1489
1507	1490
..	..	@@ -1532,6 +1515,7 @@
1532	1515	switch (status) {
1533	1516	case 0:
1534	1517	break;
	1518	+ case -ETIMEDOUT:
1535	1519	case -ESTALE:
1536	1520	case -NFS4ERR_ADMIN_REVOKED:
1537	1521	case -NFS4ERR_STALE_STATEID:
..	..	@@ -1547,7 +1531,7 @@
1547	1531	default:
1548	1532	pr_err("NFS: %s: unhandled error %d\n",
1549	1533	__func__, status);
1550		- /* Fall through */
	1534	+ fallthrough;
1551	1535	case -ENOMEM:
1552	1536	case -NFS4ERR_DENIED:
1553	1537	case -NFS4ERR_RECLAIM_BAD:
..	..	@@ -1569,11 +1553,84 @@
1569	1553	return status;
1570	1554	}
1571	1555
	1556	+#ifdef CONFIG_NFS_V4_2
	1557	+static void nfs42_complete_copies(struct nfs4_state_owner sp, struct nfs4_state state)
	1558	+{
	1559	+ struct nfs4_copy_state *copy;
	1560	+
	1561	+ if (!test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
	1562	+ !test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags))
	1563	+ return;
	1564	+
	1565	+ spin_lock(&sp->so_server->nfs_client->cl_lock);
	1566	+ list_for_each_entry(copy, &sp->so_server->ss_copies, copies) {
	1567	+ if ((test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
	1568	+ !nfs4_stateid_match_other(&state->stateid,
	1569	+ &copy->parent_dst_state->stateid)))
	1570	+ continue;
	1571	+ copy->flags = 1;
	1572	+ if (test_and_clear_bit(NFS_CLNT_DST_SSC_COPY_STATE,
	1573	+ &state->flags)) {
	1574	+ clear_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags);
	1575	+ complete(&copy->completion);
	1576	+ }
	1577	+ }
	1578	+ list_for_each_entry(copy, &sp->so_server->ss_copies, src_copies) {
	1579	+ if ((test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags) &&
	1580	+ !nfs4_stateid_match_other(&state->stateid,
	1581	+ &copy->parent_src_state->stateid)))
	1582	+ continue;
	1583	+ copy->flags = 1;
	1584	+ if (test_and_clear_bit(NFS_CLNT_DST_SSC_COPY_STATE,
	1585	+ &state->flags))
	1586	+ complete(&copy->completion);
	1587	+ }
	1588	+ spin_unlock(&sp->so_server->nfs_client->cl_lock);
	1589	+}
	1590	+#else /* !CONFIG_NFS_V4_2 */
	1591	+static inline void nfs42_complete_copies(struct nfs4_state_owner *sp,
	1592	+ struct nfs4_state *state)
	1593	+{
	1594	+}
	1595	+#endif /* CONFIG_NFS_V4_2 */
	1596	+
	1597	+static int __nfs4_reclaim_open_state(struct nfs4_state_owner sp, struct nfs4_state state,
	1598	+ const struct nfs4_state_recovery_ops *ops)
	1599	+{
	1600	+ struct nfs4_lock_state *lock;
	1601	+ int status;
	1602	+
	1603	+ status = ops->recover_open(sp, state);
	1604	+ if (status < 0)
	1605	+ return status;
	1606	+
	1607	+ status = nfs4_reclaim_locks(state, ops);
	1608	+ if (status < 0)
	1609	+ return status;
	1610	+
	1611	+ if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
	1612	+ spin_lock(&state->state_lock);
	1613	+ list_for_each_entry(lock, &state->lock_states, ls_locks) {
	1614	+ trace_nfs4_state_lock_reclaim(state, lock);
	1615	+ if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
	1616	+ pr_warn_ratelimited("NFS: %s: Lock reclaim failed!\n", __func__);
	1617	+ }
	1618	+ spin_unlock(&state->state_lock);
	1619	+ }
	1620	+
	1621	+ nfs42_complete_copies(sp, state);
	1622	+ clear_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
	1623	+ return status;
	1624	+}
	1625	+
1572	1626	static int nfs4_reclaim_open_state(struct nfs4_state_owner sp, const struct nfs4_state_recovery_ops ops)
1573	1627	{
1574	1628	struct nfs4_state *state;
1575		- struct nfs4_lock_state *lock;
	1629	+ unsigned int loop = 0;
1576	1630	int status = 0;
	1631	+#ifdef CONFIG_NFS_V4_2
	1632	+ bool found_ssc_copy_state = false;
	1633	+#endif /* CONFIG_NFS_V4_2 */
1577	1634
1578	1635	/* Note: we rely on the sp->so_states list being ordered
1579	1636	* so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
..	..	@@ -1593,79 +1650,60 @@
1593	1650	continue;
1594	1651	if (state->state == 0)
1595	1652	continue;
1596		- atomic_inc(&state->count);
1597		- spin_unlock(&sp->so_lock);
1598		- status = ops->recover_open(sp, state);
1599		- if (status >= 0) {
1600		- status = nfs4_reclaim_locks(state, ops);
1601		- if (status >= 0) {
1602		- if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
1603		- spin_lock(&state->state_lock);
1604		- list_for_each_entry(lock, &state->lock_states, ls_locks) {
1605		- if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
1606		- pr_warn_ratelimited("NFS: "
1607		- "%s: Lock reclaim "
1608		- "failed!\n", __func__);
1609		- }
1610		- spin_unlock(&state->state_lock);
1611		- }
1612		- clear_bit(NFS_STATE_RECLAIM_NOGRACE,
1613		- &state->flags);
1614	1653	#ifdef CONFIG_NFS_V4_2
1615		- if (test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags)) {
1616		- struct nfs4_copy_state *copy;
1617		-
1618		- spin_lock(&sp->so_server->nfs_client->cl_lock);
1619		- list_for_each_entry(copy, &sp->so_server->ss_copies, copies) {
1620		- if (memcmp(&state->stateid.other, &copy->parent_state->stateid.other, NFS4_STATEID_SIZE))
1621		- continue;
1622		- copy->flags = 1;
1623		- complete(&copy->completion);
1624		- printk("AGLO: server rebooted waking up the copy\n");
1625		- break;
1626		- }
1627		- spin_unlock(&sp->so_server->nfs_client->cl_lock);
1628		- }
1629		-#endif /* CONFIG_NFS_V4_2 */
1630		- nfs4_put_open_state(state);
1631		- spin_lock(&sp->so_lock);
1632		- goto restart;
1633		- }
	1654	+ if (test_bit(NFS_SRV_SSC_COPY_STATE, &state->flags)) {
	1655	+ nfs4_state_mark_recovery_failed(state, -EIO);
	1656	+ found_ssc_copy_state = true;
	1657	+ continue;
1634	1658	}
	1659	+#endif /* CONFIG_NFS_V4_2 */
	1660	+ refcount_inc(&state->count);
	1661	+ spin_unlock(&sp->so_lock);
	1662	+ status = __nfs4_reclaim_open_state(sp, state, ops);
	1663	+
1635	1664	switch (status) {
1636		- default:
1637		- printk(KERN_ERR "NFS: %s: unhandled error %d\n",
1638		- __func__, status);
1639		- /* Fall through */
1640		- case -ENOENT:
1641		- case -ENOMEM:
1642		- case -EACCES:
1643		- case -EROFS:
1644		- case -EIO:
1645		- case -ESTALE:
1646		- /* Open state on this file cannot be recovered */
1647		- nfs4_state_mark_recovery_failed(state, status);
	1665	+ default:
	1666	+ if (status >= 0) {
	1667	+ loop = 0;
1648	1668	break;
1649		- case -EAGAIN:
1650		- ssleep(1);
1651		- /* Fall through */
1652		- case -NFS4ERR_ADMIN_REVOKED:
1653		- case -NFS4ERR_STALE_STATEID:
1654		- case -NFS4ERR_OLD_STATEID:
1655		- case -NFS4ERR_BAD_STATEID:
1656		- case -NFS4ERR_RECLAIM_BAD:
1657		- case -NFS4ERR_RECLAIM_CONFLICT:
1658		- nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
	1669	+ }
	1670	+ printk(KERN_ERR "NFS: %s: unhandled error %d\n", __func__, status);
	1671	+ fallthrough;
	1672	+ case -ENOENT:
	1673	+ case -ENOMEM:
	1674	+ case -EACCES:
	1675	+ case -EROFS:
	1676	+ case -EIO:
	1677	+ case -ESTALE:
	1678	+ /* Open state on this file cannot be recovered */
	1679	+ nfs4_state_mark_recovery_failed(state, status);
	1680	+ break;
	1681	+ case -EAGAIN:
	1682	+ ssleep(1);
	1683	+ if (loop++ < 10) {
	1684	+ set_bit(ops->state_flag_bit, &state->flags);
1659	1685	break;
1660		- case -NFS4ERR_EXPIRED:
1661		- case -NFS4ERR_NO_GRACE:
1662		- nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1663		- case -NFS4ERR_STALE_CLIENTID:
1664		- case -NFS4ERR_BADSESSION:
1665		- case -NFS4ERR_BADSLOT:
1666		- case -NFS4ERR_BAD_HIGH_SLOT:
1667		- case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1668		- goto out_err;
	1686	+ }
	1687	+ fallthrough;
	1688	+ case -NFS4ERR_ADMIN_REVOKED:
	1689	+ case -NFS4ERR_STALE_STATEID:
	1690	+ case -NFS4ERR_OLD_STATEID:
	1691	+ case -NFS4ERR_BAD_STATEID:
	1692	+ case -NFS4ERR_RECLAIM_BAD:
	1693	+ case -NFS4ERR_RECLAIM_CONFLICT:
	1694	+ nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
	1695	+ break;
	1696	+ case -NFS4ERR_EXPIRED:
	1697	+ case -NFS4ERR_NO_GRACE:
	1698	+ nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
	1699	+ fallthrough;
	1700	+ case -NFS4ERR_STALE_CLIENTID:
	1701	+ case -NFS4ERR_BADSESSION:
	1702	+ case -NFS4ERR_BADSLOT:
	1703	+ case -NFS4ERR_BAD_HIGH_SLOT:
	1704	+ case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
	1705	+ case -ETIMEDOUT:
	1706	+ goto out_err;
1669	1707	}
1670	1708	nfs4_put_open_state(state);
1671	1709	spin_lock(&sp->so_lock);
..	..	@@ -1673,6 +1711,10 @@
1673	1711	}
1674	1712	raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1675	1713	spin_unlock(&sp->so_lock);
	1714	+#ifdef CONFIG_NFS_V4_2
	1715	+ if (found_ssc_copy_state)
	1716	+ return -EIO;
	1717	+#endif /* CONFIG_NFS_V4_2 */
1676	1718	return 0;
1677	1719	out_err:
1678	1720	nfs4_put_open_state(state);
..	..	@@ -1735,6 +1777,7 @@
1735	1777
1736	1778	static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1737	1779	{
	1780	+ set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1738	1781	/* Mark all delegations for reclaim */
1739	1782	nfs_delegation_mark_reclaim(clp);
1740	1783	nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot);
..	..	@@ -1742,7 +1785,7 @@
1742	1785
1743	1786	static int nfs4_reclaim_complete(struct nfs_client *clp,
1744	1787	const struct nfs4_state_recovery_ops *ops,
1745		- struct rpc_cred *cred)
	1788	+ const struct cred *cred)
1746	1789	{
1747	1790	/* Notify the server we're done reclaiming our state */
1748	1791	if (ops->reclaim_complete)
..	..	@@ -1793,7 +1836,7 @@
1793	1836	static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1794	1837	{
1795	1838	const struct nfs4_state_recovery_ops *ops;
1796		- struct rpc_cred *cred;
	1839	+ const struct cred *cred;
1797	1840	int err;
1798	1841
1799	1842	if (!nfs4_state_clear_reclaim_reboot(clp))
..	..	@@ -1801,7 +1844,7 @@
1801	1844	ops = clp->cl_mvops->reboot_recovery_ops;
1802	1845	cred = nfs4_get_clid_cred(clp);
1803	1846	err = nfs4_reclaim_complete(clp, ops, cred);
1804		- put_rpccred(cred);
	1847	+ put_cred(cred);
1805	1848	if (err == -NFS4ERR_CONN_NOT_BOUND_TO_SESSION)
1806	1849	set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1807	1850	}
..	..	@@ -1815,38 +1858,38 @@
1815	1858	static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1816	1859	{
1817	1860	switch (error) {
1818		- case 0:
1819		- break;
1820		- case -NFS4ERR_CB_PATH_DOWN:
1821		- nfs40_handle_cb_pathdown(clp);
1822		- break;
1823		- case -NFS4ERR_NO_GRACE:
1824		- nfs4_state_end_reclaim_reboot(clp);
1825		- break;
1826		- case -NFS4ERR_STALE_CLIENTID:
1827		- set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1828		- nfs4_state_start_reclaim_reboot(clp);
1829		- break;
1830		- case -NFS4ERR_EXPIRED:
1831		- set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1832		- nfs4_state_start_reclaim_nograce(clp);
1833		- break;
1834		- case -NFS4ERR_BADSESSION:
1835		- case -NFS4ERR_BADSLOT:
1836		- case -NFS4ERR_BAD_HIGH_SLOT:
1837		- case -NFS4ERR_DEADSESSION:
1838		- case -NFS4ERR_SEQ_FALSE_RETRY:
1839		- case -NFS4ERR_SEQ_MISORDERED:
1840		- set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1841		- /* Zero session reset errors */
1842		- break;
1843		- case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1844		- set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1845		- break;
1846		- default:
1847		- dprintk("%s: failed to handle error %d for server %s\n",
1848		- __func__, error, clp->cl_hostname);
1849		- return error;
	1861	+ case 0:
	1862	+ break;
	1863	+ case -NFS4ERR_CB_PATH_DOWN:
	1864	+ nfs40_handle_cb_pathdown(clp);
	1865	+ break;
	1866	+ case -NFS4ERR_NO_GRACE:
	1867	+ nfs4_state_end_reclaim_reboot(clp);
	1868	+ break;
	1869	+ case -NFS4ERR_STALE_CLIENTID:
	1870	+ set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
	1871	+ nfs4_state_start_reclaim_reboot(clp);
	1872	+ break;
	1873	+ case -NFS4ERR_EXPIRED:
	1874	+ set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
	1875	+ nfs4_state_start_reclaim_nograce(clp);
	1876	+ break;
	1877	+ case -NFS4ERR_BADSESSION:
	1878	+ case -NFS4ERR_BADSLOT:
	1879	+ case -NFS4ERR_BAD_HIGH_SLOT:
	1880	+ case -NFS4ERR_DEADSESSION:
	1881	+ case -NFS4ERR_SEQ_FALSE_RETRY:
	1882	+ case -NFS4ERR_SEQ_MISORDERED:
	1883	+ set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
	1884	+ /* Zero session reset errors */
	1885	+ break;
	1886	+ case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
	1887	+ set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
	1888	+ break;
	1889	+ default:
	1890	+ dprintk("%s: failed to handle error %d for server %s\n",
	1891	+ __func__, error, clp->cl_hostname);
	1892	+ return error;
1850	1893	}
1851	1894	dprintk("%s: handled error %d for server %s\n", __func__, error,
1852	1895	clp->cl_hostname);
..	..	@@ -1899,7 +1942,7 @@
1899	1942
1900	1943	static int nfs4_check_lease(struct nfs_client *clp)
1901	1944	{
1902		- struct rpc_cred *cred;
	1945	+ const struct cred *cred;
1903	1946	const struct nfs4_state_maintenance_ops *ops =
1904	1947	clp->cl_mvops->state_renewal_ops;
1905	1948	int status;
..	..	@@ -1907,9 +1950,7 @@
1907	1950	/* Is the client already known to have an expired lease? */
1908	1951	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1909	1952	return 0;
1910		- spin_lock(&clp->cl_lock);
1911		- cred = ops->get_state_renewal_cred_locked(clp);
1912		- spin_unlock(&clp->cl_lock);
	1953	+ cred = ops->get_state_renewal_cred(clp);
1913	1954	if (cred == NULL) {
1914	1955	cred = nfs4_get_clid_cred(clp);
1915	1956	status = -ENOKEY;
..	..	@@ -1917,7 +1958,7 @@
1917	1958	goto out;
1918	1959	}
1919	1960	status = ops->renew_lease(clp, cred);
1920		- put_rpccred(cred);
	1961	+ put_cred(cred);
1921	1962	if (status == -ETIMEDOUT) {
1922	1963	set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1923	1964	return 0;
..	..	@@ -1951,7 +1992,6 @@
1951	1992	return -EPERM;
1952	1993	case -EACCES:
1953	1994	case -NFS4ERR_DELAY:
1954		- case -ETIMEDOUT:
1955	1995	case -EAGAIN:
1956	1996	ssleep(1);
1957	1997	break;
..	..	@@ -1977,7 +2017,7 @@
1977	2017
1978	2018	static int nfs4_establish_lease(struct nfs_client *clp)
1979	2019	{
1980		- struct rpc_cred *cred;
	2020	+ const struct cred *cred;
1981	2021	const struct nfs4_state_recovery_ops *ops =
1982	2022	clp->cl_mvops->reboot_recovery_ops;
1983	2023	int status;
..	..	@@ -1989,7 +2029,7 @@
1989	2029	if (cred == NULL)
1990	2030	return -ENOENT;
1991	2031	status = ops->establish_clid(clp, cred);
1992		- put_rpccred(cred);
	2032	+ put_cred(cred);
1993	2033	if (status != 0)
1994	2034	return status;
1995	2035	pnfs_destroy_all_layouts(clp);
..	..	@@ -2036,7 +2076,7 @@
2036	2076	*
2037	2077	* Returns zero or a negative NFS4ERR status code.
2038	2078	*/
2039		-static int nfs4_try_migration(struct nfs_server server, struct rpc_cred cred)
	2079	+static int nfs4_try_migration(struct nfs_server server, const struct cred cred)
2040	2080	{
2041	2081	struct nfs_client *clp = server->nfs_client;
2042	2082	struct nfs4_fs_locations *locations = NULL;
..	..	@@ -2076,8 +2116,10 @@
2076	2116	}
2077	2117
2078	2118	status = nfs4_begin_drain_session(clp);
2079		- if (status != 0)
2080		- return status;
	2119	+ if (status != 0) {
	2120	+ result = status;
	2121	+ goto out;
	2122	+ }
2081	2123
2082	2124	status = nfs4_replace_transport(server, locations);
2083	2125	if (status != 0) {
..	..	@@ -2109,14 +2151,12 @@
2109	2151	const struct nfs4_state_maintenance_ops *ops =
2110	2152	clp->cl_mvops->state_renewal_ops;
2111	2153	struct nfs_server *server;
2112		- struct rpc_cred *cred;
	2154	+ const struct cred *cred;
2113	2155
2114	2156	dprintk("%s: migration reported on \"%s\"\n", __func__,
2115	2157	clp->cl_hostname);
2116	2158
2117		- spin_lock(&clp->cl_lock);
2118		- cred = ops->get_state_renewal_cred_locked(clp);
2119		- spin_unlock(&clp->cl_lock);
	2159	+ cred = ops->get_state_renewal_cred(clp);
2120	2160	if (cred == NULL)
2121	2161	return -NFS4ERR_NOENT;
2122	2162
..	..	@@ -2137,13 +2177,13 @@
2137	2177	rcu_read_unlock();
2138	2178	status = nfs4_try_migration(server, cred);
2139	2179	if (status < 0) {
2140		- put_rpccred(cred);
	2180	+ put_cred(cred);
2141	2181	return status;
2142	2182	}
2143	2183	goto restart;
2144	2184	}
2145	2185	rcu_read_unlock();
2146		- put_rpccred(cred);
	2186	+ put_cred(cred);
2147	2187	return 0;
2148	2188	}
2149	2189
..	..	@@ -2157,14 +2197,12 @@
2157	2197	const struct nfs4_state_maintenance_ops *ops =
2158	2198	clp->cl_mvops->state_renewal_ops;
2159	2199	struct nfs_server *server;
2160		- struct rpc_cred *cred;
	2200	+ const struct cred *cred;
2161	2201
2162	2202	dprintk("%s: lease moved reported on \"%s\"\n", __func__,
2163	2203	clp->cl_hostname);
2164	2204
2165		- spin_lock(&clp->cl_lock);
2166		- cred = ops->get_state_renewal_cred_locked(clp);
2167		- spin_unlock(&clp->cl_lock);
	2205	+ cred = ops->get_state_renewal_cred(clp);
2168	2206	if (cred == NULL)
2169	2207	return -NFS4ERR_NOENT;
2170	2208
..	..	@@ -2192,7 +2230,7 @@
2192	2230	rcu_read_unlock();
2193	2231
2194	2232	out:
2195		- put_rpccred(cred);
	2233	+ put_cred(cred);
2196	2234	return 0;
2197	2235	}
2198	2236
..	..	@@ -2215,7 +2253,7 @@
2215	2253	const struct nfs4_state_recovery_ops *ops =
2216	2254	clp->cl_mvops->reboot_recovery_ops;
2217	2255	struct rpc_clnt *clnt;
2218		- struct rpc_cred *cred;
	2256	+ const struct cred *cred;
2219	2257	int i, status;
2220	2258
2221	2259	dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);
..	..	@@ -2231,7 +2269,7 @@
2231	2269	goto out_unlock;
2232	2270
2233	2271	status = ops->detect_trunking(clp, result, cred);
2234		- put_rpccred(cred);
	2272	+ put_cred(cred);
2235	2273	switch (status) {
2236	2274	case 0:
2237	2275	case -EINTR:
..	..	@@ -2240,11 +2278,11 @@
2240	2278	case -ETIMEDOUT:
2241	2279	if (clnt->cl_softrtry)
2242	2280	break;
2243		- /* Fall through */
	2281	+ fallthrough;
2244	2282	case -NFS4ERR_DELAY:
2245	2283	case -EAGAIN:
2246	2284	ssleep(1);
2247		- /* Fall through */
	2285	+ fallthrough;
2248	2286	case -NFS4ERR_STALE_CLIENTID:
2249	2287	dprintk("NFS: %s after status %d, retrying\n",
2250	2288	__func__, status);
..	..	@@ -2256,7 +2294,7 @@
2256	2294	}
2257	2295	if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX)
2258	2296	break;
2259		- /* Fall through */
	2297	+ fallthrough;
2260	2298	case -NFS4ERR_CLID_INUSE:
2261	2299	case -NFS4ERR_WRONGSEC:
2262	2300	/* No point in retrying if we already used RPC_AUTH_UNIX */
..	..	@@ -2362,8 +2400,7 @@
2362	2400	{
2363	2401	/* FIXME: For now, we destroy all layouts. */
2364	2402	pnfs_destroy_all_layouts(clp);
2365		- /* FIXME: For now, we test all delegations+open state+locks. */
2366		- nfs41_handle_some_state_revoked(clp);
	2403	+ nfs_test_expired_all_delegations(clp);
2367	2404	dprintk("%s: Recallable state revoked on server %s!\n", __func__,
2368	2405	clp->cl_hostname);
2369	2406	}
..	..	@@ -2422,7 +2459,7 @@
2422	2459
2423	2460	static int nfs4_reset_session(struct nfs_client *clp)
2424	2461	{
2425		- struct rpc_cred *cred;
	2462	+ const struct cred *cred;
2426	2463	int status;
2427	2464
2428	2465	if (!nfs4_has_session(clp))
..	..	@@ -2460,14 +2497,13 @@
2460	2497	dprintk("%s: session reset was successful for server %s!\n",
2461	2498	__func__, clp->cl_hostname);
2462	2499	out:
2463		- if (cred)
2464		- put_rpccred(cred);
	2500	+ put_cred(cred);
2465	2501	return status;
2466	2502	}
2467	2503
2468	2504	static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2469	2505	{
2470		- struct rpc_cred *cred;
	2506	+ const struct cred *cred;
2471	2507	int ret;
2472	2508
2473	2509	if (!nfs4_has_session(clp))
..	..	@@ -2477,8 +2513,7 @@
2477	2513	return ret;
2478	2514	cred = nfs4_get_clid_cred(clp);
2479	2515	ret = nfs4_proc_bind_conn_to_session(clp, cred);
2480		- if (cred)
2481		- put_rpccred(cred);
	2516	+ put_cred(cred);
2482	2517	clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2483	2518	switch (ret) {
2484	2519	case 0:
..	..	@@ -2494,6 +2529,21 @@
2494	2529	}
2495	2530	return 0;
2496	2531	}
	2532	+
	2533	+static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
	2534	+{
	2535	+ int iomode = 0;
	2536	+
	2537	+ if (test_and_clear_bit(NFS4CLNT_RECALL_ANY_LAYOUT_READ, &clp->cl_state))
	2538	+ iomode += IOMODE_READ;
	2539	+ if (test_and_clear_bit(NFS4CLNT_RECALL_ANY_LAYOUT_RW, &clp->cl_state))
	2540	+ iomode += IOMODE_RW;
	2541	+ /* Note: IOMODE_READ + IOMODE_RW == IOMODE_ANY */
	2542	+ if (iomode) {
	2543	+ pnfs_layout_return_unused_byclid(clp, iomode);
	2544	+ set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
	2545	+ }
	2546	+}
2497	2547	#else /* CONFIG_NFS_V4_1 */
2498	2548	static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
2499	2549
..	..	@@ -2501,15 +2551,28 @@
2501	2551	{
2502	2552	return 0;
2503	2553	}
	2554	+
	2555	+static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
	2556	+{
	2557	+}
2504	2558	#endif /* CONFIG_NFS_V4_1 */
2505	2559
2506	2560	static void nfs4_state_manager(struct nfs_client *clp)
2507	2561	{
	2562	+ unsigned int memflags;
2508	2563	int status = 0;
2509	2564	const char section = "", section_sep = "";
2510	2565
	2566	+ /*
	2567	+ * State recovery can deadlock if the direct reclaim code tries
	2568	+ * start NFS writeback. So ensure memory allocations are all
	2569	+ * GFP_NOFS.
	2570	+ */
	2571	+ memflags = memalloc_nofs_save();
	2572	+
2511	2573	/* Ensure exclusive access to NFSv4 state */
2512	2574	do {
	2575	+ trace_nfs4_state_mgr(clp);
2513	2576	clear_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
2514	2577	if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2515	2578	section = "purge state";
..	..	@@ -2580,6 +2643,7 @@
2580	2643	if (status < 0)
2581	2644	goto out_error;
2582	2645	nfs4_state_end_reclaim_reboot(clp);
	2646	+ continue;
2583	2647	}
2584	2648
2585	2649	/* Detect expired delegations... */
..	..	@@ -2590,7 +2654,7 @@
2590	2654	}
2591	2655
2592	2656	/* Now recover expired state... */
2593		- if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
	2657	+ if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
2594	2658	section = "reclaim nograce";
2595	2659	status = nfs4_do_reclaim(clp,
2596	2660	clp->cl_mvops->nograce_recovery_ops);
..	..	@@ -2598,17 +2662,20 @@
2598	2662	continue;
2599	2663	if (status < 0)
2600	2664	goto out_error;
	2665	+ clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
2601	2666	}
2602	2667
	2668	+ memalloc_nofs_restore(memflags);
2603	2669	nfs4_end_drain_session(clp);
2604	2670	nfs4_clear_state_manager_bit(clp);
2605	2671
2606		- if (!test_and_set_bit(NFS4CLNT_DELEGRETURN_RUNNING, &clp->cl_state)) {
	2672	+ if (!test_and_set_bit(NFS4CLNT_RECALL_RUNNING, &clp->cl_state)) {
2607	2673	if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
2608	2674	nfs_client_return_marked_delegations(clp);
2609	2675	set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
2610	2676	}
2611		- clear_bit(NFS4CLNT_DELEGRETURN_RUNNING, &clp->cl_state);
	2677	+ nfs4_layoutreturn_any_run(clp);
	2678	+ clear_bit(NFS4CLNT_RECALL_RUNNING, &clp->cl_state);
2612	2679	}
2613	2680
2614	2681	/* Did we race with an attempt to give us more work? */
..	..	@@ -2616,17 +2683,20 @@
2616	2683	return;
2617	2684	if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
2618	2685	return;
	2686	+ memflags = memalloc_nofs_save();
2619	2687	} while (refcount_read(&clp->cl_count) > 1 && !signalled());
2620	2688	goto out_drain;
2621	2689
2622	2690	out_error:
2623	2691	if (strlen(section))
2624	2692	section_sep = ": ";
	2693	+ trace_nfs4_state_mgr_failed(clp, section, status);
2625	2694	pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
2626	2695	" with error %d\n", section_sep, section,
2627	2696	clp->cl_hostname, -status);
2628	2697	ssleep(1);
2629	2698	out_drain:
	2699	+ memalloc_nofs_restore(memflags);
2630	2700	nfs4_end_drain_session(clp);
2631	2701	nfs4_clear_state_manager_bit(clp);
2632	2702	}