/**
* @brief Compare NLM owners
*
* @param[in] owner1 A client
* @param[in] owner2 Another client
*
* @retval 0 on equality.
* @retval 1 on inequality.
*/
int compare_nlm_owner(state_owner_t *owner1, state_owner_t *owner2)
{
if (isFullDebug(COMPONENT_STATE) && isDebug(COMPONENT_HASHTABLE)) {
char str1[LOG_BUFF_LEN / 2];
char str2[LOG_BUFF_LEN / 2];
struct display_buffer dspbuf1 = {sizeof(str1), str1, str1};
struct display_buffer dspbuf2 = {sizeof(str2), str2, str2};
display_nlm_owner(&dspbuf1, owner1);
display_nlm_owner(&dspbuf2, owner2);
LogFullDebug(COMPONENT_STATE, "{%s} vs {%s}", str1, str2);
}
if (owner1 == NULL || owner2 == NULL)
return 1;
if (owner1 == owner2)
return 0;
if (compare_nlm_client
(owner1->so_owner.so_nlm_owner.so_client,
owner2->so_owner.so_nlm_owner.so_client) != 0)
return 1;
if (owner1->so_owner.so_nlm_owner.so_nlm_svid !=
owner2->so_owner.so_nlm_owner.so_nlm_svid)
return 1;
if (owner1->so_owner_len != owner2->so_owner_len)
return 1;
return memcmp(owner1->so_owner_val, owner2->so_owner_val,
owner1->so_owner_len);
}
static int Hash_del_nlm_owner_ref(hash_buffer_t *buffval)
{
int rc;
state_owner_t *powner = (state_owner_t *)(buffval->pdata);
P(powner->so_mutex);
powner->so_refcount--;
if(isFullDebug(COMPONENT_STATE))
{
char str[HASHTABLE_DISPLAY_STRLEN];
display_nlm_owner(powner, str);
LogFullDebug(COMPONENT_STATE,
"Decrement refcount for NLM Owner powner=%p {%s}, refcount = %d",
powner, str, powner->so_refcount);
}
rc = powner->so_refcount;
V(powner->so_mutex);
return rc;
}
/**
* @brief Display an NLM owner in the hash table
*
* @param[in] buff The value
* @param[out] str Output buffer
*
* @return Length of output string.
*/
int display_nlm_owner_val(struct gsh_buffdesc *buff, char *str)
{
struct display_buffer dspbuf = {HASHTABLE_DISPLAY_STRLEN, str, str};
display_nlm_owner(&dspbuf, buff->addr);
return display_buffer_len(&dspbuf);
}
void dec_nlm_owner_ref_locked(state_owner_t *powner)
{
bool_t remove = FALSE;
char str[HASHTABLE_DISPLAY_STRLEN];
if(isFullDebug(COMPONENT_STATE))
display_nlm_owner(powner, str);
if(powner->so_refcount > 1)
{
powner->so_refcount--;
LogFullDebug(COMPONENT_STATE,
"Decrement refcount for NLM Owner powner=%p {%s}, refcount = %d",
powner, str, powner->so_refcount);
}
else
remove = TRUE;
V(powner->so_mutex);
if(remove)
{
hash_buffer_t buffkey, old_key, old_value;
buffkey.pdata = (caddr_t) powner;
buffkey.len = sizeof(*powner);
switch(HashTable_DelRef(ht_nlm_owner, &buffkey, &old_key, &old_value, Hash_del_nlm_owner_ref))
{
case HASHTABLE_SUCCESS:
LogFullDebug(COMPONENT_STATE,
"Free NLM Owner powner=%p {%s}, refcount = %d",
powner, str, powner->so_refcount);
dec_nlm_client_ref(powner->so_owner.so_nlm_owner.so_client);
Mem_Free(old_key.pdata);
Mem_Free(old_value.pdata);
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 powner=%p {%s}, refcount = %d",
powner, str, powner->so_refcount);
break;
default:
/* some problem occurred */
LogDebug(COMPONENT_STATE,
"HashTable_DelRef failed for powner=%p {%s}",
powner, str);
break;
}
}
}
int compare_nlm_owner(state_owner_t *powner1,
state_owner_t *powner2)
{
if(isFullDebug(COMPONENT_STATE) && isDebug(COMPONENT_HASHTABLE))
{
char str1[HASHTABLE_DISPLAY_STRLEN];
char str2[HASHTABLE_DISPLAY_STRLEN];
display_nlm_owner(powner1, str1);
display_nlm_owner(powner2, str2);
LogFullDebug(COMPONENT_STATE,
"{%s} vs {%s}", str1, str2);
}
if(powner1 == NULL || powner2 == NULL)
return 1;
if(powner1 == powner2)
return 0;
if(compare_nlm_client(powner1->so_owner.so_nlm_owner.so_client,
powner2->so_owner.so_nlm_owner.so_client) != 0)
return 1;
/* Handle special owner that matches any lock owner with the same nlm client */
if(powner1->so_owner_len == -1 ||
powner2->so_owner_len == -1)
return 0;
if(powner1->so_owner.so_nlm_owner.so_nlm_svid !=
powner2->so_owner.so_nlm_owner.so_nlm_svid)
return 1;
if(powner1->so_owner_len !=
powner2->so_owner_len)
return 1;
return memcmp(powner1->so_owner_val,
powner2->so_owner_val,
powner1->so_owner_len);
}
void inc_nlm_owner_ref_locked(state_owner_t *powner)
{
powner->so_refcount++;
if(isFullDebug(COMPONENT_STATE))
{
char str[HASHTABLE_DISPLAY_STRLEN];
display_nlm_owner(powner, str);
LogFullDebug(COMPONENT_STATE,
"Increment refcount for NLM Owner powner=%p {%s}, refcount = %d",
powner, str, powner->so_refcount);
}
V(powner->so_mutex);
}
static void Hash_inc_owner_ref(hash_buffer_t *buffval)
{
state_owner_t *powner = (state_owner_t *)(buffval->pdata);
P(powner->so_mutex);
powner->so_refcount++;
if(isFullDebug(COMPONENT_STATE))
{
char str[HASHTABLE_DISPLAY_STRLEN];
display_nlm_owner(powner, str);
LogFullDebug(COMPONENT_STATE,
"Increment refcount for NLM Owner powner=%p {%s}, refcount = %d",
powner, str, powner->so_refcount);
}
V(powner->so_mutex);
}
int display_nlm_owner_val(hash_buffer_t * pbuff, char *str)
{
return display_nlm_owner((state_owner_t *)pbuff->pdata, str);
}
state_owner_t *get_nlm_owner(care_t care,
state_nlm_client_t * pclient,
netobj * oh,
uint32_t svid)
{
state_owner_t * pkey, *powner;
if(pclient == NULL || oh == NULL || oh->n_len > MAX_NETOBJ_SZ)
return NULL;
pkey = (state_owner_t *)Mem_Alloc(sizeof(*pkey));
if(pkey == NULL)
return NULL;
memset(pkey, 0, sizeof(*pkey));
pkey->so_type = STATE_LOCK_OWNER_NLM;
pkey->so_refcount = 1;
pkey->so_owner.so_nlm_owner.so_client = pclient;
pkey->so_owner.so_nlm_owner.so_nlm_svid = svid;
pkey->so_owner_len = oh->n_len;
memcpy(pkey->so_owner_val, oh->n_bytes, oh->n_len);
if(isFullDebug(COMPONENT_STATE))
{
char str[HASHTABLE_DISPLAY_STRLEN];
display_nlm_owner(pkey, str);
LogFullDebug(COMPONENT_STATE,
"Find NLM Owner KEY {%s}", str);
}
/* If we found it, return it, if we don't care, return NULL */
if(nlm_owner_Get_Pointer(pkey, &powner) == 1 || care == CARE_NOT)
{
/* Discard the key we created and return the found NLM Owner */
Mem_Free(pkey);
if(isFullDebug(COMPONENT_STATE))
{
char str[HASHTABLE_DISPLAY_STRLEN];
display_nlm_owner(powner, str);
LogFullDebug(COMPONENT_STATE,
"Found {%s}",
str);
}
return powner;
}
powner = (state_owner_t *)Mem_Alloc(sizeof(*pkey));
if(powner == NULL)
{
Mem_Free(pkey);
return NULL;
}
/* Copy everything over */
*powner = *pkey;
init_glist(&powner->so_lock_list);
if(pthread_mutex_init(&powner->so_mutex, NULL) == -1)
{
/* Mutex initialization failed, free the key and created owner */
Mem_Free(pkey);
Mem_Free(powner);
return NULL;
}
if(isFullDebug(COMPONENT_STATE))
{
char str[HASHTABLE_DISPLAY_STRLEN];
display_nlm_owner(powner, str);
LogFullDebug(COMPONENT_STATE,
"New {%s}", str);
}
/* Ref count the client as being used by this owner */
inc_nlm_client_ref(pclient);
if(nlm_owner_Set(pkey, powner) == 1)
{
if(isFullDebug(COMPONENT_STATE))
{
char str[HASHTABLE_DISPLAY_STRLEN];
display_nlm_owner(powner, str);
LogFullDebug(COMPONENT_STATE,
"Set NLM Owner {%s}",
str);
}
return powner;
}
dec_nlm_client_ref(pclient);
Mem_Free(pkey);
Mem_Free(powner);
return NULL;
}
