nfs4state.c 57.9 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 45
#include <linux/nfs_fs.h>
#include <linux/nfs_idmap.h>
46 47
#include <linux/kthread.h>
#include <linux/module.h>
48
#include <linux/random.h>
49
#include <linux/ratelimit.h>
L
Linus Torvalds 已提交
50 51
#include <linux/workqueue.h>
#include <linux/bitops.h>
52
#include <linux/jiffies.h>
L
Linus Torvalds 已提交
53

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

56
#include "nfs4_fs.h"
L
Linus Torvalds 已提交
57 58
#include "callback.h"
#include "delegation.h"
59
#include "internal.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
static DEFINE_MUTEX(nfs_clid_init_mutex);
L
Linus Torvalds 已提交
70

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

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

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

103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
/**
 * 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,
	};
124
	struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
125 126 127
	unsigned short port;
	int status;

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

	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);
139
	if (status == 0) {
140 141 142 143 144 145 146 147
		/* 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;
}

148
struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp)
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
{
	struct rpc_cred *cred = NULL;

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

static void nfs4_clear_machine_cred(struct nfs_client *clp)
{
	struct rpc_cred *cred;

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

169 170
static struct rpc_cred *
nfs4_get_renew_cred_server_locked(struct nfs_server *server)
171
{
172
	struct rpc_cred *cred = NULL;
173
	struct nfs4_state_owner *sp;
174
	struct rb_node *pos;
175

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

188 189 190 191 192 193 194 195 196 197 198 199
/**
 * 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;

200 201 202 203 204
	/* Use machine credentials if available */
	cred = nfs4_get_machine_cred_locked(clp);
	if (cred != NULL)
		goto out;

205 206 207 208 209 210 211
	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();
212 213

out:
214 215 216
	return cred;
}

217 218
#if defined(CONFIG_NFS_V4_1)

R
Ricardo Labiaga 已提交
219 220 221 222 223
static int nfs41_setup_state_renewal(struct nfs_client *clp)
{
	int status;
	struct nfs_fsinfo fsinfo;

224 225 226 227 228
	if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
		nfs4_schedule_state_renewal(clp);
		return 0;
	}

R
Ricardo Labiaga 已提交
229 230 231 232 233 234 235 236 237 238 239 240 241 242
	status = nfs4_proc_get_lease_time(clp, &fsinfo);
	if (status == 0) {
		/* Update lease time and schedule renewal */
		spin_lock(&clp->cl_lock);
		clp->cl_lease_time = fsinfo.lease_time * HZ;
		clp->cl_last_renewal = jiffies;
		spin_unlock(&clp->cl_lock);

		nfs4_schedule_state_renewal(clp);
	}

	return status;
}

243 244 245 246 247
/*
 * Back channel returns NFS4ERR_DELAY for new requests when
 * NFS4_SESSION_DRAINING is set so there is no work to be done when draining
 * is ended.
 */
248
static void nfs4_end_drain_session(struct nfs_client *clp)
249
{
250
	struct nfs4_session *ses = clp->cl_session;
251
	struct nfs4_slot_table *tbl;
252

253 254
	if (ses == NULL)
		return;
255
	tbl = &ses->fc_slot_table;
256
	if (test_and_clear_bit(NFS4_SESSION_DRAINING, &ses->session_state)) {
257
		spin_lock(&tbl->slot_tbl_lock);
258
		nfs41_wake_slot_table(tbl);
259
		spin_unlock(&tbl->slot_tbl_lock);
260
	}
261 262
}

263 264 265 266 267 268 269 270 271 272
/*
 * Signal state manager thread if session fore channel is drained
 */
void nfs4_session_drain_complete(struct nfs4_session *session,
		struct nfs4_slot_table *tbl)
{
	if (nfs4_session_draining(session))
		complete(&tbl->complete);
}

273
static int nfs4_wait_on_slot_tbl(struct nfs4_slot_table *tbl)
274 275
{
	spin_lock(&tbl->slot_tbl_lock);
276
	if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
277
		INIT_COMPLETION(tbl->complete);
278
		spin_unlock(&tbl->slot_tbl_lock);
279
		return wait_for_completion_interruptible(&tbl->complete);
280 281 282 283 284
	}
	spin_unlock(&tbl->slot_tbl_lock);
	return 0;
}

285 286 287 288 289 290 291 292 293 294 295 296 297 298
static int nfs4_begin_drain_session(struct nfs_client *clp)
{
	struct nfs4_session *ses = clp->cl_session;
	int ret = 0;

	set_bit(NFS4_SESSION_DRAINING, &ses->session_state);
	/* back channel */
	ret = nfs4_wait_on_slot_tbl(&ses->bc_slot_table);
	if (ret)
		return ret;
	/* fore channel */
	return nfs4_wait_on_slot_tbl(&ses->fc_slot_table);
}

299 300 301 302 303 304 305 306 307
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);
}

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

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

329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
/**
 * 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;
351
	set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
352 353 354 355

	return nfs41_walk_client_list(clp, result, cred);
}

356 357 358 359 360 361 362 363 364 365 366 367
struct rpc_cred *nfs4_get_exchange_id_cred(struct nfs_client *clp)
{
	struct rpc_cred *cred;

	spin_lock(&clp->cl_lock);
	cred = nfs4_get_machine_cred_locked(clp);
	spin_unlock(&clp->cl_lock);
	return cred;
}

#endif /* CONFIG_NFS_V4_1 */

368 369
static struct rpc_cred *
nfs4_get_setclientid_cred_server(struct nfs_server *server)
370
{
371 372
	struct nfs_client *clp = server->nfs_client;
	struct rpc_cred *cred = NULL;
373
	struct nfs4_state_owner *sp;
374
	struct rb_node *pos;
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394

	spin_lock(&clp->cl_lock);
	pos = rb_first(&server->state_owners);
	if (pos != NULL) {
		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
		cred = get_rpccred(sp->so_cred);
	}
	spin_unlock(&clp->cl_lock);
	return cred;
}

/**
 * nfs4_get_setclientid_cred - Acquire credential for a setclientid operation
 * @clp: client state handle
 *
 * Returns an rpc_cred with reference count bumped, or NULL.
 */
struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp)
{
	struct nfs_server *server;
395
	struct rpc_cred *cred;
396

397 398
	spin_lock(&clp->cl_lock);
	cred = nfs4_get_machine_cred_locked(clp);
399
	spin_unlock(&clp->cl_lock);
400 401
	if (cred != NULL)
		goto out;
402 403 404 405 406 407

	rcu_read_lock();
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
		cred = nfs4_get_setclientid_cred_server(server);
		if (cred != NULL)
			break;
408
	}
409 410
	rcu_read_unlock();

411 412
out:
	return cred;
413 414
}

