1/*
   2*  Copyright (c) 2001 The Regents of the University of Michigan.
   3*  All rights reserved.
   4*
   5*  Kendrick Smith <kmsmith@umich.edu>
   6*  Andy Adamson <kandros@umich.edu>
   7*
   8*  Redistribution and use in source and binary forms, with or without
   9*  modification, are permitted provided that the following conditions
  10*  are met:
  11*
  12*  1. Redistributions of source code must retain the above copyright
  13*     notice, this list of conditions and the following disclaimer.
  14*  2. Redistributions in binary form must reproduce the above copyright
  15*     notice, this list of conditions and the following disclaimer in the
  16*     documentation and/or other materials provided with the distribution.
  17*  3. Neither the name of the University nor the names of its
  18*     contributors may be used to endorse or promote products derived
  19*     from this software without specific prior written permission.
  20*
  21*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  22*  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  23*  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  24*  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25*  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26*  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27*  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  28*  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  29*  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  30*  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  31*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32*
  33*/
  34
  35#include <linux/file.h>
  36#include <linux/fs.h>
  37#include <linux/slab.h>
  38#include <linux/namei.h>
  39#include <linux/swap.h>
  40#include <linux/pagemap.h>
  41#include <linux/sunrpc/svcauth_gss.h>
  42#include <linux/sunrpc/clnt.h>
  43#include "xdr4.h"
  44#include "vfs.h"
 
  45
  46#define NFSDDBG_FACILITY                NFSDDBG_PROC
  47
  48/* Globals */
  49time_t nfsd4_lease = 90;     /* default lease time */
  50time_t nfsd4_grace = 90;
  51static time_t boot_time;
  52static u32 current_ownerid = 1;
  53static u32 current_fileid = 1;
  54static u32 current_delegid = 1;
  55static stateid_t zerostateid;             /* bits all 0 */
  56static stateid_t onestateid;              /* bits all 1 */
 
 
 
 
 
 
 
 
  57static u64 current_sessionid = 1;
  58
  59#define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
  60#define ONE_STATEID(stateid)  (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
 
  61
  62/* forward declarations */
  63static struct nfs4_stateid * find_stateid(stateid_t *stid, int flags);
  64static struct nfs4_stateid * search_for_stateid(stateid_t *stid);
  65static struct nfs4_delegation * search_for_delegation(stateid_t *stid);
  66static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid);
  67static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
  68static void nfs4_set_recdir(char *recdir);
  69static int check_for_locks(struct nfs4_file *filp, struct nfs4_stateowner *lowner);
  70
  71/* Locking: */
  72
  73/* Currently used for almost all code touching nfsv4 state: */
  74static DEFINE_MUTEX(client_mutex);
  75
  76/*
  77 * Currently used for the del_recall_lru and file hash table.  In an
  78 * effort to decrease the scope of the client_mutex, this spinlock may
  79 * eventually cover more:
  80 */
  81static DEFINE_SPINLOCK(recall_lock);
  82
  83static struct kmem_cache *stateowner_slab = NULL;
 
  84static struct kmem_cache *file_slab = NULL;
  85static struct kmem_cache *stateid_slab = NULL;
  86static struct kmem_cache *deleg_slab = NULL;
  87
  88void
  89nfs4_lock_state(void)
  90{
  91	mutex_lock(&client_mutex);
  92}
  93
 
 
 
 
 
 
 
 
 
 
 
 
 
  94void
  95nfs4_unlock_state(void)
  96{
  97	mutex_unlock(&client_mutex);
  98}
  99
 100static inline u32
 101opaque_hashval(const void *ptr, int nbytes)
 102{
 103	unsigned char *cptr = (unsigned char *) ptr;
 104
 105	u32 x = 0;
 106	while (nbytes--) {
 107		x *= 37;
 108		x += *cptr++;
 109	}
 110	return x;
 111}
 112
 113static struct list_head del_recall_lru;
 114
 
 
 
 
 
 115static inline void
 116put_nfs4_file(struct nfs4_file *fi)
 117{
 118	if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
 119		list_del(&fi->fi_hash);
 120		spin_unlock(&recall_lock);
 121		iput(fi->fi_inode);
 122		kmem_cache_free(file_slab, fi);
 123	}
 124}
 125
 126static inline void
 127get_nfs4_file(struct nfs4_file *fi)
 128{
 129	atomic_inc(&fi->fi_ref);
 130}
 131
 132static int num_delegations;
 133unsigned int max_delegations;
 134
 135/*
 136 * Open owner state (share locks)
 137 */
 138
 139/* hash tables for nfs4_stateowner */
 140#define OWNER_HASH_BITS              8
 141#define OWNER_HASH_SIZE             (1 << OWNER_HASH_BITS)
 142#define OWNER_HASH_MASK             (OWNER_HASH_SIZE - 1)
 143
 144#define ownerid_hashval(id) \
 145        ((id) & OWNER_HASH_MASK)
 146#define ownerstr_hashval(clientid, ownername) \
 147        (((clientid) + opaque_hashval((ownername.data), (ownername.len))) & OWNER_HASH_MASK)
 
 
 
 
 148
 149static struct list_head	ownerid_hashtbl[OWNER_HASH_SIZE];
 150static struct list_head	ownerstr_hashtbl[OWNER_HASH_SIZE];
 151
 152/* hash table for nfs4_file */
 153#define FILE_HASH_BITS                   8
 154#define FILE_HASH_SIZE                  (1 << FILE_HASH_BITS)
 155
 156/* hash table for (open)nfs4_stateid */
 157#define STATEID_HASH_BITS              10
 158#define STATEID_HASH_SIZE              (1 << STATEID_HASH_BITS)
 159#define STATEID_HASH_MASK              (STATEID_HASH_SIZE - 1)
 160
 161#define file_hashval(x) \
 162        hash_ptr(x, FILE_HASH_BITS)
 163#define stateid_hashval(owner_id, file_id)  \
 164        (((owner_id) + (file_id)) & STATEID_HASH_MASK)
 165
 166static struct list_head file_hashtbl[FILE_HASH_SIZE];
 167static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];
 168
 169static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
 170{
 171	BUG_ON(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
 172	atomic_inc(&fp->fi_access[oflag]);
 173}
 174
 175static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
 176{
 177	if (oflag == O_RDWR) {
 178		__nfs4_file_get_access(fp, O_RDONLY);
 179		__nfs4_file_get_access(fp, O_WRONLY);
 180	} else
 181		__nfs4_file_get_access(fp, oflag);
 182}
 183
 184static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
 185{
 186	if (fp->fi_fds[oflag]) {
 187		fput(fp->fi_fds[oflag]);
 188		fp->fi_fds[oflag] = NULL;
 189	}
 190}
 191
 192static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
 193{
 194	if (atomic_dec_and_test(&fp->fi_access[oflag])) {
 195		nfs4_file_put_fd(fp, O_RDWR);
 196		nfs4_file_put_fd(fp, oflag);
 
 
 
 
 
 
 
 
 197	}
 198}
 199
 200static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
 201{
 202	if (oflag == O_RDWR) {
 203		__nfs4_file_put_access(fp, O_RDONLY);
 204		__nfs4_file_put_access(fp, O_WRONLY);
 205	} else
 206		__nfs4_file_put_access(fp, oflag);
 207}
 208
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 209static struct nfs4_delegation *
 210alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_fh *current_fh, u32 type)
 211{
 212	struct nfs4_delegation *dp;
 213	struct nfs4_file *fp = stp->st_file;
 214
 215	dprintk("NFSD alloc_init_deleg\n");
 216	/*
 217	 * Major work on the lease subsystem (for example, to support
 218	 * calbacks on stat) will be required before we can support
 219	 * write delegations properly.
 220	 */
 221	if (type != NFS4_OPEN_DELEGATE_READ)
 222		return NULL;
 223	if (fp->fi_had_conflict)
 224		return NULL;
 225	if (num_delegations > max_delegations)
 226		return NULL;
 227	dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
 228	if (dp == NULL)
 229		return dp;
 
 
 
 
 
 
 
 230	num_delegations++;
 231	INIT_LIST_HEAD(&dp->dl_perfile);
 232	INIT_LIST_HEAD(&dp->dl_perclnt);
 233	INIT_LIST_HEAD(&dp->dl_recall_lru);
 234	dp->dl_client = clp;
 235	get_nfs4_file(fp);
 236	dp->dl_file = fp;
 237	dp->dl_type = type;
 238	dp->dl_stateid.si_boot = boot_time;
 239	dp->dl_stateid.si_stateownerid = current_delegid++;
 240	dp->dl_stateid.si_fileid = 0;
 241	dp->dl_stateid.si_generation = 0;
 242	fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
 243	dp->dl_time = 0;
 244	atomic_set(&dp->dl_count, 1);
 245	INIT_WORK(&dp->dl_recall.cb_work, nfsd4_do_callback_rpc);
 246	return dp;
 247}
 248
 249void
 250nfs4_put_delegation(struct nfs4_delegation *dp)
 251{
 252	if (atomic_dec_and_test(&dp->dl_count)) {
 253		dprintk("NFSD: freeing dp %p\n",dp);
 254		put_nfs4_file(dp->dl_file);
 255		kmem_cache_free(deleg_slab, dp);
 256		num_delegations--;
 257	}
 258}
 259
 260static void nfs4_put_deleg_lease(struct nfs4_file *fp)
 261{
 262	if (atomic_dec_and_test(&fp->fi_delegees)) {
 263		vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
 264		fp->fi_lease = NULL;
 265		fput(fp->fi_deleg_file);
 266		fp->fi_deleg_file = NULL;
 267	}
 268}
 269
 
 
 
 
 
 
 
 270/* Called under the state lock. */
 271static void
 272unhash_delegation(struct nfs4_delegation *dp)
 273{
 
 274	list_del_init(&dp->dl_perclnt);
 275	spin_lock(&recall_lock);
 276	list_del_init(&dp->dl_perfile);
 277	list_del_init(&dp->dl_recall_lru);
 278	spin_unlock(&recall_lock);
 279	nfs4_put_deleg_lease(dp->dl_file);
 280	nfs4_put_delegation(dp);
 281}
 282
 283/* 
 284 * SETCLIENTID state 
 285 */
 286
 287/* client_lock protects the client lru list and session hash table */
 288static DEFINE_SPINLOCK(client_lock);
 289
 290/* Hash tables for nfs4_clientid state */
 291#define CLIENT_HASH_BITS                 4
 292#define CLIENT_HASH_SIZE                (1 << CLIENT_HASH_BITS)
 293#define CLIENT_HASH_MASK                (CLIENT_HASH_SIZE - 1)
 294
 295#define clientid_hashval(id) \
 296	((id) & CLIENT_HASH_MASK)
 297#define clientstr_hashval(name) \
 298	(opaque_hashval((name), 8) & CLIENT_HASH_MASK)
 
 
 
 
 
 
 299/*
 300 * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
 301 * used in reboot/reset lease grace period processing
 302 *
 303 * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
 304 * setclientid_confirmed info. 
 305 *
 306 * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed 
 307 * setclientid info.
 308 *
 309 * client_lru holds client queue ordered by nfs4_client.cl_time
 310 * for lease renewal.
 311 *
 312 * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
 313 * for last close replay.
 314 */
 315static struct list_head	reclaim_str_hashtbl[CLIENT_HASH_SIZE];
 316static int reclaim_str_hashtbl_size = 0;
 317static struct list_head	conf_id_hashtbl[CLIENT_HASH_SIZE];
 318static struct list_head	conf_str_hashtbl[CLIENT_HASH_SIZE];
 319static struct list_head	unconf_str_hashtbl[CLIENT_HASH_SIZE];
 320static struct list_head	unconf_id_hashtbl[CLIENT_HASH_SIZE];
 321static struct list_head client_lru;
 322static struct list_head close_lru;
 323
 324/*
 325 * We store the NONE, READ, WRITE, and BOTH bits separately in the
 326 * st_{access,deny}_bmap field of the stateid, in order to track not
 327 * only what share bits are currently in force, but also what
 328 * combinations of share bits previous opens have used.  This allows us
 329 * to enforce the recommendation of rfc 3530 14.2.19 that the server
 330 * return an error if the client attempt to downgrade to a combination
 331 * of share bits not explicable by closing some of its previous opens.
 332 *
 333 * XXX: This enforcement is actually incomplete, since we don't keep
 334 * track of access/deny bit combinations; so, e.g., we allow:
 335 *
 336 *	OPEN allow read, deny write
 337 *	OPEN allow both, deny none
 338 *	DOWNGRADE allow read, deny none
 339 *
 340 * which we should reject.
 341 */
 342static void
 343set_access(unsigned int *access, unsigned long bmap) {
 344	int i;
 
 345
 346	*access = 0;
 347	for (i = 1; i < 4; i++) {
 348		if (test_bit(i, &bmap))
 349			*access |= i;
 350	}
 
 351}
 352
 353static void
 354set_deny(unsigned int *deny, unsigned long bmap) {
 355	int i;
 356
 357	*deny = 0;
 358	for (i = 0; i < 4; i++) {
 359		if (test_bit(i, &bmap))
 360			*deny |= i ;
 361	}
 362}
 363
 364static int
 365test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) {
 366	unsigned int access, deny;
 
 
 
 367
 368	set_access(&access, stp->st_access_bmap);
 369	set_deny(&deny, stp->st_deny_bmap);
 370	if ((access & open->op_share_deny) || (deny & open->op_share_access))
 371		return 0;
 372	return 1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 373}
 374
 375static int nfs4_access_to_omode(u32 access)
 376{
 377	switch (access & NFS4_SHARE_ACCESS_BOTH) {
 378	case NFS4_SHARE_ACCESS_READ:
 379		return O_RDONLY;
 380	case NFS4_SHARE_ACCESS_WRITE:
 381		return O_WRONLY;
 382	case NFS4_SHARE_ACCESS_BOTH:
 383		return O_RDWR;
 384	}
 385	BUG();
 386}
 387
 388static void unhash_generic_stateid(struct nfs4_stateid *stp)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 389{
 390	list_del(&stp->st_hash);
 391	list_del(&stp->st_perfile);
 392	list_del(&stp->st_perstateowner);
 393}
 394
 395static void free_generic_stateid(struct nfs4_stateid *stp)
 396{
 397	int i;
 398
 399	if (stp->st_access_bmap) {
 400		for (i = 1; i < 4; i++) {
 401			if (test_bit(i, &stp->st_access_bmap))
 402				nfs4_file_put_access(stp->st_file,
 403						nfs4_access_to_omode(i));
 404		}
 405	}
 406	put_nfs4_file(stp->st_file);
 
 
 
 
 
 407	kmem_cache_free(stateid_slab, stp);
 408}
 409
 410static void release_lock_stateid(struct nfs4_stateid *stp)
 411{
 412	struct file *file;
 413
 414	unhash_generic_stateid(stp);
 
 415	file = find_any_file(stp->st_file);
 416	if (file)
 417		locks_remove_posix(file, (fl_owner_t)stp->st_stateowner);
 
 418	free_generic_stateid(stp);
 419}
 420
 421static void unhash_lockowner(struct nfs4_stateowner *sop)
 422{
 423	struct nfs4_stateid *stp;
 424
 425	list_del(&sop->so_idhash);
 426	list_del(&sop->so_strhash);
 427	list_del(&sop->so_perstateid);
 428	while (!list_empty(&sop->so_stateids)) {
 429		stp = list_first_entry(&sop->so_stateids,
 430				struct nfs4_stateid, st_perstateowner);
 431		release_lock_stateid(stp);
 432	}
 433}
 434
 435static void release_lockowner(struct nfs4_stateowner *sop)
 436{
 437	unhash_lockowner(sop);
 438	nfs4_put_stateowner(sop);
 439}
 440
 441static void
 442release_stateid_lockowners(struct nfs4_stateid *open_stp)
 443{
 444	struct nfs4_stateowner *lock_sop;
 445
 446	while (!list_empty(&open_stp->st_lockowners)) {
 447		lock_sop = list_entry(open_stp->st_lockowners.next,
 448				struct nfs4_stateowner, so_perstateid);
 449		/* list_del(&open_stp->st_lockowners);  */
 450		BUG_ON(lock_sop->so_is_open_owner);
 451		release_lockowner(lock_sop);
 452	}
 453}
 454
 455static void release_open_stateid(struct nfs4_stateid *stp)
 456{
 457	unhash_generic_stateid(stp);
 458	release_stateid_lockowners(stp);
 
 
 
 
 
 
 
 459	free_generic_stateid(stp);
 460}
 461
 462static void unhash_openowner(struct nfs4_stateowner *sop)
 463{
 464	struct nfs4_stateid *stp;
 465
 466	list_del(&sop->so_idhash);
 467	list_del(&sop->so_strhash);
 468	list_del(&sop->so_perclient);
 469	list_del(&sop->so_perstateid); /* XXX: necessary? */
 470	while (!list_empty(&sop->so_stateids)) {
 471		stp = list_first_entry(&sop->so_stateids,
 472				struct nfs4_stateid, st_perstateowner);
 473		release_open_stateid(stp);
 474	}
 475}
 476
 477static void release_openowner(struct nfs4_stateowner *sop)
 
 
 
 
 
 
 
 
 
 
 
 478{
 479	unhash_openowner(sop);
 480	list_del(&sop->so_close_lru);
 481	nfs4_put_stateowner(sop);
 
 482}
 483
 484#define SESSION_HASH_SIZE	512
 485static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];
 486
 487static inline int
 488hash_sessionid(struct nfs4_sessionid *sessionid)
 489{
 490	struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
 491
 492	return sid->sequence % SESSION_HASH_SIZE;
 493}
 494
 
 495static inline void
 496dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
 497{
 498	u32 *ptr = (u32 *)(&sessionid->data[0]);
 499	dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
 500}
 
 
 
 
 
 
 
 501
 502static void
 503gen_sessionid(struct nfsd4_session *ses)
 504{
 505	struct nfs4_client *clp = ses->se_client;
 506	struct nfsd4_sessionid *sid;
 507
 508	sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
 509	sid->clientid = clp->cl_clientid;
 510	sid->sequence = current_sessionid++;
 511	sid->reserved = 0;
 512}
 513
 514/*
 515 * The protocol defines ca_maxresponssize_cached to include the size of
 516 * the rpc header, but all we need to cache is the data starting after
 517 * the end of the initial SEQUENCE operation--the rest we regenerate
 518 * each time.  Therefore we can advertise a ca_maxresponssize_cached
 519 * value that is the number of bytes in our cache plus a few additional
 520 * bytes.  In order to stay on the safe side, and not promise more than
 521 * we can cache, those additional bytes must be the minimum possible: 24
 522 * bytes of rpc header (xid through accept state, with AUTH_NULL
 523 * verifier), 12 for the compound header (with zero-length tag), and 44
 524 * for the SEQUENCE op response:
 525 */
 526#define NFSD_MIN_HDR_SEQ_SZ  (24 + 12 + 44)
 527
 528static void
 529free_session_slots(struct nfsd4_session *ses)
 530{
 531	int i;
 532
 533	for (i = 0; i < ses->se_fchannel.maxreqs; i++)
 534		kfree(ses->se_slots[i]);
 535}
 536
 537/*
 538 * We don't actually need to cache the rpc and session headers, so we
 539 * can allocate a little less for each slot:
 540 */
 541static inline int slot_bytes(struct nfsd4_channel_attrs *ca)
 542{
 543	return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
 544}
 545
 546static int nfsd4_sanitize_slot_size(u32 size)
 547{
 548	size -= NFSD_MIN_HDR_SEQ_SZ; /* We don't cache the rpc header */
 549	size = min_t(u32, size, NFSD_SLOT_CACHE_SIZE);
 550
 551	return size;
 552}
 553
 554/*
 555 * XXX: If we run out of reserved DRC memory we could (up to a point)
 556 * re-negotiate active sessions and reduce their slot usage to make
 557 * rooom for new connections. For now we just fail the create session.
 558 */
 559static int nfsd4_get_drc_mem(int slotsize, u32 num)
 560{
 561	int avail;
 562
 563	num = min_t(u32, num, NFSD_MAX_SLOTS_PER_SESSION);
 564
 565	spin_lock(&nfsd_drc_lock);
 566	avail = min_t(int, NFSD_MAX_MEM_PER_SESSION,
 567			nfsd_drc_max_mem - nfsd_drc_mem_used);
 568	num = min_t(int, num, avail / slotsize);
 569	nfsd_drc_mem_used += num * slotsize;
 570	spin_unlock(&nfsd_drc_lock);
 571
 572	return num;
 573}
 574
 575static void nfsd4_put_drc_mem(int slotsize, int num)
 576{
 577	spin_lock(&nfsd_drc_lock);
 578	nfsd_drc_mem_used -= slotsize * num;
 579	spin_unlock(&nfsd_drc_lock);
 580}
 581
 582static struct nfsd4_session *alloc_session(int slotsize, int numslots)
 583{
 584	struct nfsd4_session *new;
 585	int mem, i;
 586
 587	BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
 588			+ sizeof(struct nfsd4_session) > PAGE_SIZE);
 589	mem = numslots * sizeof(struct nfsd4_slot *);
 590
 591	new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
 592	if (!new)
 593		return NULL;
 594	/* allocate each struct nfsd4_slot and data cache in one piece */
 595	for (i = 0; i < numslots; i++) {
 596		mem = sizeof(struct nfsd4_slot) + slotsize;
 597		new->se_slots[i] = kzalloc(mem, GFP_KERNEL);
 598		if (!new->se_slots[i])
 599			goto out_free;
 600	}
 601	return new;
 602out_free:
 603	while (i--)
 604		kfree(new->se_slots[i]);
 605	kfree(new);
 606	return NULL;
 607}
 608
 609static void init_forechannel_attrs(struct nfsd4_channel_attrs *new, struct nfsd4_channel_attrs *req, int numslots, int slotsize)
 610{
 611	u32 maxrpc = nfsd_serv->sv_max_mesg;
 612
 613	new->maxreqs = numslots;
 614	new->maxresp_cached = min_t(u32, req->maxresp_cached,
 615					slotsize + NFSD_MIN_HDR_SEQ_SZ);
 616	new->maxreq_sz = min_t(u32, req->maxreq_sz, maxrpc);
 617	new->maxresp_sz = min_t(u32, req->maxresp_sz, maxrpc);
 618	new->maxops = min_t(u32, req->maxops, NFSD_MAX_OPS_PER_COMPOUND);
 619}
 620
 621static void free_conn(struct nfsd4_conn *c)
 622{
 623	svc_xprt_put(c->cn_xprt);
 624	kfree(c);
 625}
 626
 627static void nfsd4_conn_lost(struct svc_xpt_user *u)
 628{
 629	struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
 630	struct nfs4_client *clp = c->cn_session->se_client;
 631
 632	spin_lock(&clp->cl_lock);
 633	if (!list_empty(&c->cn_persession)) {
 634		list_del(&c->cn_persession);
 635		free_conn(c);
 636	}
 637	spin_unlock(&clp->cl_lock);
 638	nfsd4_probe_callback(clp);
 639}
 640
 641static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
 642{
 643	struct nfsd4_conn *conn;
 644
 645	conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
 646	if (!conn)
 647		return NULL;
 648	svc_xprt_get(rqstp->rq_xprt);
 649	conn->cn_xprt = rqstp->rq_xprt;
 650	conn->cn_flags = flags;
 651	INIT_LIST_HEAD(&conn->cn_xpt_user.list);
 652	return conn;
 653}
 654
 655static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
 656{
 657	conn->cn_session = ses;
 658	list_add(&conn->cn_persession, &ses->se_conns);
 659}
 660
 661static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
 662{
 663	struct nfs4_client *clp = ses->se_client;
 664
 665	spin_lock(&clp->cl_lock);
 666	__nfsd4_hash_conn(conn, ses);
 667	spin_unlock(&clp->cl_lock);
 668}
 669
 670static int nfsd4_register_conn(struct nfsd4_conn *conn)
 671{
 672	conn->cn_xpt_user.callback = nfsd4_conn_lost;
 673	return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
 674}
 675
 676static __be32 nfsd4_new_conn(struct svc_rqst *rqstp, struct nfsd4_session *ses, u32 dir)
 677{
 678	struct nfsd4_conn *conn;
 679	int ret;
 680
 681	conn = alloc_conn(rqstp, dir);
 682	if (!conn)
 683		return nfserr_jukebox;
 684	nfsd4_hash_conn(conn, ses);
 685	ret = nfsd4_register_conn(conn);
 686	if (ret)
 687		/* oops; xprt is already down: */
 688		nfsd4_conn_lost(&conn->cn_xpt_user);
 689	return nfs_ok;
 690}
 691
 692static __be32 nfsd4_new_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_session *ses)
 693{
 694	u32 dir = NFS4_CDFC4_FORE;
 695
 696	if (ses->se_flags & SESSION4_BACK_CHAN)
 697		dir |= NFS4_CDFC4_BACK;
 698
 699	return nfsd4_new_conn(rqstp, ses, dir);
 700}
 701
 702/* must be called under client_lock */
 703static void nfsd4_del_conns(struct nfsd4_session *s)
 704{
 705	struct nfs4_client *clp = s->se_client;
 706	struct nfsd4_conn *c;
 707
 708	spin_lock(&clp->cl_lock);
 709	while (!list_empty(&s->se_conns)) {
 710		c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
 711		list_del_init(&c->cn_persession);
 712		spin_unlock(&clp->cl_lock);
 713
 714		unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
 715		free_conn(c);
 716
 717		spin_lock(&clp->cl_lock);
 718	}
 719	spin_unlock(&clp->cl_lock);
 720}
 721
 722void free_session(struct kref *kref)
 723{
 724	struct nfsd4_session *ses;
 725	int mem;
 726
 
 727	ses = container_of(kref, struct nfsd4_session, se_ref);
 728	nfsd4_del_conns(ses);
 729	spin_lock(&nfsd_drc_lock);
 730	mem = ses->se_fchannel.maxreqs * slot_bytes(&ses->se_fchannel);
 731	nfsd_drc_mem_used -= mem;
 732	spin_unlock(&nfsd_drc_lock);
 733	free_session_slots(ses);
 734	kfree(ses);
 735}
 736
 
 
 
 
 
 
 
 737static struct nfsd4_session *alloc_init_session(struct svc_rqst *rqstp, struct nfs4_client *clp, struct nfsd4_create_session *cses)
 738{
 739	struct nfsd4_session *new;
 740	struct nfsd4_channel_attrs *fchan = &cses->fore_channel;
 741	int numslots, slotsize;
 742	int status;
 743	int idx;
 744
 745	/*
 746	 * Note decreasing slot size below client's request may
 747	 * make it difficult for client to function correctly, whereas
 748	 * decreasing the number of slots will (just?) affect
 749	 * performance.  When short on memory we therefore prefer to
 750	 * decrease number of slots instead of their size.
 751	 */
 752	slotsize = nfsd4_sanitize_slot_size(fchan->maxresp_cached);
 753	numslots = nfsd4_get_drc_mem(slotsize, fchan->maxreqs);
 754	if (numslots < 1)
 755		return NULL;
 756
 757	new = alloc_session(slotsize, numslots);
 758	if (!new) {
 759		nfsd4_put_drc_mem(slotsize, fchan->maxreqs);
 760		return NULL;
 761	}
 762	init_forechannel_attrs(&new->se_fchannel, fchan, numslots, slotsize);
 763
 764	new->se_client = clp;
 765	gen_sessionid(new);
 766
 767	INIT_LIST_HEAD(&new->se_conns);
 768
 769	new->se_cb_seq_nr = 1;
 770	new->se_flags = cses->flags;
 771	new->se_cb_prog = cses->callback_prog;
 772	kref_init(&new->se_ref);
 773	idx = hash_sessionid(&new->se_sessionid);
 774	spin_lock(&client_lock);
 775	list_add(&new->se_hash, &sessionid_hashtbl[idx]);
 776	spin_lock(&clp->cl_lock);
 777	list_add(&new->se_perclnt, &clp->cl_sessions);
 778	spin_unlock(&clp->cl_lock);
 779	spin_unlock(&client_lock);
 780
 781	status = nfsd4_new_conn_from_crses(rqstp, new);
 782	/* whoops: benny points out, status is ignored! (err, or bogus) */
 783	if (status) {
 
 784		free_session(&new->se_ref);
 
 785		return NULL;
 786	}
 787	if (cses->flags & SESSION4_BACK_CHAN) {
 788		struct sockaddr *sa = svc_addr(rqstp);
 789		/*
 790		 * This is a little silly; with sessions there's no real
 791		 * use for the callback address.  Use the peer address
 792		 * as a reasonable default for now, but consider fixing
 793		 * the rpc client not to require an address in the
 794		 * future:
 795		 */
 796		rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
 797		clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
 798	}
 799	nfsd4_probe_callback(clp);
 800	return new;
 801}
 802
 803/* caller must hold client_lock */
 804static struct nfsd4_session *
 805find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
 806{
 807	struct nfsd4_session *elem;
 808	int idx;
 809
 810	dump_sessionid(__func__, sessionid);
 811	idx = hash_sessionid(sessionid);
 812	/* Search in the appropriate list */
 813	list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
 814		if (!memcmp(elem->se_sessionid.data, sessionid->data,
 815			    NFS4_MAX_SESSIONID_LEN)) {
 816			return elem;
 817		}
 818	}
 819
 820	dprintk("%s: session not found\n", __func__);
 821	return NULL;
 822}
 823
 824/* caller must hold client_lock */
 825static void
 826unhash_session(struct nfsd4_session *ses)
 827{
 828	list_del(&ses->se_hash);
 829	spin_lock(&ses->se_client->cl_lock);
 830	list_del(&ses->se_perclnt);
 831	spin_unlock(&ses->se_client->cl_lock);
 832}
 833
 834/* must be called under the client_lock */
 835static inline void
 836renew_client_locked(struct nfs4_client *clp)
 837{
 838	if (is_client_expired(clp)) {
 839		dprintk("%s: client (clientid %08x/%08x) already expired\n",
 
 840			__func__,
 841			clp->cl_clientid.cl_boot,
 842			clp->cl_clientid.cl_id);
 843		return;
 844	}
 845
 846	/*
 847	* Move client to the end to the LRU list.
 848	*/
 849	dprintk("renewing client (clientid %08x/%08x)\n", 
 850			clp->cl_clientid.cl_boot, 
 851			clp->cl_clientid.cl_id);
 852	list_move_tail(&clp->cl_lru, &client_lru);
 853	clp->cl_time = get_seconds();
 854}
 855
 856static inline void
 857renew_client(struct nfs4_client *clp)
 858{
 859	spin_lock(&client_lock);
 860	renew_client_locked(clp);
 861	spin_unlock(&client_lock);
 862}
 863
 864/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
 865static int
 866STALE_CLIENTID(clientid_t *clid)
 867{
 868	if (clid->cl_boot == boot_time)
 869		return 0;
 870	dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
 871		clid->cl_boot, clid->cl_id, boot_time);
 872	return 1;
 873}
 874
 875/* 
 876 * XXX Should we use a slab cache ?
 877 * This type of memory management is somewhat inefficient, but we use it
 878 * anyway since SETCLIENTID is not a common operation.
 879 */
 880static struct nfs4_client *alloc_client(struct xdr_netobj name)
 881{
 882	struct nfs4_client *clp;
 883
 884	clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
 885	if (clp == NULL)
 886		return NULL;
 887	clp->cl_name.data = kmalloc(name.len, GFP_KERNEL);
 888	if (clp->cl_name.data == NULL) {
 889		kfree(clp);
 890		return NULL;
 891	}
 892	memcpy(clp->cl_name.data, name.data, name.len);
 893	clp->cl_name.len = name.len;
 894	return clp;
 895}
 896
 897static inline void
 898free_client(struct nfs4_client *clp)
 899{
 
 900	while (!list_empty(&clp->cl_sessions)) {
 901		struct nfsd4_session *ses;
 902		ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
 903				se_perclnt);
 904		list_del(&ses->se_perclnt);
 905		nfsd4_put_session(ses);
 906	}
 907	if (clp->cl_cred.cr_group_info)
 908		put_group_info(clp->cl_cred.cr_group_info);
 909	kfree(clp->cl_principal);
 910	kfree(clp->cl_name.data);
 911	kfree(clp);
 912}
 913
 914void
 915release_session_client(struct nfsd4_session *session)
 916{
 917	struct nfs4_client *clp = session->se_client;
 918
 919	if (!atomic_dec_and_lock(&clp->cl_refcount, &client_lock))
 920		return;
 921	if (is_client_expired(clp)) {
 922		free_client(clp);
 923		session->se_client = NULL;
 924	} else
 925		renew_client_locked(clp);
 926	spin_unlock(&client_lock);
 927}
 928
 929/* must be called under the client_lock */
 930static inline void
 931unhash_client_locked(struct nfs4_client *clp)
 932{
 933	struct nfsd4_session *ses;
 934
 935	mark_client_expired(clp);
 936	list_del(&clp->cl_lru);
 937	spin_lock(&clp->cl_lock);
 938	list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
 939		list_del_init(&ses->se_hash);
 940	spin_unlock(&clp->cl_lock);
 941}
 942
 943static void
 944expire_client(struct nfs4_client *clp)
 945{
 946	struct nfs4_stateowner *sop;
 947	struct nfs4_delegation *dp;
 948	struct list_head reaplist;
 949
 950	INIT_LIST_HEAD(&reaplist);
 951	spin_lock(&recall_lock);
 952	while (!list_empty(&clp->cl_delegations)) {
 953		dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
 954		list_del_init(&dp->dl_perclnt);
 955		list_move(&dp->dl_recall_lru, &reaplist);
 956	}
 957	spin_unlock(&recall_lock);
 958	while (!list_empty(&reaplist)) {
 959		dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
 960		list_del_init(&dp->dl_recall_lru);
 961		unhash_delegation(dp);
 962	}
 963	while (!list_empty(&clp->cl_openowners)) {
 964		sop = list_entry(clp->cl_openowners.next, struct nfs4_stateowner, so_perclient);
 965		release_openowner(sop);
 966	}
 967	nfsd4_shutdown_callback(clp);
 968	if (clp->cl_cb_conn.cb_xprt)
 969		svc_xprt_put(clp->cl_cb_conn.cb_xprt);
 970	list_del(&clp->cl_idhash);
 971	list_del(&clp->cl_strhash);
 972	spin_lock(&client_lock);
 973	unhash_client_locked(clp);
 974	if (atomic_read(&clp->cl_refcount) == 0)
 975		free_client(clp);
 976	spin_unlock(&client_lock);
 977}
 978
 979static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
 980{
 981	memcpy(target->cl_verifier.data, source->data,
 982			sizeof(target->cl_verifier.data));
 983}
 984
 985static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
 986{
 987	target->cl_clientid.cl_boot = source->cl_clientid.cl_boot; 
 988	target->cl_clientid.cl_id = source->cl_clientid.cl_id; 
 989}
 990
 991static void copy_cred(struct svc_cred *target, struct svc_cred *source)
 992{
 
 
 
 
 
 
 
 
 993	target->cr_uid = source->cr_uid;
 994	target->cr_gid = source->cr_gid;
 995	target->cr_group_info = source->cr_group_info;
 996	get_group_info(target->cr_group_info);
 
 997}
 998
 999static int same_name(const char *n1, const char *n2)
