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/ratelimit.h>
  42#include <linux/sunrpc/svcauth_gss.h>
  43#include <linux/sunrpc/addr.h>
  44#include <linux/jhash.h>
 
  45#include "xdr4.h"
  46#include "xdr4cb.h"
  47#include "vfs.h"
  48#include "current_stateid.h"
  49
  50#include "netns.h"
  51#include "pnfs.h"
 
 
  52
  53#define NFSDDBG_FACILITY                NFSDDBG_PROC
  54
  55#define all_ones {{~0,~0},~0}
  56static const stateid_t one_stateid = {
  57	.si_generation = ~0,
  58	.si_opaque = all_ones,
  59};
  60static const stateid_t zero_stateid = {
  61	/* all fields zero */
  62};
  63static const stateid_t currentstateid = {
  64	.si_generation = 1,
  65};
 
 
 
  66
  67static u64 current_sessionid = 1;
  68
  69#define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
  70#define ONE_STATEID(stateid)  (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
  71#define CURRENT_STATEID(stateid) (!memcmp((stateid), &currentstateid, sizeof(stateid_t)))
 
  72
  73/* forward declarations */
  74static bool check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner);
  75static void nfs4_free_ol_stateid(struct nfs4_stid *stid);
 
 
  76
  77/* Locking: */
  78
  79/*
  80 * Currently used for the del_recall_lru and file hash table.  In an
  81 * effort to decrease the scope of the client_mutex, this spinlock may
  82 * eventually cover more:
  83 */
  84static DEFINE_SPINLOCK(state_lock);
  85
 
 
 
 
 
  86/*
  87 * A waitqueue for all in-progress 4.0 CLOSE operations that are waiting for
  88 * the refcount on the open stateid to drop.
  89 */
  90static DECLARE_WAIT_QUEUE_HEAD(close_wq);
  91
 
 
 
 
 
 
 
 
  92static struct kmem_cache *openowner_slab;
  93static struct kmem_cache *lockowner_slab;
  94static struct kmem_cache *file_slab;
  95static struct kmem_cache *stateid_slab;
  96static struct kmem_cache *deleg_slab;
  97static struct kmem_cache *odstate_slab;
  98
  99static void free_session(struct nfsd4_session *);
 100
 101static const struct nfsd4_callback_ops nfsd4_cb_recall_ops;
 102static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops;
 103
 104static bool is_session_dead(struct nfsd4_session *ses)
 105{
 106	return ses->se_flags & NFS4_SESSION_DEAD;
 107}
 108
 109static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me)
 110{
 111	if (atomic_read(&ses->se_ref) > ref_held_by_me)
 112		return nfserr_jukebox;
 113	ses->se_flags |= NFS4_SESSION_DEAD;
 114	return nfs_ok;
 115}
 116
 117static bool is_client_expired(struct nfs4_client *clp)
 118{
 119	return clp->cl_time == 0;
 120}
 121
 122static __be32 get_client_locked(struct nfs4_client *clp)
 123{
 124	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
 125
 126	lockdep_assert_held(&nn->client_lock);
 127
 128	if (is_client_expired(clp))
 129		return nfserr_expired;
 130	atomic_inc(&clp->cl_refcount);
 131	return nfs_ok;
 132}
 133
 134/* must be called under the client_lock */
 135static inline void
 136renew_client_locked(struct nfs4_client *clp)
 137{
 138	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
 139
 140	if (is_client_expired(clp)) {
 141		WARN_ON(1);
 142		printk("%s: client (clientid %08x/%08x) already expired\n",
 143			__func__,
 144			clp->cl_clientid.cl_boot,
 145			clp->cl_clientid.cl_id);
 146		return;
 147	}
 148
 149	dprintk("renewing client (clientid %08x/%08x)\n",
 150			clp->cl_clientid.cl_boot,
 151			clp->cl_clientid.cl_id);
 152	list_move_tail(&clp->cl_lru, &nn->client_lru);
 153	clp->cl_time = get_seconds();
 154}
 155
 156static void put_client_renew_locked(struct nfs4_client *clp)
 157{
 158	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
 159
 160	lockdep_assert_held(&nn->client_lock);
 161
 162	if (!atomic_dec_and_test(&clp->cl_refcount))
 163		return;
 164	if (!is_client_expired(clp))
 165		renew_client_locked(clp);
 
 
 166}
 167
 168static void put_client_renew(struct nfs4_client *clp)
 169{
 170	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
 171
 172	if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock))
 173		return;
 174	if (!is_client_expired(clp))
 175		renew_client_locked(clp);
 
 
 176	spin_unlock(&nn->client_lock);
 177}
 178
 179static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
 180{
 181	__be32 status;
 182
 183	if (is_session_dead(ses))
 184		return nfserr_badsession;
 185	status = get_client_locked(ses->se_client);
 186	if (status)
 187		return status;
 188	atomic_inc(&ses->se_ref);
 189	return nfs_ok;
 190}
 191
 192static void nfsd4_put_session_locked(struct nfsd4_session *ses)
 193{
 194	struct nfs4_client *clp = ses->se_client;
 195	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
 196
 197	lockdep_assert_held(&nn->client_lock);
 198
 199	if (atomic_dec_and_test(&ses->se_ref) && is_session_dead(ses))
 200		free_session(ses);
 201	put_client_renew_locked(clp);
 202}
 203
 204static void nfsd4_put_session(struct nfsd4_session *ses)
 205{
 206	struct nfs4_client *clp = ses->se_client;
 207	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
 208
 209	spin_lock(&nn->client_lock);
 210	nfsd4_put_session_locked(ses);
 211	spin_unlock(&nn->client_lock);
 212}
 213
 214static struct nfsd4_blocked_lock *
 215find_blocked_lock(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
 216			struct nfsd_net *nn)
 217{
 218	struct nfsd4_blocked_lock *cur, *found = NULL;
 219
 220	spin_lock(&nn->blocked_locks_lock);
 221	list_for_each_entry(cur, &lo->lo_blocked, nbl_list) {
 222		if (fh_match(fh, &cur->nbl_fh)) {
 223			list_del_init(&cur->nbl_list);
 224			list_del_init(&cur->nbl_lru);
 225			found = cur;
 226			break;
 227		}
 228	}
 229	spin_unlock(&nn->blocked_locks_lock);
 230	if (found)
 231		posix_unblock_lock(&found->nbl_lock);
 232	return found;
 233}
 234
 235static struct nfsd4_blocked_lock *
 236find_or_allocate_block(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
 237			struct nfsd_net *nn)
 238{
 239	struct nfsd4_blocked_lock *nbl;
 240
 241	nbl = find_blocked_lock(lo, fh, nn);
 242	if (!nbl) {
 243		nbl= kmalloc(sizeof(*nbl), GFP_KERNEL);
 244		if (nbl) {
 
 
 245			fh_copy_shallow(&nbl->nbl_fh, fh);
 246			locks_init_lock(&nbl->nbl_lock);
 247			nfsd4_init_cb(&nbl->nbl_cb, lo->lo_owner.so_client,
 248					&nfsd4_cb_notify_lock_ops,
 249					NFSPROC4_CLNT_CB_NOTIFY_LOCK);
 250		}
 251	}
 252	return nbl;
 253}
 254
 255static void
 256free_blocked_lock(struct nfsd4_blocked_lock *nbl)
 257{
 
 258	locks_release_private(&nbl->nbl_lock);
 259	kfree(nbl);
 260}
 261
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 262static int
 263nfsd4_cb_notify_lock_done(struct nfsd4_callback *cb, struct rpc_task *task)
 264{
 265	/*
 266	 * Since this is just an optimization, we don't try very hard if it
 267	 * turns out not to succeed. We'll requeue it on NFS4ERR_DELAY, and
 268	 * just quit trying on anything else.
 269	 */
 270	switch (task->tk_status) {
 271	case -NFS4ERR_DELAY:
 272		rpc_delay(task, 1 * HZ);
 273		return 0;
 274	default:
 275		return 1;
 276	}
 277}
 278
 279static void
 280nfsd4_cb_notify_lock_release(struct nfsd4_callback *cb)
 281{
 282	struct nfsd4_blocked_lock	*nbl = container_of(cb,
 283						struct nfsd4_blocked_lock, nbl_cb);
 284
 285	free_blocked_lock(nbl);
 286}
 287
 288static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops = {
 
 289	.done		= nfsd4_cb_notify_lock_done,
 290	.release	= nfsd4_cb_notify_lock_release,
 291};
 292
 293static inline struct nfs4_stateowner *
 294nfs4_get_stateowner(struct nfs4_stateowner *sop)
 295{
 296	atomic_inc(&sop->so_count);
 297	return sop;
 298}
 299
 300static int
 301same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner)
 302{
 303	return (sop->so_owner.len == owner->len) &&
 304		0 == memcmp(sop->so_owner.data, owner->data, owner->len);
 305}
 306
 307static struct nfs4_openowner *
 308find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open,
 309			struct nfs4_client *clp)
 310{
 311	struct nfs4_stateowner *so;
 312
 313	lockdep_assert_held(&clp->cl_lock);
 314
 315	list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[hashval],
 316			    so_strhash) {
 317		if (!so->so_is_open_owner)
 318			continue;
 319		if (same_owner_str(so, &open->op_owner))
 320			return openowner(nfs4_get_stateowner(so));
 321	}
 322	return NULL;
 323}
 324
 325static struct nfs4_openowner *
 326find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
 327			struct nfs4_client *clp)
 328{
 329	struct nfs4_openowner *oo;
 330
 331	spin_lock(&clp->cl_lock);
 332	oo = find_openstateowner_str_locked(hashval, open, clp);
 333	spin_unlock(&clp->cl_lock);
 334	return oo;
 335}
 336
 337static inline u32
 338opaque_hashval(const void *ptr, int nbytes)
 339{
 340	unsigned char *cptr = (unsigned char *) ptr;
 341
 342	u32 x = 0;
 343	while (nbytes--) {
 344		x *= 37;
 345		x += *cptr++;
 346	}
 347	return x;
 348}
 349
 350static void nfsd4_free_file_rcu(struct rcu_head *rcu)
 351{
 352	struct nfs4_file *fp = container_of(rcu, struct nfs4_file, fi_rcu);
 353
 354	kmem_cache_free(file_slab, fp);
 355}
 356
 357void
 358put_nfs4_file(struct nfs4_file *fi)
 359{
 360	might_lock(&state_lock);
 361
 362	if (atomic_dec_and_lock(&fi->fi_ref, &state_lock)) {
 363		hlist_del_rcu(&fi->fi_hash);
 364		spin_unlock(&state_lock);
 365		WARN_ON_ONCE(!list_empty(&fi->fi_clnt_odstate));
 366		WARN_ON_ONCE(!list_empty(&fi->fi_delegations));
 367		call_rcu(&fi->fi_rcu, nfsd4_free_file_rcu);
 368	}
 369}
 370
 371static struct file *
 372__nfs4_get_fd(struct nfs4_file *f, int oflag)
 373{
 374	if (f->fi_fds[oflag])
 375		return get_file(f->fi_fds[oflag]);
 376	return NULL;
 377}
 378
 379static struct file *
 380find_writeable_file_locked(struct nfs4_file *f)
 381{
 382	struct file *ret;
 383
 384	lockdep_assert_held(&f->fi_lock);
 385
 386	ret = __nfs4_get_fd(f, O_WRONLY);
 387	if (!ret)
 388		ret = __nfs4_get_fd(f, O_RDWR);
 389	return ret;
 390}
 391
 392static struct file *
 393find_writeable_file(struct nfs4_file *f)
 394{
 395	struct file *ret;
 396
 397	spin_lock(&f->fi_lock);
 398	ret = find_writeable_file_locked(f);
 399	spin_unlock(&f->fi_lock);
 400
 401	return ret;
 402}
 403
 404static struct file *find_readable_file_locked(struct nfs4_file *f)
 
 405{
 406	struct file *ret;
 407
 408	lockdep_assert_held(&f->fi_lock);
 409
 410	ret = __nfs4_get_fd(f, O_RDONLY);
 411	if (!ret)
 412		ret = __nfs4_get_fd(f, O_RDWR);
 413	return ret;
 414}
 415
 416static struct file *
 417find_readable_file(struct nfs4_file *f)
 418{
 419	struct file *ret;
 420
 421	spin_lock(&f->fi_lock);
 422	ret = find_readable_file_locked(f);
 423	spin_unlock(&f->fi_lock);
 424
 425	return ret;
 426}
 427
 428struct file *
 429find_any_file(struct nfs4_file *f)
 430{
 431	struct file *ret;
 432
 
 
 433	spin_lock(&f->fi_lock);
 434	ret = __nfs4_get_fd(f, O_RDWR);
 435	if (!ret) {
 436		ret = __nfs4_get_fd(f, O_WRONLY);
 437		if (!ret)
 438			ret = __nfs4_get_fd(f, O_RDONLY);
 439	}
 440	spin_unlock(&f->fi_lock);
 441	return ret;
 442}
 443
 
 
 
 
 
 
 
 
 
 
 
 444static atomic_long_t num_delegations;
 445unsigned long max_delegations;
 446
 447/*
 448 * Open owner state (share locks)
 449 */
 450
 451/* hash tables for lock and open owners */
 452#define OWNER_HASH_BITS              8
 453#define OWNER_HASH_SIZE             (1 << OWNER_HASH_BITS)
 454#define OWNER_HASH_MASK             (OWNER_HASH_SIZE - 1)
 455
 456static unsigned int ownerstr_hashval(struct xdr_netobj *ownername)
 457{
 458	unsigned int ret;
 459
 460	ret = opaque_hashval(ownername->data, ownername->len);
 461	return ret & OWNER_HASH_MASK;
 462}
 463
 464/* hash table for nfs4_file */
 465#define FILE_HASH_BITS                   8
 466#define FILE_HASH_SIZE                  (1 << FILE_HASH_BITS)
 467
 468static unsigned int nfsd_fh_hashval(struct knfsd_fh *fh)
 469{
 470	return jhash2(fh->fh_base.fh_pad, XDR_QUADLEN(fh->fh_size), 0);
 471}
 472
 473static unsigned int file_hashval(struct knfsd_fh *fh)
 474{
 475	return nfsd_fh_hashval(fh) & (FILE_HASH_SIZE - 1);
 476}
 477
 478static struct hlist_head file_hashtbl[FILE_HASH_SIZE];
 479
 480static void
 481__nfs4_file_get_access(struct nfs4_file *fp, u32 access)
 482{
 483	lockdep_assert_held(&fp->fi_lock);
 484
 485	if (access & NFS4_SHARE_ACCESS_WRITE)
 486		atomic_inc(&fp->fi_access[O_WRONLY]);
 487	if (access & NFS4_SHARE_ACCESS_READ)
 488		atomic_inc(&fp->fi_access[O_RDONLY]);
 489}
 490
 491static __be32
 492nfs4_file_get_access(struct nfs4_file *fp, u32 access)
 493{
 494	lockdep_assert_held(&fp->fi_lock);
 495
 496	/* Does this access mode make sense? */
 497	if (access & ~NFS4_SHARE_ACCESS_BOTH)
 498		return nfserr_inval;
 499
 500	/* Does it conflict with a deny mode already set? */
 501	if ((access & fp->fi_share_deny) != 0)
 502		return nfserr_share_denied;
 503
 504	__nfs4_file_get_access(fp, access);
 505	return nfs_ok;
 506}
 507
 508static __be32 nfs4_file_check_deny(struct nfs4_file *fp, u32 deny)
 509{
 510	/* Common case is that there is no deny mode. */
 511	if (deny) {
 512		/* Does this deny mode make sense? */
 513		if (deny & ~NFS4_SHARE_DENY_BOTH)
 514			return nfserr_inval;
 515
 516		if ((deny & NFS4_SHARE_DENY_READ) &&
 517		    atomic_read(&fp->fi_access[O_RDONLY]))
 518			return nfserr_share_denied;
 519
 520		if ((deny & NFS4_SHARE_DENY_WRITE) &&
 521		    atomic_read(&fp->fi_access[O_WRONLY]))
 522			return nfserr_share_denied;
 523	}
 524	return nfs_ok;
 525}
 526
 527static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
 528{
 529	might_lock(&fp->fi_lock);
 530
 531	if (atomic_dec_and_lock(&fp->fi_access[oflag], &fp->fi_lock)) {
 532		struct file *f1 = NULL;
 533		struct file *f2 = NULL;
 534
 535		swap(f1, fp->fi_fds[oflag]);
 536		if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
 537			swap(f2, fp->fi_fds[O_RDWR]);
 538		spin_unlock(&fp->fi_lock);
 539		if (f1)
 540			fput(f1);
 541		if (f2)
 542			fput(f2);
 543	}
 544}
 545
 546static void nfs4_file_put_access(struct nfs4_file *fp, u32 access)
 547{
 548	WARN_ON_ONCE(access & ~NFS4_SHARE_ACCESS_BOTH);
 549
 550	if (access & NFS4_SHARE_ACCESS_WRITE)
 551		__nfs4_file_put_access(fp, O_WRONLY);
 552	if (access & NFS4_SHARE_ACCESS_READ)
 553		__nfs4_file_put_access(fp, O_RDONLY);
 554}
 555
 556/*
 557 * Allocate a new open/delegation state counter. This is needed for
 558 * pNFS for proper return on close semantics.
 559 *
 560 * Note that we only allocate it for pNFS-enabled exports, otherwise
 561 * all pointers to struct nfs4_clnt_odstate are always NULL.
 562 */
 563static struct nfs4_clnt_odstate *
 564alloc_clnt_odstate(struct nfs4_client *clp)
 565{
 566	struct nfs4_clnt_odstate *co;
 567
 568	co = kmem_cache_zalloc(odstate_slab, GFP_KERNEL);
 569	if (co) {
 570		co->co_client = clp;
 571		atomic_set(&co->co_odcount, 1);
 572	}
 573	return co;
 574}
 575
 576static void
 577hash_clnt_odstate_locked(struct nfs4_clnt_odstate *co)
 578{
 579	struct nfs4_file *fp = co->co_file;
 580
 581	lockdep_assert_held(&fp->fi_lock);
 582	list_add(&co->co_perfile, &fp->fi_clnt_odstate);
 583}
 584
 585static inline void
 586get_clnt_odstate(struct nfs4_clnt_odstate *co)
 587{
 588	if (co)
 589		atomic_inc(&co->co_odcount);
 590}
 591
 592static void
 593put_clnt_odstate(struct nfs4_clnt_odstate *co)
 594{
 595	struct nfs4_file *fp;
 596
 597	if (!co)
 598		return;
 599
 600	fp = co->co_file;
 601	if (atomic_dec_and_lock(&co->co_odcount, &fp->fi_lock)) {
 602		list_del(&co->co_perfile);
 603		spin_unlock(&fp->fi_lock);
 604
 605		nfsd4_return_all_file_layouts(co->co_client, fp);
 606		kmem_cache_free(odstate_slab, co);
 607	}
 608}
 609
 610static struct nfs4_clnt_odstate *
 611find_or_hash_clnt_odstate(struct nfs4_file *fp, struct nfs4_clnt_odstate *new)
 612{
 613	struct nfs4_clnt_odstate *co;
 614	struct nfs4_client *cl;
 615
 616	if (!new)
 617		return NULL;
 618
 619	cl = new->co_client;
 620
 621	spin_lock(&fp->fi_lock);
 622	list_for_each_entry(co, &fp->fi_clnt_odstate, co_perfile) {
 623		if (co->co_client == cl) {
 624			get_clnt_odstate(co);
 625			goto out;
 626		}
 627	}
 628	co = new;
 629	co->co_file = fp;
 630	hash_clnt_odstate_locked(new);
 631out:
 632	spin_unlock(&fp->fi_lock);
 633	return co;
 634}
 635
 636struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab,
 637				  void (*sc_free)(struct nfs4_stid *))
 638{
 639	struct nfs4_stid *stid;
 640	int new_id;
 641
 642	stid = kmem_cache_zalloc(slab, GFP_KERNEL);
 643	if (!stid)
 644		return NULL;
 645
 646	idr_preload(GFP_KERNEL);
 647	spin_lock(&cl->cl_lock);
 648	new_id = idr_alloc_cyclic(&cl->cl_stateids, stid, 0, 0, GFP_NOWAIT);
 
 649	spin_unlock(&cl->cl_lock);
 650	idr_preload_end();
 651	if (new_id < 0)
 652		goto out_free;
 653
 654	stid->sc_free = sc_free;
 655	stid->sc_client = cl;
 656	stid->sc_stateid.si_opaque.so_id = new_id;
 657	stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
 658	/* Will be incremented before return to client: */
 659	atomic_set(&stid->sc_count, 1);
 660	spin_lock_init(&stid->sc_lock);
 
 661
 662	/*
 663	 * It shouldn't be a problem to reuse an opaque stateid value.
 664	 * I don't think it is for 4.1.  But with 4.0 I worry that, for
 665	 * example, a stray write retransmission could be accepted by
 666	 * the server when it should have been rejected.  Therefore,
 667	 * adopt a trick from the sctp code to attempt to maximize the
 668	 * amount of time until an id is reused, by ensuring they always
 669	 * "increase" (mod INT_MAX):
 670	 */
 671	return stid;
 672out_free:
 673	kmem_cache_free(slab, stid);
 674	return NULL;
 675}
 676
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 677static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp)
 678{
 679	struct nfs4_stid *stid;
 680
 681	stid = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_ol_stateid);
 682	if (!stid)
 683		return NULL;
 684
 685	return openlockstateid(stid);
 686}
 687
 688static void nfs4_free_deleg(struct nfs4_stid *stid)
 689{
 690	kmem_cache_free(deleg_slab, stid);
 691	atomic_long_dec(&num_delegations);
 692}
 693
 694/*
 695 * When we recall a delegation, we should be careful not to hand it
 696 * out again straight away.
 697 * To ensure this we keep a pair of bloom filters ('new' and 'old')
 698 * in which the filehandles of recalled delegations are "stored".
 699 * If a filehandle appear in either filter, a delegation is blocked.
 700 * When a delegation is recalled, the filehandle is stored in the "new"
 701 * filter.
 702 * Every 30 seconds we swap the filters and clear the "new" one,
 703 * unless both are empty of course.
 704 *
 705 * Each filter is 256 bits.  We hash the filehandle to 32bit and use the
 706 * low 3 bytes as hash-table indices.
 707 *
 708 * 'blocked_delegations_lock', which is always taken in block_delegations(),
 709 * is used to manage concurrent access.  Testing does not need the lock
 710 * except when swapping the two filters.
 711 */
 712static DEFINE_SPINLOCK(blocked_delegations_lock);
 713static struct bloom_pair {
 714	int	entries, old_entries;
 715	time_t	swap_time;
 716	int	new; /* index into 'set' */
 717	DECLARE_BITMAP(set[2], 256);
 718} blocked_delegations;
 719
 720static int delegation_blocked(struct knfsd_fh *fh)
 721{
 722	u32 hash;
 723	struct bloom_pair *bd = &blocked_delegations;
 724
 725	if (bd->entries == 0)
 726		return 0;
 727	if (seconds_since_boot() - bd->swap_time > 30) {
 728		spin_lock(&blocked_delegations_lock);
 729		if (seconds_since_boot() - bd->swap_time > 30) {
 730			bd->entries -= bd->old_entries;
 731			bd->old_entries = bd->entries;
 732			memset(bd->set[bd->new], 0,
 733			       sizeof(bd->set[0]));
 734			bd->new = 1-bd->new;
 735			bd->swap_time = seconds_since_boot();
 736		}
 737		spin_unlock(&blocked_delegations_lock);
 738	}
 739	hash = jhash(&fh->fh_base, fh->fh_size, 0);
 740	if (test_bit(hash&255, bd->set[0]) &&
 741	    test_bit((hash>>8)&255, bd->set[0]) &&
 742	    test_bit((hash>>16)&255, bd->set[0]))
 743		return 1;
 744
 745	if (test_bit(hash&255, bd->set[1]) &&
 746	    test_bit((hash>>8)&255, bd->set[1]) &&
 747	    test_bit((hash>>16)&255, bd->set[1]))
 748		return 1;
 749
 750	return 0;
 751}
 752
 753static void block_delegations(struct knfsd_fh *fh)
 754{
 755	u32 hash;
 756	struct bloom_pair *bd = &blocked_delegations;
 757
 758	hash = jhash(&fh->fh_base, fh->fh_size, 0);
 759
 760	spin_lock(&blocked_delegations_lock);
 761	__set_bit(hash&255, bd->set[bd->new]);
 762	__set_bit((hash>>8)&255, bd->set[bd->new]);
 763	__set_bit((hash>>16)&255, bd->set[bd->new]);
 764	if (bd->entries == 0)
 765		bd->swap_time = seconds_since_boot();
 766	bd->entries += 1;
 767	spin_unlock(&blocked_delegations_lock);
 768}
 769
 770static struct nfs4_delegation *
 771alloc_init_deleg(struct nfs4_client *clp, struct svc_fh *current_fh,
 
 772		 struct nfs4_clnt_odstate *odstate)
 773{
 774	struct nfs4_delegation *dp;
 775	long n;
 776
 777	dprintk("NFSD alloc_init_deleg\n");
 778	n = atomic_long_inc_return(&num_delegations);
 779	if (n < 0 || n > max_delegations)
 780		goto out_dec;
 781	if (delegation_blocked(&current_fh->fh_handle))
 782		goto out_dec;
 783	dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab, nfs4_free_deleg));
 784	if (dp == NULL)
 785		goto out_dec;
 786
 787	/*
 788	 * delegation seqid's are never incremented.  The 4.1 special
 789	 * meaning of seqid 0 isn't meaningful, really, but let's avoid
 790	 * 0 anyway just for consistency and use 1:
 791	 */
 792	dp->dl_stid.sc_stateid.si_generation = 1;
 793	INIT_LIST_HEAD(&dp->dl_perfile);
 794	INIT_LIST_HEAD(&dp->dl_perclnt);
 795	INIT_LIST_HEAD(&dp->dl_recall_lru);
 796	dp->dl_clnt_odstate = odstate;
 797	get_clnt_odstate(odstate);
 798	dp->dl_type = NFS4_OPEN_DELEGATE_READ;
 799	dp->dl_retries = 1;
 800	nfsd4_init_cb(&dp->dl_recall, dp->dl_stid.sc_client,
 801		      &nfsd4_cb_recall_ops, NFSPROC4_CLNT_CB_RECALL);
 
 
 802	return dp;
 803out_dec:
 804	atomic_long_dec(&num_delegations);
 805	return NULL;
 806}
 807
 808void
 809nfs4_put_stid(struct nfs4_stid *s)
 810{
 811	struct nfs4_file *fp = s->sc_file;
 812	struct nfs4_client *clp = s->sc_client;
 813
 814	might_lock(&clp->cl_lock);
 815
 816	if (!atomic_dec_and_lock(&s->sc_count, &clp->cl_lock)) {
 817		wake_up_all(&close_wq);
 818		return;
 819	}
 820	idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
 
 821	spin_unlock(&clp->cl_lock);
 822	s->sc_free(s);
 823	if (fp)
 824		put_nfs4_file(fp);
 825}
 826
 827void
 828nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid)
 829{
 830	stateid_t *src = &stid->sc_stateid;
 831
 832	spin_lock(&stid->sc_lock);
 833	if (unlikely(++src->si_generation == 0))
 834		src->si_generation = 1;
 835	memcpy(dst, src, sizeof(*dst));
 836	spin_unlock(&stid->sc_lock);
 837}
 838
 839static void nfs4_put_deleg_lease(struct nfs4_file *fp)
 840{
 841	struct file *filp = NULL;
 842
 843	spin_lock(&fp->fi_lock);
 844	if (fp->fi_deleg_file && --fp->fi_delegees == 0)
 845		swap(filp, fp->fi_deleg_file);
 846	spin_unlock(&fp->fi_lock);
 847
 848	if (filp) {
 849		vfs_setlease(filp, F_UNLCK, NULL, (void **)&fp);
 850		fput(filp);
 851	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 852}
 853
 854void nfs4_unhash_stid(struct nfs4_stid *s)
 855{
 856	s->sc_type = 0;
 857}
 858
 859/**
 860 * nfs4_get_existing_delegation - Discover if this delegation already exists
 861 * @clp:     a pointer to the nfs4_client we're granting a delegation to
 862 * @fp:      a pointer to the nfs4_file we're granting a delegation on
 863 *
 864 * Return:
 865 *      On success: NULL if an existing delegation was not found.
 866 *
 867 *      On error: -EAGAIN if one was previously granted to this nfs4_client
 868 *                 for this nfs4_file.
 869 *
 870 */
 871
 872static int
 873nfs4_get_existing_delegation(struct nfs4_client *clp, struct nfs4_file *fp)
 874{
 875	struct nfs4_delegation *searchdp = NULL;
 876	struct nfs4_client *searchclp = NULL;
 877
 878	lockdep_assert_held(&state_lock);
 879	lockdep_assert_held(&fp->fi_lock);
 880
 881	list_for_each_entry(searchdp, &fp->fi_delegations, dl_perfile) {
 882		searchclp = searchdp->dl_stid.sc_client;
 883		if (clp == searchclp) {
 884			return -EAGAIN;
 885		}
 886	}
 887	return 0;
 888}
 889
 890/**
 891 * hash_delegation_locked - Add a delegation to the appropriate lists
 892 * @dp:     a pointer to the nfs4_delegation we are adding.
 893 * @fp:     a pointer to the nfs4_file we're granting a delegation on
 894 *
 895 * Return:
 896 *      On success: NULL if the delegation was successfully hashed.
 897 *
 898 *      On error: -EAGAIN if one was previously granted to this
 899 *                 nfs4_client for this nfs4_file. Delegation is not hashed.
 900 *
 901 */
 902
 903static int
 904hash_delegation_locked(struct nfs4_delegation *dp, struct nfs4_file *fp)
 905{
 906	int status;
 907	struct nfs4_client *clp = dp->dl_stid.sc_client;
 908
 909	lockdep_assert_held(&state_lock);
 910	lockdep_assert_held(&fp->fi_lock);
 911
 912	status = nfs4_get_existing_delegation(clp, fp);
 913	if (status)
 914		return status;
 915	++fp->fi_delegees;
 916	atomic_inc(&dp->dl_stid.sc_count);
 917	dp->dl_stid.sc_type = NFS4_DELEG_STID;
 918	list_add(&dp->dl_perfile, &fp->fi_delegations);
 919	list_add(&dp->dl_perclnt, &clp->cl_delegations);
 920	return 0;
 921}
 922
 923static bool
 924unhash_delegation_locked(struct nfs4_delegation *dp)
 925{
 926	struct nfs4_file *fp = dp->dl_stid.sc_file;
 927
 928	lockdep_assert_held(&state_lock);
 929
 930	if (list_empty(&dp->dl_perfile))
 931		return false;
 932
 933	dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID;
 934	/* Ensure that deleg break won't try to requeue it */
 935	++dp->dl_time;
 936	spin_lock(&fp->fi_lock);
 937	list_del_init(&dp->dl_perclnt);
 938	list_del_init(&dp->dl_recall_lru);
 939	list_del_init(&dp->dl_perfile);
 940	spin_unlock(&fp->fi_lock);
 941	return true;
 942}
 943
 944static void destroy_delegation(struct nfs4_delegation *dp)
 945{
 946	bool unhashed;
 947
 948	spin_lock(&state_lock);
 949	unhashed = unhash_delegation_locked(dp);
 950	spin_unlock(&state_lock);
 951	if (unhashed) {
 952		put_clnt_odstate(dp->dl_clnt_odstate);
 953		nfs4_put_deleg_lease(dp->dl_stid.sc_file);
 954		nfs4_put_stid(&dp->dl_stid);
 955	}
 956}
 957
 958static void revoke_delegation(struct nfs4_delegation *dp)
 959{
 960	struct nfs4_client *clp = dp->dl_stid.sc_client;
 961
 962	WARN_ON(!list_empty(&dp->dl_recall_lru));
 963
 964	put_clnt_odstate(dp->dl_clnt_odstate);
 965	nfs4_put_deleg_lease(dp->dl_stid.sc_file);
 966
 967	if (clp->cl_minorversion == 0)
 968		nfs4_put_stid(&dp->dl_stid);
 969	else {
 970		dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID;
 
 971		spin_lock(&clp->cl_lock);
 972		list_add(&dp->dl_recall_lru, &clp->cl_revoked);
 973		spin_unlock(&clp->cl_lock);
 974	}
 
 975}
 976
 977/* 
 978 * SETCLIENTID state 
 979 */
 980
 981static unsigned int clientid_hashval(u32 id)
 982{
 983	return id & CLIENT_HASH_MASK;
 984}
 985
 986static unsigned int clientstr_hashval(const char *name)
 987{
 988	return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
 989}
 990
 991/*
 992 * We store the NONE, READ, WRITE, and BOTH bits separately in the
 993 * st_{access,deny}_bmap field of the stateid, in order to track not
 994 * only what share bits are currently in force, but also what
 995 * combinations of share bits previous opens have used.  This allows us
 996 * to enforce the recommendation of rfc 3530 14.2.19 that the server
 997 * return an error if the client attempt to downgrade to a combination
 998 * of share bits not explicable by closing some of its previous opens.
 999 *
1000 * XXX: This enforcement is actually incomplete, since we don't keep
1001 * track of access/deny bit combinations; so, e.g., we allow:
1002 *
1003 *	OPEN allow read, deny write
1004 *	OPEN allow both, deny none
1005 *	DOWNGRADE allow read, deny none
1006 *
1007 * which we should reject.
1008 */
1009static unsigned int
1010bmap_to_share_mode(unsigned long bmap) {
1011	int i;
1012	unsigned int access = 0;
1013
1014	for (i = 1; i < 4; i++) {
1015		if (test_bit(i, &bmap))
1016			access |= i;
1017	}
1018	return access;
1019}
1020
1021/* set share access for a given stateid */
1022static inline void
1023set_access(u32 access, struct nfs4_ol_stateid *stp)
1024{
1025	unsigned char mask = 1 << access;
1026
1027	WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
1028	stp->st_access_bmap |= mask;
1029}
1030
1031/* clear share access for a given stateid */
1032static inline void
1033clear_access(u32 access, struct nfs4_ol_stateid *stp)
1034{
1035	unsigned char mask = 1 << access;
1036
1037	WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
1038	stp->st_access_bmap &= ~mask;
1039}
1040
1041/* test whether a given stateid has access */
1042static inline bool
1043test_access(u32 access, struct nfs4_ol_stateid *stp)
1044{
1045	unsigned char mask = 1 << access;
1046
1047	return (bool)(stp->st_access_bmap & mask);
1048}
1049
1050/* set share deny for a given stateid */
1051static inline void
1052set_deny(u32 deny, struct nfs4_ol_stateid *stp)
1053{
1054	unsigned char mask = 1 << deny;
1055
1056	WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
1057	stp->st_deny_bmap |= mask;
1058}
1059
1060/* clear share deny for a given stateid */
1061static inline void
1062clear_deny(u32 deny, struct nfs4_ol_stateid *stp)
1063{
1064	unsigned char mask = 1 << deny;
1065
1066	WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
1067	stp->st_deny_bmap &= ~mask;
1068}
1069
1070/* test whether a given stateid is denying specific access */
1071static inline bool
1072test_deny(u32 deny, struct nfs4_ol_stateid *stp)
1073{
1074	unsigned char mask = 1 << deny;
1075
1076	return (bool)(stp->st_deny_bmap & mask);
1077}
1078
1079static int nfs4_access_to_omode(u32 access)
1080{
1081	switch (access & NFS4_SHARE_ACCESS_BOTH) {
1082	case NFS4_SHARE_ACCESS_READ:
1083		return O_RDONLY;
1084	case NFS4_SHARE_ACCESS_WRITE:
1085		return O_WRONLY;
1086	case NFS4_SHARE_ACCESS_BOTH:
1087		return O_RDWR;
1088	}
1089	WARN_ON_ONCE(1);
1090	return O_RDONLY;
1091}
1092
1093/*
1094 * A stateid that had a deny mode associated with it is being released
1095 * or downgraded. Recalculate the deny mode on the file.
1096 */
1097static void
1098recalculate_deny_mode(struct nfs4_file *fp)
1099{
1100	struct nfs4_ol_stateid *stp;
1101
1102	spin_lock(&fp->fi_lock);
1103	fp->fi_share_deny = 0;
1104	list_for_each_entry(stp, &fp->fi_stateids, st_perfile)
1105		fp->fi_share_deny |= bmap_to_share_mode(stp->st_deny_bmap);
1106	spin_unlock(&fp->fi_lock);
1107}
1108
1109static void
1110reset_union_bmap_deny(u32 deny, struct nfs4_ol_stateid *stp)
1111{
1112	int i;
1113	bool change = false;
1114
1115	for (i = 1; i < 4; i++) {
1116		if ((i & deny) != i) {
1117			change = true;
1118			clear_deny(i, stp);
1119		}
1120	}
1121
1122	/* Recalculate per-file deny mode if there was a change */
1123	if (change)
1124		recalculate_deny_mode(stp->st_stid.sc_file);
1125}
1126
1127/* release all access and file references for a given stateid */
1128static void
1129release_all_access(struct nfs4_ol_stateid *stp)
1130{
1131	int i;
1132	struct nfs4_file *fp = stp->st_stid.sc_file;
1133
1134	if (fp && stp->st_deny_bmap != 0)
1135		recalculate_deny_mode(fp);
1136
1137	for (i = 1; i < 4; i++) {
1138		if (test_access(i, stp))
1139			nfs4_file_put_access(stp->st_stid.sc_file, i);
1140		clear_access(i, stp);
1141	}
1142}
1143
1144static inline void nfs4_free_stateowner(struct nfs4_stateowner *sop)
1145{
1146	kfree(sop->so_owner.data);
1147	sop->so_ops->so_free(sop);
1148}
1149
1150static void nfs4_put_stateowner(struct nfs4_stateowner *sop)
1151{
1152	struct nfs4_client *clp = sop->so_client;
1153
1154	might_lock(&clp->cl_lock);
1155
1156	if (!atomic_dec_and_lock(&sop->so_count, &clp->cl_lock))
1157		return;
1158	sop->so_ops->so_unhash(sop);
1159	spin_unlock(&clp->cl_lock);
1160	nfs4_free_stateowner(sop);
1161}
1162
 
 
 
 
 
 
1163static bool unhash_ol_stateid(struct nfs4_ol_stateid *stp)
1164{
1165	struct nfs4_file *fp = stp->st_stid.sc_file;
1166
1167	lockdep_assert_held(&stp->st_stateowner->so_client->cl_lock);
1168
1169	if (list_empty(&stp->st_perfile))
1170		return false;
1171
1172	spin_lock(&fp->fi_lock);
1173	list_del_init(&stp->st_perfile);
1174	spin_unlock(&fp->fi_lock);
1175	list_del(&stp->st_perstateowner);
1176	return true;
1177}
1178
1179static void nfs4_free_ol_stateid(struct nfs4_stid *stid)
1180{
1181	struct nfs4_ol_stateid *stp = openlockstateid(stid);
1182
1183	put_clnt_odstate(stp->st_clnt_odstate);
1184	release_all_access(stp);
1185	if (stp->st_stateowner)
1186		nfs4_put_stateowner(stp->st_stateowner);
1187	kmem_cache_free(stateid_slab, stid);
1188}
1189
1190static void nfs4_free_lock_stateid(struct nfs4_stid *stid)
1191{
1192	struct nfs4_ol_stateid *stp = openlockstateid(stid);
1193	struct nfs4_lockowner *lo = lockowner(stp->st_stateowner);
1194	struct file *file;
1195
1196	file = find_any_file(stp->st_stid.sc_file);
1197	if (file)
1198		filp_close(file, (fl_owner_t)lo);
 
 
 
1199	nfs4_free_ol_stateid(stid);
1200}
1201
1202/*
1203 * Put the persistent reference to an already unhashed generic stateid, while
1204 * holding the cl_lock. If it's the last reference, then put it onto the
1205 * reaplist for later destruction.
1206 */
1207static void put_ol_stateid_locked(struct nfs4_ol_stateid *stp,
1208				       struct list_head *reaplist)
1209{
1210	struct nfs4_stid *s = &stp->st_stid;
1211	struct nfs4_client *clp = s->sc_client;
1212
1213	lockdep_assert_held(&clp->cl_lock);
1214
1215	WARN_ON_ONCE(!list_empty(&stp->st_locks));
1216
1217	if (!atomic_dec_and_test(&s->sc_count)) {
1218		wake_up_all(&close_wq);
1219		return;
1220	}
1221
1222	idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
1223	list_add(&stp->st_locks, reaplist);
1224}
1225
1226static bool unhash_lock_stateid(struct nfs4_ol_stateid *stp)
1227{
1228	lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);
1229
 
 
1230	list_del_init(&stp->st_locks);
1231	nfs4_unhash_stid(&stp->st_stid);
1232	return unhash_ol_stateid(stp);
1233}
1234
1235static void release_lock_stateid(struct nfs4_ol_stateid *stp)
1236{
1237	struct nfs4_client *clp = stp->st_stid.sc_client;
1238	bool unhashed;
1239
1240	spin_lock(&clp->cl_lock);
1241	unhashed = unhash_lock_stateid(stp);
1242	spin_unlock(&clp->cl_lock);
1243	if (unhashed)
1244		nfs4_put_stid(&stp->st_stid);
1245}
1246
1247static void unhash_lockowner_locked(struct nfs4_lockowner *lo)
1248{
1249	struct nfs4_client *clp = lo->lo_owner.so_client;
1250
1251	lockdep_assert_held(&clp->cl_lock);
1252
1253	list_del_init(&lo->lo_owner.so_strhash);
1254}
1255
1256/*
1257 * Free a list of generic stateids that were collected earlier after being
1258 * fully unhashed.
1259 */
1260static void
1261free_ol_stateid_reaplist(struct list_head *reaplist)
1262{
1263	struct nfs4_ol_stateid *stp;
1264	struct nfs4_file *fp;
1265
1266	might_sleep();
1267
1268	while (!list_empty(reaplist)) {
1269		stp = list_first_entry(reaplist, struct nfs4_ol_stateid,
1270				       st_locks);
1271		list_del(&stp->st_locks);
1272		fp = stp->st_stid.sc_file;
1273		stp->st_stid.sc_free(&stp->st_stid);
1274		if (fp)
1275			put_nfs4_file(fp);
1276	}
1277}
1278
1279static void release_open_stateid_locks(struct nfs4_ol_stateid *open_stp,
1280				       struct list_head *reaplist)
1281{
1282	struct nfs4_ol_stateid *stp;
1283
1284	lockdep_assert_held(&open_stp->st_stid.sc_client->cl_lock);
1285
1286	while (!list_empty(&open_stp->st_locks)) {
1287		stp = list_entry(open_stp->st_locks.next,
1288				struct nfs4_ol_stateid, st_locks);
1289		WARN_ON(!unhash_lock_stateid(stp));
1290		put_ol_stateid_locked(stp, reaplist);
1291	}
1292}
1293
1294static bool unhash_open_stateid(struct nfs4_ol_stateid *stp,
1295				struct list_head *reaplist)
1296{
1297	bool unhashed;
1298
1299	lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);
1300
1301	unhashed = unhash_ol_stateid(stp);
 
