nfs4state.c 63.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
/*
 *  fs/nfs/nfs4state.c
 *
 *  Client-side XDR for NFSv4.
 *
 *  Copyright (c) 2002 The Regents of the University of Michigan.
 *  All rights reserved.
 *
 *  Kendrick Smith <kmsmith@umich.edu>
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the University nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Implementation of the NFSv4 state model.  For the time being,
 * this is minimal, but will be made much more complex in a
 * subsequent patch.
 */

41
#include <linux/kernel.h>
L
Linus Torvalds 已提交
42
#include <linux/slab.h>
43
#include <linux/fs.h>
L
Linus Torvalds 已提交
44
#include <linux/nfs_fs.h>
45 46
#include <linux/kthread.h>
#include <linux/module.h>
47
#include <linux/random.h>
48
#include <linux/ratelimit.h>
L
Linus Torvalds 已提交
49 50
#include <linux/workqueue.h>
#include <linux/bitops.h>
51
#include <linux/jiffies.h>
L
Linus Torvalds 已提交
52

53 54
#include <linux/sunrpc/clnt.h>

55
#include "nfs4_fs.h"
L
Linus Torvalds 已提交
56 57
#include "callback.h"
#include "delegation.h"
58
#include "internal.h"
59
#include "nfs4idmap.h"
60
#include "nfs4session.h"
61
#include "pnfs.h"
62
#include "netns.h"
L
Linus Torvalds 已提交
63

C
Chuck Lever 已提交
64 65
#define NFSDBG_FACILITY		NFSDBG_STATE

L
Linus Torvalds 已提交
66 67
#define OPENOWNER_POOL_SIZE	8

68
const nfs4_stateid zero_stateid = {
69
	{ .data = { 0 } },
70 71
	.type = NFS4_SPECIAL_STATEID_TYPE,
};
72
static DEFINE_MUTEX(nfs_clid_init_mutex);
L
Linus Torvalds 已提交
73

74
int nfs4_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
L
Linus Torvalds 已提交
75
{
76 77 78 79
	struct nfs4_setclientid_res clid = {
		.clientid = clp->cl_clientid,
		.confirm = clp->cl_confirm,
	};
80 81
	unsigned short port;
	int status;
82
	struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
83

84 85
	if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
		goto do_confirm;
86
	port = nn->nfs_callback_tcpport;
87
	if (clp->cl_addr.ss_family == AF_INET6)
88
		port = nn->nfs_callback_tcpport6;
89

90 91 92
	status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
	if (status != 0)
		goto out;
93 94 95 96
	clp->cl_clientid = clid.clientid;
	clp->cl_confirm = clid.confirm;
	set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
do_confirm:
97 98 99
	status = nfs4_proc_setclientid_confirm(clp, &clid, cred);
	if (status != 0)
		goto out;
100
	clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
101 102
	nfs4_schedule_state_renewal(clp);
out:
L
Linus Torvalds 已提交
103 104 105
	return status;
}

106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
/**
 * nfs40_discover_server_trunking - Detect server IP address trunking (mv0)
 *
 * @clp: nfs_client under test
 * @result: OUT: found nfs_client, or clp
 * @cred: credential to use for trunking test
 *
 * Returns zero, a negative errno, or a negative NFS4ERR status.
 * If zero is returned, an nfs_client pointer is planted in
 * "result".
 *
 * Note: The returned client may not yet be marked ready.
 */
int nfs40_discover_server_trunking(struct nfs_client *clp,
				   struct nfs_client **result,
				   struct rpc_cred *cred)
{
	struct nfs4_setclientid_res clid = {
		.clientid = clp->cl_clientid,
		.confirm = clp->cl_confirm,
	};
127
	struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
128 129 130
	unsigned short port;
	int status;

131
	port = nn->nfs_callback_tcpport;
132
	if (clp->cl_addr.ss_family == AF_INET6)
133
		port = nn->nfs_callback_tcpport6;
134 135 136 137 138 139 140 141

	status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
	if (status != 0)
		goto out;
	clp->cl_clientid = clid.clientid;
	clp->cl_confirm = clid.confirm;

	status = nfs40_walk_client_list(clp, result, cred);
142
	if (status == 0) {
143 144 145 146 147 148 149 150
		/* Sustain the lease, even if it's empty.  If the clientid4
		 * goes stale it's of no use for trunking discovery. */
		nfs4_schedule_state_renewal(*result);
	}
out:
	return status;
}

151
struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp)
152 153 154 155 156 157 158 159
{
	struct rpc_cred *cred = NULL;

	if (clp->cl_machine_cred != NULL)
		cred = get_rpccred(clp->cl_machine_cred);
	return cred;
}

160 161 162 163 164 165 166 167 168 169 170 171 172
static void nfs4_root_machine_cred(struct nfs_client *clp)
{
	struct rpc_cred *cred, *new;

	new = rpc_lookup_machine_cred(NULL);
	spin_lock(&clp->cl_lock);
	cred = clp->cl_machine_cred;
	clp->cl_machine_cred = new;
	spin_unlock(&clp->cl_lock);
	if (cred != NULL)
		put_rpccred(cred);
}

173 174
static struct rpc_cred *
nfs4_get_renew_cred_server_locked(struct nfs_server *server)
175
{
176
	struct rpc_cred *cred = NULL;
177
	struct nfs4_state_owner *sp;
178
	struct rb_node *pos;
179

180 181 182 183
	for (pos = rb_first(&server->state_owners);
	     pos != NULL;
	     pos = rb_next(pos)) {
		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
184 185 186 187 188 189 190 191
		if (list_empty(&sp->so_states))
			continue;
		cred = get_rpccred(sp->so_cred);
		break;
	}
	return cred;
}

192 193 194 195 196 197 198 199 200 201 202 203
/**
 * nfs4_get_renew_cred_locked - Acquire credential for a renew operation
 * @clp: client state handle
 *
 * Returns an rpc_cred with reference count bumped, or NULL.
 * Caller must hold clp->cl_lock.
 */
struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp)
{
	struct rpc_cred *cred = NULL;
	struct nfs_server *server;

204 205 206 207 208
	/* Use machine credentials if available */
	cred = nfs4_get_machine_cred_locked(clp);
	if (cred != NULL)
		goto out;

209 210 211 212 213 214 215
	rcu_read_lock();
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
		cred = nfs4_get_renew_cred_server_locked(server);
		if (cred != NULL)
			break;
	}
	rcu_read_unlock();
216 217

out:
218 219 220
	return cred;
}

221
static void nfs4_end_drain_slot_table(struct nfs4_slot_table *tbl)
222
{
223
	if (test_and_clear_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
224
		spin_lock(&tbl->slot_tbl_lock);
225
		nfs41_wake_slot_table(tbl);
226
		spin_unlock(&tbl->slot_tbl_lock);
227
	}
228 229
}

230 231 232 233
static void nfs4_end_drain_session(struct nfs_client *clp)
{
	struct nfs4_session *ses = clp->cl_session;

234 235 236 237 238
	if (clp->cl_slot_tbl) {
		nfs4_end_drain_slot_table(clp->cl_slot_tbl);
		return;
	}

239 240 241 242 243 244
	if (ses != NULL) {
		nfs4_end_drain_slot_table(&ses->bc_slot_table);
		nfs4_end_drain_slot_table(&ses->fc_slot_table);
	}
}

245
static int nfs4_drain_slot_tbl(struct nfs4_slot_table *tbl)
246
{
247
	set_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state);
248
	spin_lock(&tbl->slot_tbl_lock);
249
	if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
250
		reinit_completion(&tbl->complete);
251
		spin_unlock(&tbl->slot_tbl_lock);
252
		return wait_for_completion_interruptible(&tbl->complete);
253 254 255 256 257
	}
	spin_unlock(&tbl->slot_tbl_lock);
	return 0;
}

258 259 260 261 262
static int nfs4_begin_drain_session(struct nfs_client *clp)
{
	struct nfs4_session *ses = clp->cl_session;
	int ret = 0;

263 264 265
	if (clp->cl_slot_tbl)
		return nfs4_drain_slot_tbl(clp->cl_slot_tbl);

266
	/* back channel */
267
	ret = nfs4_drain_slot_tbl(&ses->bc_slot_table);
268 269 270
	if (ret)
		return ret;
	/* fore channel */
271
	return nfs4_drain_slot_tbl(&ses->fc_slot_table);
272 273
}

274 275
#if defined(CONFIG_NFS_V4_1)

276 277 278 279
static int nfs41_setup_state_renewal(struct nfs_client *clp)
{
	int status;
	struct nfs_fsinfo fsinfo;
280
	unsigned long now;
281 282 283 284 285 286

	if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
		nfs4_schedule_state_renewal(clp);
		return 0;
	}

287
	now = jiffies;
288 289
	status = nfs4_proc_get_lease_time(clp, &fsinfo);
	if (status == 0) {
290
		nfs4_set_lease_period(clp, fsinfo.lease_time * HZ, now);
291 292 293 294 295 296
		nfs4_schedule_state_renewal(clp);
	}

	return status;
}

297 298 299 300 301 302 303 304 305
static void nfs41_finish_session_reset(struct nfs_client *clp)
{
	clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
	clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
	/* create_session negotiated new slot table */
	clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
	nfs41_setup_state_renewal(clp);
}

306 307 308 309
int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
{
	int status;

310 311
	if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
		goto do_confirm;
312
	status = nfs4_proc_exchange_id(clp, cred);
R
Ricardo Labiaga 已提交
313 314
	if (status != 0)
		goto out;
315 316
	set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
do_confirm:
317
	status = nfs4_proc_create_session(clp, cred);
R
Ricardo Labiaga 已提交
318 319
	if (status != 0)
		goto out;
320
	nfs41_finish_session_reset(clp);
R
Ricardo Labiaga 已提交
321 322
	nfs_mark_client_ready(clp, NFS_CS_READY);
out:
323 324 325
	return status;
}

326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
/**
 * nfs41_discover_server_trunking - Detect server IP address trunking (mv1)
 *
 * @clp: nfs_client under test
 * @result: OUT: found nfs_client, or clp
 * @cred: credential to use for trunking test
 *
 * Returns NFS4_OK, a negative errno, or a negative NFS4ERR status.
 * If NFS4_OK is returned, an nfs_client pointer is planted in
 * "result".
 *
 * Note: The returned client may not yet be marked ready.
 */
