cache_inode_status_t cache_inode_kill_entry( cache_entry_t * pentry,
cache_inode_lock_how_t lock_how,
hash_table_t * ht,
cache_inode_client_t * pclient,
cache_inode_status_t * pstatus )
{
fsal_handle_t *pfsal_handle = NULL;
cache_inode_fsal_data_t fsaldata;
cache_inode_parent_entry_t *parent_iter = NULL;
cache_inode_parent_entry_t *parent_iter_next = NULL;
hash_buffer_t key, old_key;
hash_buffer_t old_value;
int rc;
fsal_status_t fsal_status;
memset( (char *)&fsaldata, 0, sizeof( fsaldata ) ) ;
LogInfo(COMPONENT_CACHE_INODE,
"Using cache_inode_kill_entry for entry %p", pentry);
/* Invalidation is not for junctions or special files */
if( ( pentry->internal_md.type == FS_JUNCTION ) ||
( pentry->internal_md.type == SOCKET_FILE ) ||
( pentry->internal_md.type == FIFO_FILE ) ||
( pentry->internal_md.type == CHARACTER_FILE ) ||
( pentry->internal_md.type == BLOCK_FILE ) )
{
free_lock( pentry, lock_how ) ;
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
}
#if 0
/** @todo: BUGAZOMEU : directory invalidation seems quite tricky, temporarily avoid it */
if( pentry->internal_md.type == DIRECTORY )
{
free_lock( pentry, lock_how ) ;
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
}
/** @todo: BUGAZOMEU : file invalidation seems quite tricky, temporarily avoid it */
/* We need to know how to manage how to deal with "files with states" */
if( pentry->internal_md.type == REGULAR_FILE )
{
free_lock( pentry, lock_how ) ;
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
}
#endif
if(pstatus == NULL)
return CACHE_INODE_INVALID_ARGUMENT;
if(pentry == NULL || pclient == NULL || ht == NULL)
{
free_lock( pentry, lock_how ) ;
*pstatus = CACHE_INODE_INVALID_ARGUMENT;
return *pstatus;
}
/* Get the FSAL handle */
if((pfsal_handle = cache_inode_get_fsal_handle(pentry, pstatus)) == NULL)
{
free_lock( pentry, lock_how ) ;
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_kill_entry: unable to retrieve pentry's specific filesystem info");
return *pstatus;
}
/* Invalidate the related LRU gc entry (no more required) */
if(pentry->gc_lru_entry != NULL)
{
if(LRU_invalidate(pentry->gc_lru, pentry->gc_lru_entry) != LRU_LIST_SUCCESS)
{
free_lock( pentry, lock_how ) ;
*pstatus = CACHE_INODE_LRU_ERROR;
return *pstatus;
}
}
fsaldata.handle = *pfsal_handle;
fsaldata.cookie = DIR_START;
/* Use the handle to build the key */
if(cache_inode_fsaldata_2_key(&key, &fsaldata, pclient))
{
free_lock( pentry, lock_how ) ;
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_kill_entry: could not build hashtable key");
cache_inode_release_fsaldata_key(&key, pclient);
*pstatus = CACHE_INODE_NOT_FOUND;
return *pstatus;
}
/* use the key to delete the entry */
if((rc = HashTable_Del(ht, &key, &old_key, &old_value)) != HASHTABLE_SUCCESS)
{
if( rc != HASHTABLE_ERROR_NO_SUCH_KEY) /* rc=3 => Entry was previously removed */
LogCrit( COMPONENT_CACHE_INODE,
"cache_inode_kill_entry: entry could not be deleted, status = %d",
rc);
cache_inode_release_fsaldata_key(&key, pclient);
*pstatus = CACHE_INODE_NOT_FOUND;
return *pstatus;
}
/* Release the hash key data */
cache_inode_release_fsaldata_key(&old_key, pclient);
/* Clean up the associated ressources in the FSAL */
if(FSAL_IS_ERROR(fsal_status = FSAL_CleanObjectResources(pfsal_handle)))
{
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_kill_entry: Couldn't free FSAL ressources fsal_status.major=%u",
fsal_status.major);
}
/* Sanity check: old_value.pdata is expected to be equal to pentry,
* and is released later in this function */
if((cache_entry_t *) old_value.pdata != pentry)
{
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_kill_entry: unexpected pdata %p from hash table (pentry=%p)",
old_value.pdata, pentry);
}
/* Release the current key */
cache_inode_release_fsaldata_key(&key, pclient);
/* Recover the parent list entries */
parent_iter = pentry->parent_list;
while(parent_iter != NULL)
{
parent_iter_next = parent_iter->next_parent;
ReleaseToPool(parent_iter, &pclient->pool_parent);
parent_iter = parent_iter_next;
}
/* If entry is datacached, remove it from the cache */
if(pentry->internal_md.type == REGULAR_FILE)
{
cache_content_status_t cache_content_status;
if(pentry->object.file.pentry_content != NULL)
if(cache_content_release_entry
((cache_content_entry_t *) pentry->object.file.pentry_content,
(cache_content_client_t *) pclient->pcontent_client,
&cache_content_status) != CACHE_CONTENT_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"Could not removed datacached entry for pentry %p", pentry);
}
/* If entry is a DIRECTORY, invalidate dirents */
if(pentry->internal_md.type == DIRECTORY)
{
cache_inode_invalidate_related_dirents(pentry, pclient);
}
// free_lock( pentry, lock_how ) ; /* Really needed ? The pentry is unaccessible now and will be destroyed */
/* Destroy the mutex associated with the pentry */
cache_inode_mutex_destroy(pentry);
/* Put the pentry back to the pool */
ReleaseToPool(pentry, &pclient->pool_entry);
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
} /* cache_inode_kill_entry */
/**
*
* cache_inode_gc_clean_entry: cleans a entry in the cache_inode.
*
* cleans an entry in the cache_inode.
*
* @param pentry [INOUT] entry to be cleaned.
* @param addparam [IN] additional parameter used for cleaning.
*
* @return LRU_LIST_SET_INVALID if ok, LRU_LIST_DO_NOT_SET_INVALID otherwise
*
*/
static int cache_inode_gc_clean_entry(cache_entry_t * pentry,
cache_inode_param_gc_t * pgcparam)
{
fsal_handle_t *pfsal_handle = NULL;
cache_inode_parent_entry_t *parent_iter = NULL;
cache_inode_parent_entry_t *parent_iter_next = NULL;
cache_inode_fsal_data_t fsaldata;
cache_inode_status_t status;
fsal_status_t fsal_status;
hash_buffer_t key, old_key, old_value;
int rc;
LogFullDebug(COMPONENT_CACHE_INODE_GC,
"(pthread_self=%p): About to remove pentry=%p, type=%d",
(caddr_t)pthread_self(),
pentry, pentry->internal_md.type);
/* sanity check */
if((pentry->gc_lru_entry != NULL) &&
((cache_entry_t *) pentry->gc_lru_entry->buffdata.pdata) != pentry)
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: LRU entry pointed by this pentry doesn't match the GC LRU");
}
/* Get the FSAL handle */
if((pfsal_handle = cache_inode_get_fsal_handle(pentry, &status)) == NULL)
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: unable to retrieve pentry's specific filesystem info");
return LRU_LIST_DO_NOT_SET_INVALID;
}
fsaldata.handle = *pfsal_handle;
if(pentry->internal_md.type != DIR_CONTINUE)
fsaldata.cookie = DIR_START;
else
fsaldata.cookie = pentry->object.dir_cont.dir_cont_pos;
/* Use the handle to build the key */
if(cache_inode_fsaldata_2_key(&key, &fsaldata, pgcparam->pclient))
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: could not build hashtable key");
cache_inode_release_fsaldata_key(&key, pgcparam->pclient);
return LRU_LIST_DO_NOT_SET_INVALID;
}
/* use the key to delete the entry */
rc = HashTable_Del(pgcparam->ht, &key, &old_key, &old_value);
if((rc != HASHTABLE_SUCCESS) && (rc != HASHTABLE_ERROR_NO_SUCH_KEY))
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: entry could not be deleted, status = %d",
rc);
cache_inode_release_fsaldata_key(&key, pgcparam->pclient);
return LRU_LIST_DO_NOT_SET_INVALID;
}
else if(rc == HASHTABLE_ERROR_NO_SUCH_KEY)
{
LogEvent(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: entry already deleted, type=%d, status=%d",
pentry->internal_md.type, rc);
cache_inode_release_fsaldata_key(&key, pgcparam->pclient);
return LRU_LIST_SET_INVALID;
}
/* Clean up the associated ressources in the FSAL */
if(FSAL_IS_ERROR(fsal_status = FSAL_CleanObjectResources(pfsal_handle)))
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: Could'nt free FSAL ressources fsal_status.major=%u",
fsal_status.major);
}
LogFullDebug(COMPONENT_CACHE_INODE_GC,
"++++> pentry %p deleted from HashTable", pentry);
/* Release the hash key data */
cache_inode_release_fsaldata_key(&old_key, pgcparam->pclient);
/* Sanity check: old_value.pdata is expected to be equal to pentry,
* and is released later in this function */
if((cache_entry_t *) old_value.pdata != pentry)
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: unexpected pdata %p from hash table (pentry=%p)",
old_value.pdata, pentry);
}
cache_inode_release_fsaldata_key(&key, pgcparam->pclient);
/* Recover the parent list entries */
parent_iter = pentry->parent_list;
while(parent_iter != NULL)
{
parent_iter_next = parent_iter->next_parent;
ReleaseToPool(parent_iter, &pgcparam->pclient->pool_parent);
parent_iter = parent_iter_next;
}
LogFullDebug(COMPONENT_CACHE_INODE_GC,
"++++> parent directory sent back to pool");
/* If entry is a DIR_CONTINUE or a DIR_BEGINNING, release pdir_data */
if(pentry->internal_md.type == DIR_BEGINNING)
{
/* Put the pentry back to the pool */
ReleaseToPool(pentry->object.dir_begin.pdir_data, &pgcparam->pclient->pool_dir_data);
}
if(pentry->internal_md.type == DIR_CONTINUE)
{
/* Put the pentry back to the pool */
ReleaseToPool(pentry->object.dir_cont.pdir_data, &pgcparam->pclient->pool_dir_data);
}
LogFullDebug(COMPONENT_CACHE_INODE_GC,
"++++> pdir_data (if needed) sent back to pool");
#ifdef _USE_NFS4_ACL
/* If entry has NFS4 ACL, release it. */
cache_inode_gc_acl(pentry);
#endif /* _USE_NFS4_ACL */
/* Free and Destroy the mutex associated with the pentry */
V_w(&pentry->lock);
cache_inode_mutex_destroy(pentry);
/* Put the pentry back to the pool */
ReleaseToPool(pentry, &pgcparam->pclient->pool_entry);
/* Regular exit */
pgcparam->nb_to_be_purged = pgcparam->nb_to_be_purged - 1;
LogFullDebug(COMPONENT_CACHE_INODE_GC,
"++++> pentry %p: clean entry is ok", pentry);
return LRU_LIST_SET_INVALID; /* Cleaning ok */
}
