nfs4state.c 58.0 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
{
	struct rpc_cred *cred = NULL;

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

157 158
static struct rpc_cred *
nfs4_get_renew_cred_server_locked(struct nfs_server *server)
159
{
160
	struct rpc_cred *cred = NULL;
161
	struct nfs4_state_owner *sp;
162
	struct rb_node *pos;
163

164 165 166 167
	for (pos = rb_first(&server->state_owners);
	     pos != NULL;
	     pos = rb_next(pos)) {
		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
168 169 170 171 172 173 174 175
		if (list_empty(&sp->so_states))
			continue;
		cred = get_rpccred(sp->so_cred);
		break;
	}
	return cred;
}

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

188 189 190 191 192
	/* Use machine credentials if available */
	cred = nfs4_get_machine_cred_locked(clp);
	if (cred != NULL)
		goto out;

193 194 195 196 197 198 199
	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();
200 201

out:
202 203 204
	return cred;
}

205 206
#if defined(CONFIG_NFS_V4_1)

R
Ricardo Labiaga 已提交
207 208 209 210 211
static int nfs41_setup_state_renewal(struct nfs_client *clp)
{
	int status;
	struct nfs_fsinfo fsinfo;

212 213 214 215 216
	if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
		nfs4_schedule_state_renewal(clp);
		return 0;
	}

R
Ricardo Labiaga 已提交
217 218 219 220 221 222 223 224 225 226 227 228 229 230
	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;
}

231 232 233 234 235
/*
 * 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.
 */
236
static void nfs4_end_drain_session(struct nfs_client *clp)
237
{
238
	struct nfs4_session *ses = clp->cl_session;
239
	struct nfs4_slot_table *tbl;
240

241 242
	if (ses == NULL)
		return;
243
	tbl = &ses->fc_slot_table;
244
	if (test_and_clear_bit(NFS4_SESSION_DRAINING, &ses->session_state)) {
245
		spin_lock(&tbl->slot_tbl_lock);
246
		nfs41_wake_slot_table(tbl);
247
		spin_unlock(&tbl->slot_tbl_lock);
248
	}
249 250
}

251 252 253 254 255 256 257 258 259 260
/*
 * 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);
}

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

273 274 275 276 277 278 279 280 281 282 283 284 285 286
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);
}

287 288 289 290 291 292 293 294 295
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);
}

296 297 298 299
int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
{
	int status;

300 301
	if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
		goto do_confirm;
302
	nfs4_begin_drain_session(clp);
303
	status = nfs4_proc_exchange_id(clp, cred);
R
Ricardo Labiaga 已提交
304 305
	if (status != 0)
		goto out;
306 307
	set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
do_confirm:
308
	status = nfs4_proc_create_session(clp, cred);
R
Ricardo Labiaga 已提交
309 310
	if (status != 0)
		goto out;
311
	nfs41_finish_session_reset(clp);
R
Ricardo Labiaga 已提交
312 313
	nfs_mark_client_ready(clp, NFS_CS_READY);
out:
314 315 316
	return status;
}

317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
/**
 * 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;
339
	set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
340 341 342 343

	return nfs41_walk_client_list(clp, result, cred);
}

344 345 346 347 348 349 350 351 352 353 354 355
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 */

356 357
static struct rpc_cred *
nfs4_get_setclientid_cred_server(struct nfs_server *server)
358
{
359 360
	struct nfs_client *clp = server->nfs_client;
	struct rpc_cred *cred = NULL;
361
	struct nfs4_state_owner *sp;
362
	struct rb_node *pos;
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382

	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;
383
	struct rpc_cred *cred;
384

385 386
	spin_lock(&clp->cl_lock);
	cred = nfs4_get_machine_cred_locked(clp);
387
	spin_unlock(&clp->cl_lock);
388 389
	if (cred != NULL)
		goto out;
390 391 392 393 394 395

	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;
396
	}
397 398
	rcu_read_unlock();

399 400
out:
	return cred;
401 402
}

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