int nfs41_discover_server_trunking(struct nfs_client *clp,
				   struct nfs_client **result,
				   struct rpc_cred *cred)
{
	int status;

	status = nfs4_proc_exchange_id(clp, cred);
	if (status != NFS4_OK)
		return status;

349 350 351 352 353 354
	status = nfs41_walk_client_list(clp, result, cred);
	if (status < 0)
		return status;
	if (clp != *result)
		return 0;

355 356 357 358 359
	/* Purge state if the client id was established in a prior instance */
	if (clp->cl_exchange_flags & EXCHGID4_FLAG_CONFIRMED_R)
		set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
	else
		set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
360 361 362 363 364
	nfs4_schedule_state_manager(clp);
	status = nfs_wait_client_init_complete(clp);
	if (status < 0)
		nfs_put_client(clp);
	return status;
365 366
}

367 368
#endif /* CONFIG_NFS_V4_1 */

369
/**
370
 * nfs4_get_clid_cred - Acquire credential for a setclientid operation
371 372 373 374
 * @clp: client state handle
 *
 * Returns an rpc_cred with reference count bumped, or NULL.
 */
375
struct rpc_cred *nfs4_get_clid_cred(struct nfs_client *clp)
376
{
377
	struct rpc_cred *cred;
378

379 380
	spin_lock(&clp->cl_lock);
	cred = nfs4_get_machine_cred_locked(clp);
381
	spin_unlock(&clp->cl_lock);
382
	return cred;
383 384
}

L
Linus Torvalds 已提交
385
static struct nfs4_state_owner *
386
nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred)
L
Linus Torvalds 已提交
387
{
388
	struct rb_node **p = &server->state_owners.rb_node,
389
		       *parent = NULL;
390
	struct nfs4_state_owner *sp;
L
Linus Torvalds 已提交
391

392 393
	while (*p != NULL) {
		parent = *p;
394
		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
395 396 397 398 399 400

		if (cred < sp->so_cred)
			p = &parent->rb_left;
		else if (cred > sp->so_cred)
			p = &parent->rb_right;
		else {
401 402
			if (!list_empty(&sp->so_lru))
				list_del_init(&sp->so_lru);
403
			atomic_inc(&sp->so_count);
404
			return sp;
405
		}
L
Linus Torvalds 已提交
406
	}
407
	return NULL;
L
Linus Torvalds 已提交
408 409
}

410
static struct nfs4_state_owner *
411
nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
412
{
413 414
	struct nfs_server *server = new->so_server;
	struct rb_node **p = &server->state_owners.rb_node,
415 416
		       *parent = NULL;
	struct nfs4_state_owner *sp;
417
	int err;
418 419 420

	while (*p != NULL) {
		parent = *p;
421
		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
422 423 424 425 426 427

		if (new->so_cred < sp->so_cred)
			p = &parent->rb_left;
		else if (new->so_cred > sp->so_cred)
			p = &parent->rb_right;
		else {
428 429
			if (!list_empty(&sp->so_lru))
				list_del_init(&sp->so_lru);
430 431 432 433
			atomic_inc(&sp->so_count);
			return sp;
		}
	}
434
	err = ida_get_new(&server->openowner_id, &new->so_seqid.owner_id);
435 436
	if (err)
		return ERR_PTR(err);
437 438
	rb_link_node(&new->so_server_node, parent, p);
	rb_insert_color(&new->so_server_node, &server->state_owners);
439 440 441 442
	return new;
}

static void
443
nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
444
{
445 446 447 448
	struct nfs_server *server = sp->so_server;

	if (!RB_EMPTY_NODE(&sp->so_server_node))
		rb_erase(&sp->so_server_node, &server->state_owners);
449
	ida_remove(&server->openowner_id, sp->so_seqid.owner_id);
450 451
}

452 453 454
static void
nfs4_init_seqid_counter(struct nfs_seqid_counter *sc)
{
455
	sc->create_time = ktime_get();
456 457 458 459 460 461 462 463 464 465 466 467 468
	sc->flags = 0;
	sc->counter = 0;
	spin_lock_init(&sc->lock);
	INIT_LIST_HEAD(&sc->list);
	rpc_init_wait_queue(&sc->wait, "Seqid_waitqueue");
}

static void
nfs4_destroy_seqid_counter(struct nfs_seqid_counter *sc)
{
	rpc_destroy_wait_queue(&sc->wait);
}

L
Linus Torvalds 已提交
469 470 471 472 473 474
/*
 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
 * create a new state_owner.
 *
 */
static struct nfs4_state_owner *
475 476 477
nfs4_alloc_state_owner(struct nfs_server *server,
		struct rpc_cred *cred,
		gfp_t gfp_flags)
L
Linus Torvalds 已提交
478 479 480
{
	struct nfs4_state_owner *sp;

481
	sp = kzalloc(sizeof(*sp), gfp_flags);
L
Linus Torvalds 已提交
482 483
	if (!sp)
		return NULL;
484 485
	sp->so_server = server;
	sp->so_cred = get_rpccred(cred);
486
	spin_lock_init(&sp->so_lock);
L
Linus Torvalds 已提交
487
	INIT_LIST_HEAD(&sp->so_states);
488
	nfs4_init_seqid_counter(&sp->so_seqid);
L
Linus Torvalds 已提交
489
	atomic_set(&sp->so_count, 1);
490
	INIT_LIST_HEAD(&sp->so_lru);
491
	seqcount_init(&sp->so_reclaim_seqcount);
492
	mutex_init(&sp->so_delegreturn_mutex);
L
Linus Torvalds 已提交
493 494 495
	return sp;
}

496
static void
L
Linus Torvalds 已提交
497 498
nfs4_drop_state_owner(struct nfs4_state_owner *sp)
{
499 500 501
	struct rb_node *rb_node = &sp->so_server_node;

	if (!RB_EMPTY_NODE(rb_node)) {
502 503
		struct nfs_server *server = sp->so_server;
		struct nfs_client *clp = server->nfs_client;
504 505

		spin_lock(&clp->cl_lock);
506 507 508 509
		if (!RB_EMPTY_NODE(rb_node)) {
			rb_erase(rb_node, &server->state_owners);
			RB_CLEAR_NODE(rb_node);
		}
510 511
		spin_unlock(&clp->cl_lock);
	}
L
Linus Torvalds 已提交
512 513
}

514 515
static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
{
516
	nfs4_destroy_seqid_counter(&sp->so_seqid);
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
	put_rpccred(sp->so_cred);
	kfree(sp);
}

static void nfs4_gc_state_owners(struct nfs_server *server)
{
	struct nfs_client *clp = server->nfs_client;
	struct nfs4_state_owner *sp, *tmp;
	unsigned long time_min, time_max;
	LIST_HEAD(doomed);

	spin_lock(&clp->cl_lock);
	time_max = jiffies;
	time_min = (long)time_max - (long)clp->cl_lease_time;
	list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
		/* NB: LRU is sorted so that oldest is at the head */
		if (time_in_range(sp->so_expires, time_min, time_max))
			break;
		list_move(&sp->so_lru, &doomed);
		nfs4_remove_state_owner_locked(sp);
	}
	spin_unlock(&clp->cl_lock);

	list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
		list_del(&sp->so_lru);
		nfs4_free_state_owner(sp);
	}
}

546 547 548 549 550 551 552 553
/**
 * nfs4_get_state_owner - Look up a state owner given a credential
 * @server: nfs_server to search
 * @cred: RPC credential to match
 *
 * Returns a pointer to an instantiated nfs4_state_owner struct, or NULL.
 */
struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,
554 555
					      struct rpc_cred *cred,
					      gfp_t gfp_flags)
L
Linus Torvalds 已提交
556
{
557
	struct nfs_client *clp = server->nfs_client;
L
Linus Torvalds 已提交
558 559 560
	struct nfs4_state_owner *sp, *new;

	spin_lock(&clp->cl_lock);
561
	sp = nfs4_find_state_owner_locked(server, cred);
L
Linus Torvalds 已提交
562 563
	spin_unlock(&clp->cl_lock);
	if (sp != NULL)
564
		goto out;
565
	new = nfs4_alloc_state_owner(server, cred, gfp_flags);
566
	if (new == NULL)
567
		goto out;
568 569 570 571 572 573 574
	do {
		if (ida_pre_get(&server->openowner_id, gfp_flags) == 0)
			break;
		spin_lock(&clp->cl_lock);
		sp = nfs4_insert_state_owner_locked(new);
		spin_unlock(&clp->cl_lock);
	} while (sp == ERR_PTR(-EAGAIN));
575 576
	if (sp != new)
		nfs4_free_state_owner(new);
577 578
out:
	nfs4_gc_state_owners(server);
579
	return sp;
L
Linus Torvalds 已提交
580 581
}

582 583 584
/**
 * nfs4_put_state_owner - Release a nfs4_state_owner
 * @sp: state owner data to release
585 586 587 588 589 590 591 592
 *
 * Note that we keep released state owners on an LRU
 * list.
 * This caches valid state owners so that they can be
 * reused, to avoid the OPEN_CONFIRM on minor version 0.
 * It also pins the uniquifier of dropped state owners for
 * a while, to ensure that those state owner names are
 * never reused.
593
 */
L
Linus Torvalds 已提交
594 595
void nfs4_put_state_owner(struct nfs4_state_owner *sp)
{
596 597
	struct nfs_server *server = sp->so_server;
	struct nfs_client *clp = server->nfs_client;
L
Linus Torvalds 已提交
598 599 600

	if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
		return;
601

602 603 604
	sp->so_expires = jiffies;
	list_add_tail(&sp->so_lru, &server->state_owners_lru);
	spin_unlock(&clp->cl_lock);
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624
}

/**
 * nfs4_purge_state_owners - Release all cached state owners
 * @server: nfs_server with cached state owners to release
 *
 * Called at umount time.  Remaining state owners will be on
 * the LRU with ref count of zero.
 */
void nfs4_purge_state_owners(struct nfs_server *server)
{
	struct nfs_client *clp = server->nfs_client;
	struct nfs4_state_owner *sp, *tmp;
	LIST_HEAD(doomed);

	spin_lock(&clp->cl_lock);
	list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
		list_move(&sp->so_lru, &doomed);
		nfs4_remove_state_owner_locked(sp);
	}
L
Linus Torvalds 已提交
625
	spin_unlock(&clp->cl_lock);
