nfs4state.c 68.2 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 73
const nfs4_stateid invalid_stateid = {
	{
74 75
		/* Funky initialiser keeps older gcc versions happy */
		.data = { 0xff, 0xff, 0xff, 0xff, 0 },
76 77 78 79
	},
	.type = NFS4_INVALID_STATEID_TYPE,
};

80 81 82 83 84 85 86 87
const nfs4_stateid current_stateid = {
	{
		/* Funky initialiser keeps older gcc versions happy */
		.data = { 0x0, 0x0, 0x0, 0x1, 0 },
	},
	.type = NFS4_SPECIAL_STATEID_TYPE,
};

88
static DEFINE_MUTEX(nfs_clid_init_mutex);
L
Linus Torvalds 已提交
89

90
int nfs4_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
L
Linus Torvalds 已提交
91
{
92 93 94 95
	struct nfs4_setclientid_res clid = {
		.clientid = clp->cl_clientid,
		.confirm = clp->cl_confirm,
	};
96 97
	unsigned short port;
	int status;
98
	struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
99

100 101
	if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
		goto do_confirm;
102
	port = nn->nfs_callback_tcpport;
103
	if (clp->cl_addr.ss_family == AF_INET6)
104
		port = nn->nfs_callback_tcpport6;
105

106 107 108
	status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
	if (status != 0)
		goto out;
109 110 111 112
	clp->cl_clientid = clid.clientid;
	clp->cl_confirm = clid.confirm;
	set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
do_confirm:
113 114 115
	status = nfs4_proc_setclientid_confirm(clp, &clid, cred);
	if (status != 0)
		goto out;
116
	clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
117 118
	nfs4_schedule_state_renewal(clp);
out:
L
Linus Torvalds 已提交
119 120 121
	return status;
}

122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
/**
 * 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,
	};
143
	struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
144 145 146
	unsigned short port;
	int status;

147
	port = nn->nfs_callback_tcpport;
148
	if (clp->cl_addr.ss_family == AF_INET6)
149
		port = nn->nfs_callback_tcpport6;
150 151 152 153 154 155 156 157

	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);
158
	if (status == 0) {
159 160 161 162 163 164 165 166
		/* 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;
}

167
struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp)
168 169 170 171 172 173 174 175
{
	struct rpc_cred *cred = NULL;

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

176 177 178 179 180 181 182 183 184 185 186 187 188
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);
}

189 190
static struct rpc_cred *
nfs4_get_renew_cred_server_locked(struct nfs_server *server)
191
{
192
	struct rpc_cred *cred = NULL;
193
	struct nfs4_state_owner *sp;
194
	struct rb_node *pos;
195

196 197 198 199
	for (pos = rb_first(&server->state_owners);
	     pos != NULL;
	     pos = rb_next(pos)) {
		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
200 201 202 203 204 205 206 207
		if (list_empty(&sp->so_states))
			continue;
		cred = get_rpccred(sp->so_cred);
		break;
	}
	return cred;
}

208 209 210 211 212 213 214 215 216 217 218 219
/**
 * 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;

220 221 222 223 224
	/* Use machine credentials if available */
	cred = nfs4_get_machine_cred_locked(clp);
	if (cred != NULL)
		goto out;

225 226 227 228 229 230 231
	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();
232 233

out:
234 235 236
	return cred;
}

237
static void nfs4_end_drain_slot_table(struct nfs4_slot_table *tbl)
238
{
239
	if (test_and_clear_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
240
		spin_lock(&tbl->slot_tbl_lock);
241
		nfs41_wake_slot_table(tbl);
242
		spin_unlock(&tbl->slot_tbl_lock);
243
	}
244 245
}

246 247 248 249
static void nfs4_end_drain_session(struct nfs_client *clp)
{
	struct nfs4_session *ses = clp->cl_session;

250 251 252 253 254
	if (clp->cl_slot_tbl) {
		nfs4_end_drain_slot_table(clp->cl_slot_tbl);
		return;
	}

255 256 257 258 259 260
	if (ses != NULL) {
		nfs4_end_drain_slot_table(&ses->bc_slot_table);
		nfs4_end_drain_slot_table(&ses->fc_slot_table);
	}
}

261
static int nfs4_drain_slot_tbl(struct nfs4_slot_table *tbl)
262
{
263
	set_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state);
264
	spin_lock(&tbl->slot_tbl_lock);
265
	if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
266
		reinit_completion(&tbl->complete);
267
		spin_unlock(&tbl->slot_tbl_lock);
268
		return wait_for_completion_interruptible(&tbl->complete);
269 270 271 272 273
	}
	spin_unlock(&tbl->slot_tbl_lock);
	return 0;
}

274 275 276
static int nfs4_begin_drain_session(struct nfs_client *clp)
{
	struct nfs4_session *ses = clp->cl_session;
277
	int ret;
278

279 280 281
	if (clp->cl_slot_tbl)
		return nfs4_drain_slot_tbl(clp->cl_slot_tbl);

282
	/* back channel */
283
	ret = nfs4_drain_slot_tbl(&ses->bc_slot_table);
284 285 286
	if (ret)
		return ret;
	/* fore channel */
287
	return nfs4_drain_slot_tbl(&ses->fc_slot_table);
288 289
}

290 291
#if defined(CONFIG_NFS_V4_1)

292 293 294 295
static int nfs41_setup_state_renewal(struct nfs_client *clp)
{
	int status;
	struct nfs_fsinfo fsinfo;
296
	unsigned long now;
297 298 299 300 301 302

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

303
	now = jiffies;
304 305
	status = nfs4_proc_get_lease_time(clp, &fsinfo);
	if (status == 0) {
306
		nfs4_set_lease_period(clp, fsinfo.lease_time * HZ, now);
307 308 309 310 311 312
		nfs4_schedule_state_renewal(clp);
	}

	return status;
}

313 314 315 316 317 318 319 320 321
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);
}

322 323 324 325
int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
{
	int status;

326 327
	if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
		goto do_confirm;
328
	status = nfs4_proc_exchange_id(clp, cred);
329 330
	if (status != 0)
		goto out;
331 332
	set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
do_confirm:
333
	status = nfs4_proc_create_session(clp, cred);
334 335
	if (status != 0)
		goto out;
336
	nfs41_finish_session_reset(clp);
337 338
	nfs_mark_client_ready(clp, NFS_CS_READY);
out:
339 340 341
	return status;
}

342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
/**
 * 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;

365 366 367 368 369 370
	status = nfs41_walk_client_list(clp, result, cred);
	if (status < 0)
		return status;
	if (clp != *result)
		return 0;

371 372 373 374 375 376 377 378 379 380 381
	/*
	 * Purge state if the client id was established in a prior
	 * instance and the client id could not have arrived on the
	 * server via Transparent State Migration.
	 */
	if (clp->cl_exchange_flags & EXCHGID4_FLAG_CONFIRMED_R) {
		if (!test_bit(NFS_CS_TSM_POSSIBLE, &clp->cl_flags))
			set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
		else
			set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
	}
382 383 384 385 386
	nfs4_schedule_state_manager(clp);
	status = nfs_wait_client_init_complete(clp);
	if (status < 0)
		nfs_put_client(clp);
	return status;
387 388
}

389 390
#endif /* CONFIG_NFS_V4_1 */

391
/**
392
 * nfs4_get_clid_cred - Acquire credential for a setclientid operation
393 394 395 396
 * @clp: client state handle
 *
 * Returns an rpc_cred with reference count bumped, or NULL.
 */
397
struct rpc_cred *nfs4_get_clid_cred(struct nfs_client *clp)
398
{
399
	struct rpc_cred *cred;
400

401 402
	spin_lock(&clp->cl_lock);
	cred = nfs4_get_machine_cred_locked(clp);
403
	spin_unlock(&clp->cl_lock);
404
	return cred;
405 406
}

