nfs4state.c 45.5 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 52
#include <linux/workqueue.h>
#include <linux/bitops.h>

53
#include "nfs4_fs.h"
L
Linus Torvalds 已提交
54 55
#include "callback.h"
#include "delegation.h"
56
#include "internal.h"
57
#include "pnfs.h"
L
Linus Torvalds 已提交
58 59 60

#define OPENOWNER_POOL_SIZE	8

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

static LIST_HEAD(nfs4_clientid_list);

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

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

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

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

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

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

136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
/**
 * 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;

	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();
	return cred;
}

158 159
#if defined(CONFIG_NFS_V4_1)

R
Ricardo Labiaga 已提交
160 161 162 163 164
static int nfs41_setup_state_renewal(struct nfs_client *clp)
{
	int status;
	struct nfs_fsinfo fsinfo;

165 166 167 168 169
	if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
		nfs4_schedule_state_renewal(clp);
		return 0;
	}

R
Ricardo Labiaga 已提交
170 171 172 173 174 175 176 177 178 179 180 181 182 183
	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;
}

184 185 186 187 188
/*
 * 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.
 */
189
static void nfs4_end_drain_session(struct nfs_client *clp)
190
{
191
	struct nfs4_session *ses = clp->cl_session;
192 193
	int max_slots;

194 195 196
	if (ses == NULL)
		return;
	if (test_and_clear_bit(NFS4_SESSION_DRAINING, &ses->session_state)) {
197 198 199 200 201 202 203 204 205 206 207 208 209
		spin_lock(&ses->fc_slot_table.slot_tbl_lock);
		max_slots = ses->fc_slot_table.max_slots;
		while (max_slots--) {
			struct rpc_task *task;

			task = rpc_wake_up_next(&ses->fc_slot_table.
						slot_tbl_waitq);
			if (!task)
				break;
			rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);
		}
		spin_unlock(&ses->fc_slot_table.slot_tbl_lock);
	}
210 211
}

212
static int nfs4_wait_on_slot_tbl(struct nfs4_slot_table *tbl)
213 214 215
{
	spin_lock(&tbl->slot_tbl_lock);
	if (tbl->highest_used_slotid != -1) {
216
		INIT_COMPLETION(tbl->complete);
217
		spin_unlock(&tbl->slot_tbl_lock);
218
		return wait_for_completion_interruptible(&tbl->complete);
219 220 221 222 223
	}
	spin_unlock(&tbl->slot_tbl_lock);
	return 0;
}

224 225 226 227 228 229 230 231 232 233 234 235 236 237
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);
}

238 239 240 241
int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
{
	int status;

242 243
	if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
		goto do_confirm;
244
	nfs4_begin_drain_session(clp);
245
	status = nfs4_proc_exchange_id(clp, cred);
R
Ricardo Labiaga 已提交
246 247
	if (status != 0)
		goto out;
248 249
	set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
do_confirm:
R
Ricardo Labiaga 已提交
250 251 252
	status = nfs4_proc_create_session(clp);
	if (status != 0)
		goto out;
253
	clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
R
Ricardo Labiaga 已提交
254 255 256
	nfs41_setup_state_renewal(clp);
	nfs_mark_client_ready(clp, NFS_CS_READY);
out:
257 258 259
	return status;
}

260 261 262 263 264 265 266 267 268 269 270 271
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 */

272 273
static struct rpc_cred *
nfs4_get_setclientid_cred_server(struct nfs_server *server)
274
{
275 276
	struct nfs_client *clp = server->nfs_client;
	struct rpc_cred *cred = NULL;
277
	struct nfs4_state_owner *sp;
278
	struct rb_node *pos;
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298

	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;
299
	struct rpc_cred *cred;
300

301 302
	spin_lock(&clp->cl_lock);
	cred = nfs4_get_machine_cred_locked(clp);
303
	spin_unlock(&clp->cl_lock);
304 305
	if (cred != NULL)
		goto out;
306 307 308 309 310 311

	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;
312
	}
313 314
	rcu_read_unlock();

315 316
out:
	return cred;
317 318
}

319 320 321
static void nfs_alloc_unique_id_locked(struct rb_root *root,
				       struct nfs_unique_id *new,
				       __u64 minval, int maxbits)
322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
{
	struct rb_node **p, *parent;
	struct nfs_unique_id *pos;
	__u64 mask = ~0ULL;

	if (maxbits < 64)
		mask = (1ULL << maxbits) - 1ULL;

	/* Ensure distribution is more or less flat */
	get_random_bytes(&new->id, sizeof(new->id));
	new->id &= mask;
	if (new->id < minval)
		new->id += minval;
retry:
	p = &root->rb_node;
	parent = NULL;

	while (*p != NULL) {
		parent = *p;
		pos = rb_entry(parent, struct nfs_unique_id, rb_node);

		if (new->id < pos->id)
			p = &(*p)->rb_left;
		else if (new->id > pos->id)
			p = &(*p)->rb_right;
		else
			goto id_exists;
	}
	rb_link_node(&new->rb_node, parent, p);
	rb_insert_color(&new->rb_node, root);
	return;
id_exists:
	for (;;) {
		new->id++;
		if (new->id < minval || (new->id & mask) != new->id) {
			new->id = minval;
			break;
		}
		parent = rb_next(parent);
		if (parent == NULL)
			break;
		pos = rb_entry(parent, struct nfs_unique_id, rb_node);
		if (new->id < pos->id)
			break;
	}
	goto retry;
}

static void nfs_free_unique_id(struct rb_root *root, struct nfs_unique_id *id)
{
	rb_erase(&id->rb_node, root);
}