1000{
1001	return 0 == memcmp(n1, n2, HEXDIR_LEN);
1002}
1003
1004static int
1005same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1006{
1007	return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
1008}
1009
1010static int
1011same_clid(clientid_t *cl1, clientid_t *cl2)
1012{
1013	return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
1014}
1015
1016/* XXX what about NGROUP */
1017static int
 
 
 
 
 
 
 
 
 
 
 
1018same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1019{
1020	return cr1->cr_uid == cr2->cr_uid;
 
 
 
 
 
 
 
 
 
1021}
1022
1023static void gen_clid(struct nfs4_client *clp)
1024{
1025	static u32 current_clientid = 1;
1026
1027	clp->cl_clientid.cl_boot = boot_time;
1028	clp->cl_clientid.cl_id = current_clientid++; 
1029}
1030
1031static void gen_confirm(struct nfs4_client *clp)
1032{
 
1033	static u32 i;
1034	u32 *p;
1035
1036	p = (u32 *)clp->cl_confirm.data;
1037	*p++ = get_seconds();
1038	*p++ = i++;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1039}
1040
1041static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
1042		struct svc_rqst *rqstp, nfs4_verifier *verf)
1043{
1044	struct nfs4_client *clp;
1045	struct sockaddr *sa = svc_addr(rqstp);
1046	char *princ;
1047
1048	clp = alloc_client(name);
1049	if (clp == NULL)
1050		return NULL;
1051
1052	INIT_LIST_HEAD(&clp->cl_sessions);
1053
1054	princ = svc_gss_principal(rqstp);
1055	if (princ) {
1056		clp->cl_principal = kstrdup(princ, GFP_KERNEL);
1057		if (clp->cl_principal == NULL) {
1058			free_client(clp);
1059			return NULL;
1060		}
1061	}
1062
1063	memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
1064	atomic_set(&clp->cl_refcount, 0);
1065	clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1066	INIT_LIST_HEAD(&clp->cl_idhash);
1067	INIT_LIST_HEAD(&clp->cl_strhash);
1068	INIT_LIST_HEAD(&clp->cl_openowners);
1069	INIT_LIST_HEAD(&clp->cl_delegations);
1070	INIT_LIST_HEAD(&clp->cl_lru);
1071	INIT_LIST_HEAD(&clp->cl_callbacks);
1072	spin_lock_init(&clp->cl_lock);
1073	INIT_WORK(&clp->cl_cb_null.cb_work, nfsd4_do_callback_rpc);
1074	clp->cl_time = get_seconds();
1075	clear_bit(0, &clp->cl_cb_slot_busy);
1076	rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1077	copy_verf(clp, verf);
1078	rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
1079	clp->cl_flavor = rqstp->rq_flavor;
1080	copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1081	gen_confirm(clp);
1082	clp->cl_cb_session = NULL;
1083	return clp;
1084}
1085
1086static int check_name(struct xdr_netobj name)
1087{
1088	if (name.len == 0) 
1089		return 0;
1090	if (name.len > NFS4_OPAQUE_LIMIT) {
1091		dprintk("NFSD: check_name: name too long(%d)!\n", name.len);
1092		return 0;
1093	}
1094	return 1;
1095}
1096
1097static void
1098add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
1099{
1100	unsigned int idhashval;
1101
1102	list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
1103	idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1104	list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
1105	renew_client(clp);
1106}
1107
1108static void
1109move_to_confirmed(struct nfs4_client *clp)
1110{
1111	unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1112	unsigned int strhashval;
1113
1114	dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
1115	list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
1116	strhashval = clientstr_hashval(clp->cl_recdir);
1117	list_move(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
1118	renew_client(clp);
1119}
1120
1121static struct nfs4_client *
1122find_confirmed_client(clientid_t *clid)
1123{
1124	struct nfs4_client *clp;
1125	unsigned int idhashval = clientid_hashval(clid->cl_id);
1126
1127	list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
1128		if (same_clid(&clp->cl_clientid, clid))
 
1129			return clp;
 
1130	}
1131	return NULL;
1132}
1133
1134static struct nfs4_client *
1135find_unconfirmed_client(clientid_t *clid)
1136{
1137	struct nfs4_client *clp;
1138	unsigned int idhashval = clientid_hashval(clid->cl_id);
1139
1140	list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
1141		if (same_clid(&clp->cl_clientid, clid))
1142			return clp;
1143	}
1144	return NULL;
1145}
1146
1147static bool clp_used_exchangeid(struct nfs4_client *clp)
1148{
1149	return clp->cl_exchange_flags != 0;
1150} 
1151
1152static struct nfs4_client *
1153find_confirmed_client_by_str(const char *dname, unsigned int hashval)
1154{
1155	struct nfs4_client *clp;
1156
1157	list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
1158		if (same_name(clp->cl_recdir, dname))
1159			return clp;
1160	}
1161	return NULL;
1162}
1163
1164static struct nfs4_client *
1165find_unconfirmed_client_by_str(const char *dname, unsigned int hashval)
1166{
1167	struct nfs4_client *clp;
1168
1169	list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
1170		if (same_name(clp->cl_recdir, dname))
1171			return clp;
1172	}
1173	return NULL;
1174}
1175
1176static void rpc_svcaddr2sockaddr(struct sockaddr *sa, unsigned short family, union svc_addr_u *svcaddr)
1177{
1178	switch (family) {
1179	case AF_INET:
1180		((struct sockaddr_in *)sa)->sin_family = AF_INET;
1181		((struct sockaddr_in *)sa)->sin_addr = svcaddr->addr;
1182		return;
1183	case AF_INET6:
1184		((struct sockaddr_in6 *)sa)->sin6_family = AF_INET6;
1185		((struct sockaddr_in6 *)sa)->sin6_addr = svcaddr->addr6;
1186		return;
1187	}
1188}
1189
1190static void
1191gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
1192{
1193	struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
1194	struct sockaddr	*sa = svc_addr(rqstp);
1195	u32 scopeid = rpc_get_scope_id(sa);
1196	unsigned short expected_family;
1197
1198	/* Currently, we only support tcp and tcp6 for the callback channel */
1199	if (se->se_callback_netid_len == 3 &&
1200	    !memcmp(se->se_callback_netid_val, "tcp", 3))
1201		expected_family = AF_INET;
1202	else if (se->se_callback_netid_len == 4 &&
1203		 !memcmp(se->se_callback_netid_val, "tcp6", 4))
1204		expected_family = AF_INET6;
1205	else
1206		goto out_err;
1207
1208	conn->cb_addrlen = rpc_uaddr2sockaddr(se->se_callback_addr_val,
1209					    se->se_callback_addr_len,
1210					    (struct sockaddr *)&conn->cb_addr,
1211					    sizeof(conn->cb_addr));
1212
1213	if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
1214		goto out_err;
1215
1216	if (conn->cb_addr.ss_family == AF_INET6)
1217		((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
1218
1219	conn->cb_prog = se->se_callback_prog;
1220	conn->cb_ident = se->se_callback_ident;
1221	rpc_svcaddr2sockaddr((struct sockaddr *)&conn->cb_saddr, expected_family, &rqstp->rq_daddr);
1222	return;
1223out_err:
1224	conn->cb_addr.ss_family = AF_UNSPEC;
1225	conn->cb_addrlen = 0;
1226	dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
1227		"will not receive delegations\n",
1228		clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1229
1230	return;
1231}
1232
1233/*
1234 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
1235 */
1236void
1237nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1238{
1239	struct nfsd4_slot *slot = resp->cstate.slot;
1240	unsigned int base;
1241
1242	dprintk("--> %s slot %p\n", __func__, slot);
1243
1244	slot->sl_opcnt = resp->opcnt;
1245	slot->sl_status = resp->cstate.status;
1246
 
1247	if (nfsd4_not_cached(resp)) {
1248		slot->sl_datalen = 0;
1249		return;
1250	}
1251	slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1252	base = (char *)resp->cstate.datap -
1253					(char *)resp->xbuf->head[0].iov_base;
1254	if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1255				    slot->sl_datalen))
1256		WARN("%s: sessions DRC could not cache compound\n", __func__);
1257	return;
1258}
1259
1260/*
1261 * Encode the replay sequence operation from the slot values.
1262 * If cachethis is FALSE encode the uncached rep error on the next
1263 * operation which sets resp->p and increments resp->opcnt for
1264 * nfs4svc_encode_compoundres.
1265 *
1266 */
1267static __be32
1268nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1269			  struct nfsd4_compoundres *resp)
1270{
1271	struct nfsd4_op *op;
1272	struct nfsd4_slot *slot = resp->cstate.slot;
1273
1274	dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__,
1275		resp->opcnt, resp->cstate.slot->sl_cachethis);
1276
1277	/* Encode the replayed sequence operation */
1278	op = &args->ops[resp->opcnt - 1];
1279	nfsd4_encode_operation(resp, op);
1280
1281	/* Return nfserr_retry_uncached_rep in next operation. */
1282	if (args->opcnt > 1 && slot->sl_cachethis == 0) {
1283		op = &args->ops[resp->opcnt++];
1284		op->status = nfserr_retry_uncached_rep;
1285		nfsd4_encode_operation(resp, op);
1286	}
1287	return op->status;
1288}
1289
1290/*
1291 * The sequence operation is not cached because we can use the slot and
1292 * session values.
1293 */
1294__be32
1295nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1296			 struct nfsd4_sequence *seq)
1297{
1298	struct nfsd4_slot *slot = resp->cstate.slot;
1299	__be32 status;
1300
1301	dprintk("--> %s slot %p\n", __func__, slot);
1302
1303	/* Either returns 0 or nfserr_retry_uncached */
1304	status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1305	if (status == nfserr_retry_uncached_rep)
1306		return status;
1307
1308	/* The sequence operation has been encoded, cstate->datap set. */
1309	memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
1310
1311	resp->opcnt = slot->sl_opcnt;
1312	resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1313	status = slot->sl_status;
1314
1315	return status;
1316}
1317
1318/*
1319 * Set the exchange_id flags returned by the server.
1320 */
1321static void
1322nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1323{
1324	/* pNFS is not supported */
1325	new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1326
1327	/* Referrals are supported, Migration is not. */
1328	new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1329
1330	/* set the wire flags to return to client. */
1331	clid->flags = new->cl_exchange_flags;
1332}
1333
 
 
 
 
 
 
 
 
 
 
 
 
 