1302	release_open_stateid_locks(stp, reaplist);
1303	return unhashed;
1304}
1305
1306static void release_open_stateid(struct nfs4_ol_stateid *stp)
1307{
1308	LIST_HEAD(reaplist);
1309
1310	spin_lock(&stp->st_stid.sc_client->cl_lock);
1311	if (unhash_open_stateid(stp, &reaplist))
1312		put_ol_stateid_locked(stp, &reaplist);
1313	spin_unlock(&stp->st_stid.sc_client->cl_lock);
1314	free_ol_stateid_reaplist(&reaplist);
1315}
1316
1317static void unhash_openowner_locked(struct nfs4_openowner *oo)
1318{
1319	struct nfs4_client *clp = oo->oo_owner.so_client;
1320
1321	lockdep_assert_held(&clp->cl_lock);
1322
1323	list_del_init(&oo->oo_owner.so_strhash);
1324	list_del_init(&oo->oo_perclient);
1325}
1326
1327static void release_last_closed_stateid(struct nfs4_openowner *oo)
1328{
1329	struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net,
1330					  nfsd_net_id);
1331	struct nfs4_ol_stateid *s;
1332
1333	spin_lock(&nn->client_lock);
1334	s = oo->oo_last_closed_stid;
1335	if (s) {
1336		list_del_init(&oo->oo_close_lru);
1337		oo->oo_last_closed_stid = NULL;
1338	}
1339	spin_unlock(&nn->client_lock);
1340	if (s)
1341		nfs4_put_stid(&s->st_stid);
1342}
1343
1344static void release_openowner(struct nfs4_openowner *oo)
1345{
1346	struct nfs4_ol_stateid *stp;
1347	struct nfs4_client *clp = oo->oo_owner.so_client;
1348	struct list_head reaplist;
1349
1350	INIT_LIST_HEAD(&reaplist);
1351
1352	spin_lock(&clp->cl_lock);
1353	unhash_openowner_locked(oo);
1354	while (!list_empty(&oo->oo_owner.so_stateids)) {
1355		stp = list_first_entry(&oo->oo_owner.so_stateids,
1356				struct nfs4_ol_stateid, st_perstateowner);
1357		if (unhash_open_stateid(stp, &reaplist))
1358			put_ol_stateid_locked(stp, &reaplist);
1359	}
1360	spin_unlock(&clp->cl_lock);
1361	free_ol_stateid_reaplist(&reaplist);
1362	release_last_closed_stateid(oo);
1363	nfs4_put_stateowner(&oo->oo_owner);
1364}
1365
1366static inline int
1367hash_sessionid(struct nfs4_sessionid *sessionid)
1368{
1369	struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
1370
1371	return sid->sequence % SESSION_HASH_SIZE;
1372}
1373
1374#ifdef CONFIG_SUNRPC_DEBUG
1375static inline void
1376dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
1377{
1378	u32 *ptr = (u32 *)(&sessionid->data[0]);
1379	dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
1380}
1381#else
1382static inline void
1383dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
1384{
1385}
1386#endif
1387
1388/*
1389 * Bump the seqid on cstate->replay_owner, and clear replay_owner if it
1390 * won't be used for replay.
1391 */
1392void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
1393{
1394	struct nfs4_stateowner *so = cstate->replay_owner;
1395
1396	if (nfserr == nfserr_replay_me)
1397		return;
1398
1399	if (!seqid_mutating_err(ntohl(nfserr))) {
1400		nfsd4_cstate_clear_replay(cstate);
1401		return;
1402	}
1403	if (!so)
1404		return;
1405	if (so->so_is_open_owner)
1406		release_last_closed_stateid(openowner(so));
1407	so->so_seqid++;
1408	return;
1409}
1410
1411static void
1412gen_sessionid(struct nfsd4_session *ses)
1413{
1414	struct nfs4_client *clp = ses->se_client;
1415	struct nfsd4_sessionid *sid;
1416
1417	sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
1418	sid->clientid = clp->cl_clientid;
1419	sid->sequence = current_sessionid++;
1420	sid->reserved = 0;
1421}
1422
1423/*
1424 * The protocol defines ca_maxresponssize_cached to include the size of
1425 * the rpc header, but all we need to cache is the data starting after
1426 * the end of the initial SEQUENCE operation--the rest we regenerate
1427 * each time.  Therefore we can advertise a ca_maxresponssize_cached
1428 * value that is the number of bytes in our cache plus a few additional
1429 * bytes.  In order to stay on the safe side, and not promise more than
1430 * we can cache, those additional bytes must be the minimum possible: 24
1431 * bytes of rpc header (xid through accept state, with AUTH_NULL
1432 * verifier), 12 for the compound header (with zero-length tag), and 44
1433 * for the SEQUENCE op response:
1434 */
1435#define NFSD_MIN_HDR_SEQ_SZ  (24 + 12 + 44)
1436
1437static void
1438free_session_slots(struct nfsd4_session *ses)
1439{
1440	int i;
1441
1442	for (i = 0; i < ses->se_fchannel.maxreqs; i++)
 
1443		kfree(ses->se_slots[i]);
 
1444}
1445
1446/*
1447 * We don't actually need to cache the rpc and session headers, so we
1448 * can allocate a little less for each slot:
1449 */
1450static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
1451{
1452	u32 size;
1453
1454	if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
1455		size = 0;
1456	else
1457		size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
1458	return size + sizeof(struct nfsd4_slot);
1459}
1460
1461/*
1462 * XXX: If we run out of reserved DRC memory we could (up to a point)
1463 * re-negotiate active sessions and reduce their slot usage to make
1464 * room for new connections. For now we just fail the create session.
1465 */
1466static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca)
1467{
1468	u32 slotsize = slot_bytes(ca);
1469	u32 num = ca->maxreqs;
1470	int avail;
 
1471
1472	spin_lock(&nfsd_drc_lock);
1473	avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION,
1474		    nfsd_drc_max_mem - nfsd_drc_mem_used);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1475	num = min_t(int, num, avail / slotsize);
 
1476	nfsd_drc_mem_used += num * slotsize;
1477	spin_unlock(&nfsd_drc_lock);
1478
1479	return num;
1480}
1481
1482static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
1483{
1484	int slotsize = slot_bytes(ca);
1485
1486	spin_lock(&nfsd_drc_lock);
1487	nfsd_drc_mem_used -= slotsize * ca->maxreqs;
1488	spin_unlock(&nfsd_drc_lock);
1489}
1490
1491static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fattrs,
1492					   struct nfsd4_channel_attrs *battrs)
1493{
1494	int numslots = fattrs->maxreqs;
1495	int slotsize = slot_bytes(fattrs);
1496	struct nfsd4_session *new;
1497	int mem, i;
1498
1499	BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
1500			+ sizeof(struct nfsd4_session) > PAGE_SIZE);
1501	mem = numslots * sizeof(struct nfsd4_slot *);
1502
1503	new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
1504	if (!new)
1505		return NULL;
1506	/* allocate each struct nfsd4_slot and data cache in one piece */
1507	for (i = 0; i < numslots; i++) {
1508		new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL);
1509		if (!new->se_slots[i])
1510			goto out_free;
1511	}
1512
1513	memcpy(&new->se_fchannel, fattrs, sizeof(struct nfsd4_channel_attrs));
1514	memcpy(&new->se_bchannel, battrs, sizeof(struct nfsd4_channel_attrs));
1515
1516	return new;
1517out_free:
1518	while (i--)
1519		kfree(new->se_slots[i]);
1520	kfree(new);
1521	return NULL;
1522}
1523
1524static void free_conn(struct nfsd4_conn *c)
1525{
1526	svc_xprt_put(c->cn_xprt);
1527	kfree(c);
1528}
1529
1530static void nfsd4_conn_lost(struct svc_xpt_user *u)
1531{
1532	struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
1533	struct nfs4_client *clp = c->cn_session->se_client;
1534
1535	spin_lock(&clp->cl_lock);
1536	if (!list_empty(&c->cn_persession)) {
1537		list_del(&c->cn_persession);
1538		free_conn(c);
1539	}
1540	nfsd4_probe_callback(clp);
1541	spin_unlock(&clp->cl_lock);
1542}
1543
1544static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
1545{
1546	struct nfsd4_conn *conn;
1547
1548	conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
1549	if (!conn)
1550		return NULL;
1551	svc_xprt_get(rqstp->rq_xprt);
1552	conn->cn_xprt = rqstp->rq_xprt;
1553	conn->cn_flags = flags;
1554	INIT_LIST_HEAD(&conn->cn_xpt_user.list);
1555	return conn;
1556}
1557
1558static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
1559{
1560	conn->cn_session = ses;
1561	list_add(&conn->cn_persession, &ses->se_conns);
1562}
1563
1564static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
1565{
1566	struct nfs4_client *clp = ses->se_client;
1567
1568	spin_lock(&clp->cl_lock);
1569	__nfsd4_hash_conn(conn, ses);
1570	spin_unlock(&clp->cl_lock);
1571}
1572
1573static int nfsd4_register_conn(struct nfsd4_conn *conn)
1574{
1575	conn->cn_xpt_user.callback = nfsd4_conn_lost;
1576	return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
1577}
1578
1579static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
1580{
1581	int ret;
1582
1583	nfsd4_hash_conn(conn, ses);
1584	ret = nfsd4_register_conn(conn);
1585	if (ret)
1586		/* oops; xprt is already down: */
1587		nfsd4_conn_lost(&conn->cn_xpt_user);
1588	/* We may have gained or lost a callback channel: */
1589	nfsd4_probe_callback_sync(ses->se_client);
1590}
1591
1592static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
1593{
1594	u32 dir = NFS4_CDFC4_FORE;
1595
1596	if (cses->flags & SESSION4_BACK_CHAN)
1597		dir |= NFS4_CDFC4_BACK;
1598	return alloc_conn(rqstp, dir);
1599}
1600
1601/* must be called under client_lock */
1602static void nfsd4_del_conns(struct nfsd4_session *s)
1603{
1604	struct nfs4_client *clp = s->se_client;
1605	struct nfsd4_conn *c;
1606
1607	spin_lock(&clp->cl_lock);
1608	while (!list_empty(&s->se_conns)) {
1609		c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
1610		list_del_init(&c->cn_persession);
1611		spin_unlock(&clp->cl_lock);
1612
1613		unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
1614		free_conn(c);
1615
1616		spin_lock(&clp->cl_lock);
1617	}
1618	spin_unlock(&clp->cl_lock);
1619}
1620
1621static void __free_session(struct nfsd4_session *ses)
1622{
1623	free_session_slots(ses);
1624	kfree(ses);
1625}
1626
1627static void free_session(struct nfsd4_session *ses)
1628{
1629	nfsd4_del_conns(ses);
1630	nfsd4_put_drc_mem(&ses->se_fchannel);
1631	__free_session(ses);
1632}
1633
1634static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses)
1635{
1636	int idx;
1637	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1638
1639	new->se_client = clp;
1640	gen_sessionid(new);
1641
1642	INIT_LIST_HEAD(&new->se_conns);
1643
1644	new->se_cb_seq_nr = 1;
1645	new->se_flags = cses->flags;
1646	new->se_cb_prog = cses->callback_prog;
1647	new->se_cb_sec = cses->cb_sec;
1648	atomic_set(&new->se_ref, 0);
1649	idx = hash_sessionid(&new->se_sessionid);
1650	list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
1651	spin_lock(&clp->cl_lock);
1652	list_add(&new->se_perclnt, &clp->cl_sessions);
1653	spin_unlock(&clp->cl_lock);
1654
1655	{
1656		struct sockaddr *sa = svc_addr(rqstp);
1657		/*
1658		 * This is a little silly; with sessions there's no real
1659		 * use for the callback address.  Use the peer address
1660		 * as a reasonable default for now, but consider fixing
1661		 * the rpc client not to require an address in the
1662		 * future:
1663		 */
1664		rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
1665		clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
1666	}
1667}
1668
1669/* caller must hold client_lock */
1670static struct nfsd4_session *
1671__find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
1672{
1673	struct nfsd4_session *elem;
1674	int idx;
1675	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1676
1677	lockdep_assert_held(&nn->client_lock);
1678
1679	dump_sessionid(__func__, sessionid);
1680	idx = hash_sessionid(sessionid);
1681	/* Search in the appropriate list */
1682	list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
1683		if (!memcmp(elem->se_sessionid.data, sessionid->data,
1684			    NFS4_MAX_SESSIONID_LEN)) {
1685			return elem;
1686		}
1687	}
1688
1689	dprintk("%s: session not found\n", __func__);
1690	return NULL;
1691}
1692
1693static struct nfsd4_session *
1694find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net,
1695		__be32 *ret)
1696{
1697	struct nfsd4_session *session;
1698	__be32 status = nfserr_badsession;
1699
1700	session = __find_in_sessionid_hashtbl(sessionid, net);
1701	if (!session)
1702		goto out;
1703	status = nfsd4_get_session_locked(session);
1704	if (status)
1705		session = NULL;
1706out:
1707	*ret = status;
1708	return session;
1709}
1710
1711/* caller must hold client_lock */
1712static void
1713unhash_session(struct nfsd4_session *ses)
1714{
1715	struct nfs4_client *clp = ses->se_client;
1716	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1717
1718	lockdep_assert_held(&nn->client_lock);
1719
1720	list_del(&ses->se_hash);
1721	spin_lock(&ses->se_client->cl_lock);
1722	list_del(&ses->se_perclnt);
1723	spin_unlock(&ses->se_client->cl_lock);
1724}
1725
1726/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
1727static int
1728STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
1729{
1730	/*
1731	 * We're assuming the clid was not given out from a boot
1732	 * precisely 2^32 (about 136 years) before this one.  That seems
1733	 * a safe assumption:
1734	 */
1735	if (clid->cl_boot == (u32)nn->boot_time)
1736		return 0;
1737	dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
1738		clid->cl_boot, clid->cl_id, nn->boot_time);
1739	return 1;
1740}
1741
1742/* 
1743 * XXX Should we use a slab cache ?
1744 * This type of memory management is somewhat inefficient, but we use it
1745 * anyway since SETCLIENTID is not a common operation.
1746 */
1747static struct nfs4_client *alloc_client(struct xdr_netobj name)
1748{
1749	struct nfs4_client *clp;
1750	int i;
1751
1752	clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
1753	if (clp == NULL)
1754		return NULL;
1755	clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
1756	if (clp->cl_name.data == NULL)
1757		goto err_no_name;
1758	clp->cl_ownerstr_hashtbl = kmalloc(sizeof(struct list_head) *
1759			OWNER_HASH_SIZE, GFP_KERNEL);
 
1760	if (!clp->cl_ownerstr_hashtbl)
1761		goto err_no_hashtbl;
1762	for (i = 0; i < OWNER_HASH_SIZE; i++)
1763		INIT_LIST_HEAD(&clp->cl_ownerstr_hashtbl[i]);
1764	clp->cl_name.len = name.len;
1765	INIT_LIST_HEAD(&clp->cl_sessions);
1766	idr_init(&clp->cl_stateids);
1767	atomic_set(&clp->cl_refcount, 0);
1768	clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1769	INIT_LIST_HEAD(&clp->cl_idhash);
1770	INIT_LIST_HEAD(&clp->cl_openowners);
1771	INIT_LIST_HEAD(&clp->cl_delegations);
1772	INIT_LIST_HEAD(&clp->cl_lru);
1773	INIT_LIST_HEAD(&clp->cl_revoked);
1774#ifdef CONFIG_NFSD_PNFS
1775	INIT_LIST_HEAD(&clp->cl_lo_states);
1776#endif
 
 
1777	spin_lock_init(&clp->cl_lock);
1778	rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1779	return clp;
1780err_no_hashtbl:
1781	kfree(clp->cl_name.data);
1782err_no_name:
1783	kfree(clp);
1784	return NULL;
1785}
1786
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1787static void
1788free_client(struct nfs4_client *clp)
1789{
1790	while (!list_empty(&clp->cl_sessions)) {
1791		struct nfsd4_session *ses;
1792		ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
1793				se_perclnt);
1794		list_del(&ses->se_perclnt);
1795		WARN_ON_ONCE(atomic_read(&ses->se_ref));
1796		free_session(ses);
1797	}
1798	rpc_destroy_wait_queue(&clp->cl_cb_waitq);
1799	free_svc_cred(&clp->cl_cred);
1800	kfree(clp->cl_ownerstr_hashtbl);
1801	kfree(clp->cl_name.data);
1802	idr_destroy(&clp->cl_stateids);
1803	kfree(clp);
 