410 411
	while (*p != NULL) {
		parent = *p;
412
		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
413 414 415 416 417 418

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

428
static struct nfs4_state_owner *
429
nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
430
{
431 432
	struct nfs_server *server = new->so_server;
	struct rb_node **p = &server->state_owners.rb_node,
433 434
		       *parent = NULL;
	struct nfs4_state_owner *sp;
435
	int err;
436 437 438

	while (*p != NULL) {
		parent = *p;
439
		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
440 441 442 443 444 445

		if (new->so_cred < sp->so_cred)
			p = &parent->rb_left;
		else if (new->so_cred > sp->so_cred)
			p = &parent->rb_right;
		else {
446 447
			if (!list_empty(&sp->so_lru))
				list_del_init(&sp->so_lru);
448 449 450 451
			atomic_inc(&sp->so_count);
			return sp;
		}
	}
452
	err = ida_get_new(&server->openowner_id, &new->so_seqid.owner_id);
453 454
	if (err)
		return ERR_PTR(err);
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
	ida_remove(&server->openowner_id, sp->so_seqid.owner_id);
468 469
}

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

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

514
static void
L
Linus Torvalds 已提交
515 516
nfs4_drop_state_owner(struct nfs4_state_owner *sp)
{
517 518 519
	struct rb_node *rb_node = &sp->so_server_node;

	if (!RB_EMPTY_NODE(rb_node)) {
520 521
		struct nfs_server *server = sp->so_server;
		struct nfs_client *clp = server->nfs_client;
522 523

		spin_lock(&clp->cl_lock);
524 525 526 527
		if (!RB_EMPTY_NODE(rb_node)) {
			rb_erase(rb_node, &server->state_owners);
			RB_CLEAR_NODE(rb_node);
		}
528 529
		spin_unlock(&clp->cl_lock);
	}
L
Linus Torvalds 已提交
530 531
}

532 533
static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
{
534
	nfs4_destroy_seqid_counter(&sp->so_seqid);
535 536 537 538 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
	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);
	}
}

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

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

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

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

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

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

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

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

656
	state = kzalloc(sizeof(*state), GFP_NOFS);
L
Linus Torvalds 已提交
657 658 659 660
	if (!state)
		return NULL;
	atomic_set(&state->count, 1);
	INIT_LIST_HEAD(&state->lock_states);
661
	spin_lock_init(&state->state_lock);
662
	seqlock_init(&state->seqlock);
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 687
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) {
688
		if (state->owner != owner)
L
Linus Torvalds 已提交
689
			continue;
690 691
		if (!nfs4_valid_open_stateid(state))
			continue;
692
		if (atomic_inc_not_zero(&state->count))
L
Linus Torvalds 已提交
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
			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();
716
	spin_lock(&owner->so_lock);
L
Linus Torvalds 已提交
717 718 719 720 721 722 723
	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);
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 (!atomic_dec_and_lock(&state->count, &owner->so_lock))
L
Linus Torvalds 已提交
747
		return;
748
	spin_lock(&inode->i_lock);
749
	list_del(&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 818 819 820
}

/*
 * Search the state->lock_states for an existing lock_owner
 * that is compatible with current->files
 */
static struct nfs4_lock_state *
821
__nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type)
L
Linus Torvalds 已提交
822 823 824
{
	struct nfs4_lock_state *pos;
	list_for_each_entry(pos, &state->lock_states, ls_locks) {
825
		if (type != NFS4_ANY_LOCK_TYPE && pos->ls_owner.lo_type != type)
L
Linus Torvalds 已提交
826
			continue;
827 828 829 830 831 832 833 834 835
		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 已提交
836 837 838 839 840 841 842 843 844 845 846
		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.
 *
 */
847
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 已提交
848 849
{
	struct nfs4_lock_state *lsp;
850
	struct nfs_server *server = state->owner->so_server;
L
Linus Torvalds 已提交
851

852
	lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
L
Linus Torvalds 已提交
853 854
	if (lsp == NULL)
		return NULL;
855
	nfs4_init_seqid_counter(&lsp->ls_seqid);
L
Linus Torvalds 已提交
856
	atomic_set(&lsp->ls_count, 1);
857
	lsp->ls_state = state;
858 859 860 861 862 863 864 865 866
	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:
867
		goto out_free;
868
	}
869 870
	lsp->ls_seqid.owner_id = ida_simple_get(&server->lockowner_id, 0, 0, GFP_NOFS);
	if (lsp->ls_seqid.owner_id < 0)
871
		goto out_free;
872
	INIT_LIST_HEAD(&lsp->ls_locks);
L
Linus Torvalds 已提交
873
	return lsp;
874 875 876
out_free:
	kfree(lsp);
	return NULL;
L
Linus Torvalds 已提交
877 878
}

879
void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
880
{
881
	ida_simple_remove(&server->lockowner_id, lsp->ls_seqid.owner_id);
882
	nfs4_destroy_seqid_counter(&lsp->ls_seqid);
883 884 885
	kfree(lsp);
}

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

/*
919 920
 * Release reference to lock_state, and free it if we see that
 * it is no longer in use
L
Linus Torvalds 已提交
921
 */
922
void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
L
Linus Torvalds 已提交
923
{
924
	struct nfs4_state *state;
L
Linus Torvalds 已提交
925

926 927 928 929 930 931 932 933 934
	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);
935
	if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
936 937 938
		if (nfs4_release_lockowner(lsp) == 0)
			return;
	}
