Commit 24d292b8 authored by Chuck Lever's avatar Chuck Lever Committed by Trond Myklebust
Browse files

NFS: Move cl_state_owners and related fields to the nfs_server struct 



NFSv4 migration needs to reassociate state owners from the source to
the destination nfs_server data structures.  To make that easier, move
the cl_state_owners field to the nfs_server struct.  cl_openowner_id
and cl_lockowner_id accompany this move, as they are used in
conjunction with cl_state_owners.

The cl_lock field in the parent nfs_client continues to protect all
three of these fields.

Signed-off-by: default avatarChuck Lever <chuck.lever@oracle.com>
Signed-off-by: default avatarTrond Myklebust <Trond.Myklebust@netapp.com>
parent fca5238e

fs/nfs/nfs4_fs.h

+1 −1
Original line number Diff line number Diff line
@@ -110,7 +110,7 @@ struct nfs_unique_id { 
struct nfs4_state_owner {

	struct nfs_unique_id so_owner_id;

	struct nfs_server    *so_server;

	struct rb_node	     so_client_node;

	struct rb_node	     so_server_node;



	struct rpc_cred	     *so_cred;	 /* Associated cred */

fs/nfs/nfs4state.c

+180 −71
Original line number Diff line number Diff line
@@ -105,14 +105,17 @@ static void nfs4_clear_machine_cred(struct nfs_client *clp) 
		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 rb_node *pos;

	struct rpc_cred *cred = NULL;



	for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {

		sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);

	for (pos = rb_first(&server->state_owners);

	     pos != NULL;

	     pos = rb_next(pos)) {

		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);

		if (list_empty(&sp->so_states))

			continue;

		cred = get_rpccred(sp->so_cred);
@@ -121,6 +124,28 @@ struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp) 
	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)



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 */



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 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;



	spin_lock(&clp->cl_lock);

	cred = nfs4_get_machine_cred_locked(clp);

	spin_unlock(&clp->cl_lock);

	if (cred != NULL)

		goto out;

	pos = rb_first(&clp->cl_state_owners);

	if (pos != NULL) {

		sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);

		cred = get_rpccred(sp->so_cred);



	rcu_read_lock();

	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

		cred = nfs4_get_setclientid_cred_server(server);

		if (cred != NULL)

			break;

	}

	rcu_read_unlock();



out:

	spin_unlock(&clp->cl_lock);

	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)

{

	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 *

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 = &clp->cl_state_owners.rb_node,

	struct rb_node **p = &server->state_owners.rb_node,

		       *parent = NULL;

	struct nfs4_state_owner *sp, *res = NULL;



	while (*p != NULL) {

		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) {

			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 *

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;

	struct nfs4_state_owner *sp;



	while (*p != NULL) {

		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)

			p = &parent->rb_left;

		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;

		}

	}

	nfs_alloc_unique_id(&clp->cl_openowner_id, &new->so_owner_id, 1, 64);

	rb_link_node(&new->so_client_node, parent, p);

	rb_insert_color(&new->so_client_node, &clp->cl_state_owners);

	nfs_alloc_unique_id_locked(&server->openowner_id,

					&new->so_owner_id, 1, 64);

	rb_link_node(&new->so_server_node, parent, p);

	rb_insert_color(&new->so_server_node, &server->state_owners);

	return new;

}



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))

		rb_erase(&sp->so_client_node, &clp->cl_state_owners);

	nfs_free_unique_id(&clp->cl_openowner_id, &sp->so_owner_id);

	struct nfs_server *server = sp->so_server;



	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

nfs4_drop_state_owner(struct nfs4_state_owner *sp)

