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