nfsd: Move the open owner hash table into struct nfs4_client (d4f0489f) · Commits · e / devices / android_kernel_xiaomi_markw

fs/nfsd/netns.h

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -63,7 +63,6 @@ struct nfsd_net {
	struct rb_root conf_name_tree;		struct rb_root conf_name_tree;
	struct list_head *unconf_id_hashtbl;		struct list_head *unconf_id_hashtbl;
	struct rb_root unconf_name_tree;		struct rb_root unconf_name_tree;
	struct list_head *ownerstr_hashtbl;
	struct list_head *sessionid_hashtbl;		struct list_head *sessionid_hashtbl;
	/*		/*
	* client_lru holds client queue ordered by nfs4_client.cl_time		* client_lru holds client queue ordered by nfs4_client.cl_time

fs/nfsd/nfs4state.c

+85 −102

Original line number	Original line	Diff line number	Diff line
	@@ -240,35 +240,27 @@ static void nfsd4_put_session(struct nfsd4_session *ses)
	}		}

	static int		static int
	same_owner_str(struct nfs4_stateowner sop, struct xdr_netobj owner,		same_owner_str(struct nfs4_stateowner sop, struct xdr_netobj owner)
	clientid_t *clid)
	{		{
	return (sop->so_owner.len == owner->len) &&		return (sop->so_owner.len == owner->len) &&
	0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&		0 == memcmp(sop->so_owner.data, owner->data, owner->len);
	(sop->so_client->cl_clientid.cl_id == clid->cl_id);
	}		}

	static struct nfs4_openowner *		static struct nfs4_openowner *
	find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open,		find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open,
	bool sessions, struct nfsd_net *nn)		struct nfs4_client *clp)
	{		{
	struct nfs4_stateowner *so;		struct nfs4_stateowner *so;
	struct nfs4_openowner *oo;
	struct nfs4_client *clp;

	lockdep_assert_held(&nn->client_lock);		lockdep_assert_held(&clp->cl_lock);

	list_for_each_entry(so, &nn->ownerstr_hashtbl[hashval], so_strhash) {		list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[hashval],
			so_strhash) {
	if (!so->so_is_open_owner)		if (!so->so_is_open_owner)
	continue;		continue;
	if (same_owner_str(so, &open->op_owner, &open->op_clientid)) {		if (same_owner_str(so, &open->op_owner)) {
	oo = openowner(so);
	clp = oo->oo_owner.so_client;
	if ((bool)clp->cl_minorversion != sessions)
	break;
	renew_client_locked(clp);
	atomic_inc(&so->so_count);		atomic_inc(&so->so_count);
	return oo;		return openowner(so);
	}		}
	}		}
	return NULL;		return NULL;
	@@ -276,17 +268,16 @@ find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open,

	static struct nfs4_openowner *		static struct nfs4_openowner *
	find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,		find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
	bool sessions, struct nfsd_net *nn)		struct nfs4_client *clp)
	{		{
	struct nfs4_openowner *oo;		struct nfs4_openowner *oo;

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


	static inline u32		static inline u32
	opaque_hashval(const void *ptr, int nbytes)		opaque_hashval(const void *ptr, int nbytes)
	{		{
	@@ -408,12 +399,11 @@ unsigned long max_delegations;
	#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)		#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
	#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)		#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)

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

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

	@@ -1002,40 +992,37 @@ static void release_lock_stateid(struct nfs4_ol_stateid *stp)

	static void unhash_lockowner_locked(struct nfs4_lockowner *lo)		static void unhash_lockowner_locked(struct nfs4_lockowner *lo)
	{		{
	struct nfsd_net *nn = net_generic(lo->lo_owner.so_client->net,		struct nfs4_client *clp = lo->lo_owner.so_client;
	nfsd_net_id);

	lockdep_assert_held(&nn->client_lock);		lockdep_assert_held(&clp->cl_lock);

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

	static void release_lockowner_stateids(struct nfs4_lockowner *lo)		static void release_lockowner_stateids(struct nfs4_lockowner *lo)
	{		{
	struct nfsd_net *nn = net_generic(lo->lo_owner.so_client->net,		struct nfs4_client *clp = lo->lo_owner.so_client;
	nfsd_net_id);
	struct nfs4_ol_stateid *stp;		struct nfs4_ol_stateid *stp;

	lockdep_assert_held(&nn->client_lock);		lockdep_assert_held(&clp->cl_lock);

	while (!list_empty(&lo->lo_owner.so_stateids)) {		while (!list_empty(&lo->lo_owner.so_stateids)) {
	stp = list_first_entry(&lo->lo_owner.so_stateids,		stp = list_first_entry(&lo->lo_owner.so_stateids,
	struct nfs4_ol_stateid, st_perstateowner);		struct nfs4_ol_stateid, st_perstateowner);
	spin_unlock(&nn->client_lock);		spin_unlock(&clp->cl_lock);
	release_lock_stateid(stp);		release_lock_stateid(stp);
	spin_lock(&nn->client_lock);		spin_lock(&clp->cl_lock);
	}		}
	}		}

	static void release_lockowner(struct nfs4_lockowner *lo)		static void release_lockowner(struct nfs4_lockowner *lo)
	{		{
	struct nfsd_net *nn = net_generic(lo->lo_owner.so_client->net,		struct nfs4_client *clp = lo->lo_owner.so_client;
	nfsd_net_id);

	spin_lock(&nn->client_lock);		spin_lock(&clp->cl_lock);
	unhash_lockowner_locked(lo);		unhash_lockowner_locked(lo);
	release_lockowner_stateids(lo);		release_lockowner_stateids(lo);
	spin_unlock(&nn->client_lock);		spin_unlock(&clp->cl_lock);
	nfs4_put_stateowner(&lo->lo_owner);		nfs4_put_stateowner(&lo->lo_owner);
	}		}

	@@ -1070,10 +1057,9 @@ static void release_open_stateid(struct nfs4_ol_stateid *stp)

	static void unhash_openowner_locked(struct nfs4_openowner *oo)		static void unhash_openowner_locked(struct nfs4_openowner *oo)
	{		{
	struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net,		struct nfs4_client *clp = oo->oo_owner.so_client;
	nfsd_net_id);

	lockdep_assert_held(&nn->client_lock);		lockdep_assert_held(&clp->cl_lock);

	list_del_init(&oo->oo_owner.so_strhash);		list_del_init(&oo->oo_owner.so_strhash);
	list_del_init(&oo->oo_perclient);		list_del_init(&oo->oo_perclient);
	@@ -1093,29 +1079,27 @@ static void release_last_closed_stateid(struct nfs4_openowner *oo)
	static void release_openowner_stateids(struct nfs4_openowner *oo)		static void release_openowner_stateids(struct nfs4_openowner *oo)
	{		{
	struct nfs4_ol_stateid *stp;		struct nfs4_ol_stateid *stp;
	struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net,		struct nfs4_client *clp = oo->oo_owner.so_client;
	nfsd_net_id);

	lockdep_assert_held(&nn->client_lock);		lockdep_assert_held(&clp->cl_lock);

	while (!list_empty(&oo->oo_owner.so_stateids)) {		while (!list_empty(&oo->oo_owner.so_stateids)) {
	stp = list_first_entry(&oo->oo_owner.so_stateids,		stp = list_first_entry(&oo->oo_owner.so_stateids,
	struct nfs4_ol_stateid, st_perstateowner);		struct nfs4_ol_stateid, st_perstateowner);
	spin_unlock(&nn->client_lock);		spin_unlock(&clp->cl_lock);
	release_open_stateid(stp);		release_open_stateid(stp);
	spin_lock(&nn->client_lock);		spin_lock(&clp->cl_lock);
	}		}
	}		}

	static void release_openowner(struct nfs4_openowner *oo)		static void release_openowner(struct nfs4_openowner *oo)
	{		{
	struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net,		struct nfs4_client *clp = oo->oo_owner.so_client;
	nfsd_net_id);

	spin_lock(&nn->client_lock);		spin_lock(&clp->cl_lock);
	unhash_openowner_locked(oo);		unhash_openowner_locked(oo);
	release_openowner_stateids(oo);		release_openowner_stateids(oo);
	spin_unlock(&nn->client_lock);		spin_unlock(&clp->cl_lock);
	release_last_closed_stateid(oo);		release_last_closed_stateid(oo);
	nfs4_put_stateowner(&oo->oo_owner);		nfs4_put_stateowner(&oo->oo_owner);
	}		}
	@@ -1497,15 +1481,20 @@ STALE_CLIENTID(clientid_t clid, struct nfsd_net nn)
	static struct nfs4_client *alloc_client(struct xdr_netobj name)		static struct nfs4_client *alloc_client(struct xdr_netobj name)
	{		{
	struct nfs4_client *clp;		struct nfs4_client *clp;
			int i;

	clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);		clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
	if (clp == NULL)		if (clp == NULL)
	return NULL;		return NULL;
	clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);		clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
	if (clp->cl_name.data == NULL) {		if (clp->cl_name.data == NULL)
	kfree(clp);		goto err_no_name;
	return NULL;		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;		clp->cl_name.len = name.len;
	INIT_LIST_HEAD(&clp->cl_sessions);		INIT_LIST_HEAD(&clp->cl_sessions);
	idr_init(&clp->cl_stateids);		idr_init(&clp->cl_stateids);
	@@ -1520,6 +1509,11 @@ static struct nfs4_client *alloc_client(struct xdr_netobj name)
	spin_lock_init(&clp->cl_lock);		spin_lock_init(&clp->cl_lock);
	rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");		rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
	return clp;		return clp;
			err_no_hashtbl:
			kfree(clp->cl_name.data);
			err_no_name:
			kfree(clp);
			return NULL;
	}		}

	static void		static void
	@@ -1538,6 +1532,7 @@ free_client(struct nfs4_client *clp)
	}		}
	rpc_destroy_wait_queue(&clp->cl_cb_waitq);		rpc_destroy_wait_queue(&clp->cl_cb_waitq);
	free_svc_cred(&clp->cl_cred);		free_svc_cred(&clp->cl_cred);
			kfree(clp->cl_ownerstr_hashtbl);
	kfree(clp->cl_name.data);		kfree(clp->cl_name.data);
	idr_destroy(&clp->cl_stateids);		idr_destroy(&clp->cl_stateids);
	kfree(clp);		kfree(clp);
	@@ -3074,20 +3069,20 @@ static inline void alloc_stateowner(struct kmem_cache slab, struct xdr_netobj

	static void hash_openowner(struct nfs4_openowner oo, struct nfs4_client clp, unsigned int strhashval)		static void hash_openowner(struct nfs4_openowner oo, struct nfs4_client clp, unsigned int strhashval)
	{		{
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);		lockdep_assert_held(&clp->cl_lock);

	list_add(&oo->oo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);		list_add(&oo->oo_owner.so_strhash,
			&clp->cl_ownerstr_hashtbl[strhashval]);
	list_add(&oo->oo_perclient, &clp->cl_openowners);		list_add(&oo->oo_perclient, &clp->cl_openowners);
	}		}

	static void nfs4_unhash_openowner(struct nfs4_stateowner *so)		static void nfs4_unhash_openowner(struct nfs4_stateowner *so)
	{		{
	struct nfs4_openowner *oo = openowner(so);		struct nfs4_client *clp = so->so_client;
	struct nfsd_net *nn = net_generic(so->so_client->net, nfsd_net_id);

	spin_lock(&nn->client_lock);		spin_lock(&clp->cl_lock);
	unhash_openowner_locked(oo);		unhash_openowner_locked(openowner(so));
	spin_unlock(&nn->client_lock);		spin_unlock(&clp->cl_lock);
	}		}

	static void nfs4_free_openowner(struct nfs4_stateowner *so)		static void nfs4_free_openowner(struct nfs4_stateowner *so)
	@@ -3107,7 +3102,6 @@ alloc_init_open_stateowner(unsigned int strhashval, struct nfsd4_open *open,
	struct nfsd4_compound_state *cstate)		struct nfsd4_compound_state *cstate)
	{		{
	struct nfs4_client *clp = cstate->clp;		struct nfs4_client *clp = cstate->clp;
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
	struct nfs4_openowner oo, ret;		struct nfs4_openowner oo, ret;

	oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);		oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
	@@ -3122,15 +3116,14 @@ alloc_init_open_stateowner(unsigned int strhashval, struct nfsd4_open *open,
	oo->oo_time = 0;		oo->oo_time = 0;
	oo->oo_last_closed_stid = NULL;		oo->oo_last_closed_stid = NULL;
	INIT_LIST_HEAD(&oo->oo_close_lru);		INIT_LIST_HEAD(&oo->oo_close_lru);
	spin_lock(&nn->client_lock);		spin_lock(&clp->cl_lock);
	ret = find_openstateowner_str_locked(strhashval,		ret = find_openstateowner_str_locked(strhashval, open, clp);
	open, clp->cl_minorversion, nn);
	if (ret == NULL) {		if (ret == NULL) {
	hash_openowner(oo, clp, strhashval);		hash_openowner(oo, clp, strhashval);
	ret = oo;		ret = oo;
	} else		} else
	nfs4_free_openowner(&oo->oo_owner);		nfs4_free_openowner(&oo->oo_owner);
	spin_unlock(&nn->client_lock);		spin_unlock(&clp->cl_lock);
	return oo;		return oo;
	}		}

	@@ -3412,8 +3405,8 @@ nfsd4_process_open1(struct nfsd4_compound_state *cstate,
	return status;		return status;
	clp = cstate->clp;		clp = cstate->clp;

	strhashval = ownerstr_hashval(clientid->cl_id, &open->op_owner);		strhashval = ownerstr_hashval(&open->op_owner);
	oo = find_openstateowner_str(strhashval, open, cstate->minorversion, nn);		oo = find_openstateowner_str(strhashval, open, clp);
	open->op_openowner = oo;		open->op_openowner = oo;
	if (!oo) {		if (!oo) {
	goto new_owner;		goto new_owner;
	@@ -4818,15 +4811,16 @@ nevermind:

	static struct nfs4_lockowner *		static struct nfs4_lockowner *
	find_lockowner_str_locked(clientid_t clid, struct xdr_netobj owner,		find_lockowner_str_locked(clientid_t clid, struct xdr_netobj owner,
	struct nfsd_net *nn)		struct nfs4_client *clp)
	{		{
	unsigned int strhashval = ownerstr_hashval(clid->cl_id, owner);		unsigned int strhashval = ownerstr_hashval(owner);
	struct nfs4_stateowner *so;		struct nfs4_stateowner *so;

	list_for_each_entry(so, &nn->ownerstr_hashtbl[strhashval], so_strhash) {		list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[strhashval],
			so_strhash) {
	if (so->so_is_open_owner)		if (so->so_is_open_owner)
	continue;		continue;
	if (!same_owner_str(so, owner, clid))		if (!same_owner_str(so, owner))
	continue;		continue;
	atomic_inc(&so->so_count);		atomic_inc(&so->so_count);
	return lockowner(so);		return lockowner(so);
	@@ -4836,23 +4830,23 @@ find_lockowner_str_locked(clientid_t clid, struct xdr_netobj owner,

	static struct nfs4_lockowner *		static struct nfs4_lockowner *
	find_lockowner_str(clientid_t clid, struct xdr_netobj owner,		find_lockowner_str(clientid_t clid, struct xdr_netobj owner,
	struct nfsd_net *nn)		struct nfs4_client *clp)
	{		{
	struct nfs4_lockowner *lo;		struct nfs4_lockowner *lo;

	spin_lock(&nn->client_lock);		spin_lock(&clp->cl_lock);
	lo = find_lockowner_str_locked(clid, owner, nn);		lo = find_lockowner_str_locked(clid, owner, clp);
	spin_unlock(&nn->client_lock);		spin_unlock(&clp->cl_lock);
	return lo;		return lo;
	}		}

	static void nfs4_unhash_lockowner(struct nfs4_stateowner *sop)		static void nfs4_unhash_lockowner(struct nfs4_stateowner *sop)
	{		{
	struct nfsd_net *nn = net_generic(sop->so_client->net, nfsd_net_id);		struct nfs4_client *clp = sop->so_client;

	spin_lock(&nn->client_lock);		spin_lock(&clp->cl_lock);
	unhash_lockowner_locked(lockowner(sop));		unhash_lockowner_locked(lockowner(sop));
	spin_unlock(&nn->client_lock);		spin_unlock(&clp->cl_lock);
	}		}

	static void nfs4_free_lockowner(struct nfs4_stateowner *sop)		static void nfs4_free_lockowner(struct nfs4_stateowner *sop)
	@@ -4879,7 +4873,6 @@ alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp,
	struct nfs4_ol_stateid *open_stp,		struct nfs4_ol_stateid *open_stp,
	struct nfsd4_lock *lock)		struct nfsd4_lock *lock)
	{		{
	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
	struct nfs4_lockowner lo, ret;		struct nfs4_lockowner lo, ret;

	lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);		lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
	@@ -4889,16 +4882,16 @@ alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp,
	lo->lo_owner.so_is_open_owner = 0;		lo->lo_owner.so_is_open_owner = 0;
	lo->lo_owner.so_seqid = lock->lk_new_lock_seqid;		lo->lo_owner.so_seqid = lock->lk_new_lock_seqid;
	lo->lo_owner.so_ops = &lockowner_ops;		lo->lo_owner.so_ops = &lockowner_ops;
	spin_lock(&nn->client_lock);		spin_lock(&clp->cl_lock);
	ret = find_lockowner_str_locked(&clp->cl_clientid,		ret = find_lockowner_str_locked(&clp->cl_clientid,
	&lock->lk_new_owner, nn);		&lock->lk_new_owner, clp);
	if (ret == NULL) {		if (ret == NULL) {
	list_add(&lo->lo_owner.so_strhash,		list_add(&lo->lo_owner.so_strhash,
	&nn->ownerstr_hashtbl[strhashval]);		&clp->cl_ownerstr_hashtbl[strhashval]);
	ret = lo;		ret = lo;
	} else		} else
	nfs4_free_lockowner(&lo->lo_owner);		nfs4_free_lockowner(&lo->lo_owner);
	spin_unlock(&nn->client_lock);		spin_unlock(&clp->cl_lock);
	return lo;		return lo;
	}		}

	@@ -5010,12 +5003,10 @@ lookup_or_create_lock_state(struct nfsd4_compound_state *cstate,
	struct inode *inode = cstate->current_fh.fh_dentry->d_inode;		struct inode *inode = cstate->current_fh.fh_dentry->d_inode;
	struct nfs4_lockowner *lo;		struct nfs4_lockowner *lo;
	unsigned int strhashval;		unsigned int strhashval;
	struct nfsd_net *nn = net_generic(cl->net, nfsd_net_id);

	lo = find_lockowner_str(&cl->cl_clientid, &lock->v.new.owner, nn);		lo = find_lockowner_str(&cl->cl_clientid, &lock->v.new.owner, cl);
	if (!lo) {		if (!lo) {
	strhashval = ownerstr_hashval(cl->cl_clientid.cl_id,		strhashval = ownerstr_hashval(&lock->v.new.owner);
	&lock->v.new.owner);
	lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);		lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
	if (lo == NULL)		if (lo == NULL)
	return nfserr_jukebox;		return nfserr_jukebox;
	@@ -5293,7 +5284,8 @@ nfsd4_lockt(struct svc_rqst rqstp, struct nfsd4_compound_state cstate,
	goto out;		goto out;
	}		}

	lo = find_lockowner_str(&lockt->lt_clientid, &lockt->lt_owner, nn);		lo = find_lockowner_str(&lockt->lt_clientid, &lockt->lt_owner,
			cstate->clp);
	if (lo)		if (lo)
	file_lock->fl_owner = (fl_owner_t)lo;		file_lock->fl_owner = (fl_owner_t)lo;
	file_lock->fl_pid = current->tgid;		file_lock->fl_pid = current->tgid;
	@@ -5436,7 +5428,7 @@ nfsd4_release_lockowner(struct svc_rqst *rqstp,
	struct nfs4_lockowner *lo;		struct nfs4_lockowner *lo;
	struct nfs4_ol_stateid *stp;		struct nfs4_ol_stateid *stp;
	struct xdr_netobj *owner = &rlockowner->rl_owner;		struct xdr_netobj *owner = &rlockowner->rl_owner;
	unsigned int hashval = ownerstr_hashval(clid->cl_id, owner);		unsigned int hashval = ownerstr_hashval(owner);
	__be32 status;		__be32 status;
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);		struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
	struct nfs4_client *clp;		struct nfs4_client *clp;
	@@ -5452,29 +5444,29 @@ nfsd4_release_lockowner(struct svc_rqst *rqstp,

	status = nfserr_locks_held;		status = nfserr_locks_held;

			clp = cstate->clp;
	/* Find the matching lock stateowner */		/* Find the matching lock stateowner */
	spin_lock(&nn->client_lock);		spin_lock(&clp->cl_lock);
	list_for_each_entry(tmp, &nn->ownerstr_hashtbl[hashval], so_strhash) {		list_for_each_entry(tmp, &clp->cl_ownerstr_hashtbl[hashval],
			so_strhash) {
	if (tmp->so_is_open_owner)		if (tmp->so_is_open_owner)
	continue;		continue;
	if (same_owner_str(tmp, owner, clid)) {		if (same_owner_str(tmp, owner)) {
	sop = tmp;		sop = tmp;
	atomic_inc(&sop->so_count);		atomic_inc(&sop->so_count);
	break;		break;
	}		}
	}		}
	spin_unlock(&nn->client_lock);

	/* No matching owner found, maybe a replay? Just declare victory... */		/* No matching owner found, maybe a replay? Just declare victory... */
	if (!sop) {		if (!sop) {
			spin_unlock(&clp->cl_lock);
	status = nfs_ok;		status = nfs_ok;
	goto out;		goto out;
	}		}

	lo = lockowner(sop);		lo = lockowner(sop);
	/* see if there are still any locks associated with it */		/* see if there are still any locks associated with it */
	clp = cstate->clp;
	spin_lock(&clp->cl_lock);
	list_for_each_entry(stp, &sop->so_stateids, st_perstateowner) {		list_for_each_entry(stp, &sop->so_stateids, st_perstateowner) {
	if (check_for_locks(stp->st_stid.sc_file, lo)) {		if (check_for_locks(stp->st_stid.sc_file, lo)) {
	spin_unlock(&clp->cl_lock);		spin_unlock(&clp->cl_lock);
	@@ -5829,10 +5821,6 @@ static int nfs4_state_create_net(struct net *net)
	CLIENT_HASH_SIZE, GFP_KERNEL);		CLIENT_HASH_SIZE, GFP_KERNEL);
	if (!nn->unconf_id_hashtbl)		if (!nn->unconf_id_hashtbl)
	goto err_unconf_id;		goto err_unconf_id;
	nn->ownerstr_hashtbl = kmalloc(sizeof(struct list_head) *
	OWNER_HASH_SIZE, GFP_KERNEL);
	if (!nn->ownerstr_hashtbl)
	goto err_ownerstr;
	nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) *		nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) *
	SESSION_HASH_SIZE, GFP_KERNEL);		SESSION_HASH_SIZE, GFP_KERNEL);
	if (!nn->sessionid_hashtbl)		if (!nn->sessionid_hashtbl)
	@@ -5842,8 +5830,6 @@ static int nfs4_state_create_net(struct net *net)
	INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);		INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);
	INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);		INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);
	}		}
	for (i = 0; i < OWNER_HASH_SIZE; i++)
	INIT_LIST_HEAD(&nn->ownerstr_hashtbl[i]);
	for (i = 0; i < SESSION_HASH_SIZE; i++)		for (i = 0; i < SESSION_HASH_SIZE; i++)
	INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);		INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
	nn->conf_name_tree = RB_ROOT;		nn->conf_name_tree = RB_ROOT;
	@@ -5859,8 +5845,6 @@ static int nfs4_state_create_net(struct net *net)
	return 0;		return 0;

	err_sessionid:		err_sessionid:
	kfree(nn->ownerstr_hashtbl);
	err_ownerstr:
	kfree(nn->unconf_id_hashtbl);		kfree(nn->unconf_id_hashtbl);
	err_unconf_id:		err_unconf_id:
	kfree(nn->conf_id_hashtbl);		kfree(nn->conf_id_hashtbl);
	@@ -5890,7 +5874,6 @@ nfs4_state_destroy_net(struct net *net)
	}		}

	kfree(nn->sessionid_hashtbl);		kfree(nn->sessionid_hashtbl);
	kfree(nn->ownerstr_hashtbl);
	kfree(nn->unconf_id_hashtbl);		kfree(nn->unconf_id_hashtbl);
	kfree(nn->conf_id_hashtbl);		kfree(nn->conf_id_hashtbl);
	put_net(net);		put_net(net);

fs/nfsd/state.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -235,6 +235,7 @@ struct nfsd4_sessionid {
	struct nfs4_client {		struct nfs4_client {
	struct list_head cl_idhash; /* hash by cl_clientid.id */		struct list_head cl_idhash; /* hash by cl_clientid.id */
	struct rb_node cl_namenode; /* link into by-name trees */		struct rb_node cl_namenode; /* link into by-name trees */
			struct list_head *cl_ownerstr_hashtbl;
	struct list_head cl_openowners;		struct list_head cl_openowners;
	struct idr cl_stateids; /* stateid lookup */		struct idr cl_stateids; /* stateid lookup */
	struct list_head cl_delegations;		struct list_head cl_delegations;