{

	if (!RB_EMPTY_NODE(&sp->so_client_node)) {

		struct nfs_client *clp = sp->so_server->nfs_client;

	if (!RB_EMPTY_NODE(&sp->so_server_node)) {

		struct nfs_server *server = sp->so_server;

		struct nfs_client *clp = server->nfs_client;



		spin_lock(&clp->cl_lock);

		rb_erase(&sp->so_client_node, &clp->cl_state_owners);

		RB_CLEAR_NODE(&sp->so_client_node);

		rb_erase(&sp->so_server_node, &server->state_owners);

		RB_CLEAR_NODE(&sp->so_server_node);

		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 nfs4_state_owner *sp, *new;



	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);

	if (sp != NULL)

		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_cred = cred;

	spin_lock(&clp->cl_lock);

	sp = nfs4_insert_state_owner(clp, new);

	sp = nfs4_insert_state_owner_locked(new);

	spin_unlock(&clp->cl_lock);

	if (sp == new)

		get_rpccred(cred);
@@ -444,6 +501,11 @@ struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server, struct 
	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)

{

	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))

		return;

	nfs4_remove_state_owner(clp, sp);

	nfs4_remove_state_owner_locked(sp);

	spin_unlock(&clp->cl_lock);

	rpc_destroy_wait_queue(&sp->so_sequence.wait);

	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)

{

	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);

	if (lsp == NULL)
@@ -681,7 +744,7 @@ static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, f 
		return NULL;

	}

	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);

	INIT_LIST_HEAD(&lsp->ls_locks);

	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)

{

	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);

	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);

	rpc_destroy_wait_queue(&lsp->ls_sequence.wait);

	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 rb_node *pos;

	struct nfs4_state *state;



	/* Reset all sequence ids to zero */

	for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {

		sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);

	spin_lock(&clp->cl_lock);

	for (pos = rb_first(&server->state_owners);

	     pos != NULL;

	     pos = rb_next(pos)) {

		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);

		sp->so_seqid.flags = 0;

		spin_lock(&sp->so_lock);

		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(&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)
@@ -1172,25 +1252,41 @@ static void nfs4_reclaim_complete(struct nfs_client *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 rb_node *pos;

	struct nfs4_state *state;



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

		return 0;



	for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {

		sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);

	spin_lock(&clp->cl_lock);

	for (pos = rb_first(&server->state_owners);

	     pos != NULL;

	     pos = rb_next(pos)) {

		sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);

		spin_lock(&sp->so_lock);

		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;

			nfs4_state_mark_reclaim_nograce(clp, state);

		}

		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);

	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)

{

	struct nfs4_state_owner *sp;

	struct nfs_server *server;

	struct rb_node *pos;

	int status = 0;



restart:

	rcu_read_lock();

	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

		spin_lock(&clp->cl_lock);

	for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {

		struct nfs4_state_owner *sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);

		if (!test_and_clear_bit(ops->owner_flag_bit, &sp->so_flags))

		for (pos = rb_first(&server->state_owners);

		     pos != NULL;

		     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;

			atomic_inc(&sp->so_count);

			spin_unlock(&clp->cl_lock);

			rcu_read_unlock();



			status = nfs4_reclaim_open_state(sp, ops);

			if (status < 0) {

				set_bit(ops->owner_flag_bit, &sp->so_flags);

				nfs4_put_state_owner(sp);

				return nfs4_recovery_handle_error(clp, status);

			}



			nfs4_put_state_owner(sp);

			goto restart;

		}

		spin_unlock(&clp->cl_lock);

	}

	rcu_read_unlock();

	return status;

}

include/linux/nfs_fs_sb.h

+5 −4
Original line number Diff line number Diff line
@@ -47,11 +47,7 @@ struct nfs_client { 
	u64			cl_clientid;	/* constant */

	unsigned long		cl_state;



	struct rb_root		cl_openowner_id;

	struct rb_root		cl_lockowner_id;



	struct list_head	cl_delegations;

	struct rb_root		cl_state_owners;

	spinlock_t		cl_lock;



	unsigned long		cl_lease_time;
@@ -150,6 +146,11 @@ struct nfs_server { 
						   filesystem */

	struct pnfs_layoutdriver_type  *pnfs_curr_ld; /* Active layout driver */

	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

	void (*destroy)(struct nfs_server *);

CRA Git | Maintained and supported by SUSTech CRA and CCSE