939
	nfs4_free_lock_state(lsp->ls_state->owner->so_server, lsp);
L
Linus Torvalds 已提交
940 941
}

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

946 947 948
	dst->fl_u.nfs4_fl.owner = lsp;
	atomic_inc(&lsp->ls_count);
}
L
Linus Torvalds 已提交
949

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

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

	if (fl->fl_ops != NULL)
		return 0;
966 967 968
	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)
969 970
		lsp = nfs4_get_lock_state(state, NULL, fl->fl_pid,
				NFS4_FLOCK_LOCK_TYPE);
971 972
	else
		return -EINVAL;
973 974 975 976 977
	if (lsp == NULL)
		return -ENOMEM;
	fl->fl_u.nfs4_fl.owner = lsp;
	fl->fl_ops = &nfs4_fl_lock_ops;
	return 0;
L
Linus Torvalds 已提交
978 979
}

980 981
static int nfs4_copy_lock_stateid(nfs4_stateid *dst,
		struct nfs4_state *state,
982
		const struct nfs_lockowner *lockowner)
L
Linus Torvalds 已提交
983
{
984
	struct nfs4_lock_state *lsp;
985 986
	fl_owner_t fl_owner;
	pid_t fl_pid;
987
	int ret = -ENOENT;
L
Linus Torvalds 已提交
988

989 990 991 992

	if (lockowner == NULL)
		goto out;

993
	if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
994
		goto out;
L
Linus Torvalds 已提交
995

996 997
	fl_owner = lockowner->l_owner;
	fl_pid = lockowner->l_pid;
998
	spin_lock(&state->state_lock);
999
	lsp = __nfs4_find_lock_state(state, fl_owner, fl_pid, NFS4_ANY_LOCK_TYPE);
1000
	if (lsp != NULL && test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) {
1001
		nfs4_stateid_copy(dst, &lsp->ls_stateid);
1002 1003 1004 1005
		ret = 0;
		smp_rmb();
		if (!list_empty(&lsp->ls_seqid.list))
			ret = -EWOULDBLOCK;
1006
	}
1007
	spin_unlock(&state->state_lock);
L
Linus Torvalds 已提交
1008
	nfs4_put_lock_state(lsp);
1009 1010 1011 1012
out:
	return ret;
}

1013
static int nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
1014
{
1015
	int ret;
1016 1017 1018 1019 1020
	int seq;

	do {
		seq = read_seqbegin(&state->seqlock);
		nfs4_stateid_copy(dst, &state->stateid);
1021 1022 1023 1024
		ret = 0;
		smp_rmb();
		if (!list_empty(&state->owner->so_seqid.list))
			ret = -EWOULDBLOCK;
1025
	} while (read_seqretry(&state->seqlock, seq));
1026
	return ret;
1027 1028 1029 1030 1031 1032
}

/*
 * Byte-range lock aware utility to initialize the stateid of read/write
 * requests.
 */
1033
int nfs4_select_rw_stateid(nfs4_stateid *dst, struct nfs4_state *state,
1034
		fmode_t fmode, const struct nfs_lockowner *lockowner)
1035
{
1036
	int ret = 0;
1037
	if (nfs4_copy_delegation_stateid(dst, state->inode, fmode))
1038 1039 1040 1041 1042 1043
		goto out;
	ret = nfs4_copy_lock_stateid(dst, state, lockowner);
	if (ret != -ENOENT)
		goto out;
	ret = nfs4_copy_open_stateid(dst, state);
out:
1044 1045
	if (nfs_server_capable(state->inode, NFS_CAP_STATEID_NFSV41))
		dst->seqid = 0;
1046
	return ret;
L
Linus Torvalds 已提交
1047 1048
}

1049
struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
1050 1051 1052
{
	struct nfs_seqid *new;

1053
	new = kmalloc(sizeof(*new), gfp_mask);
1054 1055
	if (new != NULL) {
		new->sequence = counter;
1056
		INIT_LIST_HEAD(&new->list);
1057
		new->task = NULL;
1058 1059 1060 1061
	}
	return new;
}

1062
void nfs_release_seqid(struct nfs_seqid *seqid)
L
Linus Torvalds 已提交
1063
{
1064
	struct nfs_seqid_counter *sequence;
1065

1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
	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);