L
Linus Torvalds 已提交
415
static struct nfs4_state_owner *
416
nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred)
L
Linus Torvalds 已提交
417
{
418
	struct rb_node **p = &server->state_owners.rb_node,
419
		       *parent = NULL;
420
	struct nfs4_state_owner *sp;
L
Linus Torvalds 已提交
421

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

		if (cred < sp->so_cred)
			p = &parent->rb_left;
		else if (cred > sp->so_cred)
			p = &parent->rb_right;
		else {
431 432
			if (!list_empty(&sp->so_lru))
				list_del_init(&sp->so_lru);
433
			atomic_inc(&sp->so_count);
434
			return sp;
435
		}
L
Linus Torvalds 已提交
436
	}
437
	return NULL;
L
Linus Torvalds 已提交
438 439
}

440
static struct nfs4_state_owner *
441
nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
442
{
443 444
	struct nfs_server *server = new->so_server;
	struct rb_node **p = &server->state_owners.rb_node,
445 446
		       *parent = NULL;
	struct nfs4_state_owner *sp;
447
	int err;
448 449 450

	while (*p != NULL) {
		parent = *p;
451
		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
452 453 454 455 456 457

		if (new->so_cred < sp->so_cred)
			p = &parent->rb_left;
		else if (new->so_cred > sp->so_cred)
			p = &parent->rb_right;
		else {
458 459
			if (!list_empty(&sp->so_lru))
				list_del_init(&sp->so_lru);
460 461 462 463
			atomic_inc(&sp->so_count);
			return sp;
		}
	}
464
	err = ida_get_new(&server->openowner_id, &new->so_seqid.owner_id);
465 466
	if (err)
		return ERR_PTR(err);
467 468
	rb_link_node(&new->so_server_node, parent, p);
	rb_insert_color(&new->so_server_node, &server->state_owners);
469 470 471 472
	return new;
}

static void
473
nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
474
{
475 476 477 478
	struct nfs_server *server = sp->so_server;

	if (!RB_EMPTY_NODE(&sp->so_server_node))
		rb_erase(&sp->so_server_node, &server->state_owners);
479
	ida_remove(&server->openowner_id, sp->so_seqid.owner_id);
480 481
}

482 483 484
static void
nfs4_init_seqid_counter(struct nfs_seqid_counter *sc)
{
485
	sc->create_time = ktime_get();
486 487 488 489 490 491 492 493 494 495 496 497 498
	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 已提交
499 500 501 502 503 504
/*
 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
 * create a new state_owner.
 *
 */
static struct nfs4_state_owner *
505 506 507
nfs4_alloc_state_owner(struct nfs_server *server,
		struct rpc_cred *cred,
		gfp_t gfp_flags)
L
Linus Torvalds 已提交
508 509 510
{
	struct nfs4_state_owner *sp;

511
	sp = kzalloc(sizeof(*sp), gfp_flags);
L
Linus Torvalds 已提交
512 513
	if (!sp)
		return NULL;
514 515
	sp->so_server = server;
	sp->so_cred = get_rpccred(cred);
516
	spin_lock_init(&sp->so_lock);
L
Linus Torvalds 已提交
517
	INIT_LIST_HEAD(&sp->so_states);
518
	nfs4_init_seqid_counter(&sp->so_seqid);
L
Linus Torvalds 已提交
519
	atomic_set(&sp->so_count, 1);
520
	INIT_LIST_HEAD(&sp->so_lru);
521
	seqcount_init(&sp->so_reclaim_seqcount);
522
	mutex_init(&sp->so_delegreturn_mutex);
L
Linus Torvalds 已提交
523 524 525
	return sp;
}

526
static void
L
Linus Torvalds 已提交
527 528
nfs4_drop_state_owner(struct nfs4_state_owner *sp)
{
529 530 531
	struct rb_node *rb_node = &sp->so_server_node;

	if (!RB_EMPTY_NODE(rb_node)) {
532 533
		struct nfs_server *server = sp->so_server;
		struct nfs_client *clp = server->nfs_client;
534 535

		spin_lock(&clp->cl_lock);
536 537 538 539
		if (!RB_EMPTY_NODE(rb_node)) {
			rb_erase(rb_node, &server->state_owners);
			RB_CLEAR_NODE(rb_node);
		}
540 541
		spin_unlock(&clp->cl_lock);
	}
L
Linus Torvalds 已提交
542 543
}

544 545
static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
{
546
	nfs4_destroy_seqid_counter(&sp->so_seqid);
547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
	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);
	}
}

576 577 578 579 580 581 582 583
/**
 * 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,
584 585
					      struct rpc_cred *cred,
					      gfp_t gfp_flags)
L
Linus Torvalds 已提交
586
{
587
	struct nfs_client *clp = server->nfs_client;
L
Linus Torvalds 已提交
588 589 590
	struct nfs4_state_owner *sp, *new;

	spin_lock(&clp->cl_lock);
591
	sp = nfs4_find_state_owner_locked(server, cred);
L
Linus Torvalds 已提交
592 593
	spin_unlock(&clp->cl_lock);
	if (sp != NULL)
594
		goto out;
595
	new = nfs4_alloc_state_owner(server, cred, gfp_flags);
596
	if (new == NULL)
597
		goto out;
598 599 600 601 602 603 604
	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));
605 606
	if (sp != new)
		nfs4_free_state_owner(new);
607 608
out:
	nfs4_gc_state_owners(server);
609
	return sp;
L
Linus Torvalds 已提交
610 611
}

612 613 614
/**
 * nfs4_put_state_owner - Release a nfs4_state_owner
 * @sp: state owner data to release
615 616 617 618 619 620 621 622
 *
 * 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.
623
 */
L
Linus Torvalds 已提交
624 625
void nfs4_put_state_owner(struct nfs4_state_owner *sp)
{
626 627
	struct nfs_server *server = sp->so_server;
	struct nfs_client *clp = server->nfs_client;
L
Linus Torvalds 已提交
628 629 630

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

632 633 634
	sp->so_expires = jiffies;
	list_add_tail(&sp->so_lru, &server->state_owners_lru);
	spin_unlock(&clp->cl_lock);
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
}

/**
 * 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 已提交
655
	spin_unlock(&clp->cl_lock);
656 657 658 659 660

	list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
		list_del(&sp->so_lru);
		nfs4_free_state_owner(sp);
	}
L
Linus Torvalds 已提交
661 662 663 664 665 666 667
}

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

668
	state = kzalloc(sizeof(*state), GFP_NOFS);
L
Linus Torvalds 已提交
669 670 671 672
	if (!state)
		return NULL;
	atomic_set(&state->count, 1);
	INIT_LIST_HEAD(&state->lock_states);
673
	spin_lock_init(&state->state_lock);
674
	seqlock_init(&state->seqlock);
L
Linus Torvalds 已提交
675 676 677
	return state;
}

678
void
679
nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
680
{
681
	if (state->state == fmode)
682 683
		return;
	/* NB! List reordering - see the reclaim code for why.  */