1334__be32
1335nfsd4_exchange_id(struct svc_rqst *rqstp,
1336		  struct nfsd4_compound_state *cstate,
1337		  struct nfsd4_exchange_id *exid)
1338{
1339	struct nfs4_client *unconf, *conf, *new;
1340	int status;
1341	unsigned int		strhashval;
1342	char			dname[HEXDIR_LEN];
1343	char			addr_str[INET6_ADDRSTRLEN];
1344	nfs4_verifier		verf = exid->verifier;
1345	struct sockaddr		*sa = svc_addr(rqstp);
 
1346
1347	rpc_ntop(sa, addr_str, sizeof(addr_str));
1348	dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
1349		"ip_addr=%s flags %x, spa_how %d\n",
1350		__func__, rqstp, exid, exid->clname.len, exid->clname.data,
1351		addr_str, exid->flags, exid->spa_how);
1352
1353	if (!check_name(exid->clname) || (exid->flags & ~EXCHGID4_FLAG_MASK_A))
1354		return nfserr_inval;
1355
1356	/* Currently only support SP4_NONE */
1357	switch (exid->spa_how) {
1358	case SP4_NONE:
1359		break;
1360	case SP4_SSV:
1361		return nfserr_serverfault;
1362	default:
1363		BUG();				/* checked by xdr code */
1364	case SP4_MACH_CRED:
1365		return nfserr_serverfault;	/* no excuse :-/ */
1366	}
1367
1368	status = nfs4_make_rec_clidname(dname, &exid->clname);
1369
1370	if (status)
1371		goto error;
1372
1373	strhashval = clientstr_hashval(dname);
1374
 
1375	nfs4_lock_state();
1376	status = nfs_ok;
1377
1378	conf = find_confirmed_client_by_str(dname, strhashval);
1379	if (conf) {
1380		if (!clp_used_exchangeid(conf)) {
1381			status = nfserr_clid_inuse; /* XXX: ? */
1382			goto out;
1383		}
1384		if (!same_verf(&verf, &conf->cl_verifier)) {
1385			/* 18.35.4 case 8 */
1386			if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
 
 
 
 
 
 
1387				status = nfserr_not_same;
1388				goto out;
1389			}
1390			/* Client reboot: destroy old state */
1391			expire_client(conf);
1392			goto out_new;
 
1393		}
1394		if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
1395			/* 18.35.4 case 9 */
1396			if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1397				status = nfserr_perm;
1398				goto out;
1399			}
1400			expire_client(conf);
1401			goto out_new;
1402		}
1403		/*
1404		 * Set bit when the owner id and verifier map to an already
1405		 * confirmed client id (18.35.3).
1406		 */
1407		exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1408
1409		/*
1410		 * Falling into 18.35.4 case 2, possible router replay.
1411		 * Leave confirmed record intact and return same result.
1412		 */
1413		copy_verf(conf, &verf);
1414		new = conf;
1415		goto out_copy;
1416	}
1417
1418	/* 18.35.4 case 7 */
1419	if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1420		status = nfserr_noent;
1421		goto out;
1422	}
1423
1424	unconf  = find_unconfirmed_client_by_str(dname, strhashval);
1425	if (unconf) {
1426		/*
1427		 * Possible retry or client restart.  Per 18.35.4 case 4,
1428		 * a new unconfirmed record should be generated regardless
1429		 * of whether any properties have changed.
1430		 */
1431		expire_client(unconf);
1432	}
1433
 
1434out_new:
1435	/* Normal case */
1436	new = create_client(exid->clname, dname, rqstp, &verf);
1437	if (new == NULL) {
1438		status = nfserr_jukebox;
1439		goto out;
1440	}
1441
1442	gen_clid(new);
1443	add_to_unconfirmed(new, strhashval);
1444out_copy:
1445	exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1446	exid->clientid.cl_id = new->cl_clientid.cl_id;
1447
1448	exid->seqid = 1;
1449	nfsd4_set_ex_flags(new, exid);
1450
1451	dprintk("nfsd4_exchange_id seqid %d flags %x\n",
1452		new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
1453	status = nfs_ok;
1454
1455out:
1456	nfs4_unlock_state();
1457error:
1458	dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
1459	return status;
1460}
1461
1462static int
1463check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
1464{
1465	dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1466		slot_seqid);
1467
1468	/* The slot is in use, and no response has been sent. */
1469	if (slot_inuse) {
1470		if (seqid == slot_seqid)
1471			return nfserr_jukebox;
1472		else
1473			return nfserr_seq_misordered;
1474	}
1475	/* Normal */
1476	if (likely(seqid == slot_seqid + 1))
1477		return nfs_ok;
1478	/* Replay */
1479	if (seqid == slot_seqid)
1480		return nfserr_replay_cache;
1481	/* Wraparound */
1482	if (seqid == 1 && (slot_seqid + 1) == 0)
1483		return nfs_ok;
1484	/* Misordered replay or misordered new request */
1485	return nfserr_seq_misordered;
1486}
1487
1488/*
1489 * Cache the create session result into the create session single DRC
1490 * slot cache by saving the xdr structure. sl_seqid has been set.
1491 * Do this for solo or embedded create session operations.
1492 */
1493static void
1494nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
1495			   struct nfsd4_clid_slot *slot, int nfserr)
1496{
1497	slot->sl_status = nfserr;
1498	memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1499}
1500
1501static __be32
1502nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1503			    struct nfsd4_clid_slot *slot)
1504{
1505	memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1506	return slot->sl_status;
1507}
1508
1509#define NFSD_MIN_REQ_HDR_SEQ_SZ	((\
1510			2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
1511			1 +	/* MIN tag is length with zero, only length */ \
1512			3 +	/* version, opcount, opcode */ \
1513			XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1514				/* seqid, slotID, slotID, cache */ \
1515			4 ) * sizeof(__be32))
1516
1517#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
1518			2 +	/* verifier: AUTH_NULL, length 0 */\
1519			1 +	/* status */ \
1520			1 +	/* MIN tag is length with zero, only length */ \
1521			3 +	/* opcount, opcode, opstatus*/ \
1522			XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1523				/* seqid, slotID, slotID, slotID, status */ \
1524			5 ) * sizeof(__be32))
1525
1526static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs fchannel)
1527{
1528	return fchannel.maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ
1529		|| fchannel.maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ;
1530}
1531
1532__be32
1533nfsd4_create_session(struct svc_rqst *rqstp,
1534		     struct nfsd4_compound_state *cstate,
1535		     struct nfsd4_create_session *cr_ses)
1536{
1537	struct sockaddr *sa = svc_addr(rqstp);
1538	struct nfs4_client *conf, *unconf;
1539	struct nfsd4_session *new;
1540	struct nfsd4_clid_slot *cs_slot = NULL;
1541	bool confirm_me = false;
1542	int status = 0;
1543
1544	if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
1545		return nfserr_inval;
1546
1547	nfs4_lock_state();
1548	unconf = find_unconfirmed_client(&cr_ses->clientid);
1549	conf = find_confirmed_client(&cr_ses->clientid);
1550
1551	if (conf) {
1552		cs_slot = &conf->cl_cs_slot;
1553		status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
1554		if (status == nfserr_replay_cache) {
1555			dprintk("Got a create_session replay! seqid= %d\n",
1556				cs_slot->sl_seqid);
1557			/* Return the cached reply status */
1558			status = nfsd4_replay_create_session(cr_ses, cs_slot);
1559			goto out;
1560		} else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
1561			status = nfserr_seq_misordered;
1562			dprintk("Sequence misordered!\n");
1563			dprintk("Expected seqid= %d but got seqid= %d\n",
1564				cs_slot->sl_seqid, cr_ses->seqid);
1565			goto out;
1566		}
1567	} else if (unconf) {
1568		if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
1569		    !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
1570			status = nfserr_clid_inuse;
1571			goto out;
1572		}
1573
1574		cs_slot = &unconf->cl_cs_slot;
1575		status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
1576		if (status) {
1577			/* an unconfirmed replay returns misordered */
1578			status = nfserr_seq_misordered;
1579			goto out;
1580		}
1581
1582		confirm_me = true;
1583		conf = unconf;
1584	} else {
1585		status = nfserr_stale_clientid;
1586		goto out;
1587	}
1588
1589	/*
1590	 * XXX: we should probably set this at creation time, and check
1591	 * for consistent minorversion use throughout:
1592	 */
1593	conf->cl_minorversion = 1;
1594	/*
1595	 * We do not support RDMA or persistent sessions
1596	 */
1597	cr_ses->flags &= ~SESSION4_PERSIST;
1598	cr_ses->flags &= ~SESSION4_RDMA;
1599
1600	status = nfserr_toosmall;
1601	if (check_forechannel_attrs(cr_ses->fore_channel))
1602		goto out;
1603
1604	status = nfserr_jukebox;
1605	new = alloc_init_session(rqstp, conf, cr_ses);
1606	if (!new)
1607		goto out;
1608	status = nfs_ok;
1609	memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
1610	       NFS4_MAX_SESSIONID_LEN);
1611	memcpy(&cr_ses->fore_channel, &new->se_fchannel,
1612		sizeof(struct nfsd4_channel_attrs));
1613	cs_slot->sl_seqid++;
1614	cr_ses->seqid = cs_slot->sl_seqid;
1615
1616	/* cache solo and embedded create sessions under the state lock */
1617	nfsd4_cache_create_session(cr_ses, cs_slot, status);
1618	if (confirm_me)
 
 
 
 
 
1619		move_to_confirmed(conf);
 
1620out:
1621	nfs4_unlock_state();
1622	dprintk("%s returns %d\n", __func__, ntohl(status));
1623	return status;
1624}
1625
1626static bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
1627{
1628	struct nfsd4_compoundres *resp = rqstp->rq_resp;
1629	struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1630
1631	return argp->opcnt == resp->opcnt;
1632}
1633
1634static __be32 nfsd4_map_bcts_dir(u32 *dir)
1635{
1636	switch (*dir) {
1637	case NFS4_CDFC4_FORE:
1638	case NFS4_CDFC4_BACK:
1639		return nfs_ok;
1640	case NFS4_CDFC4_FORE_OR_BOTH:
1641	case NFS4_CDFC4_BACK_OR_BOTH:
1642		*dir = NFS4_CDFC4_BOTH;
1643		return nfs_ok;
1644	};
1645	return nfserr_inval;
1646}
1647
1648__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
1649		     struct nfsd4_compound_state *cstate,
1650		     struct nfsd4_bind_conn_to_session *bcts)
1651{
1652	__be32 status;
1653
1654	if (!nfsd4_last_compound_op(rqstp))
1655		return nfserr_not_only_op;
1656	spin_lock(&client_lock);
1657	cstate->session = find_in_sessionid_hashtbl(&bcts->sessionid);
1658	/* Sorta weird: we only need the refcnt'ing because new_conn acquires
1659	 * client_lock iself: */
1660	if (cstate->session) {
1661		nfsd4_get_session(cstate->session);
1662		atomic_inc(&cstate->session->se_client->cl_refcount);
1663	}
1664	spin_unlock(&client_lock);
1665	if (!cstate->session)
1666		return nfserr_badsession;
1667
1668	status = nfsd4_map_bcts_dir(&bcts->dir);
1669	if (!status)
1670		nfsd4_new_conn(rqstp, cstate->session, bcts->dir);
1671	return status;
1672}
1673
1674static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
1675{
1676	if (!session)
1677		return 0;
1678	return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
1679}
1680
1681__be32
1682nfsd4_destroy_session(struct svc_rqst *r,
1683		      struct nfsd4_compound_state *cstate,
1684		      struct nfsd4_destroy_session *sessionid)
1685{
1686	struct nfsd4_session *ses;
1687	u32 status = nfserr_badsession;
1688
1689	/* Notes:
1690	 * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
1691	 * - Should we return nfserr_back_chan_busy if waiting for
1692	 *   callbacks on to-be-destroyed session?
1693	 * - Do we need to clear any callback info from previous session?
1694	 */
1695
1696	if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
1697		if (!nfsd4_last_compound_op(r))
1698			return nfserr_not_only_op;
1699	}
1700	dump_sessionid(__func__, &sessionid->sessionid);
1701	spin_lock(&client_lock);
1702	ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
1703	if (!ses) {
1704		spin_unlock(&client_lock);
1705		goto out;
1706	}
1707
1708	unhash_session(ses);
1709	spin_unlock(&client_lock);
1710
1711	nfs4_lock_state();
1712	nfsd4_probe_callback_sync(ses->se_client);
1713	nfs4_unlock_state();
1714
 
