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

41
#include <linux/kernel.h>
L
Linus Torvalds 已提交
42
#include <linux/slab.h>
43
#include <linux/fs.h>
L
Linus Torvalds 已提交
44 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
#include "nfs4_fs.h"
L
Linus Torvalds 已提交
55 56
#include "callback.h"
#include "delegation.h"
57
#include "internal.h"
58
#include "pnfs.h"
L
Linus Torvalds 已提交
59 60 61

#define OPENOWNER_POOL_SIZE	8

62
const nfs4_stateid zero_stateid;
L
Linus Torvalds 已提交
63 64 65

static LIST_HEAD(nfs4_clientid_list);

66
int nfs4_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
L
Linus Torvalds 已提交
67
{
68 69 70 71
	struct nfs4_setclientid_res clid = {
		.clientid = clp->cl_clientid,
		.confirm = clp->cl_confirm,
	};
72 73 74
	unsigned short port;
	int status;

75 76
	if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
		goto do_confirm;
77 78 79 80
	port = nfs_callback_tcpport;
	if (clp->cl_addr.ss_family == AF_INET6)
		port = nfs_callback_tcpport6;

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

97
struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp)
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
{
	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);
}

118 119
static struct rpc_cred *
nfs4_get_renew_cred_server_locked(struct nfs_server *server)
120
{
121
	struct rpc_cred *cred = NULL;
122
	struct nfs4_state_owner *sp;
123
	struct rb_node *pos;
124

125 126 127 128
	for (pos = rb_first(&server->state_owners);
	     pos != NULL;
	     pos = rb_next(pos)) {
		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
129 130 131 132 133 134 135 136
		if (list_empty(&sp->so_states))
			continue;
		cred = get_rpccred(sp->so_cred);
		break;
	}
	return cred;
}

137 138 139 140 141 142 143 144 145 146 147 148
/**
 * 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;

149 150 151 152 153
	/* Use machine credentials if available */
	cred = nfs4_get_machine_cred_locked(clp);
	if (cred != NULL)
		goto out;

154 155 156 157 158 159 160
	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();
161 162

out:
163 164 165
	return cred;
}

166 167
#if defined(CONFIG_NFS_V4_1)

R
Ricardo Labiaga 已提交
168 169 170 171 172
static int nfs41_setup_state_renewal(struct nfs_client *clp)
{
	int status;
	struct nfs_fsinfo fsinfo;

173 174 175 176 177
	if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
		nfs4_schedule_state_renewal(clp);
		return 0;
	}

R
Ricardo Labiaga 已提交
178 179 180 181 182 183 184 185 186 187 188 189 190 191
	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;
}

192 193 194 195 196
/*
 * 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.
 */
197
static void nfs4_end_drain_session(struct nfs_client *clp)
198
{
199
	struct nfs4_session *ses = clp->cl_session;
200
	struct nfs4_slot_table *tbl;
201 202
	int max_slots;

203 204
	if (ses == NULL)
		return;
205
	tbl = &ses->fc_slot_table;
206
	if (test_and_clear_bit(NFS4_SESSION_DRAINING, &ses->session_state)) {
207 208
		spin_lock(&tbl->slot_tbl_lock);
		max_slots = tbl->max_slots;
209
		while (max_slots--) {
210 211 212
			if (rpc_wake_up_first(&tbl->slot_tbl_waitq,
						nfs4_set_task_privileged,
						NULL) == NULL)
213 214
				break;
		}
215
		spin_unlock(&tbl->slot_tbl_lock);
216
	}
217 218
}

219
static int nfs4_wait_on_slot_tbl(struct nfs4_slot_table *tbl)
220 221
{
	spin_lock(&tbl->slot_tbl_lock);
222
	if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
223
		INIT_COMPLETION(tbl->complete);
224
		spin_unlock(&tbl->slot_tbl_lock);
225
		return wait_for_completion_interruptible(&tbl->complete);
226 227 228 229 230
	}
	spin_unlock(&tbl->slot_tbl_lock);
	return 0;
}

231 232 233 234 235 236 237 238 239 240 241 242 243 244
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);
}

245 246 247 248
int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
{
	int status;

249 250
	if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
		goto do_confirm;
251
	nfs4_begin_drain_session(clp);
252
	status = nfs4_proc_exchange_id(clp, cred);
R
Ricardo Labiaga 已提交
253 254
	if (status != 0)
		goto out;
255 256
	set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
do_confirm:
R
Ricardo Labiaga 已提交
257 258 259
	status = nfs4_proc_create_session(clp);
	if (status != 0)
		goto out;
260
	clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
R
Ricardo Labiaga 已提交
261 262 263
	nfs41_setup_state_renewal(clp);
	nfs_mark_client_ready(clp, NFS_CS_READY);
out:
264 265 266
	return status;
}

267 268 269 270 271 272 273 274 275 276 277 278
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 */

279 280
static struct rpc_cred *
nfs4_get_setclientid_cred_server(struct nfs_server *server)
281
{
282 283
	struct nfs_client *clp = server->nfs_client;
	struct rpc_cred *cred = NULL;
284
	struct nfs4_state_owner *sp;
285
	struct rb_node *pos;
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305

	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;
306
	struct rpc_cred *cred;
307

308 309
	spin_lock(&clp->cl_lock);
	cred = nfs4_get_machine_cred_locked(clp);
310
	spin_unlock(&clp->cl_lock);
311 312
	if (cred != NULL)
		goto out;
313 314 315 316 317 318

	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;
319
	}
320 321
	rcu_read_unlock();

322 323
out:
	return cred;
324 325
}

L
Linus Torvalds 已提交
326
static struct nfs4_state_owner *
327
nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred)
L
Linus Torvalds 已提交
328
{
329
	struct rb_node **p = &server->state_owners.rb_node,
330
		       *parent = NULL;
331
	struct nfs4_state_owner *sp;
L
Linus Torvalds 已提交
332

333 334
	while (*p != NULL) {
		parent = *p;
335
		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
336 337 338 339 340 341

		if (cred < sp->so_cred)
			p = &parent->rb_left;
		else if (cred > sp->so_cred)
			p = &parent->rb_right;
		else {
342 343
			if (!list_empty(&sp->so_lru))
				list_del_init(&sp->so_lru);
344
			atomic_inc(&sp->so_count);
345
			return sp;
346
		}
L
Linus Torvalds 已提交
347
	}
348
	return NULL;
L
Linus Torvalds 已提交
349 350
}

