nfs4state.c

   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
  70static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp);
  71
  72const nfs4_stateid zero_stateid = {
  73	{ .data = { 0 } },
  74	.type = NFS4_SPECIAL_STATEID_TYPE,
  75};
  76const 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
  84const 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
  92static DEFINE_MUTEX(nfs_clid_init_mutex);
  93
  94static 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);
 105	if (status == 0) {
 106		nfs4_set_lease_period(clp, fsinfo.lease_time * HZ);
 107		nfs4_schedule_state_renewal(clp);
 108	}
 109
 110	return status;
 111}
 112
 113int 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(clp->cl_net, 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(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
 135do_confirm:
 136	status = nfs4_proc_setclientid_confirm(clp, &clid, cred);
 137	if (status != 0)
 138		goto out;
 139	clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
 140	nfs4_setup_state_renewal(clp);
 141out:
 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 */
 158int 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(clp->cl_net, 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	}
 190out:
 191	return status;
 192}
 193
 194const struct cred *nfs4_get_machine_cred(struct nfs_client *clp)
 195{
 196	return get_cred(rpc_machine_cred());
 197}
 198
 199static 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
 207static const struct cred *
 208nfs4_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(&sp->so_states))
 219			continue;
 220		cred = get_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 */
 233const 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(&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(&clp->cl_lock);
 252
 253out:
 254	return cred;
 255}
 256
 257static void nfs4_end_drain_slot_table(struct nfs4_slot_table *tbl)
 258{
 259	if (test_and_clear_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
 260		spin_lock(&tbl->slot_tbl_lock);
 261		nfs41_wake_slot_table(tbl);
 262		spin_unlock(&tbl->slot_tbl_lock);
 263	}
 264}
 265
 266static 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(clp->cl_slot_tbl);
 272		return;
 273	}
 274
 275	if (ses != NULL) {
 276		nfs4_end_drain_slot_table(&ses->bc_slot_table);
 277		nfs4_end_drain_slot_table(&ses->fc_slot_table);
 278	}
 279}
 280
 281static int nfs4_drain_slot_tbl(struct nfs4_slot_table *tbl)
 282{
 283	set_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state);
 284	spin_lock(&tbl->slot_tbl_lock);
 285	if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
 286		reinit_completion(&tbl->complete);
 287		spin_unlock(&tbl->slot_tbl_lock);
 288		return wait_for_completion_interruptible(&tbl->complete);
 289	}
 290	spin_unlock(&tbl->slot_tbl_lock);
 291	return 0;
 292}
 293
 294static 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(clp->cl_slot_tbl);
 301
 302	/* back channel */
 303	ret = nfs4_drain_slot_tbl(&ses->bc_slot_table);
 304	if (ret)
 305		return ret;
 306	/* fore channel */
 307	return nfs4_drain_slot_tbl(&ses->fc_slot_table);
 308}
 309
 310#if defined(CONFIG_NFS_V4_1)
 311
 312static void nfs41_finish_session_reset(struct nfs_client *clp)
 313{
 314	clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
 315	clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
 316	/* create_session negotiated new slot table */
 317	clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
 318	nfs4_setup_state_renewal(clp);
 319}
 320
 321int 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(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
 331do_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);
 339out:
 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 */
 356int 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(NFS4CLNT_PURGE_STATE, &clp->cl_state);
 380		else
 381			set_bit(NFS4CLNT_LEASE_CONFIRM, &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 */
 398const 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
 406static struct nfs4_state_owner *
 407nfs4_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(&sp->so_lru))
 425				list_del_init(&sp->so_lru);
 426			atomic_inc(&sp->so_count);
 427			return sp;
 428		}
 429	}
 430	return NULL;
 431}
 432
 433static struct nfs4_state_owner *
 434nfs4_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(&sp->so_lru))
 453				list_del_init(&sp->so_lru);
 454			atomic_inc(&sp->so_count);
 455			return sp;
 456		}
 457	}
 458	rb_link_node(&new->so_server_node, parent, p);
 459	rb_insert_color(&new->so_server_node, &server->state_owners);
 460	return new;
 461}
 462
 463static void
 464nfs4_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
 472static void
 473nfs4_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(&sc->list);
 480	rpc_init_wait_queue(&sc->wait, "Seqid_waitqueue");
 481}
 482
 483static void
 484nfs4_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 */
 494static struct nfs4_state_owner *
 495nfs4_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(&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(&sp->so_states);
 509	nfs4_init_seqid_counter(&sp->so_seqid);
 510	atomic_set(&sp->so_count, 1);
 511	INIT_LIST_HEAD(&sp->so_lru);
 512	mutex_init(&sp->so_delegreturn_mutex);
 513	return sp;
 514}
 515
 516static void
 517nfs4_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
 531static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
 532{
 533	nfs4_destroy_seqid_counter(&sp->so_seqid);
 534	put_cred(sp->so_cred);
 535	kfree(sp);
 536}
 537
 538static 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(&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(&sp->so_lru, &doomed);
 553		nfs4_remove_state_owner_locked(sp);
 554	}
 555	spin_unlock(&clp->cl_lock);
 556
 557	list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
 558		list_del(&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 */
 571struct 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(&clp->cl_lock);
 579	sp = nfs4_find_state_owner_locked(server, cred);
 580	spin_unlock(&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(&clp->cl_lock);
 587	sp = nfs4_insert_state_owner_locked(new);
 588	spin_unlock(&clp->cl_lock);
 589	if (sp != new)
 590		nfs4_free_state_owner(new);
 591out:
 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 */
 608void 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(&sp->so_lru, &server->state_owners_lru);
 618	spin_unlock(&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 */
 632void 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(&clp->cl_lock);
 638	list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
 639		list_move(&sp->so_lru, head);
 640		nfs4_remove_state_owner_locked(sp);
 641	}
 642	spin_unlock(&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 */
 652void 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(&sp->so_lru);
 658		nfs4_free_state_owner(sp);
 659	}
 660}
 661
 662static struct nfs4_state *
 663nfs4_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(&state->count, 1);
 671	INIT_LIST_HEAD(&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
 678void
 679nfs4_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(&state->open_states, &state->owner->so_states);
 687		else
 688			list_move_tail(&state->open_states, &state->owner->so_states);
 689	}
 690	state->state = fmode;
 691}
 692
 693static 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(&state->count))
 705			return state;
 706	}
 707	return NULL;
 708}
 709
 710static void
 711nfs4_free_open_state(struct nfs4_state *state)
 712{
 713	kfree_rcu(state, rcu_head);
 714}
 715
 716struct nfs4_state *
 717nfs4_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(&owner->so_lock);
 729	spin_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(&owner->so_count);
 735		ihold(inode);
 736		state->inode = inode;
 737		list_add_rcu(&state->inode_states, &nfsi->open_states);
 738		spin_unlock(&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(&state->open_states, &owner->so_states);
 742		spin_unlock(&owner->so_lock);
 743	} else {
 744		spin_unlock(&inode->i_lock);
 745		spin_unlock(&owner->so_lock);
 746		if (new)
 747			nfs4_free_open_state(new);
 748	}
 749out:
 750	return state;
 751}
 752
 753void 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(&state->count, &owner->so_lock))
 759		return;
 760	spin_lock(&inode->i_lock);
 761	list_del_rcu(&state->inode_states);
 762	list_del(&state->open_states);
 763	spin_unlock(&inode->i_lock);
 764	spin_unlock(&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(owner);
 769}
 770
 771/*
 772 * Close the current file.
 773 */
 774static 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(&owner->so_count);
 782	/* Protect against nfs4_find_state() */
 783	spin_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(NFS_DELEGATED_STATE, &state->flags);
 808	}
 809	nfs4_state_set_mode_locked(state, newstate);
 810	spin_unlock(&owner->so_lock);
 811
 812	if (!call_close) {
 813		nfs4_put_open_state(state);
 814		nfs4_put_state_owner(owner);
 815	} else
 816		nfs4_do_close(state, gfp_mask, wait);
 817}
 818
 819void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
 820{
 821	__nfs4_close(state, fmode, GFP_KERNEL, 0);
 822}
 823
 824void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
 825{
 826	__nfs4_close(state, fmode, GFP_KERNEL, 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 */
 842static 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(&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 */
 865static 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(&lsp->ls_seqid);
 874	refcount_set(&lsp->ls_count, 1);
 875	lsp->ls_state = state;
 876	lsp->ls_owner = owner;
 877	lsp->ls_seqid.owner_id = atomic64_inc_return(&server->owner_ctr);
 878	INIT_LIST_HEAD(&lsp->ls_locks);
 879	return lsp;
 880}
 881
 882void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
 883{
 884	nfs4_destroy_seqid_counter(&lsp->ls_seqid);
 885	kfree(lsp);
 886}
 887
 888/*
 889 * Return a compatible lock_state. If no initialized lock_state structure
 890 * exists, return an uninitialized one.
 891 *
 892 */
 893static 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(&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->ls_locks, &state->lock_states);
 904			set_bit(LK_STATE_IN_USE, &state->flags);
 905			lsp = new;
 906			new = NULL;
 907			break;
 908		}
 909		spin_unlock(&state->state_lock);
 910		new = nfs4_alloc_lock_state(state, owner);
 911		if (new == NULL)
 912			return NULL;
 913	}
 914	spin_unlock(&state->state_lock);
 915	if (new != NULL)
 916		nfs4_free_lock_state(state->owner->so_server, 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 */
 924void 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(&lsp->ls_count, &state->state_lock))
 933		return;
 934	list_del(&lsp->ls_locks);
 935	if (list_empty(&state->lock_states))
 936		clear_bit(LK_STATE_IN_USE, &state->flags);
 937	spin_unlock(&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
 947static 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(&lsp->ls_count);
 953}
 954
 955static void nfs4_fl_release_lock(struct file_lock *fl)
 956{
 957	nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
 958}
 959
 960static 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
 965int 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, 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
 979static 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(&state->state_lock);
 997	lsp = __nfs4_find_lock_state(state, owner, 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, &lsp->ls_stateid);