1715	nfsd4_del_conns(ses);
1716
1717	nfsd4_put_session(ses);
1718	status = nfs_ok;
1719out:
1720	dprintk("%s returns %d\n", __func__, ntohl(status));
1721	return status;
1722}
1723
1724static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
1725{
1726	struct nfsd4_conn *c;
1727
1728	list_for_each_entry(c, &s->se_conns, cn_persession) {
1729		if (c->cn_xprt == xpt) {
1730			return c;
1731		}
1732	}
1733	return NULL;
1734}
1735
1736static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
1737{
1738	struct nfs4_client *clp = ses->se_client;
1739	struct nfsd4_conn *c;
1740	int ret;
1741
1742	spin_lock(&clp->cl_lock);
1743	c = __nfsd4_find_conn(new->cn_xprt, ses);
1744	if (c) {
1745		spin_unlock(&clp->cl_lock);
1746		free_conn(new);
1747		return;
1748	}
1749	__nfsd4_hash_conn(new, ses);
1750	spin_unlock(&clp->cl_lock);
1751	ret = nfsd4_register_conn(new);
1752	if (ret)
1753		/* oops; xprt is already down: */
1754		nfsd4_conn_lost(&new->cn_xpt_user);
1755	return;
1756}
1757
1758static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
1759{
1760	struct nfsd4_compoundargs *args = rqstp->rq_argp;
1761
1762	return args->opcnt > session->se_fchannel.maxops;
1763}
1764
1765static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
1766				  struct nfsd4_session *session)
1767{
1768	struct xdr_buf *xb = &rqstp->rq_arg;
1769
1770	return xb->len > session->se_fchannel.maxreq_sz;
1771}
1772
1773__be32
1774nfsd4_sequence(struct svc_rqst *rqstp,
1775	       struct nfsd4_compound_state *cstate,
1776	       struct nfsd4_sequence *seq)
1777{
1778	struct nfsd4_compoundres *resp = rqstp->rq_resp;
1779	struct nfsd4_session *session;
1780	struct nfsd4_slot *slot;
1781	struct nfsd4_conn *conn;
1782	int status;
1783
1784	if (resp->opcnt != 1)
1785		return nfserr_sequence_pos;
1786
1787	/*
1788	 * Will be either used or freed by nfsd4_sequence_check_conn
1789	 * below.
1790	 */
1791	conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
1792	if (!conn)
1793		return nfserr_jukebox;
1794
1795	spin_lock(&client_lock);
1796	status = nfserr_badsession;
1797	session = find_in_sessionid_hashtbl(&seq->sessionid);
1798	if (!session)
1799		goto out;
1800
1801	status = nfserr_too_many_ops;
1802	if (nfsd4_session_too_many_ops(rqstp, session))
1803		goto out;
1804
1805	status = nfserr_req_too_big;
1806	if (nfsd4_request_too_big(rqstp, session))
1807		goto out;
1808
1809	status = nfserr_badslot;
1810	if (seq->slotid >= session->se_fchannel.maxreqs)
1811		goto out;
1812
1813	slot = session->se_slots[seq->slotid];
1814	dprintk("%s: slotid %d\n", __func__, seq->slotid);
1815
1816	/* We do not negotiate the number of slots yet, so set the
1817	 * maxslots to the session maxreqs which is used to encode
1818	 * sr_highest_slotid and the sr_target_slot id to maxslots */
1819	seq->maxslots = session->se_fchannel.maxreqs;
1820
1821	status = check_slot_seqid(seq->seqid, slot->sl_seqid, slot->sl_inuse);
 
1822	if (status == nfserr_replay_cache) {
 
 
 
1823		cstate->slot = slot;
1824		cstate->session = session;
1825		/* Return the cached reply status and set cstate->status
1826		 * for nfsd4_proc_compound processing */
1827		status = nfsd4_replay_cache_entry(resp, seq);
1828		cstate->status = nfserr_replay_cache;
1829		goto out;
1830	}
1831	if (status)
1832		goto out;
1833
1834	nfsd4_sequence_check_conn(conn, session);
1835	conn = NULL;
1836
1837	/* Success! bump slot seqid */
1838	slot->sl_inuse = true;
1839	slot->sl_seqid = seq->seqid;
1840	slot->sl_cachethis = seq->cachethis;
 
 
 
 
1841
1842	cstate->slot = slot;
1843	cstate->session = session;
1844
1845out:
1846	/* Hold a session reference until done processing the compound. */
1847	if (cstate->session) {
1848		struct nfs4_client *clp = session->se_client;
1849
1850		nfsd4_get_session(cstate->session);
1851		atomic_inc(&clp->cl_refcount);
1852		if (clp->cl_cb_state == NFSD4_CB_DOWN)
1853			seq->status_flags |= SEQ4_STATUS_CB_PATH_DOWN;
 
 
 
 
 
 
 
 
1854	}
1855	kfree(conn);
1856	spin_unlock(&client_lock);
1857	dprintk("%s: return %d\n", __func__, ntohl(status));
1858	return status;
1859}
1860
1861__be32
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1862nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
1863{
1864	int status = 0;
1865
1866	if (rc->rca_one_fs) {
1867		if (!cstate->current_fh.fh_dentry)
1868			return nfserr_nofilehandle;
1869		/*
1870		 * We don't take advantage of the rca_one_fs case.
1871		 * That's OK, it's optional, we can safely ignore it.
1872		 */
1873		 return nfs_ok;
1874	}
1875
1876	nfs4_lock_state();
1877	status = nfserr_complete_already;
1878	if (cstate->session->se_client->cl_firststate)
 
1879		goto out;
1880
1881	status = nfserr_stale_clientid;
1882	if (is_client_expired(cstate->session->se_client))
1883		/*
1884		 * The following error isn't really legal.
1885		 * But we only get here if the client just explicitly
1886		 * destroyed the client.  Surely it no longer cares what
1887		 * error it gets back on an operation for the dead
1888		 * client.
1889		 */
1890		goto out;
1891
1892	status = nfs_ok;
1893	nfsd4_create_clid_dir(cstate->session->se_client);
1894out:
1895	nfs4_unlock_state();
1896	return status;
1897}
1898
1899__be32
1900nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1901		  struct nfsd4_setclientid *setclid)
1902{
1903	struct xdr_netobj 	clname = { 
1904		.len = setclid->se_namelen,
1905		.data = setclid->se_name,
1906	};
1907	nfs4_verifier		clverifier = setclid->se_verf;
1908	unsigned int 		strhashval;
1909	struct nfs4_client	*conf, *unconf, *new;
1910	__be32 			status;
1911	char                    dname[HEXDIR_LEN];
1912	
1913	if (!check_name(clname))
1914		return nfserr_inval;
1915
1916	status = nfs4_make_rec_clidname(dname, &clname);
1917	if (status)
1918		return status;
1919
1920	/* 
1921	 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1922	 * We get here on a DRC miss.
1923	 */
1924
1925	strhashval = clientstr_hashval(dname);
1926
 
1927	nfs4_lock_state();
1928	conf = find_confirmed_client_by_str(dname, strhashval);
1929	if (conf) {
1930		/* RFC 3530 14.2.33 CASE 0: */
1931		status = nfserr_clid_inuse;
1932		if (clp_used_exchangeid(conf))
1933			goto out;
1934		if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
1935			char addr_str[INET6_ADDRSTRLEN];
1936			rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
1937				 sizeof(addr_str));
1938			dprintk("NFSD: setclientid: string in use by client "
1939				"at %s\n", addr_str);
1940			goto out;
1941		}
1942	}
1943	/*
1944	 * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
1945	 * has a description of SETCLIENTID request processing consisting
1946	 * of 5 bullet points, labeled as CASE0 - CASE4 below.
1947	 */
1948	unconf = find_unconfirmed_client_by_str(dname, strhashval);
1949	status = nfserr_resource;
1950	if (!conf) {
1951		/*
1952		 * RFC 3530 14.2.33 CASE 4:
1953		 * placed first, because it is the normal case
1954		 */
1955		if (unconf)
1956			expire_client(unconf);
1957		new = create_client(clname, dname, rqstp, &clverifier);
1958		if (new == NULL)
1959			goto out;
1960		gen_clid(new);
1961	} else if (same_verf(&conf->cl_verifier, &clverifier)) {
1962		/*
1963		 * RFC 3530 14.2.33 CASE 1:
1964		 * probable callback update
1965		 */
1966		if (unconf) {
1967			/* Note this is removing unconfirmed {*x***},
1968			 * which is stronger than RFC recommended {vxc**}.
1969			 * This has the advantage that there is at most
1970			 * one {*x***} in either list at any time.
1971			 */
1972			expire_client(unconf);
1973		}
1974		new = create_client(clname, dname, rqstp, &clverifier);
1975		if (new == NULL)
1976			goto out;
1977		copy_clid(new, conf);
1978	} else if (!unconf) {
1979		/*
1980		 * RFC 3530 14.2.33 CASE 2:
1981		 * probable client reboot; state will be removed if
1982		 * confirmed.
1983		 */
1984		new = create_client(clname, dname, rqstp, &clverifier);
1985		if (new == NULL)
1986			goto out;
1987		gen_clid(new);
1988	} else {
1989		/*
1990		 * RFC 3530 14.2.33 CASE 3:
1991		 * probable client reboot; state will be removed if
1992		 * confirmed.
1993		 */
1994		expire_client(unconf);
1995		new = create_client(clname, dname, rqstp, &clverifier);
1996		if (new == NULL)
1997			goto out;
 
 
 
 
 
1998		gen_clid(new);
1999	}
2000	/*
2001	 * XXX: we should probably set this at creation time, and check
2002	 * for consistent minorversion use throughout:
2003	 */
2004	new->cl_minorversion = 0;
2005	gen_callback(new, setclid, rqstp);
2006	add_to_unconfirmed(new, strhashval);
2007	setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
2008	setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
2009	memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
2010	status = nfs_ok;
2011out:
2012	nfs4_unlock_state();
2013	return status;
2014}
2015
2016
2017/*
2018 * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
2019 * a description of SETCLIENTID_CONFIRM request processing consisting of 4
2020 * bullets, labeled as CASE1 - CASE4 below.
2021 */
2022__be32
2023nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
2024			 struct nfsd4_compound_state *cstate,
2025			 struct nfsd4_setclientid_confirm *setclientid_confirm)
2026{
2027	struct sockaddr *sa = svc_addr(rqstp);
2028	struct nfs4_client *conf, *unconf;
2029	nfs4_verifier confirm = setclientid_confirm->sc_confirm; 
2030	clientid_t * clid = &setclientid_confirm->sc_clientid;
2031	__be32 status;
2032
2033	if (STALE_CLIENTID(clid))
2034		return nfserr_stale_clientid;
2035	/* 
2036	 * XXX The Duplicate Request Cache (DRC) has been checked (??)
2037	 * We get here on a DRC miss.
2038	 */
2039
2040	nfs4_lock_state();
2041
2042	conf = find_confirmed_client(clid);
2043	unconf = find_unconfirmed_client(clid);
2044
2045	status = nfserr_clid_inuse;
2046	if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa))
2047		goto out;
2048	if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa))
2049		goto out;
2050
2051	/*
2052	 * section 14.2.34 of RFC 3530 has a description of
2053	 * SETCLIENTID_CONFIRM request processing consisting
2054	 * of 4 bullet points, labeled as CASE1 - CASE4 below.
 
2055	 */
2056	if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
2057		/*
2058		 * RFC 3530 14.2.34 CASE 1:
2059		 * callback update
2060		 */
2061		if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
2062			status = nfserr_clid_inuse;
2063		else {
2064			nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2065			nfsd4_probe_callback(conf);
2066			expire_client(unconf);
2067			status = nfs_ok;
 
 
 
 
 
 
 
 
 
 
 
2068
 
 
 
 
2069		}
2070	} else if (conf && !unconf) {
2071		/*
2072		 * RFC 3530 14.2.34 CASE 2:
2073		 * probable retransmitted request; play it safe and
2074		 * do nothing.
2075		 */
2076		if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
2077			status = nfserr_clid_inuse;
2078		else
2079			status = nfs_ok;
2080	} else if (!conf && unconf
2081			&& same_verf(&unconf->cl_confirm, &confirm)) {
2082		/*
2083		 * RFC 3530 14.2.34 CASE 3:
2084		 * Normal case; new or rebooted client:
2085		 */
2086		if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
2087			status = nfserr_clid_inuse;
2088		} else {
2089			unsigned int hash =
2090				clientstr_hashval(unconf->cl_recdir);
2091			conf = find_confirmed_client_by_str(unconf->cl_recdir,
2092							    hash);
2093			if (conf) {
2094				nfsd4_remove_clid_dir(conf);
2095				expire_client(conf);
2096			}
2097			move_to_confirmed(unconf);
2098			conf = unconf;
2099			nfsd4_probe_callback(conf);
2100			status = nfs_ok;
2101		}
2102	} else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
2103	    && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
2104				    				&confirm)))) {
2105		/*
2106		 * RFC 3530 14.2.34 CASE 4:
2107		 * Client probably hasn't noticed that we rebooted yet.
2108		 */
2109		status = nfserr_stale_clientid;
2110	} else {
2111		/* check that we have hit one of the cases...*/
2112		status = nfserr_clid_inuse;
2113	}
2114out:
2115	nfs4_unlock_state();
2116	return status;
2117}
2118
 
 
 
 
 
2119/* OPEN Share state helper functions */
2120static inline struct nfs4_file *
2121alloc_init_file(struct inode *ino)
2122{
2123	struct nfs4_file *fp;
2124	unsigned int hashval = file_hashval(ino);
2125
2126	fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
2127	if (fp) {
2128		atomic_set(&fp->fi_ref, 1);
2129		INIT_LIST_HEAD(&fp->fi_hash);
2130		INIT_LIST_HEAD(&fp->fi_stateids);
2131		INIT_LIST_HEAD(&fp->fi_delegations);
2132		fp->fi_inode = igrab(ino);
2133		fp->fi_id = current_fileid++;
2134		fp->fi_had_conflict = false;
2135		fp->fi_lease = NULL;
2136		memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2137		memset(fp->fi_access, 0, sizeof(fp->fi_access));
2138		spin_lock(&recall_lock);
2139		list_add(&fp->fi_hash, &file_hashtbl[hashval]);
2140		spin_unlock(&recall_lock);
2141		return fp;
2142	}
2143	return NULL;
2144}
2145
2146static void
2147nfsd4_free_slab(struct kmem_cache **slab)
2148{
2149	if (*slab == NULL)
2150		return;
2151	kmem_cache_destroy(*slab);
2152	*slab = NULL;
2153}
2154
2155void
2156nfsd4_free_slabs(void)
2157{
2158	nfsd4_free_slab(&stateowner_slab);
 
2159	nfsd4_free_slab(&file_slab);
2160	nfsd4_free_slab(&stateid_slab);
2161	nfsd4_free_slab(&deleg_slab);
2162}
2163
2164static int
2165nfsd4_init_slabs(void)
2166{
2167	stateowner_slab = kmem_cache_create("nfsd4_stateowners",
2168			sizeof(struct nfs4_stateowner), 0, 0, NULL);
2169	if (stateowner_slab == NULL)
 
 
 
 
2170		goto out_nomem;
2171	file_slab = kmem_cache_create("nfsd4_files",
2172			sizeof(struct nfs4_file), 0, 0, NULL);
2173	if (file_slab == NULL)
2174		goto out_nomem;
2175	stateid_slab = kmem_cache_create("nfsd4_stateids",
2176			sizeof(struct nfs4_stateid), 0, 0, NULL);
2177	if (stateid_slab == NULL)
2178		goto out_nomem;
2179	deleg_slab = kmem_cache_create("nfsd4_delegations",
2180			sizeof(struct nfs4_delegation), 0, 0, NULL);
2181	if (deleg_slab == NULL)
2182		goto out_nomem;
2183	return 0;
2184out_nomem:
2185	nfsd4_free_slabs();
2186	dprintk("nfsd4: out of memory while initializing nfsv4\n");
2187	return -ENOMEM;
2188}
2189
2190void
2191nfs4_free_stateowner(struct kref *kref)
2192{
2193	struct nfs4_stateowner *sop =
2194		container_of(kref, struct nfs4_stateowner, so_ref);
2195	kfree(sop->so_owner.data);
2196	kmem_cache_free(stateowner_slab, sop);
2197}
2198
2199static inline struct nfs4_stateowner *
2200alloc_stateowner(struct xdr_netobj *owner)
2201{
2202	struct nfs4_stateowner *sop;
 
 
2203
2204	if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) {
2205		if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) {
2206			memcpy(sop->so_owner.data, owner->data, owner->len);
2207			sop->so_owner.len = owner->len;
2208			kref_init(&sop->so_ref);
2209			return sop;
2210		} 
2211		kmem_cache_free(stateowner_slab, sop);
2212	}
2213	return NULL;
2214}
2215
2216static struct nfs4_stateowner *
2217alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
2218	struct nfs4_stateowner *sop;
2219	struct nfs4_replay *rp;
2220	unsigned int idhashval;
2221
2222	if (!(sop = alloc_stateowner(&open->op_owner)))
 