351
static struct nfs4_state_owner *
352
nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
353
{
354 355
	struct nfs_server *server = new->so_server;
	struct rb_node **p = &server->state_owners.rb_node,
356 357
		       *parent = NULL;
	struct nfs4_state_owner *sp;
358
	int err;
359 360 361

	while (*p != NULL) {
		parent = *p;
362
		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
363 364 365 366 367 368

		if (new->so_cred < sp->so_cred)
			p = &parent->rb_left;
		else if (new->so_cred > sp->so_cred)
			p = &parent->rb_right;
		else {
369 370
			if (!list_empty(&sp->so_lru))
				list_del_init(&sp->so_lru);
371 372 373 374
			atomic_inc(&sp->so_count);
			return sp;
		}
	}
375
	err = ida_get_new(&server->openowner_id, &new->so_seqid.owner_id);
376 377
	if (err)
		return ERR_PTR(err);
378 379
	rb_link_node(&new->so_server_node, parent, p);
	rb_insert_color(&new->so_server_node, &server->state_owners);
380 381 382 383
	return new;
}

static void
384
nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
385
{
386 387 388 389
	struct nfs_server *server = sp->so_server;

	if (!RB_EMPTY_NODE(&sp->so_server_node))
		rb_erase(&sp->so_server_node, &server->state_owners);
390
	ida_remove(&server->openowner_id, sp->so_seqid.owner_id);
391 392
}

393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
static void
nfs4_init_seqid_counter(struct nfs_seqid_counter *sc)
{
	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 已提交
409 410 411 412 413 414
/*
 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
 * create a new state_owner.
 *
 */
static struct nfs4_state_owner *
415 416 417
nfs4_alloc_state_owner(struct nfs_server *server,
		struct rpc_cred *cred,
		gfp_t gfp_flags)
L
Linus Torvalds 已提交
418 419 420
{
	struct nfs4_state_owner *sp;

421
	sp = kzalloc(sizeof(*sp), gfp_flags);
L
Linus Torvalds 已提交
422 423
	if (!sp)
		return NULL;
424 425
	sp->so_server = server;
	sp->so_cred = get_rpccred(cred);
426
	spin_lock_init(&sp->so_lock);
L
Linus Torvalds 已提交
427
	INIT_LIST_HEAD(&sp->so_states);
428
	nfs4_init_seqid_counter(&sp->so_seqid);
L
Linus Torvalds 已提交
429
	atomic_set(&sp->so_count, 1);
430
	INIT_LIST_HEAD(&sp->so_lru);
L
Linus Torvalds 已提交
431 432 433
	return sp;
}

434
static void
L
Linus Torvalds 已提交
435 436
nfs4_drop_state_owner(struct nfs4_state_owner *sp)
{
437 438 439
	if (!RB_EMPTY_NODE(&sp->so_server_node)) {
		struct nfs_server *server = sp->so_server;
		struct nfs_client *clp = server->nfs_client;
440 441

		spin_lock(&clp->cl_lock);
442 443
		rb_erase(&sp->so_server_node, &server->state_owners);
		RB_CLEAR_NODE(&sp->so_server_node);
444 445
		spin_unlock(&clp->cl_lock);
	}
L
Linus Torvalds 已提交
446 447
}

448 449
static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
{
450
	nfs4_destroy_seqid_counter(&sp->so_seqid);
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
	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);
	}
}

480 481 482 483 484 485 486 487
/**
 * 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,
488 489
					      struct rpc_cred *cred,
					      gfp_t gfp_flags)
L
Linus Torvalds 已提交
490
{
491
	struct nfs_client *clp = server->nfs_client;
L
Linus Torvalds 已提交
492 493 494
	struct nfs4_state_owner *sp, *new;

	spin_lock(&clp->cl_lock);
495
	sp = nfs4_find_state_owner_locked(server, cred);
L
Linus Torvalds 已提交
496 497
	spin_unlock(&clp->cl_lock);
	if (sp != NULL)
498
		goto out;
499
	new = nfs4_alloc_state_owner(server, cred, gfp_flags);
500
	if (new == NULL)
501
		goto out;
502 503 504 505 506 507 508
	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));
509 510
	if (sp != new)
		nfs4_free_state_owner(new);
511 512
out:
	nfs4_gc_state_owners(server);
513
	return sp;
L
Linus Torvalds 已提交
514 515
}

516 517 518 519
/**
 * nfs4_put_state_owner - Release a nfs4_state_owner
 * @sp: state owner data to release
 */
L
Linus Torvalds 已提交
520 521
void nfs4_put_state_owner(struct nfs4_state_owner *sp)
{
522 523
	struct nfs_server *server = sp->so_server;
	struct nfs_client *clp = server->nfs_client;
L
Linus Torvalds 已提交
524 525 526

	if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
		return;
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556

	if (!RB_EMPTY_NODE(&sp->so_server_node)) {
		sp->so_expires = jiffies;
		list_add_tail(&sp->so_lru, &server->state_owners_lru);
		spin_unlock(&clp->cl_lock);
	} else {
		nfs4_remove_state_owner_locked(sp);
		spin_unlock(&clp->cl_lock);
		nfs4_free_state_owner(sp);
	}
}

