From d4f0489f38512027fdf5190d5d1d8007e155e88f Mon Sep 17 00:00:00 2001 From: Trond Myklebust Date: Tue, 29 Jul 2014 21:34:36 -0400 Subject: nfsd: Move the open owner hash table into struct nfs4_client Preparation for removing the client_mutex. Convert the open owner hash table into a per-client table and protect it using the nfs4_client->cl_lock spin lock. Signed-off-by: Trond Myklebust Signed-off-by: J. Bruce Fields --- fs/nfsd/nfs4state.c | 187 ++++++++++++++++++++++++---------------------------- 1 file changed, 85 insertions(+), 102 deletions(-) (limited to 'fs/nfsd/nfs4state.c') diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c index 7c15918d20f0..4af4e5eff491 100644 --- a/fs/nfsd/nfs4state.c +++ b/fs/nfsd/nfs4state.c @@ -240,35 +240,27 @@ static void nfsd4_put_session(struct nfsd4_session *ses) } static int -same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner, - clientid_t *clid) +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) && - (sop->so_client->cl_clientid.cl_id == clid->cl_id); + 0 == memcmp(sop->so_owner.data, owner->data, owner->len); } static struct nfs4_openowner * 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_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) continue; - if (same_owner_str(so, &open->op_owner, &open->op_clientid)) { - oo = openowner(so); - clp = oo->oo_owner.so_client; - if ((bool)clp->cl_minorversion != sessions) - break; - renew_client_locked(clp); + if (same_owner_str(so, &open->op_owner)) { atomic_inc(&so->so_count); - return oo; + return openowner(so); } } return NULL; @@ -276,17 +268,16 @@ find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open, static struct nfs4_openowner * find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open, - bool sessions, struct nfsd_net *nn) + struct nfs4_client *clp) { struct nfs4_openowner *oo; - spin_lock(&nn->client_lock); - oo = find_openstateowner_str_locked(hashval, open, sessions, nn); - spin_unlock(&nn->client_lock); + spin_lock(&clp->cl_lock); + oo = find_openstateowner_str_locked(hashval, open, clp); + spin_unlock(&clp->cl_lock); return oo; } - static inline u32 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_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; ret = opaque_hashval(ownername->data, ownername->len); - ret += clientid; 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) { - struct nfsd_net *nn = net_generic(lo->lo_owner.so_client->net, - nfsd_net_id); + struct nfs4_client *clp = lo->lo_owner.so_client; - lockdep_assert_held(&nn->client_lock); + lockdep_assert_held(&clp->cl_lock); list_del_init(&lo->lo_owner.so_strhash); } static void release_lockowner_stateids(struct nfs4_lockowner *lo) { - struct nfsd_net *nn = net_generic(lo->lo_owner.so_client->net, - nfsd_net_id); + struct nfs4_client *clp = lo->lo_owner.so_client; 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)) { stp = list_first_entry(&lo->lo_owner.so_stateids, struct nfs4_ol_stateid, st_perstateowner); - spin_unlock(&nn->client_lock); + spin_unlock(&clp->cl_lock); release_lock_stateid(stp); - spin_lock(&nn->client_lock); + spin_lock(&clp->cl_lock); } } static void release_lockowner(struct nfs4_lockowner *lo) { - struct nfsd_net *nn = net_generic(lo->lo_owner.so_client->net, - nfsd_net_id); + struct nfs4_client *clp = lo->lo_owner.so_client; - spin_lock(&nn->client_lock); + spin_lock(&clp->cl_lock); unhash_lockowner_locked(lo); release_lockowner_stateids(lo); - spin_unlock(&nn->client_lock); + spin_unlock(&clp->cl_lock); 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) { - struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net, - nfsd_net_id); + struct nfs4_client *clp = oo->oo_owner.so_client; - 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_perclient); @@ -1093,29 +1079,27 @@ static void release_last_closed_stateid(struct nfs4_openowner *oo) static void release_openowner_stateids(struct nfs4_openowner *oo) { struct nfs4_ol_stateid *stp; - struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net, - nfsd_net_id); + struct nfs4_client *clp = oo->oo_owner.so_client; - lockdep_assert_held(&nn->client_lock); + lockdep_assert_held(&clp->cl_lock); while (!list_empty(&oo->oo_owner.so_stateids)) { stp = list_first_entry(&oo->oo_owner.so_stateids, struct nfs4_ol_stateid, st_perstateowner); - spin_unlock(&nn->client_lock); + spin_unlock(&clp->cl_lock); release_open_stateid(stp); - spin_lock(&nn->client_lock); + spin_lock(&clp->cl_lock); } } static void release_openowner(struct nfs4_openowner *oo) { - struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net, - nfsd_net_id); + struct nfs4_client *clp = oo->oo_owner.so_client; - spin_lock(&nn->client_lock); + spin_lock(&clp->cl_lock); unhash_openowner_locked(oo); release_openowner_stateids(oo); - spin_unlock(&nn->client_lock); + spin_unlock(&clp->cl_lock); release_last_closed_stateid(oo); 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) { 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) { - kfree(clp); - return NULL; - } + 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); @@ -1520,6 +1509,11 @@ static struct nfs4_client *alloc_client(struct xdr_netobj name) 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; } static void @@ -1538,6 +1532,7 @@ free_client(struct nfs4_client *clp) } 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); @@ -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) { - 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); } static void nfs4_unhash_openowner(struct nfs4_stateowner *so) { - struct nfs4_openowner *oo = openowner(so); - struct nfsd_net *nn = net_generic(so->so_client->net, nfsd_net_id); + struct nfs4_client *clp = so->so_client; - spin_lock(&nn->client_lock); - unhash_openowner_locked(oo); - spin_unlock(&nn->client_lock); + spin_lock(&clp->cl_lock); + unhash_openowner_locked(openowner(so)); + spin_unlock(&clp->cl_lock); } 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 nfs4_client *clp = cstate->clp; - struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); struct nfs4_openowner *oo, *ret; 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_last_closed_stid = NULL; INIT_LIST_HEAD(&oo->oo_close_lru); - spin_lock(&nn->client_lock); - ret = find_openstateowner_str_locked(strhashval, - open, clp->cl_minorversion, nn); + spin_lock(&clp->cl_lock); + ret = find_openstateowner_str_locked(strhashval, open, clp); if (ret == NULL) { hash_openowner(oo, clp, strhashval); ret = oo; } else nfs4_free_openowner(&oo->oo_owner); - spin_unlock(&nn->client_lock); + spin_unlock(&clp->cl_lock); return oo; } @@ -3412,8 +3405,8 @@ nfsd4_process_open1(struct nfsd4_compound_state *cstate, return status; clp = cstate->clp; - strhashval = ownerstr_hashval(clientid->cl_id, &open->op_owner); - oo = find_openstateowner_str(strhashval, open, cstate->minorversion, nn); + strhashval = ownerstr_hashval(&open->op_owner); + oo = find_openstateowner_str(strhashval, open, clp); open->op_openowner = oo; if (!oo) { goto new_owner; @@ -4818,15 +4811,16 @@ nevermind: static struct nfs4_lockowner * 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; - 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) continue; - if (!same_owner_str(so, owner, clid)) + if (!same_owner_str(so, owner)) continue; atomic_inc(&so->so_count); return lockowner(so); @@ -4836,23 +4830,23 @@ find_lockowner_str_locked(clientid_t *clid, struct xdr_netobj *owner, static struct nfs4_lockowner * find_lockowner_str(clientid_t *clid, struct xdr_netobj *owner, - struct nfsd_net *nn) + struct nfs4_client *clp) { struct nfs4_lockowner *lo; - spin_lock(&nn->client_lock); - lo = find_lockowner_str_locked(clid, owner, nn); - spin_unlock(&nn->client_lock); + spin_lock(&clp->cl_lock); + lo = find_lockowner_str_locked(clid, owner, clp); + spin_unlock(&clp->cl_lock); return lo; } 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)); - spin_unlock(&nn->client_lock); + spin_unlock(&clp->cl_lock); } 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 nfsd4_lock *lock) { - struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); struct nfs4_lockowner *lo, *ret; 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_seqid = lock->lk_new_lock_seqid; 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, - &lock->lk_new_owner, nn); + &lock->lk_new_owner, clp); if (ret == NULL) { list_add(&lo->lo_owner.so_strhash, - &nn->ownerstr_hashtbl[strhashval]); + &clp->cl_ownerstr_hashtbl[strhashval]); ret = lo; } else nfs4_free_lockowner(&lo->lo_owner); - spin_unlock(&nn->client_lock); + spin_unlock(&clp->cl_lock); 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 nfs4_lockowner *lo; 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) { - strhashval = ownerstr_hashval(cl->cl_clientid.cl_id, - &lock->v.new.owner); + strhashval = ownerstr_hashval(&lock->v.new.owner); lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock); if (lo == NULL) return nfserr_jukebox; @@ -5293,7 +5284,8 @@ nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 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) file_lock->fl_owner = (fl_owner_t)lo; file_lock->fl_pid = current->tgid; @@ -5436,7 +5428,7 @@ nfsd4_release_lockowner(struct svc_rqst *rqstp, struct nfs4_lockowner *lo; struct nfs4_ol_stateid *stp; struct xdr_netobj *owner = &rlockowner->rl_owner; - unsigned int hashval = ownerstr_hashval(clid->cl_id, owner); + unsigned int hashval = ownerstr_hashval(owner); __be32 status; struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); struct nfs4_client *clp; @@ -5452,29 +5444,29 @@ nfsd4_release_lockowner(struct svc_rqst *rqstp, status = nfserr_locks_held; + clp = cstate->clp; /* Find the matching lock stateowner */ - spin_lock(&nn->client_lock); - list_for_each_entry(tmp, &nn->ownerstr_hashtbl[hashval], so_strhash) { + spin_lock(&clp->cl_lock); + list_for_each_entry(tmp, &clp->cl_ownerstr_hashtbl[hashval], + so_strhash) { if (tmp->so_is_open_owner) continue; - if (same_owner_str(tmp, owner, clid)) { + if (same_owner_str(tmp, owner)) { sop = tmp; atomic_inc(&sop->so_count); break; } } - spin_unlock(&nn->client_lock); /* No matching owner found, maybe a replay? Just declare victory... */ if (!sop) { + spin_unlock(&clp->cl_lock); status = nfs_ok; goto out; } lo = lockowner(sop); /* 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) { if (check_for_locks(stp->st_stid.sc_file, lo)) { spin_unlock(&clp->cl_lock); @@ -5829,10 +5821,6 @@ static int nfs4_state_create_net(struct net *net) CLIENT_HASH_SIZE, GFP_KERNEL); if (!nn->unconf_id_hashtbl) 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) * SESSION_HASH_SIZE, GFP_KERNEL); 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->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++) INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]); nn->conf_name_tree = RB_ROOT; @@ -5859,8 +5845,6 @@ static int nfs4_state_create_net(struct net *net) return 0; err_sessionid: - kfree(nn->ownerstr_hashtbl); -err_ownerstr: kfree(nn->unconf_id_hashtbl); err_unconf_id: kfree(nn->conf_id_hashtbl); @@ -5890,7 +5874,6 @@ nfs4_state_destroy_net(struct net *net) } kfree(nn->sessionid_hashtbl); - kfree(nn->ownerstr_hashtbl); kfree(nn->unconf_id_hashtbl); kfree(nn->conf_id_hashtbl); put_net(net); -- cgit v1.2.3