2223		return NULL;
2224	idhashval = ownerid_hashval(current_ownerid);
2225	INIT_LIST_HEAD(&sop->so_idhash);
2226	INIT_LIST_HEAD(&sop->so_strhash);
2227	INIT_LIST_HEAD(&sop->so_perclient);
 
 
 
 
2228	INIT_LIST_HEAD(&sop->so_stateids);
2229	INIT_LIST_HEAD(&sop->so_perstateid);  /* not used */
2230	INIT_LIST_HEAD(&sop->so_close_lru);
2231	sop->so_time = 0;
2232	list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]);
2233	list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]);
2234	list_add(&sop->so_perclient, &clp->cl_openowners);
2235	sop->so_is_open_owner = 1;
2236	sop->so_id = current_ownerid++;
2237	sop->so_client = clp;
2238	sop->so_seqid = open->op_seqid;
2239	sop->so_confirmed = 0;
2240	rp = &sop->so_replay;
2241	rp->rp_status = nfserr_serverfault;
2242	rp->rp_buflen = 0;
2243	rp->rp_buf = rp->rp_ibuf;
2244	return sop;
2245}
2246
2247static inline void
2248init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
2249	struct nfs4_stateowner *sop = open->op_stateowner;
2250	unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2251
2252	INIT_LIST_HEAD(&stp->st_hash);
2253	INIT_LIST_HEAD(&stp->st_perstateowner);
2254	INIT_LIST_HEAD(&stp->st_lockowners);
2255	INIT_LIST_HEAD(&stp->st_perfile);
2256	list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
2257	list_add(&stp->st_perstateowner, &sop->so_stateids);
2258	list_add(&stp->st_perfile, &fp->fi_stateids);
2259	stp->st_stateowner = sop;
2260	get_nfs4_file(fp);
2261	stp->st_file = fp;
2262	stp->st_stateid.si_boot = boot_time;
2263	stp->st_stateid.si_stateownerid = sop->so_id;
2264	stp->st_stateid.si_fileid = fp->fi_id;
2265	stp->st_stateid.si_generation = 0;
2266	stp->st_access_bmap = 0;
2267	stp->st_deny_bmap = 0;
2268	__set_bit(open->op_share_access & ~NFS4_SHARE_WANT_MASK,
2269		  &stp->st_access_bmap);
2270	__set_bit(open->op_share_deny, &stp->st_deny_bmap);
2271	stp->st_openstp = NULL;
2272}
2273
2274static void
2275move_to_close_lru(struct nfs4_stateowner *sop)
2276{
2277	dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop);
2278
2279	list_move_tail(&sop->so_close_lru, &close_lru);
2280	sop->so_time = get_seconds();
2281}
2282
2283static int
2284same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2285							clientid_t *clid)
2286{
2287	return (sop->so_owner.len == owner->len) &&
2288		0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2289		(sop->so_client->cl_clientid.cl_id == clid->cl_id);
2290}
2291
2292static struct nfs4_stateowner *
2293find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
2294{
2295	struct nfs4_stateowner *so = NULL;
 
2296
2297	list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
2298		if (same_owner_str(so, &open->op_owner, &open->op_clientid))
2299			return so;
 
 
 
 
 
2300	}
2301	return NULL;
2302}
2303
2304/* search file_hashtbl[] for file */
2305static struct nfs4_file *
2306find_file(struct inode *ino)
2307{
2308	unsigned int hashval = file_hashval(ino);
2309	struct nfs4_file *fp;
2310
2311	spin_lock(&recall_lock);
2312	list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
2313		if (fp->fi_inode == ino) {
2314			get_nfs4_file(fp);
2315			spin_unlock(&recall_lock);
2316			return fp;
2317		}
2318	}
2319	spin_unlock(&recall_lock);
2320	return NULL;
2321}
2322
2323static inline int access_valid(u32 x, u32 minorversion)
2324{
2325	if ((x & NFS4_SHARE_ACCESS_MASK) < NFS4_SHARE_ACCESS_READ)
2326		return 0;
2327	if ((x & NFS4_SHARE_ACCESS_MASK) > NFS4_SHARE_ACCESS_BOTH)
2328		return 0;
2329	x &= ~NFS4_SHARE_ACCESS_MASK;
2330	if (minorversion && x) {
2331		if ((x & NFS4_SHARE_WANT_MASK) > NFS4_SHARE_WANT_CANCEL)
2332			return 0;
2333		if ((x & NFS4_SHARE_WHEN_MASK) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED)
2334			return 0;
2335		x &= ~(NFS4_SHARE_WANT_MASK | NFS4_SHARE_WHEN_MASK);
2336	}
2337	if (x)
2338		return 0;
2339	return 1;
2340}
2341
2342static inline int deny_valid(u32 x)
2343{
2344	/* Note: unlike access bits, deny bits may be zero. */
2345	return x <= NFS4_SHARE_DENY_BOTH;
2346}
2347
2348/*
2349 * Called to check deny when READ with all zero stateid or
2350 * WRITE with all zero or all one stateid
2351 */
2352static __be32
2353nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2354{
2355	struct inode *ino = current_fh->fh_dentry->d_inode;
2356	struct nfs4_file *fp;
2357	struct nfs4_stateid *stp;
2358	__be32 ret;
2359
2360	dprintk("NFSD: nfs4_share_conflict\n");
2361
2362	fp = find_file(ino);
2363	if (!fp)
2364		return nfs_ok;
2365	ret = nfserr_locked;
2366	/* Search for conflicting share reservations */
2367	list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
2368		if (test_bit(deny_type, &stp->st_deny_bmap) ||
2369		    test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
2370			goto out;
2371	}
2372	ret = nfs_ok;
2373out:
2374	put_nfs4_file(fp);
2375	return ret;
2376}
2377
2378static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
2379{
2380	/* We're assuming the state code never drops its reference
2381	 * without first removing the lease.  Since we're in this lease
2382	 * callback (and since the lease code is serialized by the kernel
2383	 * lock) we know the server hasn't removed the lease yet, we know
2384	 * it's safe to take a reference: */
2385	atomic_inc(&dp->dl_count);
2386
2387	list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
2388
2389	/* only place dl_time is set. protected by lock_flocks*/
2390	dp->dl_time = get_seconds();
2391
2392	nfsd4_cb_recall(dp);
2393}
2394
2395/* Called from break_lease() with lock_flocks() held. */
2396static void nfsd_break_deleg_cb(struct file_lock *fl)
2397{
2398	struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
2399	struct nfs4_delegation *dp;
2400
2401	BUG_ON(!fp);
2402	/* We assume break_lease is only called once per lease: */
2403	BUG_ON(fp->fi_had_conflict);
2404	/*
2405	 * We don't want the locks code to timeout the lease for us;
2406	 * we'll remove it ourself if a delegation isn't returned
2407	 * in time:
2408	 */
2409	fl->fl_break_time = 0;
2410
2411	spin_lock(&recall_lock);
2412	fp->fi_had_conflict = true;
2413	list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2414		nfsd_break_one_deleg(dp);
2415	spin_unlock(&recall_lock);
2416}
2417
2418static
2419int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2420{
2421	if (arg & F_UNLCK)
2422		return lease_modify(onlist, arg);
2423	else
2424		return -EAGAIN;
2425}
2426
2427static const struct lock_manager_operations nfsd_lease_mng_ops = {
2428	.lm_break = nfsd_break_deleg_cb,
2429	.lm_change = nfsd_change_deleg_cb,
2430};
2431
 
 
 
 
 
 
 
 
 
 
2432
2433__be32
2434nfsd4_process_open1(struct nfsd4_compound_state *cstate,
2435		    struct nfsd4_open *open)
2436{
2437	clientid_t *clientid = &open->op_clientid;
2438	struct nfs4_client *clp = NULL;
2439	unsigned int strhashval;
2440	struct nfs4_stateowner *sop = NULL;
2441
2442	if (!check_name(open->op_owner))
2443		return nfserr_inval;
2444
2445	if (STALE_CLIENTID(&open->op_clientid))
2446		return nfserr_stale_clientid;
 
 
 
 
 
 
 
2447
2448	strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner);
2449	sop = find_openstateowner_str(strhashval, open);
2450	open->op_stateowner = sop;
2451	if (!sop) {
2452		/* Make sure the client's lease hasn't expired. */
2453		clp = find_confirmed_client(clientid);
2454		if (clp == NULL)
2455			return nfserr_expired;
2456		goto renew;
2457	}
2458	/* When sessions are used, skip open sequenceid processing */
2459	if (nfsd4_has_session(cstate))
2460		goto renew;
2461	if (!sop->so_confirmed) {
2462		/* Replace unconfirmed owners without checking for replay. */
2463		clp = sop->so_client;
2464		release_openowner(sop);
2465		open->op_stateowner = NULL;
2466		goto renew;
2467	}
2468	if (open->op_seqid == sop->so_seqid - 1) {
2469		if (sop->so_replay.rp_buflen)
2470			return nfserr_replay_me;
2471		/* The original OPEN failed so spectacularly
2472		 * that we don't even have replay data saved!
2473		 * Therefore, we have no choice but to continue
2474		 * processing this OPEN; presumably, we'll
2475		 * fail again for the same reason.
2476		 */
2477		dprintk("nfsd4_process_open1: replay with no replay cache\n");
2478		goto renew;
2479	}
2480	if (open->op_seqid != sop->so_seqid)
2481		return nfserr_bad_seqid;
2482renew:
2483	if (open->op_stateowner == NULL) {
2484		sop = alloc_init_open_stateowner(strhashval, clp, open);
2485		if (sop == NULL)
2486			return nfserr_resource;
2487		open->op_stateowner = sop;
2488	}
2489	list_del_init(&sop->so_close_lru);
2490	renew_client(sop->so_client);
 
 
 
2491	return nfs_ok;
2492}
2493
2494static inline __be32
2495nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2496{
2497	if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2498		return nfserr_openmode;
2499	else
2500		return nfs_ok;
2501}
2502
2503static struct nfs4_delegation *
2504find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
2505{
2506	struct nfs4_delegation *dp;
2507
2508	spin_lock(&recall_lock);
2509	list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2510		if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid) {
2511			spin_unlock(&recall_lock);
2512			return dp;
2513		}
2514	spin_unlock(&recall_lock);
2515	return NULL;
2516}
2517
2518static int share_access_to_flags(u32 share_access)
2519{
2520	share_access &= ~NFS4_SHARE_WANT_MASK;
2521
2522	return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
 
 
 
 
 
 
 
 
 
2523}
2524
2525static __be32
2526nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open,
2527		struct nfs4_delegation **dp)
2528{
2529	int flags;
2530	__be32 status = nfserr_bad_stateid;
2531
2532	*dp = find_delegation_file(fp, &open->op_delegate_stateid);
2533	if (*dp == NULL)
2534		goto out;
2535	flags = share_access_to_flags(open->op_share_access);
2536	status = nfs4_check_delegmode(*dp, flags);
2537	if (status)
2538		*dp = NULL;
2539out:
2540	if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR)
2541		return nfs_ok;
2542	if (status)
2543		return status;
2544	open->op_stateowner->so_confirmed = 1;
2545	return nfs_ok;
2546}
2547
2548static __be32
2549nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp)
2550{
2551	struct nfs4_stateid *local;
2552	__be32 status = nfserr_share_denied;
2553	struct nfs4_stateowner *sop = open->op_stateowner;
2554
2555	list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
2556		/* ignore lock owners */
2557		if (local->st_stateowner->so_is_open_owner == 0)
2558			continue;
2559		/* remember if we have seen this open owner */
2560		if (local->st_stateowner == sop)
2561			*stpp = local;
2562		/* check for conflicting share reservations */
2563		if (!test_share(local, open))
2564			goto out;
2565	}
2566	status = 0;
2567out:
2568	return status;
2569}
2570
2571static inline struct nfs4_stateid *
2572nfs4_alloc_stateid(void)
2573{
2574	return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
2575}
2576
2577static inline int nfs4_access_to_access(u32 nfs4_access)
2578{
2579	int flags = 0;
2580
2581	if (nfs4_access & NFS4_SHARE_ACCESS_READ)
2582		flags |= NFSD_MAY_READ;
2583	if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
2584		flags |= NFSD_MAY_WRITE;
2585	return flags;
2586}
2587
2588static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
2589		struct svc_fh *cur_fh, struct nfsd4_open *open)
2590{
2591	__be32 status;
2592	int oflag = nfs4_access_to_omode(open->op_share_access);
2593	int access = nfs4_access_to_access(open->op_share_access);
2594
2595	/* CLAIM_DELEGATE_CUR is used in response to a broken lease;
2596	 * allowing it to break the lease and return EAGAIN leaves the
2597	 * client unable to make progress in returning the delegation */
2598	if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
2599		access |= NFSD_MAY_NOT_BREAK_LEASE;
2600
2601	if (!fp->fi_fds[oflag]) {
2602		status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
2603			&fp->fi_fds[oflag]);
2604		if (status)
2605			return status;
2606	}
2607	nfs4_file_get_access(fp, oflag);
2608
2609	return nfs_ok;
2610}
2611
2612static __be32
2613nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp,
2614		struct nfs4_file *fp, struct svc_fh *cur_fh,
2615		struct nfsd4_open *open)
2616{
2617	struct nfs4_stateid *stp;
2618	__be32 status;
2619
2620	stp = nfs4_alloc_stateid();
2621	if (stp == NULL)
2622		return nfserr_resource;
2623
2624	status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
2625	if (status) {
2626		kmem_cache_free(stateid_slab, stp);
2627		return status;
2628	}
2629	*stpp = stp;
2630	return 0;
2631}
2632
2633static inline __be32
2634nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2635		struct nfsd4_open *open)
2636{
2637	struct iattr iattr = {
2638		.ia_valid = ATTR_SIZE,
2639		.ia_size = 0,
2640	};
2641	if (!open->op_truncate)
2642		return 0;
2643	if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
2644		return nfserr_inval;
2645	return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2646}
2647
2648static __be32
2649nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open)
2650{
2651	u32 op_share_access = open->op_share_access & ~NFS4_SHARE_WANT_MASK;
2652	bool new_access;
2653	__be32 status;
2654
2655	new_access = !test_bit(op_share_access, &stp->st_access_bmap);
2656	if (new_access) {
2657		status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
2658		if (status)
2659			return status;
2660	}
2661	status = nfsd4_truncate(rqstp, cur_fh, open);
2662	if (status) {
2663		if (new_access) {
2664			int oflag = nfs4_access_to_omode(op_share_access);
2665			nfs4_file_put_access(fp, oflag);
2666		}
2667		return status;
2668	}
2669	/* remember the open */
2670	__set_bit(op_share_access, &stp->st_access_bmap);
2671	__set_bit(open->op_share_deny, &stp->st_deny_bmap);
2672
2673	return nfs_ok;
2674}
2675
2676
2677static void
2678nfs4_set_claim_prev(struct nfsd4_open *open)
2679{
2680	open->op_stateowner->so_confirmed = 1;
2681	open->op_stateowner->so_client->cl_firststate = 1;
2682}
2683
2684/* Should we give out recallable state?: */
2685static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
2686{
2687	if (clp->cl_cb_state == NFSD4_CB_UP)
2688		return true;
2689	/*
2690	 * In the sessions case, since we don't have to establish a
2691	 * separate connection for callbacks, we assume it's OK
2692	 * until we hear otherwise:
2693	 */
2694	return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
2695}
2696
2697static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
2698{
2699	struct file_lock *fl;
2700
2701	fl = locks_alloc_lock();
2702	if (!fl)
2703		return NULL;
2704	locks_init_lock(fl);
2705	fl->fl_lmops = &nfsd_lease_mng_ops;
2706	fl->fl_flags = FL_LEASE;
2707	fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
2708	fl->fl_end = OFFSET_MAX;
2709	fl->fl_owner = (fl_owner_t)(dp->dl_file);
2710	fl->fl_pid = current->tgid;
2711	return fl;
2712}
2713
2714static int nfs4_setlease(struct nfs4_delegation *dp, int flag)
2715{
2716	struct nfs4_file *fp = dp->dl_file;
2717	struct file_lock *fl;
2718	int status;
2719
2720	fl = nfs4_alloc_init_lease(dp, flag);
2721	if (!fl)
2722		return -ENOMEM;
2723	fl->fl_file = find_readable_file(fp);
2724	list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations);
2725	status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
2726	if (status) {
2727		list_del_init(&dp->dl_perclnt);
2728		locks_free_lock(fl);
2729		return -ENOMEM;
2730	}
2731	fp->fi_lease = fl;
2732	fp->fi_deleg_file = fl->fl_file;
2733	get_file(fp->fi_deleg_file);
2734	atomic_set(&fp->fi_delegees, 1);
2735	list_add(&dp->dl_perfile, &fp->fi_delegations);
2736	return 0;
2737}
2738
2739static int nfs4_set_delegation(struct nfs4_delegation *dp, int flag)
2740{
2741	struct nfs4_file *fp = dp->dl_file;
2742
2743	if (!fp->fi_lease)
2744		return nfs4_setlease(dp, flag);
2745	spin_lock(&recall_lock);
2746	if (fp->fi_had_conflict) {
2747		spin_unlock(&recall_lock);
2748		return -EAGAIN;
2749	}
2750	atomic_inc(&fp->fi_delegees);
2751	list_add(&dp->dl_perfile, &fp->fi_delegations);
2752	spin_unlock(&recall_lock);
2753	list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations);
2754	return 0;
2755}
2756
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2757/*
2758 * Attempt to hand out a delegation.
2759 */
2760static void
2761nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp)
2762{
2763	struct nfs4_delegation *dp;
2764	struct nfs4_stateowner *sop = stp->st_stateowner;
2765	int cb_up;
2766	int status, flag = 0;
2767
2768	cb_up = nfsd4_cb_channel_good(sop->so_client);
2769	flag = NFS4_OPEN_DELEGATE_NONE;
2770	open->op_recall = 0;
2771	switch (open->op_claim_type) {
2772		case NFS4_OPEN_CLAIM_PREVIOUS:
2773			if (!cb_up)
2774				open->op_recall = 1;
2775			flag = open->op_delegate_type;
2776			if (flag == NFS4_OPEN_DELEGATE_NONE)
2777				goto out;
2778			break;
2779		case NFS4_OPEN_CLAIM_NULL:
2780			/* Let's not give out any delegations till everyone's
2781			 * had the chance to reclaim theirs.... */
2782			if (locks_in_grace())
2783				goto out;
2784			if (!cb_up || !sop->so_confirmed)
2785				goto out;
2786			if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
2787				flag = NFS4_OPEN_DELEGATE_WRITE;
2788			else
2789				flag = NFS4_OPEN_DELEGATE_READ;
2790			break;
2791		default:
2792			goto out;
2793	}
2794
2795	dp = alloc_init_deleg(sop->so_client, stp, fh, flag);
2796	if (dp == NULL)
2797		goto out_no_deleg;
2798	status = nfs4_set_delegation(dp, flag);
2799	if (status)
2800		goto out_free;
2801
2802	memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid));
2803
2804	dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
2805		STATEID_VAL(&dp->dl_stateid));
2806out:
2807	if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
2808			&& flag == NFS4_OPEN_DELEGATE_NONE
2809			&& open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
2810		dprintk("NFSD: WARNING: refusing delegation reclaim\n");
2811	open->op_delegate_type = flag;
 
 
 
 
 
 
 
 
 
2812	return;
2813out_free:
2814	nfs4_put_delegation(dp);
2815out_no_deleg:
2816	flag = NFS4_OPEN_DELEGATE_NONE;
2817	goto out;
2818}
2819
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2820/*
2821 * called with nfs4_lock_state() held.
2822 */
2823__be32
2824nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
2825{
2826	struct nfsd4_compoundres *resp = rqstp->rq_resp;
 
2827	struct nfs4_file *fp = NULL;
2828	struct inode *ino = current_fh->fh_dentry->d_inode;
2829	struct nfs4_stateid *stp = NULL;
2830	struct nfs4_delegation *dp = NULL;
2831	__be32 status;
2832
2833	status = nfserr_inval;
2834	if (!access_valid(open->op_share_access, resp->cstate.minorversion)
2835			|| !deny_valid(open->op_share_deny))
2836		goto out;
2837	/*
2838	 * Lookup file; if found, lookup stateid and check open request,
2839	 * and check for delegations in the process of being recalled.
2840	 * If not found, create the nfs4_file struct
2841	 */
2842	fp = find_file(ino);
2843	if (fp) {
2844		if ((status = nfs4_check_open(fp, open, &stp)))
2845			goto out;
2846		status = nfs4_check_deleg(fp, open, &dp);
2847		if (status)
2848			goto out;
2849	} else {
2850		status = nfserr_bad_stateid;
2851		if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
2852			goto out;
2853		status = nfserr_resource;
2854		fp = alloc_init_file(ino);
2855		if (fp == NULL)
2856			goto out;
 
 
 
 
2857	}
2858
2859	/*
2860	 * OPEN the file, or upgrade an existing OPEN.
2861	 * If truncate fails, the OPEN fails.
2862	 */
2863	if (stp) {
2864		/* Stateid was found, this is an OPEN upgrade */
2865		status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
2866		if (status)
2867			goto out;
2868		update_stateid(&stp->st_stateid);
2869	} else {
2870		status = nfs4_new_open(rqstp, &stp, fp, current_fh, open);
2871		if (status)
2872			goto out;
2873		init_stateid(stp, fp, open);
 
 
2874		status = nfsd4_truncate(rqstp, current_fh, open);
2875		if (status) {
2876			release_open_stateid(stp);
2877			goto out;
2878		}
2879		if (nfsd4_has_session(&resp->cstate))
2880			update_stateid(&stp->st_stateid);
2881	}
2882	memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));
 
2883
2884	if (nfsd4_has_session(&resp->cstate))
2885		open->op_stateowner->so_confirmed = 1;
 
 
 
 
 
 
 
2886
2887	/*
2888	* Attempt to hand out a delegation. No error return, because the
2889	* OPEN succeeds even if we fail.
2890	*/
2891	nfs4_open_delegation(current_fh, open, stp);
2892
2893	status = nfs_ok;
2894
2895	dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
2896		STATEID_VAL(&stp->st_stateid));
2897out:
 
 
 
 
 