L
Linus Torvalds 已提交
407
static struct nfs4_state_owner *
408
nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred)
L
Linus Torvalds 已提交
409
{
410
	struct rb_node **p = &server->state_owners.rb_node,
411
		       *parent = NULL;
412
	struct nfs4_state_owner *sp;
L
Linus Torvalds 已提交
413

414 415
	while (*p != NULL) {
		parent = *p;
416
		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
417 418 419 420 421 422

		if (cred < sp->so_cred)
			p = &parent->rb_left;
		else if (cred > sp->so_cred)
			p = &parent->rb_right;
		else {
423 424
			if (!list_empty(&sp->so_lru))
				list_del_init(&sp->so_lru);
425
			atomic_inc(&sp->so_count);
426
			return sp;
427
		}
L
Linus Torvalds 已提交
428
	}
429
	return NULL;
L
Linus Torvalds 已提交
430 431
}

432
static struct nfs4_state_owner *
433
nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
434
{
435 436
	struct nfs_server *server = new->so_server;
	struct rb_node **p = &server->state_owners.rb_node,
437 438 439 440 441
		       *parent = NULL;
	struct nfs4_state_owner *sp;

	while (*p != NULL) {
		parent = *p;
442
		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
443 444 445 446 447 448

		if (new->so_cred < sp->so_cred)
			p = &parent->rb_left;
		else if (new->so_cred > sp->so_cred)
			p = &parent->rb_right;
		else {
449 450
			if (!list_empty(&sp->so_lru))
				list_del_init(&sp->so_lru);
451 452 453 454
			atomic_inc(&sp->so_count);
			return sp;
		}
	}
455 456
	rb_link_node(&new->so_server_node, parent, p);
	rb_insert_color(&new->so_server_node, &server->state_owners);
457 458 459 460
	return new;
}

static void
461
nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
462
{
463 464 465 466
	struct nfs_server *server = sp->so_server;

	if (!RB_EMPTY_NODE(&sp->so_server_node))
		rb_erase(&sp->so_server_node, &server->state_owners);
467 468
}

469 470 471
static void
nfs4_init_seqid_counter(struct nfs_seqid_counter *sc)
{
472
	sc->create_time = ktime_get();
473 474 475 476 477 478 479 480 481 482 483 484 485
	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 已提交
486 487 488 489 490 491
/*
 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
 * create a new state_owner.
 *
 */
static struct nfs4_state_owner *
492 493 494
nfs4_alloc_state_owner(struct nfs_server *server,
		struct rpc_cred *cred,
		gfp_t gfp_flags)
L
Linus Torvalds 已提交
495 496 497
{
	struct nfs4_state_owner *sp;

498
	sp = kzalloc(sizeof(*sp), gfp_flags);
L
Linus Torvalds 已提交
499 500
	if (!sp)
		return NULL;
501 502 503 504 505 506
	sp->so_seqid.owner_id = ida_simple_get(&server->openowner_id, 0, 0,
						gfp_flags);
	if (sp->so_seqid.owner_id < 0) {
		kfree(sp);
		return NULL;
	}
507 508
	sp->so_server = server;
	sp->so_cred = get_rpccred(cred);
509
	spin_lock_init(&sp->so_lock);
L
Linus Torvalds 已提交
510
	INIT_LIST_HEAD(&sp->so_states);
511
	nfs4_init_seqid_counter(&sp->so_seqid);
L
Linus Torvalds 已提交
512
	atomic_set(&sp->so_count, 1);
513
	INIT_LIST_HEAD(&sp->so_lru);
514
	seqcount_init(&sp->so_reclaim_seqcount);
515
	mutex_init(&sp->so_delegreturn_mutex);
L
Linus Torvalds 已提交
516 517 518
	return sp;
}

519
static void
520
nfs4_reset_state_owner(struct nfs4_state_owner *sp)
L
Linus Torvalds 已提交
521
{
522 523 524 525 526 527 528 529 530 531
	/* This state_owner is no longer usable, but must
	 * remain in place so that state recovery can find it
	 * and the opens associated with it.
	 * It may also be used for new 'open' request to
	 * return a delegation to the server.
	 * So update the 'create_time' so that it looks like
	 * a new state_owner.  This will cause the server to
	 * request an OPEN_CONFIRM to start a new sequence.
	 */
	sp->so_seqid.create_time = ktime_get();
L
Linus Torvalds 已提交
532 533
}

534 535
static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
{
536
	nfs4_destroy_seqid_counter(&sp->so_seqid);
537
	put_rpccred(sp->so_cred);
538
	ida_simple_remove(&sp->so_server->openowner_id, sp->so_seqid.owner_id);
539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
	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);
	}
}

567 568 569 570 571 572 573 574
/**
 * 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,
575 576
					      struct rpc_cred *cred,
					      gfp_t gfp_flags)
L
Linus Torvalds 已提交
577
{
578
	struct nfs_client *clp = server->nfs_client;
L
Linus Torvalds 已提交
579 580 581
	struct nfs4_state_owner *sp, *new;

	spin_lock(&clp->cl_lock);
582
	sp = nfs4_find_state_owner_locked(server, cred);
L
Linus Torvalds 已提交
583 584
	spin_unlock(&clp->cl_lock);
	if (sp != NULL)
585
		goto out;
586
	new = nfs4_alloc_state_owner(server, cred, gfp_flags);
587
	if (new == NULL)
588
		goto out;
589 590 591
	spin_lock(&clp->cl_lock);
	sp = nfs4_insert_state_owner_locked(new);
	spin_unlock(&clp->cl_lock);
592 593
	if (sp != new)
		nfs4_free_state_owner(new);
594 595
out:
	nfs4_gc_state_owners(server);
596
	return sp;
L
Linus Torvalds 已提交
597 598
}

599 600 601
/**
 * nfs4_put_state_owner - Release a nfs4_state_owner
 * @sp: state owner data to release
602 603 604 605 606 607 608 609
 *
 * 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.
610
 */
L
Linus Torvalds 已提交
611 612
void nfs4_put_state_owner(struct nfs4_state_owner *sp)
{
613 614
	struct nfs_server *server = sp->so_server;
	struct nfs_client *clp = server->nfs_client;
L
Linus Torvalds 已提交
615 616 617

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

619 620 621
	sp->so_expires = jiffies;
	list_add_tail(&sp->so_lru, &server->state_owners_lru);
	spin_unlock(&clp->cl_lock);
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
}

/**
 * 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 已提交
642
	spin_unlock(&clp->cl_lock);
643 644 645 646 647

	list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
		list_del(&sp->so_lru);
		nfs4_free_state_owner(sp);
	}
L
Linus Torvalds 已提交
648 649 650 651 652 653 654
}

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

655
	state = kzalloc(sizeof(*state), GFP_NOFS);
L
Linus Torvalds 已提交
656 657
	if (!state)
		return NULL;
658
	refcount_set(&state->count, 1);
L
Linus Torvalds 已提交
659
	INIT_LIST_HEAD(&state->lock_states);
660
	spin_lock_init(&state->state_lock);
661
	seqlock_init(&state->seqlock);
662
	init_waitqueue_head(&state->waitq);
L
Linus Torvalds 已提交
663 664 665
	return state;
}

666
void
667
nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
668
{
669
	if (state->state == fmode)
670 671
		return;
	/* NB! List reordering - see the reclaim code for why.  */
672 673
	if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
		if (fmode & FMODE_WRITE)
674 675 676 677
			list_move(&state->open_states, &state->owner->so_states);
		else
			list_move_tail(&state->open_states, &state->owner->so_states);
	}
678
	state->state = fmode;
679 680
}

L
Linus Torvalds 已提交
681 682 683 684 685 686
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;

687
	list_for_each_entry_rcu(state, &nfsi->open_states, inode_states) {
688
		if (state->owner != owner)
L
Linus Torvalds 已提交
689
			continue;
690 691
		if (!nfs4_valid_open_stateid(state))
			continue;
692
		if (refcount_inc_not_zero(&state->count))
L
Linus Torvalds 已提交
693 694 695 696 697 698 699 700
			return state;
	}
	return NULL;
}