1077
	}
1078
	spin_unlock(&sequence->lock);
1079 1080 1081 1082 1083
}

void nfs_free_seqid(struct nfs_seqid *seqid)
{
	nfs_release_seqid(seqid);
1084
	kfree(seqid);
L
Linus Torvalds 已提交
1085 1086 1087
}

/*
1088 1089 1090 1091
 * 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()
 */
1092
static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
1093 1094 1095 1096 1097
{
	switch (status) {
		case 0:
			break;
		case -NFS4ERR_BAD_SEQID:
1098 1099
			if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
				return;
1100
			pr_warn_ratelimited("NFS: v4 server returned a bad"
D
Dan Muntz 已提交
1101 1102
					" sequence-id error on an"
					" unconfirmed sequence %p!\n",
1103
					seqid->sequence);
1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
		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)
{
1122 1123 1124 1125 1126
	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 已提交
1127
		nfs4_drop_state_owner(sp);
1128 1129
	if (!nfs4_has_session(server->nfs_client))
		nfs_increment_seqid(status, seqid);
1130 1131 1132 1133 1134 1135 1136 1137 1138
}

/*
 * 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)
{
1139
	nfs_increment_seqid(status, seqid);
1140 1141 1142 1143
}

int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
{
1144
	struct nfs_seqid_counter *sequence = seqid->sequence;
1145 1146 1147
	int status = 0;

	spin_lock(&sequence->lock);
1148
	seqid->task = task;
1149 1150 1151 1152
	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;
1153
	rpc_sleep_on(&sequence->wait, task, NULL);
1154 1155
	status = -EAGAIN;
unlock:
1156 1157
	spin_unlock(&sequence->lock);
	return status;
L
Linus Torvalds 已提交
1158 1159
}

1160
static int nfs4_run_state_manager(void *);
L
Linus Torvalds 已提交
1161

1162
static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
T
Trond Myklebust 已提交
1163 1164
{
	smp_mb__before_clear_bit();
1165
	clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
T
Trond Myklebust 已提交
1166
	smp_mb__after_clear_bit();
1167
	wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
T
Trond Myklebust 已提交
1168 1169 1170
	rpc_wake_up(&clp->cl_rpcwaitq);
}

L
Linus Torvalds 已提交
1171
/*
1172
 * Schedule the nfs_client asynchronous state management routine
L
Linus Torvalds 已提交
1173
 */
1174
void nfs4_schedule_state_manager(struct nfs_client *clp)
L
Linus Torvalds 已提交
1175
{
1176
	struct task_struct *task;
1177
	char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
L
Linus Torvalds 已提交
1178

1179 1180
	if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
		return;
1181 1182
	__module_get(THIS_MODULE);
	atomic_inc(&clp->cl_count);
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198

	/* 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 已提交
1199 1200 1201
}

/*
1202
 * Schedule a lease recovery attempt
L
Linus Torvalds 已提交
1203
 */
1204
void nfs4_schedule_lease_recovery(struct nfs_client *clp)
L
Linus Torvalds 已提交
1205 1206 1207
{
	if (!clp)
		return;
1208 1209
	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1210 1211
	dprintk("%s: scheduling lease recovery for server %s\n", __func__,
			clp->cl_hostname);
1212
	nfs4_schedule_state_manager(clp);
L
Linus Torvalds 已提交
1213
}
A
Andy Adamson 已提交
1214
EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
L
Linus Torvalds 已提交
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 1244 1245 1246 1247 1248 1249
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;
}

1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
/*
 * 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);
1262 1263
	dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
			clp->cl_hostname);
1264 1265
}

1266 1267
void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
{
1268
	nfs40_handle_cb_pathdown(clp);
1269 1270 1271
	nfs4_schedule_state_manager(clp);
}

1272
static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1273 1274 1275 1276 1277 1278 1279 1280
{

	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;
	}
1281
	set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
1282 1283 1284 1285
	set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
	return 1;
}

1286
static int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1287 1288 1289
{
	set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
	clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1290
	set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
1291 1292 1293 1294
	set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
	return 1;
}

1295
int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
1296 1297 1298
{
	struct nfs_client *clp = server->nfs_client;

1299 1300
	if (!nfs4_valid_open_stateid(state))
		return -EBADF;
1301
	nfs4_state_mark_reclaim_nograce(clp, state);
1302 1303
	dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
			clp->cl_hostname);
1304
	nfs4_schedule_state_manager(clp);
1305
	return 0;
1306
}
A
Andy Adamson 已提交
1307
EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1308

1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324
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;
1325
		if (!nfs4_stateid_match(&state->stateid, stateid))
1326 1327 1328 1329 1330 1331 1332 1333 1334
			continue;
		nfs4_state_mark_reclaim_nograce(clp, state);
		found = true;
	}
	spin_unlock(&inode->i_lock);
	if (found)
		nfs4_schedule_state_manager(clp);
}

1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
static void nfs4_state_mark_open_context_bad(struct nfs4_state *state)
{
	struct inode *inode = state->inode;
	struct nfs_inode *nfsi = NFS_I(inode);
	struct nfs_open_context *ctx;

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

1350 1351 1352
static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
{
	set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags);
1353
	nfs4_state_mark_open_context_bad(state);
1354 1355
}

1356

1357
static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1358 1359
{
	struct inode *inode = state->inode;
1360
	struct nfs_inode *nfsi = NFS_I(inode);
L
Linus Torvalds 已提交
1361 1362 1363
	struct file_lock *fl;
	int status = 0;

1364 1365 1366 1367
	if (inode->i_flock == NULL)
		return 0;

	/* Guard against delegation returns and new lock/unlock calls */
1368
	down_write(&nfsi->rwsem);
1369
	/* Protect inode->i_flock using the BKL */
1370
	lock_flocks();
H
Harvey Harrison 已提交
1371
	for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
1372
		if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
L
Linus Torvalds 已提交
1373
			continue;
1374
		if (nfs_file_open_context(fl->fl_file)->state != state)
L
Linus Torvalds 已提交
1375
			continue;
1376
		unlock_flocks();
L
Linus Torvalds 已提交
1377 1378
		status = ops->recover_lock(state, fl);
		switch (status) {
1379 1380 1381 1382 1383 1384 1385 1386 1387
			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:
1388 1389 1390 1391
			case -NFS4ERR_BADSESSION:
			case -NFS4ERR_BADSLOT:
			case -NFS4ERR_BAD_HIGH_SLOT:
			case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1392
				goto out;
L
Linus Torvalds 已提交
1393
			default:
1394 1395
				printk(KERN_ERR "NFS: %s: unhandled error %d. "
					"Zeroing state\n", __func__, status);
1396 1397
			case -ENOMEM:
			case -NFS4ERR_DENIED:
L
Linus Torvalds 已提交
1398 1399
			case -NFS4ERR_RECLAIM_BAD:
			case -NFS4ERR_RECLAIM_CONFLICT:
1400
				/* kill_proc(fl->fl_pid, SIGLOST, 1); */
1401
				status = 0;
L
Linus Torvalds 已提交
1402
		}
1403
		lock_flocks();
L
Linus Torvalds 已提交
1404
	}
