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(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	rcu_read_lock();
1449	list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
1450	state = ctx->state;
1451	if (state == NULL)
1452	continue;
1453	if (nfs4_stateid_match_or_older(dst: &state->stateid, src: stateid) &&
1454	nfs4_state_mark_reclaim_nograce(clp, state)) {
1455	found = true;
1456	continue;
1457	}
1458	if (test_bit(NFS_OPEN_STATE, &state->flags) &&
1459	nfs4_stateid_match_or_older(dst: &state->open_stateid, src: stateid) &&
1460	nfs4_state_mark_reclaim_nograce(clp, state)) {
1461	found = true;
1462	continue;
1463	}
1464	if (nfs_state_lock_state_matches_stateid(state, stateid) &&
1465	nfs4_state_mark_reclaim_nograce(clp, state))
1466	found = true;
1467	}
1468	rcu_read_unlock();
1469
1470	nfs_inode_find_delegation_state_and_recover(inode, stateid);
1471	if (found)
1472	nfs4_schedule_state_manager(clp);
1473	}
1474
1475	static void nfs4_state_mark_open_context_bad(struct nfs4_state *state, int err)
1476	{
1477	struct inode *inode = state->inode;
1478	struct nfs_inode *nfsi = NFS_I(inode);
1479	struct nfs_open_context *ctx;
1480
1481	rcu_read_lock();
1482	list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
1483	if (ctx->state != state)
1484	continue;
1485	set_bit(NFS_CONTEXT_BAD, addr: &ctx->flags);
1486	pr_warn("NFSv4: state recovery failed for open file %pd2, "
1487	"error = %d\n", ctx->dentry, err);
1488	}
1489	rcu_read_unlock();
1490	}
1491
1492	static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
1493	{
1494	set_bit(nr: NFS_STATE_RECOVERY_FAILED, addr: &state->flags);
1495	nfs4_state_mark_open_context_bad(state, err: error);
1496	}
1497
1498
1499	static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
1500	{
1501	struct inode *inode = state->inode;
1502	struct nfs_inode *nfsi = NFS_I(inode);
1503	struct file_lock *fl;
1504	struct nfs4_lock_state *lsp;
1505	int status = 0;
1506	struct file_lock_context *flctx = locks_inode_context(inode);
1507	struct list_head *list;
1508
1509	if (flctx == NULL)
1510	return 0;
1511
1512	list = &flctx->flc_posix;
1513
1514	/* Guard against delegation returns and new lock/unlock calls */
1515	down_write(sem: &nfsi->rwsem);
1516	spin_lock(lock: &flctx->flc_lock);
1517	restart:
1518	for_each_file_lock(fl, list) {
1519	if (nfs_file_open_context(filp: fl->c.flc_file)->state != state)
1520	continue;
1521	spin_unlock(lock: &flctx->flc_lock);
1522	status = ops->recover_lock(state, fl);
1523	switch (status) {
1524	case 0:
1525	break;
1526	case -ETIMEDOUT:
1527	case -ESTALE:
1528	case -NFS4ERR_ADMIN_REVOKED:
1529	case -NFS4ERR_STALE_STATEID:
1530	case -NFS4ERR_BAD_STATEID:
1531	case -NFS4ERR_EXPIRED:
1532	case -NFS4ERR_NO_GRACE:
1533	case -NFS4ERR_STALE_CLIENTID:
1534	case -NFS4ERR_BADSESSION:
1535	case -NFS4ERR_BADSLOT:
1536	case -NFS4ERR_BAD_HIGH_SLOT:
1537	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1538	goto out;
1539	default:
1540	pr_err("NFS: %s: unhandled error %d\n",
1541	__func__, status);
1542	fallthrough;
1543	case -ENOMEM:
1544	case -NFS4ERR_DENIED:
1545	case -NFS4ERR_RECLAIM_BAD:
1546	case -NFS4ERR_RECLAIM_CONFLICT:
1547	lsp = fl->fl_u.nfs4_fl.owner;
1548	if (lsp)
1549	set_bit(NFS_LOCK_LOST, addr: &lsp->ls_flags);
1550	status = 0;
1551	}
1552	spin_lock(lock: &flctx->flc_lock);
1553	}
1554	if (list == &flctx->flc_posix) {
1555	list = &flctx->flc_flock;
1556	goto restart;
1557	}
1558	spin_unlock(lock: &flctx->flc_lock);
1559	out:
1560	up_write(sem: &nfsi->rwsem);
1561	return status;
1562	}
1563
1564	#ifdef CONFIG_NFS_V4_2
1565	static void nfs42_complete_copies(struct nfs4_state_owner *sp, struct nfs4_state *state)
1566	{
1567	struct nfs4_copy_state *copy;
1568
1569	if (!test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
1570	!test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags))
1571	return;
1572
1573	spin_lock(lock: &sp->so_server->nfs_client->cl_lock);
1574	list_for_each_entry(copy, &sp->so_server->ss_copies, copies) {
1575	if ((test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
1576	!nfs4_stateid_match_other(dst: &state->stateid,
1577	src: &copy->parent_dst_state->stateid)))
1578	continue;
1579	copy->flags = 1;
1580	if (test_and_clear_bit(nr: NFS_CLNT_DST_SSC_COPY_STATE,
1581	addr: &state->flags)) {
1582	clear_bit(nr: NFS_CLNT_SRC_SSC_COPY_STATE, addr: &state->flags);
1583	complete(&copy->completion);
1584	}
1585	}
1586	list_for_each_entry(copy, &sp->so_server->ss_src_copies, src_copies) {
1587	if ((test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags) &&
1588	!nfs4_stateid_match_other(dst: &state->stateid,
1589	src: &copy->parent_src_state->stateid)))
1590	continue;
1591	copy->flags = 1;
1592	if (test_and_clear_bit(nr: NFS_CLNT_DST_SSC_COPY_STATE,
1593	addr: &state->flags))
1594	complete(&copy->completion);
1595	}
1596	spin_unlock(lock: &sp->so_server->nfs_client->cl_lock);
1597	}
1598	#else /* !CONFIG_NFS_V4_2 */
1599	static inline void nfs42_complete_copies(struct nfs4_state_owner *sp,
1600	struct nfs4_state *state)
1601	{
1602	}
1603	#endif /* CONFIG_NFS_V4_2 */
1604
1605	static int __nfs4_reclaim_open_state(struct nfs4_state_owner *sp, struct nfs4_state *state,
1606	const struct nfs4_state_recovery_ops *ops,
1607	int *lost_locks)
1608	{
1609	struct nfs4_lock_state *lock;
1610	int status;
1611
1612	status = ops->recover_open(sp, state);
1613	if (status < 0)
1614	return status;
1615
1616	status = nfs4_reclaim_locks(state, ops);
1617	if (status < 0)
1618	return status;
1619
1620	if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
1621	spin_lock(lock: &state->state_lock);
1622	list_for_each_entry(lock, &state->lock_states, ls_locks) {
1623	trace_nfs4_state_lock_reclaim(state, lock);
1624	if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags) &&
1625	!test_bit(NFS_LOCK_UNLOCKING, &lock->ls_flags))
1626	*lost_locks += 1;
1627	}
1628	spin_unlock(lock: &state->state_lock);
1629	}
1630
1631	nfs42_complete_copies(sp, state);
1632	clear_bit(nr: NFS_STATE_RECLAIM_NOGRACE, addr: &state->flags);
1633	return status;
1634	}
1635
1636	static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp,
1637	const struct nfs4_state_recovery_ops *ops,
1638	int *lost_locks)
1639	{
1640	struct nfs4_state *state;
1641	unsigned int loop = 0;
1642	int status = 0;
1643	#ifdef CONFIG_NFS_V4_2
1644	bool found_ssc_copy_state = false;
1645	#endif /* CONFIG_NFS_V4_2 */
1646
1647	/* Note: we rely on the sp->so_states list being ordered
1648	* so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
1649	* states first.
1650	* This is needed to ensure that the server won't give us any
1651	* read delegations that we have to return if, say, we are
1652	* recovering after a network partition or a reboot from a
1653	* server that doesn't support a grace period.
1654	*/
1655	spin_lock(lock: &sp->so_lock);
1656	restart:
1657	list_for_each_entry(state, &sp->so_states, open_states) {
1658	if (!test_and_clear_bit(nr: ops->state_flag_bit, addr: &state->flags))
1659	continue;
1660	if (!nfs4_valid_open_stateid(state))
1661	continue;
1662	if (state->state == 0)
1663	continue;
1664	#ifdef CONFIG_NFS_V4_2
1665	if (test_bit(NFS_SRV_SSC_COPY_STATE, &state->flags)) {
1666	nfs4_state_mark_recovery_failed(state, error: -EIO);
1667	found_ssc_copy_state = true;
1668	continue;
1669	}
1670	#endif /* CONFIG_NFS_V4_2 */
1671	refcount_inc(r: &state->count);
1672	spin_unlock(lock: &sp->so_lock);
1673	status = __nfs4_reclaim_open_state(sp, state, ops, lost_locks);
1674
1675	switch (status) {
1676	default:
1677	if (status >= 0) {
1678	loop = 0;
1679	break;
1680	}
1681	printk(KERN_ERR "NFS: %s: unhandled error %d\n", __func__, status);
1682	fallthrough;
1683	case -ENOENT:
1684	case -ENOMEM:
1685	case -EACCES:
1686	case -EROFS:
1687	case -EIO:
1688	case -ESTALE:
1689	/* Open state on this file cannot be recovered */
1690	nfs4_state_mark_recovery_failed(state, error: status);
1691	break;
1692	case -EAGAIN:
1693	ssleep(seconds: 1);
1694	if (loop++ < 10) {
1695	set_bit(nr: ops->state_flag_bit, addr: &state->flags);
1696	break;
1697	}
1698	fallthrough;
1699	case -NFS4ERR_ADMIN_REVOKED:
1700	case -NFS4ERR_STALE_STATEID:
1701	case -NFS4ERR_OLD_STATEID:
1702	case -NFS4ERR_BAD_STATEID:
1703	case -NFS4ERR_RECLAIM_BAD:
1704	case -NFS4ERR_RECLAIM_CONFLICT:
1705	nfs4_state_mark_reclaim_nograce(clp: sp->so_server->nfs_client, state);
1706	break;
1707	case -NFS4ERR_EXPIRED:
1708	case -NFS4ERR_NO_GRACE:
1709	nfs4_state_mark_reclaim_nograce(clp: sp->so_server->nfs_client, state);
1710	fallthrough;
1711	case -NFS4ERR_STALE_CLIENTID:
1712	case -NFS4ERR_BADSESSION:
1713	case -NFS4ERR_BADSLOT:
1714	case -NFS4ERR_BAD_HIGH_SLOT:
1715	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1716	case -ETIMEDOUT:
1717	goto out_err;
1718	}
1719	nfs4_put_open_state(state);
1720	spin_lock(lock: &sp->so_lock);
1721	goto restart;
1722	}
1723	spin_unlock(lock: &sp->so_lock);
1724	#ifdef CONFIG_NFS_V4_2
1725	if (found_ssc_copy_state)
1726	return -EIO;
1727	#endif /* CONFIG_NFS_V4_2 */
1728	return 0;
1729	out_err:
1730	nfs4_put_open_state(state);
1731	spin_lock(lock: &sp->so_lock);
1732	spin_unlock(lock: &sp->so_lock);
1733	return status;
1734	}
1735
1736	static void nfs4_clear_open_state(struct nfs4_state *state)
1737	{
1738	struct nfs4_lock_state *lock;
1739
1740	clear_bit(nr: NFS_DELEGATED_STATE, addr: &state->flags);
1741	clear_bit(nr: NFS_O_RDONLY_STATE, addr: &state->flags);
1742	clear_bit(nr: NFS_O_WRONLY_STATE, addr: &state->flags);
1743	clear_bit(nr: NFS_O_RDWR_STATE, addr: &state->flags);
1744	spin_lock(lock: &state->state_lock);
1745	list_for_each_entry(lock, &state->lock_states, ls_locks) {
1746	lock->ls_seqid.flags = 0;
1747	clear_bit(NFS_LOCK_INITIALIZED, addr: &lock->ls_flags);
1748	}
1749	spin_unlock(lock: &state->state_lock);
1750	}
1751
1752	static void nfs4_reset_seqids(struct nfs_server *server,
1753	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1754	{
1755	struct nfs_client *clp = server->nfs_client;
1756	struct nfs4_state_owner *sp;
1757	struct rb_node *pos;
1758	struct nfs4_state *state;
1759
1760	spin_lock(lock: &clp->cl_lock);
1761	for (pos = rb_first(&server->state_owners);
1762	pos != NULL;
1763	pos = rb_next(pos)) {
1764	sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1765	sp->so_seqid.flags = 0;
1766	spin_lock(lock: &sp->so_lock);
1767	list_for_each_entry(state, &sp->so_states, open_states) {
1768	if (mark_reclaim(clp, state))
1769	nfs4_clear_open_state(state);
1770	}
1771	spin_unlock(lock: &sp->so_lock);
1772	}
1773	spin_unlock(lock: &clp->cl_lock);
1774	}
1775
1776	static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
1777	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1778	{
1779	struct nfs_server *server;
1780
1781	rcu_read_lock();
1782	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1783	nfs4_reset_seqids(server, mark_reclaim);
1784	rcu_read_unlock();
1785	}
1786
1787	static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1788	{
1789	set_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state);
1790	/* Mark all delegations for reclaim */
1791	nfs_delegation_mark_reclaim(clp);
1792	nfs4_state_mark_reclaim_helper(clp, mark_reclaim: nfs4_state_mark_reclaim_reboot);
1793	}
1794
1795	static int nfs4_reclaim_complete(struct nfs_client *clp,
1796	const struct nfs4_state_recovery_ops *ops,
1797	const struct cred *cred)
1798	{
1799	/* Notify the server we're done reclaiming our state */
1800	if (ops->reclaim_complete)
1801	return ops->reclaim_complete(clp, cred);
1802	return 0;
1803	}
1804
1805	static void nfs4_clear_reclaim_server(struct nfs_server *server)
1806	{
1807	struct nfs_client *clp = server->nfs_client;
1808	struct nfs4_state_owner *sp;
1809	struct rb_node *pos;
1810	struct nfs4_state *state;
1811
1812	spin_lock(lock: &clp->cl_lock);
1813	for (pos = rb_first(&server->state_owners);
1814	pos != NULL;
1815	pos = rb_next(pos)) {
1816	sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1817	spin_lock(lock: &sp->so_lock);
1818	list_for_each_entry(state, &sp->so_states, open_states) {
1819	if (!test_and_clear_bit(nr: NFS_STATE_RECLAIM_REBOOT,
1820	addr: &state->flags))
1821	continue;
1822	nfs4_state_mark_reclaim_nograce(clp, state);
1823	}
1824	spin_unlock(lock: &sp->so_lock);
1825	}
1826	spin_unlock(lock: &clp->cl_lock);
1827	}
1828
1829	static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
1830	{
1831	struct nfs_server *server;
1832
1833	if (!test_and_clear_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state))
1834	return 0;
1835
1836	rcu_read_lock();
1837	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1838	nfs4_clear_reclaim_server(server);
1839	rcu_read_unlock();
1840
1841	nfs_delegation_reap_unclaimed(clp);
1842	return 1;
1843	}
1844
1845	static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1846	{
1847	const struct nfs4_state_recovery_ops *ops;
1848	const struct cred *cred;
1849	int err;
1850
1851	if (!nfs4_state_clear_reclaim_reboot(clp))
1852	return;
1853	pnfs_destroy_all_layouts(clp);
1854	ops = clp->cl_mvops->reboot_recovery_ops;
1855	cred = nfs4_get_clid_cred(clp);
1856	err = nfs4_reclaim_complete(clp, ops, cred);
1857	put_cred(cred);
1858	if (err == -NFS4ERR_CONN_NOT_BOUND_TO_SESSION)
1859	set_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state);
1860	}
1861
1862	static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
1863	{
1864	nfs_mark_test_expired_all_delegations(clp);
1865	nfs4_state_mark_reclaim_helper(clp, mark_reclaim: nfs4_state_mark_reclaim_nograce);
1866	}
1867
1868	static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1869	{
1870	switch (error) {
1871	case 0:
1872	break;
1873	case -NFS4ERR_CB_PATH_DOWN:
1874	nfs40_handle_cb_pathdown(clp);
1875	break;
1876	case -NFS4ERR_NO_GRACE:
1877	nfs4_state_end_reclaim_reboot(clp);
1878	break;
1879	case -NFS4ERR_STALE_CLIENTID:
1880	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
1881	nfs4_state_start_reclaim_reboot(clp);
1882	break;
1883	case -NFS4ERR_EXPIRED:
1884	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
1885	nfs4_state_start_reclaim_nograce(clp);
1886	break;
1887	case -NFS4ERR_BADSESSION:
1888	case -NFS4ERR_BADSLOT:
1889	case -NFS4ERR_BAD_HIGH_SLOT:
1890	case -NFS4ERR_DEADSESSION:
1891	case -NFS4ERR_SEQ_FALSE_RETRY:
1892	case -NFS4ERR_SEQ_MISORDERED:
1893	set_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
1894	/* Zero session reset errors */
1895	break;
1896	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1897	set_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
1898	break;
1899	default:
1900	dprintk("%s: failed to handle error %d for server %s\n",
1901	__func__, error, clp->cl_hostname);
1902	return error;
1903	}
1904	dprintk("%s: handled error %d for server %s\n", __func__, error,
1905	clp->cl_hostname);
1906	return 0;
1907	}
1908
1909	static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
1910	{
1911	struct nfs4_state_owner *sp;
1912	struct nfs_server *server;
1913	struct rb_node *pos;
1914	LIST_HEAD(freeme);
1915	int lost_locks = 0;
1916	int status;
1917
1918	status = nfs4_begin_drain_session(clp);
1919	if (status < 0)
1920	return status;
1921	restart:
1922	rcu_read_lock();
1923	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1924	nfs4_purge_state_owners(server, head: &freeme);
1925	spin_lock(lock: &clp->cl_lock);
1926	for (pos = rb_first(&server->state_owners);
1927	pos != NULL;
1928	pos = rb_next(pos)) {
1929	sp = rb_entry(pos,
1930	struct nfs4_state_owner, so_server_node);
1931	if (!test_and_clear_bit(nr: ops->owner_flag_bit,
1932	addr: &sp->so_flags))
1933	continue;
1934	if (!atomic_inc_not_zero(v: &sp->so_count))
1935	continue;
1936	spin_unlock(lock: &clp->cl_lock);
1937	rcu_read_unlock();
1938
1939	status = nfs4_reclaim_open_state(sp, ops, lost_locks: &lost_locks);
1940	if (status < 0) {
1941	if (lost_locks)
1942	pr_warn("NFS: %s: lost %d locks\n",
1943	clp->cl_hostname, lost_locks);
1944	set_bit(nr: ops->owner_flag_bit, addr: &sp->so_flags);
1945	nfs4_put_state_owner(sp);
1946	status = nfs4_recovery_handle_error(clp, error: status);
1947	nfs4_free_state_owners(head: &freeme);
1948	return (status != 0) ? status : -EAGAIN;
1949	}
1950
1951	nfs4_put_state_owner(sp);
1952	goto restart;
1953	}
1954	spin_unlock(lock: &clp->cl_lock);
1955	}
1956	rcu_read_unlock();
1957	nfs4_free_state_owners(head: &freeme);
1958	nfs_local_probe_async(clp);
1959	if (lost_locks)
1960	pr_warn("NFS: %s: lost %d locks\n",
1961	clp->cl_hostname, lost_locks);
1962	return 0;
1963	}
1964
1965	static int nfs4_check_lease(struct nfs_client *clp)
1966	{
1967	const struct cred *cred;
1968	const struct nfs4_state_maintenance_ops *ops =
1969	clp->cl_mvops->state_renewal_ops;
1970	int status;
1971
1972	/* Is the client already known to have an expired lease? */
1973	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1974	return 0;
1975	cred = ops->get_state_renewal_cred(clp);
1976	if (cred == NULL) {
1977	cred = nfs4_get_clid_cred(clp);
1978	status = -ENOKEY;
1979	if (cred == NULL)
1980	goto out;
1981	}
1982	status = ops->renew_lease(clp, cred);
1983	put_cred(cred);
1984	if (status == -ETIMEDOUT) {
1985	set_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state);
1986	return 0;
1987	}
1988	out:
1989	return nfs4_recovery_handle_error(clp, error: status);
1990	}
1991
1992	/* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
1993	* and for recoverable errors on EXCHANGE_ID for v4.1
1994	*/
1995	static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
1996	{
1997	switch (status) {
1998	case -NFS4ERR_SEQ_MISORDERED:
1999	if (test_and_set_bit(nr: NFS4CLNT_PURGE_STATE, addr: &clp->cl_state))
2000	return -ESERVERFAULT;
2001	/* Lease confirmation error: retry after purging the lease */
2002	ssleep(seconds: 1);
2003	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
2004	break;
2005	case -NFS4ERR_STALE_CLIENTID:
2006	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
2007	nfs4_state_start_reclaim_reboot(clp);
2008	break;
2009	case -NFS4ERR_CLID_INUSE:
2010	pr_err("NFS: Server %s reports our clientid is in use\n",
2011	clp->cl_hostname);
2012	nfs_mark_client_ready(clp, state: -EPERM);
2013	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
2014	return -EPERM;
2015	case -ETIMEDOUT:
2016	if (clp->cl_cons_state == NFS_CS_SESSION_INITING) {
2017	nfs_mark_client_ready(clp, state: -EIO);
2018	return -EIO;
2019	}
2020	fallthrough;
2021	case -EACCES:
2022	case -NFS4ERR_DELAY:
2023	case -EAGAIN:
2024	ssleep(seconds: 1);
2025	break;
2026
2027	case -NFS4ERR_MINOR_VERS_MISMATCH:
2028	if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
2029	nfs_mark_client_ready(clp, state: -EPROTONOSUPPORT);
2030	dprintk("%s: exit with error %d for server %s\n",
2031	__func__, -EPROTONOSUPPORT, clp->cl_hostname);
2032	return -EPROTONOSUPPORT;
2033	case -ENOSPC:
2034	if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
2035	nfs_mark_client_ready(clp, state: -EIO);
2036	return -EIO;
2037	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2038	* in nfs4_exchange_id */
2039	default:
2040	dprintk("%s: exit with error %d for server %s\n", __func__,
2041	status, clp->cl_hostname);
2042	return status;
2043	}
2044	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
2045	dprintk("%s: handled error %d for server %s\n", __func__, status,
2046	clp->cl_hostname);
2047	return 0;
2048	}
2049
2050	static int nfs4_establish_lease(struct nfs_client *clp)
2051	{
2052	const struct cred *cred;
2053	const struct nfs4_state_recovery_ops *ops =
2054	clp->cl_mvops->reboot_recovery_ops;
2055	int status;
2056
2057	status = nfs4_begin_drain_session(clp);
2058	if (status != 0)
2059	return status;
2060	cred = nfs4_get_clid_cred(clp);
2061	if (cred == NULL)
2062	return -ENOENT;
2063	status = ops->establish_clid(clp, cred);
2064	put_cred(cred);
2065	if (status != 0)
2066	return status;
2067	return 0;
2068	}
2069
2070	/*
2071	* Returns zero or a negative errno. NFS4ERR values are converted
2072	* to local errno values.
2073	*/
2074	static int nfs4_reclaim_lease(struct nfs_client *clp)
2075	{
2076	int status;
2077
2078	status = nfs4_establish_lease(clp);
2079	if (status < 0)
2080	return nfs4_handle_reclaim_lease_error(clp, status);
2081	if (test_and_clear_bit(nr: NFS4CLNT_SERVER_SCOPE_MISMATCH, addr: &clp->cl_state))
2082	nfs4_state_start_reclaim_nograce(clp);
2083	if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
2084	set_bit(nr: NFS4CLNT_RECLAIM_REBOOT, addr: &clp->cl_state);
2085	clear_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state);
2086	clear_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
2087	return 0;
2088	}
2089
2090	static int nfs4_purge_lease(struct nfs_client *clp)
2091	{
2092	int status;
2093
2094	status = nfs4_establish_lease(clp);
2095	if (status < 0)
2096	return nfs4_handle_reclaim_lease_error(clp, status);
2097	clear_bit(nr: NFS4CLNT_PURGE_STATE, addr: &clp->cl_state);
2098	set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state);
2099	nfs4_state_start_reclaim_nograce(clp);
2100	return 0;
2101	}
2102
2103	/*
2104	* Try remote migration of one FSID from a source server to a
2105	* destination server. The source server provides a list of
2106	* potential destinations.
2107	*
2108	* Returns zero or a negative NFS4ERR status code.
2109	*/
2110	static int nfs4_try_migration(struct nfs_server *server, const struct cred *cred)
2111	{
2112	struct nfs_client *clp = server->nfs_client;
2113	struct nfs4_fs_locations *locations = NULL;
2114	struct nfs_fattr *fattr;
2115	struct inode *inode;
2116	struct page *page;
2117	int status, result;
2118
2119	dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__,
2120	(unsigned long long)server->fsid.major,
2121	(unsigned long long)server->fsid.minor,
2122	clp->cl_hostname);
2123
2124	page = alloc_page(GFP_KERNEL);
2125	locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
2126	fattr = nfs_alloc_fattr();
2127	if (page == NULL || locations == NULL || fattr == NULL) {
2128	dprintk("<-- %s: no memory\n", __func__);
2129	result = 0;
2130	goto out;
2131	}
2132
2133	locations->fattr = fattr;
2134	inode = d_inode(dentry: server->super->s_root);
2135	result = nfs4_proc_get_locations(server, NFS_FH(inode), locations,
2136	page, cred);
2137	if (result) {
2138	dprintk("<-- %s: failed to retrieve fs_locations: %d\n",
2139	__func__, result);
2140	goto out;
2141	}
2142
2143	result = -NFS4ERR_NXIO;
2144	if (!locations->nlocations)
2145	goto out;
2146
2147	if (!(locations->fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)) {
2148	dprintk("<-- %s: No fs_locations data, migration skipped\n",
2149	__func__);
2150	goto out;
2151	}
2152
2153	status = nfs4_begin_drain_session(clp);
2154	if (status != 0) {
2155	result = status;
2156	goto out;
2157	}
2158
2159	status = nfs4_replace_transport(server, locations);
2160	if (status != 0) {
2161	dprintk("<-- %s: failed to replace transport: %d\n",
2162	__func__, status);
2163	goto out;
2164	}
2165
2166	result = 0;
2167	dprintk("<-- %s: migration succeeded\n", __func__);
2168
2169	out:
2170	if (page != NULL)
2171	__free_page(page);
2172	if (locations != NULL)
2173	kfree(objp: locations->fattr);
2174	kfree(objp: locations);
2175	if (result) {
2176	pr_err("NFS: migration recovery failed (server %s)\n",
2177	clp->cl_hostname);
2178	set_bit(NFS_MIG_FAILED, addr: &server->mig_status);
2179	}
2180	return result;
2181	}
2182
2183	/*
2184	* Returns zero or a negative NFS4ERR status code.
2185	*/
2186	static int nfs4_handle_migration(struct nfs_client *clp)
2187	{
2188	const struct nfs4_state_maintenance_ops *ops =
2189	clp->cl_mvops->state_renewal_ops;
2190	struct nfs_server *server;
2191	const struct cred *cred;
2192
2193	dprintk("%s: migration reported on \"%s\"\n", __func__,
2194	clp->cl_hostname);
2195
2196	cred = ops->get_state_renewal_cred(clp);
2197	if (cred == NULL)
2198	return -NFS4ERR_NOENT;
2199
2200	clp->cl_mig_gen++;
2201	restart:
2202	rcu_read_lock();
2203	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2204	int status;
2205
2206	if (server->mig_gen == clp->cl_mig_gen)
2207	continue;
2208	server->mig_gen = clp->cl_mig_gen;
2209
2210	if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION,
2211	addr: &server->mig_status))
2212	continue;
2213
2214	rcu_read_unlock();
2215	status = nfs4_try_migration(server, cred);
2216	if (status < 0) {
2217	put_cred(cred);
2218	return status;
2219	}
2220	goto restart;
2221	}
2222	rcu_read_unlock();
2223	put_cred(cred);
2224	return 0;
2225	}
2226
2227	/*
2228	* Test each nfs_server on the clp's cl_superblocks list to see
2229	* if it's moved to another server. Stop when the server no longer
2230	* returns NFS4ERR_LEASE_MOVED.
2231	*/
2232	static int nfs4_handle_lease_moved(struct nfs_client *clp)
2233	{
2234	const struct nfs4_state_maintenance_ops *ops =
2235	clp->cl_mvops->state_renewal_ops;
2236	struct nfs_server *server;
2237	const struct cred *cred;
2238
2239	dprintk("%s: lease moved reported on \"%s\"\n", __func__,
2240	clp->cl_hostname);
2241
2242	cred = ops->get_state_renewal_cred(clp);
2243	if (cred == NULL)
2244	return -NFS4ERR_NOENT;
2245
2246	clp->cl_mig_gen++;
2247	restart:
2248	rcu_read_lock();
2249	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2250	struct inode *inode;
2251	int status;
2252
2253	if (server->mig_gen == clp->cl_mig_gen)
2254	continue;
2255	server->mig_gen = clp->cl_mig_gen;
2256
2257	rcu_read_unlock();
2258
2259	inode = d_inode(dentry: server->super->s_root);
2260	status = nfs4_proc_fsid_present(inode, cred);
2261	if (status != -NFS4ERR_MOVED)
2262	goto restart; /* wasn't this one */
2263	if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED)
2264	goto restart; /* there are more */
2265	goto out;
2266	}
2267	rcu_read_unlock();
2268
2269	out:
2270	put_cred(cred);
2271	return 0;
2272	}
2273
2274	/**
2275	* nfs4_discover_server_trunking - Detect server IP address trunking
2276	*
2277	* @clp: nfs_client under test
2278	* @result: OUT: found nfs_client, or clp
2279	*
2280	* Returns zero or a negative errno. If zero is returned,
2281	* an nfs_client pointer is planted in "result".
2282	*
2283	* Note: since we are invoked in process context, and
2284	* not from inside the state manager, we cannot use
2285	* nfs4_handle_reclaim_lease_error().
2286	*/
2287	int nfs4_discover_server_trunking(struct nfs_client *clp,
2288	struct nfs_client **result)
2289	{
2290	const struct nfs4_state_recovery_ops *ops =
2291	clp->cl_mvops->reboot_recovery_ops;
2292	struct rpc_clnt *clnt;
2293	const struct cred *cred;
2294	int i, status;
2295
2296	dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);
2297
2298	clnt = clp->cl_rpcclient;
2299	i = 0;
2300
2301	mutex_lock(&nfs_clid_init_mutex);
2302	again:
2303	status = -ENOENT;
2304	cred = nfs4_get_clid_cred(clp);
2305	if (cred == NULL)
2306	goto out_unlock;
2307
2308	status = ops->detect_trunking(clp, result, cred);
2309	put_cred(cred);
2310	switch (status) {
2311	case 0:
2312	case -EINTR:
2313	case -ERESTARTSYS:
2314	break;
2315	case -ETIMEDOUT:
2316	if (clnt->cl_softrtry)
2317	break;
2318	fallthrough;
2319	case -NFS4ERR_DELAY:
2320	case -EAGAIN:
2321	ssleep(seconds: 1);
2322	fallthrough;
2323	case -NFS4ERR_STALE_CLIENTID:
2324	dprintk("NFS: %s after status %d, retrying\n",
2325	__func__, status);
2326	goto again;
2327	case -EACCES:
2328	if (i++ == 0) {
2329	nfs4_root_machine_cred(clp);
2330	goto again;
2331	}
2332	if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX)
2333	break;
2334	fallthrough;
2335	case -NFS4ERR_CLID_INUSE:
2336	case -NFS4ERR_WRONGSEC:
2337	/* No point in retrying if we already used RPC_AUTH_UNIX */
2338	if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) {
2339	status = -EPERM;
2340	break;
2341	}
2342	clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX);
2343	if (IS_ERR(ptr: clnt)) {
2344	status = PTR_ERR(ptr: clnt);
2345	break;
2346	}
2347	/* Note: this is safe because we haven't yet marked the
2348	* client as ready, so we are the only user of
2349	* clp->cl_rpcclient
2350	*/
2351	clnt = xchg(&clp->cl_rpcclient, clnt);
2352	rpc_shutdown_client(clnt);
2353	clnt = clp->cl_rpcclient;
2354	goto again;
2355
2356	case -NFS4ERR_MINOR_VERS_MISMATCH:
2357	status = -EPROTONOSUPPORT;
2358	break;
2359
2360	case -EKEYEXPIRED:
2361	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2362	* in nfs4_exchange_id */
2363	status = -EKEYEXPIRED;
2364	break;
2365	default:
2366	pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
2367	__func__, status);
2368	status = -EIO;
2369	}
2370
2371	out_unlock:
2372	mutex_unlock(lock: &nfs_clid_init_mutex);
2373	dprintk("NFS: %s: status = %d\n", __func__, status);
2374	return status;
2375	}
2376
2377	#ifdef CONFIG_NFS_V4_1
2378	void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
2379	{
2380	struct nfs_client *clp = session->clp;
2381
2382	switch (err) {
2383	default:
2384	set_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
2385	break;
2386	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
2387	set_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
2388	}
2389	nfs4_schedule_state_manager(clp);
2390	}
2391	EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
2392
2393	void nfs41_notify_server(struct nfs_client *clp)
2394	{
2395	/* Use CHECK_LEASE to ping the server with a SEQUENCE */
2396	set_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state);
2397	nfs4_schedule_state_manager(clp);
2398	}
2399
2400	static void nfs4_reset_all_state(struct nfs_client *clp)
2401	{
2402	if (test_and_set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state) == 0) {
2403	set_bit(nr: NFS4CLNT_PURGE_STATE, addr: &clp->cl_state);
2404	clear_bit(nr: NFS4CLNT_LEASE_CONFIRM, addr: &clp->cl_state);
2405	nfs4_state_start_reclaim_nograce(clp);
2406	dprintk("%s: scheduling reset of all state for server %s!\n",
2407	__func__, clp->cl_hostname);
2408	nfs4_schedule_state_manager(clp);
2409	}
2410	}
2411
2412	static void nfs41_handle_server_reboot(struct nfs_client *clp)
2413	{
2414	if (test_and_set_bit(nr: NFS4CLNT_LEASE_EXPIRED, addr: &clp->cl_state) == 0) {
2415	nfs4_state_start_reclaim_reboot(clp);
2416	dprintk("%s: server %s rebooted!\n", __func__,
2417	clp->cl_hostname);
2418	nfs4_schedule_state_manager(clp);
2419	}
2420	}
2421
2422	static void nfs41_handle_all_state_revoked(struct nfs_client *clp)
2423	{
2424	nfs4_reset_all_state(clp);
2425	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2426	}
2427
2428	static void nfs41_handle_some_state_revoked(struct nfs_client *clp)
2429	{
2430	nfs4_state_start_reclaim_nograce(clp);
2431	nfs4_schedule_state_manager(clp);
2432
2433	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2434	}
2435
2436	static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
2437	{
2438	/* FIXME: For now, we destroy all layouts. */
2439	pnfs_destroy_all_layouts(clp);
2440	nfs_test_expired_all_delegations(clp);
2441	dprintk("%s: Recallable state revoked on server %s!\n", __func__,
2442	clp->cl_hostname);
2443	}
2444
2445	static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
2446	{
2447	set_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
2448	nfs4_schedule_state_manager(clp);
2449
2450	dprintk("%s: server %s declared a backchannel fault\n", __func__,
2451	clp->cl_hostname);
2452	}
2453
2454	static void nfs41_handle_cb_path_down(struct nfs_client *clp)
2455	{
2456	if (test_and_set_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION,
2457	addr: &clp->cl_state) == 0)
2458	nfs4_schedule_state_manager(clp);
2459	}
2460
2461	void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags,
2462	bool recovery)
2463	{
2464	if (!flags)
2465	return;
2466
2467	dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
2468	__func__, clp->cl_hostname, clp->cl_clientid, flags);
2469	/*
2470	* If we're called from the state manager thread, then assume we're
2471	* already handling the RECLAIM_NEEDED and/or STATE_REVOKED.
2472	* Those flags are expected to remain set until we're done
2473	* recovering (see RFC5661, section 18.46.3).
2474	*/
2475	if (recovery)
2476	goto out_recovery;
2477
2478	if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
2479	nfs41_handle_server_reboot(clp);
2480	if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED))
2481	nfs41_handle_all_state_revoked(clp);
2482	if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
2483	SEQ4_STATUS_ADMIN_STATE_REVOKED))
2484	nfs41_handle_some_state_revoked(clp);
2485	if (flags & SEQ4_STATUS_LEASE_MOVED)
2486	nfs4_schedule_lease_moved_recovery(clp);
2487	if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
2488	nfs41_handle_recallable_state_revoked(clp);
2489	out_recovery:
2490	if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT)
2491	nfs41_handle_backchannel_fault(clp);
2492	else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
2493	SEQ4_STATUS_CB_PATH_DOWN_SESSION))
2494	nfs41_handle_cb_path_down(clp);
2495	}
2496
2497	static int nfs4_reset_session(struct nfs_client *clp)
2498	{
2499	const struct cred *cred;
2500	int status;
2501
2502	if (!nfs4_has_session(clp))
2503	return 0;
2504	status = nfs4_begin_drain_session(clp);
2505	if (status != 0)
2506	return status;
2507	cred = nfs4_get_clid_cred(clp);
2508	status = nfs4_proc_destroy_session(clp->cl_session, cred);
2509	switch (status) {
2510	case 0:
2511	case -NFS4ERR_BADSESSION:
2512	case -NFS4ERR_DEADSESSION:
2513	break;
2514	case -NFS4ERR_BACK_CHAN_BUSY:
2515	case -NFS4ERR_DELAY:
2516	set_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state);
2517	status = 0;
2518	ssleep(seconds: 1);
2519	goto out;
2520	default:
2521	status = nfs4_recovery_handle_error(clp, error: status);
2522	goto out;
2523	}
2524
2525	memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
2526	status = nfs4_proc_create_session(clp, cred);
2527	if (status) {
2528	dprintk("%s: session reset failed with status %d for server %s!\n",
2529	__func__, status, clp->cl_hostname);
2530	status = nfs4_handle_reclaim_lease_error(clp, status);
2531	goto out;
2532	}
2533	nfs41_finish_session_reset(clp);
2534	dprintk("%s: session reset was successful for server %s!\n",
2535	__func__, clp->cl_hostname);
2536	out:
2537	put_cred(cred);
2538	return status;
2539	}
2540
2541	static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2542	{
2543	const struct cred *cred;
2544	int ret;
2545
2546	if (!nfs4_has_session(clp))
2547	return 0;
2548	ret = nfs4_begin_drain_session(clp);
2549	if (ret != 0)
2550	return ret;
2551	cred = nfs4_get_clid_cred(clp);
2552	ret = nfs4_proc_bind_conn_to_session(clp, cred);
2553	put_cred(cred);
2554	clear_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
2555	switch (ret) {
2556	case 0:
2557	dprintk("%s: bind_conn_to_session was successful for server %s!\n",
2558	__func__, clp->cl_hostname);
2559	break;
2560	case -NFS4ERR_DELAY:
2561	ssleep(seconds: 1);
2562	set_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION, addr: &clp->cl_state);
2563	break;
2564	default:
2565	return nfs4_recovery_handle_error(clp, error: ret);
2566	}
2567	return 0;
2568	}
2569
2570	static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
2571	{
2572	int iomode = 0;
2573
2574	if (test_and_clear_bit(nr: NFS4CLNT_RECALL_ANY_LAYOUT_READ, addr: &clp->cl_state))
2575	iomode += IOMODE_READ;
2576	if (test_and_clear_bit(nr: NFS4CLNT_RECALL_ANY_LAYOUT_RW, addr: &clp->cl_state))
2577	iomode += IOMODE_RW;
2578	/* Note: IOMODE_READ + IOMODE_RW == IOMODE_ANY */
2579	if (iomode) {
2580	pnfs_layout_return_unused_byclid(clp, iomode);
2581	set_bit(nr: NFS4CLNT_RUN_MANAGER, addr: &clp->cl_state);
2582	}
2583	}
2584	#else /* CONFIG_NFS_V4_1 */
2585	static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
2586
2587	static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2588	{
2589	return 0;
2590	}
2591
2592	static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
2593	{
2594	}
2595	#endif /* CONFIG_NFS_V4_1 */
2596
2597	static void nfs4_state_manager(struct nfs_client *clp)
2598	{
2599	unsigned int memflags;
2600	int status = 0;
2601	const char *section = "", *section_sep = "";
2602
2603	/*
2604	* State recovery can deadlock if the direct reclaim code tries
2605	* start NFS writeback. So ensure memory allocations are all
2606	* GFP_NOFS.
2607	*/
2608	memflags = memalloc_nofs_save();
2609
2610	/* Ensure exclusive access to NFSv4 state */
2611	do {
2612	trace_nfs4_state_mgr(clp);
2613	clear_bit(nr: NFS4CLNT_RUN_MANAGER, addr: &clp->cl_state);
2614	if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2615	section = "purge state";
2616	status = nfs4_purge_lease(clp);
2617	if (status < 0)
2618	goto out_error;
2619	continue;
2620	}
2621
2622	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
2623	section = "lease expired";
2624	/* We're going to have to re-establish a clientid */
2625	status = nfs4_reclaim_lease(clp);
2626	if (status < 0)
2627	goto out_error;
2628	continue;
2629	}
2630
2631	/* Initialize or reset the session */
2632	if (test_and_clear_bit(nr: NFS4CLNT_SESSION_RESET, addr: &clp->cl_state)) {
2633	section = "reset session";
2634	status = nfs4_reset_session(clp);
2635	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
2636	continue;
2637	if (status < 0)
2638	goto out_error;
2639	}
2640
2641	/* Send BIND_CONN_TO_SESSION */
2642	if (test_and_clear_bit(nr: NFS4CLNT_BIND_CONN_TO_SESSION,
2643	addr: &clp->cl_state)) {
2644	section = "bind conn to session";
2645	status = nfs4_bind_conn_to_session(clp);
2646	if (status < 0)
2647	goto out_error;
2648	continue;
2649	}
2650
2651	if (test_and_clear_bit(nr: NFS4CLNT_CHECK_LEASE, addr: &clp->cl_state)) {
2652	section = "check lease";
2653	status = nfs4_check_lease(clp);
2654	if (status < 0)
2655	goto out_error;
2656	continue;
2657	}
2658
2659	if (test_and_clear_bit(nr: NFS4CLNT_MOVED, addr: &clp->cl_state)) {
2660	section = "migration";
2661	status = nfs4_handle_migration(clp);
2662	if (status < 0)
2663	goto out_error;
2664	}
2665
2666	if (test_and_clear_bit(nr: NFS4CLNT_LEASE_MOVED, addr: &clp->cl_state)) {
2667	section = "lease moved";
2668	status = nfs4_handle_lease_moved(clp);
2669	if (status < 0)
2670	goto out_error;
2671	}
2672
2673	/* First recover reboot state... */
2674	if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
2675	section = "reclaim reboot";
2676	status = nfs4_do_reclaim(clp,
2677	ops: clp->cl_mvops->reboot_recovery_ops);
2678	if (status == 0)
2679	status = pnfs_layout_handle_reboot(clp);
2680	if (status == -EAGAIN)
2681	continue;
2682	if (status < 0)
2683	goto out_error;
2684	nfs4_state_end_reclaim_reboot(clp);
2685	continue;
2686	}
2687
2688	/* Detect expired delegations... */
2689	if (test_and_clear_bit(nr: NFS4CLNT_DELEGATION_EXPIRED, addr: &clp->cl_state)) {
2690	section = "detect expired delegations";
2691	status = nfs4_begin_drain_session(clp);
2692	if (status < 0)
2693	goto out_error;
2694	nfs_reap_expired_delegations(clp);
2695	continue;
2696	}
2697
2698	/* Now recover expired state... */
2699	if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
2700	section = "reclaim nograce";
2701	status = nfs4_do_reclaim(clp,
2702	ops: clp->cl_mvops->nograce_recovery_ops);
2703	if (status == -EAGAIN)
2704	continue;
2705	if (status < 0)
2706	goto out_error;
2707	clear_bit(nr: NFS4CLNT_RECLAIM_NOGRACE, addr: &clp->cl_state);
2708	}
2709
2710	memalloc_nofs_restore(flags: memflags);
2711	nfs4_end_drain_session(clp);
2712	nfs4_clear_state_manager_bit(clp);
2713
2714	if (test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&
2715	!test_and_set_bit(nr: NFS4CLNT_MANAGER_RUNNING,
2716	addr: &clp->cl_state)) {
2717	memflags = memalloc_nofs_save();
2718	continue;
2719	}
2720
2721	if (!test_and_set_bit(nr: NFS4CLNT_RECALL_RUNNING, addr: &clp->cl_state)) {
2722	if (test_and_clear_bit(nr: NFS4CLNT_DELEGRETURN, addr: &clp->cl_state)) {
2723	nfs_client_return_marked_delegations(clp);
2724	set_bit(nr: NFS4CLNT_RUN_MANAGER, addr: &clp->cl_state);
2725	}
2726	nfs4_layoutreturn_any_run(clp);
2727	clear_bit(nr: NFS4CLNT_RECALL_RUNNING, addr: &clp->cl_state);
2728	}
2729
2730	return;
2731
2732	} while (refcount_read(r: &clp->cl_count) > 1 && !signalled());
2733	goto out_drain;
2734
2735	out_error:
2736	if (strlen(section))
2737	section_sep = ": ";
2738	trace_nfs4_state_mgr_failed(clp, section, status);
2739	pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
2740	" with error %d\n", section_sep, section,
2741	clp->cl_hostname, -status);
2742	switch (status) {
2743	case -ENETDOWN:
2744	case -ENETUNREACH:
2745	nfs_mark_client_ready(clp, state: -EIO);
2746	break;
2747	default:
2748	ssleep(seconds: 1);
2749	break;
2750	}
2751	out_drain:
2752	memalloc_nofs_restore(flags: memflags);
2753	nfs4_end_drain_session(clp);
2754	nfs4_clear_state_manager_bit(clp);
2755	}
2756
2757	static int nfs4_run_state_manager(void *ptr)
2758	{
2759	struct nfs_client *clp = ptr;
2760	struct rpc_clnt *cl = clp->cl_rpcclient;
2761
2762	while (cl != cl->cl_parent)
2763	cl = cl->cl_parent;
2764
2765	allow_signal(SIGKILL);
2766	again:
2767	nfs4_state_manager(clp);
2768
2769	if (test_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state) &&
2770	!test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state)) {
2771	wait_var_event_interruptible(&clp->cl_state,
2772	test_bit(NFS4CLNT_RUN_MANAGER,
2773	&clp->cl_state));
2774	if (!atomic_read(v: &cl->cl_swapper))
2775	clear_bit(nr: NFS4CLNT_MANAGER_AVAILABLE, addr: &clp->cl_state);
2776	if (refcount_read(r: &clp->cl_count) > 1 && !signalled() &&
2777	!test_and_set_bit(nr: NFS4CLNT_MANAGER_RUNNING, addr: &clp->cl_state))
2778	goto again;
2779	/* Either no longer a swapper, or were signalled */
2780	clear_bit(nr: NFS4CLNT_MANAGER_AVAILABLE, addr: &clp->cl_state);
2781	}
2782
2783	if (refcount_read(r: &clp->cl_count) > 1 && !signalled() &&
2784	test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&
2785	!test_and_set_bit(nr: NFS4CLNT_MANAGER_RUNNING, addr: &clp->cl_state))
2786	goto again;
2787
2788	nfs_put_client(clp);
2789	module_put_and_kthread_exit(0);
2790	return 0;
2791	}
2792