/**
* @brief Renames an entry
*
* This function calls the FSAL to rename a file, then mirrors the
* operation in the cache.
*
* @param[in] dir_src The source directory
* @param[in] oldname The current name of the file
* @param[in] dir_dest The destination directory
* @param[in] newname The name to be assigned to the object
*
* @retval CACHE_INODE_SUCCESS if operation is a success.
* @retval CACHE_INODE_NOT_FOUND if source object does not exist
* @retval CACHE_INODE_ENTRY_EXISTS on collision.
* @retval CACHE_INODE_NOT_A_DIRECTORY if dir_src or dir_dest is not a
* directory.
* @retval CACHE_INODE_BADNAME if either name is "." or ".."
*/
cache_inode_status_t
cache_inode_rename(cache_entry_t *dir_src,
const char *oldname,
cache_entry_t *dir_dest,
const char *newname)
{
fsal_status_t fsal_status = { 0, 0 };
cache_entry_t *lookup_src = NULL;
cache_entry_t *lookup_dst = NULL;
cache_inode_status_t status = CACHE_INODE_SUCCESS;
cache_inode_status_t status_ref_dir_src = CACHE_INODE_SUCCESS;
cache_inode_status_t status_ref_dir_dst = CACHE_INODE_SUCCESS;
cache_inode_status_t status_ref_dst = CACHE_INODE_SUCCESS;
if ((dir_src->type != DIRECTORY) || (dir_dest->type != DIRECTORY)) {
status = CACHE_INODE_NOT_A_DIRECTORY;
goto out;
}
/* Check for . and .. on oldname and newname. */
if (!strcmp(oldname, ".") || !strcmp(oldname, "..")
|| !strcmp(newname, ".") || !strcmp(newname, "..")) {
status = CACHE_INODE_BADNAME;
goto out;
}
/* Check for object existence in source directory */
status =
cache_inode_lookup_impl(dir_src, oldname, &lookup_src);
if (lookup_src == NULL) {
/* If FSAL FH is stale, then this was managed in
* cache_inode_lookup */
if (status != CACHE_INODE_FSAL_ESTALE)
status = CACHE_INODE_NOT_FOUND;
LogEvent(COMPONENT_CACHE_INODE,
"Rename (%p,%s)->(%p,%s) : source doesn't exist",
dir_src, oldname, dir_dest, newname);
goto out;
}
/* Do not rename a junction node or an export root. */
if (lookup_src->type == DIRECTORY) {
/* Get attr_lock for looking at junction_export */
PTHREAD_RWLOCK_rdlock(&lookup_src->attr_lock);
if (lookup_src->object.dir.junction_export != NULL ||
atomic_fetch_int32_t(&lookup_src->exp_root_refcount)
!= 0) {
/* Trying to rename an export mount point */
LogCrit(COMPONENT_CACHE_INODE,
"Attempt to rename export %s",
oldname);
/* Release attr_lock */
PTHREAD_RWLOCK_unlock(&lookup_src->attr_lock);
status = CACHE_INODE_DIR_NOT_EMPTY;
goto out;
}
/* Release attr_lock */
PTHREAD_RWLOCK_unlock(&lookup_src->attr_lock);
}
/* Check if an object with the new name exists in the destination
directory */
status =
cache_inode_lookup_impl(dir_dest, newname, &lookup_dst);
if (status == CACHE_INODE_SUCCESS) {
LogDebug(COMPONENT_CACHE_INODE,
"Rename (%p,%s)->(%p,%s) : destination already exists",
dir_src, oldname, dir_dest, newname);
}
if (status == CACHE_INODE_NOT_FOUND)
status = CACHE_INODE_SUCCESS;
if (status == CACHE_INODE_FSAL_ESTALE) {
LogDebug(COMPONENT_CACHE_INODE,
"Rename (%p,%s)->(%p,%s) : stale destination", dir_src,
oldname, dir_dest, newname);
}
if (lookup_src == lookup_dst) {
/* Nothing to do according to POSIX and NFS3/4
* If from and to both refer to the same file (they might be
* hard links of each other), then RENAME should perform no
* action and return success */
LogDebug(COMPONENT_CACHE_INODE,
"Rename (%p,%s)->(%p,%s) : same file so skipping out",
dir_src, oldname, dir_dest, newname);
goto out;
}
/* Perform the rename operation in FSAL before doing anything in the
* cache. Indeed, if the FSAL_rename fails unexpectly, the cache would
* be inconsistent!
*
* We do almost no checking before making call because we want to return
* error based on the files actually present in the directories, not
* what we have in our cache.
*/
LogFullDebug(COMPONENT_CACHE_INODE, "about to call FSAL rename");
fsal_status =
dir_src->obj_handle->ops->rename(dir_src->obj_handle,
oldname, dir_dest->obj_handle,
newname);
LogFullDebug(COMPONENT_CACHE_INODE, "returned from FSAL rename");
status_ref_dir_src = cache_inode_refresh_attrs_locked(dir_src);
if (dir_src != dir_dest)
status_ref_dir_dst =
cache_inode_refresh_attrs_locked(dir_dest);
LogFullDebug(COMPONENT_CACHE_INODE, "done refreshing attributes");
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
LogFullDebug(COMPONENT_CACHE_INODE,
"FSAL rename failed with %s",
cache_inode_err_str(status));
goto out;
}
if (lookup_dst) {
/* Force a refresh of the overwritten inode */
status_ref_dst =
cache_inode_refresh_attrs_locked(lookup_dst);
if (status_ref_dst == CACHE_INODE_FSAL_ESTALE)
status_ref_dst = CACHE_INODE_SUCCESS;
}
status = status_ref_dir_src;
if (status == CACHE_INODE_SUCCESS)
status = status_ref_dir_dst;
if (status == CACHE_INODE_SUCCESS)
status = status_ref_dst;
if (status != CACHE_INODE_SUCCESS)
goto out;
/* Must take locks on directories now,
* because if another thread checks source and destination existence
* in the same time, it will try to do the same checks...
* and it will have the same conclusion !!!
*/
src_dest_lock(dir_src, dir_dest);
if (lookup_dst) {
/* Remove the entry from parent dir_entries avl */
status_ref_dir_dst =
cache_inode_remove_cached_dirent(dir_dest, newname);
if (status_ref_dir_dst != CACHE_INODE_SUCCESS) {
LogDebug(COMPONENT_CACHE_INODE,
"remove entry failed with status %s",
cache_inode_err_str(status_ref_dir_dst));
cache_inode_invalidate_all_cached_dirent(dir_dest);
}
}
if (dir_src == dir_dest) {
/* if the rename operation is made within the same dir, then we
* use an optimization: cache_inode_rename_dirent is used
* instead of adding/removing dirent. This limits the use of
* resource in this case */
LogDebug(COMPONENT_CACHE_INODE,
"Rename (%p,%s)->(%p,%s) : source and target "
"directory the same", dir_src, oldname, dir_dest,
newname);
cache_inode_status_t tmp_status =
cache_inode_rename_cached_dirent(dir_dest,
oldname, newname);
if (tmp_status != CACHE_INODE_SUCCESS) {
/* We're obviously out of date. Throw out the cached
directory */
cache_inode_invalidate_all_cached_dirent(dir_dest);
}
} else {
cache_inode_status_t tmp_status = CACHE_INODE_SUCCESS;
LogDebug(COMPONENT_CACHE_INODE,
"Rename (%p,%s)->(%p,%s) : moving entry", dir_src,
oldname, dir_dest, newname);
/* We may have a cache entry for the destination
* filename. If we do, we must delete it : it is stale. */
tmp_status =
cache_inode_remove_cached_dirent(dir_dest, newname);
if (tmp_status != CACHE_INODE_SUCCESS
&& tmp_status != CACHE_INODE_NOT_FOUND) {
LogDebug(COMPONENT_CACHE_INODE,
"Remove stale dirent returned %s",
cache_inode_err_str(tmp_status));
cache_inode_invalidate_all_cached_dirent(dir_dest);
}
tmp_status =
cache_inode_add_cached_dirent(dir_dest, newname, lookup_src,
NULL);
if (tmp_status != CACHE_INODE_SUCCESS) {
/* We're obviously out of date. Throw out the cached
directory */
LogCrit(COMPONENT_CACHE_INODE, "Add dirent returned %s",
cache_inode_err_str(tmp_status));
cache_inode_invalidate_all_cached_dirent(dir_dest);
}
/* Remove the old entry */
tmp_status =
cache_inode_remove_cached_dirent(dir_src, oldname);
if (tmp_status != CACHE_INODE_SUCCESS
&& tmp_status != CACHE_INODE_NOT_FOUND) {
LogDebug(COMPONENT_CACHE_INODE,
"Remove old dirent returned %s",
cache_inode_err_str(tmp_status));
cache_inode_invalidate_all_cached_dirent(dir_src);
}
}
/* unlock entries */
src_dest_unlock(dir_src, dir_dest);
out:
if (lookup_src)
cache_inode_put(lookup_src);
if (lookup_dst)
cache_inode_put(lookup_dst);
return status;
}
/**
*
* cache_inode_readdir_populate: fully reads a directory in FSAL and caches
* the related entries.
*
* fully reads a directory in FSAL and caches the related entries. No MT
* safety managed here !!
*
* @param pentry [IN] entry for the parent directory to be read. This must be
* a DIRECTORY
* @param ht [IN] hash table used for the cache, unused in this call.
* @param pclient [INOUT] ressource allocated by the client for the nfs
* management.
* @param pcontext [IN] FSAL credentials
* @param pstatus [OUT] returned status.
*
*/
cache_inode_status_t cache_inode_readdir_populate(
cache_entry_t * pentry_dir,
cache_inode_policy_t policy,
hash_table_t * ht,
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus)
{
fsal_dir_t fsal_dirhandle;
fsal_status_t fsal_status;
fsal_attrib_list_t dir_attributes;
fsal_cookie_t begin_cookie;
fsal_cookie_t end_cookie;
fsal_count_t nbfound;
fsal_count_t iter;
fsal_boolean_t fsal_eod;
cache_entry_t *pentry = NULL;
cache_entry_t *pentry_parent = pentry_dir;
fsal_attrib_list_t object_attributes;
cache_inode_create_arg_t create_arg;
cache_inode_file_type_t type;
cache_inode_status_t cache_status;
fsal_dirent_t array_dirent[FSAL_READDIR_SIZE + 20];
cache_inode_fsal_data_t new_entry_fsdata;
cache_inode_dir_entry_t *new_dir_entry = NULL;
uint64_t i = 0;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* Only DIRECTORY entries are concerned */
if(pentry_dir->internal_md.type != DIRECTORY)
{
*pstatus = CACHE_INODE_BAD_TYPE;
return *pstatus;
}
#ifdef _USE_MFSL_ASYNC
/* If entry is asynchronous (via MFSL), it should not be repopulated until
it is synced */
if(MFSL_ASYNC_is_synced(&pentry_dir->mobject) == FALSE)
{
/* Directory is asynchronous, do not repopulate it and let it
* in the state 'has_been_readdir == FALSE' */
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
}
#endif
/* If directory is already populated , there is no job to do */
if(pentry_dir->object.dir.has_been_readdir == CACHE_INODE_YES)
{
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
}
/* Invalidate all the dirents */
if(cache_inode_invalidate_all_cached_dirent(pentry_dir,
ht,
pclient,
pstatus) != CACHE_INODE_SUCCESS)
return *pstatus;
/* Open the directory */
dir_attributes.asked_attributes = pclient->attrmask;
#ifdef _USE_MFSL
fsal_status = MFSL_opendir(&pentry_dir->mobject,
pcontext,
&pclient->mfsl_context, &fsal_dirhandle, &dir_attributes, NULL);
#else
fsal_status = FSAL_opendir(&pentry_dir->object.dir.handle,
pcontext, &fsal_dirhandle, &dir_attributes);
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_readdir: Stale FSAL File Handle detected for pentry = %p, fsal_status=(%u,%u)",
pentry_dir, fsal_status.major, fsal_status.minor);
if(cache_inode_kill_entry(pentry_dir, WT_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_readdir: Could not kill entry %p, status = %u",
pentry_dir, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
return *pstatus;
}
/* Loop for readding the directory */
FSAL_SET_COOKIE_BEGINNING(begin_cookie);
FSAL_SET_COOKIE_BEGINNING(end_cookie);
fsal_eod = FALSE;
do
{
#ifdef _USE_MFSL
fsal_status = MFSL_readdir(&fsal_dirhandle,
begin_cookie,
pclient->attrmask,
FSAL_READDIR_SIZE * sizeof(fsal_dirent_t),
array_dirent,
&end_cookie,
&nbfound, &fsal_eod, &pclient->mfsl_context, NULL);
#else
fsal_status = FSAL_readdir(&fsal_dirhandle,
begin_cookie,
pclient->attrmask,
FSAL_READDIR_SIZE * sizeof(fsal_dirent_t),
array_dirent, &end_cookie, &nbfound, &fsal_eod);
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
return *pstatus;
}
for(iter = 0; iter < nbfound; iter++)
{
LogFullDebug(COMPONENT_NFS_READDIR,
"cache readdir populate found entry %s",
array_dirent[iter].name.name);
/* It is not needed to cache '.' and '..' */
if(!FSAL_namecmp(&(array_dirent[iter].name), (fsal_name_t *) & FSAL_DOT) ||
!FSAL_namecmp(&(array_dirent[iter].name), (fsal_name_t *) & FSAL_DOT_DOT))
{
LogFullDebug(COMPONENT_NFS_READDIR,
"cache readdir populate : do not cache . and ..");
continue;
}
/* If dir entry is a symbolic link, its content has to be read */
if((type =
cache_inode_fsal_type_convert(array_dirent[iter].attributes.type)) ==
SYMBOLIC_LINK)
{
#ifdef _USE_MFSL
mfsl_object_t tmp_mfsl;
#endif
/* Let's read the link for caching its value */
object_attributes.asked_attributes = pclient->attrmask;
if( CACHE_INODE_KEEP_CONTENT( pentry_dir->policy ) )
{
#ifdef _USE_MFSL
tmp_mfsl.handle = array_dirent[iter].handle;
fsal_status = MFSL_readlink(&tmp_mfsl,
pcontext,
&pclient->mfsl_context,
&create_arg.link_content, &object_attributes, NULL);
#else
fsal_status = FSAL_readlink(&array_dirent[iter].handle,
pcontext,
&create_arg.link_content, &object_attributes);
#endif
}
else
{
fsal_status.major = ERR_FSAL_NO_ERROR ;
fsal_status.minor = 0 ;
}
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_readdir: Stale FSAL File Handle detected for pentry = %p, fsal_status=(%u,%u)",
pentry_dir, fsal_status.major, fsal_status.minor );
if(cache_inode_kill_entry(pentry_dir, WT_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_readdir: Could not kill entry %p, status = %u",
pentry_dir, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
return *pstatus;
}
}
/* Try adding the entry, if it exists then this existing entry is
returned */
new_entry_fsdata.handle = array_dirent[iter].handle;
new_entry_fsdata.cookie = 0; /* XXX needed? */
if((pentry = cache_inode_new_entry( &new_entry_fsdata,
&array_dirent[iter].attributes,
type,
policy,
&create_arg,
NULL,
ht,
pclient,
pcontext,
FALSE, /* This is population and no creation */
pstatus)) == NULL)
return *pstatus;
cache_status = cache_inode_add_cached_dirent(
pentry_parent,
&(array_dirent[iter].name),
pentry,
ht,
&new_dir_entry,
pclient,
pcontext,
pstatus);
if(cache_status != CACHE_INODE_SUCCESS
&& cache_status != CACHE_INODE_ENTRY_EXISTS)
return *pstatus;
/*
* Remember the FSAL readdir cookie associated with this dirent. This
* is needed for partial directory reads.
*
* to_uint64 should be a lightweight operation--it is in the current
* default implementation. We think the right thing -should- happen
* therefore with if _USE_MFSL.
*
* I'm ignoring the status because the default operation is a memcmp--
* we lready -have- the cookie. */
if (cache_status != CACHE_INODE_ENTRY_EXISTS) {
(void) FSAL_cookie_to_uint64(&array_dirent[iter].handle,
pcontext, &array_dirent[iter].cookie,
&new_dir_entry->fsal_cookie);
/* we are filling in all entries, and the cookie avl was
* cleared before adding dirents */
new_dir_entry->cookie = i; /* still an offset */
(void) avltree_insert(&new_dir_entry->node_c,
&pentry_parent->object.dir.cookies);
} /* !exist */
} /* iter */
/* Get prepared for next step */
begin_cookie = end_cookie;
/* next offset */
i++;
}
while(fsal_eod != TRUE);
/* Close the directory */
#ifdef _USE_MFSL
fsal_status = MFSL_closedir(&fsal_dirhandle, &pclient->mfsl_context, NULL);
#else
fsal_status = FSAL_closedir(&fsal_dirhandle);
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
return *pstatus;
}
/* End of work */
pentry_dir->object.dir.has_been_readdir = CACHE_INODE_YES;
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
} /* cache_inode_readdir_populate */
cache_inode_status_t
cache_inode_remove(cache_entry_t *entry,
const char *name,
struct req_op_context *req_ctx)
{
cache_entry_t *to_remove_entry = NULL;
fsal_status_t fsal_status = {0, 0};
cache_inode_status_t status = CACHE_INODE_SUCCESS;
cache_inode_status_t status_ref_entry = CACHE_INODE_SUCCESS;
cache_inode_status_t status_ref_to_remove_entry = CACHE_INODE_SUCCESS;
fsal_accessflags_t access_mask = 0;
if(entry->type != DIRECTORY) {
status = CACHE_INODE_NOT_A_DIRECTORY;
goto out;
}
/* Check if caller is allowed to perform the operation */
access_mask = (FSAL_MODE_MASK_SET(FSAL_W_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_DELETE_CHILD));
status = cache_inode_access(entry,
access_mask,
req_ctx);
if (status != CACHE_INODE_SUCCESS) {
goto out;
}
/* Factor this somewhat. In the case where the directory hasn't
been populated, the entry may not exist in the cache and we'd
be bringing it in just to dispose of it. */
/* Looks up for the entry to remove */
PTHREAD_RWLOCK_rdlock(&entry->content_lock);
status = cache_inode_lookup_impl(entry,
name,
req_ctx,
&to_remove_entry);
PTHREAD_RWLOCK_unlock(&entry->content_lock);
if (to_remove_entry == NULL) {
goto out;
}
status = cache_inode_check_sticky(entry, to_remove_entry, req_ctx);
if (status != CACHE_INODE_SUCCESS) {
goto out;
}
LogDebug(COMPONENT_CACHE_INODE,
"---> Cache_inode_remove : %s", name);
if (is_open(to_remove_entry)) {
/* entry is not locked and seems to be open for fd caching purpose.
* candidate for closing since unlink of an open file results in 'silly
* rename' on certain platforms */
status = cache_inode_close(to_remove_entry,
CACHE_INODE_FLAG_REALLYCLOSE);
if (status != CACHE_INODE_SUCCESS) {
/* non-fatal error. log the warning and move on */
LogCrit(COMPONENT_CACHE_INODE,
"Error closing file before unlink: %d.",
status);
}
}
fsal_status = entry->obj_handle->ops->unlink(entry->obj_handle, req_ctx,
name);
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
if(to_remove_entry->type == DIRECTORY &&
status == CACHE_INODE_DIR_NOT_EMPTY) {
/* its dirent tree is probably stale, flush it
* to try and make things right again */
PTHREAD_RWLOCK_wrlock(&to_remove_entry->content_lock);
(void)cache_inode_invalidate_all_cached_dirent(to_remove_entry);
PTHREAD_RWLOCK_unlock(&to_remove_entry->content_lock);
}
goto out;
}
/* Remove the entry from parent dir_entries avl */
PTHREAD_RWLOCK_wrlock(&entry->content_lock);
cache_inode_remove_cached_dirent(entry, name, req_ctx);
PTHREAD_RWLOCK_unlock(&entry->content_lock);
status_ref_entry = cache_inode_refresh_attrs_locked(entry, req_ctx);
if(FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
goto out;
}
/* Update the attributes for the removed entry */
status_ref_to_remove_entry = cache_inode_refresh_attrs_locked(to_remove_entry, req_ctx);
if (status_ref_to_remove_entry == CACHE_INODE_FSAL_ESTALE) {
status_ref_to_remove_entry = CACHE_INODE_SUCCESS;
}
if (((status = status_ref_entry) != CACHE_INODE_SUCCESS) ||
((status = status_ref_to_remove_entry) != CACHE_INODE_SUCCESS)) {
goto out;
}
out:
LogFullDebug(COMPONENT_CACHE_INODE,
"cache_inode_remove_cached_dirent: status=%d", status);
/* This is for the reference taken by lookup */
if (to_remove_entry) {
cache_inode_put(to_remove_entry);
}
return status;
}
static cache_inode_status_t
cache_inode_readdir_populate(cache_entry_t *directory)
{
fsal_status_t fsal_status;
bool eod = false;
cache_inode_status_t status = CACHE_INODE_SUCCESS;
struct cache_inode_populate_cb_state state;
/* Only DIRECTORY entries are concerned */
if (directory->type != DIRECTORY) {
status = CACHE_INODE_NOT_A_DIRECTORY;
LogDebug(COMPONENT_NFS_READDIR,
"CACHE_INODE_NOT_A_DIRECTORY");
return status;
}
if ((directory->flags & CACHE_INODE_DIR_POPULATED)
&& (directory->flags & CACHE_INODE_TRUST_CONTENT)) {
LogFullDebug(COMPONENT_NFS_READDIR,
"CACHE_INODE_DIR_POPULATED and CACHE_INODE_TRUST_CONTENT"
);
status = CACHE_INODE_SUCCESS;
return status;
}
/* Invalidate all the dirents */
status = cache_inode_invalidate_all_cached_dirent(directory);
if (status != CACHE_INODE_SUCCESS) {
LogDebug(COMPONENT_NFS_READDIR,
"cache_inode_invalidate_all_cached_dirent status=%s",
cache_inode_err_str(status));
return status;
}
state.directory = directory;
state.status = &status;
state.offset_cookie = 0;
fsal_status =
directory->obj_handle->obj_ops.readdir(directory->obj_handle,
NULL,
(void *)&state,
populate_dirent,
&eod);
if (FSAL_IS_ERROR(fsal_status)) {
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_NFS_READDIR,
"FSAL returned STALE from readdir.");
cache_inode_kill_entry(directory);
}
status = cache_inode_error_convert(fsal_status);
LogDebug(COMPONENT_NFS_READDIR,
"FSAL readdir status=%s",
cache_inode_err_str(status));
return status;
}
/* we were supposed to read to the end.... */
if (!eod && cache_param.retry_readdir) {
LogInfo(COMPONENT_NFS_READDIR,
"Readdir didn't reach eod on dir %p (status %s)",
directory->obj_handle, cache_inode_err_str(status));
status = CACHE_INODE_DELAY;
} else if (eod) {
/* End of work */
atomic_set_uint32_t_bits(&directory->flags,
CACHE_INODE_DIR_POPULATED);
/* override status in case it was set to a
* minor error in the callback */
status = CACHE_INODE_SUCCESS;
}
/* If !eod (and fsal_status isn't an error), then the only error path
* is through a callback failure and status has been set the
* populate_dirent callback */
return status;
} /* cache_inode_readdir_populate */
cache_inode_status_t
cache_inode_remove(cache_entry_t *entry, const char *name)
{
cache_entry_t *to_remove_entry = NULL;
fsal_status_t fsal_status = { 0, 0 };
cache_inode_status_t status = CACHE_INODE_SUCCESS;
cache_inode_status_t status_ref_entry = CACHE_INODE_SUCCESS;
if (entry->type != DIRECTORY) {
status = CACHE_INODE_NOT_A_DIRECTORY;
goto out;
}
/* Factor this somewhat. In the case where the directory hasn't
been populated, the entry may not exist in the cache and we'd
be bringing it in just to dispose of it. */
/* Looks up for the entry to remove */
status =
cache_inode_lookup_impl(entry, name, &to_remove_entry);
if (to_remove_entry == NULL) {
LogFullDebug(COMPONENT_CACHE_INODE, "lookup %s failure %s",
name, cache_inode_err_str(status));
goto out;
}
/* Do not remove a junction node or an export root. */
if (to_remove_entry->type == DIRECTORY) {
/* Get attr_lock for looking at junction_export */
PTHREAD_RWLOCK_rdlock(&to_remove_entry->attr_lock);
if (to_remove_entry->object.dir.junction_export != NULL ||
atomic_fetch_int32_t(&to_remove_entry->exp_root_refcount)
!= 0) {
/* Trying to remove an export mount point */
LogCrit(COMPONENT_CACHE_INODE,
"Attempt to remove export %s",
name);
/* Release attr_lock */
PTHREAD_RWLOCK_unlock(&to_remove_entry->attr_lock);
status = CACHE_INODE_DIR_NOT_EMPTY;
goto out;
}
/* Release attr_lock */
PTHREAD_RWLOCK_unlock(&to_remove_entry->attr_lock);
}
LogDebug(COMPONENT_CACHE_INODE, "%s", name);
if (is_open(to_remove_entry)) {
/* entry is not locked and seems to be open for fd caching
* purpose.
* candidate for closing since unlink of an open file results
* in 'silly rename' on certain platforms */
status =
cache_inode_close(to_remove_entry,
CACHE_INODE_FLAG_REALLYCLOSE);
if (status != CACHE_INODE_SUCCESS) {
/* non-fatal error. log the warning and move on */
LogCrit(COMPONENT_CACHE_INODE,
"Error closing %s before unlink: %s.", name,
cache_inode_err_str(status));
}
}
fsal_status =
entry->obj_handle->obj_ops.unlink(entry->obj_handle, name);
if (FSAL_IS_ERROR(fsal_status)) {
if (fsal_status.major == ERR_FSAL_STALE)
cache_inode_kill_entry(entry);
status = cache_inode_error_convert(fsal_status);
LogFullDebug(COMPONENT_CACHE_INODE, "unlink %s failure %s",
name, cache_inode_err_str(status));
if (to_remove_entry->type == DIRECTORY
&& status == CACHE_INODE_DIR_NOT_EMPTY) {
/* its dirent tree is probably stale, flush it
* to try and make things right again */
PTHREAD_RWLOCK_wrlock(&to_remove_entry->content_lock);
(void)
cache_inode_invalidate_all_cached_dirent
(to_remove_entry);
PTHREAD_RWLOCK_unlock(&to_remove_entry->content_lock);
}
goto out;
}
/* Remove the entry from parent dir_entries avl */
PTHREAD_RWLOCK_wrlock(&entry->content_lock);
status_ref_entry = cache_inode_remove_cached_dirent(entry, name);
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_remove_cached_dirent %s status %s", name,
cache_inode_err_str(status_ref_entry));
PTHREAD_RWLOCK_unlock(&entry->content_lock);
status_ref_entry = cache_inode_refresh_attrs_locked(entry);
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
LogFullDebug(COMPONENT_CACHE_INODE,
"not sure this code makes sense %s failure %s",
name, cache_inode_err_str(status));
goto out;
}
/* Update the attributes for the removed entry */
(void)cache_inode_refresh_attrs_locked(to_remove_entry);
status = status_ref_entry;
if (status != CACHE_INODE_SUCCESS) {
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_refresh_attrs_locked(entry %p %s) "
"returned %s", entry, name,
cache_inode_err_str(status_ref_entry));
}
out:
LogFullDebug(COMPONENT_CACHE_INODE, "remove %s: status=%s", name,
cache_inode_err_str(status));
/* This is for the reference taken by lookup */
if (to_remove_entry)
cache_inode_put(to_remove_entry);
return status;
}
/**
*
* cache_inode_renew_entry: Renews the attributes for an entry.
*
* Sets the attributes for an entry located in the cache by its address. Attributes are provided
* with compliance to the underlying FSAL semantics. Attributes that are set are returned in "*pattr".
*
* @param pentry_parent [IN] entry for the parent directory to be managed.
* @param pattr [OUT] renewed attributes for the entry that we have found.
* @param pclient [INOUT] ressource allocated by the client for the nfs management.
* @param pcontext [IN] FSAL credentials
* @param pstatus [OUT] returned status.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
@return Other errors shows a FSAL error.
*
*/
cache_inode_status_t cache_inode_renew_entry(cache_entry_t * pentry,
fsal_attrib_list_t * pattr,
hash_table_t * ht,
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus)
{
fsal_handle_t *pfsal_handle = NULL;
fsal_status_t fsal_status;
fsal_attrib_list_t object_attributes;
fsal_path_t link_content;
time_t current_time = time(NULL);
time_t entry_time = pentry->internal_md.refresh_time;
/* If we do nothing (no expiration) then everything is all right */
*pstatus = CACHE_INODE_SUCCESS;
if(isFullDebug(COMPONENT_CACHE_INODE))
{
char *type;
char grace[20], grace2[20];
unsigned int elapsed = (unsigned int)current_time - (unsigned int)entry_time;
int print = 1;
cache_inode_expire_to_str(pclient->expire_type_attr, pclient->grace_period_attr, grace);
switch(pentry->internal_md.type)
{
case UNASSIGNED:
type = "UNASSIGNED";
break;
case REGULAR_FILE:
type = "REGULAR_FILE";
break;
case CHARACTER_FILE:
type = "CHARACTER_FILE";
break;
case BLOCK_FILE:
type = "BLOCK_FILE";
break;
case SYMBOLIC_LINK:
print = 0;
cache_inode_expire_to_str(pclient->expire_type_link, pclient->grace_period_link, grace2);
LogDebug(COMPONENT_CACHE_INODE,
"Renew Entry test of %p for SYMBOLIC_LINK elapsed time=%u, grace_period_attr=%s, grace_period_link=%s",
pentry, elapsed, grace, grace2);
break;
case SOCKET_FILE:
type = "SOCKET_FILE";
break;
case FIFO_FILE:
type = "FIFO_FILE";
break;
case DIRECTORY:
print = 0;
cache_inode_expire_to_str(pclient->expire_type_dirent, pclient->grace_period_dirent, grace2);
LogDebug(COMPONENT_CACHE_INODE,
"Renew Entry test of %p for DIRECTORY elapsed time=%u, grace_period_attr=%s, grace_period_dirent=%s, has_been_readdir=%u",
pentry, elapsed, grace, grace2,
pentry->object.dir.has_been_readdir);
break;
case FS_JUNCTION:
type = "FS_JUNCTION";
break;
case RECYCLED:
type = "RECYCLED";
break;
default:
type = "UNKNOWN";
break;
}
if(print)
{
LogDebug(COMPONENT_CACHE_INODE,
"Renew Entry test of %p for %s elapsed time=%u, grace_period_attr=%s",
pentry, type, elapsed, grace);
}
}
/* An entry that is a regular file with an associated File Content Entry won't
* expire until data exists in File Content Cache, to avoid attributes incoherency */
/* @todo: BUGAZOMEU: I got serious doubts on the following blocks: possible trouble if using data caching */
if(pentry->internal_md.type == REGULAR_FILE &&
pentry->object.file.pentry_content != NULL)
{
/* Successfull exit without having nothing to do ... */
LogDebug(COMPONENT_CACHE_INODE,
"Entry %p is a REGULAR_FILE with associated data cached %p, no expiration",
pentry, pentry->object.file.pentry_content);
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
}
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry use getattr/mtime checking %d, is dir "
"beginning %d, has bit in mask %d, has been readdir %d state %d",
pclient->getattr_dir_invalidation,
pentry->internal_md.type == DIRECTORY,
(int) FSAL_TEST_MASK(pclient->attrmask, FSAL_ATTR_MTIME),
pentry->object.dir.has_been_readdir,
pentry->internal_md.valid_state);
/* Do we use getattr/mtime checking */
if(pclient->getattr_dir_invalidation &&
pentry->internal_md.type == DIRECTORY &&
FSAL_TEST_MASK(pclient->attrmask, FSAL_ATTR_MTIME) /*&&
pentry->object.dir.has_been_readdir == CACHE_INODE_YES*/)
{
/* This checking is to be done ... */
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry testing directory mtime");
pfsal_handle = &pentry->object.dir.handle;
/* Call FSAL to get the attributes */
object_attributes.asked_attributes = pclient->attrmask;
fsal_status = FSAL_getattrs(pfsal_handle, pcontext, &object_attributes);
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Stale FSAL File Handle detected for pentry = %p, line %u, fsal_status=(%u,%u)",
pentry, __LINE__, fsal_status.major, fsal_status.minor);
if(cache_inode_kill_entry(pentry, NO_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_RENEW_ENTRY])++;
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: returning %d (%s) from FSAL_getattrs for getattr/mtime checking",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Entry=%p, type=%d, Cached Time=%d, FSAL Time=%d",
pentry, pentry->internal_md.type,
pentry->object.dir.attributes.mtime.seconds,
object_attributes.mtime.seconds);
/* Compare the FSAL mtime and the cached mtime */
if(pentry->object.dir.attributes.mtime.seconds <
object_attributes.mtime.seconds)
{
/* Cached directory content is obsolete, it must be renewed */
cache_inode_set_attributes(pentry, &object_attributes);
/* Return the attributes as set */
if(pattr != NULL)
*pattr = object_attributes;
/* Set the directory content as "to be renewed" */
/* Next call to cache_inode_readdir will repopulate the dirent array */
pentry->object.dir.has_been_readdir = CACHE_INODE_RENEW_NEEDED;
/* Set the refresh time for the cache entry */
pentry->internal_md.refresh_time = time(NULL);
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: cached directory content for entry %p must be renewed, due to getattr mismatch",
pentry);
if(cache_inode_invalidate_all_cached_dirent(pentry, ht, pclient, pstatus)
!= CACHE_INODE_SUCCESS)
{
/* Should never happen */
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_invalidate_all_cached_dirent returned %d (%s)",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
} /* if( pentry->object.dir.attributes.mtime < object_attributes.asked_attributes.mtime ) */
}
/* if( pclient->getattr_dir_invalidation && ... */
/* Check for dir content expiration and/or staleness */
if(pentry->internal_md.type == DIRECTORY &&
pclient->expire_type_dirent != CACHE_INODE_EXPIRE_NEVER &&
pentry->object.dir.has_been_readdir == CACHE_INODE_YES &&
((current_time - entry_time >= pclient->grace_period_dirent)
|| (pentry->internal_md.valid_state == STALE)))
{
/* Would be better if state was a flag that we could and/or the bits but
* in any case we need to get rid of stale so we only go through here
* once.
*/
if ( pentry->internal_md.valid_state == STALE )
pentry->internal_md.valid_state = VALID;
/* stats */
(pclient->stat.func_stats.nb_call[CACHE_INODE_RENEW_ENTRY])++;
/* Log */
LogDebug(COMPONENT_CACHE_INODE,
"Case 1: cached directory entries for entry %p must be renewed"
" (has been readdir)", pentry);
if(isFullDebug(COMPONENT_CACHE_INODE))
{
char name[1024];
struct avltree_node *d_node;
cache_inode_dir_entry_t *d_dirent;
int i = 0;
d_node = avltree_first(&pentry->object.dir.dentries);
do {
d_dirent = avltree_container_of(d_node, cache_inode_dir_entry_t,
node_n);
if (d_dirent->pentry->internal_md.valid_state == VALID) {
FSAL_name2str(&(d_dirent->name), name, 1023);
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Entry %d %s",
i, name);
}
i++;
} while ((d_node = avltree_next(d_node)));
}
/* Do the getattr if it had not being done before */
if(pfsal_handle == NULL)
{
pfsal_handle = &pentry->object.dir.handle;
/* Call FSAL to get the attributes */
object_attributes.asked_attributes = pclient->attrmask;
fsal_status = FSAL_getattrs(pfsal_handle, pcontext, &object_attributes);
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_RENEW_ENTRY])++;
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Stale FSAL File Handle detected for pentry = %p, line %u, fsal_status=(%u,%u)",
pentry, __LINE__,fsal_status.major, fsal_status.minor );
if(cache_inode_kill_entry(pentry, NO_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry returning %d (%s) from FSAL_getattrs for directory entries (1)",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
}
cache_inode_set_attributes(pentry, &object_attributes);
/* Return the attributes as set */
if(pattr != NULL)
*pattr = object_attributes;
/* Set the directory content as "to be renewed" */
/* Next call to cache_inode_readdir will repopulate the dirent array */
pentry->object.dir.has_been_readdir = CACHE_INODE_RENEW_NEEDED;
/* Set the refresh time for the cache entry */
pentry->internal_md.refresh_time = time(NULL);
}
/* if( pentry->internal_md.type == DIRECTORY && ... */
/* if the directory has not been readdir, only update its attributes */
else if(pentry->internal_md.type == DIRECTORY &&
pclient->expire_type_attr != CACHE_INODE_EXPIRE_NEVER &&
pentry->object.dir.has_been_readdir != CACHE_INODE_YES &&
((current_time - entry_time >= pclient->grace_period_attr) || (pentry->internal_md.valid_state == STALE)))
{
/* Would be better if state was a flag that we could and/or the bits but
* in any case we need to get rid of stale so we only go through here
* once.
*/
if ( pentry->internal_md.valid_state == STALE )
pentry->internal_md.valid_state = VALID;
/* stats */
(pclient->stat.func_stats.nb_call[CACHE_INODE_RENEW_ENTRY])++;
/* Log */
LogDebug(COMPONENT_CACHE_INODE,
"Case 2: cached directory entries for entry %p must be renewed (has not been readdir)",
pentry);
if(isFullDebug(COMPONENT_CACHE_INODE))
{
char name[1024];
struct avltree_node *d_node;
cache_inode_dir_entry_t *d_dirent;
int i = 0;
d_node = avltree_first(&pentry->object.dir.dentries);
do {
d_dirent = avltree_container_of(d_node, cache_inode_dir_entry_t,
node_n);
if (d_dirent->pentry->internal_md.valid_state == VALID) {
FSAL_name2str(&(d_dirent->name), name, 1023);
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Entry %d %s",
i, name);
}
i++;
} while ((d_node = avltree_next(d_node)));
}
pfsal_handle = &pentry->object.dir.handle;
/* Call FSAL to get the attributes */
object_attributes.asked_attributes = pclient->attrmask;
fsal_status = FSAL_getattrs(pfsal_handle, pcontext, &object_attributes);
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_RENEW_ENTRY])++;
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Stale FSAL File Handle detected for pentry = %p, line %u, fsal_status=(%u,%u)",
pentry, __LINE__,fsal_status.major, fsal_status.minor );
if(cache_inode_kill_entry(pentry, NO_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry returning %d (%s) from FSAL_getattrs for directory entries (2)",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
cache_inode_set_attributes(pentry, &object_attributes);
/* Return the attributes as set */
if(pattr != NULL)
*pattr = object_attributes;
/* Set the refresh time for the cache entry */
pentry->internal_md.refresh_time = time(NULL);
}
/* else if( pentry->internal_md.type == DIRECTORY && ... */
/* Check for attributes expiration in other cases */
else if(pentry->internal_md.type != DIRECTORY &&
pclient->expire_type_attr != CACHE_INODE_EXPIRE_NEVER &&
((current_time - entry_time >= pclient->grace_period_attr)
|| (pentry->internal_md.valid_state == STALE)))
{
/* Would be better if state was a flag that we could and/or the bits but
* in any case we need to get rid of stale so we only go through here
* once.
*/
if ( pentry->internal_md.valid_state == STALE )
pentry->internal_md.valid_state = VALID;
/* stats */
(pclient->stat.func_stats.nb_call[CACHE_INODE_RENEW_ENTRY])++;
/* Log */
LogDebug(COMPONENT_CACHE_INODE,
"Attributes for entry %p must be renewed", pentry);
switch (pentry->internal_md.type)
{
case REGULAR_FILE:
pfsal_handle = &pentry->object.file.handle;
break;
case SYMBOLIC_LINK:
assert(pentry->object.symlink);
pfsal_handle = &pentry->object.symlink->handle;
break;
case SOCKET_FILE:
case FIFO_FILE:
case CHARACTER_FILE:
case BLOCK_FILE:
pfsal_handle = &pentry->object.special_obj.handle;
break;
case DIRECTORY:
case FS_JUNCTION:
case UNASSIGNED:
case RECYCLED:
LogCrit(COMPONENT_CACHE_INODE,
"WARNING: unknown source pentry type: internal_md.type=%d, line %d in file %s",
pentry->internal_md.type, __LINE__, __FILE__);
*pstatus = CACHE_INODE_BAD_TYPE;
return *pstatus;
}
/* Call FSAL to get the attributes */
object_attributes.asked_attributes = pclient->attrmask;
#ifdef _USE_MFSL
fsal_status = FSAL_getattrs_descriptor(&(cache_inode_fd(pentry)->fsal_file), pfsal_handle, pcontext, &object_attributes);
#else
fsal_status = FSAL_getattrs_descriptor(cache_inode_fd(pentry), pfsal_handle, pcontext, &object_attributes);
#endif
if(FSAL_IS_ERROR(fsal_status) && fsal_status.major == ERR_FSAL_NOT_OPENED)
{
//TODO: LOOKATME !!!!!
fsal_status = FSAL_getattrs(pfsal_handle, pcontext, &object_attributes);
}
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_RENEW_ENTRY])++;
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Stale FSAL File Handle detected for pentry = %p, line %u, fsal_status=(%u,%u)",
pentry, __LINE__,fsal_status.major, fsal_status.minor );
if(cache_inode_kill_entry(pentry, NO_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry returning %d (%s) from FSAL_getattrs for non directories",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
/* Keep the new attribute in cache */
cache_inode_set_attributes(pentry, &object_attributes);
/* Return the attributes as set */
if(pattr != NULL)
*pattr = object_attributes;
/* Set the refresh time for the cache entry */
pentry->internal_md.refresh_time = time(NULL);
}
/* if( pentry->internal_md.type != DIR_CONTINUE && ... */
/* Check for link content expiration */
if(pentry->internal_md.type == SYMBOLIC_LINK &&
pclient->expire_type_link != CACHE_INODE_EXPIRE_NEVER &&
((current_time - entry_time >= pclient->grace_period_link)
|| (pentry->internal_md.valid_state == STALE)))
{
assert(pentry->object.symlink);
pfsal_handle = &pentry->object.symlink->handle;
/* Would be better if state was a flag that we could and/or the bits but
* in any case we need to get rid of stale so we only go through here
* once.
*/
if ( pentry->internal_md.valid_state == STALE )
pentry->internal_md.valid_state = VALID;
assert(pentry->object.symlink);
pfsal_handle = &pentry->object.symlink->handle;
/* Log */
LogDebug(COMPONENT_CACHE_INODE,
"cached link content for entry %p must be renewed", pentry);
FSAL_CLEAR_MASK(object_attributes.asked_attributes);
FSAL_SET_MASK(object_attributes.asked_attributes, pclient->attrmask);
if( CACHE_INODE_KEEP_CONTENT( pentry->policy ) )
{
#ifdef _USE_MFSL
fsal_status =
MFSL_readlink(&pentry->mobject, pcontext, &pclient->mfsl_context, &link_content,
&object_attributes, NULL);
#else
fsal_status =
FSAL_readlink(pfsal_handle, pcontext, &link_content, &object_attributes);
#endif
}
else
{
fsal_status.major = ERR_FSAL_NO_ERROR ;
fsal_status.minor = 0 ;
}
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_RENEW_ENTRY] += 1;
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Stale FSAL File Handle detected for pentry = %p, line %u, fsal_status=(%u,%u)",
pentry, __LINE__,fsal_status.major, fsal_status.minor );
if(cache_inode_kill_entry(pentry, NO_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_renew_entry: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
}
else
{
assert(pentry->object.symlink);
fsal_status = FSAL_pathcpy(&pentry->object.symlink->content, &link_content); /* copy ctor? */
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_RENEW_ENTRY] += 1;
}
}
/* Set the refresh time for the cache entry */
pentry->internal_md.refresh_time = time(NULL);
}
/* if( pentry->internal_md.type == SYMBOLIC_LINK && ... */
LogDebug(COMPONENT_CACHE_INODE, "cache_inode_renew_entry returning %d (%s)",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
} /* cache_inode_renew_entry */