static void
nfs4_free_open_state(struct nfs4_state *state)
{
701
	kfree_rcu(state, rcu_head);
L
Linus Torvalds 已提交
702 703 704 705 706 707 708 709
}

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);

710
	rcu_read_lock();
L
Linus Torvalds 已提交
711
	state = __nfs4_find_state_byowner(inode, owner);
712
	rcu_read_unlock();
L
Linus Torvalds 已提交
713 714 715
	if (state)
		goto out;
	new = nfs4_alloc_open_state();
716
	spin_lock(&owner->so_lock);
L
Linus Torvalds 已提交
717 718 719 720 721 722
	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);
723
		list_add_rcu(&state->inode_states, &nfsi->open_states);
724 725
		ihold(inode);
		state->inode = inode;
L
Linus Torvalds 已提交
726
		spin_unlock(&inode->i_lock);
727 728 729 730
		/* 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 已提交
731 732
	} else {
		spin_unlock(&inode->i_lock);
733
		spin_unlock(&owner->so_lock);
L
Linus Torvalds 已提交
734 735 736 737 738 739 740 741 742 743 744 745
		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;

746
	if (!refcount_dec_and_lock(&state->count, &owner->so_lock))
L
Linus Torvalds 已提交
747
		return;
748
	spin_lock(&inode->i_lock);
749
	list_del_rcu(&state->inode_states);
L
Linus Torvalds 已提交
750
	list_del(&state->open_states);
751 752
	spin_unlock(&inode->i_lock);
	spin_unlock(&owner->so_lock);
L
Linus Torvalds 已提交
753 754 755 756 757 758
	iput(inode);
	nfs4_free_open_state(state);
	nfs4_put_state_owner(owner);
}

/*
759
 * Close the current file.
L
Linus Torvalds 已提交
760
 */
761
static void __nfs4_close(struct nfs4_state *state,
762
		fmode_t fmode, gfp_t gfp_mask, int wait)
L
Linus Torvalds 已提交
763 764
{
	struct nfs4_state_owner *owner = state->owner;
765
	int call_close = 0;
766
	fmode_t newstate;
L
Linus Torvalds 已提交
767 768 769

	atomic_inc(&owner->so_count);
	/* Protect against nfs4_find_state() */
770
	spin_lock(&owner->so_lock);
771
	switch (fmode & (FMODE_READ | FMODE_WRITE)) {
772 773 774 775 776 777 778 779 780
		case FMODE_READ:
			state->n_rdonly--;
			break;
		case FMODE_WRITE:
			state->n_wronly--;
			break;
		case FMODE_READ|FMODE_WRITE:
			state->n_rdwr--;
	}
781
	newstate = FMODE_READ|FMODE_WRITE;
782
	if (state->n_rdwr == 0) {
783
		if (state->n_rdonly == 0) {
784
			newstate &= ~FMODE_READ;
785 786 787 788
			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) {
789
			newstate &= ~FMODE_WRITE;
790 791 792 793 794
			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);
795
	}
796
	nfs4_state_set_mode_locked(state, newstate);
797
	spin_unlock(&owner->so_lock);
798

799
	if (!call_close) {
800 801
		nfs4_put_open_state(state);
		nfs4_put_state_owner(owner);
802 803
	} else
		nfs4_do_close(state, gfp_mask, wait);
804 805
}

806
void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
807
{
808
	__nfs4_close(state, fmode, GFP_NOFS, 0);
809 810
}

811
void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
812
{
813
	__nfs4_close(state, fmode, GFP_KERNEL, 1);
L
Linus Torvalds 已提交
814 815 816 817
}

/*
 * Search the state->lock_states for an existing lock_owner
818 819 820 821 822 823 824 825 826 827
 * that is compatible with either of the given owners.
 * If the second is non-zero, then the first refers to a Posix-lock
 * owner (current->files) and the second refers to a flock/OFD
 * owner (struct file*).  In that case, prefer a match for the first
 * owner.
 * If both sorts of locks are held on the one file we cannot know
 * which stateid was intended to be used, so a "correct" choice cannot
 * be made.  Failing that, a "consistent" choice is preferable.  The
 * consistent choice we make is to prefer the first owner, that of a
 * Posix lock.
L
Linus Torvalds 已提交
828 829
 */
static struct nfs4_lock_state *
830 831
__nfs4_find_lock_state(struct nfs4_state *state,
		       fl_owner_t fl_owner, fl_owner_t fl_owner2)
L
Linus Torvalds 已提交
832
{
833
	struct nfs4_lock_state *pos, *ret = NULL;
L
Linus Torvalds 已提交
834
	list_for_each_entry(pos, &state->lock_states, ls_locks) {
835 836 837 838 839 840
		if (pos->ls_owner == fl_owner) {
			ret = pos;
			break;
		}
		if (pos->ls_owner == fl_owner2)
			ret = pos;
L
Linus Torvalds 已提交
841
	}
842
	if (ret)
843
		refcount_inc(&ret->ls_count);
844
	return ret;
L
Linus Torvalds 已提交
845 846 847 848 849 850 851
}

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

857
	lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
L
Linus Torvalds 已提交
858 859
	if (lsp == NULL)
		return NULL;
860
	nfs4_init_seqid_counter(&lsp->ls_seqid);
861
	refcount_set(&lsp->ls_count, 1);
862
	lsp->ls_state = state;
863
	lsp->ls_owner = fl_owner;
864 865
	lsp->ls_seqid.owner_id = ida_simple_get(&server->lockowner_id, 0, 0, GFP_NOFS);
	if (lsp->ls_seqid.owner_id < 0)
866
		goto out_free;
867
	INIT_LIST_HEAD(&lsp->ls_locks);
L
Linus Torvalds 已提交
868
	return lsp;
869 870 871
out_free:
	kfree(lsp);
	return NULL;
L
Linus Torvalds 已提交
872 873
}

874
void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
875
{
876
	ida_simple_remove(&server->lockowner_id, lsp->ls_seqid.owner_id);
877
	nfs4_destroy_seqid_counter(&lsp->ls_seqid);
878 879 880
	kfree(lsp);
}

L
Linus Torvalds 已提交
881 882 883 884 885
/*
 * Return a compatible lock_state. If no initialized lock_state structure
 * exists, return an uninitialized one.
 *
 */
886
static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner)
L
Linus Torvalds 已提交
887
{
888
	struct nfs4_lock_state *lsp, *new = NULL;
L
Linus Torvalds 已提交
889
	
890 891
	for(;;) {
		spin_lock(&state->state_lock);
892
		lsp = __nfs4_find_lock_state(state, owner, NULL);
893 894 895 896 897 898 899 900 901 902
		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);
903
		new = nfs4_alloc_lock_state(state, owner);
904 905 906 907
		if (new == NULL)
			return NULL;
	}
	spin_unlock(&state->state_lock);
908
	if (new != NULL)
909
		nfs4_free_lock_state(state->owner->so_server, new);
L
Linus Torvalds 已提交
910 911 912 913
	return lsp;
}

/*
914 915
 * Release reference to lock_state, and free it if we see that
 * it is no longer in use
L
Linus Torvalds 已提交
916
 */
917
void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
L
Linus Torvalds 已提交
918
{
919
	struct nfs_server *server;
920
	struct nfs4_state *state;
L
Linus Torvalds 已提交
921

922 923 924
	if (lsp == NULL)
		return;
	state = lsp->ls_state;
925
	if (!refcount_dec_and_lock(&lsp->ls_count, &state->state_lock))
926 927 928 929 930
		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);
931 932 933 934 935 936
	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
937
		nfs4_free_lock_state(server, lsp);
L
Linus Torvalds 已提交
938 939
}

940
static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
L
Linus Torvalds 已提交
941
{
942
	struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
L
Linus Torvalds 已提交
943

944
	dst->fl_u.nfs4_fl.owner = lsp;
945
	refcount_inc(&lsp->ls_count);
946
}
L
Linus Torvalds 已提交
947

