nfs4state.c 109.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
/*
*  linux/fs/nfsd/nfs4state.c
*
*  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.
*
*/

#include <linux/param.h>
#include <linux/major.h>
#include <linux/slab.h>

#include <linux/sunrpc/svc.h>
#include <linux/nfsd/nfsd.h>
#include <linux/nfsd/cache.h>
44
#include <linux/file.h>
L
Linus Torvalds 已提交
45 46 47 48 49 50 51
#include <linux/mount.h>
#include <linux/workqueue.h>
#include <linux/smp_lock.h>
#include <linux/kthread.h>
#include <linux/nfs4.h>
#include <linux/nfsd/state.h>
#include <linux/nfsd/xdr4.h>
52
#include <linux/namei.h>
53
#include <linux/swap.h>
I
Ingo Molnar 已提交
54
#include <linux/mutex.h>
55
#include <linux/lockd/bind.h>
56
#include <linux/module.h>
57
#include <linux/sunrpc/svcauth_gss.h>
L
Linus Torvalds 已提交
58 59 60 61 62

#define NFSDDBG_FACILITY                NFSDDBG_PROC

/* Globals */
static time_t lease_time = 90;     /* default lease time */
63
static time_t user_lease_time = 90;
64
static time_t boot_time;
L
Linus Torvalds 已提交
65 66 67 68
static u32 current_ownerid = 1;
static u32 current_fileid = 1;
static u32 current_delegid = 1;
static u32 nfs4_init;
69 70
static stateid_t zerostateid;             /* bits all 0 */
static stateid_t onestateid;              /* bits all 1 */
A
Andy Adamson 已提交
71
static u64 current_sessionid = 1;
72 73 74

#define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
#define ONE_STATEID(stateid)  (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
L
Linus Torvalds 已提交
75 76

/* forward declarations */
77
static struct nfs4_stateid * find_stateid(stateid_t *stid, int flags);
L
Linus Torvalds 已提交
78
static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid);
79 80
static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
static void nfs4_set_recdir(char *recdir);
L
Linus Torvalds 已提交
81

82 83 84
/* Locking: */

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

87 88 89 90 91 92 93
/*
 * 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);

94 95 96 97
static struct kmem_cache *stateowner_slab = NULL;
static struct kmem_cache *file_slab = NULL;
static struct kmem_cache *stateid_slab = NULL;
static struct kmem_cache *deleg_slab = NULL;
N
NeilBrown 已提交
98

L
Linus Torvalds 已提交
99 100 101
void
nfs4_lock_state(void)
{
I
Ingo Molnar 已提交
102
	mutex_lock(&client_mutex);
L
Linus Torvalds 已提交
103 104 105 106 107
}

void
nfs4_unlock_state(void)
{
I
Ingo Molnar 已提交
108
	mutex_unlock(&client_mutex);
L
Linus Torvalds 已提交
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
}

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

static struct list_head del_recall_lru;

126 127 128
static inline void
put_nfs4_file(struct nfs4_file *fi)
{
129 130 131 132 133 134
	if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
		list_del(&fi->fi_hash);
		spin_unlock(&recall_lock);
		iput(fi->fi_inode);
		kmem_cache_free(file_slab, fi);
	}
135 136 137 138 139
}

static inline void
get_nfs4_file(struct nfs4_file *fi)
{
140
	atomic_inc(&fi->fi_ref);
141 142
}

143
static int num_delegations;
144
unsigned int max_delegations;
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

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

/* hash tables for nfs4_stateowner */
#define OWNER_HASH_BITS              8
#define OWNER_HASH_SIZE             (1 << OWNER_HASH_BITS)
#define OWNER_HASH_MASK             (OWNER_HASH_SIZE - 1)

#define ownerid_hashval(id) \
        ((id) & OWNER_HASH_MASK)
#define ownerstr_hashval(clientid, ownername) \
        (((clientid) + opaque_hashval((ownername.data), (ownername.len))) & OWNER_HASH_MASK)

static struct list_head	ownerid_hashtbl[OWNER_HASH_SIZE];
static struct list_head	ownerstr_hashtbl[OWNER_HASH_SIZE];

/* hash table for nfs4_file */
#define FILE_HASH_BITS                   8
#define FILE_HASH_SIZE                  (1 << FILE_HASH_BITS)
#define FILE_HASH_MASK                  (FILE_HASH_SIZE - 1)
/* hash table for (open)nfs4_stateid */
#define STATEID_HASH_BITS              10
#define STATEID_HASH_SIZE              (1 << STATEID_HASH_BITS)
#define STATEID_HASH_MASK              (STATEID_HASH_SIZE - 1)

#define file_hashval(x) \
        hash_ptr(x, FILE_HASH_BITS)
#define stateid_hashval(owner_id, file_id)  \
        (((owner_id) + (file_id)) & STATEID_HASH_MASK)

static struct list_head file_hashtbl[FILE_HASH_SIZE];
static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];

L
Linus Torvalds 已提交
180 181 182 183 184 185 186 187
static struct nfs4_delegation *
alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_fh *current_fh, u32 type)
{
	struct nfs4_delegation *dp;
	struct nfs4_file *fp = stp->st_file;
	struct nfs4_callback *cb = &stp->st_stateowner->so_client->cl_callback;

	dprintk("NFSD alloc_init_deleg\n");
188 189
	if (fp->fi_had_conflict)
		return NULL;
190
	if (num_delegations > max_delegations)
191
		return NULL;
N
NeilBrown 已提交
192 193
	dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
	if (dp == NULL)
L
Linus Torvalds 已提交
194
		return dp;
195
	num_delegations++;
196 197
	INIT_LIST_HEAD(&dp->dl_perfile);
	INIT_LIST_HEAD(&dp->dl_perclnt);
L
Linus Torvalds 已提交
198 199
	INIT_LIST_HEAD(&dp->dl_recall_lru);
	dp->dl_client = clp;
200
	get_nfs4_file(fp);
L
Linus Torvalds 已提交
201 202 203 204 205 206 207 208 209 210 211 212
	dp->dl_file = fp;
	dp->dl_flock = NULL;
	get_file(stp->st_vfs_file);
	dp->dl_vfs_file = stp->st_vfs_file;
	dp->dl_type = type;
	dp->dl_recall.cbr_dp = NULL;
	dp->dl_recall.cbr_ident = cb->cb_ident;
	dp->dl_recall.cbr_trunc = 0;
	dp->dl_stateid.si_boot = boot_time;
	dp->dl_stateid.si_stateownerid = current_delegid++;
	dp->dl_stateid.si_fileid = 0;
	dp->dl_stateid.si_generation = 0;
213
	fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
L
Linus Torvalds 已提交
214 215
	dp->dl_time = 0;
	atomic_set(&dp->dl_count, 1);
216 217
	list_add(&dp->dl_perfile, &fp->fi_delegations);
	list_add(&dp->dl_perclnt, &clp->cl_delegations);
L
Linus Torvalds 已提交
218 219 220 221 222 223 224 225
	return dp;
}

void
nfs4_put_delegation(struct nfs4_delegation *dp)
{
	if (atomic_dec_and_test(&dp->dl_count)) {
		dprintk("NFSD: freeing dp %p\n",dp);
226
		put_nfs4_file(dp->dl_file);
N
NeilBrown 已提交
227
		kmem_cache_free(deleg_slab, dp);
228
		num_delegations--;
L
Linus Torvalds 已提交
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
	}
}

/* Remove the associated file_lock first, then remove the delegation.
 * lease_modify() is called to remove the FS_LEASE file_lock from
 * the i_flock list, eventually calling nfsd's lock_manager
 * fl_release_callback.
 */
static void
nfs4_close_delegation(struct nfs4_delegation *dp)
{
	struct file *filp = dp->dl_vfs_file;

	dprintk("NFSD: close_delegation dp %p\n",dp);
	dp->dl_vfs_file = NULL;
	/* The following nfsd_close may not actually close the file,
	 * but we want to remove the lease in any case. */
N
NeilBrown 已提交
246
	if (dp->dl_flock)
247
		vfs_setlease(filp, F_UNLCK, &dp->dl_flock);
L
Linus Torvalds 已提交
248 249 250 251 252 253 254
	nfsd_close(filp);
}

/* Called under the state lock. */
static void
unhash_delegation(struct nfs4_delegation *dp)
{
255 256
	list_del_init(&dp->dl_perfile);
	list_del_init(&dp->dl_perclnt);
L
Linus Torvalds 已提交
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
	spin_lock(&recall_lock);
	list_del_init(&dp->dl_recall_lru);
	spin_unlock(&recall_lock);
	nfs4_close_delegation(dp);
	nfs4_put_delegation(dp);
}

/* 
 * SETCLIENTID state 
 */

/* Hash tables for nfs4_clientid state */
#define CLIENT_HASH_BITS                 4
#define CLIENT_HASH_SIZE                (1 << CLIENT_HASH_BITS)
#define CLIENT_HASH_MASK                (CLIENT_HASH_SIZE - 1)

#define clientid_hashval(id) \
	((id) & CLIENT_HASH_MASK)
N
NeilBrown 已提交
275 276
#define clientstr_hashval(name) \
	(opaque_hashval((name), 8) & CLIENT_HASH_MASK)
L
Linus Torvalds 已提交
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
/*
 * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
 * used in reboot/reset lease grace period processing
 *
 * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
 * setclientid_confirmed info. 
 *
 * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed 
 * setclientid info.
 *
 * client_lru holds client queue ordered by nfs4_client.cl_time
 * for lease renewal.
 *
 * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
 * for last close replay.
 */
static struct list_head	reclaim_str_hashtbl[CLIENT_HASH_SIZE];
static int reclaim_str_hashtbl_size = 0;
static struct list_head	conf_id_hashtbl[CLIENT_HASH_SIZE];
static struct list_head	conf_str_hashtbl[CLIENT_HASH_SIZE];
static struct list_head	unconf_str_hashtbl[CLIENT_HASH_SIZE];
static struct list_head	unconf_id_hashtbl[CLIENT_HASH_SIZE];
static struct list_head client_lru;
static struct list_head close_lru;

302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
static void unhash_generic_stateid(struct nfs4_stateid *stp)
{
	list_del(&stp->st_hash);
	list_del(&stp->st_perfile);
	list_del(&stp->st_perstateowner);
}

static void free_generic_stateid(struct nfs4_stateid *stp)
{
	put_nfs4_file(stp->st_file);
	kmem_cache_free(stateid_slab, stp);
}

static void release_lock_stateid(struct nfs4_stateid *stp)
{
	unhash_generic_stateid(stp);
	locks_remove_posix(stp->st_vfs_file, (fl_owner_t)stp->st_stateowner);
	free_generic_stateid(stp);
}

322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
static void unhash_lockowner(struct nfs4_stateowner *sop)
{
	struct nfs4_stateid *stp;

	list_del(&sop->so_idhash);
	list_del(&sop->so_strhash);
	list_del(&sop->so_perstateid);
	while (!list_empty(&sop->so_stateids)) {
		stp = list_first_entry(&sop->so_stateids,
				struct nfs4_stateid, st_perstateowner);
		release_lock_stateid(stp);
	}
}

static void release_lockowner(struct nfs4_stateowner *sop)
{
	unhash_lockowner(sop);
	nfs4_put_stateowner(sop);
}

342 343 344 345 346 347 348 349 350 351
static void
release_stateid_lockowners(struct nfs4_stateid *open_stp)
{
	struct nfs4_stateowner *lock_sop;

	while (!list_empty(&open_stp->st_lockowners)) {
		lock_sop = list_entry(open_stp->st_lockowners.next,
				struct nfs4_stateowner, so_perstateid);
		/* list_del(&open_stp->st_lockowners);  */
		BUG_ON(lock_sop->so_is_open_owner);
352
		release_lockowner(lock_sop);
353 354 355
	}
}

356 357 358 359 360 361 362 363
static void release_open_stateid(struct nfs4_stateid *stp)
{
	unhash_generic_stateid(stp);
	release_stateid_lockowners(stp);
	nfsd_close(stp->st_vfs_file);
	free_generic_stateid(stp);
}

364
static void unhash_openowner(struct nfs4_stateowner *sop)
365 366 367 368 369
{
	struct nfs4_stateid *stp;

	list_del(&sop->so_idhash);
	list_del(&sop->so_strhash);
370 371
	list_del(&sop->so_perclient);
	list_del(&sop->so_perstateid); /* XXX: necessary? */
372
	while (!list_empty(&sop->so_stateids)) {
373 374 375
		stp = list_first_entry(&sop->so_stateids,
				struct nfs4_stateid, st_perstateowner);
		release_open_stateid(stp);
376 377 378
	}
}

379
static void release_openowner(struct nfs4_stateowner *sop)
380
{
381
	unhash_openowner(sop);
382 383 384 385
	list_del(&sop->so_close_lru);
	nfs4_put_stateowner(sop);
}

M
Marc Eshel 已提交
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
static DEFINE_SPINLOCK(sessionid_lock);
#define SESSION_HASH_SIZE	512
static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];

static inline int
hash_sessionid(struct nfs4_sessionid *sessionid)
{
	struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;

	return sid->sequence % SESSION_HASH_SIZE;
}

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

A
Andy Adamson 已提交
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529
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;
}

/*
 * Give the client the number of slots it requests bound by
 * NFSD_MAX_SLOTS_PER_SESSION and by sv_drc_max_pages.
 *
 * If we run out of pages (sv_drc_pages_used == sv_drc_max_pages) we
 * should (up to a point) re-negotiate active sessions and reduce their
 * slot usage to make rooom for new connections. For now we just fail the
 * create session.
 */
static int set_forechannel_maxreqs(struct nfsd4_channel_attrs *fchan)
{
	int status = 0, np = fchan->maxreqs * NFSD_PAGES_PER_SLOT;

	spin_lock(&nfsd_serv->sv_lock);
	if (np + nfsd_serv->sv_drc_pages_used > nfsd_serv->sv_drc_max_pages)
		np = nfsd_serv->sv_drc_max_pages - nfsd_serv->sv_drc_pages_used;
	nfsd_serv->sv_drc_pages_used += np;
	spin_unlock(&nfsd_serv->sv_lock);

	if (np <= 0) {
		status = nfserr_resource;
		fchan->maxreqs = 0;
	} else
		fchan->maxreqs = np / NFSD_PAGES_PER_SLOT;

	return status;
}

/*
 * fchan holds the client values on input, and the server values on output
 */
static int init_forechannel_attrs(struct svc_rqst *rqstp,
				    struct nfsd4_session *session,
				    struct nfsd4_channel_attrs *fchan)
{
	int status = 0;
	__u32   maxcount = svc_max_payload(rqstp);

	/* headerpadsz set to zero in encode routine */

	/* Use the client's max request and max response size if possible */
	if (fchan->maxreq_sz > maxcount)
		fchan->maxreq_sz = maxcount;
	session->se_fmaxreq_sz = fchan->maxreq_sz;

	if (fchan->maxresp_sz > maxcount)
		fchan->maxresp_sz = maxcount;
	session->se_fmaxresp_sz = fchan->maxresp_sz;

	/* Set the max response cached size our default which is
	 * a multiple of PAGE_SIZE and small */
	session->se_fmaxresp_cached = NFSD_PAGES_PER_SLOT * PAGE_SIZE;
	fchan->maxresp_cached = session->se_fmaxresp_cached;

	/* Use the client's maxops if possible */
	if (fchan->maxops > NFSD_MAX_OPS_PER_COMPOUND)
		fchan->maxops = NFSD_MAX_OPS_PER_COMPOUND;
	session->se_fmaxops = fchan->maxops;

	/* try to use the client requested number of slots */
	if (fchan->maxreqs > NFSD_MAX_SLOTS_PER_SESSION)
		fchan->maxreqs = NFSD_MAX_SLOTS_PER_SESSION;

	/* FIXME: Error means no more DRC pages so the server should
	 * recover pages from existing sessions. For now fail session
	 * creation.
	 */
	status = set_forechannel_maxreqs(fchan);

	session->se_fnumslots = fchan->maxreqs;
	return status;
}

static int
alloc_init_session(struct svc_rqst *rqstp, struct nfs4_client *clp,
		   struct nfsd4_create_session *cses)
{
	struct nfsd4_session *new, tmp;
	int idx, status = nfserr_resource, slotsize;

	memset(&tmp, 0, sizeof(tmp));

	/* FIXME: For now, we just accept the client back channel attributes. */
	status = init_forechannel_attrs(rqstp, &tmp, &cses->fore_channel);
	if (status)
		goto out;

	/* allocate struct nfsd4_session and slot table in one piece */
	slotsize = tmp.se_fnumslots * sizeof(struct nfsd4_slot);
	new = kzalloc(sizeof(*new) + slotsize, GFP_KERNEL);
	if (!new)
		goto out;

	memcpy(new, &tmp, sizeof(*new));

	new->se_client = clp;
	gen_sessionid(new);
	idx = hash_sessionid(&new->se_sessionid);
	memcpy(clp->cl_sessionid.data, new->se_sessionid.data,
	       NFS4_MAX_SESSIONID_LEN);

	new->se_flags = cses->flags;
	kref_init(&new->se_ref);
	spin_lock(&sessionid_lock);
	list_add(&new->se_hash, &sessionid_hashtbl[idx]);
	list_add(&new->se_perclnt, &clp->cl_sessions);
	spin_unlock(&sessionid_lock);

	status = nfs_ok;
out:
	return status;
}

M
Marc Eshel 已提交
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
/* caller must hold sessionid_lock */
static struct nfsd4_session *
find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
{
	struct nfsd4_session *elem;
	int idx;

	dump_sessionid(__func__, sessionid);
	idx = hash_sessionid(sessionid);
	dprintk("%s: idx is %d\n", __func__, idx);
	/* Search in the appropriate list */
	list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
		dump_sessionid("list traversal", &elem->se_sessionid);
		if (!memcmp(elem->se_sessionid.data, sessionid->data,
			    NFS4_MAX_SESSIONID_LEN)) {
			return elem;
		}
	}

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

/* caller must hold sessionid_lock */
A
Andy Adamson 已提交
554
static void
M
Marc Eshel 已提交
555
unhash_session(struct nfsd4_session *ses)
A
Andy Adamson 已提交
556 557 558
{
	list_del(&ses->se_hash);
	list_del(&ses->se_perclnt);
M
Marc Eshel 已提交
559 560 561 562 563 564 565 566
}

static void
release_session(struct nfsd4_session *ses)
{
	spin_lock(&sessionid_lock);
	unhash_session(ses);
	spin_unlock(&sessionid_lock);
A
Andy Adamson 已提交
567 568 569
	nfsd4_put_session(ses);
}

570 571
static void nfsd4_release_respages(struct page **respages, short resused);

