nfs4state.c 45.4 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;
L
Linus Torvalds 已提交
380 381
	struct nfs4_state_owner *sp, *res = NULL;

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 392 393
		if (server < sp->so_server) {
			p = &parent->rb_left;
			continue;
		}
		if (server > sp->so_server) {
			p = &parent->rb_right;
			continue;
		}
394 395 396 397 398 399 400 401 402
		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);
			res = sp;
			break;
		}
L
Linus Torvalds 已提交
403 404 405 406
	}
	return res;
}

407
static struct nfs4_state_owner *
408
nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
409
{
410 411
	struct nfs_server *server = new->so_server;
	struct rb_node **p = &server->state_owners.rb_node,
412 413 414 415 416
		       *parent = NULL;
	struct nfs4_state_owner *sp;

	while (*p != NULL) {
		parent = *p;
417
		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
418 419 420 421 422 423 424 425 426 427

		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;
		}
	}
428 429 430 431
	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);
432 433 434 435
	return new;
}

static void
436
nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
437
{
438 439 440 441 442
	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);
443 444
}

L
Linus Torvalds 已提交
445 446 447 448 449 450 451 452 453 454
/*
 * 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;

455
	sp = kzalloc(sizeof(*sp),GFP_NOFS);
L
Linus Torvalds 已提交
456 457
	if (!sp)
		return NULL;
458
	spin_lock_init(&sp->so_lock);
L
Linus Torvalds 已提交
459
	INIT_LIST_HEAD(&sp->so_states);
460 461 462 463
	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 已提交
464 465 466 467
	atomic_set(&sp->so_count, 1);
	return sp;
}

468
static void
L
Linus Torvalds 已提交
469 470
nfs4_drop_state_owner(struct nfs4_state_owner *sp)
{
471 472 473
	if (!RB_EMPTY_NODE(&sp->so_server_node)) {
		struct nfs_server *server = sp->so_server;
		struct nfs_client *clp = server->nfs_client;
474 475

		spin_lock(&clp->cl_lock);
476 477
		rb_erase(&sp->so_server_node, &server->state_owners);
		RB_CLEAR_NODE(&sp->so_server_node);
478 479
		spin_unlock(&clp->cl_lock);
	}
L
Linus Torvalds 已提交
480 481
}

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

	spin_lock(&clp->cl_lock);
496
	sp = nfs4_find_state_owner_locked(server, cred);
L
Linus Torvalds 已提交
497 498 499
	spin_unlock(&clp->cl_lock);
	if (sp != NULL)
		return sp;
500 501 502
	new = nfs4_alloc_state_owner();
	if (new == NULL)
		return NULL;
503
	new->so_server = server;
504 505
	new->so_cred = cred;
	spin_lock(&clp->cl_lock);
506
	sp = nfs4_insert_state_owner_locked(new);
507 508 509
	spin_unlock(&clp->cl_lock);
	if (sp == new)
		get_rpccred(cred);
510 511
	else {
		rpc_destroy_wait_queue(&new->so_sequence.wait);
512
		kfree(new);
513
	}
514
	return sp;
L
Linus Torvalds 已提交
515 516
}

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

	if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
		return;
529
	nfs4_remove_state_owner_locked(sp);
L
Linus Torvalds 已提交
530
	spin_unlock(&clp->cl_lock);
531
	rpc_destroy_wait_queue(&sp->so_sequence.wait);
L
Linus Torvalds 已提交
532 533 534 535 536 537 538 539 540
	put_rpccred(cred);
	kfree(sp);
}

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

541
	state = kzalloc(sizeof(*state), GFP_NOFS);
L
Linus Torvalds 已提交
542 543 544 545
	if (!state)
		return NULL;
	atomic_set(&state->count, 1);
	INIT_LIST_HEAD(&state->lock_states);
546
	spin_lock_init(&state->state_lock);
547
	seqlock_init(&state->seqlock);
L
Linus Torvalds 已提交
548 549 550
	return state;
}

551
void
552
nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
553
{
554
	if (state->state == fmode)
555 556
		return;
	/* NB! List reordering - see the reclaim code for why.  */
557 558
	if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
		if (fmode & FMODE_WRITE)