948
static void nfs4_fl_release_lock(struct file_lock *fl)
L
Linus Torvalds 已提交
949
{
950
	nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
L
Linus Torvalds 已提交
951 952
}

953
static const struct file_lock_operations nfs4_fl_lock_ops = {
954 955 956 957 958
	.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 已提交
959
{
960 961 962 963
	struct nfs4_lock_state *lsp;

	if (fl->fl_ops != NULL)
		return 0;
964
	lsp = nfs4_get_lock_state(state, fl->fl_owner);
965 966 967 968 969
	if (lsp == NULL)
		return -ENOMEM;
	fl->fl_u.nfs4_fl.owner = lsp;
	fl->fl_ops = &nfs4_fl_lock_ops;
	return 0;
L
Linus Torvalds 已提交
970 971
}

972 973
static int nfs4_copy_lock_stateid(nfs4_stateid *dst,
		struct nfs4_state *state,
974
		const struct nfs_lock_context *l_ctx)
L
Linus Torvalds 已提交
975
{
976
	struct nfs4_lock_state *lsp;
977
	fl_owner_t fl_owner, fl_flock_owner;
978
	int ret = -ENOENT;
L
Linus Torvalds 已提交
979

980
	if (l_ctx == NULL)
981 982
		goto out;

983
	if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
984
		goto out;
L
Linus Torvalds 已提交
985

986
	fl_owner = l_ctx->lockowner;
987 988
	fl_flock_owner = l_ctx->open_context->flock_owner;

989
	spin_lock(&state->state_lock);
990
	lsp = __nfs4_find_lock_state(state, fl_owner, fl_flock_owner);
991 992 993
	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) {
994
		nfs4_stateid_copy(dst, &lsp->ls_stateid);
995
		ret = 0;
996
	}
997
	spin_unlock(&state->state_lock);
L
Linus Torvalds 已提交
998
	nfs4_put_lock_state(lsp);
999 1000 1001 1002
out:
	return ret;
}

1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
bool nfs4_refresh_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
{
	bool ret;
	int seq;

	do {
		ret = false;
		seq = read_seqbegin(&state->seqlock);
		if (nfs4_state_match_open_stateid_other(state, dst)) {
			dst->seqid = state->open_stateid.seqid;
			ret = true;
		}
	} while (read_seqretry(&state->seqlock, seq));
	return ret;
}

1019
bool nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
1020
{
1021
	bool ret;
1022
	const nfs4_stateid *src;
1023 1024 1025
	int seq;

	do {
1026
		ret = false;
1027
		src = &zero_stateid;
1028
		seq = read_seqbegin(&state->seqlock);
1029
		if (test_bit(NFS_OPEN_STATE, &state->flags)) {
1030
			src = &state->open_stateid;
1031 1032
			ret = true;
		}
1033
		nfs4_stateid_copy(dst, src);
1034
	} while (read_seqretry(&state->seqlock, seq));
1035
	return ret;
1036 1037 1038 1039 1040 1041
}

/*
 * Byte-range lock aware utility to initialize the stateid of read/write
 * requests.
 */
1042
int nfs4_select_rw_stateid(struct nfs4_state *state,
1043
		fmode_t fmode, const struct nfs_lock_context *l_ctx,
1044
		nfs4_stateid *dst, struct rpc_cred **cred)
1045
{
1046 1047
	int ret;

1048 1049
	if (!nfs4_valid_open_stateid(state))
		return -EIO;
1050 1051
	if (cred != NULL)
		*cred = NULL;
1052
	ret = nfs4_copy_lock_stateid(dst, state, l_ctx);
1053 1054 1055
	if (ret == -EIO)
		/* A lost lock - don't even consider delegations */
		goto out;
1056
	/* returns true if delegation stateid found and copied */
1057
	if (nfs4_copy_delegation_stateid(state->inode, fmode, dst, cred)) {
1058
		ret = 0;
1059
		goto out;
1060
	}
1061
	if (ret != -ENOENT)
1062 1063 1064 1065
		/* nfs4_copy_delegation_stateid() didn't over-write
		 * dst, so it still has the lock stateid which we now
		 * choose to use.
		 */
1066
		goto out;
1067 1068
	nfs4_copy_open_stateid(dst, state);
	ret = 0;
1069
out:
1070 1071
	if (nfs_server_capable(state->inode, NFS_CAP_STATEID_NFSV41))
		dst->seqid = 0;
1072
	return ret;
L
Linus Torvalds 已提交
1073 1074
}

1075
struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
1076 1077 1078
{
	struct nfs_seqid *new;

1079
	new = kmalloc(sizeof(*new), gfp_mask);
1080 1081 1082 1083 1084
	if (new == NULL)
		return ERR_PTR(-ENOMEM);
	new->sequence = counter;
	INIT_LIST_HEAD(&new->list);
	new->task = NULL;
1085 1086 1087
	return new;
}

1088
void nfs_release_seqid(struct nfs_seqid *seqid)
L
Linus Torvalds 已提交
1089
{
1090
	struct nfs_seqid_counter *sequence;
1091

1092
	if (seqid == NULL || list_empty(&seqid->list))
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
		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);
1103
	}
1104
	spin_unlock(&sequence->lock);
1105 1106 1107 1108 1109
}

void nfs_free_seqid(struct nfs_seqid *seqid)
{
	nfs_release_seqid(seqid);
1110
	kfree(seqid);
L
Linus Torvalds 已提交
1111 1112 1113
}

/*
1114 1115
 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
 * failed with a seqid incrementing error -
1116
 * see comments nfs4.h:seqid_mutating_error()
1117
 */