A
Andy Adamson 已提交
572 573 574 575
void
free_session(struct kref *kref)
{
	struct nfsd4_session *ses;
576
	int i;
A
Andy Adamson 已提交
577 578

	ses = container_of(kref, struct nfsd4_session, se_ref);
579 580 581 582
	for (i = 0; i < ses->se_fnumslots; i++) {
		struct nfsd4_cache_entry *e = &ses->se_slots[i].sl_cache_entry;
		nfsd4_release_respages(e->ce_respages, e->ce_resused);
	}
A
Andy Adamson 已提交
583 584 585 586
	kfree(ses->se_slots);
	kfree(ses);
}

L
Linus Torvalds 已提交
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
static inline void
renew_client(struct nfs4_client *clp)
{
	/*
	* Move client to the end to the LRU list.
	*/
	dprintk("renewing client (clientid %08x/%08x)\n", 
			clp->cl_clientid.cl_boot, 
			clp->cl_clientid.cl_id);
	list_move_tail(&clp->cl_lru, &client_lru);
	clp->cl_time = get_seconds();
}

/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
static int
STALE_CLIENTID(clientid_t *clid)
{
	if (clid->cl_boot == boot_time)
		return 0;
A
Andy Adamson 已提交
606 607
	dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
		clid->cl_boot, clid->cl_id, boot_time);
L
Linus Torvalds 已提交
608 609 610 611 612 613 614 615
	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.
 */
616
static struct nfs4_client *alloc_client(struct xdr_netobj name)
L
Linus Torvalds 已提交
617 618 619
{
	struct nfs4_client *clp;

620 621 622 623 624 625 626
	clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
	if (clp == NULL)
		return NULL;
	clp->cl_name.data = kmalloc(name.len, GFP_KERNEL);
	if (clp->cl_name.data == NULL) {
		kfree(clp);
		return NULL;
L
Linus Torvalds 已提交
627
	}
628 629
	memcpy(clp->cl_name.data, name.data, name.len);
	clp->cl_name.len = name.len;
L
Linus Torvalds 已提交
630 631 632
	return clp;
}

633 634 635 636 637 638
static void
shutdown_callback_client(struct nfs4_client *clp)
{
	struct rpc_clnt *clnt = clp->cl_callback.cb_client;

	if (clnt) {
639 640 641 642
		/*
		 * Callback threads take a reference on the client, so there
		 * should be no outstanding callbacks at this point.
		 */
643 644 645 646 647
		clp->cl_callback.cb_client = NULL;
		rpc_shutdown_client(clnt);
	}
}

L
Linus Torvalds 已提交
648 649 650
static inline void
free_client(struct nfs4_client *clp)
{
651
	shutdown_callback_client(clp);
652 653
	nfsd4_release_respages(clp->cl_slot.sl_cache_entry.ce_respages,
			     clp->cl_slot.sl_cache_entry.ce_resused);
L
Linus Torvalds 已提交
654 655
	if (clp->cl_cred.cr_group_info)
		put_group_info(clp->cl_cred.cr_group_info);
656
	kfree(clp->cl_principal);
L
Linus Torvalds 已提交
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679
	kfree(clp->cl_name.data);
	kfree(clp);
}

void
put_nfs4_client(struct nfs4_client *clp)
{
	if (atomic_dec_and_test(&clp->cl_count))
		free_client(clp);
}

static void
expire_client(struct nfs4_client *clp)
{
	struct nfs4_stateowner *sop;
	struct nfs4_delegation *dp;
	struct list_head reaplist;

	dprintk("NFSD: expire_client cl_count %d\n",
	                    atomic_read(&clp->cl_count));

	INIT_LIST_HEAD(&reaplist);
	spin_lock(&recall_lock);
680 681
	while (!list_empty(&clp->cl_delegations)) {
		dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
L
Linus Torvalds 已提交
682 683
		dprintk("NFSD: expire client. dp %p, fp %p\n", dp,
				dp->dl_flock);
684
		list_del_init(&dp->dl_perclnt);
L
Linus Torvalds 已提交
685 686 687 688 689 690 691 692 693 694 695
		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);
		list_del_init(&dp->dl_recall_lru);
		unhash_delegation(dp);
	}
	list_del(&clp->cl_idhash);
	list_del(&clp->cl_strhash);
	list_del(&clp->cl_lru);
696 697
	while (!list_empty(&clp->cl_openowners)) {
		sop = list_entry(clp->cl_openowners.next, struct nfs4_stateowner, so_perclient);
698
		release_openowner(sop);
L
Linus Torvalds 已提交
699
	}
700 701 702 703 704 705
	while (!list_empty(&clp->cl_sessions)) {
		struct nfsd4_session  *ses;
		ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
				 se_perclnt);
		release_session(ses);
	}
L
Linus Torvalds 已提交
706 707 708
	put_nfs4_client(clp);
}

709 710
static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir)
{
L
Linus Torvalds 已提交
711 712
	struct nfs4_client *clp;

713 714 715
	clp = alloc_client(name);
	if (clp == NULL)
		return NULL;
N
NeilBrown 已提交
716
	memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
L
Linus Torvalds 已提交
717 718 719 720
	atomic_set(&clp->cl_count, 1);
	atomic_set(&clp->cl_callback.cb_set, 0);
	INIT_LIST_HEAD(&clp->cl_idhash);
	INIT_LIST_HEAD(&clp->cl_strhash);
721 722
	INIT_LIST_HEAD(&clp->cl_openowners);
	INIT_LIST_HEAD(&clp->cl_delegations);
723
	INIT_LIST_HEAD(&clp->cl_sessions);
L
Linus Torvalds 已提交
724 725 726 727
	INIT_LIST_HEAD(&clp->cl_lru);
	return clp;
}

728 729 730 731
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 已提交
732 733
}

734 735
static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
{
L
Linus Torvalds 已提交
736 737 738 739
	target->cl_clientid.cl_boot = source->cl_clientid.cl_boot; 
	target->cl_clientid.cl_id = source->cl_clientid.cl_id; 
}

740 741
static void copy_cred(struct svc_cred *target, struct svc_cred *source)
{
L
Linus Torvalds 已提交
742 743 744 745 746 747
	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);
}

748
static int same_name(const char *n1, const char *n2)
749
{
N
NeilBrown 已提交
750
	return 0 == memcmp(n1, n2, HEXDIR_LEN);
L
Linus Torvalds 已提交
751 752 753
}

static int
754 755 756
same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
{
	return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
L
Linus Torvalds 已提交
757 758 759
}

static int
760 761 762
same_clid(clientid_t *cl1, clientid_t *cl2)
{
	return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
L
Linus Torvalds 已提交
763 764 765 766
}

/* XXX what about NGROUP */
static int
767 768 769
same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
{
	return cr1->cr_uid == cr2->cr_uid;
L
Linus Torvalds 已提交
770 771
}

772 773 774 775
static void gen_clid(struct nfs4_client *clp)
{
	static u32 current_clientid = 1;

L
Linus Torvalds 已提交
776 777 778 779
	clp->cl_clientid.cl_boot = boot_time;
	clp->cl_clientid.cl_id = current_clientid++; 
}

780 781 782 783
static void gen_confirm(struct nfs4_client *clp)
{
	static u32 i;
	u32 *p;
L
Linus Torvalds 已提交
784 785

	p = (u32 *)clp->cl_confirm.data;
786 787
	*p++ = get_seconds();
	*p++ = i++;
L
Linus Torvalds 已提交
788 789
}

790 791
static int check_name(struct xdr_netobj name)
{
L
Linus Torvalds 已提交
792 793 794
	if (name.len == 0) 
		return 0;
	if (name.len > NFS4_OPAQUE_LIMIT) {
795
		dprintk("NFSD: check_name: name too long(%d)!\n", name.len);
L
Linus Torvalds 已提交
796 797 798 799 800
		return 0;
	}
	return 1;
}

801
static void
L
Linus Torvalds 已提交
802 803 804 805 806 807 808 809 810 811 812
add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
{
	unsigned int idhashval;

	list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
	idhashval = clientid_hashval(clp->cl_clientid.cl_id);
	list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
	list_add_tail(&clp->cl_lru, &client_lru);
	clp->cl_time = get_seconds();
}

813
static void
L
Linus Torvalds 已提交
814 815 816 817 818 819 820
move_to_confirmed(struct nfs4_client *clp)
{
	unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
	unsigned int strhashval;

	dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
	list_del_init(&clp->cl_strhash);
A
Akinobu Mita 已提交
821
	list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
N
NeilBrown 已提交
822
	strhashval = clientstr_hashval(clp->cl_recdir);
L
Linus Torvalds 已提交
823 824 825 826 827 828 829 830 831 832 833
	list_add(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
	renew_client(clp);
}

static struct nfs4_client *
find_confirmed_client(clientid_t *clid)
{
	struct nfs4_client *clp;
	unsigned int idhashval = clientid_hashval(clid->cl_id);

	list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
834
		if (same_clid(&clp->cl_clientid, clid))
L
Linus Torvalds 已提交
835 836 837 838 839 840 841 842 843 844 845 846
			return clp;
	}
	return NULL;
}

static struct nfs4_client *
find_unconfirmed_client(clientid_t *clid)
{
	struct nfs4_client *clp;
	unsigned int idhashval = clientid_hashval(clid->cl_id);

	list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
847
		if (same_clid(&clp->cl_clientid, clid))
L
Linus Torvalds 已提交
848 849 850 851 852
			return clp;
	}
	return NULL;
}

853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
/*
 * Return 1 iff clp's clientid establishment method matches the use_exchange_id
 * parameter. Matching is based on the fact the at least one of the
 * EXCHGID4_FLAG_USE_{NON_PNFS,PNFS_MDS,PNFS_DS} flags must be set for v4.1
 *
 * FIXME: we need to unify the clientid namespaces for nfsv4.x
 * and correctly deal with client upgrade/downgrade in EXCHANGE_ID
 * and SET_CLIENTID{,_CONFIRM}
 */
static inline int
match_clientid_establishment(struct nfs4_client *clp, bool use_exchange_id)
{
	bool has_exchange_flags = (clp->cl_exchange_flags != 0);
	return use_exchange_id == has_exchange_flags;
}

869
static struct nfs4_client *
870 871
find_confirmed_client_by_str(const char *dname, unsigned int hashval,
			     bool use_exchange_id)
872 873 874 875
{
	struct nfs4_client *clp;

	list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
876 877
		if (same_name(clp->cl_recdir, dname) &&
		    match_clientid_establishment(clp, use_exchange_id))
878 879 880 881 882 883
			return clp;
	}
	return NULL;
}

static struct nfs4_client *
884 885
find_unconfirmed_client_by_str(const char *dname, unsigned int hashval,
			       bool use_exchange_id)
886 887 888 889
{
	struct nfs4_client *clp;

	list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
890 891
		if (same_name(clp->cl_recdir, dname) &&
		    match_clientid_establishment(clp, use_exchange_id))
892 893 894 895 896
			return clp;
	}
	return NULL;
}

L
Linus Torvalds 已提交
897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930
/* a helper function for parse_callback */
static int
parse_octet(unsigned int *lenp, char **addrp)
{
	unsigned int len = *lenp;
	char *p = *addrp;
	int n = -1;
	char c;

	for (;;) {
		if (!len)
			break;
		len--;
		c = *p++;
		if (c == '.')
			break;
		if ((c < '0') || (c > '9')) {
			n = -1;
			break;
		}
		if (n < 0)
			n = 0;
		n = (n * 10) + (c - '0');
		if (n > 255) {
			n = -1;
			break;
		}
	}
	*lenp = len;
	*addrp = p;
	return n;
}

/* parse and set the setclientid ipv4 callback address */
931
static int
L
Linus Torvalds 已提交
932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
parse_ipv4(unsigned int addr_len, char *addr_val, unsigned int *cbaddrp, unsigned short *cbportp)
{
	int temp = 0;
	u32 cbaddr = 0;
	u16 cbport = 0;
	u32 addrlen = addr_len;
	char *addr = addr_val;
	int i, shift;

	/* ipaddress */
	shift = 24;
	for(i = 4; i > 0  ; i--) {
		if ((temp = parse_octet(&addrlen, &addr)) < 0) {
			return 0;
		}
		cbaddr |= (temp << shift);
		if (shift > 0)
		shift -= 8;
	}
	*cbaddrp = cbaddr;

	/* port */
	shift = 8;
	for(i = 2; i > 0  ; i--) {
		if ((temp = parse_octet(&addrlen, &addr)) < 0) {
			return 0;
		}
		cbport |= (temp << shift);
		if (shift > 0)
			shift -= 8;
	}
	*cbportp = cbport;
	return 1;
}

967
static void
L
Linus Torvalds 已提交
968 969 970 971 972 973 974 975 976 977 978 979 980 981 982
gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se)
{
	struct nfs4_callback *cb = &clp->cl_callback;

	/* Currently, we only support tcp for the callback channel */
	if ((se->se_callback_netid_len != 3) || memcmp((char *)se->se_callback_netid_val, "tcp", 3))
		goto out_err;

	if ( !(parse_ipv4(se->se_callback_addr_len, se->se_callback_addr_val,
	                 &cb->cb_addr, &cb->cb_port)))
		goto out_err;
	cb->cb_prog = se->se_callback_prog;
	cb->cb_ident = se->se_callback_ident;
	return;
out_err:
N
Neil Brown 已提交
983
	dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
L
Linus Torvalds 已提交
984 985 986 987 988 989
		"will not receive delegations\n",
		clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);

	return;
}

990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
void
nfsd4_set_statp(struct svc_rqst *rqstp, __be32 *statp)
{
	struct nfsd4_compoundres *resp = rqstp->rq_resp;

	resp->cstate.statp = statp;
}

/*
 * Dereference the result pages.
 */
static void
nfsd4_release_respages(struct page **respages, short resused)
{
	int i;

	dprintk("--> %s\n", __func__);
	for (i = 0; i < resused; i++) {
		if (!respages[i])
			continue;
		put_page(respages[i]);
		respages[i] = NULL;
	}
}

static void
nfsd4_copy_pages(struct page **topages, struct page **frompages, short count)
{
	int i;

	for (i = 0; i < count; i++) {
		topages[i] = frompages[i];
		if (!topages[i])
			continue;
		get_page(topages[i]);
	}
}

/*
 * Cache the reply pages up to NFSD_PAGES_PER_SLOT + 1, clearing the previous
 * pages. We add a page to NFSD_PAGES_PER_SLOT for the case where the total
 * length of the XDR response is less than se_fmaxresp_cached
 * (NFSD_PAGES_PER_SLOT * PAGE_SIZE) but the xdr_buf pages is used for a
 * of the reply (e.g. readdir).
 *
 * Store the base and length of the rq_req.head[0] page
 * of the NFSv4.1 data, just past the rpc header.
 */
void
nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
{
	struct nfsd4_cache_entry *entry = &resp->cstate.slot->sl_cache_entry;
	struct svc_rqst *rqstp = resp->rqstp;
	struct nfsd4_compoundargs *args = rqstp->rq_argp;
	struct nfsd4_op *op = &args->ops[resp->opcnt];
	struct kvec *resv = &rqstp->rq_res.head[0];

	dprintk("--> %s entry %p\n", __func__, entry);

	/* Don't cache a failed OP_SEQUENCE. */
	if (resp->opcnt == 1 && op->opnum == OP_SEQUENCE && resp->cstate.status)
		return;
1052

1053
	nfsd4_release_respages(entry->ce_respages, entry->ce_resused);
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
	entry->ce_opcnt = resp->opcnt;
	entry->ce_status = resp->cstate.status;

	/*
	 * Don't need a page to cache just the sequence operation - the slot
	 * does this for us!
	 */

	if (nfsd4_not_cached(resp)) {
		entry->ce_resused = 0;
		entry->ce_rpchdrlen = 0;
		dprintk("%s Just cache SEQUENCE. ce_cachethis %d\n", __func__,
			resp->cstate.slot->sl_cache_entry.ce_cachethis);
		return;
	}
1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
	entry->ce_resused = rqstp->rq_resused;
	if (entry->ce_resused > NFSD_PAGES_PER_SLOT + 1)
		entry->ce_resused = NFSD_PAGES_PER_SLOT + 1;
	nfsd4_copy_pages(entry->ce_respages, rqstp->rq_respages,
			 entry->ce_resused);
	entry->ce_datav.iov_base = resp->cstate.statp;
	entry->ce_datav.iov_len = resv->iov_len - ((char *)resp->cstate.statp -
				(char *)page_address(rqstp->rq_respages[0]));
	/* Current request rpc header length*/
	entry->ce_rpchdrlen = (char *)resp->cstate.statp -
				(char *)page_address(rqstp->rq_respages[0]);
}

/*
 * We keep the rpc header, but take the nfs reply from the replycache.
 */
static int
nfsd41_copy_replay_data(struct nfsd4_compoundres *resp,
			struct nfsd4_cache_entry *entry)
{
	struct svc_rqst *rqstp = resp->rqstp;
	struct kvec *resv = &resp->rqstp->rq_res.head[0];
	int len;

	/* Current request rpc header length*/
	len = (char *)resp->cstate.statp -
			(char *)page_address(rqstp->rq_respages[0]);
	if (entry->ce_datav.iov_len + len > PAGE_SIZE) {
		dprintk("%s v41 cached reply too large (%Zd).\n", __func__,
			entry->ce_datav.iov_len);
		return 0;
	}
	/* copy the cached reply nfsd data past the current rpc header */
	memcpy((char *)resv->iov_base + len, entry->ce_datav.iov_base,
		entry->ce_datav.iov_len);
	resv->iov_len = len + entry->ce_datav.iov_len;
	return 1;
}

/*
 * Keep the first page of the replay. Copy the NFSv4.1 data from the first
 * cached page.  Replace any futher replay pages from the cache.
 */
__be32
1113 1114
nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
			 struct nfsd4_sequence *seq)
