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(&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(size: sizeof(*sp), flags: gfp_flags);
502	if (!sp)
503	return NULL;
504	sp->so_seqid.owner_id = ida_alloc(ida: &server->openowner_id, gfp: gfp_flags);
505	if (sp->so_seqid.owner_id < 0) {
506	kfree(objp: sp);
507	return NULL;
508	}
509	sp->so_server = server;
510	sp->so_cred = get_cred(cred);
511	spin_lock_init(&sp->so_lock);
512	INIT_LIST_HEAD(list: &sp->so_states);
513	nfs4_init_seqid_counter(sc: &sp->so_seqid);
514	atomic_set(v: &sp->so_count, i: 1);
515	INIT_LIST_HEAD(list: &sp->so_lru);
516	seqcount_spinlock_init(&sp->so_reclaim_seqcount, &sp->so_lock);
517	mutex_init(&sp->so_delegreturn_mutex);
518	return sp;
519	}
520
521	static void
522	nfs4_reset_state_owner(struct nfs4_state_owner *sp)
523	{
524	/* This state_owner is no longer usable, but must
525	* remain in place so that state recovery can find it
526	* and the opens associated with it.
527	* It may also be used for new 'open' request to
528	* return a delegation to the server.
529	* So update the 'create_time' so that it looks like
530	* a new state_owner. This will cause the server to
531	* request an OPEN_CONFIRM to start a new sequence.
532	*/
533	sp->so_seqid.create_time = ktime_get();
534	}
535
536	static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
537	{
538	nfs4_destroy_seqid_counter(sc: &sp->so_seqid);
539	put_cred(cred: sp->so_cred);
540	ida_free(&sp->so_server->openowner_id, id: sp->so_seqid.owner_id);
541	kfree(objp: sp);
542	}
543
544	static void nfs4_gc_state_owners(struct nfs_server *server)
545	{
546	struct nfs_client *clp = server->nfs_client;
547	struct nfs4_state_owner *sp, *tmp;
548	unsigned long time_min, time_max;
549	LIST_HEAD(doomed);
550
551	spin_lock(lock: &clp->cl_lock);
552	time_max = jiffies;
553	time_min = (long)time_max - (long)clp->cl_lease_time;
554	list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
555	/* NB: LRU is sorted so that oldest is at the head */
556	if (time_in_range(sp->so_expires, time_min, time_max))
557	break;
558	list_move(list: &sp->so_lru, head: &doomed);
559	nfs4_remove_state_owner_locked(sp);
560	}
561	spin_unlock(lock: &clp->cl_lock);
562
563	list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
564	list_del(entry: &sp->so_lru);
565	nfs4_free_state_owner(sp);
566	}
567	}
568
569	/**
570	* nfs4_get_state_owner - Look up a state owner given a credential
571	* @server: nfs_server to search
572	* @cred: RPC credential to match
573	* @gfp_flags: allocation mode
574	*
575	* Returns a pointer to an instantiated nfs4_state_owner struct, or NULL.
576	*/
577	struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,
578	const struct cred *cred,
579	gfp_t gfp_flags)
580	{
581	struct nfs_client *clp = server->nfs_client;
582	struct nfs4_state_owner *sp, *new;
583
584	spin_lock(lock: &clp->cl_lock);
585	sp = nfs4_find_state_owner_locked(server, cred);
586	spin_unlock(lock: &clp->cl_lock);
587	if (sp != NULL)
588	goto out;
589	new = nfs4_alloc_state_owner(server, cred, gfp_flags);
590	if (new == NULL)
591	goto out;
592	spin_lock(lock: &clp->cl_lock);
593	sp = nfs4_insert_state_owner_locked(new);
594	spin_unlock(lock: &clp->cl_lock);
595	if (sp != new)
596	nfs4_free_state_owner(sp: new);
597	out:
598	nfs4_gc_state_owners(server);
599	return sp;
600	}
601
602	/**
603	* nfs4_put_state_owner - Release a nfs4_state_owner
604	* @sp: state owner data to release
605	*
606	* Note that we keep released state owners on an LRU
607	* list.
608	* This caches valid state owners so that they can be
609	* reused, to avoid the OPEN_CONFIRM on minor version 0.
610	* It also pins the uniquifier of dropped state owners for
611	* a while, to ensure that those state owner names are
612	* never reused.
613	*/
614	void nfs4_put_state_owner(struct nfs4_state_owner *sp)
615	{
616	struct nfs_server *server = sp->so_server;
617	struct nfs_client *clp = server->nfs_client;
618
619	if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
620	return;
621
622	sp->so_expires = jiffies;
623	list_add_tail(new: &sp->so_lru, head: &server->state_owners_lru);
624	spin_unlock(lock: &clp->cl_lock);
625	}
626
627	/**
628	* nfs4_purge_state_owners - Release all cached state owners
629	* @server: nfs_server with cached state owners to release
630	* @head: resulting list of state owners
631	*
632	* Called at umount time. Remaining state owners will be on
633	* the LRU with ref count of zero.
634	* Note that the state owners are not freed, but are added
635	* to the list @head, which can later be used as an argument
636	* to nfs4_free_state_owners.
637	*/
638	void nfs4_purge_state_owners(struct nfs_server *server, struct list_head *head)
639	{
640	struct nfs_client *clp = server->nfs_client;
641	struct nfs4_state_owner *sp, *tmp;
642
643	spin_lock(lock: &clp->cl_lock);
644	list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
645	list_move(list: &sp->so_lru, head);
646	nfs4_remove_state_owner_locked(sp);
647	}
648	spin_unlock(lock: &clp->cl_lock);
649	}
650
651	/**
652	* nfs4_free_state_owners - Release all cached state owners
653	* @head: resulting list of state owners
654	*
655	* Frees a list of state owners that was generated by
656	* nfs4_purge_state_owners
657	*/
658	void nfs4_free_state_owners(struct list_head *head)
659	{
660	struct nfs4_state_owner *sp, *tmp;
661
662	list_for_each_entry_safe(sp, tmp, head, so_lru) {
663	list_del(entry: &sp->so_lru);
664	nfs4_free_state_owner(sp);
665	}
666	}
667
668	static struct nfs4_state *
669	nfs4_alloc_open_state(void)
670	{
671	struct nfs4_state *state;
672
673	state = kzalloc(size: sizeof(*state), GFP_KERNEL_ACCOUNT);
674	if (!state)
675	return NULL;
676	refcount_set(r: &state->count, n: 1);
677	INIT_LIST_HEAD(list: &state->lock_states);
678	spin_lock_init(&state->state_lock);
679	seqlock_init(&state->seqlock);
680	init_waitqueue_head(&state->waitq);
681	return state;
682	}
683
684	void
685	nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
686	{
687	if (state->state == fmode)
688	return;
689	/* NB! List reordering - see the reclaim code for why. */
690	if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
691	if (fmode & FMODE_WRITE)
692	list_move(list: &state->open_states, head: &state->owner->so_states);
693	else
694	list_move_tail(list: &state->open_states, head: &state->owner->so_states);
695	}
696	state->state = fmode;
697	}
698
699	static struct nfs4_state *
700	__nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
701	{
702	struct nfs_inode *nfsi = NFS_I(inode);
703	struct nfs4_state *state;
704
705	list_for_each_entry_rcu(state, &nfsi->open_states, inode_states) {
706	if (state->owner != owner)
707	continue;
708	if (!nfs4_valid_open_stateid(state))
709	continue;
710	if (refcount_inc_not_zero(r: &state->count))
711	return state;
712	}
713	return NULL;
714	}
715
716	static void
717	nfs4_free_open_state(struct nfs4_state *state)
718	{
719	kfree_rcu(state, rcu_head);
720	}
721
722	struct nfs4_state *
723	nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner)
724	{
725	struct nfs4_state *state, *new;
726	struct nfs_inode *nfsi = NFS_I(inode);
727
728	rcu_read_lock();
729	state = __nfs4_find_state_byowner(inode, owner);
730	rcu_read_unlock();
731	if (state)
732	goto out;
733	new = nfs4_alloc_open_state();
734	spin_lock(lock: &owner->so_lock);
735	spin_lock(lock: &inode->i_lock);
736	state = __nfs4_find_state_byowner(inode, owner);
737	if (state == NULL && new != NULL) {
738	state = new;
739	state->owner = owner;
740	atomic_inc(v: &owner->so_count);
741	ihold(inode);
742	state->inode = inode;
743	list_add_rcu(new: &state->inode_states, head: &nfsi->open_states);
744	spin_unlock(lock: &inode->i_lock);
745	/* Note: The reclaim code dictates that we add stateless
746	* and read-only stateids to the end of the list */
747	list_add_tail(new: &state->open_states, head: &owner->so_states);
748	spin_unlock(lock: &owner->so_lock);
749	} else {
750	spin_unlock(lock: &inode->i_lock);
751	spin_unlock(lock: &owner->so_lock);
752	if (new)
753	nfs4_free_open_state(state: new);
754	}
755	out:
756	return state;
757	}
758
759	void nfs4_put_open_state(struct nfs4_state *state)
760	{
761	struct inode *inode = state->inode;
762	struct nfs4_state_owner *owner = state->owner;
763
764	if (!refcount_dec_and_lock(r: &state->count, lock: &owner->so_lock))
765	return;
766	spin_lock(lock: &inode->i_lock);
767	list_del_rcu(entry: &state->inode_states);
768	list_del(entry: &state->open_states);
769	spin_unlock(lock: &inode->i_lock);
770	spin_unlock(lock: &owner->so_lock);
771	nfs4_inode_return_delegation_on_close(inode);
772	iput(inode);
773	nfs4_free_open_state(state);
774	nfs4_put_state_owner(sp: owner);
775	}
776
777	/*
778	* Close the current file.
779	*/
780	static void __nfs4_close(struct nfs4_state *state,
781	fmode_t fmode, gfp_t gfp_mask, int wait)
782	{
783	struct nfs4_state_owner *owner = state->owner;
784	int call_close = 0;
785	fmode_t newstate;
786
787	atomic_inc(v: &owner->so_count);
788	/* Protect against nfs4_find_state() */
789	spin_lock(lock: &owner->so_lock);
790	switch (fmode & (FMODE_READ | FMODE_WRITE)) {
791	case FMODE_READ:
792	state->n_rdonly--;
793	break;
794	case FMODE_WRITE:
795	state->n_wronly--;
796	break;
797	case FMODE_READ|FMODE_WRITE:
798	state->n_rdwr--;
799	}
800	newstate = FMODE_READ|FMODE_WRITE;
801	if (state->n_rdwr == 0) {
802	if (state->n_rdonly == 0) {
803	newstate &= ~FMODE_READ;
804	call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
805	call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
806	}
807	if (state->n_wronly == 0) {
808	newstate &= ~FMODE_WRITE;
809	call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
810	call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
811	}
812	if (newstate == 0)
813	clear_bit(nr: NFS_DELEGATED_STATE, addr: &state->flags);
814	}
815	nfs4_state_set_mode_locked(state, fmode: newstate);
816	spin_unlock(lock: &owner->so_lock);
817
818	if (!call_close) {
819	nfs4_put_open_state(state);
820	nfs4_put_state_owner(sp: owner);
821	} else
822	nfs4_do_close(state, gfp_mask, wait);
823	}
824
825	void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
826	{
827	__nfs4_close(state, fmode, GFP_KERNEL, wait: 0);
828	}
829
830	void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
831	{
832	__nfs4_close(state, fmode, GFP_KERNEL, wait: 1);
833	}
834
835	/*
836	* Search the state->lock_states for an existing lock_owner
837	* that is compatible with either of the given owners.
838	* If the second is non-zero, then the first refers to a Posix-lock
839	* owner (current->files) and the second refers to a flock/OFD
840	* owner (struct file*). In that case, prefer a match for the first
841	* owner.
842	* If both sorts of locks are held on the one file we cannot know
843	* which stateid was intended to be used, so a "correct" choice cannot
844	* be made. Failing that, a "consistent" choice is preferable. The
845	* consistent choice we make is to prefer the first owner, that of a
846	* Posix lock.
847	*/
848	static struct nfs4_lock_state *
849	__nfs4_find_lock_state(struct nfs4_state *state,
850	fl_owner_t fl_owner, fl_owner_t fl_owner2)
851	{
852	struct nfs4_lock_state *pos, *ret = NULL;
853	list_for_each_entry(pos, &state->lock_states, ls_locks) {
854	if (pos->ls_owner == fl_owner) {
855	ret = pos;
856	break;
857	}
858	if (pos->ls_owner == fl_owner2)
859	ret = pos;
860	}
861	if (ret)
862	refcount_inc(r: &ret->ls_count);
863	return ret;
864	}
865
866	/*
867	* Return a compatible lock_state. If no initialized lock_state structure
868	* exists, return an uninitialized one.
869	*
870	*/
871	static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
872	{
873	struct nfs4_lock_state *lsp;
874	struct nfs_server *server = state->owner->so_server;
875
876	lsp = kzalloc(size: sizeof(*lsp), GFP_KERNEL_ACCOUNT);
877	if (lsp == NULL)
878	return NULL;
879	nfs4_init_seqid_counter(sc: &lsp->ls_seqid);
880	refcount_set(r: &lsp->ls_count, n: 1);
881	lsp->ls_state = state;
882	lsp->ls_owner = fl_owner;
883	lsp->ls_seqid.owner_id = ida_alloc(ida: &server->lockowner_id, GFP_KERNEL_ACCOUNT);
884	if (lsp->ls_seqid.owner_id < 0)
885	goto out_free;
886	INIT_LIST_HEAD(list: &lsp->ls_locks);
887	return lsp;
888	out_free:
889	kfree(objp: lsp);
890	return NULL;
891	}
892
893	void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
894	{
895	ida_free(&server->lockowner_id, id: lsp->ls_seqid.owner_id);
896	nfs4_destroy_seqid_counter(sc: &lsp->ls_seqid);
897	kfree(objp: lsp);
898	}
899
900	/*
901	* Return a compatible lock_state. If no initialized lock_state structure
902	* exists, return an uninitialized one.
903	*
904	*/
905	static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner)
906	{
907	struct nfs4_lock_state *lsp, *new = NULL;
908
909	for(;;) {
910	spin_lock(lock: &state->state_lock);
911	lsp = __nfs4_find_lock_state(state, fl_owner: owner, NULL);
912	if (lsp != NULL)
913	break;
914	if (new != NULL) {
915	list_add(new: &new->ls_locks, head: &state->lock_states);
916	set_bit(nr: LK_STATE_IN_USE, addr: &state->flags);
917	lsp = new;
918	new = NULL;
919	break;
920	}
921	spin_unlock(lock: &state->state_lock);
922	new = nfs4_alloc_lock_state(state, fl_owner: owner);
923	if (new == NULL)
924	return NULL;
925	}
926	spin_unlock(lock: &state->state_lock);
927	if (new != NULL)
928	nfs4_free_lock_state(server: state->owner->so_server, lsp: new);
929	return lsp;
930	}
931
932	/*
933	* Release reference to lock_state, and free it if we see that
934	* it is no longer in use
935	*/
936	void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
937	{
938	struct nfs_server *server;
939	struct nfs4_state *state;
940
941	if (lsp == NULL)
942	return;
943	state = lsp->ls_state;
944	if (!refcount_dec_and_lock(r: &lsp->ls_count, lock: &state->state_lock))
945	return;
946	list_del(entry: &lsp->ls_locks);
947	if (list_empty(head: &state->lock_states))
948	clear_bit(nr: LK_STATE_IN_USE, addr: &state->flags);
949	spin_unlock(lock: &state->state_lock);
950	server = state->owner->so_server;
951	if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
952	struct nfs_client *clp = server->nfs_client;
953
954	clp->cl_mvops->free_lock_state(server, lsp);
955	} else
956	nfs4_free_lock_state(server, lsp);
957	}
958
959	static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
960	{
961	struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
962
963	dst->fl_u.nfs4_fl.owner = lsp;
964	refcount_inc(r: &lsp->ls_count);
965	}
966
967	static void nfs4_fl_release_lock(struct file_lock *fl)
968	{
969	nfs4_put_lock_state(lsp: fl->fl_u.nfs4_fl.owner);
970	}
971
972	static const struct file_lock_operations nfs4_fl_lock_ops = {
973	.fl_copy_lock = nfs4_fl_copy_lock,
974	.fl_release_private = nfs4_fl_release_lock,
975	};
976
977	int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
978	{
979	struct nfs4_lock_state *lsp;
980
981	if (fl->fl_ops != NULL)
982	return 0;
983	lsp = nfs4_get_lock_state(state, owner: fl->fl_owner);
984	if (lsp == NULL)
985	return -ENOMEM;
986	fl->fl_u.nfs4_fl.owner = lsp;
987	fl->fl_ops = &nfs4_fl_lock_ops;
988	return 0;
989	}
990
991	static int nfs4_copy_lock_stateid(nfs4_stateid *dst,
992	struct nfs4_state *state,
993	const struct nfs_lock_context *l_ctx)
994	{
995	struct nfs4_lock_state *lsp;
996	fl_owner_t fl_owner, fl_flock_owner;
997	int ret = -ENOENT;
998
999	if (l_ctx == NULL)
1000	goto out;
1001
1002	if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
1003	goto out;
1004
1005	fl_owner = l_ctx->lockowner;
1006	fl_flock_owner = l_ctx->open_context->flock_owner;
1007
1008	spin_lock(lock: &state->state_lock);
1009	lsp = __nfs4_find_lock_state(state, fl_owner, fl_owner2: fl_flock_owner);
1010	if (lsp && test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
1011	ret = -EIO;
1012	else if (lsp != NULL && test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) {
1013	nfs4_stateid_copy(dst, src: &lsp->ls_stateid);
1014	ret = 0;
1015	}
1016	spin_unlock(lock: &state->state_lock);
1017	nfs4_put_lock_state(lsp);
1018	out:
1019	return ret;
1020	}
1021
1022	bool nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
1023	{
1024	bool ret;
1025	const nfs4_stateid *src;
1026	int seq;
1027
1028	do {
1029	ret = false;
1030	src = &zero_stateid;
1031	seq = read_seqbegin(sl: &state->seqlock);
1032	if (test_bit(NFS_OPEN_STATE, &state->flags)) {
1033	src = &state->open_stateid;
1034	ret = true;
1035	}
1036	nfs4_stateid_copy(dst, src);
1037	} while (read_seqretry(sl: &state->seqlock, start: seq));
1038	return ret;
1039	}
1040
1041	/*
1042	* Byte-range lock aware utility to initialize the stateid of read/write
1043	* requests.
1044	*/
1045	int nfs4_select_rw_stateid(struct nfs4_state *state,
1046	fmode_t fmode, const struct nfs_lock_context *l_ctx,
1047	nfs4_stateid *dst, const struct cred **cred)
1048	{
1049	int ret;
1050
1051	if (!nfs4_valid_open_stateid(state))
1052	return -EIO;
1053	if (cred != NULL)
1054	*cred = NULL;
1055	ret = nfs4_copy_lock_stateid(dst, state, l_ctx);
1056	if (ret == -EIO)
1057	/* A lost lock - don't even consider delegations */
1058	goto out;
1059	/* returns true if delegation stateid found and copied */
1060	if (nfs4_copy_delegation_stateid(inode: state->inode, flags: fmode, dst, cred)) {
1061	ret = 0;
1062	goto out;
1063	}
1064	if (ret != -ENOENT)
1065	/* nfs4_copy_delegation_stateid() didn't over-write
1066	* dst, so it still has the lock stateid which we now
1067	* choose to use.
1068	*/
1069	goto out;
1070	ret = nfs4_copy_open_stateid(dst, state) ? 0 : -EAGAIN;
1071	out:
1072	if (nfs_server_capable(inode: state->inode, NFS_CAP_STATEID_NFSV41))
1073	dst->seqid = 0;
1074	return ret;
1075	}
1076
1077	struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
1078	{
1079	struct nfs_seqid *new;
1080
1081	new = kmalloc(size: sizeof(*new), flags: gfp_mask);
1082	if (new == NULL)
1083	return ERR_PTR(error: -ENOMEM);
1084	new->sequence = counter;
1085	INIT_LIST_HEAD(list: &new->list);
1086	new->task = NULL;
1087	return new;
1088	}
1089
1090	void nfs_release_seqid(struct nfs_seqid *seqid)
1091	{
1092	struct nfs_seqid_counter *sequence;
1093
1094	if (seqid == NULL || list_empty(head: &seqid->list))
1095	return;
1096	sequence = seqid->sequence;
1097	spin_lock(lock: &sequence->lock);
1098	list_del_init(entry: &seqid->list);
1099	if (!list_empty(head: &sequence->list)) {
1100	struct nfs_seqid *next;
1101
1102	next = list_first_entry(&sequence->list,
1103	struct nfs_seqid, list);
1104	rpc_wake_up_queued_task(&sequence->wait, next->task);
1105	}
1106	spin_unlock(lock: &sequence->lock);
1107	}
1108
1109	void nfs_free_seqid(struct nfs_seqid *seqid)
1110	{
1111	nfs_release_seqid(seqid);
1112	kfree(objp: seqid);
1113	}
1114
1115	/*
1116	* Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
1117	* failed with a seqid incrementing error -
1118	* see comments nfs4.h:seqid_mutating_error()
1119	*/
1120	static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
1121	{
1122	switch (status) {
1123	case 0:
1124	break;
1125	case -NFS4ERR_BAD_SEQID:
1126	if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
1127	return;
1128	pr_warn_ratelimited("NFS: v4 server returned a bad"
1129	" sequence-id error on an"
1130	" unconfirmed sequence %p!\n",
1131	seqid->sequence);
1132	return;
1133	case -NFS4ERR_STALE_CLIENTID:
1134	case -NFS4ERR_STALE_STATEID:
1135	case -NFS4ERR_BAD_STATEID:
1136	case -NFS4ERR_BADXDR:
1137	case -NFS4ERR_RESOURCE:
1138	case -NFS4ERR_NOFILEHANDLE:
1139	case -NFS4ERR_MOVED:
1140	/* Non-seqid mutating errors */
1141	return;
1142	}
1143	/*
1144	* Note: no locking needed as we are guaranteed to be first
1145	* on the sequence list
1146	*/
1147	seqid->sequence->counter++;
1148	}
1149
1150	void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
1151	{
1152	struct nfs4_state_owner *sp;
1153
1154	if (seqid == NULL)
1155	return;
1156
1157	sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid);
1158	if (status == -NFS4ERR_BAD_SEQID)
1159	nfs4_reset_state_owner(sp);
1160	if (!nfs4_has_session(clp: sp->so_server->nfs_client))
1161	nfs_increment_seqid(status, seqid);
1162	}
1163
1164	/*
1165	* Increment the seqid if the LOCK/LOCKU succeeded, or
1166	* failed with a seqid incrementing error -
1167	* see comments nfs4.h:seqid_mutating_error()
1168	*/
1169	void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
1170	{
1171	if (seqid != NULL)
1172	nfs_increment_seqid(status, seqid);
1173	}
1174
1175	int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
1176	{
1177	struct nfs_seqid_counter *sequence;
1178	int status = 0;
1179
1180	if (seqid == NULL)
1181	goto out;
1182	sequence = seqid->sequence;
1183	spin_lock(lock: &sequence->lock);
1184	seqid->task = task;
1185	if (list_empty(head: &seqid->list))
1186	list_add_tail(new: &seqid->list, head: &sequence->list);
1187	if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid)
1188	goto unlock;
1189	rpc_sleep_on(&sequence->wait, task, NULL);
1190	status = -EAGAIN;
1191	unlock:
1192	spin_unlock(lock: &sequence->lock);
1193	out:
1194	return status;
1195	}
1196
1197	static int nfs4_run_state_manager(void *);
1198
1199	static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
1200	{
1201	clear_and_wake_up_bit(bit: NFS4CLNT_MANAGER_RUNNING, word: &clp->cl_state);
1202	rpc_wake_up(&clp->cl_rpcwaitq);
1203	}
1204
1205	/*
1206	* Schedule the nfs_client asynchronous state management routine
1207	*/
1208	void nfs4_schedule_state_manager(struct nfs_client *clp)
1209	{
1210	struct task_struct *task;
1211	char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
1212	struct rpc_clnt *clnt = clp->cl_rpcclient;
1213	bool swapon = false;
1214
1215	if (clnt->cl_shutdown)
1216	return;
1217
1218	set_bit(nr: NFS4CLNT_RUN_MANAGER, addr: &clp->cl_state);
1219
1220	if (atomic_read(v: &clnt->cl_swapper)) {
1221	swapon = !test_and_set_bit(nr: NFS4CLNT_MANAGER_AVAILABLE,
1222	addr: &clp->cl_state);
1223	if (!swapon) {
1224	wake_up_var(var: &clp->cl_state);
1225	return;
1226	}
1227	}
1228
1229	if (test_and_set_bit(nr: NFS4CLNT_MANAGER_RUNNING, addr: &clp->cl_state) != 0)
1230	return;
1231
1232	__module_get(THIS_MODULE);
1233	refcount_inc(r: &clp->cl_count);
1234
1235	/* The rcu_read_lock() is not strictly necessary, as the state
1236	* manager is the only thread that ever changes the rpc_xprt
1237	* after it's initialized. At this point, we're single threaded. */
1238	rcu_read_lock();
1239	snprintf(buf, size: sizeof(buf), fmt: "%s-manager",
1240	rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
1241	rcu_read_unlock();
1242	task = kthread_run(nfs4_run_state_manager, clp, "%s", buf);
1243	if (IS_ERR(ptr: task)) {
1244	printk(KERN_ERR "%s: kthread_run: %ld\n",
1245	__func__, PTR_ERR(task));
1246	if (!nfs_client_init_is_complete(clp))
1247	nfs_mark_client_ready(clp, state: PTR_ERR(ptr: task));
1248	if (swapon)
1249	clear_bit(nr: NFS4CLNT_MANAGER_AVAILABLE, addr: &clp->cl_state);
1250	nfs4_clear_state_manager_bit(clp);
1251	nfs_put_client(clp);
1252	module_put(THIS_MODULE);
1253	}
1254	}
1255
1256	/*
1257	* Schedule a lease recovery attempt
1258	*/
1259	void nfs4_schedule_lease_recovery(struct nfs_client *clp)
1260	{
1261	if (!clp)
1262	return;
1263	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1264	set_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state);
1265	dprintk("%s: scheduling lease recovery for server %s\n", __func__,
1266	clp->cl_hostname);
1267	nfs4_schedule_state_manager(clp);
1268	}
1269	EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
1270
1271	/**
1272	* nfs4_schedule_migration_recovery - trigger migration recovery
1273	*
1274	* @server: FSID that is migrating
1275	*
1276	* Returns zero if recovery has started, otherwise a negative NFS4ERR
1277	* value is returned.
1278	*/
1279	int nfs4_schedule_migration_recovery(const struct nfs_server *server)
1280	{
1281	struct nfs_client *clp = server->nfs_client;
1282
1283	if (server->fh_expire_type != NFS4_FH_PERSISTENT) {
1284	pr_err("NFS: volatile file handles not supported (server %s)\n",
1285	clp->cl_hostname);
1286	return -NFS4ERR_IO;
1287	}
1288
1289	if (test_bit(NFS_MIG_FAILED, &server->mig_status))
1290	return -NFS4ERR_IO;
1291
1292	dprintk("%s: scheduling migration recovery for (%llx:%llx) on %s\n",
1293	__func__,
1294	(unsigned long long)server->fsid.major,
1295	(unsigned long long)server->fsid.minor,
1296	clp->cl_hostname);
1297
1298	set_bit(NFS_MIG_IN_TRANSITION,
1299	addr: &((struct nfs_server *)server)->mig_status);
1300	set_bit(nr: NFS4CLNT_MOVED, addr: &clp->cl_state);
1301
1302	nfs4_schedule_state_manager(clp);
1303	return 0;
1304	}
1305	EXPORT_SYMBOL_GPL(nfs4_schedule_migration_recovery);
1306
1307	/**
1308	* nfs4_schedule_lease_moved_recovery - start lease-moved recovery
1309	*
1310	* @clp: server to check for moved leases
1311	*
1312	*/
1313	void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp)
1314	{
1315	dprintk("%s: scheduling lease-moved recovery for client ID %llx on %s\n",
1316	__func__, clp->cl_clientid, clp->cl_hostname);
1317
1318	set_bit(nr: NFS4CLNT_LEASE_MOVED, addr: &clp->cl_state);
1319	nfs4_schedule_state_manager(clp);
1320	}
1321	EXPORT_SYMBOL_GPL(nfs4_schedule_lease_moved_recovery);
1322
1323	int nfs4_wait_clnt_recover(struct nfs_client *clp)
1324	{
1325	int res;
1326
1327	might_sleep();
1328
1329	refcount_inc(r: &clp->cl_count);
1330	res = wait_on_bit_action(word: &clp->cl_state, bit: NFS4CLNT_MANAGER_RUNNING,
1331	action: nfs_wait_bit_killable,
1332	TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
1333	if (res)
1334	goto out;
1335	if (clp->cl_cons_state < 0)
1336	res = clp->cl_cons_state;
1337	out:
1338	nfs_put_client(clp);
1339	return res;
1340	}
1341
1342	int nfs4_client_recover_expired_lease(struct nfs_client *clp)
1343	{
1344	unsigned int loop;
1345	int ret;
1346
1347	for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
1348	ret = nfs4_wait_clnt_recover(clp);
1349	if (ret != 0)
1350	break;
1351	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&
1352	!test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state))
1353	break;
1354	nfs4_schedule_state_manager(clp);
1355	ret = -EIO;
1356	}
1357	return ret;
1358	}
1359
1360	/*
1361	* nfs40_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN
1362	* @clp: client to process
1363	*
1364	* Set the NFS4CLNT_LEASE_EXPIRED state in order to force a
1365	* resend of the SETCLIENTID and hence re-establish the
1366	* callback channel. Then return all existing delegations.
1367	*/
1368	static void nfs40_handle_cb_pathdown(struct nfs_client *clp)
1369	{
1370	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
1371	nfs_expire_all_delegations(clp);
1372	dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
1373	clp->cl_hostname);
1374	}
1375
1376	void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
1377	{
1378	nfs40_handle_cb_pathdown(clp);
1379	nfs4_schedule_state_manager(clp);
1380	}
1381
1382	static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1383	{
1384
1385	if (!nfs4_valid_open_stateid(state))
1386	return 0;
1387	set_bit(nr: NFS_STATE_RECLAIM_REBOOT, addr: &state->flags);
1388	/* Don't recover state that expired before the reboot */
1389	if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) {
1390	clear_bit(nr: NFS_STATE_RECLAIM_REBOOT, addr: &state->flags);
1391	return 0;
1392	}
1393	set_bit(nr: NFS_OWNER_RECLAIM_REBOOT, addr: &state->owner->so_flags);
1394	set_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state);
1395	return 1;
1396	}
1397
1398	int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1399	{
1400	if (!nfs4_valid_open_stateid(state))
1401	return 0;
1402	set_bit(nr: NFS_STATE_RECLAIM_NOGRACE, addr: &state->flags);
1403	clear_bit(nr: NFS_STATE_RECLAIM_REBOOT, addr: &state->flags);
1404	set_bit(nr: NFS_OWNER_RECLAIM_NOGRACE, addr: &state->owner->so_flags);
1405	set_bit(nr: NFS4CLNT_RECLAIM_NOGRACE, addr: &clp->cl_state);
1406	return 1;
1407	}
1408
1409	int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
1410	{
1411	struct nfs_client *clp = server->nfs_client;
1412
1413	if (!nfs4_state_mark_reclaim_nograce(clp, state))
1414	return -EBADF;
1415	nfs_inode_find_delegation_state_and_recover(inode: state->inode,
1416	stateid: &state->stateid);
1417	dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
1418	clp->cl_hostname);
1419	nfs4_schedule_state_manager(clp);
1420	return 0;
1421	}
1422	EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1423
1424	static struct nfs4_lock_state *
1425	nfs_state_find_lock_state_by_stateid(struct nfs4_state *state,
1426	const nfs4_stateid *stateid)
1427	{
1428	struct nfs4_lock_state *pos;
1429
1430	list_for_each_entry(pos, &state->lock_states, ls_locks) {
1431	if (!test_bit(NFS_LOCK_INITIALIZED, &pos->ls_flags))
1432	continue;
1433	if (nfs4_stateid_match_or_older(dst: &pos->ls_stateid, src: stateid))
1434	return pos;
1435	}
1436	return NULL;
1437	}
1438
1439	static bool nfs_state_lock_state_matches_stateid(struct nfs4_state *state,
1440	const nfs4_stateid *stateid)
1441	{
1442	bool found = false;
1443
1444	if (test_bit(LK_STATE_IN_USE, &state->flags)) {
1445	spin_lock(lock: &state->state_lock);
1446	if (nfs_state_find_lock_state_by_stateid(state, stateid))
1447	found = true;
1448	spin_unlock(lock: &state->state_lock);
1449	}
1450	return found;
1451	}
1452
1453	void nfs_inode_find_state_and_recover(struct inode *inode,
1454	const nfs4_stateid *stateid)
1455	{
1456	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1457	struct nfs_inode *nfsi = NFS_I(inode);
1458	struct nfs_open_context *ctx;
1459	struct nfs4_state *state;
1460	bool found = false;
1461
1462	rcu_read_lock();
1463	list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
1464	state = ctx->state;
1465	if (state == NULL)
1466	continue;
1467	if (nfs4_stateid_match_or_older(dst: &state->stateid, src: stateid) &&
1468	nfs4_state_mark_reclaim_nograce(clp, state)) {
1469	found = true;
1470	continue;
1471	}
1472	if (test_bit(NFS_OPEN_STATE, &state->flags) &&
1473	nfs4_stateid_match_or_older(dst: &state->open_stateid, src: stateid) &&
1474	nfs4_state_mark_reclaim_nograce(clp, state)) {
1475	found = true;
1476	continue;
1477	}
1478	if (nfs_state_lock_state_matches_stateid(state, stateid) &&
1479	nfs4_state_mark_reclaim_nograce(clp, state))
1480	found = true;
1481	}
1482	rcu_read_unlock();
1483
1484	nfs_inode_find_delegation_state_and_recover(inode, stateid);
1485	if (found)
1486	nfs4_schedule_state_manager(clp);
1487	}
1488
1489	static void nfs4_state_mark_open_context_bad(struct nfs4_state *state, int err)
1490	{
1491	struct inode *inode = state->inode;
1492	struct nfs_inode *nfsi = NFS_I(inode);
1493	struct nfs_open_context *ctx;
1494
1495	rcu_read_lock();
1496	list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
1497	if (ctx->state != state)
1498	continue;
1499	set_bit(NFS_CONTEXT_BAD, addr: &ctx->flags);
1500	pr_warn("NFSv4: state recovery failed for open file %pd2, "
1501	"error = %d\n", ctx->dentry, err);
1502	}
1503	rcu_read_unlock();
1504	}
1505
1506	static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
1507	{
1508	set_bit(nr: NFS_STATE_RECOVERY_FAILED, addr: &state->flags);
1509	nfs4_state_mark_open_context_bad(state, err: error);
1510	}
1511
1512
1513	static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
1514	{
1515	struct inode *inode = state->inode;
1516	struct nfs_inode *nfsi = NFS_I(inode);
1517	struct file_lock *fl;
1518	struct nfs4_lock_state *lsp;
1519	int status = 0;
1520	struct file_lock_context *flctx = locks_inode_context(inode);
1521	struct list_head *list;
1522
1523	if (flctx == NULL)
1524	return 0;
1525
1526	list = &flctx->flc_posix;
1527
1528	/* Guard against delegation returns and new lock/unlock calls */
1529	down_write(sem: &nfsi->rwsem);
1530	spin_lock(lock: &flctx->flc_lock);
1531	restart:
1532	list_for_each_entry(fl, list, fl_list) {
1533	if (nfs_file_open_context(filp: fl->fl_file)->state != state)
1534	continue;
1535	spin_unlock(lock: &flctx->flc_lock);
1536	status = ops->recover_lock(state, fl);
1537	switch (status) {
1538	case 0:
1539	break;
1540	case -ETIMEDOUT:
1541	case -ESTALE:
1542	case -NFS4ERR_ADMIN_REVOKED:
1543	case -NFS4ERR_STALE_STATEID:
1544	case -NFS4ERR_BAD_STATEID:
1545	case -NFS4ERR_EXPIRED:
1546	case -NFS4ERR_NO_GRACE:
1547	case -NFS4ERR_STALE_CLIENTID:
1548	case -NFS4ERR_BADSESSION:
1549	case -NFS4ERR_BADSLOT:
1550	case -NFS4ERR_BAD_HIGH_SLOT:
1551	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1552	goto out;
1553	default:
1554	pr_err("NFS: %s: unhandled error %d\n",
1555	__func__, status);
1556	fallthrough;
1557	case -ENOMEM:
1558	case -NFS4ERR_DENIED:
1559	case -NFS4ERR_RECLAIM_BAD:
1560	case -NFS4ERR_RECLAIM_CONFLICT:
1561	lsp = fl->fl_u.nfs4_fl.owner;
1562	if (lsp)
1563	set_bit(NFS_LOCK_LOST, addr: &lsp->ls_flags);
1564	status = 0;
1565	}
1566	spin_lock(lock: &flctx->flc_lock);
1567	}
1568	if (list == &flctx->flc_posix) {
1569	list = &flctx->flc_flock;
1570	goto restart;
1571	}
1572	spin_unlock(lock: &flctx->flc_lock);
1573	out:
1574	up_write(sem: &nfsi->rwsem);
1575	return status;
1576	}
1577
1578	#ifdef CONFIG_NFS_V4_2
1579	static void nfs42_complete_copies(struct nfs4_state_owner *sp, struct nfs4_state *state)
1580	{
1581	struct nfs4_copy_state *copy;
1582
1583	if (!test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
1584	!test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags))
1585	return;
1586
1587	spin_lock(lock: &sp->so_server->nfs_client->cl_lock);
1588	list_for_each_entry(copy, &sp->so_server->ss_copies, copies) {
1589	if ((test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
1590	!nfs4_stateid_match_other(dst: &state->stateid,
1591	src: &copy->parent_dst_state->stateid)))
1592	continue;
1593	copy->flags = 1;
1594	if (test_and_clear_bit(nr: NFS_CLNT_DST_SSC_COPY_STATE,
1595	addr: &state->flags)) {
1596	clear_bit(nr: NFS_CLNT_SRC_SSC_COPY_STATE, addr: &state->flags);
1597	complete(&copy->completion);
1598	}
1599	}
1600	list_for_each_entry(copy, &sp->so_server->ss_copies, src_copies) {
1601	if ((test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags) &&
1602	!nfs4_stateid_match_other(dst: &state->stateid,
1603	src: &copy->parent_src_state->stateid)))
1604	continue;
1605	copy->flags = 1;
1606	if (test_and_clear_bit(nr: NFS_CLNT_DST_SSC_COPY_STATE,
1607	addr: &state->flags))
1608	complete(&copy->completion);
1609	}
1610	spin_unlock(lock: &sp->so_server->nfs_client->cl_lock);
1611	}
1612	#else /* !CONFIG_NFS_V4_2 */
1613	static inline void nfs42_complete_copies(struct nfs4_state_owner *sp,
1614	struct nfs4_state *state)
1615	{
1616	}
1617	#endif /* CONFIG_NFS_V4_2 */
1618
1619	static int __nfs4_reclaim_open_state(struct nfs4_state_owner *sp, struct nfs4_state *state,
1620	const struct nfs4_state_recovery_ops *ops,
1621	int *lost_locks)
1622	{
1623	struct nfs4_lock_state *lock;
1624	int status;
1625
1626	status = ops->recover_open(sp, state);
1627	if (status < 0)
1628	return status;
1629
1630	status = nfs4_reclaim_locks(state, ops);
1631	if (status < 0)
1632	return status;
1633
1634	if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
1635	spin_lock(lock: &state->state_lock);
1636	list_for_each_entry(lock, &state->lock_states, ls_locks) {
1637	trace_nfs4_state_lock_reclaim(state, lock);
1638	if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags) &&
1639	!test_bit(NFS_LOCK_UNLOCKING, &lock->ls_flags))
1640	*lost_locks += 1;
1641	}
1642	spin_unlock(lock: &state->state_lock);
1643	}
1644
1645	nfs42_complete_copies(sp, state);
1646	clear_bit(nr: NFS_STATE_RECLAIM_NOGRACE, addr: &state->flags);
1647	return status;
1648	}
1649
1650	static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp,
1651	const struct nfs4_state_recovery_ops *ops,
1652	int *lost_locks)
1653	{
1654	struct nfs4_state *state;
1655	unsigned int loop = 0;
1656	int status = 0;
1657	#ifdef CONFIG_NFS_V4_2
1658	bool found_ssc_copy_state = false;
1659	#endif /* CONFIG_NFS_V4_2 */
1660
1661	/* Note: we rely on the sp->so_states list being ordered
1662	* so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
1663	* states first.
1664	* This is needed to ensure that the server won't give us any
1665	* read delegations that we have to return if, say, we are
1666	* recovering after a network partition or a reboot from a
1667	* server that doesn't support a grace period.
1668	*/
1669	spin_lock(lock: &sp->so_lock);
1670	raw_write_seqcount_begin(&sp->so_reclaim_seqcount);
1671	restart:
1672	list_for_each_entry(state, &sp->so_states, open_states) {
1673	if (!test_and_clear_bit(nr: ops->state_flag_bit, addr: &state->flags))
1674	continue;
1675	if (!nfs4_valid_open_stateid(state))
1676	continue;
1677	if (state->state == 0)
1678	continue;
1679	#ifdef CONFIG_NFS_V4_2
1680	if (test_bit(NFS_SRV_SSC_COPY_STATE, &state->flags)) {
1681	nfs4_state_mark_recovery_failed(state, error: -EIO);
1682	found_ssc_copy_state = true;
1683	continue;
1684	}
1685	#endif /* CONFIG_NFS_V4_2 */
1686	refcount_inc(r: &state->count);
1687	spin_unlock(lock: &sp->so_lock);
1688	status = __nfs4_reclaim_open_state(sp, state, ops, lost_locks);
1689
1690	switch (status) {
1691	default:
1692	if (status >= 0) {
1693	loop = 0;
1694	break;
1695	}
1696	printk(KERN_ERR "NFS: %s: unhandled error %d\n", __func__, status);
1697	fallthrough;
1698	case -ENOENT:
1699	case -ENOMEM:
1700	case -EACCES:
1701	case -EROFS:
1702	case -EIO:
1703	case -ESTALE:
1704	/* Open state on this file cannot be recovered */
1705	nfs4_state_mark_recovery_failed(state, error: status);
1706	break;
1707	case -EAGAIN:
1708	ssleep(seconds: 1);
1709	if (loop++ < 10) {
1710	set_bit(nr: ops->state_flag_bit, addr: &state->flags);
1711	break;
1712	}
1713	fallthrough;
1714	case -NFS4ERR_ADMIN_REVOKED:
1715	case -NFS4ERR_STALE_STATEID:
1716	case -NFS4ERR_OLD_STATEID:
1717	case -NFS4ERR_BAD_STATEID:
1718	case -NFS4ERR_RECLAIM_BAD:
1719	case -NFS4ERR_RECLAIM_CONFLICT:
1720	nfs4_state_mark_reclaim_nograce(clp: sp->so_server->nfs_client, state);
1721	break;
1722	case -NFS4ERR_EXPIRED:
1723	case -NFS4ERR_NO_GRACE:
1724	nfs4_state_mark_reclaim_nograce(clp: sp->so_server->nfs_client, state);
1725	fallthrough;
1726	case -NFS4ERR_STALE_CLIENTID:
1727	case -NFS4ERR_BADSESSION:
1728	case -NFS4ERR_BADSLOT:
1729	case -NFS4ERR_BAD_HIGH_SLOT:
1730	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1731	case -ETIMEDOUT:
1732	goto out_err;
1733	}
1734	nfs4_put_open_state(state);
1735	spin_lock(lock: &sp->so_lock);
1736	goto restart;
1737	}
1738	raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1739	spin_unlock(lock: &sp->so_lock);
1740	#ifdef CONFIG_NFS_V4_2
1741	if (found_ssc_copy_state)
1742	return -EIO;
1743	#endif /* CONFIG_NFS_V4_2 */
1744	return 0;
1745	out_err:
1746	nfs4_put_open_state(state);
1747	spin_lock(lock: &sp->so_lock);
1748	raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1749	spin_unlock(lock: &sp->so_lock);
1750	return status;
1751	}
1752
1753	static void nfs4_clear_open_state(struct nfs4_state *state)
1754	{
1755	struct nfs4_lock_state *lock;
1756
1757	clear_bit(nr: NFS_DELEGATED_STATE, addr: &state->flags);
1758	clear_bit(nr: NFS_O_RDONLY_STATE, addr: &state->flags);
1759	clear_bit(nr: NFS_O_WRONLY_STATE, addr: &state->flags);
1760	clear_bit(nr: NFS_O_RDWR_STATE, addr: &state->flags);
1761	spin_lock(lock: &state->state_lock);
1762	list_for_each_entry(lock, &state->lock_states, ls_locks) {
1763	lock->ls_seqid.flags = 0;
1764	clear_bit(NFS_LOCK_INITIALIZED, addr: &lock->ls_flags);
1765	}
1766	spin_unlock(lock: &state->state_lock);
1767	}
1768
1769	static void nfs4_reset_seqids(struct nfs_server *server,
1770	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1771	{
1772	struct nfs_client *clp = server->nfs_client;
1773	struct nfs4_state_owner *sp;
1774	struct rb_node *pos;
1775	struct nfs4_state *state;
1776
1777	spin_lock(lock: &clp->cl_lock);
1778	for (pos = rb_first(&server->state_owners);
1779	pos != NULL;
1780	pos = rb_next(pos)) {
1781	sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1782	sp->so_seqid.flags = 0;
1783	spin_lock(lock: &sp->so_lock);
1784	list_for_each_entry(state, &sp->so_states, open_states) {
1785	if (mark_reclaim(clp, state))
1786	nfs4_clear_open_state(state);
1787	}
1788	spin_unlock(lock: &sp->so_lock);
1789	}
1790	spin_unlock(lock: &clp->cl_lock);
1791	}
1792
1793	static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
1794	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1795	{
1796	struct nfs_server *server;
1797
1798	rcu_read_lock();
1799	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1800	nfs4_reset_seqids(server, mark_reclaim);
1801	rcu_read_unlock();
1802	}
1803
1804	static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1805	{
1806	set_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state);
1807	/* Mark all delegations for reclaim */
1808	nfs_delegation_mark_reclaim(clp);
1809	nfs4_state_mark_reclaim_helper(clp, mark_reclaim: nfs4_state_mark_reclaim_reboot);
1810	}
1811
1812	static int nfs4_reclaim_complete(struct nfs_client *clp,
1813	const struct nfs4_state_recovery_ops *ops,
1814	const struct cred *cred)
1815	{
1816	/* Notify the server we're done reclaiming our state */
1817	if (ops->reclaim_complete)
1818	return ops->reclaim_complete(clp, cred);
1819	return 0;
1820	}
1821
1822	static void nfs4_clear_reclaim_server(struct nfs_server *server)
1823	{
1824	struct nfs_client *clp = server->nfs_client;
1825	struct nfs4_state_owner *sp;
1826	struct rb_node *pos;
1827	struct nfs4_state *state;
1828
1829	spin_lock(lock: &clp->cl_lock);
1830	for (pos = rb_first(&server->state_owners);
1831	pos != NULL;
1832	pos = rb_next(pos)) {
1833	sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1834	spin_lock(lock: &sp->so_lock);
1835	list_for_each_entry(state, &sp->so_states, open_states) {
1836	if (!test_and_clear_bit(nr: NFS_STATE_RECLAIM_REBOOT,
1837	addr: &state->flags))
1838	continue;
1839	nfs4_state_mark_reclaim_nograce(clp, state);
1840	}
1841	spin_unlock(lock: &sp->so_lock);
1842	}
1843	spin_unlock(lock: &clp->cl_lock);
1844	}
1845
1846	static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
1847	{
1848	struct nfs_server *server;
1849
1850	if (!test_and_clear_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state))
1851	return 0;
1852
1853	rcu_read_lock();
1854	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1855	nfs4_clear_reclaim_server(server);
1856	rcu_read_unlock();
1857
1858	nfs_delegation_reap_unclaimed(clp);
1859	return 1;
1860	}
1861
1862	static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1863	{
1864	const struct nfs4_state_recovery_ops *ops;
1865	const struct cred *cred;
1866	int err;
1867
1868	if (!nfs4_state_clear_reclaim_reboot(clp))
1869	return;
1870	ops = clp->cl_mvops->reboot_recovery_ops;
1871	cred = nfs4_get_clid_cred(clp);
1872	err = nfs4_reclaim_complete(clp, ops, cred);
1873	put_cred(cred);
1874	if (err == -NFS4ERR_CONN_NOT_BOUND_TO_SESSION)
1875	set_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state);
1876	}
1877
1878	static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
1879	{
1880	nfs_mark_test_expired_all_delegations(clp);
1881	nfs4_state_mark_reclaim_helper(clp, mark_reclaim: nfs4_state_mark_reclaim_nograce);
1882	}
1883
1884	static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1885	{
1886	switch (error) {
1887	case 0:
1888	break;
1889	case -NFS4ERR_CB_PATH_DOWN:
1890	nfs40_handle_cb_pathdown(clp);
1891	break;
1892	case -NFS4ERR_NO_GRACE:
1893	nfs4_state_end_reclaim_reboot(clp);
1894	break;
1895	case -NFS4ERR_STALE_CLIENTID:
1896	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
1897	nfs4_state_start_reclaim_reboot(clp);
1898	break;
1899	case -NFS4ERR_EXPIRED:
1900	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
1901	nfs4_state_start_reclaim_nograce(clp);
1902	break;
1903	case -NFS4ERR_BADSESSION:
1904	case -NFS4ERR_BADSLOT:
1905	case -NFS4ERR_BAD_HIGH_SLOT:
1906	case -NFS4ERR_DEADSESSION:
1907	case -NFS4ERR_SEQ_FALSE_RETRY:
1908	case -NFS4ERR_SEQ_MISORDERED:
1909	set_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
1910	/* Zero session reset errors */
1911	break;
1912	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1913	set_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
1914	break;
1915	default:
1916	dprintk("%s: failed to handle error %d for server %s\n",
1917	__func__, error, clp->cl_hostname);
1918	return error;
1919	}
1920	dprintk("%s: handled error %d for server %s\n", __func__, error,
1921	clp->cl_hostname);
1922	return 0;
1923	}
1924
1925	static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
1926	{
1927	struct nfs4_state_owner *sp;
1928	struct nfs_server *server;
1929	struct rb_node *pos;
1930	LIST_HEAD(freeme);
1931	int status = 0;
1932	int lost_locks = 0;
1933
1934	restart:
1935	rcu_read_lock();
1936	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1937	nfs4_purge_state_owners(server, head: &freeme);
1938	spin_lock(lock: &clp->cl_lock);
1939	for (pos = rb_first(&server->state_owners);
1940	pos != NULL;
1941	pos = rb_next(pos)) {
1942	sp = rb_entry(pos,
1943	struct nfs4_state_owner, so_server_node);
1944	if (!test_and_clear_bit(nr: ops->owner_flag_bit,
1945	addr: &sp->so_flags))
1946	continue;
1947	if (!atomic_inc_not_zero(v: &sp->so_count))
1948	continue;
1949	spin_unlock(lock: &clp->cl_lock);
1950	rcu_read_unlock();
1951
1952	status = nfs4_reclaim_open_state(sp, ops, lost_locks: &lost_locks);
1953	if (status < 0) {
1954	if (lost_locks)
1955	pr_warn("NFS: %s: lost %d locks\n",
1956	clp->cl_hostname, lost_locks);
1957	set_bit(nr: ops->owner_flag_bit, addr: &sp->so_flags);
1958	nfs4_put_state_owner(sp);
1959	status = nfs4_recovery_handle_error(clp, error: status);
1960	return (status != 0) ? status : -EAGAIN;
1961	}
1962
1963	nfs4_put_state_owner(sp);
1964	goto restart;
1965	}
1966	spin_unlock(lock: &clp->cl_lock);
1967	}
1968	rcu_read_unlock();
1969	nfs4_free_state_owners(head: &freeme);
1970	if (lost_locks)
1971	pr_warn("NFS: %s: lost %d locks\n",
1972	clp->cl_hostname, lost_locks);
1973	return 0;
1974	}
1975
1976	static int nfs4_check_lease(struct nfs_client *clp)
1977	{
1978	const struct cred *cred;
1979	const struct nfs4_state_maintenance_ops *ops =
1980	clp->cl_mvops->state_renewal_ops;
1981	int status;
1982
1983	/* Is the client already known to have an expired lease? */
1984	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1985	return 0;
1986	cred = ops->get_state_renewal_cred(clp);
1987	if (cred == NULL) {
1988	cred = nfs4_get_clid_cred(clp);
1989	status = -ENOKEY;
1990	if (cred == NULL)
1991	goto out;
1992	}
1993	status = ops->renew_lease(clp, cred);
1994	put_cred(cred);
1995	if (status == -ETIMEDOUT) {
1996	set_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state);
1997	return 0;
1998	}
1999	out:
2000	return nfs4_recovery_handle_error(clp, error: status);
2001	}
2002
2003	/* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
2004	* and for recoverable errors on EXCHANGE_ID for v4.1
2005	*/
2006	static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
2007	{
2008	switch (status) {
2009	case -NFS4ERR_SEQ_MISORDERED:
2010	if (test_and_set_bit(nr: NFS4CLNT_PURGE_STATE, addr: &clp->cl_state))
2011	return -ESERVERFAULT;
2012	/* Lease confirmation error: retry after purging the lease */
2013	ssleep(seconds: 1);
2014	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
2015	break;
2016	case -NFS4ERR_STALE_CLIENTID:
2017	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
2018	nfs4_state_start_reclaim_reboot(clp);
2019	break;
2020	case -NFS4ERR_CLID_INUSE:
2021	pr_err("NFS: Server %s reports our clientid is in use\n",
2022	clp->cl_hostname);
2023	nfs_mark_client_ready(clp, state: -EPERM);
2024	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
2025	return -EPERM;
2026	case -EACCES:
2027	case -NFS4ERR_DELAY:
2028	case -EAGAIN:
2029	ssleep(seconds: 1);
2030	break;
2031
2032	case -NFS4ERR_MINOR_VERS_MISMATCH:
2033	if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
2034	nfs_mark_client_ready(clp, state: -EPROTONOSUPPORT);
2035	dprintk("%s: exit with error %d for server %s\n",
2036	__func__, -EPROTONOSUPPORT, clp->cl_hostname);
2037	return -EPROTONOSUPPORT;
2038	case -ENOSPC:
2039	if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
2040	nfs_mark_client_ready(clp, state: -EIO);
2041	return -EIO;
2042	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2043	* in nfs4_exchange_id */
2044	default:
2045	dprintk("%s: exit with error %d for server %s\n", __func__,
2046	status, clp->cl_hostname);
2047	return status;
2048	}
2049	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
2050	dprintk("%s: handled error %d for server %s\n", __func__, status,
2051	clp->cl_hostname);
2052	return 0;
2053	}
2054
2055	static int nfs4_establish_lease(struct nfs_client *clp)
2056	{
2057	const struct cred *cred;
2058	const struct nfs4_state_recovery_ops *ops =
2059	clp->cl_mvops->reboot_recovery_ops;
2060	int status;
2061
2062	status = nfs4_begin_drain_session(clp);
2063	if (status != 0)
2064	return status;
2065	cred = nfs4_get_clid_cred(clp);
2066	if (cred == NULL)
2067	return -ENOENT;
2068	status = ops->establish_clid(clp, cred);
2069	put_cred(cred);
2070	if (status != 0)
2071	return status;
2072	pnfs_destroy_all_layouts(clp);
2073	return 0;
2074	}
2075
2076	/*
2077	* Returns zero or a negative errno. NFS4ERR values are converted
2078	* to local errno values.
2079	*/
2080	static int nfs4_reclaim_lease(struct nfs_client *clp)
2081	{
2082	int status;
2083
2084	status = nfs4_establish_lease(clp);
2085	if (status < 0)
2086	return nfs4_handle_reclaim_lease_error(clp, status);
2087	if (test_and_clear_bit(nr: NFS4CLNT_SERVER_SCOPE_MISMATCH, addr: &clp->cl_state))
2088	nfs4_state_start_reclaim_nograce(clp);
2089	if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
2090	set_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state);
2091	clear_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state);
2092	clear_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
2093	return 0;
2094	}
2095
2096	static int nfs4_purge_lease(struct nfs_client *clp)
2097	{
2098	int status;
2099
2100	status = nfs4_establish_lease(clp);
2101	if (status < 0)
2102	return nfs4_handle_reclaim_lease_error(clp, status);
2103	clear_bit(nr: NFS4CLNT_PURGE_STATE, addr: &clp->cl_state);
2104	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
2105	nfs4_state_start_reclaim_nograce(clp);
2106	return 0;
2107	}
2108
2109	/*
2110	* Try remote migration of one FSID from a source server to a
2111	* destination server. The source server provides a list of
2112	* potential destinations.
2113	*
2114	* Returns zero or a negative NFS4ERR status code.
2115	*/
2116	static int nfs4_try_migration(struct nfs_server *server, const struct cred *cred)
2117	{
2118	struct nfs_client *clp = server->nfs_client;
2119	struct nfs4_fs_locations *locations = NULL;
2120	struct inode *inode;
2121	struct page *page;
2122	int status, result;
2123
2124	dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__,
2125	(unsigned long long)server->fsid.major,
2126	(unsigned long long)server->fsid.minor,
2127	clp->cl_hostname);
2128
2129	result = 0;
2130	page = alloc_page(GFP_KERNEL);
2131	locations = kmalloc(size: sizeof(struct nfs4_fs_locations), GFP_KERNEL);
2132	if (page == NULL || locations == NULL) {
2133	dprintk("<-- %s: no memory\n", __func__);
2134	goto out;
2135	}
2136	locations->fattr = nfs_alloc_fattr();
2137	if (locations->fattr == NULL) {
2138	dprintk("<-- %s: no memory\n", __func__);
2139	goto out;
2140	}
2141
2142	inode = d_inode(dentry: server->super->s_root);
2143	result = nfs4_proc_get_locations(server, NFS_FH(inode), locations,
2144	page, cred);
2145	if (result) {
2146	dprintk("<-- %s: failed to retrieve fs_locations: %d\n",
2147	__func__, result);
2148	goto out;
2149	}
2150
2151	result = -NFS4ERR_NXIO;
2152	if (!locations->nlocations)
2153	goto out;
2154
2155	if (!(locations->fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)) {
2156	dprintk("<-- %s: No fs_locations data, migration skipped\n",
2157	__func__);
2158	goto out;
2159	}
2160
2161	status = nfs4_begin_drain_session(clp);
2162	if (status != 0) {
2163	result = status;
2164	goto out;
2165	}
2166
2167	status = nfs4_replace_transport(server, locations);
2168	if (status != 0) {
2169	dprintk("<-- %s: failed to replace transport: %d\n",
2170	__func__, status);
2171	goto out;
2172	}
2173
2174	result = 0;
2175	dprintk("<-- %s: migration succeeded\n", __func__);
2176
2177	out:
2178	if (page != NULL)
2179	__free_page(page);
2180	if (locations != NULL)
2181	kfree(objp: locations->fattr);
2182	kfree(objp: locations);
2183	if (result) {
2184	pr_err("NFS: migration recovery failed (server %s)\n",
2185	clp->cl_hostname);
2186	set_bit(NFS_MIG_FAILED, addr: &server->mig_status);
2187	}
2188	return result;
2189	}
2190
2191	/*
2192	* Returns zero or a negative NFS4ERR status code.
2193	*/
2194	static int nfs4_handle_migration(struct nfs_client *clp)
2195	{
2196	const struct nfs4_state_maintenance_ops *ops =
2197	clp->cl_mvops->state_renewal_ops;
2198	struct nfs_server *server;
2199	const struct cred *cred;
2200
2201	dprintk("%s: migration reported on \"%s\"\n", __func__,
2202	clp->cl_hostname);
2203
2204	cred = ops->get_state_renewal_cred(clp);
2205	if (cred == NULL)
2206	return -NFS4ERR_NOENT;
2207
2208	clp->cl_mig_gen++;
2209	restart:
2210	rcu_read_lock();
2211	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2212	int status;
2213
2214	if (server->mig_gen == clp->cl_mig_gen)
2215	continue;
2216	server->mig_gen = clp->cl_mig_gen;
2217
2218	if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION,
2219	addr: &server->mig_status))
2220	continue;
2221
2222	rcu_read_unlock();
2223	status = nfs4_try_migration(server, cred);
2224	if (status < 0) {
2225	put_cred(cred);
2226	return status;
2227	}
2228	goto restart;
2229	}
2230	rcu_read_unlock();
2231	put_cred(cred);
2232	return 0;
2233	}
2234
2235	/*
2236	* Test each nfs_server on the clp's cl_superblocks list to see
2237	* if it's moved to another server. Stop when the server no longer
2238	* returns NFS4ERR_LEASE_MOVED.
2239	*/
2240	static int nfs4_handle_lease_moved(struct nfs_client *clp)
2241	{
2242	const struct nfs4_state_maintenance_ops *ops =
2243	clp->cl_mvops->state_renewal_ops;
2244	struct nfs_server *server;
2245	const struct cred *cred;
2246
2247	dprintk("%s: lease moved reported on \"%s\"\n", __func__,
2248	clp->cl_hostname);
2249
2250	cred = ops->get_state_renewal_cred(clp);
2251	if (cred == NULL)
2252	return -NFS4ERR_NOENT;
2253
2254	clp->cl_mig_gen++;
2255	restart:
2256	rcu_read_lock();
2257	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2258	struct inode *inode;
2259	int status;
2260
2261	if (server->mig_gen == clp->cl_mig_gen)
2262	continue;
2263	server->mig_gen = clp->cl_mig_gen;
2264
2265	rcu_read_unlock();
2266
2267	inode = d_inode(dentry: server->super->s_root);
2268	status = nfs4_proc_fsid_present(inode, cred);
2269	if (status != -NFS4ERR_MOVED)
2270	goto restart; /* wasn't this one */
2271	if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED)
2272	goto restart; /* there are more */
2273	goto out;
2274	}
2275	rcu_read_unlock();
2276
2277	out:
2278	put_cred(cred);
2279	return 0;
2280	}
2281
2282	/**
2283	* nfs4_discover_server_trunking - Detect server IP address trunking
2284	*
2285	* @clp: nfs_client under test
2286	* @result: OUT: found nfs_client, or clp
2287	*
2288	* Returns zero or a negative errno. If zero is returned,
2289	* an nfs_client pointer is planted in "result".
2290	*
2291	* Note: since we are invoked in process context, and
2292	* not from inside the state manager, we cannot use
2293	* nfs4_handle_reclaim_lease_error().
2294	*/
2295	int nfs4_discover_server_trunking(struct nfs_client *clp,
2296	struct nfs_client **result)
2297	{
2298	const struct nfs4_state_recovery_ops *ops =
2299	clp->cl_mvops->reboot_recovery_ops;
2300	struct rpc_clnt *clnt;
2301	const struct cred *cred;
2302	int i, status;
2303
2304	dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);
2305
2306	clnt = clp->cl_rpcclient;
2307	i = 0;
2308
2309	mutex_lock(&nfs_clid_init_mutex);
2310	again:
2311	status = -ENOENT;
2312	cred = nfs4_get_clid_cred(clp);
2313	if (cred == NULL)
2314	goto out_unlock;
2315
2316	status = ops->detect_trunking(clp, result, cred);
2317	put_cred(cred);
2318	switch (status) {
2319	case 0:
2320	case -EINTR:
2321	case -ERESTARTSYS:
2322	break;
2323	case -ETIMEDOUT:
2324	if (clnt->cl_softrtry)
2325	break;
2326	fallthrough;
2327	case -NFS4ERR_DELAY:
2328	case -EAGAIN:
2329	ssleep(seconds: 1);
2330	fallthrough;
2331	case -NFS4ERR_STALE_CLIENTID:
2332	dprintk("NFS: %s after status %d, retrying\n",
2333	__func__, status);
2334	goto again;
2335	case -EACCES:
2336	if (i++ == 0) {
2337	nfs4_root_machine_cred(clp);
2338	goto again;
2339	}
2340	if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX)
2341	break;
2342	fallthrough;
2343	case -NFS4ERR_CLID_INUSE:
2344	case -NFS4ERR_WRONGSEC:
2345	/* No point in retrying if we already used RPC_AUTH_UNIX */
2346	if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) {
2347	status = -EPERM;
2348	break;
2349	}
2350	clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX);
2351	if (IS_ERR(ptr: clnt)) {
2352	status = PTR_ERR(ptr: clnt);
2353	break;
2354	}
2355	/* Note: this is safe because we haven't yet marked the
2356	* client as ready, so we are the only user of
2357	* clp->cl_rpcclient
2358	*/
2359	clnt = xchg(&clp->cl_rpcclient, clnt);
2360	rpc_shutdown_client(clnt);
2361	clnt = clp->cl_rpcclient;
2362	goto again;
2363
2364	case -NFS4ERR_MINOR_VERS_MISMATCH:
2365	status = -EPROTONOSUPPORT;
2366	break;
2367
2368	case -EKEYEXPIRED:
2369	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2370	* in nfs4_exchange_id */
2371	status = -EKEYEXPIRED;
2372	break;
2373	default:
2374	pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
2375	__func__, status);
2376	status = -EIO;
2377	}
2378
2379	out_unlock:
2380	mutex_unlock(lock: &nfs_clid_init_mutex);
2381	dprintk("NFS: %s: status = %d\n", __func__, status);
2382	return status;
2383	}
2384
2385	#ifdef CONFIG_NFS_V4_1
2386	void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
2387	{
2388	struct nfs_client *clp = session->clp;
2389
2390	switch (err) {
2391	default:
2392	set_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
2393	break;
2394	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
2395	set_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
2396	}
2397	nfs4_schedule_state_manager(clp);
2398	}
2399	EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
2400
2401	void nfs41_notify_server(struct nfs_client *clp)
2402	{
2403	/* Use CHECK_LEASE to ping the server with a SEQUENCE */
2404	set_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state);
2405	nfs4_schedule_state_manager(clp);
2406	}
2407
2408	static void nfs4_reset_all_state(struct nfs_client *clp)
2409	{
2410	if (test_and_set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state) == 0) {
2411	set_bit(nr: NFS4CLNT_PURGE_STATE, addr: &clp->cl_state);
2412	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
2413	nfs4_state_start_reclaim_nograce(clp);
2414	dprintk("%s: scheduling reset of all state for server %s!\n",
2415	__func__, clp->cl_hostname);
2416	nfs4_schedule_state_manager(clp);
2417	}
2418	}
2419
2420	static void nfs41_handle_server_reboot(struct nfs_client *clp)
2421	{
2422	if (test_and_set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state) == 0) {
2423	nfs4_state_start_reclaim_reboot(clp);
2424	dprintk("%s: server %s rebooted!\n", __func__,
2425	clp->cl_hostname);
2426	nfs4_schedule_state_manager(clp);
2427	}
2428	}
2429
2430	static void nfs41_handle_all_state_revoked(struct nfs_client *clp)
2431	{
2432	nfs4_reset_all_state(clp);
2433	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2434	}
2435
2436	static void nfs41_handle_some_state_revoked(struct nfs_client *clp)
2437	{
2438	nfs4_state_start_reclaim_nograce(clp);
2439	nfs4_schedule_state_manager(clp);
2440
2441	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2442	}
2443
2444	static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
2445	{
2446	/* FIXME: For now, we destroy all layouts. */
2447	pnfs_destroy_all_layouts(clp);
2448	nfs_test_expired_all_delegations(clp);
2449	dprintk("%s: Recallable state revoked on server %s!\n", __func__,
2450	clp->cl_hostname);
2451	}
2452
2453	static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
2454	{
2455	set_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
2456	nfs4_schedule_state_manager(clp);
2457
2458	dprintk("%s: server %s declared a backchannel fault\n", __func__,
2459	clp->cl_hostname);
2460	}
2461
2462	static void nfs41_handle_cb_path_down(struct nfs_client *clp)
2463	{
2464	if (test_and_set_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION,
2465	addr: &clp->cl_state) == 0)
2466	nfs4_schedule_state_manager(clp);
2467	}
2468
2469	void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags,
2470	bool recovery)
2471	{
2472	if (!flags)
2473	return;
2474
2475	dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
2476	__func__, clp->cl_hostname, clp->cl_clientid, flags);
2477	/*
2478	* If we're called from the state manager thread, then assume we're
2479	* already handling the RECLAIM_NEEDED and/or STATE_REVOKED.
2480	* Those flags are expected to remain set until we're done
2481	* recovering (see RFC5661, section 18.46.3).
2482	*/
2483	if (recovery)
2484	goto out_recovery;
2485
2486	if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
2487	nfs41_handle_server_reboot(clp);
2488	if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED))
2489	nfs41_handle_all_state_revoked(clp);
2490	if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
2491	SEQ4_STATUS_ADMIN_STATE_REVOKED))
2492	nfs41_handle_some_state_revoked(clp);
2493	if (flags & SEQ4_STATUS_LEASE_MOVED)
2494	nfs4_schedule_lease_moved_recovery(clp);
2495	if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
2496	nfs41_handle_recallable_state_revoked(clp);
2497	out_recovery:
2498	if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT)
2499	nfs41_handle_backchannel_fault(clp);
2500	else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
2501	SEQ4_STATUS_CB_PATH_DOWN_SESSION))
2502	nfs41_handle_cb_path_down(clp);
2503	}
2504
2505	static int nfs4_reset_session(struct nfs_client *clp)
2506	{
2507	const struct cred *cred;
2508	int status;
2509
2510	if (!nfs4_has_session(clp))
2511	return 0;
2512	status = nfs4_begin_drain_session(clp);
2513	if (status != 0)
2514	return status;
2515	cred = nfs4_get_clid_cred(clp);
2516	status = nfs4_proc_destroy_session(clp->cl_session, cred);
2517	switch (status) {
2518	case 0:
2519	case -NFS4ERR_BADSESSION:
2520	case -NFS4ERR_DEADSESSION:
2521	break;
2522	case -NFS4ERR_BACK_CHAN_BUSY:
2523	case -NFS4ERR_DELAY:
2524	set_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
2525	status = 0;
2526	ssleep(seconds: 1);
2527	goto out;
2528	default:
2529	status = nfs4_recovery_handle_error(clp, error: status);
2530	goto out;
2531	}
2532
2533	memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
2534	status = nfs4_proc_create_session(clp, cred);
2535	if (status) {
2536	dprintk("%s: session reset failed with status %d for server %s!\n",
2537	__func__, status, clp->cl_hostname);
2538	status = nfs4_handle_reclaim_lease_error(clp, status);
2539	goto out;
2540	}
2541	nfs41_finish_session_reset(clp);
2542	dprintk("%s: session reset was successful for server %s!\n",
2543	__func__, clp->cl_hostname);
2544	out:
2545	put_cred(cred);
2546	return status;
2547	}
2548
2549	static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2550	{
2551	const struct cred *cred;
2552	int ret;
2553
2554	if (!nfs4_has_session(clp))
2555	return 0;
2556	ret = nfs4_begin_drain_session(clp);
2557	if (ret != 0)
2558	return ret;
2559	cred = nfs4_get_clid_cred(clp);
2560	ret = nfs4_proc_bind_conn_to_session(clp, cred);
2561	put_cred(cred);
2562	clear_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
2563	switch (ret) {
2564	case 0:
2565	dprintk("%s: bind_conn_to_session was successful for server %s!\n",
2566	__func__, clp->cl_hostname);
2567	break;
2568	case -NFS4ERR_DELAY:
2569	ssleep(seconds: 1);
2570	set_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
2571	break;
2572	default:
2573	return nfs4_recovery_handle_error(clp, error: ret);
2574	}
2575	return 0;
2576	}
2577
2578	static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
2579	{
2580	int iomode = 0;
2581
2582	if (test_and_clear_bit(nr: NFS4CLNT_RECALL_ANY_LAYOUT_READ, addr: &clp->cl_state))
2583	iomode += IOMODE_READ;
2584	if (test_and_clear_bit(nr: NFS4CLNT_RECALL_ANY_LAYOUT_RW, addr: &clp->cl_state))
2585	iomode += IOMODE_RW;
2586	/* Note: IOMODE_READ + IOMODE_RW == IOMODE_ANY */
2587	if (iomode) {
2588	pnfs_layout_return_unused_byclid(clp, iomode);
2589	set_bit(nr: NFS4CLNT_RUN_MANAGER, addr: &clp->cl_state);
2590	}
2591	}
2592	#else /* CONFIG_NFS_V4_1 */
2593	static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
2594
2595	static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2596	{
2597	return 0;
2598	}
2599
2600	static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
2601	{
2602	}
2603	#endif /* CONFIG_NFS_V4_1 */
2604
2605	static void nfs4_state_manager(struct nfs_client *clp)
2606	{
2607	unsigned int memflags;
2608	int status = 0;
2609	const char *section = "", *section_sep = "";
2610
2611	/*
2612	* State recovery can deadlock if the direct reclaim code tries
2613	* start NFS writeback. So ensure memory allocations are all
2614	* GFP_NOFS.
2615	*/
2616	memflags = memalloc_nofs_save();
2617
2618	/* Ensure exclusive access to NFSv4 state */
2619	do {
2620	trace_nfs4_state_mgr(clp);
2621	clear_bit(nr: NFS4CLNT_RUN_MANAGER, addr: &clp->cl_state);
2622	if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2623	section = "purge state";
2624	status = nfs4_purge_lease(clp);
2625	if (status < 0)
2626	goto out_error;
2627	continue;
2628	}
2629
2630	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
2631	section = "lease expired";
2632	/* We're going to have to re-establish a clientid */
2633	status = nfs4_reclaim_lease(clp);
2634	if (status < 0)
2635	goto out_error;
2636	continue;
2637	}
2638
2639	/* Initialize or reset the session */
2640	if (test_and_clear_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state)) {
2641	section = "reset session";
2642	status = nfs4_reset_session(clp);
2643	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
2644	continue;
2645	if (status < 0)
2646	goto out_error;
2647	}
2648
2649	/* Send BIND_CONN_TO_SESSION */
2650	if (test_and_clear_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION,
2651	addr: &clp->cl_state)) {
2652	section = "bind conn to session";
2653	status = nfs4_bind_conn_to_session(clp);
2654	if (status < 0)
2655	goto out_error;
2656	continue;
2657	}
2658
2659	if (test_and_clear_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state)) {
2660	section = "check lease";
2661	status = nfs4_check_lease(clp);
2662	if (status < 0)
2663	goto out_error;
2664	continue;
2665	}
2666
2667	if (test_and_clear_bit(nr: NFS4CLNT_MOVED, addr: &clp->cl_state)) {
2668	section = "migration";
2669	status = nfs4_handle_migration(clp);
2670	if (status < 0)
2671	goto out_error;
2672	}
2673
2674	if (test_and_clear_bit(nr: NFS4CLNT_LEASE_MOVED, addr: &clp->cl_state)) {
2675	section = "lease moved";
2676	status = nfs4_handle_lease_moved(clp);
2677	if (status < 0)
2678	goto out_error;
2679	}
2680
2681	/* First recover reboot state... */
2682	if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
2683	section = "reclaim reboot";
2684	status = nfs4_do_reclaim(clp,
2685	ops: clp->cl_mvops->reboot_recovery_ops);
2686	if (status == -EAGAIN)
2687	continue;
2688	if (status < 0)
2689	goto out_error;
2690	nfs4_state_end_reclaim_reboot(clp);
2691	continue;
2692	}
2693
2694	/* Detect expired delegations... */
2695	if (test_and_clear_bit(nr: NFS4CLNT_DELEGATION_EXPIRED, addr: &clp->cl_state)) {
2696	section = "detect expired delegations";
2697	nfs_reap_expired_delegations(clp);
2698	continue;
2699	}
2700
2701	/* Now recover expired state... */
2702	if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
2703	section = "reclaim nograce";
2704	status = nfs4_do_reclaim(clp,
2705	ops: clp->cl_mvops->nograce_recovery_ops);
2706	if (status == -EAGAIN)
2707	continue;
2708	if (status < 0)
2709	goto out_error;
2710	clear_bit(nr: NFS4CLNT_RECLAIM_NOGRACE, addr: &clp->cl_state);
2711	}
2712
2713	memalloc_nofs_restore(flags: memflags);
2714	nfs4_end_drain_session(clp);
2715	nfs4_clear_state_manager_bit(clp);
2716
2717	if (test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&
2718	!test_and_set_bit(nr: NFS4CLNT_MANAGER_RUNNING,
2719	addr: &clp->cl_state)) {
2720	memflags = memalloc_nofs_save();
2721	continue;
2722	}
2723
2724	if (!test_and_set_bit(nr: NFS4CLNT_RECALL_RUNNING, addr: &clp->cl_state)) {
2725	if (test_and_clear_bit(nr: NFS4CLNT_DELEGRETURN, addr: &clp->cl_state)) {
2726	nfs_client_return_marked_delegations(clp);
2727	set_bit(nr: NFS4CLNT_RUN_MANAGER, addr: &clp->cl_state);
2728	}
2729	nfs4_layoutreturn_any_run(clp);
2730	clear_bit(nr: NFS4CLNT_RECALL_RUNNING, addr: &clp->cl_state);
2731	}
2732
2733	return;
2734
2735	} while (refcount_read(r: &clp->cl_count) > 1 && !signalled());
2736	goto out_drain;
2737
2738	out_error:
2739	if (strlen(section))
2740	section_sep = ": ";
2741	trace_nfs4_state_mgr_failed(clp, section, status);
2742	pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
2743	" with error %d\n", section_sep, section,
2744	clp->cl_hostname, -status);
2745	ssleep(seconds: 1);
2746	out_drain:
2747	memalloc_nofs_restore(flags: memflags);
2748	nfs4_end_drain_session(clp);
2749	nfs4_clear_state_manager_bit(clp);
2750	}
2751
2752	static int nfs4_run_state_manager(void *ptr)
2753	{
2754	struct nfs_client *clp = ptr;
2755	struct rpc_clnt *cl = clp->cl_rpcclient;
2756
2757	while (cl != cl->cl_parent)
2758	cl = cl->cl_parent;
2759
2760	allow_signal(SIGKILL);
2761	again:
2762	nfs4_state_manager(clp);
2763
2764	if (test_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state) &&
2765	!test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state)) {
2766	wait_var_event_interruptible(&clp->cl_state,
2767	test_bit(NFS4CLNT_RUN_MANAGER,
2768	&clp->cl_state));
2769	if (!atomic_read(v: &cl->cl_swapper))
2770	clear_bit(nr: NFS4CLNT_MANAGER_AVAILABLE, addr: &clp->cl_state);
2771	if (refcount_read(r: &clp->cl_count) > 1 && !signalled() &&
2772	!test_and_set_bit(nr: NFS4CLNT_MANAGER_RUNNING, addr: &clp->cl_state))
2773	goto again;
2774	/* Either no longer a swapper, or were signalled */
2775	clear_bit(nr: NFS4CLNT_MANAGER_AVAILABLE, addr: &clp->cl_state);
2776	}
2777
2778	if (refcount_read(r: &clp->cl_count) > 1 && !signalled() &&
2779	test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&
2780	!test_and_set_bit(nr: NFS4CLNT_MANAGER_RUNNING, addr: &clp->cl_state))
2781	goto again;
2782
2783	nfs_put_client(clp);
2784	module_put_and_kthread_exit(0);
2785	return 0;
2786	}
2787