1002		ret = 0;
1003	}
1004	spin_unlock(&state->state_lock);
1005	nfs4_put_lock_state(lsp);
1006out:
1007	return ret;
1008}
1009
1010bool 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(&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(&state->seqlock, seq));
1026	return ret;
1027}
1028
1029/*
1030 * Byte-range lock aware utility to initialize the stateid of read/write
1031 * requests.
1032 */
1033int 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(state->inode, 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;
1059out:
1060	if (nfs_server_capable(state->inode, NFS_CAP_STATEID_NFSV41))
1061		dst->seqid = 0;
1062	return ret;
1063}
1064
1065struct 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(-ENOMEM);
1072	new->sequence = counter;
1073	INIT_LIST_HEAD(&new->list);
1074	new->task = NULL;
1075	return new;
1076}
1077
1078void nfs_release_seqid(struct nfs_seqid *seqid)
1079{
1080	struct nfs_seqid_counter *sequence;
1081
1082	if (seqid == NULL || list_empty(&seqid->list))
1083		return;
1084	sequence = seqid->sequence;
1085	spin_lock(&sequence->lock);
1086	if (list_is_first(&seqid->list, &sequence->list) &&
1087	    !list_is_singular(&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(&seqid->list);
1092	spin_unlock(&sequence->lock);
1093}
1094
1095void nfs_free_seqid(struct nfs_seqid *seqid)
1096{
1097	nfs_release_seqid(seqid);
1098	kfree(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 */
1106static 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
1136void 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(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 */
1155void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
1156{
1157	if (seqid != NULL)
1158		nfs_increment_seqid(status, seqid);
1159}
1160
1161int 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(&sequence->lock);
1170	seqid->task = task;
1171	if (list_empty(&seqid->list))
1172		list_add_tail(&seqid->list, &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;
1177unlock:
1178	spin_unlock(&sequence->lock);
1179out:
1180	return status;
1181}
1182
1183static int nfs4_run_state_manager(void *);
1184
1185static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
1186{
1187	clear_and_wake_up_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
1188	rpc_wake_up(&clp->cl_rpcwaitq);
1189}
1190
1191/*
1192 * Schedule the nfs_client asynchronous state management routine
1193 */
1194void 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(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
1205
1206	if (atomic_read(&clnt->cl_swapper)) {
1207		swapon = !test_and_set_bit(NFS4CLNT_MANAGER_AVAILABLE,
1208					   &clp->cl_state);
1209		if (!swapon) {
1210			wake_up_var(&clp->cl_state);
1211			return;
1212		}
1213	}
1214
1215	if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
1216		return;
1217
1218	__module_get(THIS_MODULE);
1219	refcount_inc(&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, sizeof(buf), "%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(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, PTR_ERR(task));
1234		if (swapon)
1235			clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &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 */
1245void 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(NFS4CLNT_CHECK_LEASE, &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}
1255EXPORT_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 */
1265int 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			&((struct nfs_server *)server)->mig_status);
1286	set_bit(NFS4CLNT_MOVED, &clp->cl_state);
1287
1288	nfs4_schedule_state_manager(clp);
1289	return 0;
1290}
1291EXPORT_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 */
1299void 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(NFS4CLNT_LEASE_MOVED, &clp->cl_state);
1305	nfs4_schedule_state_manager(clp);
1306}
1307EXPORT_SYMBOL_GPL(nfs4_schedule_lease_moved_recovery);
1308
1309int nfs4_wait_clnt_recover(struct nfs_client *clp)
1310{
1311	int res;
1312
1313	might_sleep();
1314
1315	refcount_inc(&clp->cl_count);
1316	res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
1317				 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;
1323out:
1324	nfs_put_client(clp);
1325	return res;
1326}
1327
1328int 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 */
1354static void nfs40_handle_cb_pathdown(struct nfs_client *clp)
1355{
1356	set_bit(NFS4CLNT_LEASE_EXPIRED, &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
1362void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
1363{
1364	nfs40_handle_cb_pathdown(clp);
1365	nfs4_schedule_state_manager(clp);
1366}
1367
1368static 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(NFS_STATE_RECLAIM_REBOOT, &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(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1377		return 0;
1378	}
1379	set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
1380	set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1381	return 1;
1382}
1383
1384int 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(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
1389	clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1390	set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
1391	set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
1392	return 1;
1393}
1394
1395int 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(state->inode,
1402			&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}
1408EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1409
1410static struct nfs4_lock_state *
1411nfs_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(&pos->ls_stateid, stateid))
1420			return pos;
1421	}
1422	return NULL;
1423}
1424
1425static 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(&state->state_lock);
1432		if (nfs_state_find_lock_state_by_stateid(state, stateid))
1433			found = true;
1434		spin_unlock(&state->state_lock);
1435	}
1436	return found;
1437}
1438
1439void nfs_inode_find_state_and_recover(struct inode *inode,
1440		const nfs4_stateid *stateid)
1441{
1442	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1443	struct nfs_inode *nfsi = NFS_I(inode);
1444	struct nfs_open_context *ctx;
1445	struct nfs4_state *state;
1446	bool found = false;
1447
1448	if (!S_ISREG(inode->i_mode))
1449		goto out;
1450	rcu_read_lock();
1451	list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
1452		state = ctx->state;
1453		if (state == NULL)
1454			continue;
1455		if (nfs4_stateid_match_or_older(&state->stateid, stateid) &&
1456		    nfs4_state_mark_reclaim_nograce(clp, state)) {
1457			found = true;
1458			continue;
1459		}
1460		if (test_bit(NFS_OPEN_STATE, &state->flags) &&
1461		    nfs4_stateid_match_or_older(&state->open_stateid, stateid) &&
1462		    nfs4_state_mark_reclaim_nograce(clp, state)) {
1463			found = true;
1464			continue;
1465		}
1466		if (nfs_state_lock_state_matches_stateid(state, stateid) &&
1467		    nfs4_state_mark_reclaim_nograce(clp, state))
1468			found = true;
1469	}
1470	rcu_read_unlock();
1471out:
1472	nfs_inode_find_delegation_state_and_recover(inode, stateid);
1473	if (found)
1474		nfs4_schedule_state_manager(clp);
1475}
1476
1477static void nfs4_state_mark_open_context_bad(struct nfs4_state *state, int err)
1478{
1479	struct inode *inode = state->inode;
1480	struct nfs_inode *nfsi = NFS_I(inode);
1481	struct nfs_open_context *ctx;
1482
1483	if (!S_ISREG(inode->i_mode))
1484		return;
1485	rcu_read_lock();
1486	list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
1487		if (ctx->state != state)
1488			continue;
1489		set_bit(NFS_CONTEXT_BAD, &ctx->flags);
1490		pr_warn("NFSv4: state recovery failed for open file %pd2, "
1491				"error = %d\n", ctx->dentry, err);
1492	}
1493	rcu_read_unlock();
1494}
1495
1496static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
1497{
1498	set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags);
1499	nfs4_state_mark_open_context_bad(state, error);
1500}
1501
1502
1503static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
1504{
1505	struct inode *inode = state->inode;
1506	struct nfs_inode *nfsi = NFS_I(inode);
1507	struct file_lock *fl;
1508	struct nfs4_lock_state *lsp;
1509	int status = 0;
1510	struct file_lock_context *flctx = locks_inode_context(inode);
1511	struct list_head *list;
1512
1513	if (flctx == NULL)
1514		return 0;
1515
1516	list = &flctx->flc_posix;
1517
1518	/* Guard against delegation returns and new lock/unlock calls */
1519	down_write(&nfsi->rwsem);
1520	spin_lock(&flctx->flc_lock);
1521restart:
1522	for_each_file_lock(fl, list) {
1523		if (nfs_file_open_context(fl->c.flc_file)->state != state)
1524			continue;
1525		spin_unlock(&flctx->flc_lock);
1526		status = ops->recover_lock(state, fl);
1527		switch (status) {
1528		case 0:
1529			break;
1530		case -ETIMEDOUT:
1531		case -ESTALE:
1532		case -NFS4ERR_ADMIN_REVOKED:
1533		case -NFS4ERR_STALE_STATEID:
1534		case -NFS4ERR_BAD_STATEID:
1535		case -NFS4ERR_EXPIRED:
1536		case -NFS4ERR_NO_GRACE:
1537		case -NFS4ERR_STALE_CLIENTID:
1538		case -NFS4ERR_BADSESSION:
1539		case -NFS4ERR_BADSLOT:
1540		case -NFS4ERR_BAD_HIGH_SLOT:
1541		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1542			goto out;
1543		default:
1544			pr_err("NFS: %s: unhandled error %d\n",
1545					__func__, status);
1546			fallthrough;
1547		case -ENOMEM:
1548		case -NFS4ERR_DENIED:
1549		case -NFS4ERR_RECLAIM_BAD:
1550		case -NFS4ERR_RECLAIM_CONFLICT:
1551			lsp = fl->fl_u.nfs4_fl.owner;
1552			if (lsp)
1553				set_bit(NFS_LOCK_LOST, &lsp->ls_flags);
1554			status = 0;
1555		}
1556		spin_lock(&flctx->flc_lock);
1557	}
1558	if (list == &flctx->flc_posix) {
1559		list = &flctx->flc_flock;
1560		goto restart;
1561	}
1562	spin_unlock(&flctx->flc_lock);
1563out:
1564	up_write(&nfsi->rwsem);
1565	return status;
1566}
1567
1568#ifdef CONFIG_NFS_V4_2
1569static void nfs42_complete_copies(struct nfs4_state_owner *sp, struct nfs4_state *state)
1570{
1571	struct nfs4_copy_state *copy;
1572
1573	if (!test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
1574		!test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags))
1575		return;
1576
1577	spin_lock(&sp->so_server->nfs_client->cl_lock);
1578	list_for_each_entry(copy, &sp->so_server->ss_copies, copies) {
1579		if ((test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
1580				!nfs4_stateid_match_other(&state->stateid,
1581				&copy->parent_dst_state->stateid)))
1582				continue;
1583		copy->flags = 1;
1584		if (test_and_clear_bit(NFS_CLNT_DST_SSC_COPY_STATE,
1585				&state->flags)) {
1586			clear_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags);
1587			complete(&copy->completion);
1588		}
1589	}
1590	list_for_each_entry(copy, &sp->so_server->ss_src_copies, src_copies) {
1591		if ((test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags) &&
1592				!nfs4_stateid_match_other(&state->stateid,
1593				&copy->parent_src_state->stateid)))
1594				continue;
1595		copy->flags = 1;
1596		if (test_and_clear_bit(NFS_CLNT_DST_SSC_COPY_STATE,
1597				&state->flags))
1598			complete(&copy->completion);
1599	}
1600	spin_unlock(&sp->so_server->nfs_client->cl_lock);
1601}
1602#else /* !CONFIG_NFS_V4_2 */
1603static inline void nfs42_complete_copies(struct nfs4_state_owner *sp,
1604					 struct nfs4_state *state)
1605{
1606}
1607#endif /* CONFIG_NFS_V4_2 */
1608
1609static int __nfs4_reclaim_open_state(struct nfs4_state_owner *sp, struct nfs4_state *state,
1610				     const struct nfs4_state_recovery_ops *ops,
1611				     int *lost_locks)
1612{
1613	struct nfs4_lock_state *lock;
1614	int status;
1615
1616	status = ops->recover_open(sp, state);
1617	if (status < 0)
1618		return status;
1619
1620	status = nfs4_reclaim_locks(state, ops);
1621	if (status < 0)
1622		return status;
1623
1624	if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
1625		spin_lock(&state->state_lock);
1626		list_for_each_entry(lock, &state->lock_states, ls_locks) {
1627			trace_nfs4_state_lock_reclaim(state, lock);
1628			if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags) &&
1629			    !test_bit(NFS_LOCK_UNLOCKING, &lock->ls_flags))
1630				*lost_locks += 1;
1631		}
1632		spin_unlock(&state->state_lock);
1633	}
1634
1635	nfs42_complete_copies(sp, state);
1636	clear_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
1637	return status;
1638}
1639
1640static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp,
1641				   const struct nfs4_state_recovery_ops *ops,
1642				   int *lost_locks)
1643{
1644	struct nfs4_state *state;
1645	unsigned int loop = 0;
1646	int status = 0;
1647#ifdef CONFIG_NFS_V4_2
1648	bool found_ssc_copy_state = false;
1649#endif /* CONFIG_NFS_V4_2 */
1650
1651	/* Note: we rely on the sp->so_states list being ordered 
1652	 * so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
1653	 * states first.
1654	 * This is needed to ensure that the server won't give us any
1655	 * read delegations that we have to return if, say, we are
1656	 * recovering after a network partition or a reboot from a
1657	 * server that doesn't support a grace period.
1658	 */
1659	spin_lock(&sp->so_lock);
1660restart:
1661	list_for_each_entry(state, &sp->so_states, open_states) {
1662		if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
1663			continue;
1664		if (!nfs4_valid_open_stateid(state))
1665			continue;
1666		if (state->state == 0)
1667			continue;
1668#ifdef CONFIG_NFS_V4_2
1669		if (test_bit(NFS_SRV_SSC_COPY_STATE, &state->flags)) {
1670			nfs4_state_mark_recovery_failed(state, -EIO);
1671			found_ssc_copy_state = true;
1672			continue;
1673		}
1674#endif /* CONFIG_NFS_V4_2 */
1675		refcount_inc(&state->count);
1676		spin_unlock(&sp->so_lock);
1677		status = __nfs4_reclaim_open_state(sp, state, ops, lost_locks);
1678
1679		switch (status) {
1680		default:
1681			if (status >= 0) {
1682				loop = 0;
1683				break;
1684			}
1685			printk(KERN_ERR "NFS: %s: unhandled error %d\n", __func__, status);
1686			fallthrough;
1687		case -ENOENT:
1688		case -ENOMEM:
1689		case -EACCES:
1690		case -EROFS:
1691		case -EIO:
1692		case -ESTALE:
1693			/* Open state on this file cannot be recovered */
1694			nfs4_state_mark_recovery_failed(state, status);
1695			break;
1696		case -EAGAIN:
1697			ssleep(1);
1698			if (loop++ < 10) {
1699				set_bit(ops->state_flag_bit, &state->flags);
1700				break;
1701			}
1702			fallthrough;
1703		case -NFS4ERR_ADMIN_REVOKED:
1704		case -NFS4ERR_STALE_STATEID:
1705		case -NFS4ERR_OLD_STATEID:
1706		case -NFS4ERR_BAD_STATEID:
1707		case -NFS4ERR_RECLAIM_BAD:
1708		case -NFS4ERR_RECLAIM_CONFLICT:
1709			nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1710			break;
1711		case -NFS4ERR_EXPIRED:
1712		case -NFS4ERR_NO_GRACE:
1713			nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1714			fallthrough;
1715		case -NFS4ERR_STALE_CLIENTID:
1716		case -NFS4ERR_BADSESSION:
1717		case -NFS4ERR_BADSLOT:
1718		case -NFS4ERR_BAD_HIGH_SLOT:
1719		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1720		case -ETIMEDOUT:
1721			goto out_err;
1722		}
1723		nfs4_put_open_state(state);
1724		spin_lock(&sp->so_lock);
1725		goto restart;
1726	}
1727	spin_unlock(&sp->so_lock);
1728#ifdef CONFIG_NFS_V4_2
1729	if (found_ssc_copy_state)
1730		return -EIO;
1731#endif /* CONFIG_NFS_V4_2 */
1732	return 0;
1733out_err:
1734	nfs4_put_open_state(state);
1735	spin_lock(&sp->so_lock);
1736	spin_unlock(&sp->so_lock);
1737	return status;
1738}
1739
1740static void nfs4_clear_open_state(struct nfs4_state *state)
1741{
1742	struct nfs4_lock_state *lock;
1743
1744	clear_bit(NFS_DELEGATED_STATE, &state->flags);
1745	clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1746	clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1747	clear_bit(NFS_O_RDWR_STATE, &state->flags);
1748	spin_lock(&state->state_lock);
1749	list_for_each_entry(lock, &state->lock_states, ls_locks) {
1750		lock->ls_seqid.flags = 0;
1751		clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags);
1752	}
1753	spin_unlock(&state->state_lock);
1754}
1755
1756static void nfs4_reset_seqids(struct nfs_server *server,
1757	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1758{
1759	struct nfs_client *clp = server->nfs_client;
1760	struct nfs4_state_owner *sp;
1761	struct rb_node *pos;
1762	struct nfs4_state *state;
1763
1764	spin_lock(&clp->cl_lock);
1765	for (pos = rb_first(&server->state_owners);
1766	     pos != NULL;
1767	     pos = rb_next(pos)) {
1768		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1769		sp->so_seqid.flags = 0;
1770		spin_lock(&sp->so_lock);
1771		list_for_each_entry(state, &sp->so_states, open_states) {
1772			if (mark_reclaim(clp, state))
1773				nfs4_clear_open_state(state);
1774		}
1775		spin_unlock(&sp->so_lock);
1776	}
1777	spin_unlock(&clp->cl_lock);
1778}
1779
1780static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
1781	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1782{
1783	struct nfs_server *server;
1784
1785	rcu_read_lock();
1786	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1787		nfs4_reset_seqids(server, mark_reclaim);
1788	rcu_read_unlock();
1789}
1790
1791static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1792{
1793	set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1794	/* Mark all delegations for reclaim */
1795	nfs_delegation_mark_reclaim(clp);
1796	nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot);
1797}
1798
1799static int nfs4_reclaim_complete(struct nfs_client *clp,
1800				 const struct nfs4_state_recovery_ops *ops,
1801				 const struct cred *cred)
1802{
1803	/* Notify the server we're done reclaiming our state */
1804	if (ops->reclaim_complete)
1805		return ops->reclaim_complete(clp, cred);
1806	return 0;
1807}
1808
1809static void nfs4_clear_reclaim_server(struct nfs_server *server)
1810{
1811	struct nfs_client *clp = server->nfs_client;
1812	struct nfs4_state_owner *sp;
1813	struct rb_node *pos;
1814	struct nfs4_state *state;
1815
1816	spin_lock(&clp->cl_lock);
1817	for (pos = rb_first(&server->state_owners);
1818	     pos != NULL;
1819	     pos = rb_next(pos)) {
1820		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1821		spin_lock(&sp->so_lock);
1822		list_for_each_entry(state, &sp->so_states, open_states) {
1823			if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
1824						&state->flags))
1825				continue;
1826			nfs4_state_mark_reclaim_nograce(clp, state);
1827		}
1828		spin_unlock(&sp->so_lock);
1829	}
1830	spin_unlock(&clp->cl_lock);
1831}
1832
1833static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
1834{
1835	struct nfs_server *server;
1836
1837	if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
1838		return 0;
1839
1840	rcu_read_lock();
1841	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1842		nfs4_clear_reclaim_server(server);
1843	rcu_read_unlock();
1844
1845	nfs_delegation_reap_unclaimed(clp);
1846	return 1;
1847}
1848
1849static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1850{
1851	const struct nfs4_state_recovery_ops *ops;
1852	const struct cred *cred;
1853	int err;
1854
1855	if (!nfs4_state_clear_reclaim_reboot(clp))
1856		return;
1857	pnfs_destroy_all_layouts(clp);
1858	ops = clp->cl_mvops->reboot_recovery_ops;
1859	cred = nfs4_get_clid_cred(clp);
1860	err = nfs4_reclaim_complete(clp, ops, cred);
1861	put_cred(cred);
1862	if (err == -NFS4ERR_CONN_NOT_BOUND_TO_SESSION)
1863		set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1864}
1865
1866static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
1867{
1868	nfs_mark_test_expired_all_delegations(clp);
1869	nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
1870}
1871
1872static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1873{
1874	switch (error) {
1875	case 0:
1876		break;
1877	case -NFS4ERR_CB_PATH_DOWN:
1878		nfs40_handle_cb_pathdown(clp);
1879		break;
1880	case -NFS4ERR_NO_GRACE:
1881		nfs4_state_end_reclaim_reboot(clp);
1882		break;
1883	case -NFS4ERR_STALE_CLIENTID:
1884		set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1885		nfs4_state_start_reclaim_reboot(clp);
1886		break;
1887	case -NFS4ERR_EXPIRED:
1888		set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1889		nfs4_state_start_reclaim_nograce(clp);
1890		break;
1891	case -NFS4ERR_BADSESSION:
1892	case -NFS4ERR_BADSLOT:
1893	case -NFS4ERR_BAD_HIGH_SLOT:
1894	case -NFS4ERR_DEADSESSION:
1895	case -NFS4ERR_SEQ_FALSE_RETRY:
1896	case -NFS4ERR_SEQ_MISORDERED:
1897		set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1898		/* Zero session reset errors */
1899		break;
1900	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1901		set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1902		break;
1903	default:
1904		dprintk("%s: failed to handle error %d for server %s\n",
1905				__func__, error, clp->cl_hostname);
1906		return error;
1907	}
1908	dprintk("%s: handled error %d for server %s\n", __func__, error,
1909			clp->cl_hostname);
1910	return 0;
1911}
1912
1913static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
1914{
1915	struct nfs4_state_owner *sp;
1916	struct nfs_server *server;
1917	struct rb_node *pos;
1918	LIST_HEAD(freeme);
1919	int lost_locks = 0;
1920	int status;
1921
1922	status = nfs4_begin_drain_session(clp);
1923	if (status < 0)
1924		return status;
1925restart:
1926	rcu_read_lock();
1927	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1928		nfs4_purge_state_owners(server, &freeme);
1929		spin_lock(&clp->cl_lock);
1930		for (pos = rb_first(&server->state_owners);
1931		     pos != NULL;
1932		     pos = rb_next(pos)) {
1933			sp = rb_entry(pos,
1934				struct nfs4_state_owner, so_server_node);
1935			if (!test_and_clear_bit(ops->owner_flag_bit,
1936							&sp->so_flags))
1937				continue;
1938			if (!atomic_inc_not_zero(&sp->so_count))
1939				continue;
1940			spin_unlock(&clp->cl_lock);
1941			rcu_read_unlock();
1942
1943			status = nfs4_reclaim_open_state(sp, ops, &lost_locks);
1944			if (status < 0) {
1945				if (lost_locks)
1946					pr_warn("NFS: %s: lost %d locks\n",
1947						clp->cl_hostname, lost_locks);
1948				set_bit(ops->owner_flag_bit, &sp->so_flags);
1949				nfs4_put_state_owner(sp);
1950				status = nfs4_recovery_handle_error(clp, status);
1951				nfs4_free_state_owners(&freeme);
1952				return (status != 0) ? status : -EAGAIN;
1953			}
1954
1955			nfs4_put_state_owner(sp);
1956			goto restart;
1957		}
1958		spin_unlock(&clp->cl_lock);
1959	}
1960	rcu_read_unlock();
1961	nfs4_free_state_owners(&freeme);
1962	nfs_local_probe_async(clp);
1963	if (lost_locks)
1964		pr_warn("NFS: %s: lost %d locks\n",
1965			clp->cl_hostname, lost_locks);
1966	return 0;
1967}
1968
1969static int nfs4_check_lease(struct nfs_client *clp)
1970{
1971	const struct cred *cred;
1972	const struct nfs4_state_maintenance_ops *ops =
1973		clp->cl_mvops->state_renewal_ops;
1974	int status;
1975
1976	/* Is the client already known to have an expired lease? */
1977	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1978		return 0;
1979	cred = ops->get_state_renewal_cred(clp);
1980	if (cred == NULL) {
1981		cred = nfs4_get_clid_cred(clp);
1982		status = -ENOKEY;
1983		if (cred == NULL)
1984			goto out;
1985	}
1986	status = ops->renew_lease(clp, cred);
1987	put_cred(cred);
1988	if (status == -ETIMEDOUT) {
1989		set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1990		return 0;
1991	}
1992out:
1993	return nfs4_recovery_handle_error(clp, status);
1994}
1995
1996/* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
1997 * and for recoverable errors on EXCHANGE_ID for v4.1
1998 */
1999static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
2000{
2001	switch (status) {
2002	case -NFS4ERR_SEQ_MISORDERED:
2003		if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state))
2004			return -ESERVERFAULT;
2005		/* Lease confirmation error: retry after purging the lease */
2006		ssleep(1);
2007		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
2008		break;
2009	case -NFS4ERR_STALE_CLIENTID:
2010		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
2011		nfs4_state_start_reclaim_reboot(clp);
2012		break;
2013	case -NFS4ERR_CLID_INUSE:
2014		pr_err("NFS: Server %s reports our clientid is in use\n",
2015			clp->cl_hostname);
2016		nfs_mark_client_ready(clp, -EPERM);
2017		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
2018		return -EPERM;
2019	case -ETIMEDOUT:
2020		if (clp->cl_cons_state == NFS_CS_SESSION_INITING) {
2021			nfs_mark_client_ready(clp, -EIO);
2022			return -EIO;
2023		}
2024		fallthrough;
2025	case -EACCES:
2026	case -NFS4ERR_DELAY:
2027	case -EAGAIN:
2028		ssleep(1);
2029		break;
2030
2031	case -NFS4ERR_MINOR_VERS_MISMATCH:
2032		if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
2033			nfs_mark_client_ready(clp, -EPROTONOSUPPORT);
2034		dprintk("%s: exit with error %d for server %s\n",
2035				__func__, -EPROTONOSUPPORT, clp->cl_hostname);
2036		return -EPROTONOSUPPORT;
2037	case -ENOSPC:
2038		if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
2039			nfs_mark_client_ready(clp, -EIO);
2040		return -EIO;
2041	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2042				 * in nfs4_exchange_id */
2043	default:
2044		dprintk("%s: exit with error %d for server %s\n", __func__,
2045				status, clp->cl_hostname);
2046		return status;
2047	}
2048	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
2049	dprintk("%s: handled error %d for server %s\n", __func__, status,
2050			clp->cl_hostname);
2051	return 0;
2052}
2053
2054static int nfs4_establish_lease(struct nfs_client *clp)
2055{
2056	const struct cred *cred;
2057	const struct nfs4_state_recovery_ops *ops =
2058		clp->cl_mvops->reboot_recovery_ops;
2059	int status;
2060
2061	status = nfs4_begin_drain_session(clp);
2062	if (status != 0)
2063		return status;
2064	cred = nfs4_get_clid_cred(clp);
2065	if (cred == NULL)
2066		return -ENOENT;
2067	status = ops->establish_clid(clp, cred);
2068	put_cred(cred);
2069	if (status != 0)
2070		return status;
2071	return 0;
2072}
2073
2074/*
2075 * Returns zero or a negative errno.  NFS4ERR values are converted
2076 * to local errno values.
2077 */
2078static int nfs4_reclaim_lease(struct nfs_client *clp)
2079{
2080	int status;
2081
2082	status = nfs4_establish_lease(clp);
2083	if (status < 0)
2084		return nfs4_handle_reclaim_lease_error(clp, status);
2085	if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state))
2086		nfs4_state_start_reclaim_nograce(clp);
2087	if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
2088		set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
2089	clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
2090	clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
2091	return 0;
2092}
2093
2094static int nfs4_purge_lease(struct nfs_client *clp)
2095{
2096	int status;
2097
2098	status = nfs4_establish_lease(clp);
2099	if (status < 0)
2100		return nfs4_handle_reclaim_lease_error(clp, status);
2101	clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
2102	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
2103	nfs4_state_start_reclaim_nograce(clp);
2104	return 0;
2105}
2106
2107/*
2108 * Try remote migration of one FSID from a source server to a
2109 * destination server.  The source server provides a list of
2110 * potential destinations.
2111 *
2112 * Returns zero or a negative NFS4ERR status code.
2113 */
2114static int nfs4_try_migration(struct nfs_server *server, const struct cred *cred)
2115{
2116	struct nfs_client *clp = server->nfs_client;
2117	struct nfs4_fs_locations *locations = NULL;
2118	struct nfs_fattr *fattr;
2119	struct inode *inode;
2120	struct page *page;
2121	int status, result;
2122
2123	dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__,
2124			(unsigned long long)server->fsid.major,
2125			(unsigned long long)server->fsid.minor,
2126			clp->cl_hostname);
2127
2128	page = alloc_page(GFP_KERNEL);
2129	locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
2130	fattr = nfs_alloc_fattr();
2131	if (page == NULL || locations == NULL || fattr == NULL) {
2132		dprintk("<-- %s: no memory\n", __func__);
2133		result = 0;
2134		goto out;
2135	}
2136
2137	locations->fattr = fattr;
2138	inode = d_inode(server->super->s_root);
2139	result = nfs4_proc_get_locations(server, NFS_FH(inode), locations,
2140					 page, cred);
2141	if (result) {
2142		dprintk("<-- %s: failed to retrieve fs_locations: %d\n",
2143			__func__, result);
2144		goto out;
2145	}
2146
2147	result = -NFS4ERR_NXIO;
2148	if (!locations->nlocations)
2149		goto out;
2150
2151	if (!(locations->fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)) {
2152		dprintk("<-- %s: No fs_locations data, migration skipped\n",
2153			__func__);
2154		goto out;
2155	}
2156
2157	status = nfs4_begin_drain_session(clp);
2158	if (status != 0) {
2159		result = status;
2160		goto out;
2161	}
2162
2163	status = nfs4_replace_transport(server, locations);
2164	if (status != 0) {
2165		dprintk("<-- %s: failed to replace transport: %d\n",
2166			__func__, status);
2167		goto out;
2168	}
2169
2170	result = 0;
2171	dprintk("<-- %s: migration succeeded\n", __func__);
2172
2173out:
2174	if (page != NULL)
2175		__free_page(page);
2176	if (locations != NULL)
2177		kfree(locations->fattr);
2178	kfree(locations);
2179	if (result) {
2180		pr_err("NFS: migration recovery failed (server %s)\n",
2181				clp->cl_hostname);
2182		set_bit(NFS_MIG_FAILED, &server->mig_status);
2183	}
2184	return result;
2185}
2186
2187/*
2188 * Returns zero or a negative NFS4ERR status code.
2189 */
2190static int nfs4_handle_migration(struct nfs_client *clp)
2191{
2192	const struct nfs4_state_maintenance_ops *ops =
2193				clp->cl_mvops->state_renewal_ops;
2194	struct nfs_server *server;
2195	const struct cred *cred;
2196
2197	dprintk("%s: migration reported on \"%s\"\n", __func__,
2198			clp->cl_hostname);
2199
2200	cred = ops->get_state_renewal_cred(clp);
2201	if (cred == NULL)
2202		return -NFS4ERR_NOENT;
2203
2204	clp->cl_mig_gen++;
2205restart:
2206	rcu_read_lock();
2207	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2208		int status;
2209
2210		if (server->mig_gen == clp->cl_mig_gen)
2211			continue;
2212		server->mig_gen = clp->cl_mig_gen;
2213
2214		if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION,
2215						&server->mig_status))
2216			continue;
2217
2218		rcu_read_unlock();
2219		status = nfs4_try_migration(server, cred);
2220		if (status < 0) {
2221			put_cred(cred);
2222			return status;
2223		}
2224		goto restart;
2225	}
2226	rcu_read_unlock();
2227	put_cred(cred);
2228	return 0;
2229}
2230
2231/*
2232 * Test each nfs_server on the clp's cl_superblocks list to see
2233 * if it's moved to another server.  Stop when the server no longer
2234 * returns NFS4ERR_LEASE_MOVED.
2235 */
2236static int nfs4_handle_lease_moved(struct nfs_client *clp)
2237{
2238	const struct nfs4_state_maintenance_ops *ops =
2239				clp->cl_mvops->state_renewal_ops;
2240	struct nfs_server *server;
2241	const struct cred *cred;
2242
2243	dprintk("%s: lease moved reported on \"%s\"\n", __func__,
2244			clp->cl_hostname);
2245
2246	cred = ops->get_state_renewal_cred(clp);
2247	if (cred == NULL)
2248		return -NFS4ERR_NOENT;
2249
2250	clp->cl_mig_gen++;
2251restart:
2252	rcu_read_lock();
2253	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2254		struct inode *inode;
2255		int status;
2256
2257		if (server->mig_gen == clp->cl_mig_gen)
2258			continue;
2259		server->mig_gen = clp->cl_mig_gen;
2260
2261		rcu_read_unlock();
2262
2263		inode = d_inode(server->super->s_root);
2264		status = nfs4_proc_fsid_present(inode, cred);
2265		if (status != -NFS4ERR_MOVED)
2266			goto restart;	/* wasn't this one */
2267		if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED)
2268			goto restart;	/* there are more */
2269		goto out;
2270	}
2271	rcu_read_unlock();
2272
2273out:
2274	put_cred(cred);
2275	return 0;
2276}
2277
2278/**
2279 * nfs4_discover_server_trunking - Detect server IP address trunking
2280 *
2281 * @clp: nfs_client under test
2282 * @result: OUT: found nfs_client, or clp
2283 *
2284 * Returns zero or a negative errno.  If zero is returned,
2285 * an nfs_client pointer is planted in "result".
2286 *
2287 * Note: since we are invoked in process context, and
2288 * not from inside the state manager, we cannot use
2289 * nfs4_handle_reclaim_lease_error().
2290 */
2291int nfs4_discover_server_trunking(struct nfs_client *clp,
2292				  struct nfs_client **result)
2293{
2294	const struct nfs4_state_recovery_ops *ops =
2295				clp->cl_mvops->reboot_recovery_ops;
2296	struct rpc_clnt *clnt;
2297	const struct cred *cred;
2298	int i, status;
2299
2300	dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);
2301
2302	clnt = clp->cl_rpcclient;
2303	i = 0;
2304
2305	mutex_lock(&nfs_clid_init_mutex);
2306again:
2307	status  = -ENOENT;
2308	cred = nfs4_get_clid_cred(clp);
2309	if (cred == NULL)
2310		goto out_unlock;
2311
2312	status = ops->detect_trunking(clp, result, cred);
2313	put_cred(cred);
2314	switch (status) {
2315	case 0:
2316	case -EINTR:
2317	case -ERESTARTSYS:
2318		break;
2319	case -ETIMEDOUT:
2320		if (clnt->cl_softrtry)
2321			break;
2322		fallthrough;
2323	case -NFS4ERR_DELAY:
2324	case -EAGAIN:
2325		ssleep(1);
2326		fallthrough;
2327	case -NFS4ERR_STALE_CLIENTID:
2328		dprintk("NFS: %s after status %d, retrying\n",
2329			__func__, status);
2330		goto again;
2331	case -EACCES:
2332		if (i++ == 0) {
2333			nfs4_root_machine_cred(clp);
2334			goto again;
2335		}
2336		if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX)
2337			break;
2338		fallthrough;
2339	case -NFS4ERR_CLID_INUSE:
2340	case -NFS4ERR_WRONGSEC:
2341		/* No point in retrying if we already used RPC_AUTH_UNIX */
2342		if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) {
2343			status = -EPERM;
2344			break;
2345		}
2346		clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX);
2347		if (IS_ERR(clnt)) {
2348			status = PTR_ERR(clnt);
2349			break;
2350		}
2351		/* Note: this is safe because we haven't yet marked the
2352		 * client as ready, so we are the only user of
2353		 * clp->cl_rpcclient
2354		 */
2355		clnt = xchg(&clp->cl_rpcclient, clnt);
2356		rpc_shutdown_client(clnt);
2357		clnt = clp->cl_rpcclient;
2358		goto again;
2359
2360	case -NFS4ERR_MINOR_VERS_MISMATCH:
2361		status = -EPROTONOSUPPORT;
2362		break;
2363
2364	case -EKEYEXPIRED:
2365	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2366				 * in nfs4_exchange_id */
2367		status = -EKEYEXPIRED;
2368		break;
2369	default:
2370		pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
2371				__func__, status);
2372		status = -EIO;
2373	}
2374
2375out_unlock:
2376	mutex_unlock(&nfs_clid_init_mutex);
2377	dprintk("NFS: %s: status = %d\n", __func__, status);
2378	return status;
2379}
2380
2381#ifdef CONFIG_NFS_V4_1
2382void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
2383{
2384	struct nfs_client *clp = session->clp;
2385
2386	switch (err) {
2387	default:
2388		set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2389		break;
2390	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
2391		set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2392	}
2393	nfs4_schedule_state_manager(clp);
2394}
2395EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
2396
2397void nfs41_notify_server(struct nfs_client *clp)
2398{
2399	/* Use CHECK_LEASE to ping the server with a SEQUENCE */
2400	set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
2401	nfs4_schedule_state_manager(clp);
2402}
2403
2404static void nfs4_reset_all_state(struct nfs_client *clp)
2405{
2406	if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2407		set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
2408		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
2409		nfs4_state_start_reclaim_nograce(clp);
2410		dprintk("%s: scheduling reset of all state for server %s!\n",
2411				__func__, clp->cl_hostname);
2412		nfs4_schedule_state_manager(clp);
2413	}
2414}
2415
2416static void nfs41_handle_server_reboot(struct nfs_client *clp)
2417{
2418	if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2419		nfs4_state_start_reclaim_reboot(clp);
2420		dprintk("%s: server %s rebooted!\n", __func__,
2421				clp->cl_hostname);
2422		nfs4_schedule_state_manager(clp);
2423	}
2424}
2425
2426static void nfs41_handle_all_state_revoked(struct nfs_client *clp)
2427{
2428	nfs4_reset_all_state(clp);
2429	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2430}
2431
2432static void nfs41_handle_some_state_revoked(struct nfs_client *clp)
2433{
2434	nfs4_state_start_reclaim_nograce(clp);
2435	nfs4_schedule_state_manager(clp);
2436
2437	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2438}
2439
2440static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
2441{
2442	/* FIXME: For now, we destroy all layouts. */
2443	pnfs_destroy_all_layouts(clp);
2444	nfs_test_expired_all_delegations(clp);
2445	dprintk("%s: Recallable state revoked on server %s!\n", __func__,
2446			clp->cl_hostname);
2447}
2448
2449static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
2450{
2451	set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2452	nfs4_schedule_state_manager(clp);
2453
2454	dprintk("%s: server %s declared a backchannel fault\n", __func__,
2455			clp->cl_hostname);
2456}
2457
2458static void nfs41_handle_cb_path_down(struct nfs_client *clp)
2459{
2460	if (test_and_set_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2461		&clp->cl_state) == 0)
2462		nfs4_schedule_state_manager(clp);
2463}
2464
2465void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags,
2466		bool recovery)
2467{
2468	if (!flags)
2469		return;
2470
2471	dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
2472		__func__, clp->cl_hostname, clp->cl_clientid, flags);
2473	/*
2474	 * If we're called from the state manager thread, then assume we're
2475	 * already handling the RECLAIM_NEEDED and/or STATE_REVOKED.
2476	 * Those flags are expected to remain set until we're done
2477	 * recovering (see RFC5661, section 18.46.3).
2478	 */
2479	if (recovery)
2480		goto out_recovery;
2481
2482	if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
2483		nfs41_handle_server_reboot(clp);
2484	if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED))
2485		nfs41_handle_all_state_revoked(clp);
2486	if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
2487			    SEQ4_STATUS_ADMIN_STATE_REVOKED))
2488		nfs41_handle_some_state_revoked(clp);
2489	if (flags & SEQ4_STATUS_LEASE_MOVED)
2490		nfs4_schedule_lease_moved_recovery(clp);
2491	if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
2492		nfs41_handle_recallable_state_revoked(clp);
2493out_recovery:
2494	if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT)
2495		nfs41_handle_backchannel_fault(clp);
2496	else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
2497				SEQ4_STATUS_CB_PATH_DOWN_SESSION))
2498		nfs41_handle_cb_path_down(clp);
2499}
2500
2501static int nfs4_reset_session(struct nfs_client *clp)
2502{
2503	const struct cred *cred;
2504	int status;
2505
2506	if (!nfs4_has_session(clp))
2507		return 0;
2508	status = nfs4_begin_drain_session(clp);
2509	if (status != 0)
2510		return status;
2511	cred = nfs4_get_clid_cred(clp);
2512	status = nfs4_proc_destroy_session(clp->cl_session, cred);
2513	switch (status) {
2514	case 0:
2515	case -NFS4ERR_BADSESSION:
2516	case -NFS4ERR_DEADSESSION:
2517		break;
2518	case -NFS4ERR_BACK_CHAN_BUSY:
2519	case -NFS4ERR_DELAY:
2520		set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2521		status = 0;
2522		ssleep(1);
2523		goto out;
2524	default:
2525		status = nfs4_recovery_handle_error(clp, status);
2526		goto out;
2527	}
2528
2529	memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
2530	status = nfs4_proc_create_session(clp, cred);
2531	if (status) {
2532		dprintk("%s: session reset failed with status %d for server %s!\n",
2533			__func__, status, clp->cl_hostname);
2534		status = nfs4_handle_reclaim_lease_error(clp, status);
2535		goto out;
2536	}
2537	nfs41_finish_session_reset(clp);
2538	dprintk("%s: session reset was successful for server %s!\n",
2539			__func__, clp->cl_hostname);
2540out:
2541	put_cred(cred);
2542	return status;
2543}
2544
2545static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2546{
2547	const struct cred *cred;
2548	int ret;
2549
2550	if (!nfs4_has_session(clp))
2551		return 0;
2552	ret = nfs4_begin_drain_session(clp);
2553	if (ret != 0)
2554		return ret;
2555	cred = nfs4_get_clid_cred(clp);
2556	ret = nfs4_proc_bind_conn_to_session(clp, cred);
2557	put_cred(cred);
2558	clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2559	switch (ret) {
2560	case 0:
2561		dprintk("%s: bind_conn_to_session was successful for server %s!\n",
2562			__func__, clp->cl_hostname);
2563		break;
2564	case -NFS4ERR_DELAY:
2565		ssleep(1);
2566		set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2567		break;
2568	default:
2569		return nfs4_recovery_handle_error(clp, ret);
2570	}
2571	return 0;
2572}
2573
2574static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
2575{
2576	int iomode = 0;
2577
2578	if (test_and_clear_bit(NFS4CLNT_RECALL_ANY_LAYOUT_READ, &clp->cl_state))
2579		iomode += IOMODE_READ;
2580	if (test_and_clear_bit(NFS4CLNT_RECALL_ANY_LAYOUT_RW, &clp->cl_state))
2581		iomode += IOMODE_RW;
2582	/* Note: IOMODE_READ + IOMODE_RW == IOMODE_ANY */
2583	if (iomode) {
2584		pnfs_layout_return_unused_byclid(clp, iomode);
2585		set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
2586	}
2587}
2588#else /* CONFIG_NFS_V4_1 */
2589static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
2590
2591static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2592{
2593	return 0;
2594}
2595
2596static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
2597{
2598}
2599#endif /* CONFIG_NFS_V4_1 */
2600
2601static void nfs4_state_manager(struct nfs_client *clp)
2602{
2603	unsigned int memflags;
2604	int status = 0;
2605	const char *section = "", *section_sep = "";
2606
2607	/*
2608	 * State recovery can deadlock if the direct reclaim code tries
2609	 * start NFS writeback. So ensure memory allocations are all
2610	 * GFP_NOFS.
2611	 */
2612	memflags = memalloc_nofs_save();
2613
2614	/* Ensure exclusive access to NFSv4 state */
2615	do {
2616		trace_nfs4_state_mgr(clp);
2617		clear_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
2618		if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2619			section = "purge state";
2620			status = nfs4_purge_lease(clp);
2621			if (status < 0)
2622				goto out_error;
2623			continue;
2624		}
2625
2626		if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
2627			section = "lease expired";
2628			/* We're going to have to re-establish a clientid */
2629			status = nfs4_reclaim_lease(clp);
2630			if (status < 0)
2631				goto out_error;
2632			continue;
2633		}
2634
2635		/* Initialize or reset the session */
2636		if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) {
2637			section = "reset session";
2638			status = nfs4_reset_session(clp);
2639			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
2640				continue;
2641			if (status < 0)
2642				goto out_error;
2643		}
2644
2645		/* Send BIND_CONN_TO_SESSION */
2646		if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2647				&clp->cl_state)) {
2648			section = "bind conn to session";
2649			status = nfs4_bind_conn_to_session(clp);
2650			if (status < 0)
2651				goto out_error;
2652			continue;
2653		}
2654
2655		if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
2656			section = "check lease";
2657			status = nfs4_check_lease(clp);
2658			if (status < 0)
2659				goto out_error;
2660			continue;
2661		}
2662
2663		if (test_and_clear_bit(NFS4CLNT_MOVED, &clp->cl_state)) {
2664			section = "migration";
2665			status = nfs4_handle_migration(clp);
2666			if (status < 0)
2667				goto out_error;
2668		}
2669
2670		if (test_and_clear_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state)) {
2671			section = "lease moved";
2672			status = nfs4_handle_lease_moved(clp);
2673			if (status < 0)
2674				goto out_error;
2675		}
2676
2677		/* First recover reboot state... */
2678		if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
2679			section = "reclaim reboot";
2680			status = nfs4_do_reclaim(clp,
2681				clp->cl_mvops->reboot_recovery_ops);
2682			if (status == 0)
2683				status = pnfs_layout_handle_reboot(clp);
2684			if (status == -EAGAIN)
2685				continue;
2686			if (status < 0)
2687				goto out_error;
2688			nfs4_state_end_reclaim_reboot(clp);
2689			continue;
2690		}
2691
2692		/* Detect expired delegations... */
2693		if (test_and_clear_bit(NFS4CLNT_DELEGATION_EXPIRED, &clp->cl_state)) {
2694			section = "detect expired delegations";
2695			status = nfs4_begin_drain_session(clp);
2696			if (status < 0)
2697				goto out_error;
2698			nfs_reap_expired_delegations(clp);
2699			continue;
2700		}
2701
2702		/* Now recover expired state... */
2703		if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
2704			section = "reclaim nograce";
2705			status = nfs4_do_reclaim(clp,
2706				clp->cl_mvops->nograce_recovery_ops);
2707			if (status == -EAGAIN)
2708				continue;
2709			if (status < 0)
2710				goto out_error;
2711			clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
2712		}
2713
2714		memalloc_nofs_restore(memflags);
2715		nfs4_end_drain_session(clp);
2716		nfs4_clear_state_manager_bit(clp);
2717
2718		if (test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&
2719		    !test_and_set_bit(NFS4CLNT_MANAGER_RUNNING,
2720				      &clp->cl_state)) {
2721			memflags = memalloc_nofs_save();
2722			continue;
2723		}
2724
2725		if (!test_and_set_bit(NFS4CLNT_RECALL_RUNNING, &clp->cl_state)) {
2726			if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
2727				nfs_client_return_marked_delegations(clp);
2728				set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
2729			}
2730			nfs4_layoutreturn_any_run(clp);
2731			clear_bit(NFS4CLNT_RECALL_RUNNING, &clp->cl_state);
2732		}
2733
2734		return;
2735
2736	} while (refcount_read(&clp->cl_count) > 1 && !signalled());
2737	goto out_drain;
2738
2739out_error:
2740	if (strlen(section))
2741		section_sep = ": ";
2742	trace_nfs4_state_mgr_failed(clp, section, status);
2743	pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
2744			" with error %d\n", section_sep, section,
2745			clp->cl_hostname, -status);
2746	switch (status) {
2747	case -ENETDOWN:
2748	case -ENETUNREACH:
2749		nfs_mark_client_ready(clp, -EIO);
2750		break;
2751	case -EINVAL:
2752		nfs_mark_client_ready(clp, status);
2753		break;
2754	default:
2755		ssleep(1);
2756		break;
2757	}
2758out_drain:
2759	memalloc_nofs_restore(memflags);
2760	nfs4_end_drain_session(clp);
2761	nfs4_clear_state_manager_bit(clp);
2762}
2763
2764static int nfs4_run_state_manager(void *ptr)
2765{
2766	struct nfs_client *clp = ptr;
2767	struct rpc_clnt *cl = clp->cl_rpcclient;
2768
2769	while (cl != cl->cl_parent)
2770		cl = cl->cl_parent;
2771
2772	allow_signal(SIGKILL);
2773again:
2774	nfs4_state_manager(clp);
2775
2776	if (test_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state) &&
2777	    !test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state)) {
2778		wait_var_event_interruptible(&clp->cl_state,
2779					     test_bit(NFS4CLNT_RUN_MANAGER,
2780						      &clp->cl_state));
2781		if (!atomic_read(&cl->cl_swapper))
2782			clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state);
2783		if (refcount_read(&clp->cl_count) > 1 && !signalled() &&
2784		    !test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state))
2785			goto again;
2786		/* Either no longer a swapper, or were signalled */
2787		clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state);
2788	}
2789
2790	if (refcount_read(&clp->cl_count) > 1 && !signalled() &&
2791	    test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&
2792	    !test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state))
2793		goto again;
2794
2795	nfs_put_client(clp);
2796	module_put_and_kthread_exit(0);
2797	return 0;
2798}