559 560 561 562
			list_move(&state->open_states, &state->owner->so_states);
		else
			list_move_tail(&state->open_states, &state->owner->so_states);
	}
563
	state->state = fmode;
564 565
}

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

629
	if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
L
Linus Torvalds 已提交
630
		return;
631
	spin_lock(&inode->i_lock);
632
	list_del(&state->inode_states);
L
Linus Torvalds 已提交
633
	list_del(&state->open_states);
634 635
	spin_unlock(&inode->i_lock);
	spin_unlock(&owner->so_lock);
L
Linus Torvalds 已提交
636 637 638 639 640 641
	iput(inode);
	nfs4_free_open_state(state);
	nfs4_put_state_owner(owner);
}

/*
642
 * Close the current file.
L
Linus Torvalds 已提交
643
 */
644
static void __nfs4_close(struct nfs4_state *state,
645
		fmode_t fmode, gfp_t gfp_mask, int wait)
L
Linus Torvalds 已提交
646 647
{
	struct nfs4_state_owner *owner = state->owner;
648
	int call_close = 0;
649
	fmode_t newstate;
L
Linus Torvalds 已提交
650 651 652

	atomic_inc(&owner->so_count);
	/* Protect against nfs4_find_state() */
653
	spin_lock(&owner->so_lock);
654
	switch (fmode & (FMODE_READ | FMODE_WRITE)) {
655 656 657 658 659 660 661 662 663
		case FMODE_READ:
			state->n_rdonly--;
			break;
		case FMODE_WRITE:
			state->n_wronly--;
			break;
		case FMODE_READ|FMODE_WRITE:
			state->n_rdwr--;
	}
664
	newstate = FMODE_READ|FMODE_WRITE;
665
	if (state->n_rdwr == 0) {
666
		if (state->n_rdonly == 0) {
667
			newstate &= ~FMODE_READ;
668 669 670 671
			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) {
672
			newstate &= ~FMODE_WRITE;
673 674 675 676 677
			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);
678
	}
679
	nfs4_state_set_mode_locked(state, newstate);
680
	spin_unlock(&owner->so_lock);
681

682
	if (!call_close) {
683 684
		nfs4_put_open_state(state);
		nfs4_put_state_owner(owner);
F
Fred Isaman 已提交
685 686 687
	} else {
		bool roc = pnfs_roc(state->inode);

688
		nfs4_do_close(state, gfp_mask, wait, roc);
F
Fred Isaman 已提交
689
	}
690 691
}

692
void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
693
{
694
	__nfs4_close(state, fmode, GFP_NOFS, 0);
695 696
}

697
void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
698
{
699
	__nfs4_close(state, fmode, GFP_KERNEL, 1);
L
Linus Torvalds 已提交
700 701 702 703 704 705 706
}

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

739
	lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
L
Linus Torvalds 已提交
740 741
	if (lsp == NULL)
		return NULL;
742 743 744 745
	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 已提交
746
	atomic_set(&lsp->ls_count, 1);
747
	lsp->ls_state = state;
748 749 750 751 752 753 754 755 756 757 758 759
	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 已提交
760
	spin_lock(&clp->cl_lock);
761
	nfs_alloc_unique_id_locked(&server->lockowner_id, &lsp->ls_id, 1, 64);
L
Linus Torvalds 已提交
762
	spin_unlock(&clp->cl_lock);
763
	INIT_LIST_HEAD(&lsp->ls_locks);
L
Linus Torvalds 已提交
764 765 766
	return lsp;
}

767 768
static void nfs4_free_lock_state(struct nfs4_lock_state *lsp)
{
769 770
	struct nfs_server *server = lsp->ls_state->owner->so_server;
	struct nfs_client *clp = server->nfs_client;
771 772

	spin_lock(&clp->cl_lock);
773
	nfs_free_unique_id(&server->lockowner_id, &lsp->ls_id);
774
	spin_unlock(&clp->cl_lock);
775
	rpc_destroy_wait_queue(&lsp->ls_sequence.wait);
776 777 778
	kfree(lsp);
}

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

/*
812 813
 * Release reference to lock_state, and free it if we see that
 * it is no longer in use
L
Linus Torvalds 已提交
814
 */