684 685
	if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
		if (fmode & FMODE_WRITE)
686 687 688 689
			list_move(&state->open_states, &state->owner->so_states);
		else
			list_move_tail(&state->open_states, &state->owner->so_states);
	}
690
	state->state = fmode;
691 692
}

L
Linus Torvalds 已提交
693 694 695 696 697 698 699
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) {
700
		if (state->owner != owner)
L
Linus Torvalds 已提交
701
			continue;
702
		if (atomic_inc_not_zero(&state->count))
L
Linus Torvalds 已提交
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
			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();
726
	spin_lock(&owner->so_lock);
L
Linus Torvalds 已提交
727 728 729 730 731 732 733
	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);
734 735
		ihold(inode);
		state->inode = inode;
L
Linus Torvalds 已提交
736
		spin_unlock(&inode->i_lock);
737 738 739 740
		/* 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 已提交
741 742
	} else {
		spin_unlock(&inode->i_lock);
743
		spin_unlock(&owner->so_lock);
L
Linus Torvalds 已提交
744 745 746 747 748 749 750 751 752 753 754 755
		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;

756
	if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
L
Linus Torvalds 已提交
757
		return;
758
	spin_lock(&inode->i_lock);
759
	list_del(&state->inode_states);
L
Linus Torvalds 已提交
760
	list_del(&state->open_states);
761 762
	spin_unlock(&inode->i_lock);
	spin_unlock(&owner->so_lock);
L
Linus Torvalds 已提交
763 764 765 766 767 768
	iput(inode);
	nfs4_free_open_state(state);
	nfs4_put_state_owner(owner);
}

/*
769
 * Close the current file.
L
Linus Torvalds 已提交
770
 */
771
static void __nfs4_close(struct nfs4_state *state,
772
		fmode_t fmode, gfp_t gfp_mask, int wait)
L
Linus Torvalds 已提交
773 774
{
	struct nfs4_state_owner *owner = state->owner;
775
	int call_close = 0;
776
	fmode_t newstate;
L
Linus Torvalds 已提交
777 778 779

	atomic_inc(&owner->so_count);
	/* Protect against nfs4_find_state() */
780
	spin_lock(&owner->so_lock);
781
	switch (fmode & (FMODE_READ | FMODE_WRITE)) {
782 783 784 785 786 787 788 789 790
		case FMODE_READ:
			state->n_rdonly--;
			break;
		case FMODE_WRITE:
			state->n_wronly--;
			break;
		case FMODE_READ|FMODE_WRITE:
			state->n_rdwr--;
	}
791
	newstate = FMODE_READ|FMODE_WRITE;
792
	if (state->n_rdwr == 0) {
793
		if (state->n_rdonly == 0) {
794
			newstate &= ~FMODE_READ;
795 796 797 798
			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) {
799
			newstate &= ~FMODE_WRITE;
800 801 802 803 804
			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);
805
	}
806
	nfs4_state_set_mode_locked(state, newstate);
807
	spin_unlock(&owner->so_lock);
808

809
	if (!call_close) {
810 811
		nfs4_put_open_state(state);
		nfs4_put_state_owner(owner);
812 813
	} else
		nfs4_do_close(state, gfp_mask, wait);
814 815
}

816
void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
817
{
818
	__nfs4_close(state, fmode, GFP_NOFS, 0);
819 820
}

821
void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
822
{
823
	__nfs4_close(state, fmode, GFP_KERNEL, 1);
L
Linus Torvalds 已提交
824 825 826 827 828 829 830
}

/*
 * Search the state->lock_states for an existing lock_owner
 * that is compatible with current->files
 */
static struct nfs4_lock_state *
831
__nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type)
L
Linus Torvalds 已提交
832 833 834
{
	struct nfs4_lock_state *pos;
	list_for_each_entry(pos, &state->lock_states, ls_locks) {
835
		if (type != NFS4_ANY_LOCK_TYPE && pos->ls_owner.lo_type != type)
L
Linus Torvalds 已提交
836
			continue;
837 838 839 840 841 842 843 844 845
		switch (pos->ls_owner.lo_type) {
		case NFS4_POSIX_LOCK_TYPE:
			if (pos->ls_owner.lo_u.posix_owner != fl_owner)
				continue;
			break;
		case NFS4_FLOCK_LOCK_TYPE:
			if (pos->ls_owner.lo_u.flock_owner != fl_pid)
				continue;
		}
L
Linus Torvalds 已提交
846 847 848 849 850 851 852 853 854 855 856
		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.
 *
 */
857
static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type)
L
Linus Torvalds 已提交
858 859
{
	struct nfs4_lock_state *lsp;
860
	struct nfs_server *server = state->owner->so_server;
L
Linus Torvalds 已提交
861

862
	lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
L
Linus Torvalds 已提交
863 864
	if (lsp == NULL)
		return NULL;
865
	nfs4_init_seqid_counter(&lsp->ls_seqid);
L
Linus Torvalds 已提交
866
	atomic_set(&lsp->ls_count, 1);
867
	lsp->ls_state = state;
868 869 870 871 872 873 874 875 876
	lsp->ls_owner.lo_type = type;
	switch (lsp->ls_owner.lo_type) {
	case NFS4_FLOCK_LOCK_TYPE:
		lsp->ls_owner.lo_u.flock_owner = fl_pid;
		break;
	case NFS4_POSIX_LOCK_TYPE:
		lsp->ls_owner.lo_u.posix_owner = fl_owner;
		break;
	default:
877
		goto out_free;
878
	}
879 880
	lsp->ls_seqid.owner_id = ida_simple_get(&server->lockowner_id, 0, 0, GFP_NOFS);
	if (lsp->ls_seqid.owner_id < 0)
881
		goto out_free;
882
	INIT_LIST_HEAD(&lsp->ls_locks);
L
Linus Torvalds 已提交
883
	return lsp;
884 885 886
out_free:
	kfree(lsp);
	return NULL;
L
Linus Torvalds 已提交
887 888
}

889
void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
890
{
891
	ida_simple_remove(&server->lockowner_id, lsp->ls_seqid.owner_id);
892
	nfs4_destroy_seqid_counter(&lsp->ls_seqid);
893 894 895
	kfree(lsp);
}

L
Linus Torvalds 已提交
896 897 898 899 900
/*
 * Return a compatible lock_state. If no initialized lock_state structure
 * exists, return an uninitialized one.
 *
 */
901
static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner, pid_t pid, unsigned int type)
L
Linus Torvalds 已提交
902
{
903
	struct nfs4_lock_state *lsp, *new = NULL;
L
Linus Torvalds 已提交
904
	
905 906
	for(;;) {
		spin_lock(&state->state_lock);
907
		lsp = __nfs4_find_lock_state(state, owner, pid, type);
908 909 910 911 912 913 914 915 916 917
		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);
918
		new = nfs4_alloc_lock_state(state, owner, pid, type);
919 920 921 922
		if (new == NULL)
			return NULL;
	}
	spin_unlock(&state->state_lock);
