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