626 627 628 629 630

	list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
		list_del(&sp->so_lru);
		nfs4_free_state_owner(sp);
	}
L
Linus Torvalds 已提交
631 632 633 634 635 636 637
}

static struct nfs4_state *
nfs4_alloc_open_state(void)
{
	struct nfs4_state *state;

638
	state = kzalloc(sizeof(*state), GFP_NOFS);
L
Linus Torvalds 已提交
639 640 641 642
	if (!state)
		return NULL;
	atomic_set(&state->count, 1);
	INIT_LIST_HEAD(&state->lock_states);
643
	spin_lock_init(&state->state_lock);
644
	seqlock_init(&state->seqlock);
L
Linus Torvalds 已提交
645 646 647
	return state;
}

648
void
649
nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
650
{
651
	if (state->state == fmode)
652 653
		return;
	/* NB! List reordering - see the reclaim code for why.  */
654 655
	if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
		if (fmode & FMODE_WRITE)
656 657 658 659
			list_move(&state->open_states, &state->owner->so_states);
		else
			list_move_tail(&state->open_states, &state->owner->so_states);
	}
660
	state->state = fmode;
661 662
}

L
Linus Torvalds 已提交
663 664 665 666 667 668 669
static struct nfs4_state *
__nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
{
	struct nfs_inode *nfsi = NFS_I(inode);
	struct nfs4_state *state;

	list_for_each_entry(state, &nfsi->open_states, inode_states) {
670
		if (state->owner != owner)
L
Linus Torvalds 已提交
671
			continue;
672 673
		if (!nfs4_valid_open_stateid(state))
			continue;
674
		if (atomic_inc_not_zero(&state->count))
L
Linus Torvalds 已提交
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
			return state;
	}
	return NULL;
}

static void
nfs4_free_open_state(struct nfs4_state *state)
{
	kfree(state);
}

struct nfs4_state *
nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner)
{
	struct nfs4_state *state, *new;
	struct nfs_inode *nfsi = NFS_I(inode);

	spin_lock(&inode->i_lock);
	state = __nfs4_find_state_byowner(inode, owner);
	spin_unlock(&inode->i_lock);
	if (state)
		goto out;
	new = nfs4_alloc_open_state();
698
	spin_lock(&owner->so_lock);
L
Linus Torvalds 已提交
699 700 701 702 703 704 705
	spin_lock(&inode->i_lock);
	state = __nfs4_find_state_byowner(inode, owner);
	if (state == NULL && new != NULL) {
		state = new;
		state->owner = owner;
		atomic_inc(&owner->so_count);
		list_add(&state->inode_states, &nfsi->open_states);
706 707
		ihold(inode);
		state->inode = inode;
L
Linus Torvalds 已提交
708
		spin_unlock(&inode->i_lock);
709 710 711 712
		/* Note: The reclaim code dictates that we add stateless
		 * and read-only stateids to the end of the list */
		list_add_tail(&state->open_states, &owner->so_states);
		spin_unlock(&owner->so_lock);
L
Linus Torvalds 已提交
713 714
	} else {
		spin_unlock(&inode->i_lock);
715
		spin_unlock(&owner->so_lock);
L
Linus Torvalds 已提交
716 717 718 719 720 721 722 723 724 725 726 727
		if (new)
			nfs4_free_open_state(new);
	}
out:
	return state;
}

void nfs4_put_open_state(struct nfs4_state *state)
{
	struct inode *inode = state->inode;
	struct nfs4_state_owner *owner = state->owner;

728
	if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
L
Linus Torvalds 已提交
729
		return;
730
	spin_lock(&inode->i_lock);
731
	list_del(&state->inode_states);
L
Linus Torvalds 已提交
732
	list_del(&state->open_states);
733 734
	spin_unlock(&inode->i_lock);
	spin_unlock(&owner->so_lock);
L
Linus Torvalds 已提交
735 736 737 738 739 740
	iput(inode);
	nfs4_free_open_state(state);
	nfs4_put_state_owner(owner);
}

/*
741
 * Close the current file.
L
Linus Torvalds 已提交
742
 */
743
static void __nfs4_close(struct nfs4_state *state,
744
		fmode_t fmode, gfp_t gfp_mask, int wait)
L
Linus Torvalds 已提交
745 746
{
	struct nfs4_state_owner *owner = state->owner;
747
	int call_close = 0;
748
	fmode_t newstate;
L
Linus Torvalds 已提交
749 750 751

	atomic_inc(&owner->so_count);
	/* Protect against nfs4_find_state() */
752
	spin_lock(&owner->so_lock);
753
	switch (fmode & (FMODE_READ | FMODE_WRITE)) {
754 755 756 757 758 759 760 761 762
		case FMODE_READ:
			state->n_rdonly--;
			break;
		case FMODE_WRITE:
			state->n_wronly--;
			break;
		case FMODE_READ|FMODE_WRITE:
			state->n_rdwr--;
	}
763
	newstate = FMODE_READ|FMODE_WRITE;
764
	if (state->n_rdwr == 0) {
765
		if (state->n_rdonly == 0) {
766
			newstate &= ~FMODE_READ;
767 768 769 770
			call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
			call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
		}
		if (state->n_wronly == 0) {
771
			newstate &= ~FMODE_WRITE;
772 773 774 775 776
			call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
			call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
		}
		if (newstate == 0)
			clear_bit(NFS_DELEGATED_STATE, &state->flags);
777
	}
778
	nfs4_state_set_mode_locked(state, newstate);
779
	spin_unlock(&owner->so_lock);
780

781
	if (!call_close) {
782 783
		nfs4_put_open_state(state);
		nfs4_put_state_owner(owner);
784 785
	} else
		nfs4_do_close(state, gfp_mask, wait);
786 787
}

788
void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
789
{
790
	__nfs4_close(state, fmode, GFP_NOFS, 0);
791 792
}

793
void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
794
{
795
	__nfs4_close(state, fmode, GFP_KERNEL, 1);
L
Linus Torvalds 已提交
796 797 798 799 800 801 802
}

/*
 * Search the state->lock_states for an existing lock_owner
 * that is compatible with current->files
 */
static struct nfs4_lock_state *
803
__nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
L
Linus Torvalds 已提交
804 805 806
{
	struct nfs4_lock_state *pos;
	list_for_each_entry(pos, &state->lock_states, ls_locks) {
807
		if (pos->ls_owner != fl_owner)
L
Linus Torvalds 已提交
808 809 810 811 812 813 814 815 816 817 818 819
			continue;
		atomic_inc(&pos->ls_count);
		return pos;
	}
	return NULL;
}

/*
 * Return a compatible lock_state. If no initialized lock_state structure
 * exists, return an uninitialized one.
 *
 */
820
static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
L
Linus Torvalds 已提交
821 822
{
	struct nfs4_lock_state *lsp;
823
	struct nfs_server *server = state->owner->so_server;
L
Linus Torvalds 已提交
824

825
	lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
L
Linus Torvalds 已提交
826 827
	if (lsp == NULL)
		return NULL;
828
	nfs4_init_seqid_counter(&lsp->ls_seqid);
L
Linus Torvalds 已提交
829
	atomic_set(&lsp->ls_count, 1);
830
	lsp->ls_state = state;
831
	lsp->ls_owner = fl_owner;
832 833
	lsp->ls_seqid.owner_id = ida_simple_get(&server->lockowner_id, 0, 0, GFP_NOFS);
	if (lsp->ls_seqid.owner_id < 0)
834
		goto out_free;
835
	INIT_LIST_HEAD(&lsp->ls_locks);
L
Linus Torvalds 已提交
836
	return lsp;
837 838 839
out_free:
	kfree(lsp);
	return NULL;
L
Linus Torvalds 已提交
840 841
}

842
void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
843
{
844
	ida_simple_remove(&server->lockowner_id, lsp->ls_seqid.owner_id);
845
	nfs4_destroy_seqid_counter(&lsp->ls_seqid);
846 847 848
	kfree(lsp);
}

L
Linus Torvalds 已提交
849 850 851 852 853
/*
 * Return a compatible lock_state. If no initialized lock_state structure
 * exists, return an uninitialized one.
 *
 */
854
static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner)
L
Linus Torvalds 已提交
855
{
856
	struct nfs4_lock_state *lsp, *new = NULL;
L
Linus Torvalds 已提交
857
	
858 859
	for(;;) {
		spin_lock(&state->state_lock);
860
		lsp = __nfs4_find_lock_state(state, owner);
861 862 863 864 865 866 867 868 869 870
		if (lsp != NULL)
			break;
		if (new != NULL) {
			list_add(&new->ls_locks, &state->lock_states);
			set_bit(LK_STATE_IN_USE, &state->flags);
			lsp = new;
			new = NULL;
			break;
		}
		spin_unlock(&state->state_lock);
871
		new = nfs4_alloc_lock_state(state, owner);
872 873 874 875
		if (new == NULL)
			return NULL;
	}
	spin_unlock(&state->state_lock);
876
	if (new != NULL)
877
		nfs4_free_lock_state(state->owner->so_server, new);
L
Linus Torvalds 已提交
878 879 880 881
	return lsp;
}

/*
882 883
 * Release reference to lock_state, and free it if we see that
 * it is no longer in use
L
Linus Torvalds 已提交
884
 */
885
void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
L
Linus Torvalds 已提交
886
{
887
	struct nfs_server *server;
888
	struct nfs4_state *state;
L
Linus Torvalds 已提交
889

890 891 892 893 894 895 896 897 898
	if (lsp == NULL)
		return;
	state = lsp->ls_state;
	if (!atomic_dec_and_lock(&lsp->ls_count, &state->state_lock))
		return;
	list_del(&lsp->ls_locks);
	if (list_empty(&state->lock_states))
		clear_bit(LK_STATE_IN_USE, &state->flags);
	spin_unlock(&state->state_lock);
899 900 901 902 903 904
	server = state->owner->so_server;
	if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
		struct nfs_client *clp = server->nfs_client;

		clp->cl_mvops->free_lock_state(server, lsp);
	} else
905
		nfs4_free_lock_state(server, lsp);
L
Linus Torvalds 已提交
906 907
}

908
static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
L
Linus Torvalds 已提交
909
{
910
	struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
L
Linus Torvalds 已提交
911

912 913 914
	dst->fl_u.nfs4_fl.owner = lsp;
	atomic_inc(&lsp->ls_count);
}
L
Linus Torvalds 已提交
915