923
	if (new != NULL)
924
		nfs4_free_lock_state(state->owner->so_server, new);
L
Linus Torvalds 已提交
925 926 927 928
	return lsp;
}

/*
929 930
 * Release reference to lock_state, and free it if we see that
 * it is no longer in use
L
Linus Torvalds 已提交
931
 */
932
void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
L
Linus Torvalds 已提交
933
{
934
	struct nfs4_state *state;
L
Linus Torvalds 已提交
935

936 937 938 939 940 941 942 943 944
	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);
945
	if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
946 947 948
		if (nfs4_release_lockowner(lsp) == 0)
			return;
	}
949
	nfs4_free_lock_state(lsp->ls_state->owner->so_server, lsp);
L
Linus Torvalds 已提交
950 951
}

952
static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
L
Linus Torvalds 已提交
953
{
954
	struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
L
Linus Torvalds 已提交
955

956 957 958
	dst->fl_u.nfs4_fl.owner = lsp;
	atomic_inc(&lsp->ls_count);
}
L
Linus Torvalds 已提交
959

960
static void nfs4_fl_release_lock(struct file_lock *fl)
L
Linus Torvalds 已提交
961
{
962
	nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
L
Linus Torvalds 已提交
963 964
}

965
static const struct file_lock_operations nfs4_fl_lock_ops = {
966 967 968 969 970
	.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 已提交
971
{
972 973 974 975
	struct nfs4_lock_state *lsp;

	if (fl->fl_ops != NULL)
		return 0;
976 977 978
	if (fl->fl_flags & FL_POSIX)
		lsp = nfs4_get_lock_state(state, fl->fl_owner, 0, NFS4_POSIX_LOCK_TYPE);
	else if (fl->fl_flags & FL_FLOCK)
979 980
		lsp = nfs4_get_lock_state(state, NULL, fl->fl_pid,
				NFS4_FLOCK_LOCK_TYPE);
981 982
	else
		return -EINVAL;
983 984 985 986 987
	if (lsp == NULL)
		return -ENOMEM;
	fl->fl_u.nfs4_fl.owner = lsp;
	fl->fl_ops = &nfs4_fl_lock_ops;
	return 0;
L
Linus Torvalds 已提交
988 989
}

990
static bool nfs4_copy_lock_stateid(nfs4_stateid *dst, struct nfs4_state *state,
991
		const struct nfs_lockowner *lockowner)
L
Linus Torvalds 已提交
992
{
993
	struct nfs4_lock_state *lsp;
994 995
	fl_owner_t fl_owner;
	pid_t fl_pid;
996
	bool ret = false;
L
Linus Torvalds 已提交
997

998 999 1000 1001

	if (lockowner == NULL)
		goto out;

1002
	if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
1003
		goto out;
L
Linus Torvalds 已提交
1004

1005 1006
	fl_owner = lockowner->l_owner;
	fl_pid = lockowner->l_pid;
1007
	spin_lock(&state->state_lock);
1008
	lsp = __nfs4_find_lock_state(state, fl_owner, fl_pid, NFS4_ANY_LOCK_TYPE);
1009
	if (lsp != NULL && test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) {
1010
		nfs4_stateid_copy(dst, &lsp->ls_stateid);
1011 1012
		ret = true;
	}
1013
	spin_unlock(&state->state_lock);
L
Linus Torvalds 已提交
1014
	nfs4_put_lock_state(lsp);
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
out:
	return ret;
}

static void nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
{
	int seq;

	do {
		seq = read_seqbegin(&state->seqlock);
		nfs4_stateid_copy(dst, &state->stateid);
	} while (read_seqretry(&state->seqlock, seq));
}

/*
 * Byte-range lock aware utility to initialize the stateid of read/write
 * requests.
 */
void nfs4_select_rw_stateid(nfs4_stateid *dst, struct nfs4_state *state,
1034
		fmode_t fmode, const struct nfs_lockowner *lockowner)
1035 1036 1037
{
	if (nfs4_copy_delegation_stateid(dst, state->inode, fmode))
		return;
1038
	if (nfs4_copy_lock_stateid(dst, state, lockowner))
1039 1040
		return;
	nfs4_copy_open_stateid(dst, state);
L
Linus Torvalds 已提交
1041 1042
}

1043
struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
1044 1045 1046
{
	struct nfs_seqid *new;

1047
	new = kmalloc(sizeof(*new), gfp_mask);
1048 1049
	if (new != NULL) {
		new->sequence = counter;
1050
		INIT_LIST_HEAD(&new->list);
1051
		new->task = NULL;
1052 1053 1054 1055
	}
	return new;
}

1056
void nfs_release_seqid(struct nfs_seqid *seqid)
L
Linus Torvalds 已提交
1057
{
1058
	struct nfs_seqid_counter *sequence;
1059

1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
	if (list_empty(&seqid->list))
		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);
1071
	}
1072
	spin_unlock(&sequence->lock);
1073 1074 1075 1076 1077
}

void nfs_free_seqid(struct nfs_seqid *seqid)
{
	nfs_release_seqid(seqid);
1078
	kfree(seqid);
L
Linus Torvalds 已提交
1079 1080 1081
}

/*
1082 1083 1084 1085
 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
 * failed with a seqid incrementing error -
 * see comments nfs_fs.h:seqid_mutating_error()
 */