1115 1116 1117 1118 1119 1120
{
	struct nfsd4_cache_entry *entry = &resp->cstate.slot->sl_cache_entry;
	__be32 status;

	dprintk("--> %s entry %p\n", __func__, entry);

1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
	/*
	 * If this is just the sequence operation, we did not keep
	 * a page in the cache entry because we can just use the
	 * slot info stored in struct nfsd4_sequence that was checked
	 * against the slot in nfsd4_sequence().
	 *
	 * This occurs when seq->cachethis is FALSE, or when the client
	 * session inactivity timer fires and a solo sequence operation
	 * is sent (lease renewal).
	 */
	if (seq && nfsd4_not_cached(resp)) {
		seq->maxslots = resp->cstate.session->se_fnumslots;
		return nfs_ok;
	}
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155

	if (!nfsd41_copy_replay_data(resp, entry)) {
		/*
		 * Not enough room to use the replay rpc header, send the
		 * cached header. Release all the allocated result pages.
		 */
		svc_free_res_pages(resp->rqstp);
		nfsd4_copy_pages(resp->rqstp->rq_respages, entry->ce_respages,
			entry->ce_resused);
	} else {
		/* Release all but the first allocated result page */

		resp->rqstp->rq_resused--;
		svc_free_res_pages(resp->rqstp);

		nfsd4_copy_pages(&resp->rqstp->rq_respages[1],
				 &entry->ce_respages[1],
				 entry->ce_resused - 1);
	}

	resp->rqstp->rq_resused = entry->ce_resused;
A
Andy Adamson 已提交
1156 1157
	resp->opcnt = entry->ce_opcnt;
	resp->cstate.iovlen = entry->ce_datav.iov_len + entry->ce_rpchdrlen;
1158 1159 1160 1161 1162
	status = entry->ce_status;

	return status;
}

A
Andy Adamson 已提交
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
/*
 * 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;
}

A
Andy Adamson 已提交
1179 1180 1181 1182 1183
__be32
nfsd4_exchange_id(struct svc_rqst *rqstp,
		  struct nfsd4_compound_state *cstate,
		  struct nfsd4_exchange_id *exid)
{
A
Andy Adamson 已提交
1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
	struct nfs4_client *unconf, *conf, *new;
	int status;
	unsigned int		strhashval;
	char			dname[HEXDIR_LEN];
	nfs4_verifier		verf = exid->verifier;
	u32			ip_addr = svc_addr_in(rqstp)->sin_addr.s_addr;

	dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
		" ip_addr=%u flags %x, spa_how %d\n",
		__func__, rqstp, exid, exid->clname.len, exid->clname.data,
		ip_addr, exid->flags, exid->spa_how);

	if (!check_name(exid->clname) || (exid->flags & ~EXCHGID4_FLAG_MASK_A))
		return nfserr_inval;

	/* Currently only support SP4_NONE */
	switch (exid->spa_how) {
	case SP4_NONE:
		break;
	case SP4_SSV:
		return nfserr_encr_alg_unsupp;
	default:
		BUG();				/* checked by xdr code */
	case SP4_MACH_CRED:
		return nfserr_serverfault;	/* no excuse :-/ */
	}

	status = nfs4_make_rec_clidname(dname, &exid->clname);

	if (status)
		goto error;

	strhashval = clientstr_hashval(dname);

	nfs4_lock_state();
	status = nfs_ok;

1221
	conf = find_confirmed_client_by_str(dname, strhashval, true);
A
Andy Adamson 已提交
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268
	if (conf) {
		if (!same_verf(&verf, &conf->cl_verifier)) {
			/* 18.35.4 case 8 */
			if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
				status = nfserr_not_same;
				goto out;
			}
			/* Client reboot: destroy old state */
			expire_client(conf);
			goto out_new;
		}
		if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
			/* 18.35.4 case 9 */
			if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
				status = nfserr_perm;
				goto out;
			}
			expire_client(conf);
			goto out_new;
		}
		if (ip_addr != conf->cl_addr &&
		    !(exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A)) {
			/* Client collision. 18.35.4 case 3 */
			status = nfserr_clid_inuse;
			goto out;
		}
		/*
		 * Set bit when the owner id and verifier map to an already
		 * confirmed client id (18.35.3).
		 */
		exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;

		/*
		 * Falling into 18.35.4 case 2, possible router replay.
		 * Leave confirmed record intact and return same result.
		 */
		copy_verf(conf, &verf);
		new = conf;
		goto out_copy;
	} else {
		/* 18.35.4 case 7 */
		if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
			status = nfserr_noent;
			goto out;
		}
	}

1269
	unconf  = find_unconfirmed_client_by_str(dname, strhashval, true);
A
Andy Adamson 已提交
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
	if (unconf) {
		/*
		 * Possible retry or client restart.  Per 18.35.4 case 4,
		 * a new unconfirmed record should be generated regardless
		 * of whether any properties have changed.
		 */
		expire_client(unconf);
	}

out_new:
	/* Normal case */
	new = create_client(exid->clname, dname);
	if (new == NULL) {
		status = nfserr_resource;
		goto out;
	}

	copy_verf(new, &verf);
	copy_cred(&new->cl_cred, &rqstp->rq_cred);
	new->cl_addr = ip_addr;
	gen_clid(new);
	gen_confirm(new);
	add_to_unconfirmed(new, strhashval);
out_copy:
	exid->clientid.cl_boot = new->cl_clientid.cl_boot;
	exid->clientid.cl_id = new->cl_clientid.cl_id;

1297 1298
	new->cl_slot.sl_seqid = 0;
	exid->seqid = 1;
A
Andy Adamson 已提交
1299 1300 1301
	nfsd4_set_ex_flags(new, exid);

	dprintk("nfsd4_exchange_id seqid %d flags %x\n",
1302
		new->cl_slot.sl_seqid, new->cl_exchange_flags);
A
Andy Adamson 已提交
1303 1304 1305 1306 1307 1308 1309
	status = nfs_ok;

out:
	nfs4_unlock_state();
error:
	dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
	return status;
A
Andy Adamson 已提交
1310 1311
}

B
Benny Halevy 已提交
1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
static int
check_slot_seqid(u32 seqid, struct nfsd4_slot *slot)
{
	dprintk("%s enter. seqid %d slot->sl_seqid %d\n", __func__, seqid,
		slot->sl_seqid);

	/* The slot is in use, and no response has been sent. */
	if (slot->sl_inuse) {
		if (seqid == slot->sl_seqid)
			return nfserr_jukebox;
		else
			return nfserr_seq_misordered;
	}
	/* Normal */
	if (likely(seqid == slot->sl_seqid + 1))
		return nfs_ok;
	/* Replay */
	if (seqid == slot->sl_seqid)
		return nfserr_replay_cache;
	/* Wraparound */
	if (seqid == 1 && (slot->sl_seqid + 1) == 0)
		return nfs_ok;
	/* Misordered replay or misordered new request */
	return nfserr_seq_misordered;
}

A
Andy Adamson 已提交
1338 1339 1340 1341 1342
__be32
nfsd4_create_session(struct svc_rqst *rqstp,
		     struct nfsd4_compound_state *cstate,
		     struct nfsd4_create_session *cr_ses)
{
A
Andy Adamson 已提交
1343
	u32 ip_addr = svc_addr_in(rqstp)->sin_addr.s_addr;
1344
	struct nfsd4_compoundres *resp = rqstp->rq_resp;
A
Andy Adamson 已提交
1345
	struct nfs4_client *conf, *unconf;
1346
	struct nfsd4_slot *slot = NULL;
A
Andy Adamson 已提交
1347 1348 1349 1350 1351 1352 1353
	int status = 0;

	nfs4_lock_state();
	unconf = find_unconfirmed_client(&cr_ses->clientid);
	conf = find_confirmed_client(&cr_ses->clientid);

	if (conf) {
1354 1355 1356
		slot = &conf->cl_slot;
		status = check_slot_seqid(cr_ses->seqid, slot);
		if (status == nfserr_replay_cache) {
A
Andy Adamson 已提交
1357
			dprintk("Got a create_session replay! seqid= %d\n",
1358 1359 1360 1361
				slot->sl_seqid);
			cstate->slot = slot;
			cstate->status = status;
			/* Return the cached reply status */
1362
			status = nfsd4_replay_cache_entry(resp, NULL);
1363 1364
			goto out;
		} else if (cr_ses->seqid != conf->cl_slot.sl_seqid + 1) {
A
Andy Adamson 已提交
1365 1366 1367
			status = nfserr_seq_misordered;
			dprintk("Sequence misordered!\n");
			dprintk("Expected seqid= %d but got seqid= %d\n",
1368
				slot->sl_seqid, cr_ses->seqid);
A
Andy Adamson 已提交
1369 1370
			goto out;
		}
1371
		conf->cl_slot.sl_seqid++;
A
Andy Adamson 已提交
1372 1373 1374 1375 1376 1377 1378
	} else if (unconf) {
		if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
		    (ip_addr != unconf->cl_addr)) {
			status = nfserr_clid_inuse;
			goto out;
		}

1379 1380 1381 1382
		slot = &unconf->cl_slot;
		status = check_slot_seqid(cr_ses->seqid, slot);
		if (status) {
			/* an unconfirmed replay returns misordered */
A
Andy Adamson 已提交
1383 1384 1385 1386
			status = nfserr_seq_misordered;
			goto out;
		}

1387
		slot->sl_seqid++; /* from 0 to 1 */
A
Andy Adamson 已提交
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
		move_to_confirmed(unconf);

		/*
		 * We do not support RDMA or persistent sessions
		 */
		cr_ses->flags &= ~SESSION4_PERSIST;
		cr_ses->flags &= ~SESSION4_RDMA;

		conf = unconf;
	} else {
		status = nfserr_stale_clientid;
		goto out;
	}

	status = alloc_init_session(rqstp, conf, cr_ses);
	if (status)
		goto out;

	memcpy(cr_ses->sessionid.data, conf->cl_sessionid.data,
	       NFS4_MAX_SESSIONID_LEN);
1408
	cr_ses->seqid = slot->sl_seqid;
A
Andy Adamson 已提交
1409

1410 1411
	slot->sl_inuse = true;
	cstate->slot = slot;
1412 1413
	/* Ensure a page is used for the cache */
	slot->sl_cache_entry.ce_cachethis = 1;
A
Andy Adamson 已提交
1414 1415 1416 1417
out:
	nfs4_unlock_state();
	dprintk("%s returns %d\n", __func__, ntohl(status));
	return status;
A
Andy Adamson 已提交
1418 1419 1420 1421 1422 1423 1424
}

__be32
nfsd4_destroy_session(struct svc_rqst *r,
		      struct nfsd4_compound_state *cstate,
		      struct nfsd4_destroy_session *sessionid)
{
B
Benny Halevy 已提交
1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
	struct nfsd4_session *ses;
	u32 status = nfserr_badsession;

	/* Notes:
	 * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
	 * - Should we return nfserr_back_chan_busy if waiting for
	 *   callbacks on to-be-destroyed session?
	 * - Do we need to clear any callback info from previous session?
	 */

	dump_sessionid(__func__, &sessionid->sessionid);
	spin_lock(&sessionid_lock);
	ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
	if (!ses) {
		spin_unlock(&sessionid_lock);
		goto out;
	}

	unhash_session(ses);
	spin_unlock(&sessionid_lock);

	/* wait for callbacks */
	shutdown_callback_client(ses->se_client);
	nfsd4_put_session(ses);
	status = nfs_ok;
out:
	dprintk("%s returns %d\n", __func__, ntohl(status));
	return status;
A
Andy Adamson 已提交
1453 1454 1455
}

__be32
B
Benny Halevy 已提交
1456
nfsd4_sequence(struct svc_rqst *rqstp,
A
Andy Adamson 已提交
1457 1458 1459
	       struct nfsd4_compound_state *cstate,
	       struct nfsd4_sequence *seq)
{
1460
	struct nfsd4_compoundres *resp = rqstp->rq_resp;
B
Benny Halevy 已提交
1461 1462 1463 1464
	struct nfsd4_session *session;
	struct nfsd4_slot *slot;
	int status;

1465 1466 1467
	if (resp->opcnt != 1)
		return nfserr_sequence_pos;

B
Benny Halevy 已提交
1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
	spin_lock(&sessionid_lock);
	status = nfserr_badsession;
	session = find_in_sessionid_hashtbl(&seq->sessionid);
	if (!session)
		goto out;

	status = nfserr_badslot;
	if (seq->slotid >= session->se_fnumslots)
		goto out;

	slot = &session->se_slots[seq->slotid];
	dprintk("%s: slotid %d\n", __func__, seq->slotid);

	status = check_slot_seqid(seq->seqid, slot);
	if (status == nfserr_replay_cache) {
		cstate->slot = slot;
		cstate->session = session;
A
Andy Adamson 已提交
1485
		/* Return the cached reply status and set cstate->status
1486 1487
		 * for nfsd4_svc_encode_compoundres processing */
		status = nfsd4_replay_cache_entry(resp, seq);
A
Andy Adamson 已提交
1488
		cstate->status = nfserr_replay_cache;
B
Benny Halevy 已提交
1489 1490 1491 1492 1493 1494 1495 1496
		goto replay_cache;
	}
	if (status)
		goto out;

	/* Success! bump slot seqid */
	slot->sl_inuse = true;
	slot->sl_seqid = seq->seqid;
1497 1498 1499 1500
	slot->sl_cache_entry.ce_cachethis = seq->cachethis;
	/* Always set the cache entry cachethis for solo sequence */
	if (nfsd4_is_solo_sequence(resp))
		slot->sl_cache_entry.ce_cachethis = 1;
B
Benny Halevy 已提交
1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515

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

replay_cache:
	/* Renew the clientid on success and on replay.
	 * Hold a session reference until done processing the compound:
	 * nfsd4_put_session called only if the cstate slot is set.
	 */
	renew_client(session->se_client);
	nfsd4_get_session(session);
out:
	spin_unlock(&sessionid_lock);
	dprintk("%s: return %d\n", __func__, ntohl(status));
	return status;
A
Andy Adamson 已提交
1516 1517
}

1518
__be32
1519 1520
nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
		  struct nfsd4_setclientid *setclid)
L
Linus Torvalds 已提交
1521
{
1522
	struct sockaddr_in	*sin = svc_addr_in(rqstp);
L
Linus Torvalds 已提交
1523 1524 1525 1526 1527 1528
	struct xdr_netobj 	clname = { 
		.len = setclid->se_namelen,
		.data = setclid->se_name,
	};
	nfs4_verifier		clverifier = setclid->se_verf;
	unsigned int 		strhashval;
1529
	struct nfs4_client	*conf, *unconf, *new;
1530
	__be32 			status;
1531
	char			*princ;
N
NeilBrown 已提交
1532
	char                    dname[HEXDIR_LEN];
L
Linus Torvalds 已提交
1533 1534
	
	if (!check_name(clname))
1535
		return nfserr_inval;
L
Linus Torvalds 已提交
1536

N
NeilBrown 已提交
1537 1538
	status = nfs4_make_rec_clidname(dname, &clname);
	if (status)
1539
		return status;
N
NeilBrown 已提交
1540

L
Linus Torvalds 已提交
1541 1542 1543 1544 1545
	/* 
	 * XXX The Duplicate Request Cache (DRC) has been checked (??)
	 * We get here on a DRC miss.
	 */

N
NeilBrown 已提交
1546
	strhashval = clientstr_hashval(dname);
L
Linus Torvalds 已提交
1547 1548

	nfs4_lock_state();
1549
	conf = find_confirmed_client_by_str(dname, strhashval, false);
1550
	if (conf) {
1551
		/* RFC 3530 14.2.33 CASE 0: */
L
Linus Torvalds 已提交
1552
		status = nfserr_clid_inuse;
1553 1554 1555
		if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
			dprintk("NFSD: setclientid: string in use by client"
				" at %pI4\n", &conf->cl_addr);
L
Linus Torvalds 已提交
1556 1557 1558
			goto out;
		}
	}
1559 1560 1561 1562 1563
	/*
	 * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
	 * has a description of SETCLIENTID request processing consisting
	 * of 5 bullet points, labeled as CASE0 - CASE4 below.
	 */
1564
	unconf = find_unconfirmed_client_by_str(dname, strhashval, false);
L
Linus Torvalds 已提交
1565 1566
	status = nfserr_resource;
	if (!conf) {
1567 1568 1569
		/*
		 * RFC 3530 14.2.33 CASE 4:
		 * placed first, because it is the normal case
L
Linus Torvalds 已提交
1570 1571 1572
		 */
		if (unconf)
			expire_client(unconf);
N
NeilBrown 已提交
1573 1574
		new = create_client(clname, dname);
		if (new == NULL)
L
Linus Torvalds 已提交
1575 1576
			goto out;
		gen_clid(new);
1577
	} else if (same_verf(&conf->cl_verifier, &clverifier)) {
L
Linus Torvalds 已提交
1578
		/*
1579 1580
		 * RFC 3530 14.2.33 CASE 1:
		 * probable callback update
L
Linus Torvalds 已提交
1581
		 */
1582 1583 1584 1585 1586 1587 1588
		if (unconf) {
			/* Note this is removing unconfirmed {*x***},
			 * which is stronger than RFC recommended {vxc**}.
			 * This has the advantage that there is at most
			 * one {*x***} in either list at any time.
			 */
			expire_client(unconf);
L
Linus Torvalds 已提交
1589
		}
N
NeilBrown 已提交
1590 1591
		new = create_client(clname, dname);
		if (new == NULL)
L
Linus Torvalds 已提交
1592 1593 1594 1595
			goto out;
		copy_clid(new, conf);
	} else if (!unconf) {
		/*
1596 1597 1598
		 * RFC 3530 14.2.33 CASE 2:
		 * probable client reboot; state will be removed if
		 * confirmed.
L
Linus Torvalds 已提交
1599
		 */
N
NeilBrown 已提交
1600 1601
		new = create_client(clname, dname);
		if (new == NULL)
L
Linus Torvalds 已提交
1602 1603
			goto out;
		gen_clid(new);
1604
	} else {
1605 1606 1607 1608
		/*
		 * RFC 3530 14.2.33 CASE 3:
		 * probable client reboot; state will be removed if
		 * confirmed.
L
Linus Torvalds 已提交
1609 1610
		 */
		expire_client(unconf);
N
NeilBrown 已提交
1611 1612
		new = create_client(clname, dname);
		if (new == NULL)
L
Linus Torvalds 已提交
1613 1614 1615
			goto out;
		gen_clid(new);
	}
1616 1617
	copy_verf(new, &clverifier);
	new->cl_addr = sin->sin_addr.s_addr;
1618
	new->cl_flavor = rqstp->rq_flavor;
1619 1620 1621 1622 1623 1624 1625 1626
	princ = svc_gss_principal(rqstp);
	if (princ) {
		new->cl_principal = kstrdup(princ, GFP_KERNEL);
		if (new->cl_principal == NULL) {
			free_client(new);
			goto out;
		}
	}
1627 1628 1629 1630
	copy_cred(&new->cl_cred, &rqstp->rq_cred);
	gen_confirm(new);
	gen_callback(new, setclid);
	add_to_unconfirmed(new, strhashval);
L
Linus Torvalds 已提交
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
	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;
}


/*
1642 1643 1644
 * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
 * a description of SETCLIENTID_CONFIRM request processing consisting of 4
 * bullets, labeled as CASE1 - CASE4 below.
L
Linus Torvalds 已提交
1645
 */
