NFS: Move cl_state_owners and related fields to the nfs_server struct (24d292b8) · Commits · e / devices / android_kernel_xiaomi_markw

fs/nfs/nfs4_fs.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -110,7 +110,7 @@ struct nfs_unique_id {
	struct nfs4_state_owner {		struct nfs4_state_owner {
	struct nfs_unique_id so_owner_id;		struct nfs_unique_id so_owner_id;
	struct nfs_server *so_server;		struct nfs_server *so_server;
	struct rb_node so_client_node;		struct rb_node so_server_node;

	struct rpc_cred so_cred; / Associated cred */		struct rpc_cred so_cred; / Associated cred */

fs/nfs/nfs4state.c

+180 −71

Original line number	Original line	Diff line number	Diff line
	@@ -105,14 +105,17 @@ static void nfs4_clear_machine_cred(struct nfs_client *clp)
	put_rpccred(cred);		put_rpccred(cred);
	}		}

	struct rpc_cred nfs4_get_renew_cred_locked(struct nfs_client clp)		static struct rpc_cred *
			nfs4_get_renew_cred_server_locked(struct nfs_server *server)
	{		{
			struct rpc_cred *cred = NULL;
	struct nfs4_state_owner *sp;		struct nfs4_state_owner *sp;
	struct rb_node *pos;		struct rb_node *pos;
	struct rpc_cred *cred = NULL;

	for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {		for (pos = rb_first(&server->state_owners);
	sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);		pos != NULL;
			pos = rb_next(pos)) {
			sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
	if (list_empty(&sp->so_states))		if (list_empty(&sp->so_states))
	continue;		continue;
	cred = get_rpccred(sp->so_cred);		cred = get_rpccred(sp->so_cred);
	@@ -121,6 +124,28 @@ struct rpc_cred nfs4_get_renew_cred_locked(struct nfs_client clp)
	return cred;		return cred;
	}		}

			/**
			* nfs4_get_renew_cred_locked - Acquire credential for a renew operation
			* @clp: client state handle
			*
			* Returns an rpc_cred with reference count bumped, or NULL.
			* Caller must hold clp->cl_lock.
			*/
			struct rpc_cred nfs4_get_renew_cred_locked(struct nfs_client clp)
			{
			struct rpc_cred *cred = NULL;
			struct nfs_server *server;

			rcu_read_lock();
			list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
			cred = nfs4_get_renew_cred_server_locked(server);
			if (cred != NULL)
			break;
			}
			rcu_read_unlock();
			return cred;
			}

	#if defined(CONFIG_NFS_V4_1)		#if defined(CONFIG_NFS_V4_1)

	static int nfs41_setup_state_renewal(struct nfs_client *clp)		static int nfs41_setup_state_renewal(struct nfs_client *clp)
	@@ -231,27 +256,55 @@ struct rpc_cred nfs4_get_exchange_id_cred(struct nfs_client clp)

	#endif /* CONFIG_NFS_V4_1 */		#endif /* CONFIG_NFS_V4_1 */

	struct rpc_cred nfs4_get_setclientid_cred(struct nfs_client clp)		static struct rpc_cred *
			nfs4_get_setclientid_cred_server(struct nfs_server *server)
	{		{
			struct nfs_client *clp = server->nfs_client;
			struct rpc_cred *cred = NULL;
	struct nfs4_state_owner *sp;		struct nfs4_state_owner *sp;
	struct rb_node *pos;		struct rb_node *pos;

			spin_lock(&clp->cl_lock);
			pos = rb_first(&server->state_owners);
			if (pos != NULL) {
			sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
			cred = get_rpccred(sp->so_cred);
			}
			spin_unlock(&clp->cl_lock);
			return cred;
			}

			/**
			* nfs4_get_setclientid_cred - Acquire credential for a setclientid operation
			* @clp: client state handle
			*
			* Returns an rpc_cred with reference count bumped, or NULL.
			*/
			struct rpc_cred nfs4_get_setclientid_cred(struct nfs_client clp)
			{
			struct nfs_server *server;
	struct rpc_cred *cred;		struct rpc_cred *cred;

	spin_lock(&clp->cl_lock);		spin_lock(&clp->cl_lock);
	cred = nfs4_get_machine_cred_locked(clp);		cred = nfs4_get_machine_cred_locked(clp);
			spin_unlock(&clp->cl_lock);
	if (cred != NULL)		if (cred != NULL)
	goto out;		goto out;
	pos = rb_first(&clp->cl_state_owners);
	if (pos != NULL) {		rcu_read_lock();
	sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);		list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
	cred = get_rpccred(sp->so_cred);		cred = nfs4_get_setclientid_cred_server(server);
			if (cred != NULL)
			break;
	}		}
			rcu_read_unlock();

	out:		out:
	spin_unlock(&clp->cl_lock);
	return cred;		return cred;
	}		}

	static void nfs_alloc_unique_id(struct rb_root root, struct nfs_unique_id new,		static void nfs_alloc_unique_id_locked(struct rb_root *root,
			struct nfs_unique_id *new,
	__u64 minval, int maxbits)		__u64 minval, int maxbits)
	{		{
	struct rb_node *p, parent;		struct rb_node *p, parent;
	@@ -307,16 +360,15 @@ static void nfs_free_unique_id(struct rb_root root, struct nfs_unique_id id)
	}		}

	static struct nfs4_state_owner *		static struct nfs4_state_owner *
	nfs4_find_state_owner(struct nfs_server server, struct rpc_cred cred)		nfs4_find_state_owner_locked(struct nfs_server server, struct rpc_cred cred)
	{		{
	struct nfs_client *clp = server->nfs_client;		struct rb_node **p = &server->state_owners.rb_node,
	struct rb_node **p = &clp->cl_state_owners.rb_node,
	*parent = NULL;		*parent = NULL;
	struct nfs4_state_owner sp, res = NULL;		struct nfs4_state_owner sp, res = NULL;

	while (*p != NULL) {		while (*p != NULL) {
	parent = *p;		parent = *p;
	sp = rb_entry(parent, struct nfs4_state_owner, so_client_node);		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);

	if (server < sp->so_server) {		if (server < sp->so_server) {
	p = &parent->rb_left;		p = &parent->rb_left;
	@@ -340,24 +392,17 @@ nfs4_find_state_owner(struct nfs_server server, struct rpc_cred cred)
	}		}

	static struct nfs4_state_owner *		static struct nfs4_state_owner *
	nfs4_insert_state_owner(struct nfs_client clp, struct nfs4_state_owner new)		nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
	{		{
	struct rb_node **p = &clp->cl_state_owners.rb_node,		struct nfs_server *server = new->so_server;
			struct rb_node **p = &server->state_owners.rb_node,
	*parent = NULL;		*parent = NULL;
	struct nfs4_state_owner *sp;		struct nfs4_state_owner *sp;

	while (*p != NULL) {		while (*p != NULL) {
	parent = *p;		parent = *p;
	sp = rb_entry(parent, struct nfs4_state_owner, so_client_node);		sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);

	if (new->so_server < sp->so_server) {
	p = &parent->rb_left;
	continue;
	}
	if (new->so_server > sp->so_server) {
	p = &parent->rb_right;
	continue;
	}
	if (new->so_cred < sp->so_cred)		if (new->so_cred < sp->so_cred)
	p = &parent->rb_left;		p = &parent->rb_left;
	else if (new->so_cred > sp->so_cred)		else if (new->so_cred > sp->so_cred)
	@@ -367,18 +412,21 @@ nfs4_insert_state_owner(struct nfs_client clp, struct nfs4_state_owner new)
	return sp;		return sp;
	}		}
	}		}
	nfs_alloc_unique_id(&clp->cl_openowner_id, &new->so_owner_id, 1, 64);		nfs_alloc_unique_id_locked(&server->openowner_id,
	rb_link_node(&new->so_client_node, parent, p);		&new->so_owner_id, 1, 64);
	rb_insert_color(&new->so_client_node, &clp->cl_state_owners);		rb_link_node(&new->so_server_node, parent, p);
			rb_insert_color(&new->so_server_node, &server->state_owners);
	return new;		return new;
	}		}

	static void		static void
	nfs4_remove_state_owner(struct nfs_client clp, struct nfs4_state_owner sp)		nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
	{		{
	if (!RB_EMPTY_NODE(&sp->so_client_node))		struct nfs_server *server = sp->so_server;
	rb_erase(&sp->so_client_node, &clp->cl_state_owners);
	nfs_free_unique_id(&clp->cl_openowner_id, &sp->so_owner_id);		if (!RB_EMPTY_NODE(&sp->so_server_node))
			rb_erase(&sp->so_server_node, &server->state_owners);
			nfs_free_unique_id(&server->openowner_id, &sp->so_owner_id);
	}		}

	/*		/*
	@@ -407,23 +455,32 @@ nfs4_alloc_state_owner(void)
	static void		static void
	nfs4_drop_state_owner(struct nfs4_state_owner *sp)		nfs4_drop_state_owner(struct nfs4_state_owner *sp)
	{		{
	if (!RB_EMPTY_NODE(&sp->so_client_node)) {		if (!RB_EMPTY_NODE(&sp->so_server_node)) {
	struct nfs_client *clp = sp->so_server->nfs_client;		struct nfs_server *server = sp->so_server;
			struct nfs_client *clp = server->nfs_client;

	spin_lock(&clp->cl_lock);		spin_lock(&clp->cl_lock);
	rb_erase(&sp->so_client_node, &clp->cl_state_owners);		rb_erase(&sp->so_server_node, &server->state_owners);
	RB_CLEAR_NODE(&sp->so_client_node);		RB_CLEAR_NODE(&sp->so_server_node);
	spin_unlock(&clp->cl_lock);		spin_unlock(&clp->cl_lock);
	}		}
	}		}

	struct nfs4_state_owner nfs4_get_state_owner(struct nfs_server server, struct rpc_cred *cred)		/**
			* nfs4_get_state_owner - Look up a state owner given a credential
			* @server: nfs_server to search
			* @cred: RPC credential to match
			*
			* Returns a pointer to an instantiated nfs4_state_owner struct, or NULL.
			*/
			struct nfs4_state_owner nfs4_get_state_owner(struct nfs_server server,
			struct rpc_cred *cred)
	{		{
	struct nfs_client *clp = server->nfs_client;		struct nfs_client *clp = server->nfs_client;
	struct nfs4_state_owner sp, new;		struct nfs4_state_owner sp, new;

	spin_lock(&clp->cl_lock);		spin_lock(&clp->cl_lock);
	sp = nfs4_find_state_owner(server, cred);		sp = nfs4_find_state_owner_locked(server, cred);
	spin_unlock(&clp->cl_lock);		spin_unlock(&clp->cl_lock);
	if (sp != NULL)		if (sp != NULL)
	return sp;		return sp;
	@@ -433,7 +490,7 @@ struct nfs4_state_owner nfs4_get_state_owner(struct nfs_server server, struct
	new->so_server = server;		new->so_server = server;
	new->so_cred = cred;		new->so_cred = cred;
	spin_lock(&clp->cl_lock);		spin_lock(&clp->cl_lock);
	sp = nfs4_insert_state_owner(clp, new);		sp = nfs4_insert_state_owner_locked(new);
	spin_unlock(&clp->cl_lock);		spin_unlock(&clp->cl_lock);
	if (sp == new)		if (sp == new)
	get_rpccred(cred);		get_rpccred(cred);
	@@ -444,6 +501,11 @@ struct nfs4_state_owner nfs4_get_state_owner(struct nfs_server server, struct
	return sp;		return sp;
	}		}

			/**
			* nfs4_put_state_owner - Release a nfs4_state_owner
			* @sp: state owner data to release
			*
			*/
	void nfs4_put_state_owner(struct nfs4_state_owner *sp)		void nfs4_put_state_owner(struct nfs4_state_owner *sp)
	{		{
	struct nfs_client *clp = sp->so_server->nfs_client;		struct nfs_client *clp = sp->so_server->nfs_client;
	@@ -451,7 +513,7 @@ void nfs4_put_state_owner(struct nfs4_state_owner *sp)

	if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))		if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
	return;		return;
	nfs4_remove_state_owner(clp, sp);		nfs4_remove_state_owner_locked(sp);
	spin_unlock(&clp->cl_lock);		spin_unlock(&clp->cl_lock);
	rpc_destroy_wait_queue(&sp->so_sequence.wait);		rpc_destroy_wait_queue(&sp->so_sequence.wait);
	put_rpccred(cred);		put_rpccred(cred);
	@@ -657,7 +719,8 @@ __nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_p
	static struct nfs4_lock_state nfs4_alloc_lock_state(struct nfs4_state state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type)		static struct nfs4_lock_state nfs4_alloc_lock_state(struct nfs4_state state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type)
	{		{
	struct nfs4_lock_state *lsp;		struct nfs4_lock_state *lsp;
	struct nfs_client *clp = state->owner->so_server->nfs_client;		struct nfs_server *server = state->owner->so_server;
			struct nfs_client *clp = server->nfs_client;

	lsp = kzalloc(sizeof(*lsp), GFP_NOFS);		lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
	if (lsp == NULL)		if (lsp == NULL)
	@@ -681,7 +744,7 @@ static struct nfs4_lock_state nfs4_alloc_lock_state(struct nfs4_state state, f
	return NULL;		return NULL;
	}		}
	spin_lock(&clp->cl_lock);		spin_lock(&clp->cl_lock);
	nfs_alloc_unique_id(&clp->cl_lockowner_id, &lsp->ls_id, 1, 64);		nfs_alloc_unique_id_locked(&server->lockowner_id, &lsp->ls_id, 1, 64);
	spin_unlock(&clp->cl_lock);		spin_unlock(&clp->cl_lock);
	INIT_LIST_HEAD(&lsp->ls_locks);		INIT_LIST_HEAD(&lsp->ls_locks);
	return lsp;		return lsp;
	@@ -689,10 +752,11 @@ static struct nfs4_lock_state nfs4_alloc_lock_state(struct nfs4_state state, f

	static void nfs4_free_lock_state(struct nfs4_lock_state *lsp)		static void nfs4_free_lock_state(struct nfs4_lock_state *lsp)
	{		{
	struct nfs_client *clp = lsp->ls_state->owner->so_server->nfs_client;		struct nfs_server *server = lsp->ls_state->owner->so_server;
			struct nfs_client *clp = server->nfs_client;

	spin_lock(&clp->cl_lock);		spin_lock(&clp->cl_lock);
	nfs_free_unique_id(&clp->cl_lockowner_id, &lsp->ls_id);		nfs_free_unique_id(&server->lockowner_id, &lsp->ls_id);
	spin_unlock(&clp->cl_lock);		spin_unlock(&clp->cl_lock);
	rpc_destroy_wait_queue(&lsp->ls_sequence.wait);		rpc_destroy_wait_queue(&lsp->ls_sequence.wait);
	kfree(lsp);		kfree(lsp);
	@@ -1138,15 +1202,19 @@ static void nfs4_clear_open_state(struct nfs4_state *state)
	}		}
	}		}

	static void nfs4_state_mark_reclaim_helper(struct nfs_client clp, int (mark_reclaim)(struct nfs_client clp, struct nfs4_state state))		static void nfs4_reset_seqids(struct nfs_server *server,
			int (mark_reclaim)(struct nfs_client clp, struct nfs4_state *state))
	{		{
			struct nfs_client *clp = server->nfs_client;
	struct nfs4_state_owner *sp;		struct nfs4_state_owner *sp;
	struct rb_node *pos;		struct rb_node *pos;
	struct nfs4_state *state;		struct nfs4_state *state;

	/* Reset all sequence ids to zero */		spin_lock(&clp->cl_lock);
	for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {		for (pos = rb_first(&server->state_owners);
	sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);		pos != NULL;
			pos = rb_next(pos)) {
			sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
	sp->so_seqid.flags = 0;		sp->so_seqid.flags = 0;
	spin_lock(&sp->so_lock);		spin_lock(&sp->so_lock);
	list_for_each_entry(state, &sp->so_states, open_states) {		list_for_each_entry(state, &sp->so_states, open_states) {
	@@ -1155,6 +1223,18 @@ static void nfs4_state_mark_reclaim_helper(struct nfs_client clp, int (mark_re
	}		}
	spin_unlock(&sp->so_lock);		spin_unlock(&sp->so_lock);
	}		}
			spin_unlock(&clp->cl_lock);
			}

			static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
			int (mark_reclaim)(struct nfs_client clp, struct nfs4_state *state))
			{
			struct nfs_server *server;

			rcu_read_lock();
			list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
			nfs4_reset_seqids(server, mark_reclaim);
			rcu_read_unlock();
	}		}

	static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)		static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
	@@ -1172,25 +1252,41 @@ static void nfs4_reclaim_complete(struct nfs_client *clp,
	(void)ops->reclaim_complete(clp);		(void)ops->reclaim_complete(clp);
	}		}

	static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)		static void nfs4_clear_reclaim_server(struct nfs_server *server)
	{		{
			struct nfs_client *clp = server->nfs_client;
	struct nfs4_state_owner *sp;		struct nfs4_state_owner *sp;
	struct rb_node *pos;		struct rb_node *pos;
	struct nfs4_state *state;		struct nfs4_state *state;

	if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))		spin_lock(&clp->cl_lock);
	return 0;		for (pos = rb_first(&server->state_owners);
			pos != NULL;
	for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {		pos = rb_next(pos)) {
	sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
	spin_lock(&sp->so_lock);		spin_lock(&sp->so_lock);
	list_for_each_entry(state, &sp->so_states, open_states) {		list_for_each_entry(state, &sp->so_states, open_states) {
	if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags))		if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
			&state->flags))
	continue;		continue;
	nfs4_state_mark_reclaim_nograce(clp, state);		nfs4_state_mark_reclaim_nograce(clp, state);
	}		}
	spin_unlock(&sp->so_lock);		spin_unlock(&sp->so_lock);
	}		}
			spin_unlock(&clp->cl_lock);
			}

			static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
			{
			struct nfs_server *server;

			if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
			return 0;

			rcu_read_lock();
			list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
			nfs4_clear_reclaim_server(server);
			rcu_read_unlock();

	nfs_delegation_reap_unclaimed(clp);		nfs_delegation_reap_unclaimed(clp);
	return 1;		return 1;
	@@ -1262,27 +1358,40 @@ static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)

	static int nfs4_do_reclaim(struct nfs_client clp, const struct nfs4_state_recovery_ops ops)		static int nfs4_do_reclaim(struct nfs_client clp, const struct nfs4_state_recovery_ops ops)
	{		{
			struct nfs4_state_owner *sp;
			struct nfs_server *server;
	struct rb_node *pos;		struct rb_node *pos;
	int status = 0;		int status = 0;

	restart:		restart:
			rcu_read_lock();
			list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
	spin_lock(&clp->cl_lock);		spin_lock(&clp->cl_lock);
	for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {		for (pos = rb_first(&server->state_owners);
	struct nfs4_state_owner *sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);		pos != NULL;
	if (!test_and_clear_bit(ops->owner_flag_bit, &sp->so_flags))		pos = rb_next(pos)) {
			sp = rb_entry(pos,
			struct nfs4_state_owner, so_server_node);
			if (!test_and_clear_bit(ops->owner_flag_bit,
			&sp->so_flags))
	continue;		continue;
	atomic_inc(&sp->so_count);		atomic_inc(&sp->so_count);
	spin_unlock(&clp->cl_lock);		spin_unlock(&clp->cl_lock);
			rcu_read_unlock();

	status = nfs4_reclaim_open_state(sp, ops);		status = nfs4_reclaim_open_state(sp, ops);
	if (status < 0) {		if (status < 0) {
	set_bit(ops->owner_flag_bit, &sp->so_flags);		set_bit(ops->owner_flag_bit, &sp->so_flags);
	nfs4_put_state_owner(sp);		nfs4_put_state_owner(sp);
	return nfs4_recovery_handle_error(clp, status);		return nfs4_recovery_handle_error(clp, status);
	}		}

	nfs4_put_state_owner(sp);		nfs4_put_state_owner(sp);
	goto restart;		goto restart;
	}		}
	spin_unlock(&clp->cl_lock);		spin_unlock(&clp->cl_lock);
			}
			rcu_read_unlock();
	return status;		return status;
	}		}