916
static void nfs4_fl_release_lock(struct file_lock *fl)
L
Linus Torvalds 已提交
917
{
918
	nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
L
Linus Torvalds 已提交
919 920
}

921
static const struct file_lock_operations nfs4_fl_lock_ops = {
922 923 924 925 926
	.fl_copy_lock = nfs4_fl_copy_lock,
	.fl_release_private = nfs4_fl_release_lock,
};

int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
L
Linus Torvalds 已提交
927
{
928 929 930 931
	struct nfs4_lock_state *lsp;

	if (fl->fl_ops != NULL)
		return 0;
932
	lsp = nfs4_get_lock_state(state, fl->fl_owner);
933 934 935 936 937
	if (lsp == NULL)
		return -ENOMEM;
	fl->fl_u.nfs4_fl.owner = lsp;
	fl->fl_ops = &nfs4_fl_lock_ops;
	return 0;
L
Linus Torvalds 已提交
938 939
}

940 941
static int nfs4_copy_lock_stateid(nfs4_stateid *dst,
		struct nfs4_state *state,
942
		const struct nfs_lockowner *lockowner)
L
Linus Torvalds 已提交
943
{
944
	struct nfs4_lock_state *lsp;
945
	fl_owner_t fl_owner;
946
	int ret = -ENOENT;
L
Linus Torvalds 已提交
947

948 949 950 951

	if (lockowner == NULL)
		goto out;

952
	if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
953
		goto out;
L
Linus Torvalds 已提交
954

955
	fl_owner = lockowner->l_owner;
956
	spin_lock(&state->state_lock);
957
	lsp = __nfs4_find_lock_state(state, fl_owner);
958 959 960
	if (lsp && test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
		ret = -EIO;
	else if (lsp != NULL && test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) {
961
		nfs4_stateid_copy(dst, &lsp->ls_stateid);
962
		ret = 0;
963
	}
964
	spin_unlock(&state->state_lock);
L
Linus Torvalds 已提交
965
	nfs4_put_lock_state(lsp);
966 967 968 969
out:
	return ret;
}

970
static void nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
971
{
972
	const nfs4_stateid *src;
973 974 975
	int seq;

	do {
976
		src = &zero_stateid;
977
		seq = read_seqbegin(&state->seqlock);
978 979 980
		if (test_bit(NFS_OPEN_STATE, &state->flags))
			src = &state->open_stateid;
		nfs4_stateid_copy(dst, src);
981 982 983 984 985 986 987
	} while (read_seqretry(&state->seqlock, seq));
}

/*
 * Byte-range lock aware utility to initialize the stateid of read/write
 * requests.
 */
988 989 990
int nfs4_select_rw_stateid(struct nfs4_state *state,
		fmode_t fmode, const struct nfs_lockowner *lockowner,
		nfs4_stateid *dst, struct rpc_cred **cred)
991
{
992 993 994 995 996
	int ret;

	if (cred != NULL)
		*cred = NULL;
	ret = nfs4_copy_lock_stateid(dst, state, lockowner);
997 998 999
	if (ret == -EIO)
		/* A lost lock - don't even consider delegations */
		goto out;
1000
	/* returns true if delegation stateid found and copied */
1001
	if (nfs4_copy_delegation_stateid(state->inode, fmode, dst, cred)) {
1002
		ret = 0;
1003
		goto out;
1004
	}
1005
	if (ret != -ENOENT)
1006 1007 1008 1009
		/* nfs4_copy_delegation_stateid() didn't over-write
		 * dst, so it still has the lock stateid which we now
		 * choose to use.
		 */
1010
		goto out;
1011 1012
	nfs4_copy_open_stateid(dst, state);
	ret = 0;
1013
out:
1014 1015
	if (nfs_server_capable(state->inode, NFS_CAP_STATEID_NFSV41))
		dst->seqid = 0;
1016
	return ret;
L
Linus Torvalds 已提交
1017 1018
}

1019
struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
1020 1021 1022
{
	struct nfs_seqid *new;

1023
	new = kmalloc(sizeof(*new), gfp_mask);
1024 1025 1026 1027 1028
	if (new == NULL)
		return ERR_PTR(-ENOMEM);
	new->sequence = counter;
	INIT_LIST_HEAD(&new->list);
	new->task = NULL;
1029 1030 1031
	return new;
}

1032
void nfs_release_seqid(struct nfs_seqid *seqid)
L
Linus Torvalds 已提交
1033
{
1034
	struct nfs_seqid_counter *sequence;
1035

1036
	if (seqid == NULL || list_empty(&seqid->list))
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
		return;
	sequence = seqid->sequence;
	spin_lock(&sequence->lock);
	list_del_init(&seqid->list);
	if (!list_empty(&sequence->list)) {
		struct nfs_seqid *next;

		next = list_first_entry(&sequence->list,
				struct nfs_seqid, list);
		rpc_wake_up_queued_task(&sequence->wait, next->task);
1047
	}
1048
	spin_unlock(&sequence->lock);
1049 1050 1051 1052 1053
}

void nfs_free_seqid(struct nfs_seqid *seqid)
{
	nfs_release_seqid(seqid);
1054
	kfree(seqid);
L
Linus Torvalds 已提交
1055 1056 1057
}

/*
1058 1059
 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
 * failed with a seqid incrementing error -
1060
 * see comments nfs4.h:seqid_mutating_error()
1061
 */
1062
static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
1063 1064 1065 1066 1067
{
	switch (status) {
		case 0:
			break;
		case -NFS4ERR_BAD_SEQID:
1068 1069
			if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
				return;
1070
			pr_warn_ratelimited("NFS: v4 server returned a bad"
D
Dan Muntz 已提交
1071 1072
					" sequence-id error on an"
					" unconfirmed sequence %p!\n",
1073
					seqid->sequence);
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
		case -NFS4ERR_STALE_CLIENTID:
		case -NFS4ERR_STALE_STATEID:
		case -NFS4ERR_BAD_STATEID:
		case -NFS4ERR_BADXDR:
		case -NFS4ERR_RESOURCE:
		case -NFS4ERR_NOFILEHANDLE:
			/* Non-seqid mutating errors */
			return;
	};
	/*
	 * Note: no locking needed as we are guaranteed to be first
	 * on the sequence list
	 */
	seqid->sequence->counter++;
}

void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
{
1092 1093 1094 1095
	struct nfs4_state_owner *sp;

	if (seqid == NULL)
		return;
1096

1097
	sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid);
1098
	if (status == -NFS4ERR_BAD_SEQID)
L
Linus Torvalds 已提交
1099
		nfs4_drop_state_owner(sp);
1100
	if (!nfs4_has_session(sp->so_server->nfs_client))
1101
		nfs_increment_seqid(status, seqid);
1102 1103 1104 1105 1106
}

/*
 * Increment the seqid if the LOCK/LOCKU succeeded, or
 * failed with a seqid incrementing error -
1107
 * see comments nfs4.h:seqid_mutating_error()
1108 1109 1110
 */
void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
{
1111 1112
	if (seqid != NULL)
		nfs_increment_seqid(status, seqid);
1113 1114 1115 1116
}

int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
{
1117
	struct nfs_seqid_counter *sequence;
1118 1119
	int status = 0;

1120 1121 1122
	if (seqid == NULL)
		goto out;
	sequence = seqid->sequence;
1123
	spin_lock(&sequence->lock);
1124
	seqid->task = task;
1125 1126 1127 1128
	if (list_empty(&seqid->list))
		list_add_tail(&seqid->list, &sequence->list);
	if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid)
		goto unlock;
1129
	rpc_sleep_on(&sequence->wait, task, NULL);
1130 1131
	status = -EAGAIN;
unlock:
1132
	spin_unlock(&sequence->lock);
1133
out:
1134
	return status;
L
Linus Torvalds 已提交
1135 1136
}

1137
static int nfs4_run_state_manager(void *);
L
Linus Torvalds 已提交
1138

1139
static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
T
Trond Myklebust 已提交
1140
{
1141
	smp_mb__before_atomic();
1142
	clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
1143
	smp_mb__after_atomic();
1144
	wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
T
Trond Myklebust 已提交
1145 1146 1147
	rpc_wake_up(&clp->cl_rpcwaitq);
}

L
Linus Torvalds 已提交
1148
/*
1149
 * Schedule the nfs_client asynchronous state management routine
L
Linus Torvalds 已提交
1150
 */
1151
void nfs4_schedule_state_manager(struct nfs_client *clp)
L
Linus Torvalds 已提交
1152
{
1153
	struct task_struct *task;
1154
	char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
L
Linus Torvalds 已提交
1155

1156 1157
	if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
		return;
1158 1159
	__module_get(THIS_MODULE);
	atomic_inc(&clp->cl_count);
1160 1161 1162 1163 1164 1165 1166 1167

	/* The rcu_read_lock() is not strictly necessary, as the state
	 * manager is the only thread that ever changes the rpc_xprt
	 * after it's initialized.  At this point, we're single threaded. */
	rcu_read_lock();
	snprintf(buf, sizeof(buf), "%s-manager",
			rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
	rcu_read_unlock();
1168
	task = kthread_run(nfs4_run_state_manager, clp, "%s", buf);
1169 1170 1171 1172 1173 1174 1175
	if (IS_ERR(task)) {
		printk(KERN_ERR "%s: kthread_run: %ld\n",
			__func__, PTR_ERR(task));
		nfs4_clear_state_manager_bit(clp);
		nfs_put_client(clp);
		module_put(THIS_MODULE);
	}
L
Linus Torvalds 已提交
1176 1177 1178
}

/*
1179
 * Schedule a lease recovery attempt
L
Linus Torvalds 已提交
1180
 */
1181
void nfs4_schedule_lease_recovery(struct nfs_client *clp)
L
Linus Torvalds 已提交
1182 1183 1184
{
	if (!clp)
		return;
1185 1186
	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1187 1188
	dprintk("%s: scheduling lease recovery for server %s\n", __func__,
			clp->cl_hostname);
1189
	nfs4_schedule_state_manager(clp);
L
Linus Torvalds 已提交
1190
}
A
Andy Adamson 已提交
1191
EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
L
Linus Torvalds 已提交
1192

1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
/**
 * nfs4_schedule_migration_recovery - trigger migration recovery
 *
 * @server: FSID that is migrating
 *
 * Returns zero if recovery has started, otherwise a negative NFS4ERR
 * value is returned.
 */
int nfs4_schedule_migration_recovery(const struct nfs_server *server)
{
	struct nfs_client *clp = server->nfs_client;

	if (server->fh_expire_type != NFS4_FH_PERSISTENT) {
		pr_err("NFS: volatile file handles not supported (server %s)\n",
				clp->cl_hostname);
		return -NFS4ERR_IO;
	}

	if (test_bit(NFS_MIG_FAILED, &server->mig_status))
		return -NFS4ERR_IO;

	dprintk("%s: scheduling migration recovery for (%llx:%llx) on %s\n",
			__func__,
			(unsigned long long)server->fsid.major,
			(unsigned long long)server->fsid.minor,
			clp->cl_hostname);

	set_bit(NFS_MIG_IN_TRANSITION,
			&((struct nfs_server *)server)->mig_status);
	set_bit(NFS4CLNT_MOVED, &clp->cl_state);

	nfs4_schedule_state_manager(clp);
	return 0;
}
EXPORT_SYMBOL_GPL(nfs4_schedule_migration_recovery);

1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
/**
 * nfs4_schedule_lease_moved_recovery - start lease-moved recovery
 *
 * @clp: server to check for moved leases
 *
 */
void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp)
{
	dprintk("%s: scheduling lease-moved recovery for client ID %llx on %s\n",
		__func__, clp->cl_clientid, clp->cl_hostname);

	set_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state);
	nfs4_schedule_state_manager(clp);
}
EXPORT_SYMBOL_GPL(nfs4_schedule_lease_moved_recovery);