/**
 * 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 已提交
557
	spin_unlock(&clp->cl_lock);
558 559 560 561 562

	list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
		list_del(&sp->so_lru);
		nfs4_free_state_owner(sp);
	}
L
Linus Torvalds 已提交
563 564 565 566 567 568 569
}

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

570
	state = kzalloc(sizeof(*state), GFP_NOFS);
L
Linus Torvalds 已提交
571 572 573 574
	if (!state)
		return NULL;
	atomic_set(&state->count, 1);
	INIT_LIST_HEAD(&state->lock_states);
575
	spin_lock_init(&state->state_lock);
576
	seqlock_init(&state->seqlock);
L
Linus Torvalds 已提交
577 578 579
	return state;
}

580
void
581
nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
582
{
583
	if (state->state == fmode)
584 585
		return;
	/* NB! List reordering - see the reclaim code for why.  */
586 587
	if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
		if (fmode & FMODE_WRITE)
588 589 590 591
			list_move(&state->open_states, &state->owner->so_states);
		else
			list_move_tail(&state->open_states, &state->owner->so_states);
	}
592
	state->state = fmode;
593 594
}

L
Linus Torvalds 已提交
595 596 597 598 599 600 601
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) {
602
		if (state->owner != owner)
L
Linus Torvalds 已提交
603
			continue;
604
		if (atomic_inc_not_zero(&state->count))
L
Linus Torvalds 已提交
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627
			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();
628
	spin_lock(&owner->so_lock);
L
Linus Torvalds 已提交
629 630 631 632 633 634 635
	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);
636 637
		ihold(inode);
		state->inode = inode;
L
Linus Torvalds 已提交
638
		spin_unlock(&inode->i_lock);
639 640 641 642
		/* 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 已提交
643 644
	} else {
		spin_unlock(&inode->i_lock);
645
		spin_unlock(&owner->so_lock);
L
Linus Torvalds 已提交
646 647 648 649 650 651 652 653 654 655 656 657
		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;

658
	if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
L
Linus Torvalds 已提交
659
		return;
660
	spin_lock(&inode->i_lock);
661
	list_del(&state->inode_states);
L
Linus Torvalds 已提交
662
	list_del(&state->open_states);
663 664
	spin_unlock(&inode->i_lock);
	spin_unlock(&owner->so_lock);
L
Linus Torvalds 已提交
665 666 667 668 669 670
	iput(inode);
	nfs4_free_open_state(state);
	nfs4_put_state_owner(owner);
}

/*
671
 * Close the current file.
L
Linus Torvalds 已提交
672
 */
673
static void __nfs4_close(struct nfs4_state *state,
674
		fmode_t fmode, gfp_t gfp_mask, int wait)
L
Linus Torvalds 已提交
675 676
{
	struct nfs4_state_owner *owner = state->owner;
677
	int call_close = 0;
678
	fmode_t newstate;
L
Linus Torvalds 已提交
679 680 681

	atomic_inc(&owner->so_count);
	/* Protect against nfs4_find_state() */
682
	spin_lock(&owner->so_lock);
683
	switch (fmode & (FMODE_READ | FMODE_WRITE)) {
684 685 686 687 688 689 690 691 692
		case FMODE_READ:
			state->n_rdonly--;
			break;
		case FMODE_WRITE:
			state->n_wronly--;
			break;
		case FMODE_READ|FMODE_WRITE:
			state->n_rdwr--;
	}
693
	newstate = FMODE_READ|FMODE_WRITE;
694
	if (state->n_rdwr == 0) {
695
		if (state->n_rdonly == 0) {
696
			newstate &= ~FMODE_READ;
697 698 699 700
			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) {
701
			newstate &= ~FMODE_WRITE;
702 703 704 705 706
			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);
707
	}
708
	nfs4_state_set_mode_locked(state, newstate);
709
	spin_unlock(&owner->so_lock);
710

711
	if (!call_close) {
712 713
		nfs4_put_open_state(state);
		nfs4_put_state_owner(owner);
F
Fred Isaman 已提交
714 715 716
	} else {
		bool roc = pnfs_roc(state->inode);

717
		nfs4_do_close(state, gfp_mask, wait, roc);
F
Fred Isaman 已提交
718
	}
719 720
}

721
void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
722
{
723
	__nfs4_close(state, fmode, GFP_NOFS, 0);
724 725
}

726
void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
727
{
728
	__nfs4_close(state, fmode, GFP_KERNEL, 1);
L
Linus Torvalds 已提交
729 730 731 732 733 734 735
}

/*
 * Search the state->lock_states for an existing lock_owner
 * that is compatible with current->files
 */
static struct nfs4_lock_state *
736
__nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type)
L
Linus Torvalds 已提交
737 738 739
{
	struct nfs4_lock_state *pos;
	list_for_each_entry(pos, &state->lock_states, ls_locks) {
740
		if (type != NFS4_ANY_LOCK_TYPE && pos->ls_owner.lo_type != type)
L
Linus Torvalds 已提交
741
			continue;
742 743 744 745 746 747 748 749 750
		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 已提交
751 752 753 754 755 756 757 758 759 760 761
		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.
 *
 */
762
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 已提交
763 764
{
	struct nfs4_lock_state *lsp;
765
	struct nfs_server *server = state->owner->so_server;
L
Linus Torvalds 已提交
766

767
	lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
L
Linus Torvalds 已提交
768 769
	if (lsp == NULL)
		return NULL;
770
	nfs4_init_seqid_counter(&lsp->ls_seqid);
L
Linus Torvalds 已提交
771
	atomic_set(&lsp->ls_count, 1);
772
	lsp->ls_state = state;
773 774 775 776 777 778 779 780 781
	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:
782
		goto out_free;
783
	}
784 785
	lsp->ls_seqid.owner_id = ida_simple_get(&server->lockowner_id, 0, 0, GFP_NOFS);
	if (lsp->ls_seqid.owner_id < 0)
786
		goto out_free;
787
	INIT_LIST_HEAD(&lsp->ls_locks);
L
Linus Torvalds 已提交
788
	return lsp;
789 790 791
out_free:
	kfree(lsp);
	return NULL;
L
Linus Torvalds 已提交
792 793
}

794
void nfs4_free_lock_state(struct nfs4_lock_state *lsp)
795
{
796
	struct nfs_server *server = lsp->ls_state->owner->so_server;
797

798
	ida_simple_remove(&server->lockowner_id, lsp->ls_seqid.owner_id);
799
	nfs4_destroy_seqid_counter(&lsp->ls_seqid);
800 801 802
	kfree(lsp);
}

L
Linus Torvalds 已提交
803 804 805 806 807
/*
 * Return a compatible lock_state. If no initialized lock_state structure
 * exists, return an uninitialized one.
 *
 */
808
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 已提交
809
{
810
	struct nfs4_lock_state *lsp, *new = NULL;
L
Linus Torvalds 已提交
811
	
812 813
	for(;;) {
		spin_lock(&state->state_lock);
814
		lsp = __nfs4_find_lock_state(state, owner, pid, type);
815 816 817 818 819 820 821 822 823 824
		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);
825
		new = nfs4_alloc_lock_state(state, owner, pid, type);
826 827 828 829
		if (new == NULL)
			return NULL;
	}
	spin_unlock(&state->state_lock);
830 831
	if (new != NULL)
		nfs4_free_lock_state(new);
L
Linus Torvalds 已提交
832 833 834 835
	return lsp;
}