include/linux/nfs_fs_sb.h

+5 −4

Original line number	Original line	Diff line number	Diff line
	@@ -47,11 +47,7 @@ struct nfs_client {
	u64 cl_clientid; /* constant */		u64 cl_clientid; /* constant */
	unsigned long cl_state;		unsigned long cl_state;

	struct rb_root cl_openowner_id;
	struct rb_root cl_lockowner_id;

	struct list_head cl_delegations;		struct list_head cl_delegations;
	struct rb_root cl_state_owners;
	spinlock_t cl_lock;		spinlock_t cl_lock;

	unsigned long cl_lease_time;		unsigned long cl_lease_time;
	@@ -150,6 +146,11 @@ struct nfs_server {
	filesystem */		filesystem */
	struct pnfs_layoutdriver_type pnfs_curr_ld; / Active layout driver */		struct pnfs_layoutdriver_type pnfs_curr_ld; / Active layout driver */
	struct rpc_wait_queue roc_rpcwaitq;		struct rpc_wait_queue roc_rpcwaitq;

			/* the following fields are protected by nfs_client->cl_lock */
			struct rb_root state_owners;
			struct rb_root openowner_id;
			struct rb_root lockowner_id;
	#endif		#endif
	void (destroy)(struct nfs_server );		void (destroy)(struct nfs_server );