nfs4state.c 134.1 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
/*
*  Copyright (c) 2001 The Regents of the University of Michigan.
*  All rights reserved.
*
*  Kendrick Smith <kmsmith@umich.edu>
*  Andy Adamson <kandros@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.
*
*/

35
#include <linux/file.h>
36
#include <linux/fs.h>
37
#include <linux/slab.h>
38
#include <linux/namei.h>
39
#include <linux/swap.h>
40
#include <linux/pagemap.h>
41
#include <linux/ratelimit.h>
42
#include <linux/sunrpc/svcauth_gss.h>
43
#include <linux/sunrpc/addr.h>
44
#include "xdr4.h"
45
#include "xdr4cb.h"
46
#include "vfs.h"
47
#include "current_stateid.h"
L
Linus Torvalds 已提交
48

49 50
#include "netns.h"

L
Linus Torvalds 已提交
51 52
#define NFSDDBG_FACILITY                NFSDDBG_PROC

53 54 55 56 57 58 59 60
#define all_ones {{~0,~0},~0}
static const stateid_t one_stateid = {
	.si_generation = ~0,
	.si_opaque = all_ones,
};
static const stateid_t zero_stateid = {
	/* all fields zero */
};
61 62 63
static const stateid_t currentstateid = {
	.si_generation = 1,
};
64

A
Andy Adamson 已提交
65
static u64 current_sessionid = 1;
66

67 68
#define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
#define ONE_STATEID(stateid)  (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
69
#define CURRENT_STATEID(stateid) (!memcmp((stateid), &currentstateid, sizeof(stateid_t)))
L
Linus Torvalds 已提交
70 71

/* forward declarations */
72
static int check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner);
L
Linus Torvalds 已提交
73

74 75 76
/* Locking: */

/* Currently used for almost all code touching nfsv4 state: */
I
Ingo Molnar 已提交
77
static DEFINE_MUTEX(client_mutex);
L
Linus Torvalds 已提交
78

79 80 81 82 83 84 85
/*
 * Currently used for the del_recall_lru and file hash table.  In an
 * effort to decrease the scope of the client_mutex, this spinlock may
 * eventually cover more:
 */
static DEFINE_SPINLOCK(recall_lock);

86 87
static struct kmem_cache *openowner_slab = NULL;
static struct kmem_cache *lockowner_slab = NULL;
88 89 90
static struct kmem_cache *file_slab = NULL;
static struct kmem_cache *stateid_slab = NULL;
static struct kmem_cache *deleg_slab = NULL;
N
NeilBrown 已提交
91

L
Linus Torvalds 已提交
92 93 94
void
nfs4_lock_state(void)
{
I
Ingo Molnar 已提交
95
	mutex_lock(&client_mutex);
L
Linus Torvalds 已提交
96 97
}

98
static void free_session(struct nfsd4_session *);
99

100 101 102 103 104 105
void nfsd4_put_session(struct nfsd4_session *ses)
{
	atomic_dec(&ses->se_ref);
}

static bool is_session_dead(struct nfsd4_session *ses)
106
{
107 108 109 110
	return ses->se_flags & NFS4_SESSION_DEAD;
}

static __be32 mark_session_dead_locked(struct nfsd4_session *ses)
111
{
112 113 114 115
	if (atomic_read(&ses->se_ref))
		return nfserr_jukebox;
	ses->se_flags |= NFS4_SESSION_DEAD;
	return nfs_ok;
116 117
}

118
static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
119
{
120 121 122 123
	if (is_session_dead(ses))
		return nfserr_badsession;
	atomic_inc(&ses->se_ref);
	return nfs_ok;
124 125
}

L
Linus Torvalds 已提交
126 127 128
void
nfs4_unlock_state(void)
{
I
Ingo Molnar 已提交
129
	mutex_unlock(&client_mutex);
L
Linus Torvalds 已提交
130 131
}

132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
static bool is_client_expired(struct nfs4_client *clp)
{
	return clp->cl_time == 0;
}

static __be32 mark_client_expired_locked(struct nfs4_client *clp)
{
	if (atomic_read(&clp->cl_refcount))
		return nfserr_jukebox;
	clp->cl_time = 0;
	return nfs_ok;
}

static __be32 mark_client_expired(struct nfs4_client *clp)
{
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
	__be32 ret;

	spin_lock(&nn->client_lock);
	ret = mark_client_expired_locked(clp);
	spin_unlock(&nn->client_lock);
	return ret;
}

static __be32 get_client_locked(struct nfs4_client *clp)
{
	if (is_client_expired(clp))
		return nfserr_expired;
	atomic_inc(&clp->cl_refcount);
	return nfs_ok;
}

/* must be called under the client_lock */
static inline void
renew_client_locked(struct nfs4_client *clp)
{
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	if (is_client_expired(clp)) {
		WARN_ON(1);
		printk("%s: client (clientid %08x/%08x) already expired\n",
			__func__,
			clp->cl_clientid.cl_boot,
			clp->cl_clientid.cl_id);
		return;
	}

	dprintk("renewing client (clientid %08x/%08x)\n",
			clp->cl_clientid.cl_boot,
			clp->cl_clientid.cl_id);
	list_move_tail(&clp->cl_lru, &nn->client_lru);
	clp->cl_time = get_seconds();
}

static inline void
renew_client(struct nfs4_client *clp)
{
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	spin_lock(&nn->client_lock);
	renew_client_locked(clp);
	spin_unlock(&nn->client_lock);
}

196
static void put_client_renew_locked(struct nfs4_client *clp)
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
{
	if (!atomic_dec_and_test(&clp->cl_refcount))
		return;
	if (!is_client_expired(clp))
		renew_client_locked(clp);
}

void put_client_renew(struct nfs4_client *clp)
{
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock))
		return;
	if (!is_client_expired(clp))
		renew_client_locked(clp);
	spin_unlock(&nn->client_lock);
}


L
Linus Torvalds 已提交
216 217 218 219 220 221 222 223 224 225 226 227 228
static inline u32
opaque_hashval(const void *ptr, int nbytes)
{
	unsigned char *cptr = (unsigned char *) ptr;

	u32 x = 0;
	while (nbytes--) {
		x *= 37;
		x += *cptr++;
	}
	return x;
}

229 230 231 232 233
static void nfsd4_free_file(struct nfs4_file *f)
{
	kmem_cache_free(file_slab, f);
}

234 235 236
static inline void
put_nfs4_file(struct nfs4_file *fi)
{
237
	if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
238
		hlist_del(&fi->fi_hash);
239 240
		spin_unlock(&recall_lock);
		iput(fi->fi_inode);
241
		nfsd4_free_file(fi);
242
	}
243 244 245 246 247
}

static inline void
get_nfs4_file(struct nfs4_file *fi)
{
248
	atomic_inc(&fi->fi_ref);
249 250
}

251
static int num_delegations;
252
unsigned long max_delegations;
253 254 255 256 257

/*
 * Open owner state (share locks)
 */

258 259 260 261
/* hash tables for lock and open owners */
#define OWNER_HASH_BITS              8
#define OWNER_HASH_SIZE             (1 << OWNER_HASH_BITS)
#define OWNER_HASH_MASK             (OWNER_HASH_SIZE - 1)
262

263
static unsigned int ownerstr_hashval(u32 clientid, struct xdr_netobj *ownername)
264 265 266 267 268
{
	unsigned int ret;

	ret = opaque_hashval(ownername->data, ownername->len);
	ret += clientid;
269
	return ret & OWNER_HASH_MASK;
270
}
271 272 273 274

/* hash table for nfs4_file */
#define FILE_HASH_BITS                   8
#define FILE_HASH_SIZE                  (1 << FILE_HASH_BITS)
S
Shan Wei 已提交
275

276 277 278 279 280 281
static unsigned int file_hashval(struct inode *ino)
{
	/* XXX: why are we hashing on inode pointer, anyway? */
	return hash_ptr(ino, FILE_HASH_BITS);
}

282
static struct hlist_head file_hashtbl[FILE_HASH_SIZE];
283

284
static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
285
{
286
	WARN_ON_ONCE(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
287 288 289
	atomic_inc(&fp->fi_access[oflag]);
}

290 291 292 293 294 295 296 297 298 299
static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
{
	if (oflag == O_RDWR) {
		__nfs4_file_get_access(fp, O_RDONLY);
		__nfs4_file_get_access(fp, O_WRONLY);
	} else
		__nfs4_file_get_access(fp, oflag);
}

static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
300 301 302 303 304 305 306
{
	if (fp->fi_fds[oflag]) {
		fput(fp->fi_fds[oflag]);
		fp->fi_fds[oflag] = NULL;
	}
}

307
static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
308 309 310
{
	if (atomic_dec_and_test(&fp->fi_access[oflag])) {
		nfs4_file_put_fd(fp, oflag);
311
		if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
312
			nfs4_file_put_fd(fp, O_RDWR);
313 314 315
	}
}

316 317 318 319 320 321 322 323 324
static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
{
	if (oflag == O_RDWR) {
		__nfs4_file_put_access(fp, O_RDONLY);
		__nfs4_file_put_access(fp, O_WRONLY);
	} else
		__nfs4_file_put_access(fp, oflag);
}

J
J. Bruce Fields 已提交
325 326
static struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct
kmem_cache *slab)
327
{
J
J. Bruce Fields 已提交
328 329
	struct idr *stateids = &cl->cl_stateids;
	struct nfs4_stid *stid;
J
J. Bruce Fields 已提交
330
	int new_id;
331

J
J. Bruce Fields 已提交
332 333 334 335
	stid = kmem_cache_alloc(slab, GFP_KERNEL);
	if (!stid)
		return NULL;

336
	new_id = idr_alloc_cyclic(stateids, stid, 0, 0, GFP_KERNEL);
T
Tejun Heo 已提交
337
	if (new_id < 0)
J
J. Bruce Fields 已提交
338
		goto out_free;
339
	stid->sc_client = cl;
J
J. Bruce Fields 已提交
340 341 342
	stid->sc_type = 0;
	stid->sc_stateid.si_opaque.so_id = new_id;
	stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
343
	/* Will be incremented before return to client: */
J
J. Bruce Fields 已提交
344
	stid->sc_stateid.si_generation = 0;
345 346

	/*
J
J. Bruce Fields 已提交
347 348 349 350 351 352 353
	 * It shouldn't be a problem to reuse an opaque stateid value.
	 * I don't think it is for 4.1.  But with 4.0 I worry that, for
	 * example, a stray write retransmission could be accepted by
	 * the server when it should have been rejected.  Therefore,
	 * adopt a trick from the sctp code to attempt to maximize the
	 * amount of time until an id is reused, by ensuring they always
	 * "increase" (mod INT_MAX):
354
	 */
J
J. Bruce Fields 已提交
355 356
	return stid;
out_free:
357
	kmem_cache_free(slab, stid);
J
J. Bruce Fields 已提交
358
	return NULL;
359 360
}

361 362 363 364 365
static struct nfs4_ol_stateid * nfs4_alloc_stateid(struct nfs4_client *clp)
{
	return openlockstateid(nfs4_alloc_stid(clp, stateid_slab));
}

L
Linus Torvalds 已提交
366
static struct nfs4_delegation *
367
alloc_init_deleg(struct nfs4_client *clp, struct nfs4_ol_stateid *stp, struct svc_fh *current_fh, u32 type)
L
Linus Torvalds 已提交
368 369 370 371 372
{
	struct nfs4_delegation *dp;
	struct nfs4_file *fp = stp->st_file;

	dprintk("NFSD alloc_init_deleg\n");
373 374 375 376 377 378 379
	/*
	 * Major work on the lease subsystem (for example, to support
	 * calbacks on stat) will be required before we can support
	 * write delegations properly.
	 */
	if (type != NFS4_OPEN_DELEGATE_READ)
		return NULL;
380 381
	if (fp->fi_had_conflict)
		return NULL;
382
	if (num_delegations > max_delegations)
383
		return NULL;
384
	dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab));
N
NeilBrown 已提交
385
	if (dp == NULL)
L
Linus Torvalds 已提交
386
		return dp;
J
J. Bruce Fields 已提交
387
	dp->dl_stid.sc_type = NFS4_DELEG_STID;
388 389
	/*
	 * delegation seqid's are never incremented.  The 4.1 special
J
J. Bruce Fields 已提交
390 391
	 * meaning of seqid 0 isn't meaningful, really, but let's avoid
	 * 0 anyway just for consistency and use 1:
392 393
	 */
	dp->dl_stid.sc_stateid.si_generation = 1;
394
	num_delegations++;
395 396
	INIT_LIST_HEAD(&dp->dl_perfile);
	INIT_LIST_HEAD(&dp->dl_perclnt);
L
Linus Torvalds 已提交
397
	INIT_LIST_HEAD(&dp->dl_recall_lru);
398
	get_nfs4_file(fp);
L
Linus Torvalds 已提交
399 400
	dp->dl_file = fp;
	dp->dl_type = type;
401
	fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
L
Linus Torvalds 已提交
402 403
	dp->dl_time = 0;
	atomic_set(&dp->dl_count, 1);
404
	nfsd4_init_callback(&dp->dl_recall);
L
Linus Torvalds 已提交
405 406 407
	return dp;
}

408
static void remove_stid(struct nfs4_stid *s)
J
J. Bruce Fields 已提交
409 410 411 412 413 414
{
	struct idr *stateids = &s->sc_client->cl_stateids;

	idr_remove(stateids, s->sc_stateid.si_opaque.so_id);
}

L
Linus Torvalds 已提交
415 416 417 418
void
nfs4_put_delegation(struct nfs4_delegation *dp)
{
	if (atomic_dec_and_test(&dp->dl_count)) {
419
		kmem_cache_free(deleg_slab, dp);
420
		num_delegations--;
L
Linus Torvalds 已提交
421 422 423
	}
}

424
static void nfs4_put_deleg_lease(struct nfs4_file *fp)
L
Linus Torvalds 已提交
425
{
426 427 428
	if (atomic_dec_and_test(&fp->fi_delegees)) {
		vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
		fp->fi_lease = NULL;
429
		fput(fp->fi_deleg_file);
430 431
		fp->fi_deleg_file = NULL;
	}
L
Linus Torvalds 已提交
432 433
}

J
J. Bruce Fields 已提交
434 435
static void unhash_stid(struct nfs4_stid *s)
{
J
J. Bruce Fields 已提交
436
	s->sc_type = 0;
J
J. Bruce Fields 已提交
437 438
}

L
Linus Torvalds 已提交
439 440 441 442
/* Called under the state lock. */
static void
unhash_delegation(struct nfs4_delegation *dp)
{
443
	list_del_init(&dp->dl_perclnt);
L
Linus Torvalds 已提交
444
	spin_lock(&recall_lock);
445
	list_del_init(&dp->dl_perfile);
L
Linus Torvalds 已提交
446 447
	list_del_init(&dp->dl_recall_lru);
	spin_unlock(&recall_lock);
448
	nfs4_put_deleg_lease(dp->dl_file);
449 450
	put_nfs4_file(dp->dl_file);
	dp->dl_file = NULL;
451 452 453 454 455 456 457
}



static void destroy_revoked_delegation(struct nfs4_delegation *dp)
{
	list_del_init(&dp->dl_recall_lru);
458
	remove_stid(&dp->dl_stid);
L
Linus Torvalds 已提交
459 460 461
	nfs4_put_delegation(dp);
}

462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
static void destroy_delegation(struct nfs4_delegation *dp)
{
	unhash_delegation(dp);
	remove_stid(&dp->dl_stid);
	nfs4_put_delegation(dp);
}

static void revoke_delegation(struct nfs4_delegation *dp)
{
	struct nfs4_client *clp = dp->dl_stid.sc_client;

	if (clp->cl_minorversion == 0)
		destroy_delegation(dp);
	else {
		unhash_delegation(dp);
		dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID;
		list_add(&dp->dl_recall_lru, &clp->cl_revoked);
	}
}

L
Linus Torvalds 已提交
482 483 484 485
/* 
 * SETCLIENTID state 
 */

486 487 488 489 490 491 492 493 494 495
static unsigned int clientid_hashval(u32 id)
{
	return id & CLIENT_HASH_MASK;
}

static unsigned int clientstr_hashval(const char *name)
{
	return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
}

496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513
/*
 * We store the NONE, READ, WRITE, and BOTH bits separately in the
 * st_{access,deny}_bmap field of the stateid, in order to track not
 * only what share bits are currently in force, but also what
 * combinations of share bits previous opens have used.  This allows us
 * to enforce the recommendation of rfc 3530 14.2.19 that the server
 * return an error if the client attempt to downgrade to a combination
 * of share bits not explicable by closing some of its previous opens.
 *
 * XXX: This enforcement is actually incomplete, since we don't keep
 * track of access/deny bit combinations; so, e.g., we allow:
 *
 *	OPEN allow read, deny write
 *	OPEN allow both, deny none
 *	DOWNGRADE allow read, deny none
 *
 * which we should reject.
 */
514 515
static unsigned int
bmap_to_share_mode(unsigned long bmap) {
516
	int i;
517
	unsigned int access = 0;
518 519 520

	for (i = 1; i < 4; i++) {
		if (test_bit(i, &bmap))
521
			access |= i;
522
	}
523
	return access;
524 525
}

526
static bool
527
test_share(struct nfs4_ol_stateid *stp, struct nfsd4_open *open) {
528 529
	unsigned int access, deny;

530 531
	access = bmap_to_share_mode(stp->st_access_bmap);
	deny = bmap_to_share_mode(stp->st_deny_bmap);
532
	if ((access & open->op_share_deny) || (deny & open->op_share_access))
533 534
		return false;
	return true;
535 536
}

537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557
/* set share access for a given stateid */
static inline void
set_access(u32 access, struct nfs4_ol_stateid *stp)
{
	__set_bit(access, &stp->st_access_bmap);
}

/* clear share access for a given stateid */
static inline void
clear_access(u32 access, struct nfs4_ol_stateid *stp)
{
	__clear_bit(access, &stp->st_access_bmap);
}

/* test whether a given stateid has access */
static inline bool
test_access(u32 access, struct nfs4_ol_stateid *stp)
{
	return test_bit(access, &stp->st_access_bmap);
}

558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576
/* set share deny for a given stateid */
static inline void
set_deny(u32 access, struct nfs4_ol_stateid *stp)
{
	__set_bit(access, &stp->st_deny_bmap);
}

/* clear share deny for a given stateid */
static inline void
clear_deny(u32 access, struct nfs4_ol_stateid *stp)
{
	__clear_bit(access, &stp->st_deny_bmap);
}

/* test whether a given stateid is denying specific access */
static inline bool
test_deny(u32 access, struct nfs4_ol_stateid *stp)
{
	return test_bit(access, &stp->st_deny_bmap);
577 578 579 580
}

static int nfs4_access_to_omode(u32 access)
{
581
	switch (access & NFS4_SHARE_ACCESS_BOTH) {
582 583 584 585 586 587 588
	case NFS4_SHARE_ACCESS_READ:
		return O_RDONLY;
	case NFS4_SHARE_ACCESS_WRITE:
		return O_WRONLY;
	case NFS4_SHARE_ACCESS_BOTH:
		return O_RDWR;
	}
589 590
	WARN_ON_ONCE(1);
	return O_RDONLY;
591 592
}

593 594 595 596 597 598 599 600 601 602 603 604 605 606
/* release all access and file references for a given stateid */
static void
release_all_access(struct nfs4_ol_stateid *stp)
{
	int i;

	for (i = 1; i < 4; i++) {
		if (test_access(i, stp))
			nfs4_file_put_access(stp->st_file,
					     nfs4_access_to_omode(i));
		clear_access(i, stp);
	}
}

607
static void unhash_generic_stateid(struct nfs4_ol_stateid *stp)
608 609 610 611 612
{
	list_del(&stp->st_perfile);
	list_del(&stp->st_perstateowner);
}

613
static void close_generic_stateid(struct nfs4_ol_stateid *stp)
614
{
615
	release_all_access(stp);
O
OGAWA Hirofumi 已提交
616
	put_nfs4_file(stp->st_file);
617 618 619
	stp->st_file = NULL;
}

620
static void free_generic_stateid(struct nfs4_ol_stateid *stp)
621
{
622 623
	remove_stid(&stp->st_stid);
	kmem_cache_free(stateid_slab, stp);
624 625
}

626
static void release_lock_stateid(struct nfs4_ol_stateid *stp)
627 628 629 630
{
	struct file *file;

	unhash_generic_stateid(stp);
J
J. Bruce Fields 已提交
631
	unhash_stid(&stp->st_stid);
632 633
	file = find_any_file(stp->st_file);
	if (file)
634
		locks_remove_posix(file, (fl_owner_t)lockowner(stp->st_stateowner));
635
	close_generic_stateid(stp);
636 637 638
	free_generic_stateid(stp);
}

639
static void unhash_lockowner(struct nfs4_lockowner *lo)
640
{
641
	struct nfs4_ol_stateid *stp;
642

643 644
	list_del(&lo->lo_owner.so_strhash);
	list_del(&lo->lo_perstateid);
645
	list_del(&lo->lo_owner_ino_hash);
646 647
	while (!list_empty(&lo->lo_owner.so_stateids)) {
		stp = list_first_entry(&lo->lo_owner.so_stateids,
648
				struct nfs4_ol_stateid, st_perstateowner);
649 650 651 652
		release_lock_stateid(stp);
	}
}

653
static void release_lockowner(struct nfs4_lockowner *lo)
654
{
655 656
	unhash_lockowner(lo);
	nfs4_free_lockowner(lo);
657 658 659
}

static void
660
release_stateid_lockowners(struct nfs4_ol_stateid *open_stp)
661
{
662
	struct nfs4_lockowner *lo;
663 664

	while (!list_empty(&open_stp->st_lockowners)) {
665 666 667
		lo = list_entry(open_stp->st_lockowners.next,
				struct nfs4_lockowner, lo_perstateid);
		release_lockowner(lo);
668 669 670
	}
}

671
static void unhash_open_stateid(struct nfs4_ol_stateid *stp)
672 673 674
{
	unhash_generic_stateid(stp);
	release_stateid_lockowners(stp);
675 676 677 678 679 680
	close_generic_stateid(stp);
}

static void release_open_stateid(struct nfs4_ol_stateid *stp)
{
	unhash_open_stateid(stp);
J
J. Bruce Fields 已提交
681
	unhash_stid(&stp->st_stid);
682 683 684
	free_generic_stateid(stp);
}

685
static void unhash_openowner(struct nfs4_openowner *oo)
686
{
687
	struct nfs4_ol_stateid *stp;
688

689 690 691 692
	list_del(&oo->oo_owner.so_strhash);
	list_del(&oo->oo_perclient);
	while (!list_empty(&oo->oo_owner.so_stateids)) {
		stp = list_first_entry(&oo->oo_owner.so_stateids,
693
				struct nfs4_ol_stateid, st_perstateowner);
694
		release_open_stateid(stp);
695 696 697
	}
}

698 699 700 701 702
static void release_last_closed_stateid(struct nfs4_openowner *oo)
{
	struct nfs4_ol_stateid *s = oo->oo_last_closed_stid;

	if (s) {
J
J. Bruce Fields 已提交
703
		unhash_stid(&s->st_stid);
704 705 706 707 708
		free_generic_stateid(s);
		oo->oo_last_closed_stid = NULL;
	}
}

709
static void release_openowner(struct nfs4_openowner *oo)
710
{
711 712
	unhash_openowner(oo);
	list_del(&oo->oo_close_lru);
713
	release_last_closed_stateid(oo);
714
	nfs4_free_openowner(oo);
715 716
}

M
Marc Eshel 已提交
717 718 719 720 721 722 723 724
static inline int
hash_sessionid(struct nfs4_sessionid *sessionid)
{
	struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;

	return sid->sequence % SESSION_HASH_SIZE;
}

725
#ifdef NFSD_DEBUG
M
Marc Eshel 已提交
726 727 728 729 730 731
static inline void
dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
{
	u32 *ptr = (u32 *)(&sessionid->data[0]);
	dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
}
732 733 734 735 736 737 738
#else
static inline void
dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
{
}
#endif