L
Linus Torvalds 已提交
375
static struct nfs4_state_owner *
376
nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred)
L
Linus Torvalds 已提交
377
{
378
	struct rb_node **p = &server->state_owners.rb_node,
379
		       *parent = NULL;
380
	struct nfs4_state_owner *sp;
L
Linus Torvalds 已提交
381

382 383
	while (*p != NULL) {
		parent = *p;
384
		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
385 386 387 388 389 390 391

		if (cred < sp->so_cred)
			p = &parent->rb_left;
		else if (cred > sp->so_cred)
			p = &parent->rb_right;
		else {
			atomic_inc(&sp->so_count);
392
			return sp;
393
		}
L
Linus Torvalds 已提交
394
	}
395
	return NULL;
L
Linus Torvalds 已提交
396 397
}

398
static struct nfs4_state_owner *
399
nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
400
{
401 402
	struct nfs_server *server = new->so_server;
	struct rb_node **p = &server->state_owners.rb_node,
403 404 405 406 407
		       *parent = NULL;
	struct nfs4_state_owner *sp;

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

		if (new->so_cred < sp->so_cred)
			p = &parent->rb_left;
		else if (new->so_cred > sp->so_cred)
			p = &parent->rb_right;
		else {
			atomic_inc(&sp->so_count);
			return sp;
		}
	}
419 420 421 422
	nfs_alloc_unique_id_locked(&server->openowner_id,
					&new->so_owner_id, 1, 64);
	rb_link_node(&new->so_server_node, parent, p);
	rb_insert_color(&new->so_server_node, &server->state_owners);
423 424 425 426
	return new;
}

static void
427
nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
428
{
429 430 431 432 433
	struct nfs_server *server = sp->so_server;

	if (!RB_EMPTY_NODE(&sp->so_server_node))
		rb_erase(&sp->so_server_node, &server->state_owners);
	nfs_free_unique_id(&server->openowner_id, &sp->so_owner_id);
434 435
}

L
Linus Torvalds 已提交
436 437 438 439 440 441 442 443 444 445
/*
 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
 * create a new state_owner.
 *
 */
static struct nfs4_state_owner *
nfs4_alloc_state_owner(void)
{
	struct nfs4_state_owner *sp;

446
	sp = kzalloc(sizeof(*sp),GFP_NOFS);
L
Linus Torvalds 已提交
447 448
	if (!sp)
		return NULL;
449
	spin_lock_init(&sp->so_lock);
L
Linus Torvalds 已提交
450
	INIT_LIST_HEAD(&sp->so_states);
451 452 453 454
	rpc_init_wait_queue(&sp->so_sequence.wait, "Seqid_waitqueue");
	sp->so_seqid.sequence = &sp->so_sequence;
	spin_lock_init(&sp->so_sequence.lock);
	INIT_LIST_HEAD(&sp->so_sequence.list);
L
Linus Torvalds 已提交
455 456 457 458
	atomic_set(&sp->so_count, 1);
	return sp;
}

459
static void
L
Linus Torvalds 已提交
460 461
nfs4_drop_state_owner(struct nfs4_state_owner *sp)
{
462 463 464
	if (!RB_EMPTY_NODE(&sp->so_server_node)) {
		struct nfs_server *server = sp->so_server;
		struct nfs_client *clp = server->nfs_client;
465 466

		spin_lock(&clp->cl_lock);
467 468
		rb_erase(&sp->so_server_node, &server->state_owners);
		RB_CLEAR_NODE(&sp->so_server_node);
469 470
		spin_unlock(&clp->cl_lock);
	}
L
Linus Torvalds 已提交
471 472
}

473 474 475 476 477 478 479 480 481
/**
 * 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,
					      struct rpc_cred *cred)
L
Linus Torvalds 已提交
482
{
483
	struct nfs_client *clp = server->nfs_client;
L
Linus Torvalds 已提交
484 485 486
	struct nfs4_state_owner *sp, *new;

	spin_lock(&clp->cl_lock);
487
	sp = nfs4_find_state_owner_locked(server, cred);
L
Linus Torvalds 已提交
488 489 490
	spin_unlock(&clp->cl_lock);
	if (sp != NULL)
		return sp;
491 492 493
	new = nfs4_alloc_state_owner();
	if (new == NULL)
		return NULL;
494
	new->so_server = server;
495 496
	new->so_cred = cred;
	spin_lock(&clp->cl_lock);
497
	sp = nfs4_insert_state_owner_locked(new);
498 499 500
	spin_unlock(&clp->cl_lock);
	if (sp == new)
		get_rpccred(cred);
501 502
	else {
		rpc_destroy_wait_queue(&new->so_sequence.wait);
503
		kfree(new);
504
	}
505
	return sp;
L
Linus Torvalds 已提交
506 507
}

508 509 510 511 512
/**
 * nfs4_put_state_owner - Release a nfs4_state_owner
 * @sp: state owner data to release
 *
 */
L
Linus Torvalds 已提交
513 514
void nfs4_put_state_owner(struct nfs4_state_owner *sp)
{
515
	struct nfs_client *clp = sp->so_server->nfs_client;
L
Linus Torvalds 已提交
516 517 518 519
	struct rpc_cred *cred = sp->so_cred;

	if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
		return;
520
	nfs4_remove_state_owner_locked(sp);
L
Linus Torvalds 已提交
521
	spin_unlock(&clp->cl_lock);
522
	rpc_destroy_wait_queue(&sp->so_sequence.wait);
L
Linus Torvalds 已提交
523 524 525 526 527 528 529 530 531
	put_rpccred(cred);
	kfree(sp);
}

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