1804}
1805
1806/* must be called under the client_lock */
1807static void
1808unhash_client_locked(struct nfs4_client *clp)
1809{
1810	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1811	struct nfsd4_session *ses;
1812
1813	lockdep_assert_held(&nn->client_lock);
1814
1815	/* Mark the client as expired! */
1816	clp->cl_time = 0;
1817	/* Make it invisible */
1818	if (!list_empty(&clp->cl_idhash)) {
1819		list_del_init(&clp->cl_idhash);
1820		if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
1821			rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
1822		else
1823			rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
1824	}
1825	list_del_init(&clp->cl_lru);
1826	spin_lock(&clp->cl_lock);
1827	list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
1828		list_del_init(&ses->se_hash);
1829	spin_unlock(&clp->cl_lock);
1830}
1831
1832static void
1833unhash_client(struct nfs4_client *clp)
1834{
1835	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1836
1837	spin_lock(&nn->client_lock);
1838	unhash_client_locked(clp);
1839	spin_unlock(&nn->client_lock);
1840}
1841
1842static __be32 mark_client_expired_locked(struct nfs4_client *clp)
1843{
1844	if (atomic_read(&clp->cl_refcount))
1845		return nfserr_jukebox;
1846	unhash_client_locked(clp);
1847	return nfs_ok;
1848}
1849
1850static void
1851__destroy_client(struct nfs4_client *clp)
1852{
 
1853	struct nfs4_openowner *oo;
1854	struct nfs4_delegation *dp;
1855	struct list_head reaplist;
1856
1857	INIT_LIST_HEAD(&reaplist);
1858	spin_lock(&state_lock);
1859	while (!list_empty(&clp->cl_delegations)) {
1860		dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
1861		WARN_ON(!unhash_delegation_locked(dp));
1862		list_add(&dp->dl_recall_lru, &reaplist);
1863	}
1864	spin_unlock(&state_lock);
1865	while (!list_empty(&reaplist)) {
1866		dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
1867		list_del_init(&dp->dl_recall_lru);
1868		put_clnt_odstate(dp->dl_clnt_odstate);
1869		nfs4_put_deleg_lease(dp->dl_stid.sc_file);
1870		nfs4_put_stid(&dp->dl_stid);
1871	}
1872	while (!list_empty(&clp->cl_revoked)) {
1873		dp = list_entry(clp->cl_revoked.next, struct nfs4_delegation, dl_recall_lru);
1874		list_del_init(&dp->dl_recall_lru);
1875		nfs4_put_stid(&dp->dl_stid);
1876	}
1877	while (!list_empty(&clp->cl_openowners)) {
1878		oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
1879		nfs4_get_stateowner(&oo->oo_owner);
1880		release_openowner(oo);
1881	}
 
 
 
 
 
 
 
 
 
 
1882	nfsd4_return_all_client_layouts(clp);
 
1883	nfsd4_shutdown_callback(clp);
1884	if (clp->cl_cb_conn.cb_xprt)
1885		svc_xprt_put(clp->cl_cb_conn.cb_xprt);
1886	free_client(clp);
 
1887}
1888
1889static void
1890destroy_client(struct nfs4_client *clp)
1891{
1892	unhash_client(clp);
1893	__destroy_client(clp);
1894}
1895
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1896static void expire_client(struct nfs4_client *clp)
1897{
1898	unhash_client(clp);
1899	nfsd4_client_record_remove(clp);
1900	__destroy_client(clp);
1901}
1902
1903static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
1904{
1905	memcpy(target->cl_verifier.data, source->data,
1906			sizeof(target->cl_verifier.data));
1907}
1908
1909static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
1910{
1911	target->cl_clientid.cl_boot = source->cl_clientid.cl_boot; 
1912	target->cl_clientid.cl_id = source->cl_clientid.cl_id; 
1913}
1914
1915int strdup_if_nonnull(char **target, char *source)
1916{
1917	if (source) {
1918		*target = kstrdup(source, GFP_KERNEL);
1919		if (!*target)
1920			return -ENOMEM;
1921	} else
1922		*target = NULL;
1923	return 0;
1924}
1925
1926static int copy_cred(struct svc_cred *target, struct svc_cred *source)
1927{
1928	int ret;
 
 
 
 
 
 
 
1929
1930	ret = strdup_if_nonnull(&target->cr_principal, source->cr_principal);
1931	if (ret)
1932		return ret;
1933	ret = strdup_if_nonnull(&target->cr_raw_principal,
1934					source->cr_raw_principal);
1935	if (ret)
1936		return ret;
1937	target->cr_flavor = source->cr_flavor;
1938	target->cr_uid = source->cr_uid;
1939	target->cr_gid = source->cr_gid;
1940	target->cr_group_info = source->cr_group_info;
1941	get_group_info(target->cr_group_info);
1942	target->cr_gss_mech = source->cr_gss_mech;
1943	if (source->cr_gss_mech)
1944		gss_mech_get(source->cr_gss_mech);
1945	return 0;
1946}
1947
1948static int
1949compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
1950{
1951	if (o1->len < o2->len)
1952		return -1;
1953	if (o1->len > o2->len)
1954		return 1;
1955	return memcmp(o1->data, o2->data, o1->len);
1956}
1957
1958static int same_name(const char *n1, const char *n2)
1959{
1960	return 0 == memcmp(n1, n2, HEXDIR_LEN);
1961}
1962
1963static int
1964same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1965{
1966	return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
1967}
1968
1969static int
1970same_clid(clientid_t *cl1, clientid_t *cl2)
1971{
1972	return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
1973}
1974
1975static bool groups_equal(struct group_info *g1, struct group_info *g2)
1976{
1977	int i;
1978
1979	if (g1->ngroups != g2->ngroups)
1980		return false;
1981	for (i=0; i<g1->ngroups; i++)
1982		if (!gid_eq(g1->gid[i], g2->gid[i]))
1983			return false;
1984	return true;
1985}
1986
1987/*
1988 * RFC 3530 language requires clid_inuse be returned when the
1989 * "principal" associated with a requests differs from that previously
1990 * used.  We use uid, gid's, and gss principal string as our best
1991 * approximation.  We also don't want to allow non-gss use of a client
1992 * established using gss: in theory cr_principal should catch that
1993 * change, but in practice cr_principal can be null even in the gss case
1994 * since gssd doesn't always pass down a principal string.
1995 */
1996static bool is_gss_cred(struct svc_cred *cr)
1997{
1998	/* Is cr_flavor one of the gss "pseudoflavors"?: */
1999	return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
2000}
2001
2002
2003static bool
2004same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
2005{
2006	if ((is_gss_cred(cr1) != is_gss_cred(cr2))
2007		|| (!uid_eq(cr1->cr_uid, cr2->cr_uid))
2008		|| (!gid_eq(cr1->cr_gid, cr2->cr_gid))
2009		|| !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
2010		return false;
 
2011	if (cr1->cr_principal == cr2->cr_principal)
2012		return true;
2013	if (!cr1->cr_principal || !cr2->cr_principal)
2014		return false;
2015	return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
2016}
2017
2018static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp)
2019{
2020	struct svc_cred *cr = &rqstp->rq_cred;
2021	u32 service;
2022
2023	if (!cr->cr_gss_mech)
2024		return false;
2025	service = gss_pseudoflavor_to_service(cr->cr_gss_mech, cr->cr_flavor);
2026	return service == RPC_GSS_SVC_INTEGRITY ||
2027	       service == RPC_GSS_SVC_PRIVACY;
2028}
2029
2030bool nfsd4_mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp)
2031{
2032	struct svc_cred *cr = &rqstp->rq_cred;
2033
2034	if (!cl->cl_mach_cred)
2035		return true;
2036	if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech)
2037		return false;
2038	if (!svc_rqst_integrity_protected(rqstp))
2039		return false;
2040	if (cl->cl_cred.cr_raw_principal)
2041		return 0 == strcmp(cl->cl_cred.cr_raw_principal,
2042						cr->cr_raw_principal);
2043	if (!cr->cr_principal)
2044		return false;
2045	return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal);
2046}
2047
2048static void gen_confirm(struct nfs4_client *clp, struct nfsd_net *nn)
2049{
2050	__be32 verf[2];
2051
2052	/*
2053	 * This is opaque to client, so no need to byte-swap. Use
2054	 * __force to keep sparse happy
2055	 */
2056	verf[0] = (__force __be32)get_seconds();
2057	verf[1] = (__force __be32)nn->clverifier_counter++;
2058	memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
2059}
2060
2061static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
2062{
2063	clp->cl_clientid.cl_boot = nn->boot_time;
2064	clp->cl_clientid.cl_id = nn->clientid_counter++;
2065	gen_confirm(clp, nn);
2066}
2067
2068static struct nfs4_stid *
2069find_stateid_locked(struct nfs4_client *cl, stateid_t *t)
2070{
2071	struct nfs4_stid *ret;
2072
2073	ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
2074	if (!ret || !ret->sc_type)
2075		return NULL;
2076	return ret;
2077}
2078
2079static struct nfs4_stid *
2080find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
2081{
2082	struct nfs4_stid *s;
2083
2084	spin_lock(&cl->cl_lock);
2085	s = find_stateid_locked(cl, t);
2086	if (s != NULL) {
2087		if (typemask & s->sc_type)
2088			atomic_inc(&s->sc_count);
2089		else
2090			s = NULL;
2091	}
2092	spin_unlock(&cl->cl_lock);
2093	return s;
2094}
2095
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2096static struct nfs4_client *create_client(struct xdr_netobj name,
2097		struct svc_rqst *rqstp, nfs4_verifier *verf)
2098{
2099	struct nfs4_client *clp;
2100	struct sockaddr *sa = svc_addr(rqstp);
2101	int ret;
2102	struct net *net = SVC_NET(rqstp);
 
2103
2104	clp = alloc_client(name);
2105	if (clp == NULL)
2106		return NULL;
2107
2108	ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
2109	if (ret) {
2110		free_client(clp);
2111		return NULL;
2112	}
 
 
2113	nfsd4_init_cb(&clp->cl_cb_null, clp, NULL, NFSPROC4_CLNT_CB_NULL);
2114	clp->cl_time = get_seconds();
2115	clear_bit(0, &clp->cl_cb_slot_busy);
2116	copy_verf(clp, verf);
2117	rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
2118	clp->cl_cb_session = NULL;
2119	clp->net = net;
 
 
 
 
 
 
 
2120	return clp;
2121}
2122
2123static void
2124add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
2125{
2126	struct rb_node **new = &(root->rb_node), *parent = NULL;
2127	struct nfs4_client *clp;
2128
2129	while (*new) {
2130		clp = rb_entry(*new, struct nfs4_client, cl_namenode);
2131		parent = *new;
2132
2133		if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
2134			new = &((*new)->rb_left);
2135		else
2136			new = &((*new)->rb_right);
2137	}
2138
2139	rb_link_node(&new_clp->cl_namenode, parent, new);
2140	rb_insert_color(&new_clp->cl_namenode, root);
2141}
2142
2143static struct nfs4_client *
2144find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
2145{
2146	int cmp;
2147	struct rb_node *node = root->rb_node;
2148	struct nfs4_client *clp;
2149
2150	while (node) {
2151		clp = rb_entry(node, struct nfs4_client, cl_namenode);
2152		cmp = compare_blob(&clp->cl_name, name);
2153		if (cmp > 0)
2154			node = node->rb_left;
2155		else if (cmp < 0)
2156			node = node->rb_right;
2157		else
2158			return clp;
2159	}
2160	return NULL;
2161}
2162
2163static void
2164add_to_unconfirmed(struct nfs4_client *clp)
2165{
2166	unsigned int idhashval;
2167	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2168
2169	lockdep_assert_held(&nn->client_lock);
2170
2171	clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
2172	add_clp_to_name_tree(clp, &nn->unconf_name_tree);
2173	idhashval = clientid_hashval(clp->cl_clientid.cl_id);
2174	list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
2175	renew_client_locked(clp);
2176}
2177
2178static void
2179move_to_confirmed(struct nfs4_client *clp)
2180{
2181	unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
2182	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2183
2184	lockdep_assert_held(&nn->client_lock);
2185
2186	dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
2187	list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
2188	rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
2189	add_clp_to_name_tree(clp, &nn->conf_name_tree);
2190	set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
2191	renew_client_locked(clp);
2192}
2193
2194static struct nfs4_client *
2195find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
2196{
2197	struct nfs4_client *clp;
2198	unsigned int idhashval = clientid_hashval(clid->cl_id);
2199
2200	list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
2201		if (same_clid(&clp->cl_clientid, clid)) {
2202			if ((bool)clp->cl_minorversion != sessions)
2203				return NULL;
2204			renew_client_locked(clp);
2205			return clp;
2206		}
2207	}
2208	return NULL;
2209}
2210
2211static struct nfs4_client *
2212find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
2213{
2214	struct list_head *tbl = nn->conf_id_hashtbl;
2215
2216	lockdep_assert_held(&nn->client_lock);
2217	return find_client_in_id_table(tbl, clid, sessions);
2218}
2219
2220static struct nfs4_client *
2221find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
2222{
2223	struct list_head *tbl = nn->unconf_id_hashtbl;
2224
2225	lockdep_assert_held(&nn->client_lock);
2226	return find_client_in_id_table(tbl, clid, sessions);
2227}
2228
2229static bool clp_used_exchangeid(struct nfs4_client *clp)
2230{
2231	return clp->cl_exchange_flags != 0;
2232} 
2233
2234static struct nfs4_client *
2235find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
2236{
2237	lockdep_assert_held(&nn->client_lock);
2238	return find_clp_in_name_tree(name, &nn->conf_name_tree);
2239}
2240
2241static struct nfs4_client *
2242find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
2243{
2244	lockdep_assert_held(&nn->client_lock);
2245	return find_clp_in_name_tree(name, &nn->unconf_name_tree);
2246}
2247
2248static void
2249gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
2250{
2251	struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
2252	struct sockaddr	*sa = svc_addr(rqstp);
2253	u32 scopeid = rpc_get_scope_id(sa);
2254	unsigned short expected_family;
2255
2256	/* Currently, we only support tcp and tcp6 for the callback channel */
2257	if (se->se_callback_netid_len == 3 &&
2258	    !memcmp(se->se_callback_netid_val, "tcp", 3))
2259		expected_family = AF_INET;
2260	else if (se->se_callback_netid_len == 4 &&
2261		 !memcmp(se->se_callback_netid_val, "tcp6", 4))
2262		expected_family = AF_INET6;
2263	else
2264		goto out_err;
2265
2266	conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
2267					    se->se_callback_addr_len,
2268					    (struct sockaddr *)&conn->cb_addr,
2269					    sizeof(conn->cb_addr));
2270
2271	if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
2272		goto out_err;
2273
2274	if (conn->cb_addr.ss_family == AF_INET6)
2275		((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
2276
2277	conn->cb_prog = se->se_callback_prog;
2278	conn->cb_ident = se->se_callback_ident;
2279	memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
 
2280	return;
2281out_err:
2282	conn->cb_addr.ss_family = AF_UNSPEC;
2283	conn->cb_addrlen = 0;
2284	dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
2285		"will not receive delegations\n",
2286		clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
2287
2288	return;
2289}
2290
2291/*
2292 * Cache a reply. nfsd4_check_resp_size() has bounded the cache size.
2293 */
2294static void
2295nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
2296{
2297	struct xdr_buf *buf = resp->xdr.buf;
2298	struct nfsd4_slot *slot = resp->cstate.slot;
2299	unsigned int base;
2300
2301	dprintk("--> %s slot %p\n", __func__, slot);
2302
 
2303	slot->sl_opcnt = resp->opcnt;
2304	slot->sl_status = resp->cstate.status;
 
 
2305
2306	slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
2307	if (nfsd4_not_cached(resp)) {
2308		slot->sl_datalen = 0;
2309		return;
2310	}
 
 
2311	base = resp->cstate.data_offset;
2312	slot->sl_datalen = buf->len - base;
2313	if (read_bytes_from_xdr_buf(buf, base, slot->sl_data, slot->sl_datalen))
2314		WARN(1, "%s: sessions DRC could not cache compound\n",
2315		     __func__);
2316	return;
2317}
2318
2319/*
2320 * Encode the replay sequence operation from the slot values.
2321 * If cachethis is FALSE encode the uncached rep error on the next
2322 * operation which sets resp->p and increments resp->opcnt for
2323 * nfs4svc_encode_compoundres.
2324 *
2325 */
2326static __be32
2327nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
2328			  struct nfsd4_compoundres *resp)
2329{
2330	struct nfsd4_op *op;
2331	struct nfsd4_slot *slot = resp->cstate.slot;
2332
2333	/* Encode the replayed sequence operation */
2334	op = &args->ops[resp->opcnt - 1];
2335	nfsd4_encode_operation(resp, op);
2336
2337	/* Return nfserr_retry_uncached_rep in next operation. */
2338	if (args->opcnt > 1 && !(slot->sl_flags & NFSD4_SLOT_CACHETHIS)) {
 
 
 
 
 
 
 
 
2339		op = &args->ops[resp->opcnt++];
2340		op->status = nfserr_retry_uncached_rep;
2341		nfsd4_encode_operation(resp, op);
2342	}
2343	return op->status;
2344}
2345
2346/*
2347 * The sequence operation is not cached because we can use the slot and
2348 * session values.
2349 */
2350static __be32
2351nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
2352			 struct nfsd4_sequence *seq)
2353{
2354	struct nfsd4_slot *slot = resp->cstate.slot;
2355	struct xdr_stream *xdr = &resp->xdr;
2356	__be32 *p;
2357	__be32 status;
2358
2359	dprintk("--> %s slot %p\n", __func__, slot);
2360
2361	status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
2362	if (status)
2363		return status;
2364
2365	p = xdr_reserve_space(xdr, slot->sl_datalen);
2366	if (!p) {
2367		WARN_ON_ONCE(1);
2368		return nfserr_serverfault;
2369	}
2370	xdr_encode_opaque_fixed(p, slot->sl_data, slot->sl_datalen);
2371	xdr_commit_encode(xdr);
2372
2373	resp->opcnt = slot->sl_opcnt;
2374	return slot->sl_status;
2375}
2376
2377/*
2378 * Set the exchange_id flags returned by the server.
2379 */
2380static void
2381nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
2382{
2383#ifdef CONFIG_NFSD_PNFS
2384	new->cl_exchange_flags |= EXCHGID4_FLAG_USE_PNFS_MDS;
2385#else
2386	new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
2387#endif
2388
2389	/* Referrals are supported, Migration is not. */
2390	new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
2391
2392	/* set the wire flags to return to client. */
2393	clid->flags = new->cl_exchange_flags;
2394}
2395
2396static bool client_has_openowners(struct nfs4_client *clp)
2397{
2398	struct nfs4_openowner *oo;
2399
2400	list_for_each_entry(oo, &clp->cl_openowners, oo_perclient) {
2401		if (!list_empty(&oo->oo_owner.so_stateids))
2402			return true;
2403	}
2404	return false;
2405}
2406
2407static bool client_has_state(struct nfs4_client *clp)
2408{
2409	return client_has_openowners(clp)
2410#ifdef CONFIG_NFSD_PNFS
2411		|| !list_empty(&clp->cl_lo_states)
2412#endif
2413		|| !list_empty(&clp->cl_delegations)
2414		|| !list_empty(&clp->cl_sessions);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2415}
2416
2417__be32
2418nfsd4_exchange_id(struct svc_rqst *rqstp,
2419		  struct nfsd4_compound_state *cstate,
2420		  struct nfsd4_exchange_id *exid)
2421{
 
2422	struct nfs4_client *conf, *new;
2423	struct nfs4_client *unconf = NULL;
2424	__be32 status;
2425	char			addr_str[INET6_ADDRSTRLEN];
2426	nfs4_verifier		verf = exid->verifier;
2427	struct sockaddr		*sa = svc_addr(rqstp);
2428	bool	update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
2429	struct nfsd_net		*nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2430
2431	rpc_ntop(sa, addr_str, sizeof(addr_str));
2432	dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
2433		"ip_addr=%s flags %x, spa_how %d\n",
2434		__func__, rqstp, exid, exid->clname.len, exid->clname.data,
2435		addr_str, exid->flags, exid->spa_how);
2436
2437	if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
2438		return nfserr_inval;
2439
2440	new = create_client(exid->clname, rqstp, &verf);
2441	if (new == NULL)
2442		return nfserr_jukebox;
 
 
 