1086
static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
1087 1088 1089 1090 1091
{
	switch (status) {
		case 0:
			break;
		case -NFS4ERR_BAD_SEQID:
1092 1093
			if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
				return;
1094
			pr_warn_ratelimited("NFS: v4 server returned a bad"
D
Dan Muntz 已提交
1095 1096
					" sequence-id error on an"
					" unconfirmed sequence %p!\n",
1097
					seqid->sequence);
1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
		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)
{
1116 1117 1118 1119 1120
	struct nfs4_state_owner *sp = container_of(seqid->sequence,
					struct nfs4_state_owner, so_seqid);
	struct nfs_server *server = sp->so_server;

	if (status == -NFS4ERR_BAD_SEQID)
L
Linus Torvalds 已提交
1121
		nfs4_drop_state_owner(sp);
1122 1123
	if (!nfs4_has_session(server->nfs_client))
		nfs_increment_seqid(status, seqid);
1124 1125 1126 1127 1128 1129 1130 1131 1132
}

/*
 * Increment the seqid if the LOCK/LOCKU succeeded, or
 * failed with a seqid incrementing error -
 * see comments nfs_fs.h:seqid_mutating_error()
 */
void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
{
1133
	nfs_increment_seqid(status, seqid);
1134 1135 1136 1137
}

int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
{
1138
	struct nfs_seqid_counter *sequence = seqid->sequence;
1139 1140 1141
	int status = 0;

	spin_lock(&sequence->lock);
1142
	seqid->task = task;
1143 1144 1145 1146
	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;
1147
	rpc_sleep_on(&sequence->wait, task, NULL);
1148 1149
	status = -EAGAIN;
unlock:
1150 1151
	spin_unlock(&sequence->lock);
	return status;
L
Linus Torvalds 已提交
1152 1153
}

1154
static int nfs4_run_state_manager(void *);
L
Linus Torvalds 已提交
1155

1156
static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
T
Trond Myklebust 已提交
1157 1158
{
	smp_mb__before_clear_bit();
1159
	clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
T
Trond Myklebust 已提交
1160
	smp_mb__after_clear_bit();
1161
	wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
T
Trond Myklebust 已提交
1162 1163 1164
	rpc_wake_up(&clp->cl_rpcwaitq);
}

L
Linus Torvalds 已提交
1165
/*
1166
 * Schedule the nfs_client asynchronous state management routine
L
Linus Torvalds 已提交
1167
 */
1168
void nfs4_schedule_state_manager(struct nfs_client *clp)
L
Linus Torvalds 已提交
1169
{
1170
	struct task_struct *task;
1171
	char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
L
Linus Torvalds 已提交
1172

1173 1174
	if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
		return;
1175 1176
	__module_get(THIS_MODULE);
	atomic_inc(&clp->cl_count);
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192

	/* 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();
	task = kthread_run(nfs4_run_state_manager, clp, buf);
	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 已提交
1193 1194 1195
}

/*
1196
 * Schedule a lease recovery attempt
L
Linus Torvalds 已提交
1197
 */
1198
void nfs4_schedule_lease_recovery(struct nfs_client *clp)
L
Linus Torvalds 已提交
1199 1200 1201
{
	if (!clp)
		return;
1202 1203
	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1204 1205
	dprintk("%s: scheduling lease recovery for server %s\n", __func__,
			clp->cl_hostname);
1206
	nfs4_schedule_state_manager(clp);
L
Linus Torvalds 已提交
1207
}
A
Andy Adamson 已提交
1208
EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
L
Linus Torvalds 已提交
1209

1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
int nfs4_wait_clnt_recover(struct nfs_client *clp)
{
	int res;

	might_sleep();

	res = wait_on_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
			nfs_wait_bit_killable, TASK_KILLABLE);
	if (res)
		return res;

	if (clp->cl_cons_state < 0)
		return clp->cl_cons_state;
	return 0;
}

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

1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
/*
 * 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);
1256 1257
	dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
			clp->cl_hostname);
1258 1259
}

1260 1261
void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
{
1262
	nfs40_handle_cb_pathdown(clp);
1263 1264 1265
	nfs4_schedule_state_manager(clp);
}

1266
static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1267 1268 1269 1270 1271 1272 1273 1274
{

	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;
	}
1275
	set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
1276 1277 1278 1279
	set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
	return 1;
}

1280
static int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1281 1282 1283
{
	set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
	clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1284
	set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
1285 1286 1287 1288
	set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
	return 1;
}

1289 1290 1291 1292 1293
void nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
{
	struct nfs_client *clp = server->nfs_client;

	nfs4_state_mark_reclaim_nograce(clp, state);
1294 1295
	dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
			clp->cl_hostname);
1296 1297
	nfs4_schedule_state_manager(clp);
}
A
Andy Adamson 已提交
1298
EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1299

1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
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;
1316
		if (!nfs4_stateid_match(&state->stateid, stateid))
1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
			continue;
		nfs4_state_mark_reclaim_nograce(clp, state);
		found = true;
	}
	spin_unlock(&inode->i_lock);
	if (found)
		nfs4_schedule_state_manager(clp);
}


1327
static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1328 1329
{
	struct inode *inode = state->inode;
1330
	struct nfs_inode *nfsi = NFS_I(inode);
L
Linus Torvalds 已提交
1331 1332 1333
	struct file_lock *fl;
	int status = 0;

1334 1335 1336 1337
	if (inode->i_flock == NULL)
		return 0;

	/* Guard against delegation returns and new lock/unlock calls */
1338
	down_write(&nfsi->rwsem);
1339
	/* Protect inode->i_flock using the BKL */
1340
	lock_flocks();
H
Harvey Harrison 已提交
1341
	for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
1342
		if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
L
Linus Torvalds 已提交
1343
			continue;
1344
		if (nfs_file_open_context(fl->fl_file)->state != state)
L
Linus Torvalds 已提交
1345
			continue;
1346
		unlock_flocks();
L
Linus Torvalds 已提交
1347 1348
		status = ops->recover_lock(state, fl);
		switch (status) {
1349 1350 1351 1352 1353 1354 1355 1356 1357
			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:
1358 1359 1360 1361
			case -NFS4ERR_BADSESSION:
			case -NFS4ERR_BADSLOT:
			case -NFS4ERR_BAD_HIGH_SLOT:
			case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1362
				goto out;
L
Linus Torvalds 已提交
1363
			default:
1364 1365
				printk(KERN_ERR "NFS: %s: unhandled error %d. "
					"Zeroing state\n", __func__, status);
1366 1367
			case -ENOMEM:
			case -NFS4ERR_DENIED:
L
Linus Torvalds 已提交
1368 1369
			case -NFS4ERR_RECLAIM_BAD:
			case -NFS4ERR_RECLAIM_CONFLICT:
1370
				/* kill_proc(fl->fl_pid, SIGLOST, 1); */
1371
				status = 0;
L
Linus Torvalds 已提交
1372
		}
1373
		lock_flocks();
L
Linus Torvalds 已提交
1374
	}
1375
	unlock_flocks();
1376
out:
1377
	up_write(&nfsi->rwsem);
L
Linus Torvalds 已提交
1378 1379 1380
	return status;
}