532
	state = kzalloc(sizeof(*state), GFP_NOFS);
L
Linus Torvalds 已提交
533 534 535 536
	if (!state)
		return NULL;
	atomic_set(&state->count, 1);
	INIT_LIST_HEAD(&state->lock_states);
537
	spin_lock_init(&state->state_lock);
538
	seqlock_init(&state->seqlock);
L
Linus Torvalds 已提交
539 540 541
	return state;
}

542
void
543
nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
544
{
545
	if (state->state == fmode)
546 547
		return;
	/* NB! List reordering - see the reclaim code for why.  */
548 549
	if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
		if (fmode & FMODE_WRITE)
550 551 552 553
			list_move(&state->open_states, &state->owner->so_states);
		else
			list_move_tail(&state->open_states, &state->owner->so_states);
	}
554
	state->state = fmode;
555 556
}

L
Linus Torvalds 已提交
557 558 559 560 561 562 563
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) {
564
		if (state->owner != owner)
L
Linus Torvalds 已提交
565
			continue;
566
		if (atomic_inc_not_zero(&state->count))
L
Linus Torvalds 已提交
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
			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();
590
	spin_lock(&owner->so_lock);
L
Linus Torvalds 已提交
591 592 593 594 595 596 597
	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);
598 599
		ihold(inode);
		state->inode = inode;
L
Linus Torvalds 已提交
600
		spin_unlock(&inode->i_lock);
601 602 603 604
		/* 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 已提交
605 606
	} else {
		spin_unlock(&inode->i_lock);
607
		spin_unlock(&owner->so_lock);
L
Linus Torvalds 已提交
608 609 610 611 612 613 614 615 616 617 618 619
		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;

620
	if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
L
Linus Torvalds 已提交
621
		return;
622
	spin_lock(&inode->i_lock);
623
	list_del(&state->inode_states);
L
Linus Torvalds 已提交
624
	list_del(&state->open_states);
625 626
	spin_unlock(&inode->i_lock);
	spin_unlock(&owner->so_lock);
L
Linus Torvalds 已提交
627 628 629 630 631 632
	iput(inode);
	nfs4_free_open_state(state);
	nfs4_put_state_owner(owner);
}

/*
633
 * Close the current file.
L
Linus Torvalds 已提交
634
 */
635
static void __nfs4_close(struct nfs4_state *state,
636
		fmode_t fmode, gfp_t gfp_mask, int wait)
L
Linus Torvalds 已提交
637 638
{
	struct nfs4_state_owner *owner = state->owner;
639
	int call_close = 0;
640
	fmode_t newstate;
L
Linus Torvalds 已提交
641 642 643

	atomic_inc(&owner->so_count);
	/* Protect against nfs4_find_state() */
644
	spin_lock(&owner->so_lock);
645
	switch (fmode & (FMODE_READ | FMODE_WRITE)) {
646 647 648 649 650 651 652 653 654
		case FMODE_READ:
			state->n_rdonly--;
			break;
		case FMODE_WRITE:
			state->n_wronly--;
			break;
		case FMODE_READ|FMODE_WRITE:
			state->n_rdwr--;
	}
655
	newstate = FMODE_READ|FMODE_WRITE;
656
	if (state->n_rdwr == 0) {
657
		if (state->n_rdonly == 0) {
658
			newstate &= ~FMODE_READ;
659 660 661 662
			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) {
663
			newstate &= ~FMODE_WRITE;
664 665 666 667 668
			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);
669
	}
670
	nfs4_state_set_mode_locked(state, newstate);
671
	spin_unlock(&owner->so_lock);
672

673
	if (!call_close) {
674 675
		nfs4_put_open_state(state);
		nfs4_put_state_owner(owner);
F
Fred Isaman 已提交
676 677 678
	} else {
		bool roc = pnfs_roc(state->inode);

679
		nfs4_do_close(state, gfp_mask, wait, roc);
F
Fred Isaman 已提交
680
	}
681 682
}

683
void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
684
{
685
	__nfs4_close(state, fmode, GFP_NOFS, 0);
686 687
}

688
void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
689
{
690
	__nfs4_close(state, fmode, GFP_KERNEL, 1);
L
Linus Torvalds 已提交
691 692 693 694 695 696 697
}

/*
 * Search the state->lock_states for an existing lock_owner
 * that is compatible with current->files
 */