1118
static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
1119 1120 1121 1122 1123
{
	switch (status) {
		case 0:
			break;
		case -NFS4ERR_BAD_SEQID:
1124 1125
			if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
				return;
1126
			pr_warn_ratelimited("NFS: v4 server returned a bad"
1127 1128
					" sequence-id error on an"
					" unconfirmed sequence %p!\n",
1129
					seqid->sequence);
1130 1131 1132 1133 1134 1135
		case -NFS4ERR_STALE_CLIENTID:
		case -NFS4ERR_STALE_STATEID:
		case -NFS4ERR_BAD_STATEID:
		case -NFS4ERR_BADXDR:
		case -NFS4ERR_RESOURCE:
		case -NFS4ERR_NOFILEHANDLE:
1136
		case -NFS4ERR_MOVED:
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148
			/* 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)
{
1149 1150 1151 1152
	struct nfs4_state_owner *sp;

	if (seqid == NULL)
		return;
1153

1154
	sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid);
1155
	if (status == -NFS4ERR_BAD_SEQID)
1156
		nfs4_reset_state_owner(sp);
1157
	if (!nfs4_has_session(sp->so_server->nfs_client))
1158
		nfs_increment_seqid(status, seqid);
1159 1160 1161 1162 1163
}

/*
 * Increment the seqid if the LOCK/LOCKU succeeded, or
 * failed with a seqid incrementing error -
1164
 * see comments nfs4.h:seqid_mutating_error()
1165 1166 1167
 */
void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
{
1168 1169
	if (seqid != NULL)
		nfs_increment_seqid(status, seqid);
1170 1171 1172 1173
}

int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
{
1174
	struct nfs_seqid_counter *sequence;
1175 1176
	int status = 0;

1177 1178 1179
	if (seqid == NULL)
		goto out;
	sequence = seqid->sequence;
1180
	spin_lock(&sequence->lock);
1181
	seqid->task = task;
1182 1183 1184 1185
	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;
1186
	rpc_sleep_on(&sequence->wait, task, NULL);
1187 1188
	status = -EAGAIN;
unlock:
1189
	spin_unlock(&sequence->lock);
1190
out:
1191
	return status;
L
Linus Torvalds 已提交
1192 1193
}

1194
static int nfs4_run_state_manager(void *);
L
Linus Torvalds 已提交
1195

1196
static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
1197
{
1198
	smp_mb__before_atomic();
1199
	clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
1200
	smp_mb__after_atomic();
1201
	wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
1202 1203 1204
	rpc_wake_up(&clp->cl_rpcwaitq);
}

L
Linus Torvalds 已提交
1205
/*
1206
 * Schedule the nfs_client asynchronous state management routine
L
Linus Torvalds 已提交
1207
 */
1208
void nfs4_schedule_state_manager(struct nfs_client *clp)
L
Linus Torvalds 已提交
1209
{
1210
	struct task_struct *task;
1211
	char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
L
Linus Torvalds 已提交
1212

1213 1214
	if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
		return;
1215
	__module_get(THIS_MODULE);
1216
	refcount_inc(&clp->cl_count);
1217 1218 1219 1220 1221 1222 1223 1224

	/* 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();
1225
	task = kthread_run(nfs4_run_state_manager, clp, "%s", buf);
1226 1227 1228 1229 1230 1231 1232
	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 已提交
1233 1234 1235
}

/*
1236
 * Schedule a lease recovery attempt
L
Linus Torvalds 已提交
1237
 */
1238
void nfs4_schedule_lease_recovery(struct nfs_client *clp)
L
Linus Torvalds 已提交
1239 1240 1241
{
	if (!clp)
		return;
1242 1243
	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1244 1245
	dprintk("%s: scheduling lease recovery for server %s\n", __func__,
			clp->cl_hostname);
1246
	nfs4_schedule_state_manager(clp);
L
Linus Torvalds 已提交
1247
}
1248
EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
L
Linus Torvalds 已提交
1249

1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
/**
 * 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);

1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
/**
 * 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);

1302 1303 1304 1305 1306 1307
int nfs4_wait_clnt_recover(struct nfs_client *clp)
{
	int res;

	might_sleep();

1308
	refcount_inc(&clp->cl_count);
1309 1310
	res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
				 nfs_wait_bit_killable, TASK_KILLABLE);
1311
	if (res)
1312
		goto out;
1313
	if (clp->cl_cons_state < 0)
1314 1315 1316 1317
		res = clp->cl_cons_state;
out:
	nfs_put_client(clp);
	return res;
1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
}

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;
}

1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
/*
 * 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);
1350 1351
	dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
			clp->cl_hostname);
1352 1353
}

1354 1355
void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
{
1356
	nfs40_handle_cb_pathdown(clp);
1357 1358 1359
	nfs4_schedule_state_manager(clp);
}

1360
static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1361 1362
{

1363 1364
	if (!nfs4_valid_open_stateid(state))
		return 0;
1365 1366 1367 1368 1369 1370
	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;
	}
1371
	set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
1372 1373 1374 1375
	set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
	return 1;
}

1376
int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1377
{
1378 1379
	if (!nfs4_valid_open_stateid(state))
		return 0;
1380 1381
	set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
	clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1382
	set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
1383 1384 1385 1386
	set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
	return 1;
}

1387
int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
1388 1389 1390
{
	struct nfs_client *clp = server->nfs_client;

1391
	if (!nfs4_state_mark_reclaim_nograce(clp, state))
1392
		return -EBADF;
1393 1394
	nfs_inode_find_delegation_state_and_recover(state->inode,
			&state->stateid);
1395 1396
	dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
			clp->cl_hostname);
1397
	nfs4_schedule_state_manager(clp);
1398
	return 0;
1399
}
1400
EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1401

1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
static struct nfs4_lock_state *
nfs_state_find_lock_state_by_stateid(struct nfs4_state *state,
		const nfs4_stateid *stateid)
{
	struct nfs4_lock_state *pos;

	list_for_each_entry(pos, &state->lock_states, ls_locks) {
		if (!test_bit(NFS_LOCK_INITIALIZED, &pos->ls_flags))
			continue;
		if (nfs4_stateid_match_other(&pos->ls_stateid, stateid))
			return pos;
	}
	return NULL;
}

static bool nfs_state_lock_state_matches_stateid(struct nfs4_state *state,
		const nfs4_stateid *stateid)
{
	bool found = false;

	if (test_bit(LK_STATE_IN_USE, &state->flags)) {
		spin_lock(&state->state_lock);
		if (nfs_state_find_lock_state_by_stateid(state, stateid))
			found = true;
		spin_unlock(&state->state_lock);
	}
	return found;
}

1431 1432 1433 1434 1435 1436 1437 1438 1439
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;

1440 1441
	rcu_read_lock();
	list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
1442 1443 1444
		state = ctx->state;
		if (state == NULL)
			continue;
1445 1446
		if (nfs4_stateid_match_other(&state->stateid, stateid) &&
		    nfs4_state_mark_reclaim_nograce(clp, state)) {
1447
			found = true;
1448
			continue;
1449
		}
1450 1451 1452 1453 1454
		if (nfs4_stateid_match_other(&state->open_stateid, stateid) &&
		    nfs4_state_mark_reclaim_nograce(clp, state)) {
			found = true;
			continue;
		}
1455 1456
		if (nfs_state_lock_state_matches_stateid(state, stateid) &&
		    nfs4_state_mark_reclaim_nograce(clp, state))
1457
			found = true;
1458
	}
1459
	rcu_read_unlock();
1460 1461

	nfs_inode_find_delegation_state_and_recover(inode, stateid);
1462 1463 1464 1465
	if (found)
		nfs4_schedule_state_manager(clp);
}

1466 1467 1468 1469 1470 1471
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;

1472 1473
	rcu_read_lock();
	list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
1474 1475 1476 1477
		if (ctx->state != state)
			continue;
		set_bit(NFS_CONTEXT_BAD, &ctx->flags);
	}
1478
	rcu_read_unlock();
1479 1480
}

1481 1482 1483
static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
{
	set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags);
1484
	nfs4_state_mark_open_context_bad(state);
1485 1486
}

1487

1488
static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1489 1490
{
	struct inode *inode = state->inode;
1491
	struct nfs_inode *nfsi = NFS_I(inode);
L
Linus Torvalds 已提交
1492
	struct file_lock *fl;
1493
	struct nfs4_lock_state *lsp;
L
Linus Torvalds 已提交
1494
	int status = 0;
1495
	struct file_lock_context *flctx = inode->i_flctx;
1496
	struct list_head *list;
L
Linus Torvalds 已提交
1497

1498
	if (flctx == NULL)
1499 1500
		return 0;

1501 1502
	list = &flctx->flc_posix;

1503
	/* Guard against delegation returns and new lock/unlock calls */
1504
	down_write(&nfsi->rwsem);
1505
	spin_lock(&flctx->flc_lock);
1506 1507
restart:
	list_for_each_entry(fl, list, fl_list) {
1508 1509
		if (nfs_file_open_context(fl->fl_file)->state != state)
			continue;
1510
		spin_unlock(&flctx->flc_lock);
1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
		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);
1530
			/* Fall through */
1531 1532 1533 1534
		case -ENOMEM:
		case -NFS4ERR_DENIED:
		case -NFS4ERR_RECLAIM_BAD:
		case -NFS4ERR_RECLAIM_CONFLICT:
1535 1536 1537
			lsp = fl->fl_u.nfs4_fl.owner;
			if (lsp)
				set_bit(NFS_LOCK_LOST, &lsp->ls_flags);
1538 1539
			status = 0;
		}
1540
		spin_lock(&flctx->flc_lock);
1541
	}
1542 1543 1544 1545
	if (list == &flctx->flc_posix) {
		list = &flctx->flc_flock;
		goto restart;
	}
1546
	spin_unlock(&flctx->flc_lock);
1547
out:
1548
	up_write(&nfsi->rwsem);
L
Linus Torvalds 已提交
1549 1550 1551
	return status;
}

