/**
* @brief Remove a state from the stateid table
*
* @param[in] other stateid4.other
*
* This really can't fail.
*/
void nfs4_State_Del(char other[OTHERSIZE])
{
struct gsh_buffdesc buffkey, old_key, old_value;
hash_error_t err;
buffkey.addr = other;
buffkey.len = OTHERSIZE;
err = HashTable_Del(ht_state_id, &buffkey, &old_key, &old_value);
if (err == HASHTABLE_SUCCESS) {
/* free the key that was stored in hash table */
LogFullDebug(COMPONENT_STATE, "Freeing stateid key %p",
old_key.addr);
gsh_free(old_key.addr);
/* State is managed in stuff alloc, no free is needed for
* old_value.addr
*/
} else {
LogCrit(COMPONENT_STATE,
"Failure to delete state %s",
hash_table_err_to_str(err));
}
}
void remove_nfs4_owner(cache_inode_client_t * pclient,
state_owner_t * powner,
const char * str)
{
hash_buffer_t buffkey, old_key, old_value;
state_nfs4_owner_name_t oname;
int rc;
oname.son_clientid = powner->so_owner.so_nfs4_owner.so_clientid;
oname.son_owner_len = powner->so_owner_len;
oname.son_islock = powner->so_type == STATE_LOCK_OWNER_NFSV4;
memcpy(oname.son_owner_val, powner->so_owner_val, powner->so_owner_len);
buffkey.pdata = (caddr_t) &oname;
buffkey.len = sizeof(*powner);
rc = HashTable_DelRef(ht_nfs4_owner,
&buffkey,
&old_key,
&old_value,
Hash_dec_state_owner_ref);
switch(rc)
{
case HASHTABLE_SUCCESS:
if(powner->so_type == STATE_LOCK_OWNER_NFSV4)
dec_state_owner_ref(powner->so_owner.so_nfs4_owner.so_related_owner, pclient);
/* Release the owner_name (key) and owner (data) back to appropriate pools */
LogFullDebug(COMPONENT_STATE, "Free %s", str);
nfs4_Compound_FreeOne(&powner->so_owner.so_nfs4_owner.so_resp);
ReleaseToPool(old_value.pdata, &pclient->pool_state_owner);
ReleaseToPool(old_key.pdata, &pclient->pool_nfs4_owner_name);
break;
case HASHTABLE_NOT_DELETED:
/* ref count didn't end up at 0, don't free. */
LogDebug(COMPONENT_STATE,
"HashTable_DelRef didn't reduce refcount to 0 for %s",
str);
break;
default:
/* some problem occurred */
LogDebug(COMPONENT_STATE,
"HashTable_DelRef failed (%s) for %s",
hash_table_err_to_str(rc), str);
break;
}
}
hash_error_t
hashtable_setlatched(struct hash_table *ht,
struct gsh_buffdesc *key,
struct gsh_buffdesc *val,
struct hash_latch *latch, int overwrite,
struct gsh_buffdesc *stored_key,
struct gsh_buffdesc *stored_val)
{
/* Stored error return */
hash_error_t rc = HASHTABLE_SUCCESS;
/* The pair of buffer descriptors locating both key and value
for this object, what actually gets stored. */
struct hash_data *descriptors = NULL;
/* Node giving the location to insert new node */
struct rbt_node *locator = NULL;
/* New node for the case of non-overwrite */
struct rbt_node *mutator = NULL;
if (isDebug(COMPONENT_HASHTABLE)
&& isFullDebug(ht->parameter.ht_log_component)) {
char dispkey[HASHTABLE_DISPLAY_STRLEN];
char dispval[HASHTABLE_DISPLAY_STRLEN];
if (ht->parameter.key_to_str != NULL)
ht->parameter.key_to_str(key, dispkey);
else
dispkey[0] = '\0';
if (ht->parameter.val_to_str != NULL)
ht->parameter.val_to_str(val, dispval);
else
dispval[0] = '\0';
LogFullDebug(ht->parameter.ht_log_component,
"Set %s Key=%p {%s} Value=%p {%s} index=%" PRIu32
" rbt_hash=%" PRIu64, ht->parameter.ht_name,
key->addr, dispkey, val->addr, dispval,
latch->index, latch->rbt_hash);
}
/* In the case of collision */
if (latch->locator) {
if (!overwrite) {
rc = HASHTABLE_ERROR_KEY_ALREADY_EXISTS;
goto out;
}
descriptors = RBT_OPAQ(latch->locator);
if (isDebug(COMPONENT_HASHTABLE)
&& isFullDebug(ht->parameter.ht_log_component)) {
char dispkey[HASHTABLE_DISPLAY_STRLEN];
char dispval[HASHTABLE_DISPLAY_STRLEN];
if (ht->parameter.key_to_str != NULL)
ht->parameter.key_to_str(&descriptors->key,
dispkey);
else
dispkey[0] = '\0';
if (ht->parameter.val_to_str != NULL)
ht->parameter.val_to_str(&descriptors->val,
dispval);
else
dispval[0] = '\0';
LogFullDebug(ht->parameter.ht_log_component,
"Set %s Key=%p {%s} Value=%p {%s} index=%"
PRIu32" rbt_hash=%"PRIu64" was replaced",
ht->parameter.ht_name,
descriptors->key.addr, dispkey,
descriptors->val.addr, dispval,
latch->index, latch->rbt_hash);
}
if (stored_key)
*stored_key = descriptors->key;
if (stored_val)
*stored_val = descriptors->val;
descriptors->key = *key;
descriptors->val = *val;
rc = HASHTABLE_OVERWRITTEN;
goto out;
}
/* We have no collision, so go about creating and inserting a new
node. */
RBT_FIND(&ht->partitions[latch->index].rbt, locator, latch->rbt_hash);
mutator = pool_alloc(ht->node_pool);
descriptors = pool_alloc(ht->data_pool);
RBT_OPAQ(mutator) = descriptors;
RBT_VALUE(mutator) = latch->rbt_hash;
RBT_INSERT(&ht->partitions[latch->index].rbt, mutator, locator);
descriptors->key.addr = key->addr;
descriptors->key.len = key->len;
descriptors->val.addr = val->addr;
descriptors->val.len = val->len;
/* Only in the non-overwrite case */
++ht->partitions[latch->index].count;
rc = HASHTABLE_SUCCESS;
out:
hashtable_releaselatched(ht, latch);
if (rc != HASHTABLE_SUCCESS && isDebug(COMPONENT_HASHTABLE)
&& isFullDebug(ht->parameter.ht_log_component))
LogFullDebug(ht->parameter.ht_log_component,
"Set %s returning failure %s",
ht->parameter.ht_name, hash_table_err_to_str(rc));
return rc;
}
/**
* @brief Look up an entry, latching the table
*
* This function looks up an entry in the hash table and latches the
* partition in which that entry would belong in preparation for other
* activities. This function is a primitive and is intended more for
* use building other access functions than for client code itself.
*
* @brief[in] ht The hash table to search
* @brief[in] key The key for which to search
* @brief[out] val The value found
* @brief[in] may_write This must be true if the followup call might
* mutate the hash table (set or delete)
* @brief[out] latch Opaque structure holding information on the
* table.
*
* @retval HASHTABLE_SUCCESS The entry was found, the table is
* latched.
* @retval HASHTABLE_ERROR_NOT_FOUND The entry was not found, the
* table is latched.
* @retval Others, failure, the table is not latched.
*/
hash_error_t
hashtable_getlatch(struct hash_table *ht,
const struct gsh_buffdesc *key,
struct gsh_buffdesc *val, bool may_write,
struct hash_latch *latch)
{
/* The index specifying the partition to search */
uint32_t index = 0;
/* The node found for the key */
struct rbt_node *locator = NULL;
/* The buffer descritpros for the key and value for the found entry */
struct hash_data *data = NULL;
/* The hash value to be searched for within the Red-Black tree */
uint64_t rbt_hash = 0;
/* Stored error return */
hash_error_t rc = HASHTABLE_SUCCESS;
/* This combination of options makes no sense ever */
assert(!(may_write && !latch));
rc = compute(ht, key, &index, &rbt_hash);
if (rc != HASHTABLE_SUCCESS)
return rc;
/* Acquire mutex */
if (may_write)
PTHREAD_RWLOCK_wrlock(&(ht->partitions[index].lock));
else
PTHREAD_RWLOCK_rdlock(&(ht->partitions[index].lock));
rc = key_locate(ht, key, index, rbt_hash, &locator);
if (rc == HASHTABLE_SUCCESS) {
/* Key was found */
data = RBT_OPAQ(locator);
if (val) {
val->addr = data->val.addr;
val->len = data->val.len;
}
if (isDebug(COMPONENT_HASHTABLE)
&& isFullDebug(ht->parameter.ht_log_component)) {
char dispval[HASHTABLE_DISPLAY_STRLEN];
if (ht->parameter.val_to_str != NULL)
ht->parameter.val_to_str(&data->val, dispval);
else
dispval[0] = '\0';
LogFullDebug(ht->parameter.ht_log_component,
"Get %s returning Value=%p {%s}",
ht->parameter.ht_name, data->val.addr,
dispval);
}
}
if (((rc == HASHTABLE_SUCCESS) || (rc == HASHTABLE_ERROR_NO_SUCH_KEY))
&& (latch != NULL)) {
latch->index = index;
latch->rbt_hash = rbt_hash;
latch->locator = locator;
} else {
PTHREAD_RWLOCK_unlock(&ht->partitions[index].lock);
}
if (rc != HASHTABLE_SUCCESS && isDebug(COMPONENT_HASHTABLE)
&& isFullDebug(ht->parameter.ht_log_component))
LogFullDebug(ht->parameter.ht_log_component,
"Get %s returning failure %s",
ht->parameter.ht_name, hash_table_err_to_str(rc));
return rc;
}
void nfs4_acl_release_entry(fsal_acl_t *acl, fsal_acl_status_t *status)
{
struct gsh_buffdesc key, old_key;
struct gsh_buffdesc old_value;
int rc;
struct hash_latch latch;
/* Set the return default to NFS_V4_ACL_SUCCESS */
*status = NFS_V4_ACL_SUCCESS;
if (!acl)
return;
PTHREAD_RWLOCK_wrlock(&acl->lock);
if (acl->ref > 1) {
nfs4_acl_entry_dec_ref(acl);
PTHREAD_RWLOCK_unlock(&acl->lock);
return;
} else
LogDebug(COMPONENT_NFS_V4_ACL, "Free ACL %p", acl);
key.addr = acl->aces;
key.len = acl->naces * sizeof(fsal_ace_t);
PTHREAD_RWLOCK_unlock(&acl->lock);
/* Get the hash table entry and hold latch */
rc = hashtable_getlatch(fsal_acl_hash, &key, &old_value, true, &latch);
switch (rc) {
case HASHTABLE_ERROR_NO_SUCH_KEY:
hashtable_releaselatched(fsal_acl_hash, &latch);
return;
case HASHTABLE_SUCCESS:
PTHREAD_RWLOCK_wrlock(&acl->lock);
nfs4_acl_entry_dec_ref(acl);
if (acl->ref != 0) {
/* Did not actually release last reference */
hashtable_releaselatched(fsal_acl_hash, &latch);
PTHREAD_RWLOCK_unlock(&acl->lock);
return;
}
/* use the key to delete the entry */
hashtable_deletelatched(fsal_acl_hash, &key, &latch,
&old_key, &old_value);
/* Release the latch */
hashtable_releaselatched(fsal_acl_hash, &latch);
break;
default:
LogCrit(COMPONENT_NFS_V4_ACL,
"ACL entry could not be deleted, status=%s",
hash_table_err_to_str(rc));
return;
}
/* Sanity check: old_value.addr is expected to be equal to acl,
* and is released later in this function */
assert(old_value.addr == acl);
PTHREAD_RWLOCK_unlock(&acl->lock);
/* Release acl */
nfs4_acl_free(acl);
}
fsal_acl_t *nfs4_acl_new_entry(fsal_acl_data_t *acldata,
fsal_acl_status_t *status)
{
fsal_acl_t *acl = NULL;
struct gsh_buffdesc key;
struct gsh_buffdesc value;
int rc;
struct hash_latch latch;
/* Set the return default to NFS_V4_ACL_SUCCESS */
*status = NFS_V4_ACL_SUCCESS;
key.addr = acldata->aces;
key.len = acldata->naces * sizeof(fsal_ace_t);
/* Check if the entry already exists */
rc = hashtable_getlatch(fsal_acl_hash, &key, &value, true, &latch);
if (rc == HASHTABLE_SUCCESS) {
/* Entry is already in the cache, do not add it */
acl = value.addr;
*status = NFS_V4_ACL_EXISTS;
nfs4_ace_free(acldata->aces);
nfs4_acl_entry_inc_ref(acl);
hashtable_releaselatched(fsal_acl_hash, &latch);
return acl;
}
/* Any other result other than no such key is an error */
if (rc != HASHTABLE_ERROR_NO_SUCH_KEY) {
*status = NFS_V4_ACL_INIT_ENTRY_FAILED;
nfs4_ace_free(acldata->aces);
return NULL;
}
/* Adding the entry in the cache */
acl = nfs4_acl_alloc();
if (pthread_rwlock_init(&(acl->lock), NULL) != 0) {
nfs4_acl_free(acl);
LogCrit(COMPONENT_NFS_V4_ACL,
"New ACL RW lock init returned %d (%s)", errno,
strerror(errno));
*status = NFS_V4_ACL_INIT_ENTRY_FAILED;
nfs4_ace_free(acldata->aces);
hashtable_releaselatched(fsal_acl_hash, &latch);
return NULL;
}
acl->naces = acldata->naces;
acl->aces = acldata->aces;
acl->ref = 1; /* We give out one reference */
/* Build the value */
value.addr = acl;
value.len = sizeof(fsal_acl_t);
rc = hashtable_setlatched(fsal_acl_hash, &key, &value, &latch,
HASHTABLE_SET_HOW_SET_NO_OVERWRITE, NULL,
NULL);
if (rc != HASHTABLE_SUCCESS) {
/* Put the entry back in its pool */
nfs4_acl_free(acl);
LogWarn(COMPONENT_NFS_V4_ACL,
"New ACL entry could not be added to hash, rc=%s",
hash_table_err_to_str(rc));
*status = NFS_V4_ACL_HASH_SET_ERROR;
return NULL;
}
return acl;
}
state_nlm_client_t *get_nlm_client(care_t care,
SVCXPRT * xprt,
state_nsm_client_t * pnsm_client,
char * caller_name)
{
state_nlm_client_t key;
state_nlm_client_t * pclient;
char str[HASHTABLE_DISPLAY_STRLEN];
struct hash_latch latch;
hash_error_t rc;
hash_buffer_t buffkey;
hash_buffer_t buffval;
if(caller_name == NULL)
return NULL;
memset(&key, 0, sizeof(key));
key.slc_nsm_client = pnsm_client;
key.slc_nlm_caller_name_len = strlen(caller_name);
key.slc_client_type = svc_get_xprt_type(xprt);
if(key.slc_nlm_caller_name_len > LM_MAXSTRLEN)
return NULL;
key.slc_nlm_caller_name = caller_name;
if(isFullDebug(COMPONENT_STATE))
{
display_nlm_client(&key, str);
LogFullDebug(COMPONENT_STATE,
"Find {%s}", str);
}
buffkey.pdata = &key;
buffkey.len = sizeof(key);
rc = HashTable_GetLatch(ht_nlm_client,
&buffkey,
&buffval,
TRUE,
&latch);
/* If we found it, return it */
if(rc == HASHTABLE_SUCCESS)
{
pclient = buffval.pdata;
/* Return the found NLM Client */
if(isFullDebug(COMPONENT_STATE))
{
display_nlm_client(pclient, str);
LogFullDebug(COMPONENT_STATE,
"Found {%s}",
str);
}
/* Increment refcount under hash latch.
* This prevents dec ref from removing this entry from hash if a race
* occurs.
*/
inc_nlm_client_ref(pclient);
HashTable_ReleaseLatched(ht_nlm_client, &latch);
if(care == CARE_MONITOR && !nsm_monitor(pnsm_client))
{
dec_nlm_client_ref(pclient);
pclient = NULL;
}
return pclient;
}
/* An error occurred, return NULL */
if(rc != HASHTABLE_ERROR_NO_SUCH_KEY)
{
display_nlm_client(&key, str);
LogCrit(COMPONENT_STATE,
"Error %s, could not find {%s}",
hash_table_err_to_str(rc), str);
return NULL;
}
/* Not found, but we don't care, return NULL */
if(care == CARE_NOT)
{
/* Return the found NLM Client */
if(isFullDebug(COMPONENT_STATE))
{
display_nlm_client(&key, str);
LogFullDebug(COMPONENT_STATE,
"Ignoring {%s}",
str);
}
HashTable_ReleaseLatched(ht_nlm_client, &latch);
return NULL;
}
pclient = gsh_malloc(sizeof(*pclient));
if(pclient == NULL)
{
display_nlm_client(&key, str);
LogCrit(COMPONENT_STATE,
"No memory for {%s}",
str);
return NULL;
}
/* Copy everything over */
memcpy(pclient, &key, sizeof(key));
pclient->slc_nlm_caller_name = gsh_strdup(key.slc_nlm_caller_name);
/* Take a reference to the NSM Client */
inc_nsm_client_ref(pnsm_client);
if(pclient->slc_nlm_caller_name == NULL)
{
/* Discard the created client */
free_nlm_client(pclient);
return NULL;
}
pclient->slc_refcount = 1;
if(isFullDebug(COMPONENT_STATE))
{
display_nlm_client(pclient, str);
LogFullDebug(COMPONENT_STATE,
"New {%s}", str);
}
buffkey.pdata = pclient;
buffkey.len = sizeof(*pclient);
buffval.pdata = pclient;
buffval.len = sizeof(*pclient);
rc = HashTable_SetLatched(ht_nlm_client,
&buffval,
&buffval,
&latch,
FALSE,
NULL,
NULL);
/* An error occurred, return NULL */
if(rc != HASHTABLE_SUCCESS)
{
display_nlm_client(pclient, str);
LogCrit(COMPONENT_STATE,
"Error %s, inserting {%s}",
hash_table_err_to_str(rc), str);
free_nlm_client(pclient);
return NULL;
}
if(care != CARE_MONITOR || nsm_monitor(pnsm_client))
return pclient;
/* Failed to monitor, release client reference
* and almost certainly remove it from the hash table.
*/
dec_nlm_client_ref(pclient);
return NULL;
}
void dec_nlm_client_ref(state_nlm_client_t *pclient)
{
char str[HASHTABLE_DISPLAY_STRLEN];
struct hash_latch latch;
hash_error_t rc;
hash_buffer_t buffkey;
hash_buffer_t old_value;
hash_buffer_t old_key;
int32_t refcount;
if(isDebug(COMPONENT_STATE))
display_nlm_client(pclient, str);
refcount = atomic_dec_int32_t(&pclient->slc_refcount);
if(refcount > 0)
{
LogFullDebug(COMPONENT_STATE,
"Decrement refcount now=%"PRId32" {%s}",
refcount, str);
return;
}
LogFullDebug(COMPONENT_STATE,
"Try to remove {%s}",
str);
buffkey.pdata = pclient;
buffkey.len = sizeof(*pclient);
/* Get the hash table entry and hold latch */
rc = HashTable_GetLatch(ht_nlm_client,
&buffkey,
&old_value,
TRUE,
&latch);
if(rc != HASHTABLE_SUCCESS)
{
if(rc == HASHTABLE_ERROR_NO_SUCH_KEY)
HashTable_ReleaseLatched(ht_nlm_client, &latch);
display_nlm_client(pclient, str);
LogCrit(COMPONENT_STATE,
"Error %s, could not find {%s}",
hash_table_err_to_str(rc), str);
return;
}
refcount = atomic_fetch_int32_t(&pclient->slc_refcount);
if(refcount > 0)
{
LogDebug(COMPONENT_STATE,
"Did not release refcount now=%"PRId32" {%s}",
refcount, str);
HashTable_ReleaseLatched(ht_nlm_client, &latch);
return;
}
/* use the key to delete the entry */
rc = HashTable_DeleteLatched(ht_nlm_client,
&buffkey,
&latch,
&old_key,
&old_value);
if(rc != HASHTABLE_SUCCESS)
{
if(rc == HASHTABLE_ERROR_NO_SUCH_KEY)
HashTable_ReleaseLatched(ht_nlm_client, &latch);
display_nlm_client(pclient, str);
LogCrit(COMPONENT_STATE,
"Error %s, could not remove {%s}",
hash_table_err_to_str(rc), str);
return;
}
LogFullDebug(COMPONENT_STATE,
"Free {%s}",
str);
free_nlm_client(old_value.pdata);
}
state_nsm_client_t *get_nsm_client(care_t care,
SVCXPRT * xprt,
char * caller_name)
{
state_nsm_client_t key;
state_nsm_client_t * pclient;
char sock_name[SOCK_NAME_MAX];
char str[HASHTABLE_DISPLAY_STRLEN];
struct hash_latch latch;
hash_error_t rc;
hash_buffer_t buffkey;
hash_buffer_t buffval;
if(caller_name == NULL)
return NULL;
memset(&key, 0, sizeof(key));
if(nfs_param.core_param.nsm_use_caller_name)
{
key.ssc_nlm_caller_name_len = strlen(caller_name);
if(key.ssc_nlm_caller_name_len > LM_MAXSTRLEN)
{
return NULL;
}
key.ssc_nlm_caller_name = caller_name;
}
else if(xprt == NULL)
{
int rc = ipstring_to_sockaddr(caller_name, &key.ssc_client_addr);
if(rc != 0)
{
LogEvent(COMPONENT_STATE,
"Error %s, converting caller_name %s to an ipaddress",
gai_strerror(rc), caller_name);
return NULL;
}
key.ssc_nlm_caller_name_len = strlen(caller_name);
if(key.ssc_nlm_caller_name_len > LM_MAXSTRLEN)
{
return NULL;
}
key.ssc_nlm_caller_name = caller_name;
}
else
{
key.ssc_nlm_caller_name = sock_name;
if(copy_xprt_addr(&key.ssc_client_addr, xprt) == 0)
{
LogCrit(COMPONENT_STATE,
"Error converting caller_name %s to an ipaddress",
caller_name);
return NULL;
}
if(sprint_sockip(&key.ssc_client_addr,
key.ssc_nlm_caller_name,
sizeof(sock_name)) == 0)
{
LogCrit(COMPONENT_STATE,
"Error converting caller_name %s to an ipaddress",
caller_name);
return NULL;
}
key.ssc_nlm_caller_name_len = strlen(key.ssc_nlm_caller_name);
}
if(isFullDebug(COMPONENT_STATE))
{
display_nsm_client(&key, str);
LogFullDebug(COMPONENT_STATE,
"Find {%s}", str);
}
buffkey.pdata = &key;
buffkey.len = sizeof(key);
rc = HashTable_GetLatch(ht_nsm_client,
&buffkey,
&buffval,
TRUE,
&latch);
/* If we found it, return it */
if(rc == HASHTABLE_SUCCESS)
{
pclient = buffval.pdata;
/* Return the found NSM Client */
if(isFullDebug(COMPONENT_STATE))
{
display_nsm_client(pclient, str);
LogFullDebug(COMPONENT_STATE,
"Found {%s}",
str);
}
/* Increment refcount under hash latch.
* This prevents dec ref from removing this entry from hash if a race
* occurs.
*/
inc_nsm_client_ref(pclient);
HashTable_ReleaseLatched(ht_nsm_client, &latch);
if(care == CARE_MONITOR && !nsm_monitor(pclient))
{
dec_nsm_client_ref(pclient);
pclient = NULL;
}
return pclient;
}
/* An error occurred, return NULL */
if(rc != HASHTABLE_ERROR_NO_SUCH_KEY)
{
display_nsm_client(&key, str);
LogCrit(COMPONENT_STATE,
"Error %s, could not find {%s}",
hash_table_err_to_str(rc), str);
return NULL;
}
/* Not found, but we don't care, return NULL */
if(care == CARE_NOT)
{
/* Return the found NSM Client */
if(isFullDebug(COMPONENT_STATE))
{
display_nsm_client(&key, str);
LogFullDebug(COMPONENT_STATE,
"Ignoring {%s}",
str);
}
HashTable_ReleaseLatched(ht_nsm_client, &latch);
return NULL;
}
pclient = gsh_malloc(sizeof(*pclient));
if(pclient == NULL)
{
display_nsm_client(&key, str);
LogCrit(COMPONENT_STATE,
"No memory for {%s}",
str);
return NULL;
}
/* Copy everything over */
memcpy(pclient, &key, sizeof(key));
if(pthread_mutex_init(&pclient->ssc_mutex, NULL) == -1)
{
/* Mutex initialization failed, free the created client */
display_nsm_client(&key, str);
LogCrit(COMPONENT_STATE,
"Could not init mutex for {%s}",
str);
gsh_free(pclient);
return NULL;
}
pclient->ssc_nlm_caller_name = gsh_strdup(key.ssc_nlm_caller_name);
if(pclient->ssc_nlm_caller_name == NULL)
{
/* Discard the created client */
free_nsm_client(pclient);
return NULL;
}
init_glist(&pclient->ssc_lock_list);
init_glist(&pclient->ssc_share_list);
pclient->ssc_refcount = 1;
if(isFullDebug(COMPONENT_STATE))
{
display_nsm_client(pclient, str);
LogFullDebug(COMPONENT_STATE,
"New {%s}", str);
}
buffkey.pdata = pclient;
buffkey.len = sizeof(*pclient);
buffval.pdata = pclient;
buffval.len = sizeof(*pclient);
rc = HashTable_SetLatched(ht_nsm_client,
&buffval,
&buffval,
&latch,
FALSE,
NULL,
NULL);
/* An error occurred, return NULL */
if(rc != HASHTABLE_SUCCESS)
{
display_nsm_client(pclient, str);
LogCrit(COMPONENT_STATE,
"Error %s, inserting {%s}",
hash_table_err_to_str(rc), str);
free_nsm_client(pclient);
return NULL;
}
if(care != CARE_MONITOR || nsm_monitor(pclient))
return pclient;
/* Failed to monitor, release client reference
* and almost certainly remove it from the hash table.
*/
dec_nsm_client_ref(pclient);
return NULL;
}
/**
* @brief Get an NSM client
*
* @param[in] care Care status
* @param[in] xprt RPC transport
* @param[in] caller_name Caller name
*
* @return NSM client or NULL.
*/
state_nsm_client_t *get_nsm_client(care_t care, SVCXPRT *xprt,
char *caller_name)
{
state_nsm_client_t key;
state_nsm_client_t *pclient;
char str[LOG_BUFF_LEN];
struct display_buffer dspbuf = {sizeof(str), str, str};
struct hash_latch latch;
hash_error_t rc;
struct gsh_buffdesc buffkey;
struct gsh_buffdesc buffval;
if (caller_name == NULL)
return NULL;
memset(&key, 0, sizeof(key));
if (nfs_param.core_param.nsm_use_caller_name) {
key.ssc_nlm_caller_name_len = strlen(caller_name);
if (key.ssc_nlm_caller_name_len > LM_MAXSTRLEN)
return NULL;
key.ssc_nlm_caller_name = caller_name;
} else if (op_ctx->client == NULL) {
LogCrit(COMPONENT_STATE,
"No gsh_client for caller_name %s", caller_name);
return NULL;
} else {
key.ssc_nlm_caller_name = op_ctx->client->hostaddr_str;
key.ssc_nlm_caller_name_len = strlen(key.ssc_nlm_caller_name);
key.ssc_client = op_ctx->client;
}
if (isFullDebug(COMPONENT_STATE)) {
display_nsm_client(&dspbuf, &key);
LogFullDebug(COMPONENT_STATE, "Find {%s}", str);
}
buffkey.addr = &key;
buffkey.len = sizeof(key);
rc = hashtable_getlatch(ht_nsm_client, &buffkey, &buffval, true,
&latch);
/* If we found it, return it */
if (rc == HASHTABLE_SUCCESS) {
pclient = buffval.addr;
/* Return the found NSM Client */
if (isFullDebug(COMPONENT_STATE)) {
display_nsm_client(&dspbuf, pclient);
LogFullDebug(COMPONENT_STATE, "Found {%s}", str);
}
/* Increment refcount under hash latch.
* This prevents dec ref from removing this entry from hash
* if a race occurs.
*/
inc_nsm_client_ref(pclient);
hashtable_releaselatched(ht_nsm_client, &latch);
if (care == CARE_MONITOR && !nsm_monitor(pclient)) {
dec_nsm_client_ref(pclient);
pclient = NULL;
}
return pclient;
}
/* An error occurred, return NULL */
if (rc != HASHTABLE_ERROR_NO_SUCH_KEY) {
display_nsm_client(&dspbuf, &key);
LogCrit(COMPONENT_STATE, "Error %s, could not find {%s}",
hash_table_err_to_str(rc), str);
return NULL;
}
/* Not found, but we don't care, return NULL */
if (care == CARE_NOT) {
/* Return the found NSM Client */
if (isFullDebug(COMPONENT_STATE)) {
display_nsm_client(&dspbuf, &key);
LogFullDebug(COMPONENT_STATE, "Ignoring {%s}", str);
}
hashtable_releaselatched(ht_nsm_client, &latch);
return NULL;
}
pclient = gsh_malloc(sizeof(*pclient));
if (pclient == NULL) {
display_nsm_client(&dspbuf, &key);
LogCrit(COMPONENT_STATE, "No memory for {%s}", str);
return NULL;
}
/* Copy everything over */
memcpy(pclient, &key, sizeof(key));
PTHREAD_MUTEX_init(&pclient->ssc_mutex, NULL);
pclient->ssc_nlm_caller_name = gsh_strdup(key.ssc_nlm_caller_name);
if (pclient->ssc_nlm_caller_name == NULL) {
/* Discard the created client */
PTHREAD_MUTEX_destroy(&pclient->ssc_mutex);
free_nsm_client(pclient);
return NULL;
}
glist_init(&pclient->ssc_lock_list);
glist_init(&pclient->ssc_share_list);
pclient->ssc_refcount = 1;
if (op_ctx->client != NULL) {
pclient->ssc_client = op_ctx->client;
inc_gsh_client_refcount(op_ctx->client);
}
if (isFullDebug(COMPONENT_STATE)) {
display_nsm_client(&dspbuf, pclient);
LogFullDebug(COMPONENT_STATE, "New {%s}", str);
}
buffkey.addr = pclient;
buffkey.len = sizeof(*pclient);
buffval.addr = pclient;
buffval.len = sizeof(*pclient);
rc = hashtable_setlatched(ht_nsm_client, &buffval, &buffval, &latch,
false, NULL, NULL);
/* An error occurred, return NULL */
if (rc != HASHTABLE_SUCCESS) {
display_nsm_client(&dspbuf, pclient);
LogCrit(COMPONENT_STATE, "Error %s, inserting {%s}",
hash_table_err_to_str(rc), str);
PTHREAD_MUTEX_destroy(&pclient->ssc_mutex);
free_nsm_client(pclient);
return NULL;
}
if (care != CARE_MONITOR || nsm_monitor(pclient))
return pclient;
/* Failed to monitor, release client reference
* and almost certainly remove it from the hash table.
*/
dec_nsm_client_ref(pclient);
return NULL;
}
/**
* @brief Relinquish a reference on an NSM client
*
* @param[in] client The client to release
*/
void dec_nsm_client_ref(state_nsm_client_t *client)
{
char str[LOG_BUFF_LEN];
struct display_buffer dspbuf = {sizeof(str), str, str};
bool str_valid = false;
struct hash_latch latch;
hash_error_t rc;
struct gsh_buffdesc buffkey;
struct gsh_buffdesc old_value;
struct gsh_buffdesc old_key;
int32_t refcount;
if (isDebug(COMPONENT_STATE)) {
display_nsm_client(&dspbuf, client);
str_valid = true;
}
refcount = atomic_dec_int32_t(&client->ssc_refcount);
if (refcount > 0) {
if (str_valid)
LogFullDebug(COMPONENT_STATE,
"Decrement refcount now=%" PRId32 " {%s}",
refcount, str);
return;
}
if (str_valid)
LogFullDebug(COMPONENT_STATE, "Try to remove {%s}", str);
buffkey.addr = client;
buffkey.len = sizeof(*client);
/* Get the hash table entry and hold latch */
rc = hashtable_getlatch(ht_nsm_client, &buffkey, &old_value, true,
&latch);
if (rc != HASHTABLE_SUCCESS) {
if (rc == HASHTABLE_ERROR_NO_SUCH_KEY)
hashtable_releaselatched(ht_nsm_client, &latch);
if (!str_valid)
display_nsm_client(&dspbuf, client);
LogCrit(COMPONENT_STATE, "Error %s, could not find {%s}",
hash_table_err_to_str(rc), str);
return;
}
refcount = atomic_fetch_int32_t(&client->ssc_refcount);
if (refcount > 0) {
if (str_valid)
LogDebug(COMPONENT_STATE,
"Did not release refcount now=%"PRId32" {%s}",
refcount, str);
hashtable_releaselatched(ht_nsm_client, &latch);
return;
}
/* use the key to delete the entry */
rc = hashtable_deletelatched(ht_nsm_client, &buffkey, &latch, &old_key,
&old_value);
if (rc != HASHTABLE_SUCCESS) {
if (rc == HASHTABLE_ERROR_NO_SUCH_KEY)
hashtable_releaselatched(ht_nsm_client, &latch);
if (!str_valid)
display_nsm_client(&dspbuf, client);
LogCrit(COMPONENT_STATE, "Error %s, could not remove {%s}",
hash_table_err_to_str(rc), str);
return;
}
LogFullDebug(COMPONENT_STATE, "Free {%s}", str);
nsm_unmonitor(old_value.addr);
free_nsm_client(old_value.addr);
}
/**
* @brief Get an NLM client
*
* @param[in] care Care status
* @param[in] xprt RPC transport
* @param[in] nsm_client Related NSM client
* @param[in] caller_name Caller name
*
* @return NLM client or NULL.
*/
state_nlm_client_t *get_nlm_client(care_t care, SVCXPRT *xprt,
state_nsm_client_t *nsm_client,
char *caller_name)
{
state_nlm_client_t key;
state_nlm_client_t *pclient;
char str[LOG_BUFF_LEN];
struct display_buffer dspbuf = {sizeof(str), str, str};
struct hash_latch latch;
hash_error_t rc;
struct gsh_buffdesc buffkey;
struct gsh_buffdesc buffval;
struct sockaddr_storage local_addr;
socklen_t addr_len;
if (caller_name == NULL)
return NULL;
memset(&key, 0, sizeof(key));
key.slc_nsm_client = nsm_client;
key.slc_nlm_caller_name_len = strlen(caller_name);
key.slc_client_type = svc_get_xprt_type(xprt);
addr_len = sizeof(local_addr);
if (getsockname(xprt->xp_fd, (struct sockaddr *)&local_addr, &addr_len)
== -1) {
LogEvent(COMPONENT_CLIENTID, "Failed to get local addr.");
} else {
memcpy(&(key.slc_server_addr), &local_addr,
sizeof(struct sockaddr_storage));
}
if (key.slc_nlm_caller_name_len > LM_MAXSTRLEN)
return NULL;
key.slc_nlm_caller_name = caller_name;
if (isFullDebug(COMPONENT_STATE)) {
display_nlm_client(&dspbuf, &key);
LogFullDebug(COMPONENT_STATE, "Find {%s}", str);
}
buffkey.addr = &key;
buffkey.len = sizeof(key);
rc = hashtable_getlatch(ht_nlm_client, &buffkey, &buffval, true,
&latch);
/* If we found it, return it */
if (rc == HASHTABLE_SUCCESS) {
pclient = buffval.addr;
/* Return the found NLM Client */
if (isFullDebug(COMPONENT_STATE)) {
display_nlm_client(&dspbuf, pclient);
LogFullDebug(COMPONENT_STATE, "Found {%s}", str);
}
/* Increment refcount under hash latch.
* This prevents dec ref from removing this entry from hash
* if a race occurs.
*/
inc_nlm_client_ref(pclient);
hashtable_releaselatched(ht_nlm_client, &latch);
if (care == CARE_MONITOR && !nsm_monitor(nsm_client)) {
dec_nlm_client_ref(pclient);
pclient = NULL;
}
return pclient;
}
/* An error occurred, return NULL */
if (rc != HASHTABLE_ERROR_NO_SUCH_KEY) {
display_nlm_client(&dspbuf, &key);
LogCrit(COMPONENT_STATE, "Error %s, could not find {%s}",
hash_table_err_to_str(rc), str);
return NULL;
}
/* Not found, but we don't care, return NULL */
if (care == CARE_NOT) {
/* Return the found NLM Client */
if (isFullDebug(COMPONENT_STATE)) {
display_nlm_client(&dspbuf, &key);
LogFullDebug(COMPONENT_STATE, "Ignoring {%s}", str);
}
hashtable_releaselatched(ht_nlm_client, &latch);
return NULL;
}
pclient = gsh_malloc(sizeof(*pclient));
if (pclient == NULL) {
display_nlm_client(&dspbuf, &key);
LogCrit(COMPONENT_STATE, "No memory for {%s}", str);
return NULL;
}
/* Copy everything over */
memcpy(pclient, &key, sizeof(key));
pclient->slc_nlm_caller_name = gsh_strdup(key.slc_nlm_caller_name);
/* Take a reference to the NSM Client */
inc_nsm_client_ref(nsm_client);
if (pclient->slc_nlm_caller_name == NULL) {
/* Discard the created client */
free_nlm_client(pclient);
return NULL;
}
pclient->slc_refcount = 1;
if (isFullDebug(COMPONENT_STATE)) {
display_nlm_client(&dspbuf, pclient);
LogFullDebug(COMPONENT_STATE, "New {%s}", str);
}
buffkey.addr = pclient;
buffkey.len = sizeof(*pclient);
buffval.addr = pclient;
buffval.len = sizeof(*pclient);
rc = hashtable_setlatched(ht_nlm_client, &buffval, &buffval, &latch,
false, NULL, NULL);
/* An error occurred, return NULL */
if (rc != HASHTABLE_SUCCESS) {
display_nlm_client(&dspbuf, pclient);
LogCrit(COMPONENT_STATE, "Error %s, inserting {%s}",
hash_table_err_to_str(rc), str);
free_nlm_client(pclient);
return NULL;
}
if (care != CARE_MONITOR || nsm_monitor(nsm_client))
return pclient;
/* Failed to monitor, release client reference
* and almost certainly remove it from the hash table.
*/
dec_nlm_client_ref(pclient);
return NULL;
}