1381
static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
{
	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.
	 */
1395
	spin_lock(&sp->so_lock);
1396 1397
	write_seqcount_begin(&sp->so_reclaim_seqcount);
restart:
L
Linus Torvalds 已提交
1398
	list_for_each_entry(state, &sp->so_states, open_states) {
1399 1400
		if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
			continue;
L
Linus Torvalds 已提交
1401 1402
		if (state->state == 0)
			continue;
1403 1404
		atomic_inc(&state->count);
		spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1405 1406
		status = ops->recover_open(sp, state);
		if (status >= 0) {
1407 1408
			status = nfs4_reclaim_locks(state, ops);
			if (status >= 0) {
1409
				spin_lock(&state->state_lock);
1410
				list_for_each_entry(lock, &state->lock_states, ls_locks) {
1411
					if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
1412 1413
						pr_warn_ratelimited("NFS: "
							"%s: Lock reclaim "
1414
							"failed!\n", __func__);
1415
				}
1416
				spin_unlock(&state->state_lock);
1417
				nfs4_put_open_state(state);
1418
				spin_lock(&sp->so_lock);
1419
				goto restart;
L
Linus Torvalds 已提交
1420 1421 1422 1423
			}
		}
		switch (status) {
			default:
1424 1425
				printk(KERN_ERR "NFS: %s: unhandled error %d. "
					"Zeroing state\n", __func__, status);
L
Linus Torvalds 已提交
1426
			case -ENOENT:
1427
			case -ENOMEM:
1428
			case -ESTALE:
L
Linus Torvalds 已提交
1429 1430 1431 1432
				/*
				 * Open state on this file cannot be recovered
				 * All we can do is revert to using the zero stateid.
				 */
1433 1434
				memset(&state->stateid, 0,
					sizeof(state->stateid));
L
Linus Torvalds 已提交
1435 1436 1437
				/* Mark the file as being 'closed' */
				state->state = 0;
				break;
1438 1439 1440
			case -NFS4ERR_ADMIN_REVOKED:
			case -NFS4ERR_STALE_STATEID:
			case -NFS4ERR_BAD_STATEID:
1441 1442
			case -NFS4ERR_RECLAIM_BAD:
			case -NFS4ERR_RECLAIM_CONFLICT:
1443
				nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1444
				break;
L
Linus Torvalds 已提交
1445 1446
			case -NFS4ERR_EXPIRED:
			case -NFS4ERR_NO_GRACE:
1447
				nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
L
Linus Torvalds 已提交
1448
			case -NFS4ERR_STALE_CLIENTID:
1449 1450 1451 1452
			case -NFS4ERR_BADSESSION:
			case -NFS4ERR_BADSLOT:
			case -NFS4ERR_BAD_HIGH_SLOT:
			case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
L
Linus Torvalds 已提交
1453 1454
				goto out_err;
		}
1455
		nfs4_put_open_state(state);
1456
		spin_lock(&sp->so_lock);
1457
		goto restart;
L
Linus Torvalds 已提交
1458
	}
1459
	write_seqcount_end(&sp->so_reclaim_seqcount);
1460
	spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1461 1462
	return 0;
out_err:
1463
	nfs4_put_open_state(state);
1464 1465 1466
	spin_lock(&sp->so_lock);
	write_seqcount_end(&sp->so_reclaim_seqcount);
	spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1467 1468 1469
	return status;
}

1470 1471 1472 1473 1474 1475 1476 1477
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);
1478
	spin_lock(&state->state_lock);
1479 1480
	list_for_each_entry(lock, &state->lock_states, ls_locks) {
		lock->ls_seqid.flags = 0;
1481
		clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags);
1482
	}
1483
	spin_unlock(&state->state_lock);
1484 1485
}

1486 1487
static void nfs4_reset_seqids(struct nfs_server *server,
	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1488
{
1489
	struct nfs_client *clp = server->nfs_client;
1490
	struct nfs4_state_owner *sp;
1491
	struct rb_node *pos;
1492 1493
	struct nfs4_state *state;

1494 1495 1496 1497 1498
	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);
1499
		sp->so_seqid.flags = 0;
1500
		spin_lock(&sp->so_lock);
1501
		list_for_each_entry(state, &sp->so_states, open_states) {
1502 1503
			if (mark_reclaim(clp, state))
				nfs4_clear_open_state(state);
1504
		}
1505
		spin_unlock(&sp->so_lock);
1506
	}
1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
	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();
1519 1520
}

1521 1522 1523 1524 1525 1526 1527
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);
}

1528 1529 1530 1531 1532 1533 1534 1535
static void nfs4_reclaim_complete(struct nfs_client *clp,
				 const struct nfs4_state_recovery_ops *ops)
{
	/* Notify the server we're done reclaiming our state */
	if (ops->reclaim_complete)
		(void)ops->reclaim_complete(clp);
}

1536
static void nfs4_clear_reclaim_server(struct nfs_server *server)
1537
{
1538
	struct nfs_client *clp = server->nfs_client;
1539 1540 1541 1542
	struct nfs4_state_owner *sp;
	struct rb_node *pos;
	struct nfs4_state *state;

1543 1544 1545 1546 1547
	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);
1548 1549
		spin_lock(&sp->so_lock);
		list_for_each_entry(state, &sp->so_states, open_states) {
1550 1551
			if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
						&state->flags))
1552 1553 1554 1555 1556
				continue;
			nfs4_state_mark_reclaim_nograce(clp, state);
		}
		spin_unlock(&sp->so_lock);
	}
1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
	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();
1571 1572

	nfs_delegation_reap_unclaimed(clp);
1573 1574 1575 1576 1577 1578 1579 1580
	return 1;
}

static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
{
	if (!nfs4_state_clear_reclaim_reboot(clp))
		return;
	nfs4_reclaim_complete(clp, clp->cl_mvops->reboot_recovery_ops);
1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594
}

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

1595
static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1596 1597
{
	switch (error) {
1598 1599
		case 0:
			break;
1600
		case -NFS4ERR_CB_PATH_DOWN:
1601
			nfs40_handle_cb_pathdown(clp);
1602
			break;
1603 1604
		case -NFS4ERR_NO_GRACE:
			nfs4_state_end_reclaim_reboot(clp);
1605
			break;
1606 1607 1608
		case -NFS4ERR_STALE_CLIENTID:
		case -NFS4ERR_LEASE_MOVED:
			set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1609
			nfs4_state_clear_reclaim_reboot(clp);
1610 1611 1612 1613 1614
			nfs4_state_start_reclaim_reboot(clp);
			break;
		case -NFS4ERR_EXPIRED:
			set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
			nfs4_state_start_reclaim_nograce(clp);
1615
			break;
1616 1617 1618 1619 1620 1621
		case -NFS4ERR_BADSESSION:
		case -NFS4ERR_BADSLOT:
		case -NFS4ERR_BAD_HIGH_SLOT:
		case -NFS4ERR_DEADSESSION:
		case -NFS4ERR_SEQ_FALSE_RETRY:
		case -NFS4ERR_SEQ_MISORDERED:
1622
			set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1623
			/* Zero session reset errors */
1624
			break;
1625 1626 1627
		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
			set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
			break;
1628
		default:
1629 1630
			dprintk("%s: failed to handle error %d for server %s\n",
					__func__, error, clp->cl_hostname);
1631
			return error;
1632
	}
1633 1634
	dprintk("%s: handled error %d for server %s\n", __func__, error,
			clp->cl_hostname);
1635
	return 0;
1636 1637
}

1638
static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1639
{
1640 1641
	struct nfs4_state_owner *sp;
	struct nfs_server *server;
1642
	struct rb_node *pos;
L
Linus Torvalds 已提交
1643 1644
	int status = 0;

1645
restart:
1646 1647
	rcu_read_lock();
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1648
		nfs4_purge_state_owners(server);
1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668
		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;
			atomic_inc(&sp->so_count);
			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);
				return nfs4_recovery_handle_error(clp, status);
			}