815
void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
L
Linus Torvalds 已提交
816
{
817
	struct nfs4_state *state;
L
Linus Torvalds 已提交
818

819 820 821 822 823 824 825 826 827
	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);
828 829
	if (lsp->ls_flags & NFS_LOCK_INITIALIZED)
		nfs4_release_lockowner(lsp);
830
	nfs4_free_lock_state(lsp);
L
Linus Torvalds 已提交
831 832
}

833
static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
L
Linus Torvalds 已提交
834
{
835
	struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
L
Linus Torvalds 已提交
836

837 838 839
	dst->fl_u.nfs4_fl.owner = lsp;
	atomic_inc(&lsp->ls_count);
}
L
Linus Torvalds 已提交
840

841
static void nfs4_fl_release_lock(struct file_lock *fl)
L
Linus Torvalds 已提交
842
{
843
	nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
L
Linus Torvalds 已提交
844 845
}

846
static const struct file_lock_operations nfs4_fl_lock_ops = {
847 848 849 850 851
	.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 已提交
852
{
853 854 855 856
	struct nfs4_lock_state *lsp;

	if (fl->fl_ops != NULL)
		return 0;
857 858 859 860 861 862
	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;
863 864 865 866 867
	if (lsp == NULL)
		return -ENOMEM;
	fl->fl_u.nfs4_fl.owner = lsp;
	fl->fl_ops = &nfs4_fl_lock_ops;
	return 0;
L
Linus Torvalds 已提交
868 869
}

870 871 872
/*
 * Byte-range lock aware utility to initialize the stateid of read/write
 * requests.
L
Linus Torvalds 已提交
873
 */
874
void nfs4_copy_stateid(nfs4_stateid *dst, struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid)
L
Linus Torvalds 已提交
875
{
876
	struct nfs4_lock_state *lsp;
877
	int seq;
L
Linus Torvalds 已提交
878

879 880 881 882
	do {
		seq = read_seqbegin(&state->seqlock);
		memcpy(dst, &state->stateid, sizeof(*dst));
	} while (read_seqretry(&state->seqlock, seq));
883 884
	if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
		return;
L
Linus Torvalds 已提交
885

886
	spin_lock(&state->state_lock);
887
	lsp = __nfs4_find_lock_state(state, fl_owner, fl_pid, NFS4_ANY_LOCK_TYPE);
888 889 890
	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 已提交
891 892 893
	nfs4_put_lock_state(lsp);
}

894
struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
895 896 897
{
	struct nfs_seqid *new;

898
	new = kmalloc(sizeof(*new), gfp_mask);
899 900
	if (new != NULL) {
		new->sequence = counter;
901
		INIT_LIST_HEAD(&new->list);
902 903 904 905
	}
	return new;
}

906
void nfs_release_seqid(struct nfs_seqid *seqid)
L
Linus Torvalds 已提交
907
{
908 909
	if (!list_empty(&seqid->list)) {
		struct rpc_sequence *sequence = seqid->sequence->sequence;
910

911
		spin_lock(&sequence->lock);
912
		list_del_init(&seqid->list);
913 914 915
		spin_unlock(&sequence->lock);
		rpc_wake_up(&sequence->wait);
	}
916 917 918 919 920
}

void nfs_free_seqid(struct nfs_seqid *seqid)
{
	nfs_release_seqid(seqid);
921
	kfree(seqid);
L
Linus Torvalds 已提交
922 923 924
}

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

/*
 * 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)
{
977
	nfs_increment_seqid(status, seqid);
978 979 980 981 982 983 984 985
}

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);
986 987 988 989
	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;
990
	rpc_sleep_on(&sequence->wait, task, NULL);
991 992
	status = -EAGAIN;
unlock:
993 994
	spin_unlock(&sequence->lock);
	return status;
L
Linus Torvalds 已提交
995 996
}

997
static int nfs4_run_state_manager(void *);
L
Linus Torvalds 已提交
998

999
static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
T
Trond Myklebust 已提交
1000 1001
{
	smp_mb__before_clear_bit();
1002
	clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
T
Trond Myklebust 已提交
1003
	smp_mb__after_clear_bit();
1004
	wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
T
Trond Myklebust 已提交
1005 1006 1007
	rpc_wake_up(&clp->cl_rpcwaitq);
}

L
Linus Torvalds 已提交
1008
/*
1009
 * Schedule the nfs_client asynchronous state management routine
L
Linus Torvalds 已提交
1010
 */
1011
void nfs4_schedule_state_manager(struct nfs_client *clp)
L
Linus Torvalds 已提交
1012
{
1013
	struct task_struct *task;
L
Linus Torvalds 已提交
1014

1015 1016
	if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
		return;
1017 1018
	__module_get(THIS_MODULE);
	atomic_inc(&clp->cl_count);
1019
	task = kthread_run(nfs4_run_state_manager, clp, "%s-manager",
1020 1021
				rpc_peeraddr2str(clp->cl_rpcclient,
							RPC_DISPLAY_ADDR));
1022 1023
	if (!IS_ERR(task))
		return;
1024
	nfs4_clear_state_manager_bit(clp);
1025
	nfs_put_client(clp);
1026
	module_put(THIS_MODULE);
L
Linus Torvalds 已提交
1027 1028 1029
}

/*
1030
 * Schedule a lease recovery attempt
L
Linus Torvalds 已提交
1031
 */
1032
void nfs4_schedule_lease_recovery(struct nfs_client *clp)
L
Linus Torvalds 已提交
1033 1034 1035
{
	if (!clp)
		return;
1036 1037
	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1038
	nfs4_schedule_state_manager(clp);
L
Linus Torvalds 已提交
1039 1040
}

1041
static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1042 1043 1044 1045 1046 1047 1048 1049
{

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

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

1064 1065 1066 1067 1068 1069 1070 1071
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);
}

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