1245 1246 1247 1248 1249 1250
int nfs4_wait_clnt_recover(struct nfs_client *clp)
{
	int res;

	might_sleep();

1251
	atomic_inc(&clp->cl_count);
1252 1253
	res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
				 nfs_wait_bit_killable, TASK_KILLABLE);
1254
	if (res)
1255
		goto out;
1256
	if (clp->cl_cons_state < 0)
1257 1258 1259 1260
		res = clp->cl_cons_state;
out:
	nfs_put_client(clp);
	return res;
1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
}

int nfs4_client_recover_expired_lease(struct nfs_client *clp)
{
	unsigned int loop;
	int ret;

	for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
		ret = nfs4_wait_clnt_recover(clp);
		if (ret != 0)
			break;
		if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&
		    !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state))
			break;
		nfs4_schedule_state_manager(clp);
		ret = -EIO;
	}
	return ret;
}

1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292
/*
 * nfs40_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN
 * @clp: client to process
 *
 * Set the NFS4CLNT_LEASE_EXPIRED state in order to force a
 * resend of the SETCLIENTID and hence re-establish the
 * callback channel. Then return all existing delegations.
 */
static void nfs40_handle_cb_pathdown(struct nfs_client *clp)
{
	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
	nfs_expire_all_delegations(clp);
1293 1294
	dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
			clp->cl_hostname);
1295 1296
}

1297 1298
void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
{
1299
	nfs40_handle_cb_pathdown(clp);
1300 1301 1302
	nfs4_schedule_state_manager(clp);
}

1303
static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1304 1305 1306 1307 1308 1309 1310 1311
{

	set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
	/* Don't recover state that expired before the reboot */
	if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) {
		clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
		return 0;
	}
1312
	set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
1313 1314 1315 1316
	set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
	return 1;
}

1317
int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1318 1319 1320
{
	set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
	clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1321
	set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
1322 1323 1324 1325
	set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
	return 1;
}

1326
int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
1327 1328 1329
{
	struct nfs_client *clp = server->nfs_client;

1330 1331
	if (!nfs4_valid_open_stateid(state))
		return -EBADF;
1332
	nfs4_state_mark_reclaim_nograce(clp, state);
1333 1334
	dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
			clp->cl_hostname);
1335
	nfs4_schedule_state_manager(clp);
1336
	return 0;
1337
}
A
Andy Adamson 已提交
1338
EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1339

1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355
void nfs_inode_find_state_and_recover(struct inode *inode,
		const nfs4_stateid *stateid)
{
	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
	struct nfs_inode *nfsi = NFS_I(inode);
	struct nfs_open_context *ctx;
	struct nfs4_state *state;
	bool found = false;

	spin_lock(&inode->i_lock);
	list_for_each_entry(ctx, &nfsi->open_files, list) {
		state = ctx->state;
		if (state == NULL)
			continue;
		if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
			continue;
1356
		if (!nfs4_stateid_match(&state->stateid, stateid))
1357 1358 1359 1360 1361 1362 1363 1364 1365
			continue;
		nfs4_state_mark_reclaim_nograce(clp, state);
		found = true;
	}
	spin_unlock(&inode->i_lock);
	if (found)
		nfs4_schedule_state_manager(clp);
}

1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380
static void nfs4_state_mark_open_context_bad(struct nfs4_state *state)
{
	struct inode *inode = state->inode;
	struct nfs_inode *nfsi = NFS_I(inode);
	struct nfs_open_context *ctx;

	spin_lock(&inode->i_lock);
	list_for_each_entry(ctx, &nfsi->open_files, list) {
		if (ctx->state != state)
			continue;
		set_bit(NFS_CONTEXT_BAD, &ctx->flags);
	}
	spin_unlock(&inode->i_lock);
}

1381 1382 1383
static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
{
	set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags);
1384
	nfs4_state_mark_open_context_bad(state);
1385 1386
}

1387

1388
static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1389 1390
{
	struct inode *inode = state->inode;
1391
	struct nfs_inode *nfsi = NFS_I(inode);
L
Linus Torvalds 已提交
1392 1393
	struct file_lock *fl;
	int status = 0;
1394
	struct file_lock_context *flctx = inode->i_flctx;
1395
	struct list_head *list;
L
Linus Torvalds 已提交
1396

1397
	if (flctx == NULL)
1398 1399
		return 0;

1400 1401
	list = &flctx->flc_posix;

1402
	/* Guard against delegation returns and new lock/unlock calls */
1403
	down_write(&nfsi->rwsem);
1404
	spin_lock(&flctx->flc_lock);
1405 1406
restart:
	list_for_each_entry(fl, list, fl_list) {
1407 1408
		if (nfs_file_open_context(fl->fl_file)->state != state)
			continue;
1409
		spin_unlock(&flctx->flc_lock);
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435
		status = ops->recover_lock(state, fl);
		switch (status) {
		case 0:
			break;
		case -ESTALE:
		case -NFS4ERR_ADMIN_REVOKED:
		case -NFS4ERR_STALE_STATEID:
		case -NFS4ERR_BAD_STATEID:
		case -NFS4ERR_EXPIRED:
		case -NFS4ERR_NO_GRACE:
		case -NFS4ERR_STALE_CLIENTID:
		case -NFS4ERR_BADSESSION:
		case -NFS4ERR_BADSLOT:
		case -NFS4ERR_BAD_HIGH_SLOT:
		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
			goto out;
		default:
			pr_err("NFS: %s: unhandled error %d\n",
					__func__, status);
		case -ENOMEM:
		case -NFS4ERR_DENIED:
		case -NFS4ERR_RECLAIM_BAD:
		case -NFS4ERR_RECLAIM_CONFLICT:
			/* kill_proc(fl->fl_pid, SIGLOST, 1); */
			status = 0;
		}
1436
		spin_lock(&flctx->flc_lock);
1437
	}
1438 1439 1440 1441
	if (list == &flctx->flc_posix) {
		list = &flctx->flc_flock;
		goto restart;
	}
1442
	spin_unlock(&flctx->flc_lock);
1443
out:
1444
	up_write(&nfsi->rwsem);
L
Linus Torvalds 已提交
1445 1446 1447
	return status;
}

1448
static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461
{
	struct nfs4_state *state;
	struct nfs4_lock_state *lock;
	int status = 0;

	/* Note: we rely on the sp->so_states list being ordered 
	 * so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
	 * states first.
	 * This is needed to ensure that the server won't give us any
	 * read delegations that we have to return if, say, we are
	 * recovering after a network partition or a reboot from a
	 * server that doesn't support a grace period.
	 */
1462
	spin_lock(&sp->so_lock);
1463
	raw_write_seqcount_begin(&sp->so_reclaim_seqcount);
1464
restart:
L
Linus Torvalds 已提交
1465
	list_for_each_entry(state, &sp->so_states, open_states) {
1466 1467
		if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
			continue;
1468 1469
		if (!nfs4_valid_open_stateid(state))
			continue;
L
Linus Torvalds 已提交
1470 1471
		if (state->state == 0)
			continue;
1472 1473
		atomic_inc(&state->count);
		spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1474 1475
		status = ops->recover_open(sp, state);
		if (status >= 0) {
1476 1477
			status = nfs4_reclaim_locks(state, ops);
			if (status >= 0) {
1478
				if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
1479 1480 1481 1482 1483 1484 1485 1486
					spin_lock(&state->state_lock);
					list_for_each_entry(lock, &state->lock_states, ls_locks) {
						if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
							pr_warn_ratelimited("NFS: "
									    "%s: Lock reclaim "
									    "failed!\n", __func__);
					}
					spin_unlock(&state->state_lock);
1487
				}
1488
				clear_bit(NFS_STATE_RECLAIM_NOGRACE,
1489
					&state->flags);
1490
				nfs4_put_open_state(state);
1491
				spin_lock(&sp->so_lock);
1492
				goto restart;
L
Linus Torvalds 已提交
1493 1494 1495 1496
			}
		}
		switch (status) {
			default:
1497 1498
				printk(KERN_ERR "NFS: %s: unhandled error %d\n",
					__func__, status);
L
Linus Torvalds 已提交
1499
			case -ENOENT:
1500
			case -ENOMEM:
1501
			case -ESTALE:
1502
				/* Open state on this file cannot be recovered */
1503
				nfs4_state_mark_recovery_failed(state, status);
L
Linus Torvalds 已提交
1504
				break;
1505 1506
			case -EAGAIN:
				ssleep(1);
1507 1508 1509
			case -NFS4ERR_ADMIN_REVOKED:
			case -NFS4ERR_STALE_STATEID:
			case -NFS4ERR_BAD_STATEID:
1510 1511
			case -NFS4ERR_RECLAIM_BAD:
			case -NFS4ERR_RECLAIM_CONFLICT:
1512
				nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1513
				break;
L
Linus Torvalds 已提交
1514 1515
			case -NFS4ERR_EXPIRED:
			case -NFS4ERR_NO_GRACE:
1516
				nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
L
Linus Torvalds 已提交
1517
			case -NFS4ERR_STALE_CLIENTID:
1518 1519 1520 1521
			case -NFS4ERR_BADSESSION:
			case -NFS4ERR_BADSLOT:
			case -NFS4ERR_BAD_HIGH_SLOT:
			case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
L
Linus Torvalds 已提交
1522 1523
				goto out_err;
		}
1524
		nfs4_put_open_state(state);
1525
		spin_lock(&sp->so_lock);
1526
		goto restart;
L
Linus Torvalds 已提交
1527
	}