static struct nfs4_lock_state *
698
__nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type)
L
Linus Torvalds 已提交
699 700 701
{
	struct nfs4_lock_state *pos;
	list_for_each_entry(pos, &state->lock_states, ls_locks) {
702
		if (type != NFS4_ANY_LOCK_TYPE && pos->ls_owner.lo_type != type)
L
Linus Torvalds 已提交
703
			continue;
704 705 706 707 708 709 710 711 712
		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 已提交
713 714 715 716 717 718 719 720 721 722 723
		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.
 *
 */
724
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 已提交
725 726
{
	struct nfs4_lock_state *lsp;
727 728
	struct nfs_server *server = state->owner->so_server;
	struct nfs_client *clp = server->nfs_client;
L
Linus Torvalds 已提交
729

730
	lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
L
Linus Torvalds 已提交
731 732
	if (lsp == NULL)
		return NULL;
733 734 735 736
	rpc_init_wait_queue(&lsp->ls_sequence.wait, "lock_seqid_waitqueue");
	spin_lock_init(&lsp->ls_sequence.lock);
	INIT_LIST_HEAD(&lsp->ls_sequence.list);
	lsp->ls_seqid.sequence = &lsp->ls_sequence;
L
Linus Torvalds 已提交
737
	atomic_set(&lsp->ls_count, 1);
738
	lsp->ls_state = state;
739 740 741 742 743 744 745 746 747 748 749 750
	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:
		kfree(lsp);
		return NULL;
	}
L
Linus Torvalds 已提交
751
	spin_lock(&clp->cl_lock);
752
	nfs_alloc_unique_id_locked(&server->lockowner_id, &lsp->ls_id, 1, 64);
L
Linus Torvalds 已提交
753
	spin_unlock(&clp->cl_lock);
754
	INIT_LIST_HEAD(&lsp->ls_locks);
L
Linus Torvalds 已提交
755 756 757
	return lsp;
}

758 759
static void nfs4_free_lock_state(struct nfs4_lock_state *lsp)
{
760 761
	struct nfs_server *server = lsp->ls_state->owner->so_server;
	struct nfs_client *clp = server->nfs_client;
762 763

	spin_lock(&clp->cl_lock);
764
	nfs_free_unique_id(&server->lockowner_id, &lsp->ls_id);
765
	spin_unlock(&clp->cl_lock);
766
	rpc_destroy_wait_queue(&lsp->ls_sequence.wait);
767 768 769
	kfree(lsp);
}

L
Linus Torvalds 已提交
770 771 772 773 774
/*
 * Return a compatible lock_state. If no initialized lock_state structure
 * exists, return an uninitialized one.
 *
 */
775
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 已提交
776
{
777
	struct nfs4_lock_state *lsp, *new = NULL;
L
Linus Torvalds 已提交
778
	
779 780
	for(;;) {
		spin_lock(&state->state_lock);
781
		lsp = __nfs4_find_lock_state(state, owner, pid, type);
782 783 784 785 786 787 788 789 790 791
		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);
792
		new = nfs4_alloc_lock_state(state, owner, pid, type);
793 794 795 796
		if (new == NULL)
			return NULL;
	}
	spin_unlock(&state->state_lock);
797 798
	if (new != NULL)
		nfs4_free_lock_state(new);
L
Linus Torvalds 已提交
799 800 801 802
	return lsp;
}

/*
803 804
 * Release reference to lock_state, and free it if we see that
 * it is no longer in use
L
Linus Torvalds 已提交
805
 */
806
void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
L
Linus Torvalds 已提交
807
{
808
	struct nfs4_state *state;
L
Linus Torvalds 已提交
809

810 811 812 813 814 815 816 817 818
	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);
819 820
	if (lsp->ls_flags & NFS_LOCK_INITIALIZED)
		nfs4_release_lockowner(lsp);
821
	nfs4_free_lock_state(lsp);
L
Linus Torvalds 已提交
822 823
}

824
static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
L
Linus Torvalds 已提交
825
{
826
	struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
L
Linus Torvalds 已提交
827

828 829 830
	dst->fl_u.nfs4_fl.owner = lsp;
	atomic_inc(&lsp->ls_count);
}
L
Linus Torvalds 已提交
831

832
static void nfs4_fl_release_lock(struct file_lock *fl)
L
Linus Torvalds 已提交
833
{
834
	nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
L
Linus Torvalds 已提交
835 836
}

837
static const struct file_lock_operations nfs4_fl_lock_ops = {
838 839 840 841 842
	.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 已提交
843
{
844 845 846 847
	struct nfs4_lock_state *lsp;

	if (fl->fl_ops != NULL)
		return 0;
848 849 850 851 852 853
	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)
		lsp = nfs4_get_lock_state(state, 0, fl->fl_pid, NFS4_FLOCK_LOCK_TYPE);
	else
		return -EINVAL;
854 855 856 857 858
	if (lsp == NULL)
		return -ENOMEM;
	fl->fl_u.nfs4_fl.owner = lsp;
	fl->fl_ops = &nfs4_fl_lock_ops;
	return 0;
L
Linus Torvalds 已提交
859 860
}

861 862 863
/*
 * Byte-range lock aware utility to initialize the stateid of read/write
 * requests.
L
Linus Torvalds 已提交
864
 */
865
void nfs4_copy_stateid(nfs4_stateid *dst, struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid)
L
Linus Torvalds 已提交
866
{
867
	struct nfs4_lock_state *lsp;
868
	int seq;
L
Linus Torvalds 已提交
869

870 871 872 873
	do {
		seq = read_seqbegin(&state->seqlock);
		memcpy(dst, &state->stateid, sizeof(*dst));
	} while (read_seqretry(&state->seqlock, seq));
874 875
	if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
		return;
L
Linus Torvalds 已提交
876

877
	spin_lock(&state->state_lock);
878
	lsp = __nfs4_find_lock_state(state, fl_owner, fl_pid, NFS4_ANY_LOCK_TYPE);
879 880 881
	if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0)
		memcpy(dst, &lsp->ls_stateid, sizeof(*dst));
	spin_unlock(&state->state_lock);
L
Linus Torvalds 已提交
882 883 884
	nfs4_put_lock_state(lsp);
}

885
struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
886 887 888
{
	struct nfs_seqid *new;

889
	new = kmalloc(sizeof(*new), gfp_mask);
890 891
	if (new != NULL) {
		new->sequence = counter;
892
		INIT_LIST_HEAD(&new->list);
893 894 895 896
	}
	return new;
}