2443
2444	switch (exid->spa_how) {
2445	case SP4_MACH_CRED:
2446		exid->spo_must_enforce[0] = 0;
2447		exid->spo_must_enforce[1] = (
2448			1 << (OP_BIND_CONN_TO_SESSION - 32) |
2449			1 << (OP_EXCHANGE_ID - 32) |
2450			1 << (OP_CREATE_SESSION - 32) |
2451			1 << (OP_DESTROY_SESSION - 32) |
2452			1 << (OP_DESTROY_CLIENTID - 32));
2453
2454		exid->spo_must_allow[0] &= (1 << (OP_CLOSE) |
2455					1 << (OP_OPEN_DOWNGRADE) |
2456					1 << (OP_LOCKU) |
2457					1 << (OP_DELEGRETURN));
2458
2459		exid->spo_must_allow[1] &= (
2460					1 << (OP_TEST_STATEID - 32) |
2461					1 << (OP_FREE_STATEID - 32));
2462		if (!svc_rqst_integrity_protected(rqstp)) {
2463			status = nfserr_inval;
2464			goto out_nolock;
2465		}
2466		/*
2467		 * Sometimes userspace doesn't give us a principal.
2468		 * Which is a bug, really.  Anyway, we can't enforce
2469		 * MACH_CRED in that case, better to give up now:
2470		 */
2471		if (!new->cl_cred.cr_principal &&
2472					!new->cl_cred.cr_raw_principal) {
2473			status = nfserr_serverfault;
2474			goto out_nolock;
2475		}
2476		new->cl_mach_cred = true;
2477	case SP4_NONE:
2478		break;
2479	default:				/* checked by xdr code */
2480		WARN_ON_ONCE(1);
 
2481	case SP4_SSV:
2482		status = nfserr_encr_alg_unsupp;
2483		goto out_nolock;
2484	}
2485
2486	/* Cases below refer to rfc 5661 section 18.35.4: */
2487	spin_lock(&nn->client_lock);
2488	conf = find_confirmed_client_by_name(&exid->clname, nn);
2489	if (conf) {
2490		bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
2491		bool verfs_match = same_verf(&verf, &conf->cl_verifier);
2492
2493		if (update) {
2494			if (!clp_used_exchangeid(conf)) { /* buggy client */
2495				status = nfserr_inval;
2496				goto out;
2497			}
2498			if (!nfsd4_mach_creds_match(conf, rqstp)) {
2499				status = nfserr_wrong_cred;
2500				goto out;
2501			}
2502			if (!creds_match) { /* case 9 */
2503				status = nfserr_perm;
2504				goto out;
2505			}
2506			if (!verfs_match) { /* case 8 */
2507				status = nfserr_not_same;
2508				goto out;
2509			}
2510			/* case 6 */
2511			exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
2512			goto out_copy;
2513		}
2514		if (!creds_match) { /* case 3 */
2515			if (client_has_state(conf)) {
2516				status = nfserr_clid_inuse;
2517				goto out;
2518			}
2519			goto out_new;
2520		}
2521		if (verfs_match) { /* case 2 */
2522			conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
2523			goto out_copy;
2524		}
2525		/* case 5, client reboot */
2526		conf = NULL;
2527		goto out_new;
2528	}
2529
2530	if (update) { /* case 7 */
2531		status = nfserr_noent;
2532		goto out;
2533	}
2534
2535	unconf  = find_unconfirmed_client_by_name(&exid->clname, nn);
2536	if (unconf) /* case 4, possible retry or client restart */
2537		unhash_client_locked(unconf);
2538
2539	/* case 1 (normal case) */
2540out_new:
2541	if (conf) {
2542		status = mark_client_expired_locked(conf);
2543		if (status)
2544			goto out;
2545	}
2546	new->cl_minorversion = cstate->minorversion;
2547	new->cl_spo_must_allow.u.words[0] = exid->spo_must_allow[0];
2548	new->cl_spo_must_allow.u.words[1] = exid->spo_must_allow[1];
2549
2550	gen_clid(new, nn);
2551	add_to_unconfirmed(new);
2552	swap(new, conf);
2553out_copy:
2554	exid->clientid.cl_boot = conf->cl_clientid.cl_boot;
2555	exid->clientid.cl_id = conf->cl_clientid.cl_id;
2556
2557	exid->seqid = conf->cl_cs_slot.sl_seqid + 1;
2558	nfsd4_set_ex_flags(conf, exid);
2559
2560	dprintk("nfsd4_exchange_id seqid %d flags %x\n",
2561		conf->cl_cs_slot.sl_seqid, conf->cl_exchange_flags);
2562	status = nfs_ok;
2563
2564out:
2565	spin_unlock(&nn->client_lock);
2566out_nolock:
2567	if (new)
2568		expire_client(new);
2569	if (unconf)
2570		expire_client(unconf);
2571	return status;
2572}
2573
2574static __be32
2575check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
2576{
2577	dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
2578		slot_seqid);
2579
2580	/* The slot is in use, and no response has been sent. */
2581	if (slot_inuse) {
2582		if (seqid == slot_seqid)
2583			return nfserr_jukebox;
2584		else
2585			return nfserr_seq_misordered;
2586	}
2587	/* Note unsigned 32-bit arithmetic handles wraparound: */
2588	if (likely(seqid == slot_seqid + 1))
2589		return nfs_ok;
2590	if (seqid == slot_seqid)
2591		return nfserr_replay_cache;
2592	return nfserr_seq_misordered;
2593}
2594
2595/*
2596 * Cache the create session result into the create session single DRC
2597 * slot cache by saving the xdr structure. sl_seqid has been set.
2598 * Do this for solo or embedded create session operations.
2599 */
2600static void
2601nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
2602			   struct nfsd4_clid_slot *slot, __be32 nfserr)
2603{
2604	slot->sl_status = nfserr;
2605	memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
2606}
2607
2608static __be32
2609nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
2610			    struct nfsd4_clid_slot *slot)
2611{
2612	memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
2613	return slot->sl_status;
2614}
2615
2616#define NFSD_MIN_REQ_HDR_SEQ_SZ	((\
2617			2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
2618			1 +	/* MIN tag is length with zero, only length */ \
2619			3 +	/* version, opcount, opcode */ \
2620			XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
2621				/* seqid, slotID, slotID, cache */ \
2622			4 ) * sizeof(__be32))
2623
2624#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
2625			2 +	/* verifier: AUTH_NULL, length 0 */\
2626			1 +	/* status */ \
2627			1 +	/* MIN tag is length with zero, only length */ \
2628			3 +	/* opcount, opcode, opstatus*/ \
2629			XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
2630				/* seqid, slotID, slotID, slotID, status */ \
2631			5 ) * sizeof(__be32))
2632
2633static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
2634{
2635	u32 maxrpc = nn->nfsd_serv->sv_max_mesg;
2636
2637	if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
2638		return nfserr_toosmall;
2639	if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
2640		return nfserr_toosmall;
2641	ca->headerpadsz = 0;
2642	ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
2643	ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
2644	ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
2645	ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
2646			NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
2647	ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
2648	/*
2649	 * Note decreasing slot size below client's request may make it
2650	 * difficult for client to function correctly, whereas
2651	 * decreasing the number of slots will (just?) affect
2652	 * performance.  When short on memory we therefore prefer to
2653	 * decrease number of slots instead of their size.  Clients that
2654	 * request larger slots than they need will get poor results:
 
 
2655	 */
2656	ca->maxreqs = nfsd4_get_drc_mem(ca);
2657	if (!ca->maxreqs)
2658		return nfserr_jukebox;
2659
2660	return nfs_ok;
2661}
2662
2663/*
2664 * Server's NFSv4.1 backchannel support is AUTH_SYS-only for now.
2665 * These are based on similar macros in linux/sunrpc/msg_prot.h .
2666 */
2667#define RPC_MAX_HEADER_WITH_AUTH_SYS \
2668	(RPC_CALLHDRSIZE + 2 * (2 + UNX_CALLSLACK))
2669
2670#define RPC_MAX_REPHEADER_WITH_AUTH_SYS \
2671	(RPC_REPHDRSIZE + (2 + NUL_REPLYSLACK))
2672
2673#define NFSD_CB_MAX_REQ_SZ	((NFS4_enc_cb_recall_sz + \
2674				 RPC_MAX_HEADER_WITH_AUTH_SYS) * sizeof(__be32))
2675#define NFSD_CB_MAX_RESP_SZ	((NFS4_dec_cb_recall_sz + \
2676				 RPC_MAX_REPHEADER_WITH_AUTH_SYS) * \
2677				 sizeof(__be32))
2678
2679static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
2680{
2681	ca->headerpadsz = 0;
2682
2683	if (ca->maxreq_sz < NFSD_CB_MAX_REQ_SZ)
2684		return nfserr_toosmall;
2685	if (ca->maxresp_sz < NFSD_CB_MAX_RESP_SZ)
2686		return nfserr_toosmall;
2687	ca->maxresp_cached = 0;
2688	if (ca->maxops < 2)
2689		return nfserr_toosmall;
2690
2691	return nfs_ok;
2692}
2693
2694static __be32 nfsd4_check_cb_sec(struct nfsd4_cb_sec *cbs)
2695{
2696	switch (cbs->flavor) {
2697	case RPC_AUTH_NULL:
2698	case RPC_AUTH_UNIX:
2699		return nfs_ok;
2700	default:
2701		/*
2702		 * GSS case: the spec doesn't allow us to return this
2703		 * error.  But it also doesn't allow us not to support
2704		 * GSS.
2705		 * I'd rather this fail hard than return some error the
2706		 * client might think it can already handle:
2707		 */
2708		return nfserr_encr_alg_unsupp;
2709	}
2710}
2711
2712__be32
2713nfsd4_create_session(struct svc_rqst *rqstp,
2714		     struct nfsd4_compound_state *cstate,
2715		     struct nfsd4_create_session *cr_ses)
2716{
 
2717	struct sockaddr *sa = svc_addr(rqstp);
2718	struct nfs4_client *conf, *unconf;
2719	struct nfs4_client *old = NULL;
2720	struct nfsd4_session *new;
2721	struct nfsd4_conn *conn;
2722	struct nfsd4_clid_slot *cs_slot = NULL;
2723	__be32 status = 0;
2724	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2725
2726	if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
2727		return nfserr_inval;
2728	status = nfsd4_check_cb_sec(&cr_ses->cb_sec);
2729	if (status)
2730		return status;
2731	status = check_forechannel_attrs(&cr_ses->fore_channel, nn);
2732	if (status)
2733		return status;
2734	status = check_backchannel_attrs(&cr_ses->back_channel);
2735	if (status)
2736		goto out_release_drc_mem;
2737	status = nfserr_jukebox;
2738	new = alloc_session(&cr_ses->fore_channel, &cr_ses->back_channel);
2739	if (!new)
2740		goto out_release_drc_mem;
2741	conn = alloc_conn_from_crses(rqstp, cr_ses);
2742	if (!conn)
2743		goto out_free_session;
2744
2745	spin_lock(&nn->client_lock);
2746	unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
2747	conf = find_confirmed_client(&cr_ses->clientid, true, nn);
2748	WARN_ON_ONCE(conf && unconf);
2749
2750	if (conf) {
2751		status = nfserr_wrong_cred;
2752		if (!nfsd4_mach_creds_match(conf, rqstp))
2753			goto out_free_conn;
2754		cs_slot = &conf->cl_cs_slot;
2755		status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
2756		if (status) {
2757			if (status == nfserr_replay_cache)
2758				status = nfsd4_replay_create_session(cr_ses, cs_slot);
2759			goto out_free_conn;
2760		}
2761	} else if (unconf) {
2762		if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
2763		    !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
2764			status = nfserr_clid_inuse;
2765			goto out_free_conn;
2766		}
2767		status = nfserr_wrong_cred;
2768		if (!nfsd4_mach_creds_match(unconf, rqstp))
2769			goto out_free_conn;
2770		cs_slot = &unconf->cl_cs_slot;
2771		status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
2772		if (status) {
2773			/* an unconfirmed replay returns misordered */
2774			status = nfserr_seq_misordered;
2775			goto out_free_conn;
2776		}
2777		old = find_confirmed_client_by_name(&unconf->cl_name, nn);
2778		if (old) {
2779			status = mark_client_expired_locked(old);
2780			if (status) {
2781				old = NULL;
2782				goto out_free_conn;
2783			}
2784		}
2785		move_to_confirmed(unconf);
2786		conf = unconf;
2787	} else {
2788		status = nfserr_stale_clientid;
2789		goto out_free_conn;
2790	}
2791	status = nfs_ok;
2792	/* Persistent sessions are not supported */
2793	cr_ses->flags &= ~SESSION4_PERSIST;
2794	/* Upshifting from TCP to RDMA is not supported */
2795	cr_ses->flags &= ~SESSION4_RDMA;
2796
2797	init_session(rqstp, new, conf, cr_ses);
2798	nfsd4_get_session_locked(new);
2799
2800	memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
2801	       NFS4_MAX_SESSIONID_LEN);
2802	cs_slot->sl_seqid++;
2803	cr_ses->seqid = cs_slot->sl_seqid;
2804
2805	/* cache solo and embedded create sessions under the client_lock */
2806	nfsd4_cache_create_session(cr_ses, cs_slot, status);
2807	spin_unlock(&nn->client_lock);
2808	/* init connection and backchannel */
2809	nfsd4_init_conn(rqstp, conn, new);
2810	nfsd4_put_session(new);
2811	if (old)
2812		expire_client(old);
2813	return status;
2814out_free_conn:
2815	spin_unlock(&nn->client_lock);
2816	free_conn(conn);
2817	if (old)
2818		expire_client(old);
2819out_free_session:
2820	__free_session(new);
2821out_release_drc_mem:
2822	nfsd4_put_drc_mem(&cr_ses->fore_channel);
2823	return status;
2824}
2825
2826static __be32 nfsd4_map_bcts_dir(u32 *dir)
2827{
2828	switch (*dir) {
2829	case NFS4_CDFC4_FORE:
2830	case NFS4_CDFC4_BACK:
2831		return nfs_ok;
2832	case NFS4_CDFC4_FORE_OR_BOTH:
2833	case NFS4_CDFC4_BACK_OR_BOTH:
2834		*dir = NFS4_CDFC4_BOTH;
2835		return nfs_ok;
2836	};
2837	return nfserr_inval;
2838}
2839
2840__be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_backchannel_ctl *bc)
 
 
2841{
 
2842	struct nfsd4_session *session = cstate->session;
2843	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2844	__be32 status;
2845
2846	status = nfsd4_check_cb_sec(&bc->bc_cb_sec);
2847	if (status)
2848		return status;
2849	spin_lock(&nn->client_lock);
2850	session->se_cb_prog = bc->bc_cb_program;
2851	session->se_cb_sec = bc->bc_cb_sec;
2852	spin_unlock(&nn->client_lock);
2853
2854	nfsd4_probe_callback(session->se_client);
2855
2856	return nfs_ok;
2857}
2858
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2859__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
2860		     struct nfsd4_compound_state *cstate,
2861		     struct nfsd4_bind_conn_to_session *bcts)
2862{
 
2863	__be32 status;
2864	struct nfsd4_conn *conn;
2865	struct nfsd4_session *session;
2866	struct net *net = SVC_NET(rqstp);
2867	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2868
2869	if (!nfsd4_last_compound_op(rqstp))
2870		return nfserr_not_only_op;
2871	spin_lock(&nn->client_lock);
2872	session = find_in_sessionid_hashtbl(&bcts->sessionid, net, &status);
2873	spin_unlock(&nn->client_lock);
2874	if (!session)
2875		goto out_no_session;
2876	status = nfserr_wrong_cred;
2877	if (!nfsd4_mach_creds_match(session->se_client, rqstp))
2878		goto out;
 
 
 
2879	status = nfsd4_map_bcts_dir(&bcts->dir);
2880	if (status)
2881		goto out;
2882	conn = alloc_conn(rqstp, bcts->dir);
2883	status = nfserr_jukebox;
2884	if (!conn)
2885		goto out;
2886	nfsd4_init_conn(rqstp, conn, session);
2887	status = nfs_ok;
2888out:
2889	nfsd4_put_session(session);
2890out_no_session:
2891	return status;
2892}
2893
2894static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
2895{
2896	if (!session)
2897		return 0;
2898	return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
2899}
2900
2901__be32
2902nfsd4_destroy_session(struct svc_rqst *r,
2903		      struct nfsd4_compound_state *cstate,
2904		      struct nfsd4_destroy_session *sessionid)
2905{
 
2906	struct nfsd4_session *ses;
2907	__be32 status;
2908	int ref_held_by_me = 0;
2909	struct net *net = SVC_NET(r);
2910	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2911
2912	status = nfserr_not_only_op;
2913	if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
2914		if (!nfsd4_last_compound_op(r))
2915			goto out;
2916		ref_held_by_me++;
2917	}
2918	dump_sessionid(__func__, &sessionid->sessionid);
2919	spin_lock(&nn->client_lock);
2920	ses = find_in_sessionid_hashtbl(&sessionid->sessionid, net, &status);
2921	if (!ses)
2922		goto out_client_lock;
2923	status = nfserr_wrong_cred;
2924	if (!nfsd4_mach_creds_match(ses->se_client, r))
2925		goto out_put_session;
2926	status = mark_session_dead_locked(ses, 1 + ref_held_by_me);
2927	if (status)
2928		goto out_put_session;
2929	unhash_session(ses);
2930	spin_unlock(&nn->client_lock);
2931
2932	nfsd4_probe_callback_sync(ses->se_client);
2933
2934	spin_lock(&nn->client_lock);
2935	status = nfs_ok;
2936out_put_session:
2937	nfsd4_put_session_locked(ses);
2938out_client_lock:
2939	spin_unlock(&nn->client_lock);
2940out:
2941	return status;
2942}
2943
2944static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
2945{
2946	struct nfsd4_conn *c;
2947
2948	list_for_each_entry(c, &s->se_conns, cn_persession) {
2949		if (c->cn_xprt == xpt) {
2950			return c;
2951		}
2952	}
2953	return NULL;
2954}
2955
2956static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
2957{
2958	struct nfs4_client *clp = ses->se_client;
2959	struct nfsd4_conn *c;
2960	__be32 status = nfs_ok;
2961	int ret;
2962
2963	spin_lock(&clp->cl_lock);
2964	c = __nfsd4_find_conn(new->cn_xprt, ses);
2965	if (c)
2966		goto out_free;
2967	status = nfserr_conn_not_bound_to_session;
2968	if (clp->cl_mach_cred)
2969		goto out_free;
2970	__nfsd4_hash_conn(new, ses);
2971	spin_unlock(&clp->cl_lock);
2972	ret = nfsd4_register_conn(new);
2973	if (ret)
2974		/* oops; xprt is already down: */
2975		nfsd4_conn_lost(&new->cn_xpt_user);
2976	return nfs_ok;
2977out_free:
2978	spin_unlock(&clp->cl_lock);
2979	free_conn(new);
2980	return status;
2981}
2982
2983static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
2984{
2985	struct nfsd4_compoundargs *args = rqstp->rq_argp;
2986
2987	return args->opcnt > session->se_fchannel.maxops;
2988}
2989
2990static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
2991				  struct nfsd4_session *session)
2992{
2993	struct xdr_buf *xb = &rqstp->rq_arg;
2994
2995	return xb->len > session->se_fchannel.maxreq_sz;
2996}
2997
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2998__be32
2999nfsd4_sequence(struct svc_rqst *rqstp,
3000	       struct nfsd4_compound_state *cstate,
3001	       struct nfsd4_sequence *seq)
3002{
 
3003	struct nfsd4_compoundres *resp = rqstp->rq_resp;
3004	struct xdr_stream *xdr = &resp->xdr;
3005	struct nfsd4_session *session;
3006	struct nfs4_client *clp;
3007	struct nfsd4_slot *slot;
3008	struct nfsd4_conn *conn;
3009	__be32 status;
3010	int buflen;
3011	struct net *net = SVC_NET(rqstp);
3012	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
3013
3014	if (resp->opcnt != 1)
3015		return nfserr_sequence_pos;
3016
3017	/*
3018	 * Will be either used or freed by nfsd4_sequence_check_conn
3019	 * below.
3020	 */
3021	conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
3022	if (!conn)
3023		return nfserr_jukebox;
3024
3025	spin_lock(&nn->client_lock);
3026	session = find_in_sessionid_hashtbl(&seq->sessionid, net, &status);
3027	if (!session)
3028		goto out_no_session;
3029	clp = session->se_client;
3030
3031	status = nfserr_too_many_ops;
3032	if (nfsd4_session_too_many_ops(rqstp, session))
3033		goto out_put_session;
3034
3035	status = nfserr_req_too_big;
3036	if (nfsd4_request_too_big(rqstp, session))
3037		goto out_put_session;
3038
3039	status = nfserr_badslot;
3040	if (seq->slotid >= session->se_fchannel.maxreqs)
3041		goto out_put_session;
3042
3043	slot = session->se_slots[seq->slotid];
3044	dprintk("%s: slotid %d\n", __func__, seq->slotid);
3045
3046	/* We do not negotiate the number of slots yet, so set the
3047	 * maxslots to the session maxreqs which is used to encode
3048	 * sr_highest_slotid and the sr_target_slot id to maxslots */
3049	seq->maxslots = session->se_fchannel.maxreqs;
3050
3051	status = check_slot_seqid(seq->seqid, slot->sl_seqid,
3052					slot->sl_flags & NFSD4_SLOT_INUSE);
3053	if (status == nfserr_replay_cache) {
3054		status = nfserr_seq_misordered;
3055		if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
3056			goto out_put_session;
 
 
 
3057		cstate->slot = slot;
3058		cstate->session = session;
3059		cstate->clp = clp;
3060		/* Return the cached reply status and set cstate->status
3061		 * for nfsd4_proc_compound processing */
3062		status = nfsd4_replay_cache_entry(resp, seq);
3063		cstate->status = nfserr_replay_cache;
3064		goto out;
3065	}
3066	if (status)
3067		goto out_put_session;
3068
3069	status = nfsd4_sequence_check_conn(conn, session);
3070	conn = NULL;
3071	if (status)
3072		goto out_put_session;
3073
3074	buflen = (seq->cachethis) ?
3075			session->se_fchannel.maxresp_cached :
3076			session->se_fchannel.maxresp_sz;
3077	status = (seq->cachethis) ? nfserr_rep_too_big_to_cache :
3078				    nfserr_rep_too_big;
3079	if (xdr_restrict_buflen(xdr, buflen - rqstp->rq_auth_slack))
3080		goto out_put_session;
3081	svc_reserve(rqstp, buflen);
3082
3083	status = nfs_ok;
3084	/* Success! bump slot seqid */
3085	slot->sl_seqid = seq->seqid;
3086	slot->sl_flags |= NFSD4_SLOT_INUSE;
3087	if (seq->cachethis)
3088		slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
3089	else
3090		slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
3091
3092	cstate->slot = slot;
3093	cstate->session = session;
3094	cstate->clp = clp;
3095
3096out:
3097	switch (clp->cl_cb_state) {
3098	case NFSD4_CB_DOWN:
3099		seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
3100		break;
3101	case NFSD4_CB_FAULT:
3102		seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
3103		break;
3104	default:
3105		seq->status_flags = 0;
3106	}
3107	if (!list_empty(&clp->cl_revoked))
3108		seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
3109out_no_session:
3110	if (conn)
3111		free_conn(conn);
3112	spin_unlock(&nn->client_lock);
3113	return status;
3114out_put_session:
3115	nfsd4_put_session_locked(session);
3116	goto out_no_session;
3117}
3118
3119void
3120nfsd4_sequence_done(struct nfsd4_compoundres *resp)
3121{
3122	struct nfsd4_compound_state *cs = &resp->cstate;
3123
3124	if (nfsd4_has_session(cs)) {
3125		if (cs->status != nfserr_replay_cache) {
3126			nfsd4_store_cache_entry(resp);
3127			cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE;
3128		}
3129		/* Drop session reference that was taken in nfsd4_sequence() */
3130		nfsd4_put_session(cs->session);
3131	} else if (cs->clp)
3132		put_client_renew(cs->clp);
3133}
3134
3135__be32
3136nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
 
 
3137{
 
3138	struct nfs4_client *conf, *unconf;
3139	struct nfs4_client *clp = NULL;
3140	__be32 status = 0;
3141	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3142
3143	spin_lock(&nn->client_lock);
3144	unconf = find_unconfirmed_client(&dc->clientid, true, nn);
3145	conf = find_confirmed_client(&dc->clientid, true, nn);
3146	WARN_ON_ONCE(conf && unconf);
3147
3148	if (conf) {
3149		if (client_has_state(conf)) {
3150			status = nfserr_clientid_busy;
3151			goto out;
3152		}
3153		status = mark_client_expired_locked(conf);
3154		if (status)
3155			goto out;
3156		clp = conf;
3157	} else if (unconf)
3158		clp = unconf;
3159	else {
3160		status = nfserr_stale_clientid;
3161		goto out;
3162	}
3163	if (!nfsd4_mach_creds_match(clp, rqstp)) {
3164		clp = NULL;
3165		status = nfserr_wrong_cred;
3166		goto out;
3167	}
3168	unhash_client_locked(clp);
3169out:
3170	spin_unlock(&nn->client_lock);
3171	if (clp)
3172		expire_client(clp);
3173	return status;
3174}
3175
3176__be32
3177nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
 
3178{
 
3179	__be32 status = 0;
3180
3181	if (rc->rca_one_fs) {
3182		if (!cstate->current_fh.fh_dentry)
3183			return nfserr_nofilehandle;
3184		/*
3185		 * We don't take advantage of the rca_one_fs case.
3186		 * That's OK, it's optional, we can safely ignore it.
3187		 */
3188		return nfs_ok;
3189	}
3190
3191	status = nfserr_complete_already;
3192	if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
3193			     &cstate->session->se_client->cl_flags))
3194		goto out;
3195
3196	status = nfserr_stale_clientid;
3197	if (is_client_expired(cstate->session->se_client))
3198		/*
3199		 * The following error isn't really legal.
3200		 * But we only get here if the client just explicitly
3201		 * destroyed the client.  Surely it no longer cares what
3202		 * error it gets back on an operation for the dead
3203		 * client.
3204		 */
3205		goto out;
3206
3207	status = nfs_ok;
3208	nfsd4_client_record_create(cstate->session->se_client);
 
3209out:
3210	return status;
3211}
3212
3213__be32
3214nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3215		  struct nfsd4_setclientid *setclid)
3216{
 
3217	struct xdr_netobj 	clname = setclid->se_name;
3218	nfs4_verifier		clverifier = setclid->se_verf;
3219	struct nfs4_client	*conf, *new;
3220	struct nfs4_client	*unconf = NULL;
3221	__be32 			status;
3222	struct nfsd_net		*nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3223
3224	new = create_client(clname, rqstp, &clverifier);
3225	if (new == NULL)
3226		return nfserr_jukebox;
3227	/* Cases below refer to rfc 3530 section 14.2.33: */
3228	spin_lock(&nn->client_lock);
3229	conf = find_confirmed_client_by_name(&clname, nn);
3230	if (conf && client_has_state(conf)) {
3231		/* case 0: */
3232		status = nfserr_clid_inuse;
3233		if (clp_used_exchangeid(conf))
3234			goto out;
3235		if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
3236			char addr_str[INET6_ADDRSTRLEN];
3237			rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
3238				 sizeof(addr_str));
3239			dprintk("NFSD: setclientid: string in use by client "
3240				"at %s\n", addr_str);
3241			goto out;
3242		}
3243	}
3244	unconf = find_unconfirmed_client_by_name(&clname, nn);
3245	if (unconf)
3246		unhash_client_locked(unconf);
 
3247	if (conf && same_verf(&conf->cl_verifier, &clverifier)) {
3248		/* case 1: probable callback update */
3249		copy_clid(new, conf);
3250		gen_confirm(new, nn);
3251	} else /* case 4 (new client) or cases 2, 3 (client reboot): */
3252		gen_clid(new, nn);
3253	new->cl_minorversion = 0;
3254	gen_callback(new, setclid, rqstp);
3255	add_to_unconfirmed(new);
3256	setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
3257	setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
3258	memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
3259	new = NULL;
3260	status = nfs_ok;
3261out:
3262	spin_unlock(&nn->client_lock);
3263	if (new)
3264		free_client(new);
3265	if (unconf)
3266		expire_client(unconf);
3267	return status;
3268}
3269
3270
3271__be32
3272nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
3273			 struct nfsd4_compound_state *cstate,
3274			 struct nfsd4_setclientid_confirm *setclientid_confirm)
3275{
 
 
3276	struct nfs4_client *conf, *unconf;
3277	struct nfs4_client *old = NULL;
3278	nfs4_verifier confirm = setclientid_confirm->sc_confirm; 
3279	clientid_t * clid = &setclientid_confirm->sc_clientid;
3280	__be32 status;
3281	struct nfsd_net	*nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3282
3283	if (STALE_CLIENTID(clid, nn))
3284		return nfserr_stale_clientid;
3285
3286	spin_lock(&nn->client_lock);
3287	conf = find_confirmed_client(clid, false, nn);
3288	unconf = find_unconfirmed_client(clid, false, nn);
3289	/*
3290	 * We try hard to give out unique clientid's, so if we get an
3291	 * attempt to confirm the same clientid with a different cred,
3292	 * the client may be buggy; this should never happen.
3293	 *
3294	 * Nevertheless, RFC 7530 recommends INUSE for this case:
3295	 */
3296	status = nfserr_clid_inuse;
3297	if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred))
3298		goto out;
3299	if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred))
3300		goto out;
3301	/* cases below refer to rfc 3530 section 14.2.34: */
3302	if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
3303		if (conf && same_verf(&confirm, &conf->cl_confirm)) {
3304			/* case 2: probable retransmit */
3305			status = nfs_ok;
3306		} else /* case 4: client hasn't noticed we rebooted yet? */
3307			status = nfserr_stale_clientid;
3308		goto out;
3309	}
3310	status = nfs_ok;
3311	if (conf) { /* case 1: callback update */
3312		old = unconf;
3313		unhash_client_locked(old);
3314		nfsd4_change_callback(conf, &unconf->cl_cb_conn);
3315	} else { /* case 3: normal case; new or rebooted client */
3316		old = find_confirmed_client_by_name(&unconf->cl_name, nn);
3317		if (old) {
3318			status = nfserr_clid_inuse;
3319			if (client_has_state(old)
3320					&& !same_creds(&unconf->cl_cred,
3321							&old->cl_cred))
3322				goto out;
3323			status = mark_client_expired_locked(old);
3324			if (status) {
3325				old = NULL;
3326				goto out;
3327			}
3328		}
3329		move_to_confirmed(unconf);
3330		conf = unconf;
3331	}
3332	get_client_locked(conf);
3333	spin_unlock(&nn->client_lock);
3334	nfsd4_probe_callback(conf);
3335	spin_lock(&nn->client_lock);
3336	put_client_renew_locked(conf);
3337out:
3338	spin_unlock(&nn->client_lock);
3339	if (old)
3340		expire_client(old);
3341	return status;
3342}
3343
3344static struct nfs4_file *nfsd4_alloc_file(void)
3345{
3346	return kmem_cache_alloc(file_slab, GFP_KERNEL);
3347}
3348
3349/* OPEN Share state helper functions */
3350static void nfsd4_init_file(struct knfsd_fh *fh, unsigned int hashval,
3351				struct nfs4_file *fp)
3352{
3353	lockdep_assert_held(&state_lock);
3354
3355	atomic_set(&fp->fi_ref, 1);
3356	spin_lock_init(&fp->fi_lock);
3357	INIT_LIST_HEAD(&fp->fi_stateids);
3358	INIT_LIST_HEAD(&fp->fi_delegations);
3359	INIT_LIST_HEAD(&fp->fi_clnt_odstate);
3360	fh_copy_shallow(&fp->fi_fhandle, fh);
3361	fp->fi_deleg_file = NULL;
3362	fp->fi_had_conflict = false;
3363	fp->fi_share_deny = 0;
3364	memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
3365	memset(fp->fi_access, 0, sizeof(fp->fi_access));
3366#ifdef CONFIG_NFSD_PNFS
3367	INIT_LIST_HEAD(&fp->fi_lo_states);
3368	atomic_set(&fp->fi_lo_recalls, 0);
3369#endif
3370	hlist_add_head_rcu(&fp->fi_hash, &file_hashtbl[hashval]);
3371}
3372
3373void
3374nfsd4_free_slabs(void)
3375{
3376	kmem_cache_destroy(odstate_slab);
3377	kmem_cache_destroy(openowner_slab);
3378	kmem_cache_destroy(lockowner_slab);
3379	kmem_cache_destroy(file_slab);
3380	kmem_cache_destroy(stateid_slab);
3381	kmem_cache_destroy(deleg_slab);
 
3382}
3383
3384int
3385nfsd4_init_slabs(void)
3386{
 
 
 
 
3387	openowner_slab = kmem_cache_create("nfsd4_openowners",
3388			sizeof(struct nfs4_openowner), 0, 0, NULL);
3389	if (openowner_slab == NULL)
3390		goto out;
3391	lockowner_slab = kmem_cache_create("nfsd4_lockowners",
3392			sizeof(struct nfs4_lockowner), 0, 0, NULL);
3393	if (lockowner_slab == NULL)
3394		goto out_free_openowner_slab;
3395	file_slab = kmem_cache_create("nfsd4_files",
3396			sizeof(struct nfs4_file), 0, 0, NULL);
3397	if (file_slab == NULL)
3398		goto out_free_lockowner_slab;
3399	stateid_slab = kmem_cache_create("nfsd4_stateids",
3400			sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
3401	if (stateid_slab == NULL)
3402		goto out_free_file_slab;
3403	deleg_slab = kmem_cache_create("nfsd4_delegations",
3404			sizeof(struct nfs4_delegation), 0, 0, NULL);
3405	if (deleg_slab == NULL)
3406		goto out_free_stateid_slab;
3407	odstate_slab = kmem_cache_create("nfsd4_odstate",
3408			sizeof(struct nfs4_clnt_odstate), 0, 0, NULL);
3409	if (odstate_slab == NULL)
3410		goto out_free_deleg_slab;
3411	return 0;
3412
3413out_free_deleg_slab:
3414	kmem_cache_destroy(deleg_slab);
3415out_free_stateid_slab:
3416	kmem_cache_destroy(stateid_slab);
3417out_free_file_slab:
3418	kmem_cache_destroy(file_slab);
3419out_free_lockowner_slab:
3420	kmem_cache_destroy(lockowner_slab);
3421out_free_openowner_slab:
3422	kmem_cache_destroy(openowner_slab);
 
 
3423out:
3424	dprintk("nfsd4: out of memory while initializing nfsv4\n");
3425	return -ENOMEM;
3426}
3427
3428static void init_nfs4_replay(struct nfs4_replay *rp)
3429{
3430	rp->rp_status = nfserr_serverfault;
3431	rp->rp_buflen = 0;
3432	rp->rp_buf = rp->rp_ibuf;
3433	mutex_init(&rp->rp_mutex);
3434}
3435
3436static void nfsd4_cstate_assign_replay(struct nfsd4_compound_state *cstate,
3437		struct nfs4_stateowner *so)
3438{
3439	if (!nfsd4_has_session(cstate)) {
3440		mutex_lock(&so->so_replay.rp_mutex);
3441		cstate->replay_owner = nfs4_get_stateowner(so);
3442	}
3443}
3444
3445void nfsd4_cstate_clear_replay(struct nfsd4_compound_state *cstate)
3446{
3447	struct nfs4_stateowner *so = cstate->replay_owner;
3448
3449	if (so != NULL) {
3450		cstate->replay_owner = NULL;
3451		mutex_unlock(&so->so_replay.rp_mutex);
3452		nfs4_put_stateowner(so);
3453	}
3454}
3455
3456static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
3457{
3458	struct nfs4_stateowner *sop;
3459
3460	sop = kmem_cache_alloc(slab, GFP_KERNEL);
3461	if (!sop)
3462		return NULL;
3463
3464	sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
3465	if (!sop->so_owner.data) {
3466		kmem_cache_free(slab, sop);
3467		return NULL;
3468	}
3469	sop->so_owner.len = owner->len;
3470
3471	INIT_LIST_HEAD(&sop->so_stateids);
3472	sop->so_client = clp;
3473	init_nfs4_replay(&sop->so_replay);
3474	atomic_set(&sop->so_count, 1);
3475	return sop;
3476}
3477
3478static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
3479{
3480	lockdep_assert_held(&clp->cl_lock);
3481
3482	list_add(&oo->oo_owner.so_strhash,
3483		 &clp->cl_ownerstr_hashtbl[strhashval]);
3484	list_add(&oo->oo_perclient, &clp->cl_openowners);
3485}
3486
3487static void nfs4_unhash_openowner(struct nfs4_stateowner *so)
3488{
3489	unhash_openowner_locked(openowner(so));
3490}
3491
3492static void nfs4_free_openowner(struct nfs4_stateowner *so)
3493{
3494	struct nfs4_openowner *oo = openowner(so);
3495
3496	kmem_cache_free(openowner_slab, oo);
3497}
3498
3499static const struct nfs4_stateowner_operations openowner_ops = {
3500	.so_unhash =	nfs4_unhash_openowner,
3501	.so_free =	nfs4_free_openowner,
3502};
3503
3504static struct nfs4_ol_stateid *
3505nfsd4_find_existing_open(struct nfs4_file *fp, struct nfsd4_open *open)
3506{
3507	struct nfs4_ol_stateid *local, *ret = NULL;
3508	struct nfs4_openowner *oo = open->op_openowner;
3509
3510	lockdep_assert_held(&fp->fi_lock);
3511
3512	list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
3513		/* ignore lock owners */
3514		if (local->st_stateowner->so_is_open_owner == 0)
3515			continue;
3516		if (local->st_stateowner == &oo->oo_owner) {
 
 
3517			ret = local;
3518			atomic_inc(&ret->st_stid.sc_count);
3519			break;
3520		}
3521	}
3522	return ret;
3523}
3524
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3525static struct nfs4_openowner *
3526alloc_init_open_stateowner(unsigned int strhashval, struct nfsd4_open *open,
3527			   struct nfsd4_compound_state *cstate)
3528{
3529	struct nfs4_client *clp = cstate->clp;
3530	struct nfs4_openowner *oo, *ret;
3531
3532	oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
3533	if (!oo)
3534		return NULL;
3535	oo->oo_owner.so_ops = &openowner_ops;
3536	oo->oo_owner.so_is_open_owner = 1;
3537	oo->oo_owner.so_seqid = open->op_seqid;
3538	oo->oo_flags = 0;
3539	if (nfsd4_has_session(cstate))
3540		oo->oo_flags |= NFS4_OO_CONFIRMED;
3541	oo->oo_time = 0;
3542	oo->oo_last_closed_stid = NULL;
3543	INIT_LIST_HEAD(&oo->oo_close_lru);
3544	spin_lock(&clp->cl_lock);
3545	ret = find_openstateowner_str_locked(strhashval, open, clp);
3546	if (ret == NULL) {
3547		hash_openowner(oo, clp, strhashval);
3548		ret = oo;
3549	} else
3550		nfs4_free_stateowner(&oo->oo_owner);
3551
3552	spin_unlock(&clp->cl_lock);
3553	return ret;
3554}
3555
3556static struct nfs4_ol_stateid *
3557init_open_stateid(struct nfs4_file *fp, struct nfsd4_open *open)
3558{
3559
3560	struct nfs4_openowner *oo = open->op_openowner;
3561	struct nfs4_ol_stateid *retstp = NULL;
3562	struct nfs4_ol_stateid *stp;
3563
3564	stp = open->op_stp;
3565	/* We are moving these outside of the spinlocks to avoid the warnings */
3566	mutex_init(&stp->st_mutex);
3567	mutex_lock(&stp->st_mutex);
3568
 
3569	spin_lock(&oo->oo_owner.so_client->cl_lock);
3570	spin_lock(&fp->fi_lock);
3571
3572	retstp = nfsd4_find_existing_open(fp, open);
3573	if (retstp)
3574		goto out_unlock;
3575
3576	open->op_stp = NULL;
3577	atomic_inc(&stp->st_stid.sc_count);
3578	stp->st_stid.sc_type = NFS4_OPEN_STID;
3579	INIT_LIST_HEAD(&stp->st_locks);
3580	stp->st_stateowner = nfs4_get_stateowner(&oo->oo_owner);
3581	get_nfs4_file(fp);
3582	stp->st_stid.sc_file = fp;
3583	stp->st_access_bmap = 0;
3584	stp->st_deny_bmap = 0;
3585	stp->st_openstp = NULL;
3586	list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
3587	list_add(&stp->st_perfile, &fp->fi_stateids);
3588
3589out_unlock:
3590	spin_unlock(&fp->fi_lock);
3591	spin_unlock(&oo->oo_owner.so_client->cl_lock);
3592	if (retstp) {
3593		mutex_lock(&retstp->st_mutex);
 
 
 
 
3594		/* To keep mutex tracking happy */
3595		mutex_unlock(&stp->st_mutex);
3596		stp = retstp;
3597	}
3598	return stp;
3599}
3600
3601/*
3602 * In the 4.0 case we need to keep the owners around a little while to handle
3603 * CLOSE replay. We still do need to release any file access that is held by
3604 * them before returning however.
3605 */
3606static void
3607move_to_close_lru(struct nfs4_ol_stateid *s, struct net *net)
3608{
3609	struct nfs4_ol_stateid *last;
3610	struct nfs4_openowner *oo = openowner(s->st_stateowner);
3611	struct nfsd_net *nn = net_generic(s->st_stid.sc_client->net,
3612						nfsd_net_id);
3613
3614	dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
3615
3616	/*
3617	 * We know that we hold one reference via nfsd4_close, and another
3618	 * "persistent" reference for the client. If the refcount is higher
3619	 * than 2, then there are still calls in progress that are using this
3620	 * stateid. We can't put the sc_file reference until they are finished.
3621	 * Wait for the refcount to drop to 2. Since it has been unhashed,
3622	 * there should be no danger of the refcount going back up again at
3623	 * this point.
3624	 */
3625	wait_event(close_wq, atomic_read(&s->st_stid.sc_count) == 2);
3626
3627	release_all_access(s);
3628	if (s->st_stid.sc_file) {
3629		put_nfs4_file(s->st_stid.sc_file);
3630		s->st_stid.sc_file = NULL;
3631	}
3632
3633	spin_lock(&nn->client_lock);
3634	last = oo->oo_last_closed_stid;
3635	oo->oo_last_closed_stid = s;
3636	list_move_tail(&oo->oo_close_lru, &nn->close_lru);
3637	oo->oo_time = get_seconds();
3638	spin_unlock(&nn->client_lock);
3639	if (last)
3640		nfs4_put_stid(&last->st_stid);
3641}
3642
3643/* search file_hashtbl[] for file */
3644static struct nfs4_file *
3645find_file_locked(struct knfsd_fh *fh, unsigned int hashval)
3646{
3647	struct nfs4_file *fp;
3648
3649	hlist_for_each_entry_rcu(fp, &file_hashtbl[hashval], fi_hash) {
 
3650		if (fh_match(&fp->fi_fhandle, fh)) {
3651			if (atomic_inc_not_zero(&fp->fi_ref))
3652				return fp;
3653		}
3654	}
3655	return NULL;
3656}
3657
3658struct nfs4_file *
3659find_file(struct knfsd_fh *fh)
3660{
3661	struct nfs4_file *fp;
3662	unsigned int hashval = file_hashval(fh);
3663
3664	rcu_read_lock();
3665	fp = find_file_locked(fh, hashval);
3666	rcu_read_unlock();
3667	return fp;
3668}
3669
3670static struct nfs4_file *
3671find_or_add_file(struct nfs4_file *new, struct knfsd_fh *fh)
3672{
3673	struct nfs4_file *fp;
3674	unsigned int hashval = file_hashval(fh);
3675
3676	rcu_read_lock();
3677	fp = find_file_locked(fh, hashval);
3678	rcu_read_unlock();
3679	if (fp)
3680		return fp;
3681
3682	spin_lock(&state_lock);
3683	fp = find_file_locked(fh, hashval);
3684	if (likely(fp == NULL)) {
3685		nfsd4_init_file(fh, hashval, new);
3686		fp = new;
3687	}
3688	spin_unlock(&state_lock);
3689
3690	return fp;
3691}
3692
3693/*
3694 * Called to check deny when READ with all zero stateid or
3695 * WRITE with all zero or all one stateid
3696 */
3697static __be32
3698nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
3699{
3700	struct nfs4_file *fp;
3701	__be32 ret = nfs_ok;
3702
3703	fp = find_file(&current_fh->fh_handle);
3704	if (!fp)
3705		return ret;
3706	/* Check for conflicting share reservations */
3707	spin_lock(&fp->fi_lock);
3708	if (fp->fi_share_deny & deny_type)
3709		ret = nfserr_locked;
3710	spin_unlock(&fp->fi_lock);
3711	put_nfs4_file(fp);
3712	return ret;
3713}
3714
3715static void nfsd4_cb_recall_prepare(struct nfsd4_callback *cb)
3716{
3717	struct nfs4_delegation *dp = cb_to_delegation(cb);
3718	struct nfsd_net *nn = net_generic(dp->dl_stid.sc_client->net,
3719					  nfsd_net_id);
3720
3721	block_delegations(&dp->dl_stid.sc_file->fi_fhandle);
3722
3723	/*
3724	 * We can't do this in nfsd_break_deleg_cb because it is
3725	 * already holding inode->i_lock.
3726	 *
3727	 * If the dl_time != 0, then we know that it has already been
3728	 * queued for a lease break. Don't queue it again.
3729	 */
3730	spin_lock(&state_lock);
3731	if (dp->dl_time == 0) {
3732		dp->dl_time = get_seconds();
3733		list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
3734	}
3735	spin_unlock(&state_lock);
3736}
3737
3738static int nfsd4_cb_recall_done(struct nfsd4_callback *cb,
3739		struct rpc_task *task)
3740{
3741	struct nfs4_delegation *dp = cb_to_delegation(cb);
3742
3743	if (dp->dl_stid.sc_type == NFS4_CLOSED_DELEG_STID)
3744	        return 1;
3745
3746	switch (task->tk_status) {
3747	case 0:
3748		return 1;
 
 
 
3749	case -EBADHANDLE:
3750	case -NFS4ERR_BAD_STATEID:
3751		/*
3752		 * Race: client probably got cb_recall before open reply
3753		 * granting delegation.
3754		 */
3755		if (dp->dl_retries--) {
3756			rpc_delay(task, 2 * HZ);
3757			return 0;
3758		}
3759		/*FALLTHRU*/
3760	default:
3761		return -1;
3762	}
3763}
3764
3765static void nfsd4_cb_recall_release(struct nfsd4_callback *cb)
3766{
3767	struct nfs4_delegation *dp = cb_to_delegation(cb);
3768
3769	nfs4_put_stid(&dp->dl_stid);
3770}
3771
3772static const struct nfsd4_callback_ops nfsd4_cb_recall_ops = {
3773	.prepare	= nfsd4_cb_recall_prepare,
3774	.done		= nfsd4_cb_recall_done,
3775	.release	= nfsd4_cb_recall_release,
3776};
3777
3778static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
3779{
3780	/*
3781	 * We're assuming the state code never drops its reference
3782	 * without first removing the lease.  Since we're in this lease
3783	 * callback (and since the lease code is serialized by the kernel
3784	 * lock) we know the server hasn't removed the lease yet, we know
3785	 * it's safe to take a reference.
3786	 */
3787	atomic_inc(&dp->dl_stid.sc_count);
3788	nfsd4_run_cb(&dp->dl_recall);
3789}
3790
3791/* Called from break_lease() with i_lock held. */
3792static bool
3793nfsd_break_deleg_cb(struct file_lock *fl)
3794{
3795	bool ret = false;
3796	struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
3797	struct nfs4_delegation *dp;
 
 
3798
3799	if (!fp) {
3800		WARN(1, "(%p)->fl_owner NULL\n", fl);
3801		return ret;
3802	}
3803	if (fp->fi_had_conflict) {
3804		WARN(1, "duplicate break on %p\n", fp);
3805		return ret;
3806	}
3807	/*
3808	 * We don't want the locks code to timeout the lease for us;
3809	 * we'll remove it ourself if a delegation isn't returned
3810	 * in time:
3811	 */
3812	fl->fl_break_time = 0;
3813
3814	spin_lock(&fp->fi_lock);
3815	fp->fi_had_conflict = true;
3816	/*
3817	 * If there are no delegations on the list, then return true
3818	 * so that the lease code will go ahead and delete it.
3819	 */
3820	if (list_empty(&fp->fi_delegations))
3821		ret = true;
3822	else
3823		list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
3824			nfsd_break_one_deleg(dp);
3825	spin_unlock(&fp->fi_lock);
3826	return ret;
3827}
3828
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3829static int
3830nfsd_change_deleg_cb(struct file_lock *onlist, int arg,
3831		     struct list_head *dispose)
3832{
3833	if (arg & F_UNLCK)
3834		return lease_modify(onlist, arg, dispose);
3835	else
3836		return -EAGAIN;
3837}
3838
3839static const struct lock_manager_operations nfsd_lease_mng_ops = {
 
3840	.lm_break = nfsd_break_deleg_cb,
3841	.lm_change = nfsd_change_deleg_cb,
3842};
3843
3844static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
3845{
3846	if (nfsd4_has_session(cstate))
3847		return nfs_ok;
3848	if (seqid == so->so_seqid - 1)
3849		return nfserr_replay_me;
3850	if (seqid == so->so_seqid)
3851		return nfs_ok;
3852	return nfserr_bad_seqid;
3853}
3854
3855static __be32 lookup_clientid(clientid_t *clid,
3856		struct nfsd4_compound_state *cstate,
3857		struct nfsd_net *nn)
 