1079 1080 1081 1082
	if (inode->i_flock == NULL)
		return 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

1381
static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
L
Linus Torvalds 已提交
1382
{
1383 1384
	struct nfs4_state_owner *sp;
	struct nfs_server *server;
1385
	struct rb_node *pos;
L
Linus Torvalds 已提交
1386 1387
	int status = 0;

1388
restart:
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
	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);
			}

1411
			nfs4_put_state_owner(sp);
1412
			goto restart;
1413
		}
1414
		spin_unlock(&clp->cl_lock);
1415
	}
1416
	rcu_read_unlock();
1417 1418 1419 1420 1421 1422
	return status;
}

static int nfs4_check_lease(struct nfs_client *clp)
{
	struct rpc_cred *cred;
1423 1424
	const struct nfs4_state_maintenance_ops *ops =
		clp->cl_mvops->state_renewal_ops;
1425
	int status = -NFS4ERR_EXPIRED;
L
Linus Torvalds 已提交
1426

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

static int nfs4_reclaim_lease(struct nfs_client *clp)
{
	struct rpc_cred *cred;
1447 1448
	const struct nfs4_state_recovery_ops *ops =
		clp->cl_mvops->reboot_recovery_ops;
1449 1450
	int status = -ENOENT;

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

1466
#ifdef CONFIG_NFS_V4_1
1467 1468
void nfs4_schedule_session_recovery(struct nfs4_session *session)
{
1469 1470 1471 1472
	struct nfs_client *clp = session->clp;

	set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
	nfs4_schedule_lease_recovery(clp);
1473
}
1474
EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
1475

A
Andy Adamson 已提交
1476 1477 1478
void nfs41_handle_recall_slot(struct nfs_client *clp)
{
	set_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state);
1479
	nfs4_schedule_state_manager(clp);
A
Andy Adamson 已提交
1480 1481
}

1482 1483 1484 1485 1486
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);
1487
		nfs4_schedule_state_manager(clp);
1488 1489 1490 1491 1492 1493 1494
	}
}

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);
1495
		nfs4_schedule_state_manager(clp);
1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
	}
}

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)
1515
		nfs4_schedule_state_manager(clp);
1516 1517
}

1518 1519 1520 1521
void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)
{
	if (!flags)
		return;
1522 1523 1524
	else if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
		nfs41_handle_server_reboot(clp);
	else if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED |
1525 1526
			    SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
			    SEQ4_STATUS_ADMIN_STATE_REVOKED |
1527 1528 1529 1530 1531
			    SEQ4_STATUS_LEASE_MOVED))
		nfs41_handle_state_revoked(clp);
	else if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
		nfs41_handle_recallable_state_revoked(clp);
	else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