1528
	raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1529
	spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1530 1531
	return 0;
out_err:
1532
	nfs4_put_open_state(state);
1533
	spin_lock(&sp->so_lock);
1534
	raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1535
	spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1536 1537 1538
	return status;
}

1539 1540 1541 1542 1543 1544 1545 1546
static void nfs4_clear_open_state(struct nfs4_state *state)
{
	struct nfs4_lock_state *lock;

	clear_bit(NFS_DELEGATED_STATE, &state->flags);
	clear_bit(NFS_O_RDONLY_STATE, &state->flags);
	clear_bit(NFS_O_WRONLY_STATE, &state->flags);
	clear_bit(NFS_O_RDWR_STATE, &state->flags);
1547
	spin_lock(&state->state_lock);
1548 1549
	list_for_each_entry(lock, &state->lock_states, ls_locks) {
		lock->ls_seqid.flags = 0;
1550
		clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags);
1551
	}
1552
	spin_unlock(&state->state_lock);
1553 1554
}

1555 1556
static void nfs4_reset_seqids(struct nfs_server *server,
	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1557
{
1558
	struct nfs_client *clp = server->nfs_client;
1559
	struct nfs4_state_owner *sp;
1560
	struct rb_node *pos;
1561 1562
	struct nfs4_state *state;

1563 1564 1565 1566 1567
	spin_lock(&clp->cl_lock);
	for (pos = rb_first(&server->state_owners);
	     pos != NULL;
	     pos = rb_next(pos)) {
		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1568
		sp->so_seqid.flags = 0;
1569
		spin_lock(&sp->so_lock);
1570
		list_for_each_entry(state, &sp->so_states, open_states) {
1571 1572
			if (mark_reclaim(clp, state))
				nfs4_clear_open_state(state);
1573
		}
1574
		spin_unlock(&sp->so_lock);
1575
	}
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587
	spin_unlock(&clp->cl_lock);
}

static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
{
	struct nfs_server *server;

	rcu_read_lock();
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
		nfs4_reset_seqids(server, mark_reclaim);
	rcu_read_unlock();
1588 1589
}

1590 1591 1592 1593 1594 1595 1596
static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
{
	/* Mark all delegations for reclaim */
	nfs_delegation_mark_reclaim(clp);
	nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot);
}

1597
static void nfs4_reclaim_complete(struct nfs_client *clp,
1598 1599
				 const struct nfs4_state_recovery_ops *ops,
				 struct rpc_cred *cred)
1600 1601 1602
{
	/* Notify the server we're done reclaiming our state */
	if (ops->reclaim_complete)
1603
		(void)ops->reclaim_complete(clp, cred);
1604 1605
}

1606
static void nfs4_clear_reclaim_server(struct nfs_server *server)
1607
{
1608
	struct nfs_client *clp = server->nfs_client;
1609 1610 1611 1612
	struct nfs4_state_owner *sp;
	struct rb_node *pos;
	struct nfs4_state *state;

1613 1614 1615 1616 1617
	spin_lock(&clp->cl_lock);
	for (pos = rb_first(&server->state_owners);
	     pos != NULL;
	     pos = rb_next(pos)) {
		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1618 1619
		spin_lock(&sp->so_lock);
		list_for_each_entry(state, &sp->so_states, open_states) {
1620 1621
			if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
						&state->flags))
1622 1623 1624 1625 1626
				continue;
			nfs4_state_mark_reclaim_nograce(clp, state);
		}
		spin_unlock(&sp->so_lock);
	}
1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640
	spin_unlock(&clp->cl_lock);
}

static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
{
	struct nfs_server *server;

	if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
		return 0;

	rcu_read_lock();
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
		nfs4_clear_reclaim_server(server);
	rcu_read_unlock();
1641 1642

	nfs_delegation_reap_unclaimed(clp);
1643 1644 1645 1646 1647
	return 1;
}

static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
{
1648 1649 1650
	const struct nfs4_state_recovery_ops *ops;
	struct rpc_cred *cred;

1651 1652
	if (!nfs4_state_clear_reclaim_reboot(clp))
		return;
1653
	ops = clp->cl_mvops->reboot_recovery_ops;
1654
	cred = nfs4_get_clid_cred(clp);
1655 1656
	nfs4_reclaim_complete(clp, ops, cred);
	put_rpccred(cred);
1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
}

static void nfs_delegation_clear_all(struct nfs_client *clp)
{
	nfs_delegation_mark_reclaim(clp);
	nfs_delegation_reap_unclaimed(clp);
}

static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
{
	nfs_delegation_clear_all(clp);
	nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
}

1671
static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1672 1673
{
	switch (error) {
1674 1675
		case 0:
			break;
1676
		case -NFS4ERR_CB_PATH_DOWN:
1677
			nfs40_handle_cb_pathdown(clp);
1678
			break;
1679 1680
		case -NFS4ERR_NO_GRACE:
			nfs4_state_end_reclaim_reboot(clp);
1681
			break;
1682 1683
		case -NFS4ERR_STALE_CLIENTID:
			set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1684
			nfs4_state_clear_reclaim_reboot(clp);
1685 1686 1687 1688 1689
			nfs4_state_start_reclaim_reboot(clp);
			break;
		case -NFS4ERR_EXPIRED:
			set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
			nfs4_state_start_reclaim_nograce(clp);
1690
			break;
1691 1692 1693 1694 1695 1696
		case -NFS4ERR_BADSESSION:
		case -NFS4ERR_BADSLOT:
		case -NFS4ERR_BAD_HIGH_SLOT:
		case -NFS4ERR_DEADSESSION:
		case -NFS4ERR_SEQ_FALSE_RETRY:
		case -NFS4ERR_SEQ_MISORDERED:
1697
			set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1698
			/* Zero session reset errors */
1699
			break;
1700 1701 1702
		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
			set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
			break;
1703
		default:
1704 1705
			dprintk("%s: failed to handle error %d for server %s\n",
					__func__, error, clp->cl_hostname);
1706
			return error;
1707
	}
1708 1709
	dprintk("%s: handled error %d for server %s\n", __func__, error,
			clp->cl_hostname);
1710
	return 0;
1711 1712
}

1713
static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1714
{
1715 1716
	struct nfs4_state_owner *sp;
	struct nfs_server *server;
1717
	struct rb_node *pos;
L
Linus Torvalds 已提交
1718 1719
	int status = 0;

1720
restart:
1721 1722
	rcu_read_lock();
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1723
		nfs4_purge_state_owners(server);
1724 1725 1726 1727 1728 1729 1730 1731 1732
		spin_lock(&clp->cl_lock);
		for (pos = rb_first(&server->state_owners);
		     pos != NULL;
		     pos = rb_next(pos)) {
			sp = rb_entry(pos,
				struct nfs4_state_owner, so_server_node);
			if (!test_and_clear_bit(ops->owner_flag_bit,
							&sp->so_flags))
				continue;
1733 1734
			if (!atomic_inc_not_zero(&sp->so_count))
				continue;
1735 1736 1737 1738 1739 1740 1741
			spin_unlock(&clp->cl_lock);
			rcu_read_unlock();

			status = nfs4_reclaim_open_state(sp, ops);
			if (status < 0) {
				set_bit(ops->owner_flag_bit, &sp->so_flags);
				nfs4_put_state_owner(sp);
1742 1743
				status = nfs4_recovery_handle_error(clp, status);
				return (status != 0) ? status : -EAGAIN;
1744 1745
			}

1746
			nfs4_put_state_owner(sp);
1747
			goto restart;
1748
		}
1749
		spin_unlock(&clp->cl_lock);
1750
	}
1751
	rcu_read_unlock();
1752
	return 0;
1753 1754 1755 1756 1757
}

static int nfs4_check_lease(struct nfs_client *clp)
{
	struct rpc_cred *cred;
1758 1759
	const struct nfs4_state_maintenance_ops *ops =
		clp->cl_mvops->state_renewal_ops;
1760
	int status;
L
Linus Torvalds 已提交
1761

1762 1763 1764
	/* Is the client already known to have an expired lease? */
	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		return 0;
1765 1766 1767
	spin_lock(&clp->cl_lock);
	cred = ops->get_state_renewal_cred_locked(clp);
	spin_unlock(&clp->cl_lock);
1768
	if (cred == NULL) {
1769
		cred = nfs4_get_clid_cred(clp);
1770
		status = -ENOKEY;
1771 1772
		if (cred == NULL)
			goto out;
1773
	}
1774
	status = ops->renew_lease(clp, cred);
1775
	put_rpccred(cred);
1776 1777 1778 1779
	if (status == -ETIMEDOUT) {
		set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
		return 0;
	}
1780
out:
1781
	return nfs4_recovery_handle_error(clp, status);
1782 1783
}

1784 1785
/* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
 * and for recoverable errors on EXCHANGE_ID for v4.1
1786 1787 1788 1789
 */
static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
{
	switch (status) {
1790 1791 1792 1793 1794
	case -NFS4ERR_SEQ_MISORDERED:
		if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state))
			return -ESERVERFAULT;
		/* Lease confirmation error: retry after purging the lease */
		ssleep(1);
1795 1796
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
		break;
1797 1798
	case -NFS4ERR_STALE_CLIENTID:
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1799
		nfs4_state_start_reclaim_reboot(clp);
1800
		break;
1801 1802 1803 1804 1805 1806
	case -NFS4ERR_CLID_INUSE:
		pr_err("NFS: Server %s reports our clientid is in use\n",
			clp->cl_hostname);
		nfs_mark_client_ready(clp, -EPERM);
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
		return -EPERM;