1646
__be32
1647 1648 1649
nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
			 struct nfsd4_compound_state *cstate,
			 struct nfsd4_setclientid_confirm *setclientid_confirm)
L
Linus Torvalds 已提交
1650
{
1651
	struct sockaddr_in *sin = svc_addr_in(rqstp);
1652
	struct nfs4_client *conf, *unconf;
L
Linus Torvalds 已提交
1653 1654
	nfs4_verifier confirm = setclientid_confirm->sc_confirm; 
	clientid_t * clid = &setclientid_confirm->sc_clientid;
1655
	__be32 status;
L
Linus Torvalds 已提交
1656 1657 1658 1659 1660 1661 1662 1663 1664

	if (STALE_CLIENTID(clid))
		return nfserr_stale_clientid;
	/* 
	 * XXX The Duplicate Request Cache (DRC) has been checked (??)
	 * We get here on a DRC miss.
	 */

	nfs4_lock_state();
1665 1666 1667 1668 1669

	conf = find_confirmed_client(clid);
	unconf = find_unconfirmed_client(clid);

	status = nfserr_clid_inuse;
1670
	if (conf && conf->cl_addr != sin->sin_addr.s_addr)
1671
		goto out;
1672
	if (unconf && unconf->cl_addr != sin->sin_addr.s_addr)
1673 1674
		goto out;

1675 1676 1677 1678 1679
	/*
	 * section 14.2.34 of RFC 3530 has a description of
	 * SETCLIENTID_CONFIRM request processing consisting
	 * of 4 bullet points, labeled as CASE1 - CASE4 below.
	 */
1680
	if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
1681 1682 1683 1684
		/*
		 * RFC 3530 14.2.34 CASE 1:
		 * callback update
		 */
1685
		if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
L
Linus Torvalds 已提交
1686 1687
			status = nfserr_clid_inuse;
		else {
1688 1689
			/* XXX: We just turn off callbacks until we can handle
			  * change request correctly. */
1690
			atomic_set(&conf->cl_callback.cb_set, 0);
1691
			gen_confirm(conf);
N
NeilBrown 已提交
1692
			nfsd4_remove_clid_dir(unconf);
1693
			expire_client(unconf);
L
Linus Torvalds 已提交
1694
			status = nfs_ok;
1695

L
Linus Torvalds 已提交
1696
		}
1697
	} else if (conf && !unconf) {
1698 1699 1700 1701
		/*
		 * RFC 3530 14.2.34 CASE 2:
		 * probable retransmitted request; play it safe and
		 * do nothing.
1702
		 */
1703
		if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
L
Linus Torvalds 已提交
1704
			status = nfserr_clid_inuse;
1705
		else
L
Linus Torvalds 已提交
1706
			status = nfs_ok;
1707
	} else if (!conf && unconf
1708
			&& same_verf(&unconf->cl_confirm, &confirm)) {
1709 1710 1711
		/*
		 * RFC 3530 14.2.34 CASE 3:
		 * Normal case; new or rebooted client:
1712
		 */
1713
		if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
L
Linus Torvalds 已提交
1714 1715
			status = nfserr_clid_inuse;
		} else {
1716 1717 1718
			unsigned int hash =
				clientstr_hashval(unconf->cl_recdir);
			conf = find_confirmed_client_by_str(unconf->cl_recdir,
1719
							    hash, false);
1720
			if (conf) {
1721
				nfsd4_remove_clid_dir(conf);
1722 1723
				expire_client(conf);
			}
L
Linus Torvalds 已提交
1724
			move_to_confirmed(unconf);
1725
			conf = unconf;
1726
			nfsd4_probe_callback(conf);
1727
			status = nfs_ok;
L
Linus Torvalds 已提交
1728
		}
1729 1730
	} else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
	    && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
1731
				    				&confirm)))) {
1732 1733 1734
		/*
		 * RFC 3530 14.2.34 CASE 4:
		 * Client probably hasn't noticed that we rebooted yet.
1735
		 */
L
Linus Torvalds 已提交
1736
		status = nfserr_stale_clientid;
1737
	} else {
1738 1739 1740
		/* check that we have hit one of the cases...*/
		status = nfserr_clid_inuse;
	}
L
Linus Torvalds 已提交
1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752
out:
	nfs4_unlock_state();
	return status;
}

/* OPEN Share state helper functions */
static inline struct nfs4_file *
alloc_init_file(struct inode *ino)
{
	struct nfs4_file *fp;
	unsigned int hashval = file_hashval(ino);

N
NeilBrown 已提交
1753 1754
	fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
	if (fp) {
1755
		atomic_set(&fp->fi_ref, 1);
L
Linus Torvalds 已提交
1756
		INIT_LIST_HEAD(&fp->fi_hash);
1757 1758
		INIT_LIST_HEAD(&fp->fi_stateids);
		INIT_LIST_HEAD(&fp->fi_delegations);
1759
		spin_lock(&recall_lock);
L
Linus Torvalds 已提交
1760
		list_add(&fp->fi_hash, &file_hashtbl[hashval]);
1761
		spin_unlock(&recall_lock);
L
Linus Torvalds 已提交
1762 1763
		fp->fi_inode = igrab(ino);
		fp->fi_id = current_fileid++;
1764
		fp->fi_had_conflict = false;
L
Linus Torvalds 已提交
1765 1766 1767 1768 1769
		return fp;
	}
	return NULL;
}

N
NeilBrown 已提交
1770
static void
1771
nfsd4_free_slab(struct kmem_cache **slab)
L
Linus Torvalds 已提交
1772
{
N
NeilBrown 已提交
1773 1774
	if (*slab == NULL)
		return;
1775
	kmem_cache_destroy(*slab);
N
NeilBrown 已提交
1776
	*slab = NULL;
L
Linus Torvalds 已提交
1777 1778
}

1779
void
L
Linus Torvalds 已提交
1780 1781
nfsd4_free_slabs(void)
{
N
NeilBrown 已提交
1782 1783
	nfsd4_free_slab(&stateowner_slab);
	nfsd4_free_slab(&file_slab);
N
NeilBrown 已提交
1784
	nfsd4_free_slab(&stateid_slab);
N
NeilBrown 已提交
1785
	nfsd4_free_slab(&deleg_slab);
N
NeilBrown 已提交
1786
}
L
Linus Torvalds 已提交
1787

N
NeilBrown 已提交
1788 1789 1790 1791
static int
nfsd4_init_slabs(void)
{
	stateowner_slab = kmem_cache_create("nfsd4_stateowners",
1792
			sizeof(struct nfs4_stateowner), 0, 0, NULL);
N
NeilBrown 已提交
1793 1794 1795
	if (stateowner_slab == NULL)
		goto out_nomem;
	file_slab = kmem_cache_create("nfsd4_files",
1796
			sizeof(struct nfs4_file), 0, 0, NULL);
N
NeilBrown 已提交
1797 1798
	if (file_slab == NULL)
		goto out_nomem;
N
NeilBrown 已提交
1799
	stateid_slab = kmem_cache_create("nfsd4_stateids",
1800
			sizeof(struct nfs4_stateid), 0, 0, NULL);
N
NeilBrown 已提交
1801 1802
	if (stateid_slab == NULL)
		goto out_nomem;
N
NeilBrown 已提交
1803
	deleg_slab = kmem_cache_create("nfsd4_delegations",
1804
			sizeof(struct nfs4_delegation), 0, 0, NULL);
N
NeilBrown 已提交
1805 1806
	if (deleg_slab == NULL)
		goto out_nomem;
N
NeilBrown 已提交
1807 1808 1809 1810 1811
	return 0;
out_nomem:
	nfsd4_free_slabs();
	dprintk("nfsd4: out of memory while initializing nfsv4\n");
	return -ENOMEM;
L
Linus Torvalds 已提交
1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
}

void
nfs4_free_stateowner(struct kref *kref)
{
	struct nfs4_stateowner *sop =
		container_of(kref, struct nfs4_stateowner, so_ref);
	kfree(sop->so_owner.data);
	kmem_cache_free(stateowner_slab, sop);
}

static inline struct nfs4_stateowner *
alloc_stateowner(struct xdr_netobj *owner)
{
	struct nfs4_stateowner *sop;

	if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) {
		if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) {
			memcpy(sop->so_owner.data, owner->data, owner->len);
			sop->so_owner.len = owner->len;
			kref_init(&sop->so_ref);
			return sop;
		} 
		kmem_cache_free(stateowner_slab, sop);
	}
	return NULL;
}

static struct nfs4_stateowner *
alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
	struct nfs4_stateowner *sop;
	struct nfs4_replay *rp;
	unsigned int idhashval;

	if (!(sop = alloc_stateowner(&open->op_owner)))
		return NULL;
	idhashval = ownerid_hashval(current_ownerid);
	INIT_LIST_HEAD(&sop->so_idhash);
	INIT_LIST_HEAD(&sop->so_strhash);
	INIT_LIST_HEAD(&sop->so_perclient);
1852 1853
	INIT_LIST_HEAD(&sop->so_stateids);
	INIT_LIST_HEAD(&sop->so_perstateid);  /* not used */
L
Linus Torvalds 已提交
1854 1855 1856 1857
	INIT_LIST_HEAD(&sop->so_close_lru);
	sop->so_time = 0;
	list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]);
	list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]);
1858
	list_add(&sop->so_perclient, &clp->cl_openowners);
L
Linus Torvalds 已提交
1859 1860 1861 1862 1863 1864
	sop->so_is_open_owner = 1;
	sop->so_id = current_ownerid++;
	sop->so_client = clp;
	sop->so_seqid = open->op_seqid;
	sop->so_confirmed = 0;
	rp = &sop->so_replay;
1865
	rp->rp_status = nfserr_serverfault;
L
Linus Torvalds 已提交
1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876
	rp->rp_buflen = 0;
	rp->rp_buf = rp->rp_ibuf;
	return sop;
}

static inline void
init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
	struct nfs4_stateowner *sop = open->op_stateowner;
	unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);

	INIT_LIST_HEAD(&stp->st_hash);
1877 1878
	INIT_LIST_HEAD(&stp->st_perstateowner);
	INIT_LIST_HEAD(&stp->st_lockowners);
L
Linus Torvalds 已提交
1879 1880
	INIT_LIST_HEAD(&stp->st_perfile);
	list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
1881
	list_add(&stp->st_perstateowner, &sop->so_stateids);
1882
	list_add(&stp->st_perfile, &fp->fi_stateids);
L
Linus Torvalds 已提交
1883
	stp->st_stateowner = sop;
1884
	get_nfs4_file(fp);
L
Linus Torvalds 已提交
1885 1886 1887 1888 1889 1890 1891
	stp->st_file = fp;
	stp->st_stateid.si_boot = boot_time;
	stp->st_stateid.si_stateownerid = sop->so_id;
	stp->st_stateid.si_fileid = fp->fi_id;
	stp->st_stateid.si_generation = 0;
	stp->st_access_bmap = 0;
	stp->st_deny_bmap = 0;
1892 1893
	__set_bit(open->op_share_access & ~NFS4_SHARE_WANT_MASK,
		  &stp->st_access_bmap);
L
Linus Torvalds 已提交
1894
	__set_bit(open->op_share_deny, &stp->st_deny_bmap);
1895
	stp->st_openstp = NULL;
L
Linus Torvalds 已提交
1896 1897
}

1898
static void
L
Linus Torvalds 已提交
1899 1900 1901 1902
move_to_close_lru(struct nfs4_stateowner *sop)
{
	dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop);

1903
	list_move_tail(&sop->so_close_lru, &close_lru);
L
Linus Torvalds 已提交
1904 1905 1906 1907
	sop->so_time = get_seconds();
}

static int
1908 1909 1910 1911 1912 1913
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 已提交
1914 1915 1916 1917 1918 1919 1920 1921
}

static struct nfs4_stateowner *
find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
{
	struct nfs4_stateowner *so = NULL;

	list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
1922
		if (same_owner_str(so, &open->op_owner, &open->op_clientid))
L
Linus Torvalds 已提交
1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
			return so;
	}
	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;

1935
	spin_lock(&recall_lock);
L
Linus Torvalds 已提交
1936
	list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
1937 1938
		if (fp->fi_inode == ino) {
			get_nfs4_file(fp);
1939
			spin_unlock(&recall_lock);
L
Linus Torvalds 已提交
1940
			return fp;
1941
		}
L
Linus Torvalds 已提交
1942
	}
1943
	spin_unlock(&recall_lock);
L
Linus Torvalds 已提交
1944 1945 1946
	return NULL;
}

A
Andy Adamson 已提交
1947
static inline int access_valid(u32 x, u32 minorversion)
1948
{
A
Andy Adamson 已提交
1949
	if ((x & NFS4_SHARE_ACCESS_MASK) < NFS4_SHARE_ACCESS_READ)
1950
		return 0;
A
Andy Adamson 已提交
1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961
	if ((x & NFS4_SHARE_ACCESS_MASK) > NFS4_SHARE_ACCESS_BOTH)
		return 0;
	x &= ~NFS4_SHARE_ACCESS_MASK;
	if (minorversion && x) {
		if ((x & NFS4_SHARE_WANT_MASK) > NFS4_SHARE_WANT_CANCEL)
			return 0;
		if ((x & NFS4_SHARE_WHEN_MASK) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED)
			return 0;
		x &= ~(NFS4_SHARE_WANT_MASK | NFS4_SHARE_WHEN_MASK);
	}
	if (x)
1962 1963
		return 0;
	return 1;
1964 1965
}

1966
static inline int deny_valid(u32 x)
1967
{
1968 1969
	/* Note: unlike access bits, deny bits may be zero. */
	return x <= NFS4_SHARE_DENY_BOTH;
1970
}
L
Linus Torvalds 已提交
1971

1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989
/*
 * 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.
 */
1990
static void
L
Linus Torvalds 已提交
1991 1992 1993 1994 1995 1996 1997 1998 1999 2000
set_access(unsigned int *access, unsigned long bmap) {
	int i;

	*access = 0;
	for (i = 1; i < 4; i++) {
		if (test_bit(i, &bmap))
			*access |= i;
	}
}

2001
static void
L
Linus Torvalds 已提交
2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
set_deny(unsigned int *deny, unsigned long bmap) {
	int i;

	*deny = 0;
	for (i = 0; i < 4; i++) {
		if (test_bit(i, &bmap))
			*deny |= i ;
	}
}

static int
test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) {
	unsigned int access, deny;

	set_access(&access, stp->st_access_bmap);
	set_deny(&deny, stp->st_deny_bmap);
	if ((access & open->op_share_deny) || (deny & open->op_share_access))
		return 0;
	return 1;
}

/*
 * Called to check deny when READ with all zero stateid or
 * WRITE with all zero or all one stateid
 */
2027
static __be32
L
Linus Torvalds 已提交
2028 2029 2030 2031 2032
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;
	struct nfs4_stateid *stp;
2033
	__be32 ret;
L
Linus Torvalds 已提交
2034 2035 2036 2037

	dprintk("NFSD: nfs4_share_conflict\n");

	fp = find_file(ino);
2038 2039
	if (!fp)
		return nfs_ok;
2040
	ret = nfserr_locked;
L
Linus Torvalds 已提交
2041
	/* Search for conflicting share reservations */
2042 2043 2044 2045
	list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
		if (test_bit(deny_type, &stp->st_deny_bmap) ||
		    test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
			goto out;
L
Linus Torvalds 已提交
2046
	}
2047 2048 2049 2050
	ret = nfs_ok;
out:
	put_nfs4_file(fp);
	return ret;
L
Linus Torvalds 已提交
2051 2052 2053 2054 2055 2056
}

static inline void
nfs4_file_downgrade(struct file *filp, unsigned int share_access)
{
	if (share_access & NFS4_SHARE_ACCESS_WRITE) {
2057
		drop_file_write_access(filp);
L
Linus Torvalds 已提交
2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069
		filp->f_mode = (filp->f_mode | FMODE_READ) & ~FMODE_WRITE;
	}
}

/*
 * Recall a delegation
 */
static int
do_recall(void *__dp)
{
	struct nfs4_delegation *dp = __dp;

2070
	dp->dl_file->fi_had_conflict = true;
L
Linus Torvalds 已提交
2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098
	nfsd4_cb_recall(dp);
	return 0;
}

/*
 * Spawn a thread to perform a recall on the delegation represented
 * by the lease (file_lock)
 *
 * Called from break_lease() with lock_kernel() held.
 * Note: we assume break_lease will only call this *once* for any given
 * lease.
 */