1669
			nfs4_put_state_owner(sp);
1670
			goto restart;
1671
		}
1672
		spin_unlock(&clp->cl_lock);
1673
	}
1674
	rcu_read_unlock();
1675 1676 1677 1678 1679 1680
	return status;
}

static int nfs4_check_lease(struct nfs_client *clp)
{
	struct rpc_cred *cred;
1681 1682
	const struct nfs4_state_maintenance_ops *ops =
		clp->cl_mvops->state_renewal_ops;
1683
	int status;
L
Linus Torvalds 已提交
1684

1685 1686 1687
	/* Is the client already known to have an expired lease? */
	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		return 0;
1688 1689 1690
	spin_lock(&clp->cl_lock);
	cred = ops->get_state_renewal_cred_locked(clp);
	spin_unlock(&clp->cl_lock);
1691 1692
	if (cred == NULL) {
		cred = nfs4_get_setclientid_cred(clp);
1693
		status = -ENOKEY;
1694 1695
		if (cred == NULL)
			goto out;
1696
	}
1697
	status = ops->renew_lease(clp, cred);
1698 1699
	put_rpccred(cred);
out:
1700
	return nfs4_recovery_handle_error(clp, status);
1701 1702
}

1703 1704
/* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
 * and for recoverable errors on EXCHANGE_ID for v4.1
1705 1706 1707 1708
 */
static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
{
	switch (status) {
1709 1710 1711 1712 1713
	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);
1714 1715
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
		break;
1716 1717
	case -NFS4ERR_STALE_CLIENTID:
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1718 1719
		nfs4_state_clear_reclaim_reboot(clp);
		nfs4_state_start_reclaim_reboot(clp);
1720
		break;
1721 1722 1723 1724 1725 1726
	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;
1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
	case -EACCES:
		if (clp->cl_machine_cred == NULL)
			return -EACCES;
		/* Handle case where the user hasn't set up machine creds */
		nfs4_clear_machine_cred(clp);
	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);
1741 1742
		dprintk("%s: exit with error %d for server %s\n",
				__func__, -EPROTONOSUPPORT, clp->cl_hostname);
1743 1744 1745 1746
		return -EPROTONOSUPPORT;
	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
				 * in nfs4_exchange_id */
	default:
1747 1748
		dprintk("%s: exit with error %d for server %s\n", __func__,
				status, clp->cl_hostname);
1749 1750 1751
		return status;
	}
	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1752 1753
	dprintk("%s: handled error %d for server %s\n", __func__, status,
			clp->cl_hostname);
1754 1755 1756
	return 0;
}

1757
static int nfs4_establish_lease(struct nfs_client *clp)
1758 1759
{
	struct rpc_cred *cred;
1760 1761
	const struct nfs4_state_recovery_ops *ops =
		clp->cl_mvops->reboot_recovery_ops;
1762
	int status;
1763

1764
	cred = ops->get_clid_cred(clp);
1765 1766 1767 1768 1769
	if (cred == NULL)
		return -ENOENT;
	status = ops->establish_clid(clp, cred);
	put_rpccred(cred);
	if (status != 0)
1770 1771 1772 1773 1774
		return status;
	pnfs_destroy_all_layouts(clp);
	return 0;
}

1775 1776 1777 1778
/*
 * Returns zero or a negative errno.  NFS4ERR values are converted
 * to local errno values.
 */
1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800
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)
1801
		return nfs4_handle_reclaim_lease_error(clp, status);
1802 1803 1804
	clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
	nfs4_state_start_reclaim_nograce(clp);
1805
	return 0;
1806 1807
}

1808 1809 1810 1811 1812 1813 1814 1815 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 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869
/**
 * 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;
	rpc_authflavor_t *flavors, flav, save;
	struct rpc_clnt *clnt;
	struct rpc_cred *cred;
	int i, len, status;

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

	len = NFS_MAX_SECFLAVORS;
	flavors = kcalloc(len, sizeof(*flavors), GFP_KERNEL);
	if (flavors == NULL) {
		status = -ENOMEM;
		goto out;
	}
	len = rpcauth_list_flavors(flavors, len);
	if (len < 0) {
		status = len;
		goto out_free;
	}
	clnt = clp->cl_rpcclient;
	save = clnt->cl_auth->au_flavor;
	i = 0;

	mutex_lock(&nfs_clid_init_mutex);
	status  = -ENOENT;
again:
	cred = ops->get_clid_cred(clp);
	if (cred == NULL)
		goto out_unlock;

	status = ops->detect_trunking(clp, result, cred);
	put_rpccred(cred);
	switch (status) {
	case 0:
		break;

	case -EACCES:
		if (clp->cl_machine_cred == NULL)
			break;
		/* Handle case where the user hasn't set up machine creds */
		nfs4_clear_machine_cred(clp);
	case -NFS4ERR_DELAY:
	case -ETIMEDOUT:
	case -EAGAIN:
		ssleep(1);
1870
	case -NFS4ERR_STALE_CLIENTID:
1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 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
		dprintk("NFS: %s after status %d, retrying\n",
			__func__, status);
		goto again;

	case -NFS4ERR_CLID_INUSE:
	case -NFS4ERR_WRONGSEC:
		status = -EPERM;
		if (i >= len)
			break;

		flav = flavors[i++];
		if (flav == save)
			flav = flavors[i++];
		clnt = rpc_clone_client_set_auth(clnt, flav);
		if (IS_ERR(clnt)) {
			status = PTR_ERR(clnt);
			break;
		}
		clp->cl_rpcclient = clnt;
		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;
	}

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

1911
#ifdef CONFIG_NFS_V4_1
1912
void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
1913
{
1914 1915
	struct nfs_client *clp = session->clp;

1916 1917 1918 1919 1920 1921 1922
	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);
	}
1923
	nfs4_schedule_lease_recovery(clp);
1924
}
1925
EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
1926

1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938
static void nfs41_ping_server(struct nfs_client *clp)
{
	/* Use CHECK_LEASE to ping the server with a SEQUENCE */
	set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
	nfs4_schedule_state_manager(clp);
}

void nfs41_server_notify_target_slotid_update(struct nfs_client *clp)
{
	nfs41_ping_server(clp);
}

1939 1940 1941 1942 1943
void nfs41_server_notify_highest_slotid_update(struct nfs_client *clp)
{
	nfs41_ping_server(clp);
}

1944 1945 1946
static void nfs4_reset_all_state(struct nfs_client *clp)
{
	if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
1947
		set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
1948
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1949
		nfs4_state_start_reclaim_nograce(clp);
1950 1951
		dprintk("%s: scheduling reset of all state for server %s!\n",
				__func__, clp->cl_hostname);
1952
		nfs4_schedule_state_manager(clp);
1953 1954 1955 1956 1957 1958 1959
	}
}

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);
1960 1961
		dprintk("%s: server %s rebooted!\n", __func__,
				clp->cl_hostname);