1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576
#ifdef CONFIG_NFS_V4_2
static void nfs42_complete_copies(struct nfs4_state_owner *sp, struct nfs4_state *state)
{
	struct nfs4_copy_state *copy;

	if (!test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags))
		return;

	spin_lock(&sp->so_server->nfs_client->cl_lock);
	list_for_each_entry(copy, &sp->so_server->ss_copies, copies) {
		if (nfs4_stateid_match_other(&state->stateid, &copy->parent_state->stateid))
			continue;
		copy->flags = 1;
		complete(&copy->completion);
		break;
	}
	spin_unlock(&sp->so_server->nfs_client->cl_lock);
}
#else /* !CONFIG_NFS_V4_2 */
static inline void nfs42_complete_copies(struct nfs4_state_owner *sp,
					 struct nfs4_state *state)
{
}
#endif /* CONFIG_NFS_V4_2 */

1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599
static int __nfs4_reclaim_open_state(struct nfs4_state_owner *sp, struct nfs4_state *state,
				     const struct nfs4_state_recovery_ops *ops)
{
	struct nfs4_lock_state *lock;
	int status;

	status = ops->recover_open(sp, state);
	if (status < 0)
		return status;

	status = nfs4_reclaim_locks(state, ops);
	if (status < 0)
		return status;

	if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
		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);
	}

1600
	nfs42_complete_copies(sp, state);
1601 1602 1603 1604
	clear_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
	return status;
}

1605
static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617
{
	struct nfs4_state *state;
	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.
	 */
1618
	spin_lock(&sp->so_lock);
1619
	raw_write_seqcount_begin(&sp->so_reclaim_seqcount);
1620
restart:
L
Linus Torvalds 已提交
1621
	list_for_each_entry(state, &sp->so_states, open_states) {
1622 1623
		if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
			continue;
1624 1625
		if (!nfs4_valid_open_stateid(state))
			continue;
L
Linus Torvalds 已提交
1626 1627
		if (state->state == 0)
			continue;
1628
		refcount_inc(&state->count);
1629
		spin_unlock(&sp->so_lock);
1630 1631
		status = __nfs4_reclaim_open_state(sp, state, ops);

L
Linus Torvalds 已提交
1632
		switch (status) {
1633 1634
		default:
			if (status >= 0)
1635
				break;
1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
			printk(KERN_ERR "NFS: %s: unhandled error %d\n", __func__, status);
			/* Fall through */
		case -ENOENT:
		case -ENOMEM:
		case -EACCES:
		case -EROFS:
		case -EIO:
		case -ESTALE:
			/* Open state on this file cannot be recovered */
			nfs4_state_mark_recovery_failed(state, status);
			break;
		case -EAGAIN:
			ssleep(1);
			/* Fall through */
		case -NFS4ERR_ADMIN_REVOKED:
		case -NFS4ERR_STALE_STATEID:
		case -NFS4ERR_OLD_STATEID:
		case -NFS4ERR_BAD_STATEID:
		case -NFS4ERR_RECLAIM_BAD:
		case -NFS4ERR_RECLAIM_CONFLICT:
			nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
			break;
		case -NFS4ERR_EXPIRED:
		case -NFS4ERR_NO_GRACE:
			nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
		case -NFS4ERR_STALE_CLIENTID:
		case -NFS4ERR_BADSESSION:
		case -NFS4ERR_BADSLOT:
		case -NFS4ERR_BAD_HIGH_SLOT:
		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
			goto out_err;
L
Linus Torvalds 已提交
1667
		}
1668
		nfs4_put_open_state(state);
1669
		spin_lock(&sp->so_lock);
1670
		goto restart;
L
Linus Torvalds 已提交
1671
	}
1672
	raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1673
	spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1674 1675
	return 0;
out_err:
1676
	nfs4_put_open_state(state);
1677
	spin_lock(&sp->so_lock);
1678
	raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1679
	spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1680 1681 1682
	return status;
}

1683 1684 1685 1686 1687 1688 1689 1690
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);
1691
	spin_lock(&state->state_lock);
1692 1693
	list_for_each_entry(lock, &state->lock_states, ls_locks) {
		lock->ls_seqid.flags = 0;
1694
		clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags);
1695
	}
1696
	spin_unlock(&state->state_lock);
1697 1698
}

1699 1700
static void nfs4_reset_seqids(struct nfs_server *server,
	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1701
{
1702
	struct nfs_client *clp = server->nfs_client;
1703
	struct nfs4_state_owner *sp;
1704
	struct rb_node *pos;
1705 1706
	struct nfs4_state *state;

1707 1708 1709 1710 1711
	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);
1712
		sp->so_seqid.flags = 0;
1713
		spin_lock(&sp->so_lock);
1714
		list_for_each_entry(state, &sp->so_states, open_states) {
1715 1716
			if (mark_reclaim(clp, state))
				nfs4_clear_open_state(state);
1717
		}
1718
		spin_unlock(&sp->so_lock);
1719
	}
1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731
	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();
1732 1733
}

1734 1735 1736 1737 1738 1739 1740
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);
}

1741
static int nfs4_reclaim_complete(struct nfs_client *clp,
1742 1743
				 const struct nfs4_state_recovery_ops *ops,
				 struct rpc_cred *cred)
1744 1745 1746
{
	/* Notify the server we're done reclaiming our state */
	if (ops->reclaim_complete)
1747 1748
		return ops->reclaim_complete(clp, cred);
	return 0;
1749 1750
}

1751
static void nfs4_clear_reclaim_server(struct nfs_server *server)
1752
{
1753
	struct nfs_client *clp = server->nfs_client;
1754 1755 1756 1757
	struct nfs4_state_owner *sp;
	struct rb_node *pos;
	struct nfs4_state *state;

1758 1759 1760 1761 1762
	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);
1763 1764
		spin_lock(&sp->so_lock);
		list_for_each_entry(state, &sp->so_states, open_states) {
1765 1766
			if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
						&state->flags))
1767 1768 1769 1770 1771
				continue;
			nfs4_state_mark_reclaim_nograce(clp, state);
		}
		spin_unlock(&sp->so_lock);
	}
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785
	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();
1786 1787

	nfs_delegation_reap_unclaimed(clp);
1788 1789 1790 1791 1792
	return 1;
}

static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
{
1793 1794
	const struct nfs4_state_recovery_ops *ops;
	struct rpc_cred *cred;
1795
	int err;
1796

1797 1798
	if (!nfs4_state_clear_reclaim_reboot(clp))
		return;
1799
	ops = clp->cl_mvops->reboot_recovery_ops;
1800
	cred = nfs4_get_clid_cred(clp);
1801
	err = nfs4_reclaim_complete(clp, ops, cred);
1802
	put_rpccred(cred);
1803 1804
	if (err == -NFS4ERR_CONN_NOT_BOUND_TO_SESSION)
		set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1805 1806 1807 1808
}

static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
{
1809
	nfs_mark_test_expired_all_delegations(clp);
1810 1811 1812
	nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
}

1813
static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1814 1815
{
	switch (error) {
1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847
	case 0:
		break;
	case -NFS4ERR_CB_PATH_DOWN:
		nfs40_handle_cb_pathdown(clp);
		break;
	case -NFS4ERR_NO_GRACE:
		nfs4_state_end_reclaim_reboot(clp);
		break;
	case -NFS4ERR_STALE_CLIENTID:
		set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
		nfs4_state_start_reclaim_reboot(clp);
		break;
	case -NFS4ERR_EXPIRED:
		set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
		nfs4_state_start_reclaim_nograce(clp);
		break;
	case -NFS4ERR_BADSESSION:
	case -NFS4ERR_BADSLOT:
	case -NFS4ERR_BAD_HIGH_SLOT:
	case -NFS4ERR_DEADSESSION:
	case -NFS4ERR_SEQ_FALSE_RETRY:
	case -NFS4ERR_SEQ_MISORDERED:
		set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
		/* Zero session reset errors */
		break;
	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
		set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
		break;
	default:
		dprintk("%s: failed to handle error %d for server %s\n",
				__func__, error, clp->cl_hostname);
		return error;
1848
	}
1849 1850
	dprintk("%s: handled error %d for server %s\n", __func__, error,
			clp->cl_hostname);
1851
	return 0;
1852 1853
}

