Release 4.11 fs/nfsd/nfs4state.c

Directory: fs/nfsd
/*
*  Copyright (c) 2001 The Regents of the University of Michigan.
*  All rights reserved.
*
*  Kendrick Smith <kmsmith@umich.edu>
*  Andy Adamson <kandros@umich.edu>
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions
*  are met:
*
*  1. Redistributions of source code must retain the above copyright
*     notice, this list of conditions and the following disclaimer.
*  2. Redistributions in binary form must reproduce the above copyright
*     notice, this list of conditions and the following disclaimer in the
*     documentation and/or other materials provided with the distribution.
*  3. Neither the name of the University nor the names of its
*     contributors may be used to endorse or promote products derived
*     from this software without specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
*  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
*  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
*  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
*  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
*  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
*  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
*  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
*  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

#include <linux/file.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/namei.h>
#include <linux/swap.h>
#include <linux/pagemap.h>
#include <linux/ratelimit.h>
#include <linux/sunrpc/svcauth_gss.h>
#include <linux/sunrpc/addr.h>
#include <linux/jhash.h>
#include "xdr4.h"
#include "xdr4cb.h"
#include "vfs.h"
#include "current_stateid.h"

#include "netns.h"
#include "pnfs.h"


#define NFSDDBG_FACILITY                NFSDDBG_PROC


#define all_ones {{~0,~0},~0}

static const stateid_t one_stateid = {
	.si_generation = ~0,
	.si_opaque = all_ones,
};

static const stateid_t zero_stateid = {
	/* all fields zero */
};

static const stateid_t currentstateid = {
	.si_generation = 1,
};


static u64 current_sessionid = 1;


#define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))

#define ONE_STATEID(stateid)  (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))

#define CURRENT_STATEID(stateid) (!memcmp((stateid), &currentstateid, sizeof(stateid_t)))

/* forward declarations */
static bool check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner);
static void nfs4_free_ol_stateid(struct nfs4_stid *stid);

/* Locking: */

/*
 * Currently used for the del_recall_lru and file hash table.  In an
 * effort to decrease the scope of the client_mutex, this spinlock may
 * eventually cover more:
 */
static DEFINE_SPINLOCK(state_lock);

/*
 * A waitqueue for all in-progress 4.0 CLOSE operations that are waiting for
 * the refcount on the open stateid to drop.
 */
static DECLARE_WAIT_QUEUE_HEAD(close_wq);


static struct kmem_cache *openowner_slab;

static struct kmem_cache *lockowner_slab;

static struct kmem_cache *file_slab;

static struct kmem_cache *stateid_slab;

static struct kmem_cache *deleg_slab;

static struct kmem_cache *odstate_slab;

static void free_session(struct nfsd4_session *);


static const struct nfsd4_callback_ops nfsd4_cb_recall_ops;

static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops;



static bool is_session_dead(struct nfsd4_session *ses)
{
	return ses->se_flags & NFS4_SESSION_DEAD;
}

Contributors
Person Tokens Prop Commits CommitProp
Benny Halevy 10 55.56% 1 50.00%
J. Bruce Fields 8 44.44% 1 50.00%
Total 18 100.00% 2 100.00%