static
void nfsd_break_deleg_cb(struct file_lock *fl)
{
	struct nfs4_delegation *dp=  (struct nfs4_delegation *)fl->fl_owner;
	struct task_struct *t;

	dprintk("NFSD nfsd_break_deleg_cb: dp %p fl %p\n",dp,fl);
	if (!dp)
		return;

	/* 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);
2099
	atomic_inc(&dp->dl_client->cl_count);
L
Linus Torvalds 已提交
2100 2101 2102 2103 2104 2105 2106 2107

	spin_lock(&recall_lock);
	list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
	spin_unlock(&recall_lock);

	/* only place dl_time is set. protected by lock_kernel*/
	dp->dl_time = get_seconds();

2108 2109 2110 2111 2112 2113
	/*
	 * We don't want the locks code to timeout the lease for us;
	 * we'll remove it ourself if the delegation isn't returned
	 * in time.
	 */
	fl->fl_break_time = 0;
L
Linus Torvalds 已提交
2114 2115 2116 2117 2118 2119 2120 2121

	t = kthread_run(do_recall, dp, "%s", "nfs4_cb_recall");
	if (IS_ERR(t)) {
		struct nfs4_client *clp = dp->dl_client;

		printk(KERN_INFO "NFSD: Callback thread failed for "
			"for client (clientid %08x/%08x)\n",
			clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
2122
		put_nfs4_client(dp->dl_client);
L
Linus Torvalds 已提交
2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146
		nfs4_put_delegation(dp);
	}
}

/*
 * The file_lock is being reapd.
 *
 * Called by locks_free_lock() with lock_kernel() held.
 */
static
void nfsd_release_deleg_cb(struct file_lock *fl)
{
	struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner;

	dprintk("NFSD nfsd_release_deleg_cb: fl %p dp %p dl_count %d\n", fl,dp, atomic_read(&dp->dl_count));

	if (!(fl->fl_flags & FL_LEASE) || !dp)
		return;
	dp->dl_flock = NULL;
}

/*
 * Set the delegation file_lock back pointer.
 *
2147
 * Called from setlease() with lock_kernel() held.
L
Linus Torvalds 已提交
2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160
 */
static
void nfsd_copy_lock_deleg_cb(struct file_lock *new, struct file_lock *fl)
{
	struct nfs4_delegation *dp = (struct nfs4_delegation *)new->fl_owner;

	dprintk("NFSD: nfsd_copy_lock_deleg_cb: new fl %p dp %p\n", new, dp);
	if (!dp)
		return;
	dp->dl_flock = new;
}

/*
2161
 * Called from setlease() with lock_kernel() held
L
Linus Torvalds 已提交
2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186
 */
static
int nfsd_same_client_deleg_cb(struct file_lock *onlist, struct file_lock *try)
{
	struct nfs4_delegation *onlistd =
		(struct nfs4_delegation *)onlist->fl_owner;
	struct nfs4_delegation *tryd =
		(struct nfs4_delegation *)try->fl_owner;

	if (onlist->fl_lmops != try->fl_lmops)
		return 0;

	return onlistd->dl_client == tryd->dl_client;
}


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

2187
static struct lock_manager_operations nfsd_lease_mng_ops = {
L
Linus Torvalds 已提交
2188 2189 2190 2191 2192 2193 2194 2195
	.fl_break = nfsd_break_deleg_cb,
	.fl_release_private = nfsd_release_deleg_cb,
	.fl_copy_lock = nfsd_copy_lock_deleg_cb,
	.fl_mylease = nfsd_same_client_deleg_cb,
	.fl_change = nfsd_change_deleg_cb,
};


2196
__be32
A
Andy Adamson 已提交
2197 2198
nfsd4_process_open1(struct nfsd4_compound_state *cstate,
		    struct nfsd4_open *open)
L
Linus Torvalds 已提交
2199 2200 2201 2202 2203 2204 2205
{
	clientid_t *clientid = &open->op_clientid;
	struct nfs4_client *clp = NULL;
	unsigned int strhashval;
	struct nfs4_stateowner *sop = NULL;

	if (!check_name(open->op_owner))
2206
		return nfserr_inval;
L
Linus Torvalds 已提交
2207 2208 2209 2210 2211 2212

	if (STALE_CLIENTID(&open->op_clientid))
		return nfserr_stale_clientid;

	strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner);
	sop = find_openstateowner_str(strhashval, open);
2213 2214 2215
	open->op_stateowner = sop;
	if (!sop) {
		/* Make sure the client's lease hasn't expired. */
L
Linus Torvalds 已提交
2216 2217
		clp = find_confirmed_client(clientid);
		if (clp == NULL)
2218 2219
			return nfserr_expired;
		goto renew;
L
Linus Torvalds 已提交
2220
	}
A
Andy Adamson 已提交
2221 2222 2223
	/* When sessions are used, skip open sequenceid processing */
	if (nfsd4_has_session(cstate))
		goto renew;
2224 2225 2226
	if (!sop->so_confirmed) {
		/* Replace unconfirmed owners without checking for replay. */
		clp = sop->so_client;
2227
		release_openowner(sop);
2228 2229 2230 2231 2232
		open->op_stateowner = NULL;
		goto renew;
	}
	if (open->op_seqid == sop->so_seqid - 1) {
		if (sop->so_replay.rp_buflen)
A
Al Viro 已提交
2233
			return nfserr_replay_me;
2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244
		/* The original OPEN failed so spectacularly
		 * that we don't even have replay data saved!
		 * Therefore, we have no choice but to continue
		 * processing this OPEN; presumably, we'll
		 * fail again for the same reason.
		 */
		dprintk("nfsd4_process_open1: replay with no replay cache\n");
		goto renew;
	}
	if (open->op_seqid != sop->so_seqid)
		return nfserr_bad_seqid;
L
Linus Torvalds 已提交
2245
renew:
2246 2247 2248 2249 2250 2251 2252
	if (open->op_stateowner == NULL) {
		sop = alloc_init_open_stateowner(strhashval, clp, open);
		if (sop == NULL)
			return nfserr_resource;
		open->op_stateowner = sop;
	}
	list_del_init(&sop->so_close_lru);
L
Linus Torvalds 已提交
2253
	renew_client(sop->so_client);
2254
	return nfs_ok;
L
Linus Torvalds 已提交
2255 2256
}

2257
static inline __be32
N
NeilBrown 已提交
2258 2259 2260 2261 2262 2263 2264 2265
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;
}

2266 2267 2268 2269 2270
static struct nfs4_delegation *
find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
{
	struct nfs4_delegation *dp;

2271
	list_for_each_entry(dp, &fp->fi_delegations, dl_perfile) {
2272 2273 2274 2275 2276 2277
		if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid)
			return dp;
	}
	return NULL;
}

2278
static __be32
2279 2280 2281 2282
nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open,
		struct nfs4_delegation **dp)
{
	int flags;
2283
	__be32 status = nfserr_bad_stateid;
2284 2285 2286

	*dp = find_delegation_file(fp, &open->op_delegate_stateid);
	if (*dp == NULL)
2287
		goto out;
2288 2289 2290 2291 2292
	flags = open->op_share_access == NFS4_SHARE_ACCESS_READ ?
						RD_STATE : WR_STATE;
	status = nfs4_check_delegmode(*dp, flags);
	if (status)
		*dp = NULL;
2293 2294 2295 2296 2297 2298 2299
out:
	if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR)
		return nfs_ok;
	if (status)
		return status;
	open->op_stateowner->so_confirmed = 1;
	return nfs_ok;
2300 2301
}

2302
static __be32
L
Linus Torvalds 已提交
2303 2304 2305
nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp)
{
	struct nfs4_stateid *local;
2306
	__be32 status = nfserr_share_denied;
L
Linus Torvalds 已提交
2307 2308
	struct nfs4_stateowner *sop = open->op_stateowner;

2309
	list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
L
Linus Torvalds 已提交
2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324
		/* ignore lock owners */
		if (local->st_stateowner->so_is_open_owner == 0)
			continue;
		/* remember if we have seen this open owner */
		if (local->st_stateowner == sop)
			*stpp = local;
		/* check for conflicting share reservations */
		if (!test_share(local, open))
			goto out;
	}
	status = 0;
out:
	return status;
}

N
NeilBrown 已提交
2325 2326 2327 2328 2329 2330
static inline struct nfs4_stateid *
nfs4_alloc_stateid(void)
{
	return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
}

2331
static __be32
L
Linus Torvalds 已提交
2332
nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp,
2333
		struct nfs4_delegation *dp,
L
Linus Torvalds 已提交
2334 2335 2336 2337
		struct svc_fh *cur_fh, int flags)
{
	struct nfs4_stateid *stp;

N
NeilBrown 已提交
2338
	stp = nfs4_alloc_stateid();
L
Linus Torvalds 已提交
2339 2340 2341
	if (stp == NULL)
		return nfserr_resource;

2342 2343 2344 2345
	if (dp) {
		get_file(dp->dl_vfs_file);
		stp->st_vfs_file = dp->dl_vfs_file;
	} else {
2346
		__be32 status;
2347 2348 2349 2350 2351
		status = nfsd_open(rqstp, cur_fh, S_IFREG, flags,
				&stp->st_vfs_file);
		if (status) {
			if (status == nfserr_dropit)
				status = nfserr_jukebox;
N
NeilBrown 已提交
2352
			kmem_cache_free(stateid_slab, stp);
2353 2354
			return status;
		}
L
Linus Torvalds 已提交
2355 2356 2357 2358 2359
	}
	*stpp = stp;
	return 0;
}

2360
static inline __be32
L
Linus Torvalds 已提交
2361 2362 2363 2364 2365 2366 2367 2368 2369 2370
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))
2371
		return nfserr_inval;
L
Linus Torvalds 已提交
2372 2373 2374
	return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
}

2375
static __be32
L
Linus Torvalds 已提交
2376 2377 2378
nfs4_upgrade_open(struct svc_rqst *rqstp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open)
{
	struct file *filp = stp->st_vfs_file;
2379
	struct inode *inode = filp->f_path.dentry->d_inode;
2380
	unsigned int share_access, new_writer;
2381
	__be32 status;
L
Linus Torvalds 已提交
2382 2383

	set_access(&share_access, stp->st_access_bmap);
2384 2385
	new_writer = (~share_access) & open->op_share_access
			& NFS4_SHARE_ACCESS_WRITE;
L
Linus Torvalds 已提交
2386

2387
	if (new_writer) {
2388 2389 2390
		int err = get_write_access(inode);
		if (err)
			return nfserrno(err);
2391 2392 2393 2394
		err = mnt_want_write(cur_fh->fh_export->ex_path.mnt);
		if (err)
			return nfserrno(err);
		file_take_write(filp);
2395
	}
L
Linus Torvalds 已提交
2396 2397
	status = nfsd4_truncate(rqstp, cur_fh, open);
	if (status) {
2398 2399
		if (new_writer)
			put_write_access(inode);
L
Linus Torvalds 已提交
2400 2401 2402
		return status;
	}
	/* remember the open */
2403
	filp->f_mode |= open->op_share_access;
2404 2405
	__set_bit(open->op_share_access, &stp->st_access_bmap);
	__set_bit(open->op_share_deny, &stp->st_deny_bmap);
L
Linus Torvalds 已提交
2406 2407 2408 2409 2410 2411

	return nfs_ok;
}


static void
2412
nfs4_set_claim_prev(struct nfsd4_open *open)
L
Linus Torvalds 已提交
2413
{
2414 2415
	open->op_stateowner->so_confirmed = 1;
	open->op_stateowner->so_client->cl_firststate = 1;
L
Linus Torvalds 已提交
2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430
}

/*
 * Attempt to hand out a delegation.
 */
static void
nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp)
{
	struct nfs4_delegation *dp;
	struct nfs4_stateowner *sop = stp->st_stateowner;
	struct nfs4_callback *cb = &sop->so_client->cl_callback;
	struct file_lock fl, *flp = &fl;
	int status, flag = 0;

	flag = NFS4_OPEN_DELEGATE_NONE;
2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442
	open->op_recall = 0;
	switch (open->op_claim_type) {
		case NFS4_OPEN_CLAIM_PREVIOUS:
			if (!atomic_read(&cb->cb_set))
				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.... */
2443
			if (locks_in_grace())
2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454
				goto out;
			if (!atomic_read(&cb->cb_set) || !sop->so_confirmed)
				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 已提交
2455 2456 2457 2458 2459 2460 2461 2462 2463

	dp = alloc_init_deleg(sop->so_client, stp, fh, flag);
	if (dp == NULL) {
		flag = NFS4_OPEN_DELEGATE_NONE;
		goto out;
	}
	locks_init_lock(&fl);
	fl.fl_lmops = &nfsd_lease_mng_ops;
	fl.fl_flags = FL_LEASE;
2464
	fl.fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
L
Linus Torvalds 已提交
2465 2466 2467 2468 2469
	fl.fl_end = OFFSET_MAX;
	fl.fl_owner =  (fl_owner_t)dp;
	fl.fl_file = stp->st_vfs_file;
	fl.fl_pid = current->tgid;

2470
	/* vfs_setlease checks to see if delegation should be handed out.
L
Linus Torvalds 已提交
2471 2472
	 * the lock_manager callbacks fl_mylease and fl_change are used
	 */
2473
	if ((status = vfs_setlease(stp->st_vfs_file, fl.fl_type, &flp))) {
L
Linus Torvalds 已提交
2474
		dprintk("NFSD: setlease failed [%d], no delegation\n", status);
N
NeilBrown 已提交
2475
		unhash_delegation(dp);
L
Linus Torvalds 已提交
2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487
		flag = NFS4_OPEN_DELEGATE_NONE;
		goto out;
	}

	memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid));

	dprintk("NFSD: delegation stateid=(%08x/%08x/%08x/%08x)\n\n",
	             dp->dl_stateid.si_boot,
	             dp->dl_stateid.si_stateownerid,
	             dp->dl_stateid.si_fileid,
	             dp->dl_stateid.si_generation);
out:
2488 2489 2490
	if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
			&& flag == NFS4_OPEN_DELEGATE_NONE
			&& open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
2491
		dprintk("NFSD: WARNING: refusing delegation reclaim\n");
L
Linus Torvalds 已提交
2492 2493 2494 2495 2496 2497
	open->op_delegate_type = flag;
}

/*
 * called with nfs4_lock_state() held.
 */
2498
__be32
L
Linus Torvalds 已提交
2499 2500
nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
{
A
Andy Adamson 已提交
2501
	struct nfsd4_compoundres *resp = rqstp->rq_resp;
L
Linus Torvalds 已提交
2502 2503 2504
	struct nfs4_file *fp = NULL;
	struct inode *ino = current_fh->fh_dentry->d_inode;
	struct nfs4_stateid *stp = NULL;
2505
	struct nfs4_delegation *dp = NULL;
2506
	__be32 status;
L
Linus Torvalds 已提交
2507 2508

	status = nfserr_inval;
A
Andy Adamson 已提交
2509
	if (!access_valid(open->op_share_access, resp->cstate.minorversion)
2510
			|| !deny_valid(open->op_share_deny))
L
Linus Torvalds 已提交
2511 2512 2513 2514 2515 2516 2517 2518 2519 2520
		goto out;
	/*
	 * 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;
2521 2522 2523
		status = nfs4_check_deleg(fp, open, &dp);
		if (status)
			goto out;
L
Linus Torvalds 已提交
2524
	} else {
2525 2526 2527
		status = nfserr_bad_stateid;
		if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
			goto out;
L
Linus Torvalds 已提交
2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542
		status = nfserr_resource;
		fp = alloc_init_file(ino);
		if (fp == NULL)
			goto out;
	}

	/*
	 * OPEN the file, or upgrade an existing OPEN.
	 * If truncate fails, the OPEN fails.
	 */
	if (stp) {
		/* Stateid was found, this is an OPEN upgrade */
		status = nfs4_upgrade_open(rqstp, current_fh, stp, open);
		if (status)
			goto out;
2543
		update_stateid(&stp->st_stateid);
L
Linus Torvalds 已提交
2544 2545 2546
	} else {
		/* Stateid was not found, this is a new OPEN */
		int flags = 0;
2547
		if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
M
Miklos Szeredi 已提交
2548
			flags |= NFSD_MAY_READ;
L
Linus Torvalds 已提交
2549
		if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
M
Miklos Szeredi 已提交
2550
			flags |= NFSD_MAY_WRITE;
2551 2552
		status = nfs4_new_open(rqstp, &stp, dp, current_fh, flags);
		if (status)
L
Linus Torvalds 已提交
2553 2554 2555 2556
			goto out;
		init_stateid(stp, fp, open);
		status = nfsd4_truncate(rqstp, current_fh, open);
		if (status) {
2557
			release_open_stateid(stp);
L
Linus Torvalds 已提交
2558 2559
			goto out;
		}
A
Andy Adamson 已提交
2560 2561
		if (nfsd4_has_session(&resp->cstate))
			update_stateid(&stp->st_stateid);
L
Linus Torvalds 已提交
2562 2563 2564
	}
	memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));

A
Andy Adamson 已提交
2565 2566 2567
	if (nfsd4_has_session(&resp->cstate))
		open->op_stateowner->so_confirmed = 1;

L
Linus Torvalds 已提交
2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579
	/*
	* Attempt to hand out a delegation. No error return, because the
	* OPEN succeeds even if we fail.
	*/
	nfs4_open_delegation(current_fh, open, stp);

	status = nfs_ok;

	dprintk("nfs4_process_open2: stateid=(%08x/%08x/%08x/%08x)\n",
	            stp->st_stateid.si_boot, stp->st_stateid.si_stateownerid,
	            stp->st_stateid.si_fileid, stp->st_stateid.si_generation);
out:
2580 2581
	if (fp)
		put_nfs4_file(fp);
2582 2583
	if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
		nfs4_set_claim_prev(open);
L
Linus Torvalds 已提交
2584 2585 2586 2587
	/*
	* To finish the open response, we just need to set the rflags.
	*/
	open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
A
Andy Adamson 已提交
2588 2589
	if (!open->op_stateowner->so_confirmed &&
	    !nfsd4_has_session(&resp->cstate))
L
Linus Torvalds 已提交
2590 2591 2592 2593 2594
		open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;

	return status;
}

2595
__be32
2596 2597
nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	    clientid_t *clid)
L
Linus Torvalds 已提交
2598 2599
{
	struct nfs4_client *clp;
2600
	__be32 status;
L
Linus Torvalds 已提交
2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616

	nfs4_lock_state();
	dprintk("process_renew(%08x/%08x): starting\n", 
			clid->cl_boot, clid->cl_id);
	status = nfserr_stale_clientid;
	if (STALE_CLIENTID(clid))
		goto out;
	clp = find_confirmed_client(clid);
	status = nfserr_expired;
	if (clp == NULL) {
		/* We assume the client took too long to RENEW. */
		dprintk("nfsd4_renew: clientid not found!\n");
		goto out;
	}
	renew_client(clp);
	status = nfserr_cb_path_down;
2617
	if (!list_empty(&clp->cl_delegations)
L
Linus Torvalds 已提交
2618 2619 2620 2621 2622 2623 2624 2625
			&& !atomic_read(&clp->cl_callback.cb_set))
		goto out;
	status = nfs_ok;
out:
	nfs4_unlock_state();
	return status;
}

2626 2627 2628
struct lock_manager nfsd4_manager = {
};

2629
static void
2630
nfsd4_end_grace(void)
2631 2632
{
	dprintk("NFSD: end of grace period\n");
2633
	nfsd4_recdir_purge_old();
2634
	locks_end_grace(&nfsd4_manager);
2635 2636
}

2637
static time_t
L
Linus Torvalds 已提交
2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650
nfs4_laundromat(void)
{
	struct nfs4_client *clp;
	struct nfs4_stateowner *sop;
	struct nfs4_delegation *dp;
	struct list_head *pos, *next, reaplist;
	time_t cutoff = get_seconds() - NFSD_LEASE_TIME;
	time_t t, clientid_val = NFSD_LEASE_TIME;
	time_t u, test_val = NFSD_LEASE_TIME;

	nfs4_lock_state();

	dprintk("NFSD: laundromat service - starting\n");
2651 2652
	if (locks_in_grace())
		nfsd4_end_grace();
L
Linus Torvalds 已提交
2653 2654 2655 2656 2657 2658 2659 2660 2661 2662
	list_for_each_safe(pos, next, &client_lru) {
		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;
		}
		dprintk("NFSD: purging unused client (clientid %08x)\n",
			clp->cl_clientid.cl_id);
2663
		nfsd4_remove_clid_dir(clp);
L
Linus Torvalds 已提交
2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696
		expire_client(clp);
	}
	INIT_LIST_HEAD(&reaplist);
	spin_lock(&recall_lock);
	list_for_each_safe(pos, next, &del_recall_lru) {
		dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
		if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
			u = dp->dl_time - cutoff;
			if (test_val > u)
				test_val = u;
			break;
		}
		dprintk("NFSD: purging unused delegation dp %p, fp %p\n",
			            dp, dp->dl_flock);
		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);
		list_del_init(&dp->dl_recall_lru);
		unhash_delegation(dp);
	}
	test_val = NFSD_LEASE_TIME;
	list_for_each_safe(pos, next, &close_lru) {
		sop = list_entry(pos, struct nfs4_stateowner, so_close_lru);
		if (time_after((unsigned long)sop->so_time, (unsigned long)cutoff)) {
			u = sop->so_time - cutoff;
			if (test_val > u)
				test_val = u;
			break;
		}
		dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
			sop->so_id);