739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
/*
 * Bump the seqid on cstate->replay_owner, and clear replay_owner if it
 * won't be used for replay.
 */
void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
{
	struct nfs4_stateowner *so = cstate->replay_owner;

	if (nfserr == nfserr_replay_me)
		return;

	if (!seqid_mutating_err(ntohl(nfserr))) {
		cstate->replay_owner = NULL;
		return;
	}
	if (!so)
		return;
	if (so->so_is_open_owner)
		release_last_closed_stateid(openowner(so));
	so->so_seqid++;
	return;
}
M
Marc Eshel 已提交
761

A
Andy Adamson 已提交
762 763 764 765 766 767 768 769 770 771 772 773 774
static void
gen_sessionid(struct nfsd4_session *ses)
{
	struct nfs4_client *clp = ses->se_client;
	struct nfsd4_sessionid *sid;

	sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
	sid->clientid = clp->cl_clientid;
	sid->sequence = current_sessionid++;
	sid->reserved = 0;
}

/*
775 776 777 778 779 780 781 782 783 784 785 786 787
 * The protocol defines ca_maxresponssize_cached to include the size of
 * the rpc header, but all we need to cache is the data starting after
 * the end of the initial SEQUENCE operation--the rest we regenerate
 * each time.  Therefore we can advertise a ca_maxresponssize_cached
 * value that is the number of bytes in our cache plus a few additional
 * bytes.  In order to stay on the safe side, and not promise more than
 * we can cache, those additional bytes must be the minimum possible: 24
 * bytes of rpc header (xid through accept state, with AUTH_NULL
 * verifier), 12 for the compound header (with zero-length tag), and 44
 * for the SEQUENCE op response:
 */
#define NFSD_MIN_HDR_SEQ_SZ  (24 + 12 + 44)

788 789 790 791 792 793 794 795 796
static void
free_session_slots(struct nfsd4_session *ses)
{
	int i;

	for (i = 0; i < ses->se_fchannel.maxreqs; i++)
		kfree(ses->se_slots[i]);
}

797
/*
798 799 800
 * We don't actually need to cache the rpc and session headers, so we
 * can allocate a little less for each slot:
 */
801
static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
802
{
803
	u32 size;
804

805 806 807 808 809
	if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
		size = 0;
	else
		size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
	return size + sizeof(struct nfsd4_slot);
810
}
A
Andy Adamson 已提交
811

812 813
/*
 * XXX: If we run out of reserved DRC memory we could (up to a point)
814
 * re-negotiate active sessions and reduce their slot usage to make
815
 * room for new connections. For now we just fail the create session.
A
Andy Adamson 已提交
816
 */
817
static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca)
A
Andy Adamson 已提交
818
{
819 820
	u32 slotsize = slot_bytes(ca);
	u32 num = ca->maxreqs;
821
	int avail;
A
Andy Adamson 已提交
822

823
	spin_lock(&nfsd_drc_lock);
824 825
	avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION,
		    nfsd_drc_max_mem - nfsd_drc_mem_used);
826 827 828
	num = min_t(int, num, avail / slotsize);
	nfsd_drc_mem_used += num * slotsize;
	spin_unlock(&nfsd_drc_lock);
A
Andy Adamson 已提交
829

830 831
	return num;
}
A
Andy Adamson 已提交
832

833
static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
834
{
835 836
	int slotsize = slot_bytes(ca);

837
	spin_lock(&nfsd_drc_lock);
838
	nfsd_drc_mem_used -= slotsize * ca->maxreqs;
839
	spin_unlock(&nfsd_drc_lock);
840
}
A
Andy Adamson 已提交
841

842
static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *attrs)
843
{
844 845
	int numslots = attrs->maxreqs;
	int slotsize = slot_bytes(attrs);
846 847
	struct nfsd4_session *new;
	int mem, i;
848

849 850 851
	BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
			+ sizeof(struct nfsd4_session) > PAGE_SIZE);
	mem = numslots * sizeof(struct nfsd4_slot *);
A
Andy Adamson 已提交
852

853 854 855
	new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
	if (!new)
		return NULL;
856
	/* allocate each struct nfsd4_slot and data cache in one piece */
857
	for (i = 0; i < numslots; i++) {
858
		new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL);
859
		if (!new->se_slots[i])
860 861
			goto out_free;
	}
862 863 864 865 866 867
	return new;
out_free:
	while (i--)
		kfree(new->se_slots[i]);
	kfree(new);
	return NULL;
A
Andy Adamson 已提交
868 869
}

870 871 872 873 874
static void free_conn(struct nfsd4_conn *c)
{
	svc_xprt_put(c->cn_xprt);
	kfree(c);
}
A
Andy Adamson 已提交
875

876 877 878 879
static void nfsd4_conn_lost(struct svc_xpt_user *u)
{
	struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
	struct nfs4_client *clp = c->cn_session->se_client;
A
Andy Adamson 已提交
880

881 882 883 884 885
	spin_lock(&clp->cl_lock);
	if (!list_empty(&c->cn_persession)) {
		list_del(&c->cn_persession);
		free_conn(c);
	}
886
	nfsd4_probe_callback(clp);
887
	spin_unlock(&clp->cl_lock);
888
}
A
Andy Adamson 已提交
889

890
static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
891 892
{
	struct nfsd4_conn *conn;
A
Andy Adamson 已提交
893

894 895
	conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
	if (!conn)
896
		return NULL;
897 898
	svc_xprt_get(rqstp->rq_xprt);
	conn->cn_xprt = rqstp->rq_xprt;
899
	conn->cn_flags = flags;
900 901 902
	INIT_LIST_HEAD(&conn->cn_xpt_user.list);
	return conn;
}
903

904 905 906 907
static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
{
	conn->cn_session = ses;
	list_add(&conn->cn_persession, &ses->se_conns);
A
Andy Adamson 已提交
908 909
}

910
static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
911
{
912
	struct nfs4_client *clp = ses->se_client;
913

914
	spin_lock(&clp->cl_lock);
915
	__nfsd4_hash_conn(conn, ses);
916
	spin_unlock(&clp->cl_lock);
917 918
}

919
static int nfsd4_register_conn(struct nfsd4_conn *conn)
920
{
921
	conn->cn_xpt_user.callback = nfsd4_conn_lost;
922
	return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
923 924
}

925
static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
A
Andy Adamson 已提交
926
{
927
	int ret;
A
Andy Adamson 已提交
928

929
	nfsd4_hash_conn(conn, ses);
930 931 932 933
	ret = nfsd4_register_conn(conn);
	if (ret)
		/* oops; xprt is already down: */
		nfsd4_conn_lost(&conn->cn_xpt_user);
934
	if (conn->cn_flags & NFS4_CDFC4_BACK) {
935 936 937
		/* callback channel may be back up */
		nfsd4_probe_callback(ses->se_client);
	}
938
}
A
Andy Adamson 已提交
939

940
static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
941 942 943
{
	u32 dir = NFS4_CDFC4_FORE;

944
	if (cses->flags & SESSION4_BACK_CHAN)
945
		dir |= NFS4_CDFC4_BACK;
946
	return alloc_conn(rqstp, dir);
947 948 949
}

/* must be called under client_lock */
950
static void nfsd4_del_conns(struct nfsd4_session *s)
951
{
952 953
	struct nfs4_client *clp = s->se_client;
	struct nfsd4_conn *c;
A
Andy Adamson 已提交
954

955 956 957 958 959
	spin_lock(&clp->cl_lock);
	while (!list_empty(&s->se_conns)) {
		c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
		list_del_init(&c->cn_persession);
		spin_unlock(&clp->cl_lock);
960

961 962
		unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
		free_conn(c);
A
Andy Adamson 已提交
963

964 965 966
		spin_lock(&clp->cl_lock);
	}
	spin_unlock(&clp->cl_lock);
967
}
A
Andy Adamson 已提交
968

969 970 971 972 973 974
static void __free_session(struct nfsd4_session *ses)
{
	free_session_slots(ses);
	kfree(ses);
}

975
static void free_session(struct nfsd4_session *ses)
976
{
977
	struct nfsd_net *nn = net_generic(ses->se_client->net, nfsd_net_id);
978 979

	lockdep_assert_held(&nn->client_lock);
980
	nfsd4_del_conns(ses);
981
	nfsd4_put_drc_mem(&ses->se_fchannel);
982
	__free_session(ses);
983 984
}

985
static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses)
986 987
{
	int idx;
988
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
989

A
Andy Adamson 已提交
990 991 992
	new->se_client = clp;
	gen_sessionid(new);

993 994
	INIT_LIST_HEAD(&new->se_conns);

995
	new->se_cb_seq_nr = 1;
A
Andy Adamson 已提交
996
	new->se_flags = cses->flags;
997
	new->se_cb_prog = cses->callback_prog;
998
	new->se_cb_sec = cses->cb_sec;
999
	atomic_set(&new->se_ref, 0);
1000
	idx = hash_sessionid(&new->se_sessionid);
1001
	spin_lock(&nn->client_lock);
1002
	list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
1003
	spin_lock(&clp->cl_lock);
A
Andy Adamson 已提交
1004
	list_add(&new->se_perclnt, &clp->cl_sessions);
1005
	spin_unlock(&clp->cl_lock);
1006
	spin_unlock(&nn->client_lock);
1007 1008
	memcpy(&new->se_fchannel, &cses->fore_channel,
			sizeof(struct nfsd4_channel_attrs));
1009
	if (cses->flags & SESSION4_BACK_CHAN) {
1010
		struct sockaddr *sa = svc_addr(rqstp);
1011 1012 1013 1014 1015 1016 1017
		/*
		 * This is a little silly; with sessions there's no real
		 * use for the callback address.  Use the peer address
		 * as a reasonable default for now, but consider fixing
		 * the rpc client not to require an address in the
		 * future:
		 */
1018 1019 1020
		rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
		clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
	}
A
Andy Adamson 已提交
1021 1022
}

1023
/* caller must hold client_lock */
M
Marc Eshel 已提交
1024
static struct nfsd4_session *
1025
find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
M
Marc Eshel 已提交
1026 1027 1028
{
	struct nfsd4_session *elem;
	int idx;
1029
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
M
Marc Eshel 已提交
1030 1031 1032 1033

	dump_sessionid(__func__, sessionid);
	idx = hash_sessionid(sessionid);
	/* Search in the appropriate list */
1034
	list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
M
Marc Eshel 已提交
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044
		if (!memcmp(elem->se_sessionid.data, sessionid->data,
			    NFS4_MAX_SESSIONID_LEN)) {
			return elem;
		}
	}

	dprintk("%s: session not found\n", __func__);
	return NULL;
}

1045
/* caller must hold client_lock */
A
Andy Adamson 已提交
1046
static void
M
Marc Eshel 已提交
1047
unhash_session(struct nfsd4_session *ses)
A
Andy Adamson 已提交
1048 1049
{
	list_del(&ses->se_hash);
1050
	spin_lock(&ses->se_client->cl_lock);
A
Andy Adamson 已提交
1051
	list_del(&ses->se_perclnt);
1052
	spin_unlock(&ses->se_client->cl_lock);
M
Marc Eshel 已提交
1053 1054
}

L
Linus Torvalds 已提交
1055 1056
/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
static int
1057
STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
L
Linus Torvalds 已提交
1058
{
1059
	if (clid->cl_boot == nn->boot_time)
L
Linus Torvalds 已提交
1060
		return 0;
A
Andy Adamson 已提交
1061
	dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
1062
		clid->cl_boot, clid->cl_id, nn->boot_time);
L
Linus Torvalds 已提交
1063 1064 1065 1066 1067 1068 1069 1070
	return 1;
}

/* 
 * XXX Should we use a slab cache ?
 * This type of memory management is somewhat inefficient, but we use it
 * anyway since SETCLIENTID is not a common operation.
 */
1071
static struct nfs4_client *alloc_client(struct xdr_netobj name)
L
Linus Torvalds 已提交
1072 1073 1074
{
	struct nfs4_client *clp;

1075 1076 1077
	clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
	if (clp == NULL)
		return NULL;
1078
	clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
1079 1080 1081
	if (clp->cl_name.data == NULL) {
		kfree(clp);
		return NULL;
L
Linus Torvalds 已提交
1082
	}
1083
	clp->cl_name.len = name.len;
L
Linus Torvalds 已提交
1084 1085 1086 1087 1088 1089
	return clp;
}

static inline void
free_client(struct nfs4_client *clp)
{
1090
	struct nfsd_net __maybe_unused *nn = net_generic(clp->net, nfsd_net_id);
1091 1092

	lockdep_assert_held(&nn->client_lock);
1093 1094 1095 1096 1097
	while (!list_empty(&clp->cl_sessions)) {
		struct nfsd4_session *ses;
		ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
				se_perclnt);
		list_del(&ses->se_perclnt);
1098 1099
		WARN_ON_ONCE(atomic_read(&ses->se_ref));
		free_session(ses);
1100
	}
1101
	free_svc_cred(&clp->cl_cred);
L
Linus Torvalds 已提交
1102
	kfree(clp->cl_name.data);
M
majianpeng 已提交
1103
	idr_destroy(&clp->cl_stateids);
L
Linus Torvalds 已提交
1104 1105 1106
	kfree(clp);
}

B
Benny Halevy 已提交
1107 1108 1109 1110
/* must be called under the client_lock */
static inline void
unhash_client_locked(struct nfs4_client *clp)
{
1111 1112
	struct nfsd4_session *ses;

B
Benny Halevy 已提交
1113
	list_del(&clp->cl_lru);
1114
	spin_lock(&clp->cl_lock);
1115 1116
	list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
		list_del_init(&ses->se_hash);
1117
	spin_unlock(&clp->cl_lock);
B
Benny Halevy 已提交
1118 1119
}

L
Linus Torvalds 已提交
1120
static void
1121
destroy_client(struct nfs4_client *clp)
L
Linus Torvalds 已提交
1122
{
1123
	struct nfs4_openowner *oo;
L
Linus Torvalds 已提交
1124 1125
	struct nfs4_delegation *dp;
	struct list_head reaplist;
1126
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
L
Linus Torvalds 已提交
1127 1128 1129

	INIT_LIST_HEAD(&reaplist);
	spin_lock(&recall_lock);
1130 1131 1132
	while (!list_empty(&clp->cl_delegations)) {
		dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
		list_del_init(&dp->dl_perclnt);
L
Linus Torvalds 已提交
1133 1134 1135 1136 1137
		list_move(&dp->dl_recall_lru, &reaplist);
	}
	spin_unlock(&recall_lock);
	while (!list_empty(&reaplist)) {
		dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
1138
		destroy_delegation(dp);
L
Linus Torvalds 已提交
1139
	}
1140
	while (!list_empty(&clp->cl_openowners)) {
1141 1142
		oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
		release_openowner(oo);
L
Linus Torvalds 已提交
1143
	}
1144
	nfsd4_shutdown_callback(clp);
B
Benny Halevy 已提交
1145 1146
	if (clp->cl_cb_conn.cb_xprt)
		svc_xprt_put(clp->cl_cb_conn.cb_xprt);
1147
	list_del(&clp->cl_idhash);
1148
	if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
1149
		rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
1150
	else
1151
		rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
1152
	spin_lock(&nn->client_lock);
B
Benny Halevy 已提交
1153
	unhash_client_locked(clp);
1154 1155
	WARN_ON_ONCE(atomic_read(&clp->cl_refcount));
	free_client(clp);
1156
	spin_unlock(&nn->client_lock);
L
Linus Torvalds 已提交
1157 1158
}

1159 1160 1161 1162 1163 1164
static void expire_client(struct nfs4_client *clp)
{
	nfsd4_client_record_remove(clp);
	destroy_client(clp);
}

1165 1166 1167 1168
static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
{
	memcpy(target->cl_verifier.data, source->data,
			sizeof(target->cl_verifier.data));
L
Linus Torvalds 已提交
1169 1170
}

1171 1172
static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
{
L
Linus Torvalds 已提交
1173 1174 1175 1176
	target->cl_clientid.cl_boot = source->cl_clientid.cl_boot; 
	target->cl_clientid.cl_id = source->cl_clientid.cl_id; 
}

1177
static int copy_cred(struct svc_cred *target, struct svc_cred *source)
1178
{
1179 1180 1181 1182 1183 1184 1185
	if (source->cr_principal) {
		target->cr_principal =
				kstrdup(source->cr_principal, GFP_KERNEL);
		if (target->cr_principal == NULL)
			return -ENOMEM;
	} else
		target->cr_principal = NULL;
1186
	target->cr_flavor = source->cr_flavor;
L
Linus Torvalds 已提交
1187 1188 1189 1190
	target->cr_uid = source->cr_uid;
	target->cr_gid = source->cr_gid;
	target->cr_group_info = source->cr_group_info;
	get_group_info(target->cr_group_info);
1191
	return 0;
L
Linus Torvalds 已提交
1192 1193
}

1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
static long long
compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
{
	long long res;

	res = o1->len - o2->len;
	if (res)
		return res;
	return (long long)memcmp(o1->data, o2->data, o1->len);
}

1205
static int same_name(const char *n1, const char *n2)
1206
{
N
NeilBrown 已提交
1207
	return 0 == memcmp(n1, n2, HEXDIR_LEN);
L
Linus Torvalds 已提交
1208 1209 1210
}

static int
1211 1212 1213
same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
{
	return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
L
Linus Torvalds 已提交
1214 1215 1216
}

static int
1217 1218 1219
same_clid(clientid_t *cl1, clientid_t *cl2)
{
	return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
L
Linus Torvalds 已提交
1220 1221
}

1222 1223 1224 1225 1226 1227 1228
static bool groups_equal(struct group_info *g1, struct group_info *g2)
{
	int i;

	if (g1->ngroups != g2->ngroups)
		return false;
	for (i=0; i<g1->ngroups; i++)
1229
		if (!gid_eq(GROUP_AT(g1, i), GROUP_AT(g2, i)))
1230 1231 1232 1233
			return false;
	return true;
}

1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
/*
 * RFC 3530 language requires clid_inuse be returned when the
 * "principal" associated with a requests differs from that previously
 * used.  We use uid, gid's, and gss principal string as our best
 * approximation.  We also don't want to allow non-gss use of a client
 * established using gss: in theory cr_principal should catch that
 * change, but in practice cr_principal can be null even in the gss case
 * since gssd doesn't always pass down a principal string.
 */
static bool is_gss_cred(struct svc_cred *cr)
{
	/* Is cr_flavor one of the gss "pseudoflavors"?: */
	return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
}


1250
static bool
1251 1252
same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
{
1253
	if ((is_gss_cred(cr1) != is_gss_cred(cr2))
1254 1255
		|| (!uid_eq(cr1->cr_uid, cr2->cr_uid))
		|| (!gid_eq(cr1->cr_gid, cr2->cr_gid))
1256 1257 1258 1259 1260 1261
		|| !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
		return false;
	if (cr1->cr_principal == cr2->cr_principal)
		return true;
	if (!cr1->cr_principal || !cr2->cr_principal)
		return false;
1262
	return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
L
Linus Torvalds 已提交
1263 1264
}

1265
static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
1266 1267 1268
{
	static u32 current_clientid = 1;

1269
	clp->cl_clientid.cl_boot = nn->boot_time;
L
Linus Torvalds 已提交
1270 1271 1272
	clp->cl_clientid.cl_id = current_clientid++; 
}

1273 1274
static void gen_confirm(struct nfs4_client *clp)
{
1275
	__be32 verf[2];
1276
	static u32 i;
L
Linus Torvalds 已提交
1277

1278 1279 1280
	verf[0] = (__be32)get_seconds();
	verf[1] = (__be32)i++;
	memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
L
Linus Torvalds 已提交
1281 1282
}

1283
static struct nfs4_stid *find_stateid(struct nfs4_client *cl, stateid_t *t)
1284
{
J
J. Bruce Fields 已提交
1285 1286 1287 1288 1289 1290
	struct nfs4_stid *ret;

	ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
	if (!ret || !ret->sc_type)
		return NULL;
	return ret;
J
J. Bruce Fields 已提交
1291 1292
}

1293
static struct nfs4_stid *find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
1294 1295
{
	struct nfs4_stid *s;
J
J. Bruce Fields 已提交
1296

1297
	s = find_stateid(cl, t);
J
J. Bruce Fields 已提交
1298 1299
	if (!s)
		return NULL;
1300
	if (typemask & s->sc_type)
1301 1302 1303 1304
		return s;
	return NULL;
}

J
Jeff Layton 已提交
1305
static struct nfs4_client *create_client(struct xdr_netobj name,
1306 1307 1308 1309
		struct svc_rqst *rqstp, nfs4_verifier *verf)
{
	struct nfs4_client *clp;
	struct sockaddr *sa = svc_addr(rqstp);
1310
	int ret;
1311
	struct net *net = SVC_NET(rqstp);
1312
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1313 1314 1315 1316 1317

	clp = alloc_client(name);
	if (clp == NULL)
		return NULL;

1318
	INIT_LIST_HEAD(&clp->cl_sessions);
1319 1320
	ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
	if (ret) {
1321
		spin_lock(&nn->client_lock);
1322
		free_client(clp);
1323
		spin_unlock(&nn->client_lock);
1324
		return NULL;
1325
	}
1326
	idr_init(&clp->cl_stateids);
1327
	atomic_set(&clp->cl_refcount, 0);
1328
	clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1329 1330 1331 1332
	INIT_LIST_HEAD(&clp->cl_idhash);
	INIT_LIST_HEAD(&clp->cl_openowners);
	INIT_LIST_HEAD(&clp->cl_delegations);
	INIT_LIST_HEAD(&clp->cl_lru);
1333
	INIT_LIST_HEAD(&clp->cl_callbacks);
1334
	INIT_LIST_HEAD(&clp->cl_revoked);
1335
	spin_lock_init(&clp->cl_lock);
1336
	nfsd4_init_callback(&clp->cl_cb_null);
B
Benny Halevy 已提交
1337
	clp->cl_time = get_seconds();
1338 1339 1340 1341 1342
	clear_bit(0, &clp->cl_cb_slot_busy);
	rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
	copy_verf(clp, verf);
	rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
	gen_confirm(clp);
1343
	clp->cl_cb_session = NULL;
1344
	clp->net = net;
1345 1346 1347
	return clp;
}

1348
static void
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389
add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
{
	struct rb_node **new = &(root->rb_node), *parent = NULL;
	struct nfs4_client *clp;

	while (*new) {
		clp = rb_entry(*new, struct nfs4_client, cl_namenode);
		parent = *new;

		if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
			new = &((*new)->rb_left);
		else
			new = &((*new)->rb_right);
	}

	rb_link_node(&new_clp->cl_namenode, parent, new);
	rb_insert_color(&new_clp->cl_namenode, root);
}

static struct nfs4_client *
find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
{
	long long cmp;
	struct rb_node *node = root->rb_node;
	struct nfs4_client *clp;

	while (node) {
		clp = rb_entry(node, struct nfs4_client, cl_namenode);
		cmp = compare_blob(&clp->cl_name, name);
		if (cmp > 0)
			node = node->rb_left;
		else if (cmp < 0)
			node = node->rb_right;
		else
			return clp;
	}
	return NULL;
}

static void
add_to_unconfirmed(struct nfs4_client *clp)
L
Linus Torvalds 已提交
1390 1391
{
	unsigned int idhashval;
1392
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
L
Linus Torvalds 已提交
1393

1394
	clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
1395
	add_clp_to_name_tree(clp, &nn->unconf_name_tree);
L
Linus Torvalds 已提交
1396
	idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1397
	list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
1398
	renew_client(clp);
L
Linus Torvalds 已提交
1399 1400
}

1401
static void
L
Linus Torvalds 已提交
1402 1403 1404
move_to_confirmed(struct nfs4_client *clp)
{
	unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1405
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
L
Linus Torvalds 已提交
1406 1407

	dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
1408
	list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
1409
	rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
1410
	add_clp_to_name_tree(clp, &nn->conf_name_tree);
1411
	set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
L
Linus Torvalds 已提交
1412 1413 1414 1415
	renew_client(clp);
}

static struct nfs4_client *
J
J. Bruce Fields 已提交
1416
find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
L
Linus Torvalds 已提交
1417 1418 1419 1420
{
	struct nfs4_client *clp;
	unsigned int idhashval = clientid_hashval(clid->cl_id);

J
J. Bruce Fields 已提交
1421
	list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
1422
		if (same_clid(&clp->cl_clientid, clid)) {
1423 1424
			if ((bool)clp->cl_minorversion != sessions)
				return NULL;
1425
			renew_client(clp);
L
Linus Torvalds 已提交
1426
			return clp;
1427
		}
L
Linus Torvalds 已提交
1428 1429 1430 1431
	}
	return NULL;
}