2898	if (fp)
2899		put_nfs4_file(fp);
2900	if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
2901		nfs4_set_claim_prev(open);
2902	/*
2903	* To finish the open response, we just need to set the rflags.
2904	*/
2905	open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
2906	if (!open->op_stateowner->so_confirmed &&
2907	    !nfsd4_has_session(&resp->cstate))
2908		open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
2909
2910	return status;
2911}
2912
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2913__be32
2914nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2915	    clientid_t *clid)
2916{
2917	struct nfs4_client *clp;
2918	__be32 status;
2919
2920	nfs4_lock_state();
2921	dprintk("process_renew(%08x/%08x): starting\n", 
2922			clid->cl_boot, clid->cl_id);
2923	status = nfserr_stale_clientid;
2924	if (STALE_CLIENTID(clid))
2925		goto out;
2926	clp = find_confirmed_client(clid);
2927	status = nfserr_expired;
2928	if (clp == NULL) {
2929		/* We assume the client took too long to RENEW. */
2930		dprintk("nfsd4_renew: clientid not found!\n");
2931		goto out;
2932	}
2933	renew_client(clp);
2934	status = nfserr_cb_path_down;
2935	if (!list_empty(&clp->cl_delegations)
2936			&& clp->cl_cb_state != NFSD4_CB_UP)
2937		goto out;
2938	status = nfs_ok;
2939out:
2940	nfs4_unlock_state();
2941	return status;
2942}
2943
2944static struct lock_manager nfsd4_manager = {
2945};
2946
 
 
2947static void
2948nfsd4_end_grace(void)
2949{
 
 
 
 
2950	dprintk("NFSD: end of grace period\n");
2951	nfsd4_recdir_purge_old();
 
2952	locks_end_grace(&nfsd4_manager);
2953	/*
2954	 * Now that every NFSv4 client has had the chance to recover and
2955	 * to see the (possibly new, possibly shorter) lease time, we
2956	 * can safely set the next grace time to the current lease time:
2957	 */
2958	nfsd4_grace = nfsd4_lease;
2959}
2960
2961static time_t
2962nfs4_laundromat(void)
2963{
2964	struct nfs4_client *clp;
2965	struct nfs4_stateowner *sop;
2966	struct nfs4_delegation *dp;
2967	struct list_head *pos, *next, reaplist;
2968	time_t cutoff = get_seconds() - nfsd4_lease;
2969	time_t t, clientid_val = nfsd4_lease;
2970	time_t u, test_val = nfsd4_lease;
2971
2972	nfs4_lock_state();
2973
2974	dprintk("NFSD: laundromat service - starting\n");
2975	if (locks_in_grace())
2976		nfsd4_end_grace();
2977	INIT_LIST_HEAD(&reaplist);
2978	spin_lock(&client_lock);
2979	list_for_each_safe(pos, next, &client_lru) {
2980		clp = list_entry(pos, struct nfs4_client, cl_lru);
2981		if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
2982			t = clp->cl_time - cutoff;
2983			if (clientid_val > t)
2984				clientid_val = t;
2985			break;
2986		}
2987		if (atomic_read(&clp->cl_refcount)) {
2988			dprintk("NFSD: client in use (clientid %08x)\n",
2989				clp->cl_clientid.cl_id);
2990			continue;
2991		}
2992		unhash_client_locked(clp);
2993		list_add(&clp->cl_lru, &reaplist);
2994	}
2995	spin_unlock(&client_lock);
2996	list_for_each_safe(pos, next, &reaplist) {
2997		clp = list_entry(pos, struct nfs4_client, cl_lru);
2998		dprintk("NFSD: purging unused client (clientid %08x)\n",
2999			clp->cl_clientid.cl_id);
3000		nfsd4_remove_clid_dir(clp);
3001		expire_client(clp);
3002	}
3003	spin_lock(&recall_lock);
3004	list_for_each_safe(pos, next, &del_recall_lru) {
3005		dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3006		if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
3007			u = dp->dl_time - cutoff;
3008			if (test_val > u)
3009				test_val = u;
3010			break;
3011		}
3012		list_move(&dp->dl_recall_lru, &reaplist);
3013	}
3014	spin_unlock(&recall_lock);
3015	list_for_each_safe(pos, next, &reaplist) {
3016		dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3017		list_del_init(&dp->dl_recall_lru);
3018		unhash_delegation(dp);
3019	}
3020	test_val = nfsd4_lease;
3021	list_for_each_safe(pos, next, &close_lru) {
3022		sop = list_entry(pos, struct nfs4_stateowner, so_close_lru);
3023		if (time_after((unsigned long)sop->so_time, (unsigned long)cutoff)) {
3024			u = sop->so_time - cutoff;
3025			if (test_val > u)
3026				test_val = u;
3027			break;
3028		}
3029		dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
3030			sop->so_id);
3031		release_openowner(sop);
3032	}
3033	if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
3034		clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
3035	nfs4_unlock_state();
3036	return clientid_val;
3037}
3038
3039static struct workqueue_struct *laundry_wq;
3040static void laundromat_main(struct work_struct *);
3041static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
3042
3043static void
3044laundromat_main(struct work_struct *not_used)
3045{
3046	time_t t;
3047
3048	t = nfs4_laundromat();
3049	dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
3050	queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
3051}
3052
3053static struct nfs4_stateowner *
3054search_close_lru(u32 st_id, int flags)
3055{
3056	struct nfs4_stateowner *local = NULL;
3057
3058	if (flags & CLOSE_STATE) {
3059		list_for_each_entry(local, &close_lru, so_close_lru) {
3060			if (local->so_id == st_id)
3061				return local;
3062		}
3063	}
3064	return NULL;
3065}
3066
3067static inline int
3068nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
3069{
3070	return fhp->fh_dentry->d_inode != stp->st_file->fi_inode;
3071}
3072
3073static int
3074STALE_STATEID(stateid_t *stateid)
3075{
3076	if (stateid->si_boot == boot_time)
3077		return 0;
3078	dprintk("NFSD: stale stateid " STATEID_FMT "!\n",
3079		STATEID_VAL(stateid));
3080	return 1;
3081}
3082
3083static inline int
3084access_permit_read(unsigned long access_bmap)
3085{
3086	return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
3087		test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
3088		test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
3089}
3090
3091static inline int
3092access_permit_write(unsigned long access_bmap)
3093{
3094	return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
3095		test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
3096}
3097
3098static
3099__be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags)
3100{
3101        __be32 status = nfserr_openmode;
3102
3103	/* For lock stateid's, we test the parent open, not the lock: */
3104	if (stp->st_openstp)
3105		stp = stp->st_openstp;
3106	if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
3107                goto out;
3108	if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
3109                goto out;
3110	status = nfs_ok;
3111out:
3112	return status;
3113}
3114
3115static inline __be32
3116check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
3117{
3118	if (ONE_STATEID(stateid) && (flags & RD_STATE))
3119		return nfs_ok;
3120	else if (locks_in_grace()) {
3121		/* Answer in remaining cases depends on existence of
3122		 * conflicting state; so we must wait out the grace period. */
3123		return nfserr_grace;
3124	} else if (flags & WR_STATE)
3125		return nfs4_share_conflict(current_fh,
3126				NFS4_SHARE_DENY_WRITE);
3127	else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
3128		return nfs4_share_conflict(current_fh,
3129				NFS4_SHARE_DENY_READ);
3130}
3131
3132/*
3133 * Allow READ/WRITE during grace period on recovered state only for files
3134 * that are not able to provide mandatory locking.
3135 */
3136static inline int
3137grace_disallows_io(struct inode *inode)
3138{
3139	return locks_in_grace() && mandatory_lock(inode);
3140}
3141
3142static int check_stateid_generation(stateid_t *in, stateid_t *ref, int flags)
 
 
 
 
 
 
3143{
3144	/*
3145	 * When sessions are used the stateid generation number is ignored
3146	 * when it is zero.
3147	 */
3148	if ((flags & HAS_SESSION) && in->si_generation == 0)
3149		goto out;
 
 
 
3150
3151	/* If the client sends us a stateid from the future, it's buggy: */
3152	if (in->si_generation > ref->si_generation)
3153		return nfserr_bad_stateid;
3154	/*
3155	 * The following, however, can happen.  For example, if the
3156	 * client sends an open and some IO at the same time, the open
3157	 * may bump si_generation while the IO is still in flight.
3158	 * Thanks to hard links and renames, the client never knows what
3159	 * file an open will affect.  So it could avoid that situation
3160	 * only by serializing all opens and IO from the same open
3161	 * owner.  To recover from the old_stateid error, the client
3162	 * will just have to retry the IO:
3163	 */
3164	if (in->si_generation < ref->si_generation)
3165		return nfserr_old_stateid;
3166out:
3167	return nfs_ok;
3168}
3169
3170static int is_delegation_stateid(stateid_t *stateid)
3171{
3172	return stateid->si_fileid == 0;
3173}
 
3174
3175static int is_open_stateid(struct nfs4_stateid *stateid)
3176{
3177	return stateid->st_openstp == NULL;
 
 
 
 
 
 
 
 
 
 
 
 
 
3178}
3179
3180__be32 nfs4_validate_stateid(stateid_t *stateid, int flags)
3181{
3182	struct nfs4_stateid *stp = NULL;
3183	__be32 status = nfserr_stale_stateid;
3184
 
 
3185	if (STALE_STATEID(stateid))
3186		goto out;
3187
3188	status = nfserr_expired;
3189	stp = search_for_stateid(stateid);
3190	if (!stp)
3191		goto out;
3192	status = nfserr_bad_stateid;
3193
3194	if (!stp->st_stateowner->so_confirmed)
3195		goto out;
3196
3197	status = check_stateid_generation(stateid, &stp->st_stateid, flags);
3198	if (status)
3199		goto out;
3200
3201	status = nfs_ok;
3202out:
3203	return status;
3204}
3205
3206/*
3207* Checks for stateid operations
3208*/
3209__be32
3210nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
3211			   stateid_t *stateid, int flags, struct file **filpp)
3212{
3213	struct nfs4_stateid *stp = NULL;
 
3214	struct nfs4_delegation *dp = NULL;
3215	struct svc_fh *current_fh = &cstate->current_fh;
3216	struct inode *ino = current_fh->fh_dentry->d_inode;
3217	__be32 status;
3218
3219	if (filpp)
3220		*filpp = NULL;
3221
3222	if (grace_disallows_io(ino))
3223		return nfserr_grace;
3224
3225	if (nfsd4_has_session(cstate))
3226		flags |= HAS_SESSION;
3227
3228	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3229		return check_special_stateids(current_fh, stateid, flags);
3230
3231	status = nfserr_stale_stateid;
3232	if (STALE_STATEID(stateid)) 
 
 
 
3233		goto out;
3234
3235	/*
3236	 * We assume that any stateid that has the current boot time,
3237	 * but that we can't find, is expired:
3238	 */
3239	status = nfserr_expired;
3240	if (is_delegation_stateid(stateid)) {
3241		dp = find_delegation_stateid(ino, stateid);
3242		if (!dp)
3243			goto out;
3244		status = check_stateid_generation(stateid, &dp->dl_stateid,
3245						  flags);
3246		if (status)
3247			goto out;
3248		status = nfs4_check_delegmode(dp, flags);
3249		if (status)
3250			goto out;
3251		renew_client(dp->dl_client);
3252		if (filpp) {
3253			*filpp = dp->dl_file->fi_deleg_file;
3254			BUG_ON(!*filpp);
3255		}
3256	} else { /* open or lock stateid */
3257		stp = find_stateid(stateid, flags);
3258		if (!stp)
3259			goto out;
3260		status = nfserr_bad_stateid;
3261		if (nfs4_check_fh(current_fh, stp))
3262			goto out;
3263		if (!stp->st_stateowner->so_confirmed)
3264			goto out;
3265		status = check_stateid_generation(stateid, &stp->st_stateid,
3266						  flags);
3267		if (status)
3268			goto out;
 
 
 
3269		status = nfs4_check_openmode(stp, flags);
3270		if (status)
3271			goto out;
3272		renew_client(stp->st_stateowner->so_client);
3273		if (filpp) {
3274			if (flags & RD_STATE)
3275				*filpp = find_readable_file(stp->st_file);
3276			else
3277				*filpp = find_writeable_file(stp->st_file);
3278		}
 
 
 
3279	}
3280	status = nfs_ok;
3281out:
3282	return status;
3283}
3284
3285static __be32
3286nfsd4_free_delegation_stateid(stateid_t *stateid)
3287{
3288	struct nfs4_delegation *dp = search_for_delegation(stateid);
3289	if (dp)
3290		return nfserr_locks_held;
3291	return nfserr_bad_stateid;
3292}
3293
3294static __be32
3295nfsd4_free_lock_stateid(struct nfs4_stateid *stp)
3296{
3297	if (check_for_locks(stp->st_file, stp->st_stateowner))
3298		return nfserr_locks_held;
3299	release_lock_stateid(stp);
3300	return nfs_ok;
3301}
3302
3303/*
3304 * Test if the stateid is valid
3305 */
3306__be32
3307nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3308		   struct nfsd4_test_stateid *test_stateid)
3309{
3310	test_stateid->ts_has_session = nfsd4_has_session(cstate);
 
 
 
 
 
 
 
3311	return nfs_ok;
3312}
3313
3314/*
3315 * Free a state id
3316 */
3317__be32
3318nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3319		   struct nfsd4_free_stateid *free_stateid)
3320{
3321	stateid_t *stateid = &free_stateid->fr_stateid;
3322	struct nfs4_stateid *stp;
3323	__be32 ret;
 
3324
3325	nfs4_lock_state();
3326	if (is_delegation_stateid(stateid)) {
3327		ret = nfsd4_free_delegation_stateid(stateid);
3328		goto out;
3329	}
3330
3331	stp = search_for_stateid(stateid);
3332	if (!stp) {
3333		ret = nfserr_bad_stateid;
3334		goto out;
3335	}
3336	if (stateid->si_generation != 0) {
3337		if (stateid->si_generation < stp->st_stateid.si_generation) {
3338			ret = nfserr_old_stateid;
3339			goto out;
3340		}
3341		if (stateid->si_generation > stp->st_stateid.si_generation) {
3342			ret = nfserr_bad_stateid;
3343			goto out;
3344		}
3345	}
3346
3347	if (is_open_stateid(stp)) {
3348		ret = nfserr_locks_held;
3349		goto out;
3350	} else {
3351		ret = nfsd4_free_lock_stateid(stp);
3352		goto out;
 
 
 
 
 
 
 
 
 
3353	}
3354
3355out:
3356	nfs4_unlock_state();
3357	return ret;
3358}
3359
3360static inline int
3361setlkflg (int type)
3362{
3363	return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
3364		RD_STATE : WR_STATE;
3365}
3366
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3367/* 
3368 * Checks for sequence id mutating operations. 
3369 */
3370static __be32
3371nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3372			 stateid_t *stateid, int flags,
3373			 struct nfs4_stateowner **sopp,
3374			 struct nfs4_stateid **stpp, struct nfsd4_lock *lock)
3375{
3376	struct nfs4_stateid *stp;
3377	struct nfs4_stateowner *sop;
3378	struct svc_fh *current_fh = &cstate->current_fh;
3379	__be32 status;
 
3380
3381	dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3382		seqid, STATEID_VAL(stateid));
3383
3384	*stpp = NULL;
3385	*sopp = NULL;
3386
3387	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
3388		dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");
3389		return nfserr_bad_stateid;
3390	}
3391
3392	if (STALE_STATEID(stateid))
3393		return nfserr_stale_stateid;
3394
3395	if (nfsd4_has_session(cstate))
3396		flags |= HAS_SESSION;
3397
3398	/*
3399	* We return BAD_STATEID if filehandle doesn't match stateid, 
3400	* the confirmed flag is incorrecly set, or the generation 
3401	* number is incorrect.  
3402	*/
3403	stp = find_stateid(stateid, flags);
3404	if (stp == NULL) {
3405		/*
3406		 * Also, we should make sure this isn't just the result of
3407		 * a replayed close:
3408		 */
3409		sop = search_close_lru(stateid->si_stateownerid, flags);
3410		/* It's not stale; let's assume it's expired: */
3411		if (sop == NULL)
3412			return nfserr_expired;
3413		*sopp = sop;
3414		goto check_replay;
3415	}
3416
3417	*stpp = stp;
3418	*sopp = sop = stp->st_stateowner;
3419
3420	if (lock) {
3421		clientid_t *lockclid = &lock->v.new.clientid;
3422		struct nfs4_client *clp = sop->so_client;
3423		int lkflg = 0;
3424		__be32 status;
3425
3426		lkflg = setlkflg(lock->lk_type);
3427
3428		if (lock->lk_is_new) {
3429			if (!sop->so_is_open_owner)
3430				return nfserr_bad_stateid;
3431			if (!(flags & HAS_SESSION) &&
3432			    !same_clid(&clp->cl_clientid, lockclid))
3433				return nfserr_bad_stateid;
3434			/* stp is the open stateid */
3435			status = nfs4_check_openmode(stp, lkflg);
3436			if (status)
3437				return status;
3438		} else {
3439			/* stp is the lock stateid */
3440			status = nfs4_check_openmode(stp->st_openstp, lkflg);
3441			if (status)
3442				return status;
3443               }
3444	}
3445
3446	if (nfs4_check_fh(current_fh, stp)) {
3447		dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
3448		return nfserr_bad_stateid;
3449	}
3450
3451	/*
3452	*  We now validate the seqid and stateid generation numbers.
3453	*  For the moment, we ignore the possibility of 
3454	*  generation number wraparound.
3455	*/
3456	if (!(flags & HAS_SESSION) && seqid != sop->so_seqid)
3457		goto check_replay;
3458
3459	if (sop->so_confirmed && flags & CONFIRM) {
3460		dprintk("NFSD: preprocess_seqid_op: expected"
3461				" unconfirmed stateowner!\n");
3462		return nfserr_bad_stateid;
3463	}
3464	if (!sop->so_confirmed && !(flags & CONFIRM)) {
3465		dprintk("NFSD: preprocess_seqid_op: stateowner not"
3466				" confirmed yet!\n");
3467		return nfserr_bad_stateid;
3468	}
3469	status = check_stateid_generation(stateid, &stp->st_stateid, flags);
3470	if (status)
3471		return status;
3472	renew_client(sop->so_client);
 
 
3473	return nfs_ok;
3474
3475check_replay:
3476	if (seqid == sop->so_seqid - 1) {
3477		dprintk("NFSD: preprocess_seqid_op: retransmission?\n");
3478		/* indicate replay to calling function */
3479		return nfserr_replay_me;
3480	}
3481	dprintk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",
3482			sop->so_seqid, seqid);
3483	*sopp = NULL;
3484	return nfserr_bad_seqid;
3485}
3486
3487__be32
3488nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3489		   struct nfsd4_open_confirm *oc)
3490{
3491	__be32 status;
3492	struct nfs4_stateowner *sop;
3493	struct nfs4_stateid *stp;
3494
3495	dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
3496			(int)cstate->current_fh.fh_dentry->d_name.len,
3497			cstate->current_fh.fh_dentry->d_name.name);
3498
3499	status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
3500	if (status)
3501		return status;
3502
3503	nfs4_lock_state();
3504
3505	if ((status = nfs4_preprocess_seqid_op(cstate,
3506					oc->oc_seqid, &oc->oc_req_stateid,
3507					CONFIRM | OPEN_STATE,
3508					&oc->oc_stateowner, &stp, NULL)))
3509		goto out; 
3510
3511	sop = oc->oc_stateowner;
3512	sop->so_confirmed = 1;
3513	update_stateid(&stp->st_stateid);
3514	memcpy(&oc->oc_resp_stateid, &stp->st_stateid, sizeof(stateid_t));
 
 
3515	dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
3516		__func__, oc->oc_seqid, STATEID_VAL(&stp->st_stateid));
3517
3518	nfsd4_create_clid_dir(sop->so_client);
 