2697
		release_openowner(sop);
L
Linus Torvalds 已提交
2698 2699 2700 2701 2702 2703 2704
	}
	if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
		clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
	nfs4_unlock_state();
	return clientid_val;
}

H
Harvey Harrison 已提交
2705 2706 2707 2708 2709
static struct workqueue_struct *laundry_wq;
static void laundromat_main(struct work_struct *);
static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);

static void
D
David Howells 已提交
2710
laundromat_main(struct work_struct *not_used)
L
Linus Torvalds 已提交
2711 2712 2713 2714 2715
{
	time_t t;

	t = nfs4_laundromat();
	dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
2716
	queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
L
Linus Torvalds 已提交
2717 2718
}

2719
static struct nfs4_stateowner *
2720 2721
search_close_lru(u32 st_id, int flags)
{
L
Linus Torvalds 已提交
2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735
	struct nfs4_stateowner *local = NULL;

	if (flags & CLOSE_STATE) {
		list_for_each_entry(local, &close_lru, so_close_lru) {
			if (local->so_id == st_id)
				return local;
		}
	}
	return NULL;
}

static inline int
nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
{
2736
	return fhp->fh_dentry->d_inode != stp->st_vfs_file->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
2737 2738 2739 2740 2741 2742 2743
}

static int
STALE_STATEID(stateid_t *stateid)
{
	if (stateid->si_boot == boot_time)
		return 0;
N
Neil Brown 已提交
2744
	dprintk("NFSD: stale stateid (%08x/%08x/%08x/%08x)!\n",
L
Linus Torvalds 已提交
2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765
		stateid->si_boot, stateid->si_stateownerid, stateid->si_fileid,
		stateid->si_generation);
	return 1;
}

static inline int
access_permit_read(unsigned long access_bmap)
{
	return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
		test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
		test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
}

static inline int
access_permit_write(unsigned long access_bmap)
{
	return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
		test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
}

static
2766
__be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags)
L
Linus Torvalds 已提交
2767
{
2768
        __be32 status = nfserr_openmode;
L
Linus Torvalds 已提交
2769 2770 2771 2772 2773 2774 2775 2776 2777 2778

	if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
                goto out;
	if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
                goto out;
	status = nfs_ok;
out:
	return status;
}

2779
static inline __be32
L
Linus Torvalds 已提交
2780 2781
check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
{
2782
	if (ONE_STATEID(stateid) && (flags & RD_STATE))
L
Linus Torvalds 已提交
2783
		return nfs_ok;
2784
	else if (locks_in_grace()) {
L
Linus Torvalds 已提交
2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800
		/* Answer in remaining cases depends on existance of
		 * 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
2801
grace_disallows_io(struct inode *inode)
L
Linus Torvalds 已提交
2802
{
2803
	return locks_in_grace() && mandatory_lock(inode);
L
Linus Torvalds 已提交
2804 2805
}

A
Andy Adamson 已提交
2806
static int check_stateid_generation(stateid_t *in, stateid_t *ref, int flags)
2807
{
A
Andy Adamson 已提交
2808 2809 2810 2811 2812 2813 2814
	/*
	 * When sessions are used the stateid generation number is ignored
	 * when it is zero.
	 */
	if ((flags & HAS_SESSION) && in->si_generation == 0)
		goto out;

2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829
	/* If the client sends us a stateid from the future, it's buggy: */
	if (in->si_generation > ref->si_generation)
		return nfserr_bad_stateid;
	/*
	 * The following, however, can happen.  For example, if the
	 * client sends an open and some IO at the same time, the open
	 * may bump si_generation while the IO is still in flight.
	 * Thanks to hard links and renames, the client never knows what
	 * file an open will affect.  So it could avoid that situation
	 * only by serializing all opens and IO from the same open
	 * owner.  To recover from the old_stateid error, the client
	 * will just have to retry the IO:
	 */
	if (in->si_generation < ref->si_generation)
		return nfserr_old_stateid;
A
Andy Adamson 已提交
2830
out:
2831 2832 2833
	return nfs_ok;
}

2834 2835 2836 2837 2838
static int is_delegation_stateid(stateid_t *stateid)
{
	return stateid->si_fileid == 0;
}

L
Linus Torvalds 已提交
2839 2840 2841
/*
* Checks for stateid operations
*/
2842
__be32
2843 2844
nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
			   stateid_t *stateid, int flags, struct file **filpp)
L
Linus Torvalds 已提交
2845 2846 2847
{
	struct nfs4_stateid *stp = NULL;
	struct nfs4_delegation *dp = NULL;
2848
	struct svc_fh *current_fh = &cstate->current_fh;
L
Linus Torvalds 已提交
2849
	struct inode *ino = current_fh->fh_dentry->d_inode;
2850
	__be32 status;
L
Linus Torvalds 已提交
2851 2852 2853 2854

	if (filpp)
		*filpp = NULL;

2855
	if (grace_disallows_io(ino))
L
Linus Torvalds 已提交
2856 2857
		return nfserr_grace;

A
Andy Adamson 已提交
2858 2859 2860
	if (nfsd4_has_session(cstate))
		flags |= HAS_SESSION;

L
Linus Torvalds 已提交
2861 2862 2863 2864 2865 2866 2867 2868
	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
		return check_special_stateids(current_fh, stateid, flags);

	status = nfserr_stale_stateid;
	if (STALE_STATEID(stateid)) 
		goto out;

	status = nfserr_bad_stateid;
2869
	if (is_delegation_stateid(stateid)) {
2870
		dp = find_delegation_stateid(ino, stateid);
J
J. Bruce Fields 已提交
2871
		if (!dp)
L
Linus Torvalds 已提交
2872
			goto out;
A
Andy Adamson 已提交
2873 2874
		status = check_stateid_generation(stateid, &dp->dl_stateid,
						  flags);
2875 2876
		if (status)
			goto out;
2877 2878 2879 2880 2881 2882
		status = nfs4_check_delegmode(dp, flags);
		if (status)
			goto out;
		renew_client(dp->dl_client);
		if (filpp)
			*filpp = dp->dl_vfs_file;
L
Linus Torvalds 已提交
2883
	} else { /* open or lock stateid */
2884
		stp = find_stateid(stateid, flags);
J
J. Bruce Fields 已提交
2885
		if (!stp)
L
Linus Torvalds 已提交
2886
			goto out;
2887
		if (nfs4_check_fh(current_fh, stp))
L
Linus Torvalds 已提交
2888 2889 2890
			goto out;
		if (!stp->st_stateowner->so_confirmed)
			goto out;
A
Andy Adamson 已提交
2891 2892
		status = check_stateid_generation(stateid, &stp->st_stateid,
						  flags);
2893 2894
		if (status)
			goto out;
2895 2896
		status = nfs4_check_openmode(stp, flags);
		if (status)
L
Linus Torvalds 已提交
2897 2898 2899 2900 2901 2902 2903 2904 2905 2906
			goto out;
		renew_client(stp->st_stateowner->so_client);
		if (filpp)
			*filpp = stp->st_vfs_file;
	}
	status = nfs_ok;
out:
	return status;
}

2907 2908 2909 2910 2911 2912
static inline int
setlkflg (int type)
{
	return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
		RD_STATE : WR_STATE;
}
L
Linus Torvalds 已提交
2913 2914 2915 2916

/* 
 * Checks for sequence id mutating operations. 
 */
2917
static __be32
2918 2919 2920 2921
nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
			 stateid_t *stateid, int flags,
			 struct nfs4_stateowner **sopp,
			 struct nfs4_stateid **stpp, struct nfsd4_lock *lock)
L
Linus Torvalds 已提交
2922 2923 2924
{
	struct nfs4_stateid *stp;
	struct nfs4_stateowner *sop;
2925
	struct svc_fh *current_fh = &cstate->current_fh;
2926
	__be32 status;
L
Linus Torvalds 已提交
2927 2928 2929 2930 2931

	dprintk("NFSD: preprocess_seqid_op: seqid=%d " 
			"stateid = (%08x/%08x/%08x/%08x)\n", seqid,
		stateid->si_boot, stateid->si_stateownerid, stateid->si_fileid,
		stateid->si_generation);
2932

L
Linus Torvalds 已提交
2933 2934 2935 2936
	*stpp = NULL;
	*sopp = NULL;

	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
2937
		dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");
2938
		return nfserr_bad_stateid;
L
Linus Torvalds 已提交
2939 2940 2941
	}

	if (STALE_STATEID(stateid))
2942
		return nfserr_stale_stateid;
A
Andy Adamson 已提交
2943 2944 2945 2946

	if (nfsd4_has_session(cstate))
		flags |= HAS_SESSION;

L
Linus Torvalds 已提交
2947 2948 2949 2950 2951
	/*
	* We return BAD_STATEID if filehandle doesn't match stateid, 
	* the confirmed flag is incorrecly set, or the generation 
	* number is incorrect.  
	*/
2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963
	stp = find_stateid(stateid, flags);
	if (stp == NULL) {
		/*
		 * Also, we should make sure this isn't just the result of
		 * a replayed close:
		 */
		sop = search_close_lru(stateid->si_stateownerid, flags);
		if (sop == NULL)
			return nfserr_bad_stateid;
		*sopp = sop;
		goto check_replay;
	}
L
Linus Torvalds 已提交
2964

2965 2966 2967
	*stpp = stp;
	*sopp = sop = stp->st_stateowner;

2968 2969
	if (lock) {
		clientid_t *lockclid = &lock->v.new.clientid;
L
Linus Torvalds 已提交
2970
		struct nfs4_client *clp = sop->so_client;
2971
		int lkflg = 0;
2972
		__be32 status;
2973 2974 2975 2976

		lkflg = setlkflg(lock->lk_type);

		if (lock->lk_is_new) {
2977 2978
			if (!sop->so_is_open_owner)
				return nfserr_bad_stateid;
A
Andy Adamson 已提交
2979 2980 2981
			if (!(flags & HAS_SESSION) &&
			    !same_clid(&clp->cl_clientid, lockclid))
				return nfserr_bad_stateid;
2982 2983 2984 2985 2986 2987 2988 2989 2990
			/* stp is the open stateid */
			status = nfs4_check_openmode(stp, lkflg);
			if (status)
				return status;
		} else {
			/* stp is the lock stateid */
			status = nfs4_check_openmode(stp->st_openstp, lkflg);
			if (status)
				return status;
2991
               }
L
Linus Torvalds 已提交
2992 2993
	}

2994
	if (nfs4_check_fh(current_fh, stp)) {
2995
		dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
2996
		return nfserr_bad_stateid;
L
Linus Torvalds 已提交
2997 2998 2999 3000 3001 3002 3003
	}

	/*
	*  We now validate the seqid and stateid generation numbers.
	*  For the moment, we ignore the possibility of 
	*  generation number wraparound.
	*/
A
Andy Adamson 已提交
3004
	if (!(flags & HAS_SESSION) && seqid != sop->so_seqid)
L
Linus Torvalds 已提交
3005 3006
		goto check_replay;

3007
	if (sop->so_confirmed && flags & CONFIRM) {
3008
		dprintk("NFSD: preprocess_seqid_op: expected"
3009 3010
				" unconfirmed stateowner!\n");
		return nfserr_bad_stateid;
L
Linus Torvalds 已提交
3011
	}
3012
	if (!sop->so_confirmed && !(flags & CONFIRM)) {
3013
		dprintk("NFSD: preprocess_seqid_op: stateowner not"
3014 3015
				" confirmed yet!\n");
		return nfserr_bad_stateid;
L
Linus Torvalds 已提交
3016
	}
A
Andy Adamson 已提交
3017
	status = check_stateid_generation(stateid, &stp->st_stateid, flags);
3018 3019
	if (status)
		return status;
3020
	renew_client(sop->so_client);
3021
	return nfs_ok;
L
Linus Torvalds 已提交
3022 3023

check_replay:
3024
	if (seqid == sop->so_seqid - 1) {
N
Neil Brown 已提交
3025
		dprintk("NFSD: preprocess_seqid_op: retransmission?\n");
L
Linus Torvalds 已提交
3026
		/* indicate replay to calling function */
A
Al Viro 已提交
3027
		return nfserr_replay_me;
L
Linus Torvalds 已提交
3028
	}
3029
	dprintk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",
3030 3031 3032
			sop->so_seqid, seqid);
	*sopp = NULL;
	return nfserr_bad_seqid;
L
Linus Torvalds 已提交
3033 3034
}

3035
__be32
3036
nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3037
		   struct nfsd4_open_confirm *oc)
L
Linus Torvalds 已提交
3038
{
3039
	__be32 status;
L
Linus Torvalds 已提交
3040 3041 3042 3043
	struct nfs4_stateowner *sop;
	struct nfs4_stateid *stp;

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

3047
	status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
3048 3049
	if (status)
		return status;
L
Linus Torvalds 已提交
3050 3051 3052

	nfs4_lock_state();

3053
	if ((status = nfs4_preprocess_seqid_op(cstate,
3054
					oc->oc_seqid, &oc->oc_req_stateid,
3055
					CONFIRM | OPEN_STATE,
L
Linus Torvalds 已提交
3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068
					&oc->oc_stateowner, &stp, NULL)))
		goto out; 

	sop = oc->oc_stateowner;
	sop->so_confirmed = 1;
	update_stateid(&stp->st_stateid);
	memcpy(&oc->oc_resp_stateid, &stp->st_stateid, sizeof(stateid_t));
	dprintk("NFSD: nfsd4_open_confirm: success, seqid=%d " 
		"stateid=(%08x/%08x/%08x/%08x)\n", oc->oc_seqid,
		         stp->st_stateid.si_boot,
		         stp->st_stateid.si_stateownerid,
		         stp->st_stateid.si_fileid,
		         stp->st_stateid.si_generation);
3069 3070

	nfsd4_create_clid_dir(sop->so_client);
L
Linus Torvalds 已提交
3071
out:
N
Neil Brown 已提交
3072
	if (oc->oc_stateowner) {
L
Linus Torvalds 已提交
3073
		nfs4_get_stateowner(oc->oc_stateowner);
3074
		cstate->replay_owner = oc->oc_stateowner;
N
Neil Brown 已提交
3075
	}
L
Linus Torvalds 已提交
3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104
	nfs4_unlock_state();
	return status;
}


/*
 * unset all bits in union bitmap (bmap) that
 * do not exist in share (from successful OPEN_DOWNGRADE)
 */
static void
reset_union_bmap_access(unsigned long access, unsigned long *bmap)
{
	int i;
	for (i = 1; i < 4; i++) {
		if ((i & access) != i)
			__clear_bit(i, bmap);
	}
}

static void
reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
{
	int i;
	for (i = 0; i < 4; i++) {
		if ((i & deny) != i)
			__clear_bit(i, bmap);
	}
}

3105
__be32
3106 3107
nfsd4_open_downgrade(struct svc_rqst *rqstp,
		     struct nfsd4_compound_state *cstate,
3108
		     struct nfsd4_open_downgrade *od)
L
Linus Torvalds 已提交
3109
{
3110
	__be32 status;
L
Linus Torvalds 已提交
3111 3112 3113 3114
	struct nfs4_stateid *stp;
	unsigned int share_access;

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

A
Andy Adamson 已提交
3118
	if (!access_valid(od->od_share_access, cstate->minorversion)
3119
			|| !deny_valid(od->od_share_deny))
L
Linus Torvalds 已提交
3120 3121 3122
		return nfserr_inval;

	nfs4_lock_state();
3123
	if ((status = nfs4_preprocess_seqid_op(cstate,
3124
					od->od_seqid,
L
Linus Torvalds 已提交
3125
					&od->od_stateid, 
3126
					OPEN_STATE,
L
Linus Torvalds 已提交
3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151
					&od->od_stateowner, &stp, NULL)))
		goto out; 

	status = nfserr_inval;
	if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
		dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
			stp->st_access_bmap, od->od_share_access);
		goto out;
	}
	if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
		dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
			stp->st_deny_bmap, od->od_share_deny);
		goto out;
	}
	set_access(&share_access, stp->st_access_bmap);
	nfs4_file_downgrade(stp->st_vfs_file,
	                    share_access & ~od->od_share_access);

	reset_union_bmap_access(od->od_share_access, &stp->st_access_bmap);
	reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);

	update_stateid(&stp->st_stateid);
	memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t));
	status = nfs_ok;
out:
N
Neil Brown 已提交
3152
	if (od->od_stateowner) {
L
Linus Torvalds 已提交
3153
		nfs4_get_stateowner(od->od_stateowner);
3154
		cstate->replay_owner = od->od_stateowner;
N
Neil Brown 已提交
3155
	}
L
Linus Torvalds 已提交
3156 3157 3158 3159 3160 3161 3162
	nfs4_unlock_state();
	return status;
}

/*
 * nfs4_unlock_state() called after encode
 */
3163
__be32
3164
nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3165
	    struct nfsd4_close *close)
L
Linus Torvalds 已提交
3166
{
3167
	__be32 status;
L
Linus Torvalds 已提交
3168 3169 3170
	struct nfs4_stateid *stp;

	dprintk("NFSD: nfsd4_close on file %.*s\n", 
3171 3172
			(int)cstate->current_fh.fh_dentry->d_name.len,
			cstate->current_fh.fh_dentry->d_name.name);
L
Linus Torvalds 已提交
3173 3174 3175

	nfs4_lock_state();
	/* check close_lru for replay */
3176
	if ((status = nfs4_preprocess_seqid_op(cstate,
3177
					close->cl_seqid,
L
Linus Torvalds 已提交
3178
					&close->cl_stateid, 
3179
					OPEN_STATE | CLOSE_STATE,
L
Linus Torvalds 已提交
3180 3181 3182 3183 3184 3185
					&close->cl_stateowner, &stp, NULL)))
		goto out; 
	status = nfs_ok;
	update_stateid(&stp->st_stateid);
	memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t));

3186
	/* release_stateid() calls nfsd_close() if needed */
3187
	release_open_stateid(stp);