1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
	case -EACCES:
	case -NFS4ERR_DELAY:
	case -ETIMEDOUT:
	case -EAGAIN:
		ssleep(1);
		break;

	case -NFS4ERR_MINOR_VERS_MISMATCH:
		if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
			nfs_mark_client_ready(clp, -EPROTONOSUPPORT);
1817 1818
		dprintk("%s: exit with error %d for server %s\n",
				__func__, -EPROTONOSUPPORT, clp->cl_hostname);
1819 1820 1821 1822
		return -EPROTONOSUPPORT;
	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
				 * in nfs4_exchange_id */
	default:
1823 1824
		dprintk("%s: exit with error %d for server %s\n", __func__,
				status, clp->cl_hostname);
1825 1826 1827
		return status;
	}
	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1828 1829
	dprintk("%s: handled error %d for server %s\n", __func__, status,
			clp->cl_hostname);
1830 1831 1832
	return 0;
}

1833
static int nfs4_establish_lease(struct nfs_client *clp)
1834 1835
{
	struct rpc_cred *cred;
1836 1837
	const struct nfs4_state_recovery_ops *ops =
		clp->cl_mvops->reboot_recovery_ops;
1838
	int status;
1839

1840
	nfs4_begin_drain_session(clp);
1841
	cred = nfs4_get_clid_cred(clp);
1842 1843 1844 1845 1846
	if (cred == NULL)
		return -ENOENT;
	status = ops->establish_clid(clp, cred);
	put_rpccred(cred);
	if (status != 0)
1847 1848 1849 1850 1851
		return status;
	pnfs_destroy_all_layouts(clp);
	return 0;
}

1852 1853 1854 1855
/*
 * Returns zero or a negative errno.  NFS4ERR values are converted
 * to local errno values.
 */
1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877
static int nfs4_reclaim_lease(struct nfs_client *clp)
{
	int status;

	status = nfs4_establish_lease(clp);
	if (status < 0)
		return nfs4_handle_reclaim_lease_error(clp, status);
	if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state))
		nfs4_state_start_reclaim_nograce(clp);
	if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
		set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
	clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
	clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
	return 0;
}

static int nfs4_purge_lease(struct nfs_client *clp)
{
	int status;

	status = nfs4_establish_lease(clp);
	if (status < 0)
1878
		return nfs4_handle_reclaim_lease_error(clp, status);
1879 1880 1881
	clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
	nfs4_state_start_reclaim_nograce(clp);
1882
	return 0;
1883 1884
}

1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912
/*
 * Try remote migration of one FSID from a source server to a
 * destination server.  The source server provides a list of
 * potential destinations.
 *
 * Returns zero or a negative NFS4ERR status code.
 */
static int nfs4_try_migration(struct nfs_server *server, struct rpc_cred *cred)
{
	struct nfs_client *clp = server->nfs_client;
	struct nfs4_fs_locations *locations = NULL;
	struct inode *inode;
	struct page *page;
	int status, result;

	dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__,
			(unsigned long long)server->fsid.major,
			(unsigned long long)server->fsid.minor,
			clp->cl_hostname);

	result = 0;
	page = alloc_page(GFP_KERNEL);
	locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
	if (page == NULL || locations == NULL) {
		dprintk("<-- %s: no memory\n", __func__);
		goto out;
	}

1913
	inode = d_inode(server->super->s_root);
1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997
	result = nfs4_proc_get_locations(inode, locations, page, cred);
	if (result) {
		dprintk("<-- %s: failed to retrieve fs_locations: %d\n",
			__func__, result);
		goto out;
	}

	result = -NFS4ERR_NXIO;
	if (!(locations->fattr.valid & NFS_ATTR_FATTR_V4_LOCATIONS)) {
		dprintk("<-- %s: No fs_locations data, migration skipped\n",
			__func__);
		goto out;
	}

	nfs4_begin_drain_session(clp);

	status = nfs4_replace_transport(server, locations);
	if (status != 0) {
		dprintk("<-- %s: failed to replace transport: %d\n",
			__func__, status);
		goto out;
	}

	result = 0;
	dprintk("<-- %s: migration succeeded\n", __func__);

out:
	if (page != NULL)
		__free_page(page);
	kfree(locations);
	if (result) {
		pr_err("NFS: migration recovery failed (server %s)\n",
				clp->cl_hostname);
		set_bit(NFS_MIG_FAILED, &server->mig_status);
	}
	return result;
}

/*
 * Returns zero or a negative NFS4ERR status code.
 */
static int nfs4_handle_migration(struct nfs_client *clp)
{
	const struct nfs4_state_maintenance_ops *ops =
				clp->cl_mvops->state_renewal_ops;
	struct nfs_server *server;
	struct rpc_cred *cred;

	dprintk("%s: migration reported on \"%s\"\n", __func__,
			clp->cl_hostname);

	spin_lock(&clp->cl_lock);
	cred = ops->get_state_renewal_cred_locked(clp);
	spin_unlock(&clp->cl_lock);
	if (cred == NULL)
		return -NFS4ERR_NOENT;

	clp->cl_mig_gen++;
restart:
	rcu_read_lock();
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
		int status;

		if (server->mig_gen == clp->cl_mig_gen)
			continue;
		server->mig_gen = clp->cl_mig_gen;

		if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION,
						&server->mig_status))
			continue;

		rcu_read_unlock();
		status = nfs4_try_migration(server, cred);
		if (status < 0) {
			put_rpccred(cred);
			return status;
		}
		goto restart;
	}
	rcu_read_unlock();
	put_rpccred(cred);
	return 0;
}

1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031
/*
 * Test each nfs_server on the clp's cl_superblocks list to see
 * if it's moved to another server.  Stop when the server no longer
 * returns NFS4ERR_LEASE_MOVED.
 */
static int nfs4_handle_lease_moved(struct nfs_client *clp)
{
	const struct nfs4_state_maintenance_ops *ops =
				clp->cl_mvops->state_renewal_ops;
	struct nfs_server *server;
	struct rpc_cred *cred;

	dprintk("%s: lease moved reported on \"%s\"\n", __func__,
			clp->cl_hostname);

	spin_lock(&clp->cl_lock);
	cred = ops->get_state_renewal_cred_locked(clp);
	spin_unlock(&clp->cl_lock);
	if (cred == NULL)
		return -NFS4ERR_NOENT;

	clp->cl_mig_gen++;
restart:
	rcu_read_lock();
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
		struct inode *inode;
		int status;

		if (server->mig_gen == clp->cl_mig_gen)
			continue;
		server->mig_gen = clp->cl_mig_gen;

		rcu_read_unlock();

2032
		inode = d_inode(server->super->s_root);
2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046
		status = nfs4_proc_fsid_present(inode, cred);
		if (status != -NFS4ERR_MOVED)
			goto restart;	/* wasn't this one */
		if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED)
			goto restart;	/* there are more */
		goto out;
	}
	rcu_read_unlock();

out:
	put_rpccred(cred);
	return 0;
}

2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066
/**
 * nfs4_discover_server_trunking - Detect server IP address trunking
 *
 * @clp: nfs_client under test
 * @result: OUT: found nfs_client, or clp
 *
 * Returns zero or a negative errno.  If zero is returned,
 * an nfs_client pointer is planted in "result".
 *
 * Note: since we are invoked in process context, and
 * not from inside the state manager, we cannot use
 * nfs4_handle_reclaim_lease_error().
 */
int nfs4_discover_server_trunking(struct nfs_client *clp,
				  struct nfs_client **result)
{
	const struct nfs4_state_recovery_ops *ops =
				clp->cl_mvops->reboot_recovery_ops;
	struct rpc_clnt *clnt;
	struct rpc_cred *cred;
2067
	int i, status;
2068 2069 2070 2071 2072 2073 2074 2075

	dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);

	clnt = clp->cl_rpcclient;
	i = 0;

	mutex_lock(&nfs_clid_init_mutex);
again:
2076
	status  = -ENOENT;
2077
	cred = nfs4_get_clid_cred(clp);
2078 2079 2080 2081 2082 2083 2084 2085 2086
	if (cred == NULL)
		goto out_unlock;

	status = ops->detect_trunking(clp, result, cred);
	put_rpccred(cred);
	switch (status) {
	case 0:
		break;
	case -ETIMEDOUT:
2087 2088 2089
		if (clnt->cl_softrtry)
			break;
	case -NFS4ERR_DELAY:
2090 2091
	case -EAGAIN:
		ssleep(1);
2092
	case -NFS4ERR_STALE_CLIENTID:
2093 2094 2095
		dprintk("NFS: %s after status %d, retrying\n",
			__func__, status);
		goto again;
2096
	case -EACCES:
2097 2098 2099 2100
		if (i++ == 0) {
			nfs4_root_machine_cred(clp);
			goto again;
		}
2101
		if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX)
2102
			break;
2103 2104
	case -NFS4ERR_CLID_INUSE:
	case -NFS4ERR_WRONGSEC:
2105 2106 2107 2108 2109
		/* No point in retrying if we already used RPC_AUTH_UNIX */
		if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) {
			status = -EPERM;
			break;
		}
2110
		clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX);
2111 2112 2113 2114
		if (IS_ERR(clnt)) {
			status = PTR_ERR(clnt);
			break;
		}
2115 2116 2117 2118 2119 2120 2121
		/* Note: this is safe because we haven't yet marked the
		 * client as ready, so we are the only user of
		 * clp->cl_rpcclient
		 */
		clnt = xchg(&clp->cl_rpcclient, clnt);
		rpc_shutdown_client(clnt);
		clnt = clp->cl_rpcclient;
2122 2123 2124 2125 2126 2127 2128 2129 2130 2131
		goto again;

	case -NFS4ERR_MINOR_VERS_MISMATCH:
		status = -EPROTONOSUPPORT;
		break;

	case -EKEYEXPIRED:
	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
				 * in nfs4_exchange_id */
		status = -EKEYEXPIRED;
2132 2133 2134 2135 2136
		break;
	default:
		pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
				__func__, status);
		status = -EIO;
2137 2138 2139 2140 2141 2142 2143 2144
	}

out_unlock:
	mutex_unlock(&nfs_clid_init_mutex);
	dprintk("NFS: %s: status = %d\n", __func__, status);
	return status;
}