J
J. Bruce Fields 已提交
1432 1433 1434 1435 1436 1437 1438 1439
static struct nfs4_client *
find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
{
	struct list_head *tbl = nn->conf_id_hashtbl;

	return find_client_in_id_table(tbl, clid, sessions);
}

L
Linus Torvalds 已提交
1440
static struct nfs4_client *
1441
find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
L
Linus Torvalds 已提交
1442
{
J
J. Bruce Fields 已提交
1443
	struct list_head *tbl = nn->unconf_id_hashtbl;
L
Linus Torvalds 已提交
1444

J
J. Bruce Fields 已提交
1445
	return find_client_in_id_table(tbl, clid, sessions);
L
Linus Torvalds 已提交
1446 1447
}

1448
static bool clp_used_exchangeid(struct nfs4_client *clp)
1449
{
1450
	return clp->cl_exchange_flags != 0;
1451
} 
1452

1453
static struct nfs4_client *
1454
find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
1455
{
1456
	return find_clp_in_name_tree(name, &nn->conf_name_tree);
1457 1458 1459
}

static struct nfs4_client *
1460
find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
1461
{
1462
	return find_clp_in_name_tree(name, &nn->unconf_name_tree);
1463 1464
}

1465
static void
1466
gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
L
Linus Torvalds 已提交
1467
{
1468
	struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
1469 1470
	struct sockaddr	*sa = svc_addr(rqstp);
	u32 scopeid = rpc_get_scope_id(sa);
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
	unsigned short expected_family;

	/* Currently, we only support tcp and tcp6 for the callback channel */
	if (se->se_callback_netid_len == 3 &&
	    !memcmp(se->se_callback_netid_val, "tcp", 3))
		expected_family = AF_INET;
	else if (se->se_callback_netid_len == 4 &&
		 !memcmp(se->se_callback_netid_val, "tcp6", 4))
		expected_family = AF_INET6;
	else
L
Linus Torvalds 已提交
1481 1482
		goto out_err;

1483
	conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
1484
					    se->se_callback_addr_len,
1485 1486
					    (struct sockaddr *)&conn->cb_addr,
					    sizeof(conn->cb_addr));
1487

1488
	if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
L
Linus Torvalds 已提交
1489
		goto out_err;
1490

1491 1492
	if (conn->cb_addr.ss_family == AF_INET6)
		((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
1493

1494 1495
	conn->cb_prog = se->se_callback_prog;
	conn->cb_ident = se->se_callback_ident;
1496
	memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
L
Linus Torvalds 已提交
1497 1498
	return;
out_err:
1499 1500
	conn->cb_addr.ss_family = AF_UNSPEC;
	conn->cb_addrlen = 0;
N
Neil Brown 已提交
1501
	dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
L
Linus Torvalds 已提交
1502 1503 1504 1505 1506 1507
		"will not receive delegations\n",
		clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);

	return;
}

1508
/*
1509
 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
1510 1511 1512 1513
 */
void
nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
{
1514 1515
	struct nfsd4_slot *slot = resp->cstate.slot;
	unsigned int base;
1516

1517
	dprintk("--> %s slot %p\n", __func__, slot);
1518

1519 1520
	slot->sl_opcnt = resp->opcnt;
	slot->sl_status = resp->cstate.status;
1521

1522
	slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
1523
	if (nfsd4_not_cached(resp)) {
1524
		slot->sl_datalen = 0;
1525
		return;
1526
	}
1527 1528 1529 1530 1531 1532 1533
	slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
	base = (char *)resp->cstate.datap -
					(char *)resp->xbuf->head[0].iov_base;
	if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
				    slot->sl_datalen))
		WARN("%s: sessions DRC could not cache compound\n", __func__);
	return;
1534 1535 1536
}

/*
1537 1538 1539 1540
 * Encode the replay sequence operation from the slot values.
 * If cachethis is FALSE encode the uncached rep error on the next
 * operation which sets resp->p and increments resp->opcnt for
 * nfs4svc_encode_compoundres.
1541 1542
 *
 */
1543 1544 1545
static __be32
nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
			  struct nfsd4_compoundres *resp)
1546
{
1547 1548
	struct nfsd4_op *op;
	struct nfsd4_slot *slot = resp->cstate.slot;
1549

1550 1551 1552
	/* Encode the replayed sequence operation */
	op = &args->ops[resp->opcnt - 1];
	nfsd4_encode_operation(resp, op);
1553

1554
	/* Return nfserr_retry_uncached_rep in next operation. */
1555
	if (args->opcnt > 1 && !(slot->sl_flags & NFSD4_SLOT_CACHETHIS)) {
1556 1557 1558
		op = &args->ops[resp->opcnt++];
		op->status = nfserr_retry_uncached_rep;
		nfsd4_encode_operation(resp, op);
1559
	}
1560
	return op->status;
1561 1562 1563
}

/*
1564 1565
 * The sequence operation is not cached because we can use the slot and
 * session values.
1566 1567
 */
__be32
1568 1569
nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
			 struct nfsd4_sequence *seq)
1570
{
1571
	struct nfsd4_slot *slot = resp->cstate.slot;
1572 1573
	__be32 status;

1574
	dprintk("--> %s slot %p\n", __func__, slot);
1575

1576 1577 1578 1579
	/* Either returns 0 or nfserr_retry_uncached */
	status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
	if (status == nfserr_retry_uncached_rep)
		return status;
1580

1581 1582
	/* The sequence operation has been encoded, cstate->datap set. */
	memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
1583

1584 1585 1586
	resp->opcnt = slot->sl_opcnt;
	resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
	status = slot->sl_status;
1587 1588 1589 1590

	return status;
}

A
Andy Adamson 已提交
1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606
/*
 * Set the exchange_id flags returned by the server.
 */
static void
nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
{
	/* pNFS is not supported */
	new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;

	/* Referrals are supported, Migration is not. */
	new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;

	/* set the wire flags to return to client. */
	clid->flags = new->cl_exchange_flags;
}

1607 1608 1609 1610 1611 1612 1613 1614
static bool client_has_state(struct nfs4_client *clp)
{
	/*
	 * Note clp->cl_openowners check isn't quite right: there's no
	 * need to count owners without stateid's.
	 *
	 * Also note we should probably be using this in 4.0 case too.
	 */
1615 1616 1617
	return !list_empty(&clp->cl_openowners)
		|| !list_empty(&clp->cl_delegations)
		|| !list_empty(&clp->cl_sessions);
1618 1619
}

A
Andy Adamson 已提交
1620 1621 1622 1623 1624
__be32
nfsd4_exchange_id(struct svc_rqst *rqstp,
		  struct nfsd4_compound_state *cstate,
		  struct nfsd4_exchange_id *exid)
{
A
Andy Adamson 已提交
1625
	struct nfs4_client *unconf, *conf, *new;
J
J. Bruce Fields 已提交
1626
	__be32 status;
1627
	char			addr_str[INET6_ADDRSTRLEN];
A
Andy Adamson 已提交
1628
	nfs4_verifier		verf = exid->verifier;
1629
	struct sockaddr		*sa = svc_addr(rqstp);
1630
	bool	update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
1631
	struct nfsd_net		*nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
A
Andy Adamson 已提交
1632

1633
	rpc_ntop(sa, addr_str, sizeof(addr_str));
A
Andy Adamson 已提交
1634
	dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
1635
		"ip_addr=%s flags %x, spa_how %d\n",
A
Andy Adamson 已提交
1636
		__func__, rqstp, exid, exid->clname.len, exid->clname.data,
1637
		addr_str, exid->flags, exid->spa_how);
A
Andy Adamson 已提交
1638

1639
	if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
A
Andy Adamson 已提交
1640 1641 1642 1643 1644 1645
		return nfserr_inval;

	/* Currently only support SP4_NONE */
	switch (exid->spa_how) {
	case SP4_NONE:
		break;
1646 1647
	default:				/* checked by xdr code */
		WARN_ON_ONCE(1);
A
Andy Adamson 已提交
1648
	case SP4_SSV:
1649
		return nfserr_encr_alg_unsupp;
A
Andy Adamson 已提交
1650 1651 1652 1653
	case SP4_MACH_CRED:
		return nfserr_serverfault;	/* no excuse :-/ */
	}

1654
	/* Cases below refer to rfc 5661 section 18.35.4: */
A
Andy Adamson 已提交
1655
	nfs4_lock_state();
1656
	conf = find_confirmed_client_by_name(&exid->clname, nn);
A
Andy Adamson 已提交
1657
	if (conf) {
1658 1659 1660
		bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
		bool verfs_match = same_verf(&verf, &conf->cl_verifier);

1661 1662
		if (update) {
			if (!clp_used_exchangeid(conf)) { /* buggy client */
1663
				status = nfserr_inval;
1664 1665
				goto out;
			}
1666
			if (!creds_match) { /* case 9 */
1667
				status = nfserr_perm;
1668 1669 1670
				goto out;
			}
			if (!verfs_match) { /* case 8 */
A
Andy Adamson 已提交
1671 1672 1673
				status = nfserr_not_same;
				goto out;
			}
1674 1675 1676 1677
			/* case 6 */
			exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
			new = conf;
			goto out_copy;
A
Andy Adamson 已提交
1678
		}
1679
		if (!creds_match) { /* case 3 */
1680 1681
			if (client_has_state(conf)) {
				status = nfserr_clid_inuse;
A
Andy Adamson 已提交
1682 1683 1684 1685 1686
				goto out;
			}
			expire_client(conf);
			goto out_new;
		}
1687
		if (verfs_match) { /* case 2 */
1688
			conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
1689 1690 1691 1692 1693
			new = conf;
			goto out_copy;
		}
		/* case 5, client reboot */
		goto out_new;
1694 1695
	}

1696
	if (update) { /* case 7 */
1697 1698
		status = nfserr_noent;
		goto out;
A
Andy Adamson 已提交
1699 1700
	}

1701
	unconf  = find_unconfirmed_client_by_name(&exid->clname, nn);
1702
	if (unconf) /* case 4, possible retry or client restart */
A
Andy Adamson 已提交
1703 1704
		expire_client(unconf);

1705
	/* case 1 (normal case) */
A
Andy Adamson 已提交
1706
out_new:
J
Jeff Layton 已提交
1707
	new = create_client(exid->clname, rqstp, &verf);
A
Andy Adamson 已提交
1708
	if (new == NULL) {
1709
		status = nfserr_jukebox;
A
Andy Adamson 已提交
1710 1711
		goto out;
	}
1712
	new->cl_minorversion = cstate->minorversion;
A
Andy Adamson 已提交
1713

1714
	gen_clid(new, nn);
1715
	add_to_unconfirmed(new);
A
Andy Adamson 已提交
1716 1717 1718 1719
out_copy:
	exid->clientid.cl_boot = new->cl_clientid.cl_boot;
	exid->clientid.cl_id = new->cl_clientid.cl_id;

1720
	exid->seqid = new->cl_cs_slot.sl_seqid + 1;
A
Andy Adamson 已提交
1721 1722 1723
	nfsd4_set_ex_flags(new, exid);

	dprintk("nfsd4_exchange_id seqid %d flags %x\n",
1724
		new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
A
Andy Adamson 已提交
1725 1726 1727 1728 1729
	status = nfs_ok;

out:
	nfs4_unlock_state();
	return status;
A
Andy Adamson 已提交
1730 1731
}

J
J. Bruce Fields 已提交
1732
static __be32
1733
check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
B
Benny Halevy 已提交
1734
{
1735 1736
	dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
		slot_seqid);
B
Benny Halevy 已提交
1737 1738

	/* The slot is in use, and no response has been sent. */
1739 1740
	if (slot_inuse) {
		if (seqid == slot_seqid)
B
Benny Halevy 已提交
1741 1742 1743 1744
			return nfserr_jukebox;
		else
			return nfserr_seq_misordered;
	}
1745
	/* Note unsigned 32-bit arithmetic handles wraparound: */
1746
	if (likely(seqid == slot_seqid + 1))
B
Benny Halevy 已提交
1747
		return nfs_ok;
1748
	if (seqid == slot_seqid)
B
Benny Halevy 已提交
1749 1750 1751 1752
		return nfserr_replay_cache;
	return nfserr_seq_misordered;
}

1753 1754 1755 1756 1757 1758 1759
/*
 * Cache the create session result into the create session single DRC
 * slot cache by saving the xdr structure. sl_seqid has been set.
 * Do this for solo or embedded create session operations.
 */
static void
nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
J
J. Bruce Fields 已提交
1760
			   struct nfsd4_clid_slot *slot, __be32 nfserr)
1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773
{
	slot->sl_status = nfserr;
	memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
}

static __be32
nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
			    struct nfsd4_clid_slot *slot)
{
	memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
	return slot->sl_status;
}

1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790
#define NFSD_MIN_REQ_HDR_SEQ_SZ	((\
			2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
			1 +	/* MIN tag is length with zero, only length */ \
			3 +	/* version, opcount, opcode */ \
			XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
				/* seqid, slotID, slotID, cache */ \
			4 ) * sizeof(__be32))

#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
			2 +	/* verifier: AUTH_NULL, length 0 */\
			1 +	/* status */ \
			1 +	/* MIN tag is length with zero, only length */ \
			3 +	/* opcount, opcode, opstatus*/ \
			XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
				/* seqid, slotID, slotID, slotID, status */ \
			5 ) * sizeof(__be32))

1791
static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
1792
{
1793 1794
	u32 maxrpc = nn->nfsd_serv->sv_max_mesg;

1795 1796 1797 1798
	if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
		return nfserr_toosmall;
	if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
		return nfserr_toosmall;
1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817
	ca->headerpadsz = 0;
	ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
	ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
	ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
	ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
			NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
	ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
	/*
	 * Note decreasing slot size below client's request may make it
	 * difficult for client to function correctly, whereas
	 * decreasing the number of slots will (just?) affect
	 * performance.  When short on memory we therefore prefer to
	 * decrease number of slots instead of their size.  Clients that
	 * request larger slots than they need will get poor results:
	 */
	ca->maxreqs = nfsd4_get_drc_mem(ca);
	if (!ca->maxreqs)
		return nfserr_jukebox;

1818
	return nfs_ok;
1819 1820
}

1821
static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
1822
{
1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839
	ca->headerpadsz = 0;

	/*
	 * These RPC_MAX_HEADER macros are overkill, especially since we
	 * don't even do gss on the backchannel yet.  But this is still
	 * less than 1k.  Tighten up this estimate in the unlikely event
	 * it turns out to be a problem for some client:
	 */
	if (ca->maxreq_sz < NFS4_enc_cb_recall_sz + RPC_MAX_HEADER_WITH_AUTH)
		return nfserr_toosmall;
	if (ca->maxresp_sz < NFS4_dec_cb_recall_sz + RPC_MAX_REPHEADER_WITH_AUTH)
		return nfserr_toosmall;
	ca->maxresp_cached = 0;
	if (ca->maxops < 2)
		return nfserr_toosmall;

	return nfs_ok;
1840 1841
}

A
Andy Adamson 已提交
1842 1843 1844 1845 1846
__be32
nfsd4_create_session(struct svc_rqst *rqstp,
		     struct nfsd4_compound_state *cstate,
		     struct nfsd4_create_session *cr_ses)
{
1847
	struct sockaddr *sa = svc_addr(rqstp);
A
Andy Adamson 已提交
1848
	struct nfs4_client *conf, *unconf;
1849
	struct nfsd4_session *new;
1850
	struct nfsd4_conn *conn;
1851
	struct nfsd4_clid_slot *cs_slot = NULL;
J
J. Bruce Fields 已提交
1852
	__be32 status = 0;
1853
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
A
Andy Adamson 已提交
1854

1855 1856
	if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
		return nfserr_inval;
1857
	status = check_forechannel_attrs(&cr_ses->fore_channel, nn);
1858 1859 1860
	if (status)
		return status;
	status = check_backchannel_attrs(&cr_ses->back_channel);
1861 1862
	if (status)
		return status;
1863
	status = nfserr_jukebox;
1864 1865 1866
	new = alloc_session(&cr_ses->fore_channel);
	if (!new)
		goto out_release_drc_mem;
1867 1868 1869
	conn = alloc_conn_from_crses(rqstp, cr_ses);
	if (!conn)
		goto out_free_session;
1870

A
Andy Adamson 已提交
1871
	nfs4_lock_state();
1872
	unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
1873
	conf = find_confirmed_client(&cr_ses->clientid, true, nn);
1874
	WARN_ON_ONCE(conf && unconf);
A
Andy Adamson 已提交
1875 1876

	if (conf) {
1877 1878
		cs_slot = &conf->cl_cs_slot;
		status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
1879
		if (status == nfserr_replay_cache) {
1880
			status = nfsd4_replay_create_session(cr_ses, cs_slot);
1881
			goto out_free_conn;
1882
		} else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
A
Andy Adamson 已提交
1883
			status = nfserr_seq_misordered;
1884
			goto out_free_conn;
A
Andy Adamson 已提交
1885 1886
		}
	} else if (unconf) {
J
J. Bruce Fields 已提交
1887
		struct nfs4_client *old;
A
Andy Adamson 已提交
1888
		if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
1889
		    !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
A
Andy Adamson 已提交
1890
			status = nfserr_clid_inuse;
1891
			goto out_free_conn;
A
Andy Adamson 已提交
1892
		}
1893 1894
		cs_slot = &unconf->cl_cs_slot;
		status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
1895 1896
		if (status) {
			/* an unconfirmed replay returns misordered */
A
Andy Adamson 已提交
1897
			status = nfserr_seq_misordered;
1898
			goto out_free_conn;
A
Andy Adamson 已提交
1899
		}
1900
		old = find_confirmed_client_by_name(&unconf->cl_name, nn);
1901 1902 1903 1904
		if (old) {
			status = mark_client_expired(old);
			if (status)
				goto out_free_conn;
J
J. Bruce Fields 已提交
1905
			expire_client(old);
1906
		}
J
J. Bruce Fields 已提交
1907
		move_to_confirmed(unconf);
A
Andy Adamson 已提交
1908 1909 1910
		conf = unconf;
	} else {
		status = nfserr_stale_clientid;
1911
		goto out_free_conn;
A
Andy Adamson 已提交
1912
	}
1913
	status = nfs_ok;
1914 1915 1916 1917 1918 1919
	/*
	 * We do not support RDMA or persistent sessions
	 */
	cr_ses->flags &= ~SESSION4_PERSIST;
	cr_ses->flags &= ~SESSION4_RDMA;

1920 1921 1922
	init_session(rqstp, new, conf, cr_ses);
	nfsd4_init_conn(rqstp, conn, new);

1923
	memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
A
Andy Adamson 已提交
1924
	       NFS4_MAX_SESSIONID_LEN);
1925
	cs_slot->sl_seqid++;
1926
	cr_ses->seqid = cs_slot->sl_seqid;
A
Andy Adamson 已提交
1927

1928 1929
	/* cache solo and embedded create sessions under the state lock */
	nfsd4_cache_create_session(cr_ses, cs_slot, status);
A
Andy Adamson 已提交
1930 1931
	nfs4_unlock_state();
	return status;
1932
out_free_conn:
1933
	nfs4_unlock_state();
1934 1935 1936
	free_conn(conn);
out_free_session:
	__free_session(new);
1937 1938
out_release_drc_mem:
	nfsd4_put_drc_mem(&cr_ses->fore_channel);
J
J. Bruce Fields 已提交
1939
	return status;
A
Andy Adamson 已提交
1940 1941
}

1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955
static __be32 nfsd4_map_bcts_dir(u32 *dir)
{
	switch (*dir) {
	case NFS4_CDFC4_FORE:
	case NFS4_CDFC4_BACK:
		return nfs_ok;
	case NFS4_CDFC4_FORE_OR_BOTH:
	case NFS4_CDFC4_BACK_OR_BOTH:
		*dir = NFS4_CDFC4_BOTH;
		return nfs_ok;
	};
	return nfserr_inval;
}

1956 1957 1958
__be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_backchannel_ctl *bc)
{
	struct nfsd4_session *session = cstate->session;
1959
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1960

1961
	spin_lock(&nn->client_lock);
1962 1963
	session->se_cb_prog = bc->bc_cb_program;
	session->se_cb_sec = bc->bc_cb_sec;
1964
	spin_unlock(&nn->client_lock);
1965 1966 1967 1968 1969 1970

	nfsd4_probe_callback(session->se_client);

	return nfs_ok;
}

1971 1972 1973 1974 1975
__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
		     struct nfsd4_compound_state *cstate,
		     struct nfsd4_bind_conn_to_session *bcts)
{
	__be32 status;
1976
	struct nfsd4_conn *conn;
1977
	struct nfsd4_session *session;
1978
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1979 1980 1981

	if (!nfsd4_last_compound_op(rqstp))
		return nfserr_not_only_op;
1982
	nfs4_lock_state();
1983
	spin_lock(&nn->client_lock);
1984
	session = find_in_sessionid_hashtbl(&bcts->sessionid, SVC_NET(rqstp));
1985
	spin_unlock(&nn->client_lock);
1986 1987 1988
	status = nfserr_badsession;
	if (!session)
		goto out;
1989
	status = nfsd4_map_bcts_dir(&bcts->dir);
1990
	if (status)
1991
		goto out;
1992
	conn = alloc_conn(rqstp, bcts->dir);
1993
	status = nfserr_jukebox;
1994
	if (!conn)
1995 1996 1997 1998 1999 2000
		goto out;
	nfsd4_init_conn(rqstp, conn, session);
	status = nfs_ok;
out:
	nfs4_unlock_state();
	return status;
2001 2002
}

2003 2004 2005 2006 2007 2008 2009
static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
{
	if (!session)
		return 0;
	return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
}

A
Andy Adamson 已提交
2010 2011 2012 2013 2014
__be32
nfsd4_destroy_session(struct svc_rqst *r,
		      struct nfsd4_compound_state *cstate,
		      struct nfsd4_destroy_session *sessionid)
{
B
Benny Halevy 已提交
2015
	struct nfsd4_session *ses;
2016
	__be32 status;
2017
	struct nfsd_net *nn = net_generic(SVC_NET(r), nfsd_net_id);
B
Benny Halevy 已提交
2018

2019 2020
	nfs4_lock_state();
	status = nfserr_not_only_op;
2021
	if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
2022
		if (!nfsd4_last_compound_op(r))
2023
			goto out;
2024
	}
B
Benny Halevy 已提交
2025
	dump_sessionid(__func__, &sessionid->sessionid);
2026
	spin_lock(&nn->client_lock);
2027
	ses = find_in_sessionid_hashtbl(&sessionid->sessionid, SVC_NET(r));
2028 2029 2030
	status = nfserr_badsession;
	if (!ses)
		goto out_client_lock;
2031 2032 2033
	status = mark_session_dead_locked(ses);
	if (status)
		goto out_client_lock;
B
Benny Halevy 已提交
2034
	unhash_session(ses);
2035
	spin_unlock(&nn->client_lock);
B
Benny Halevy 已提交
2036

2037
	nfsd4_probe_callback_sync(ses->se_client);
2038

2039
	spin_lock(&nn->client_lock);
2040
	free_session(ses);
B
Benny Halevy 已提交
2041
	status = nfs_ok;
2042 2043
out_client_lock:
	spin_unlock(&nn->client_lock);
B
Benny Halevy 已提交
2044
out:
2045
	nfs4_unlock_state();