1854
static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1855
{
1856 1857
	struct nfs4_state_owner *sp;
	struct nfs_server *server;
1858
	struct rb_node *pos;
L
Linus Torvalds 已提交
1859 1860
	int status = 0;

1861
restart:
1862 1863
	rcu_read_lock();
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1864
		nfs4_purge_state_owners(server);
1865 1866 1867 1868 1869 1870 1871 1872 1873
		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;
1874 1875
			if (!atomic_inc_not_zero(&sp->so_count))
				continue;
1876 1877 1878 1879 1880 1881 1882
			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);
1883 1884
				status = nfs4_recovery_handle_error(clp, status);
				return (status != 0) ? status : -EAGAIN;
1885 1886
			}

1887
			nfs4_put_state_owner(sp);
1888
			goto restart;
1889
		}
1890
		spin_unlock(&clp->cl_lock);
1891
	}
1892
	rcu_read_unlock();
1893
	return 0;
1894 1895 1896 1897 1898
}

static int nfs4_check_lease(struct nfs_client *clp)
{
	struct rpc_cred *cred;
1899 1900
	const struct nfs4_state_maintenance_ops *ops =
		clp->cl_mvops->state_renewal_ops;
1901
	int status;
L
Linus Torvalds 已提交
1902

1903 1904 1905
	/* Is the client already known to have an expired lease? */
	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		return 0;
1906 1907 1908
	spin_lock(&clp->cl_lock);
	cred = ops->get_state_renewal_cred_locked(clp);
	spin_unlock(&clp->cl_lock);
1909
	if (cred == NULL) {
1910
		cred = nfs4_get_clid_cred(clp);
1911
		status = -ENOKEY;
1912 1913
		if (cred == NULL)
			goto out;
1914
	}
1915
	status = ops->renew_lease(clp, cred);
1916
	put_rpccred(cred);
1917 1918 1919 1920
	if (status == -ETIMEDOUT) {
		set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
		return 0;
	}
1921
out:
1922
	return nfs4_recovery_handle_error(clp, status);
1923 1924
}

1925 1926
/* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
 * and for recoverable errors on EXCHANGE_ID for v4.1
1927 1928 1929 1930
 */
static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
{
	switch (status) {
1931 1932 1933 1934 1935
	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);
1936 1937
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
		break;
1938 1939
	case -NFS4ERR_STALE_CLIENTID:
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1940
		nfs4_state_start_reclaim_reboot(clp);
1941
		break;
1942 1943 1944 1945 1946 1947
	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;
1948 1949 1950 1951 1952 1953 1954 1955 1956 1957
	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);
1958 1959
		dprintk("%s: exit with error %d for server %s\n",
				__func__, -EPROTONOSUPPORT, clp->cl_hostname);
1960 1961 1962 1963
		return -EPROTONOSUPPORT;
	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
				 * in nfs4_exchange_id */
	default:
1964 1965
		dprintk("%s: exit with error %d for server %s\n", __func__,
				status, clp->cl_hostname);
1966 1967 1968
		return status;
	}
	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1969 1970
	dprintk("%s: handled error %d for server %s\n", __func__, status,
			clp->cl_hostname);
1971 1972 1973
	return 0;
}

1974
static int nfs4_establish_lease(struct nfs_client *clp)
1975 1976
{
	struct rpc_cred *cred;
1977 1978
	const struct nfs4_state_recovery_ops *ops =
		clp->cl_mvops->reboot_recovery_ops;
1979
	int status;
1980

1981 1982 1983
	status = nfs4_begin_drain_session(clp);
	if (status != 0)
		return status;
1984
	cred = nfs4_get_clid_cred(clp);
1985 1986 1987 1988 1989
	if (cred == NULL)
		return -ENOENT;
	status = ops->establish_clid(clp, cred);
	put_rpccred(cred);
	if (status != 0)
1990 1991 1992 1993 1994
		return status;
	pnfs_destroy_all_layouts(clp);
	return 0;
}

1995 1996 1997 1998
/*
 * Returns zero or a negative errno.  NFS4ERR values are converted
 * to local errno values.
 */
1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020
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)
2021
		return nfs4_handle_reclaim_lease_error(clp, status);
2022 2023 2024
	clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
	nfs4_state_start_reclaim_nograce(clp);
2025
	return 0;
2026 2027
}

2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055
/*
 * 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;
	}

2056
	inode = d_inode(server->super->s_root);
2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070
	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;
	}

2071 2072 2073
	status = nfs4_begin_drain_session(clp);
	if (status != 0)
		return status;
2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142

	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;
}

2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176
/*
 * 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();

2177
		inode = d_inode(server->super->s_root);
2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191
		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;
}

2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211
/**
 * 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;
2212
	int i, status;
2213 2214 2215 2216 2217 2218 2219 2220

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

	clnt = clp->cl_rpcclient;
	i = 0;

	mutex_lock(&nfs_clid_init_mutex);
again:
2221
	status  = -ENOENT;
2222
	cred = nfs4_get_clid_cred(clp);
2223 2224 2225 2226 2227 2228 2229
	if (cred == NULL)
		goto out_unlock;

	status = ops->detect_trunking(clp, result, cred);
	put_rpccred(cred);
	switch (status) {
	case 0:
2230 2231
	case -EINTR:
	case -ERESTARTSYS:
2232 2233
		break;
	case -ETIMEDOUT:
2234 2235
		if (clnt->cl_softrtry)
			break;
2236
		/* Fall through */
2237
	case -NFS4ERR_DELAY:
2238 2239
	case -EAGAIN:
		ssleep(1);
2240
		/* Fall through */
2241
	case -NFS4ERR_STALE_CLIENTID:
2242 2243 2244
		dprintk("NFS: %s after status %d, retrying\n",
			__func__, status);
		goto again;
2245
	case -EACCES:
2246 2247 2248 2249
		if (i++ == 0) {
			nfs4_root_machine_cred(clp);
			goto again;
		}
2250
		if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX)
2251
			break;
2252
		/* Fall through */
2253 2254
	case -NFS4ERR_CLID_INUSE:
	case -NFS4ERR_WRONGSEC:
2255 2256 2257 2258 2259
		/* No point in retrying if we already used RPC_AUTH_UNIX */
		if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) {
			status = -EPERM;
			break;
		}
2260
		clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX);
2261 2262 2263 2264
		if (IS_ERR(clnt)) {
			status = PTR_ERR(clnt);
			break;
		}
2265 2266 2267 2268 2269 2270 2271
		/* 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;
2272 2273 2274 2275 2276 2277 2278 2279 2280 2281
		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;
2282 2283 2284 2285 2286
		break;
	default:
		pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
				__func__, status);
		status = -EIO;
2287 2288 2289 2290 2291 2292 2293 2294
	}

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

2295
#ifdef CONFIG_NFS_V4_1
2296
void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
2297
{
2298 2299
	struct nfs_client *clp = session->clp;

2300 2301 2302 2303 2304 2305 2306
	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);
	}
2307
	nfs4_schedule_state_manager(clp);
2308
}
2309
EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
2310

2311
void nfs41_notify_server(struct nfs_client *clp)
2312 2313 2314 2315 2316 2317
{
	/* Use CHECK_LEASE to ping the server with a SEQUENCE */
	set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
	nfs4_schedule_state_manager(clp);
}

2318 2319 2320
static void nfs4_reset_all_state(struct nfs_client *clp)
{
	if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2321
		set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
2322
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
2323
		nfs4_state_start_reclaim_nograce(clp);
2324 2325
		dprintk("%s: scheduling reset of all state for server %s!\n",
				__func__, clp->cl_hostname);
2326
		nfs4_schedule_state_manager(clp);
2327 2328 2329 2330 2331 2332 2333
	}
}

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);
2334 2335
		dprintk("%s: server %s rebooted!\n", __func__,
				clp->cl_hostname);