1405
	unlock_flocks();
1406
out:
1407
	up_write(&nfsi->rwsem);
L
Linus Torvalds 已提交
1408 1409 1410
	return status;
}

1411
static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
{
	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.
	 */
1425
	spin_lock(&sp->so_lock);
1426 1427
	write_seqcount_begin(&sp->so_reclaim_seqcount);
restart:
L
Linus Torvalds 已提交
1428
	list_for_each_entry(state, &sp->so_states, open_states) {
1429 1430
		if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
			continue;
1431 1432
		if (!nfs4_valid_open_stateid(state))
			continue;
L
Linus Torvalds 已提交
1433 1434
		if (state->state == 0)
			continue;
1435 1436
		atomic_inc(&state->count);
		spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1437 1438
		status = ops->recover_open(sp, state);
		if (status >= 0) {
1439 1440
			status = nfs4_reclaim_locks(state, ops);
			if (status >= 0) {
1441
				spin_lock(&state->state_lock);
1442
				list_for_each_entry(lock, &state->lock_states, ls_locks) {
1443
					if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
1444 1445
						pr_warn_ratelimited("NFS: "
							"%s: Lock reclaim "
1446
							"failed!\n", __func__);
1447
				}
1448
				spin_unlock(&state->state_lock);
1449
				nfs4_put_open_state(state);
1450
				spin_lock(&sp->so_lock);
1451
				goto restart;
L
Linus Torvalds 已提交
1452 1453 1454 1455
			}
		}
		switch (status) {
			default:
1456 1457
				printk(KERN_ERR "NFS: %s: unhandled error %d. "
					"Zeroing state\n", __func__, status);
L
Linus Torvalds 已提交
1458
			case -ENOENT:
1459
			case -ENOMEM:
1460
			case -ESTALE:
L
Linus Torvalds 已提交
1461 1462 1463 1464
				/*
				 * Open state on this file cannot be recovered
				 * All we can do is revert to using the zero stateid.
				 */
1465
				nfs4_state_mark_recovery_failed(state, status);
L
Linus Torvalds 已提交
1466
				break;
1467 1468
			case -EAGAIN:
				ssleep(1);
1469 1470 1471
			case -NFS4ERR_ADMIN_REVOKED:
			case -NFS4ERR_STALE_STATEID:
			case -NFS4ERR_BAD_STATEID:
1472 1473
			case -NFS4ERR_RECLAIM_BAD:
			case -NFS4ERR_RECLAIM_CONFLICT:
1474
				nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1475
				break;
L
Linus Torvalds 已提交
1476 1477
			case -NFS4ERR_EXPIRED:
			case -NFS4ERR_NO_GRACE:
1478
				nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
L
Linus Torvalds 已提交
1479
			case -NFS4ERR_STALE_CLIENTID:
1480 1481 1482 1483
			case -NFS4ERR_BADSESSION:
			case -NFS4ERR_BADSLOT:
			case -NFS4ERR_BAD_HIGH_SLOT:
			case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
L
Linus Torvalds 已提交
1484 1485
				goto out_err;
		}
1486
		nfs4_put_open_state(state);
1487
		spin_lock(&sp->so_lock);
1488
		goto restart;
L
Linus Torvalds 已提交
1489
	}
1490
	write_seqcount_end(&sp->so_reclaim_seqcount);
1491
	spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1492 1493
	return 0;
out_err:
1494
	nfs4_put_open_state(state);
1495 1496 1497
	spin_lock(&sp->so_lock);
	write_seqcount_end(&sp->so_reclaim_seqcount);
	spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1498 1499 1500
	return status;
}