B
Benny Halevy 已提交
2046
	return status;
A
Andy Adamson 已提交
2047 2048
}

2049
static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
2050 2051 2052 2053
{
	struct nfsd4_conn *c;

	list_for_each_entry(c, &s->se_conns, cn_persession) {
2054
		if (c->cn_xprt == xpt) {
2055 2056 2057 2058 2059 2060
			return c;
		}
	}
	return NULL;
}

2061
static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
2062 2063
{
	struct nfs4_client *clp = ses->se_client;
2064
	struct nfsd4_conn *c;
2065
	int ret;
2066 2067

	spin_lock(&clp->cl_lock);
2068
	c = __nfsd4_find_conn(new->cn_xprt, ses);
2069 2070 2071 2072 2073 2074 2075
	if (c) {
		spin_unlock(&clp->cl_lock);
		free_conn(new);
		return;
	}
	__nfsd4_hash_conn(new, ses);
	spin_unlock(&clp->cl_lock);
2076 2077 2078 2079
	ret = nfsd4_register_conn(new);
	if (ret)
		/* oops; xprt is already down: */
		nfsd4_conn_lost(&new->cn_xpt_user);
2080 2081 2082
	return;
}

2083 2084 2085 2086 2087 2088 2089
static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
{
	struct nfsd4_compoundargs *args = rqstp->rq_argp;

	return args->opcnt > session->se_fchannel.maxops;
}

M
Mi Jinlong 已提交
2090 2091 2092 2093 2094 2095 2096 2097
static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
				  struct nfsd4_session *session)
{
	struct xdr_buf *xb = &rqstp->rq_arg;

	return xb->len > session->se_fchannel.maxreq_sz;
}

A
Andy Adamson 已提交
2098
__be32
B
Benny Halevy 已提交
2099
nfsd4_sequence(struct svc_rqst *rqstp,
A
Andy Adamson 已提交
2100 2101 2102
	       struct nfsd4_compound_state *cstate,
	       struct nfsd4_sequence *seq)
{
2103
	struct nfsd4_compoundres *resp = rqstp->rq_resp;
B
Benny Halevy 已提交
2104
	struct nfsd4_session *session;
2105
	struct nfs4_client *clp;
B
Benny Halevy 已提交
2106
	struct nfsd4_slot *slot;
2107
	struct nfsd4_conn *conn;
J
J. Bruce Fields 已提交
2108
	__be32 status;
2109
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
B
Benny Halevy 已提交
2110

2111 2112 2113
	if (resp->opcnt != 1)
		return nfserr_sequence_pos;

2114 2115 2116 2117 2118 2119 2120 2121
	/*
	 * Will be either used or freed by nfsd4_sequence_check_conn
	 * below.
	 */
	conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
	if (!conn)
		return nfserr_jukebox;

2122
	spin_lock(&nn->client_lock);
B
Benny Halevy 已提交
2123
	status = nfserr_badsession;
2124
	session = find_in_sessionid_hashtbl(&seq->sessionid, SVC_NET(rqstp));
B
Benny Halevy 已提交
2125
	if (!session)
2126 2127 2128 2129 2130
		goto out_no_session;
	clp = session->se_client;
	status = get_client_locked(clp);
	if (status)
		goto out_no_session;
2131 2132 2133
	status = nfsd4_get_session_locked(session);
	if (status)
		goto out_put_client;
B
Benny Halevy 已提交
2134

2135 2136
	status = nfserr_too_many_ops;
	if (nfsd4_session_too_many_ops(rqstp, session))
2137
		goto out_put_session;
2138

M
Mi Jinlong 已提交
2139 2140
	status = nfserr_req_too_big;
	if (nfsd4_request_too_big(rqstp, session))
2141
		goto out_put_session;
M
Mi Jinlong 已提交
2142

B
Benny Halevy 已提交
2143
	status = nfserr_badslot;
2144
	if (seq->slotid >= session->se_fchannel.maxreqs)
2145
		goto out_put_session;
B
Benny Halevy 已提交
2146

2147
	slot = session->se_slots[seq->slotid];
B
Benny Halevy 已提交
2148 2149
	dprintk("%s: slotid %d\n", __func__, seq->slotid);

2150 2151 2152 2153 2154
	/* We do not negotiate the number of slots yet, so set the
	 * maxslots to the session maxreqs which is used to encode
	 * sr_highest_slotid and the sr_target_slot id to maxslots */
	seq->maxslots = session->se_fchannel.maxreqs;

2155 2156
	status = check_slot_seqid(seq->seqid, slot->sl_seqid,
					slot->sl_flags & NFSD4_SLOT_INUSE);
B
Benny Halevy 已提交
2157
	if (status == nfserr_replay_cache) {
2158 2159
		status = nfserr_seq_misordered;
		if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
2160
			goto out_put_session;
B
Benny Halevy 已提交
2161 2162
		cstate->slot = slot;
		cstate->session = session;
A
Andy Adamson 已提交
2163
		/* Return the cached reply status and set cstate->status
2164
		 * for nfsd4_proc_compound processing */
2165
		status = nfsd4_replay_cache_entry(resp, seq);
A
Andy Adamson 已提交
2166
		cstate->status = nfserr_replay_cache;
2167
		goto out;
B
Benny Halevy 已提交
2168 2169
	}
	if (status)
2170
		goto out_put_session;
B
Benny Halevy 已提交
2171

2172 2173
	nfsd4_sequence_check_conn(conn, session);
	conn = NULL;
2174

B
Benny Halevy 已提交
2175 2176
	/* Success! bump slot seqid */
	slot->sl_seqid = seq->seqid;
2177
	slot->sl_flags |= NFSD4_SLOT_INUSE;
2178 2179
	if (seq->cachethis)
		slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
2180 2181
	else
		slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
B
Benny Halevy 已提交
2182 2183 2184 2185 2186

	cstate->slot = slot;
	cstate->session = session;

out:
2187 2188 2189 2190 2191 2192 2193 2194 2195
	switch (clp->cl_cb_state) {
	case NFSD4_CB_DOWN:
		seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
		break;
	case NFSD4_CB_FAULT:
		seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
		break;
	default:
		seq->status_flags = 0;
2196
	}
2197 2198
	if (!list_empty(&clp->cl_revoked))
		seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
2199
out_no_session:
2200
	kfree(conn);
2201
	spin_unlock(&nn->client_lock);
B
Benny Halevy 已提交
2202
	return status;
2203 2204
out_put_session:
	nfsd4_put_session(session);
2205 2206 2207
out_put_client:
	put_client_renew_locked(clp);
	goto out_no_session;
A
Andy Adamson 已提交
2208 2209
}

2210 2211 2212 2213
__be32
nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
{
	struct nfs4_client *conf, *unconf, *clp;
J
J. Bruce Fields 已提交
2214
	__be32 status = 0;
2215
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2216 2217

	nfs4_lock_state();
2218
	unconf = find_unconfirmed_client(&dc->clientid, true, nn);
2219
	conf = find_confirmed_client(&dc->clientid, true, nn);
2220
	WARN_ON_ONCE(conf && unconf);
2221 2222 2223 2224

	if (conf) {
		clp = conf;

2225
		if (client_has_state(conf)) {
2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241
			status = nfserr_clientid_busy;
			goto out;
		}
	} else if (unconf)
		clp = unconf;
	else {
		status = nfserr_stale_clientid;
		goto out;
	}

	expire_client(clp);
out:
	nfs4_unlock_state();
	return status;
}

2242 2243 2244
__be32
nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
{
J
J. Bruce Fields 已提交
2245
	__be32 status = 0;
2246

2247 2248 2249 2250 2251 2252 2253 2254 2255
	if (rc->rca_one_fs) {
		if (!cstate->current_fh.fh_dentry)
			return nfserr_nofilehandle;
		/*
		 * We don't take advantage of the rca_one_fs case.
		 * That's OK, it's optional, we can safely ignore it.
		 */
		 return nfs_ok;
	}
2256

2257
	nfs4_lock_state();
2258
	status = nfserr_complete_already;
2259 2260
	if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
			     &cstate->session->se_client->cl_flags))
2261 2262 2263 2264
		goto out;

	status = nfserr_stale_clientid;
	if (is_client_expired(cstate->session->se_client))
2265 2266 2267 2268 2269 2270 2271
		/*
		 * The following error isn't really legal.
		 * But we only get here if the client just explicitly
		 * destroyed the client.  Surely it no longer cares what
		 * error it gets back on an operation for the dead
		 * client.
		 */
2272 2273 2274
		goto out;

	status = nfs_ok;
2275
	nfsd4_client_record_create(cstate->session->se_client);
2276
out:
2277
	nfs4_unlock_state();
2278
	return status;
2279 2280
}

2281
__be32
2282 2283
nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
		  struct nfsd4_setclientid *setclid)
L
Linus Torvalds 已提交
2284
{
2285
	struct xdr_netobj 	clname = setclid->se_name;
L
Linus Torvalds 已提交
2286
	nfs4_verifier		clverifier = setclid->se_verf;
2287
	struct nfs4_client	*conf, *unconf, *new;
2288
	__be32 			status;
2289 2290
	struct nfsd_net		*nn = net_generic(SVC_NET(rqstp), nfsd_net_id);

2291
	/* Cases below refer to rfc 3530 section 14.2.33: */
L
Linus Torvalds 已提交
2292
	nfs4_lock_state();
2293
	conf = find_confirmed_client_by_name(&clname, nn);
2294
	if (conf) {
2295
		/* case 0: */
L
Linus Torvalds 已提交
2296
		status = nfserr_clid_inuse;
2297 2298
		if (clp_used_exchangeid(conf))
			goto out;
2299
		if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
2300 2301 2302 2303 2304
			char addr_str[INET6_ADDRSTRLEN];
			rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
				 sizeof(addr_str));
			dprintk("NFSD: setclientid: string in use by client "
				"at %s\n", addr_str);
L
Linus Torvalds 已提交
2305 2306 2307
			goto out;
		}
	}
2308
	unconf = find_unconfirmed_client_by_name(&clname, nn);
2309 2310
	if (unconf)
		expire_client(unconf);
2311
	status = nfserr_jukebox;
J
Jeff Layton 已提交
2312
	new = create_client(clname, rqstp, &clverifier);
2313 2314
	if (new == NULL)
		goto out;
2315
	if (conf && same_verf(&conf->cl_verifier, &clverifier))
2316
		/* case 1: probable callback update */
L
Linus Torvalds 已提交
2317
		copy_clid(new, conf);
2318
	else /* case 4 (new client) or cases 2, 3 (client reboot): */
2319
		gen_clid(new, nn);
2320
	new->cl_minorversion = 0;
2321
	gen_callback(new, setclid, rqstp);
2322
	add_to_unconfirmed(new);
L
Linus Torvalds 已提交
2323 2324 2325 2326 2327 2328 2329 2330 2331 2332
	setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
	setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
	memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
	status = nfs_ok;
out:
	nfs4_unlock_state();
	return status;
}


2333
__be32
2334 2335 2336
nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
			 struct nfsd4_compound_state *cstate,
			 struct nfsd4_setclientid_confirm *setclientid_confirm)
L
Linus Torvalds 已提交
2337
{
2338
	struct nfs4_client *conf, *unconf;
L
Linus Torvalds 已提交
2339 2340
	nfs4_verifier confirm = setclientid_confirm->sc_confirm; 
	clientid_t * clid = &setclientid_confirm->sc_clientid;
2341
	__be32 status;
2342
	struct nfsd_net	*nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
L
Linus Torvalds 已提交
2343

2344
	if (STALE_CLIENTID(clid, nn))
L
Linus Torvalds 已提交
2345 2346
		return nfserr_stale_clientid;
	nfs4_lock_state();
2347

2348
	conf = find_confirmed_client(clid, false, nn);
2349
	unconf = find_unconfirmed_client(clid, false, nn);
2350
	/*
2351 2352 2353 2354
	 * We try hard to give out unique clientid's, so if we get an
	 * attempt to confirm the same clientid with a different cred,
	 * there's a bug somewhere.  Let's charitably assume it's our
	 * bug.
2355
	 */
2356 2357 2358 2359 2360
	status = nfserr_serverfault;
	if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred))
		goto out;
	if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred))
		goto out;
2361
	/* cases below refer to rfc 3530 section 14.2.34: */
2362 2363
	if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
		if (conf && !unconf) /* case 2: probable retransmit */
L
Linus Torvalds 已提交
2364
			status = nfs_ok;
2365 2366 2367 2368 2369 2370
		else /* case 4: client hasn't noticed we rebooted yet? */
			status = nfserr_stale_clientid;
		goto out;
	}
	status = nfs_ok;
	if (conf) { /* case 1: callback update */
2371 2372 2373
		nfsd4_change_callback(conf, &unconf->cl_cb_conn);
		nfsd4_probe_callback(conf);
		expire_client(unconf);
2374
	} else { /* case 3: normal case; new or rebooted client */
2375
		conf = find_confirmed_client_by_name(&unconf->cl_name, nn);
2376 2377 2378 2379
		if (conf) {
			status = mark_client_expired(conf);
			if (status)
				goto out;
2380
			expire_client(conf);
2381
		}
2382
		move_to_confirmed(unconf);
2383
		nfsd4_probe_callback(unconf);
2384
	}
L
Linus Torvalds 已提交
2385 2386 2387 2388 2389
out:
	nfs4_unlock_state();
	return status;
}

2390 2391 2392 2393 2394
static struct nfs4_file *nfsd4_alloc_file(void)
{
	return kmem_cache_alloc(file_slab, GFP_KERNEL);
}

L
Linus Torvalds 已提交
2395
/* OPEN Share state helper functions */
2396
static void nfsd4_init_file(struct nfs4_file *fp, struct inode *ino)
L
Linus Torvalds 已提交
2397 2398 2399
{
	unsigned int hashval = file_hashval(ino);

2400 2401 2402 2403 2404 2405 2406 2407 2408
	atomic_set(&fp->fi_ref, 1);
	INIT_LIST_HEAD(&fp->fi_stateids);
	INIT_LIST_HEAD(&fp->fi_delegations);
	fp->fi_inode = igrab(ino);
	fp->fi_had_conflict = false;
	fp->fi_lease = NULL;
	memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
	memset(fp->fi_access, 0, sizeof(fp->fi_access));
	spin_lock(&recall_lock);
2409
	hlist_add_head(&fp->fi_hash, &file_hashtbl[hashval]);
2410
	spin_unlock(&recall_lock);
L
Linus Torvalds 已提交
2411 2412
}

N
NeilBrown 已提交
2413
static void
2414
nfsd4_free_slab(struct kmem_cache **slab)
L
Linus Torvalds 已提交
2415
{
N
NeilBrown 已提交
2416 2417
	if (*slab == NULL)
		return;
2418
	kmem_cache_destroy(*slab);
N
NeilBrown 已提交
2419
	*slab = NULL;
L
Linus Torvalds 已提交
2420 2421
}

2422
void
L
Linus Torvalds 已提交
2423 2424
nfsd4_free_slabs(void)
{
2425 2426
	nfsd4_free_slab(&openowner_slab);
	nfsd4_free_slab(&lockowner_slab);
N
NeilBrown 已提交
2427
	nfsd4_free_slab(&file_slab);
N
NeilBrown 已提交
2428
	nfsd4_free_slab(&stateid_slab);
N
NeilBrown 已提交
2429
	nfsd4_free_slab(&deleg_slab);
N
NeilBrown 已提交
2430
}
L
Linus Torvalds 已提交
2431

2432
int
N
NeilBrown 已提交
2433 2434
nfsd4_init_slabs(void)
{
2435 2436 2437 2438 2439
	openowner_slab = kmem_cache_create("nfsd4_openowners",
			sizeof(struct nfs4_openowner), 0, 0, NULL);
	if (openowner_slab == NULL)
		goto out_nomem;
	lockowner_slab = kmem_cache_create("nfsd4_lockowners",
2440
			sizeof(struct nfs4_lockowner), 0, 0, NULL);
2441
	if (lockowner_slab == NULL)
N
NeilBrown 已提交
2442 2443
		goto out_nomem;
	file_slab = kmem_cache_create("nfsd4_files",
2444
			sizeof(struct nfs4_file), 0, 0, NULL);
N
NeilBrown 已提交
2445 2446
	if (file_slab == NULL)
		goto out_nomem;
N
NeilBrown 已提交
2447
	stateid_slab = kmem_cache_create("nfsd4_stateids",
2448
			sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
N
NeilBrown 已提交
2449 2450
	if (stateid_slab == NULL)
		goto out_nomem;
N
NeilBrown 已提交
2451
	deleg_slab = kmem_cache_create("nfsd4_delegations",
2452
			sizeof(struct nfs4_delegation), 0, 0, NULL);
N
NeilBrown 已提交
2453 2454
	if (deleg_slab == NULL)
		goto out_nomem;
N
NeilBrown 已提交
2455 2456 2457 2458 2459
	return 0;
out_nomem:
	nfsd4_free_slabs();
	dprintk("nfsd4: out of memory while initializing nfsv4\n");
	return -ENOMEM;
L
Linus Torvalds 已提交
2460 2461
}

2462 2463 2464 2465 2466 2467 2468
void nfs4_free_openowner(struct nfs4_openowner *oo)
{
	kfree(oo->oo_owner.so_owner.data);
	kmem_cache_free(openowner_slab, oo);
}

void nfs4_free_lockowner(struct nfs4_lockowner *lo)
L
Linus Torvalds 已提交
2469
{
2470 2471
	kfree(lo->lo_owner.so_owner.data);
	kmem_cache_free(lockowner_slab, lo);
L
Linus Torvalds 已提交
2472 2473
}

2474
static void init_nfs4_replay(struct nfs4_replay *rp)
L
Linus Torvalds 已提交
2475
{
2476 2477 2478
	rp->rp_status = nfserr_serverfault;
	rp->rp_buflen = 0;
	rp->rp_buf = rp->rp_ibuf;
L
Linus Torvalds 已提交
2479 2480
}

2481
static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
2482
{
L
Linus Torvalds 已提交
2483 2484
	struct nfs4_stateowner *sop;

2485
	sop = kmem_cache_alloc(slab, GFP_KERNEL);
2486 2487 2488 2489 2490
	if (!sop)
		return NULL;

	sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
	if (!sop->so_owner.data) {
2491
		kmem_cache_free(slab, sop);
L
Linus Torvalds 已提交
2492
		return NULL;
2493 2494 2495
	}
	sop->so_owner.len = owner->len;

2496
	INIT_LIST_HEAD(&sop->so_stateids);
2497 2498 2499 2500 2501
	sop->so_client = clp;
	init_nfs4_replay(&sop->so_replay);
	return sop;
}

2502
static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
2503
{
2504 2505 2506
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	list_add(&oo->oo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
2507
	list_add(&oo->oo_perclient, &clp->cl_openowners);
2508 2509
}

2510
static struct nfs4_openowner *
2511
alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
2512
	struct nfs4_openowner *oo;
2513

2514 2515
	oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
	if (!oo)
2516
		return NULL;
2517 2518
	oo->oo_owner.so_is_open_owner = 1;
	oo->oo_owner.so_seqid = open->op_seqid;
2519
	oo->oo_flags = NFS4_OO_NEW;
2520
	oo->oo_time = 0;
2521
	oo->oo_last_closed_stid = NULL;
2522 2523 2524
	INIT_LIST_HEAD(&oo->oo_close_lru);
	hash_openowner(oo, clp, strhashval);
	return oo;
L
Linus Torvalds 已提交
2525 2526
}

2527
static void init_open_stateid(struct nfs4_ol_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
2528
	struct nfs4_openowner *oo = open->op_openowner;
L
Linus Torvalds 已提交
2529

J
J. Bruce Fields 已提交
2530
	stp->st_stid.sc_type = NFS4_OPEN_STID;
2531
	INIT_LIST_HEAD(&stp->st_lockowners);
2532
	list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
2533
	list_add(&stp->st_perfile, &fp->fi_stateids);
2534
	stp->st_stateowner = &oo->oo_owner;
2535
	get_nfs4_file(fp);
L
Linus Torvalds 已提交
2536 2537 2538
	stp->st_file = fp;
	stp->st_access_bmap = 0;
	stp->st_deny_bmap = 0;
2539
	set_access(open->op_share_access, stp);
2540
	set_deny(open->op_share_deny, stp);
2541
	stp->st_openstp = NULL;
L
Linus Torvalds 已提交
2542 2543
}

2544
static void
2545
move_to_close_lru(struct nfs4_openowner *oo, struct net *net)
L
Linus Torvalds 已提交
2546
{
2547 2548
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);

2549
	dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
L
Linus Torvalds 已提交
2550

2551
	list_move_tail(&oo->oo_close_lru, &nn->close_lru);
2552
	oo->oo_time = get_seconds();
L
Linus Torvalds 已提交
2553 2554 2555
}

static int
2556 2557 2558 2559 2560 2561
same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
							clientid_t *clid)
{
	return (sop->so_owner.len == owner->len) &&
		0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
		(sop->so_client->cl_clientid.cl_id == clid->cl_id);
L
Linus Torvalds 已提交
2562 2563
}

2564
static struct nfs4_openowner *
2565 2566
find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
			bool sessions, struct nfsd_net *nn)
L
Linus Torvalds 已提交
2567
{
2568 2569
	struct nfs4_stateowner *so;
	struct nfs4_openowner *oo;
2570
	struct nfs4_client *clp;
L
Linus Torvalds 已提交
2571

2572
	list_for_each_entry(so, &nn->ownerstr_hashtbl[hashval], so_strhash) {
2573 2574
		if (!so->so_is_open_owner)
			continue;
2575 2576
		if (same_owner_str(so, &open->op_owner, &open->op_clientid)) {
			oo = openowner(so);
2577 2578 2579
			clp = oo->oo_owner.so_client;
			if ((bool)clp->cl_minorversion != sessions)
				return NULL;
2580 2581 2582
			renew_client(oo->oo_owner.so_client);
			return oo;
		}
L
Linus Torvalds 已提交
2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593
	}
	return NULL;
}

/* search file_hashtbl[] for file */
static struct nfs4_file *
find_file(struct inode *ino)
{
	unsigned int hashval = file_hashval(ino);
	struct nfs4_file *fp;

2594
	spin_lock(&recall_lock);
2595
	hlist_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
2596 2597
		if (fp->fi_inode == ino) {
			get_nfs4_file(fp);
2598
			spin_unlock(&recall_lock);
L
Linus Torvalds 已提交
2599
			return fp;
2600
		}
L
Linus Torvalds 已提交
2601
	}
2602
	spin_unlock(&recall_lock);
L
Linus Torvalds 已提交
2603 2604 2605 2606 2607 2608 2609
	return NULL;
}

/*
 * Called to check deny when READ with all zero stateid or
 * WRITE with all zero or all one stateid
 */
2610
static __be32
L
Linus Torvalds 已提交
2611 2612 2613 2614
nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
{
	struct inode *ino = current_fh->fh_dentry->d_inode;
	struct nfs4_file *fp;
2615
	struct nfs4_ol_stateid *stp;
2616
	__be32 ret;
L
Linus Torvalds 已提交
2617 2618

	fp = find_file(ino);
2619 2620
	if (!fp)
		return nfs_ok;
2621
	ret = nfserr_locked;
L
Linus Torvalds 已提交
2622
	/* Search for conflicting share reservations */
2623
	list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
2624 2625
		if (test_deny(deny_type, stp) ||
		    test_deny(NFS4_SHARE_DENY_BOTH, stp))
2626
			goto out;
L
Linus Torvalds 已提交
2627
	}
2628 2629 2630 2631
	ret = nfs_ok;
out:
	put_nfs4_file(fp);
	return ret;
L
Linus Torvalds 已提交
2632 2633
}