3519out:
3520	if (oc->oc_stateowner) {
3521		nfs4_get_stateowner(oc->oc_stateowner);
3522		cstate->replay_owner = oc->oc_stateowner;
3523	}
3524	nfs4_unlock_state();
3525	return status;
3526}
3527
3528static inline void nfs4_file_downgrade(struct nfs4_stateid *stp, unsigned int to_access)
3529{
3530	int i;
 
 
 
 
3531
3532	for (i = 1; i < 4; i++) {
3533		if (test_bit(i, &stp->st_access_bmap) && !(i & to_access)) {
3534			nfs4_file_put_access(stp->st_file, i);
3535			__clear_bit(i, &stp->st_access_bmap);
3536		}
 
 
 
 
 
 
 
 
 
 
3537	}
3538}
3539
3540static void
3541reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
3542{
3543	int i;
3544	for (i = 0; i < 4; i++) {
3545		if ((i & deny) != i)
3546			__clear_bit(i, bmap);
3547	}
3548}
3549
3550__be32
3551nfsd4_open_downgrade(struct svc_rqst *rqstp,
3552		     struct nfsd4_compound_state *cstate,
3553		     struct nfsd4_open_downgrade *od)
3554{
3555	__be32 status;
3556	struct nfs4_stateid *stp;
3557
3558	dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n", 
3559			(int)cstate->current_fh.fh_dentry->d_name.len,
3560			cstate->current_fh.fh_dentry->d_name.name);
3561
3562	if (!access_valid(od->od_share_access, cstate->minorversion)
3563			|| !deny_valid(od->od_share_deny))
3564		return nfserr_inval;
 
3565
3566	nfs4_lock_state();
3567	if ((status = nfs4_preprocess_seqid_op(cstate,
3568					od->od_seqid,
3569					&od->od_stateid, 
3570					OPEN_STATE,
3571					&od->od_stateowner, &stp, NULL)))
3572		goto out; 
3573
3574	status = nfserr_inval;
3575	if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
3576		dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
3577			stp->st_access_bmap, od->od_share_access);
3578		goto out;
3579	}
3580	if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
3581		dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3582			stp->st_deny_bmap, od->od_share_deny);
3583		goto out;
3584	}
3585	nfs4_file_downgrade(stp, od->od_share_access);
3586
3587	reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);
3588
3589	update_stateid(&stp->st_stateid);
3590	memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t));
3591	status = nfs_ok;
3592out:
3593	if (od->od_stateowner) {
3594		nfs4_get_stateowner(od->od_stateowner);
3595		cstate->replay_owner = od->od_stateowner;
3596	}
3597	nfs4_unlock_state();
3598	return status;
3599}
3600
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3601/*
3602 * nfs4_unlock_state() called after encode
3603 */
3604__be32
3605nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3606	    struct nfsd4_close *close)
3607{
3608	__be32 status;
3609	struct nfs4_stateid *stp;
 
3610
3611	dprintk("NFSD: nfsd4_close on file %.*s\n", 
3612			(int)cstate->current_fh.fh_dentry->d_name.len,
3613			cstate->current_fh.fh_dentry->d_name.name);
3614
3615	nfs4_lock_state();
3616	/* check close_lru for replay */
3617	if ((status = nfs4_preprocess_seqid_op(cstate,
3618					close->cl_seqid,
3619					&close->cl_stateid, 
3620					OPEN_STATE | CLOSE_STATE,
3621					&close->cl_stateowner, &stp, NULL)))
3622		goto out; 
 
3623	status = nfs_ok;
3624	update_stateid(&stp->st_stateid);
3625	memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t));
3626
3627	/* release_stateid() calls nfsd_close() if needed */
3628	release_open_stateid(stp);
3629
3630	/* place unused nfs4_stateowners on so_close_lru list to be
3631	 * released by the laundromat service after the lease period
3632	 * to enable us to handle CLOSE replay
3633	 */
3634	if (list_empty(&close->cl_stateowner->so_stateids))
3635		move_to_close_lru(close->cl_stateowner);
3636out:
3637	if (close->cl_stateowner) {
3638		nfs4_get_stateowner(close->cl_stateowner);
3639		cstate->replay_owner = close->cl_stateowner;
3640	}
3641	nfs4_unlock_state();
3642	return status;
3643}
3644
3645__be32
3646nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3647		  struct nfsd4_delegreturn *dr)
3648{
3649	struct nfs4_delegation *dp;
3650	stateid_t *stateid = &dr->dr_stateid;
 
3651	struct inode *inode;
3652	__be32 status;
3653	int flags = 0;
3654
3655	if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
3656		return status;
3657	inode = cstate->current_fh.fh_dentry->d_inode;
3658
3659	if (nfsd4_has_session(cstate))
3660		flags |= HAS_SESSION;
3661	nfs4_lock_state();
3662	status = nfserr_bad_stateid;
3663	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3664		goto out;
3665	status = nfserr_stale_stateid;
3666	if (STALE_STATEID(stateid))
3667		goto out;
3668	status = nfserr_bad_stateid;
3669	if (!is_delegation_stateid(stateid))
3670		goto out;
3671	status = nfserr_expired;
3672	dp = find_delegation_stateid(inode, stateid);
3673	if (!dp)
3674		goto out;
3675	status = check_stateid_generation(stateid, &dp->dl_stateid, flags);
 
3676	if (status)
3677		goto out;
3678	renew_client(dp->dl_client);
3679
3680	unhash_delegation(dp);
3681out:
3682	nfs4_unlock_state();
3683
3684	return status;
3685}
3686
3687
3688/* 
3689 * Lock owner state (byte-range locks)
3690 */
3691#define LOFF_OVERFLOW(start, len)      ((u64)(len) > ~(u64)(start))
3692#define LOCK_HASH_BITS              8
3693#define LOCK_HASH_SIZE             (1 << LOCK_HASH_BITS)
3694#define LOCK_HASH_MASK             (LOCK_HASH_SIZE - 1)
 
3695
3696static inline u64
3697end_offset(u64 start, u64 len)
3698{
3699	u64 end;
3700
3701	end = start + len;
3702	return end >= start ? end: NFS4_MAX_UINT64;
3703}
3704
3705/* last octet in a range */
3706static inline u64
3707last_byte_offset(u64 start, u64 len)
3708{
3709	u64 end;
3710
3711	BUG_ON(!len);
3712	end = start + len;
3713	return end > start ? end - 1: NFS4_MAX_UINT64;
3714}
3715
3716#define lockownerid_hashval(id) \
3717        ((id) & LOCK_HASH_MASK)
3718
3719static inline unsigned int
3720lock_ownerstr_hashval(struct inode *inode, u32 cl_id,
3721		struct xdr_netobj *ownername)
3722{
3723	return (file_hashval(inode) + cl_id
3724			+ opaque_hashval(ownername->data, ownername->len))
3725		& LOCK_HASH_MASK;
3726}
3727
3728static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE];
3729static struct list_head	lock_ownerstr_hashtbl[LOCK_HASH_SIZE];
3730static struct list_head lockstateid_hashtbl[STATEID_HASH_SIZE];
3731
3732static int
3733same_stateid(stateid_t *id_one, stateid_t *id_two)
3734{
3735	if (id_one->si_stateownerid != id_two->si_stateownerid)
3736		return 0;
3737	return id_one->si_fileid == id_two->si_fileid;
3738}
3739
3740static struct nfs4_stateid *
3741find_stateid(stateid_t *stid, int flags)
3742{
3743	struct nfs4_stateid *local;
3744	u32 st_id = stid->si_stateownerid;
3745	u32 f_id = stid->si_fileid;
3746	unsigned int hashval;
3747
3748	dprintk("NFSD: find_stateid flags 0x%x\n",flags);
3749	if (flags & (LOCK_STATE | RD_STATE | WR_STATE)) {
3750		hashval = stateid_hashval(st_id, f_id);
3751		list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
3752			if ((local->st_stateid.si_stateownerid == st_id) &&
3753			    (local->st_stateid.si_fileid == f_id))
3754				return local;
3755		}
3756	} 
3757
3758	if (flags & (OPEN_STATE | RD_STATE | WR_STATE)) {
3759		hashval = stateid_hashval(st_id, f_id);
3760		list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
3761			if ((local->st_stateid.si_stateownerid == st_id) &&
3762			    (local->st_stateid.si_fileid == f_id))
3763				return local;
3764		}
3765	}
3766	return NULL;
3767}
3768
3769static struct nfs4_stateid *
3770search_for_stateid(stateid_t *stid)
3771{
3772	struct nfs4_stateid *local;
3773	unsigned int hashval = stateid_hashval(stid->si_stateownerid, stid->si_fileid);
3774
3775	list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
3776		if (same_stateid(&local->st_stateid, stid))
3777			return local;
3778	}
3779
3780	list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
3781		if (same_stateid(&local->st_stateid, stid))
3782			return local;
3783	}
3784	return NULL;
3785}
3786
3787static struct nfs4_delegation *
3788search_for_delegation(stateid_t *stid)
3789{
3790	struct nfs4_file *fp;
3791	struct nfs4_delegation *dp;
3792	struct list_head *pos;
3793	int i;
3794
3795	for (i = 0; i < FILE_HASH_SIZE; i++) {
3796		list_for_each_entry(fp, &file_hashtbl[i], fi_hash) {
3797			list_for_each(pos, &fp->fi_delegations) {
3798				dp = list_entry(pos, struct nfs4_delegation, dl_perfile);
3799				if (same_stateid(&dp->dl_stateid, stid))
3800					return dp;
3801			}
3802		}
3803	}
3804	return NULL;
3805}
3806
3807static struct nfs4_delegation *
3808find_delegation_stateid(struct inode *ino, stateid_t *stid)
3809{
3810	struct nfs4_file *fp;
3811	struct nfs4_delegation *dl;
3812
3813	dprintk("NFSD: %s: stateid=" STATEID_FMT "\n", __func__,
3814		STATEID_VAL(stid));
3815
3816	fp = find_file(ino);
3817	if (!fp)
3818		return NULL;
3819	dl = find_delegation_file(fp, stid);
3820	put_nfs4_file(fp);
3821	return dl;
3822}
3823
3824/*
3825 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
3826 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
3827 * byte, because of sign extension problems.  Since NFSv4 calls for 64-bit
3828 * locking, this prevents us from being completely protocol-compliant.  The
3829 * real solution to this problem is to start using unsigned file offsets in
3830 * the VFS, but this is a very deep change!
3831 */
3832static inline void
3833nfs4_transform_lock_offset(struct file_lock *lock)
3834{
3835	if (lock->fl_start < 0)
3836		lock->fl_start = OFFSET_MAX;
3837	if (lock->fl_end < 0)
3838		lock->fl_end = OFFSET_MAX;
3839}
3840
3841/* Hack!: For now, we're defining this just so we can use a pointer to it
3842 * as a unique cookie to identify our (NFSv4's) posix locks. */
3843static const struct lock_manager_operations nfsd_posix_mng_ops  = {
3844};
3845
3846static inline void
3847nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
3848{
3849	struct nfs4_stateowner *sop;
3850
3851	if (fl->fl_lmops == &nfsd_posix_mng_ops) {
3852		sop = (struct nfs4_stateowner *) fl->fl_owner;
3853		kref_get(&sop->so_ref);
3854		deny->ld_sop = sop;
3855		deny->ld_clientid = sop->so_client->cl_clientid;
 
 
 
 
3856	} else {
3857		deny->ld_sop = NULL;
 
 
3858		deny->ld_clientid.cl_boot = 0;
3859		deny->ld_clientid.cl_id = 0;
3860	}
3861	deny->ld_start = fl->fl_start;
3862	deny->ld_length = NFS4_MAX_UINT64;
3863	if (fl->fl_end != NFS4_MAX_UINT64)
3864		deny->ld_length = fl->fl_end - fl->fl_start + 1;        
3865	deny->ld_type = NFS4_READ_LT;
3866	if (fl->fl_type != F_RDLCK)
3867		deny->ld_type = NFS4_WRITE_LT;
3868}
3869
3870static struct nfs4_stateowner *
3871find_lockstateowner_str(struct inode *inode, clientid_t *clid,
 
 
 
 
 
 
 
 
 
 
 
3872		struct xdr_netobj *owner)
3873{
3874	unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner);
3875	struct nfs4_stateowner *op;
3876
3877	list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) {
3878		if (same_owner_str(op, owner, clid))
3879			return op;
3880	}
3881	return NULL;
3882}
3883
 
 
 
 
 
 
 
 
 
 
 
3884/*
3885 * Alloc a lock owner structure.
3886 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has 
3887 * occurred. 
3888 *
3889 * strhashval = lock_ownerstr_hashval 
3890 */
3891
3892static struct nfs4_stateowner *
3893alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp, struct nfsd4_lock *lock) {
3894	struct nfs4_stateowner *sop;
3895	struct nfs4_replay *rp;
3896	unsigned int idhashval;
3897
3898	if (!(sop = alloc_stateowner(&lock->lk_new_owner)))
 
3899		return NULL;
3900	idhashval = lockownerid_hashval(current_ownerid);
3901	INIT_LIST_HEAD(&sop->so_idhash);
3902	INIT_LIST_HEAD(&sop->so_strhash);
3903	INIT_LIST_HEAD(&sop->so_perclient);
3904	INIT_LIST_HEAD(&sop->so_stateids);
3905	INIT_LIST_HEAD(&sop->so_perstateid);
3906	INIT_LIST_HEAD(&sop->so_close_lru); /* not used */
3907	sop->so_time = 0;
3908	list_add(&sop->so_idhash, &lock_ownerid_hashtbl[idhashval]);
3909	list_add(&sop->so_strhash, &lock_ownerstr_hashtbl[strhashval]);
3910	list_add(&sop->so_perstateid, &open_stp->st_lockowners);
3911	sop->so_is_open_owner = 0;
3912	sop->so_id = current_ownerid++;
3913	sop->so_client = clp;
3914	/* It is the openowner seqid that will be incremented in encode in the
3915	 * case of new lockowners; so increment the lock seqid manually: */
3916	sop->so_seqid = lock->lk_new_lock_seqid + 1;
3917	sop->so_confirmed = 1;
3918	rp = &sop->so_replay;
3919	rp->rp_status = nfserr_serverfault;
3920	rp->rp_buflen = 0;
3921	rp->rp_buf = rp->rp_ibuf;
3922	return sop;
3923}
3924
3925static struct nfs4_stateid *
3926alloc_init_lock_stateid(struct nfs4_stateowner *sop, struct nfs4_file *fp, struct nfs4_stateid *open_stp)
3927{
3928	struct nfs4_stateid *stp;
3929	unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
3930
3931	stp = nfs4_alloc_stateid();
3932	if (stp == NULL)
3933		goto out;
3934	INIT_LIST_HEAD(&stp->st_hash);
3935	INIT_LIST_HEAD(&stp->st_perfile);
3936	INIT_LIST_HEAD(&stp->st_perstateowner);
3937	INIT_LIST_HEAD(&stp->st_lockowners); /* not used */
3938	list_add(&stp->st_hash, &lockstateid_hashtbl[hashval]);
3939	list_add(&stp->st_perfile, &fp->fi_stateids);
3940	list_add(&stp->st_perstateowner, &sop->so_stateids);
3941	stp->st_stateowner = sop;
3942	get_nfs4_file(fp);
3943	stp->st_file = fp;
3944	stp->st_stateid.si_boot = boot_time;
3945	stp->st_stateid.si_stateownerid = sop->so_id;
3946	stp->st_stateid.si_fileid = fp->fi_id;
3947	stp->st_stateid.si_generation = 0;
3948	stp->st_access_bmap = 0;
3949	stp->st_deny_bmap = open_stp->st_deny_bmap;
3950	stp->st_openstp = open_stp;
3951
3952out:
3953	return stp;
3954}
3955
3956static int
3957check_lock_length(u64 offset, u64 length)
3958{
3959	return ((length == 0)  || ((length != NFS4_MAX_UINT64) &&
3960	     LOFF_OVERFLOW(offset, length)));
3961}
3962
3963static void get_lock_access(struct nfs4_stateid *lock_stp, u32 access)
3964{
3965	struct nfs4_file *fp = lock_stp->st_file;
3966	int oflag = nfs4_access_to_omode(access);
3967
3968	if (test_bit(access, &lock_stp->st_access_bmap))
3969		return;
3970	nfs4_file_get_access(fp, oflag);
3971	__set_bit(access, &lock_stp->st_access_bmap);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3972}
3973
3974/*
3975 *  LOCK operation 
3976 */
3977__be32
3978nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3979	   struct nfsd4_lock *lock)
3980{
3981	struct nfs4_stateowner *open_sop = NULL;
3982	struct nfs4_stateowner *lock_sop = NULL;
3983	struct nfs4_stateid *lock_stp;
3984	struct nfs4_file *fp;
3985	struct file *filp = NULL;
3986	struct file_lock file_lock;
3987	struct file_lock conflock;
3988	__be32 status = 0;
3989	unsigned int strhashval;
 
3990	int err;
3991
3992	dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
3993		(long long) lock->lk_offset,
3994		(long long) lock->lk_length);
3995
3996	if (check_lock_length(lock->lk_offset, lock->lk_length))
3997		 return nfserr_inval;
3998
3999	if ((status = fh_verify(rqstp, &cstate->current_fh,
4000				S_IFREG, NFSD_MAY_LOCK))) {
4001		dprintk("NFSD: nfsd4_lock: permission denied!\n");
4002		return status;
4003	}
4004
4005	nfs4_lock_state();
4006
4007	if (lock->lk_is_new) {
4008		/*
4009		 * Client indicates that this is a new lockowner.
4010		 * Use open owner and open stateid to create lock owner and
4011		 * lock stateid.
4012		 */
4013		struct nfs4_stateid *open_stp = NULL;
4014		
 
 
 
 
 
 
4015		status = nfserr_stale_clientid;
4016		if (!nfsd4_has_session(cstate) &&
4017		    STALE_CLIENTID(&lock->lk_new_clientid))
4018			goto out;
4019
4020		/* validate and update open stateid and open seqid */
4021		status = nfs4_preprocess_seqid_op(cstate,
4022				        lock->lk_new_open_seqid,
4023		                        &lock->lk_new_open_stateid,
4024					OPEN_STATE,
4025		                        &lock->lk_replay_owner, &open_stp,
4026					lock);
4027		if (status)
4028			goto out;
4029		open_sop = lock->lk_replay_owner;
4030		/* create lockowner and lock stateid */
4031		fp = open_stp->st_file;
4032		strhashval = lock_ownerstr_hashval(fp->fi_inode, 
4033				open_sop->so_client->cl_clientid.cl_id, 
4034				&lock->v.new.owner);
4035		/* XXX: Do we need to check for duplicate stateowners on
4036		 * the same file, or should they just be allowed (and
4037		 * create new stateids)? */
4038		status = nfserr_resource;
4039		lock_sop = alloc_init_lock_stateowner(strhashval,
4040				open_sop->so_client, open_stp, lock);
4041		if (lock_sop == NULL)
4042			goto out;
4043		lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp);
4044		if (lock_stp == NULL)
 
4045			goto out;
4046	} else {
4047		/* lock (lock owner + lock stateid) already exists */
4048		status = nfs4_preprocess_seqid_op(cstate,
4049				       lock->lk_old_lock_seqid, 
4050				       &lock->lk_old_lock_stateid, 
4051				       LOCK_STATE,
4052				       &lock->lk_replay_owner, &lock_stp, lock);
4053		if (status)
4054			goto out;
4055		lock_sop = lock->lk_replay_owner;
4056		fp = lock_stp->st_file;
4057	}
4058	/* lock->lk_replay_owner and lock_stp have been created or found */
 
 
 
 
 