1501 1502 1503 1504 1505 1506 1507 1508
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);
1509
	spin_lock(&state->state_lock);
1510 1511
	list_for_each_entry(lock, &state->lock_states, ls_locks) {
		lock->ls_seqid.flags = 0;
1512
		clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags);
1513
	}
1514
	spin_unlock(&state->state_lock);
1515 1516
}

1517 1518
static void nfs4_reset_seqids(struct nfs_server *server,
	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1519
{
1520
	struct nfs_client *clp = server->nfs_client;
1521
	struct nfs4_state_owner *sp;
1522
	struct rb_node *pos;
1523 1524
	struct nfs4_state *state;

1525 1526 1527 1528 1529
	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);
1530
		sp->so_seqid.flags = 0;
1531
		spin_lock(&sp->so_lock);
1532
		list_for_each_entry(state, &sp->so_states, open_states) {
1533 1534
			if (mark_reclaim(clp, state))
				nfs4_clear_open_state(state);
1535
		}
1536
		spin_unlock(&sp->so_lock);
1537
	}
1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549
	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();
1550 1551
}

1552 1553 1554 1555 1556 1557 1558
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);
}

1559 1560 1561 1562 1563 1564 1565 1566
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);
}

1567
static void nfs4_clear_reclaim_server(struct nfs_server *server)
1568
{
1569
	struct nfs_client *clp = server->nfs_client;
1570 1571 1572 1573
	struct nfs4_state_owner *sp;
	struct rb_node *pos;
	struct nfs4_state *state;

1574 1575 1576 1577 1578
	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);
1579 1580
		spin_lock(&sp->so_lock);
		list_for_each_entry(state, &sp->so_states, open_states) {
1581 1582
			if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
						&state->flags))
1583 1584 1585 1586 1587
				continue;
			nfs4_state_mark_reclaim_nograce(clp, state);
		}
		spin_unlock(&sp->so_lock);
	}
1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
	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();
1602 1603

	nfs_delegation_reap_unclaimed(clp);
1604 1605 1606 1607 1608 1609 1610 1611
	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);
1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
}

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