897
void nfs_release_seqid(struct nfs_seqid *seqid)
L
Linus Torvalds 已提交
898
{
899 900
	if (!list_empty(&seqid->list)) {
		struct rpc_sequence *sequence = seqid->sequence->sequence;
901

902
		spin_lock(&sequence->lock);
903
		list_del_init(&seqid->list);
904 905 906
		spin_unlock(&sequence->lock);
		rpc_wake_up(&sequence->wait);
	}
907 908 909 910 911
}

void nfs_free_seqid(struct nfs_seqid *seqid)
{
	nfs_release_seqid(seqid);
912
	kfree(seqid);
L
Linus Torvalds 已提交
913 914 915
}

/*
916 917 918 919
 * 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()
 */
920
static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
921
{
922
	BUG_ON(list_first_entry(&seqid->sequence->sequence->list, struct nfs_seqid, list) != seqid);
923 924 925 926
	switch (status) {
		case 0:
			break;
		case -NFS4ERR_BAD_SEQID:
927 928 929
			if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
				return;
			printk(KERN_WARNING "NFS: v4 server returned a bad"
D
Dan Muntz 已提交
930 931
					" sequence-id error on an"
					" unconfirmed sequence %p!\n",
932
					seqid->sequence);
933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950
		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)
{
951 952 953 954 955
	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 已提交
956
		nfs4_drop_state_owner(sp);
957 958
	if (!nfs4_has_session(server->nfs_client))
		nfs_increment_seqid(status, seqid);
959 960 961 962 963 964 965 966 967
}

/*
 * 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)
{
968
	nfs_increment_seqid(status, seqid);
969 970 971 972 973 974 975 976
}

int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
{
	struct rpc_sequence *sequence = seqid->sequence->sequence;
	int status = 0;

	spin_lock(&sequence->lock);
977 978 979 980
	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;
981
	rpc_sleep_on(&sequence->wait, task, NULL);
982 983
	status = -EAGAIN;
unlock:
984 985
	spin_unlock(&sequence->lock);
	return status;
L
Linus Torvalds 已提交
986 987
}

988
static int nfs4_run_state_manager(void *);
L
Linus Torvalds 已提交
989

990
static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
T
Trond Myklebust 已提交
991 992
{
	smp_mb__before_clear_bit();
993
	clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
T
Trond Myklebust 已提交
994
	smp_mb__after_clear_bit();
995
	wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
T
Trond Myklebust 已提交
996 997 998
	rpc_wake_up(&clp->cl_rpcwaitq);
}

L
Linus Torvalds 已提交
999
/*
1000
 * Schedule the nfs_client asynchronous state management routine
L
Linus Torvalds 已提交
1001
 */
1002
void nfs4_schedule_state_manager(struct nfs_client *clp)
L
Linus Torvalds 已提交
1003
{
1004
	struct task_struct *task;
L
Linus Torvalds 已提交
1005

1006 1007
	if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
		return;
1008 1009
	__module_get(THIS_MODULE);
	atomic_inc(&clp->cl_count);
1010
	task = kthread_run(nfs4_run_state_manager, clp, "%s-manager",
1011 1012
				rpc_peeraddr2str(clp->cl_rpcclient,
							RPC_DISPLAY_ADDR));
1013 1014
	if (!IS_ERR(task))
		return;
1015
	nfs4_clear_state_manager_bit(clp);
1016
	nfs_put_client(clp);
1017
	module_put(THIS_MODULE);
L
Linus Torvalds 已提交
1018 1019 1020
}

/*
1021
 * Schedule a lease recovery attempt
L
Linus Torvalds 已提交
1022
 */
1023
void nfs4_schedule_lease_recovery(struct nfs_client *clp)
L
Linus Torvalds 已提交
1024 1025 1026
{
	if (!clp)
		return;
1027 1028
	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1029
	nfs4_schedule_state_manager(clp);
L
Linus Torvalds 已提交
1030 1031
}

1032 1033 1034 1035 1036 1037
void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
{
	nfs_handle_cb_pathdown(clp);
	nfs4_schedule_state_manager(clp);
}

1038
static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1039 1040 1041 1042 1043 1044 1045 1046
{

	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;
	}
1047
	set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
1048 1049 1050 1051
	set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
	return 1;
}

1052
static int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1053 1054 1055
{
	set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
	clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1056
	set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
1057 1058 1059 1060
	set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
	return 1;
}

1061 1062 1063 1064 1065 1066 1067 1068
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);
}

1069
static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1070 1071
{
	struct inode *inode = state->inode;
1072
	struct nfs_inode *nfsi = NFS_I(inode);
L
Linus Torvalds 已提交
1073 1074 1075
	struct file_lock *fl;
	int status = 0;

1076 1077 1078 1079
	if (inode->i_flock == NULL)
		return 0;

	/* Guard against delegation returns and new lock/unlock calls */
1080
	down_write(&nfsi->rwsem);
1081
	/* Protect inode->i_flock using the BKL */
1082
	lock_flocks();
H
Harvey Harrison 已提交
1083
	for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
1084
		if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
L
Linus Torvalds 已提交
1085
			continue;
1086
		if (nfs_file_open_context(fl->fl_file)->state != state)
L
Linus Torvalds 已提交
1087
			continue;
1088
		unlock_flocks();
L
Linus Torvalds 已提交
1089 1090
		status = ops->recover_lock(state, fl);
		switch (status) {
1091 1092 1093 1094 1095 1096 1097 1098 1099
			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:
1100 1101 1102 1103
			case -NFS4ERR_BADSESSION:
			case -NFS4ERR_BADSLOT:
			case -NFS4ERR_BAD_HIGH_SLOT:
			case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1104
				goto out;
L
Linus Torvalds 已提交
1105 1106
			default:
				printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n",
1107
						__func__, status);
1108 1109
			case -ENOMEM:
			case -NFS4ERR_DENIED:
L
Linus Torvalds 已提交
1110 1111
			case -NFS4ERR_RECLAIM_BAD:
			case -NFS4ERR_RECLAIM_CONFLICT:
1112
				/* kill_proc(fl->fl_pid, SIGLOST, 1); */
1113
				status = 0;
L
Linus Torvalds 已提交
1114
		}