4059
4060	status = nfserr_grace;
4061	if (locks_in_grace() && !lock->lk_reclaim)
4062		goto out;
4063	status = nfserr_no_grace;
4064	if (!locks_in_grace() && lock->lk_reclaim)
4065		goto out;
4066
4067	locks_init_lock(&file_lock);
4068	switch (lock->lk_type) {
4069		case NFS4_READ_LT:
4070		case NFS4_READW_LT:
4071			filp = find_readable_file(lock_stp->st_file);
4072			if (filp)
4073				get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
4074			file_lock.fl_type = F_RDLCK;
4075			break;
4076		case NFS4_WRITE_LT:
4077		case NFS4_WRITEW_LT:
4078			filp = find_writeable_file(lock_stp->st_file);
4079			if (filp)
4080				get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
4081			file_lock.fl_type = F_WRLCK;
4082			break;
4083		default:
4084			status = nfserr_inval;
4085		goto out;
4086	}
4087	if (!filp) {
4088		status = nfserr_openmode;
4089		goto out;
4090	}
4091	file_lock.fl_owner = (fl_owner_t)lock_sop;
4092	file_lock.fl_pid = current->tgid;
4093	file_lock.fl_file = filp;
4094	file_lock.fl_flags = FL_POSIX;
4095	file_lock.fl_lmops = &nfsd_posix_mng_ops;
4096
4097	file_lock.fl_start = lock->lk_offset;
4098	file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
4099	nfs4_transform_lock_offset(&file_lock);
4100
4101	/*
4102	* Try to lock the file in the VFS.
4103	* Note: locks.c uses the BKL to protect the inode's lock list.
4104	*/
4105
4106	err = vfs_lock_file(filp, F_SETLK, &file_lock, &conflock);
4107	switch (-err) {
4108	case 0: /* success! */
4109		update_stateid(&lock_stp->st_stateid);
4110		memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid, 
4111				sizeof(stateid_t));
4112		status = 0;
4113		break;
4114	case (EAGAIN):		/* conflock holds conflicting lock */
4115		status = nfserr_denied;
4116		dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
4117		nfs4_set_lock_denied(&conflock, &lock->lk_denied);
4118		break;
4119	case (EDEADLK):
4120		status = nfserr_deadlock;
4121		break;
4122	default:        
4123		dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
4124		status = nfserr_resource;
4125		break;
4126	}
4127out:
4128	if (status && lock->lk_is_new && lock_sop)
4129		release_lockowner(lock_sop);
4130	if (lock->lk_replay_owner) {
4131		nfs4_get_stateowner(lock->lk_replay_owner);
4132		cstate->replay_owner = lock->lk_replay_owner;
4133	}
4134	nfs4_unlock_state();
4135	return status;
4136}
4137
4138/*
4139 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
4140 * so we do a temporary open here just to get an open file to pass to
4141 * vfs_test_lock.  (Arguably perhaps test_lock should be done with an
4142 * inode operation.)
4143 */
4144static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
4145{
4146	struct file *file;
4147	int err;
4148
4149	err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
4150	if (err)
4151		return err;
4152	err = vfs_test_lock(file, lock);
4153	nfsd_close(file);
4154	return err;
4155}
4156
4157/*
4158 * LOCKT operation
4159 */
4160__be32
4161nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4162	    struct nfsd4_lockt *lockt)
4163{
4164	struct inode *inode;
4165	struct file_lock file_lock;
4166	int error;
4167	__be32 status;
4168
4169	if (locks_in_grace())
4170		return nfserr_grace;
4171
4172	if (check_lock_length(lockt->lt_offset, lockt->lt_length))
4173		 return nfserr_inval;
4174
4175	lockt->lt_stateowner = NULL;
4176	nfs4_lock_state();
4177
4178	status = nfserr_stale_clientid;
4179	if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid))
4180		goto out;
4181
4182	if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) {
4183		dprintk("NFSD: nfsd4_lockt: fh_verify() failed!\n");
4184		if (status == nfserr_symlink)
4185			status = nfserr_inval;
4186		goto out;
4187	}
4188
4189	inode = cstate->current_fh.fh_dentry->d_inode;
4190	locks_init_lock(&file_lock);
4191	switch (lockt->lt_type) {
4192		case NFS4_READ_LT:
4193		case NFS4_READW_LT:
4194			file_lock.fl_type = F_RDLCK;
4195		break;
4196		case NFS4_WRITE_LT:
4197		case NFS4_WRITEW_LT:
4198			file_lock.fl_type = F_WRLCK;
4199		break;
4200		default:
4201			dprintk("NFSD: nfs4_lockt: bad lock type!\n");
4202			status = nfserr_inval;
4203		goto out;
4204	}
4205
4206	lockt->lt_stateowner = find_lockstateowner_str(inode,
4207			&lockt->lt_clientid, &lockt->lt_owner);
4208	if (lockt->lt_stateowner)
4209		file_lock.fl_owner = (fl_owner_t)lockt->lt_stateowner;
4210	file_lock.fl_pid = current->tgid;
4211	file_lock.fl_flags = FL_POSIX;
4212
4213	file_lock.fl_start = lockt->lt_offset;
4214	file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
4215
4216	nfs4_transform_lock_offset(&file_lock);
4217
4218	status = nfs_ok;
4219	error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
4220	if (error) {
4221		status = nfserrno(error);
4222		goto out;
4223	}
4224	if (file_lock.fl_type != F_UNLCK) {
4225		status = nfserr_denied;
4226		nfs4_set_lock_denied(&file_lock, &lockt->lt_denied);
4227	}
4228out:
4229	nfs4_unlock_state();
4230	return status;
4231}
4232
4233__be32
4234nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4235	    struct nfsd4_locku *locku)
4236{
4237	struct nfs4_stateid *stp;
4238	struct file *filp = NULL;
4239	struct file_lock file_lock;
4240	__be32 status;
4241	int err;
4242						        
4243	dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
4244		(long long) locku->lu_offset,
4245		(long long) locku->lu_length);
4246
4247	if (check_lock_length(locku->lu_offset, locku->lu_length))
4248		 return nfserr_inval;
4249
4250	nfs4_lock_state();
4251									        
4252	if ((status = nfs4_preprocess_seqid_op(cstate,
4253					locku->lu_seqid, 
4254					&locku->lu_stateid, 
4255					LOCK_STATE,
4256					&locku->lu_stateowner, &stp, NULL)))
4257		goto out;
4258
4259	filp = find_any_file(stp->st_file);
4260	if (!filp) {
4261		status = nfserr_lock_range;
4262		goto out;
4263	}
4264	BUG_ON(!filp);
4265	locks_init_lock(&file_lock);
4266	file_lock.fl_type = F_UNLCK;
4267	file_lock.fl_owner = (fl_owner_t) locku->lu_stateowner;
4268	file_lock.fl_pid = current->tgid;
4269	file_lock.fl_file = filp;
4270	file_lock.fl_flags = FL_POSIX; 
4271	file_lock.fl_lmops = &nfsd_posix_mng_ops;
4272	file_lock.fl_start = locku->lu_offset;
4273
4274	file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
4275	nfs4_transform_lock_offset(&file_lock);
4276
4277	/*
4278	*  Try to unlock the file in the VFS.
4279	*/
4280	err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL);
4281	if (err) {
4282		dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
4283		goto out_nfserr;
4284	}
4285	/*
4286	* OK, unlock succeeded; the only thing left to do is update the stateid.
4287	*/
4288	update_stateid(&stp->st_stateid);
4289	memcpy(&locku->lu_stateid, &stp->st_stateid, sizeof(stateid_t));
4290
4291out:
4292	if (locku->lu_stateowner) {
4293		nfs4_get_stateowner(locku->lu_stateowner);
4294		cstate->replay_owner = locku->lu_stateowner;
4295	}
4296	nfs4_unlock_state();
4297	return status;
4298
4299out_nfserr:
4300	status = nfserrno(err);
4301	goto out;
4302}
4303
4304/*
4305 * returns
4306 * 	1: locks held by lockowner
4307 * 	0: no locks held by lockowner
4308 */
4309static int
4310check_for_locks(struct nfs4_file *filp, struct nfs4_stateowner *lowner)
4311{
4312	struct file_lock **flpp;
4313	struct inode *inode = filp->fi_inode;
4314	int status = 0;
4315
4316	lock_flocks();
4317	for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
4318		if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
4319			status = 1;
4320			goto out;
4321		}
4322	}
4323out:
4324	unlock_flocks();
4325	return status;
4326}
4327
4328__be32
4329nfsd4_release_lockowner(struct svc_rqst *rqstp,
4330			struct nfsd4_compound_state *cstate,
4331			struct nfsd4_release_lockowner *rlockowner)
4332{
4333	clientid_t *clid = &rlockowner->rl_clientid;
4334	struct nfs4_stateowner *sop;
4335	struct nfs4_stateid *stp;
 
4336	struct xdr_netobj *owner = &rlockowner->rl_owner;
4337	struct list_head matches;
4338	int i;
4339	__be32 status;
4340
4341	dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
4342		clid->cl_boot, clid->cl_id);
4343
4344	/* XXX check for lease expiration */
4345
4346	status = nfserr_stale_clientid;
4347	if (STALE_CLIENTID(clid))
4348		return status;
4349
4350	nfs4_lock_state();
4351
4352	status = nfserr_locks_held;
4353	/* XXX: we're doing a linear search through all the lockowners.
4354	 * Yipes!  For now we'll just hope clients aren't really using
4355	 * release_lockowner much, but eventually we have to fix these
4356	 * data structures. */
4357	INIT_LIST_HEAD(&matches);
4358	for (i = 0; i < LOCK_HASH_SIZE; i++) {
4359		list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) {
4360			if (!same_owner_str(sop, owner, clid))
4361				continue;
4362			list_for_each_entry(stp, &sop->so_stateids,
4363					st_perstateowner) {
4364				if (check_for_locks(stp->st_file, sop))
4365					goto out;
4366				/* Note: so_perclient unused for lockowners,
4367				 * so it's OK to fool with here. */
4368				list_add(&sop->so_perclient, &matches);
4369			}
4370		}
4371	}
4372	/* Clients probably won't expect us to return with some (but not all)
4373	 * of the lockowner state released; so don't release any until all
4374	 * have been checked. */
4375	status = nfs_ok;
4376	while (!list_empty(&matches)) {
4377		sop = list_entry(matches.next, struct nfs4_stateowner,
4378								so_perclient);
4379		/* unhash_stateowner deletes so_perclient only
4380		 * for openowners. */
4381		list_del(&sop->so_perclient);
4382		release_lockowner(sop);
4383	}
4384out:
4385	nfs4_unlock_state();
4386	return status;
4387}
4388
4389static inline struct nfs4_client_reclaim *
4390alloc_reclaim(void)
4391{
4392	return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
4393}
4394
4395int
4396nfs4_has_reclaimed_state(const char *name, bool use_exchange_id)
4397{
4398	unsigned int strhashval = clientstr_hashval(name);
4399	struct nfs4_client *clp;
4400
4401	clp = find_confirmed_client_by_str(name, strhashval);
4402	return clp ? 1 : 0;
 
 
4403}
4404
4405/*
4406 * failure => all reset bets are off, nfserr_no_grace...
4407 */
4408int
4409nfs4_client_to_reclaim(const char *name)
4410{
4411	unsigned int strhashval;
4412	struct nfs4_client_reclaim *crp = NULL;
4413
4414	dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
4415	crp = alloc_reclaim();
4416	if (!crp)
4417		return 0;
4418	strhashval = clientstr_hashval(name);
4419	INIT_LIST_HEAD(&crp->cr_strhash);
4420	list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
4421	memcpy(crp->cr_recdir, name, HEXDIR_LEN);
4422	reclaim_str_hashtbl_size++;
4423	return 1;
4424}
4425
4426static void
4427nfs4_release_reclaim(void)
4428{
4429	struct nfs4_client_reclaim *crp = NULL;
4430	int i;
4431
4432	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4433		while (!list_empty(&reclaim_str_hashtbl[i])) {
4434			crp = list_entry(reclaim_str_hashtbl[i].next,
4435			                struct nfs4_client_reclaim, cr_strhash);
4436			list_del(&crp->cr_strhash);
4437			kfree(crp);
4438			reclaim_str_hashtbl_size--;
4439		}
4440	}
4441	BUG_ON(reclaim_str_hashtbl_size);
4442}
4443
4444/*
4445 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
4446static struct nfs4_client_reclaim *
4447nfs4_find_reclaim_client(clientid_t *clid)
4448{
4449	unsigned int strhashval;
4450	struct nfs4_client *clp;
4451	struct nfs4_client_reclaim *crp = NULL;
4452
4453
4454	/* find clientid in conf_id_hashtbl */
4455	clp = find_confirmed_client(clid);
4456	if (clp == NULL)
4457		return NULL;
4458
4459	dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
4460		            clp->cl_name.len, clp->cl_name.data,
4461			    clp->cl_recdir);
4462
4463	/* find clp->cl_name in reclaim_str_hashtbl */
4464	strhashval = clientstr_hashval(clp->cl_recdir);
4465	list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
4466		if (same_name(crp->cr_recdir, clp->cl_recdir)) {
4467			return crp;
4468		}
4469	}
4470	return NULL;
4471}
4472
4473/*
4474* Called from OPEN. Look for clientid in reclaim list.
4475*/
4476__be32
4477nfs4_check_open_reclaim(clientid_t *clid)
4478{
4479	return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4480}
4481
 
 
4482/* initialization to perform at module load time: */
4483
4484int
4485nfs4_state_init(void)
4486{
4487	int i, status;
4488
4489	status = nfsd4_init_slabs();
4490	if (status)
4491		return status;
4492	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4493		INIT_LIST_HEAD(&conf_id_hashtbl[i]);
4494		INIT_LIST_HEAD(&conf_str_hashtbl[i]);
4495		INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
4496		INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
4497		INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
4498	}
4499	for (i = 0; i < SESSION_HASH_SIZE; i++)
4500		INIT_LIST_HEAD(&sessionid_hashtbl[i]);
4501	for (i = 0; i < FILE_HASH_SIZE; i++) {
4502		INIT_LIST_HEAD(&file_hashtbl[i]);
4503	}
4504	for (i = 0; i < OWNER_HASH_SIZE; i++) {
4505		INIT_LIST_HEAD(&ownerstr_hashtbl[i]);
4506		INIT_LIST_HEAD(&ownerid_hashtbl[i]);
4507	}
4508	for (i = 0; i < STATEID_HASH_SIZE; i++) {
4509		INIT_LIST_HEAD(&stateid_hashtbl[i]);
4510		INIT_LIST_HEAD(&lockstateid_hashtbl[i]);
4511	}
4512	for (i = 0; i < LOCK_HASH_SIZE; i++) {
4513		INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]);
4514		INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]);
4515	}
4516	memset(&onestateid, ~0, sizeof(stateid_t));
4517	INIT_LIST_HEAD(&close_lru);
4518	INIT_LIST_HEAD(&client_lru);
4519	INIT_LIST_HEAD(&del_recall_lru);
4520	reclaim_str_hashtbl_size = 0;
4521	return 0;
4522}
4523
4524static void
4525nfsd4_load_reboot_recovery_data(void)
4526{
4527	int status;
4528
4529	nfs4_lock_state();
4530	nfsd4_init_recdir(user_recovery_dirname);
4531	status = nfsd4_recdir_load();
4532	nfs4_unlock_state();
4533	if (status)
4534		printk("NFSD: Failure reading reboot recovery data\n");
4535}
4536
4537/*
4538 * Since the lifetime of a delegation isn't limited to that of an open, a
4539 * client may quite reasonably hang on to a delegation as long as it has
4540 * the inode cached.  This becomes an obvious problem the first time a
4541 * client's inode cache approaches the size of the server's total memory.
4542 *
4543 * For now we avoid this problem by imposing a hard limit on the number
4544 * of delegations, which varies according to the server's memory size.
4545 */
4546static void
4547set_max_delegations(void)
4548{
4549	/*
4550	 * Allow at most 4 delegations per megabyte of RAM.  Quick
4551	 * estimates suggest that in the worst case (where every delegation
4552	 * is for a different inode), a delegation could take about 1.5K,
4553	 * giving a worst case usage of about 6% of memory.
4554	 */
4555	max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4556}
4557
4558/* initialization to perform when the nfsd service is started: */
4559
4560static int
4561__nfs4_state_start(void)
4562{
4563	int ret;
4564
 
 
 
 
 
 
 
 
 
4565	boot_time = get_seconds();
4566	locks_start_grace(&nfsd4_manager);
 
4567	printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
4568	       nfsd4_grace);
4569	ret = set_callback_cred();
4570	if (ret)
4571		return -ENOMEM;
 
 
4572	laundry_wq = create_singlethread_workqueue("nfsd4");
4573	if (laundry_wq == NULL)
4574		return -ENOMEM;
 
 
4575	ret = nfsd4_create_callback_queue();
4576	if (ret)
4577		goto out_free_laundry;
4578	queue_delayed_work(laundry_wq, &laundromat_work, nfsd4_grace * HZ);
4579	set_max_delegations();
4580	return 0;
4581out_free_laundry:
4582	destroy_workqueue(laundry_wq);
 
 
 
4583	return ret;
4584}
4585
4586int
4587nfs4_state_start(void)
4588{
4589	nfsd4_load_reboot_recovery_data();
4590	return __nfs4_state_start();
4591}
4592
4593static void
4594__nfs4_state_shutdown(void)
4595{
4596	int i;
4597	struct nfs4_client *clp = NULL;
4598	struct nfs4_delegation *dp = NULL;
4599	struct list_head *pos, *next, reaplist;
4600
4601	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4602		while (!list_empty(&conf_id_hashtbl[i])) {
4603			clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
4604			expire_client(clp);
4605		}
4606		while (!list_empty(&unconf_str_hashtbl[i])) {
4607			clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
4608			expire_client(clp);
4609		}
4610	}
4611	INIT_LIST_HEAD(&reaplist);
4612	spin_lock(&recall_lock);
4613	list_for_each_safe(pos, next, &del_recall_lru) {
4614		dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4615		list_move(&dp->dl_recall_lru, &reaplist);
4616	}
4617	spin_unlock(&recall_lock);
4618	list_for_each_safe(pos, next, &reaplist) {
4619		dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4620		list_del_init(&dp->dl_recall_lru);
4621		unhash_delegation(dp);
4622	}
4623
4624	nfsd4_shutdown_recdir();
 
4625}
4626
4627void
4628nfs4_state_shutdown(void)
4629{
4630	cancel_delayed_work_sync(&laundromat_work);
4631	destroy_workqueue(laundry_wq);
4632	locks_end_grace(&nfsd4_manager);
4633	nfs4_lock_state();
4634	nfs4_release_reclaim();
4635	__nfs4_state_shutdown();
4636	nfs4_unlock_state();
4637	nfsd4_destroy_callback_queue();
4638}
4639
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4640/*
4641 * user_recovery_dirname is protected by the nfsd_mutex since it's only
4642 * accessed when nfsd is starting.
4643 */
4644static void
4645nfs4_set_recdir(char *recdir)
 
 
 
 
 
 
 
 
 
 
 
 
4646{
4647	strcpy(user_recovery_dirname, recdir);
 
 
 
 
 
 
4648}
4649
4650/*
4651 * Change the NFSv4 recovery directory to recdir.
4652 */
4653int
4654nfs4_reset_recoverydir(char *recdir)
 
4655{
4656	int status;
4657	struct path path;
4658
4659	status = kern_path(recdir, LOOKUP_FOLLOW, &path);
4660	if (status)
4661		return status;
4662	status = -ENOTDIR;
4663	if (S_ISDIR(path.dentry->d_inode->i_mode)) {
4664		nfs4_set_recdir(recdir);
4665		status = 0;
4666	}
4667	path_put(&path);
4668	return status;
4669}
4670
4671char *
4672nfs4_recoverydir(void)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4673{
4674	return user_recovery_dirname;
4675}