3188 3189 3190 3191 3192 3193 3194

	/* place unused nfs4_stateowners on so_close_lru list to be
	 * released by the laundromat service after the lease period
	 * to enable us to handle CLOSE replay
	 */
	if (list_empty(&close->cl_stateowner->so_stateids))
		move_to_close_lru(close->cl_stateowner);
L
Linus Torvalds 已提交
3195
out:
N
Neil Brown 已提交
3196
	if (close->cl_stateowner) {
L
Linus Torvalds 已提交
3197
		nfs4_get_stateowner(close->cl_stateowner);
3198
		cstate->replay_owner = close->cl_stateowner;
N
Neil Brown 已提交
3199
	}
L
Linus Torvalds 已提交
3200 3201 3202 3203
	nfs4_unlock_state();
	return status;
}

3204
__be32
3205 3206
nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
		  struct nfsd4_delegreturn *dr)
L
Linus Torvalds 已提交
3207
{
3208 3209 3210
	struct nfs4_delegation *dp;
	stateid_t *stateid = &dr->dr_stateid;
	struct inode *inode;
3211
	__be32 status;
A
Andy Adamson 已提交
3212
	int flags = 0;
L
Linus Torvalds 已提交
3213

3214
	if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
3215 3216
		return status;
	inode = cstate->current_fh.fh_dentry->d_inode;
L
Linus Torvalds 已提交
3217

A
Andy Adamson 已提交
3218 3219
	if (nfsd4_has_session(cstate))
		flags |= HAS_SESSION;
L
Linus Torvalds 已提交
3220
	nfs4_lock_state();
3221 3222 3223 3224 3225 3226
	status = nfserr_bad_stateid;
	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
		goto out;
	status = nfserr_stale_stateid;
	if (STALE_STATEID(stateid))
		goto out;
3227
	status = nfserr_bad_stateid;
3228 3229 3230 3231 3232
	if (!is_delegation_stateid(stateid))
		goto out;
	dp = find_delegation_stateid(inode, stateid);
	if (!dp)
		goto out;
A
Andy Adamson 已提交
3233
	status = check_stateid_generation(stateid, &dp->dl_stateid, flags);
3234 3235 3236 3237 3238
	if (status)
		goto out;
	renew_client(dp->dl_client);

	unhash_delegation(dp);
L
Linus Torvalds 已提交
3239
out:
3240 3241
	nfs4_unlock_state();

L
Linus Torvalds 已提交
3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253
	return status;
}


/* 
 * Lock owner state (byte-range locks)
 */
#define LOFF_OVERFLOW(start, len)      ((u64)(len) > ~(u64)(start))
#define LOCK_HASH_BITS              8
#define LOCK_HASH_SIZE             (1 << LOCK_HASH_BITS)
#define LOCK_HASH_MASK             (LOCK_HASH_SIZE - 1)

B
Benny Halevy 已提交
3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273
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;

	BUG_ON(!len);
	end = start + len;
	return end > start ? end - 1: NFS4_MAX_UINT64;
}

L
Linus Torvalds 已提交
3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289
#define lockownerid_hashval(id) \
        ((id) & LOCK_HASH_MASK)

static inline unsigned int
lock_ownerstr_hashval(struct inode *inode, u32 cl_id,
		struct xdr_netobj *ownername)
{
	return (file_hashval(inode) + cl_id
			+ opaque_hashval(ownername->data, ownername->len))
		& LOCK_HASH_MASK;
}

static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE];
static struct list_head	lock_ownerstr_hashtbl[LOCK_HASH_SIZE];
static struct list_head lockstateid_hashtbl[STATEID_HASH_SIZE];

3290
static struct nfs4_stateid *
L
Linus Torvalds 已提交
3291 3292
find_stateid(stateid_t *stid, int flags)
{
3293
	struct nfs4_stateid *local;
L
Linus Torvalds 已提交
3294 3295 3296 3297 3298
	u32 st_id = stid->si_stateownerid;
	u32 f_id = stid->si_fileid;
	unsigned int hashval;

	dprintk("NFSD: find_stateid flags 0x%x\n",flags);
3299
	if (flags & (LOCK_STATE | RD_STATE | WR_STATE)) {
L
Linus Torvalds 已提交
3300 3301 3302 3303 3304 3305 3306
		hashval = stateid_hashval(st_id, f_id);
		list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
			if ((local->st_stateid.si_stateownerid == st_id) &&
			    (local->st_stateid.si_fileid == f_id))
				return local;
		}
	} 
3307 3308

	if (flags & (OPEN_STATE | RD_STATE | WR_STATE)) {
L
Linus Torvalds 已提交
3309 3310 3311 3312 3313 3314
		hashval = stateid_hashval(st_id, f_id);
		list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
			if ((local->st_stateid.si_stateownerid == st_id) &&
			    (local->st_stateid.si_fileid == f_id))
				return local;
		}
N
Neil Brown 已提交
3315
	}
L
Linus Torvalds 已提交
3316 3317 3318 3319 3320 3321
	return NULL;
}

static struct nfs4_delegation *
find_delegation_stateid(struct inode *ino, stateid_t *stid)
{
3322 3323
	struct nfs4_file *fp;
	struct nfs4_delegation *dl;
L
Linus Torvalds 已提交
3324 3325 3326 3327 3328 3329

	dprintk("NFSD:find_delegation_stateid stateid=(%08x/%08x/%08x/%08x)\n",
                    stid->si_boot, stid->si_stateownerid,
                    stid->si_fileid, stid->si_generation);

	fp = find_file(ino);
3330 3331 3332 3333 3334
	if (!fp)
		return NULL;
	dl = find_delegation_file(fp, stid);
	put_nfs4_file(fp);
	return dl;
L
Linus Torvalds 已提交
3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353
}

/*
 * 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;
}

3354 3355
/* 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. */
3356
static struct lock_manager_operations nfsd_posix_mng_ops  = {
3357
};
L
Linus Torvalds 已提交
3358 3359 3360 3361

static inline void
nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
{
3362 3363
	struct nfs4_stateowner *sop;
	unsigned int hval;
L
Linus Torvalds 已提交
3364

3365 3366 3367
	if (fl->fl_lmops == &nfsd_posix_mng_ops) {
		sop = (struct nfs4_stateowner *) fl->fl_owner;
		hval = lockownerid_hashval(sop->so_id);
L
Linus Torvalds 已提交
3368 3369 3370
		kref_get(&sop->so_ref);
		deny->ld_sop = sop;
		deny->ld_clientid = sop->so_client->cl_clientid;
3371 3372 3373 3374
	} else {
		deny->ld_sop = NULL;
		deny->ld_clientid.cl_boot = 0;
		deny->ld_clientid.cl_id = 0;
L
Linus Torvalds 已提交
3375 3376
	}
	deny->ld_start = fl->fl_start;
B
Benny Halevy 已提交
3377 3378
	deny->ld_length = NFS4_MAX_UINT64;
	if (fl->fl_end != NFS4_MAX_UINT64)
L
Linus Torvalds 已提交
3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392
		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;
}

static struct nfs4_stateowner *
find_lockstateowner_str(struct inode *inode, clientid_t *clid,
		struct xdr_netobj *owner)
{
	unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner);
	struct nfs4_stateowner *op;

	list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) {
3393
		if (same_owner_str(op, owner, clid))
L
Linus Torvalds 已提交
3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418
			return op;
	}
	return NULL;
}

/*
 * Alloc a lock owner structure.
 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has 
 * occured. 
 *
 * strhashval = lock_ownerstr_hashval 
 */

static struct nfs4_stateowner *
alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp, struct nfsd4_lock *lock) {
	struct nfs4_stateowner *sop;
	struct nfs4_replay *rp;
	unsigned int idhashval;

	if (!(sop = alloc_stateowner(&lock->lk_new_owner)))
		return NULL;
	idhashval = lockownerid_hashval(current_ownerid);
	INIT_LIST_HEAD(&sop->so_idhash);
	INIT_LIST_HEAD(&sop->so_strhash);
	INIT_LIST_HEAD(&sop->so_perclient);
3419 3420
	INIT_LIST_HEAD(&sop->so_stateids);
	INIT_LIST_HEAD(&sop->so_perstateid);
L
Linus Torvalds 已提交
3421 3422 3423 3424
	INIT_LIST_HEAD(&sop->so_close_lru); /* not used */
	sop->so_time = 0;
	list_add(&sop->so_idhash, &lock_ownerid_hashtbl[idhashval]);
	list_add(&sop->so_strhash, &lock_ownerstr_hashtbl[strhashval]);
3425
	list_add(&sop->so_perstateid, &open_stp->st_lockowners);
L
Linus Torvalds 已提交
3426 3427 3428
	sop->so_is_open_owner = 0;
	sop->so_id = current_ownerid++;
	sop->so_client = clp;
3429 3430 3431
	/* It is the openowner seqid that will be incremented in encode in the
	 * case of new lockowners; so increment the lock seqid manually: */
	sop->so_seqid = lock->lk_new_lock_seqid + 1;
L
Linus Torvalds 已提交
3432 3433
	sop->so_confirmed = 1;
	rp = &sop->so_replay;
3434
	rp->rp_status = nfserr_serverfault;
L
Linus Torvalds 已提交
3435 3436 3437 3438 3439
	rp->rp_buflen = 0;
	rp->rp_buf = rp->rp_ibuf;
	return sop;
}

3440
static struct nfs4_stateid *
L
Linus Torvalds 已提交
3441 3442 3443 3444 3445
alloc_init_lock_stateid(struct nfs4_stateowner *sop, struct nfs4_file *fp, struct nfs4_stateid *open_stp)
{
	struct nfs4_stateid *stp;
	unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);

N
NeilBrown 已提交
3446 3447
	stp = nfs4_alloc_stateid();
	if (stp == NULL)
L
Linus Torvalds 已提交
3448 3449 3450
		goto out;
	INIT_LIST_HEAD(&stp->st_hash);
	INIT_LIST_HEAD(&stp->st_perfile);
3451 3452
	INIT_LIST_HEAD(&stp->st_perstateowner);
	INIT_LIST_HEAD(&stp->st_lockowners); /* not used */
L
Linus Torvalds 已提交
3453
	list_add(&stp->st_hash, &lockstateid_hashtbl[hashval]);
3454
	list_add(&stp->st_perfile, &fp->fi_stateids);
3455
	list_add(&stp->st_perstateowner, &sop->so_stateids);
L
Linus Torvalds 已提交
3456
	stp->st_stateowner = sop;
3457
	get_nfs4_file(fp);
L
Linus Torvalds 已提交
3458 3459 3460 3461 3462 3463 3464 3465
	stp->st_file = fp;
	stp->st_stateid.si_boot = boot_time;
	stp->st_stateid.si_stateownerid = sop->so_id;
	stp->st_stateid.si_fileid = fp->fi_id;
	stp->st_stateid.si_generation = 0;
	stp->st_vfs_file = open_stp->st_vfs_file; /* FIXME refcount?? */
	stp->st_access_bmap = open_stp->st_access_bmap;
	stp->st_deny_bmap = open_stp->st_deny_bmap;
3466
	stp->st_openstp = open_stp;
L
Linus Torvalds 已提交
3467 3468 3469 3470 3471

out:
	return stp;
}

3472
static int
L
Linus Torvalds 已提交
3473 3474
check_lock_length(u64 offset, u64 length)
{
B
Benny Halevy 已提交
3475
	return ((length == 0)  || ((length != NFS4_MAX_UINT64) &&
L
Linus Torvalds 已提交
3476 3477 3478 3479 3480 3481
	     LOFF_OVERFLOW(offset, length)));
}

/*
 *  LOCK operation 
 */
3482
__be32
3483
nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3484
	   struct nfsd4_lock *lock)
L
Linus Torvalds 已提交
3485
{
3486
	struct nfs4_stateowner *open_sop = NULL;
3487
	struct nfs4_stateowner *lock_sop = NULL;
L
Linus Torvalds 已提交
3488 3489 3490
	struct nfs4_stateid *lock_stp;
	struct file *filp;
	struct file_lock file_lock;
3491
	struct file_lock conflock;
3492
	__be32 status = 0;
L
Linus Torvalds 已提交
3493
	unsigned int strhashval;
3494
	unsigned int cmd;
3495
	int err;
L
Linus Torvalds 已提交
3496 3497 3498 3499 3500 3501 3502 3503

	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;

3504
	if ((status = fh_verify(rqstp, &cstate->current_fh,
M
Miklos Szeredi 已提交
3505
				S_IFREG, NFSD_MAY_LOCK))) {
A
Andy Adamson 已提交
3506 3507 3508 3509
		dprintk("NFSD: nfsd4_lock: permission denied!\n");
		return status;
	}

L
Linus Torvalds 已提交
3510 3511 3512
	nfs4_lock_state();

	if (lock->lk_is_new) {
N
NeilBrown 已提交
3513 3514 3515 3516 3517
		/*
		 * Client indicates that this is a new lockowner.
		 * Use open owner and open stateid to create lock owner and
		 * lock stateid.
		 */
L
Linus Torvalds 已提交
3518 3519 3520 3521
		struct nfs4_stateid *open_stp = NULL;
		struct nfs4_file *fp;
		
		status = nfserr_stale_clientid;
A
Andy Adamson 已提交
3522 3523
		if (!nfsd4_has_session(cstate) &&
		    STALE_CLIENTID(&lock->lk_new_clientid))
L
Linus Torvalds 已提交
3524 3525 3526
			goto out;

		/* validate and update open stateid and open seqid */
3527
		status = nfs4_preprocess_seqid_op(cstate,
L
Linus Torvalds 已提交
3528 3529
				        lock->lk_new_open_seqid,
		                        &lock->lk_new_open_stateid,
3530
					OPEN_STATE,
3531
		                        &lock->lk_replay_owner, &open_stp,
3532
					lock);
3533
		if (status)
L
Linus Torvalds 已提交
3534
			goto out;
3535
		open_sop = lock->lk_replay_owner;
L
Linus Torvalds 已提交
3536 3537 3538 3539 3540
		/* create lockowner and lock stateid */
		fp = open_stp->st_file;
		strhashval = lock_ownerstr_hashval(fp->fi_inode, 
				open_sop->so_client->cl_clientid.cl_id, 
				&lock->v.new.owner);
3541 3542 3543
		/* XXX: Do we need to check for duplicate stateowners on
		 * the same file, or should they just be allowed (and
		 * create new stateids)? */
L
Linus Torvalds 已提交
3544
		status = nfserr_resource;
3545 3546 3547
		lock_sop = alloc_init_lock_stateowner(strhashval,
				open_sop->so_client, open_stp, lock);
		if (lock_sop == NULL)
L
Linus Torvalds 已提交
3548
			goto out;
3549
		lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp);
3550
		if (lock_stp == NULL)
L
Linus Torvalds 已提交
3551 3552 3553
			goto out;
	} else {
		/* lock (lock owner + lock stateid) already exists */
3554
		status = nfs4_preprocess_seqid_op(cstate,
L
Linus Torvalds 已提交
3555 3556
				       lock->lk_old_lock_seqid, 
				       &lock->lk_old_lock_stateid, 
3557
				       LOCK_STATE,
3558
				       &lock->lk_replay_owner, &lock_stp, lock);
L
Linus Torvalds 已提交
3559 3560
		if (status)
			goto out;
3561
		lock_sop = lock->lk_replay_owner;
L
Linus Torvalds 已提交
3562
	}
3563
	/* lock->lk_replay_owner and lock_stp have been created or found */
L
Linus Torvalds 已提交
3564 3565
	filp = lock_stp->st_vfs_file;

3566
	status = nfserr_grace;
3567
	if (locks_in_grace() && !lock->lk_reclaim)
3568 3569
		goto out;
	status = nfserr_no_grace;
3570
	if (!locks_in_grace() && lock->lk_reclaim)
3571 3572
		goto out;

L
Linus Torvalds 已提交
3573 3574 3575 3576 3577
	locks_init_lock(&file_lock);
	switch (lock->lk_type) {
		case NFS4_READ_LT:
		case NFS4_READW_LT:
			file_lock.fl_type = F_RDLCK;
3578
			cmd = F_SETLK;
L
Linus Torvalds 已提交
3579 3580 3581 3582
		break;
		case NFS4_WRITE_LT:
		case NFS4_WRITEW_LT:
			file_lock.fl_type = F_WRLCK;
3583
			cmd = F_SETLK;
L
Linus Torvalds 已提交
3584 3585 3586 3587 3588
		break;
		default:
			status = nfserr_inval;
		goto out;
	}
3589
	file_lock.fl_owner = (fl_owner_t)lock_sop;
L
Linus Torvalds 已提交
3590 3591 3592
	file_lock.fl_pid = current->tgid;
	file_lock.fl_file = filp;
	file_lock.fl_flags = FL_POSIX;
3593
	file_lock.fl_lmops = &nfsd_posix_mng_ops;
L
Linus Torvalds 已提交
3594 3595

	file_lock.fl_start = lock->lk_offset;
B
Benny Halevy 已提交
3596
	file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
L
Linus Torvalds 已提交
3597 3598 3599 3600 3601 3602 3603
	nfs4_transform_lock_offset(&file_lock);

	/*
	* Try to lock the file in the VFS.
	* Note: locks.c uses the BKL to protect the inode's lock list.
	*/

3604
	err = vfs_lock_file(filp, cmd, &file_lock, &conflock);
3605
	switch (-err) {
L
Linus Torvalds 已提交
3606 3607 3608 3609
	case 0: /* success! */
		update_stateid(&lock_stp->st_stateid);
		memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid, 
				sizeof(stateid_t));
3610
		status = 0;
3611 3612 3613 3614 3615 3616
		break;
	case (EAGAIN):		/* conflock holds conflicting lock */
		status = nfserr_denied;
		dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
		nfs4_set_lock_denied(&conflock, &lock->lk_denied);
		break;
L
Linus Torvalds 已提交
3617 3618
	case (EDEADLK):
		status = nfserr_deadlock;
3619
		break;
L
Linus Torvalds 已提交
3620
	default:        
3621
		dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
3622 3623
		status = nfserr_resource;
		break;
L
Linus Torvalds 已提交
3624 3625
	}
out:
3626
	if (status && lock->lk_is_new && lock_sop)
3627
		release_lockowner(lock_sop);
3628 3629
	if (lock->lk_replay_owner) {
		nfs4_get_stateowner(lock->lk_replay_owner);
3630
		cstate->replay_owner = lock->lk_replay_owner;
N
Neil Brown 已提交
3631
	}
L
Linus Torvalds 已提交
3632 3633 3634 3635
	nfs4_unlock_state();
	return status;
}

3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654
/*
 * 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.)
 */
static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
{
	struct file *file;
	int err;

	err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
	if (err)
		return err;
	err = vfs_test_lock(file, lock);
	nfsd_close(file);
	return err;
}