1115
		lock_flocks();
L
Linus Torvalds 已提交
1116
	}
1117
	unlock_flocks();
1118
out:
1119
	up_write(&nfsi->rwsem);
L
Linus Torvalds 已提交
1120 1121 1122
	return status;
}

1123
static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
{
	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.
	 */
1137 1138
restart:
	spin_lock(&sp->so_lock);
L
Linus Torvalds 已提交
1139
	list_for_each_entry(state, &sp->so_states, open_states) {
1140 1141
		if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
			continue;
L
Linus Torvalds 已提交
1142 1143
		if (state->state == 0)
			continue;
1144 1145
		atomic_inc(&state->count);
		spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1146 1147
		status = ops->recover_open(sp, state);
		if (status >= 0) {
1148 1149
			status = nfs4_reclaim_locks(state, ops);
			if (status >= 0) {
1150
				spin_lock(&state->state_lock);
1151 1152 1153
				list_for_each_entry(lock, &state->lock_states, ls_locks) {
					if (!(lock->ls_flags & NFS_LOCK_INITIALIZED))
						printk("%s: Lock reclaim failed!\n",
1154
							__func__);
1155
				}
1156
				spin_unlock(&state->state_lock);
1157 1158
				nfs4_put_open_state(state);
				goto restart;
L
Linus Torvalds 已提交
1159 1160 1161 1162 1163
			}
		}
		switch (status) {
			default:
				printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n",
1164
						__func__, status);
L
Linus Torvalds 已提交
1165
			case -ENOENT:
1166
			case -ENOMEM:
1167
			case -ESTALE:
L
Linus Torvalds 已提交
1168 1169 1170 1171 1172 1173 1174 1175 1176
				/*
				 * Open state on this file cannot be recovered
				 * All we can do is revert to using the zero stateid.
				 */
				memset(state->stateid.data, 0,
					sizeof(state->stateid.data));
				/* Mark the file as being 'closed' */
				state->state = 0;
				break;
1177 1178 1179 1180 1181 1182 1183 1184
			case -EKEYEXPIRED:
				/*
				 * User RPCSEC_GSS context has expired.
				 * We cannot recover this stateid now, so
				 * skip it and allow recovery thread to
				 * proceed.
				 */
				break;
1185 1186 1187
			case -NFS4ERR_ADMIN_REVOKED:
			case -NFS4ERR_STALE_STATEID:
			case -NFS4ERR_BAD_STATEID:
1188 1189
			case -NFS4ERR_RECLAIM_BAD:
			case -NFS4ERR_RECLAIM_CONFLICT:
1190
				nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1191
				break;
L
Linus Torvalds 已提交
1192 1193
			case -NFS4ERR_EXPIRED:
			case -NFS4ERR_NO_GRACE:
1194
				nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
L
Linus Torvalds 已提交
1195
			case -NFS4ERR_STALE_CLIENTID:
1196 1197 1198 1199
			case -NFS4ERR_BADSESSION:
			case -NFS4ERR_BADSLOT:
			case -NFS4ERR_BAD_HIGH_SLOT:
			case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
L
Linus Torvalds 已提交
1200 1201
				goto out_err;
		}
1202 1203
		nfs4_put_open_state(state);
		goto restart;
L
Linus Torvalds 已提交
1204
	}
1205
	spin_unlock(&sp->so_lock);
L
Linus Torvalds 已提交
1206 1207
	return 0;
out_err:
1208
	nfs4_put_open_state(state);
L
Linus Torvalds 已提交
1209 1210 1211
	return status;
}

1212 1213 1214 1215 1216 1217 1218 1219
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);
1220
	spin_lock(&state->state_lock);
1221 1222 1223 1224
	list_for_each_entry(lock, &state->lock_states, ls_locks) {
		lock->ls_seqid.flags = 0;
		lock->ls_flags &= ~NFS_LOCK_INITIALIZED;
	}
1225
	spin_unlock(&state->state_lock);
1226 1227
}

1228 1229
static void nfs4_reset_seqids(struct nfs_server *server,
	int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1230
{
1231
	struct nfs_client *clp = server->nfs_client;
1232
	struct nfs4_state_owner *sp;
1233
	struct rb_node *pos;
1234 1235
	struct nfs4_state *state;

1236 1237 1238 1239 1240
	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);
1241
		sp->so_seqid.flags = 0;
1242
		spin_lock(&sp->so_lock);
1243
		list_for_each_entry(state, &sp->so_states, open_states) {
1244 1245
			if (mark_reclaim(clp, state))
				nfs4_clear_open_state(state);
1246
		}
1247
		spin_unlock(&sp->so_lock);
1248
	}
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260
	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();
1261 1262
}

1263 1264 1265 1266 1267 1268 1269
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);
}

1270 1271 1272 1273 1274 1275 1276 1277
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);
}

1278
static void nfs4_clear_reclaim_server(struct nfs_server *server)
1279
{
1280
	struct nfs_client *clp = server->nfs_client;
1281 1282 1283 1284
	struct nfs4_state_owner *sp;
	struct rb_node *pos;
	struct nfs4_state *state;

1285 1286 1287 1288 1289
	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);