1626
static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1627 1628
{
	switch (error) {
1629 1630
		case 0:
			break;
1631
		case -NFS4ERR_CB_PATH_DOWN:
1632
			nfs40_handle_cb_pathdown(clp);
1633
			break;
1634 1635
		case -NFS4ERR_NO_GRACE:
			nfs4_state_end_reclaim_reboot(clp);
1636
			break;
1637 1638 1639
		case -NFS4ERR_STALE_CLIENTID:
		case -NFS4ERR_LEASE_MOVED:
			set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1640
			nfs4_state_clear_reclaim_reboot(clp);
1641 1642 1643 1644 1645
			nfs4_state_start_reclaim_reboot(clp);
			break;
		case -NFS4ERR_EXPIRED:
			set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
			nfs4_state_start_reclaim_nograce(clp);
1646
			break;
1647 1648 1649 1650 1651 1652
		case -NFS4ERR_BADSESSION:
		case -NFS4ERR_BADSLOT:
		case -NFS4ERR_BAD_HIGH_SLOT:
		case -NFS4ERR_DEADSESSION:
		case -NFS4ERR_SEQ_FALSE_RETRY:
		case -NFS4ERR_SEQ_MISORDERED:
1653
			set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1654
			/* Zero session reset errors */
1655
			break;
1656 1657 1658
		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
			set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
			break;
1659
		default:
1660 1661
			dprintk("%s: failed to handle error %d for server %s\n",
					__func__, error, clp->cl_hostname);
1662
			return error;
1663
	}
1664 1665
	dprintk("%s: handled error %d for server %s\n", __func__, error,
			clp->cl_hostname);
1666
	return 0;
1667 1668
}

1669
static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1670
{
1671 1672
	struct nfs4_state_owner *sp;
	struct nfs_server *server;
1673
	struct rb_node *pos;
L
Linus Torvalds 已提交
1674 1675
	int status = 0;

1676
restart:
1677 1678
	rcu_read_lock();
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1679
		nfs4_purge_state_owners(server);
1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699
		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);
			}

1700
			nfs4_put_state_owner(sp);
1701
			goto restart;
1702
		}
1703
		spin_unlock(&clp->cl_lock);
1704
	}
1705
	rcu_read_unlock();
1706 1707 1708 1709 1710 1711
	return status;
}

static int nfs4_check_lease(struct nfs_client *clp)
{
	struct rpc_cred *cred;
1712 1713
	const struct nfs4_state_maintenance_ops *ops =
		clp->cl_mvops->state_renewal_ops;
1714
	int status;
L
Linus Torvalds 已提交
1715

1716 1717 1718
	/* Is the client already known to have an expired lease? */
	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		return 0;
1719 1720 1721
	spin_lock(&clp->cl_lock);
	cred = ops->get_state_renewal_cred_locked(clp);
	spin_unlock(&clp->cl_lock);
1722 1723
	if (cred == NULL) {
		cred = nfs4_get_setclientid_cred(clp);
1724
		status = -ENOKEY;
1725 1726
		if (cred == NULL)
			goto out;
1727
	}
1728
	status = ops->renew_lease(clp, cred);
1729 1730
	put_rpccred(cred);
out:
1731
	return nfs4_recovery_handle_error(clp, status);
1732 1733
}

1734 1735
/* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
 * and for recoverable errors on EXCHANGE_ID for v4.1
1736 1737 1738 1739
 */
static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
{
	switch (status) {
1740 1741 1742 1743 1744
	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);
1745 1746
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
		break;
1747 1748
	case -NFS4ERR_STALE_CLIENTID:
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1749 1750
		nfs4_state_clear_reclaim_reboot(clp);
		nfs4_state_start_reclaim_reboot(clp);
1751
		break;
1752 1753 1754 1755 1756 1757
	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;
1758 1759 1760 1761 1762 1763 1764 1765 1766 1767
	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);
1768 1769
		dprintk("%s: exit with error %d for server %s\n",
				__func__, -EPROTONOSUPPORT, clp->cl_hostname);
1770 1771 1772 1773
		return -EPROTONOSUPPORT;
	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
				 * in nfs4_exchange_id */
	default:
1774 1775
		dprintk("%s: exit with error %d for server %s\n", __func__,
				status, clp->cl_hostname);
1776 1777 1778
		return status;
	}
	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1779 1780
	dprintk("%s: handled error %d for server %s\n", __func__, status,
			clp->cl_hostname);
1781 1782 1783
	return 0;
}

1784
static int nfs4_establish_lease(struct nfs_client *clp)
1785 1786
{
	struct rpc_cred *cred;
1787 1788
	const struct nfs4_state_recovery_ops *ops =
		clp->cl_mvops->reboot_recovery_ops;
1789
	int status;
1790

1791
	cred = ops->get_clid_cred(clp);
1792 1793 1794 1795 1796
	if (cred == NULL)
		return -ENOENT;
	status = ops->establish_clid(clp, cred);
	put_rpccred(cred);
	if (status != 0)
1797 1798 1799 1800 1801
		return status;
	pnfs_destroy_all_layouts(clp);
	return 0;
}

1802 1803 1804 1805
/*
 * Returns zero or a negative errno.  NFS4ERR values are converted
 * to local errno values.
 */