static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me)
{
	if (atomic_read(&ses->se_ref) > ref_held_by_me)
		return nfserr_jukebox;
	ses->se_flags |= NFS4_SESSION_DEAD;
	return nfs_ok;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 38 100.00% 2 100.00%
Total 38 100.00% 2 100.00%



static bool is_client_expired(struct nfs4_client *clp)
{
	return clp->cl_time == 0;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 10 55.56% 1 50.00%
Neil Brown 8 44.44% 1 50.00%
Total 18 100.00% 2 100.00%



static __be32 get_client_locked(struct nfs4_client *clp)
{
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	lockdep_assert_held(&nn->client_lock);

	if (is_client_expired(clp))
		return nfserr_expired;
	atomic_inc(&clp->cl_refcount);
	return nfs_ok;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 22 40.74% 1 25.00%
J. Bruce Fields 21 38.89% 2 50.00%
Neil Brown 11 20.37% 1 25.00%
Total 54 100.00% 4 100.00%

/* must be called under the client_lock */

static inline void

renew_client_locked(struct nfs4_client *clp)
{
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	if (is_client_expired(clp)) {
		WARN_ON(1);
		printk("%s: client (clientid %08x/%08x) already expired\n",
			__func__,
			clp->cl_clientid.cl_boot,
			clp->cl_clientid.cl_id);
		return;
	}

	dprintk("renewing client (clientid %08x/%08x)\n",
			clp->cl_clientid.cl_boot,
			clp->cl_clientid.cl_id);
	list_move_tail(&clp->cl_lru, &nn->client_lru);
	clp->cl_time = get_seconds();
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 97 100.00% 1 100.00%
Total 97 100.00% 1 100.00%



static void put_client_renew_locked(struct nfs4_client *clp)
{
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	lockdep_assert_held(&nn->client_lock);

	if (!atomic_dec_and_test(&clp->cl_refcount))
		return;
	if (!is_client_expired(clp))
		renew_client_locked(clp);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 35 60.34% 1 33.33%
Trond Myklebust 22 37.93% 1 33.33%
Fengguang Wu 1 1.72% 1 33.33%
Total 58 100.00% 3 100.00%



static void put_client_renew(struct nfs4_client *clp)
{
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock))
		return;
	if (!is_client_expired(clp))
		renew_client_locked(clp);
	spin_unlock(&nn->client_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 63 100.00% 2 100.00%
Total 63 100.00% 2 100.00%



static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
{
	__be32 status;

	if (is_session_dead(ses))
		return nfserr_badsession;
	status = get_client_locked(ses->se_client);
	if (status)
		return status;
	atomic_inc(&ses->se_ref);
	return nfs_ok;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 51 100.00% 1 100.00%
Total 51 100.00% 1 100.00%



static void nfsd4_put_session_locked(struct nfsd4_session *ses)
{
	struct nfs4_client *clp = ses->se_client;
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	lockdep_assert_held(&nn->client_lock);

	if (atomic_dec_and_test(&ses->se_ref) && is_session_dead(ses))
		free_session(ses);
	put_client_renew_locked(clp);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 67 100.00% 2 100.00%
Total 67 100.00% 2 100.00%



static void nfsd4_put_session(struct nfsd4_session *ses)
{
	struct nfs4_client *clp = ses->se_client;
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	spin_lock(&nn->client_lock);
	nfsd4_put_session_locked(ses);
	spin_unlock(&nn->client_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 55 100.00% 1 100.00%
Total 55 100.00% 1 100.00%


static struct nfsd4_blocked_lock *

find_blocked_lock(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
			struct nfsd_net *nn)
{
	struct nfsd4_blocked_lock *cur, *found = NULL;

	spin_lock(&nn->blocked_locks_lock);
	list_for_each_entry(cur, &lo->lo_blocked, nbl_list) {
		if (fh_match(fh, &cur->nbl_fh)) {
			list_del_init(&cur->nbl_list);
			list_del_init(&cur->nbl_lru);
			found = cur;
			break;
		}
	}
	spin_unlock(&nn->blocked_locks_lock);
	if (found)
		posix_unblock_lock(&found->nbl_lock);
	return found;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 108 99.08% 3 75.00%
Neil Brown 1 0.92% 1 25.00%
Total 109 100.00% 4 100.00%


static struct nfsd4_blocked_lock *

find_or_allocate_block(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
			struct nfsd_net *nn)
{
	struct nfsd4_blocked_lock *nbl;

	nbl = find_blocked_lock(lo, fh, nn);
	if (!nbl) {
		nbl= kmalloc(sizeof(*nbl), GFP_KERNEL);
		if (nbl) {
			fh_copy_shallow(&nbl->nbl_fh, fh);
			locks_init_lock(&nbl->nbl_lock);
			nfsd4_init_cb(&nbl->nbl_cb, lo->lo_owner.so_client,
					&nfsd4_cb_notify_lock_ops,
					NFSPROC4_CLNT_CB_NOTIFY_LOCK);
		}
	}
	return nbl;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 105 100.00% 1 100.00%
Total 105 100.00% 1 100.00%


static void

free_blocked_lock(struct nfsd4_blocked_lock *nbl)
{
	locks_release_private(&nbl->nbl_lock);
	kfree(nbl);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%


static int

nfsd4_cb_notify_lock_done(struct nfsd4_callback *cb, struct rpc_task *task)
{
	/*
         * Since this is just an optimization, we don't try very hard if it
         * turns out not to succeed. We'll requeue it on NFS4ERR_DELAY, and
         * just quit trying on anything else.
         */
	switch (task->tk_status) {
	case -NFS4ERR_DELAY:
		rpc_delay(task, 1 * HZ);
		return 0;
	default:
		return 1;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 45 100.00% 1 100.00%
Total 45 100.00% 1 100.00%


static void

nfsd4_cb_notify_lock_release(struct nfsd4_callback *cb)
{
	struct nfsd4_blocked_lock	*nbl = container_of(cb,
						struct nfsd4_blocked_lock, nbl_cb);

	free_blocked_lock(nbl);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%


static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops = {
	.done		= nfsd4_cb_notify_lock_done,
	.release	= nfsd4_cb_notify_lock_release,
};


static inline struct nfs4_stateowner *

nfs4_get_stateowner(struct nfs4_stateowner *sop)
{
	atomic_inc(&sop->so_count);
	return sop;
}

Contributors
Person Tokens Prop Commits CommitProp
Kinglong Mee 24 96.00% 1 50.00%
Jeff Layton 1 4.00% 1 50.00%
Total 25 100.00% 2 100.00%


static int

same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner)
{
	return (sop->so_owner.len == owner->len) &&
		0 == memcmp(sop->so_owner.data, owner->data, owner->len);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 47 97.92% 1 50.00%
Kinglong Mee 1 2.08% 1 50.00%
Total 48 100.00% 2 100.00%


static struct nfs4_openowner *

find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open,
			struct nfs4_client *clp)
{
	struct nfs4_stateowner *so;

	lockdep_assert_held(&clp->cl_lock);

	list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[hashval],
			    so_strhash) {
		if (!so->so_is_open_owner)
			continue;
		if (same_owner_str(so, &open->op_owner))
			return openowner(nfs4_get_stateowner(so));
	}
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 74 96.10% 2 66.67%
Kinglong Mee 3 3.90% 1 33.33%
Total 77 100.00% 3 100.00%


static struct nfs4_openowner *

find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
			struct nfs4_client *clp)
{
	struct nfs4_openowner *oo;

	spin_lock(&clp->cl_lock);
	oo = find_openstateowner_str_locked(hashval, open, clp);
	spin_unlock(&clp->cl_lock);
	return oo;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 57 100.00% 2 100.00%
Total 57 100.00% 2 100.00%


static inline u32

opaque_hashval(const void *ptr, int nbytes)
{
	unsigned char *cptr = (unsigned char *) ptr;

	u32 x = 0;
	while (nbytes--) {
		x *= 37;
		x += *cptr++;
	}
	return x;
}

Contributors
Person Tokens Prop Commits CommitProp
Neil Brown 51 98.08% 1 50.00%
Trond Myklebust 1 1.92% 1 50.00%
Total 52 100.00% 2 100.00%



static void nfsd4_free_file_rcu(struct rcu_head *rcu)
{
	struct nfs4_file *fp = container_of(rcu, struct nfs4_file, fi_rcu);

	kmem_cache_free(file_slab, fp);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 19 57.58% 1 50.00%
J. Bruce Fields 14 42.42% 1 50.00%
Total 33 100.00% 2 100.00%


void

put_nfs4_file(struct nfs4_file *fi)
{
	might_lock(&state_lock);

	if (atomic_dec_and_lock(&fi->fi_ref, &state_lock)) {
		hlist_del_rcu(&fi->fi_hash);
		spin_unlock(&state_lock);
		WARN_ON_ONCE(!list_empty(&fi->fi_clnt_odstate));
		WARN_ON_ONCE(!list_empty(&fi->fi_delegations));
		call_rcu(&fi->fi_rcu, nfsd4_free_file_rcu);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 25 31.65% 2 33.33%
Neil Brown 20 25.32% 1 16.67%
J. Bruce Fields 20 25.32% 1 16.67%
Sachin Bhamare 12 15.19% 1 16.67%
Benny Halevy 2 2.53% 1 16.67%
Total 79 100.00% 6 100.00%


static struct file *

__nfs4_get_fd(struct nfs4_file *f, int oflag)
{
	if (f->fi_fds[oflag])
		return get_file(f->fi_fds[oflag]);
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 38 97.44% 1 50.00%
Neil Brown 1 2.56% 1 50.00%
Total 39 100.00% 2 100.00%


static struct file *

find_writeable_file_locked(struct nfs4_file *f)
{
	struct file *ret;

	lockdep_assert_held(&f->fi_lock);

	ret = __nfs4_get_fd(f, O_WRONLY);
	if (!ret)
		ret = __nfs4_get_fd(f, O_RDWR);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 52 100.00% 1 100.00%
Total 52 100.00% 1 100.00%


static struct file *

find_writeable_file(struct nfs4_file *f)
{
	struct file *ret;

	spin_lock(&f->fi_lock);
	ret = find_writeable_file_locked(f);
	spin_unlock(&f->fi_lock);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 44 100.00% 1 100.00%
Total 44 100.00% 1 100.00%



static struct file *find_readable_file_locked(struct nfs4_file *f)
{
	struct file *ret;

	lockdep_assert_held(&f->fi_lock);

	ret = __nfs4_get_fd(f, O_RDONLY);
	if (!ret)
		ret = __nfs4_get_fd(f, O_RDWR);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 52 100.00% 1 100.00%
Total 52 100.00% 1 100.00%


static struct file *

find_readable_file(struct nfs4_file *f)
{
	struct file *ret;

	spin_lock(&f->fi_lock);
	ret = find_readable_file_locked(f);
	spin_unlock(&f->fi_lock);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 44 100.00% 1 100.00%
Total 44 100.00% 1 100.00%


struct file *

find_any_file(struct nfs4_file *f)
{
	struct file *ret;

	spin_lock(&f->fi_lock);
	ret = __nfs4_get_fd(f, O_RDWR);
	if (!ret) {
		ret = __nfs4_get_fd(f, O_WRONLY);
		if (!ret)
			ret = __nfs4_get_fd(f, O_RDONLY);
	}
	spin_unlock(&f->fi_lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 75 100.00% 1 100.00%
Total 75 100.00% 1 100.00%


static atomic_long_t num_delegations;

unsigned long max_delegations;

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

/* hash tables for lock and open owners */

#define OWNER_HASH_BITS              8

#define OWNER_HASH_SIZE             (1 << OWNER_HASH_BITS)

#define OWNER_HASH_MASK             (OWNER_HASH_SIZE - 1)



static unsigned int ownerstr_hashval(struct xdr_netobj *ownername)
{
	unsigned int ret;

	ret = opaque_hashval(ownername->data, ownername->len);
	return ret & OWNER_HASH_MASK;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 31 91.18% 2 66.67%
Neil Brown 3 8.82% 1 33.33%
Total 34 100.00% 3 100.00%

/* hash table for nfs4_file */

#define FILE_HASH_BITS                   8

#define FILE_HASH_SIZE                  (1 << FILE_HASH_BITS)



static unsigned int nfsd_fh_hashval(struct knfsd_fh *fh)
{
	return jhash2(fh->fh_base.fh_pad, XDR_QUADLEN(fh->fh_size), 0);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%



static unsigned int file_hashval(struct knfsd_fh *fh)
{
	return nfsd_fh_hashval(fh) & (FILE_HASH_SIZE - 1);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 13 54.17% 1 33.33%
J. Bruce Fields 8 33.33% 1 33.33%
Neil Brown 3 12.50% 1 33.33%
Total 24 100.00% 3 100.00%


static struct hlist_head file_hashtbl[FILE_HASH_SIZE];


static void

__nfs4_file_get_access(struct nfs4_file *fp, u32 access)
{
	lockdep_assert_held(&fp->fi_lock);

	if (access & NFS4_SHARE_ACCESS_WRITE)
		atomic_inc(&fp->fi_access[O_WRONLY]);
	if (access & NFS4_SHARE_ACCESS_READ)
		atomic_inc(&fp->fi_access[O_RDONLY]);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 29 51.79% 2 50.00%
Jeff Layton 27 48.21% 2 50.00%
Total 56 100.00% 4 100.00%


static __be32

nfs4_file_get_access(struct nfs4_file *fp, u32 access)
{
	lockdep_assert_held(&fp->fi_lock);

	/* Does this access mode make sense? */
	if (access & ~NFS4_SHARE_ACCESS_BOTH)
		return nfserr_inval;

	/* Does it conflict with a deny mode already set? */
	if ((access & fp->fi_share_deny) != 0)
		return nfserr_share_denied;

	__nfs4_file_get_access(fp, access);
	return nfs_ok;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 39 66.10% 3 60.00%
J. Bruce Fields 20 33.90% 2 40.00%
Total 59 100.00% 5 100.00%



static __be32 nfs4_file_check_deny(struct nfs4_file *fp, u32 deny)
{
	/* Common case is that there is no deny mode. */
	if (deny) {
		/* Does this deny mode make sense? */
		if (deny & ~NFS4_SHARE_DENY_BOTH)
			return nfserr_inval;

		if ((deny & NFS4_SHARE_DENY_READ) &&
		    atomic_read(&fp->fi_access[O_RDONLY]))
			return nfserr_share_denied;

		if ((deny & NFS4_SHARE_DENY_WRITE) &&
		    atomic_read(&fp->fi_access[O_WRONLY]))
			return nfserr_share_denied;
	}
	return nfs_ok;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 79 100.00% 1 100.00%
Total 79 100.00% 1 100.00%



static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
{
	might_lock(&fp->fi_lock);

	if (atomic_dec_and_lock(&fp->fi_access[oflag], &fp->fi_lock)) {
		struct file *f1 = NULL;
		struct file *f2 = NULL;

		swap(f1, fp->fi_fds[oflag]);
		if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
			swap(f2, fp->fi_fds[O_RDWR]);
		spin_unlock(&fp->fi_lock);
		if (f1)
			fput(f1);
		if (f2)
			fput(f2);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 55 44.72% 3 60.00%
Trond Myklebust 54 43.90% 1 20.00%
Jeff Layton 14 11.38% 1 20.00%
Total 123 100.00% 5 100.00%



static void nfs4_file_put_access(struct nfs4_file *fp, u32 access)
{
	WARN_ON_ONCE(access & ~NFS4_SHARE_ACCESS_BOTH);

	if (access & NFS4_SHARE_ACCESS_WRITE)
		__nfs4_file_put_access(fp, O_WRONLY);
	if (access & NFS4_SHARE_ACCESS_READ)
		__nfs4_file_put_access(fp, O_RDONLY);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 28 58.33% 1 50.00%
Jeff Layton 20 41.67% 1 50.00%
Total 48 100.00% 2 100.00%

/*
 * Allocate a new open/delegation state counter. This is needed for
 * pNFS for proper return on close semantics.
 *
 * Note that we only allocate it for pNFS-enabled exports, otherwise
 * all pointers to struct nfs4_clnt_odstate are always NULL.
 */

static struct nfs4_clnt_odstate *

alloc_clnt_odstate(struct nfs4_client *clp)
{
	struct nfs4_clnt_odstate *co;

	co = kmem_cache_zalloc(odstate_slab, GFP_KERNEL);
	if (co) {
		co->co_client = clp;
		atomic_set(&co->co_odcount, 1);
	}
	return co;
}

Contributors
Person Tokens Prop Commits CommitProp
Sachin Bhamare 52 100.00% 1 100.00%
Total 52 100.00% 1 100.00%


static void

hash_clnt_odstate_locked(struct nfs4_clnt_odstate *co)
{
	struct nfs4_file *fp = co->co_file;

	lockdep_assert_held(&fp->fi_lock);
	list_add(&co->co_perfile, &fp->fi_clnt_odstate);
}

Contributors
Person Tokens Prop Commits CommitProp
Sachin Bhamare 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%


static inline void

get_clnt_odstate(struct nfs4_clnt_odstate *co)
{
	if (co)
		atomic_inc(&co->co_odcount);
}

Contributors
Person Tokens Prop Commits CommitProp
Sachin Bhamare 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%


static void

put_clnt_odstate(struct nfs4_clnt_odstate *co)
{
	struct nfs4_file *fp;

	if (!co)
		return;

	fp = co->co_file;
	if (atomic_dec_and_lock(&co->co_odcount, &fp->fi_lock)) {
		list_del(&co->co_perfile);
		spin_unlock(&fp->fi_lock);

		nfsd4_return_all_file_layouts(co->co_client, fp);
		kmem_cache_free(odstate_slab, co);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Sachin Bhamare 77 100.00% 1 100.00%
Total 77 100.00% 1 100.00%


static struct nfs4_clnt_odstate *

find_or_hash_clnt_odstate(struct nfs4_file *fp, struct nfs4_clnt_odstate *new)
{
	struct nfs4_clnt_odstate *co;
	struct nfs4_client *cl;

	if (!new)
		return NULL;

	cl = new->co_client;

	spin_lock(&fp->fi_lock);
	list_for_each_entry(co, &fp->fi_clnt_odstate, co_perfile) {
		if (co->co_client == cl) {
			get_clnt_odstate(co);
			goto out;
		}
	}
	co = new;
	co->co_file = fp;
	hash_clnt_odstate_locked(new);
out:
	spin_unlock(&fp->fi_lock);
	return co;
}

Contributors
Person Tokens Prop Commits CommitProp
Sachin Bhamare 106 100.00% 1 100.00%
Total 106 100.00% 1 100.00%



struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab,
				  void (*sc_free)(struct nfs4_stid *))
{
	struct nfs4_stid *stid;
	int new_id;

	stid = kmem_cache_zalloc(slab, GFP_KERNEL);
	if (!stid)
		return NULL;

	idr_preload(GFP_KERNEL);
	spin_lock(&cl->cl_lock);
	new_id = idr_alloc_cyclic(&cl->cl_stateids, stid, 0, 0, GFP_NOWAIT);
	spin_unlock(&cl->cl_lock);
	idr_preload_end();
	if (new_id < 0)
		goto out_free;

	stid->sc_free = sc_free;
	stid->sc_client = cl;
	stid->sc_stateid.si_opaque.so_id = new_id;
	stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
	/* Will be incremented before return to client: */
	atomic_set(&stid->sc_count, 1);
	spin_lock_init(&stid->sc_lock);

	/*
         * It shouldn't be a problem to reuse an opaque stateid value.
         * I don't think it is for 4.1.  But with 4.0 I worry that, for
         * example, a stray write retransmission could be accepted by
         * the server when it should have been rejected.  Therefore,
         * adopt a trick from the sctp code to attempt to maximize the
         * amount of time until an id is reused, by ensuring they always
         * "increase" (mod INT_MAX):
         */
	return stid;
out_free:
	kmem_cache_free(slab, stid);
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 93 53.76% 4 33.33%
Jeff Layton 39 22.54% 3 25.00%
Kinglong Mee 17 9.83% 1 8.33%
Trond Myklebust 11 6.36% 2 16.67%
Tejun Heo 10 5.78% 1 8.33%
Wei Yongjun 3 1.73% 1 8.33%
Total 173 100.00% 12 100.00%



static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp)
{
	struct nfs4_stid *stid;

	stid = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_ol_stateid);
	if (!stid)
		return NULL;

	return openlockstateid(stid);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 20 46.51% 1 25.00%
Trond Myklebust 19 44.19% 1 25.00%
Kinglong Mee 3 6.98% 1 25.00%
Jeff Layton 1 2.33% 1 25.00%
Total 43 100.00% 4 100.00%



static void nfs4_free_deleg(struct nfs4_stid *stid)
{
	kmem_cache_free(deleg_slab, stid);
	atomic_long_dec(&num_delegations);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%

/*
 * When we recall a delegation, we should be careful not to hand it
 * out again straight away.
 * To ensure this we keep a pair of bloom filters ('new' and 'old')
 * in which the filehandles of recalled delegations are "stored".
 * If a filehandle appear in either filter, a delegation is blocked.
 * When a delegation is recalled, the filehandle is stored in the "new"
 * filter.
 * Every 30 seconds we swap the filters and clear the "new" one,
 * unless both are empty of course.
 *
 * Each filter is 256 bits.  We hash the filehandle to 32bit and use the
 * low 3 bytes as hash-table indices.
 *
 * 'blocked_delegations_lock', which is always taken in block_delegations(),
 * is used to manage concurrent access.  Testing does not need the lock
 * except when swapping the two filters.
 */
static DEFINE_SPINLOCK(blocked_delegations_lock);

static struct bloom_pair {
	

int	entries, old_entries;
	
time_t	swap_time;
	
int	new; /* index into 'set' */
	DECLARE_BITMAP(set[2], 256);
} 
blocked_delegations;



static int delegation_blocked(struct knfsd_fh *fh)
{
	u32 hash;
	struct bloom_pair *bd = &blocked_delegations;

	if (bd->entries == 0)
		return 0;
	if (seconds_since_boot() - bd->swap_time > 30) {
		spin_lock(&blocked_delegations_lock);
		if (seconds_since_boot() - bd->swap_time > 30) {
			bd->entries -= bd->old_entries;
			bd->old_entries = bd->entries;
			memset(bd->set[bd->new], 0,
			       sizeof(bd->set[0]));
			bd->new = 1-bd->new;
			bd->swap_time = seconds_since_boot();
		}
		spin_unlock(&blocked_delegations_lock);
	}
	hash = jhash(&fh->fh_base, fh->fh_size, 0);
	if (test_bit(hash&255, bd->set[0]) &&
	    test_bit((hash>>8)&255, bd->set[0]) &&
	    test_bit((hash>>16)&255, bd->set[0]))
		return 1;

	if (test_bit(hash&255, bd->set[1]) &&
	    test_bit((hash>>8)&255, bd->set[1]) &&
	    test_bit((hash>>16)&255, bd->set[1]))
		return 1;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Neil Brown 254 98.83% 1 33.33%
Jeff Layton 2 0.78% 1 33.33%
Daniel Borkmann 1 0.39% 1 33.33%
Total 257 100.00% 3 100.00%



static void block_delegations(struct knfsd_fh *fh)
{
	u32 hash;
	struct bloom_pair *bd = &blocked_delegations;

	hash = jhash(&fh->fh_base, fh->fh_size, 0);

	spin_lock(&blocked_delegations_lock);
	__set_bit(hash&255, bd->set[bd->new]);
	__set_bit((hash>>8)&255, bd->set[bd->new]);
	__set_bit((hash>>16)&255, bd->set[bd->new]);
	if (bd->entries == 0)
		bd->swap_time = seconds_since_boot();
	bd->entries += 1;
	spin_unlock(&blocked_delegations_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Neil Brown 114 89.76% 1 33.33%
Jeff Layton 12 9.45% 1 33.33%
Daniel Borkmann 1 0.79% 1 33.33%
Total 127 100.00% 3 100.00%


static struct nfs4_delegation *

alloc_init_deleg(struct nfs4_client *clp, struct svc_fh *current_fh,
		 struct nfs4_clnt_odstate *odstate)
{
	struct nfs4_delegation *dp;
	long n;

	dprintk("NFSD alloc_init_deleg\n");
	n = atomic_long_inc_return(&num_delegations);
	if (n < 0 || n > max_delegations)
		goto out_dec;
	if (delegation_blocked(&current_fh->fh_handle))
		goto out_dec;
	dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab, nfs4_free_deleg));
	if (dp == NULL)
		goto out_dec;

	/*
         * delegation seqid's are never incremented.  The 4.1 special
         * meaning of seqid 0 isn't meaningful, really, but let's avoid
         * 0 anyway just for consistency and use 1:
         */
	dp->dl_stid.sc_stateid.si_generation = 1;
	INIT_LIST_HEAD(&dp->dl_perfile);
	INIT_LIST_HEAD(&dp->dl_perclnt);
	INIT_LIST_HEAD(&dp->dl_recall_lru);
	dp->dl_clnt_odstate = odstate;
	get_clnt_odstate(odstate);
	dp->dl_type = NFS4_OPEN_DELEGATE_READ;
	dp->dl_retries = 1;
	nfsd4_init_cb(&dp->dl_recall, dp->dl_stid.sc_client,
		      &nfsd4_cb_recall_ops, NFSPROC4_CLNT_CB_RECALL);
	return dp;
out_dec:
	atomic_long_dec(&num_delegations);
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Neil Brown 86 46.74% 6 33.33%
Trond Myklebust 36 19.57% 1 5.56%
Christoph Hellwig 21 11.41% 2 11.11%
J. Bruce Fields 21 11.41% 5 27.78%
Sachin Bhamare 16 8.70% 1 5.56%
Kinglong Mee 2 1.09% 1 5.56%
Meelap Shah 1 0.54% 1 5.56%
Jeff Layton 1 0.54% 1 5.56%
Total 184 100.00% 18 100.00%


void

nfs4_put_stid(struct nfs4_stid *s)
{
	struct nfs4_file *fp = s->sc_file;
	struct nfs4_client *clp = s->sc_client;

	might_lock(&clp->cl_lock);

	if (!atomic_dec_and_lock(&s->sc_count, &clp->cl_lock)) {
		wake_up_all(&close_wq);
		return;
	}
	idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
	spin_unlock(&clp->cl_lock);
	s->sc_free(s);
	if (fp)
		put_nfs4_file(fp);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 43 42.57% 5 41.67%
Jeff Layton 30 29.70% 2 16.67%
J. Bruce Fields 15 14.85% 1 8.33%
Neil Brown 12 11.88% 3 25.00%
Benny Halevy 1 0.99% 1 8.33%
Total 101 100.00% 12 100.00%


void

nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid)
{
	stateid_t *src = &stid->sc_stateid;

	spin_lock(&stid->sc_lock);
	if (unlikely(++src->si_generation == 0))
		src->si_generation = 1;
	memcpy(dst, src, sizeof(*dst));
	spin_unlock(&stid->sc_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 70 100.00% 1 100.00%
Total 70 100.00% 1 100.00%



static void nfs4_put_deleg_lease(struct nfs4_file *fp)
{
	struct file *filp = NULL;

	spin_lock(&fp->fi_lock);
	if (fp->fi_deleg_file && --fp->fi_delegees == 0)
		swap(filp, fp->fi_deleg_file);
	spin_unlock(&fp->fi_lock);

	if (filp) {
		vfs_setlease(filp, F_UNLCK, NULL, (void **)&fp);
		fput(filp);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 47 55.95% 6 42.86%
J. Bruce Fields 17 20.24% 4 28.57%
Neil Brown 13 15.48% 3 21.43%
Christoph Hellwig 7 8.33% 1 7.14%
Total 84 100.00% 14 100.00%



void nfs4_unhash_stid(struct nfs4_stid *s)
{
	s->sc_type = 0;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 15 93.75% 2 66.67%
Christoph Hellwig 1 6.25% 1 33.33%
Total 16 100.00% 3 100.00%

/**
 * nfs4_get_existing_delegation - Discover if this delegation already exists
 * @clp:     a pointer to the nfs4_client we're granting a delegation to
 * @fp:      a pointer to the nfs4_file we're granting a delegation on
 *
 * Return:
 *      On success: NULL if an existing delegation was not found.
 *
 *      On error: -EAGAIN if one was previously granted to this nfs4_client
 *                 for this nfs4_file.
 *
 */


static int

nfs4_get_existing_delegation(struct nfs4_client *clp, struct nfs4_file *fp)
{
	struct nfs4_delegation *searchdp = NULL;
	struct nfs4_client *searchclp = NULL;

	lockdep_assert_held(&state_lock);
	lockdep_assert_held(&fp->fi_lock);

	list_for_each_entry(searchdp, &fp->fi_delegations, dl_perfile) {
		searchclp = searchdp->dl_stid.sc_client;
		if (clp == searchclp) {
			return -EAGAIN;
		}
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Andrew Elble 76 98.70% 1 50.00%
Neil Brown 1 1.30% 1 50.00%
Total 77 100.00% 2 100.00%

/**
 * hash_delegation_locked - Add a delegation to the appropriate lists
 * @dp:     a pointer to the nfs4_delegation we are adding.
 * @fp:     a pointer to the nfs4_file we're granting a delegation on
 *
 * Return:
 *      On success: NULL if the delegation was successfully hashed.
 *
 *      On error: -EAGAIN if one was previously granted to this
 *                 nfs4_client for this nfs4_file. Delegation is not hashed.
 *
 */


static int

hash_delegation_locked(struct nfs4_delegation *dp, struct nfs4_file *fp)
{
	int status;
	struct nfs4_client *clp = dp->dl_stid.sc_client;

	lockdep_assert_held(&state_lock);
	lockdep_assert_held(&fp->fi_lock);

	status = nfs4_get_existing_delegation(clp, fp);
	if (status)
		return status;
	++fp->fi_delegees;
	atomic_inc(&dp->dl_stid.sc_count);
	dp->dl_stid.sc_type = NFS4_DELEG_STID;
	list_add(&dp->dl_perfile, &fp->fi_delegations);
	list_add(&dp->dl_perclnt, &clp->cl_delegations);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Andrew Elble 41 36.61% 1 11.11%
Benny Halevy 39 34.82% 3 33.33%
Neil Brown 13 11.61% 2 22.22%
Trond Myklebust 10 8.93% 1 11.11%
Jeff Layton 8 7.14% 1 11.11%
J. Bruce Fields 1 0.89% 1 11.11%
Total 112 100.00% 9 100.00%


static bool

unhash_delegation_locked(struct nfs4_delegation *dp)
{
	struct nfs4_file *fp = dp->dl_stid.sc_file;

	lockdep_assert_held(&state_lock);

	if (list_empty(&dp->dl_perfile))
		return false;

	dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID;
	/* Ensure that deleg break won't try to requeue it */
	++dp->dl_time;
	spin_lock(&fp->fi_lock);
	list_del_init(&dp->dl_perclnt);
	list_del_init(&dp->dl_recall_lru);
	list_del_init(&dp->dl_perfile);
	spin_unlock(&fp->fi_lock);
	return true;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 54 55.10% 5 38.46%
Benny Halevy 16 16.33% 2 15.38%
Neil Brown 11 11.22% 2 15.38%
Trond Myklebust 11 11.22% 2 15.38%
J. Bruce Fields 6 6.12% 2 15.38%
Total 98 100.00% 13 100.00%



static void destroy_delegation(struct nfs4_delegation *dp)
{
	bool unhashed;

	spin_lock(&state_lock);
	unhashed = unhash_delegation_locked(dp);
	spin_unlock(&state_lock);
	if (unhashed) {
		put_clnt_odstate(dp->dl_clnt_odstate);
		nfs4_put_deleg_lease(dp->dl_stid.sc_file);
		nfs4_put_stid(&dp->dl_stid);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 33 52.38% 3 50.00%
J. Bruce Fields 19 30.16% 1 16.67%
Sachin Bhamare 7 11.11% 1 16.67%
Trond Myklebust 4 6.35% 1 16.67%
Total 63 100.00% 6 100.00%



static void revoke_delegation(struct nfs4_delegation *dp)
{
	struct nfs4_client *clp = dp->dl_stid.sc_client;

	WARN_ON(!list_empty(&dp->dl_recall_lru));

	put_clnt_odstate(dp->dl_clnt_odstate);
	nfs4_put_deleg_lease(dp->dl_stid.sc_file);

	if (clp->cl_minorversion == 0)
		nfs4_put_stid(&dp->dl_stid);
	else {
		dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID;
		spin_lock(&clp->cl_lock);
		list_add(&dp->dl_recall_lru, &clp->cl_revoked);
		spin_unlock(&clp->cl_lock);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 46 43.40% 2 25.00%
Jeff Layton 38 35.85% 2 25.00%
Neil Brown 11 10.38% 2 25.00%
Sachin Bhamare 7 6.60% 1 12.50%
Trond Myklebust 4 3.77% 1 12.50%
Total 106 100.00% 8 100.00%

/* 
 * SETCLIENTID state 
 */



static unsigned int clientid_hashval(u32 id)
{
	return id & CLIENT_HASH_MASK;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 11 73.33% 1 50.00%
Neil Brown 4 26.67% 1 50.00%
Total 15 100.00% 2 100.00%



static unsigned int clientstr_hashval(const char *name)
{
	return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 18 81.82% 1 50.00%
Neil Brown 4 18.18% 1 50.00%
Total 22 100.00% 2 100.00%

/*
 * We store the NONE, READ, WRITE, and BOTH bits separately in the
 * st_{access,deny}_bmap field of the stateid, in order to track not
 * only what share bits are currently in force, but also what
 * combinations of share bits previous opens have used.  This allows us
 * to enforce the recommendation of rfc 3530 14.2.19 that the server
 * return an error if the client attempt to downgrade to a combination
 * of share bits not explicable by closing some of its previous opens.
 *
 * XXX: This enforcement is actually incomplete, since we don't keep
 * track of access/deny bit combinations; so, e.g., we allow:
 *
 *      OPEN allow read, deny write
 *      OPEN allow both, deny none
 *      DOWNGRADE allow read, deny none
 *
 * which we should reject.
 */

static unsigned int

bmap_to_share_mode(unsigned long bmap) {
	int i;
	unsigned int access = 0;

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

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 43 82.69% 2 66.67%
Jeff Layton 9 17.31% 1 33.33%
Total 52 100.00% 3 100.00%

/* set share access for a given stateid */

static inline void

set_access(u32 access, struct nfs4_ol_stateid *stp)
{
	unsigned char mask = 1 << access;

	WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
	stp->st_access_bmap |= mask;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 27 75.00% 2 50.00%
J. Bruce Fields 9 25.00% 2 50.00%
Total 36 100.00% 4 100.00%

/* clear share access for a given stateid */

static inline void

clear_access(u32 access, struct nfs4_ol_stateid *stp)
{
	unsigned char mask = 1 << access;

	WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
	stp->st_access_bmap &= ~mask;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 23 62.16% 2 40.00%
J. Bruce Fields 14 37.84% 3 60.00%
Total 37 100.00% 5 100.00%

/* test whether a given stateid has access */

static inline bool

test_access(u32 access, struct nfs4_ol_stateid *stp)
{
	unsigned char mask = 1 << access;

	return (bool)(stp->st_access_bmap & mask);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 21 60.00% 2 28.57%
J. Bruce Fields 14 40.00% 5 71.43%
Total 35 100.00% 7 100.00%

/* set share deny for a given stateid */

static inline void

set_deny(u32 deny, struct nfs4_ol_stateid *stp)
{
	unsigned char mask = 1 << deny;

	WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
	stp->st_deny_bmap |= mask;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 27 75.00% 2 50.00%
J. Bruce Fields 9 25.00% 2 50.00%
Total 36 100.00% 4 100.00%

/* clear share deny for a given stateid */

static inline void

clear_deny(u32 deny, struct nfs4_ol_stateid *stp)
{
	unsigned char mask = 1 << deny;

	WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
	stp->st_deny_bmap &= ~mask;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 37 100.00% 2 100.00%
Total 37 100.00% 2 100.00%

/* test whether a given stateid is denying specific access */

static inline bool

test_deny(u32 deny, struct nfs4_ol_stateid *stp)
{
	unsigned char mask = 1 << deny;

	return (bool)(stp->st_deny_bmap & mask);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 35 100.00% 2 100.00%
Total 35 100.00% 2 100.00%



static int nfs4_access_to_omode(u32 access)
{
	switch (access & NFS4_SHARE_ACCESS_BOTH) {
	case NFS4_SHARE_ACCESS_READ:
		return O_RDONLY;
	case NFS4_SHARE_ACCESS_WRITE:
		return O_WRONLY;
	case NFS4_SHARE_ACCESS_BOTH:
		return O_RDWR;
	}
	WARN_ON_ONCE(1);
	return O_RDONLY;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 43 100.00% 3 100.00%
Total 43 100.00% 3 100.00%

/*
 * A stateid that had a deny mode associated with it is being released
 * or downgraded. Recalculate the deny mode on the file.
 */

static void

recalculate_deny_mode(struct nfs4_file *fp)
{
	struct nfs4_ol_stateid *stp;

	spin_lock(&fp->fi_lock);
	fp->fi_share_deny = 0;
	list_for_each_entry(stp, &fp->fi_stateids, st_perfile)
		fp->fi_share_deny |= bmap_to_share_mode(stp->st_deny_bmap);
	spin_unlock(&fp->fi_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 57 100.00% 1 100.00%
Total 57 100.00% 1 100.00%


static void

reset_union_bmap_deny(u32 deny, struct nfs4_ol_stateid *stp)
{
	int i;
	bool change = false;

	for (i = 1; i < 4; i++) {
		if ((i & deny) != i) {
			change = true;
			clear_deny(i, stp);
		}
	}

	/* Recalculate per-file deny mode if there was a change */
	if (change)
		recalculate_deny_mode(stp->st_stid.sc_file);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 71 95.95% 1 50.00%
Trond Myklebust 3 4.05% 1 50.00%
Total 74 100.00% 2 100.00%

/* release all access and file references for a given stateid */

static void

release_all_access(struct nfs4_ol_stateid *stp)
{
	int i;
	struct nfs4_file *fp = stp->st_stid.sc_file;

	if (fp && stp->st_deny_bmap != 0)
		recalculate_deny_mode(fp);

	for (i = 1; i < 4; i++) {
		if (test_access(i, stp))
			nfs4_file_put_access(stp->st_stid.sc_file, i);
		clear_access(i, stp);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 45 54.88% 7 70.00%
Jeff Layton 31 37.80% 2 20.00%
Trond Myklebust 6 7.32% 1 10.00%
Total 82 100.00% 10 100.00%



static inline void nfs4_free_stateowner(struct nfs4_stateowner *sop)
{
	kfree(sop->so_owner.data);
	sop->so_ops->so_free(sop);
}

Contributors
Person Tokens Prop Commits CommitProp
Kinglong Mee 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%



static void nfs4_put_stateowner(struct nfs4_stateowner *sop)
{
	struct nfs4_client *clp = sop->so_client;

	might_lock(&clp->cl_lock);

	if (!atomic_dec_and_lock(&sop->so_count, &clp->cl_lock))
		return;
	sop->so_ops->so_unhash(sop);
	spin_unlock(&clp->cl_lock);
	nfs4_free_stateowner(sop);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 66 98.51% 3 75.00%
Kinglong Mee 1 1.49% 1 25.00%
Total 67 100.00% 4 100.00%



static bool unhash_ol_stateid(struct nfs4_ol_stateid *stp)
{
	struct nfs4_file *fp = stp->st_stid.sc_file;

	lockdep_assert_held(&stp->st_stateowner->so_client->cl_lock);

	if (list_empty(&stp->st_perfile))
		return false;

	spin_lock(&fp->fi_lock);
	list_del_init(&stp->st_perfile);
	spin_unlock(&fp->fi_lock);
	list_del(&stp->st_perstateowner);
	return true;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 49 59.76% 4 50.00%
Trond Myklebust 27 32.93% 2 25.00%
J. Bruce Fields 5 6.10% 1 12.50%
Hirofumi Ogawa 1 1.22% 1 12.50%
Total 82 100.00% 8 100.00%



static void nfs4_free_ol_stateid(struct nfs4_stid *stid)
{
	struct nfs4_ol_stateid *stp = openlockstateid(stid);

	put_clnt_odstate(stp->st_clnt_odstate);
	release_all_access(stp);
	if (stp->st_stateowner)
		nfs4_put_stateowner(stp->st_stateowner);
	kmem_cache_free(stateid_slab, stid);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 25 47.17% 2 25.00%
Trond Myklebust 15 28.30% 1 12.50%
Sachin Bhamare 7 13.21% 1 12.50%
J. Bruce Fields 6 11.32% 4 50.00%
Total 53 100.00% 8 100.00%



static void nfs4_free_lock_stateid(struct nfs4_stid *stid)
{
	struct nfs4_ol_stateid *stp = openlockstateid(stid);
	struct nfs4_lockowner *lo = lockowner(stp->st_stateowner);
	struct file *file;

	file = find_any_file(stp->st_stid.sc_file);
	if (file)
		filp_close(file, (fl_owner_t)lo);
	nfs4_free_ol_stateid(stid);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 33 48.53% 3 42.86%
Jeff Layton 30 44.12% 1 14.29%
Trond Myklebust 5 7.35% 3 42.86%
Total 68 100.00% 7 100.00%

/*
 * Put the persistent reference to an already unhashed generic stateid, while
 * holding the cl_lock. If it's the last reference, then put it onto the
 * reaplist for later destruction.
 */


static void put_ol_stateid_locked(struct nfs4_ol_stateid *stp,
				       struct list_head *reaplist)
{
	struct nfs4_stid *s = &stp->st_stid;
	struct nfs4_client *clp = s->sc_client;

	lockdep_assert_held(&clp->cl_lock);

	WARN_ON_ONCE(!list_empty(&stp->st_locks));

	if (!atomic_dec_and_test(&s->sc_count)) {
		wake_up_all(&close_wq);
		return;
	}

	idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
	list_add(&stp->st_locks, reaplist);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 101 100.00% 1 100.00%
Total 101 100.00% 1 100.00%



static bool unhash_lock_stateid(struct nfs4_ol_stateid *stp)
{
	lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);

	list_del_init(&stp->st_locks);
	nfs4_unhash_stid(&stp->st_stid);
	return unhash_ol_stateid(stp);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 35 77.78% 4 44.44%
J. Bruce Fields 6 13.33% 3 33.33%
Chuck Lever 3 6.67% 1 11.11%
Christoph Hellwig 1 2.22% 1 11.11%
Total 45 100.00% 9 100.00%



static void release_lock_stateid(struct nfs4_ol_stateid *stp)
{
	struct nfs4_client *clp = stp->st_stid.sc_client;
	bool unhashed;

	spin_lock(&clp->cl_lock);
	unhashed = unhash_lock_stateid(stp);
	spin_unlock(&clp->cl_lock);
	if (unhashed)
		nfs4_put_stid(&stp->st_stid);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 44 73.33% 3 42.86%
Chuck Lever 7 11.67% 1 14.29%
J. Bruce Fields 5 8.33% 2 28.57%
Trond Myklebust 4 6.67% 1 14.29%
Total 60 100.00% 7 100.00%



static void unhash_lockowner_locked(struct nfs4_lockowner *lo)
{
	struct nfs4_client *clp = lo->lo_owner.so_client;

	lockdep_assert_held(&clp->cl_lock);

	list_del_init(&lo->lo_owner.so_strhash);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 20 50.00% 2 33.33%
J. Bruce Fields 18 45.00% 3 50.00%
Jeff Layton 2 5.00% 1 16.67%
Total 40 100.00% 6 100.00%

/*
 * Free a list of generic stateids that were collected earlier after being
 * fully unhashed.
 */

static void

free_ol_stateid_reaplist(struct list_head *reaplist)
{
	struct nfs4_ol_stateid *stp;
	struct nfs4_file *fp;

	might_sleep();

	while (!list_empty(reaplist)) {
		stp = list_first_entry(reaplist, struct nfs4_ol_stateid,
				       st_locks);
		list_del(&stp->st_locks);
		fp = stp->st_stid.sc_file;
		stp->st_stid.sc_free(&stp->st_stid);
		if (fp)
			put_nfs4_file(fp);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 61 73.49% 1 50.00%
Kinglong Mee 22 26.51% 1 50.00%
Total 83 100.00% 2 100.00%



static void release_open_stateid_locks(struct nfs4_ol_stateid *open_stp,
				       struct list_head *reaplist)
{
	struct nfs4_ol_stateid *stp;

	lockdep_assert_held(&open_stp->st_stid.sc_client->cl_lock);

	while (!list_empty(&open_stp->st_locks)) {
		stp = list_entry(open_stp->st_locks.next,
				struct nfs4_ol_stateid, st_locks);
		WARN_ON(!unhash_lock_stateid(stp));
		put_ol_stateid_locked(stp, reaplist);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 29 37.18% 3 50.00%
J. Bruce Fields 28 35.90% 2 33.33%
Trond Myklebust 21 26.92% 1 16.67%
Total 78 100.00% 6 100.00%



static bool unhash_open_stateid(struct nfs4_ol_stateid *stp,
				struct list_head *reaplist)
{
	bool unhashed;

	lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);

	unhashed = unhash_ol_stateid(stp);
	release_open_stateid_locks(stp, reaplist);
	return unhashed;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 29 60.42% 5 55.56%
J. Bruce Fields 18 37.50% 3 33.33%
Trond Myklebust 1 2.08% 1 11.11%
Total 48 100.00% 9 100.00%



static void release_open_stateid(struct nfs4_ol_stateid *stp)
{
	LIST_HEAD(reaplist);

	spin_lock(&stp->st_stid.sc_client->cl_lock);
	if (unhash_open_stateid(stp, &reaplist))
		put_ol_stateid_locked(stp, &reaplist);
	spin_unlock(&stp->st_stid.sc_client->cl_lock);
	free_ol_stateid_reaplist(&reaplist);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 42 65.62% 3 50.00%
J. Bruce Fields 19 29.69% 2 33.33%
Trond Myklebust 3 4.69% 1 16.67%
Total 64 100.00% 6 100.00%



static void unhash_openowner_locked(struct nfs4_openowner *oo)
{
	struct nfs4_client *clp = oo->oo_owner.so_client;

	lockdep_assert_held(&clp->cl_lock);

	list_del_init(&oo->oo_owner.so_strhash);
	list_del_init(&oo->oo_perclient);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 25 52.08% 2 33.33%
Trond Myklebust 20 41.67% 2 33.33%
Jeff Layton 2 4.17% 1 16.67%
Neil Brown 1 2.08% 1 16.67%
Total 48 100.00% 6 100.00%



static void release_last_closed_stateid(struct nfs4_openowner *oo)
{
	struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net,
					  nfsd_net_id);
	struct nfs4_ol_stateid *s;

	spin_lock(&nn->client_lock);
	s = oo->oo_last_closed_stid;
	if (s) {
		list_del_init(&oo->oo_close_lru);
		oo->oo_last_closed_stid = NULL;
	}
	spin_unlock(&nn->client_lock);
	if (s)
		nfs4_put_stid(&s->st_stid);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 54 61.36% 2 50.00%
J. Bruce Fields 32 36.36% 1 25.00%
Trond Myklebust 2 2.27% 1 25.00%
Total 88 100.00% 4 100.00%



static void release_openowner(struct nfs4_openowner *oo)
{
	struct nfs4_ol_stateid *stp;
	struct nfs4_client *clp = oo->oo_owner.so_client;
	struct list_head reaplist;

	INIT_LIST_HEAD(&reaplist);

	spin_lock(&clp->cl_lock);
	unhash_openowner_locked(oo);
	while (!list_empty(&oo->oo_owner.so_stateids)) {
		stp = list_first_entry(&oo->oo_owner.so_stateids,
				struct nfs4_ol_stateid, st_perstateowner);
		if (unhash_open_stateid(stp, &reaplist))
			put_ol_stateid_locked(stp, &reaplist);
	}
	spin_unlock(&clp->cl_lock);
	free_ol_stateid_reaplist(&reaplist);
	release_last_closed_stateid(oo);
	nfs4_put_stateowner(&oo->oo_owner);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 84 66.14% 5 45.45%
Trond Myklebust 33 25.98% 2 18.18%
J. Bruce Fields 10 7.87% 4 36.36%
Total 127 100.00% 11 100.00%


static inline int

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

	return sid->sequence % SESSION_HASH_SIZE;
}

Contributors
Person Tokens Prop Commits CommitProp
Marc Eshel 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

#ifdef CONFIG_SUNRPC_DEBUG

static inline void

dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
{
	u32 *ptr = (u32 *)(&sessionid->data[0]);
	dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
}
Contributors
Person Tokens Prop Commits CommitProp
Marc Eshel 60 96.77% 1 33.33%
Andy Adamson 1 1.61% 1 33.33%
J. Bruce Fields 1 1.61% 1 33.33%
Total 62 100.00% 3 100.00%

#else

static inline void

dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
{
}
Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%

#endif

/*
 * Bump the seqid on cstate->replay_owner, and clear replay_owner if it
 * won't be used for replay.
 */


void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
{
	struct nfs4_stateowner *so = cstate->replay_owner;

	if (nfserr == nfserr_replay_me)
		return;

	if (!seqid_mutating_err(ntohl(nfserr))) {
		nfsd4_cstate_clear_replay(cstate);
		return;
	}
	if (!so)
		return;
	if (so->so_is_open_owner)
		release_last_closed_stateid(openowner(so));
	so->so_seqid++;
	return;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 71 95.95% 1 50.00%
Jeff Layton 3 4.05% 1 50.00%
Total 74 100.00% 2 100.00%


static void

gen_sessionid(struct nfsd4_session *ses)
{
	struct nfs4_client *clp = ses->se_client;
	struct nfsd4_sessionid *sid;

	sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
	sid->clientid = clp->cl_clientid;
	sid->sequence = current_sessionid++;
	sid->reserved = 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 41 69.49% 2 66.67%
Marc Eshel 18 30.51% 1 33.33%
Total 59 100.00% 3 100.00%

/*
 * The protocol defines ca_maxresponssize_cached to include the size of
 * the rpc header, but all we need to cache is the data starting after
 * the end of the initial SEQUENCE operation--the rest we regenerate
 * each time.  Therefore we can advertise a ca_maxresponssize_cached
 * value that is the number of bytes in our cache plus a few additional
 * bytes.  In order to stay on the safe side, and not promise more than
 * we can cache, those additional bytes must be the minimum possible: 24
 * bytes of rpc header (xid through accept state, with AUTH_NULL
 * verifier), 12 for the compound header (with zero-length tag), and 44
 * for the SEQUENCE op response:
 */

#define NFSD_MIN_HDR_SEQ_SZ  (24 + 12 + 44)


static void

free_session_slots(struct nfsd4_session *ses)
{
	int i;

	for (i = 0; i < ses->se_fchannel.maxreqs; i++)
		kfree(ses->se_slots[i]);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%

/*
 * We don't actually need to cache the rpc and session headers, so we
 * can allocate a little less for each slot:
 */


static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
{
	u32 size;

	if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
		size = 0;
	else
		size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
	return size + sizeof(struct nfsd4_slot);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 29 64.44% 2 40.00%
Andy Adamson 10 22.22% 2 40.00%
Marc Eshel 6 13.33% 1 20.00%
Total 45 100.00% 5 100.00%

/*
 * XXX: If we run out of reserved DRC memory we could (up to a point)
 * re-negotiate active sessions and reduce their slot usage to make
 * room for new connections. For now we just fail the create session.
 */


static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca)
{
	u32 slotsize = slot_bytes(ca);
	u32 num = ca->maxreqs;
	int avail;

	spin_lock(&nfsd_drc_lock);
	avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION,
		    nfsd_drc_max_mem - nfsd_drc_mem_used);
	num = min_t(int, num, avail / slotsize);
	nfsd_drc_mem_used += num * slotsize;
	spin_unlock(&nfsd_drc_lock);

	return num;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 48 61.54% 2 25.00%
Andy Adamson 14 17.95% 4 50.00%
Marc Eshel 11 14.10% 1 12.50%
Zhang Yanfei 5 6.41% 1 12.50%
Total 78 100.00% 8 100.00%



static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
{
	int slotsize = slot_bytes(ca);

	spin_lock(&nfsd_drc_lock);
	nfsd_drc_mem_used -= slotsize * ca->maxreqs;
	spin_unlock(&nfsd_drc_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 37 94.87% 2 66.67%
Andy Adamson 2 5.13% 1 33.33%
Total 39 100.00% 3 100.00%



static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fattrs,
					   struct nfsd4_channel_attrs *battrs)
{
	int numslots = fattrs->maxreqs;
	int slotsize = slot_bytes(fattrs);
	struct nfsd4_session *new;
	int mem, i;

	BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
			+ sizeof(struct nfsd4_session) > PAGE_SIZE);
	mem = numslots * sizeof(struct nfsd4_slot *);

	new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
	if (!new)
		return NULL;
	/* allocate each struct nfsd4_slot and data cache in one piece */
	for (i = 0; i < numslots; i++) {
		new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL);
		if (!new->se_slots[i])
			goto out_free;
	}

	memcpy(&new->se_fchannel, fattrs, sizeof(struct nfsd4_channel_attrs));
	memcpy(&new->se_bchannel, battrs, sizeof(struct nfsd4_channel_attrs));

	return new;
out_free:
	while (i--)
		kfree(new->se_slots[i]);
	kfree(new);
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 132 66.00% 2 22.22%
Kinglong Mee 40 20.00% 1 11.11%
Andy Adamson 21 10.50% 4 44.44%
Neil Brown 7 3.50% 2 22.22%
Total 200 100.00% 9 100.00%



static void free_conn(struct nfsd4_conn *c)
{
	svc_xprt_put(c->cn_xprt);
	kfree(c);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%



static void nfsd4_conn_lost(struct svc_xpt_user *u)
{
	struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
	struct nfs4_client *clp = c->cn_session->se_client;

	spin_lock(&clp->cl_lock);
	if (!list_empty(&c->cn_persession)) {
		list_del(&c->cn_persession);
		free_conn(c);
	}
	nfsd4_probe_callback(clp);
	spin_unlock(&clp->cl_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 84 100.00% 3 100.00%
Total 84 100.00% 3 100.00%



static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
{
	struct nfsd4_conn *conn;

	conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
	if (!conn)
		return NULL;
	svc_xprt_get(rqstp->rq_xprt);
	conn->cn_xprt = rqstp->rq_xprt;
	conn->cn_flags = flags;
	INIT_LIST_HEAD(&conn->cn_xpt_user.list);
	return conn;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 76 100.00% 4 100.00%
Total 76 100.00% 4 100.00%



static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
{
	conn->cn_session = ses;
	list_add(&conn->cn_persession, &ses->se_conns);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%



static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
{
	struct nfs4_client *clp = ses->se_client;

	spin_lock(&clp->cl_lock);
	__nfsd4_hash_conn(conn, ses);
	spin_unlock(&clp->cl_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 48 100.00% 3 100.00%
Total 48 100.00% 3 100.00%



static int nfsd4_register_conn(struct nfsd4_conn *conn)
{
	conn->cn_xpt_user.callback = nfsd4_conn_lost;
	return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 32 100.00% 3 100.00%
Total 32 100.00% 3 100.00%



static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
{
	int ret;

	nfsd4_hash_conn(conn, ses);
	ret = nfsd4_register_conn(conn);
	if (ret)
		/* oops; xprt is already down: */
		nfsd4_conn_lost(&conn->cn_xpt_user);
	/* We may have gained or lost a callback channel: */
	nfsd4_probe_callback_sync(ses->se_client);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 45 76.27% 4 57.14%
Weston Andros Adamson 7 11.86% 1 14.29%
Andy Adamson 7 11.86% 2 28.57%
Total 59 100.00% 7 100.00%



static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
{
	u32 dir = NFS4_CDFC4_FORE;

	if (cses->flags & SESSION4_BACK_CHAN)
		dir |= NFS4_CDFC4_BACK;
	return alloc_conn(rqstp, dir);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 43 100.00% 2 100.00%
Total 43 100.00% 2 100.00%

/* must be called under client_lock */


static void nfsd4_del_conns(struct nfsd4_session *s)
{
	struct nfs4_client *clp = s->se_client;
	struct nfsd4_conn *c;

	spin_lock(&clp->cl_lock);
	while (!list_empty(&s->se_conns)) {
		c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
		list_del_init(&c->cn_persession);
		spin_unlock(&clp->cl_lock);

		unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
		free_conn(c);

		spin_lock(&clp->cl_lock);
	}
	spin_unlock(&clp->cl_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 88 80.00% 2 28.57%
Andy Adamson 14 12.73% 3 42.86%
Neil Brown 8 7.27% 2 28.57%
Total 110 100.00% 7 100.00%



static void __free_session(struct nfsd4_session *ses)
{
	free_session_slots(ses);
	kfree(ses);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%



static void free_session(struct nfsd4_session *ses)
{
	nfsd4_del_conns(ses);
	nfsd4_put_drc_mem(&ses->se_fchannel);
	__free_session(ses);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 13 44.83% 5 50.00%
Andy Adamson 9 31.03% 2 20.00%
Neil Brown 3 10.34% 1 10.00%
Stanislav Kinsbursky 2 6.90% 1 10.00%
Benny Halevy 2 6.90% 1 10.00%
Total 29 100.00% 10 100.00%



static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses)
{
	int idx;
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);

	new->se_client = clp;
	gen_sessionid(new);

	INIT_LIST_HEAD(&new->se_conns);

	new->se_cb_seq_nr = 1;
	new->se_flags = cses->flags;
	new->se_cb_prog = cses->callback_prog;
	new->se_cb_sec = cses->cb_sec;
	atomic_set(&new->se_ref, 0);
	idx = hash_sessionid(&new->se_sessionid);
	list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
	spin_lock(&clp->cl_lock);
	list_add(&new->se_perclnt, &clp->cl_sessions);
	spin_unlock(&clp->cl_lock);

	{
		struct sockaddr *sa = svc_addr(rqstp);
		/*
                 * This is a little silly; with sessions there's no real
                 * use for the callback address.  Use the peer address
                 * as a reasonable default for now, but consider fixing
                 * the rpc client not to require an address in the
                 * future:
                 */
		rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
		clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 124 62.31% 13 61.90%
Andy Adamson 41 20.60% 2 9.52%
Stanislav Kinsbursky 17 8.54% 1 4.76%
Neil Brown 12 6.03% 2 9.52%
Olga Kornievskaia 2 1.01% 1 4.76%
Andrew Morton 2 1.01% 1 4.76%
Fengguang Wu 1 0.50% 1 4.76%
Total 199 100.00% 21 100.00%

/* caller must hold client_lock */

static struct nfsd4_session *

__find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
{
	struct nfsd4_session *elem;
	int idx;
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);

	lockdep_assert_held(&nn->client_lock);

	dump_sessionid(__func__, sessionid);
	idx = hash_sessionid(sessionid);
	/* Search in the appropriate list */
	list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
		if (!memcmp(elem->se_sessionid.data, sessionid->data,
			    NFS4_MAX_SESSIONID_LEN)) {
			return elem;
		}
	}

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

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 49 47.12% 1 9.09%
Neil Brown 19 18.27% 5 45.45%
Stanislav Kinsbursky 18 17.31% 1 9.09%
Trond Myklebust 9 8.65% 2 18.18%
Benny Halevy 6 5.77% 1 9.09%
J. Bruce Fields 3 2.88% 1 9.09%
Total 104 100.00% 11 100.00%


static struct nfsd4_session *

find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net,
		__be32 *ret)
{
	struct nfsd4_session *session;
	__be32 status = nfserr_badsession;

	session = __find_in_sessionid_hashtbl(sessionid, net);
	if (!session)
		goto out;
	status = nfsd4_get_session_locked(session);
	if (status)
		session = NULL;
out:
	*ret = status;
	return session;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 74 100.00% 1 100.00%
Total 74 100.00% 1 100.00%

/* caller must hold client_lock */

static void

unhash_session(struct nfsd4_session *ses)
{
	struct nfs4_client *clp = ses->se_client;
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	lockdep_assert_held(&nn->client_lock);

	list_del(&ses->se_hash);
	spin_lock(&ses->se_client->cl_lock);
	list_del(&ses->se_perclnt);
	spin_unlock(&ses->se_client->cl_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 31 39.74% 1 25.00%
J. Bruce Fields 21 26.92% 1 25.00%
Benny Halevy 21 26.92% 1 25.00%
Stanislav Kinsbursky 5 6.41% 1 25.00%
Total 78 100.00% 4 100.00%

/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */

static int

STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
{
	/*
         * We're assuming the clid was not given out from a boot
         * precisely 2^32 (about 136 years) before this one.  That seems
         * a safe assumption:
         */
	if (clid->cl_boot == (u32)nn->boot_time)
		return 0;
	dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
		clid->cl_boot, clid->cl_id, nn->boot_time);
	return 1;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 39 75.00% 2 50.00%
Stanislav Kinsbursky 9 17.31% 1 25.00%
J. Bruce Fields 4 7.69% 1 25.00%
Total 52 100.00% 4 100.00%

/* 
 * XXX Should we use a slab cache ?
 * This type of memory management is somewhat inefficient, but we use it
 * anyway since SETCLIENTID is not a common operation.
 */


static struct nfs4_client *alloc_client(struct xdr_netobj name)
{
	struct nfs4_client *clp;
	int i;

	clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
	if (clp == NULL)
		return NULL;
	clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
	if (clp->cl_name.data == NULL)
		goto err_no_name;
	clp->cl_ownerstr_hashtbl = kmalloc(sizeof(struct list_head) *
			OWNER_HASH_SIZE, GFP_KERNEL);
	if (!clp->cl_ownerstr_hashtbl)
		goto err_no_hashtbl;
	for (i = 0; i < OWNER_HASH_SIZE; i++)
		INIT_LIST_HEAD(&clp->cl_ownerstr_hashtbl[i]);
	clp->cl_name.len = name.len;
	INIT_LIST_HEAD(&clp->cl_sessions);
	idr_init(&clp->cl_stateids);
	atomic_set(&clp->cl_refcount, 0);
	clp->cl_cb_state = NFSD4_CB_UNKNOWN;
	INIT_LIST_HEAD(&clp->cl_idhash);
	INIT_LIST_HEAD(&clp->cl_openowners);
	INIT_LIST_HEAD(&clp->cl_delegations);
	INIT_LIST_HEAD(&clp->cl_lru);
	INIT_LIST_HEAD(&clp->cl_revoked);
#ifdef CONFIG_NFSD_PNFS
	INIT_LIST_HEAD(&clp->cl_lo_states);
#endif
	spin_lock_init(&clp->cl_lock);
	rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
	return clp;
err_no_hashtbl:
	kfree(clp->cl_name.data);
err_no_name:
	kfree(clp);
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 164 62.60% 2 20.00%
Neil Brown 39 14.89% 4 40.00%
Andy Adamson 32 12.21% 1 10.00%
Christoph Hellwig 13 4.96% 1 10.00%
J. Bruce Fields 9 3.44% 1 10.00%
Thomas Meyer 5 1.91% 1 10.00%
Total 262 100.00% 10 100.00%


static void

free_client(struct nfs4_client *clp)
{
	while (!list_empty(&clp->cl_sessions)) {
		struct nfsd4_session *ses;
		ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
				se_perclnt);
		list_del(&ses->se_perclnt);
		WARN_ON_ONCE(atomic_read(&ses->se_ref));
		free_session(ses);
	}
	rpc_destroy_wait_queue(&clp->cl_cb_waitq);
	free_svc_cred(&clp->cl_cred);
	kfree(clp->cl_ownerstr_hashtbl);
	kfree(clp->cl_name.data);
	idr_destroy(&clp->cl_stateids);
	kfree(clp);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 55 48.25% 3 33.33%
Andy Adamson 18 15.79% 1 11.11%
Neil Brown 18 15.79% 2 22.22%
Trond Myklebust 15 13.16% 2 22.22%
Jianpeng Ma (马建朋) 8 7.02% 1 11.11%
Total 114 100.00% 9 100.00%

/* must be called under the client_lock */

static void

unhash_client_locked(struct nfs4_client *clp)
{
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
	struct nfsd4_session *ses;

	lockdep_assert_held(&nn->client_lock);

	/* Mark the client as expired! */
	clp->cl_time = 0;
	/* Make it invisible */
	if (!list_empty(&clp->cl_idhash)) {
		list_del_init(&clp->cl_idhash);
		if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
			rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
		else
			rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
	}
	list_del_init(&clp->cl_lru);
	spin_lock(&clp->cl_lock);
	list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
		list_del_init(&ses->se_hash);
	spin_unlock(&clp->cl_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 91 62.33% 2 40.00%
J. Bruce Fields 29 19.86% 2 40.00%
Benny Halevy 26 17.81% 1 20.00%
Total 146 100.00% 5 100.00%


static void

unhash_client(struct nfs4_client *clp)
{
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	spin_lock(&nn->client_lock);
	unhash_client_locked(clp);
	spin_unlock(&nn->client_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 44 95.65% 1 33.33%
Neil Brown 1 2.17% 1 33.33%
Andy Adamson 1 2.17% 1 33.33%
Total 46 100.00% 3 100.00%



static __be32 mark_client_expired_locked(struct nfs4_client *clp)
{
	if (atomic_read(&clp->cl_refcount))
		return nfserr_jukebox;
	unhash_client_locked(clp);
	return nfs_ok;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 32 100.00% 1 100.00%
Total 32 100.00% 1 100.00%


static void

__destroy_client(struct nfs4_client *clp)
{
	struct nfs4_openowner *oo;
	struct nfs4_delegation *dp;
	struct list_head reaplist;

	INIT_LIST_HEAD(&reaplist);
	spin_lock(&state_lock);
	while (!list_empty(&clp->cl_delegations)) {
		dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
		WARN_ON(!unhash_delegation_locked(dp));
		list_add(&dp->dl_recall_lru, &reaplist);
	}
	spin_unlock(&state_lock);
	while (!list_empty(&reaplist)) {
		dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
		list_del_init(&dp->dl_recall_lru);
		put_clnt_odstate(dp->dl_clnt_odstate);
		nfs4_put_deleg_lease(dp->dl_stid.sc_file);
		nfs4_put_stid(&dp->dl_stid);
	}
	while (!list_empty(&clp->cl_revoked)) {
		dp = list_entry(clp->cl_revoked.next, struct nfs4_delegation, dl_recall_lru);
		list_del_init(&dp->dl_recall_lru);
		nfs4_put_stid(&dp->dl_stid);
	}
	while (!list_empty(&clp->cl_openowners)) {
		oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
		nfs4_get_stateowner(&oo->oo_owner);
		release_openowner(oo);
	}
	nfsd4_return_all_client_layouts(clp);
	nfsd4_shutdown_callback(clp);
	if (clp->cl_cb_conn.cb_xprt)
		svc_xprt_put(clp->cl_cb_conn.cb_xprt);
	free_client(clp);
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 139 51.87% 1 4.55%
Benny Halevy 47 17.54% 5 22.73%
Jeff Layton 41 15.30% 5 22.73%
Trond Myklebust 13 4.85% 3 13.64%
J. Bruce Fields 8 2.99% 3 13.64%
Sachin Bhamare 7 2.61% 1 4.55%
Christoph Hellwig 5 1.87% 1 4.55%
Neil Brown 4 1.49% 1 4.55%
Andrew Elble 3 1.12% 1 4.55%
Kinglong Mee 1 0.37% 1 4.55%
Total 268 100.00% 22 100.00%


static void

destroy_client(struct nfs4_client *clp)
{
	unhash_client(clp);
	__destroy_client(clp);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%



static void expire_client(struct nfs4_client *clp)
{
	unhash_client(clp);
	nfsd4_client_record_remove(clp);
	__destroy_client(clp);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 20 76.92% 1 50.00%
Trond Myklebust 6 23.08% 1 50.00%
Total 26 100.00% 2 100.00%



static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
{
	memcpy(target->cl_verifier.data, source->data,
			sizeof(target->cl_verifier.data));
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 37 100.00% 1 100.00%
Total 37 100.00% 1 100.00%



static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
{
	target->cl_clientid.cl_boot = source->cl_clientid.cl_boot; 
	target->cl_clientid.cl_id = source->cl_clientid.cl_id; 
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 40 100.00% 1 100.00%
Total 40 100.00% 1 100.00%



int strdup_if_nonnull(char **target, char *source)
{
	if (source) {
		*target = kstrdup(source, GFP_KERNEL);
		if (!*target)
			return -ENOMEM;
	} else
		*target = NULL;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 41 83.67% 2 66.67%
Andy Adamson 8 16.33% 1 33.33%
Total 49 100.00% 3 100.00%



static int copy_cred(struct svc_cred *target, struct svc_cred *source)
{
	int ret;

	ret = strdup_if_nonnull(&target->cr_principal, source->cr_principal);
	if (ret)
		return ret;
	ret = strdup_if_nonnull(&target->cr_raw_principal,
					source->cr_raw_principal);
	if (ret)
		return ret;
	target->cr_flavor = source->cr_flavor;
	target->cr_uid = source->cr_uid;
	target->cr_gid = source->cr_gid;
	target->cr_group_info = source->cr_group_info;
	get_group_info(target->cr_group_info);
	target->cr_gss_mech = source->cr_gss_mech;
	if (source->cr_gss_mech)
		gss_mech_get(source->cr_gss_mech);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 90 72.58% 5 83.33%
Andy Adamson 34 27.42% 1 16.67%
Total 124 100.00% 6 100.00%


static int

compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
{
	if (o1->len < o2->len)
		return -1;
	if (o1->len > o2->len)
		return 1;
	return memcmp(o1->data, o2->data, o1->len);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 44 72.13% 1 50.00%
Rasmus Villemoes 17 27.87% 1 50.00%
Total 61 100.00% 2 100.00%



static int same_name(const char *n1, const char *n2)
{
	return 0 == memcmp(n1, n2, HEXDIR_LEN);
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%


static int

same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
{
	return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%


static int

same_clid(clientid_t *cl1, clientid_t *cl2)
{
	return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%



static bool groups_equal(struct group_info *g1, struct group_info *g2)
{
	int i;

	if (g1->ngroups != g2->ngroups)
		return false;
	for (i=0; i<g1->ngroups; i++)
		if (!gid_eq(g1->gid[i], g2->gid[i]))
			return false;
	return true;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 60 82.19% 1 33.33%
Alexey Dobriyan 8 10.96% 1 33.33%
Eric W. Biedermann 5 6.85% 1 33.33%
Total 73 100.00% 3 100.00%

/*
 * RFC 3530 language requires clid_inuse be returned when the
 * "principal" associated with a requests differs from that previously
 * used.  We use uid, gid's, and gss principal string as our best
 * approximation.  We also don't want to allow non-gss use of a client
 * established using gss: in theory cr_principal should catch that
 * change, but in practice cr_principal can be null even in the gss case
 * since gssd doesn't always pass down a principal string.
 */


static bool is_gss_cred(struct svc_cred *cr)
{
	/* Is cr_flavor one of the gss "pseudoflavors"?: */
	return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
}


Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%


static bool

same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
{
	if ((is_gss_cred(cr1) != is_gss_cred(cr2))
		|| (!uid_eq(cr1->cr_uid, cr2->cr_uid))
		|| (!gid_eq(cr1->cr_gid, cr2->cr_gid))
		|| !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
		return false;
	if (cr1->cr_principal == cr2->cr_principal)
		return true;
	if (!cr1->cr_principal || !cr2->cr_principal)
		return false;
	return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 80 69.57% 3 50.00%
Andy Adamson 23 20.00% 1 16.67%
Eric W. Biedermann 10 8.70% 1 16.67%
Vivek Trivedi 2 1.74% 1 16.67%
Total 115 100.00% 6 100.00%



static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp)
{
	struct svc_cred *cr = &rqstp->rq_cred;
	u32 service;

	if (!cr->cr_gss_mech)
		return false;
	service = gss_pseudoflavor_to_service(cr->cr_gss_mech, cr->cr_flavor);
	return service == RPC_GSS_SVC_INTEGRITY ||
	       service == RPC_GSS_SVC_PRIVACY;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 56 100.00% 2 100.00%
Total 56 100.00% 2 100.00%



bool nfsd4_mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp)
{
	struct svc_cred *cr = &rqstp->rq_cred;

	if (!cl->cl_mach_cred)
		return true;
	if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech)
		return false;
	if (!svc_rqst_integrity_protected(rqstp))
		return false;
	if (cl->cl_cred.cr_raw_principal)
		return 0 == strcmp(cl->cl_cred.cr_raw_principal,
						cr->cr_raw_principal);
	if (!cr->cr_principal)
		return false;
	return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 110 99.10% 2 66.67%
Andrew Elble 1 0.90% 1 33.33%
Total 111 100.00% 3 100.00%



static void gen_confirm(struct nfs4_client *clp, struct nfsd_net *nn)
{
	__be32 verf[2];

	/*
         * This is opaque to client, so no need to byte-swap. Use
         * __force to keep sparse happy
         */
	verf[0] = (__force __be32)get_seconds();
	verf[1] = (__force __be32)nn->clverifier_counter++;
	memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
}

Contributors
Person Tokens Prop Commits CommitProp
Chuck Lever 38 55.07% 1 16.67%
Andy Adamson 18 26.09% 1 16.67%
Jeff Layton 6 8.70% 2 33.33%
Stanislav Kinsbursky 5 7.25% 1 16.67%
Kinglong Mee 2 2.90% 1 16.67%
Total 69 100.00% 6 100.00%



static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
{
	clp->cl_clientid.cl_boot = nn->boot_time;
	clp->cl_clientid.cl_id = nn->clientid_counter++;
	gen_confirm(clp, nn);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 44 100.00% 1 100.00%
Total 44 100.00% 1 100.00%


static struct nfs4_stid *

find_stateid_locked(struct nfs4_client *cl, stateid_t *t)
{
	struct nfs4_stid *ret;

	ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
	if (!ret || !ret->sc_type)
		return NULL;
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 53 98.15% 6 85.71%
Jeff Layton 1 1.85% 1 14.29%
Total 54 100.00% 7 100.00%


static struct nfs4_stid *

find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
{
	struct nfs4_stid *s;

	spin_lock(&cl->cl_lock);
	s = find_stateid_locked(cl, t);
	if (s != NULL) {
		if (typemask & s->sc_type)
			atomic_inc(&s->sc_count);
		else
			s = NULL;
	}
	spin_unlock(&cl->cl_lock);
	return s;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 46 56.10% 6 75.00%
Jeff Layton 22 26.83% 1 12.50%
Trond Myklebust 14 17.07% 1 12.50%
Total 82 100.00% 8 100.00%



static struct nfs4_client *create_client(struct xdr_netobj name,
		struct svc_rqst *rqstp, nfs4_verifier *verf)
{
	struct nfs4_client *clp;
	struct sockaddr *sa = svc_addr(rqstp);
	int ret;
	struct net *net = SVC_NET(rqstp);

	clp = alloc_client(name);
	if (clp == NULL)
		return NULL;

	ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
	if (ret) {
		free_client(clp);
		return NULL;
	}
	nfsd4_init_cb(&clp->cl_cb_null, clp, NULL, NFSPROC4_CLNT_CB_NULL);
	clp->cl_time = get_seconds();
	clear_bit(0, &clp->cl_cb_slot_busy);
	copy_verf(clp, verf);
	rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
	clp->cl_cb_session = NULL;
	clp->net = net;
	return clp;
}

Contributors
Person Tokens Prop Commits CommitProp
Ricardo Labiaga 83 51.23% 1 11.11%
Andy Adamson 27 16.67% 1 11.11%
J. Bruce Fields 17 10.49% 2 22.22%
Stanislav Kinsbursky 16 9.88% 1 11.11%
Christoph Hellwig 11 6.79% 2 22.22%
Benny Halevy 7 4.32% 1 11.11%
Jeff Layton 1 0.62% 1 11.11%
Total 162 100.00% 9 100.00%


static void

add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
{
	struct rb_node **new = &(root->rb_node), *parent = NULL;
	struct nfs4_client *clp;

	while (*new) {
		clp = rb_entry(*new, struct nfs4_client, cl_namenode);
		parent = *new;

		if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
			new = &((*new)->rb_left);
		else
			new = &((*new)->rb_right);
	}

	rb_link_node(&new_clp->cl_namenode, parent, new);
	rb_insert_color(&new_clp->cl_namenode, root);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 126 98.44% 1 50.00%
Andy Adamson 2 1.56% 1 50.00%
Total 128 100.00% 2 100.00%


static struct nfs4_client *

find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
{
	int cmp;
	struct rb_node *node = root->rb_node;
	struct nfs4_client *clp;

	while (node) {
		clp = rb_entry(node, struct nfs4_client, cl_namenode);
		cmp = compare_blob(&clp->cl_name, name);
		if (cmp > 0)
			node = node->rb_left;
		else if (cmp < 0)
			node = node->rb_right;
		else
			return clp;
	}
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 96 98.97% 1 50.00%
Rasmus Villemoes 1 1.03% 1 50.00%
Total 97 100.00% 2 100.00%


static void

add_to_unconfirmed(struct nfs4_client *clp)
{
	unsigned int idhashval;
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	lockdep_assert_held(&nn->client_lock);

	clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
	add_clp_to_name_tree(clp, &nn->unconf_name_tree);
	idhashval = clientid_hashval(clp->cl_clientid.cl_id);
	list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
	renew_client_locked(clp);
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 50 56.18% 1 16.67%
Stanislav Kinsbursky 18 20.22% 2 33.33%
Jeff Layton 12 13.48% 1 16.67%
Trond Myklebust 9 10.11% 2 33.33%
Total 89 100.00% 6 100.00%


static void

move_to_confirmed(struct nfs4_client *clp)
{
	unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

	lockdep_assert_held(&nn->client_lock);

	dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
	list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
	rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
	add_clp_to_name_tree(clp, &nn->conf_name_tree);
	set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
	renew_client_locked(clp);
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 60 56.07% 1 14.29%
Stanislav Kinsbursky 20 18.69% 3 42.86%
Jeff Layton 18 16.82% 1 14.29%
Trond Myklebust 9 8.41% 2 28.57%
Total 107 100.00% 7 100.00%


static struct nfs4_client *

find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
{
	struct nfs4_client *clp;
	unsigned int idhashval = clientid_hashval(clid->cl_id);

	list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
		if (same_clid(&clp->cl_clientid, clid)) {
			if ((bool)clp->cl_minorversion != sessions)
				return NULL;
			renew_client_locked(clp);
			return clp;
		}
	}
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 54 63.53% 1 20.00%
J. Bruce Fields 30 35.29% 3 60.00%
Trond Myklebust 1 1.18% 1 20.00%
Total 85 100.00% 5 100.00%


static struct nfs4_client *

find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
{
	struct list_head *tbl = nn->conf_id_hashtbl;

	lockdep_assert_held(&nn->client_lock);
	return find_client_in_id_table(tbl, clid, sessions);
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 19 40.43% 1 20.00%
J. Bruce Fields 15 31.91% 2 40.00%
Trond Myklebust 8 17.02% 1 20.00%
Stanislav Kinsbursky 5 10.64% 1 20.00%
Total 47 100.00% 5 100.00%


static struct nfs4_client *

find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
{
	struct list_head *tbl = nn->unconf_id_hashtbl;

	lockdep_assert_held(&nn->client_lock);
	return find_client_in_id_table(tbl, clid, sessions);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 33 70.21% 2 50.00%
Trond Myklebust 8 17.02% 1 25.00%
Andy Adamson 6 12.77% 1 25.00%
Total 47 100.00% 4 100.00%



static bool clp_used_exchangeid(struct nfs4_client *clp)
{
	return clp->cl_exchange_flags != 0;
} 

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 15 83.33% 1 50.00%
J. Bruce Fields 3 16.67% 1 50.00%
Total 18 100.00% 2 100.00%


static struct nfs4_client *

find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
{
	lockdep_assert_held(&nn->client_lock);
	return find_clp_in_name_tree(name, &nn->conf_name_tree);
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 11 29.73% 1 20.00%
Jeff Layton 9 24.32% 1 20.00%
Trond Myklebust 8 21.62% 1 20.00%
Stanislav Kinsbursky 7 18.92% 1 20.00%
Neil Brown 2 5.41% 1 20.00%
Total 37 100.00% 5 100.00%


static struct nfs4_client *

find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
{
	lockdep_assert_held(&nn->client_lock);
	return find_clp_in_name_tree(name, &nn->unconf_name_tree);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 9 24.32% 1 20.00%
Trond Myklebust 8 21.62% 1 20.00%
Andy Adamson 7 18.92% 1 20.00%
Stanislav Kinsbursky 7 18.92% 1 20.00%
Neil Brown 6 16.22% 1 20.00%
Total 37 100.00% 5 100.00%


static void

gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
{
	struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
	struct sockaddr	*sa = svc_addr(rqstp);
	u32 scopeid = rpc_get_scope_id(sa);
	unsigned short expected_family;

	/* Currently, we only support tcp and tcp6 for the callback channel */
	if (se->se_callback_netid_len == 3 &&
	    !memcmp(se->se_callback_netid_val, "tcp", 3))
		expected_family = AF_INET;
	else if (se->se_callback_netid_len == 4 &&
		 !memcmp(se->se_callback_netid_val, "tcp6", 4))
		expected_family = AF_INET6;
	else
		goto out_err;

	conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
					    se->se_callback_addr_len,
					    (struct sockaddr *)&conn->cb_addr,
					    sizeof(conn->cb_addr));

	if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
		goto out_err;

	if (conn->cb_addr.ss_family == AF_INET6)
		((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;

	conn->cb_prog = se->se_callback_prog;
	conn->cb_ident = se->se_callback_ident;
	memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
	return;
out_err:
	conn->cb_addr.ss_family = AF_UNSPEC;
	conn->cb_addrlen = 0;
	dprintk("NFSD: this client (clientid %08x/%08x) "
		"will not receive delegations\n",
		clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);

	return;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 94 36.72% 3 20.00%
Jeff Layton 78 30.47% 3 20.00%
Takuma Umeya 34 13.28% 1 6.67%
Neil Brown 27 10.55% 3 20.00%
J. Bruce Fields 14 5.47% 2 13.33%
Mi Jinlong 5 1.95% 1 6.67%
Stanislav Kinsbursky 4 1.56% 2 13.33%
Total 256 100.00% 15 100.00%

/*
 * Cache a reply. nfsd4_check_resp_size() has bounded the cache size.
 */

static void

nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
{
	struct xdr_buf *buf = resp->xdr.buf;
	struct nfsd4_slot *slot = resp->cstate.slot;
	unsigned int base;

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

	slot->sl_opcnt = resp->opcnt;
	slot->sl_status = resp->cstate.status;

	slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
	if (nfsd4_not_cached(resp)) {
		slot->sl_datalen = 0;
		return;
	}
	base = resp->cstate.data_offset;
	slot->sl_datalen = buf->len - base;
	if (read_bytes_from_xdr_buf(buf, base, slot->sl_data, slot->sl_datalen))
		WARN(1, "%s: sessions DRC could not cache compound\n",
		     __func__);
	return;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 86 65.65% 3 33.33%
J. Bruce Fields 27 20.61% 3 33.33%
Neil Brown 15 11.45% 1 11.11%
Dan Carpenter 2 1.53% 1 11.11%
Trond Myklebust 1 0.76% 1 11.11%
Total 131 100.00% 9 100.00%

/*
 * Encode the replay sequence operation from the slot values.
 * If cachethis is FALSE encode the uncached rep error on the next
 * operation which sets resp->p and increments resp->opcnt for
 * nfs4svc_encode_compoundres.
 *
 */

static __be32

nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
			  struct nfsd4_compoundres *resp)
{
	struct nfsd4_op *op;
	struct nfsd4_slot *slot = resp->cstate.slot;

	/* Encode the replayed sequence operation */
	op = &args->ops[resp->opcnt - 1];
	nfsd4_encode_operation(resp, op);

	/* Return nfserr_retry_uncached_rep in next operation. */
	if (args->opcnt > 1 && !(slot->sl_flags & NFSD4_SLOT_CACHETHIS)) {
		op = &args->ops[resp->opcnt++];
		op->status = nfserr_retry_uncached_rep;
		nfsd4_encode_operation(resp, op);
	}
	return op->status;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 83 79.05% 2 40.00%
Neil Brown 16 15.24% 2 40.00%
J. Bruce Fields 6 5.71% 1 20.00%
Total 105 100.00% 5 100.00%

/*
 * The sequence operation is not cached because we can use the slot and
 * session values.
 */

static __be32

nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
			 struct nfsd4_sequence *seq)
{
	struct nfsd4_slot *slot = resp->cstate.slot;
	struct xdr_stream *xdr = &resp->xdr;
	__be32 *p;
	__be32 status;

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

	status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
	if (status)
		return status;

	p = xdr_reserve_space(xdr, slot->sl_datalen);
	if (!p) {
		WARN_ON_ONCE(1);
		return nfserr_serverfault;
	}
	xdr_encode_opaque_fixed(p, slot->sl_data, slot->sl_datalen);
	xdr_commit_encode(xdr);

	resp->opcnt = slot->sl_opcnt;
	return slot->sl_status;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 57 43.85% 5 50.00%
J. Bruce Fields 53 40.77% 3 30.00%
Neil Brown 20 15.38% 2 20.00%
Total 130 100.00% 10 100.00%

/*
 * Set the exchange_id flags returned by the server.
 */

static void

nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
{
#ifdef CONFIG_NFSD_PNFS
	new->cl_exchange_flags |= EXCHGID4_FLAG_USE_PNFS_MDS;
#else
	new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
#endif

	/* Referrals are supported, Migration is not. */
	new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;

	/* set the wire flags to return to client. */
	clid->flags = new->cl_exchange_flags;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 38 74.51% 2 66.67%
Christoph Hellwig 13 25.49% 1 33.33%
Total 51 100.00% 3 100.00%



static bool client_has_openowners(struct nfs4_client *clp)
{
	struct nfs4_openowner *oo;

	list_for_each_entry(oo, &clp->cl_openowners, oo_perclient) {
		if (!list_empty(&oo->oo_owner.so_stateids))
			return true;
	}
	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 42 93.33% 3 75.00%
Andy Adamson 3 6.67% 1 25.00%
Total 45 100.00% 4 100.00%



static bool client_has_state(struct nfs4_client *clp)
{
	return client_has_openowners(clp)
#ifdef CONFIG_NFSD_PNFS
		|| !list_empty(&clp->cl_lo_states)
#endif
		|| !list_empty(&clp->cl_delegations)
		|| !list_empty(&clp->cl_sessions);
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 35 71.43% 3 75.00%
Kinglong Mee 14 28.57% 1 25.00%
Total 49 100.00% 4 100.00%


__be32

nfsd4_exchange_id(struct svc_rqst *rqstp,
		  struct nfsd4_compound_state *cstate,
		  struct nfsd4_exchange_id *exid)
{
	struct nfs4_client *conf, *new;
	struct nfs4_client *unconf = NULL;
	__be32 status;
	char			addr_str[INET6_ADDRSTRLEN];
	nfs4_verifier		verf = exid->verifier;
	struct sockaddr		*sa = svc_addr(rqstp);
	bool	update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
	struct nfsd_net		*nn = net_generic(SVC_NET(rqstp), nfsd_net_id);

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

	if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
		return nfserr_inval;

	new = create_client(exid->clname, rqstp, &verf);
	if (new == NULL)
		return nfserr_jukebox;

	switch (exid->spa_how) {
	case SP4_MACH_CRED:
		exid->spo_must_enforce[0] = 0;
		exid->spo_must_enforce[1] = (
			1 << (OP_BIND_CONN_TO_SESSION - 32) |
			1 << (OP_EXCHANGE_ID - 32) |
			1 << (OP_CREATE_SESSION - 32) |
			1 << (OP_DESTROY_SESSION - 32) |
			1 << (OP_DESTROY_CLIENTID - 32));

		exid->spo_must_allow[0] &= (1 << (OP_CLOSE) |
					1 << (OP_OPEN_DOWNGRADE) |
					1 << (OP_LOCKU) |
					1 << (OP_DELEGRETURN));

		exid->spo_must_allow[1] &= (
					1 << (OP_TEST_STATEID - 32) |
					1 << (OP_FREE_STATEID - 32));
		if (!svc_rqst_integrity_protected(rqstp)) {
			status = nfserr_inval;
			goto out_nolock;
		}
		/*
                 * Sometimes userspace doesn't give us a principal.
                 * Which is a bug, really.  Anyway, we can't enforce
                 * MACH_CRED in that case, better to give up now:
                 */
		if (!new->cl_cred.cr_principal &&
					!new->cl_cred.cr_raw_principal) {
			status = nfserr_serverfault;
			goto out_nolock;
		}
		new->cl_mach_cred = true;
	case SP4_NONE:
		break;
	default:				/* checked by xdr code */
		WARN_ON_ONCE(1);
	case SP4_SSV:
		status = nfserr_encr_alg_unsupp;
		goto out_nolock;
	}

	/* Cases below refer to rfc 5661 section 18.35.4: */
	spin_lock(&nn->client_lock);
	conf = find_confirmed_client_by_name(&exid->clname, nn);
	if (conf) {
		bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
		bool verfs_match = same_verf(&verf, &conf->cl_verifier);

		if (update) {
			if (!clp_used_exchangeid(conf)) { /* buggy client */
				status = nfserr_inval;
				goto out;
			}
			if (!nfsd4_mach_creds_match(conf, rqstp)) {
				status = nfserr_wrong_cred;
				goto out;
			}
			if (!creds_match) { /* case 9 */
				status = nfserr_perm;
				goto out;
			}
			if (!verfs_match) { /* case 8 */
				status = nfserr_not_same;
				goto out;
			}
			/* case 6 */
			exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
			goto out_copy;
		}
		if (!creds_match) { /* case 3 */
			if (client_has_state(conf)) {
				status = nfserr_clid_inuse;
				goto out;
			}
			goto out_new;
		}
		if (verfs_match) { /* case 2 */
			conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
			goto out_copy;
		}
		/* case 5, client reboot */
		conf = NULL;
		goto out_new;
	}

	if (update) { /* case 7 */
		status = nfserr_noent;
		goto out;
	}

	unconf  = find_unconfirmed_client_by_name(&exid->clname, nn);
	if (unconf) /* case 4, possible retry or client restart */
		unhash_client_locked(unconf);

	/* case 1 (normal case) */
out_new:
	if (conf) {
		status = mark_client_expired_locked(conf);
		if (status)
			goto out;
	}
	new->cl_minorversion = cstate->minorversion;
	new->cl_spo_must_allow.u.words[0] = exid->spo_must_allow[0];
	new->cl_spo_must_allow.u.words[1] = exid->spo_must_allow[1];

	gen_clid(new, nn);
	add_to_unconfirmed(new);
	swap(new, conf);
out_copy:
	exid->clientid.cl_boot = conf->cl_clientid.cl_boot;
	exid->clientid.cl_id = conf->cl_clientid.cl_id;

	exid->seqid = conf->cl_cs_slot.sl_seqid + 1;
	nfsd4_set_ex_flags(conf, exid);

	dprintk("nfsd4_exchange_id seqid %d flags %x\n",
		conf->cl_cs_slot.sl_seqid, conf->cl_exchange_flags);
	status = nfs_ok;

out:
	spin_unlock(&nn->client_lock);
out_nolock:
	if (new)
		expire_client(new);
	if (unconf)
		expire_client(unconf);
	return status;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 265 34.28% 6 17.14%
J. Bruce Fields 215 27.81% 18 51.43%
Andrew Elble 153 19.79% 2 5.71%
Trond Myklebust 67 8.67% 2 5.71%
Jeff Layton 46 5.95% 3 8.57%
Stanislav Kinsbursky 21 2.72% 3 8.57%
Kinglong Mee 6 0.78% 1 2.86%
Total 773 100.00% 35 100.00%


static __be32

check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
{
	dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
		slot_seqid);

	/* The slot is in use, and no response has been sent. */
	if (slot_inuse) {
		if (seqid == slot_seqid)
			return nfserr_jukebox;
		else
			return nfserr_seq_misordered;
	}
	/* Note unsigned 32-bit arithmetic handles wraparound: */
	if (likely(seqid == slot_seqid + 1))
		return nfs_ok;
	if (seqid == slot_seqid)
		return nfserr_replay_cache;
	return nfserr_seq_misordered;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 71 97.26% 4 66.67%
J. Bruce Fields 2 2.74% 2 33.33%
Total 73 100.00% 6 100.00%

/*
 * Cache the create session result into the create session single DRC
 * slot cache by saving the xdr structure. sl_seqid has been set.
 * Do this for solo or embedded create session operations.
 */

static void

nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
			   struct nfsd4_clid_slot *slot, __be32 nfserr)
{
	slot->sl_status = nfserr;
	memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 40 97.56% 1 50.00%
J. Bruce Fields 1 2.44% 1 50.00%
Total 41 100.00% 2 100.00%


static __be32

nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
			    struct nfsd4_clid_slot *slot)
{
	memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
	return slot->sl_status;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Adamson 37 100.00% 1 100.00%
Total 37 100.00% 1 100.00%


#define NFSD_MIN_REQ_HDR_SEQ_SZ	((\
                        2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
                        1 +	/* MIN tag is length with zero, only length */ \
                        3 +	/* version, opcount, opcode */ \
                        XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
				/* seqid, slotID, slotID, cache */ \
                        4 ) * sizeof(__be32))


#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
                        2 +	/* verifier: AUTH_NULL, length 0 */\
                        1 +	/* status */ \
                        1 +	/* MIN tag is length with zero, only length */ \
                        3 +	/* opcount, opcode, opstatus*/ \
                        XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
				/* seqid, slotID, slotID, slotID, status */ \
                        5 ) * sizeof(__be32))



static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
{
	u32 maxrpc = nn->nfsd_serv->sv_max_mesg;

	if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
		return nfserr_toosmall;
	if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
		return nfserr_toosmall;
	ca->headerpadsz = 0;
	ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
	ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
	ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
	ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
			NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
	ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
	/*
         * Note decreasing slot size below client's request may make it
         * difficult for client to function correctly, whereas
         * decreasing the number of slots will (just?) affect
         * performance.  When short on memory we therefore prefer to
         * decrease number of slots instead of their size.  Clients that
         * request larger slots than they need will get poor results:
         */
	ca->maxreqs = nfsd4_get_drc_mem(ca);
	if (!ca->maxreqs)
		return nfserr_jukebox;

	return nfs_ok;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 138 90.20% 2 66.67%
Mi Jinlong 15 9.80% 1 33.33%
Total 153 100.00% 3 100.00%

/*
 * Server's NFSv4.1 backchannel support is AUTH_SYS-only for now.
 * These are based on similar macros in linux/sunrpc/msg_prot.h .
 */

#define RPC_MAX_HEADER_WITH_AUTH_SYS \
	(RPC_CALLHDRSIZE + 2 * (2 + UNX_CALLSLACK))


#define RPC_MAX_REPHEADER_WITH_AUTH_SYS \
	(RPC_REPHDRSIZE + (2 + NUL_REPLYSLACK))


#define NFSD_CB_MAX_REQ_SZ	((NFS4_enc_cb_recall_sz + \
                                 RPC_MAX_HEADER_WITH_AUTH_SYS) * sizeof(__be32))

#define NFSD_CB_MAX_RESP_SZ	((NFS4_dec_cb_recall_sz + \
                                 RPC_MAX_REPHEADER_WITH_AUTH_SYS) * \
                                 sizeof(__be32))



static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
{
	ca->headerpadsz = 0;

	if (ca->maxreq_sz < NFSD_CB_MAX_REQ_SZ)
		return nfserr_toosmall;
	if (ca->maxresp_sz < NFSD_CB_MAX_RESP_SZ)
		return nfserr_toosmall;
	ca->maxresp_cached = 0;
	if (ca->maxops < 2)
		return nfserr_toosmall;

	return nfs_ok;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 49 83.05% 1 33.33%
Mi Jinlong 8 13.56% 1 33.33%
Kinglong Mee 2 3.39% 1 33.33%
Total 59 100.00% 3 100.00%



static __be32 nfsd4_check_cb_sec(struct nfsd4_cb_sec *cbs)
{
	switch (cbs->flavor) {
	case RPC_AUTH_NULL:
	case RPC_AUTH_UNIX:
		return nfs_ok;
	default:
		/*
                 * GSS case: the spec doesn't allow us to return this
                 * error.  But it also doesn't allow us not to support
                 * GSS.
                 * I'd rather this fail hard than return some error the
                 * client might think it can already handle:
                 */
		return nfserr_encr_alg_unsupp;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 33 100.00% 1 100.00%
Total 33 100.00% 1 100.00%


__be32

nfsd4_create_session(struct svc_rqst *rqstp,
		     struct nfsd4_compound_state *cstate,
		     struct nfsd4_create_session *cr_ses)
{
	struct sockaddr *sa = svc_addr(rqstp);
	struct nfs4_client *conf, *unconf;
	struct nfs4_client *old = NULL;
	struct nfsd4_session *new;
	struct nfsd4_conn *conn;
	struct nfsd4_clid_slot *cs_slot = NULL;
	__be32 status = 0;
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);

	if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
		return nfserr_inval;
	status = nfsd4_check_cb_sec(&cr_ses->cb_sec);
	if (status)
		return status;
	status = check_forechannel_attrs(&cr_ses->fore_channel, nn);
	if (status)
		return status;
	status = check_backchannel_attrs(&cr_ses->back_channel);
	if (status)
		goto out_release_drc_mem;
	status = nfserr_jukebox;
	new = alloc_session(&cr_ses->fore_channel, &cr_ses->back_channel);
	if (!new)
		goto out_release_drc_mem;
	conn = alloc_conn_from_crses(rqstp, cr_ses);
	if (!conn)
		goto out_free_session;

	spin_lock(&nn->client_lock);
	unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
	conf = find_confirmed_client(&cr_ses->clientid, true, nn);
	WARN_ON_ONCE(conf && unconf);

	if (conf) {
		status = nfserr_wrong_cred;
		if (!nfsd4_mach_creds_match(conf, rqstp))
			goto out_free_conn;
		cs_slot = &conf->cl_cs_slot;
		status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
		if (status) {
			if (status == nfserr_replay_cache)
				status = nfsd4_replay_create_session(cr_ses, cs_slot);
			goto out_free_conn;
		}
	} else if (unconf) {
		if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
		    !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
			status = nfserr_clid_inuse;
			goto out_free_conn;
		}
		status = nfserr_wrong_cred;
		if (!nfsd4_mach_creds_match(unconf, rqstp))
			goto out_free_conn;
		cs_slot = &unconf->cl_cs_slot;
		status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
		if (status) {
			/* an unconfirmed replay returns misordered */
			status = nfserr_seq_misordered;
			goto out_free_conn;
		}
		old = find_confirmed_client_by_name(&unconf->cl_name, nn);
		if (old) {
			status = mark_client_expired_locked(old);
			if (status) {
				old = NULL;
				goto out_free_conn;
			}
		}
		move_to_confirmed(unconf);
		conf = unconf;
	} else {
		status = nfserr_stale_clientid;
		goto out_free_conn;
	}
	status = nfs_ok;
	/* Persistent sessions are not supported */
	cr_ses->flags &= ~SESSION4_PERSIST;
	/* Upshifting from TCP to RDMA is not supported */
	cr_ses->flags &= ~SESSION4_RDMA;

	init_session(rqstp, new, conf, cr_ses);
	nfsd4_get_session_locked(new);

	memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
	       NFS4_MAX_SESSIONID_LEN);
	cs_slot->sl_seqid++;
	cr_ses->seqid = cs_slot->sl_seqid;

	/* cache solo and embedded create sessions under the client_lock */
	nfsd4_cache_create_session(cr_ses, cs_slot, status);
	spin_unlock(&nn->client_lock);
	/* init connection and backchannel */
	nfsd4_init_conn(rqstp, conn, new);
	nfsd4_put_session(new);
	if (old)
		expire_client(old);
	return status;
out_free_conn:
	spin_unlock(&nn->client_lock);
	free_conn(conn);
	if (old)
		expire_client(old);
out_free_session:
	__free_session(new);
out_release_drc_mem:
	nfsd4_put_drc_mem(&cr_ses->fore_channel);
	return status;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 238 38.64% 18 45.00%
Andy Adamson 235 38.15% 8 20.00%
Jeff Layton 90 14.61% 4 10.00%
Stanislav Kinsbursky 21 3.41% 3 7.50%
Kinglong Mee 13 2.11% 3 7.50%
Mi Jinlong 12 1.95% 1 2.50%
Ricardo Labiaga 3 0.49% 1 2.50%
Chuck Lever 2 0.32% 1 2.50%
Andrew Elble 2 0.32% 1 2.50%
Total 616 100.00% 40 100.00%



static __be32 nfsd4_map_bcts_dir(u32 *dir)
{
	switch (*dir) {
	case NFS4_CDFC4_FORE:
	case NFS4_CDFC4_BACK:
		return nfs_ok;
	case NFS4_CDFC4_FORE_OR_BOTH:
	case NFS4_CDFC4_BACK_OR_BOTH:
		*dir = NFS4_CDFC4_BOTH;
		return nfs_ok;
	};
	return nfserr_inval;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 44 100.00% 1 100.00%
Total 44 100.00% 1 100.00%



__be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_backchannel_ctl *bc)
{
	struct nfsd4_session *session = cstate->session;
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
	__be32 status;

	status = nfsd4_check_cb_sec(&bc->bc_cb_sec);
	if (status)
		return status;
	spin_lock(&nn->client_lock);
	session->se_cb_prog = bc->bc_cb_program;
	session->se_cb_sec = bc->bc_cb_sec;
	spin_unlock(&nn->client_lock);

	nfsd4_probe_callback(session->se_client);

	return nfs_ok;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 87 82.08% 2 66.67%
Stanislav Kinsbursky 19 17.92% 1 33.33%
Total 106 100.00% 3 100.00%



__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
		     struct nfsd4_compound_state *cstate,
		     struct nfsd4_bind_conn_to_session *bcts)
{
	__be32 status;
	struct nfsd4_conn *conn;
	struct nfsd4_session *session;
	struct net *net = SVC_NET(rqstp);
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);

	if (!nfsd4_last_compound_op(rqstp))
		return nfserr_not_only_op;
	spin_lock(&nn->client_lock);
	session = find_in_sessionid_hashtbl(&bcts->sessionid, net, &status);
	spin_unlock(&nn->client_lock);
	if (!session)
		goto out_no_session;
	status = nfserr_wrong_cred;
	if (!nfsd4_mach_creds_match(session->se_client, rqstp))
		goto out;
	status = nfsd4_map_bcts_dir(&bcts->dir);
	if (status)
		goto out;
	conn = alloc_conn(rqstp, bcts->dir);
	status = nfserr_jukebox;
	if (!conn)
		goto out;
	nfsd4_init_conn(rqstp, conn, session);
	status = nfs_ok;
out:
	nfsd4_put_session(session);
out_no_session:
	return status;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 145 76.72% 4 44.44%
Trond Myklebust 23 12.17% 1 11.11%
Stanislav Kinsbursky 16 8.47% 2 22.22%
Bryan Schumaker 4 2.12% 1 11.11%
Andrew Elble 1 0.53% 1 11.11%
Total 189 100.00% 9 100.00%



static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
{
	if (!session)
		return 0;
	return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 42 100.00% 1 100.00%
Total 42 100.00% 1 100.00%


__be32

nfsd4_destroy_session(struct svc_rqst *r,
		      struct nfsd4_compound_state *cstate,
		      struct nfsd4_destroy_session *sessionid)
{
	struct nfsd4_session *ses;
	__be32 status;
	int ref_held_by_me = 0;
	struct net *net = SVC_NET(r);
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);

	status = nfserr_not_only_op;
	if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
		if (!nfsd4_last_compound_op(r))
			goto out;
		ref_held_by_me++;
	}
	dump_sessionid(__func__, &sessionid->sessionid);
	spin_lock(&nn->client_lock);
	ses = find_in_sessionid_hashtbl(&sessionid->sessionid, net, &status);
	if (!ses)
		goto out_client_lock;
	status = nfserr_wrong_cred;
	if (!nfsd4_mach_creds_match(ses->se_client, r))
		goto out_put_session;
	status = mark_session_dead_locked(ses, 1 + ref_held_by_me);
	if (status)
		goto out_put_session;
	unhash_session(ses);
	spin_unlock(&nn->client_lock);

	nfsd4_probe_callback_sync(ses->se_client);

	spin_lock(&nn->client_lock);
	status = nfs_ok;
out_put_session:
	nfsd4_put_session_locked(ses);
out_client_lock:
	spin_unlock(&nn->client_lock);
out:
	return status;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 85 38.46% 8 50.00%
Benny Halevy 76 34.39% 3 18.75%
Andy Adamson 22 9.95% 1 6.25%
Stanislav Kinsbursky 20 9.05% 2 12.50%
Trond Myklebust 17 7.69% 1 6.25%
Andrew Elble 1 0.45% 1 6.25%
Total 221 100.00% 16 100.00%



static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
{
	struct nfsd4_conn *c;

	list_for_each_entry(c, &s->se_conns, cn_persession) {
		if (c->cn_xprt == xpt) {
			return c;
		}
	}
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 49 100.00% 2 100.00%
Total 49 100.00% 2 100.00%



static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
{
	struct nfs4_client *clp = ses->se_client;
	struct nfsd4_conn *c;
	__be32 status = nfs_ok;
	int ret;

	spin_lock(&clp->cl_lock);
	c = __nfsd4_find_conn(new->cn_xprt, ses);
	if (c)
		goto out_free;
	status = nfserr_conn_not_bound_to_session;
	if (clp->cl_mach_cred)
		goto out_free;
	__nfsd4_hash_conn(new, ses);
	spin_unlock(&clp->cl_lock);
	ret = nfsd4_register_conn(new);
	if (ret)
		/* oops; xprt is already down: */
		nfsd4_conn_lost(&new->cn_xpt_user);
	return nfs_ok;
out_free:
	spin_unlock(&clp->cl_lock);
	free_conn(new);
	return status;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 133 100.00% 4 100.00%
Total 133 100.00% 4 100.00%



static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
{
	struct nfsd4_compoundargs *args = rqstp->rq_argp;

	return args->opcnt > session->se_fchannel.maxops;
}

Contributors
Person Tokens Prop Commits CommitProp
Mi Jinlong 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%



static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
				  struct nfsd4_session *session)
{
	struct xdr_buf *xb = &rqstp->rq_arg;

	return xb->len > session->se_fchannel.maxreq_sz;
}

Contributors
Person Tokens Prop Commits CommitProp
Mi Jinlong 37 100.00% 1 100.00%
Total 37 100.00% 1 100.00%


__be32

nfsd4_sequence(struct svc_rqst *rqstp,
	       struct nfsd4_compound_state *cstate,
	       struct nfsd4_sequence *seq)
{
	struct nfsd4_compoundres *resp = rqstp->rq_resp;
	struct xdr_stream *xdr = &resp->xdr;
	struct nfsd4_session *session;
	struct nfs4_client *clp;
	struct nfsd4_slot *slot;
	struct nfsd4_conn *conn;
	__be32 status;
	int buflen;
	struct net *net = SVC_NET(rqstp);
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);

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

	/*
         * Will be either used or freed by nfsd4_sequence_check_conn
         * below.
         */
	conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
	if (!conn)
		return nfserr_jukebox;

	spin_lock(&nn->client_lock);
	session = find_in_sessionid_hashtbl(&seq->sessionid, net, &status);
	if (!session)
		goto out_no_session;
	clp = session->se_client;

	status = nfserr_too_many_ops;
	if (nfsd4_session_too_many_ops(rqstp, session))
		goto out_put_session;

	status = nfserr_req_too_big;
	if (nfsd4_request_too_big(rqstp, session))
		goto out_put_session;

	status = nfserr_badslot;
	if (seq->slotid >= session->se_fchannel.maxreqs)
		goto out_put_session;

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

	/* We do not negotiate the number of slots yet, so set the
         * maxslots to the session maxreqs which is used to encode
         * sr_highest_slotid and the sr_target_slot id to maxslots */
	seq->maxslots = session->se_fchannel.maxreqs;

	status = check_slot_seqid(seq->seqid, slot->sl_seqid,
					slot->sl_flags & NFSD4_SLOT_INUSE);
	if (status == nfserr_replay_cache) {
		status = nfserr_seq_misordered;
		if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
			goto out_put_session;
		cstate->slot = slot;
		cstate->session = session;
		cstate->clp = clp;
		/* Return the cached reply status and set cstate->status
                 * for nfsd4_proc_compound processing */
		status = nfsd4_replay_cache_entry(resp, seq);
		cstate->status = nfserr_replay_cache;
		goto out;
	}
	if (status)
		goto out_put_session;

	status = nfsd4_sequence_check_conn(conn, session);
	conn = NULL;
	if (status)
		goto out_put_session;

	buflen = (seq->cachethis) ?
			session->se_fchannel.maxresp_cached :
			session->se_fchannel.maxresp_sz;
	status = (seq->cachethis) ? nfserr_rep_too_big_to_cache :
				    nfserr_rep_too_big;
	if (xdr_restrict_buflen(xdr, buflen - rqstp->rq_auth_slack))
		goto out_put_session;
	svc_reserve(rqstp, buflen);

	status = nfs_ok;
	/* Success! bump slot seqid */
	slot->sl_seqid = seq->seqid;
	slot->sl_flags |= NFSD4_SLOT_INUSE;
	if (seq->cachethis)
		slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
	else
		slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;

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

out:
	switch (clp->cl_cb_state) {
	case NFSD4_CB_DOWN:
		seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
		break;
	case NFSD4_CB_FAULT:
		seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
		break;
	default:
		seq->status_flags = 0;
	}
	if (!list_empty(&clp->cl_revoked))
		seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
out_no_session:
	if (conn)
		free_conn(conn);
	spin_unlock(&nn->client_lock);
	return status;
out_put_session:
	nfsd4_put_session_locked(session);
	goto out_no_session;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 219 40.26% 14 40.00%
Benny Halevy 164 30.15% 6 17.14%
Andy Adamson 79 14.52% 7 20.00%
Mi Jinlong 30 5.51% 2 5.71%
Stanislav Kinsbursky 16 2.94% 2 5.71%
Trond Myklebust 16 2.94% 1 2.86%
Jeff Layton 12 2.21% 1 2.86%
Kinglong Mee 5 0.92% 1 2.86%
Alexandros Batsakis 3 0.55% 1 2.86%
Total 544 100.00% 35 100.00%


void

nfsd4_sequence_done(struct nfsd4_compoundres *resp)
{
	struct nfsd4_compound_state *cs = &resp->cstate;

	if (nfsd4_has_session(cs)) {
		if (cs->status != nfserr_replay_cache) {
			nfsd4_store_cache_entry(resp);
			cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE;
		}
		/* Drop session reference that was taken in nfsd4_sequence() */
		nfsd4_put_session(cs->session);
	} else if (cs->clp)
		put_client_renew(cs->clp);
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 61 81.33% 2 66.67%
Jeff Layton 14 18.67% 1 33.33%
Total 75 100.00% 3 100.00%


__be32

nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
{
	struct nfs4_client *conf, *unconf;
	struct nfs4_client *clp = NULL;
	__be32 status = 0;
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);

	spin_lock(&nn->client_lock);
	unconf = find_unconfirmed_client(&dc->clientid, true, nn);
	conf = find_confirmed_client(&dc->clientid, true, nn);
	WARN_ON_ONCE(conf && unconf);

	if (conf) {
		if (client_has_state(conf)) {
			status = nfserr_clientid_busy;
			goto out;
		}
		status = mark_client_expired_locked(conf);
		if (status)
			goto out;
		clp = conf;
	} else if (unconf)
		clp = unconf;
	else {
		status = nfserr_stale_clientid;
		goto out;
	}
	if (!nfsd4_mach_creds_match(clp, rqstp)) {
		clp = NULL;
		status = nfserr_wrong_cred;
		goto out;
	}
	unhash_client_locked(clp);
out:
	spin_unlock(&nn->client_lock);
	if (clp)
		expire_client(clp);
	return status;
}

Contributors
Person Tokens Prop Commits CommitProp
Mi Jinlong 103 49.76% 1 9.09%
Trond Myklebust 39 18.84% 1 9.09%
J. Bruce Fields 31 14.98% 5 45.45%
Stanislav Kinsbursky 19 9.18% 2 18.18%
Jeff Layton 14 6.76% 1 9.09%
Andrew Elble 1 0.48% 1 9.09%
Total 207 100.00% 11 100.00%


__be32

nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
{
	__be32 status = 0;

	if (rc->rca_one_fs) {
		if (!cstate->current_fh.fh_dentry)
			return nfserr_nofilehandle;
		/*
                 * We don't take advantage of the rca_one_fs case.
                 * That's OK, it's optional, we can safely ignore it.
                 */
		return nfs_ok;
	}

	status = nfserr_complete_already;
	if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
			     &cstate->session->se_client->cl_flags))
		goto out;

	status = nfserr_stale_clientid;
	if (is_client_expired(cstate->session->se_client))
		/*
                 * The following error isn't really legal.
                 * But we only get here if the client just explicitly
                 * destroyed the client.  Surely it no longer cares what
                 * error it gets back on an operation for the dead
                 * client.
                 */
		goto out;

	status = nfs_ok;
	nfsd4_client_record_create(cstate->session->se_client);
out:
	return status;
}

Contributors
Person Tokens Prop Commits CommitProp
J. Bruce Fields 66 60.55% 2 33.33%
Mi Jinlong 34 31.19% 1 16.67%
Jeff Layton 8 7.34% 2 33.33%
Andy Adamson 1 0.92% 1 16.67%
Total 109 100.00% 6 100.00%


__be32

nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
		  struct nfsd4_setclientid *setclid)
{
	struct xdr_netobj 	clname = setclid->se_name;
	nfs4_verifier		clverifier = setclid->se_verf;
	struct nfs4_client	*
Person	Tokens	Prop	Commits	CommitProp
Benny Halevy	10	55.56%	1	50.00%
J. Bruce Fields	8	44.44%	1	50.00%
Total	18	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.11 fs/nfsd/nfs4state.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