/*
836 837
 * Release reference to lock_state, and free it if we see that
 * it is no longer in use
L
Linus Torvalds 已提交
838
 */
839
void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
L
Linus Torvalds 已提交
840
{
841
	struct nfs4_state *state;
L
Linus Torvalds 已提交
842

843 844 845 846 847 848 849 850 851
	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);
852 853 854 855
	if (lsp->ls_flags & NFS_LOCK_INITIALIZED) {
		if (nfs4_release_lockowner(lsp) == 0)
			return;
	}
856
	nfs4_free_lock_state(lsp);
L
Linus Torvalds 已提交
857 858
}

859
static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
L
Linus Torvalds 已提交
860
{
861
	struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
L
Linus Torvalds 已提交
862

863 864 865
	dst->fl_u.nfs4_fl.owner = lsp;
	atomic_inc(&lsp->ls_count);
}
L
Linus Torvalds 已提交
866

867
static void nfs4_fl_release_lock(struct file_lock *fl)
L
Linus Torvalds 已提交
868
{
869
	nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
L
Linus Torvalds 已提交
870 871
}

872
static const struct file_lock_operations nfs4_fl_lock_ops = {
873 874 875 876 877
	.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 已提交
878
{
879 880 881 882
	struct nfs4_lock_state *lsp;

	if (fl->fl_ops != NULL)
		return 0;
883 884 885
	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)
886 887
		lsp = nfs4_get_lock_state(state, NULL, fl->fl_pid,
				NFS4_FLOCK_LOCK_TYPE);
888 889
	else
		return -EINVAL;
890 891 892 893 894
	if (lsp == NULL)
		return -ENOMEM;
	fl->fl_u.nfs4_fl.owner = lsp;
	fl->fl_ops = &nfs4_fl_lock_ops;
	return 0;
L
Linus Torvalds 已提交
895 896
}

897 898
static bool nfs4_copy_lock_stateid(nfs4_stateid *dst, struct nfs4_state *state,
		fl_owner_t fl_owner, pid_t fl_pid)
L
Linus Torvalds 已提交
899
{
900
	struct nfs4_lock_state *lsp;
901
	bool ret = false;
L
Linus Torvalds 已提交
902

903
	if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
904
		goto out;
L
Linus Torvalds 已提交
905

906
	spin_lock(&state->state_lock);
907
	lsp = __nfs4_find_lock_state(state, fl_owner, fl_pid, NFS4_ANY_LOCK_TYPE);
908
	if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0) {
909
		nfs4_stateid_copy(dst, &lsp->ls_stateid);
910 911
		ret = true;
	}
912
	spin_unlock(&state->state_lock);
L
Linus Torvalds 已提交
913
	nfs4_put_lock_state(lsp);
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939
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,
		fmode_t fmode, fl_owner_t fl_owner, pid_t fl_pid)
{
	if (nfs4_copy_delegation_stateid(dst, state->inode, fmode))
		return;
	if (nfs4_copy_lock_stateid(dst, state, fl_owner, fl_pid))
		return;
	nfs4_copy_open_stateid(dst, state);
L
Linus Torvalds 已提交
940 941
}

942
struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
943 944 945
{
	struct nfs_seqid *new;

946
	new = kmalloc(sizeof(*new), gfp_mask);
947 948
	if (new != NULL) {
		new->sequence = counter;
949
		INIT_LIST_HEAD(&new->list);
950
		new->task = NULL;
951 952 953 954
	}
	return new;
}

955
void nfs_release_seqid(struct nfs_seqid *seqid)
L
Linus Torvalds 已提交
956
{
957
	struct nfs_seqid_counter *sequence;
958

959 960 961 962 963 964 965 966 967 968 969
	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);
970
	}
971
	spin_unlock(&sequence->lock);
972 973 974 975 976
}

void nfs_free_seqid(struct nfs_seqid *seqid)
{
	nfs_release_seqid(seqid);
977
	kfree(seqid);
L
Linus Torvalds 已提交
978 979 980
}

/*
981 982 983 984
 * 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()
 */