1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827
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)
1828
		return nfs4_handle_reclaim_lease_error(clp, status);
1829 1830 1831
	clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
	nfs4_state_start_reclaim_nograce(clp);
1832
	return 0;
1833 1834
}

1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854
/**
 * 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;
1855
	int i, status;
1856 1857 1858 1859 1860 1861 1862 1863

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

	clnt = clp->cl_rpcclient;
	i = 0;

	mutex_lock(&nfs_clid_init_mutex);
again:
1864
	status  = -ENOENT;
1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877
	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 -NFS4ERR_DELAY:
	case -ETIMEDOUT:
	case -EAGAIN:
		ssleep(1);
1878
	case -NFS4ERR_STALE_CLIENTID:
1879 1880 1881
		dprintk("NFS: %s after status %d, retrying\n",
			__func__, status);
		goto again;
1882 1883 1884
	case -EACCES:
		if (i++)
			break;
1885 1886
	case -NFS4ERR_CLID_INUSE:
	case -NFS4ERR_WRONGSEC:
1887
		clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_NULL);
1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902
		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;
1903 1904 1905 1906 1907
		break;
	default:
		pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
				__func__, status);
		status = -EIO;
1908 1909 1910 1911 1912 1913 1914 1915
	}

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

1916
#ifdef CONFIG_NFS_V4_1
1917
void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
1918
{
1919 1920
	struct nfs_client *clp = session->clp;

1921 1922 1923 1924 1925 1926 1927
	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);
	}
1928
	nfs4_schedule_lease_recovery(clp);
1929
}
1930
EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
1931

1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943
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);
}

1944 1945 1946 1947 1948
void nfs41_server_notify_highest_slotid_update(struct nfs_client *clp)
{
	nfs41_ping_server(clp);
}

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

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);
1965 1966
		dprintk("%s: server %s rebooted!\n", __func__,
				clp->cl_hostname);
1967
		nfs4_schedule_state_manager(clp);
1968 1969 1970 1971 1972 1973
	}
}

static void nfs41_handle_state_revoked(struct nfs_client *clp)
{
	nfs4_reset_all_state(clp);
1974
	dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
1975 1976 1977 1978 1979 1980
}

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

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

1994 1995 1996 1997 1998 1999 2000
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);
}

2001 2002 2003 2004
void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)
{
	if (!flags)
		return;
2005 2006 2007 2008

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

2009
	if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
2010
		nfs41_handle_server_reboot(clp);
2011
	if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED |
2012 2013
			    SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
			    SEQ4_STATUS_ADMIN_STATE_REVOKED |
2014 2015
			    SEQ4_STATUS_LEASE_MOVED))
		nfs41_handle_state_revoked(clp);
2016
	if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
2017
		nfs41_handle_recallable_state_revoked(clp);
2018 2019 2020 2021
	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))
2022
		nfs41_handle_cb_path_down(clp);
2023 2024
}

2025 2026
static int nfs4_reset_session(struct nfs_client *clp)
{
2027
	struct rpc_cred *cred;
2028 2029
	int status;

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

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

2068 2069
static int nfs4_bind_conn_to_session(struct nfs_client *clp)
{
2070 2071 2072
	struct rpc_cred *cred;
	int ret;

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

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

2105
static void nfs4_state_manager(struct nfs_client *clp)
2106 2107
{
	int status = 0;
2108
	const char *section = "", *section_sep = "";
2109 2110

	/* Ensure exclusive access to NFSv4 state */
2111
	do {
2112
		if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2113
			section = "purge state";
2114
			status = nfs4_purge_lease(clp);
2115 2116
			if (status < 0)
				goto out_error;
2117
			continue;
2118 2119
		}

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

2129
		/* Initialize or reset the session */
2130
		if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) {
2131
			section = "reset session";
2132
			status = nfs4_reset_session(clp);
2133 2134 2135
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
				continue;
			if (status < 0)
2136 2137
				goto out_error;
		}
2138

2139 2140
		/* Send BIND_CONN_TO_SESSION */
		if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2141
				&clp->cl_state)) {
2142
			section = "bind conn to session";
2143 2144 2145
			status = nfs4_bind_conn_to_session(clp);
			if (status < 0)
				goto out_error;
2146
			continue;
2147 2148
		}

2149 2150 2151 2152 2153 2154 2155 2156
		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;
		}

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

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

2185
		nfs4_end_drain_session(clp);
2186 2187 2188 2189
		if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
			nfs_client_return_marked_delegations(clp);
			continue;
		}
2190 2191

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

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