3858{
3859	struct nfs4_client *found;
3860
3861	if (cstate->clp) {
3862		found = cstate->clp;
3863		if (!same_clid(&found->cl_clientid, clid))
3864			return nfserr_stale_clientid;
3865		return nfs_ok;
3866	}
3867
3868	if (STALE_CLIENTID(clid, nn))
3869		return nfserr_stale_clientid;
3870
3871	/*
3872	 * For v4.1+ we get the client in the SEQUENCE op. If we don't have one
3873	 * cached already then we know this is for is for v4.0 and "sessions"
3874	 * will be false.
3875	 */
3876	WARN_ON_ONCE(cstate->session);
3877	spin_lock(&nn->client_lock);
3878	found = find_confirmed_client(clid, false, nn);
3879	if (!found) {
3880		spin_unlock(&nn->client_lock);
3881		return nfserr_expired;
3882	}
3883	atomic_inc(&found->cl_refcount);
3884	spin_unlock(&nn->client_lock);
3885
3886	/* Cache the nfs4_client in cstate! */
3887	cstate->clp = found;
3888	return nfs_ok;
3889}
3890
3891__be32
3892nfsd4_process_open1(struct nfsd4_compound_state *cstate,
3893		    struct nfsd4_open *open, struct nfsd_net *nn)
3894{
3895	clientid_t *clientid = &open->op_clientid;
3896	struct nfs4_client *clp = NULL;
3897	unsigned int strhashval;
3898	struct nfs4_openowner *oo = NULL;
3899	__be32 status;
3900
3901	if (STALE_CLIENTID(&open->op_clientid, nn))
3902		return nfserr_stale_clientid;
3903	/*
3904	 * In case we need it later, after we've already created the
3905	 * file and don't want to risk a further failure:
3906	 */
3907	open->op_file = nfsd4_alloc_file();
3908	if (open->op_file == NULL)
3909		return nfserr_jukebox;
3910
3911	status = lookup_clientid(clientid, cstate, nn);
3912	if (status)
3913		return status;
3914	clp = cstate->clp;
3915
3916	strhashval = ownerstr_hashval(&open->op_owner);
3917	oo = find_openstateowner_str(strhashval, open, clp);
3918	open->op_openowner = oo;
3919	if (!oo) {
3920		goto new_owner;
3921	}
3922	if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
3923		/* Replace unconfirmed owners without checking for replay. */
3924		release_openowner(oo);
3925		open->op_openowner = NULL;
3926		goto new_owner;
3927	}
3928	status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
3929	if (status)
3930		return status;
3931	goto alloc_stateid;
3932new_owner:
3933	oo = alloc_init_open_stateowner(strhashval, open, cstate);
3934	if (oo == NULL)
3935		return nfserr_jukebox;
3936	open->op_openowner = oo;
3937alloc_stateid:
3938	open->op_stp = nfs4_alloc_open_stateid(clp);
3939	if (!open->op_stp)
3940		return nfserr_jukebox;
3941
3942	if (nfsd4_has_session(cstate) &&
3943	    (cstate->current_fh.fh_export->ex_flags & NFSEXP_PNFS)) {
3944		open->op_odstate = alloc_clnt_odstate(clp);
3945		if (!open->op_odstate)
3946			return nfserr_jukebox;
3947	}
3948
3949	return nfs_ok;
3950}
3951
3952static inline __be32
3953nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
3954{
3955	if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
3956		return nfserr_openmode;
3957	else
3958		return nfs_ok;
3959}
3960
3961static int share_access_to_flags(u32 share_access)
3962{
3963	return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
3964}
3965
3966static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
3967{
3968	struct nfs4_stid *ret;
3969
3970	ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID);
 
3971	if (!ret)
3972		return NULL;
3973	return delegstateid(ret);
3974}
3975
3976static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
3977{
3978	return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
3979	       open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
3980}
3981
3982static __be32
3983nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,
3984		struct nfs4_delegation **dp)
3985{
3986	int flags;
3987	__be32 status = nfserr_bad_stateid;
3988	struct nfs4_delegation *deleg;
3989
3990	deleg = find_deleg_stateid(cl, &open->op_delegate_stateid);
3991	if (deleg == NULL)
3992		goto out;
 
 
 
 
 
 
3993	flags = share_access_to_flags(open->op_share_access);
3994	status = nfs4_check_delegmode(deleg, flags);
3995	if (status) {
3996		nfs4_put_stid(&deleg->dl_stid);
3997		goto out;
3998	}
3999	*dp = deleg;
4000out:
4001	if (!nfsd4_is_deleg_cur(open))
4002		return nfs_ok;
4003	if (status)
4004		return status;
4005	open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
4006	return nfs_ok;
4007}
4008
4009static inline int nfs4_access_to_access(u32 nfs4_access)
4010{
4011	int flags = 0;
4012
4013	if (nfs4_access & NFS4_SHARE_ACCESS_READ)
4014		flags |= NFSD_MAY_READ;
4015	if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
4016		flags |= NFSD_MAY_WRITE;
4017	return flags;
4018}
4019
4020static inline __be32
4021nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
4022		struct nfsd4_open *open)
4023{
4024	struct iattr iattr = {
4025		.ia_valid = ATTR_SIZE,
4026		.ia_size = 0,
4027	};
4028	if (!open->op_truncate)
4029		return 0;
4030	if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
4031		return nfserr_inval;
4032	return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
4033}
4034
4035static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
4036		struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp,
4037		struct nfsd4_open *open)
4038{
4039	struct file *filp = NULL;
4040	__be32 status;
4041	int oflag = nfs4_access_to_omode(open->op_share_access);
4042	int access = nfs4_access_to_access(open->op_share_access);
4043	unsigned char old_access_bmap, old_deny_bmap;
4044
4045	spin_lock(&fp->fi_lock);
4046
4047	/*
4048	 * Are we trying to set a deny mode that would conflict with
4049	 * current access?
4050	 */
4051	status = nfs4_file_check_deny(fp, open->op_share_deny);
4052	if (status != nfs_ok) {
4053		spin_unlock(&fp->fi_lock);
4054		goto out;
4055	}
4056
4057	/* set access to the file */
4058	status = nfs4_file_get_access(fp, open->op_share_access);
4059	if (status != nfs_ok) {
4060		spin_unlock(&fp->fi_lock);
4061		goto out;
4062	}
4063
4064	/* Set access bits in stateid */
4065	old_access_bmap = stp->st_access_bmap;
4066	set_access(open->op_share_access, stp);
4067
4068	/* Set new deny mask */
4069	old_deny_bmap = stp->st_deny_bmap;
4070	set_deny(open->op_share_deny, stp);
4071	fp->fi_share_deny |= (open->op_share_deny & NFS4_SHARE_DENY_BOTH);
4072
4073	if (!fp->fi_fds[oflag]) {
4074		spin_unlock(&fp->fi_lock);
4075		status = nfsd_open(rqstp, cur_fh, S_IFREG, access, &filp);
4076		if (status)
4077			goto out_put_access;
4078		spin_lock(&fp->fi_lock);
4079		if (!fp->fi_fds[oflag]) {
4080			fp->fi_fds[oflag] = filp;
4081			filp = NULL;
4082		}
4083	}
4084	spin_unlock(&fp->fi_lock);
4085	if (filp)
4086		fput(filp);
4087
4088	status = nfsd4_truncate(rqstp, cur_fh, open);
4089	if (status)
4090		goto out_put_access;
4091out:
4092	return status;
4093out_put_access:
4094	stp->st_access_bmap = old_access_bmap;
4095	nfs4_file_put_access(fp, open->op_share_access);
4096	reset_union_bmap_deny(bmap_to_share_mode(old_deny_bmap), stp);
4097	goto out;
4098}
4099
4100static __be32
4101nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp, struct nfsd4_open *open)
4102{
4103	__be32 status;
4104	unsigned char old_deny_bmap = stp->st_deny_bmap;
4105
4106	if (!test_access(open->op_share_access, stp))
4107		return nfs4_get_vfs_file(rqstp, fp, cur_fh, stp, open);
4108
4109	/* test and set deny mode */
4110	spin_lock(&fp->fi_lock);
4111	status = nfs4_file_check_deny(fp, open->op_share_deny);
4112	if (status == nfs_ok) {
4113		set_deny(open->op_share_deny, stp);
4114		fp->fi_share_deny |=
4115				(open->op_share_deny & NFS4_SHARE_DENY_BOTH);
4116	}
4117	spin_unlock(&fp->fi_lock);
4118
4119	if (status != nfs_ok)
4120		return status;
4121
4122	status = nfsd4_truncate(rqstp, cur_fh, open);
4123	if (status != nfs_ok)
4124		reset_union_bmap_deny(old_deny_bmap, stp);
4125	return status;
4126}
4127
4128/* Should we give out recallable state?: */
4129static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
4130{
4131	if (clp->cl_cb_state == NFSD4_CB_UP)
4132		return true;
4133	/*
4134	 * In the sessions case, since we don't have to establish a
4135	 * separate connection for callbacks, we assume it's OK
4136	 * until we hear otherwise:
4137	 */
4138	return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
4139}
4140
4141static struct file_lock *nfs4_alloc_init_lease(struct nfs4_file *fp, int flag)
 