2634
static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
L
Linus Torvalds 已提交
2635
{
2636 2637 2638
	struct nfs4_client *clp = dp->dl_stid.sc_client;
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

L
Linus Torvalds 已提交
2639 2640 2641 2642 2643 2644 2645
	/* We're assuming the state code never drops its reference
	 * without first removing the lease.  Since we're in this lease
	 * callback (and since the lease code is serialized by the kernel
	 * lock) we know the server hasn't removed the lease yet, we know
	 * it's safe to take a reference: */
	atomic_inc(&dp->dl_count);

2646
	list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
L
Linus Torvalds 已提交
2647

2648
	/* only place dl_time is set. protected by lock_flocks*/
L
Linus Torvalds 已提交
2649 2650
	dp->dl_time = get_seconds();

2651 2652 2653
	nfsd4_cb_recall(dp);
}

2654
/* Called from break_lease() with lock_flocks() held. */
2655 2656
static void nfsd_break_deleg_cb(struct file_lock *fl)
{
2657 2658
	struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
	struct nfs4_delegation *dp;
2659

2660 2661 2662 2663 2664 2665 2666 2667
	if (!fp) {
		WARN(1, "(%p)->fl_owner NULL\n", fl);
		return;
	}
	if (fp->fi_had_conflict) {
		WARN(1, "duplicate break on %p\n", fp);
		return;
	}
2668 2669
	/*
	 * We don't want the locks code to timeout the lease for us;
2670
	 * we'll remove it ourself if a delegation isn't returned
2671
	 * in time:
2672 2673
	 */
	fl->fl_break_time = 0;
L
Linus Torvalds 已提交
2674

2675
	spin_lock(&recall_lock);
2676 2677 2678
	fp->fi_had_conflict = true;
	list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
		nfsd_break_one_deleg(dp);
2679
	spin_unlock(&recall_lock);
L
Linus Torvalds 已提交
2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690
}

static
int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
{
	if (arg & F_UNLCK)
		return lease_modify(onlist, arg);
	else
		return -EAGAIN;
}

2691
static const struct lock_manager_operations nfsd_lease_mng_ops = {
J
J. Bruce Fields 已提交
2692 2693
	.lm_break = nfsd_break_deleg_cb,
	.lm_change = nfsd_change_deleg_cb,
L
Linus Torvalds 已提交
2694 2695
};

2696 2697 2698 2699 2700 2701 2702 2703 2704 2705
static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
{
	if (nfsd4_has_session(cstate))
		return nfs_ok;
	if (seqid == so->so_seqid - 1)
		return nfserr_replay_me;
	if (seqid == so->so_seqid)
		return nfs_ok;
	return nfserr_bad_seqid;
}
L
Linus Torvalds 已提交
2706

2707
__be32
A
Andy Adamson 已提交
2708
nfsd4_process_open1(struct nfsd4_compound_state *cstate,
2709
		    struct nfsd4_open *open, struct nfsd_net *nn)
L
Linus Torvalds 已提交
2710 2711 2712 2713
{
	clientid_t *clientid = &open->op_clientid;
	struct nfs4_client *clp = NULL;
	unsigned int strhashval;
2714
	struct nfs4_openowner *oo = NULL;
2715
	__be32 status;
L
Linus Torvalds 已提交
2716

2717
	if (STALE_CLIENTID(&open->op_clientid, nn))
L
Linus Torvalds 已提交
2718
		return nfserr_stale_clientid;
2719 2720 2721 2722 2723 2724 2725
	/*
	 * In case we need it later, after we've already created the
	 * file and don't want to risk a further failure:
	 */
	open->op_file = nfsd4_alloc_file();
	if (open->op_file == NULL)
		return nfserr_jukebox;
L
Linus Torvalds 已提交
2726

2727
	strhashval = ownerstr_hashval(clientid->cl_id, &open->op_owner);
2728
	oo = find_openstateowner_str(strhashval, open, cstate->minorversion, nn);
2729 2730
	open->op_openowner = oo;
	if (!oo) {
2731 2732
		clp = find_confirmed_client(clientid, cstate->minorversion,
					    nn);
L
Linus Torvalds 已提交
2733
		if (clp == NULL)
2734
			return nfserr_expired;
2735
		goto new_owner;
L
Linus Torvalds 已提交
2736
	}
2737
	if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
2738
		/* Replace unconfirmed owners without checking for replay. */
2739 2740 2741
		clp = oo->oo_owner.so_client;
		release_openowner(oo);
		open->op_openowner = NULL;
2742
		goto new_owner;
2743
	}
2744 2745 2746 2747 2748
	status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
	if (status)
		return status;
	clp = oo->oo_owner.so_client;
	goto alloc_stateid;
2749 2750 2751 2752 2753
new_owner:
	oo = alloc_init_open_stateowner(strhashval, clp, open);
	if (oo == NULL)
		return nfserr_jukebox;
	open->op_openowner = oo;
2754 2755 2756 2757
alloc_stateid:
	open->op_stp = nfs4_alloc_stateid(clp);
	if (!open->op_stp)
		return nfserr_jukebox;
2758
	return nfs_ok;
L
Linus Torvalds 已提交
2759 2760
}

2761
static inline __be32
N
NeilBrown 已提交
2762 2763 2764 2765 2766 2767 2768 2769
nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
{
	if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
		return nfserr_openmode;
	else
		return nfs_ok;
}

2770
static int share_access_to_flags(u32 share_access)
2771
{
2772
	return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2773 2774
}

2775
static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
2776
{
2777
	struct nfs4_stid *ret;
2778

2779
	ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID);
2780 2781 2782
	if (!ret)
		return NULL;
	return delegstateid(ret);
2783 2784
}

2785 2786 2787 2788 2789 2790
static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
{
	return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
	       open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
}

2791
static __be32
2792
nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,
2793 2794 2795
		struct nfs4_delegation **dp)
{
	int flags;
2796
	__be32 status = nfserr_bad_stateid;
2797

2798
	*dp = find_deleg_stateid(cl, &open->op_delegate_stateid);
2799
	if (*dp == NULL)
2800
		goto out;
2801
	flags = share_access_to_flags(open->op_share_access);
2802 2803 2804
	status = nfs4_check_delegmode(*dp, flags);
	if (status)
		*dp = NULL;
2805
out:
2806
	if (!nfsd4_is_deleg_cur(open))
2807 2808 2809
		return nfs_ok;
	if (status)
		return status;
2810
	open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
2811
	return nfs_ok;
2812 2813
}

2814
static __be32
2815
nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_ol_stateid **stpp)
L
Linus Torvalds 已提交
2816
{
2817
	struct nfs4_ol_stateid *local;
2818
	struct nfs4_openowner *oo = open->op_openowner;
L
Linus Torvalds 已提交
2819

2820
	list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
L
Linus Torvalds 已提交
2821 2822 2823 2824
		/* ignore lock owners */
		if (local->st_stateowner->so_is_open_owner == 0)
			continue;
		/* remember if we have seen this open owner */
2825
		if (local->st_stateowner == &oo->oo_owner)
L
Linus Torvalds 已提交
2826 2827 2828
			*stpp = local;
		/* check for conflicting share reservations */
		if (!test_share(local, open))
2829
			return nfserr_share_denied;
L
Linus Torvalds 已提交
2830
	}
2831
	return nfs_ok;
L
Linus Torvalds 已提交
2832 2833
}

2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844
static inline int nfs4_access_to_access(u32 nfs4_access)
{
	int flags = 0;

	if (nfs4_access & NFS4_SHARE_ACCESS_READ)
		flags |= NFSD_MAY_READ;
	if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
		flags |= NFSD_MAY_WRITE;
	return flags;
}

2845 2846
static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
		struct svc_fh *cur_fh, struct nfsd4_open *open)
2847 2848
{
	__be32 status;
2849 2850 2851
	int oflag = nfs4_access_to_omode(open->op_share_access);
	int access = nfs4_access_to_access(open->op_share_access);

2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862
	if (!fp->fi_fds[oflag]) {
		status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
			&fp->fi_fds[oflag]);
		if (status)
			return status;
	}
	nfs4_file_get_access(fp, oflag);

	return nfs_ok;
}

2863
static inline __be32
L
Linus Torvalds 已提交
2864 2865 2866 2867 2868 2869 2870 2871 2872 2873
nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
		struct nfsd4_open *open)
{
	struct iattr iattr = {
		.ia_valid = ATTR_SIZE,
		.ia_size = 0,
	};
	if (!open->op_truncate)
		return 0;
	if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
2874
		return nfserr_inval;
L
Linus Torvalds 已提交
2875 2876 2877
	return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
}

2878
static __be32
2879
nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp, struct nfsd4_open *open)
L
Linus Torvalds 已提交
2880
{
2881
	u32 op_share_access = open->op_share_access;
2882
	bool new_access;
2883
	__be32 status;
L
Linus Torvalds 已提交
2884

2885
	new_access = !test_access(op_share_access, stp);
2886
	if (new_access) {
2887
		status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
2888 2889
		if (status)
			return status;
2890
	}
L
Linus Torvalds 已提交
2891 2892
	status = nfsd4_truncate(rqstp, cur_fh, open);
	if (status) {
2893
		if (new_access) {
2894
			int oflag = nfs4_access_to_omode(op_share_access);
2895 2896
			nfs4_file_put_access(fp, oflag);
		}
L
Linus Torvalds 已提交
2897 2898 2899
		return status;
	}
	/* remember the open */
2900
	set_access(op_share_access, stp);
2901
	set_deny(open->op_share_deny, stp);
L
Linus Torvalds 已提交
2902 2903 2904 2905 2906 2907

	return nfs_ok;
}


static void
2908
nfs4_set_claim_prev(struct nfsd4_open *open, bool has_session)
L
Linus Torvalds 已提交
2909
{
2910
	open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
L
Linus Torvalds 已提交
2911 2912
}

2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925
/* Should we give out recallable state?: */
static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
{
	if (clp->cl_cb_state == NFSD4_CB_UP)
		return true;
	/*
	 * In the sessions case, since we don't have to establish a
	 * separate connection for callbacks, we assume it's OK
	 * until we hear otherwise:
	 */
	return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
}

2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937
static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
{
	struct file_lock *fl;

	fl = locks_alloc_lock();
	if (!fl)
		return NULL;
	locks_init_lock(fl);
	fl->fl_lmops = &nfsd_lease_mng_ops;
	fl->fl_flags = FL_LEASE;
	fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
	fl->fl_end = OFFSET_MAX;
2938
	fl->fl_owner = (fl_owner_t)(dp->dl_file);
2939 2940 2941 2942
	fl->fl_pid = current->tgid;
	return fl;
}

2943 2944
static int nfs4_setlease(struct nfs4_delegation *dp, int flag)
{
2945
	struct nfs4_file *fp = dp->dl_file;
2946 2947 2948 2949 2950 2951
	struct file_lock *fl;
	int status;

	fl = nfs4_alloc_init_lease(dp, flag);
	if (!fl)
		return -ENOMEM;
2952
	fl->fl_file = find_readable_file(fp);
2953
	list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
2954
	status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
2955
	if (status) {
2956
		list_del_init(&dp->dl_perclnt);
2957 2958 2959
		locks_free_lock(fl);
		return -ENOMEM;
	}
2960
	fp->fi_lease = fl;
A
Al Viro 已提交
2961
	fp->fi_deleg_file = get_file(fl->fl_file);
2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980
	atomic_set(&fp->fi_delegees, 1);
	list_add(&dp->dl_perfile, &fp->fi_delegations);
	return 0;
}

static int nfs4_set_delegation(struct nfs4_delegation *dp, int flag)
{
	struct nfs4_file *fp = dp->dl_file;

	if (!fp->fi_lease)
		return nfs4_setlease(dp, flag);
	spin_lock(&recall_lock);
	if (fp->fi_had_conflict) {
		spin_unlock(&recall_lock);
		return -EAGAIN;
	}
	atomic_inc(&fp->fi_delegees);
	list_add(&dp->dl_perfile, &fp->fi_delegations);
	spin_unlock(&recall_lock);
2981
	list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
2982 2983 2984
	return 0;
}

2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000
static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
{
	open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
	if (status == -EAGAIN)
		open->op_why_no_deleg = WND4_CONTENTION;
	else {
		open->op_why_no_deleg = WND4_RESOURCE;
		switch (open->op_deleg_want) {
		case NFS4_SHARE_WANT_READ_DELEG:
		case NFS4_SHARE_WANT_WRITE_DELEG:
		case NFS4_SHARE_WANT_ANY_DELEG:
			break;
		case NFS4_SHARE_WANT_CANCEL:
			open->op_why_no_deleg = WND4_CANCELLED;
			break;
		case NFS4_SHARE_WANT_NO_DELEG:
3001
			WARN_ON_ONCE(1);
3002 3003 3004 3005
		}
	}
}

L
Linus Torvalds 已提交
3006 3007 3008 3009
/*
 * Attempt to hand out a delegation.
 */
static void
3010 3011
nfs4_open_delegation(struct net *net, struct svc_fh *fh,
		     struct nfsd4_open *open, struct nfs4_ol_stateid *stp)
L
Linus Torvalds 已提交
3012 3013
{
	struct nfs4_delegation *dp;
3014
	struct nfs4_openowner *oo = container_of(stp->st_stateowner, struct nfs4_openowner, oo_owner);
3015
	int cb_up;
3016
	int status = 0, flag = 0;
L
Linus Torvalds 已提交
3017

3018
	cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
L
Linus Torvalds 已提交
3019
	flag = NFS4_OPEN_DELEGATE_NONE;
3020 3021 3022
	open->op_recall = 0;
	switch (open->op_claim_type) {
		case NFS4_OPEN_CLAIM_PREVIOUS:
3023
			if (!cb_up)
3024 3025 3026 3027 3028 3029 3030 3031
				open->op_recall = 1;
			flag = open->op_delegate_type;
			if (flag == NFS4_OPEN_DELEGATE_NONE)
				goto out;
			break;
		case NFS4_OPEN_CLAIM_NULL:
			/* Let's not give out any delegations till everyone's
			 * had the chance to reclaim theirs.... */
3032
			if (locks_in_grace(net))
3033
				goto out;
3034
			if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
3035 3036 3037 3038 3039 3040 3041 3042 3043
				goto out;
			if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
				flag = NFS4_OPEN_DELEGATE_WRITE;
			else
				flag = NFS4_OPEN_DELEGATE_READ;
			break;
		default:
			goto out;
	}
L
Linus Torvalds 已提交
3044

3045
	dp = alloc_init_deleg(oo->oo_owner.so_client, stp, fh, flag);
3046 3047
	if (dp == NULL)
		goto out_no_deleg;
3048
	status = nfs4_set_delegation(dp, flag);
3049
	if (status)
3050
		goto out_free;
L
Linus Torvalds 已提交
3051

3052
	memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
L
Linus Torvalds 已提交
3053

3054
	dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
3055
		STATEID_VAL(&dp->dl_stid.sc_stateid));
L
Linus Torvalds 已提交
3056 3057
out:
	open->op_delegate_type = flag;
3058 3059 3060 3061 3062
	if (flag == NFS4_OPEN_DELEGATE_NONE) {
		if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
		    open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
			dprintk("NFSD: WARNING: refusing delegation reclaim\n");

3063 3064 3065
		/* 4.1 client asking for a delegation? */
		if (open->op_deleg_want)
			nfsd4_open_deleg_none_ext(open, status);
3066
	}
3067 3068
	return;
out_free:
3069
	unhash_stid(&dp->dl_stid);
3070
	nfs4_put_delegation(dp);
3071 3072 3073
out_no_deleg:
	flag = NFS4_OPEN_DELEGATE_NONE;
	goto out;
L
Linus Torvalds 已提交
3074 3075
}

3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093
static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
					struct nfs4_delegation *dp)
{
	if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
	    dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
		open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
		open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
	} else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
		   dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
		open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
		open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
	}
	/* Otherwise the client must be confused wanting a delegation
	 * it already has, therefore we don't return
	 * NFS4_OPEN_DELEGATE_NONE_EXT and reason.
	 */
}

L
Linus Torvalds 已提交
3094 3095 3096
/*
 * called with nfs4_lock_state() held.
 */
3097
__be32
L
Linus Torvalds 已提交
3098 3099
nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
{
A
Andy Adamson 已提交
3100
	struct nfsd4_compoundres *resp = rqstp->rq_resp;
3101
	struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
L
Linus Torvalds 已提交
3102 3103
	struct nfs4_file *fp = NULL;
	struct inode *ino = current_fh->fh_dentry->d_inode;
3104
	struct nfs4_ol_stateid *stp = NULL;
3105
	struct nfs4_delegation *dp = NULL;
3106
	__be32 status;
L
Linus Torvalds 已提交
3107 3108 3109 3110 3111 3112 3113 3114 3115 3116

	/*
	 * Lookup file; if found, lookup stateid and check open request,
	 * and check for delegations in the process of being recalled.
	 * If not found, create the nfs4_file struct
	 */
	fp = find_file(ino);
	if (fp) {
		if ((status = nfs4_check_open(fp, open, &stp)))
			goto out;
3117
		status = nfs4_check_deleg(cl, open, &dp);
3118 3119
		if (status)
			goto out;
L
Linus Torvalds 已提交
3120
	} else {
3121
		status = nfserr_bad_stateid;
3122
		if (nfsd4_is_deleg_cur(open))
3123
			goto out;
3124
		status = nfserr_jukebox;
3125 3126 3127
		fp = open->op_file;
		open->op_file = NULL;
		nfsd4_init_file(fp, ino);
L
Linus Torvalds 已提交
3128 3129 3130 3131 3132 3133 3134 3135
	}

	/*
	 * OPEN the file, or upgrade an existing OPEN.
	 * If truncate fails, the OPEN fails.
	 */
	if (stp) {
		/* Stateid was found, this is an OPEN upgrade */
3136
		status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
L
Linus Torvalds 已提交
3137 3138 3139
		if (status)
			goto out;
	} else {
3140
		status = nfs4_get_vfs_file(rqstp, fp, current_fh, open);
J
J. Bruce Fields 已提交
3141 3142 3143
		if (status)
			goto out;
		status = nfsd4_truncate(rqstp, current_fh, open);
3144
		if (status)
L
Linus Torvalds 已提交
3145
			goto out;
3146 3147
		stp = open->op_stp;
		open->op_stp = NULL;
3148
		init_open_stateid(stp, fp, open);
L
Linus Torvalds 已提交
3149
	}
3150 3151
	update_stateid(&stp->st_stid.sc_stateid);
	memcpy(&open->op_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
L
Linus Torvalds 已提交
3152

3153
	if (nfsd4_has_session(&resp->cstate)) {
3154
		open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
A
Andy Adamson 已提交
3155

3156 3157 3158 3159 3160 3161 3162
		if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
			open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
			open->op_why_no_deleg = WND4_NOT_WANTED;
			goto nodeleg;
		}
	}

L
Linus Torvalds 已提交
3163 3164 3165 3166
	/*
	* Attempt to hand out a delegation. No error return, because the
	* OPEN succeeds even if we fail.
	*/
3167
	nfs4_open_delegation(SVC_NET(rqstp), current_fh, open, stp);
3168
nodeleg:
L
Linus Torvalds 已提交
3169 3170
	status = nfs_ok;

3171
	dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
3172
		STATEID_VAL(&stp->st_stid.sc_stateid));
L
Linus Torvalds 已提交
3173
out:
3174 3175
	/* 4.1 client trying to upgrade/downgrade delegation? */
	if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
3176 3177
	    open->op_deleg_want)
		nfsd4_deleg_xgrade_none_ext(open, dp);
3178

3179 3180
	if (fp)
		put_nfs4_file(fp);
3181
	if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
3182
		nfs4_set_claim_prev(open, nfsd4_has_session(&resp->cstate));
L
Linus Torvalds 已提交
3183 3184 3185 3186
	/*
	* To finish the open response, we just need to set the rflags.
	*/
	open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
3187
	if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED) &&
A
Andy Adamson 已提交
3188
	    !nfsd4_has_session(&resp->cstate))
L
Linus Torvalds 已提交
3189 3190 3191 3192 3193
		open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;

	return status;
}

3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208
void nfsd4_cleanup_open_state(struct nfsd4_open *open, __be32 status)
{
	if (open->op_openowner) {
		struct nfs4_openowner *oo = open->op_openowner;

		if (!list_empty(&oo->oo_owner.so_stateids))
			list_del_init(&oo->oo_close_lru);
		if (oo->oo_flags & NFS4_OO_NEW) {
			if (status) {
				release_openowner(oo);
				open->op_openowner = NULL;
			} else
				oo->oo_flags &= ~NFS4_OO_NEW;
		}
	}
3209 3210
	if (open->op_file)
		nfsd4_free_file(open->op_file);
3211
	if (open->op_stp)
3212
		free_generic_stateid(open->op_stp);
3213 3214
}

3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226
static __be32 lookup_clientid(clientid_t *clid, bool session, struct nfsd_net *nn, struct nfs4_client **clp)
{
	struct nfs4_client *found;

	if (STALE_CLIENTID(clid, nn))
		return nfserr_stale_clientid;
	found = find_confirmed_client(clid, session, nn);
	if (clp)
		*clp = found;
	return found ? nfs_ok : nfserr_expired;
}

3227
__be32
3228 3229
nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	    clientid_t *clid)
L
Linus Torvalds 已提交
3230 3231
{
	struct nfs4_client *clp;
3232
	__be32 status;
3233
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
L
Linus Torvalds 已提交
3234 3235 3236 3237

	nfs4_lock_state();
	dprintk("process_renew(%08x/%08x): starting\n", 
			clid->cl_boot, clid->cl_id);
3238 3239
	status = lookup_clientid(clid, cstate->minorversion, nn, &clp);
	if (status)
L
Linus Torvalds 已提交
3240 3241
		goto out;
	status = nfserr_cb_path_down;
3242
	if (!list_empty(&clp->cl_delegations)
3243
			&& clp->cl_cb_state != NFSD4_CB_UP)
L
Linus Torvalds 已提交
3244 3245 3246 3247 3248 3249 3250
		goto out;
	status = nfs_ok;
out:
	nfs4_unlock_state();
	return status;
}

3251
static void
3252
nfsd4_end_grace(struct nfsd_net *nn)
3253
{
3254
	/* do nothing if grace period already ended */
3255
	if (nn->grace_ended)
3256 3257
		return;

3258
	dprintk("NFSD: end of grace period\n");
3259
	nn->grace_ended = true;
3260
	nfsd4_record_grace_done(nn, nn->boot_time);
3261
	locks_end_grace(&nn->nfsd4_manager);
3262 3263 3264 3265 3266
	/*
	 * Now that every NFSv4 client has had the chance to recover and
	 * to see the (possibly new, possibly shorter) lease time, we
	 * can safely set the next grace time to the current lease time:
	 */
3267
	nn->nfsd4_grace = nn->nfsd4_lease;
3268 3269
}

3270
static time_t
3271
nfs4_laundromat(struct nfsd_net *nn)
L
Linus Torvalds 已提交
3272 3273
{
	struct nfs4_client *clp;
3274
	struct nfs4_openowner *oo;
L
Linus Torvalds 已提交
3275 3276
	struct nfs4_delegation *dp;
	struct list_head *pos, *next, reaplist;
3277 3278 3279
	time_t cutoff = get_seconds() - nn->nfsd4_lease;
	time_t t, clientid_val = nn->nfsd4_lease;
	time_t u, test_val = nn->nfsd4_lease;
L
Linus Torvalds 已提交
3280 3281 3282 3283

	nfs4_lock_state();

	dprintk("NFSD: laundromat service - starting\n");
3284
	nfsd4_end_grace(nn);
3285
	INIT_LIST_HEAD(&reaplist);
3286
	spin_lock(&nn->client_lock);
3287
	list_for_each_safe(pos, next, &nn->client_lru) {
L
Linus Torvalds 已提交
3288 3289 3290 3291 3292 3293 3294
		clp = list_entry(pos, struct nfs4_client, cl_lru);
		if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
			t = clp->cl_time - cutoff;
			if (clientid_val > t)
				clientid_val = t;
			break;
		}
3295
		if (mark_client_expired_locked(clp)) {
3296 3297 3298 3299
			dprintk("NFSD: client in use (clientid %08x)\n",
				clp->cl_clientid.cl_id);
			continue;
		}
3300
		list_move(&clp->cl_lru, &reaplist);
3301
	}