L
Linus Torvalds 已提交
3655 3656 3657
/*
 * LOCKT operation
 */
3658
__be32
3659 3660
nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	    struct nfsd4_lockt *lockt)
L
Linus Torvalds 已提交
3661 3662 3663
{
	struct inode *inode;
	struct file_lock file_lock;
3664
	int error;
3665
	__be32 status;
L
Linus Torvalds 已提交
3666

3667
	if (locks_in_grace())
L
Linus Torvalds 已提交
3668 3669 3670 3671 3672 3673 3674 3675 3676
		return nfserr_grace;

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

	lockt->lt_stateowner = NULL;
	nfs4_lock_state();

	status = nfserr_stale_clientid;
A
Andy Adamson 已提交
3677
	if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid))
L
Linus Torvalds 已提交
3678 3679
		goto out;

3680
	if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) {
N
Neil Brown 已提交
3681
		dprintk("NFSD: nfsd4_lockt: fh_verify() failed!\n");
L
Linus Torvalds 已提交
3682 3683 3684 3685 3686
		if (status == nfserr_symlink)
			status = nfserr_inval;
		goto out;
	}

3687
	inode = cstate->current_fh.fh_dentry->d_inode;
L
Linus Torvalds 已提交
3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698
	locks_init_lock(&file_lock);
	switch (lockt->lt_type) {
		case NFS4_READ_LT:
		case NFS4_READW_LT:
			file_lock.fl_type = F_RDLCK;
		break;
		case NFS4_WRITE_LT:
		case NFS4_WRITEW_LT:
			file_lock.fl_type = F_WRLCK;
		break;
		default:
3699
			dprintk("NFSD: nfs4_lockt: bad lock type!\n");
L
Linus Torvalds 已提交
3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711
			status = nfserr_inval;
		goto out;
	}

	lockt->lt_stateowner = find_lockstateowner_str(inode,
			&lockt->lt_clientid, &lockt->lt_owner);
	if (lockt->lt_stateowner)
		file_lock.fl_owner = (fl_owner_t)lockt->lt_stateowner;
	file_lock.fl_pid = current->tgid;
	file_lock.fl_flags = FL_POSIX;

	file_lock.fl_start = lockt->lt_offset;
B
Benny Halevy 已提交
3712
	file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
L
Linus Torvalds 已提交
3713 3714 3715 3716

	nfs4_transform_lock_offset(&file_lock);

	status = nfs_ok;
3717
	error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
3718 3719 3720 3721
	if (error) {
		status = nfserrno(error);
		goto out;
	}
3722
	if (file_lock.fl_type != F_UNLCK) {
L
Linus Torvalds 已提交
3723
		status = nfserr_denied;
3724
		nfs4_set_lock_denied(&file_lock, &lockt->lt_denied);
L
Linus Torvalds 已提交
3725 3726 3727 3728 3729 3730
	}
out:
	nfs4_unlock_state();
	return status;
}

3731
__be32
3732
nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3733
	    struct nfsd4_locku *locku)
L
Linus Torvalds 已提交
3734 3735 3736 3737
{
	struct nfs4_stateid *stp;
	struct file *filp = NULL;
	struct file_lock file_lock;
3738
	__be32 status;
3739
	int err;
L
Linus Torvalds 已提交
3740 3741 3742 3743 3744 3745 3746 3747 3748 3749
						        
	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();
									        
3750
	if ((status = nfs4_preprocess_seqid_op(cstate,
L
Linus Torvalds 已提交
3751 3752
					locku->lu_seqid, 
					&locku->lu_stateid, 
3753
					LOCK_STATE,
L
Linus Torvalds 已提交
3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764
					&locku->lu_stateowner, &stp, NULL)))
		goto out;

	filp = stp->st_vfs_file;
	BUG_ON(!filp);
	locks_init_lock(&file_lock);
	file_lock.fl_type = F_UNLCK;
	file_lock.fl_owner = (fl_owner_t) locku->lu_stateowner;
	file_lock.fl_pid = current->tgid;
	file_lock.fl_file = filp;
	file_lock.fl_flags = FL_POSIX; 
3765
	file_lock.fl_lmops = &nfsd_posix_mng_ops;
L
Linus Torvalds 已提交
3766 3767
	file_lock.fl_start = locku->lu_offset;

B
Benny Halevy 已提交
3768
	file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
L
Linus Torvalds 已提交
3769 3770 3771 3772 3773
	nfs4_transform_lock_offset(&file_lock);

	/*
	*  Try to unlock the file in the VFS.
	*/
3774
	err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL);
3775
	if (err) {
3776
		dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
L
Linus Torvalds 已提交
3777 3778 3779 3780 3781 3782 3783 3784 3785
		goto out_nfserr;
	}
	/*
	* OK, unlock succeeded; the only thing left to do is update the stateid.
	*/
	update_stateid(&stp->st_stateid);
	memcpy(&locku->lu_stateid, &stp->st_stateid, sizeof(stateid_t));

out:
N
Neil Brown 已提交
3786
	if (locku->lu_stateowner) {
L
Linus Torvalds 已提交
3787
		nfs4_get_stateowner(locku->lu_stateowner);
3788
		cstate->replay_owner = locku->lu_stateowner;
N
Neil Brown 已提交
3789
	}
L
Linus Torvalds 已提交
3790 3791 3792 3793
	nfs4_unlock_state();
	return status;

out_nfserr:
3794
	status = nfserrno(err);
L
Linus Torvalds 已提交
3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806
	goto out;
}

/*
 * returns
 * 	1: locks held by lockowner
 * 	0: no locks held by lockowner
 */
static int
check_for_locks(struct file *filp, struct nfs4_stateowner *lowner)
{
	struct file_lock **flpp;
3807
	struct inode *inode = filp->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
3808 3809 3810 3811
	int status = 0;

	lock_kernel();
	for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
3812
		if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
L
Linus Torvalds 已提交
3813 3814
			status = 1;
			goto out;
3815
		}
L
Linus Torvalds 已提交
3816 3817 3818 3819 3820 3821
	}
out:
	unlock_kernel();
	return status;
}

3822
__be32
3823 3824 3825
nfsd4_release_lockowner(struct svc_rqst *rqstp,
			struct nfsd4_compound_state *cstate,
			struct nfsd4_release_lockowner *rlockowner)
L
Linus Torvalds 已提交
3826 3827
{
	clientid_t *clid = &rlockowner->rl_clientid;
3828 3829
	struct nfs4_stateowner *sop;
	struct nfs4_stateid *stp;
L
Linus Torvalds 已提交
3830
	struct xdr_netobj *owner = &rlockowner->rl_owner;
3831 3832
	struct list_head matches;
	int i;
3833
	__be32 status;
L
Linus Torvalds 已提交
3834 3835 3836 3837 3838 3839 3840

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

	/* XXX check for lease expiration */

	status = nfserr_stale_clientid;
N
Neil Brown 已提交
3841
	if (STALE_CLIENTID(clid))
L
Linus Torvalds 已提交
3842 3843 3844 3845
		return status;

	nfs4_lock_state();

3846 3847 3848 3849 3850 3851 3852 3853
	status = nfserr_locks_held;
	/* XXX: we're doing a linear search through all the lockowners.
	 * Yipes!  For now we'll just hope clients aren't really using
	 * release_lockowner much, but eventually we have to fix these
	 * data structures. */
	INIT_LIST_HEAD(&matches);
	for (i = 0; i < LOCK_HASH_SIZE; i++) {
		list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) {
3854
			if (!same_owner_str(sop, owner, clid))
3855 3856 3857 3858 3859 3860 3861 3862 3863
				continue;
			list_for_each_entry(stp, &sop->so_stateids,
					st_perstateowner) {
				if (check_for_locks(stp->st_vfs_file, sop))
					goto out;
				/* Note: so_perclient unused for lockowners,
				 * so it's OK to fool with here. */
				list_add(&sop->so_perclient, &matches);
			}
L
Linus Torvalds 已提交
3864
		}
3865 3866 3867 3868 3869
	}
	/* 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 已提交
3870 3871 3872 3873 3874 3875
	while (!list_empty(&matches)) {
		sop = list_entry(matches.next, struct nfs4_stateowner,
								so_perclient);
		/* unhash_stateowner deletes so_perclient only
		 * for openowners. */
		list_del(&sop->so_perclient);
3876
		release_lockowner(sop);
L
Linus Torvalds 已提交
3877 3878 3879 3880 3881 3882 3883
	}
out:
	nfs4_unlock_state();
	return status;
}

static inline struct nfs4_client_reclaim *
N
NeilBrown 已提交
3884
alloc_reclaim(void)
L
Linus Torvalds 已提交
3885
{
N
NeilBrown 已提交
3886
	return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
L
Linus Torvalds 已提交
3887 3888
}

3889
int
3890
nfs4_has_reclaimed_state(const char *name, bool use_exchange_id)
3891 3892 3893 3894
{
	unsigned int strhashval = clientstr_hashval(name);
	struct nfs4_client *clp;

3895
	clp = find_confirmed_client_by_str(name, strhashval, use_exchange_id);
3896 3897 3898
	return clp ? 1 : 0;
}

L
Linus Torvalds 已提交
3899 3900 3901
/*
 * failure => all reset bets are off, nfserr_no_grace...
 */
3902 3903
int
nfs4_client_to_reclaim(const char *name)
L
Linus Torvalds 已提交
3904 3905 3906 3907
{
	unsigned int strhashval;
	struct nfs4_client_reclaim *crp = NULL;

N
NeilBrown 已提交
3908 3909
	dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
	crp = alloc_reclaim();
L
Linus Torvalds 已提交
3910 3911
	if (!crp)
		return 0;
N
NeilBrown 已提交
3912
	strhashval = clientstr_hashval(name);
L
Linus Torvalds 已提交
3913 3914
	INIT_LIST_HEAD(&crp->cr_strhash);
	list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
N
NeilBrown 已提交
3915
	memcpy(crp->cr_recdir, name, HEXDIR_LEN);
L
Linus Torvalds 已提交
3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939
	reclaim_str_hashtbl_size++;
	return 1;
}

static void
nfs4_release_reclaim(void)
{
	struct nfs4_client_reclaim *crp = NULL;
	int i;

	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
		while (!list_empty(&reclaim_str_hashtbl[i])) {
			crp = list_entry(reclaim_str_hashtbl[i].next,
			                struct nfs4_client_reclaim, cr_strhash);
			list_del(&crp->cr_strhash);
			kfree(crp);
			reclaim_str_hashtbl_size--;
		}
	}
	BUG_ON(reclaim_str_hashtbl_size);
}

/*
 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
3940
static struct nfs4_client_reclaim *
L
Linus Torvalds 已提交
3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952
nfs4_find_reclaim_client(clientid_t *clid)
{
	unsigned int strhashval;
	struct nfs4_client *clp;
	struct nfs4_client_reclaim *crp = NULL;


	/* find clientid in conf_id_hashtbl */
	clp = find_confirmed_client(clid);
	if (clp == NULL)
		return NULL;

N
NeilBrown 已提交
3953 3954 3955
	dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
		            clp->cl_name.len, clp->cl_name.data,
			    clp->cl_recdir);
L
Linus Torvalds 已提交
3956 3957

	/* find clp->cl_name in reclaim_str_hashtbl */
N
NeilBrown 已提交
3958
	strhashval = clientstr_hashval(clp->cl_recdir);
L
Linus Torvalds 已提交
3959
	list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
N
NeilBrown 已提交
3960
		if (same_name(crp->cr_recdir, clp->cl_recdir)) {
L
Linus Torvalds 已提交
3961 3962 3963 3964 3965 3966 3967 3968 3969
			return crp;
		}
	}
	return NULL;
}

/*
* Called from OPEN. Look for clientid in reclaim list.
*/
3970
__be32
L
Linus Torvalds 已提交
3971 3972
nfs4_check_open_reclaim(clientid_t *clid)
{
3973
	return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad;
L
Linus Torvalds 已提交
3974 3975
}

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

3978
int
3979
nfs4_state_init(void)
L
Linus Torvalds 已提交
3980
{
3981
	int i, status;
L
Linus Torvalds 已提交
3982

3983 3984 3985
	status = nfsd4_init_slabs();
	if (status)
		return status;
L
Linus Torvalds 已提交
3986 3987 3988 3989 3990 3991
	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
		INIT_LIST_HEAD(&conf_id_hashtbl[i]);
		INIT_LIST_HEAD(&conf_str_hashtbl[i]);
		INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
		INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
	}
M
Marc Eshel 已提交
3992 3993
	for (i = 0; i < SESSION_HASH_SIZE; i++)
		INIT_LIST_HEAD(&sessionid_hashtbl[i]);
L
Linus Torvalds 已提交
3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012
	for (i = 0; i < FILE_HASH_SIZE; i++) {
		INIT_LIST_HEAD(&file_hashtbl[i]);
	}
	for (i = 0; i < OWNER_HASH_SIZE; i++) {
		INIT_LIST_HEAD(&ownerstr_hashtbl[i]);
		INIT_LIST_HEAD(&ownerid_hashtbl[i]);
	}
	for (i = 0; i < STATEID_HASH_SIZE; i++) {
		INIT_LIST_HEAD(&stateid_hashtbl[i]);
		INIT_LIST_HEAD(&lockstateid_hashtbl[i]);
	}
	for (i = 0; i < LOCK_HASH_SIZE; i++) {
		INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]);
		INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]);
	}
	memset(&onestateid, ~0, sizeof(stateid_t));
	INIT_LIST_HEAD(&close_lru);
	INIT_LIST_HEAD(&client_lru);
	INIT_LIST_HEAD(&del_recall_lru);
4013 4014 4015
	for (i = 0; i < CLIENT_HASH_SIZE; i++)
		INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
	reclaim_str_hashtbl_size = 0;
4016
	return 0;
4017 4018
}

4019 4020 4021 4022 4023
static void
nfsd4_load_reboot_recovery_data(void)
{
	int status;

4024 4025
	nfs4_lock_state();
	nfsd4_init_recdir(user_recovery_dirname);
4026
	status = nfsd4_recdir_load();
4027
	nfs4_unlock_state();
4028 4029 4030 4031
	if (status)
		printk("NFSD: Failure reading reboot recovery data\n");
}

4032 4033 4034 4035 4036 4037
unsigned long
get_nfs4_grace_period(void)
{
	return max(user_lease_time, lease_time) * HZ;
}

4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058
/*
 * 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);
}

4059 4060 4061 4062 4063
/* initialization to perform when the nfsd service is started: */

static void
__nfs4_state_start(void)
{
4064
	unsigned long grace_time;
4065

L
Linus Torvalds 已提交
4066
	boot_time = get_seconds();
4067
	grace_time = get_nfs4_grace_period();
4068
	lease_time = user_lease_time;
4069
	locks_start_grace(&nfsd4_manager);
4070 4071
	printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
	       grace_time/HZ);
4072
	laundry_wq = create_singlethread_workqueue("nfsd4");
4073
	queue_delayed_work(laundry_wq, &laundromat_work, grace_time);
4074
	set_max_delegations();
L
Linus Torvalds 已提交
4075 4076
}

4077
void
4078
nfs4_state_start(void)
L
Linus Torvalds 已提交
4079 4080
{
	if (nfs4_init)
4081
		return;
4082
	nfsd4_load_reboot_recovery_data();
4083
	__nfs4_state_start();
L
Linus Torvalds 已提交
4084
	nfs4_init = 1;
4085
	return;
L
Linus Torvalds 已提交
4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124
}

time_t
nfs4_lease_time(void)
{
	return lease_time;
}

static void
__nfs4_state_shutdown(void)
{
	int i;
	struct nfs4_client *clp = NULL;
	struct nfs4_delegation *dp = NULL;
	struct list_head *pos, *next, reaplist;

	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
		while (!list_empty(&conf_id_hashtbl[i])) {
			clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
			expire_client(clp);
		}
		while (!list_empty(&unconf_str_hashtbl[i])) {
			clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
			expire_client(clp);
		}
	}
	INIT_LIST_HEAD(&reaplist);
	spin_lock(&recall_lock);
	list_for_each_safe(pos, next, &del_recall_lru) {
		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);
		list_del_init(&dp->dl_recall_lru);
		unhash_delegation(dp);
	}

4125
	nfsd4_shutdown_recdir();
L
Linus Torvalds 已提交
4126 4127 4128 4129 4130 4131
	nfs4_init = 0;
}

void
nfs4_state_shutdown(void)
{
4132 4133
	cancel_rearming_delayed_workqueue(laundry_wq, &laundromat_work);
	destroy_workqueue(laundry_wq);
4134
	locks_end_grace(&nfsd4_manager);
L
Linus Torvalds 已提交
4135 4136 4137 4138 4139 4140
	nfs4_lock_state();
	nfs4_release_reclaim();
	__nfs4_state_shutdown();
	nfs4_unlock_state();
}

4141 4142 4143 4144
/*
 * user_recovery_dirname is protected by the nfsd_mutex since it's only
 * accessed when nfsd is starting.
 */
4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157
static void
nfs4_set_recdir(char *recdir)
{
	strcpy(user_recovery_dirname, recdir);
}

/*
 * Change the NFSv4 recovery directory to recdir.
 */
int
nfs4_reset_recoverydir(char *recdir)
{
	int status;
A
Al Viro 已提交
4158
	struct path path;
4159

A
Al Viro 已提交
4160
	status = kern_path(recdir, LOOKUP_FOLLOW, &path);
4161 4162 4163
	if (status)
		return status;
	status = -ENOTDIR;
A
Al Viro 已提交
4164
	if (S_ISDIR(path.dentry->d_inode->i_mode)) {
4165 4166 4167
		nfs4_set_recdir(recdir);
		status = 0;
	}
A
Al Viro 已提交
4168
	path_put(&path);
4169 4170 4171
	return status;
}

4172 4173 4174 4175 4176 4177
char *
nfs4_recoverydir(void)
{
	return user_recovery_dirname;
}

L
Linus Torvalds 已提交
4178 4179 4180
/*
 * Called when leasetime is changed.
 *
4181 4182 4183 4184 4185
 * The only way the protocol gives us to handle on-the-fly lease changes is to
 * simulate a reboot.  Instead of doing that, we just wait till the next time
 * we start to register any changes in lease time.  If the administrator
 * really wants to change the lease time *now*, they can go ahead and bring
 * nfsd down and then back up again after changing the lease time.
4186 4187 4188
 *
 * user_lease_time is protected by nfsd_mutex since it's only really accessed
 * when nfsd is starting
L
Linus Torvalds 已提交
4189 4190 4191 4192
 */
void
nfs4_reset_lease(time_t leasetime)
{
4193
	user_lease_time = leasetime;
L
Linus Torvalds 已提交
4194
}