1962
		nfs4_schedule_state_manager(clp);
1963 1964 1965 1966 1967 1968
	}
}

static void nfs41_handle_state_revoked(struct nfs_client *clp)
{
	nfs4_reset_all_state(clp);
1969
	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
1970 1971 1972 1973 1974 1975
}

static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
{
	/* This will need to handle layouts too */
	nfs_expire_all_delegations(clp);
1976 1977
	dprintk("%s: Recallable state revoked on server %s!\n", __func__,
			clp->cl_hostname);
1978 1979
}

1980
static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
1981 1982 1983
{
	nfs_expire_all_delegations(clp);
	if (test_and_set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) == 0)
1984
		nfs4_schedule_state_manager(clp);
1985 1986
	dprintk("%s: server %s declared a backchannel fault\n", __func__,
			clp->cl_hostname);
1987 1988
}

1989 1990 1991 1992 1993 1994 1995
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);
}

1996 1997 1998 1999
void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)
{
	if (!flags)
		return;
2000 2001 2002 2003

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

2004
	if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
2005
		nfs41_handle_server_reboot(clp);
2006
	if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED |
2007 2008
			    SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
			    SEQ4_STATUS_ADMIN_STATE_REVOKED |
2009 2010
			    SEQ4_STATUS_LEASE_MOVED))
		nfs41_handle_state_revoked(clp);
2011
	if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
2012
		nfs41_handle_recallable_state_revoked(clp);
2013 2014 2015 2016
	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))
2017
		nfs41_handle_cb_path_down(clp);
2018 2019
}

2020 2021
static int nfs4_reset_session(struct nfs_client *clp)
{
2022
	struct rpc_cred *cred;
2023 2024
	int status;

2025 2026
	if (!nfs4_has_session(clp))
		return 0;
2027
	nfs4_begin_drain_session(clp);
2028 2029
	cred = nfs4_get_exchange_id_cred(clp);
	status = nfs4_proc_destroy_session(clp->cl_session, cred);
2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041
	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:
2042
		status = nfs4_recovery_handle_error(clp, status);
2043 2044 2045 2046
		goto out;
	}

	memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
2047
	status = nfs4_proc_create_session(clp, cred);
2048
	if (status) {
2049 2050
		dprintk("%s: session reset failed with status %d for server %s!\n",
			__func__, status, clp->cl_hostname);
2051
		status = nfs4_handle_reclaim_lease_error(clp, status);
2052 2053
		goto out;
	}
2054
	nfs41_finish_session_reset(clp);
2055 2056
	dprintk("%s: session reset was successful for server %s!\n",
			__func__, clp->cl_hostname);
2057
out:
2058 2059
	if (cred)
		put_rpccred(cred);
2060 2061
	return status;
}
2062

2063 2064
static int nfs4_bind_conn_to_session(struct nfs_client *clp)
{
2065 2066 2067
	struct rpc_cred *cred;
	int ret;

2068 2069
	if (!nfs4_has_session(clp))
		return 0;
2070
	nfs4_begin_drain_session(clp);
2071 2072 2073 2074
	cred = nfs4_get_exchange_id_cred(clp);
	ret = nfs4_proc_bind_conn_to_session(clp, cred);
	if (cred)
		put_rpccred(cred);
2075
	clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2076 2077
	switch (ret) {
	case 0:
2078 2079
		dprintk("%s: bind_conn_to_session was successful for server %s!\n",
			__func__, clp->cl_hostname);
2080 2081 2082 2083 2084 2085 2086 2087 2088
		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;
2089
}
2090
#else /* CONFIG_NFS_V4_1 */
2091
static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
2092
static int nfs4_end_drain_session(struct nfs_client *clp) { return 0; }
2093 2094 2095 2096 2097

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

2100
static void nfs4_state_manager(struct nfs_client *clp)
2101 2102
{
	int status = 0;
2103
	const char *section = "", *section_sep = "";
2104 2105

	/* Ensure exclusive access to NFSv4 state */
2106
	do {
2107
		if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2108
			section = "purge state";
2109
			status = nfs4_purge_lease(clp);
2110 2111
			if (status < 0)
				goto out_error;
2112
			continue;
2113 2114
		}

2115
		if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
2116
			section = "lease expired";
2117 2118
			/* We're going to have to re-establish a clientid */
			status = nfs4_reclaim_lease(clp);
2119
			if (status < 0)
2120
				goto out_error;
2121
			continue;
2122 2123
		}

2124
		/* Initialize or reset the session */
2125
		if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) {
2126
			section = "reset session";
2127
			status = nfs4_reset_session(clp);
2128 2129 2130
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
				continue;
			if (status < 0)
2131 2132
				goto out_error;
		}
2133

2134 2135
		/* Send BIND_CONN_TO_SESSION */
		if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2136
				&clp->cl_state)) {
2137
			section = "bind conn to session";
2138 2139 2140
			status = nfs4_bind_conn_to_session(clp);
			if (status < 0)
				goto out_error;
2141
			continue;
2142 2143
		}

2144 2145 2146 2147 2148 2149 2150 2151
		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;
			continue;
		}

2152
		/* First recover reboot state... */
2153
		if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
2154
			section = "reclaim reboot";
2155
			status = nfs4_do_reclaim(clp,
2156
				clp->cl_mvops->reboot_recovery_ops);
2157
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
2158
			    test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state))
2159
				continue;
2160
			nfs4_state_end_reclaim_reboot(clp);
2161 2162 2163 2164
			if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
				continue;
			if (status < 0)
				goto out_error;
2165 2166
		}

2167 2168
		/* Now recover expired state... */
		if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
2169
			section = "reclaim nograce";
2170
			status = nfs4_do_reclaim(clp,
2171
				clp->cl_mvops->nograce_recovery_ops);
2172
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
2173
			    test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) ||
2174 2175 2176
			    test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
				continue;
			if (status < 0)
2177
				goto out_error;
L
Linus Torvalds 已提交
2178
		}
2179

2180
		nfs4_end_drain_session(clp);
2181 2182 2183 2184
		if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
			nfs_client_return_marked_delegations(clp);
			continue;
		}
2185 2186

		nfs4_clear_state_manager_bit(clp);
2187 2188 2189 2190 2191
		/* 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;
2192
	} while (atomic_read(&clp->cl_count) > 1);
2193
	return;
L
Linus Torvalds 已提交
2194
out_error:
2195 2196 2197 2198 2199
	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);
2200
	ssleep(1);
2201
	nfs4_end_drain_session(clp);
2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213
	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 已提交
2214 2215 2216 2217 2218 2219 2220
}

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