3302
	spin_unlock(&nn->client_lock);
3303 3304
	list_for_each_safe(pos, next, &reaplist) {
		clp = list_entry(pos, struct nfs4_client, cl_lru);
L
Linus Torvalds 已提交
3305 3306 3307 3308 3309
		dprintk("NFSD: purging unused client (clientid %08x)\n",
			clp->cl_clientid.cl_id);
		expire_client(clp);
	}
	spin_lock(&recall_lock);
3310
	list_for_each_safe(pos, next, &nn->del_recall_lru) {
L
Linus Torvalds 已提交
3311
		dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3312 3313
		if (net_generic(dp->dl_stid.sc_client->net, nfsd_net_id) != nn)
			continue;
L
Linus Torvalds 已提交
3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324
		if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
			u = dp->dl_time - cutoff;
			if (test_val > u)
				test_val = u;
			break;
		}
		list_move(&dp->dl_recall_lru, &reaplist);
	}
	spin_unlock(&recall_lock);
	list_for_each_safe(pos, next, &reaplist) {
		dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3325
		revoke_delegation(dp);
L
Linus Torvalds 已提交
3326
	}
3327
	test_val = nn->nfsd4_lease;
3328
	list_for_each_safe(pos, next, &nn->close_lru) {
3329 3330 3331
		oo = container_of(pos, struct nfs4_openowner, oo_close_lru);
		if (time_after((unsigned long)oo->oo_time, (unsigned long)cutoff)) {
			u = oo->oo_time - cutoff;
L
Linus Torvalds 已提交
3332 3333 3334 3335
			if (test_val > u)
				test_val = u;
			break;
		}
3336
		release_openowner(oo);
L
Linus Torvalds 已提交
3337 3338 3339 3340 3341 3342 3343
	}
	if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
		clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
	nfs4_unlock_state();
	return clientid_val;
}

H
Harvey Harrison 已提交
3344 3345 3346 3347
static struct workqueue_struct *laundry_wq;
static void laundromat_main(struct work_struct *);

static void
3348
laundromat_main(struct work_struct *laundry)
L
Linus Torvalds 已提交
3349 3350
{
	time_t t;
3351 3352 3353 3354
	struct delayed_work *dwork = container_of(laundry, struct delayed_work,
						  work);
	struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
					   laundromat_work);
L
Linus Torvalds 已提交
3355

3356
	t = nfs4_laundromat(nn);
L
Linus Torvalds 已提交
3357
	dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
3358
	queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ);
L
Linus Torvalds 已提交
3359 3360
}

3361
static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_ol_stateid *stp)
L
Linus Torvalds 已提交
3362
{
3363 3364 3365
	if (fhp->fh_dentry->d_inode != stp->st_file->fi_inode)
		return nfserr_bad_stateid;
	return nfs_ok;
L
Linus Torvalds 已提交
3366 3367 3368
}

static inline int
3369
access_permit_read(struct nfs4_ol_stateid *stp)
L
Linus Torvalds 已提交
3370
{
3371 3372 3373
	return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
		test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
		test_access(NFS4_SHARE_ACCESS_WRITE, stp);
L
Linus Torvalds 已提交
3374 3375 3376
}

static inline int
3377
access_permit_write(struct nfs4_ol_stateid *stp)
L
Linus Torvalds 已提交
3378
{
3379 3380
	return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
		test_access(NFS4_SHARE_ACCESS_BOTH, stp);
L
Linus Torvalds 已提交
3381 3382 3383
}

static
3384
__be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
L
Linus Torvalds 已提交
3385
{
3386
        __be32 status = nfserr_openmode;
L
Linus Torvalds 已提交
3387

3388 3389 3390
	/* For lock stateid's, we test the parent open, not the lock: */
	if (stp->st_openstp)
		stp = stp->st_openstp;
3391
	if ((flags & WR_STATE) && !access_permit_write(stp))
L
Linus Torvalds 已提交
3392
                goto out;
3393
	if ((flags & RD_STATE) && !access_permit_read(stp))
L
Linus Torvalds 已提交
3394 3395 3396 3397 3398 3399
                goto out;
	status = nfs_ok;
out:
	return status;
}

3400
static inline __be32
3401
check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags)
L
Linus Torvalds 已提交
3402
{
3403
	if (ONE_STATEID(stateid) && (flags & RD_STATE))
L
Linus Torvalds 已提交
3404
		return nfs_ok;
3405
	else if (locks_in_grace(net)) {
L
Lucas De Marchi 已提交
3406
		/* Answer in remaining cases depends on existence of
L
Linus Torvalds 已提交
3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421
		 * conflicting state; so we must wait out the grace period. */
		return nfserr_grace;
	} else if (flags & WR_STATE)
		return nfs4_share_conflict(current_fh,
				NFS4_SHARE_DENY_WRITE);
	else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
		return nfs4_share_conflict(current_fh,
				NFS4_SHARE_DENY_READ);
}

/*
 * Allow READ/WRITE during grace period on recovered state only for files
 * that are not able to provide mandatory locking.
 */
static inline int
3422
grace_disallows_io(struct net *net, struct inode *inode)
L
Linus Torvalds 已提交
3423
{
3424
	return locks_in_grace(net) && mandatory_lock(inode);
L
Linus Torvalds 已提交
3425 3426
}

3427 3428 3429 3430 3431 3432
/* Returns true iff a is later than b: */
static bool stateid_generation_after(stateid_t *a, stateid_t *b)
{
	return (s32)a->si_generation - (s32)b->si_generation > 0;
}

J
J. Bruce Fields 已提交
3433
static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
3434
{
A
Andy Adamson 已提交
3435 3436 3437 3438
	/*
	 * When sessions are used the stateid generation number is ignored
	 * when it is zero.
	 */
J
J. Bruce Fields 已提交
3439
	if (has_session && in->si_generation == 0)
3440 3441 3442 3443
		return nfs_ok;

	if (in->si_generation == ref->si_generation)
		return nfs_ok;
A
Andy Adamson 已提交
3444

3445
	/* If the client sends us a stateid from the future, it's buggy: */
3446
	if (stateid_generation_after(in, ref))
3447 3448
		return nfserr_bad_stateid;
	/*
3449 3450 3451 3452 3453 3454 3455 3456
	 * However, we could see a stateid from the past, even from a
	 * non-buggy client.  For example, if the client sends a lock
	 * while some IO is outstanding, the lock may bump si_generation
	 * while the IO is still in flight.  The client could avoid that
	 * situation by waiting for responses on all the IO requests,
	 * but better performance may result in retrying IO that
	 * receives an old_stateid error if requests are rarely
	 * reordered in flight:
3457
	 */
3458
	return nfserr_old_stateid;
3459 3460
}

3461
static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
3462
{
3463 3464 3465
	struct nfs4_stid *s;
	struct nfs4_ol_stateid *ols;
	__be32 status;
3466

3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477
	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
		return nfserr_bad_stateid;
	/* Client debugging aid. */
	if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid)) {
		char addr_str[INET6_ADDRSTRLEN];
		rpc_ntop((struct sockaddr *)&cl->cl_addr, addr_str,
				 sizeof(addr_str));
		pr_warn_ratelimited("NFSD: client %s testing state ID "
					"with incorrect client ID\n", addr_str);
		return nfserr_bad_stateid;
	}
3478
	s = find_stateid(cl, stateid);
3479
	if (!s)
3480
		return nfserr_bad_stateid;
3481
	status = check_stateid_generation(stateid, &s->sc_stateid, 1);
3482
	if (status)
3483
		return status;
3484 3485
	switch (s->sc_type) {
	case NFS4_DELEG_STID:
3486
		return nfs_ok;
3487 3488
	case NFS4_REVOKED_DELEG_STID:
		return nfserr_deleg_revoked;
3489 3490 3491 3492 3493 3494 3495
	case NFS4_OPEN_STID:
	case NFS4_LOCK_STID:
		ols = openlockstateid(s);
		if (ols->st_stateowner->so_is_open_owner
	    			&& !(openowner(ols->st_stateowner)->oo_flags
						& NFS4_OO_CONFIRMED))
			return nfserr_bad_stateid;
3496
		return nfs_ok;
3497 3498 3499
	default:
		printk("unknown stateid type %x\n", s->sc_type);
	case NFS4_CLOSED_STID:
3500
		return nfserr_bad_stateid;
3501
	}
3502 3503
}

3504 3505 3506
static __be32 nfsd4_lookup_stateid(stateid_t *stateid, unsigned char typemask,
				   struct nfs4_stid **s, bool sessions,
				   struct nfsd_net *nn)
3507 3508
{
	struct nfs4_client *cl;
J
J. Bruce Fields 已提交
3509
	__be32 status;
3510 3511 3512

	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
		return nfserr_bad_stateid;
J
J. Bruce Fields 已提交
3513 3514 3515
	status = lookup_clientid(&stateid->si_opaque.so_clid, sessions,
							nn, &cl);
	if (status == nfserr_stale_clientid)
3516
		return nfserr_stale_stateid;
J
J. Bruce Fields 已提交
3517 3518
	if (status)
		return status;
3519 3520 3521 3522 3523 3524
	*s = find_stateid_by_type(cl, stateid, typemask);
	if (!*s)
		return nfserr_bad_stateid;
	return nfs_ok;
}

L
Linus Torvalds 已提交
3525 3526 3527
/*
* Checks for stateid operations
*/
3528
__be32
3529
nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
3530
			   stateid_t *stateid, int flags, struct file **filpp)
L
Linus Torvalds 已提交
3531
{
3532
	struct nfs4_stid *s;
3533
	struct nfs4_ol_stateid *stp = NULL;
L
Linus Torvalds 已提交
3534
	struct nfs4_delegation *dp = NULL;
3535
	struct svc_fh *current_fh = &cstate->current_fh;
L
Linus Torvalds 已提交
3536
	struct inode *ino = current_fh->fh_dentry->d_inode;
3537
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
3538
	__be32 status;
L
Linus Torvalds 已提交
3539 3540 3541 3542

	if (filpp)
		*filpp = NULL;

3543
	if (grace_disallows_io(net, ino))
L
Linus Torvalds 已提交
3544 3545 3546
		return nfserr_grace;

	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3547
		return check_special_stateids(net, current_fh, stateid, flags);
L
Linus Torvalds 已提交
3548

3549 3550
	status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID,
				      &s, cstate->minorversion, nn);
3551 3552
	if (status)
		return status;
3553 3554 3555
	status = check_stateid_generation(stateid, &s->sc_stateid, nfsd4_has_session(cstate));
	if (status)
		goto out;
3556 3557
	switch (s->sc_type) {
	case NFS4_DELEG_STID:
3558
		dp = delegstateid(s);
3559 3560 3561
		status = nfs4_check_delegmode(dp, flags);
		if (status)
			goto out;
3562
		if (filpp) {
3563
			*filpp = dp->dl_file->fi_deleg_file;
3564 3565 3566 3567 3568
			if (!*filpp) {
				WARN_ON_ONCE(1);
				status = nfserr_serverfault;
				goto out;
			}
3569
		}
3570 3571 3572
		break;
	case NFS4_OPEN_STID:
	case NFS4_LOCK_STID:
3573
		stp = openlockstateid(s);
3574 3575
		status = nfs4_check_fh(current_fh, stp);
		if (status)
L
Linus Torvalds 已提交
3576
			goto out;
3577
		if (stp->st_stateowner->so_is_open_owner
3578
		    && !(openowner(stp->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
L
Linus Torvalds 已提交
3579
			goto out;
3580 3581
		status = nfs4_check_openmode(stp, flags);
		if (status)
L
Linus Torvalds 已提交
3582
			goto out;
3583 3584 3585 3586 3587 3588
		if (filpp) {
			if (flags & RD_STATE)
				*filpp = find_readable_file(stp->st_file);
			else
				*filpp = find_writeable_file(stp->st_file);
		}
3589 3590 3591
		break;
	default:
		return nfserr_bad_stateid;
L
Linus Torvalds 已提交
3592 3593 3594 3595 3596 3597
	}
	status = nfs_ok;
out:
	return status;
}

3598
static __be32
3599
nfsd4_free_lock_stateid(struct nfs4_ol_stateid *stp)
3600
{
3601
	if (check_for_locks(stp->st_file, lockowner(stp->st_stateowner)))
3602 3603 3604 3605 3606
		return nfserr_locks_held;
	release_lock_stateid(stp);
	return nfs_ok;
}

3607 3608 3609 3610 3611 3612 3613
/*
 * Test if the stateid is valid
 */
__be32
nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
		   struct nfsd4_test_stateid *test_stateid)
{
3614 3615 3616 3617 3618
	struct nfsd4_test_stateid_id *stateid;
	struct nfs4_client *cl = cstate->session->se_client;

	nfs4_lock_state();
	list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
3619 3620
		stateid->ts_id_status =
			nfsd4_validate_stateid(cl, &stateid->ts_id_stateid);
3621 3622
	nfs4_unlock_state();

3623 3624 3625
	return nfs_ok;
}

3626 3627 3628 3629 3630
__be32
nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
		   struct nfsd4_free_stateid *free_stateid)
{
	stateid_t *stateid = &free_stateid->fr_stateid;
J
J. Bruce Fields 已提交
3631
	struct nfs4_stid *s;
3632
	struct nfs4_delegation *dp;
3633
	struct nfs4_client *cl = cstate->session->se_client;
J
J. Bruce Fields 已提交
3634
	__be32 ret = nfserr_bad_stateid;
3635 3636

	nfs4_lock_state();
3637
	s = find_stateid(cl, stateid);
J
J. Bruce Fields 已提交
3638
	if (!s)
3639
		goto out;
J
J. Bruce Fields 已提交
3640 3641
	switch (s->sc_type) {
	case NFS4_DELEG_STID:
3642 3643
		ret = nfserr_locks_held;
		goto out;
J
J. Bruce Fields 已提交
3644 3645 3646 3647 3648 3649 3650 3651 3652
	case NFS4_OPEN_STID:
	case NFS4_LOCK_STID:
		ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
		if (ret)
			goto out;
		if (s->sc_type == NFS4_LOCK_STID)
			ret = nfsd4_free_lock_stateid(openlockstateid(s));
		else
			ret = nfserr_locks_held;
3653
		break;
3654 3655 3656 3657 3658
	case NFS4_REVOKED_DELEG_STID:
		dp = delegstateid(s);
		destroy_revoked_delegation(dp);
		ret = nfs_ok;
		break;
3659 3660
	default:
		ret = nfserr_bad_stateid;
3661 3662 3663 3664 3665 3666
	}
out:
	nfs4_unlock_state();
	return ret;
}

3667 3668 3669 3670 3671 3672
static inline int
setlkflg (int type)
{
	return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
		RD_STATE : WR_STATE;
}
L
Linus Torvalds 已提交
3673

3674
static __be32 nfs4_seqid_op_checks(struct nfsd4_compound_state *cstate, stateid_t *stateid, u32 seqid, struct nfs4_ol_stateid *stp)
3675 3676 3677 3678 3679 3680 3681 3682
{
	struct svc_fh *current_fh = &cstate->current_fh;
	struct nfs4_stateowner *sop = stp->st_stateowner;
	__be32 status;

	status = nfsd4_check_seqid(cstate, sop, seqid);
	if (status)
		return status;
3683 3684
	if (stp->st_stid.sc_type == NFS4_CLOSED_STID
		|| stp->st_stid.sc_type == NFS4_REVOKED_DELEG_STID)
3685 3686
		/*
		 * "Closed" stateid's exist *only* to return
3687 3688
		 * nfserr_replay_me from the previous step, and
		 * revoked delegations are kept only for free_stateid.
3689 3690 3691 3692 3693 3694
		 */
		return nfserr_bad_stateid;
	status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
	if (status)
		return status;
	return nfs4_check_fh(current_fh, stp);
3695 3696
}

L
Linus Torvalds 已提交
3697 3698 3699
/* 
 * Checks for sequence id mutating operations. 
 */
3700
static __be32
3701
nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3702
			 stateid_t *stateid, char typemask,
3703 3704
			 struct nfs4_ol_stateid **stpp,
			 struct nfsd_net *nn)
L
Linus Torvalds 已提交
3705
{
3706
	__be32 status;
3707
	struct nfs4_stid *s;
L
Linus Torvalds 已提交
3708

3709 3710
	dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
		seqid, STATEID_VAL(stateid));
3711

L
Linus Torvalds 已提交
3712
	*stpp = NULL;
3713 3714
	status = nfsd4_lookup_stateid(stateid, typemask, &s,
				      cstate->minorversion, nn);
3715 3716
	if (status)
		return status;
3717
	*stpp = openlockstateid(s);
3718 3719
	if (!nfsd4_has_session(cstate))
		cstate->replay_owner = (*stpp)->st_stateowner;
L
Linus Torvalds 已提交
3720

3721 3722
	return nfs4_seqid_op_checks(cstate, stateid, seqid, *stpp);
}
3723

3724 3725
static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
						 stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn)
3726 3727 3728
{
	__be32 status;
	struct nfs4_openowner *oo;
L
Linus Torvalds 已提交
3729

3730
	status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
3731
						NFS4_OPEN_STID, stpp, nn);
3732 3733
	if (status)
		return status;
3734
	oo = openowner((*stpp)->st_stateowner);
3735
	if (!(oo->oo_flags & NFS4_OO_CONFIRMED))
3736 3737
		return nfserr_bad_stateid;
	return nfs_ok;
L
Linus Torvalds 已提交
3738 3739
}

3740
__be32
3741
nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3742
		   struct nfsd4_open_confirm *oc)
L
Linus Torvalds 已提交
3743
{
3744
	__be32 status;
3745
	struct nfs4_openowner *oo;
3746
	struct nfs4_ol_stateid *stp;
3747
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
L
Linus Torvalds 已提交
3748 3749

	dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
3750 3751
			(int)cstate->current_fh.fh_dentry->d_name.len,
			cstate->current_fh.fh_dentry->d_name.name);
L
Linus Torvalds 已提交
3752

3753
	status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
3754 3755
	if (status)
		return status;
L
Linus Torvalds 已提交
3756 3757 3758

	nfs4_lock_state();

3759
	status = nfs4_preprocess_seqid_op(cstate,
3760
					oc->oc_seqid, &oc->oc_req_stateid,
3761
					NFS4_OPEN_STID, &stp, nn);
3762
	if (status)
3763
		goto out;
3764
	oo = openowner(stp->st_stateowner);
3765
	status = nfserr_bad_stateid;
3766
	if (oo->oo_flags & NFS4_OO_CONFIRMED)
3767
		goto out;
3768
	oo->oo_flags |= NFS4_OO_CONFIRMED;
3769 3770
	update_stateid(&stp->st_stid.sc_stateid);
	memcpy(&oc->oc_resp_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
3771
	dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
3772
		__func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid));
3773

3774
	nfsd4_client_record_create(oo->oo_owner.so_client);
3775
	status = nfs_ok;
L
Linus Torvalds 已提交
3776
out:
3777
	nfsd4_bump_seqid(cstate, status);
3778 3779
	if (!cstate->replay_owner)
		nfs4_unlock_state();
L
Linus Torvalds 已提交
3780 3781 3782
	return status;
}

J
J. Bruce Fields 已提交
3783
static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
L
Linus Torvalds 已提交
3784
{
3785
	if (!test_access(access, stp))
J
J. Bruce Fields 已提交
3786 3787
		return;
	nfs4_file_put_access(stp->st_file, nfs4_access_to_omode(access));
3788
	clear_access(access, stp);
J
J. Bruce Fields 已提交
3789
}
3790

J
J. Bruce Fields 已提交
3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804
static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
{
	switch (to_access) {
	case NFS4_SHARE_ACCESS_READ:
		nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
		nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
		break;
	case NFS4_SHARE_ACCESS_WRITE:
		nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
		nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
		break;
	case NFS4_SHARE_ACCESS_BOTH:
		break;
	default:
3805
		WARN_ON_ONCE(1);
L
Linus Torvalds 已提交
3806 3807 3808 3809
	}
}

static void
3810
reset_union_bmap_deny(unsigned long deny, struct nfs4_ol_stateid *stp)
L
Linus Torvalds 已提交
3811 3812 3813 3814
{
	int i;
	for (i = 0; i < 4; i++) {
		if ((i & deny) != i)
3815
			clear_deny(i, stp);
L
Linus Torvalds 已提交
3816 3817 3818
	}
}

3819
__be32
3820 3821
nfsd4_open_downgrade(struct svc_rqst *rqstp,
		     struct nfsd4_compound_state *cstate,
3822
		     struct nfsd4_open_downgrade *od)
L
Linus Torvalds 已提交
3823
{
3824
	__be32 status;
3825
	struct nfs4_ol_stateid *stp;
3826
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
L
Linus Torvalds 已提交
3827 3828

	dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n", 
3829 3830
			(int)cstate->current_fh.fh_dentry->d_name.len,
			cstate->current_fh.fh_dentry->d_name.name);
L
Linus Torvalds 已提交
3831

3832
	/* We don't yet support WANT bits: */
3833 3834 3835
	if (od->od_deleg_want)
		dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
			od->od_deleg_want);
L
Linus Torvalds 已提交
3836 3837

	nfs4_lock_state();
3838
	status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
3839
					&od->od_stateid, &stp, nn);
3840
	if (status)
L
Linus Torvalds 已提交
3841 3842
		goto out; 
	status = nfserr_inval;
3843 3844
	if (!test_access(od->od_share_access, stp)) {
		dprintk("NFSD: access not a subset current bitmap: 0x%lx, input access=%08x\n",
L
Linus Torvalds 已提交
3845 3846 3847
			stp->st_access_bmap, od->od_share_access);
		goto out;
	}
3848
	if (!test_deny(od->od_share_deny, stp)) {
L
Linus Torvalds 已提交
3849 3850 3851 3852
		dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
			stp->st_deny_bmap, od->od_share_deny);
		goto out;
	}
J
J. Bruce Fields 已提交
3853
	nfs4_stateid_downgrade(stp, od->od_share_access);
L
Linus Torvalds 已提交
3854

3855
	reset_union_bmap_deny(od->od_share_deny, stp);
L
Linus Torvalds 已提交
3856

3857 3858
	update_stateid(&stp->st_stid.sc_stateid);
	memcpy(&od->od_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
L
Linus Torvalds 已提交
3859 3860
	status = nfs_ok;
out:
3861
	nfsd4_bump_seqid(cstate, status);
3862 3863
	if (!cstate->replay_owner)
		nfs4_unlock_state();
L
Linus Torvalds 已提交
3864 3865 3866
	return status;
}

3867 3868 3869 3870
static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
{
	unhash_open_stateid(s);
	s->st_stid.sc_type = NFS4_CLOSED_STID;
3871 3872
}

L
Linus Torvalds 已提交
3873 3874 3875
/*
 * nfs4_unlock_state() called after encode
 */
3876
__be32
3877
nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3878
	    struct nfsd4_close *close)
L
Linus Torvalds 已提交
3879
{
3880
	__be32 status;
3881
	struct nfs4_openowner *oo;
3882
	struct nfs4_ol_stateid *stp;
3883 3884
	struct net *net = SVC_NET(rqstp);
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
L
Linus Torvalds 已提交
3885 3886

	dprintk("NFSD: nfsd4_close on file %.*s\n", 
3887 3888
			(int)cstate->current_fh.fh_dentry->d_name.len,
			cstate->current_fh.fh_dentry->d_name.name);
L
Linus Torvalds 已提交
3889 3890

	nfs4_lock_state();
3891 3892 3893
	status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
					&close->cl_stateid,
					NFS4_OPEN_STID|NFS4_CLOSED_STID,
3894
					&stp, nn);
3895
	nfsd4_bump_seqid(cstate, status);
3896
	if (status)
L
Linus Torvalds 已提交
3897
		goto out; 
3898
	oo = openowner(stp->st_stateowner);