2145
#ifdef CONFIG_NFS_V4_1
2146
void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
2147
{
2148 2149
	struct nfs_client *clp = session->clp;

2150 2151 2152 2153 2154 2155 2156
	switch (err) {
	default:
		set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
		break;
	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
		set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
	}
2157
	nfs4_schedule_lease_recovery(clp);
2158
}
2159
EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
2160

2161
void nfs41_notify_server(struct nfs_client *clp)
2162 2163 2164 2165 2166 2167
{
	/* Use CHECK_LEASE to ping the server with a SEQUENCE */
	set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
	nfs4_schedule_state_manager(clp);
}

2168 2169 2170
static void nfs4_reset_all_state(struct nfs_client *clp)
{
	if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2171
		set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
2172
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
2173
		nfs4_state_start_reclaim_nograce(clp);
2174 2175
		dprintk("%s: scheduling reset of all state for server %s!\n",
				__func__, clp->cl_hostname);
2176
		nfs4_schedule_state_manager(clp);
2177 2178 2179 2180 2181 2182 2183
	}
}

static void nfs41_handle_server_reboot(struct nfs_client *clp)
{
	if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
		nfs4_state_start_reclaim_reboot(clp);
2184 2185
		dprintk("%s: server %s rebooted!\n", __func__,
				clp->cl_hostname);
2186
		nfs4_schedule_state_manager(clp);
2187 2188 2189
	}
}

2190
static void nfs41_handle_all_state_revoked(struct nfs_client *clp)
2191 2192
{
	nfs4_reset_all_state(clp);
2193
	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2194 2195
}

2196 2197 2198 2199 2200 2201 2202 2203
static void nfs41_handle_some_state_revoked(struct nfs_client *clp)
{
	nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
	nfs4_schedule_state_manager(clp);

	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
}

2204 2205
static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
{
2206 2207 2208 2209
	/* FIXME: For now, we destroy all layouts. */
	pnfs_destroy_all_layouts(clp);
	/* FIXME: For now, we test all delegations+open state+locks. */
	nfs41_handle_some_state_revoked(clp);
2210 2211
	dprintk("%s: Recallable state revoked on server %s!\n", __func__,
			clp->cl_hostname);
2212 2213
}

2214
static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
2215
{
2216 2217 2218
	set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
	nfs4_schedule_state_manager(clp);

2219 2220
	dprintk("%s: server %s declared a backchannel fault\n", __func__,
			clp->cl_hostname);
2221 2222
}

2223 2224 2225 2226 2227 2228 2229
static void nfs41_handle_cb_path_down(struct nfs_client *clp)
{
	if (test_and_set_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
		&clp->cl_state) == 0)
		nfs4_schedule_state_manager(clp);
}

2230 2231 2232 2233
void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)
{
	if (!flags)
		return;
2234 2235 2236 2237

	dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
		__func__, clp->cl_hostname, clp->cl_clientid, flags);

2238
	if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
2239
		nfs41_handle_server_reboot(clp);
2240 2241 2242
	if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED))
		nfs41_handle_all_state_revoked(clp);
	if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
C
Chuck Lever 已提交
2243
			    SEQ4_STATUS_ADMIN_STATE_REVOKED))
2244
		nfs41_handle_some_state_revoked(clp);
C
Chuck Lever 已提交
2245 2246
	if (flags & SEQ4_STATUS_LEASE_MOVED)
		nfs4_schedule_lease_moved_recovery(clp);
2247
	if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
2248
		nfs41_handle_recallable_state_revoked(clp);
2249 2250 2251 2252
	if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT)
		nfs41_handle_backchannel_fault(clp);
	else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
				SEQ4_STATUS_CB_PATH_DOWN_SESSION))
2253
		nfs41_handle_cb_path_down(clp);
2254 2255
}

2256 2257
static int nfs4_reset_session(struct nfs_client *clp)
{
2258
	struct rpc_cred *cred;
2259 2260
	int status;

2261 2262
	if (!nfs4_has_session(clp))
		return 0;
2263
	nfs4_begin_drain_session(clp);
2264
	cred = nfs4_get_clid_cred(clp);
2265
	status = nfs4_proc_destroy_session(clp->cl_session, cred);
2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277
	switch (status) {
	case 0:
	case -NFS4ERR_BADSESSION:
	case -NFS4ERR_DEADSESSION:
		break;
	case -NFS4ERR_BACK_CHAN_BUSY:
	case -NFS4ERR_DELAY:
		set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
		status = 0;
		ssleep(1);
		goto out;
	default:
2278
		status = nfs4_recovery_handle_error(clp, status);
2279 2280 2281 2282
		goto out;
	}

	memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
2283
	status = nfs4_proc_create_session(clp, cred);
2284
	if (status) {
2285 2286
		dprintk("%s: session reset failed with status %d for server %s!\n",
			__func__, status, clp->cl_hostname);
2287
		status = nfs4_handle_reclaim_lease_error(clp, status);
2288 2289
		goto out;
	}
2290
	nfs41_finish_session_reset(clp);
2291 2292
	dprintk("%s: session reset was successful for server %s!\n",
			__func__, clp->cl_hostname);
2293
out:
2294 2295
	if (cred)
		put_rpccred(cred);
2296 2297
	return status;
}
2298

2299 2300
static int nfs4_bind_conn_to_session(struct nfs_client *clp)
{
2301 2302 2303
	struct rpc_cred *cred;
	int ret;

2304 2305
	if (!nfs4_has_session(clp))
		return 0;
2306
	nfs4_begin_drain_session(clp);
2307
	cred = nfs4_get_clid_cred(clp);
2308 2309 2310
	ret = nfs4_proc_bind_conn_to_session(clp, cred);
	if (cred)
		put_rpccred(cred);
2311
	clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2312 2313
	switch (ret) {
	case 0:
2314 2315
		dprintk("%s: bind_conn_to_session was successful for server %s!\n",
			__func__, clp->cl_hostname);
2316 2317 2318 2319 2320 2321 2322 2323 2324
		break;
	case -NFS4ERR_DELAY:
		ssleep(1);
		set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
		break;
	default:
		return nfs4_recovery_handle_error(clp, ret);
	}
	return 0;
2325
}
2326
#else /* CONFIG_NFS_V4_1 */
2327
static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
2328 2329 2330 2331 2332

static int nfs4_bind_conn_to_session(struct nfs_client *clp)
{
	return 0;
}
2333 2334
#endif /* CONFIG_NFS_V4_1 */

2335
static void nfs4_state_manager(struct nfs_client *clp)
2336 2337
{
	int status = 0;
2338
	const char *section = "", *section_sep = "";
2339 2340

	/* Ensure exclusive access to NFSv4 state */
2341
	do {
2342
		if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2343
			section = "purge state";
2344
			status = nfs4_purge_lease(clp);
2345 2346
			if (status < 0)
				goto out_error;
2347
			continue;
2348 2349
		}

2350
		if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
2351
			section = "lease expired";
2352 2353
			/* We're going to have to re-establish a clientid */
			status = nfs4_reclaim_lease(clp);
2354
			if (status < 0)
2355
				goto out_error;
2356
			continue;
2357 2358
		}

2359
		/* Initialize or reset the session */
2360
		if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) {
2361
			section = "reset session";
2362
			status = nfs4_reset_session(clp);
2363 2364 2365
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
				continue;
			if (status < 0)
2366 2367
				goto out_error;
		}
2368

2369 2370
		/* Send BIND_CONN_TO_SESSION */
		if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2371
				&clp->cl_state)) {
2372
			section = "bind conn to session";
2373 2374 2375
			status = nfs4_bind_conn_to_session(clp);
			if (status < 0)
				goto out_error;
2376
			continue;
2377 2378
		}

2379 2380 2381 2382 2383
		if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
			section = "check lease";
			status = nfs4_check_lease(clp);
			if (status < 0)
				goto out_error;
O
Olga Kornievskaia 已提交
2384
			continue;
2385 2386 2387 2388 2389 2390 2391
		}

		if (test_and_clear_bit(NFS4CLNT_MOVED, &clp->cl_state)) {
			section = "migration";
			status = nfs4_handle_migration(clp);
			if (status < 0)
				goto out_error;
2392 2393
		}

2394 2395 2396 2397 2398 2399 2400
		if (test_and_clear_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state)) {
			section = "lease moved";
			status = nfs4_handle_lease_moved(clp);
			if (status < 0)
				goto out_error;
		}

2401
		/* First recover reboot state... */
2402
		if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
2403
			section = "reclaim reboot";
2404
			status = nfs4_do_reclaim(clp,
2405
				clp->cl_mvops->reboot_recovery_ops);
2406
			if (status == -EAGAIN)
2407 2408 2409
				continue;
			if (status < 0)
				goto out_error;
2410
			nfs4_state_end_reclaim_reboot(clp);
2411 2412
		}

2413 2414
		/* Now recover expired state... */
		if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
2415
			section = "reclaim nograce";
2416
			status = nfs4_do_reclaim(clp,
2417
				clp->cl_mvops->nograce_recovery_ops);
2418
			if (status == -EAGAIN)
2419 2420
				continue;
			if (status < 0)
2421
				goto out_error;
L
Linus Torvalds 已提交
2422
		}
2423

2424
		nfs4_end_drain_session(clp);
2425 2426 2427 2428
		if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
			nfs_client_return_marked_delegations(clp);
			continue;
		}
2429 2430

		nfs4_clear_state_manager_bit(clp);
2431 2432 2433 2434 2435
		/* Did we race with an attempt to give us more work? */
		if (clp->cl_state == 0)
			break;
		if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
			break;
2436
	} while (atomic_read(&clp->cl_count) > 1);
2437
	return;
L
Linus Torvalds 已提交
2438
out_error:
2439 2440 2441 2442 2443
	if (strlen(section))
		section_sep = ": ";
	pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
			" with error %d\n", section_sep, section,
			clp->cl_hostname, -status);
2444
	ssleep(1);
2445
	nfs4_end_drain_session(clp);
2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457
	nfs4_clear_state_manager_bit(clp);
}

static int nfs4_run_state_manager(void *ptr)
{
	struct nfs_client *clp = ptr;

	allow_signal(SIGKILL);
	nfs4_state_manager(clp);
	nfs_put_client(clp);
	module_put_and_exit(0);
	return 0;
L
Linus Torvalds 已提交
2458 2459 2460 2461 2462 2463 2464
}

/*
 * Local variables:
 *  c-basic-offset: 8
 * End:
 */