4142{
4143	struct file_lock *fl;
4144
4145	fl = locks_alloc_lock();
4146	if (!fl)
4147		return NULL;
4148	fl->fl_lmops = &nfsd_lease_mng_ops;
4149	fl->fl_flags = FL_DELEG;
4150	fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
4151	fl->fl_end = OFFSET_MAX;
4152	fl->fl_owner = (fl_owner_t)fp;
4153	fl->fl_pid = current->tgid;
 
4154	return fl;
4155}
4156
4157/**
4158 * nfs4_setlease - Obtain a delegation by requesting lease from vfs layer
4159 * @dp:   a pointer to the nfs4_delegation we're adding.
4160 *
4161 * Return:
4162 *      On success: Return code will be 0 on success.
4163 *
4164 *      On error: -EAGAIN if there was an existing delegation.
4165 *                 nonzero if there is an error in other cases.
4166 *
4167 */
4168
4169static int nfs4_setlease(struct nfs4_delegation *dp)
4170{
4171	struct nfs4_file *fp = dp->dl_stid.sc_file;
4172	struct file_lock *fl;
4173	struct file *filp;
4174	int status = 0;
4175
4176	fl = nfs4_alloc_init_lease(fp, NFS4_OPEN_DELEGATE_READ);
4177	if (!fl)
4178		return -ENOMEM;
4179	filp = find_readable_file(fp);
4180	if (!filp) {
4181		/* We should always have a readable file here */
4182		WARN_ON_ONCE(1);
4183		locks_free_lock(fl);
4184		return -EBADF;
4185	}
4186	fl->fl_file = filp;
4187	status = vfs_setlease(filp, fl->fl_type, &fl, NULL);
4188	if (fl)
4189		locks_free_lock(fl);
4190	if (status)
4191		goto out_fput;
4192	spin_lock(&state_lock);
4193	spin_lock(&fp->fi_lock);
4194	/* Did the lease get broken before we took the lock? */
4195	status = -EAGAIN;
4196	if (fp->fi_had_conflict)
4197		goto out_unlock;
4198	/* Race breaker */
4199	if (fp->fi_deleg_file) {
4200		status = hash_delegation_locked(dp, fp);
4201		goto out_unlock;
4202	}
4203	fp->fi_deleg_file = filp;
4204	fp->fi_delegees = 0;
4205	status = hash_delegation_locked(dp, fp);
4206	spin_unlock(&fp->fi_lock);
4207	spin_unlock(&state_lock);
4208	if (status) {
4209		/* Should never happen, this is a new fi_deleg_file  */
4210		WARN_ON_ONCE(1);
4211		goto out_fput;
4212	}
4213	return 0;
4214out_unlock:
4215	spin_unlock(&fp->fi_lock);
4216	spin_unlock(&state_lock);
4217out_fput:
4218	fput(filp);
4219	return status;
4220}
4221
4222static struct nfs4_delegation *
4223nfs4_set_delegation(struct nfs4_client *clp, struct svc_fh *fh,
4224		    struct nfs4_file *fp, struct nfs4_clnt_odstate *odstate)
4225{
4226	int status;
4227	struct nfs4_delegation *dp;
 
 
4228
 
 
 
 
 
4229	if (fp->fi_had_conflict)
4230		return ERR_PTR(-EAGAIN);
4231
 
 
 
 
 
 
 
 
 
4232	spin_lock(&state_lock);
4233	spin_lock(&fp->fi_lock);
4234	status = nfs4_get_existing_delegation(clp, fp);
 
 
 
 
 
 
 
 
 
4235	spin_unlock(&fp->fi_lock);
4236	spin_unlock(&state_lock);
4237
 
4238	if (status)
4239		return ERR_PTR(status);
4240
4241	dp = alloc_init_deleg(clp, fh, odstate);
 
4242	if (!dp)
4243		return ERR_PTR(-ENOMEM);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4244
4245	get_nfs4_file(fp);
4246	spin_lock(&state_lock);
4247	spin_lock(&fp->fi_lock);
4248	dp->dl_stid.sc_file = fp;
4249	if (!fp->fi_deleg_file) {
4250		spin_unlock(&fp->fi_lock);
4251		spin_unlock(&state_lock);
4252		status = nfs4_setlease(dp);
4253		goto out;
4254	}
4255	if (fp->fi_had_conflict) {
4256		status = -EAGAIN;
4257		goto out_unlock;
4258	}
4259	status = hash_delegation_locked(dp, fp);
4260out_unlock:
4261	spin_unlock(&fp->fi_lock);
4262	spin_unlock(&state_lock);
4263out:
4264	if (status) {
4265		put_clnt_odstate(dp->dl_clnt_odstate);
4266		nfs4_put_stid(&dp->dl_stid);
4267		return ERR_PTR(status);
4268	}
4269	return dp;
 
 
 
 
 
 
 
 
4270}
4271
4272static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
4273{
4274	open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
4275	if (status == -EAGAIN)
4276		open->op_why_no_deleg = WND4_CONTENTION;
4277	else {
4278		open->op_why_no_deleg = WND4_RESOURCE;
4279		switch (open->op_deleg_want) {
4280		case NFS4_SHARE_WANT_READ_DELEG:
4281		case NFS4_SHARE_WANT_WRITE_DELEG:
4282		case NFS4_SHARE_WANT_ANY_DELEG:
4283			break;
4284		case NFS4_SHARE_WANT_CANCEL:
4285			open->op_why_no_deleg = WND4_CANCELLED;
4286			break;
4287		case NFS4_SHARE_WANT_NO_DELEG:
4288			WARN_ON_ONCE(1);
4289		}
4290	}
4291}
4292
4293/*
4294 * Attempt to hand out a delegation.
4295 *
4296 * Note we don't support write delegations, and won't until the vfs has
4297 * proper support for them.
4298 */
4299static void
4300nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open,
4301			struct nfs4_ol_stateid *stp)
4302{
4303	struct nfs4_delegation *dp;
4304	struct nfs4_openowner *oo = openowner(stp->st_stateowner);
4305	struct nfs4_client *clp = stp->st_stid.sc_client;
4306	int cb_up;
4307	int status = 0;
4308
4309	cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
4310	open->op_recall = 0;
4311	switch (open->op_claim_type) {
4312		case NFS4_OPEN_CLAIM_PREVIOUS:
4313			if (!cb_up)
4314				open->op_recall = 1;
4315			if (open->op_delegate_type != NFS4_OPEN_DELEGATE_READ)
4316				goto out_no_deleg;
4317			break;
4318		case NFS4_OPEN_CLAIM_NULL:
4319		case NFS4_OPEN_CLAIM_FH:
4320			/*
4321			 * Let's not give out any delegations till everyone's
4322			 * had the chance to reclaim theirs, *and* until
4323			 * NLM locks have all been reclaimed:
4324			 */
4325			if (locks_in_grace(clp->net))
4326				goto out_no_deleg;
4327			if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
4328				goto out_no_deleg;
4329			/*
4330			 * Also, if the file was opened for write or
4331			 * create, there's a good chance the client's
4332			 * about to write to it, resulting in an
4333			 * immediate recall (since we don't support
4334			 * write delegations):
4335			 */
4336			if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
4337				goto out_no_deleg;
4338			if (open->op_create == NFS4_OPEN_CREATE)
4339				goto out_no_deleg;
4340			break;
4341		default:
4342			goto out_no_deleg;
4343	}
4344	dp = nfs4_set_delegation(clp, fh, stp->st_stid.sc_file, stp->st_clnt_odstate);
4345	if (IS_ERR(dp))
4346		goto out_no_deleg;
4347
4348	memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
4349
4350	dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
4351		STATEID_VAL(&dp->dl_stid.sc_stateid));
4352	open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
4353	nfs4_put_stid(&dp->dl_stid);
4354	return;
4355out_no_deleg:
4356	open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE;
4357	if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
4358	    open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE) {
4359		dprintk("NFSD: WARNING: refusing delegation reclaim\n");
4360		open->op_recall = 1;
4361	}
4362
4363	/* 4.1 client asking for a delegation? */
4364	if (open->op_deleg_want)
4365		nfsd4_open_deleg_none_ext(open, status);
4366	return;
4367}
4368
4369static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
4370					struct nfs4_delegation *dp)
4371{
4372	if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
4373	    dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
4374		open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
4375		open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
4376	} else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
4377		   dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
4378		open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
4379		open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
4380	}
4381	/* Otherwise the client must be confused wanting a delegation
4382	 * it already has, therefore we don't return
4383	 * NFS4_OPEN_DELEGATE_NONE_EXT and reason.
4384	 */
4385}
4386
4387__be32
4388nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
4389{
4390	struct nfsd4_compoundres *resp = rqstp->rq_resp;
4391	struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
4392	struct nfs4_file *fp = NULL;
4393	struct nfs4_ol_stateid *stp = NULL;
4394	struct nfs4_delegation *dp = NULL;
4395	__be32 status;
 
4396
4397	/*
4398	 * Lookup file; if found, lookup stateid and check open request,
4399	 * and check for delegations in the process of being recalled.
4400	 * If not found, create the nfs4_file struct
4401	 */
4402	fp = find_or_add_file(open->op_file, &current_fh->fh_handle);
4403	if (fp != open->op_file) {
4404		status = nfs4_check_deleg(cl, open, &dp);
4405		if (status)
4406			goto out;
4407		spin_lock(&fp->fi_lock);
4408		stp = nfsd4_find_existing_open(fp, open);
4409		spin_unlock(&fp->fi_lock);
4410	} else {
4411		open->op_file = NULL;
4412		status = nfserr_bad_stateid;
4413		if (nfsd4_is_deleg_cur(open))
4414			goto out;
4415	}
4416
 
 
 
 
 
 
4417	/*
4418	 * OPEN the file, or upgrade an existing OPEN.
4419	 * If truncate fails, the OPEN fails.
 
 
4420	 */
4421	if (stp) {
4422		/* Stateid was found, this is an OPEN upgrade */
4423		mutex_lock(&stp->st_mutex);
4424		status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
4425		if (status) {
4426			mutex_unlock(&stp->st_mutex);
4427			goto out;
4428		}
4429	} else {
4430		/* stp is returned locked. */
4431		stp = init_open_stateid(fp, open);
4432		/* See if we lost the race to some other thread */
4433		if (stp->st_access_bmap != 0) {
4434			status = nfs4_upgrade_open(rqstp, fp, current_fh,
4435						stp, open);
4436			if (status) {
4437				mutex_unlock(&stp->st_mutex);
4438				goto out;
4439			}
4440			goto upgrade_out;
4441		}
4442		status = nfs4_get_vfs_file(rqstp, fp, current_fh, stp, open);
4443		if (status) {
4444			mutex_unlock(&stp->st_mutex);
4445			release_open_stateid(stp);
 
4446			goto out;
4447		}
4448
4449		stp->st_clnt_odstate = find_or_hash_clnt_odstate(fp,
4450							open->op_odstate);
4451		if (stp->st_clnt_odstate == open->op_odstate)
4452			open->op_odstate = NULL;
4453	}
4454upgrade_out:
4455	nfs4_inc_and_copy_stateid(&open->op_stateid, &stp->st_stid);
4456	mutex_unlock(&stp->st_mutex);
4457
4458	if (nfsd4_has_session(&resp->cstate)) {
4459		if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
4460			open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
4461			open->op_why_no_deleg = WND4_NOT_WANTED;
4462			goto nodeleg;
4463		}
4464	}
4465
4466	/*
4467	* Attempt to hand out a delegation. No error return, because the
4468	* OPEN succeeds even if we fail.
4469	*/
4470	nfs4_open_delegation(current_fh, open, stp);
4471nodeleg:
4472	status = nfs_ok;
4473
4474	dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
4475		STATEID_VAL(&stp->st_stid.sc_stateid));
4476out:
4477	/* 4.1 client trying to upgrade/downgrade delegation? */
4478	if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
4479	    open->op_deleg_want)
4480		nfsd4_deleg_xgrade_none_ext(open, dp);
4481
4482	if (fp)
4483		put_nfs4_file(fp);
4484	if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
4485		open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
4486	/*
4487	* To finish the open response, we just need to set the rflags.
4488	*/
4489	open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
4490	if (nfsd4_has_session(&resp->cstate))
4491		open->op_rflags |= NFS4_OPEN_RESULT_MAY_NOTIFY_LOCK;
4492	else if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED))
4493		open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
4494
4495	if (dp)
4496		nfs4_put_stid(&dp->dl_stid);
4497	if (stp)
4498		nfs4_put_stid(&stp->st_stid);
4499
4500	return status;
4501}
4502
4503void nfsd4_cleanup_open_state(struct nfsd4_compound_state *cstate,
4504			      struct nfsd4_open *open)
4505{
4506	if (open->op_openowner) {
4507		struct nfs4_stateowner *so = &open->op_openowner->oo_owner;
4508
4509		nfsd4_cstate_assign_replay(cstate, so);
4510		nfs4_put_stateowner(so);
4511	}
4512	if (open->op_file)
4513		kmem_cache_free(file_slab, open->op_file);
4514	if (open->op_stp)
4515		nfs4_put_stid(&open->op_stp->st_stid);
4516	if (open->op_odstate)
4517		kmem_cache_free(odstate_slab, open->op_odstate);
4518}
4519
4520__be32
4521nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4522	    clientid_t *clid)
4523{
 
4524	struct nfs4_client *clp;
4525	__be32 status;
4526	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4527
4528	dprintk("process_renew(%08x/%08x): starting\n", 
4529			clid->cl_boot, clid->cl_id);
4530	status = lookup_clientid(clid, cstate, nn);
4531	if (status)
4532		goto out;
4533	clp = cstate->clp;
4534	status = nfserr_cb_path_down;
4535	if (!list_empty(&clp->cl_delegations)
4536			&& clp->cl_cb_state != NFSD4_CB_UP)
4537		goto out;
4538	status = nfs_ok;
4539out:
4540	return status;
4541}
4542
4543void
4544nfsd4_end_grace(struct nfsd_net *nn)
4545{
4546	/* do nothing if grace period already ended */
4547	if (nn->grace_ended)
4548		return;
4549
4550	dprintk("NFSD: end of grace period\n");
4551	nn->grace_ended = true;
4552	/*
4553	 * If the server goes down again right now, an NFSv4
4554	 * client will still be allowed to reclaim after it comes back up,
4555	 * even if it hasn't yet had a chance to reclaim state this time.
4556	 *
4557	 */
4558	nfsd4_record_grace_done(nn);
4559	/*
4560	 * At this point, NFSv4 clients can still reclaim.  But if the
4561	 * server crashes, any that have not yet reclaimed will be out
4562	 * of luck on the next boot.
4563	 *
4564	 * (NFSv4.1+ clients are considered to have reclaimed once they
4565	 * call RECLAIM_COMPLETE.  NFSv4.0 clients are considered to
4566	 * have reclaimed after their first OPEN.)
4567	 */
4568	locks_end_grace(&nn->nfsd4_manager);
4569	/*
4570	 * At this point, and once lockd and/or any other containers
4571	 * exit their grace period, further reclaims will fail and
4572	 * regular locking can resume.
4573	 */
4574}
4575
4576static time_t
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4577nfs4_laundromat(struct nfsd_net *nn)
4578{
4579	struct nfs4_client *clp;
4580	struct nfs4_openowner *oo;
4581	struct nfs4_delegation *dp;
4582	struct nfs4_ol_stateid *stp;
4583	struct nfsd4_blocked_lock *nbl;
4584	struct list_head *pos, *next, reaplist;
4585	time_t cutoff = get_seconds() - nn->nfsd4_lease;
4586	time_t t, new_timeo = nn->nfsd4_lease;
 
 
 
4587
4588	dprintk("NFSD: laundromat service - starting\n");
 
 
 
4589	nfsd4_end_grace(nn);
4590	INIT_LIST_HEAD(&reaplist);
 
 
 
 
 
 
 
 
 
 
4591	spin_lock(&nn->client_lock);
4592	list_for_each_safe(pos, next, &nn->client_lru) {
4593		clp = list_entry(pos, struct nfs4_client, cl_lru);
4594		if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
4595			t = clp->cl_time - cutoff;
4596			new_timeo = min(new_timeo, t);
4597			break;
4598		}
4599		if (mark_client_expired_locked(clp)) {
4600			dprintk("NFSD: client in use (clientid %08x)\n",
4601				clp->cl_clientid.cl_id);
4602			continue;
4603		}
4604		list_add(&clp->cl_lru, &reaplist);
4605	}
4606	spin_unlock(&nn->client_lock);
4607	list_for_each_safe(pos, next, &reaplist) {
4608		clp = list_entry(pos, struct nfs4_client, cl_lru);
4609		dprintk("NFSD: purging unused client (clientid %08x)\n",
4610			clp->cl_clientid.cl_id);
4611		list_del_init(&clp->cl_lru);
4612		expire_client(clp);
4613	}
4614	spin_lock(&state_lock);
4615	list_for_each_safe(pos, next, &nn->del_recall_lru) {
4616		dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4617		if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
4618			t = dp->dl_time - cutoff;
4619			new_timeo = min(new_timeo, t);
4620			break;
4621		}
4622		WARN_ON(!unhash_delegation_locked(dp));
4623		list_add(&dp->dl_recall_lru, &reaplist);
4624	}
4625	spin_unlock(&state_lock);
4626	while (!list_empty(&reaplist)) {
4627		dp = list_first_entry(&reaplist, struct nfs4_delegation,
4628					dl_recall_lru);
4629		list_del_init(&dp->dl_recall_lru);
4630		revoke_delegation(dp);
4631	}
4632
4633	spin_lock(&nn->client_lock);
4634	while (!list_empty(&nn->close_lru)) {
4635		oo = list_first_entry(&nn->close_lru, struct nfs4_openowner,
4636					oo_close_lru);
4637		if (time_after((unsigned long)oo->oo_time,
4638			       (unsigned long)cutoff)) {
4639			t = oo->oo_time - cutoff;
4640			new_timeo = min(new_timeo, t);
4641			break;
4642		}
4643		list_del_init(&oo->oo_close_lru);
4644		stp = oo->oo_last_closed_stid;
4645		oo->oo_last_closed_stid = NULL;
4646		spin_unlock(&nn->client_lock);
4647		nfs4_put_stid(&stp->st_stid);
4648		spin_lock(&nn->client_lock);
4649	}
4650	spin_unlock(&nn->client_lock);
4651
4652	/*
4653	 * It's possible for a client to try and acquire an already held lock
4654	 * that is being held for a long time, and then lose interest in it.
4655	 * So, we clean out any un-revisited request after a lease period
4656	 * under the assumption that the client is no longer interested.
4657	 *
4658	 * RFC5661, sec. 9.6 states that the client must not rely on getting
4659	 * notifications and must continue to poll for locks, even when the
4660	 * server supports them. Thus this shouldn't lead to clients blocking
4661	 * indefinitely once the lock does become free.
4662	 */
4663	BUG_ON(!list_empty(&reaplist));
4664	spin_lock(&nn->blocked_locks_lock);
4665	while (!list_empty(&nn->blocked_locks_lru)) {
4666		nbl = list_first_entry(&nn->blocked_locks_lru,
4667					struct nfsd4_blocked_lock, nbl_lru);
4668		if (time_after((unsigned long)nbl->nbl_time,
4669			       (unsigned long)cutoff)) {
4670			t = nbl->nbl_time - cutoff;
4671			new_timeo = min(new_timeo, t);
4672			break;
4673		}
4674		list_move(&nbl->nbl_lru, &reaplist);
4675		list_del_init(&nbl->nbl_list);
4676	}
4677	spin_unlock(&nn->blocked_locks_lock);
4678
4679	while (!list_empty(&reaplist)) {
4680		nbl = list_first_entry(&nn->blocked_locks_lru,
4681					struct nfsd4_blocked_lock, nbl_lru);
4682		list_del_init(&nbl->nbl_lru);
4683		posix_unblock_lock(&nbl->nbl_lock);
4684		free_blocked_lock(nbl);
4685	}
4686
4687	new_timeo = max_t(time_t, new_timeo, NFSD_LAUNDROMAT_MINTIMEOUT);
4688	return new_timeo;
4689}
4690
4691static struct workqueue_struct *laundry_wq;
4692static void laundromat_main(struct work_struct *);
4693
4694static void
4695laundromat_main(struct work_struct *laundry)
4696{
4697	time_t t;
4698	struct delayed_work *dwork = to_delayed_work(laundry);
4699	struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
4700					   laundromat_work);
4701
4702	t = nfs4_laundromat(nn);
4703	dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
4704	queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ);
4705}
4706
4707static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stid *stp)
4708{
4709	if (!fh_match(&fhp->fh_handle, &stp->sc_file->fi_fhandle))
4710		return nfserr_bad_stateid;
4711	return nfs_ok;
4712}
4713
4714static inline int
4715access_permit_read(struct nfs4_ol_stateid *stp)
4716{
4717	return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
4718		test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
4719		test_access(NFS4_SHARE_ACCESS_WRITE, stp);
4720}
4721
4722static inline int
4723access_permit_write(struct nfs4_ol_stateid *stp)
4724{
4725	return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
4726		test_access(NFS4_SHARE_ACCESS_BOTH, stp);
4727}
4728
4729static
4730__be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
4731{
4732        __be32 status = nfserr_openmode;
4733
4734	/* For lock stateid's, we test the parent open, not the lock: */
4735	if (stp->st_openstp)
4736		stp = stp->st_openstp;
4737	if ((flags & WR_STATE) && !access_permit_write(stp))
4738                goto out;
4739	if ((flags & RD_STATE) && !access_permit_read(stp))
4740                goto out;
4741	status = nfs_ok;
4742out:
4743	return status;
4744}
4745
4746static inline __be32
4747check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags)
4748{
4749	if (ONE_STATEID(stateid) && (flags & RD_STATE))
4750		return nfs_ok;
4751	else if (opens_in_grace(net)) {
4752		/* Answer in remaining cases depends on existence of
4753		 * conflicting state; so we must wait out the grace period. */
4754		return nfserr_grace;
4755	} else if (flags & WR_STATE)
4756		return nfs4_share_conflict(current_fh,
4757				NFS4_SHARE_DENY_WRITE);
4758	else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
4759		return nfs4_share_conflict(current_fh,
4760				NFS4_SHARE_DENY_READ);
4761}
4762
4763/*
4764 * Allow READ/WRITE during grace period on recovered state only for files
4765 * that are not able to provide mandatory locking.
4766 */
4767static inline int
4768grace_disallows_io(struct net *net, struct inode *inode)
4769{
4770	return opens_in_grace(net) && mandatory_lock(inode);
4771}
4772
4773static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
4774{
4775	/*
4776	 * When sessions are used the stateid generation number is ignored
4777	 * when it is zero.
4778	 */
4779	if (has_session && in->si_generation == 0)
4780		return nfs_ok;
4781
4782	if (in->si_generation == ref->si_generation)
4783		return nfs_ok;
4784
4785	/* If the client sends us a stateid from the future, it's buggy: */
4786	if (nfsd4_stateid_generation_after(in, ref))
4787		return nfserr_bad_stateid;
4788	/*
4789	 * However, we could see a stateid from the past, even from a
4790	 * non-buggy client.  For example, if the client sends a lock
4791	 * while some IO is outstanding, the lock may bump si_generation
4792	 * while the IO is still in flight.  The client could avoid that
4793	 * situation by waiting for responses on all the IO requests,
4794	 * but better performance may result in retrying IO that
4795	 * receives an old_stateid error if requests are rarely
4796	 * reordered in flight:
4797	 */
4798	return nfserr_old_stateid;
4799}
4800
 
 
 
 
 
 
 
 
 
 
 
 
4801static __be32 nfsd4_check_openowner_confirmed(struct nfs4_ol_stateid *ols)
4802{
4803	if (ols->st_stateowner->so_is_open_owner &&
4804	    !(openowner(ols->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
4805		return nfserr_bad_stateid;
4806	return nfs_ok;
4807}
4808
4809static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
4810{
4811	struct nfs4_stid *s;
4812	__be32 status = nfserr_bad_stateid;
4813
4814	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
 
4815		return status;
4816	/* Client debugging aid. */
4817	if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid)) {
4818		char addr_str[INET6_ADDRSTRLEN];
4819		rpc_ntop((struct sockaddr *)&cl->cl_addr, addr_str,
4820				 sizeof(addr_str));
4821		pr_warn_ratelimited("NFSD: client %s testing state ID "
4822					"with incorrect client ID\n", addr_str);
4823		return status;
4824	}
4825	spin_lock(&cl->cl_lock);
4826	s = find_stateid_locked(cl, stateid);
4827	if (!s)
4828		goto out_unlock;
4829	status = check_stateid_generation(stateid, &s->sc_stateid, 1);
4830	if (status)
4831		goto out_unlock;
4832	switch (s->sc_type) {
4833	case NFS4_DELEG_STID:
4834		status = nfs_ok;
4835		break;
4836	case NFS4_REVOKED_DELEG_STID:
4837		status = nfserr_deleg_revoked;
4838		break;
4839	case NFS4_OPEN_STID:
4840	case NFS4_LOCK_STID:
4841		status = nfsd4_check_openowner_confirmed(openlockstateid(s));
4842		break;
4843	default:
4844		printk("unknown stateid type %x\n", s->sc_type);
4845		/* Fallthrough */
4846	case NFS4_CLOSED_STID:
4847	case NFS4_CLOSED_DELEG_STID:
4848		status = nfserr_bad_stateid;
4849	}
4850out_unlock:
4851	spin_unlock(&cl->cl_lock);
4852	return status;
4853}
4854
4855__be32
4856nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate,
4857		     stateid_t *stateid, unsigned char typemask,
4858		     struct nfs4_stid **s, struct nfsd_net *nn)
4859{
4860	__be32 status;
 
4861
4862	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
 
 
 
 
 
 
 
 
 
 
4863		return nfserr_bad_stateid;
4864	status = lookup_clientid(&stateid->si_opaque.so_clid, cstate, nn);
 
4865	if (status == nfserr_stale_clientid) {
4866		if (cstate->session)
4867			return nfserr_bad_stateid;
4868		return nfserr_stale_stateid;
4869	}
4870	if (status)
4871		return status;
4872	*s = find_stateid_by_type(cstate->clp, stateid, typemask);
4873	if (!*s)
4874		return nfserr_bad_stateid;
 
 
 
 
 
 
4875	return nfs_ok;
4876}
4877
4878static struct file *
4879nfs4_find_file(struct nfs4_stid *s, int flags)
4880{
4881	if (!s)
4882		return NULL;
4883
4884	switch (s->sc_type) {
4885	case NFS4_DELEG_STID:
4886		if (WARN_ON_ONCE(!s->sc_file->fi_deleg_file))
4887			return NULL;
4888		return get_file(s->sc_file->fi_deleg_file);
4889	case NFS4_OPEN_STID:
4890	case NFS4_LOCK_STID:
4891		if (flags & RD_STATE)
4892			return find_readable_file(s->sc_file);
4893		else
4894			return find_writeable_file(s->sc_file);
4895		break;
4896	}
4897
4898	return NULL;
4899}
4900
4901static __be32
4902nfs4_check_olstateid(struct svc_fh *fhp, struct nfs4_ol_stateid *ols, int flags)
4903{
4904	__be32 status;
4905
4906	status = nfsd4_check_openowner_confirmed(ols);
4907	if (status)
4908		return status;
4909	return nfs4_check_openmode(ols, flags);
4910}
4911
4912static __be32
4913nfs4_check_file(struct svc_rqst *rqstp, struct svc_fh *fhp, struct nfs4_stid *s,
4914		struct file **filpp, bool *tmp_file, int flags)
4915{
4916	int acc = (flags & RD_STATE) ? NFSD_MAY_READ : NFSD_MAY_WRITE;
4917	struct file *file;
4918	__be32 status;
4919
4920	file = nfs4_find_file(s, flags);
4921	if (file) {
4922		status = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
4923				acc | NFSD_MAY_OWNER_OVERRIDE);
4924		if (status) {
4925			fput(file);
4926			return status;
4927		}
4928
4929		*filpp = file;
4930	} else {
4931		status = nfsd_open(rqstp, fhp, S_IFREG, acc, filpp);
4932		if (status)
4933			return status;
4934
4935		if (tmp_file)
4936			*tmp_file = true;
4937	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4938
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4939	return 0;
4940}
4941
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4942/*
4943 * Checks for stateid operations
4944 */
4945__be32
4946nfs4_preprocess_stateid_op(struct svc_rqst *rqstp,
4947		struct nfsd4_compound_state *cstate, struct svc_fh *fhp,
4948		stateid_t *stateid, int flags, struct file **filpp, bool *tmp_file)
 
4949{
4950	struct inode *ino = d_inode(fhp->fh_dentry);
4951	struct net *net = SVC_NET(rqstp);
4952	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
4953	struct nfs4_stid *s = NULL;
4954	__be32 status;
4955
4956	if (filpp)
4957		*filpp = NULL;
4958	if (tmp_file)
4959		*tmp_file = false;
4960
4961	if (grace_disallows_io(net, ino))
4962		return nfserr_grace;
4963
4964	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
4965		status = check_special_stateids(net, fhp, stateid, flags);
4966		goto done;
4967	}
4968
4969	status = nfsd4_lookup_stateid(cstate, stateid,
4970				NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID,
4971				&s, nn);
 
 
4972	if (status)
4973		return status;
4974	status = check_stateid_generation(stateid, &s->sc_stateid,
4975			nfsd4_has_session(cstate));
4976	if (status)
4977		goto out;
4978
4979	switch (s->sc_type) {
4980	case NFS4_DELEG_STID:
4981		status = nfs4_check_delegmode(delegstateid(s), flags);
4982		break;
4983	case NFS4_OPEN_STID:
4984	case NFS4_LOCK_STID:
4985		status = nfs4_check_olstateid(fhp, openlockstateid(s), flags);
4986		break;
4987	default:
4988		status = nfserr_bad_stateid;
4989		break;
4990	}
4991	if (status)
4992		goto out;
4993	status = nfs4_check_fh(fhp, s);
4994
4995done:
4996	if (!status && filpp)
4997		status = nfs4_check_file(rqstp, fhp, s, filpp, tmp_file, flags);
4998out:
4999	if (s)
5000		nfs4_put_stid(s);
 
 
 
 
5001	return status;
5002}
5003
5004/*
5005 * Test if the stateid is valid
5006 */
5007__be32
5008nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
5009		   struct nfsd4_test_stateid *test_stateid)
5010{
 
5011	struct nfsd4_test_stateid_id *stateid;
5012	struct nfs4_client *cl = cstate->session->se_client;
5013
5014	list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
5015		stateid->ts_id_status =
5016			nfsd4_validate_stateid(cl, &stateid->ts_id_stateid);
5017
5018	return nfs_ok;
5019}
5020
5021static __be32
5022nfsd4_free_lock_stateid(stateid_t *stateid, struct nfs4_stid *s)
5023{
5024	struct nfs4_ol_stateid *stp = openlockstateid(s);
5025	__be32 ret;
5026
5027	mutex_lock(&stp->st_mutex);
 
 
5028
5029	ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
5030	if (ret)
5031		goto out;
5032
5033	ret = nfserr_locks_held;
5034	if (check_for_locks(stp->st_stid.sc_file,
5035			    lockowner(stp->st_stateowner)))
5036		goto out;
5037
5038	release_lock_stateid(stp);
5039	ret = nfs_ok;
5040
5041out:
5042	mutex_unlock(&stp->st_mutex);
 
5043	nfs4_put_stid(s);
5044	return ret;
5045}
5046
5047__be32
5048nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
5049		   struct nfsd4_free_stateid *free_stateid)
5050{
 
5051	stateid_t *stateid = &free_stateid->fr_stateid;
5052	struct nfs4_stid *s;
5053	struct nfs4_delegation *dp;
5054	struct nfs4_client *cl = cstate->session->se_client;
5055	__be32 ret = nfserr_bad_stateid;
5056
5057	spin_lock(&cl->cl_lock);
5058	s = find_stateid_locked(cl, stateid);
5059	if (!s)
5060		goto out_unlock;
 
5061	switch (s->sc_type) {
5062	case NFS4_DELEG_STID:
5063		ret = nfserr_locks_held;
5064		break;
5065	case NFS4_OPEN_STID:
5066		ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
5067		if (ret)
5068			break;
5069		ret = nfserr_locks_held;
5070		break;
5071	case NFS4_LOCK_STID:
5072		atomic_inc(&s->sc_count);
 
5073		spin_unlock(&cl->cl_lock);
5074		ret = nfsd4_free_lock_stateid(stateid, s);
5075		goto out;
5076	case NFS4_REVOKED_DELEG_STID:
 
5077		dp = delegstateid(s);
5078		list_del_init(&dp->dl_recall_lru);
5079		spin_unlock(&cl->cl_lock);
5080		nfs4_put_stid(s);
5081		ret = nfs_ok;
5082		goto out;
5083	/* Default falls through and returns nfserr_bad_stateid */
5084	}
 
5085out_unlock:
5086	spin_unlock(&cl->cl_lock);
5087out:
5088	return ret;
5089}
5090
5091static inline int
5092setlkflg (int type)
5093{
5094	return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
5095		RD_STATE : WR_STATE;
5096}
5097
5098static __be32 nfs4_seqid_op_checks(struct nfsd4_compound_state *cstate, stateid_t *stateid, u32 seqid, struct nfs4_ol_stateid *stp)
5099{
5100	struct svc_fh *current_fh = &cstate->current_fh;
5101	struct nfs4_stateowner *sop = stp->st_stateowner;
5102	__be32 status;
5103
5104	status = nfsd4_check_seqid(cstate, sop, seqid);
5105	if (status)
5106		return status;
5107	if (stp->st_stid.sc_type == NFS4_CLOSED_STID
5108		|| stp->st_stid.sc_type == NFS4_REVOKED_DELEG_STID)
5109		/*
5110		 * "Closed" stateid's exist *only* to return
5111		 * nfserr_replay_me from the previous step, and
5112		 * revoked delegations are kept only for free_stateid.
5113		 */
5114		return nfserr_bad_stateid;
5115	mutex_lock(&stp->st_mutex);
5116	status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
5117	if (status == nfs_ok)
5118		status = nfs4_check_fh(current_fh, &stp->st_stid);
5119	if (status != nfs_ok)
5120		mutex_unlock(&stp->st_mutex);
5121	return status;
5122}
5123
5124/* 
5125 * Checks for sequence id mutating operations. 
5126 */
5127static __be32
5128nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
5129			 stateid_t *stateid, char typemask,
5130			 struct nfs4_ol_stateid **stpp,
5131			 struct nfsd_net *nn)
5132{
5133	__be32 status;
5134	struct nfs4_stid *s;
5135	struct nfs4_ol_stateid *stp = NULL;
5136
5137	dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
5138		seqid, STATEID_VAL(stateid));
5139
5140	*stpp = NULL;
5141	status = nfsd4_lookup_stateid(cstate, stateid, typemask, &s, nn);
5142	if (status)
5143		return status;
5144	stp = openlockstateid(s);
5145	nfsd4_cstate_assign_replay(cstate, stp->st_stateowner);
5146
5147	status = nfs4_seqid_op_checks(cstate, stateid, seqid, stp);
5148	if (!status)
5149		*stpp = stp;
5150	else
5151		nfs4_put_stid(&stp->st_stid);
5152	return status;
5153}
5154
5155static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
5156						 stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn)
5157{
5158	__be32 status;
5159	struct nfs4_openowner *oo;
5160	struct nfs4_ol_stateid *stp;
5161
5162	status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
5163						NFS4_OPEN_STID, &stp, nn);
5164	if (status)
5165		return status;
5166	oo = openowner(stp->st_stateowner);
5167	if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
5168		mutex_unlock(&stp->st_mutex);
5169		nfs4_put_stid(&stp->st_stid);
5170		return nfserr_bad_stateid;
5171	}
5172	*stpp = stp;
5173	return nfs_ok;
5174}
5175
5176__be32
5177nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
5178		   struct nfsd4_open_confirm *oc)
5179{
 
5180	__be32 status;
5181	struct nfs4_openowner *oo;
5182	struct nfs4_ol_stateid *stp;
5183	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
5184
5185	dprintk("NFSD: nfsd4_open_confirm on file %pd\n",
5186			cstate->current_fh.fh_dentry);
5187
5188	status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
5189	if (status)
5190		return status;
5191
5192	status = nfs4_preprocess_seqid_op(cstate,
5193					oc->oc_seqid, &oc->oc_req_stateid,
5194					NFS4_OPEN_STID, &stp, nn);
5195	if (status)
5196		goto out;
5197	oo = openowner(stp->st_stateowner);
5198	status = nfserr_bad_stateid;
5199	if (oo->oo_flags & NFS4_OO_CONFIRMED) {
5200		mutex_unlock(&stp->st_mutex);
5201		goto put_stateid;
5202	}
5203	oo->oo_flags |= NFS4_OO_CONFIRMED;
5204	nfs4_inc_and_copy_stateid(&oc->oc_resp_stateid, &stp->st_stid);
5205	mutex_unlock(&stp->st_mutex);
5206	dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
5207		__func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid));
5208
5209	nfsd4_client_record_create(oo->oo_owner.so_client);
5210	status = nfs_ok;
5211put_stateid:
5212	nfs4_put_stid(&stp->st_stid);
5213out:
5214	nfsd4_bump_seqid(cstate, status);
5215	return status;
5216}
5217
5218static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
5219{
5220	if (!test_access(access, stp))
5221		return;
5222	nfs4_file_put_access(stp->st_stid.sc_file, access);
5223	clear_access(access, stp);
5224}
5225
5226static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
5227{
5228	switch (to_access) {
5229	case NFS4_SHARE_ACCESS_READ:
5230		nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
5231		nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
5232		break;
5233	case NFS4_SHARE_ACCESS_WRITE:
5234		nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
5235		nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
5236		break;
5237	case NFS4_SHARE_ACCESS_BOTH:
5238		break;
5239	default:
5240		WARN_ON_ONCE(1);
5241	}
5242}
5243
5244__be32
5245nfsd4_open_downgrade(struct svc_rqst *rqstp,
5246		     struct nfsd4_compound_state *cstate,
5247		     struct nfsd4_open_downgrade *od)
5248{
 
5249	__be32 status;
5250	struct nfs4_ol_stateid *stp;
5251	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
5252
5253	dprintk("NFSD: nfsd4_open_downgrade on file %pd\n", 
5254			cstate->current_fh.fh_dentry);
5255
5256	/* We don't yet support WANT bits: */
5257	if (od->od_deleg_want)
5258		dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
5259			od->od_deleg_want);
5260
5261	status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
5262					&od->od_stateid, &stp, nn);
5263	if (status)
5264		goto out; 
5265	status = nfserr_inval;
5266	if (!test_access(od->od_share_access, stp)) {
5267		dprintk("NFSD: access not a subset of current bitmap: 0x%hhx, input access=%08x\n",
5268			stp->st_access_bmap, od->od_share_access);
5269		goto put_stateid;
5270	}
5271	if (!test_deny(od->od_share_deny, stp)) {
5272		dprintk("NFSD: deny not a subset of current bitmap: 0x%hhx, input deny=%08x\n",
5273			stp->st_deny_bmap, od->od_share_deny);
5274		goto put_stateid;
5275	}
5276	nfs4_stateid_downgrade(stp, od->od_share_access);
5277	reset_union_bmap_deny(od->od_share_deny, stp);
5278	nfs4_inc_and_copy_stateid(&od->od_stateid, &stp->st_stid);
5279	status = nfs_ok;
5280put_stateid:
5281	mutex_unlock(&stp->st_mutex);
5282	nfs4_put_stid(&stp->st_stid);
5283out:
5284	nfsd4_bump_seqid(cstate, status);
5285	return status;
5286}
5287
5288static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
5289{
5290	struct nfs4_client *clp = s->st_stid.sc_client;
5291	bool unhashed;
5292	LIST_HEAD(reaplist);
5293
5294	s->st_stid.sc_type = NFS4_CLOSED_STID;
5295	spin_lock(&clp->cl_lock);
5296	unhashed = unhash_open_stateid(s, &reaplist);
5297
5298	if (clp->cl_minorversion) {
5299		if (unhashed)
5300			put_ol_stateid_locked(s, &reaplist);
5301		spin_unlock(&clp->cl_lock);
5302		free_ol_stateid_reaplist(&reaplist);
5303	} else {
5304		spin_unlock(&clp->cl_lock);
5305		free_ol_stateid_reaplist(&reaplist);
5306		if (unhashed)
5307			move_to_close_lru(s, clp->net);
5308	}
5309}
5310
5311/*
5312 * nfs4_unlock_state() called after encode
5313 */
5314__be32
5315nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
5316	    struct nfsd4_close *close)
5317{
 
5318	__be32 status;
5319	struct nfs4_ol_stateid *stp;
5320	struct net *net = SVC_NET(rqstp);
5321	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
5322
5323	dprintk("NFSD: nfsd4_close on file %pd\n", 
5324			cstate->current_fh.fh_dentry);
5325
5326	status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
5327					&close->cl_stateid,
5328					NFS4_OPEN_STID|NFS4_CLOSED_STID,
5329					&stp, nn);
5330	nfsd4_bump_seqid(cstate, status);
5331	if (status)
5332		goto out; 
 
 
 
 
 
 
 
 
 