3899 3900
	update_stateid(&stp->st_stid.sc_stateid);
	memcpy(&close->cl_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
L
Linus Torvalds 已提交
3901

3902
	nfsd4_close_open_stateid(stp);
3903 3904 3905 3906 3907 3908

	if (cstate->minorversion) {
		unhash_stid(&stp->st_stid);
		free_generic_stateid(stp);
	} else
		oo->oo_last_closed_stid = stp;
3909

3910
	if (list_empty(&oo->oo_owner.so_stateids)) {
3911
		if (cstate->minorversion)
3912
			release_openowner(oo);
3913
		else {
3914 3915 3916 3917
			/*
			 * In the 4.0 case we need to keep the owners around a
			 * little while to handle CLOSE replay.
			 */
F
fanchaoting 已提交
3918
			move_to_close_lru(oo, SVC_NET(rqstp));
3919 3920
		}
	}
L
Linus Torvalds 已提交
3921
out:
3922 3923
	if (!cstate->replay_owner)
		nfs4_unlock_state();
L
Linus Torvalds 已提交
3924 3925 3926
	return status;
}

3927
__be32
3928 3929
nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
		  struct nfsd4_delegreturn *dr)
L
Linus Torvalds 已提交
3930
{
3931 3932
	struct nfs4_delegation *dp;
	stateid_t *stateid = &dr->dr_stateid;
3933
	struct nfs4_stid *s;
3934
	__be32 status;
3935
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
L
Linus Torvalds 已提交
3936

3937
	if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
3938
		return status;
L
Linus Torvalds 已提交
3939 3940

	nfs4_lock_state();
3941 3942
	status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID, &s,
				      cstate->minorversion, nn);
3943
	if (status)
3944
		goto out;
3945
	dp = delegstateid(s);
3946
	status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate));
3947 3948 3949
	if (status)
		goto out;

3950
	destroy_delegation(dp);
L
Linus Torvalds 已提交
3951
out:
3952 3953
	nfs4_unlock_state();

L
Linus Torvalds 已提交
3954 3955 3956 3957 3958 3959
	return status;
}


#define LOFF_OVERFLOW(start, len)      ((u64)(len) > ~(u64)(start))

3960
#define LOCKOWNER_INO_HASH_MASK (LOCKOWNER_INO_HASH_SIZE - 1)
L
Linus Torvalds 已提交
3961

B
Benny Halevy 已提交
3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976
static inline u64
end_offset(u64 start, u64 len)
{
	u64 end;

	end = start + len;
	return end >= start ? end: NFS4_MAX_UINT64;
}

/* last octet in a range */
static inline u64
last_byte_offset(u64 start, u64 len)
{
	u64 end;

3977
	WARN_ON_ONCE(!len);
B
Benny Halevy 已提交
3978 3979 3980 3981
	end = start + len;
	return end > start ? end - 1: NFS4_MAX_UINT64;
}

3982
static unsigned int lockowner_ino_hashval(struct inode *inode, u32 cl_id, struct xdr_netobj *ownername)
L
Linus Torvalds 已提交
3983 3984 3985
{
	return (file_hashval(inode) + cl_id
			+ opaque_hashval(ownername->data, ownername->len))
3986
		& LOCKOWNER_INO_HASH_MASK;
L
Linus Torvalds 已提交
3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005
}

/*
 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
 * byte, because of sign extension problems.  Since NFSv4 calls for 64-bit
 * locking, this prevents us from being completely protocol-compliant.  The
 * real solution to this problem is to start using unsigned file offsets in
 * the VFS, but this is a very deep change!
 */
static inline void
nfs4_transform_lock_offset(struct file_lock *lock)
{
	if (lock->fl_start < 0)
		lock->fl_start = OFFSET_MAX;
	if (lock->fl_end < 0)
		lock->fl_end = OFFSET_MAX;
}

4006 4007
/* Hack!: For now, we're defining this just so we can use a pointer to it
 * as a unique cookie to identify our (NFSv4's) posix locks. */
4008
static const struct lock_manager_operations nfsd_posix_mng_ops  = {
4009
};
L
Linus Torvalds 已提交
4010 4011 4012 4013

static inline void
nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
{
4014
	struct nfs4_lockowner *lo;
L
Linus Torvalds 已提交
4015

4016
	if (fl->fl_lmops == &nfsd_posix_mng_ops) {
4017 4018 4019
		lo = (struct nfs4_lockowner *) fl->fl_owner;
		deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
					lo->lo_owner.so_owner.len, GFP_KERNEL);
4020 4021 4022
		if (!deny->ld_owner.data)
			/* We just don't care that much */
			goto nevermind;
4023 4024
		deny->ld_owner.len = lo->lo_owner.so_owner.len;
		deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
4025
	} else {
4026 4027 4028
nevermind:
		deny->ld_owner.len = 0;
		deny->ld_owner.data = NULL;
4029 4030
		deny->ld_clientid.cl_boot = 0;
		deny->ld_clientid.cl_id = 0;
L
Linus Torvalds 已提交
4031 4032
	}
	deny->ld_start = fl->fl_start;
B
Benny Halevy 已提交
4033 4034
	deny->ld_length = NFS4_MAX_UINT64;
	if (fl->fl_end != NFS4_MAX_UINT64)
L
Linus Torvalds 已提交
4035 4036 4037 4038 4039 4040
		deny->ld_length = fl->fl_end - fl->fl_start + 1;        
	deny->ld_type = NFS4_READ_LT;
	if (fl->fl_type != F_RDLCK)
		deny->ld_type = NFS4_WRITE_LT;
}

J
J. Bruce Fields 已提交
4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051
static bool same_lockowner_ino(struct nfs4_lockowner *lo, struct inode *inode, clientid_t *clid, struct xdr_netobj *owner)
{
	struct nfs4_ol_stateid *lst;

	if (!same_owner_str(&lo->lo_owner, owner, clid))
		return false;
	lst = list_first_entry(&lo->lo_owner.so_stateids,
			       struct nfs4_ol_stateid, st_perstateowner);
	return lst->st_file->fi_inode == inode;
}

4052 4053
static struct nfs4_lockowner *
find_lockowner_str(struct inode *inode, clientid_t *clid,
4054
		   struct xdr_netobj *owner, struct nfsd_net *nn)
L
Linus Torvalds 已提交
4055
{
4056
	unsigned int hashval = lockowner_ino_hashval(inode, clid->cl_id, owner);
J
J. Bruce Fields 已提交
4057
	struct nfs4_lockowner *lo;
L
Linus Torvalds 已提交
4058

4059
	list_for_each_entry(lo, &nn->lockowner_ino_hashtbl[hashval], lo_owner_ino_hash) {
J
J. Bruce Fields 已提交
4060 4061
		if (same_lockowner_ino(lo, inode, clid, owner))
			return lo;
L
Linus Torvalds 已提交
4062 4063 4064 4065
	}
	return NULL;
}

4066
static void hash_lockowner(struct nfs4_lockowner *lo, unsigned int strhashval, struct nfs4_client *clp, struct nfs4_ol_stateid *open_stp)
4067
{
4068 4069 4070
	struct inode *inode = open_stp->st_file->fi_inode;
	unsigned int inohash = lockowner_ino_hashval(inode,
			clp->cl_clientid.cl_id, &lo->lo_owner.so_owner);
4071
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
4072

4073
	list_add(&lo->lo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
4074
	list_add(&lo->lo_owner_ino_hash, &nn->lockowner_ino_hashtbl[inohash]);
4075
	list_add(&lo->lo_perstateid, &open_stp->st_lockowners);
4076 4077
}

L
Linus Torvalds 已提交
4078 4079 4080
/*
 * Alloc a lock owner structure.
 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has 
L
Lucas De Marchi 已提交
4081
 * occurred. 
L
Linus Torvalds 已提交
4082
 *
4083
 * strhashval = ownerstr_hashval
L
Linus Torvalds 已提交
4084 4085
 */

4086
static struct nfs4_lockowner *
4087
alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_ol_stateid *open_stp, struct nfsd4_lock *lock) {
4088
	struct nfs4_lockowner *lo;
L
Linus Torvalds 已提交
4089

4090 4091
	lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
	if (!lo)
L
Linus Torvalds 已提交
4092
		return NULL;
4093 4094
	INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
	lo->lo_owner.so_is_open_owner = 0;
4095 4096
	/* It is the openowner seqid that will be incremented in encode in the
	 * case of new lockowners; so increment the lock seqid manually: */
4097 4098 4099
	lo->lo_owner.so_seqid = lock->lk_new_lock_seqid + 1;
	hash_lockowner(lo, strhashval, clp, open_stp);
	return lo;
L
Linus Torvalds 已提交
4100 4101
}

4102 4103
static struct nfs4_ol_stateid *
alloc_init_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp, struct nfs4_ol_stateid *open_stp)
L
Linus Torvalds 已提交
4104
{
4105
	struct nfs4_ol_stateid *stp;
4106
	struct nfs4_client *clp = lo->lo_owner.so_client;
L
Linus Torvalds 已提交
4107

4108
	stp = nfs4_alloc_stateid(clp);
N
NeilBrown 已提交
4109
	if (stp == NULL)
J
J. Bruce Fields 已提交
4110
		return NULL;
J
J. Bruce Fields 已提交
4111
	stp->st_stid.sc_type = NFS4_LOCK_STID;
4112
	list_add(&stp->st_perfile, &fp->fi_stateids);
4113 4114
	list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
	stp->st_stateowner = &lo->lo_owner;
4115
	get_nfs4_file(fp);
L
Linus Torvalds 已提交
4116
	stp->st_file = fp;
J
J. Bruce Fields 已提交
4117
	stp->st_access_bmap = 0;
L
Linus Torvalds 已提交
4118
	stp->st_deny_bmap = open_stp->st_deny_bmap;
4119
	stp->st_openstp = open_stp;
L
Linus Torvalds 已提交
4120 4121 4122
	return stp;
}

4123
static int
L
Linus Torvalds 已提交
4124 4125
check_lock_length(u64 offset, u64 length)
{
B
Benny Halevy 已提交
4126
	return ((length == 0)  || ((length != NFS4_MAX_UINT64) &&
L
Linus Torvalds 已提交
4127 4128 4129
	     LOFF_OVERFLOW(offset, length)));
}

4130
static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
J
J. Bruce Fields 已提交
4131 4132 4133 4134
{
	struct nfs4_file *fp = lock_stp->st_file;
	int oflag = nfs4_access_to_omode(access);

4135
	if (test_access(access, lock_stp))
J
J. Bruce Fields 已提交
4136 4137
		return;
	nfs4_file_get_access(fp, oflag);
4138
	set_access(access, lock_stp);
J
J. Bruce Fields 已提交
4139 4140
}

J
J. Bruce Fields 已提交
4141
static __be32 lookup_or_create_lock_state(struct nfsd4_compound_state *cstate, struct nfs4_ol_stateid *ost, struct nfsd4_lock *lock, struct nfs4_ol_stateid **lst, bool *new)
4142 4143 4144 4145 4146 4147
{
	struct nfs4_file *fi = ost->st_file;
	struct nfs4_openowner *oo = openowner(ost->st_stateowner);
	struct nfs4_client *cl = oo->oo_owner.so_client;
	struct nfs4_lockowner *lo;
	unsigned int strhashval;
4148
	struct nfsd_net *nn = net_generic(cl->net, nfsd_net_id);
4149

4150 4151
	lo = find_lockowner_str(fi->fi_inode, &cl->cl_clientid,
				&lock->v.new.owner, nn);
4152 4153 4154 4155 4156 4157 4158 4159
	if (lo) {
		if (!cstate->minorversion)
			return nfserr_bad_seqid;
		/* XXX: a lockowner always has exactly one stateid: */
		*lst = list_first_entry(&lo->lo_owner.so_stateids,
				struct nfs4_ol_stateid, st_perstateowner);
		return nfs_ok;
	}
4160
	strhashval = ownerstr_hashval(cl->cl_clientid.cl_id,
4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173
			&lock->v.new.owner);
	lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
	if (lo == NULL)
		return nfserr_jukebox;
	*lst = alloc_init_lock_stateid(lo, fi, ost);
	if (*lst == NULL) {
		release_lockowner(lo);
		return nfserr_jukebox;
	}
	*new = true;
	return nfs_ok;
}

L
Linus Torvalds 已提交
4174 4175 4176
/*
 *  LOCK operation 
 */
4177
__be32
4178
nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4179
	   struct nfsd4_lock *lock)
L
Linus Torvalds 已提交
4180
{
4181 4182
	struct nfs4_openowner *open_sop = NULL;
	struct nfs4_lockowner *lock_sop = NULL;
4183
	struct nfs4_ol_stateid *lock_stp;
4184
	struct file *filp = NULL;
4185 4186
	struct file_lock *file_lock = NULL;
	struct file_lock *conflock = NULL;
4187
	__be32 status = 0;
4188
	bool new_state = false;
4189
	int lkflg;
4190
	int err;
4191 4192
	struct net *net = SVC_NET(rqstp);
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
L
Linus Torvalds 已提交
4193 4194 4195 4196 4197 4198 4199 4200

	dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
		(long long) lock->lk_offset,
		(long long) lock->lk_length);

	if (check_lock_length(lock->lk_offset, lock->lk_length))
		 return nfserr_inval;

4201
	if ((status = fh_verify(rqstp, &cstate->current_fh,
M
Miklos Szeredi 已提交
4202
				S_IFREG, NFSD_MAY_LOCK))) {
A
Andy Adamson 已提交
4203 4204 4205 4206
		dprintk("NFSD: nfsd4_lock: permission denied!\n");
		return status;
	}

L
Linus Torvalds 已提交
4207 4208 4209
	nfs4_lock_state();

	if (lock->lk_is_new) {
4210
		struct nfs4_ol_stateid *open_stp = NULL;
4211 4212 4213 4214 4215 4216 4217

		if (nfsd4_has_session(cstate))
			/* See rfc 5661 18.10.3: given clientid is ignored: */
			memcpy(&lock->v.new.clientid,
				&cstate->session->se_client->cl_clientid,
				sizeof(clientid_t));

L
Linus Torvalds 已提交
4218
		status = nfserr_stale_clientid;
4219
		if (STALE_CLIENTID(&lock->lk_new_clientid, nn))
L
Linus Torvalds 已提交
4220 4221 4222
			goto out;

		/* validate and update open stateid and open seqid */
4223
		status = nfs4_preprocess_confirmed_seqid_op(cstate,
L
Linus Torvalds 已提交
4224 4225
				        lock->lk_new_open_seqid,
		                        &lock->lk_new_open_stateid,
4226
					&open_stp, nn);
4227
		if (status)
L
Linus Torvalds 已提交
4228
			goto out;
4229
		open_sop = openowner(open_stp->st_stateowner);
4230
		status = nfserr_bad_stateid;
4231
		if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
4232 4233
						&lock->v.new.clientid))
			goto out;
4234 4235
		status = lookup_or_create_lock_state(cstate, open_stp, lock,
							&lock_stp, &new_state);
J
J. Bruce Fields 已提交
4236
	} else
4237
		status = nfs4_preprocess_seqid_op(cstate,
4238 4239
				       lock->lk_old_lock_seqid,
				       &lock->lk_old_lock_stateid,
4240
				       NFS4_LOCK_STID, &lock_stp, nn);
J
J. Bruce Fields 已提交
4241 4242
	if (status)
		goto out;
4243
	lock_sop = lockowner(lock_stp->st_stateowner);
L
Linus Torvalds 已提交
4244

4245 4246 4247 4248 4249
	lkflg = setlkflg(lock->lk_type);
	status = nfs4_check_openmode(lock_stp, lkflg);
	if (status)
		goto out;

4250
	status = nfserr_grace;
4251
	if (locks_in_grace(net) && !lock->lk_reclaim)
4252 4253
		goto out;
	status = nfserr_no_grace;
4254
	if (!locks_in_grace(net) && lock->lk_reclaim)
4255 4256
		goto out;

4257 4258 4259 4260 4261 4262 4263 4264
	file_lock = locks_alloc_lock();
	if (!file_lock) {
		dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
		status = nfserr_jukebox;
		goto out;
	}

	locks_init_lock(file_lock);
L
Linus Torvalds 已提交
4265 4266 4267
	switch (lock->lk_type) {
		case NFS4_READ_LT:
		case NFS4_READW_LT:
J
J. Bruce Fields 已提交
4268 4269 4270
			filp = find_readable_file(lock_stp->st_file);
			if (filp)
				get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
4271
			file_lock->fl_type = F_RDLCK;
4272
			break;
L
Linus Torvalds 已提交
4273 4274
		case NFS4_WRITE_LT:
		case NFS4_WRITEW_LT:
J
J. Bruce Fields 已提交
4275 4276 4277
			filp = find_writeable_file(lock_stp->st_file);
			if (filp)
				get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
4278
			file_lock->fl_type = F_WRLCK;
4279
			break;
L
Linus Torvalds 已提交
4280 4281 4282 4283
		default:
			status = nfserr_inval;
		goto out;
	}
4284 4285 4286 4287
	if (!filp) {
		status = nfserr_openmode;
		goto out;
	}
4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302
	file_lock->fl_owner = (fl_owner_t)lock_sop;
	file_lock->fl_pid = current->tgid;
	file_lock->fl_file = filp;
	file_lock->fl_flags = FL_POSIX;
	file_lock->fl_lmops = &nfsd_posix_mng_ops;
	file_lock->fl_start = lock->lk_offset;
	file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
	nfs4_transform_lock_offset(file_lock);

	conflock = locks_alloc_lock();
	if (!conflock) {
		dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
		status = nfserr_jukebox;
		goto out;
	}
L
Linus Torvalds 已提交
4303

4304
	err = vfs_lock_file(filp, F_SETLK, file_lock, conflock);
4305
	switch (-err) {
L
Linus Torvalds 已提交
4306
	case 0: /* success! */
4307 4308
		update_stateid(&lock_stp->st_stid.sc_stateid);
		memcpy(&lock->lk_resp_stateid, &lock_stp->st_stid.sc_stateid, 
L
Linus Torvalds 已提交
4309
				sizeof(stateid_t));
4310
		status = 0;
4311 4312 4313 4314
		break;
	case (EAGAIN):		/* conflock holds conflicting lock */
		status = nfserr_denied;
		dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
4315
		nfs4_set_lock_denied(conflock, &lock->lk_denied);
4316
		break;
L
Linus Torvalds 已提交
4317 4318
	case (EDEADLK):
		status = nfserr_deadlock;
4319
		break;
4320
	default:
4321
		dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
4322
		status = nfserrno(err);
4323
		break;
L
Linus Torvalds 已提交
4324 4325
	}
out:
4326
	if (status && new_state)
4327
		release_lockowner(lock_sop);
4328
	nfsd4_bump_seqid(cstate, status);
4329 4330
	if (!cstate->replay_owner)
		nfs4_unlock_state();
4331 4332 4333 4334
	if (file_lock)
		locks_free_lock(file_lock);
	if (conflock)
		locks_free_lock(conflock);
L
Linus Torvalds 已提交
4335 4336 4337
	return status;
}

4338 4339 4340 4341 4342 4343
/*
 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
 * so we do a temporary open here just to get an open file to pass to
 * vfs_test_lock.  (Arguably perhaps test_lock should be done with an
 * inode operation.)
 */
4344
static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
4345 4346
{
	struct file *file;
4347 4348 4349 4350 4351
	__be32 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
	if (!err) {
		err = nfserrno(vfs_test_lock(file, lock));
		nfsd_close(file);
	}
4352 4353 4354
	return err;
}

L
Linus Torvalds 已提交
4355 4356 4357
/*
 * LOCKT operation
 */
4358
__be32
4359 4360
nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	    struct nfsd4_lockt *lockt)
L
Linus Torvalds 已提交
4361 4362
{
	struct inode *inode;
4363
	struct file_lock *file_lock = NULL;
4364
	struct nfs4_lockowner *lo;
4365
	__be32 status;
4366
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
L
Linus Torvalds 已提交
4367

4368
	if (locks_in_grace(SVC_NET(rqstp)))
L
Linus Torvalds 已提交
4369 4370 4371 4372 4373 4374 4375
		return nfserr_grace;

	if (check_lock_length(lockt->lt_offset, lockt->lt_length))
		 return nfserr_inval;

	nfs4_lock_state();

4376 4377 4378 4379 4380
	if (!nfsd4_has_session(cstate)) {
		status = lookup_clientid(&lockt->lt_clientid, false, nn, NULL);
		if (status)
			goto out;
	}
L
Linus Torvalds 已提交
4381

4382
	if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
L
Linus Torvalds 已提交
4383 4384
		goto out;

4385
	inode = cstate->current_fh.fh_dentry->d_inode;
4386 4387 4388 4389 4390 4391 4392
	file_lock = locks_alloc_lock();
	if (!file_lock) {
		dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
		status = nfserr_jukebox;
		goto out;
	}
	locks_init_lock(file_lock);
L
Linus Torvalds 已提交
4393 4394 4395
	switch (lockt->lt_type) {
		case NFS4_READ_LT:
		case NFS4_READW_LT:
4396
			file_lock->fl_type = F_RDLCK;
L
Linus Torvalds 已提交
4397 4398 4399
		break;
		case NFS4_WRITE_LT:
		case NFS4_WRITEW_LT:
4400
			file_lock->fl_type = F_WRLCK;
L
Linus Torvalds 已提交
4401 4402
		break;
		default:
4403
			dprintk("NFSD: nfs4_lockt: bad lock type!\n");
L
Linus Torvalds 已提交
4404 4405 4406 4407
			status = nfserr_inval;
		goto out;
	}

4408
	lo = find_lockowner_str(inode, &lockt->lt_clientid, &lockt->lt_owner, nn);
4409
	if (lo)
4410 4411 4412
		file_lock->fl_owner = (fl_owner_t)lo;
	file_lock->fl_pid = current->tgid;
	file_lock->fl_flags = FL_POSIX;
L
Linus Torvalds 已提交
4413

4414 4415
	file_lock->fl_start = lockt->lt_offset;
	file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
L
Linus Torvalds 已提交
4416

4417
	nfs4_transform_lock_offset(file_lock);
L
Linus Torvalds 已提交
4418

4419
	status = nfsd_test_lock(rqstp, &cstate->current_fh, file_lock);
4420
	if (status)
4421
		goto out;
4422

4423
	if (file_lock->fl_type != F_UNLCK) {
L
Linus Torvalds 已提交
4424
		status = nfserr_denied;
4425
		nfs4_set_lock_denied(file_lock, &lockt->lt_denied);
L
Linus Torvalds 已提交
4426 4427 4428
	}
out:
	nfs4_unlock_state();
4429 4430
	if (file_lock)
		locks_free_lock(file_lock);
L
Linus Torvalds 已提交
4431 4432 4433
	return status;
}

4434
__be32
4435
nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4436
	    struct nfsd4_locku *locku)
L
Linus Torvalds 已提交
4437
{
4438
	struct nfs4_lockowner *lo;
4439
	struct nfs4_ol_stateid *stp;
L
Linus Torvalds 已提交
4440
	struct file *filp = NULL;
4441
	struct file_lock *file_lock = NULL;
4442
	__be32 status;
4443
	int err;
4444 4445
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);

L
Linus Torvalds 已提交
4446 4447 4448 4449 4450 4451 4452 4453 4454
	dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
		(long long) locku->lu_offset,
		(long long) locku->lu_length);

	if (check_lock_length(locku->lu_offset, locku->lu_length))
		 return nfserr_inval;

	nfs4_lock_state();
									        
4455
	status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
4456 4457
					&locku->lu_stateid, NFS4_LOCK_STID,
					&stp, nn);
4458
	if (status)
L
Linus Torvalds 已提交
4459
		goto out;
4460 4461 4462 4463 4464
	filp = find_any_file(stp->st_file);
	if (!filp) {
		status = nfserr_lock_range;
		goto out;
	}
4465 4466 4467 4468 4469 4470
	file_lock = locks_alloc_lock();
	if (!file_lock) {
		dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
		status = nfserr_jukebox;
		goto out;
	}
4471
	lo = lockowner(stp->st_stateowner);
4472 4473
	locks_init_lock(file_lock);
	file_lock->fl_type = F_UNLCK;
4474
	file_lock->fl_owner = (fl_owner_t)lo;
