uint32_t x2__atomic_clear_uint32_t_bits(uint32_t *p, uint32_t v)
{
return atomic_clear_uint32_t_bits(p, v);
}
/**
*
* @brief invalidates an entry in the cache
*
* This function invalidates the related cache entry correponding to a
* FSAL handle. It is designed to be called when an FSAL upcall is
* triggered.
*
* @param[in] handle FSAL handle for the entry to be invalidated
* @param[out] status Returned status
*
* @retval CACHE_INODE_SUCCESS if operation is a success
* @retval CACHE_INODE_INVALID_ARGUMENT bad parameter(s) as input
* @retval CACHE_INODE_NOT_FOUND if entry is not cached
* @retval CACHE_INODE_STATE_CONFLICT if invalidating this entry would
* result is state conflict
* @retval CACHE_INODE_INCONSISTENT_ENTRY if entry is not consistent
* @retval Other errors shows a FSAL error.
*
*/
cache_inode_status_t
cache_inode_invalidate(cache_inode_fsal_data_t *fsal_data,
cache_inode_status_t *status,
uint32_t flags)
{
hash_buffer_t key, value;
int rc = 0 ;
cache_entry_t *entry;
struct hash_latch latch;
if (status == NULL || fsal_data == NULL) {
*status = CACHE_INODE_INVALID_ARGUMENT;
goto out;
}
/* Locate the entry in the cache */
FSAL_ExpandHandle(NULL, /* pcontext but not used... */
FSAL_DIGEST_SIZEOF,
&fsal_data->fh_desc);
/* Turn the input to a hash key */
key.pdata = fsal_data->fh_desc.start;
key.len = fsal_data->fh_desc.len;
if ((rc = HashTable_GetLatch(fh_to_cache_entry_ht,
&key,
&value,
FALSE,
&latch)) == HASHTABLE_ERROR_NO_SUCH_KEY) {
/* Entry is not cached */
HashTable_ReleaseLatched(fh_to_cache_entry_ht, &latch);
*status = CACHE_INODE_NOT_FOUND;
return *status;
} else if (rc != HASHTABLE_SUCCESS) {
LogCrit(COMPONENT_CACHE_INODE,
"Unexpected error %u while calling HashTable_GetLatch", rc) ;
*status = CACHE_INODE_INVALID_ARGUMENT;
goto out;
}
entry = value.pdata;
if (cache_inode_lru_ref(entry, 0) != CACHE_INODE_SUCCESS) {
HashTable_ReleaseLatched(fh_to_cache_entry_ht, &latch);
*status = CACHE_INODE_NOT_FOUND;
return *status;
}
HashTable_ReleaseLatched(fh_to_cache_entry_ht, &latch);
PTHREAD_RWLOCK_WRLOCK(&entry->attr_lock);
PTHREAD_RWLOCK_WRLOCK(&entry->content_lock);
/* We can invalidate entries with state just fine. We force
Cache_inode to contact the FSAL for any use of content or
attributes, and if the FSAL indicates the entry is stale, it
can be disposed of then. */
/* We should have a way to invalidate content and attributes
separately. Or at least a way to invalidate attributes
without invalidating content (since any change in content
really ought to modify mtime, at least.) */
if ((flags & CACHE_INODE_INVALIDATE_CLEARBITS) != 0)
atomic_clear_uint32_t_bits(&entry->flags,
CACHE_INODE_TRUST_ATTRS |
CACHE_INODE_DIR_POPULATED |
CACHE_INODE_TRUST_CONTENT);
/* The main reason for holding the lock at this point is so we
don't clear the trust bits while someone is populating the
directory or refreshing attributes. */
if (((flags & CACHE_INODE_INVALIDATE_CLOSE) != 0) &&
(entry->type == REGULAR_FILE)) {
cache_inode_close(entry,
NULL,
(CACHE_INODE_FLAG_REALLYCLOSE |
CACHE_INODE_FLAG_CONTENT_HAVE |
CACHE_INODE_FLAG_CONTENT_HOLD),
status);
}
PTHREAD_RWLOCK_UNLOCK(&entry->attr_lock);
PTHREAD_RWLOCK_UNLOCK(&entry->content_lock);
cache_inode_lru_unref(entry, 0);
out:
/* Memory copying attributes with every call is expensive.
Let's not do it. */
return (*status);
} /* cache_inode_invalidate */
cache_inode_status_t
cache_inode_readdir(cache_entry_t *directory,
uint64_t cookie, unsigned int *nbfound,
bool *eod_met,
attrmask_t attrmask,
cache_inode_getattr_cb_t cb,
void *opaque)
{
/* The entry being examined */
cache_inode_dir_entry_t *dirent = NULL;
/* The node in the tree being traversed */
struct avltree_node *dirent_node;
/* The access mask corresponding to permission to list directory
entries */
fsal_accessflags_t access_mask =
(FSAL_MODE_MASK_SET(FSAL_R_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_LIST_DIR));
fsal_accessflags_t access_mask_attr =
(FSAL_MODE_MASK_SET(FSAL_R_OK) | FSAL_MODE_MASK_SET(FSAL_X_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_LIST_DIR) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_EXECUTE));
cache_inode_status_t status = CACHE_INODE_SUCCESS;
cache_inode_status_t attr_status;
struct cache_inode_readdir_cb_parms cb_parms = { opaque, NULL,
true, 0, true };
bool retry_stale = true;
LogFullDebug(COMPONENT_NFS_READDIR,
"Enter....");
/* readdir can be done only with a directory */
if (directory->type != DIRECTORY) {
status = CACHE_INODE_NOT_A_DIRECTORY;
/* no lock acquired so far, just return status */
LogFullDebug(COMPONENT_NFS_READDIR,
"Not a directory");
return status;
}
/* cache_inode_lock_trust_attrs can return an error, and no lock will
* be acquired */
status = cache_inode_lock_trust_attrs(directory, false);
if (status != CACHE_INODE_SUCCESS) {
LogDebug(COMPONENT_NFS_READDIR,
"cache_inode_lock_trust_attrs status=%s",
cache_inode_err_str(status));
return status;
}
/* Adjust access mask if ACL is asked for.
* NOTE: We intentionally do NOT check ACE4_READ_ATTR.
*/
if ((attrmask & ATTR_ACL) != 0) {
access_mask |= FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_READ_ACL);
access_mask_attr |= FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_READ_ACL);
}
/* Check if user (as specified by the credentials) is authorized to read
* the directory or not */
status = cache_inode_access_no_mutex(directory, access_mask);
if (status != CACHE_INODE_SUCCESS) {
LogFullDebug(COMPONENT_NFS_READDIR,
"permission check for directory status=%s",
cache_inode_err_str(status));
PTHREAD_RWLOCK_unlock(&directory->attr_lock);
return status;
}
if (attrmask != 0) {
/* Check for access permission to get attributes */
attr_status = cache_inode_access_no_mutex(directory,
access_mask_attr);
if (attr_status != CACHE_INODE_SUCCESS) {
LogFullDebug(COMPONENT_NFS_READDIR,
"permission check for attributes "
"status=%s",
cache_inode_err_str(attr_status));
}
} else
/* No attributes requested, we don't need permission */
attr_status = CACHE_INODE_SUCCESS;
PTHREAD_RWLOCK_rdlock(&directory->content_lock);
PTHREAD_RWLOCK_unlock(&directory->attr_lock);
if (!
((directory->flags & CACHE_INODE_TRUST_CONTENT)
&& (directory->flags & CACHE_INODE_DIR_POPULATED))) {
PTHREAD_RWLOCK_unlock(&directory->content_lock);
PTHREAD_RWLOCK_wrlock(&directory->content_lock);
status = cache_inode_readdir_populate(directory);
if (status != CACHE_INODE_SUCCESS) {
LogFullDebug(COMPONENT_NFS_READDIR,
"cache_inode_readdir_populate status=%s",
cache_inode_err_str(status));
goto unlock_dir;
}
}
/* deal with initial cookie value:
* 1. cookie is invalid (-should- be checked by caller)
* 2. cookie is 0 (first cookie) -- ok
* 3. cookie is > than highest dirent position (error)
* 4. cookie <= highest dirent position but > highest cached cookie
* (currently equivalent to #2, because we pre-populate the cookie
* avl)
* 5. cookie is in cached range -- ok */
if (cookie > 0) {
/* N.B., cache_inode_avl_qp_insert_s ensures k > 2 */
if (cookie < 3) {
status = CACHE_INODE_BAD_COOKIE;
LogFullDebug(COMPONENT_NFS_READDIR,
"Bad cookie");
goto unlock_dir;
}
/* we assert this can now succeed */
dirent =
cache_inode_avl_lookup_k(directory, cookie,
CACHE_INODE_FLAG_NEXT_ACTIVE);
if (!dirent) {
/* Linux (3.4, etc) has been observed to send readdir
* at the offset of the last entry's cookie, and
* returns no dirents to userland if that readdir
* notfound or badcookie. */
if (cache_inode_avl_lookup_k
(directory, cookie, CACHE_INODE_FLAG_NONE)) {
/* yup, it was the last entry */
LogFullDebug(COMPONENT_NFS_READDIR,
"EOD because empty result");
*eod_met = true;
goto unlock_dir;
}
LogFullDebug(COMPONENT_NFS_READDIR,
"seek to cookie=%" PRIu64 " fail",
cookie);
status = CACHE_INODE_BAD_COOKIE;
goto unlock_dir;
}
/* dirent is the NEXT entry to return, since we sent
* CACHE_INODE_FLAG_NEXT_ACTIVE */
dirent_node = &dirent->node_hk;
} else {
/* initial readdir */
dirent_node = avltree_first(&directory->object.dir.avl.t);
}
LogFullDebug(COMPONENT_NFS_READDIR,
"About to readdir in cache_inode_readdir: directory=%p "
"cookie=%" PRIu64 " collisions %d", directory, cookie,
directory->object.dir.avl.collisions);
/* Now satisfy the request from the cached readdir--stop when either
* the requested sequence or dirent sequence is exhausted */
*nbfound = 0;
*eod_met = false;
for (; cb_parms.in_result && dirent_node;
dirent_node = avltree_next(dirent_node)) {
cache_entry_t *entry = NULL;
cache_inode_status_t tmp_status = 0;
dirent =
avltree_container_of(dirent_node, cache_inode_dir_entry_t,
node_hk);
estale_retry:
LogFullDebug(COMPONENT_NFS_READDIR,
"Lookup direct %s",
dirent->name);
entry =
cache_inode_get_keyed(&dirent->ckey,
CIG_KEYED_FLAG_NONE, &tmp_status);
if (!entry) {
LogFullDebug(COMPONENT_NFS_READDIR,
"Lookup returned %s",
cache_inode_err_str(tmp_status));
if (retry_stale
&& tmp_status == CACHE_INODE_ESTALE) {
LogDebug(COMPONENT_NFS_READDIR,
"cache_inode_get_keyed returned %s "
"for %s - retrying entry",
cache_inode_err_str(tmp_status),
dirent->name);
retry_stale = false; /* only one retry per
* dirent */
goto estale_retry;
}
if (tmp_status == CACHE_INODE_NOT_FOUND
|| tmp_status == CACHE_INODE_ESTALE) {
/* Directory changed out from under us.
Invalidate it, skip the name, and keep
going. */
atomic_clear_uint32_t_bits(
&directory->flags,
CACHE_INODE_TRUST_CONTENT);
LogDebug(COMPONENT_NFS_READDIR,
"cache_inode_get_keyed returned %s "
"for %s - skipping entry",
cache_inode_err_str(tmp_status),
dirent->name);
continue;
} else {
/* Something is more seriously wrong,
probably an inconsistency. */
status = tmp_status;
LogCrit(COMPONENT_NFS_READDIR,
"cache_inode_get_keyed returned %s "
"for %s - bailing out",
cache_inode_err_str(status),
dirent->name);
goto unlock_dir;
}
}
LogFullDebug(COMPONENT_NFS_READDIR,
"cache_inode_readdir: dirent=%p name=%s "
"cookie=%" PRIu64 " (probes %d)", dirent,
dirent->name, dirent->hk.k, dirent->hk.p);
cb_parms.name = dirent->name;
cb_parms.attr_allowed = attr_status == CACHE_INODE_SUCCESS;
cb_parms.cookie = dirent->hk.k;
tmp_status =
cache_inode_getattr(entry, &cb_parms, cb, CB_ORIGINAL);
if (tmp_status != CACHE_INODE_SUCCESS) {
cache_inode_lru_unref(entry, LRU_FLAG_NONE);
if (tmp_status == CACHE_INODE_ESTALE) {
if (retry_stale) {
LogDebug(COMPONENT_NFS_READDIR,
"cache_inode_getattr returned "
"%s for %s - retrying entry",
cache_inode_err_str
(tmp_status), dirent->name);
retry_stale = false; /* only one retry
* per dirent */
goto estale_retry;
}
/* Directory changed out from under us.
Invalidate it, skip the name, and keep
going. */
atomic_clear_uint32_t_bits(
&directory->flags,
CACHE_INODE_TRUST_CONTENT);
LogDebug(COMPONENT_NFS_READDIR,
"cache_inode_lock_trust_attrs "
"returned %s for %s - skipping entry",
cache_inode_err_str(tmp_status),
dirent->name);
continue;
}
status = tmp_status;
LogCrit(COMPONENT_NFS_READDIR,
"cache_inode_lock_trust_attrs returned %s for "
"%s - bailing out",
cache_inode_err_str(status), dirent->name);
goto unlock_dir;
}
(*nbfound)++;
cache_inode_lru_unref(entry, LRU_FLAG_NONE);
if (!cb_parms.in_result) {
LogDebug(COMPONENT_NFS_READDIR,
"bailing out due to entry not in result");
break;
}
}
/* We have reached the last node and every node traversed was
added to the result */
LogDebug(COMPONENT_NFS_READDIR,
"dirent_node = %p, nbfound = %u, in_result = %s", dirent_node,
*nbfound, cb_parms.in_result ? "TRUE" : "FALSE");
if (!dirent_node && cb_parms.in_result)
*eod_met = true;
else
*eod_met = false;
unlock_dir:
PTHREAD_RWLOCK_unlock(&directory->content_lock);
return status;
} /* cache_inode_readdir */
