1	/*
2	* fs/nfs/nfs4state.c
3	*
4	* Client-side XDR for NFSv4.
5	*
6	* Copyright (c) 2002 The Regents of the University of Michigan.
7	* All rights reserved.
8	*
9	* Kendrick Smith <kmsmith@umich.edu>
10	*
11	* Redistribution and use in source and binary forms, with or without
12	* modification, are permitted provided that the following conditions
13	* are met:
14	*
15	* 1. Redistributions of source code must retain the above copyright
16	* notice, this list of conditions and the following disclaimer.
17	* 2. Redistributions in binary form must reproduce the above copyright
18	* notice, this list of conditions and the following disclaimer in the
19	* documentation and/or other materials provided with the distribution.
20	* 3. Neither the name of the University nor the names of its
21	* contributors may be used to endorse or promote products derived
22	* from this software without specific prior written permission.
23	*
24	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
25	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
26	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27	* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
31	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
32	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
33	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
34	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35	*
36	* Implementation of the NFSv4 state model. For the time being,
37	* this is minimal, but will be made much more complex in a
38	* subsequent patch.
39	*/
40
41	#include <linux/kernel.h>
42	#include <linux/slab.h>
43	#include <linux/fs.h>
44	#include <linux/nfs_fs.h>
45	#include <linux/kthread.h>
46	#include <linux/module.h>
47	#include <linux/random.h>
48	#include <linux/ratelimit.h>
49	#include <linux/workqueue.h>
50	#include <linux/bitops.h>
51	#include <linux/jiffies.h>
52	#include <linux/sched/mm.h>
53
54	#include <linux/sunrpc/clnt.h>
55
56	#include "nfs4_fs.h"
57	#include "callback.h"
58	#include "delegation.h"
59	#include "internal.h"
60	#include "nfs4idmap.h"
61	#include "nfs4session.h"
62	#include "pnfs.h"
63	#include "netns.h"
64	#include "nfs4trace.h"
65
66	#define NFSDBG_FACILITY NFSDBG_STATE
67
68	#define OPENOWNER_POOL_SIZE 8
69
70	static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp);
71
72	const nfs4_stateid zero_stateid = {
73	{ .data = { 0 } },
74	.type = NFS4_SPECIAL_STATEID_TYPE,
75	};
76	const nfs4_stateid invalid_stateid = {
77	{
78	/* Funky initialiser keeps older gcc versions happy */
79	.data = { 0xff, 0xff, 0xff, 0xff, 0 },
80	},
81	.type = NFS4_INVALID_STATEID_TYPE,
82	};
83
84	const nfs4_stateid current_stateid = {
85	{
86	/* Funky initialiser keeps older gcc versions happy */
87	.data = { 0x0, 0x0, 0x0, 0x1, 0 },
88	},
89	.type = NFS4_SPECIAL_STATEID_TYPE,
90	};
91
92	static DEFINE_MUTEX(nfs_clid_init_mutex);
93
94	static int nfs4_setup_state_renewal(struct nfs_client *clp)
95	{
96	int status;
97	struct nfs_fsinfo fsinfo;
98
99	if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
100	nfs4_schedule_state_renewal(clp);
101	return 0;
102	}
103
104	status = nfs4_proc_get_lease_time(clp, fsinfo: &fsinfo);
105	if (status == 0) {
106	nfs4_set_lease_period(clp, lease: fsinfo.lease_time * HZ);
107	nfs4_schedule_state_renewal(clp);
108	}
109
110	return status;
111	}
112
113	int nfs4_init_clientid(struct nfs_client *clp, const struct cred *cred)
114	{
115	struct nfs4_setclientid_res clid = {
116	.clientid = clp->cl_clientid,
117	.confirm = clp->cl_confirm,
118	};
119	unsigned short port;
120	int status;
121	struct nfs_net *nn = net_generic(net: clp->cl_net, id: nfs_net_id);
122
123	if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
124	goto do_confirm;
125	port = nn->nfs_callback_tcpport;
126	if (clp->cl_addr.ss_family == AF_INET6)
127	port = nn->nfs_callback_tcpport6;
128
129	status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
130	if (status != 0)
131	goto out;
132	clp->cl_clientid = clid.clientid;
133	clp->cl_confirm = clid.confirm;
134	set_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
135	do_confirm:
136	status = nfs4_proc_setclientid_confirm(clp, arg: &clid, cred);
137	if (status != 0)
138	goto out;
139	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
140	nfs4_setup_state_renewal(clp);
141	out:
142	return status;
143	}
144
145	/**
146	* nfs40_discover_server_trunking - Detect server IP address trunking (mv0)
147	*
148	* @clp: nfs_client under test
149	* @result: OUT: found nfs_client, or clp
150	* @cred: credential to use for trunking test
151	*
152	* Returns zero, a negative errno, or a negative NFS4ERR status.
153	* If zero is returned, an nfs_client pointer is planted in
154	* "result".
155	*
156	* Note: The returned client may not yet be marked ready.
157	*/
158	int nfs40_discover_server_trunking(struct nfs_client *clp,
159	struct nfs_client **result,
160	const struct cred *cred)
161	{
162	struct nfs4_setclientid_res clid = {
163	.clientid = clp->cl_clientid,
164	.confirm = clp->cl_confirm,
165	};
166	struct nfs_net *nn = net_generic(net: clp->cl_net, id: nfs_net_id);
167	unsigned short port;
168	int status;
169
170	port = nn->nfs_callback_tcpport;
171	if (clp->cl_addr.ss_family == AF_INET6)
172	port = nn->nfs_callback_tcpport6;
173
174	status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
175	if (status != 0)
176	goto out;
177	clp->cl_clientid = clid.clientid;
178	clp->cl_confirm = clid.confirm;
179
180	status = nfs40_walk_client_list(clp, result, cred);
181	if (status == 0) {
182	/* Sustain the lease, even if it's empty. If the clientid4
183	* goes stale it's of no use for trunking discovery. */
184	nfs4_schedule_state_renewal(*result);
185
186	/* If the client state need to recover, do it. */
187	if (clp->cl_state)
188	nfs4_schedule_state_manager(clp);
189	}
190	out:
191	return status;
192	}
193
194	const struct cred *nfs4_get_machine_cred(struct nfs_client *clp)
195	{
196	return get_cred(cred: rpc_machine_cred());
197	}
198
199	static void nfs4_root_machine_cred(struct nfs_client *clp)
200	{
201
202	/* Force root creds instead of machine */
203	clp->cl_principal = NULL;
204	clp->cl_rpcclient->cl_principal = NULL;
205	}
206
207	static const struct cred *
208	nfs4_get_renew_cred_server_locked(struct nfs_server *server)
209	{
210	const struct cred *cred = NULL;
211	struct nfs4_state_owner *sp;
212	struct rb_node *pos;
213
214	for (pos = rb_first(root: &server->state_owners);
215	pos != NULL;
216	pos = rb_next(pos)) {
217	sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
218	if (list_empty(head: &sp->so_states))
219	continue;
220	cred = get_cred(cred: sp->so_cred);
221	break;
222	}
223	return cred;
224	}
225
226	/**
227	* nfs4_get_renew_cred - Acquire credential for a renew operation
228	* @clp: client state handle
229	*
230	* Returns an rpc_cred with reference count bumped, or NULL.
231	* Caller must hold clp->cl_lock.
232	*/
233	const struct cred *nfs4_get_renew_cred(struct nfs_client *clp)
234	{
235	const struct cred *cred = NULL;
236	struct nfs_server *server;
237
238	/* Use machine credentials if available */
239	cred = nfs4_get_machine_cred(clp);
240	if (cred != NULL)
241	goto out;
242
243	spin_lock(lock: &clp->cl_lock);
244	rcu_read_lock();
245	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
246	cred = nfs4_get_renew_cred_server_locked(server);
247	if (cred != NULL)
248	break;
249	}
250	rcu_read_unlock();
251	spin_unlock(lock: &clp->cl_lock);
252
253	out:
254	return cred;
255	}
256
257	static void nfs4_end_drain_slot_table(struct nfs4_slot_table *tbl)
258	{
259	if (test_and_clear_bit(nr: NFS4_SLOT_TBL_DRAINING, addr: &tbl->slot_tbl_state)) {
260	spin_lock(lock: &tbl->slot_tbl_lock);
261	nfs41_wake_slot_table(tbl);
262	spin_unlock(lock: &tbl->slot_tbl_lock);
263	}
264	}
265
266	static void nfs4_end_drain_session(struct nfs_client *clp)
267	{
268	struct nfs4_session *ses = clp->cl_session;
269
270	if (clp->cl_slot_tbl) {
271	nfs4_end_drain_slot_table(tbl: clp->cl_slot_tbl);
272	return;
273	}
274
275	if (ses != NULL) {
276	nfs4_end_drain_slot_table(tbl: &ses->bc_slot_table);
277	nfs4_end_drain_slot_table(tbl: &ses->fc_slot_table);
278	}
279	}
280
281	static int nfs4_drain_slot_tbl(struct nfs4_slot_table *tbl)
282	{
283	set_bit(nr: NFS4_SLOT_TBL_DRAINING, addr: &tbl->slot_tbl_state);
284	spin_lock(lock: &tbl->slot_tbl_lock);
285	if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
286	reinit_completion(x: &tbl->complete);
287	spin_unlock(lock: &tbl->slot_tbl_lock);
288	return wait_for_completion_interruptible(x: &tbl->complete);
289	}
290	spin_unlock(lock: &tbl->slot_tbl_lock);
291	return 0;
292	}
293
294	static int nfs4_begin_drain_session(struct nfs_client *clp)
295	{
296	struct nfs4_session *ses = clp->cl_session;
297	int ret;
298
299	if (clp->cl_slot_tbl)
300	return nfs4_drain_slot_tbl(tbl: clp->cl_slot_tbl);
301
302	/* back channel */
303	ret = nfs4_drain_slot_tbl(tbl: &ses->bc_slot_table);
304	if (ret)
305	return ret;
306	/* fore channel */
307	return nfs4_drain_slot_tbl(tbl: &ses->fc_slot_table);
308	}
309
310	#if defined(CONFIG_NFS_V4_1)
311
312	static void nfs41_finish_session_reset(struct nfs_client *clp)
313	{
314	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
315	clear_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
316	/* create_session negotiated new slot table */
317	clear_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
318	nfs4_setup_state_renewal(clp);
319	}
320
321	int nfs41_init_clientid(struct nfs_client *clp, const struct cred *cred)
322	{
323	int status;
324
325	if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
326	goto do_confirm;
327	status = nfs4_proc_exchange_id(clp, cred);
328	if (status != 0)
329	goto out;
330	set_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
331	do_confirm:
332	status = nfs4_proc_create_session(clp, cred);
333	if (status != 0)
334	goto out;
335	if (!(clp->cl_exchange_flags & EXCHGID4_FLAG_CONFIRMED_R))
336	nfs4_state_start_reclaim_reboot(clp);
337	nfs41_finish_session_reset(clp);
338	nfs_mark_client_ready(clp, NFS_CS_READY);
339	out:
340	return status;
341	}
342
343	/**
344	* nfs41_discover_server_trunking - Detect server IP address trunking (mv1)
345	*
346	* @clp: nfs_client under test
347	* @result: OUT: found nfs_client, or clp
348	* @cred: credential to use for trunking test
349	*
350	* Returns NFS4_OK, a negative errno, or a negative NFS4ERR status.
351	* If NFS4_OK is returned, an nfs_client pointer is planted in
352	* "result".
353	*
354	* Note: The returned client may not yet be marked ready.
355	*/
356	int nfs41_discover_server_trunking(struct nfs_client *clp,
357	struct nfs_client **result,
358	const struct cred *cred)
359	{
360	int status;
361
362	status = nfs4_proc_exchange_id(clp, cred);
363	if (status != NFS4_OK)
364	return status;
365
366	status = nfs41_walk_client_list(clp, result, cred);
367	if (status < 0)
368	return status;
369	if (clp != *result)
370	return 0;
371
372	/*
373	* Purge state if the client id was established in a prior
374	* instance and the client id could not have arrived on the
375	* server via Transparent State Migration.
376	*/
377	if (clp->cl_exchange_flags & EXCHGID4_FLAG_CONFIRMED_R) {
378	if (!test_bit(NFS_CS_TSM_POSSIBLE, &clp->cl_flags))
379	set_bit(nr: NFS4CLNT_PURGE_STATE, addr: &clp->cl_state);
380	else
381	set_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
382	}
383	nfs4_schedule_state_manager(clp);
384	status = nfs_wait_client_init_complete(clp);
385	if (status < 0)
386	nfs_put_client(clp);
387	return status;
388	}
389
390	#endif /* CONFIG_NFS_V4_1 */
391
392	/**
393	* nfs4_get_clid_cred - Acquire credential for a setclientid operation
394	* @clp: client state handle
395	*
396	* Returns a cred with reference count bumped, or NULL.
397	*/
398	const struct cred *nfs4_get_clid_cred(struct nfs_client *clp)
399	{
400	const struct cred *cred;
401
402	cred = nfs4_get_machine_cred(clp);
403	return cred;
404	}
405
406	static struct nfs4_state_owner *
407	nfs4_find_state_owner_locked(struct nfs_server *server, const struct cred *cred)
408	{
409	struct rb_node **p = &server->state_owners.rb_node,
410	*parent = NULL;
411	struct nfs4_state_owner *sp;
412	int cmp;
413
414	while (*p != NULL) {
415	parent = *p;
416	sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
417	cmp = cred_fscmp(cred, sp->so_cred);
418
419	if (cmp < 0)
420	p = &parent->rb_left;
421	else if (cmp > 0)
422	p = &parent->rb_right;
423	else {
424	if (!list_empty(head: &sp->so_lru))
425	list_del_init(entry: &sp->so_lru);
426	atomic_inc(v: &sp->so_count);
427	return sp;
428	}
429	}
430	return NULL;
431	}
432
433	static struct nfs4_state_owner *
434	nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
435	{
436	struct nfs_server *server = new->so_server;
437	struct rb_node **p = &server->state_owners.rb_node,
438	*parent = NULL;
439	struct nfs4_state_owner *sp;
440	int cmp;
441
442	while (*p != NULL) {
443	parent = *p;
444	sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
445	cmp = cred_fscmp(new->so_cred, sp->so_cred);
446
447	if (cmp < 0)
448	p = &parent->rb_left;
449	else if (cmp > 0)
450	p = &parent->rb_right;
451	else {
452	if (!list_empty(head: &sp->so_lru))
453	list_del_init(entry: &sp->so_lru);
454	atomic_inc(v: &sp->so_count);
455	return sp;
456	}
457	}
458	rb_link_node(node: &new->so_server_node, parent, rb_link: p);
459	rb_insert_color(&new->so_server_node, &server->state_owners);
460	return new;
461	}
462
463	static void
464	nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
465	{
466	struct nfs_server *server = sp->so_server;
467
468	if (!RB_EMPTY_NODE(&sp->so_server_node))
469	rb_erase(&sp->so_server_node, &server->state_owners);
470	}
471
472	static void
473	nfs4_init_seqid_counter(struct nfs_seqid_counter *sc)
474	{
475	sc->create_time = ktime_get();
476	sc->flags = 0;
477	sc->counter = 0;
478	spin_lock_init(&sc->lock);
479	INIT_LIST_HEAD(list: &sc->list);
480	rpc_init_wait_queue(&sc->wait, "Seqid_waitqueue");
481	}
482
483	static void
484	nfs4_destroy_seqid_counter(struct nfs_seqid_counter *sc)
485	{
486	rpc_destroy_wait_queue(&sc->wait);
487	}
488
489	/*
490	* nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
491	* create a new state_owner.
492	*
493	*/
494	static struct nfs4_state_owner *
495	nfs4_alloc_state_owner(struct nfs_server *server,
496	const struct cred *cred,
497	gfp_t gfp_flags)
498	{
499	struct nfs4_state_owner *sp;
500
501	sp = kzalloc(sizeof(*sp), gfp_flags);
502	if (!sp)
503	return NULL;
504	sp->so_seqid.owner_id = atomic64_inc_return(v: &server->owner_ctr);
505	sp->so_server = server;
506	sp->so_cred = get_cred(cred);
507	spin_lock_init(&sp->so_lock);
508	INIT_LIST_HEAD(list: &sp->so_states);
509	nfs4_init_seqid_counter(sc: &sp->so_seqid);
510	atomic_set(v: &sp->so_count, i: 1);
511	INIT_LIST_HEAD(list: &sp->so_lru);
512	mutex_init(&sp->so_delegreturn_mutex);
513	return sp;
514	}
515
516	static void
517	nfs4_reset_state_owner(struct nfs4_state_owner *sp)
518	{
519	/* This state_owner is no longer usable, but must
520	* remain in place so that state recovery can find it
521	* and the opens associated with it.
522	* It may also be used for new 'open' request to
523	* return a delegation to the server.
524	* So update the 'create_time' so that it looks like
525	* a new state_owner. This will cause the server to
526	* request an OPEN_CONFIRM to start a new sequence.
527	*/
528	sp->so_seqid.create_time = ktime_get();
529	}
530
531	static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
532	{
533	nfs4_destroy_seqid_counter(sc: &sp->so_seqid);
534	put_cred(cred: sp->so_cred);
535	kfree(objp: sp);
536	}
537
538	static void nfs4_gc_state_owners(struct nfs_server *server)
539	{
540	struct nfs_client *clp = server->nfs_client;
541	struct nfs4_state_owner *sp, *tmp;
542	unsigned long time_min, time_max;
543	LIST_HEAD(doomed);
544
545	spin_lock(lock: &clp->cl_lock);
546	time_max = jiffies;
547	time_min = (long)time_max - (long)clp->cl_lease_time;
548	list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
549	/* NB: LRU is sorted so that oldest is at the head */
550	if (time_in_range(sp->so_expires, time_min, time_max))
551	break;
552	list_move(list: &sp->so_lru, head: &doomed);
553	nfs4_remove_state_owner_locked(sp);
554	}
555	spin_unlock(lock: &clp->cl_lock);
556
557	list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
558	list_del(entry: &sp->so_lru);
559	nfs4_free_state_owner(sp);
560	}
561	}
562
563	/**
564	* nfs4_get_state_owner - Look up a state owner given a credential
565	* @server: nfs_server to search
566	* @cred: RPC credential to match
567	* @gfp_flags: allocation mode
568	*
569	* Returns a pointer to an instantiated nfs4_state_owner struct, or NULL.
570	*/
571	struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,
572	const struct cred *cred,
573	gfp_t gfp_flags)
574	{
575	struct nfs_client *clp = server->nfs_client;
576	struct nfs4_state_owner *sp, *new;
577
578	spin_lock(lock: &clp->cl_lock);
579	sp = nfs4_find_state_owner_locked(server, cred);
580	spin_unlock(lock: &clp->cl_lock);
581	if (sp != NULL)
582	goto out;
583	new = nfs4_alloc_state_owner(server, cred, gfp_flags);
584	if (new == NULL)
585	goto out;
586	spin_lock(lock: &clp->cl_lock);
587	sp = nfs4_insert_state_owner_locked(new);
588	spin_unlock(lock: &clp->cl_lock);
589	if (sp != new)
590	nfs4_free_state_owner(sp: new);
591	out:
592	nfs4_gc_state_owners(server);
593	return sp;
594	}
595
596	/**
597	* nfs4_put_state_owner - Release a nfs4_state_owner
598	* @sp: state owner data to release
599	*
600	* Note that we keep released state owners on an LRU
601	* list.
602	* This caches valid state owners so that they can be
603	* reused, to avoid the OPEN_CONFIRM on minor version 0.
604	* It also pins the uniquifier of dropped state owners for
605	* a while, to ensure that those state owner names are
606	* never reused.
607	*/
608	void nfs4_put_state_owner(struct nfs4_state_owner *sp)
609	{
610	struct nfs_server *server = sp->so_server;
611	struct nfs_client *clp = server->nfs_client;
612
613	if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
614	return;
615
616	sp->so_expires = jiffies;
617	list_add_tail(new: &sp->so_lru, head: &server->state_owners_lru);
618	spin_unlock(lock: &clp->cl_lock);
619	}
620
621	/**
622	* nfs4_purge_state_owners - Release all cached state owners
623	* @server: nfs_server with cached state owners to release
624	* @head: resulting list of state owners
625	*
626	* Called at umount time. Remaining state owners will be on
627	* the LRU with ref count of zero.
628	* Note that the state owners are not freed, but are added
629	* to the list @head, which can later be used as an argument
630	* to nfs4_free_state_owners.
631	*/
632	void nfs4_purge_state_owners(struct nfs_server *server, struct list_head *head)
633	{
634	struct nfs_client *clp = server->nfs_client;
635	struct nfs4_state_owner *sp, *tmp;
636
637	spin_lock(lock: &clp->cl_lock);
638	list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
639	list_move(list: &sp->so_lru, head);
640	nfs4_remove_state_owner_locked(sp);
641	}
642	spin_unlock(lock: &clp->cl_lock);
643	}
644
645	/**
646	* nfs4_free_state_owners - Release all cached state owners
647	* @head: resulting list of state owners
648	*
649	* Frees a list of state owners that was generated by
650	* nfs4_purge_state_owners
651	*/
652	void nfs4_free_state_owners(struct list_head *head)
653	{
654	struct nfs4_state_owner *sp, *tmp;
655
656	list_for_each_entry_safe(sp, tmp, head, so_lru) {
657	list_del(entry: &sp->so_lru);
658	nfs4_free_state_owner(sp);
659	}
660	}
661
662	static struct nfs4_state *
663	nfs4_alloc_open_state(void)
664	{
665	struct nfs4_state *state;
666
667	state = kzalloc(sizeof(*state), GFP_KERNEL_ACCOUNT);
668	if (!state)
669	return NULL;
670	refcount_set(r: &state->count, n: 1);
671	INIT_LIST_HEAD(list: &state->lock_states);
672	spin_lock_init(&state->state_lock);
673	seqlock_init(&state->seqlock);
674	init_waitqueue_head(&state->waitq);
675	return state;
676	}
677
678	void
679	nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
680	{
681	if (state->state == fmode)
682	return;
683	/* NB! List reordering - see the reclaim code for why. */
684	if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
685	if (fmode & FMODE_WRITE)
686	list_move(list: &state->open_states, head: &state->owner->so_states);
687	else
688	list_move_tail(list: &state->open_states, head: &state->owner->so_states);
689	}
690	state->state = fmode;
691	}
692
693	static struct nfs4_state *
694	__nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
695	{
696	struct nfs_inode *nfsi = NFS_I(inode);
697	struct nfs4_state *state;
698
699	list_for_each_entry_rcu(state, &nfsi->open_states, inode_states) {
700	if (state->owner != owner)
701	continue;
702	if (!nfs4_valid_open_stateid(state))
703	continue;
704	if (refcount_inc_not_zero(r: &state->count))
705	return state;
706	}
707	return NULL;
708	}
709
710	static void
711	nfs4_free_open_state(struct nfs4_state *state)
712	{
713	kfree_rcu(state, rcu_head);
714	}
715
716	struct nfs4_state *
717	nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner)
718	{
719	struct nfs4_state *state, *new;
720	struct nfs_inode *nfsi = NFS_I(inode);
721
722	rcu_read_lock();
723	state = __nfs4_find_state_byowner(inode, owner);
724	rcu_read_unlock();
725	if (state)
726	goto out;
727	new = nfs4_alloc_open_state();
728	spin_lock(lock: &owner->so_lock);
729	spin_lock(lock: &inode->i_lock);
730	state = __nfs4_find_state_byowner(inode, owner);
731	if (state == NULL && new != NULL) {
732	state = new;
733	state->owner = owner;
734	atomic_inc(v: &owner->so_count);
735	ihold(inode);
736	state->inode = inode;
737	list_add_rcu(new: &state->inode_states, head: &nfsi->open_states);
738	spin_unlock(lock: &inode->i_lock);
739	/* Note: The reclaim code dictates that we add stateless
740	* and read-only stateids to the end of the list */
741	list_add_tail(new: &state->open_states, head: &owner->so_states);
742	spin_unlock(lock: &owner->so_lock);
743	} else {
744	spin_unlock(lock: &inode->i_lock);
745	spin_unlock(lock: &owner->so_lock);
746	if (new)
747	nfs4_free_open_state(state: new);
748	}
749	out:
750	return state;
751	}
752
753	void nfs4_put_open_state(struct nfs4_state *state)
754	{
755	struct inode *inode = state->inode;
756	struct nfs4_state_owner *owner = state->owner;
757
758	if (!refcount_dec_and_lock(r: &state->count, lock: &owner->so_lock))
759	return;
760	spin_lock(lock: &inode->i_lock);
761	list_del_rcu(entry: &state->inode_states);
762	list_del(entry: &state->open_states);
763	spin_unlock(lock: &inode->i_lock);
764	spin_unlock(lock: &owner->so_lock);
765	nfs4_inode_return_delegation_on_close(inode);
766	iput(inode);
767	nfs4_free_open_state(state);
768	nfs4_put_state_owner(sp: owner);
769	}
770
771	/*
772	* Close the current file.
773	*/
774	static void __nfs4_close(struct nfs4_state *state,
775	fmode_t fmode, gfp_t gfp_mask, int wait)
776	{
777	struct nfs4_state_owner *owner = state->owner;
778	int call_close = 0;
779	fmode_t newstate;
780
781	atomic_inc(v: &owner->so_count);
782	/* Protect against nfs4_find_state() */
783	spin_lock(lock: &owner->so_lock);
784	switch (fmode & (FMODE_READ | FMODE_WRITE)) {
785	case FMODE_READ:
786	state->n_rdonly--;
787	break;
788	case FMODE_WRITE:
789	state->n_wronly--;
790	break;
791	case FMODE_READ|FMODE_WRITE:
792	state->n_rdwr--;
793	}
794	newstate = FMODE_READ|FMODE_WRITE;
795	if (state->n_rdwr == 0) {
796	if (state->n_rdonly == 0) {
797	newstate &= ~FMODE_READ;
798	call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
799	call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
800	}
801	if (state->n_wronly == 0) {
802	newstate &= ~FMODE_WRITE;
803	call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
804	call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
805	}
806	if (newstate == 0)
807	clear_bit(nr: NFS_DELEGATED_STATE, addr: &state->flags);
808	}
809	nfs4_state_set_mode_locked(state, fmode: newstate);
810	spin_unlock(lock: &owner->so_lock);
811
812	if (!call_close) {
813	nfs4_put_open_state(state);
814	nfs4_put_state_owner(sp: owner);
815	} else
816	nfs4_do_close(state, gfp_mask, wait);
817	}
818
819	void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
820	{
821	__nfs4_close(state, fmode, GFP_KERNEL, wait: 0);
822	}
823
824	void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
825	{
826	__nfs4_close(state, fmode, GFP_KERNEL, wait: 1);
827	}
828
829	/*
830	* Search the state->lock_states for an existing lock_owner
831	* that is compatible with either of the given owners.
832	* If the second is non-zero, then the first refers to a Posix-lock
833	* owner (current->files) and the second refers to a flock/OFD
834	* owner (struct file*). In that case, prefer a match for the first
835	* owner.
836	* If both sorts of locks are held on the one file we cannot know
837	* which stateid was intended to be used, so a "correct" choice cannot
838	* be made. Failing that, a "consistent" choice is preferable. The
839	* consistent choice we make is to prefer the first owner, that of a
840	* Posix lock.
841	*/
842	static struct nfs4_lock_state *
843	__nfs4_find_lock_state(struct nfs4_state *state,
844	fl_owner_t owner, fl_owner_t owner2)
845	{
846	struct nfs4_lock_state *pos, *ret = NULL;
847	list_for_each_entry(pos, &state->lock_states, ls_locks) {
848	if (pos->ls_owner == owner) {
849	ret = pos;
850	break;
851	}
852	if (pos->ls_owner == owner2)
853	ret = pos;
854	}
855	if (ret)
856	refcount_inc(r: &ret->ls_count);
857	return ret;
858	}
859
860	/*
861	* Return a compatible lock_state. If no initialized lock_state structure
862	* exists, return an uninitialized one.
863	*
864	*/
865	static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t owner)
866	{
867	struct nfs4_lock_state *lsp;
868	struct nfs_server *server = state->owner->so_server;
869
870	lsp = kzalloc(sizeof(*lsp), GFP_KERNEL_ACCOUNT);
871	if (lsp == NULL)
872	return NULL;
873	nfs4_init_seqid_counter(sc: &lsp->ls_seqid);
874	refcount_set(r: &lsp->ls_count, n: 1);
875	lsp->ls_state = state;
876	lsp->ls_owner = owner;
877	lsp->ls_seqid.owner_id = atomic64_inc_return(v: &server->owner_ctr);
878	INIT_LIST_HEAD(list: &lsp->ls_locks);
879	return lsp;
880	}
881
882	void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
883	{
884	nfs4_destroy_seqid_counter(sc: &lsp->ls_seqid);
885	kfree(objp: lsp);
886	}
887
888	/*
889	* Return a compatible lock_state. If no initialized lock_state structure
890	* exists, return an uninitialized one.
891	*
892	*/
893	static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner)
894	{
895	struct nfs4_lock_state *lsp, *new = NULL;
896
897	for(;;) {
898	spin_lock(lock: &state->state_lock);
899	lsp = __nfs4_find_lock_state(state, owner, NULL);
900	if (lsp != NULL)
901	break;
902	if (new != NULL) {
903	list_add(new: &new->ls_locks, head: &state->lock_states);
904	set_bit(nr: LK_STATE_IN_USE, addr: &state->flags);
905	lsp = new;
906	new = NULL;
907	break;
908	}
909	spin_unlock(lock: &state->state_lock);
910	new = nfs4_alloc_lock_state(state, owner);
911	if (new == NULL)
912	return NULL;
913	}
914	spin_unlock(lock: &state->state_lock);
915	if (new != NULL)
916	nfs4_free_lock_state(server: state->owner->so_server, lsp: new);
917	return lsp;
918	}
919
920	/*
921	* Release reference to lock_state, and free it if we see that
922	* it is no longer in use
923	*/
924	void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
925	{
926	struct nfs_server *server;
927	struct nfs4_state *state;
928
929	if (lsp == NULL)
930	return;
931	state = lsp->ls_state;
932	if (!refcount_dec_and_lock(r: &lsp->ls_count, lock: &state->state_lock))
933	return;
934	list_del(entry: &lsp->ls_locks);
935	if (list_empty(head: &state->lock_states))
936	clear_bit(nr: LK_STATE_IN_USE, addr: &state->flags);
937	spin_unlock(lock: &state->state_lock);
938	server = state->owner->so_server;
939	if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
940	struct nfs_client *clp = server->nfs_client;
941
942	clp->cl_mvops->free_lock_state(server, lsp);
943	} else
944	nfs4_free_lock_state(server, lsp);
945	}
946
947	static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
948	{
949	struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
950
951	dst->fl_u.nfs4_fl.owner = lsp;
952	refcount_inc(r: &lsp->ls_count);
953	}
954
955	static void nfs4_fl_release_lock(struct file_lock *fl)
956	{
957	nfs4_put_lock_state(lsp: fl->fl_u.nfs4_fl.owner);
958	}
959
960	static const struct file_lock_operations nfs4_fl_lock_ops = {
961	.fl_copy_lock = nfs4_fl_copy_lock,
962	.fl_release_private = nfs4_fl_release_lock,
963	};
964
965	int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
966	{
967	struct nfs4_lock_state *lsp;
968
969	if (fl->fl_ops != NULL)
970	return 0;
971	lsp = nfs4_get_lock_state(state, owner: fl->c.flc_owner);
972	if (lsp == NULL)
973	return -ENOMEM;
974	fl->fl_u.nfs4_fl.owner = lsp;
975	fl->fl_ops = &nfs4_fl_lock_ops;
976	return 0;
977	}
978
979	static int nfs4_copy_lock_stateid(nfs4_stateid *dst,
980	struct nfs4_state *state,
981	const struct nfs_lock_context *l_ctx)
982	{
983	struct nfs4_lock_state *lsp;
984	fl_owner_t owner, fl_flock_owner;
985	int ret = -ENOENT;
986
987	if (l_ctx == NULL)
988	goto out;
989
990	if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
991	goto out;
992
993	owner = l_ctx->lockowner;
994	fl_flock_owner = l_ctx->open_context->flock_owner;
995
996	spin_lock(lock: &state->state_lock);
997	lsp = __nfs4_find_lock_state(state, owner, owner2: fl_flock_owner);
998	if (lsp && test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
999	ret = -EIO;
1000	else if (lsp != NULL && test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) {
1001	nfs4_stateid_copy(dst, src: &lsp->ls_stateid);
1002	ret = 0;
1003	}
1004	spin_unlock(lock: &state->state_lock);
1005	nfs4_put_lock_state(lsp);
1006	out:
1007	return ret;
1008	}
1009
1010	bool nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
1011	{
1012	bool ret;
1013	const nfs4_stateid *src;
1014	int seq;
1015
1016	do {
1017	ret = false;
1018	src = &zero_stateid;
1019	seq = read_seqbegin(sl: &state->seqlock);
1020	if (test_bit(NFS_OPEN_STATE, &state->flags)) {
1021	src = &state->open_stateid;
1022	ret = true;
1023	}
1024	nfs4_stateid_copy(dst, src);
1025	} while (read_seqretry(sl: &state->seqlock, start: seq));
1026	return ret;
1027	}
1028
1029	/*
1030	* Byte-range lock aware utility to initialize the stateid of read/write
1031	* requests.
1032	*/
1033	int nfs4_select_rw_stateid(struct nfs4_state *state,
1034	fmode_t fmode, const struct nfs_lock_context *l_ctx,
1035	nfs4_stateid *dst, const struct cred **cred)
1036	{
1037	int ret;
1038
1039	if (!nfs4_valid_open_stateid(state))
1040	return -EIO;
1041	if (cred != NULL)
1042	*cred = NULL;
1043	ret = nfs4_copy_lock_stateid(dst, state, l_ctx);
1044	if (ret == -EIO)
1045	/* A lost lock - don't even consider delegations */
1046	goto out;
1047	/* returns true if delegation stateid found and copied */
1048	if (nfs4_copy_delegation_stateid(inode: state->inode, flags: fmode, dst, cred)) {
1049	ret = 0;
1050	goto out;
1051	}
1052	if (ret != -ENOENT)
1053	/* nfs4_copy_delegation_stateid() didn't over-write
1054	* dst, so it still has the lock stateid which we now
1055	* choose to use.
1056	*/
1057	goto out;
1058	ret = nfs4_copy_open_stateid(dst, state) ? 0 : -EAGAIN;
1059	out:
1060	if (nfs_server_capable(inode: state->inode, NFS_CAP_STATEID_NFSV41))
1061	dst->seqid = 0;
1062	return ret;
1063	}
1064
1065	struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
1066	{
1067	struct nfs_seqid *new;
1068
1069	new = kmalloc(sizeof(*new), gfp_mask);
1070	if (new == NULL)
1071	return ERR_PTR(error: -ENOMEM);
1072	new->sequence = counter;
1073	INIT_LIST_HEAD(list: &new->list);
1074	new->task = NULL;
1075	return new;
1076	}
1077
1078	void nfs_release_seqid(struct nfs_seqid *seqid)
1079	{
1080	struct nfs_seqid_counter *sequence;
1081
1082	if (seqid == NULL || list_empty(head: &seqid->list))
1083	return;
1084	sequence = seqid->sequence;
1085	spin_lock(lock: &sequence->lock);
1086	if (list_is_first(list: &seqid->list, head: &sequence->list) &&
1087	!list_is_singular(head: &sequence->list)) {
1088	struct nfs_seqid *next = list_next_entry(seqid, list);
1089	rpc_wake_up_queued_task(&sequence->wait, next->task);
1090	}
1091	list_del_init(entry: &seqid->list);
1092	spin_unlock(lock: &sequence->lock);
1093	}
1094
1095	void nfs_free_seqid(struct nfs_seqid *seqid)
1096	{
1097	nfs_release_seqid(seqid);
1098	kfree(objp: seqid);
1099	}
1100
1101	/*
1102	* Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
1103	* failed with a seqid incrementing error -
1104	* see comments nfs4.h:seqid_mutating_error()
1105	*/
1106	static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
1107	{
1108	switch (status) {
1109	case 0:
1110	break;
1111	case -NFS4ERR_BAD_SEQID:
1112	if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
1113	return;
1114	pr_warn_ratelimited("NFS: v4 server returned a bad"
1115	" sequence-id error on an"
1116	" unconfirmed sequence %p!\n",
1117	seqid->sequence);
1118	return;
1119	case -NFS4ERR_STALE_CLIENTID:
1120	case -NFS4ERR_STALE_STATEID:
1121	case -NFS4ERR_BAD_STATEID:
1122	case -NFS4ERR_BADXDR:
1123	case -NFS4ERR_RESOURCE:
1124	case -NFS4ERR_NOFILEHANDLE:
1125	case -NFS4ERR_MOVED:
1126	/* Non-seqid mutating errors */
1127	return;
1128	}
1129	/*
1130	* Note: no locking needed as we are guaranteed to be first
1131	* on the sequence list
1132	*/
1133	seqid->sequence->counter++;
1134	}
1135
1136	void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
1137	{
1138	struct nfs4_state_owner *sp;
1139
1140	if (seqid == NULL)
1141	return;
1142
1143	sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid);
1144	if (status == -NFS4ERR_BAD_SEQID)
1145	nfs4_reset_state_owner(sp);
1146	if (!nfs4_has_session(clp: sp->so_server->nfs_client))
1147	nfs_increment_seqid(status, seqid);
1148	}
1149
1150	/*
1151	* Increment the seqid if the LOCK/LOCKU succeeded, or
1152	* failed with a seqid incrementing error -
1153	* see comments nfs4.h:seqid_mutating_error()
1154	*/
1155	void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
1156	{
1157	if (seqid != NULL)
1158	nfs_increment_seqid(status, seqid);
1159	}
1160
1161	int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
1162	{
1163	struct nfs_seqid_counter *sequence;
1164	int status = 0;
1165
1166	if (seqid == NULL)
1167	goto out;
1168	sequence = seqid->sequence;
1169	spin_lock(lock: &sequence->lock);
1170	seqid->task = task;
1171	if (list_empty(head: &seqid->list))
1172	list_add_tail(new: &seqid->list, head: &sequence->list);
1173	if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid)
1174	goto unlock;
1175	rpc_sleep_on(&sequence->wait, task, NULL);
1176	status = -EAGAIN;
1177	unlock:
1178	spin_unlock(lock: &sequence->lock);
1179	out:
1180	return status;
1181	}
1182
1183	static int nfs4_run_state_manager(void *);
1184
1185	static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
1186	{
1187	clear_and_wake_up_bit(bit: NFS4CLNT_MANAGER_RUNNING, word: &clp->cl_state);
1188	rpc_wake_up(&clp->cl_rpcwaitq);
1189	}
1190
1191	/*
1192	* Schedule the nfs_client asynchronous state management routine
1193	*/
1194	void nfs4_schedule_state_manager(struct nfs_client *clp)
1195	{
1196	struct task_struct *task;
1197	char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
1198	struct rpc_clnt *clnt = clp->cl_rpcclient;
1199	bool swapon = false;
1200
1201	if (clp->cl_cons_state < 0)
1202	return;
1203
1204	set_bit(nr: NFS4CLNT_RUN_MANAGER, addr: &clp->cl_state);
1205
1206	if (atomic_read(v: &clnt->cl_swapper)) {
1207	swapon = !test_and_set_bit(nr: NFS4CLNT_MANAGER_AVAILABLE,
1208	addr: &clp->cl_state);
1209	if (!swapon) {
1210	wake_up_var(var: &clp->cl_state);
1211	return;
1212	}
1213	}
1214
1215	if (test_and_set_bit(nr: NFS4CLNT_MANAGER_RUNNING, addr: &clp->cl_state) != 0)
1216	return;
1217
1218	__module_get(THIS_MODULE);
1219	refcount_inc(r: &clp->cl_count);
1220
1221	/* The rcu_read_lock() is not strictly necessary, as the state
1222	* manager is the only thread that ever changes the rpc_xprt
1223	* after it's initialized. At this point, we're single threaded. */
1224	rcu_read_lock();
1225	snprintf(buf, size: sizeof(buf), fmt: "%s-manager",
1226	rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
1227	rcu_read_unlock();
1228	task = kthread_run(nfs4_run_state_manager, clp, "%s", buf);
1229	if (IS_ERR(ptr: task)) {
1230	printk(KERN_ERR "%s: kthread_run: %ld\n",
1231	__func__, PTR_ERR(task));
1232	if (!nfs_client_init_is_complete(clp))
1233	nfs_mark_client_ready(clp, state: PTR_ERR(ptr: task));
1234	if (swapon)
1235	clear_bit(nr: NFS4CLNT_MANAGER_AVAILABLE, addr: &clp->cl_state);
1236	nfs4_clear_state_manager_bit(clp);
1237	nfs_put_client(clp);
1238	module_put(THIS_MODULE);
1239	}
1240	}
1241
1242	/*
1243	* Schedule a lease recovery attempt
1244	*/
1245	void nfs4_schedule_lease_recovery(struct nfs_client *clp)
1246	{
1247	if (!clp)
1248	return;
1249	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1250	set_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state);
1251	dprintk("%s: scheduling lease recovery for server %s\n", __func__,
1252	clp->cl_hostname);
1253	nfs4_schedule_state_manager(clp);
1254	}
1255	EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
1256
1257	/**
1258	* nfs4_schedule_migration_recovery - trigger migration recovery
1259	*
1260	* @server: FSID that is migrating
1261	*
1262	* Returns zero if recovery has started, otherwise a negative NFS4ERR
1263	* value is returned.
1264	*/
1265	int nfs4_schedule_migration_recovery(const struct nfs_server *server)
1266	{
1267	struct nfs_client *clp = server->nfs_client;
1268
1269	if (server->fh_expire_type != NFS4_FH_PERSISTENT) {
1270	pr_err("NFS: volatile file handles not supported (server %s)\n",
1271	clp->cl_hostname);
1272	return -NFS4ERR_IO;
1273	}
1274
1275	if (test_bit(NFS_MIG_FAILED, &server->mig_status))
1276	return -NFS4ERR_IO;
1277
1278	dprintk("%s: scheduling migration recovery for (%llx:%llx) on %s\n",
1279	__func__,
1280	(unsigned long long)server->fsid.major,
1281	(unsigned long long)server->fsid.minor,
1282	clp->cl_hostname);
1283
1284	set_bit(NFS_MIG_IN_TRANSITION,
1285	addr: &((struct nfs_server *)server)->mig_status);
1286	set_bit(nr: NFS4CLNT_MOVED, addr: &clp->cl_state);
1287
1288	nfs4_schedule_state_manager(clp);
1289	return 0;
1290	}
1291	EXPORT_SYMBOL_GPL(nfs4_schedule_migration_recovery);
1292
1293	/**
1294	* nfs4_schedule_lease_moved_recovery - start lease-moved recovery
1295	*
1296	* @clp: server to check for moved leases
1297	*
1298	*/
1299	void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp)
1300	{
1301	dprintk("%s: scheduling lease-moved recovery for client ID %llx on %s\n",
1302	__func__, clp->cl_clientid, clp->cl_hostname);
1303
1304	set_bit(nr: NFS4CLNT_LEASE_MOVED, addr: &clp->cl_state);
1305	nfs4_schedule_state_manager(clp);
1306	}
1307	EXPORT_SYMBOL_GPL(nfs4_schedule_lease_moved_recovery);
1308
1309	int nfs4_wait_clnt_recover(struct nfs_client *clp)
1310	{
1311	int res;
1312
1313	might_sleep();
1314
1315	refcount_inc(r: &clp->cl_count);
1316	res = wait_on_bit_action(word: &clp->cl_state, bit: NFS4CLNT_MANAGER_RUNNING,
1317	action: nfs_wait_bit_killable,
1318	TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
1319	if (res)
1320	goto out;
1321	if (clp->cl_cons_state < 0)
1322	res = clp->cl_cons_state;
1323	out:
1324	nfs_put_client(clp);
1325	return res;
1326	}
1327
1328	int nfs4_client_recover_expired_lease(struct nfs_client *clp)
1329	{
1330	unsigned int loop;
1331	int ret;
1332
1333	for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
1334	ret = nfs4_wait_clnt_recover(clp);
1335	if (ret != 0)
1336	break;
1337	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&
1338	!test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state))
1339	break;
1340	nfs4_schedule_state_manager(clp);
1341	ret = -EIO;
1342	}
1343	return ret;
1344	}
1345
1346	/*
1347	* nfs40_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN
1348	* @clp: client to process
1349	*
1350	* Set the NFS4CLNT_LEASE_EXPIRED state in order to force a
1351	* resend of the SETCLIENTID and hence re-establish the
1352	* callback channel. Then return all existing delegations.
1353	*/
1354	static void nfs40_handle_cb_pathdown(struct nfs_client *clp)
1355	{
1356	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
1357	nfs_expire_all_delegations(clp);
1358	dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
1359	clp->cl_hostname);
1360	}
1361
1362	void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
1363	{
1364	nfs40_handle_cb_pathdown(clp);
1365	nfs4_schedule_state_manager(clp);
1366	}
1367
1368	static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1369	{
1370
1371	if (!nfs4_valid_open_stateid(state))
1372	return 0;
1373	set_bit(nr: NFS_STATE_RECLAIM_REBOOT, addr: &state->flags);
1374	/* Don't recover state that expired before the reboot */
1375	if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) {
1376	clear_bit(nr: NFS_STATE_RECLAIM_REBOOT, addr: &state->flags);
1377	return 0;
1378	}
1379	set_bit(nr: NFS_OWNER_RECLAIM_REBOOT, addr: &state->owner->so_flags);
1380	set_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state);
1381	return 1;
1382	}
1383
1384	int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1385	{
1386	if (!nfs4_valid_open_stateid(state))
1387	return 0;
1388	set_bit(nr: NFS_STATE_RECLAIM_NOGRACE, addr: &state->flags);
1389	clear_bit(nr: NFS_STATE_RECLAIM_REBOOT, addr: &state->flags);
1390	set_bit(nr: NFS_OWNER_RECLAIM_NOGRACE, addr: &state->owner->so_flags);
1391	set_bit(nr: NFS4CLNT_RECLAIM_NOGRACE, addr: &clp->cl_state);
1392	return 1;
1393	}
1394
1395	int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
1396	{
1397	struct nfs_client *clp = server->nfs_client;
1398
1399	if (!nfs4_state_mark_reclaim_nograce(clp, state))
1400	return -EBADF;
1401	nfs_inode_find_delegation_state_and_recover(inode: state->inode,
1402	stateid: &state->stateid);
1403	dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
1404	clp->cl_hostname);
1405	nfs4_schedule_state_manager(clp);
1406	return clp->cl_cons_state < 0 ? clp->cl_cons_state : 0;
1407	}
1408	EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1409
1410	static struct nfs4_lock_state *
1411	nfs_state_find_lock_state_by_stateid(struct nfs4_state *state,
1412	const nfs4_stateid *stateid)
1413	{
1414	struct nfs4_lock_state *pos;
1415
1416	list_for_each_entry(pos, &state->lock_states, ls_locks) {
1417	if (!test_bit(NFS_LOCK_INITIALIZED, &pos->ls_flags))
1418	continue;
1419	if (nfs4_stateid_match_or_older(dst: &pos->ls_stateid, src: stateid))
1420	return pos;
1421	}
1422	return NULL;
1423	}
1424
1425	static bool nfs_state_lock_state_matches_stateid(struct nfs4_state *state,
1426	const nfs4_stateid *stateid)
1427	{
1428	bool found = false;
1429
1430	if (test_bit(LK_STATE_IN_USE, &state->flags)) {
1431	spin_lock(lock: &state->state_lock);
1432	if (nfs_state_find_lock_state_by_stateid(state, stateid))
1433	found = true;
1434	spin_unlock(lock: &state->state_lock);
1435	}
1436	return found;
1437	}
1438
1439	void nfs_inode_find_state_and_recover(struct inode *inode,
1440	const nfs4_stateid *stateid)
1441	{
1442	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1443	struct nfs_inode *nfsi = NFS_I(inode);
1444	struct nfs_open_context *ctx;
1445	struct nfs4_state *state;
1446	bool found = false;
1447
1448	if (!S_ISREG(inode->i_mode))
1449	goto out;
1450	rcu_read_lock();
1451	list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
1452	state = ctx->state;
1453	if (state == NULL)
1454	continue;
1455	if (nfs4_stateid_match_or_older(dst: &state->stateid, src: stateid) &&
1456	nfs4_state_mark_reclaim_nograce(clp, state)) {
1457	found = true;
1458	continue;
1459	}
1460	if (test_bit(NFS_OPEN_STATE, &state->flags) &&
1461	nfs4_stateid_match_or_older(dst: &state->open_stateid, src: stateid) &&
1462	nfs4_state_mark_reclaim_nograce(clp, state)) {
1463	found = true;
1464	continue;
1465	}
1466	if (nfs_state_lock_state_matches_stateid(state, stateid) &&
1467	nfs4_state_mark_reclaim_nograce(clp, state))
1468	found = true;
1469	}
1470	rcu_read_unlock();
1471	out:
1472	nfs_inode_find_delegation_state_and_recover(inode, stateid);
1473	if (found)
1474	nfs4_schedule_state_manager(clp);
1475	}
1476
1477	static void nfs4_state_mark_open_context_bad(struct nfs4_state *state, int err)
1478	{
1479	struct inode *inode = state->inode;
1480	struct nfs_inode *nfsi = NFS_I(inode);
1481	struct nfs_open_context *ctx;
1482
1483	if (!S_ISREG(inode->i_mode))
1484	return;
1485	rcu_read_lock();
1486	list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
1487	if (ctx->state != state)
1488	continue;
1489	set_bit(NFS_CONTEXT_BAD, addr: &ctx->flags);
1490	pr_warn("NFSv4: state recovery failed for open file %pd2, "
1491	"error = %d\n", ctx->dentry, err);
1492	}
1493	rcu_read_unlock();
1494	}
1495
1496	static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
1497	{
1498	set_bit(nr: NFS_STATE_RECOVERY_FAILED, addr: &state->flags);
1499	nfs4_state_mark_open_context_bad(state, err: error);
1500	}
1501
1502
1503	static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
1504	{
1505	struct inode *inode = state->inode;
1506	struct nfs_inode *nfsi = NFS_I(inode);
1507	struct file_lock *fl;
1508	struct nfs4_lock_state *lsp;
1509	int status = 0;
1510	struct file_lock_context *flctx = locks_inode_context(inode);
1511	struct list_head *list;
1512
1513	if (flctx == NULL)
1514	return 0;
1515
1516	list = &flctx->flc_posix;
1517
1518	/* Guard against delegation returns and new lock/unlock calls */
1519	down_write(sem: &nfsi->rwsem);
1520	spin_lock(lock: &flctx->flc_lock);
1521	restart:
1522	for_each_file_lock(fl, list) {
1523	if (nfs_file_open_context(filp: fl->c.flc_file)->state != state)
1524	continue;
1525	spin_unlock(lock: &flctx->flc_lock);
1526	status = ops->recover_lock(state, fl);
1527	switch (status) {
1528	case 0:
1529	break;
1530	case -ETIMEDOUT:
1531	case -ESTALE:
1532	case -NFS4ERR_ADMIN_REVOKED:
1533	case -NFS4ERR_STALE_STATEID:
1534	case -NFS4ERR_BAD_STATEID:
1535	case -NFS4ERR_EXPIRED:
1536	case -NFS4ERR_NO_GRACE:
1537	case -NFS4ERR_STALE_CLIENTID:
1538	case -NFS4ERR_BADSESSION:
1539	case -NFS4ERR_BADSLOT:
1540	case -NFS4ERR_BAD_HIGH_SLOT:
1541	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1542	goto out;
1543	default:
1544	pr_err("NFS: %s: unhandled error %d\n",
1545	__func__, status);
1546	fallthrough;
1547	case -ENOMEM:
1548	case -NFS4ERR_DENIED:
1549	case -NFS4ERR_RECLAIM_BAD:
1550	case -NFS4ERR_RECLAIM_CONFLICT:
1551	lsp = fl->fl_u.nfs4_fl.owner;
1552	if (lsp)
1553	set_bit(NFS_LOCK_LOST, addr: &lsp->ls_flags);
1554	status = 0;
1555	}
1556	spin_lock(lock: &flctx->flc_lock);
1557	}
1558	if (list == &flctx->flc_posix) {
1559	list = &flctx->flc_flock;
1560	goto restart;
1561	}
1562	spin_unlock(lock: &flctx->flc_lock);
1563	out:
1564	up_write(sem: &nfsi->rwsem);
1565	return status;
1566	}
1567
1568	#ifdef CONFIG_NFS_V4_2
1569	static void nfs42_complete_copies(struct nfs4_state_owner *sp, struct nfs4_state *state)
1570	{
1571	struct nfs4_copy_state *copy;
1572
1573	if (!test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
1574	!test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags))
1575	return;
1576
1577	spin_lock(lock: &sp->so_server->nfs_client->cl_lock);
1578	list_for_each_entry(copy, &sp->so_server->ss_copies, copies) {
1579	if ((test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
1580	!nfs4_stateid_match_other(dst: &state->stateid,
1581	src: &copy->parent_dst_state->stateid)))
1582	continue;
1583	copy->flags = 1;
1584	if (test_and_clear_bit(nr: NFS_CLNT_DST_SSC_COPY_STATE,
1585	addr: &state->flags)) {
1586	clear_bit(nr: NFS_CLNT_SRC_SSC_COPY_STATE, addr: &state->flags);
1587	complete(&copy->completion);
1588	}
1589	}
1590	list_for_each_entry(copy, &sp->so_server->ss_src_copies, src_copies) {
1591	if ((test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags) &&
1592	!nfs4_stateid_match_other(dst: &state->stateid,
1593	src: &copy->parent_src_state->stateid)))
1594	continue;
1595	copy->flags = 1;
1596	if (test_and_clear_bit(nr: NFS_CLNT_DST_SSC_COPY_STATE,
1597	addr: &state->flags))
1598	complete(&copy->completion);
1599	}
1600	spin_unlock(lock: &sp->so_server->nfs_client->cl_lock);
1601	}
1602	#else /* !CONFIG_NFS_V4_2 */
1603	static inline void nfs42_complete_copies(struct nfs4_state_owner *sp,
1604	struct nfs4_state *state)
1605	{
1606	}
1607	#endif /* CONFIG_NFS_V4_2 */
1608
1609	static int __nfs4_reclaim_open_state(struct nfs4_state_owner *sp, struct nfs4_state *state,
1610	const struct nfs4_state_recovery_ops *ops,
1611	int *lost_locks)
1612	{
1613	struct nfs4_lock_state *lock;
1614	int status;
1615
1616	status = ops->recover_open(sp, state);
1617	if (status < 0)
1618	return status;
1619
1620	status = nfs4_reclaim_locks(state, ops);
1621	if (status < 0)
1622	return status;
1623
1624	if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
1625	spin_lock(lock: &state->state_lock);
1626	list_for_each_entry(lock, &state->lock_states, ls_locks) {
1627	trace_nfs4_state_lock_reclaim(state, lock);
1628	if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags) &&
1629	!test_bit(NFS_LOCK_UNLOCKING, &lock->ls_flags))
1630	*lost_locks += 1;
1631	}
1632	spin_unlock(lock: &state->state_lock);
1633	}
1634
1635	nfs42_complete_copies(sp, state);
1636	clear_bit(nr: NFS_STATE_RECLAIM_NOGRACE, addr: &state->flags);
1637	return status;
1638	}
1639
1640	static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp,
1641	const struct nfs4_state_recovery_ops *ops,
1642	int *lost_locks)
1643	{
1644	struct nfs4_state *state;
1645	unsigned int loop = 0;
1646	int status = 0;
1647	#ifdef CONFIG_NFS_V4_2
1648	bool found_ssc_copy_state = false;
1649	#endif /* CONFIG_NFS_V4_2 */
1650
1651	/* Note: we rely on the sp->so_states list being ordered
1652	* so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
1653	* states first.
1654	* This is needed to ensure that the server won't give us any
1655	* read delegations that we have to return if, say, we are
1656	* recovering after a network partition or a reboot from a
1657	* server that doesn't support a grace period.
1658	*/
1659	spin_lock(lock: &sp->so_lock);
1660	restart:
1661	list_for_each_entry(state, &sp->so_states, open_states) {
1662	if (!test_and_clear_bit(nr: ops->state_flag_bit, addr: &state->flags))
1663	continue;
1664	if (!nfs4_valid_open_stateid(state))
1665	continue;
1666	if (state->state == 0)
1667	continue;
1668	#ifdef CONFIG_NFS_V4_2
1669	if (test_bit(NFS_SRV_SSC_COPY_STATE, &state->flags)) {
1670	nfs4_state_mark_recovery_failed(state, error: -EIO);
1671	found_ssc_copy_state = true;
1672	continue;
1673	}
1674	#endif /* CONFIG_NFS_V4_2 */
1675	refcount_inc(r: &state->count);
1676	spin_unlock(lock: &sp->so_lock);
1677	status = __nfs4_reclaim_open_state(sp, state, ops, lost_locks);
1678
1679	switch (status) {
1680	default:
1681	if (status >= 0) {
1682	loop = 0;
1683	break;
1684	}
1685	printk(KERN_ERR "NFS: %s: unhandled error %d\n", __func__, status);
1686	fallthrough;
1687	case -ENOENT:
1688	case -ENOMEM:
1689	case -EACCES:
1690	case -EROFS:
1691	case -EIO:
1692	case -ESTALE:
1693	/* Open state on this file cannot be recovered */
1694	nfs4_state_mark_recovery_failed(state, error: status);
1695	break;
1696	case -EAGAIN:
1697	ssleep(seconds: 1);
1698	if (loop++ < 10) {
1699	set_bit(nr: ops->state_flag_bit, addr: &state->flags);
1700	break;
1701	}
1702	fallthrough;
1703	case -NFS4ERR_ADMIN_REVOKED:
1704	case -NFS4ERR_STALE_STATEID:
1705	case -NFS4ERR_OLD_STATEID:
1706	case -NFS4ERR_BAD_STATEID:
1707	case -NFS4ERR_RECLAIM_BAD:
1708	case -NFS4ERR_RECLAIM_CONFLICT:
1709	nfs4_state_mark_reclaim_nograce(clp: sp->so_server->nfs_client, state);
1710	break;
1711	case -NFS4ERR_EXPIRED:
1712	case -NFS4ERR_NO_GRACE:
1713	nfs4_state_mark_reclaim_nograce(clp: sp->so_server->nfs_client, state);
1714	fallthrough;
1715	case -NFS4ERR_STALE_CLIENTID:
1716	case -NFS4ERR_BADSESSION:
1717	case -NFS4ERR_BADSLOT:
1718	case -NFS4ERR_BAD_HIGH_SLOT:
1719	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1720	case -ETIMEDOUT:
1721	goto out_err;
1722	}
1723	nfs4_put_open_state(state);
1724	spin_lock(lock: &sp->so_lock);
1725	goto restart;
1726	}
1727	spin_unlock(lock: &sp->so_lock);
1728	#ifdef CONFIG_NFS_V4_2
1729	if (found_ssc_copy_state)
1730	return -EIO;
1731	#endif /* CONFIG_NFS_V4_2 */
1732	return 0;
1733	out_err:
1734	nfs4_put_open_state(state);
1735	spin_lock(lock: &sp->so_lock);
1736	spin_unlock(lock: &sp->so_lock);
1737	return status;
1738	}
1739
1740	static void nfs4_clear_open_state(struct nfs4_state *state)
1741	{
1742	struct nfs4_lock_state *lock;
1743
1744	clear_bit(nr: NFS_DELEGATED_STATE, addr: &state->flags);
1745	clear_bit(nr: NFS_O_RDONLY_STATE, addr: &state->flags);
1746	clear_bit(nr: NFS_O_WRONLY_STATE, addr: &state->flags);
1747	clear_bit(nr: NFS_O_RDWR_STATE, addr: &state->flags);
1748	spin_lock(lock: &state->state_lock);
1749	list_for_each_entry(lock, &state->lock_states, ls_locks) {
1750	lock->ls_seqid.flags = 0;
1751	clear_bit(NFS_LOCK_INITIALIZED, addr: &lock->ls_flags);
1752	}
1753	spin_unlock(lock: &state->state_lock);
1754	}
1755
1756	static void nfs4_reset_seqids(struct nfs_server *server,
1757	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1758	{
1759	struct nfs_client *clp = server->nfs_client;
1760	struct nfs4_state_owner *sp;
1761	struct rb_node *pos;
1762	struct nfs4_state *state;
1763
1764	spin_lock(lock: &clp->cl_lock);
1765	for (pos = rb_first(root: &server->state_owners);
1766	pos != NULL;
1767	pos = rb_next(pos)) {
1768	sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1769	sp->so_seqid.flags = 0;
1770	spin_lock(lock: &sp->so_lock);
1771	list_for_each_entry(state, &sp->so_states, open_states) {
1772	if (mark_reclaim(clp, state))
1773	nfs4_clear_open_state(state);
1774	}
1775	spin_unlock(lock: &sp->so_lock);
1776	}
1777	spin_unlock(lock: &clp->cl_lock);
1778	}
1779
1780	static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
1781	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1782	{
1783	struct nfs_server *server;
1784
1785	rcu_read_lock();
1786	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1787	nfs4_reset_seqids(server, mark_reclaim);
1788	rcu_read_unlock();
1789	}
1790
1791	static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1792	{
1793	set_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state);
1794	/* Mark all delegations for reclaim */
1795	nfs_delegation_mark_reclaim(clp);
1796	nfs4_state_mark_reclaim_helper(clp, mark_reclaim: nfs4_state_mark_reclaim_reboot);
1797	}
1798
1799	static int nfs4_reclaim_complete(struct nfs_client *clp,
1800	const struct nfs4_state_recovery_ops *ops,
1801	const struct cred *cred)
1802	{
1803	/* Notify the server we're done reclaiming our state */
1804	if (ops->reclaim_complete)
1805	return ops->reclaim_complete(clp, cred);
1806	return 0;
1807	}
1808
1809	static void nfs4_clear_reclaim_server(struct nfs_server *server)
1810	{
1811	struct nfs_client *clp = server->nfs_client;
1812	struct nfs4_state_owner *sp;
1813	struct rb_node *pos;
1814	struct nfs4_state *state;
1815
1816	spin_lock(lock: &clp->cl_lock);
1817	for (pos = rb_first(root: &server->state_owners);
1818	pos != NULL;
1819	pos = rb_next(pos)) {
1820	sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1821	spin_lock(lock: &sp->so_lock);
1822	list_for_each_entry(state, &sp->so_states, open_states) {
1823	if (!test_and_clear_bit(nr: NFS_STATE_RECLAIM_REBOOT,
1824	addr: &state->flags))
1825	continue;
1826	nfs4_state_mark_reclaim_nograce(clp, state);
1827	}
1828	spin_unlock(lock: &sp->so_lock);
1829	}
1830	spin_unlock(lock: &clp->cl_lock);
1831	}
1832
1833	static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
1834	{
1835	struct nfs_server *server;
1836
1837	if (!test_and_clear_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state))
1838	return 0;
1839
1840	rcu_read_lock();
1841	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1842	nfs4_clear_reclaim_server(server);
1843	rcu_read_unlock();
1844
1845	nfs_delegation_reap_unclaimed(clp);
1846	return 1;
1847	}
1848
1849	static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1850	{
1851	const struct nfs4_state_recovery_ops *ops;
1852	const struct cred *cred;
1853	int err;
1854
1855	if (!nfs4_state_clear_reclaim_reboot(clp))
1856	return;
1857	pnfs_destroy_all_layouts(clp);
1858	ops = clp->cl_mvops->reboot_recovery_ops;
1859	cred = nfs4_get_clid_cred(clp);
1860	err = nfs4_reclaim_complete(clp, ops, cred);
1861	put_cred(cred);
1862	if (err == -NFS4ERR_CONN_NOT_BOUND_TO_SESSION)
1863	set_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state);
1864	}
1865
1866	static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
1867	{
1868	nfs_mark_test_expired_all_delegations(clp);
1869	nfs4_state_mark_reclaim_helper(clp, mark_reclaim: nfs4_state_mark_reclaim_nograce);
1870	}
1871
1872	static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1873	{
1874	switch (error) {
1875	case 0:
1876	break;
1877	case -NFS4ERR_CB_PATH_DOWN:
1878	nfs40_handle_cb_pathdown(clp);
1879	break;
1880	case -NFS4ERR_NO_GRACE:
1881	nfs4_state_end_reclaim_reboot(clp);
1882	break;
1883	case -NFS4ERR_STALE_CLIENTID:
1884	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
1885	nfs4_state_start_reclaim_reboot(clp);
1886	break;
1887	case -NFS4ERR_EXPIRED:
1888	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
1889	nfs4_state_start_reclaim_nograce(clp);
1890	break;
1891	case -NFS4ERR_BADSESSION:
1892	case -NFS4ERR_BADSLOT:
1893	case -NFS4ERR_BAD_HIGH_SLOT:
1894	case -NFS4ERR_DEADSESSION:
1895	case -NFS4ERR_SEQ_FALSE_RETRY:
1896	case -NFS4ERR_SEQ_MISORDERED:
1897	set_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
1898	/* Zero session reset errors */
1899	break;
1900	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1901	set_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
1902	break;
1903	default:
1904	dprintk("%s: failed to handle error %d for server %s\n",
1905	__func__, error, clp->cl_hostname);
1906	return error;
1907	}
1908	dprintk("%s: handled error %d for server %s\n", __func__, error,
1909	clp->cl_hostname);
1910	return 0;
1911	}
1912
1913	static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
1914	{
1915	struct nfs4_state_owner *sp;
1916	struct nfs_server *server;
1917	struct rb_node *pos;
1918	LIST_HEAD(freeme);
1919	int lost_locks = 0;
1920	int status;
1921
1922	status = nfs4_begin_drain_session(clp);
1923	if (status < 0)
1924	return status;
1925	restart:
1926	rcu_read_lock();
1927	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1928	nfs4_purge_state_owners(server, head: &freeme);
1929	spin_lock(lock: &clp->cl_lock);
1930	for (pos = rb_first(root: &server->state_owners);
1931	pos != NULL;
1932	pos = rb_next(pos)) {
1933	sp = rb_entry(pos,
1934	struct nfs4_state_owner, so_server_node);
1935	if (!test_and_clear_bit(nr: ops->owner_flag_bit,
1936	addr: &sp->so_flags))
1937	continue;
1938	if (!atomic_inc_not_zero(v: &sp->so_count))
1939	continue;
1940	spin_unlock(lock: &clp->cl_lock);
1941	rcu_read_unlock();
1942
1943	status = nfs4_reclaim_open_state(sp, ops, lost_locks: &lost_locks);
1944	if (status < 0) {
1945	if (lost_locks)
1946	pr_warn("NFS: %s: lost %d locks\n",
1947	clp->cl_hostname, lost_locks);
1948	set_bit(nr: ops->owner_flag_bit, addr: &sp->so_flags);
1949	nfs4_put_state_owner(sp);
1950	status = nfs4_recovery_handle_error(clp, error: status);
1951	nfs4_free_state_owners(head: &freeme);
1952	return (status != 0) ? status : -EAGAIN;
1953	}
1954
1955	nfs4_put_state_owner(sp);
1956	goto restart;
1957	}
1958	spin_unlock(lock: &clp->cl_lock);
1959	}
1960	rcu_read_unlock();
1961	nfs4_free_state_owners(head: &freeme);
1962	nfs_local_probe_async(clp);
1963	if (lost_locks)
1964	pr_warn("NFS: %s: lost %d locks\n",
1965	clp->cl_hostname, lost_locks);
1966	return 0;
1967	}
1968
1969	static int nfs4_check_lease(struct nfs_client *clp)
1970	{
1971	const struct cred *cred;
1972	const struct nfs4_state_maintenance_ops *ops =
1973	clp->cl_mvops->state_renewal_ops;
1974	int status;
1975
1976	/* Is the client already known to have an expired lease? */
1977	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1978	return 0;
1979	cred = ops->get_state_renewal_cred(clp);
1980	if (cred == NULL) {
1981	cred = nfs4_get_clid_cred(clp);
1982	status = -ENOKEY;
1983	if (cred == NULL)
1984	goto out;
1985	}
1986	status = ops->renew_lease(clp, cred);
1987	put_cred(cred);
1988	if (status == -ETIMEDOUT) {
1989	set_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state);
1990	return 0;
1991	}
1992	out:
1993	return nfs4_recovery_handle_error(clp, error: status);
1994	}
1995
1996	/* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
1997	* and for recoverable errors on EXCHANGE_ID for v4.1
1998	*/
1999	static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
2000	{
2001	switch (status) {
2002	case -NFS4ERR_SEQ_MISORDERED:
2003	if (test_and_set_bit(nr: NFS4CLNT_PURGE_STATE, addr: &clp->cl_state))
2004	return -ESERVERFAULT;
2005	/* Lease confirmation error: retry after purging the lease */
2006	ssleep(seconds: 1);
2007	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
2008	break;
2009	case -NFS4ERR_STALE_CLIENTID:
2010	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
2011	nfs4_state_start_reclaim_reboot(clp);
2012	break;
2013	case -NFS4ERR_CLID_INUSE:
2014	pr_err("NFS: Server %s reports our clientid is in use\n",
2015	clp->cl_hostname);
2016	nfs_mark_client_ready(clp, state: -EPERM);
2017	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
2018	return -EPERM;
2019	case -ETIMEDOUT:
2020	if (clp->cl_cons_state == NFS_CS_SESSION_INITING) {
2021	nfs_mark_client_ready(clp, state: -EIO);
2022	return -EIO;
2023	}
2024	fallthrough;
2025	case -EACCES:
2026	case -NFS4ERR_DELAY:
2027	case -EAGAIN:
2028	ssleep(seconds: 1);
2029	break;
2030
2031	case -NFS4ERR_MINOR_VERS_MISMATCH:
2032	if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
2033	nfs_mark_client_ready(clp, state: -EPROTONOSUPPORT);
2034	dprintk("%s: exit with error %d for server %s\n",
2035	__func__, -EPROTONOSUPPORT, clp->cl_hostname);
2036	return -EPROTONOSUPPORT;
2037	case -ENOSPC:
2038	if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
2039	nfs_mark_client_ready(clp, state: -EIO);
2040	return -EIO;
2041	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2042	* in nfs4_exchange_id */
2043	default:
2044	dprintk("%s: exit with error %d for server %s\n", __func__,
2045	status, clp->cl_hostname);
2046	return status;
2047	}
2048	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
2049	dprintk("%s: handled error %d for server %s\n", __func__, status,
2050	clp->cl_hostname);
2051	return 0;
2052	}
2053
2054	static int nfs4_establish_lease(struct nfs_client *clp)
2055	{
2056	const struct cred *cred;
2057	const struct nfs4_state_recovery_ops *ops =
2058	clp->cl_mvops->reboot_recovery_ops;
2059	int status;
2060
2061	status = nfs4_begin_drain_session(clp);
2062	if (status != 0)
2063	return status;
2064	cred = nfs4_get_clid_cred(clp);
2065	if (cred == NULL)
2066	return -ENOENT;
2067	status = ops->establish_clid(clp, cred);
2068	put_cred(cred);
2069	if (status != 0)
2070	return status;
2071	return 0;
2072	}
2073
2074	/*
2075	* Returns zero or a negative errno. NFS4ERR values are converted
2076	* to local errno values.
2077	*/
2078	static int nfs4_reclaim_lease(struct nfs_client *clp)
2079	{
2080	int status;
2081
2082	status = nfs4_establish_lease(clp);
2083	if (status < 0)
2084	return nfs4_handle_reclaim_lease_error(clp, status);
2085	if (test_and_clear_bit(nr: NFS4CLNT_SERVER_SCOPE_MISMATCH, addr: &clp->cl_state))
2086	nfs4_state_start_reclaim_nograce(clp);
2087	if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
2088	set_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state);
2089	clear_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state);
2090	clear_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
2091	return 0;
2092	}
2093
2094	static int nfs4_purge_lease(struct nfs_client *clp)
2095	{
2096	int status;
2097
2098	status = nfs4_establish_lease(clp);
2099	if (status < 0)
2100	return nfs4_handle_reclaim_lease_error(clp, status);
2101	clear_bit(nr: NFS4CLNT_PURGE_STATE, addr: &clp->cl_state);
2102	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
2103	nfs4_state_start_reclaim_nograce(clp);
2104	return 0;
2105	}
2106
2107	/*
2108	* Try remote migration of one FSID from a source server to a
2109	* destination server. The source server provides a list of
2110	* potential destinations.
2111	*
2112	* Returns zero or a negative NFS4ERR status code.
2113	*/
2114	static int nfs4_try_migration(struct nfs_server *server, const struct cred *cred)
2115	{
2116	struct nfs_client *clp = server->nfs_client;
2117	struct nfs4_fs_locations *locations = NULL;
2118	struct nfs_fattr *fattr;
2119	struct inode *inode;
2120	struct page *page;
2121	int status, result;
2122
2123	dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__,
2124	(unsigned long long)server->fsid.major,
2125	(unsigned long long)server->fsid.minor,
2126	clp->cl_hostname);
2127
2128	page = alloc_page(GFP_KERNEL);
2129	locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
2130	fattr = nfs_alloc_fattr();
2131	if (page == NULL || locations == NULL || fattr == NULL) {
2132	dprintk("<-- %s: no memory\n", __func__);
2133	result = 0;
2134	goto out;
2135	}
2136
2137	locations->fattr = fattr;
2138	inode = d_inode(dentry: server->super->s_root);
2139	result = nfs4_proc_get_locations(server, NFS_FH(inode), locations,
2140	page, cred);
2141	if (result) {
2142	dprintk("<-- %s: failed to retrieve fs_locations: %d\n",
2143	__func__, result);
2144	goto out;
2145	}
2146
2147	result = -NFS4ERR_NXIO;
2148	if (!locations->nlocations)
2149	goto out;
2150
2151	if (!(locations->fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)) {
2152	dprintk("<-- %s: No fs_locations data, migration skipped\n",
2153	__func__);
2154	goto out;
2155	}
2156
2157	status = nfs4_begin_drain_session(clp);
2158	if (status != 0) {
2159	result = status;
2160	goto out;
2161	}
2162
2163	status = nfs4_replace_transport(server, locations);
2164	if (status != 0) {
2165	dprintk("<-- %s: failed to replace transport: %d\n",
2166	__func__, status);
2167	goto out;
2168	}
2169
2170	result = 0;
2171	dprintk("<-- %s: migration succeeded\n", __func__);
2172
2173	out:
2174	if (page != NULL)
2175	__free_page(page);
2176	if (locations != NULL)
2177	kfree(objp: locations->fattr);
2178	kfree(objp: locations);
2179	if (result) {
2180	pr_err("NFS: migration recovery failed (server %s)\n",
2181	clp->cl_hostname);
2182	set_bit(NFS_MIG_FAILED, addr: &server->mig_status);
2183	}
2184	return result;
2185	}
2186
2187	/*
2188	* Returns zero or a negative NFS4ERR status code.
2189	*/
2190	static int nfs4_handle_migration(struct nfs_client *clp)
2191	{
2192	const struct nfs4_state_maintenance_ops *ops =
2193	clp->cl_mvops->state_renewal_ops;
2194	struct nfs_server *server;
2195	const struct cred *cred;
2196
2197	dprintk("%s: migration reported on \"%s\"\n", __func__,
2198	clp->cl_hostname);
2199
2200	cred = ops->get_state_renewal_cred(clp);
2201	if (cred == NULL)
2202	return -NFS4ERR_NOENT;
2203
2204	clp->cl_mig_gen++;
2205	restart:
2206	rcu_read_lock();
2207	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2208	int status;
2209
2210	if (server->mig_gen == clp->cl_mig_gen)
2211	continue;
2212	server->mig_gen = clp->cl_mig_gen;
2213
2214	if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION,
2215	addr: &server->mig_status))
2216	continue;
2217
2218	rcu_read_unlock();
2219	status = nfs4_try_migration(server, cred);
2220	if (status < 0) {
2221	put_cred(cred);
2222	return status;
2223	}
2224	goto restart;
2225	}
2226	rcu_read_unlock();
2227	put_cred(cred);
2228	return 0;
2229	}
2230
2231	/*
2232	* Test each nfs_server on the clp's cl_superblocks list to see
2233	* if it's moved to another server. Stop when the server no longer
2234	* returns NFS4ERR_LEASE_MOVED.
2235	*/
2236	static int nfs4_handle_lease_moved(struct nfs_client *clp)
2237	{
2238	const struct nfs4_state_maintenance_ops *ops =
2239	clp->cl_mvops->state_renewal_ops;
2240	struct nfs_server *server;
2241	const struct cred *cred;
2242
2243	dprintk("%s: lease moved reported on \"%s\"\n", __func__,
2244	clp->cl_hostname);
2245
2246	cred = ops->get_state_renewal_cred(clp);
2247	if (cred == NULL)
2248	return -NFS4ERR_NOENT;
2249
2250	clp->cl_mig_gen++;
2251	restart:
2252	rcu_read_lock();
2253	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2254	struct inode *inode;
2255	int status;
2256
2257	if (server->mig_gen == clp->cl_mig_gen)
2258	continue;
2259	server->mig_gen = clp->cl_mig_gen;
2260
2261	rcu_read_unlock();
2262
2263	inode = d_inode(dentry: server->super->s_root);
2264	status = nfs4_proc_fsid_present(inode, cred);
2265	if (status != -NFS4ERR_MOVED)
2266	goto restart; /* wasn't this one */
2267	if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED)
2268	goto restart; /* there are more */
2269	goto out;
2270	}
2271	rcu_read_unlock();
2272
2273	out:
2274	put_cred(cred);
2275	return 0;
2276	}
2277
2278	/**
2279	* nfs4_discover_server_trunking - Detect server IP address trunking
2280	*
2281	* @clp: nfs_client under test
2282	* @result: OUT: found nfs_client, or clp
2283	*
2284	* Returns zero or a negative errno. If zero is returned,
2285	* an nfs_client pointer is planted in "result".
2286	*
2287	* Note: since we are invoked in process context, and
2288	* not from inside the state manager, we cannot use
2289	* nfs4_handle_reclaim_lease_error().
2290	*/
2291	int nfs4_discover_server_trunking(struct nfs_client *clp,
2292	struct nfs_client **result)
2293	{
2294	const struct nfs4_state_recovery_ops *ops =
2295	clp->cl_mvops->reboot_recovery_ops;
2296	struct rpc_clnt *clnt;
2297	const struct cred *cred;
2298	int i, status;
2299
2300	dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);
2301
2302	clnt = clp->cl_rpcclient;
2303	i = 0;
2304
2305	mutex_lock(&nfs_clid_init_mutex);
2306	again:
2307	status = -ENOENT;
2308	cred = nfs4_get_clid_cred(clp);
2309	if (cred == NULL)
2310	goto out_unlock;
2311
2312	status = ops->detect_trunking(clp, result, cred);
2313	put_cred(cred);
2314	switch (status) {
2315	case 0:
2316	case -EINTR:
2317	case -ERESTARTSYS:
2318	break;
2319	case -ETIMEDOUT:
2320	if (clnt->cl_softrtry)
2321	break;
2322	fallthrough;
2323	case -NFS4ERR_DELAY:
2324	case -EAGAIN:
2325	ssleep(seconds: 1);
2326	fallthrough;
2327	case -NFS4ERR_STALE_CLIENTID:
2328	dprintk("NFS: %s after status %d, retrying\n",
2329	__func__, status);
2330	goto again;
2331	case -EACCES:
2332	if (i++ == 0) {
2333	nfs4_root_machine_cred(clp);
2334	goto again;
2335	}
2336	if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX)
2337	break;
2338	fallthrough;
2339	case -NFS4ERR_CLID_INUSE:
2340	case -NFS4ERR_WRONGSEC:
2341	/* No point in retrying if we already used RPC_AUTH_UNIX */
2342	if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) {
2343	status = -EPERM;
2344	break;
2345	}
2346	clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX);
2347	if (IS_ERR(ptr: clnt)) {
2348	status = PTR_ERR(ptr: clnt);
2349	break;
2350	}
2351	/* Note: this is safe because we haven't yet marked the
2352	* client as ready, so we are the only user of
2353	* clp->cl_rpcclient
2354	*/
2355	clnt = xchg(&clp->cl_rpcclient, clnt);
2356	rpc_shutdown_client(clnt);
2357	clnt = clp->cl_rpcclient;
2358	goto again;
2359
2360	case -NFS4ERR_MINOR_VERS_MISMATCH:
2361	status = -EPROTONOSUPPORT;
2362	break;
2363
2364	case -EKEYEXPIRED:
2365	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2366	* in nfs4_exchange_id */
2367	status = -EKEYEXPIRED;
2368	break;
2369	default:
2370	pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
2371	__func__, status);
2372	status = -EIO;
2373	}
2374
2375	out_unlock:
2376	mutex_unlock(lock: &nfs_clid_init_mutex);
2377	dprintk("NFS: %s: status = %d\n", __func__, status);
2378	return status;
2379	}
2380
2381	#ifdef CONFIG_NFS_V4_1
2382	void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
2383	{
2384	struct nfs_client *clp = session->clp;
2385
2386	switch (err) {
2387	default:
2388	set_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
2389	break;
2390	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
2391	set_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
2392	}
2393	nfs4_schedule_state_manager(clp);
2394	}
2395	EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
2396
2397	void nfs41_notify_server(struct nfs_client *clp)
2398	{
2399	/* Use CHECK_LEASE to ping the server with a SEQUENCE */
2400	set_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state);
2401	nfs4_schedule_state_manager(clp);
2402	}
2403
2404	static void nfs4_reset_all_state(struct nfs_client *clp)
2405	{
2406	if (test_and_set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state) == 0) {
2407	set_bit(nr: NFS4CLNT_PURGE_STATE, addr: &clp->cl_state);
2408	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
2409	nfs4_state_start_reclaim_nograce(clp);
2410	dprintk("%s: scheduling reset of all state for server %s!\n",
2411	__func__, clp->cl_hostname);
2412	nfs4_schedule_state_manager(clp);
2413	}
2414	}
2415
2416	static void nfs41_handle_server_reboot(struct nfs_client *clp)
2417	{
2418	if (test_and_set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state) == 0) {
2419	nfs4_state_start_reclaim_reboot(clp);
2420	dprintk("%s: server %s rebooted!\n", __func__,
2421	clp->cl_hostname);
2422	nfs4_schedule_state_manager(clp);
2423	}
2424	}
2425
2426	static void nfs41_handle_all_state_revoked(struct nfs_client *clp)
2427	{
2428	nfs4_reset_all_state(clp);
2429	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2430	}
2431
2432	static void nfs41_handle_some_state_revoked(struct nfs_client *clp)
2433	{
2434	nfs4_state_start_reclaim_nograce(clp);
2435	nfs4_schedule_state_manager(clp);
2436
2437	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2438	}
2439
2440	static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
2441	{
2442	/* FIXME: For now, we destroy all layouts. */
2443	pnfs_destroy_all_layouts(clp);
2444	nfs_test_expired_all_delegations(clp);
2445	dprintk("%s: Recallable state revoked on server %s!\n", __func__,
2446	clp->cl_hostname);
2447	}
2448
2449	static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
2450	{
2451	set_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
2452	nfs4_schedule_state_manager(clp);
2453
2454	dprintk("%s: server %s declared a backchannel fault\n", __func__,
2455	clp->cl_hostname);
2456	}
2457
2458	static void nfs41_handle_cb_path_down(struct nfs_client *clp)
2459	{
2460	if (test_and_set_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION,
2461	addr: &clp->cl_state) == 0)
2462	nfs4_schedule_state_manager(clp);
2463	}
2464
2465	void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags,
2466	bool recovery)
2467	{
2468	if (!flags)
2469	return;
2470
2471	dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
2472	__func__, clp->cl_hostname, clp->cl_clientid, flags);
2473	/*
2474	* If we're called from the state manager thread, then assume we're
2475	* already handling the RECLAIM_NEEDED and/or STATE_REVOKED.
2476	* Those flags are expected to remain set until we're done
2477	* recovering (see RFC5661, section 18.46.3).
2478	*/
2479	if (recovery)
2480	goto out_recovery;
2481
2482	if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
2483	nfs41_handle_server_reboot(clp);
2484	if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED))
2485	nfs41_handle_all_state_revoked(clp);
2486	if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
2487	SEQ4_STATUS_ADMIN_STATE_REVOKED))
2488	nfs41_handle_some_state_revoked(clp);
2489	if (flags & SEQ4_STATUS_LEASE_MOVED)
2490	nfs4_schedule_lease_moved_recovery(clp);
2491	if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
2492	nfs41_handle_recallable_state_revoked(clp);
2493	out_recovery:
2494	if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT)
2495	nfs41_handle_backchannel_fault(clp);
2496	else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
2497	SEQ4_STATUS_CB_PATH_DOWN_SESSION))
2498	nfs41_handle_cb_path_down(clp);
2499	}
2500
2501	static int nfs4_reset_session(struct nfs_client *clp)
2502	{
2503	const struct cred *cred;
2504	int status;
2505
2506	if (!nfs4_has_session(clp))
2507	return 0;
2508	status = nfs4_begin_drain_session(clp);
2509	if (status != 0)
2510	return status;
2511	cred = nfs4_get_clid_cred(clp);
2512	status = nfs4_proc_destroy_session(clp->cl_session, cred);
2513	switch (status) {
2514	case 0:
2515	case -NFS4ERR_BADSESSION:
2516	case -NFS4ERR_DEADSESSION:
2517	break;
2518	case -NFS4ERR_BACK_CHAN_BUSY:
2519	case -NFS4ERR_DELAY:
2520	set_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
2521	status = 0;
2522	ssleep(seconds: 1);
2523	goto out;
2524	default:
2525	status = nfs4_recovery_handle_error(clp, error: status);
2526	goto out;
2527	}
2528
2529	memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
2530	status = nfs4_proc_create_session(clp, cred);
2531	if (status) {
2532	dprintk("%s: session reset failed with status %d for server %s!\n",
2533	__func__, status, clp->cl_hostname);
2534	status = nfs4_handle_reclaim_lease_error(clp, status);
2535	goto out;
2536	}
2537	nfs41_finish_session_reset(clp);
2538	dprintk("%s: session reset was successful for server %s!\n",
2539	__func__, clp->cl_hostname);
2540	out:
2541	put_cred(cred);
2542	return status;
2543	}
2544
2545	static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2546	{
2547	const struct cred *cred;
2548	int ret;
2549
2550	if (!nfs4_has_session(clp))
2551	return 0;
2552	ret = nfs4_begin_drain_session(clp);
2553	if (ret != 0)
2554	return ret;
2555	cred = nfs4_get_clid_cred(clp);
2556	ret = nfs4_proc_bind_conn_to_session(clp, cred);
2557	put_cred(cred);
2558	clear_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
2559	switch (ret) {
2560	case 0:
2561	dprintk("%s: bind_conn_to_session was successful for server %s!\n",
2562	__func__, clp->cl_hostname);
2563	break;
2564	case -NFS4ERR_DELAY:
2565	ssleep(seconds: 1);
2566	set_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
2567	break;
2568	default:
2569	return nfs4_recovery_handle_error(clp, error: ret);
2570	}
2571	return 0;
2572	}
2573
2574	static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
2575	{
2576	int iomode = 0;
2577
2578	if (test_and_clear_bit(nr: NFS4CLNT_RECALL_ANY_LAYOUT_READ, addr: &clp->cl_state))
2579	iomode += IOMODE_READ;
2580	if (test_and_clear_bit(nr: NFS4CLNT_RECALL_ANY_LAYOUT_RW, addr: &clp->cl_state))
2581	iomode += IOMODE_RW;
2582	/* Note: IOMODE_READ + IOMODE_RW == IOMODE_ANY */
2583	if (iomode) {
2584	pnfs_layout_return_unused_byclid(clp, iomode);
2585	set_bit(nr: NFS4CLNT_RUN_MANAGER, addr: &clp->cl_state);
2586	}
2587	}
2588	#else /* CONFIG_NFS_V4_1 */
2589	static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
2590
2591	static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2592	{
2593	return 0;
2594	}
2595
2596	static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
2597	{
2598	}
2599	#endif /* CONFIG_NFS_V4_1 */
2600
2601	static void nfs4_state_manager(struct nfs_client *clp)
2602	{
2603	unsigned int memflags;
2604	int status = 0;
2605	const char *section = "", *section_sep = "";
2606
2607	/*
2608	* State recovery can deadlock if the direct reclaim code tries
2609	* start NFS writeback. So ensure memory allocations are all
2610	* GFP_NOFS.
2611	*/
2612	memflags = memalloc_nofs_save();
2613
2614	/* Ensure exclusive access to NFSv4 state */
2615	do {
2616	trace_nfs4_state_mgr(clp);
2617	clear_bit(nr: NFS4CLNT_RUN_MANAGER, addr: &clp->cl_state);
2618	if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2619	section = "purge state";
2620	status = nfs4_purge_lease(clp);
2621	if (status < 0)
2622	goto out_error;
2623	continue;
2624	}
2625
2626	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
2627	section = "lease expired";
2628	/* We're going to have to re-establish a clientid */
2629	status = nfs4_reclaim_lease(clp);
2630	if (status < 0)
2631	goto out_error;
2632	continue;
2633	}
2634
2635	/* Initialize or reset the session */
2636	if (test_and_clear_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state)) {
2637	section = "reset session";
2638	status = nfs4_reset_session(clp);
2639	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
2640	continue;
2641	if (status < 0)
2642	goto out_error;
2643	}
2644
2645	/* Send BIND_CONN_TO_SESSION */
2646	if (test_and_clear_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION,
2647	addr: &clp->cl_state)) {
2648	section = "bind conn to session";
2649	status = nfs4_bind_conn_to_session(clp);
2650	if (status < 0)
2651	goto out_error;
2652	continue;
2653	}
2654
2655	if (test_and_clear_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state)) {
2656	section = "check lease";
2657	status = nfs4_check_lease(clp);
2658	if (status < 0)
2659	goto out_error;
2660	continue;
2661	}
2662
2663	if (test_and_clear_bit(nr: NFS4CLNT_MOVED, addr: &clp->cl_state)) {
2664	section = "migration";
2665	status = nfs4_handle_migration(clp);
2666	if (status < 0)
2667	goto out_error;
2668	}
2669
2670	if (test_and_clear_bit(nr: NFS4CLNT_LEASE_MOVED, addr: &clp->cl_state)) {
2671	section = "lease moved";
2672	status = nfs4_handle_lease_moved(clp);
2673	if (status < 0)
2674	goto out_error;
2675	}
2676
2677	/* First recover reboot state... */
2678	if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
2679	section = "reclaim reboot";
2680	status = nfs4_do_reclaim(clp,
2681	ops: clp->cl_mvops->reboot_recovery_ops);
2682	if (status == 0)
2683	status = pnfs_layout_handle_reboot(clp);
2684	if (status == -EAGAIN)
2685	continue;
2686	if (status < 0)
2687	goto out_error;
2688	nfs4_state_end_reclaim_reboot(clp);
2689	continue;
2690	}
2691
2692	/* Detect expired delegations... */
2693	if (test_and_clear_bit(nr: NFS4CLNT_DELEGATION_EXPIRED, addr: &clp->cl_state)) {
2694	section = "detect expired delegations";
2695	status = nfs4_begin_drain_session(clp);
2696	if (status < 0)
2697	goto out_error;
2698	nfs_reap_expired_delegations(clp);
2699	continue;
2700	}
2701
2702	/* Now recover expired state... */
2703	if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
2704	section = "reclaim nograce";
2705	status = nfs4_do_reclaim(clp,
2706	ops: clp->cl_mvops->nograce_recovery_ops);
2707	if (status == -EAGAIN)
2708	continue;
2709	if (status < 0)
2710	goto out_error;
2711	clear_bit(nr: NFS4CLNT_RECLAIM_NOGRACE, addr: &clp->cl_state);
2712	}
2713
2714	memalloc_nofs_restore(flags: memflags);
2715	nfs4_end_drain_session(clp);
2716	nfs4_clear_state_manager_bit(clp);
2717
2718	if (test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&
2719	!test_and_set_bit(nr: NFS4CLNT_MANAGER_RUNNING,
2720	addr: &clp->cl_state)) {
2721	memflags = memalloc_nofs_save();
2722	continue;
2723	}
2724
2725	if (!test_and_set_bit(nr: NFS4CLNT_RECALL_RUNNING, addr: &clp->cl_state)) {
2726	if (test_and_clear_bit(nr: NFS4CLNT_DELEGRETURN, addr: &clp->cl_state)) {
2727	nfs_client_return_marked_delegations(clp);
2728	set_bit(nr: NFS4CLNT_RUN_MANAGER, addr: &clp->cl_state);
2729	}
2730	nfs4_layoutreturn_any_run(clp);
2731	clear_bit(nr: NFS4CLNT_RECALL_RUNNING, addr: &clp->cl_state);
2732	}
2733
2734	return;
2735
2736	} while (refcount_read(r: &clp->cl_count) > 1 && !signalled());
2737	goto out_drain;
2738
2739	out_error:
2740	if (strlen(section))
2741	section_sep = ": ";
2742	trace_nfs4_state_mgr_failed(clp, section, status);
2743	pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
2744	" with error %d\n", section_sep, section,
2745	clp->cl_hostname, -status);
2746	switch (status) {
2747	case -ENETDOWN:
2748	case -ENETUNREACH:
2749	nfs_mark_client_ready(clp, state: -EIO);
2750	break;
2751	case -EINVAL:
2752	nfs_mark_client_ready(clp, state: status);
2753	break;
2754	default:
2755	ssleep(seconds: 1);
2756	break;
2757	}
2758	out_drain:
2759	memalloc_nofs_restore(flags: memflags);
2760	nfs4_end_drain_session(clp);
2761	nfs4_clear_state_manager_bit(clp);
2762	}
2763
2764	static int nfs4_run_state_manager(void *ptr)
2765	{
2766	struct nfs_client *clp = ptr;
2767	struct rpc_clnt *cl = clp->cl_rpcclient;
2768
2769	while (cl != cl->cl_parent)
2770	cl = cl->cl_parent;
2771
2772	allow_signal(SIGKILL);
2773	again:
2774	nfs4_state_manager(clp);
2775
2776	if (test_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state) &&
2777	!test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state)) {
2778	wait_var_event_interruptible(&clp->cl_state,
2779	test_bit(NFS4CLNT_RUN_MANAGER,
2780	&clp->cl_state));
2781	if (!atomic_read(v: &cl->cl_swapper))
2782	clear_bit(nr: NFS4CLNT_MANAGER_AVAILABLE, addr: &clp->cl_state);
2783	if (refcount_read(r: &clp->cl_count) > 1 && !signalled() &&
2784	!test_and_set_bit(nr: NFS4CLNT_MANAGER_RUNNING, addr: &clp->cl_state))
2785	goto again;
2786	/* Either no longer a swapper, or were signalled */
2787	clear_bit(nr: NFS4CLNT_MANAGER_AVAILABLE, addr: &clp->cl_state);
2788	}
2789
2790	if (refcount_read(r: &clp->cl_count) > 1 && !signalled() &&
2791	test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&
2792	!test_and_set_bit(nr: NFS4CLNT_MANAGER_RUNNING, addr: &clp->cl_state))
2793	goto again;
2794
2795	nfs_put_client(clp);
2796	module_put_and_kthread_exit(0);
2797	return 0;
2798	}
2799