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