1290 1291
		spin_lock(&sp->so_lock);
		list_for_each_entry(state, &sp->so_states, open_states) {
1292 1293
			if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
						&state->flags))
1294 1295 1296 1297 1298
				continue;
			nfs4_state_mark_reclaim_nograce(clp, state);
		}
		spin_unlock(&sp->so_lock);
	}
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
	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();
1313 1314

	nfs_delegation_reap_unclaimed(clp);
1315 1316 1317 1318 1319 1320 1321 1322
	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);
1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336
}

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

1337 1338 1339 1340 1341 1342 1343 1344
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);
}

1345
static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1346 1347
{
	switch (error) {
1348 1349
		case 0:
			break;
1350
		case -NFS4ERR_CB_PATH_DOWN:
1351
			nfs_handle_cb_pathdown(clp);
1352
			break;
1353 1354
		case -NFS4ERR_NO_GRACE:
			nfs4_state_end_reclaim_reboot(clp);
1355
			break;
1356 1357 1358
		case -NFS4ERR_STALE_CLIENTID:
		case -NFS4ERR_LEASE_MOVED:
			set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1359
			nfs4_state_clear_reclaim_reboot(clp);
1360 1361 1362 1363 1364
			nfs4_state_start_reclaim_reboot(clp);
			break;
		case -NFS4ERR_EXPIRED:
			set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
			nfs4_state_start_reclaim_nograce(clp);
1365
			break;
1366 1367 1368 1369 1370 1371 1372
		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:
1373
			set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1374
			/* Zero session reset errors */
1375
			break;
1376 1377 1378
		case -EKEYEXPIRED:
			/* Nothing we can do */
			nfs4_warn_keyexpired(clp->cl_hostname);
1379 1380 1381
			break;
		default:
			return error;
1382
	}
1383
	return 0;
1384 1385
}

1386
static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1387
{
1388 1389
	struct nfs4_state_owner *sp;
	struct nfs_server *server;
1390
	struct rb_node *pos;
L
Linus Torvalds 已提交
1391 1392
	int status = 0;

1393
restart:
1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
	rcu_read_lock();
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
		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);
			}

1416
			nfs4_put_state_owner(sp);
1417
			goto restart;
1418
		}
1419
		spin_unlock(&clp->cl_lock);
1420
	}
1421
	rcu_read_unlock();
1422 1423 1424 1425 1426 1427
	return status;
}

static int nfs4_check_lease(struct nfs_client *clp)
{
	struct rpc_cred *cred;
1428 1429
	const struct nfs4_state_maintenance_ops *ops =
		clp->cl_mvops->state_renewal_ops;
1430
	int status;
L
Linus Torvalds 已提交
1431

1432 1433 1434
	/* Is the client already known to have an expired lease? */
	if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		return 0;
1435 1436 1437
	spin_lock(&clp->cl_lock);
	cred = ops->get_state_renewal_cred_locked(clp);
	spin_unlock(&clp->cl_lock);
1438 1439
	if (cred == NULL) {
		cred = nfs4_get_setclientid_cred(clp);
1440
		status = -ENOKEY;
1441 1442
		if (cred == NULL)
			goto out;
1443
	}
1444
	status = ops->renew_lease(clp, cred);
1445 1446
	put_rpccred(cred);
out:
1447
	return nfs4_recovery_handle_error(clp, status);
1448 1449 1450 1451 1452
}

static int nfs4_reclaim_lease(struct nfs_client *clp)
{
	struct rpc_cred *cred;
1453 1454
	const struct nfs4_state_recovery_ops *ops =
		clp->cl_mvops->reboot_recovery_ops;
1455 1456
	int status = -ENOENT;

1457
	cred = ops->get_clid_cred(clp);
1458
	if (cred != NULL) {
1459
		status = ops->establish_clid(clp, cred);
1460
		put_rpccred(cred);
1461 1462 1463
		/* Handle case where the user hasn't set up machine creds */
		if (status == -EACCES && cred == clp->cl_machine_cred) {
			nfs4_clear_machine_cred(clp);
1464
			status = -EAGAIN;
1465
		}
1466 1467
		if (status == -NFS4ERR_MINOR_VERS_MISMATCH)
			status = -EPROTONOSUPPORT;
1468
	}
1469 1470 1471
	return status;
}

1472
#ifdef CONFIG_NFS_V4_1
1473 1474
void nfs4_schedule_session_recovery(struct nfs4_session *session)
{
1475 1476 1477 1478
	struct nfs_client *clp = session->clp;

	set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
	nfs4_schedule_lease_recovery(clp);
1479
}
1480
EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
1481

A
Andy Adamson 已提交
1482 1483 1484
void nfs41_handle_recall_slot(struct nfs_client *clp)
{
	set_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state);
1485
	nfs4_schedule_state_manager(clp);
A
Andy Adamson 已提交
1486 1487
}

1488 1489 1490 1491 1492
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);
1493
		nfs4_schedule_state_manager(clp);
1494 1495 1496 1497 1498 1499 1500
	}
}

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);
1501
		nfs4_schedule_state_manager(clp);
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
	}
}

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)
1521
		nfs4_schedule_state_manager(clp);
1522 1523
}

1524 1525 1526 1527
void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)
{
	if (!flags)
		return;
1528
	if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
1529
		nfs41_handle_server_reboot(clp);
1530
	if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED |
1531 1532
			    SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
			    SEQ4_STATUS_ADMIN_STATE_REVOKED |
1533 1534
			    SEQ4_STATUS_LEASE_MOVED))
		nfs41_handle_state_revoked(clp);