5333	nfs4_inc_and_copy_stateid(&close->cl_stateid, &stp->st_stid);
5334	mutex_unlock(&stp->st_mutex);
5335
5336	nfsd4_close_open_stateid(stp);
 
 
 
 
 
 
 
 
 
 
5337
5338	/* put reference from nfs4_preprocess_seqid_op */
5339	nfs4_put_stid(&stp->st_stid);
5340out:
5341	return status;
5342}
5343
5344__be32
5345nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
5346		  struct nfsd4_delegreturn *dr)
5347{
 
5348	struct nfs4_delegation *dp;
5349	stateid_t *stateid = &dr->dr_stateid;
5350	struct nfs4_stid *s;
5351	__be32 status;
5352	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
5353
5354	if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
5355		return status;
5356
5357	status = nfsd4_lookup_stateid(cstate, stateid, NFS4_DELEG_STID, &s, nn);
5358	if (status)
5359		goto out;
5360	dp = delegstateid(s);
5361	status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate));
5362	if (status)
5363		goto put_stateid;
5364
5365	destroy_delegation(dp);
5366put_stateid:
5367	nfs4_put_stid(&dp->dl_stid);
5368out:
5369	return status;
5370}
5371
5372static inline u64
5373end_offset(u64 start, u64 len)
5374{
5375	u64 end;
5376
5377	end = start + len;
5378	return end >= start ? end: NFS4_MAX_UINT64;
5379}
5380
5381/* last octet in a range */
5382static inline u64
5383last_byte_offset(u64 start, u64 len)
5384{
5385	u64 end;
5386
5387	WARN_ON_ONCE(!len);
5388	end = start + len;
5389	return end > start ? end - 1: NFS4_MAX_UINT64;
5390}
5391
5392/*
5393 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
5394 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
5395 * byte, because of sign extension problems.  Since NFSv4 calls for 64-bit
5396 * locking, this prevents us from being completely protocol-compliant.  The
5397 * real solution to this problem is to start using unsigned file offsets in
5398 * the VFS, but this is a very deep change!
5399 */
5400static inline void
5401nfs4_transform_lock_offset(struct file_lock *lock)
5402{
5403	if (lock->fl_start < 0)
5404		lock->fl_start = OFFSET_MAX;
5405	if (lock->fl_end < 0)
5406		lock->fl_end = OFFSET_MAX;
5407}
5408
5409static fl_owner_t
5410nfsd4_fl_get_owner(fl_owner_t owner)
5411{
5412	struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner;
5413
5414	nfs4_get_stateowner(&lo->lo_owner);
5415	return owner;
5416}
5417
5418static void
5419nfsd4_fl_put_owner(fl_owner_t owner)
5420{
5421	struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner;
5422
5423	if (lo)
5424		nfs4_put_stateowner(&lo->lo_owner);
5425}
5426
5427static void
5428nfsd4_lm_notify(struct file_lock *fl)
5429{
5430	struct nfs4_lockowner		*lo = (struct nfs4_lockowner *)fl->fl_owner;
5431	struct net			*net = lo->lo_owner.so_client->net;
5432	struct nfsd_net			*nn = net_generic(net, nfsd_net_id);
5433	struct nfsd4_blocked_lock	*nbl = container_of(fl,
5434						struct nfsd4_blocked_lock, nbl_lock);
5435	bool queue = false;
5436
5437	/* An empty list means that something else is going to be using it */
5438	spin_lock(&nn->blocked_locks_lock);
5439	if (!list_empty(&nbl->nbl_list)) {
5440		list_del_init(&nbl->nbl_list);
5441		list_del_init(&nbl->nbl_lru);
5442		queue = true;
5443	}
5444	spin_unlock(&nn->blocked_locks_lock);
5445
5446	if (queue)
5447		nfsd4_run_cb(&nbl->nbl_cb);
5448}
5449
5450static const struct lock_manager_operations nfsd_posix_mng_ops  = {
5451	.lm_notify = nfsd4_lm_notify,
5452	.lm_get_owner = nfsd4_fl_get_owner,
5453	.lm_put_owner = nfsd4_fl_put_owner,
5454};
5455
5456static inline void
5457nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
5458{
5459	struct nfs4_lockowner *lo;
5460
5461	if (fl->fl_lmops == &nfsd_posix_mng_ops) {
5462		lo = (struct nfs4_lockowner *) fl->fl_owner;
5463		deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
5464					lo->lo_owner.so_owner.len, GFP_KERNEL);
5465		if (!deny->ld_owner.data)
5466			/* We just don't care that much */
5467			goto nevermind;
5468		deny->ld_owner.len = lo->lo_owner.so_owner.len;
5469		deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
5470	} else {
5471nevermind:
5472		deny->ld_owner.len = 0;
5473		deny->ld_owner.data = NULL;
5474		deny->ld_clientid.cl_boot = 0;
5475		deny->ld_clientid.cl_id = 0;
5476	}
5477	deny->ld_start = fl->fl_start;
5478	deny->ld_length = NFS4_MAX_UINT64;
5479	if (fl->fl_end != NFS4_MAX_UINT64)
5480		deny->ld_length = fl->fl_end - fl->fl_start + 1;        
5481	deny->ld_type = NFS4_READ_LT;
5482	if (fl->fl_type != F_RDLCK)
5483		deny->ld_type = NFS4_WRITE_LT;
5484}
5485
5486static struct nfs4_lockowner *
5487find_lockowner_str_locked(struct nfs4_client *clp, struct xdr_netobj *owner)
5488{
5489	unsigned int strhashval = ownerstr_hashval(owner);
5490	struct nfs4_stateowner *so;
5491
5492	lockdep_assert_held(&clp->cl_lock);
5493
5494	list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[strhashval],
5495			    so_strhash) {
5496		if (so->so_is_open_owner)
5497			continue;
5498		if (same_owner_str(so, owner))
5499			return lockowner(nfs4_get_stateowner(so));
5500	}
5501	return NULL;
5502}
5503
5504static struct nfs4_lockowner *
5505find_lockowner_str(struct nfs4_client *clp, struct xdr_netobj *owner)
5506{
5507	struct nfs4_lockowner *lo;
5508
5509	spin_lock(&clp->cl_lock);
5510	lo = find_lockowner_str_locked(clp, owner);
5511	spin_unlock(&clp->cl_lock);
5512	return lo;
5513}
5514
5515static void nfs4_unhash_lockowner(struct nfs4_stateowner *sop)
5516{
5517	unhash_lockowner_locked(lockowner(sop));
5518}
5519
5520static void nfs4_free_lockowner(struct nfs4_stateowner *sop)
5521{
5522	struct nfs4_lockowner *lo = lockowner(sop);
5523
5524	kmem_cache_free(lockowner_slab, lo);
5525}
5526
5527static const struct nfs4_stateowner_operations lockowner_ops = {
5528	.so_unhash =	nfs4_unhash_lockowner,
5529	.so_free =	nfs4_free_lockowner,
5530};
5531
5532/*
5533 * Alloc a lock owner structure.
5534 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has 
5535 * occurred. 
5536 *
5537 * strhashval = ownerstr_hashval
5538 */
5539static struct nfs4_lockowner *
5540alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp,
5541			   struct nfs4_ol_stateid *open_stp,
5542			   struct nfsd4_lock *lock)
5543{
5544	struct nfs4_lockowner *lo, *ret;
5545
5546	lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
5547	if (!lo)
5548		return NULL;
5549	INIT_LIST_HEAD(&lo->lo_blocked);
5550	INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
5551	lo->lo_owner.so_is_open_owner = 0;
5552	lo->lo_owner.so_seqid = lock->lk_new_lock_seqid;
5553	lo->lo_owner.so_ops = &lockowner_ops;
5554	spin_lock(&clp->cl_lock);
5555	ret = find_lockowner_str_locked(clp, &lock->lk_new_owner);
5556	if (ret == NULL) {
5557		list_add(&lo->lo_owner.so_strhash,
5558			 &clp->cl_ownerstr_hashtbl[strhashval]);
5559		ret = lo;
5560	} else
5561		nfs4_free_stateowner(&lo->lo_owner);
5562
5563	spin_unlock(&clp->cl_lock);
5564	return ret;
5565}
5566
5567static void
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5568init_lock_stateid(struct nfs4_ol_stateid *stp, struct nfs4_lockowner *lo,
5569		  struct nfs4_file *fp, struct inode *inode,
5570		  struct nfs4_ol_stateid *open_stp)
5571{
5572	struct nfs4_client *clp = lo->lo_owner.so_client;
 
5573
5574	lockdep_assert_held(&clp->cl_lock);
5575
5576	atomic_inc(&stp->st_stid.sc_count);
 
 
 
 
 
 
 
5577	stp->st_stid.sc_type = NFS4_LOCK_STID;
5578	stp->st_stateowner = nfs4_get_stateowner(&lo->lo_owner);
5579	get_nfs4_file(fp);
5580	stp->st_stid.sc_file = fp;
5581	stp->st_access_bmap = 0;
5582	stp->st_deny_bmap = open_stp->st_deny_bmap;
5583	stp->st_openstp = open_stp;
5584	mutex_init(&stp->st_mutex);
5585	list_add(&stp->st_locks, &open_stp->st_locks);
5586	list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
5587	spin_lock(&fp->fi_lock);
5588	list_add(&stp->st_perfile, &fp->fi_stateids);
5589	spin_unlock(&fp->fi_lock);
5590}
5591
5592static struct nfs4_ol_stateid *
5593find_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp)
5594{
5595	struct nfs4_ol_stateid *lst;
5596	struct nfs4_client *clp = lo->lo_owner.so_client;
5597
5598	lockdep_assert_held(&clp->cl_lock);
5599
5600	list_for_each_entry(lst, &lo->lo_owner.so_stateids, st_perstateowner) {
5601		if (lst->st_stid.sc_file == fp) {
5602			atomic_inc(&lst->st_stid.sc_count);
5603			return lst;
5604		}
5605	}
 
 
 
 
 
 
5606	return NULL;
5607}
5608
5609static struct nfs4_ol_stateid *
5610find_or_create_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fi,
5611			    struct inode *inode, struct nfs4_ol_stateid *ost,
5612			    bool *new)
5613{
5614	struct nfs4_stid *ns = NULL;
5615	struct nfs4_ol_stateid *lst;
5616	struct nfs4_openowner *oo = openowner(ost->st_stateowner);
5617	struct nfs4_client *clp = oo->oo_owner.so_client;
5618
 
5619	spin_lock(&clp->cl_lock);
5620	lst = find_lock_stateid(lo, fi);
5621	if (lst == NULL) {
5622		spin_unlock(&clp->cl_lock);
5623		ns = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_lock_stateid);
5624		if (ns == NULL)
5625			return NULL;
5626
5627		spin_lock(&clp->cl_lock);
5628		lst = find_lock_stateid(lo, fi);
5629		if (likely(!lst)) {
5630			lst = openlockstateid(ns);
5631			init_lock_stateid(lst, lo, fi, inode, ost);
5632			ns = NULL;
5633			*new = true;
5634		}
5635	}
5636	spin_unlock(&clp->cl_lock);
5637	if (ns)
 
 
 
 
 
 
 
 
 
 
 
 
5638		nfs4_put_stid(ns);
 
5639	return lst;
5640}
5641
5642static int
5643check_lock_length(u64 offset, u64 length)
5644{
5645	return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
5646		(length > ~offset)));
5647}
5648
5649static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
5650{
5651	struct nfs4_file *fp = lock_stp->st_stid.sc_file;
5652
5653	lockdep_assert_held(&fp->fi_lock);
5654
5655	if (test_access(access, lock_stp))
5656		return;
5657	__nfs4_file_get_access(fp, access);
5658	set_access(access, lock_stp);
5659}
5660
5661static __be32
5662lookup_or_create_lock_state(struct nfsd4_compound_state *cstate,
5663			    struct nfs4_ol_stateid *ost,
5664			    struct nfsd4_lock *lock,
5665			    struct nfs4_ol_stateid **plst, bool *new)
5666{
5667	__be32 status;
5668	struct nfs4_file *fi = ost->st_stid.sc_file;
5669	struct nfs4_openowner *oo = openowner(ost->st_stateowner);
5670	struct nfs4_client *cl = oo->oo_owner.so_client;
5671	struct inode *inode = d_inode(cstate->current_fh.fh_dentry);
5672	struct nfs4_lockowner *lo;
5673	struct nfs4_ol_stateid *lst;
5674	unsigned int strhashval;
5675	bool hashed;
5676
5677	lo = find_lockowner_str(cl, &lock->lk_new_owner);
5678	if (!lo) {
5679		strhashval = ownerstr_hashval(&lock->lk_new_owner);
5680		lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
5681		if (lo == NULL)
5682			return nfserr_jukebox;
5683	} else {
5684		/* with an existing lockowner, seqids must be the same */
5685		status = nfserr_bad_seqid;
5686		if (!cstate->minorversion &&
5687		    lock->lk_new_lock_seqid != lo->lo_owner.so_seqid)
5688			goto out;
5689	}
5690
5691retry:
5692	lst = find_or_create_lock_stateid(lo, fi, inode, ost, new);
5693	if (lst == NULL) {
5694		status = nfserr_jukebox;
5695		goto out;
5696	}
5697
5698	mutex_lock(&lst->st_mutex);
5699
5700	/* See if it's still hashed to avoid race with FREE_STATEID */
5701	spin_lock(&cl->cl_lock);
5702	hashed = !list_empty(&lst->st_perfile);
5703	spin_unlock(&cl->cl_lock);
5704
5705	if (!hashed) {
5706		mutex_unlock(&lst->st_mutex);
5707		nfs4_put_stid(&lst->st_stid);
5708		goto retry;
5709	}
5710	status = nfs_ok;
5711	*plst = lst;
5712out:
5713	nfs4_put_stateowner(&lo->lo_owner);
5714	return status;
5715}
5716
5717/*
5718 *  LOCK operation 
5719 */
5720__be32
5721nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
5722	   struct nfsd4_lock *lock)
5723{
 
5724	struct nfs4_openowner *open_sop = NULL;
5725	struct nfs4_lockowner *lock_sop = NULL;
5726	struct nfs4_ol_stateid *lock_stp = NULL;
5727	struct nfs4_ol_stateid *open_stp = NULL;
5728	struct nfs4_file *fp;
5729	struct file *filp = NULL;
5730	struct nfsd4_blocked_lock *nbl = NULL;
5731	struct file_lock *file_lock = NULL;
5732	struct file_lock *conflock = NULL;
5733	__be32 status = 0;
5734	int lkflg;
5735	int err;
5736	bool new = false;
5737	unsigned char fl_type;
5738	unsigned int fl_flags = FL_POSIX;
5739	struct net *net = SVC_NET(rqstp);
5740	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
5741
5742	dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
5743		(long long) lock->lk_offset,
5744		(long long) lock->lk_length);
5745
5746	if (check_lock_length(lock->lk_offset, lock->lk_length))
5747		 return nfserr_inval;
5748
5749	if ((status = fh_verify(rqstp, &cstate->current_fh,
5750				S_IFREG, NFSD_MAY_LOCK))) {
5751		dprintk("NFSD: nfsd4_lock: permission denied!\n");
5752		return status;
5753	}
5754
5755	if (lock->lk_is_new) {
5756		if (nfsd4_has_session(cstate))
5757			/* See rfc 5661 18.10.3: given clientid is ignored: */
5758			memcpy(&lock->lk_new_clientid,
5759				&cstate->session->se_client->cl_clientid,
5760				sizeof(clientid_t));
5761
5762		status = nfserr_stale_clientid;
5763		if (STALE_CLIENTID(&lock->lk_new_clientid, nn))
5764			goto out;
5765
5766		/* validate and update open stateid and open seqid */
5767		status = nfs4_preprocess_confirmed_seqid_op(cstate,
5768				        lock->lk_new_open_seqid,
5769		                        &lock->lk_new_open_stateid,
5770					&open_stp, nn);
5771		if (status)
5772			goto out;
5773		mutex_unlock(&open_stp->st_mutex);
5774		open_sop = openowner(open_stp->st_stateowner);
5775		status = nfserr_bad_stateid;
5776		if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
5777						&lock->lk_new_clientid))
5778			goto out;
5779		status = lookup_or_create_lock_state(cstate, open_stp, lock,
5780							&lock_stp, &new);
5781	} else {
5782		status = nfs4_preprocess_seqid_op(cstate,
5783				       lock->lk_old_lock_seqid,
5784				       &lock->lk_old_lock_stateid,
5785				       NFS4_LOCK_STID, &lock_stp, nn);
5786	}
5787	if (status)
5788		goto out;
5789	lock_sop = lockowner(lock_stp->st_stateowner);
5790
5791	lkflg = setlkflg(lock->lk_type);
5792	status = nfs4_check_openmode(lock_stp, lkflg);
5793	if (status)
5794		goto out;
5795
5796	status = nfserr_grace;
5797	if (locks_in_grace(net) && !lock->lk_reclaim)
5798		goto out;
5799	status = nfserr_no_grace;
5800	if (!locks_in_grace(net) && lock->lk_reclaim)
5801		goto out;
5802
5803	fp = lock_stp->st_stid.sc_file;
5804	switch (lock->lk_type) {
5805		case NFS4_READW_LT:
5806			if (nfsd4_has_session(cstate))
5807				fl_flags |= FL_SLEEP;
5808			/* Fallthrough */
5809		case NFS4_READ_LT:
5810			spin_lock(&fp->fi_lock);
5811			filp = find_readable_file_locked(fp);
5812			if (filp)
5813				get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
5814			spin_unlock(&fp->fi_lock);
5815			fl_type = F_RDLCK;
5816			break;
5817		case NFS4_WRITEW_LT:
5818			if (nfsd4_has_session(cstate))
5819				fl_flags |= FL_SLEEP;
5820			/* Fallthrough */
5821		case NFS4_WRITE_LT:
5822			spin_lock(&fp->fi_lock);
5823			filp = find_writeable_file_locked(fp);
5824			if (filp)
5825				get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
5826			spin_unlock(&fp->fi_lock);
5827			fl_type = F_WRLCK;
5828			break;
5829		default:
5830			status = nfserr_inval;
5831		goto out;
5832	}
5833
5834	if (!filp) {
5835		status = nfserr_openmode;
5836		goto out;
5837	}
5838
5839	nbl = find_or_allocate_block(lock_sop, &fp->fi_fhandle, nn);
5840	if (!nbl) {
5841		dprintk("NFSD: %s: unable to allocate block!\n", __func__);
5842		status = nfserr_jukebox;
5843		goto out;
5844	}
5845
5846	file_lock = &nbl->nbl_lock;
5847	file_lock->fl_type = fl_type;
5848	file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(&lock_sop->lo_owner));
5849	file_lock->fl_pid = current->tgid;
5850	file_lock->fl_file = filp;
5851	file_lock->fl_flags = fl_flags;
5852	file_lock->fl_lmops = &nfsd_posix_mng_ops;
5853	file_lock->fl_start = lock->lk_offset;
5854	file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
5855	nfs4_transform_lock_offset(file_lock);
5856
5857	conflock = locks_alloc_lock();
5858	if (!conflock) {
5859		dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
5860		status = nfserr_jukebox;
5861		goto out;
5862	}
5863
5864	if (fl_flags & FL_SLEEP) {
5865		nbl->nbl_time = jiffies;
5866		spin_lock(&nn->blocked_locks_lock);
5867		list_add_tail(&nbl->nbl_list, &lock_sop->lo_blocked);
5868		list_add_tail(&nbl->nbl_lru, &nn->blocked_locks_lru);
5869		spin_unlock(&nn->blocked_locks_lock);
5870	}
5871
5872	err = vfs_lock_file(filp, F_SETLK, file_lock, conflock);
5873	switch (err) {
5874	case 0: /* success! */
5875		nfs4_inc_and_copy_stateid(&lock->lk_resp_stateid, &lock_stp->st_stid);
5876		status = 0;
 
 
5877		break;
5878	case FILE_LOCK_DEFERRED:
5879		nbl = NULL;
5880		/* Fallthrough */
5881	case -EAGAIN:		/* conflock holds conflicting lock */
5882		status = nfserr_denied;
5883		dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
5884		nfs4_set_lock_denied(conflock, &lock->lk_denied);
5885		break;
5886	case -EDEADLK:
5887		status = nfserr_deadlock;
5888		break;
5889	default:
5890		dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
5891		status = nfserrno(err);
5892		break;
5893	}
5894out:
5895	if (nbl) {
5896		/* dequeue it if we queued it before */
5897		if (fl_flags & FL_SLEEP) {
5898			spin_lock(&nn->blocked_locks_lock);
5899			list_del_init(&nbl->nbl_list);
5900			list_del_init(&nbl->nbl_lru);
5901			spin_unlock(&nn->blocked_locks_lock);
5902		}
5903		free_blocked_lock(nbl);
5904	}
5905	if (filp)
5906		fput(filp);
5907	if (lock_stp) {
5908		/* Bump seqid manually if the 4.0 replay owner is openowner */
5909		if (cstate->replay_owner &&
5910		    cstate->replay_owner != &lock_sop->lo_owner &&
5911		    seqid_mutating_err(ntohl(status)))
5912			lock_sop->lo_owner.so_seqid++;
5913
5914		mutex_unlock(&lock_stp->st_mutex);
5915
5916		/*
5917		 * If this is a new, never-before-used stateid, and we are
5918		 * returning an error, then just go ahead and release it.
5919		 */
5920		if (status && new)
5921			release_lock_stateid(lock_stp);
5922
 
 
5923		nfs4_put_stid(&lock_stp->st_stid);
5924	}
5925	if (open_stp)
5926		nfs4_put_stid(&open_stp->st_stid);
5927	nfsd4_bump_seqid(cstate, status);
5928	if (conflock)
5929		locks_free_lock(conflock);
5930	return status;
5931}
5932
5933/*
5934 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
5935 * so we do a temporary open here just to get an open file to pass to
5936 * vfs_test_lock.  (Arguably perhaps test_lock should be done with an
5937 * inode operation.)
5938 */
5939static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
5940{
5941	struct file *file;
5942	__be32 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
5943	if (!err) {
5944		err = nfserrno(vfs_test_lock(file, lock));
5945		fput(file);
5946	}
5947	return err;
5948}
5949
5950/*
5951 * LOCKT operation
5952 */
5953__be32
5954nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
5955	    struct nfsd4_lockt *lockt)
5956{
 
5957	struct file_lock *file_lock = NULL;
5958	struct nfs4_lockowner *lo = NULL;
5959	__be32 status;
5960	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
5961
5962	if (locks_in_grace(SVC_NET(rqstp)))
5963		return nfserr_grace;
5964
5965	if (check_lock_length(lockt->lt_offset, lockt->lt_length))
5966		 return nfserr_inval;
5967
5968	if (!nfsd4_has_session(cstate)) {
5969		status = lookup_clientid(&lockt->lt_clientid, cstate, nn);
 
5970		if (status)
5971			goto out;
5972	}
5973
5974	if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
5975		goto out;
5976
5977	file_lock = locks_alloc_lock();
5978	if (!file_lock) {
5979		dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
5980		status = nfserr_jukebox;
5981		goto out;
5982	}
5983
5984	switch (lockt->lt_type) {
5985		case NFS4_READ_LT:
5986		case NFS4_READW_LT:
5987			file_lock->fl_type = F_RDLCK;
5988		break;
5989		case NFS4_WRITE_LT:
5990		case NFS4_WRITEW_LT:
5991			file_lock->fl_type = F_WRLCK;
5992		break;
5993		default:
5994			dprintk("NFSD: nfs4_lockt: bad lock type!\n");
5995			status = nfserr_inval;
5996		goto out;
5997	}
5998
5999	lo = find_lockowner_str(cstate->clp, &lockt->lt_owner);
6000	if (lo)
6001		file_lock->fl_owner = (fl_owner_t)lo;
6002	file_lock->fl_pid = current->tgid;
6003	file_lock->fl_flags = FL_POSIX;
6004
6005	file_lock->fl_start = lockt->lt_offset;
6006	file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
6007
6008	nfs4_transform_lock_offset(file_lock);
6009
6010	status = nfsd_test_lock(rqstp, &cstate->current_fh, file_lock);
6011	if (status)
6012		goto out;
6013
6014	if (file_lock->fl_type != F_UNLCK) {
6015		status = nfserr_denied;
6016		nfs4_set_lock_denied(file_lock, &lockt->lt_denied);
6017	}
6018out:
6019	if (lo)
6020		nfs4_put_stateowner(&lo->lo_owner);
6021	if (file_lock)
6022		locks_free_lock(file_lock);
6023	return status;
6024}
6025
6026__be32
6027nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
6028	    struct nfsd4_locku *locku)
6029{
 
6030	struct nfs4_ol_stateid *stp;
6031	struct file *filp = NULL;
6032	struct file_lock *file_lock = NULL;
6033	__be32 status;
6034	int err;
6035	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
6036
6037	dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
6038		(long long) locku->lu_offset,
6039		(long long) locku->lu_length);
6040
6041	if (check_lock_length(locku->lu_offset, locku->lu_length))
6042		 return nfserr_inval;
6043
6044	status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
6045					&locku->lu_stateid, NFS4_LOCK_STID,
6046					&stp, nn);
6047	if (status)
6048		goto out;
6049	filp = find_any_file(stp->st_stid.sc_file);
6050	if (!filp) {
6051		status = nfserr_lock_range;
6052		goto put_stateid;
6053	}
6054	file_lock = locks_alloc_lock();
6055	if (!file_lock) {
6056		dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
6057		status = nfserr_jukebox;
6058		goto fput;
6059	}
6060
6061	file_lock->fl_type = F_UNLCK;
6062	file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(stp->st_stateowner));
6063	file_lock->fl_pid = current->tgid;
6064	file_lock->fl_file = filp;
6065	file_lock->fl_flags = FL_POSIX;
6066	file_lock->fl_lmops = &nfsd_posix_mng_ops;
6067	file_lock->fl_start = locku->lu_offset;
6068
6069	file_lock->fl_end = last_byte_offset(locku->lu_offset,
6070						locku->lu_length);
6071	nfs4_transform_lock_offset(file_lock);
6072
6073	err = vfs_lock_file(filp, F_SETLK, file_lock, NULL);
6074	if (err) {
6075		dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
6076		goto out_nfserr;
6077	}
6078	nfs4_inc_and_copy_stateid(&locku->lu_stateid, &stp->st_stid);
6079fput:
6080	fput(filp);
6081put_stateid:
6082	mutex_unlock(&stp->st_mutex);
6083	nfs4_put_stid(&stp->st_stid);
6084out:
6085	nfsd4_bump_seqid(cstate, status);
6086	if (file_lock)
6087		locks_free_lock(file_lock);
6088	return status;
6089
6090out_nfserr:
6091	status = nfserrno(err);
6092	goto fput;
6093}
6094
6095/*
6096 * returns
6097 * 	true:  locks held by lockowner
6098 * 	false: no locks held by lockowner
6099 */
6100static bool
6101check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner)
6102{
6103	struct file_lock *fl;
6104	int status = false;
6105	struct file *filp = find_any_file(fp);
6106	struct inode *inode;
6107	struct file_lock_context *flctx;
6108
6109	if (!filp) {
6110		/* Any valid lock stateid should have some sort of access */
6111		WARN_ON_ONCE(1);
6112		return status;
6113	}
6114
6115	inode = file_inode(filp);
6116	flctx = inode->i_flctx;
6117
6118	if (flctx && !list_empty_careful(&flctx->flc_posix)) {
6119		spin_lock(&flctx->flc_lock);
6120		list_for_each_entry(fl, &flctx->flc_posix, fl_list) {
6121			if (fl->fl_owner == (fl_owner_t)lowner) {
6122				status = true;
6123				break;
6124			}
6125		}
6126		spin_unlock(&flctx->flc_lock);
6127	}
6128	fput(filp);
6129	return status;
6130}
6131
6132__be32
6133nfsd4_release_lockowner(struct svc_rqst *rqstp,
6134			struct nfsd4_compound_state *cstate,
6135			struct nfsd4_release_lockowner *rlockowner)
6136{
 
6137	clientid_t *clid = &rlockowner->rl_clientid;
6138	struct nfs4_stateowner *sop;
6139	struct nfs4_lockowner *lo = NULL;
6140	struct nfs4_ol_stateid *stp;
6141	struct xdr_netobj *owner = &rlockowner->rl_owner;
6142	unsigned int hashval = ownerstr_hashval(owner);
6143	__be32 status;
6144	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
6145	struct nfs4_client *clp;
6146	LIST_HEAD (reaplist);
6147
6148	dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
6149		clid->cl_boot, clid->cl_id);
6150
6151	status = lookup_clientid(clid, cstate, nn);
6152	if (status)
6153		return status;
6154
6155	clp = cstate->clp;
6156	/* Find the matching lock stateowner */
6157	spin_lock(&clp->cl_lock);
6158	list_for_each_entry(sop, &clp->cl_ownerstr_hashtbl[hashval],
6159			    so_strhash) {
6160
6161		if (sop->so_is_open_owner || !same_owner_str(sop, owner))
6162			continue;
6163
6164		/* see if there are still any locks associated with it */
6165		lo = lockowner(sop);
6166		list_for_each_entry(stp, &sop->so_stateids, st_perstateowner) {
6167			if (check_for_locks(stp->st_stid.sc_file, lo)) {
6168				status = nfserr_locks_held;
6169				spin_unlock(&clp->cl_lock);
6170				return status;
6171			}
6172		}
6173
6174		nfs4_get_stateowner(sop);
6175		break;
6176	}
6177	if (!lo) {
6178		spin_unlock(&clp->cl_lock);
6179		return status;
6180	}
6181
6182	unhash_lockowner_locked(lo);
6183	while (!list_empty(&lo->lo_owner.so_stateids)) {
6184		stp = list_first_entry(&lo->lo_owner.so_stateids,
6185				       struct nfs4_ol_stateid,
6186				       st_perstateowner);
6187		WARN_ON(!unhash_lock_stateid(stp));
6188		put_ol_stateid_locked(stp, &reaplist);
6189	}
6190	spin_unlock(&clp->cl_lock);
6191	free_ol_stateid_reaplist(&reaplist);
 
6192	nfs4_put_stateowner(&lo->lo_owner);
6193
6194	return status;
6195}
6196
6197static inline struct nfs4_client_reclaim *
6198alloc_reclaim(void)
6199{
6200	return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
6201}
6202
6203bool
6204nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn)
6205{
6206	struct nfs4_client_reclaim *crp;
6207
6208	crp = nfsd4_find_reclaim_client(name, nn);
6209	return (crp && crp->cr_clp);
6210}
6211
6212/*
6213 * failure => all reset bets are off, nfserr_no_grace...
 
 
 
6214 */
6215struct nfs4_client_reclaim *
6216nfs4_client_to_reclaim(const char *name, struct nfsd_net *nn)
 