985
static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
986
{
987
	BUG_ON(list_first_entry(&seqid->sequence->list, struct nfs_seqid, list) != seqid);
988 989 990 991
	switch (status) {
		case 0:
			break;
		case -NFS4ERR_BAD_SEQID:
992 993
			if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
				return;
994
			pr_warn_ratelimited("NFS: v4 server returned a bad"
D
Dan Muntz 已提交
995 996
					" sequence-id error on an"
					" unconfirmed sequence %p!\n",
997
					seqid->sequence);
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
		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)
{
1016 1017 1018 1019 1020
	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 已提交
1021
		nfs4_drop_state_owner(sp);
1022 1023
	if (!nfs4_has_session(server->nfs_client))
		nfs_increment_seqid(status, seqid);
1024 1025 1026 1027 1028 1029 1030 1031 1032
}

/*
 * 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)
{
1033
	nfs_increment_seqid(status, seqid);
1034 1035 1036 1037
}

int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
{
1038
	struct nfs_seqid_counter *sequence = seqid->sequence;
1039 1040 1041
	int status = 0;

	spin_lock(&sequence->lock);
1042
	seqid->task = task;
1043 1044 1045 1046
	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;
1047
	rpc_sleep_on(&sequence->wait, task, NULL);
1048 1049
	status = -EAGAIN;
unlock:
1050 1051
	spin_unlock(&sequence->lock);
	return status;
L
Linus Torvalds 已提交
1052 1053
}

1054
static int nfs4_run_state_manager(void *);
L
Linus Torvalds 已提交
1055

1056
static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
T
Trond Myklebust 已提交
1057 1058
{
	smp_mb__before_clear_bit();
1059
	clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
T
Trond Myklebust 已提交
1060
	smp_mb__after_clear_bit();
1061
	wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
T
Trond Myklebust 已提交
1062 1063 1064
	rpc_wake_up(&clp->cl_rpcwaitq);
}

L
Linus Torvalds 已提交
1065
/*
1066
 * Schedule the nfs_client asynchronous state management routine
L
Linus Torvalds 已提交
1067
 */
1068
void nfs4_schedule_state_manager(struct nfs_client *clp)
L
Linus Torvalds 已提交
1069
{
1070
	struct task_struct *task;
1071
	char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
L
Linus Torvalds 已提交
1072

1073 1074
	if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
		return;
1075 1076
	__module_get(THIS_MODULE);
	atomic_inc(&clp->cl_count);
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092

	/* 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 已提交
1093 1094 1095
}

/*
1096
 * Schedule a lease recovery attempt
L
Linus Torvalds 已提交
1097
 */
1098
void nfs4_schedule_lease_recovery(struct nfs_client *clp)
L
Linus Torvalds 已提交
1099 1100 1101
{
	if (!clp)
		return;
1102 1103
	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1104
	nfs4_schedule_state_manager(clp);
L
Linus Torvalds 已提交
1105
}
A
Andy Adamson 已提交
1106
EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
L
Linus Torvalds 已提交
1107

1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
/*
 * 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);
}

1122 1123
void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
{
1124
	nfs40_handle_cb_pathdown(clp);
1125 1126 1127
	nfs4_schedule_state_manager(clp);
}

1128
static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1129 1130 1131 1132 1133 1134 1135 1136
{

	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;
	}
1137
	set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
1138 1139 1140 1141
	set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
	return 1;
}

1142
static int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1143 1144 1145
{
	set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
	clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1146
	set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
1147 1148 1149 1150
	set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
	return 1;
}

1151 1152 1153 1154 1155 1156 1157
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);
	nfs4_schedule_state_manager(clp);
}
A
Andy Adamson 已提交
1158
EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1159

1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
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;
1176
		if (!nfs4_stateid_match(&state->stateid, stateid))
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
			continue;
		nfs4_state_mark_reclaim_nograce(clp, state);
		found = true;
	}
	spin_unlock(&inode->i_lock);
	if (found)
		nfs4_schedule_state_manager(clp);
}


1187
static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1188 1189
{
	struct inode *inode = state->inode;
1190
	struct nfs_inode *nfsi = NFS_I(inode);
L
Linus Torvalds 已提交
1191 1192 1193
	struct file_lock *fl;
	int status = 0;

1194 1195 1196 1197
	if (inode->i_flock == NULL)
		return 0;

	/* Guard against delegation returns and new lock/unlock calls */
1198
	down_write(&nfsi->rwsem);
1199
	/* Protect inode->i_flock using the BKL */
1200
	lock_flocks();
H
Harvey Harrison 已提交
1201
	for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
1202
		if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
L
Linus Torvalds 已提交
1203
			continue;
1204
		if (nfs_file_open_context(fl->fl_file)->state != state)
L
Linus Torvalds 已提交
1205
			continue;
1206
		unlock_flocks();
L
Linus Torvalds 已提交
1207 1208
		status = ops->recover_lock(state, fl);
		switch (status) {
1209 1210 1211 1212 1213 1214 1215 1216 1217
			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:
1218 1219 1220 1221
			case -NFS4ERR_BADSESSION:
			case -NFS4ERR_BADSLOT:
			case -NFS4ERR_BAD_HIGH_SLOT:
			case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1222
				goto out;
L
Linus Torvalds 已提交
1223
			default:
1224 1225
				printk(KERN_ERR "NFS: %s: unhandled error %d. "
					"Zeroing state\n", __func__, status);
1226 1227
			case -ENOMEM:
			case -NFS4ERR_DENIED:
L
Linus Torvalds 已提交
1228 1229
			case -NFS4ERR_RECLAIM_BAD:
			case -NFS4ERR_RECLAIM_CONFLICT:
1230
				/* kill_proc(fl->fl_pid, SIGLOST, 1); */
1231
				status = 0;
L
Linus Torvalds 已提交
1232
		}
1233
		lock_flocks();
L
Linus Torvalds 已提交
1234
	}
1235
	unlock_flocks();
1236
out:
1237
	up_write(&nfsi->rwsem);
L
Linus Torvalds 已提交
1238 1239 1240
	return status;
}