2336
		nfs4_schedule_state_manager(clp);
2337 2338 2339
	}
}

2340
static void nfs41_handle_all_state_revoked(struct nfs_client *clp)
2341 2342
{
	nfs4_reset_all_state(clp);
2343
	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2344 2345
}

2346 2347
static void nfs41_handle_some_state_revoked(struct nfs_client *clp)
{
2348
	nfs4_state_start_reclaim_nograce(clp);
2349 2350 2351 2352 2353
	nfs4_schedule_state_manager(clp);

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

2354 2355
static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
{
2356 2357 2358 2359
	/* 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);
2360 2361
	dprintk("%s: Recallable state revoked on server %s!\n", __func__,
			clp->cl_hostname);
2362 2363
}

2364
static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
2365
{
2366 2367 2368
	set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
	nfs4_schedule_state_manager(clp);

2369 2370
	dprintk("%s: server %s declared a backchannel fault\n", __func__,
			clp->cl_hostname);
2371 2372
}

2373 2374 2375 2376 2377 2378 2379
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);
}

2380 2381
void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags,
		bool recovery)
2382 2383 2384
{
	if (!flags)
		return;
2385 2386 2387

	dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
		__func__, clp->cl_hostname, clp->cl_clientid, flags);
2388 2389 2390 2391 2392 2393 2394 2395
	/*
	 * If we're called from the state manager thread, then assume we're
	 * already handling the RECLAIM_NEEDED and/or STATE_REVOKED.
	 * Those flags are expected to remain set until we're done
	 * recovering (see RFC5661, section 18.46.3).
	 */
	if (recovery)
		goto out_recovery;
2396

2397
	if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
2398
		nfs41_handle_server_reboot(clp);
2399 2400 2401
	if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED))
		nfs41_handle_all_state_revoked(clp);
	if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
2402
			    SEQ4_STATUS_ADMIN_STATE_REVOKED))
2403
		nfs41_handle_some_state_revoked(clp);
2404 2405
	if (flags & SEQ4_STATUS_LEASE_MOVED)
		nfs4_schedule_lease_moved_recovery(clp);
2406
	if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
2407
		nfs41_handle_recallable_state_revoked(clp);
2408
out_recovery:
2409 2410 2411 2412
	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))
2413
		nfs41_handle_cb_path_down(clp);
2414 2415
}

2416 2417
static int nfs4_reset_session(struct nfs_client *clp)
{
2418
	struct rpc_cred *cred;
2419 2420
	int status;

2421 2422
	if (!nfs4_has_session(clp))
		return 0;
2423 2424 2425
	status = nfs4_begin_drain_session(clp);
	if (status != 0)
		return status;
2426
	cred = nfs4_get_clid_cred(clp);
2427
	status = nfs4_proc_destroy_session(clp->cl_session, cred);
2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439
	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:
2440
		status = nfs4_recovery_handle_error(clp, status);
2441 2442 2443 2444
		goto out;
	}

	memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
2445
	status = nfs4_proc_create_session(clp, cred);
2446
	if (status) {
2447 2448
		dprintk("%s: session reset failed with status %d for server %s!\n",
			__func__, status, clp->cl_hostname);
2449
		status = nfs4_handle_reclaim_lease_error(clp, status);
2450 2451
		goto out;
	}
2452
	nfs41_finish_session_reset(clp);
2453 2454
	dprintk("%s: session reset was successful for server %s!\n",
			__func__, clp->cl_hostname);
2455
out:
2456 2457
	if (cred)
		put_rpccred(cred);
2458 2459
	return status;
}
2460

2461 2462
static int nfs4_bind_conn_to_session(struct nfs_client *clp)
{
2463 2464 2465
	struct rpc_cred *cred;
	int ret;

2466 2467
	if (!nfs4_has_session(clp))
		return 0;
2468 2469 2470
	ret = nfs4_begin_drain_session(clp);
	if (ret != 0)
		return ret;
2471
	cred = nfs4_get_clid_cred(clp);
2472 2473 2474
	ret = nfs4_proc_bind_conn_to_session(clp, cred);
	if (cred)
		put_rpccred(cred);
2475
	clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2476 2477
	switch (ret) {
	case 0:
2478 2479
		dprintk("%s: bind_conn_to_session was successful for server %s!\n",
			__func__, clp->cl_hostname);
2480 2481 2482 2483 2484 2485 2486 2487 2488
		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;
2489
}
2490
#else /* CONFIG_NFS_V4_1 */
2491
static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
2492 2493 2494 2495 2496

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

2499
static void nfs4_state_manager(struct nfs_client *clp)
2500 2501
{
	int status = 0;
2502
	const char *section = "", *section_sep = "";
2503 2504

	/* Ensure exclusive access to NFSv4 state */
2505
	do {
2506
		if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2507
			section = "purge state";
2508
			status = nfs4_purge_lease(clp);
2509 2510
			if (status < 0)
				goto out_error;
2511
			continue;
2512 2513
		}

2514
		if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
2515
			section = "lease expired";
2516 2517
			/* We're going to have to re-establish a clientid */
			status = nfs4_reclaim_lease(clp);
2518
			if (status < 0)
2519
				goto out_error;
2520
			continue;
2521 2522
		}

2523
		/* Initialize or reset the session */
2524
		if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) {
2525
			section = "reset session";
2526
			status = nfs4_reset_session(clp);
2527 2528 2529
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
				continue;
			if (status < 0)
2530 2531
				goto out_error;
		}
2532

2533 2534
		/* Send BIND_CONN_TO_SESSION */
		if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2535
				&clp->cl_state)) {
2536
			section = "bind conn to session";
2537 2538 2539
			status = nfs4_bind_conn_to_session(clp);
			if (status < 0)
				goto out_error;
2540
			continue;
2541 2542
		}

2543 2544 2545 2546 2547
		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 已提交
2548
			continue;
2549 2550 2551 2552 2553 2554 2555
		}

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

2558 2559 2560 2561 2562 2563 2564
		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;
		}

2565
		/* First recover reboot state... */
2566
		if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
2567
			section = "reclaim reboot";
2568
			status = nfs4_do_reclaim(clp,
2569
				clp->cl_mvops->reboot_recovery_ops);
2570
			if (status == -EAGAIN)
2571 2572 2573
				continue;
			if (status < 0)
				goto out_error;
2574
			nfs4_state_end_reclaim_reboot(clp);
2575 2576
		}

2577 2578 2579 2580 2581 2582 2583
		/* Detect expired delegations... */
		if (test_and_clear_bit(NFS4CLNT_DELEGATION_EXPIRED, &clp->cl_state)) {
			section = "detect expired delegations";
			nfs_reap_expired_delegations(clp);
			continue;
		}

2584 2585
		/* Now recover expired state... */
		if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
2586
			section = "reclaim nograce";
2587
			status = nfs4_do_reclaim(clp,
2588
				clp->cl_mvops->nograce_recovery_ops);
2589
			if (status == -EAGAIN)
2590 2591
				continue;
			if (status < 0)
2592
				goto out_error;
L
Linus Torvalds 已提交
2593
		}
2594

2595
		nfs4_end_drain_session(clp);
2596 2597 2598 2599
		if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
			nfs_client_return_marked_delegations(clp);
			continue;
		}
2600 2601

		nfs4_clear_state_manager_bit(clp);
2602 2603
		/* Did we race with an attempt to give us more work? */
		if (clp->cl_state == 0)
2604
			return;
2605
		if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
2606
			return;
2607
	} while (refcount_read(&clp->cl_count) > 1);
2608 2609
	goto out_drain;

L
Linus Torvalds 已提交
2610
out_error:
2611 2612 2613 2614 2615
	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);
2616
	ssleep(1);
2617
out_drain:
2618
	nfs4_end_drain_session(clp);
2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630
	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 已提交
2631 2632 2633 2634 2635 2636 2637
}

/*
 * Local variables:
 *  c-basic-offset: 8
 * End:
 */
新手
引导
客服 返回
顶部