6217{
6218	unsigned int strhashval;
6219	struct nfs4_client_reclaim *crp;
6220
6221	dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
6222	crp = alloc_reclaim();
6223	if (crp) {
6224		strhashval = clientstr_hashval(name);
6225		INIT_LIST_HEAD(&crp->cr_strhash);
6226		list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]);
6227		memcpy(crp->cr_recdir, name, HEXDIR_LEN);
 
 
 
6228		crp->cr_clp = NULL;
6229		nn->reclaim_str_hashtbl_size++;
6230	}
6231	return crp;
6232}
6233
6234void
6235nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn)
6236{
6237	list_del(&crp->cr_strhash);
 
 
6238	kfree(crp);
6239	nn->reclaim_str_hashtbl_size--;
6240}
6241
6242void
6243nfs4_release_reclaim(struct nfsd_net *nn)
6244{
6245	struct nfs4_client_reclaim *crp = NULL;
6246	int i;
6247
6248	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
6249		while (!list_empty(&nn->reclaim_str_hashtbl[i])) {
6250			crp = list_entry(nn->reclaim_str_hashtbl[i].next,
6251			                struct nfs4_client_reclaim, cr_strhash);
6252			nfs4_remove_reclaim_record(crp, nn);
6253		}
6254	}
6255	WARN_ON_ONCE(nn->reclaim_str_hashtbl_size);
6256}
6257
6258/*
6259 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
6260struct nfs4_client_reclaim *
6261nfsd4_find_reclaim_client(const char *recdir, struct nfsd_net *nn)
6262{
6263	unsigned int strhashval;
6264	struct nfs4_client_reclaim *crp = NULL;
6265
6266	dprintk("NFSD: nfs4_find_reclaim_client for recdir %s\n", recdir);
6267
6268	strhashval = clientstr_hashval(recdir);
6269	list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
6270		if (same_name(crp->cr_recdir, recdir)) {
6271			return crp;
6272		}
6273	}
6274	return NULL;
6275}
6276
6277/*
6278* Called from OPEN. Look for clientid in reclaim list.
6279*/
6280__be32
6281nfs4_check_open_reclaim(clientid_t *clid,
6282		struct nfsd4_compound_state *cstate,
6283		struct nfsd_net *nn)
6284{
6285	__be32 status;
6286
6287	/* find clientid in conf_id_hashtbl */
6288	status = lookup_clientid(clid, cstate, nn);
6289	if (status)
6290		return nfserr_reclaim_bad;
6291
6292	if (test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &cstate->clp->cl_flags))
6293		return nfserr_no_grace;
6294
6295	if (nfsd4_client_record_check(cstate->clp))
6296		return nfserr_reclaim_bad;
6297
6298	return nfs_ok;
6299}
6300
6301#ifdef CONFIG_NFSD_FAULT_INJECTION
6302static inline void
6303put_client(struct nfs4_client *clp)
6304{
6305	atomic_dec(&clp->cl_refcount);
6306}
6307
6308static struct nfs4_client *
6309nfsd_find_client(struct sockaddr_storage *addr, size_t addr_size)
6310{
6311	struct nfs4_client *clp;
6312	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6313					  nfsd_net_id);
6314
6315	if (!nfsd_netns_ready(nn))
6316		return NULL;
6317
6318	list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6319		if (memcmp(&clp->cl_addr, addr, addr_size) == 0)
6320			return clp;
6321	}
6322	return NULL;
6323}
6324
6325u64
6326nfsd_inject_print_clients(void)
6327{
6328	struct nfs4_client *clp;
6329	u64 count = 0;
6330	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6331					  nfsd_net_id);
6332	char buf[INET6_ADDRSTRLEN];
6333
6334	if (!nfsd_netns_ready(nn))
6335		return 0;
6336
6337	spin_lock(&nn->client_lock);
6338	list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6339		rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
6340		pr_info("NFS Client: %s\n", buf);
6341		++count;
6342	}
6343	spin_unlock(&nn->client_lock);
6344
6345	return count;
6346}
6347
6348u64
6349nfsd_inject_forget_client(struct sockaddr_storage *addr, size_t addr_size)
6350{
6351	u64 count = 0;
6352	struct nfs4_client *clp;
6353	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6354					  nfsd_net_id);
6355
6356	if (!nfsd_netns_ready(nn))
6357		return count;
6358
6359	spin_lock(&nn->client_lock);
6360	clp = nfsd_find_client(addr, addr_size);
6361	if (clp) {
6362		if (mark_client_expired_locked(clp) == nfs_ok)
6363			++count;
6364		else
6365			clp = NULL;
6366	}
6367	spin_unlock(&nn->client_lock);
6368
6369	if (clp)
6370		expire_client(clp);
6371
6372	return count;
6373}
6374
6375u64
6376nfsd_inject_forget_clients(u64 max)
6377{
6378	u64 count = 0;
6379	struct nfs4_client *clp, *next;
6380	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6381						nfsd_net_id);
6382	LIST_HEAD(reaplist);
6383
6384	if (!nfsd_netns_ready(nn))
6385		return count;
6386
6387	spin_lock(&nn->client_lock);
6388	list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
6389		if (mark_client_expired_locked(clp) == nfs_ok) {
6390			list_add(&clp->cl_lru, &reaplist);
6391			if (max != 0 && ++count >= max)
6392				break;
6393		}
6394	}
6395	spin_unlock(&nn->client_lock);
6396
6397	list_for_each_entry_safe(clp, next, &reaplist, cl_lru)
6398		expire_client(clp);
6399
6400	return count;
6401}
6402
6403static void nfsd_print_count(struct nfs4_client *clp, unsigned int count,
6404			     const char *type)
6405{
6406	char buf[INET6_ADDRSTRLEN];
6407	rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
6408	printk(KERN_INFO "NFS Client: %s has %u %s\n", buf, count, type);
6409}
6410
6411static void
6412nfsd_inject_add_lock_to_list(struct nfs4_ol_stateid *lst,
6413			     struct list_head *collect)
6414{
6415	struct nfs4_client *clp = lst->st_stid.sc_client;
6416	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6417					  nfsd_net_id);
6418
6419	if (!collect)
6420		return;
6421
6422	lockdep_assert_held(&nn->client_lock);
6423	atomic_inc(&clp->cl_refcount);
6424	list_add(&lst->st_locks, collect);
6425}
6426
6427static u64 nfsd_foreach_client_lock(struct nfs4_client *clp, u64 max,
6428				    struct list_head *collect,
6429				    bool (*func)(struct nfs4_ol_stateid *))
6430{
6431	struct nfs4_openowner *oop;
6432	struct nfs4_ol_stateid *stp, *st_next;
6433	struct nfs4_ol_stateid *lst, *lst_next;
6434	u64 count = 0;
6435
6436	spin_lock(&clp->cl_lock);
6437	list_for_each_entry(oop, &clp->cl_openowners, oo_perclient) {
6438		list_for_each_entry_safe(stp, st_next,
6439				&oop->oo_owner.so_stateids, st_perstateowner) {
6440			list_for_each_entry_safe(lst, lst_next,
6441					&stp->st_locks, st_locks) {
6442				if (func) {
6443					if (func(lst))
6444						nfsd_inject_add_lock_to_list(lst,
6445									collect);
6446				}
6447				++count;
6448				/*
6449				 * Despite the fact that these functions deal
6450				 * with 64-bit integers for "count", we must
6451				 * ensure that it doesn't blow up the
6452				 * clp->cl_refcount. Throw a warning if we
6453				 * start to approach INT_MAX here.
6454				 */
6455				WARN_ON_ONCE(count == (INT_MAX / 2));
6456				if (count == max)
6457					goto out;
6458			}
6459		}
6460	}
6461out:
6462	spin_unlock(&clp->cl_lock);
6463
6464	return count;
6465}
6466
6467static u64
6468nfsd_collect_client_locks(struct nfs4_client *clp, struct list_head *collect,
6469			  u64 max)
6470{
6471	return nfsd_foreach_client_lock(clp, max, collect, unhash_lock_stateid);
6472}
6473
6474static u64
6475nfsd_print_client_locks(struct nfs4_client *clp)
6476{
6477	u64 count = nfsd_foreach_client_lock(clp, 0, NULL, NULL);
6478	nfsd_print_count(clp, count, "locked files");
6479	return count;
6480}
6481
6482u64
6483nfsd_inject_print_locks(void)
6484{
6485	struct nfs4_client *clp;
6486	u64 count = 0;
6487	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6488						nfsd_net_id);
6489
6490	if (!nfsd_netns_ready(nn))
6491		return 0;
6492
6493	spin_lock(&nn->client_lock);
6494	list_for_each_entry(clp, &nn->client_lru, cl_lru)
6495		count += nfsd_print_client_locks(clp);
6496	spin_unlock(&nn->client_lock);
6497
6498	return count;
6499}
6500
6501static void
6502nfsd_reap_locks(struct list_head *reaplist)
6503{
6504	struct nfs4_client *clp;
6505	struct nfs4_ol_stateid *stp, *next;
6506
6507	list_for_each_entry_safe(stp, next, reaplist, st_locks) {
6508		list_del_init(&stp->st_locks);
6509		clp = stp->st_stid.sc_client;
6510		nfs4_put_stid(&stp->st_stid);
6511		put_client(clp);
6512	}
6513}
6514
6515u64
6516nfsd_inject_forget_client_locks(struct sockaddr_storage *addr, size_t addr_size)
6517{
6518	unsigned int count = 0;
6519	struct nfs4_client *clp;
6520	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6521						nfsd_net_id);
6522	LIST_HEAD(reaplist);
6523
6524	if (!nfsd_netns_ready(nn))
6525		return count;
6526
6527	spin_lock(&nn->client_lock);
6528	clp = nfsd_find_client(addr, addr_size);
6529	if (clp)
6530		count = nfsd_collect_client_locks(clp, &reaplist, 0);
6531	spin_unlock(&nn->client_lock);
6532	nfsd_reap_locks(&reaplist);
6533	return count;
6534}
6535
6536u64
6537nfsd_inject_forget_locks(u64 max)
6538{
6539	u64 count = 0;
6540	struct nfs4_client *clp;
6541	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6542						nfsd_net_id);
6543	LIST_HEAD(reaplist);
6544
6545	if (!nfsd_netns_ready(nn))
6546		return count;
6547
6548	spin_lock(&nn->client_lock);
6549	list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6550		count += nfsd_collect_client_locks(clp, &reaplist, max - count);
6551		if (max != 0 && count >= max)
6552			break;
6553	}
6554	spin_unlock(&nn->client_lock);
6555	nfsd_reap_locks(&reaplist);
6556	return count;
6557}
6558
6559static u64
6560nfsd_foreach_client_openowner(struct nfs4_client *clp, u64 max,
6561			      struct list_head *collect,
6562			      void (*func)(struct nfs4_openowner *))
6563{
6564	struct nfs4_openowner *oop, *next;
6565	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6566						nfsd_net_id);
6567	u64 count = 0;
6568
6569	lockdep_assert_held(&nn->client_lock);
6570
6571	spin_lock(&clp->cl_lock);
6572	list_for_each_entry_safe(oop, next, &clp->cl_openowners, oo_perclient) {
6573		if (func) {
6574			func(oop);
6575			if (collect) {
6576				atomic_inc(&clp->cl_refcount);
6577				list_add(&oop->oo_perclient, collect);
6578			}
6579		}
6580		++count;
6581		/*
6582		 * Despite the fact that these functions deal with
6583		 * 64-bit integers for "count", we must ensure that
6584		 * it doesn't blow up the clp->cl_refcount. Throw a
6585		 * warning if we start to approach INT_MAX here.
6586		 */
6587		WARN_ON_ONCE(count == (INT_MAX / 2));
6588		if (count == max)
6589			break;
6590	}
6591	spin_unlock(&clp->cl_lock);
6592
6593	return count;
6594}
6595
6596static u64
6597nfsd_print_client_openowners(struct nfs4_client *clp)
6598{
6599	u64 count = nfsd_foreach_client_openowner(clp, 0, NULL, NULL);
6600
6601	nfsd_print_count(clp, count, "openowners");
6602	return count;
6603}
6604
6605static u64
6606nfsd_collect_client_openowners(struct nfs4_client *clp,
6607			       struct list_head *collect, u64 max)
6608{
6609	return nfsd_foreach_client_openowner(clp, max, collect,
6610						unhash_openowner_locked);
6611}
6612
6613u64
6614nfsd_inject_print_openowners(void)
6615{
6616	struct nfs4_client *clp;
6617	u64 count = 0;
6618	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6619						nfsd_net_id);
6620
6621	if (!nfsd_netns_ready(nn))
6622		return 0;
6623
6624	spin_lock(&nn->client_lock);
6625	list_for_each_entry(clp, &nn->client_lru, cl_lru)
6626		count += nfsd_print_client_openowners(clp);
6627	spin_unlock(&nn->client_lock);
6628
6629	return count;
6630}
6631
6632static void
6633nfsd_reap_openowners(struct list_head *reaplist)
6634{
6635	struct nfs4_client *clp;
6636	struct nfs4_openowner *oop, *next;
6637
6638	list_for_each_entry_safe(oop, next, reaplist, oo_perclient) {
6639		list_del_init(&oop->oo_perclient);
6640		clp = oop->oo_owner.so_client;
6641		release_openowner(oop);
6642		put_client(clp);
6643	}
6644}
6645
6646u64
6647nfsd_inject_forget_client_openowners(struct sockaddr_storage *addr,
6648				     size_t addr_size)
6649{
6650	unsigned int count = 0;
6651	struct nfs4_client *clp;
6652	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6653						nfsd_net_id);
6654	LIST_HEAD(reaplist);
6655
6656	if (!nfsd_netns_ready(nn))
6657		return count;
6658
6659	spin_lock(&nn->client_lock);
6660	clp = nfsd_find_client(addr, addr_size);
6661	if (clp)
6662		count = nfsd_collect_client_openowners(clp, &reaplist, 0);
6663	spin_unlock(&nn->client_lock);
6664	nfsd_reap_openowners(&reaplist);
6665	return count;
6666}
6667
6668u64
6669nfsd_inject_forget_openowners(u64 max)
6670{
6671	u64 count = 0;
6672	struct nfs4_client *clp;
6673	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6674						nfsd_net_id);
6675	LIST_HEAD(reaplist);
6676
6677	if (!nfsd_netns_ready(nn))
6678		return count;
6679
6680	spin_lock(&nn->client_lock);
6681	list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6682		count += nfsd_collect_client_openowners(clp, &reaplist,
6683							max - count);
6684		if (max != 0 && count >= max)
6685			break;
6686	}
6687	spin_unlock(&nn->client_lock);
6688	nfsd_reap_openowners(&reaplist);
6689	return count;
6690}
6691
6692static u64 nfsd_find_all_delegations(struct nfs4_client *clp, u64 max,
6693				     struct list_head *victims)
6694{
6695	struct nfs4_delegation *dp, *next;
6696	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6697						nfsd_net_id);
6698	u64 count = 0;
6699
6700	lockdep_assert_held(&nn->client_lock);
6701
6702	spin_lock(&state_lock);
6703	list_for_each_entry_safe(dp, next, &clp->cl_delegations, dl_perclnt) {
6704		if (victims) {
6705			/*
6706			 * It's not safe to mess with delegations that have a
6707			 * non-zero dl_time. They might have already been broken
6708			 * and could be processed by the laundromat outside of
6709			 * the state_lock. Just leave them be.
6710			 */
6711			if (dp->dl_time != 0)
6712				continue;
6713
6714			atomic_inc(&clp->cl_refcount);
6715			WARN_ON(!unhash_delegation_locked(dp));
6716			list_add(&dp->dl_recall_lru, victims);
6717		}
6718		++count;
6719		/*
6720		 * Despite the fact that these functions deal with
6721		 * 64-bit integers for "count", we must ensure that
6722		 * it doesn't blow up the clp->cl_refcount. Throw a
6723		 * warning if we start to approach INT_MAX here.
6724		 */
6725		WARN_ON_ONCE(count == (INT_MAX / 2));
6726		if (count == max)
6727			break;
6728	}
6729	spin_unlock(&state_lock);
6730	return count;
6731}
6732
6733static u64
6734nfsd_print_client_delegations(struct nfs4_client *clp)
6735{
6736	u64 count = nfsd_find_all_delegations(clp, 0, NULL);
6737
6738	nfsd_print_count(clp, count, "delegations");
6739	return count;
6740}
6741
6742u64
6743nfsd_inject_print_delegations(void)
6744{
6745	struct nfs4_client *clp;
6746	u64 count = 0;
6747	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6748						nfsd_net_id);
6749
6750	if (!nfsd_netns_ready(nn))
6751		return 0;
6752
6753	spin_lock(&nn->client_lock);
6754	list_for_each_entry(clp, &nn->client_lru, cl_lru)
6755		count += nfsd_print_client_delegations(clp);
6756	spin_unlock(&nn->client_lock);
6757
6758	return count;
6759}
6760
6761static void
6762nfsd_forget_delegations(struct list_head *reaplist)
6763{
6764	struct nfs4_client *clp;
6765	struct nfs4_delegation *dp, *next;
6766
6767	list_for_each_entry_safe(dp, next, reaplist, dl_recall_lru) {
6768		list_del_init(&dp->dl_recall_lru);
6769		clp = dp->dl_stid.sc_client;
6770		revoke_delegation(dp);
6771		put_client(clp);
6772	}
6773}
6774
6775u64
6776nfsd_inject_forget_client_delegations(struct sockaddr_storage *addr,
6777				      size_t addr_size)
6778{
6779	u64 count = 0;
6780	struct nfs4_client *clp;
6781	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6782						nfsd_net_id);
6783	LIST_HEAD(reaplist);
6784
6785	if (!nfsd_netns_ready(nn))
6786		return count;
6787
6788	spin_lock(&nn->client_lock);
6789	clp = nfsd_find_client(addr, addr_size);
6790	if (clp)
6791		count = nfsd_find_all_delegations(clp, 0, &reaplist);
6792	spin_unlock(&nn->client_lock);
6793
6794	nfsd_forget_delegations(&reaplist);
6795	return count;
6796}
6797
6798u64
6799nfsd_inject_forget_delegations(u64 max)
6800{
6801	u64 count = 0;
6802	struct nfs4_client *clp;
6803	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6804						nfsd_net_id);
6805	LIST_HEAD(reaplist);
6806
6807	if (!nfsd_netns_ready(nn))
6808		return count;
6809
6810	spin_lock(&nn->client_lock);
6811	list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6812		count += nfsd_find_all_delegations(clp, max - count, &reaplist);
6813		if (max != 0 && count >= max)
6814			break;
6815	}
6816	spin_unlock(&nn->client_lock);
6817	nfsd_forget_delegations(&reaplist);
6818	return count;
6819}
6820
6821static void
6822nfsd_recall_delegations(struct list_head *reaplist)
6823{
6824	struct nfs4_client *clp;
6825	struct nfs4_delegation *dp, *next;
6826
6827	list_for_each_entry_safe(dp, next, reaplist, dl_recall_lru) {
6828		list_del_init(&dp->dl_recall_lru);
6829		clp = dp->dl_stid.sc_client;
 
 
 
6830		/*
6831		 * We skipped all entries that had a zero dl_time before,
6832		 * so we can now reset the dl_time back to 0. If a delegation
6833		 * break comes in now, then it won't make any difference since
6834		 * we're recalling it either way.
6835		 */
6836		spin_lock(&state_lock);
6837		dp->dl_time = 0;
6838		spin_unlock(&state_lock);
6839		nfsd_break_one_deleg(dp);
6840		put_client(clp);
6841	}
6842}
6843
6844u64
6845nfsd_inject_recall_client_delegations(struct sockaddr_storage *addr,
6846				      size_t addr_size)
6847{
6848	u64 count = 0;
6849	struct nfs4_client *clp;
6850	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6851						nfsd_net_id);
6852	LIST_HEAD(reaplist);
6853
6854	if (!nfsd_netns_ready(nn))
6855		return count;
6856
6857	spin_lock(&nn->client_lock);
6858	clp = nfsd_find_client(addr, addr_size);
6859	if (clp)
6860		count = nfsd_find_all_delegations(clp, 0, &reaplist);
6861	spin_unlock(&nn->client_lock);
6862
6863	nfsd_recall_delegations(&reaplist);
6864	return count;
6865}
6866
6867u64
6868nfsd_inject_recall_delegations(u64 max)
6869{
6870	u64 count = 0;
6871	struct nfs4_client *clp, *next;
6872	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6873						nfsd_net_id);
6874	LIST_HEAD(reaplist);
6875
6876	if (!nfsd_netns_ready(nn))
6877		return count;
6878
6879	spin_lock(&nn->client_lock);
6880	list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
6881		count += nfsd_find_all_delegations(clp, max - count, &reaplist);
6882		if (max != 0 && ++count >= max)
6883			break;
6884	}
6885	spin_unlock(&nn->client_lock);
6886	nfsd_recall_delegations(&reaplist);
6887	return count;
6888}
6889#endif /* CONFIG_NFSD_FAULT_INJECTION */
6890
6891/*
6892 * Since the lifetime of a delegation isn't limited to that of an open, a
6893 * client may quite reasonably hang on to a delegation as long as it has
6894 * the inode cached.  This becomes an obvious problem the first time a
6895 * client's inode cache approaches the size of the server's total memory.
6896 *
6897 * For now we avoid this problem by imposing a hard limit on the number
6898 * of delegations, which varies according to the server's memory size.
6899 */
6900static void
6901set_max_delegations(void)
6902{
6903	/*
6904	 * Allow at most 4 delegations per megabyte of RAM.  Quick
6905	 * estimates suggest that in the worst case (where every delegation
6906	 * is for a different inode), a delegation could take about 1.5K,
6907	 * giving a worst case usage of about 6% of memory.
6908	 */
6909	max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
6910}
6911
6912static int nfs4_state_create_net(struct net *net)
6913{
6914	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
6915	int i;
6916
6917	nn->conf_id_hashtbl = kmalloc(sizeof(struct list_head) *
6918			CLIENT_HASH_SIZE, GFP_KERNEL);
 
6919	if (!nn->conf_id_hashtbl)
6920		goto err;
6921	nn->unconf_id_hashtbl = kmalloc(sizeof(struct list_head) *
6922			CLIENT_HASH_SIZE, GFP_KERNEL);
 
6923	if (!nn->unconf_id_hashtbl)
6924		goto err_unconf_id;
6925	nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) *
6926			SESSION_HASH_SIZE, GFP_KERNEL);
 
6927	if (!nn->sessionid_hashtbl)
6928		goto err_sessionid;
6929
6930	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
6931		INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);
6932		INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);
6933	}
6934	for (i = 0; i < SESSION_HASH_SIZE; i++)
6935		INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
6936	nn->conf_name_tree = RB_ROOT;
6937	nn->unconf_name_tree = RB_ROOT;
 
 
 
 
6938	INIT_LIST_HEAD(&nn->client_lru);
6939	INIT_LIST_HEAD(&nn->close_lru);
6940	INIT_LIST_HEAD(&nn->del_recall_lru);
6941	spin_lock_init(&nn->client_lock);
 
 
6942
6943	spin_lock_init(&nn->blocked_locks_lock);
6944	INIT_LIST_HEAD(&nn->blocked_locks_lru);
6945
6946	INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
6947	get_net(net);
6948
6949	return 0;
6950
6951err_sessionid:
6952	kfree(nn->unconf_id_hashtbl);
6953err_unconf_id:
6954	kfree(nn->conf_id_hashtbl);
6955err:
6956	return -ENOMEM;
6957}
6958
6959static void
6960nfs4_state_destroy_net(struct net *net)
6961{
6962	int i;
6963	struct nfs4_client *clp = NULL;
6964	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
6965
6966	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
6967		while (!list_empty(&nn->conf_id_hashtbl[i])) {
6968			clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
6969			destroy_client(clp);
6970		}
6971	}
6972
 
 
6973	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
6974		while (!list_empty(&nn->unconf_id_hashtbl[i])) {
6975			clp = list_entry(nn->unconf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
6976			destroy_client(clp);
6977		}
6978	}
6979
6980	kfree(nn->sessionid_hashtbl);
6981	kfree(nn->unconf_id_hashtbl);
6982	kfree(nn->conf_id_hashtbl);
6983	put_net(net);
6984}
6985
6986int
6987nfs4_state_start_net(struct net *net)
6988{
6989	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
6990	int ret;
6991
6992	ret = nfs4_state_create_net(net);
6993	if (ret)
6994		return ret;
6995	nn->boot_time = get_seconds();
6996	nn->grace_ended = false;
6997	nn->nfsd4_manager.block_opens = true;
 
 
6998	locks_start_grace(net, &nn->nfsd4_manager);
6999	nfsd4_client_tracking_init(net);
7000	printk(KERN_INFO "NFSD: starting %ld-second grace period (net %p)\n",
7001	       nn->nfsd4_grace, net);
 
 
 
7002	queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ);
7003	return 0;
 
 
 
 
 
 
 
7004}
7005
7006/* initialization to perform when the nfsd service is started: */
7007
7008int
7009nfs4_state_start(void)
7010{
7011	int ret;
7012
7013	ret = set_callback_cred();
7014	if (ret)
7015		return -ENOMEM;
7016	laundry_wq = alloc_workqueue("%s", WQ_UNBOUND, 0, "nfsd4");
7017	if (laundry_wq == NULL) {
7018		ret = -ENOMEM;
7019		goto out_recovery;
7020	}
7021	ret = nfsd4_create_callback_queue();
7022	if (ret)
7023		goto out_free_laundry;
7024
7025	set_max_delegations();
7026
7027	return 0;
7028
7029out_free_laundry:
7030	destroy_workqueue(laundry_wq);
7031out_recovery:
7032	return ret;
7033}
7034
7035void
7036nfs4_state_shutdown_net(struct net *net)
7037{
7038	struct nfs4_delegation *dp = NULL;
7039	struct list_head *pos, *next, reaplist;
7040	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
7041	struct nfsd4_blocked_lock *nbl;
7042
7043	cancel_delayed_work_sync(&nn->laundromat_work);
7044	locks_end_grace(&nn->nfsd4_manager);
7045
7046	INIT_LIST_HEAD(&reaplist);
7047	spin_lock(&state_lock);
7048	list_for_each_safe(pos, next, &nn->del_recall_lru) {
7049		dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
7050		WARN_ON(!unhash_delegation_locked(dp));
7051		list_add(&dp->dl_recall_lru, &reaplist);
7052	}
7053	spin_unlock(&state_lock);
7054	list_for_each_safe(pos, next, &reaplist) {
7055		dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
7056		list_del_init(&dp->dl_recall_lru);
7057		put_clnt_odstate(dp->dl_clnt_odstate);
7058		nfs4_put_deleg_lease(dp->dl_stid.sc_file);
7059		nfs4_put_stid(&dp->dl_stid);
7060	}
7061
7062	BUG_ON(!list_empty(&reaplist));
7063	spin_lock(&nn->blocked_locks_lock);
7064	while (!list_empty(&nn->blocked_locks_lru)) {
7065		nbl = list_first_entry(&nn->blocked_locks_lru,
7066					struct nfsd4_blocked_lock, nbl_lru);
7067		list_move(&nbl->nbl_lru, &reaplist);
7068		list_del_init(&nbl->nbl_list);
7069	}
7070	spin_unlock(&nn->blocked_locks_lock);
7071
7072	while (!list_empty(&reaplist)) {
7073		nbl = list_first_entry(&nn->blocked_locks_lru,
7074					struct nfsd4_blocked_lock, nbl_lru);
7075		list_del_init(&nbl->nbl_lru);
7076		posix_unblock_lock(&nbl->nbl_lock);
7077		free_blocked_lock(nbl);
7078	}
7079
7080	nfsd4_client_tracking_exit(net);
7081	nfs4_state_destroy_net(net);
 
7082}
7083
7084void
7085nfs4_state_shutdown(void)
7086{
7087	destroy_workqueue(laundry_wq);
7088	nfsd4_destroy_callback_queue();
7089}
7090
7091static void
7092get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
7093{
7094	if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG) && CURRENT_STATEID(stateid))
 
7095		memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
7096}
7097
7098static void
7099put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
7100{
7101	if (cstate->minorversion) {
7102		memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
7103		SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
7104	}
7105}
7106
7107void
7108clear_current_stateid(struct nfsd4_compound_state *cstate)
7109{
7110	CLEAR_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
7111}
7112
7113/*
7114 * functions to set current state id
7115 */
7116void
7117nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
 
7118{
7119	put_stateid(cstate, &odp->od_stateid);
7120}
7121
7122void
7123nfsd4_set_openstateid(struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
 
7124{
7125	put_stateid(cstate, &open->op_stateid);
7126}
7127
7128void
7129nfsd4_set_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
 
7130{
7131	put_stateid(cstate, &close->cl_stateid);
7132}
7133
7134void
7135nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate, struct nfsd4_lock *lock)
 
7136{
7137	put_stateid(cstate, &lock->lk_resp_stateid);
7138}
7139
7140/*
7141 * functions to consume current state id
7142 */
7143
7144void
7145nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
 
7146{
7147	get_stateid(cstate, &odp->od_stateid);
7148}
7149
7150void
7151nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate, struct nfsd4_delegreturn *drp)
 
7152{
7153	get_stateid(cstate, &drp->dr_stateid);
7154}
7155
7156void
7157nfsd4_get_freestateid(struct nfsd4_compound_state *cstate, struct nfsd4_free_stateid *fsp)
 
7158{
7159	get_stateid(cstate, &fsp->fr_stateid);
7160}
7161
7162void
7163nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate, struct nfsd4_setattr *setattr)
 
7164{
7165	get_stateid(cstate, &setattr->sa_stateid);
7166}
7167
7168void
7169nfsd4_get_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
 
7170{
7171	get_stateid(cstate, &close->cl_stateid);
7172}
7173
7174void
7175nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate, struct nfsd4_locku *locku)
 
7176{
7177	get_stateid(cstate, &locku->lu_stateid);
7178}
7179
7180void
7181nfsd4_get_readstateid(struct nfsd4_compound_state *cstate, struct nfsd4_read *read)
 
7182{
7183	get_stateid(cstate, &read->rd_stateid);
7184}
7185
7186void
7187nfsd4_get_writestateid(struct nfsd4_compound_state *cstate, struct nfsd4_write *write)
 
7188{
7189	get_stateid(cstate, &write->wr_stateid);
7190}