1241
static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
{
	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.
	 */
1255 1256
restart:
	spin_lock(&sp->so_lock);
L
Linus Torvalds 已提交
1257
	list_for_each_entry(state, &sp->so_states, open_states) {
1258 1259
		if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
			continue;
L
Linus Torvalds 已提交
1260 1261
		if (state->state == 0)
			continue;
1262 1263
		atomic_inc(&state->count);
		spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1264 1265
		status = ops->recover_open(sp, state);
		if (status >= 0) {
1266 1267
			status = nfs4_reclaim_locks(state, ops);
			if (status >= 0) {
1268
				spin_lock(&state->state_lock);
1269 1270
				list_for_each_entry(lock, &state->lock_states, ls_locks) {
					if (!(lock->ls_flags & NFS_LOCK_INITIALIZED))
1271 1272
						pr_warn_ratelimited("NFS: "
							"%s: Lock reclaim "
1273
							"failed!\n", __func__);
1274
				}
1275
				spin_unlock(&state->state_lock);
1276 1277
				nfs4_put_open_state(state);
				goto restart;
L
Linus Torvalds 已提交
1278 1279 1280 1281
			}
		}
		switch (status) {
			default:
1282 1283
				printk(KERN_ERR "NFS: %s: unhandled error %d. "
					"Zeroing state\n", __func__, status);
L
Linus Torvalds 已提交
1284
			case -ENOENT:
1285
			case -ENOMEM:
1286
			case -ESTALE:
L
Linus Torvalds 已提交
1287 1288 1289 1290
				/*
				 * Open state on this file cannot be recovered
				 * All we can do is revert to using the zero stateid.
				 */
1291 1292
				memset(&state->stateid, 0,
					sizeof(state->stateid));
L
Linus Torvalds 已提交
1293 1294 1295
				/* Mark the file as being 'closed' */
				state->state = 0;
				break;
1296 1297 1298 1299 1300 1301 1302 1303
			case -EKEYEXPIRED:
				/*
				 * User RPCSEC_GSS context has expired.
				 * We cannot recover this stateid now, so
				 * skip it and allow recovery thread to
				 * proceed.
				 */
				break;
1304 1305 1306
			case -NFS4ERR_ADMIN_REVOKED:
			case -NFS4ERR_STALE_STATEID:
			case -NFS4ERR_BAD_STATEID:
1307 1308
			case -NFS4ERR_RECLAIM_BAD:
			case -NFS4ERR_RECLAIM_CONFLICT:
1309
				nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1310
				break;
L
Linus Torvalds 已提交
1311 1312
			case -NFS4ERR_EXPIRED:
			case -NFS4ERR_NO_GRACE:
1313
				nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
L
Linus Torvalds 已提交
1314
			case -NFS4ERR_STALE_CLIENTID:
1315 1316 1317 1318
			case -NFS4ERR_BADSESSION:
			case -NFS4ERR_BADSLOT:
			case -NFS4ERR_BAD_HIGH_SLOT:
			case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
L
Linus Torvalds 已提交
1319 1320
				goto out_err;
		}
1321 1322
		nfs4_put_open_state(state);
		goto restart;
L
Linus Torvalds 已提交
1323
	}
1324
	spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1325 1326
	return 0;
out_err:
1327
	nfs4_put_open_state(state);
L
Linus Torvalds 已提交
1328 1329 1330
	return status;
}

1331 1332 1333 1334 1335 1336 1337 1338
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);
1339
	spin_lock(&state->state_lock);
1340 1341 1342 1343
	list_for_each_entry(lock, &state->lock_states, ls_locks) {
		lock->ls_seqid.flags = 0;
		lock->ls_flags &= ~NFS_LOCK_INITIALIZED;
	}
1344
	spin_unlock(&state->state_lock);
1345 1346
}

1347 1348
static void nfs4_reset_seqids(struct nfs_server *server,
	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1349
{
1350
	struct nfs_client *clp = server->nfs_client;
1351
	struct nfs4_state_owner *sp;
1352
	struct rb_node *pos;
1353 1354
	struct nfs4_state *state;

1355 1356 1357 1358 1359
	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);
1360
		sp->so_seqid.flags = 0;
1361
		spin_lock(&sp->so_lock);
1362
		list_for_each_entry(state, &sp->so_states, open_states) {
1363 1364
			if (mark_reclaim(clp, state))
				nfs4_clear_open_state(state);
1365
		}
1366
		spin_unlock(&sp->so_lock);
1367
	}
1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379
	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();
1380 1381
}

1382 1383 1384 1385 1386 1387 1388
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);
}

1389 1390 1391 1392 1393 1394 1395 1396
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);
}

1397
static void nfs4_clear_reclaim_server(struct nfs_server *server)
1398
{
1399
	struct nfs_client *clp = server->nfs_client;
1400 1401 1402 1403
	struct nfs4_state_owner *sp;
	struct rb_node *pos;
	struct nfs4_state *state;

1404 1405 1406 1407 1408
	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);
1409 1410
		spin_lock(&sp->so_lock);
		list_for_each_entry(state, &sp->so_states, open_states) {
1411 1412
			if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
						&state->flags))
1413 1414 1415 1416 1417
				continue;
			nfs4_state_mark_reclaim_nograce(clp, state);
		}
		spin_unlock(&sp->so_lock);
	}
1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
	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();
1432 1433

	nfs_delegation_reap_unclaimed(clp);
1434 1435 1436 1437 1438 1439 1440 1441
	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);
1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455
}

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

1456 1457 1458 1459 1460 1461 1462 1463
static void nfs4_warn_keyexpired(const char *s)
{
	printk_ratelimited(KERN_WARNING "Error: state manager"
			" encountered RPCSEC_GSS session"
			" expired against NFSv4 server %s.\n",
			s);
}

1464
static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1465 1466
{
	switch (error) {
1467 1468
		case 0:
			break;
1469
		case -NFS4ERR_CB_PATH_DOWN:
1470
			nfs40_handle_cb_pathdown(clp);
1471
			break;
1472 1473
		case -NFS4ERR_NO_GRACE:
			nfs4_state_end_reclaim_reboot(clp);
1474
			break;
1475 1476 1477
		case -NFS4ERR_STALE_CLIENTID:
		case -NFS4ERR_LEASE_MOVED:
			set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1478
			nfs4_state_clear_reclaim_reboot(clp);
1479 1480 1481 1482 1483
			nfs4_state_start_reclaim_reboot(clp);
			break;
		case -NFS4ERR_EXPIRED:
			set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
			nfs4_state_start_reclaim_nograce(clp);
1484
			break;
1485 1486 1487 1488 1489 1490 1491
		case -NFS4ERR_BADSESSION:
		case -NFS4ERR_BADSLOT:
		case -NFS4ERR_BAD_HIGH_SLOT:
		case -NFS4ERR_DEADSESSION:
		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
		case -NFS4ERR_SEQ_FALSE_RETRY:
		case -NFS4ERR_SEQ_MISORDERED:
1492
			set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1493
			/* Zero session reset errors */
1494
			break;
1495 1496 1497
		case -EKEYEXPIRED:
			/* Nothing we can do */
			nfs4_warn_keyexpired(clp->cl_hostname);
1498 1499 1500
			break;
		default:
			return error;
1501
	}
1502
	return 0;
1503 1504
}