1535
	if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
1536
		nfs41_handle_recallable_state_revoked(clp);
1537
	if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
1538 1539
			    SEQ4_STATUS_BACKCHANNEL_FAULT |
			    SEQ4_STATUS_CB_PATH_DOWN_SESSION))
1540
		nfs41_handle_cb_path_down(clp);
1541 1542
}

1543 1544 1545 1546
static int nfs4_reset_session(struct nfs_client *clp)
{
	int status;

1547
	nfs4_begin_drain_session(clp);
1548 1549 1550
	status = nfs4_proc_destroy_session(clp->cl_session);
	if (status && status != -NFS4ERR_BADSESSION &&
	    status != -NFS4ERR_DEADSESSION) {
1551
		status = nfs4_recovery_handle_error(clp, status);
1552 1553 1554 1555
		goto out;
	}

	memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
1556
	status = nfs4_proc_create_session(clp);
1557
	if (status) {
1558
		status = nfs4_recovery_handle_error(clp, status);
1559 1560
		goto out;
	}
1561
	clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1562 1563
	/* create_session negotiated new slot table */
	clear_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state);
1564

1565 1566
	 /* Let the state manager reestablish state */
	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1567
		nfs41_setup_state_renewal(clp);
1568
out:
1569 1570
	return status;
}
1571

A
Andy Adamson 已提交
1572 1573 1574 1575 1576 1577 1578 1579 1580
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),
1581
		      GFP_NOFS);
A
Andy Adamson 已提交
1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599
        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;
}

1600
#else /* CONFIG_NFS_V4_1 */
1601
static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
1602
static int nfs4_end_drain_session(struct nfs_client *clp) { return 0; }
A
Andy Adamson 已提交
1603
static int nfs4_recall_slot(struct nfs_client *clp) { return 0; }
1604 1605
#endif /* CONFIG_NFS_V4_1 */

1606 1607 1608 1609 1610
/* 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)
{
1611 1612 1613 1614 1615 1616
	switch (status) {
	case -NFS4ERR_CLID_INUSE:
	case -NFS4ERR_STALE_CLIENTID:
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
		break;
	case -NFS4ERR_DELAY:
1617
	case -ETIMEDOUT:
1618 1619 1620
	case -EAGAIN:
		ssleep(1);
		break;
1621

1622 1623 1624 1625 1626 1627
	case -EKEYEXPIRED:
		nfs4_warn_keyexpired(clp->cl_hostname);
	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
				 * in nfs4_exchange_id */
	default:
		return;
1628 1629 1630 1631
	}
	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
}

1632
static void nfs4_state_manager(struct nfs_client *clp)
1633 1634 1635 1636
{
	int status = 0;

	/* Ensure exclusive access to NFSv4 state */
1637
	do {
1638 1639 1640 1641
		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) {
1642
				nfs4_set_lease_expired(clp, status);
1643 1644
				if (test_bit(NFS4CLNT_LEASE_EXPIRED,
							&clp->cl_state))
1645
					continue;
1646 1647 1648
				if (clp->cl_cons_state ==
							NFS_CS_SESSION_INITING)
					nfs_mark_client_ready(clp, status);
1649 1650
				goto out_error;
			}
1651
			clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1652 1653 1654 1655 1656 1657 1658 1659

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

1660
			pnfs_destroy_all_layouts(clp);
1661 1662 1663 1664
		}

		if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
			status = nfs4_check_lease(clp);
1665 1666
			if (status < 0)
				goto out_error;
1667
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1668
				continue;
1669
		}
1670

1671
		/* Initialize or reset the session */
1672
		if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)
1673
		   && nfs4_has_session(clp)) {
1674
			status = nfs4_reset_session(clp);
1675 1676 1677
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
				continue;
			if (status < 0)
1678 1679
				goto out_error;
		}
1680

1681
		/* First recover reboot state... */
1682
		if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
1683
			status = nfs4_do_reclaim(clp,
1684
				clp->cl_mvops->reboot_recovery_ops);
1685
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
1686
			    test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state))
1687
				continue;
1688
			nfs4_state_end_reclaim_reboot(clp);
1689 1690 1691 1692
			if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
				continue;
			if (status < 0)
				goto out_error;
1693 1694
		}

1695 1696
		/* Now recover expired state... */
		if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
1697
			status = nfs4_do_reclaim(clp,
1698
				clp->cl_mvops->nograce_recovery_ops);
1699
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
1700
			    test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) ||
1701 1702 1703
			    test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
				continue;
			if (status < 0)
1704
				goto out_error;
L
Linus Torvalds 已提交
1705
		}
1706

1707
		nfs4_end_drain_session(clp);
1708 1709 1710 1711
		if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
			nfs_client_return_marked_delegations(clp);
			continue;
		}
A
Andy Adamson 已提交
1712 1713 1714 1715 1716 1717 1718 1719 1720
		/* 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;
		}

1721 1722

		nfs4_clear_state_manager_bit(clp);
1723 1724 1725 1726 1727
		/* 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;
1728
	} while (atomic_read(&clp->cl_count) > 1);
1729
	return;
L
Linus Torvalds 已提交
1730
out_error:
1731
	printk(KERN_WARNING "Error: state manager failed on NFSv4 server %s"
1732
			" with error %d\n", clp->cl_hostname, -status);
1733
	nfs4_end_drain_session(clp);
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745
	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 已提交
1746 1747 1748 1749 1750 1751 1752
}

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