4475 4476 4477 4478 4479 4480 4481 4482 4483
	file_lock->fl_pid = current->tgid;
	file_lock->fl_file = filp;
	file_lock->fl_flags = FL_POSIX;
	file_lock->fl_lmops = &nfsd_posix_mng_ops;
	file_lock->fl_start = locku->lu_offset;

	file_lock->fl_end = last_byte_offset(locku->lu_offset,
						locku->lu_length);
	nfs4_transform_lock_offset(file_lock);
L
Linus Torvalds 已提交
4484

4485
	err = vfs_lock_file(filp, F_SETLK, file_lock, NULL);
4486
	if (err) {
4487
		dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
L
Linus Torvalds 已提交
4488 4489
		goto out_nfserr;
	}
4490 4491
	update_stateid(&stp->st_stid.sc_stateid);
	memcpy(&locku->lu_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
L
Linus Torvalds 已提交
4492

4493 4494 4495 4496 4497
	if (nfsd4_has_session(cstate) && !check_for_locks(stp->st_file, lo)) {
		WARN_ON_ONCE(cstate->replay_owner);
		release_lockowner(lo);
	}

L
Linus Torvalds 已提交
4498
out:
4499
	nfsd4_bump_seqid(cstate, status);
4500 4501
	if (!cstate->replay_owner)
		nfs4_unlock_state();
4502 4503
	if (file_lock)
		locks_free_lock(file_lock);
L
Linus Torvalds 已提交
4504 4505 4506
	return status;

out_nfserr:
4507
	status = nfserrno(err);
L
Linus Torvalds 已提交
4508 4509 4510 4511 4512 4513 4514 4515 4516
	goto out;
}

/*
 * returns
 * 	1: locks held by lockowner
 * 	0: no locks held by lockowner
 */
static int
4517
check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner)
L
Linus Torvalds 已提交
4518 4519
{
	struct file_lock **flpp;
4520
	struct inode *inode = filp->fi_inode;
L
Linus Torvalds 已提交
4521 4522
	int status = 0;

4523
	lock_flocks();
L
Linus Torvalds 已提交
4524
	for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
4525
		if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
L
Linus Torvalds 已提交
4526 4527
			status = 1;
			goto out;
4528
		}
L
Linus Torvalds 已提交
4529 4530
	}
out:
4531
	unlock_flocks();
L
Linus Torvalds 已提交
4532 4533 4534
	return status;
}

4535
__be32
4536 4537 4538
nfsd4_release_lockowner(struct svc_rqst *rqstp,
			struct nfsd4_compound_state *cstate,
			struct nfsd4_release_lockowner *rlockowner)
L
Linus Torvalds 已提交
4539 4540
{
	clientid_t *clid = &rlockowner->rl_clientid;
4541
	struct nfs4_stateowner *sop;
4542
	struct nfs4_lockowner *lo;
4543
	struct nfs4_ol_stateid *stp;
L
Linus Torvalds 已提交
4544
	struct xdr_netobj *owner = &rlockowner->rl_owner;
4545
	struct list_head matches;
4546
	unsigned int hashval = ownerstr_hashval(clid->cl_id, owner);
4547
	__be32 status;
4548
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
L
Linus Torvalds 已提交
4549 4550 4551 4552 4553 4554

	dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
		clid->cl_boot, clid->cl_id);

	nfs4_lock_state();

4555 4556 4557 4558
	status = lookup_clientid(clid, cstate->minorversion, nn, NULL);
	if (status)
		goto out;

4559 4560
	status = nfserr_locks_held;
	INIT_LIST_HEAD(&matches);
4561

4562
	list_for_each_entry(sop, &nn->ownerstr_hashtbl[hashval], so_strhash) {
4563 4564
		if (sop->so_is_open_owner)
			continue;
4565 4566 4567 4568 4569 4570 4571 4572
		if (!same_owner_str(sop, owner, clid))
			continue;
		list_for_each_entry(stp, &sop->so_stateids,
				st_perstateowner) {
			lo = lockowner(sop);
			if (check_for_locks(stp->st_file, lo))
				goto out;
			list_add(&lo->lo_list, &matches);
L
Linus Torvalds 已提交
4573
		}
4574 4575 4576 4577 4578
	}
	/* Clients probably won't expect us to return with some (but not all)
	 * of the lockowner state released; so don't release any until all
	 * have been checked. */
	status = nfs_ok;
N
NeilBrown 已提交
4579
	while (!list_empty(&matches)) {
4580 4581
		lo = list_entry(matches.next, struct nfs4_lockowner,
								lo_list);
N
NeilBrown 已提交
4582 4583
		/* unhash_stateowner deletes so_perclient only
		 * for openowners. */
4584 4585
		list_del(&lo->lo_list);
		release_lockowner(lo);
L
Linus Torvalds 已提交
4586 4587 4588 4589 4590 4591 4592
	}
out:
	nfs4_unlock_state();
	return status;
}

static inline struct nfs4_client_reclaim *
N
NeilBrown 已提交
4593
alloc_reclaim(void)
L
Linus Torvalds 已提交
4594
{
N
NeilBrown 已提交
4595
	return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
L
Linus Torvalds 已提交
4596 4597
}

4598
bool
4599
nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn)
4600
{
4601
	struct nfs4_client_reclaim *crp;
4602

4603
	crp = nfsd4_find_reclaim_client(name, nn);
4604
	return (crp && crp->cr_clp);
4605 4606
}

L
Linus Torvalds 已提交
4607 4608 4609
/*
 * failure => all reset bets are off, nfserr_no_grace...
 */
4610
struct nfs4_client_reclaim *
4611
nfs4_client_to_reclaim(const char *name, struct nfsd_net *nn)
L
Linus Torvalds 已提交
4612 4613
{
	unsigned int strhashval;
4614
	struct nfs4_client_reclaim *crp;
L
Linus Torvalds 已提交
4615

N
NeilBrown 已提交
4616 4617
	dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
	crp = alloc_reclaim();
4618 4619 4620
	if (crp) {
		strhashval = clientstr_hashval(name);
		INIT_LIST_HEAD(&crp->cr_strhash);
4621
		list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]);
4622
		memcpy(crp->cr_recdir, name, HEXDIR_LEN);
4623
		crp->cr_clp = NULL;
4624
		nn->reclaim_str_hashtbl_size++;
4625 4626
	}
	return crp;
L
Linus Torvalds 已提交
4627 4628
}

4629
void
4630
nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn)
4631 4632 4633
{
	list_del(&crp->cr_strhash);
	kfree(crp);
4634
	nn->reclaim_str_hashtbl_size--;
4635 4636
}

4637
void
4638
nfs4_release_reclaim(struct nfsd_net *nn)
L
Linus Torvalds 已提交
4639 4640 4641 4642 4643
{
	struct nfs4_client_reclaim *crp = NULL;
	int i;

	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4644 4645
		while (!list_empty(&nn->reclaim_str_hashtbl[i])) {
			crp = list_entry(nn->reclaim_str_hashtbl[i].next,
L
Linus Torvalds 已提交
4646
			                struct nfs4_client_reclaim, cr_strhash);
4647
			nfs4_remove_reclaim_record(crp, nn);
L
Linus Torvalds 已提交
4648 4649
		}
	}
4650
	WARN_ON_ONCE(nn->reclaim_str_hashtbl_size);
L
Linus Torvalds 已提交
4651 4652 4653 4654
}

/*
 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
4655
struct nfs4_client_reclaim *
4656
nfsd4_find_reclaim_client(const char *recdir, struct nfsd_net *nn)
L
Linus Torvalds 已提交
4657 4658 4659 4660
{
	unsigned int strhashval;
	struct nfs4_client_reclaim *crp = NULL;

4661
	dprintk("NFSD: nfs4_find_reclaim_client for recdir %s\n", recdir);
L
Linus Torvalds 已提交
4662

4663
	strhashval = clientstr_hashval(recdir);
4664
	list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
4665
		if (same_name(crp->cr_recdir, recdir)) {
L
Linus Torvalds 已提交
4666 4667 4668 4669 4670 4671 4672 4673 4674
			return crp;
		}
	}
	return NULL;
}

/*
* Called from OPEN. Look for clientid in reclaim list.
*/
4675
__be32
4676
nfs4_check_open_reclaim(clientid_t *clid, bool sessions, struct nfsd_net *nn)
L
Linus Torvalds 已提交
4677
{
4678 4679 4680
	struct nfs4_client *clp;

	/* find clientid in conf_id_hashtbl */
4681
	clp = find_confirmed_client(clid, sessions, nn);
4682 4683 4684 4685
	if (clp == NULL)
		return nfserr_reclaim_bad;

	return nfsd4_client_record_check(clp) ? nfserr_reclaim_bad : nfs_ok;
L
Linus Torvalds 已提交
4686 4687
}

B
Bryan Schumaker 已提交
4688 4689
#ifdef CONFIG_NFSD_FAULT_INJECTION

4690 4691
u64 nfsd_forget_client(struct nfs4_client *clp, u64 max)
{
4692 4693
	if (mark_client_expired(clp))
		return 0;
4694 4695 4696 4697
	expire_client(clp);
	return 1;
}

4698 4699 4700
u64 nfsd_print_client(struct nfs4_client *clp, u64 num)
{
	char buf[INET6_ADDRSTRLEN];
4701
	rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
4702 4703 4704 4705 4706 4707 4708 4709
	printk(KERN_INFO "NFS Client: %s\n", buf);
	return 1;
}

static void nfsd_print_count(struct nfs4_client *clp, unsigned int count,
			     const char *type)
{
	char buf[INET6_ADDRSTRLEN];
4710
	rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
4711 4712 4713
	printk(KERN_INFO "NFS Client: %s has %u %s\n", buf, count, type);
}

B
Bryan Schumaker 已提交
4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739
static u64 nfsd_foreach_client_lock(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_lockowner *))
{
	struct nfs4_openowner *oop;
	struct nfs4_lockowner *lop, *lo_next;
	struct nfs4_ol_stateid *stp, *st_next;
	u64 count = 0;

	list_for_each_entry(oop, &clp->cl_openowners, oo_perclient) {
		list_for_each_entry_safe(stp, st_next, &oop->oo_owner.so_stateids, st_perstateowner) {
			list_for_each_entry_safe(lop, lo_next, &stp->st_lockowners, lo_perstateid) {
				if (func)
					func(lop);
				if (++count == max)
					return count;
			}
		}
	}

	return count;
}

u64 nfsd_forget_client_locks(struct nfs4_client *clp, u64 max)
{
	return nfsd_foreach_client_lock(clp, max, release_lockowner);
}

4740 4741 4742 4743 4744 4745 4746
u64 nfsd_print_client_locks(struct nfs4_client *clp, u64 max)
{
	u64 count = nfsd_foreach_client_lock(clp, max, NULL);
	nfsd_print_count(clp, count, "locked files");
	return count;
}

4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766
static u64 nfsd_foreach_client_open(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_openowner *))
{
	struct nfs4_openowner *oop, *next;
	u64 count = 0;

	list_for_each_entry_safe(oop, next, &clp->cl_openowners, oo_perclient) {
		if (func)
			func(oop);
		if (++count == max)
			break;
	}

	return count;
}

u64 nfsd_forget_client_openowners(struct nfs4_client *clp, u64 max)
{
	return nfsd_foreach_client_open(clp, max, release_openowner);
}

4767 4768 4769 4770 4771 4772 4773
u64 nfsd_print_client_openowners(struct nfs4_client *clp, u64 max)
{
	u64 count = nfsd_foreach_client_open(clp, max, NULL);
	nfsd_print_count(clp, count, "open files");
	return count;
}

4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799
static u64 nfsd_find_all_delegations(struct nfs4_client *clp, u64 max,
				     struct list_head *victims)
{
	struct nfs4_delegation *dp, *next;
	u64 count = 0;

	list_for_each_entry_safe(dp, next, &clp->cl_delegations, dl_perclnt) {
		if (victims)
			list_move(&dp->dl_recall_lru, victims);
		if (++count == max)
			break;
	}
	return count;
}

u64 nfsd_forget_client_delegations(struct nfs4_client *clp, u64 max)
{
	struct nfs4_delegation *dp, *next;
	LIST_HEAD(victims);
	u64 count;

	spin_lock(&recall_lock);
	count = nfsd_find_all_delegations(clp, max, &victims);
	spin_unlock(&recall_lock);

	list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
4800
		revoke_delegation(dp);
4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819

	return count;
}

u64 nfsd_recall_client_delegations(struct nfs4_client *clp, u64 max)
{
	struct nfs4_delegation *dp, *next;
	LIST_HEAD(victims);
	u64 count;

	spin_lock(&recall_lock);
	count = nfsd_find_all_delegations(clp, max, &victims);
	list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
		nfsd_break_one_deleg(dp);
	spin_unlock(&recall_lock);

	return count;
}

4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831
u64 nfsd_print_client_delegations(struct nfs4_client *clp, u64 max)
{
	u64 count = 0;

	spin_lock(&recall_lock);
	count = nfsd_find_all_delegations(clp, max, NULL);
	spin_unlock(&recall_lock);

	nfsd_print_count(clp, count, "delegations");
	return count;
}

4832
u64 nfsd_for_n_state(u64 max, u64 (*func)(struct nfs4_client *, u64))
B
Bryan Schumaker 已提交
4833 4834
{
	struct nfs4_client *clp, *next;
4835
	u64 count = 0;
4836
	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
B
Bryan Schumaker 已提交
4837

4838 4839 4840
	if (!nfsd_netns_ready(nn))
		return 0;

4841
	list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
4842 4843
		count += func(clp, max - count);
		if ((max != 0) && (count >= max))
B
Bryan Schumaker 已提交
4844 4845 4846
			break;
	}

4847 4848 4849
	return count;
}

4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864
struct nfs4_client *nfsd_find_client(struct sockaddr_storage *addr, size_t addr_size)
{
	struct nfs4_client *clp;
	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);

	if (!nfsd_netns_ready(nn))
		return NULL;

	list_for_each_entry(clp, &nn->client_lru, cl_lru) {
		if (memcmp(&clp->cl_addr, addr, addr_size) == 0)
			return clp;
	}
	return NULL;
}

B
Bryan Schumaker 已提交
4865 4866
#endif /* CONFIG_NFSD_FAULT_INJECTION */

4867
/* initialization to perform at module load time: */
L
Linus Torvalds 已提交
4868

4869
void
4870
nfs4_state_init(void)
L
Linus Torvalds 已提交
4871
{
4872 4873
}

4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894
/*
 * Since the lifetime of a delegation isn't limited to that of an open, a
 * client may quite reasonably hang on to a delegation as long as it has
 * the inode cached.  This becomes an obvious problem the first time a
 * client's inode cache approaches the size of the server's total memory.
 *
 * For now we avoid this problem by imposing a hard limit on the number
 * of delegations, which varies according to the server's memory size.
 */
static void
set_max_delegations(void)
{
	/*
	 * Allow at most 4 delegations per megabyte of RAM.  Quick
	 * estimates suggest that in the worst case (where every delegation
	 * is for a different inode), a delegation could take about 1.5K,
	 * giving a worst case usage of about 6% of memory.
	 */
	max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
}

4895
static int nfs4_state_create_net(struct net *net)
4896 4897 4898 4899 4900 4901 4902
{
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
	int i;

	nn->conf_id_hashtbl = kmalloc(sizeof(struct list_head) *
			CLIENT_HASH_SIZE, GFP_KERNEL);
	if (!nn->conf_id_hashtbl)
4903
		goto err;
4904 4905 4906 4907
	nn->unconf_id_hashtbl = kmalloc(sizeof(struct list_head) *
			CLIENT_HASH_SIZE, GFP_KERNEL);
	if (!nn->unconf_id_hashtbl)
		goto err_unconf_id;
4908 4909 4910 4911
	nn->ownerstr_hashtbl = kmalloc(sizeof(struct list_head) *
			OWNER_HASH_SIZE, GFP_KERNEL);
	if (!nn->ownerstr_hashtbl)
		goto err_ownerstr;
4912 4913 4914 4915
	nn->lockowner_ino_hashtbl = kmalloc(sizeof(struct list_head) *
			LOCKOWNER_INO_HASH_SIZE, GFP_KERNEL);
	if (!nn->lockowner_ino_hashtbl)
		goto err_lockowner_ino;
4916 4917 4918 4919
	nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) *
			SESSION_HASH_SIZE, GFP_KERNEL);
	if (!nn->sessionid_hashtbl)
		goto err_sessionid;
4920

4921
	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4922
		INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);
4923
		INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);
4924
	}
4925 4926
	for (i = 0; i < OWNER_HASH_SIZE; i++)
		INIT_LIST_HEAD(&nn->ownerstr_hashtbl[i]);
4927 4928
	for (i = 0; i < LOCKOWNER_INO_HASH_SIZE; i++)
		INIT_LIST_HEAD(&nn->lockowner_ino_hashtbl[i]);
4929 4930
	for (i = 0; i < SESSION_HASH_SIZE; i++)
		INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
4931
	nn->conf_name_tree = RB_ROOT;
4932
	nn->unconf_name_tree = RB_ROOT;
4933
	INIT_LIST_HEAD(&nn->client_lru);
4934
	INIT_LIST_HEAD(&nn->close_lru);
4935
	INIT_LIST_HEAD(&nn->del_recall_lru);
4936
	spin_lock_init(&nn->client_lock);
4937

4938
	INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
4939
	get_net(net);
4940

4941
	return 0;
4942

4943 4944
err_sessionid:
	kfree(nn->lockowner_ino_hashtbl);
4945 4946
err_lockowner_ino:
	kfree(nn->ownerstr_hashtbl);
4947 4948
err_ownerstr:
	kfree(nn->unconf_id_hashtbl);
4949 4950
err_unconf_id:
	kfree(nn->conf_id_hashtbl);
4951 4952
err:
	return -ENOMEM;
4953 4954 4955
}

static void
4956
nfs4_state_destroy_net(struct net *net)
4957 4958 4959 4960
{
	int i;
	struct nfs4_client *clp = NULL;
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
4961
	struct rb_node *node, *tmp;
4962 4963 4964 4965 4966 4967 4968

	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
		while (!list_empty(&nn->conf_id_hashtbl[i])) {
			clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
			destroy_client(clp);
		}
	}
4969 4970 4971 4972 4973 4974 4975 4976 4977 4978

	node = rb_first(&nn->unconf_name_tree);
	while (node != NULL) {
		tmp = node;
		node = rb_next(tmp);
		clp = rb_entry(tmp, struct nfs4_client, cl_namenode);
		rb_erase(tmp, &nn->unconf_name_tree);
		destroy_client(clp);
	}

4979
	kfree(nn->sessionid_hashtbl);
4980
	kfree(nn->lockowner_ino_hashtbl);
4981
	kfree(nn->ownerstr_hashtbl);
4982
	kfree(nn->unconf_id_hashtbl);
4983
	kfree(nn->conf_id_hashtbl);
4984
	put_net(net);
4985 4986
}

4987
int
4988
nfs4_state_start_net(struct net *net)
4989
{
4990
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
4991 4992
	int ret;

4993
	ret = nfs4_state_create_net(net);
4994 4995
	if (ret)
		return ret;
4996
	nfsd4_client_tracking_init(net);
4997
	nn->boot_time = get_seconds();
4998
	locks_start_grace(net, &nn->nfsd4_manager);
4999
	nn->grace_ended = false;
5000
	printk(KERN_INFO "NFSD: starting %ld-second grace period (net %p)\n",
5001 5002
	       nn->nfsd4_grace, net);
	queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ);
5003 5004 5005 5006 5007 5008 5009 5010 5011 5012
	return 0;
}

/* initialization to perform when the nfsd service is started: */

int
nfs4_state_start(void)
{
	int ret;

5013
	ret = set_callback_cred();
5014 5015
	if (ret)
		return -ENOMEM;
5016
	laundry_wq = create_singlethread_workqueue("nfsd4");
5017 5018 5019 5020
	if (laundry_wq == NULL) {
		ret = -ENOMEM;
		goto out_recovery;
	}
5021 5022 5023
	ret = nfsd4_create_callback_queue();
	if (ret)
		goto out_free_laundry;
5024

5025
	set_max_delegations();
5026

5027
	return 0;
5028

5029 5030
out_free_laundry:
	destroy_workqueue(laundry_wq);
5031
out_recovery:
5032
	return ret;
L
Linus Torvalds 已提交
5033 5034
}

5035
/* should be called with the state lock held */
5036
void
5037
nfs4_state_shutdown_net(struct net *net)
L
Linus Torvalds 已提交
5038 5039 5040
{
	struct nfs4_delegation *dp = NULL;
	struct list_head *pos, *next, reaplist;
5041
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
L
Linus Torvalds 已提交
5042

5043 5044
	cancel_delayed_work_sync(&nn->laundromat_work);
	locks_end_grace(&nn->nfsd4_manager);
5045

L
Linus Torvalds 已提交
5046 5047
	INIT_LIST_HEAD(&reaplist);
	spin_lock(&recall_lock);
5048
	list_for_each_safe(pos, next, &nn->del_recall_lru) {
L
Linus Torvalds 已提交
5049 5050 5051 5052 5053 5054
		dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
		list_move(&dp->dl_recall_lru, &reaplist);
	}
	spin_unlock(&recall_lock);
	list_for_each_safe(pos, next, &reaplist) {
		dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
5055
		destroy_delegation(dp);
L
Linus Torvalds 已提交
5056 5057
	}

5058
	nfsd4_client_tracking_exit(net);
5059
	nfs4_state_destroy_net(net);
L
Linus Torvalds 已提交
5060 5061 5062 5063 5064
}

void
nfs4_state_shutdown(void)
{
5065
	destroy_workqueue(laundry_wq);
5066
	nfsd4_destroy_callback_queue();
L
Linus Torvalds 已提交
5067
}
5068 5069 5070 5071

static void
get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
{
5072 5073
	if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG) && CURRENT_STATEID(stateid))
		memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
5074 5075 5076 5077 5078
}

static void
put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
{
5079 5080 5081 5082 5083 5084 5085 5086 5087 5088
	if (cstate->minorversion) {
		memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
		SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
	}
}

void
clear_current_stateid(struct nfsd4_compound_state *cstate)
{
	CLEAR_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
5089 5090
}

5091 5092 5093
/*
 * functions to set current state id
 */
5094 5095 5096 5097 5098 5099
void
nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
{
	put_stateid(cstate, &odp->od_stateid);
}

5100 5101 5102 5103 5104 5105
void
nfsd4_set_openstateid(struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
{
	put_stateid(cstate, &open->op_stateid);
}

5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120
void
nfsd4_set_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
{
	put_stateid(cstate, &close->cl_stateid);
}

void
nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate, struct nfsd4_lock *lock)
{
	put_stateid(cstate, &lock->lk_resp_stateid);
}

/*
 * functions to consume current state id
 */
5121

5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133
void
nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
{
	get_stateid(cstate, &odp->od_stateid);
}

void
nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate, struct nfsd4_delegreturn *drp)
{
	get_stateid(cstate, &drp->dr_stateid);
}

5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145
void
nfsd4_get_freestateid(struct nfsd4_compound_state *cstate, struct nfsd4_free_stateid *fsp)
{
	get_stateid(cstate, &fsp->fr_stateid);
}

void
nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate, struct nfsd4_setattr *setattr)
{
	get_stateid(cstate, &setattr->sa_stateid);
}

5146 5147 5148 5149 5150 5151 5152
void
nfsd4_get_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
{
	get_stateid(cstate, &close->cl_stateid);
}

void
5153
nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate, struct nfsd4_locku *locku)
5154
{
5155
	get_stateid(cstate, &locku->lu_stateid);
5156
}
5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168

void
nfsd4_get_readstateid(struct nfsd4_compound_state *cstate, struct nfsd4_read *read)
{
	get_stateid(cstate, &read->rd_stateid);
}

void
nfsd4_get_writestateid(struct nfsd4_compound_state *cstate, struct nfsd4_write *write)
{
	get_stateid(cstate, &write->wr_stateid);
}