1505
static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1506
{
1507 1508
	struct nfs4_state_owner *sp;
	struct nfs_server *server;
1509
	struct rb_node *pos;
L
Linus Torvalds 已提交
1510 1511
	int status = 0;

1512
restart:
1513 1514
	rcu_read_lock();
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1515
		nfs4_purge_state_owners(server);
1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535
		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);
			}

1536
			nfs4_put_state_owner(sp);
1537
			goto restart;
1538
		}
1539
		spin_unlock(&clp->cl_lock);
1540
	}
1541
	rcu_read_unlock();
1542 1543 1544 1545 1546 1547
	return status;
}

static int nfs4_check_lease(struct nfs_client *clp)
{
	struct rpc_cred *cred;
1548 1549
	const struct nfs4_state_maintenance_ops *ops =
		clp->cl_mvops->state_renewal_ops;
1550
	int status;
L
Linus Torvalds 已提交
1551

1552 1553 1554
	/* Is the client already known to have an expired lease? */
	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		return 0;
1555 1556 1557
	spin_lock(&clp->cl_lock);
	cred = ops->get_state_renewal_cred_locked(clp);
	spin_unlock(&clp->cl_lock);
1558 1559
	if (cred == NULL) {
		cred = nfs4_get_setclientid_cred(clp);
1560
		status = -ENOKEY;
1561 1562
		if (cred == NULL)
			goto out;
1563
	}
1564
	status = ops->renew_lease(clp, cred);
1565 1566
	put_rpccred(cred);
out:
1567
	return nfs4_recovery_handle_error(clp, status);
1568 1569 1570 1571 1572
}

static int nfs4_reclaim_lease(struct nfs_client *clp)
{
	struct rpc_cred *cred;
1573 1574
	const struct nfs4_state_recovery_ops *ops =
		clp->cl_mvops->reboot_recovery_ops;
1575 1576
	int status = -ENOENT;

1577
	cred = ops->get_clid_cred(clp);
1578
	if (cred != NULL) {
1579
		status = ops->establish_clid(clp, cred);
1580
		put_rpccred(cred);
1581 1582 1583
		/* Handle case where the user hasn't set up machine creds */
		if (status == -EACCES && cred == clp->cl_machine_cred) {
			nfs4_clear_machine_cred(clp);
1584
			status = -EAGAIN;
1585
		}
1586 1587
		if (status == -NFS4ERR_MINOR_VERS_MISMATCH)
			status = -EPROTONOSUPPORT;
1588
	}
1589 1590 1591
	return status;
}

1592
#ifdef CONFIG_NFS_V4_1
1593 1594
void nfs4_schedule_session_recovery(struct nfs4_session *session)
{
1595 1596 1597 1598
	struct nfs_client *clp = session->clp;

	set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
	nfs4_schedule_lease_recovery(clp);
1599
}
1600
EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
1601

A
Andy Adamson 已提交
1602 1603 1604
void nfs41_handle_recall_slot(struct nfs_client *clp)
{
	set_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state);
1605
	nfs4_schedule_state_manager(clp);
A
Andy Adamson 已提交
1606 1607
}

1608 1609 1610 1611 1612
static void nfs4_reset_all_state(struct nfs_client *clp)
{
	if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
		clp->cl_boot_time = CURRENT_TIME;
		nfs4_state_start_reclaim_nograce(clp);
1613
		nfs4_schedule_state_manager(clp);
1614 1615 1616 1617 1618 1619 1620
	}
}

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);
1621
		nfs4_schedule_state_manager(clp);
1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640
	}
}

static void nfs41_handle_state_revoked(struct nfs_client *clp)
{
	/* Temporary */
	nfs4_reset_all_state(clp);
}

static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
{
	/* This will need to handle layouts too */
	nfs_expire_all_delegations(clp);
}

static void nfs41_handle_cb_path_down(struct nfs_client *clp)
{
	nfs_expire_all_delegations(clp);
	if (test_and_set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) == 0)
1641
		nfs4_schedule_state_manager(clp);
1642 1643
}

1644 1645 1646 1647
void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)
{
	if (!flags)
		return;
1648
	if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
1649
		nfs41_handle_server_reboot(clp);
1650
	if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED |
1651 1652
			    SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
			    SEQ4_STATUS_ADMIN_STATE_REVOKED |
1653 1654
			    SEQ4_STATUS_LEASE_MOVED))
		nfs41_handle_state_revoked(clp);
1655
	if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
1656
		nfs41_handle_recallable_state_revoked(clp);
1657
	if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
1658 1659
			    SEQ4_STATUS_BACKCHANNEL_FAULT |
			    SEQ4_STATUS_CB_PATH_DOWN_SESSION))
1660
		nfs41_handle_cb_path_down(clp);
1661 1662
}

1663 1664 1665 1666
static int nfs4_reset_session(struct nfs_client *clp)
{
	int status;

1667
	nfs4_begin_drain_session(clp);
1668 1669 1670
	status = nfs4_proc_destroy_session(clp->cl_session);
	if (status && status != -NFS4ERR_BADSESSION &&
	    status != -NFS4ERR_DEADSESSION) {
1671
		status = nfs4_recovery_handle_error(clp, status);
1672 1673 1674 1675
		goto out;
	}

	memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
1676
	status = nfs4_proc_create_session(clp);
1677
	if (status) {
1678
		status = nfs4_recovery_handle_error(clp, status);
1679 1680
		goto out;
	}
1681
	clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1682 1683
	/* create_session negotiated new slot table */
	clear_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state);
1684

1685 1686
	 /* Let the state manager reestablish state */
	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1687
		nfs41_setup_state_renewal(clp);