1532 1533
			    SEQ4_STATUS_BACKCHANNEL_FAULT |
			    SEQ4_STATUS_CB_PATH_DOWN_SESSION))
1534
		nfs41_handle_cb_path_down(clp);
1535 1536
}

1537 1538 1539 1540
static int nfs4_reset_session(struct nfs_client *clp)
{
	int status;

1541
	nfs4_begin_drain_session(clp);
1542 1543 1544
	status = nfs4_proc_destroy_session(clp->cl_session);
	if (status && status != -NFS4ERR_BADSESSION &&
	    status != -NFS4ERR_DEADSESSION) {
1545
		status = nfs4_recovery_handle_error(clp, status);
1546 1547 1548 1549
		goto out;
	}

	memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
1550
	status = nfs4_proc_create_session(clp);
1551
	if (status) {
1552
		status = nfs4_recovery_handle_error(clp, status);
1553 1554
		goto out;
	}
1555
	clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1556 1557
	/* create_session negotiated new slot table */
	clear_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state);
1558

1559 1560
	 /* Let the state manager reestablish state */
	if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1561
		nfs41_setup_state_renewal(clp);
1562
out:
1563 1564
	return status;
}
1565

A
Andy Adamson 已提交
1566 1567 1568 1569 1570 1571 1572 1573 1574
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),
1575
		      GFP_NOFS);
A
Andy Adamson 已提交
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
        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;
}

1594
#else /* CONFIG_NFS_V4_1 */
1595
static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
1596
static int nfs4_end_drain_session(struct nfs_client *clp) { return 0; }
A
Andy Adamson 已提交
1597
static int nfs4_recall_slot(struct nfs_client *clp) { return 0; }
1598 1599
#endif /* CONFIG_NFS_V4_1 */

1600 1601 1602 1603 1604
/* 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)
{
1605 1606 1607 1608 1609 1610
	switch (status) {
	case -NFS4ERR_CLID_INUSE:
	case -NFS4ERR_STALE_CLIENTID:
		clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
		break;
	case -NFS4ERR_DELAY:
1611
	case -ETIMEDOUT:
1612 1613 1614
	case -EAGAIN:
		ssleep(1);
		break;
1615

1616 1617 1618 1619 1620 1621
	case -EKEYEXPIRED:
		nfs4_warn_keyexpired(clp->cl_hostname);
	case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
				 * in nfs4_exchange_id */
	default:
		return;
1622 1623 1624 1625
	}
	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
}

1626
static void nfs4_state_manager(struct nfs_client *clp)
1627 1628 1629 1630
{
	int status = 0;

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

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

1654
			pnfs_destroy_all_layouts(clp);
1655 1656 1657 1658
		}

		if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
			status = nfs4_check_lease(clp);
1659
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1660
				continue;
1661 1662
			if (status < 0 && status != -NFS4ERR_CB_PATH_DOWN)
				goto out_error;
1663
		}
1664

1665
		/* Initialize or reset the session */
1666
		if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)
1667
		   && nfs4_has_session(clp)) {
1668
			status = nfs4_reset_session(clp);
1669 1670 1671
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
				continue;
			if (status < 0)
1672 1673
				goto out_error;
		}
1674

1675
		/* First recover reboot state... */
1676
		if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
1677
			status = nfs4_do_reclaim(clp,
1678
				clp->cl_mvops->reboot_recovery_ops);
1679
			if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
1680
			    test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state))
1681
				continue;
1682
			nfs4_state_end_reclaim_reboot(clp);
1683 1684 1685 1686
			if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
				continue;
			if (status < 0)
				goto out_error;
1687 1688
		}

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

1701
		nfs4_end_drain_session(clp);
1702 1703 1704 1705
		if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
			nfs_client_return_marked_delegations(clp);
			continue;
		}
A
Andy Adamson 已提交
1706 1707 1708 1709 1710 1711 1712 1713 1714
		/* 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;
		}

1715 1716

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

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