1688
out:
1689 1690
	return status;
}
1691

A
Andy Adamson 已提交
1692 1693 1694 1695 1696 1697 1698 1699 1700
static int nfs4_recall_slot(struct nfs_client *clp)
{
	struct nfs4_slot_table *fc_tbl = &clp->cl_session->fc_slot_table;
	struct nfs4_channel_attrs *fc_attrs = &clp->cl_session->fc_attrs;
	struct nfs4_slot *new, *old;
	int i;

	nfs4_begin_drain_session(clp);
	new = kmalloc(fc_tbl->target_max_slots * sizeof(struct nfs4_slot),
1701
		      GFP_NOFS);
A
Andy Adamson 已提交
1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719
        if (!new)
		return -ENOMEM;

	spin_lock(&fc_tbl->slot_tbl_lock);
	for (i = 0; i < fc_tbl->target_max_slots; i++)
		new[i].seq_nr = fc_tbl->slots[i].seq_nr;
	old = fc_tbl->slots;
	fc_tbl->slots = new;
	fc_tbl->max_slots = fc_tbl->target_max_slots;
	fc_tbl->target_max_slots = 0;
	fc_attrs->max_reqs = fc_tbl->max_slots;
	spin_unlock(&fc_tbl->slot_tbl_lock);

	kfree(old);
	nfs4_end_drain_session(clp);
	return 0;
}

1720
#else /* CONFIG_NFS_V4_1 */
1721
static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
1722
static int nfs4_end_drain_session(struct nfs_client *clp) { return 0; }
A
Andy Adamson 已提交
1723
static int nfs4_recall_slot(struct nfs_client *clp) { return 0; }
1724 1725
#endif /* CONFIG_NFS_V4_1 */

1726 1727 1728 1729 1730
/* Set NFS4CLNT_LEASE_EXPIRED for all v4.0 errors and for recoverable errors
 * on EXCHANGE_ID for v4.1
 */
static void nfs4_set_lease_expired(struct nfs_client *clp, int status)
{
1731 1732 1733 1734 1735 1736
	switch (status) {
	case -NFS4ERR_CLID_INUSE:
	case -NFS4ERR_STALE_CLIENTID:
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
		break;
	case -NFS4ERR_DELAY:
1737
	case -ETIMEDOUT:
1738 1739 1740
	case -EAGAIN:
		ssleep(1);
		break;
1741

1742 1743 1744 1745 1746 1747
	case -EKEYEXPIRED:
		nfs4_warn_keyexpired(clp->cl_hostname);
	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
				 * in nfs4_exchange_id */
	default:
		return;
1748 1749 1750 1751
	}
	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
}

1752
static void nfs4_state_manager(struct nfs_client *clp)
1753 1754 1755 1756
{
	int status = 0;

	/* Ensure exclusive access to NFSv4 state */
1757
	do {
1758 1759 1760 1761
		if (test_and_clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
			/* We're going to have to re-establish a clientid */
			status = nfs4_reclaim_lease(clp);
			if (status) {
1762
				nfs4_set_lease_expired(clp, status);
1763 1764
				if (test_bit(NFS4CLNT_LEASE_EXPIRED,
							&clp->cl_state))
1765
					continue;
1766 1767 1768
				if (clp->cl_cons_state ==
							NFS_CS_SESSION_INITING)
					nfs_mark_client_ready(clp, status);
1769 1770
				goto out_error;
			}
1771
			clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1772 1773 1774 1775 1776 1777 1778 1779

			if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH,
					       &clp->cl_state))
				nfs4_state_start_reclaim_nograce(clp);
			else
				set_bit(NFS4CLNT_RECLAIM_REBOOT,
					&clp->cl_state);

1780
			pnfs_destroy_all_layouts(clp);
1781 1782 1783 1784
		}

		if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
			status = nfs4_check_lease(clp);
1785 1786
			if (status < 0)
				goto out_error;
1787
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1788
				continue;
1789
		}
1790

1791
		/* Initialize or reset the session */
1792
		if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)
1793
		   && nfs4_has_session(clp)) {
1794
			status = nfs4_reset_session(clp);
1795 1796 1797
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
				continue;
			if (status < 0)
1798 1799
				goto out_error;
		}
1800

1801
		/* First recover reboot state... */
1802
		if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
1803
			status = nfs4_do_reclaim(clp,
1804
				clp->cl_mvops->reboot_recovery_ops);
1805
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
1806
			    test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state))
1807
				continue;
1808
			nfs4_state_end_reclaim_reboot(clp);
1809 1810 1811 1812
			if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
				continue;
			if (status < 0)
				goto out_error;
1813 1814
		}

1815 1816
		/* Now recover expired state... */
		if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
1817
			status = nfs4_do_reclaim(clp,
1818
				clp->cl_mvops->nograce_recovery_ops);
1819
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
1820
			    test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) ||
1821 1822 1823
			    test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
				continue;
			if (status < 0)
1824
				goto out_error;
L
Linus Torvalds 已提交
1825
		}
1826

1827
		nfs4_end_drain_session(clp);
1828 1829 1830 1831
		if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
			nfs_client_return_marked_delegations(clp);
			continue;
		}
A
Andy Adamson 已提交
1832 1833 1834 1835 1836 1837 1838 1839 1840
		/* Recall session slots */
		if (test_and_clear_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state)
		   && nfs4_has_session(clp)) {
			status = nfs4_recall_slot(clp);
			if (status < 0)
				goto out_error;
			continue;
		}

1841 1842

		nfs4_clear_state_manager_bit(clp);
1843 1844 1845 1846 1847
		/* 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;
1848
	} while (atomic_read(&clp->cl_count) > 1);
1849
	return;
L
Linus Torvalds 已提交
1850
out_error:
1851
	pr_warn_ratelimited("NFS: state manager failed on NFSv4 server %s"
1852
			" with error %d\n", clp->cl_hostname, -status);
1853
	nfs4_end_drain_session(clp);
1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865
	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 已提交
1866 1867 1868 1869 1870 1871 1872
}

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