/**
*
* cache_inode_get_cookieverf: get a cookie verifier
*
* Get the cookie verifier for a directory
*
* @param pentry [IN] entry for the directory to be read.
* @param pcontext [IN] FSAL credentials
* @param pverf [OUT] Verifier
* @param pstatus [OUT] Returned status.
*
* @return CACHE_INODE_SUCCESS if operation is a success
*
*/
cache_inode_status_t cache_inode_cookieverf(cache_entry_t * pentry,
fsal_op_context_t * pcontext,
uint64_t * pverf,
cache_inode_status_t * pstatus)
{
fsal_status_t fsal_status;
fsal_handle_t* handle = cache_inode_get_fsal_handle(pentry,
pstatus);
if (*pstatus != CACHE_INODE_SUCCESS)
{
return *pstatus;
}
fsal_status = FSAL_get_cookieverf(handle, pcontext, pverf);
if (FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
}
else
{
*pstatus = CACHE_INODE_SUCCESS;
}
return *pstatus;
}
cache_inode_status_t
cache_inode_readlink(cache_entry_t *entry,
fsal_path_t *link_content,
fsal_op_context_t *context,
cache_inode_status_t *status)
{
fsal_status_t fsal_status = {0, 0};
/* Set the return default to CACHE_INODE_SUCCESS */
*status = CACHE_INODE_SUCCESS;
if (entry->type != SYMBOLIC_LINK) {
*status = CACHE_INODE_BAD_TYPE;
return *status;
}
assert(entry->object.symlink);
PTHREAD_RWLOCK_RDLOCK(&entry->content_lock);
if (!(entry->flags & CACHE_INODE_TRUST_CONTENT)) {
/* Our data are stale. Drop the lock, get a
write-lock, load in new data, and copy it out to
the caller. */
PTHREAD_RWLOCK_UNLOCK(&entry->content_lock);
PTHREAD_RWLOCK_WRLOCK(&entry->content_lock);
/* Make sure nobody updated the content while we were
waiting. */
if (!(entry->flags & CACHE_INODE_TRUST_CONTENT)) {
fsal_status
= FSAL_readlink(&entry->handle,
context,
&entry->object.symlink->content,
NULL);
if (!(FSAL_IS_ERROR(fsal_status))) {
atomic_set_uint32_t_bits(&entry->flags,
CACHE_INODE_TRUST_CONTENT);
}
}
}
if (!(FSAL_IS_ERROR(fsal_status))) {
FSAL_pathcpy(link_content,
&(entry->object.symlink->content));
}
PTHREAD_RWLOCK_UNLOCK(&entry->content_lock);
if (FSAL_IS_ERROR(fsal_status)) {
*status = cache_inode_error_convert(fsal_status);
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_CACHE_INODE,
"FSAL returned STALE from readlink");
cache_inode_kill_entry(entry);
}
return *status;
}
return *status;
} /* cache_inode_readlink */
/**
*
* @brief Checks the permissions on an object
*
* This function returns success if the supplied credentials possess
* permission required to meet the specified access.
*
* @param[in] entry The object to be checked
* @param[in] access_type The kind of access to be checked
* @param[in] use_mutex Whether to acquire a read lock
*
* @return CACHE_INODE_SUCCESS if operation is a success
*
*/
cache_inode_status_t
cache_inode_access_sw(cache_entry_t *entry,
fsal_accessflags_t access_type,
fsal_accessflags_t *allowed,
fsal_accessflags_t *denied,
bool use_mutex)
{
fsal_status_t fsal_status;
struct fsal_obj_handle *pfsal_handle = entry->obj_handle;
cache_inode_status_t status = CACHE_INODE_SUCCESS;
LogDebugCIA(COMPONENT_CACHE_INODE, COMPONENT_NFS_V4_ACL,
"access_type=0X%x", access_type);
/* Set the return default to CACHE_INODE_SUCCESS */
status = CACHE_INODE_SUCCESS;
/* We actually need the lock here since we're using
the attribute cache, so get it if the caller didn't
acquire it. */
if (use_mutex) {
status = cache_inode_lock_trust_attrs(entry, false);
if (status != CACHE_INODE_SUCCESS)
goto out;
}
fsal_status =
pfsal_handle->ops->test_access(pfsal_handle, access_type,
allowed, denied);
if (use_mutex)
PTHREAD_RWLOCK_unlock(&entry->attr_lock);
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
LogDebugCIA(COMPONENT_CACHE_INODE, COMPONENT_NFS_V4_ACL,
"status=%s", cache_inode_err_str(status));
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_CACHE_INODE,
"STALE returned by FSAL, calling kill_entry");
cache_inode_kill_entry(entry);
}
} else {
status = CACHE_INODE_SUCCESS;
}
out:
return status;
}
cache_inode_status_t
cache_inode_readlink(cache_entry_t *entry,
struct gsh_buffdesc *link_content)
{
cache_inode_status_t status = CACHE_INODE_SUCCESS;
fsal_status_t fsal_status = { ERR_FSAL_NO_ERROR, 0 };
bool refresh = false;
if (entry->type != SYMBOLIC_LINK) {
status = CACHE_INODE_BAD_TYPE;
return status;
}
PTHREAD_RWLOCK_rdlock(&entry->content_lock);
if (!(entry->flags & CACHE_INODE_TRUST_CONTENT)) {
/* Our data are stale. Drop the lock, get a
write-lock, load in new data, and copy it out to
the caller. */
PTHREAD_RWLOCK_unlock(&entry->content_lock);
PTHREAD_RWLOCK_wrlock(&entry->content_lock);
/* Make sure nobody updated the content while we were
waiting. */
refresh = !(entry->flags & CACHE_INODE_TRUST_CONTENT);
}
fsal_status =
entry->obj_handle->ops->readlink(entry->obj_handle,
link_content, refresh);
if (refresh && !(FSAL_IS_ERROR(fsal_status)))
atomic_set_uint32_t_bits(&entry->flags,
CACHE_INODE_TRUST_CONTENT);
PTHREAD_RWLOCK_unlock(&entry->content_lock);
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_CACHE_INODE,
"FSAL returned STALE from readlink");
cache_inode_kill_entry(entry);
}
return status;
}
return status;
}
cache_inode_status_t cache_inode_statfs(cache_entry_t *entry,
fsal_dynamicfsinfo_t *dynamicinfo,
fsal_op_context_t *context,
cache_inode_status_t *status)
{
fsal_status_t fsal_status = {0, 0};
/* Sanity check */
if(!entry || !context || !dynamicinfo || !status)
{
*status = CACHE_INODE_INVALID_ARGUMENT;
return *status;
}
/* Default return value */
*status = CACHE_INODE_SUCCESS;
/* Get FSAL to get dynamic info */
if(FSAL_IS_ERROR
((fsal_status = FSAL_dynamic_fsinfo(&entry->handle,
context,
dynamicinfo))))
{
*status = cache_inode_error_convert(fsal_status);
if (fsal_status.major == ERR_FSAL_STALE) {
cache_inode_kill_entry(entry);
}
return *status;
}
LogFullDebug(COMPONENT_CACHE_INODE,
"cache_inode_statfs: dynamicinfo: {total_bytes = %zu, "
"free_bytes = %zu, avail_bytes = %zu, total_files = %llu, "
"free_files = %llu, avail_files = %llu}",
dynamicinfo->total_bytes, dynamicinfo->free_bytes,
dynamicinfo->avail_bytes, dynamicinfo->total_files,
dynamicinfo->free_files, dynamicinfo->avail_files);
return CACHE_INODE_SUCCESS;
} /* cache_inode_statfs */
cache_inode_status_t cache_inode_rdwr(cache_entry_t * pentry,
cache_inode_io_direction_t read_or_write,
fsal_seek_t * seek_descriptor,
fsal_size_t buffer_size,
fsal_size_t * pio_size,
fsal_attrib_list_t * pfsal_attr,
caddr_t buffer,
fsal_boolean_t * p_fsal_eof,
hash_table_t * ht,
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
uint64_t stable,
cache_inode_status_t * pstatus)
{
int statindex = 0;
cache_content_io_direction_t io_direction;
cache_content_status_t cache_content_status;
fsal_status_t fsal_status;
fsal_openflags_t openflags;
fsal_size_t io_size;
fsal_attrib_list_t post_write_attr;
fsal_status_t fsal_status_getattr;
struct stat buffstat;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* For now, only FSAL_SEEK_SET is supported */
if(seek_descriptor->whence != FSAL_SEEK_SET)
{
LogCrit(COMPONENT_CACHE_INODE,
"Implementation trouble: seek_descriptor was not a 'FSAL_SEEK_SET' cursor");
*pstatus = CACHE_INODE_INVALID_ARGUMENT;
return *pstatus;
}
io_size = buffer_size;
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_rdwr: INODE : IO Size = %llu fdsize =%zu seeksize=%zu",
buffer_size, sizeof(fsal_file_t), sizeof(fsal_seek_t));
/* stat */
pclient->stat.nb_call_total += 1;
if(read_or_write == CACHE_INODE_READ)
{
statindex = CACHE_INODE_READ_DATA;
io_direction = CACHE_CONTENT_READ;
openflags = FSAL_O_RDONLY;
pclient->stat.func_stats.nb_call[CACHE_INODE_READ_DATA] += 1;
}
else
{
statindex = CACHE_INODE_WRITE_DATA;
io_direction = CACHE_CONTENT_WRITE;
openflags = FSAL_O_WRONLY;
pclient->stat.func_stats.nb_call[CACHE_INODE_WRITE_DATA] += 1;
}
P_w(&pentry->lock);
/* IO are done only on REGULAR_FILEs */
if(pentry->internal_md.type != REGULAR_FILE)
{
*pstatus = CACHE_INODE_BAD_TYPE;
V_w(&pentry->lock);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
return *pstatus;
}
/* Non absolute address within the file are not supported (we act only like pread/pwrite) */
if(seek_descriptor->whence != FSAL_SEEK_SET)
{
*pstatus = CACHE_INODE_INVALID_ARGUMENT;
V_w(&pentry->lock);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
return *pstatus;
}
/* Do we use stable or unstable storage ? */
if(stable == FSAL_UNSAFE_WRITE_TO_GANESHA_BUFFER)
{
/* Data will be stored in memory and not flush to FSAL */
/* If the unstable_data buffer allocated ? */
if(pentry->object.file.unstable_data.buffer == NULL)
{
if((pentry->object.file.unstable_data.buffer =
Mem_Alloc_Label(CACHE_INODE_UNSTABLE_BUFFERSIZE,
"Cache_Inode Unstable Buffer")) == NULL)
{
*pstatus = CACHE_INODE_MALLOC_ERROR;
V_w(&pentry->lock);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
return *pstatus;
}
pentry->object.file.unstable_data.offset = seek_descriptor->offset;
pentry->object.file.unstable_data.length = buffer_size;
memcpy(pentry->object.file.unstable_data.buffer, buffer, buffer_size);
/* Set mtime and ctime */
cache_inode_set_time_current( &pentry->attributes.mtime ) ;
/* BUGAZOMEU : write operation must NOT modify file's ctime */
pentry->attributes.ctime = pentry->attributes.mtime;
*pio_size = buffer_size;
} /* if( pentry->object.file.unstable_data.buffer == NULL ) */
else
{
if((pentry->object.file.unstable_data.offset < seek_descriptor->offset) &&
(buffer_size + seek_descriptor->offset < CACHE_INODE_UNSTABLE_BUFFERSIZE))
{
pentry->object.file.unstable_data.length =
buffer_size + seek_descriptor->offset;
memcpy((char *)(pentry->object.file.unstable_data.buffer +
seek_descriptor->offset), buffer, buffer_size);
/* Set mtime and ctime */
cache_inode_set_time_current( &pentry->attributes.mtime ) ;
/* BUGAZOMEU : write operation must NOT modify file's ctime */
pentry->attributes.ctime = pentry->attributes.mtime;
*pio_size = buffer_size;
}
else
{
/* Go back to regular situation */
stable = FSAL_SAFE_WRITE_TO_FS;
}
}
}
/* if( stable == FALSE ) */
if(stable == FSAL_SAFE_WRITE_TO_FS ||
stable == FSAL_UNSAFE_WRITE_TO_FS_BUFFER)
{
/* Calls file content cache to operate on the cache */
if(pentry->object.file.pentry_content != NULL)
{
/* Entry is data cached */
cache_content_rdwr(pentry->object.file.pentry_content,
io_direction,
seek_descriptor,
&io_size,
pio_size,
buffer,
p_fsal_eof,
&buffstat,
(cache_content_client_t *) pclient->pcontent_client,
pcontext, &cache_content_status);
/* If the entry under resync */
if(cache_content_status == CACHE_CONTENT_LOCAL_CACHE_NOT_FOUND)
{
/* Data cache gc has removed this entry */
if(cache_content_new_entry(pentry,
NULL,
(cache_content_client_t *)pclient->pcontent_client,
RENEW_ENTRY, pcontext,
&cache_content_status) == NULL)
{
/* Entry could not be recoverd, cache_content_status contains an error, let it be managed by the next block */
LogCrit(COMPONENT_CACHE_INODE,
"Read/Write Operation through cache failed with status %d (renew process failed)",
cache_content_status);
/* Will go to the end of the function on the error clause with cache_content_status describing the error */
}
else
{
/* Entry was successfully renewed */
LogInfo(COMPONENT_CACHE_INODE,
"----> File Content Entry %p was successfully renewed",
pentry);
/* Try to access the content of the file again */
cache_content_rdwr(pentry->object.file.pentry_content,
io_direction,
seek_descriptor,
&io_size,
pio_size,
buffer,
p_fsal_eof,
&buffstat,
(cache_content_client_t *) pclient->pcontent_client,
pcontext, &cache_content_status);
/* No management of cache_content_status in case of failure, this will be done
* within the next block */
}
}
if(cache_content_status != CACHE_CONTENT_SUCCESS)
{
*pstatus = cache_content_error_convert(cache_content_status);
V_w(&pentry->lock);
LogCrit(COMPONENT_CACHE_INODE,
"Read/Write Operation through cache failed with status %d",
cache_content_status);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
return *pstatus;
}
LogFullDebug(COMPONENT_CACHE_INODE,
"cache_inode_rdwr: inode/dc: io_size=%llu, pio_size=%llu, eof=%d, seek=%d.%"PRIu64,
io_size, *pio_size, *p_fsal_eof, seek_descriptor->whence,
seek_descriptor->offset);
LogMidDebug(COMPONENT_CACHE_INODE,
"cache_inode_rdwr: INODE AFTER : IO Size = %llu %llu",
io_size, *pio_size);
/* Use information from the buffstat to update the file metadata */
pentry->attributes.filesize = buffstat.st_size;
pentry->attributes.spaceused =
buffstat.st_blksize * buffstat.st_blocks;
}
else
{
/* No data cache entry, we operated directly on FSAL */
pentry->attributes.asked_attributes = pclient->attrmask;
/* We need to open if we don't have a cached
* descriptor or our open flags differs.
*/
if(cache_inode_open(pentry,
pclient,
openflags, pcontext, pstatus) != CACHE_INODE_SUCCESS)
{
V_w(&pentry->lock);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
return *pstatus;
}
/* Call FSAL_read or FSAL_write */
if(read_or_write == CACHE_INODE_READ)
{
#ifdef _USE_MFSL
fsal_status = MFSL_read(&(pentry->object.file.open_fd.mfsl_fd),
seek_descriptor,
io_size,
buffer,
pio_size, p_fsal_eof, &pclient->mfsl_context, NULL);
#else
fsal_status = FSAL_read(&(pentry->object.file.open_fd.fd),
seek_descriptor,
io_size, buffer, pio_size, p_fsal_eof);
#endif
}
else
{
#ifdef _USE_MFSL
fsal_status = MFSL_write(&(pentry->object.file.open_fd.mfsl_fd),
seek_descriptor,
io_size, buffer, pio_size, &pclient->mfsl_context, NULL);
#else
fsal_status = FSAL_write(&(pentry->object.file.open_fd.fd),
seek_descriptor, io_size, buffer, pio_size);
#endif
#if 0
/* Alright, the unstable write is complete. Now if it was supposed to be a stable write
* we can sync to the hard drive. */
if(stable == FSAL_SAFE_WRITE_TO_FS)
{
#ifdef _USE_MFSL
fsal_status = MFSL_commit(&(pentry->object.file.open_fd.mfsl_fd), NULL);
#else
fsal_status = FSAL_commit(&(pentry->object.file.open_fd.fd));
#endif
#endif
}
LogFullDebug(COMPONENT_FSAL,
"cache_inode_rdwr: FSAL IO operation returned %d, asked_size=%llu, effective_size=%llu",
fsal_status.major, (unsigned long long)io_size,
(unsigned long long)*pio_size);
if(FSAL_IS_ERROR(fsal_status))
{
if(fsal_status.major == ERR_FSAL_DELAY)
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_rdwr: FSAL_write returned EBUSY");
else
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_rdwr: fsal_status.major = %d",
fsal_status.major);
if((fsal_status.major != ERR_FSAL_NOT_OPENED)
&& (pentry->object.file.open_fd.fileno != 0))
{
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_rdwr: CLOSING pentry %p: fd=%d",
pentry, pentry->object.file.open_fd.fileno);
#ifdef _USE_MFSL
MFSL_close(&(pentry->object.file.open_fd.mfsl_fd), &pclient->mfsl_context, NULL);
#else
FSAL_close(&(pentry->object.file.open_fd.fd));
#endif
*pstatus = cache_inode_error_convert(fsal_status);
}
else
{
/* the fd has been close by another thread.
* return CACHE_INODE_FSAL_DELAY so the client will
* retry with a new fd.
*/
*pstatus = CACHE_INODE_FSAL_DELAY;
}
pentry->object.file.open_fd.last_op = 0;
pentry->object.file.open_fd.fileno = 0;
V_w(&pentry->lock);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
return *pstatus;
}
LogFullDebug(COMPONENT_CACHE_INODE,
"cache_inode_rdwr: inode/direct: io_size=%llu, pio_size=%llu, eof=%d, seek=%d.%"PRIu64,
io_size, *pio_size, *p_fsal_eof, seek_descriptor->whence,
seek_descriptor->offset);
if(cache_inode_close(pentry, pclient, pstatus) != CACHE_INODE_SUCCESS)
{
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_rdwr: cache_inode_close = %d", *pstatus);
V_w(&pentry->lock);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
return *pstatus;
}
if(read_or_write == CACHE_INODE_WRITE)
{
/* Do a getattr in order to have update information on filesize
* This query is done directly on FSAL (object is not data cached), and result
* will be propagated to cache Inode */
/* WARNING: This operation is to be done AFTER FSAL_close (some FSAL, like POSIX,
* may not flush data until the file is closed */
/*post_write_attr.asked_attributes = pclient->attrmask ; */
post_write_attr.asked_attributes = FSAL_ATTR_SIZE | FSAL_ATTR_SPACEUSED;
fsal_status_getattr =
FSAL_getattrs(&(pentry->handle), pcontext,
&post_write_attr);
/* if failed, the next block will handle the error */
if(FSAL_IS_ERROR(fsal_status_getattr))
fsal_status = fsal_status_getattr;
else
{
/* Update Cache Inode attributes */
pentry->attributes.filesize = post_write_attr.filesize;
pentry->attributes.spaceused = post_write_attr.spaceused;
}
}
}
/* IO was successfull (through cache content or not), we manually update the times in the attributes */
switch (read_or_write)
{
case CACHE_INODE_READ:
/* Set the atime */
cache_inode_set_time_current( & pentry->attributes.atime ) ;
break;
case CACHE_INODE_WRITE:
/* Set mtime and ctime */
cache_inode_set_time_current( & pentry->attributes.mtime ) ;
/* BUGAZOMEU : write operation must NOT modify file's ctime */
pentry->attributes.ctime = pentry->attributes.mtime;
break;
}
}
/* if(stable == TRUE ) */
/* Return attributes to caller */
if(pfsal_attr != NULL)
*pfsal_attr = pentry->attributes;
*pstatus = CACHE_INODE_SUCCESS;
/* stat */
if(read_or_write == CACHE_INODE_READ)
{
*pstatus = cache_inode_valid(pentry, CACHE_INODE_OP_GET, pclient);
if(*pstatus != CACHE_INODE_SUCCESS)
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_READ] += 1;
else
pclient->stat.func_stats.nb_success[CACHE_INODE_READ] += 1;
}
else
{
*pstatus = cache_inode_valid(pentry, CACHE_INODE_OP_SET, pclient);
if(*pstatus != CACHE_INODE_SUCCESS)
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_WRITE] += 1;
else
pclient->stat.func_stats.nb_success[CACHE_INODE_WRITE] += 1;
}
V_w(&pentry->lock);
return *pstatus;
} /* cache_inode_rdwr */
int nfs4_op_link(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_link";
cache_entry_t * dir_pentry = NULL;
cache_entry_t * file_pentry = NULL;
cache_inode_status_t cache_status;
fsal_attrib_list_t attr;
fsal_name_t newname;
resp->resop = NFS4_OP_LINK;
res_LINK4.status = NFS4_OK;
/* Do basic checks on a filehandle */
res_LINK4.status = nfs4_sanity_check_FH(data, 0LL);
if(res_LINK4.status != NFS4_OK)
return res_LINK4.status;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->savedFH)))
{
res_LINK4.status = NFS4ERR_NOFILEHANDLE;
return res_LINK4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->savedFH)))
{
res_LINK4.status = NFS4ERR_BADHANDLE;
return res_LINK4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->savedFH)))
{
res_LINK4.status = NFS4ERR_FHEXPIRED;
return res_LINK4.status;
}
/* Pseudo Fs is explictely a Read-Only File system */
if(nfs4_Is_Fh_Pseudo(&(data->currentFH)))
{
res_LINK4.status = NFS4ERR_ROFS;
return res_LINK4.status;
}
/* If data->exportp is null, a junction from pseudo fs was traversed, credp and exportp have to be updated */
if(data->pexport == NULL)
{
res_LINK4.status = nfs4_SetCompoundExport(data);
if(res_LINK4.status != NFS4_OK)
return res_LINK4.status;
}
/*
* This operation creates a hard link, for the file represented by the saved FH, in directory represented by currentFH under the
* name arg_LINK4.target
*/
/* Crossing device is not allowed */
if(((file_handle_v4_t *) (data->currentFH.nfs_fh4_val))->exportid !=
((file_handle_v4_t *) (data->savedFH.nfs_fh4_val))->exportid)
{
res_LINK4.status = NFS4ERR_XDEV;
return res_LINK4.status;
}
/* If name is empty, return EINVAL */
if(arg_LINK4.newname.utf8string_len == 0)
{
res_LINK4.status = NFS4ERR_INVAL;
return res_LINK4.status;
}
/* Check for name to long */
if(arg_LINK4.newname.utf8string_len > FSAL_MAX_NAME_LEN)
{
res_LINK4.status = NFS4ERR_NAMETOOLONG;
return res_LINK4.status;
}
/* Convert the UFT8 objname to a regular string */
if((cache_status =
cache_inode_error_convert(FSAL_buffdesc2name
((fsal_buffdesc_t *) & arg_LINK4.newname,
&newname))) != CACHE_INODE_SUCCESS)
{
res_LINK4.status = nfs4_Errno(cache_status);
return res_LINK4.status;
}
/* Sanity check: never create a link named '.' or '..' */
if(!FSAL_namecmp(&newname, (fsal_name_t *) & FSAL_DOT)
|| !FSAL_namecmp(&newname, (fsal_name_t *) & FSAL_DOT_DOT))
{
res_LINK4.status = NFS4ERR_BADNAME;
return res_LINK4.status;
}
/* get info from compound data */
dir_pentry = data->current_entry;
/* Destination FH (the currentFH) must be a directory */
if(data->current_filetype != DIRECTORY)
{
res_LINK4.status = NFS4ERR_NOTDIR;
return res_LINK4.status;
}
/* Target object (the savedFH) must not be a directory */
if(data->saved_filetype == DIRECTORY)
{
res_LINK4.status = NFS4ERR_ISDIR;
return res_LINK4.status;
}
/* We have to keep track of the 'change' file attribute for reply structure */
if((cache_status = cache_inode_getattr(dir_pentry,
&attr,
data->pcontext,
&cache_status)) != CACHE_INODE_SUCCESS)
{
res_LINK4.status = nfs4_Errno(cache_status);
return res_LINK4.status;
}
res_LINK4.LINK4res_u.resok4.cinfo.before
= cache_inode_get_changeid4(dir_pentry);
/* Convert savedFH into a vnode */
file_pentry = data->saved_entry;
/* make the link */
if(cache_inode_link(file_pentry,
dir_pentry,
&newname,
&attr,
data->pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
res_LINK4.status = nfs4_Errno(cache_status);
return res_LINK4.status;
}
res_LINK4.LINK4res_u.resok4.cinfo.after
= cache_inode_get_changeid4(dir_pentry);
res_LINK4.LINK4res_u.resok4.cinfo.atomic = FALSE;
res_LINK4.status = NFS4_OK;
return NFS4_OK;
} /* nfs4_op_link */
/**
*
* cache_inode_create: creates an entry through the cache.
*
* Creates an entry through the cache.
*
* @param pentry_parent [IN] pointer to the pentry parent
* @param pname [IN] pointer to the name of the object in the destination directory.
* @param type [IN] type of the object to be created.
* @param mode [IN] mode to be used at file creation
* @param pcreate_arg [IN] additional argument for object creation
* @param pattr [OUT] attributes for the new object.
* @param ht [INOUT] hash table used for the cache.
* @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 CACHE_INODE_LRU_ERROR if allocation error occured when validating the entry\n
* @return CACHE_INODE_BAD_TYPE either source or destination have incorrect type\n
* @return CACHE_INODE_ENTRY_EXISTS entry of that name already exists in destination.
*
*/
cache_entry_t *
cache_inode_create(cache_entry_t * pentry_parent,
fsal_name_t * pname,
cache_inode_file_type_t type,
fsal_accessmode_t mode,
cache_inode_create_arg_t * pcreate_arg,
fsal_attrib_list_t * pattr,
hash_table_t * ht,
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus)
{
cache_entry_t *pentry = NULL;
fsal_status_t fsal_status;
#ifdef _USE_MFSL
mfsl_object_t object_handle;
#else
fsal_handle_t object_handle;
#endif
fsal_attrib_list_t parent_attributes;
fsal_attrib_list_t object_attributes;
fsal_handle_t dir_handle;
cache_inode_fsal_data_t fsal_data;
cache_inode_status_t status;
struct cache_inode_dir_begin__ *dir_begin;
int pnfs_status;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stats */
pclient->stat.nb_call_total += 1;
inc_func_call(pclient, CACHE_INODE_CREATE);
/*
* Check if the required type is correct, with this
* function, we manage file, dir and symlink
*/
if(type != REGULAR_FILE && type != DIR_BEGINNING && type != SYMBOLIC_LINK &&
type != SOCKET_FILE && type != FIFO_FILE && type != CHARACTER_FILE &&
type != BLOCK_FILE)
{
*pstatus = CACHE_INODE_BAD_TYPE;
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
return NULL;
}
/*
* Check if caller is allowed to perform the operation
*/
status = cache_inode_access(pentry_parent,
FSAL_W_OK, ht,
pclient, pcontext, &status);
if (status != CACHE_INODE_SUCCESS)
{
*pstatus = status;
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
/* pentry is a directory */
return NULL;
}
/*
* Check if an entry of the same name exists
*/
pentry = cache_inode_lookup(pentry_parent,
pname, &object_attributes,
ht, pclient, pcontext, pstatus);
if (pentry != NULL)
{
*pstatus = CACHE_INODE_ENTRY_EXISTS;
if(pentry->internal_md.type != type)
{
/*
* Incompatible types, returns NULL
*/
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
return NULL;
}
else
{
/* stats */
inc_func_success(pclient, CACHE_INODE_CREATE);
/*
* redondant creation, returned the
* previously created entry
*/
return pentry;
}
}
/*
* At this point, the entry was not found, this means
* that is doesn't exist is FSAL, we can create it
*/
/* Get the lock for the parent */
P_w(&pentry_parent->lock);
if(pentry_parent->internal_md.type == DIR_BEGINNING)
dir_handle = pentry_parent->object.dir_begin.handle;
if(pentry_parent->internal_md.type == DIR_CONTINUE)
{
P_r(&pentry_parent->object.dir_cont.pdir_begin->lock);
dir_handle = pentry_parent->object.dir_cont.pdir_begin->object.dir_begin.handle;
V_r(&pentry_parent->object.dir_cont.pdir_begin->lock);
}
object_attributes.asked_attributes = pclient->attrmask;
switch (type)
{
case REGULAR_FILE:
#ifdef _USE_MFSL
cache_inode_get_attributes(pentry_parent, &parent_attributes);
fsal_status = MFSL_create(&pentry_parent->mobject,
pname, pcontext,
&pclient->mfsl_context,
mode, &object_handle,
&object_attributes, &parent_attributes);
#else
fsal_status = FSAL_create(&dir_handle,
pname, pcontext, mode,
&object_handle, &object_attributes);
#endif
break;
case DIR_BEGINNING:
#ifdef _USE_MFSL
cache_inode_get_attributes(pentry_parent, &parent_attributes);
fsal_status = MFSL_mkdir(&pentry_parent->mobject,
pname, pcontext,
&pclient->mfsl_context,
mode, &object_handle,
&object_attributes, &parent_attributes);
#else
fsal_status = FSAL_mkdir(&dir_handle,
pname, pcontext, mode,
&object_handle, &object_attributes);
#endif
break;
case SYMBOLIC_LINK:
#ifdef _USE_MFSL
cache_inode_get_attributes(pentry_parent, &object_attributes);
fsal_status = MFSL_symlink(&pentry_parent->mobject,
pname, &pcreate_arg->link_content,
pcontext, &pclient->mfsl_context,
mode, &object_handle, &object_attributes);
#else
fsal_status = FSAL_symlink(&dir_handle,
pname, &pcreate_arg->link_content,
pcontext, mode, &object_handle,
&object_attributes);
#endif
break;
case SOCKET_FILE:
#ifdef _USE_MFSL
fsal_status = MFSL_mknode(&pentry_parent->mobject, pname,
pcontext, &pclient->mfsl_context, mode,
FSAL_TYPE_SOCK, NULL, /* no dev_t needed for socket file */
&object_handle, &object_attributes);
#else
fsal_status = FSAL_mknode(&dir_handle, pname, pcontext,
mode, FSAL_TYPE_SOCK, NULL, /* no dev_t needed for socket file */
&object_handle, &object_attributes);
#endif
break;
case FIFO_FILE:
#ifdef _USE_MFSL
fsal_status = MFSL_mknode(&pentry_parent->mobject, pname,
pcontext, &pclient->mfsl_context,
mode, FSAL_TYPE_FIFO, NULL, /* no dev_t needed for FIFO file */
&object_handle, &object_attributes);
#else
fsal_status = FSAL_mknode(&dir_handle, pname, pcontext,
mode, FSAL_TYPE_FIFO, NULL, /* no dev_t needed for FIFO file */
&object_handle, &object_attributes);
#endif
break;
case BLOCK_FILE:
#ifdef _USE_MFSL
fsal_status = MFSL_mknode(&pentry_parent->mobject,
pname, pcontext,
&pclient->mfsl_context,
mode, FSAL_TYPE_BLK,
&pcreate_arg->dev_spec,
&object_handle, &object_attributes);
#else
fsal_status = FSAL_mknode(&dir_handle,
pname, pcontext,
mode, FSAL_TYPE_BLK,
&pcreate_arg->dev_spec,
&object_handle, &object_attributes);
#endif
break;
case CHARACTER_FILE:
#ifdef _USE_MFSL
fsal_status = MFSL_mknode(&pentry_parent->mobject,
pname, pcontext,
&pclient->mfsl_context,
mode, FSAL_TYPE_CHR,
&pcreate_arg->dev_spec,
&object_handle, &object_attributes);
#else
fsal_status = FSAL_mknode(&dir_handle,
pname, pcontext,
mode, FSAL_TYPE_CHR,
&pcreate_arg->dev_spec,
&object_handle, &object_attributes);
#endif
break;
default:
/* we should never go there */
*pstatus = CACHE_INODE_INCONSISTENT_ENTRY;
V_w(&pentry_parent->lock);
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
return NULL;
break;
}
/* Check for the result */
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
V_w(&pentry_parent->lock);
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_create: Stale FSAL File Handle "
"detected for pentry = %p",
pentry_parent);
cache_inode_kill_entry(pentry_parent, ht,
pclient, &kill_status);
if(kill_status != CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE, "cache_inode_create: "
"Could not kill entry %p, status = %u",
pentry_parent, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
return NULL;
}
else
{
#ifdef _USE_MFSL
fsal_data.handle = object_handle.handle;
#else
fsal_data.handle = object_handle;
#endif
fsal_data.cookie = DIR_START;
pentry = cache_inode_new_entry(&fsal_data, &object_attributes,
type, pcreate_arg, NULL,
ht, pclient, pcontext,
TRUE, /* This is a creation and not a population */
pstatus);
if (pentry == NULL)
{
*pstatus = CACHE_INODE_INSERT_ERROR;
V_w(&pentry_parent->lock);
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
return NULL;
}
#ifdef _USE_MFSL
/* Copy the MFSL object to the cache */
memcpy((char *)&(pentry->mobject),
(char *)&object_handle, sizeof(mfsl_object_t));
#endif
/* Add this entry to the directory */
status = cache_inode_add_cached_dirent(pentry_parent,
pname, pentry,
NULL, ht,
pclient, pcontext,
pstatus);
if (status != CACHE_INODE_SUCCESS)
{
V_w(&pentry_parent->lock);
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
return NULL;
}
}
#ifdef _USE_PNFS
if((type == REGULAR_FILE) &&
(pcreate_arg != NULL) &&
(pcreate_arg->use_pnfs == TRUE))
{
pnfs_status = pnfs_create_ds_file(&pclient->pnfsclient,
pentry->object.file.attributes.fileid,
&pentry->object.file.pnfs_file.ds_file);
if (pnfs_status != NFS4_OK)
{
V_w(&pentry_parent->lock);
LogDebug(COMPONENT_CACHE_INODE, "OPEN PNFS CREATE DS FILE : Error %u",
pnfs_status);
*pstatus = CACHE_INODE_IO_ERROR;
return NULL;
}
}
#endif
/* Update the parent cached attributes */
if(pentry_parent->internal_md.type == DIR_BEGINNING)
dir_begin = &pentry_parent->object.dir_begin;
else
dir_begin = &pentry_parent->object.dir_cont.pdir_begin->object.dir_begin;
dir_begin->attributes.mtime.seconds = time(NULL);
dir_begin->attributes.mtime.nseconds = 0;
dir_begin->attributes.ctime = dir_begin->attributes.mtime;
/*
* if the created object is a directory, it contains a link
* to its parent : '..'. Thus the numlink attr must be increased.
*/
if(type == DIR_BEGINNING)
{
dir_begin->attributes.numlinks++;
}
/* Get the attributes in return */
*pattr = object_attributes;
/* valid the parent */
*pstatus = cache_inode_valid(pentry_parent,
CACHE_INODE_OP_SET,
pclient);
/* release the lock for the parent */
V_w(&pentry_parent->lock);
/* stat */
if(*pstatus != CACHE_INODE_SUCCESS)
inc_func_err_retryable(pclient, CACHE_INODE_CREATE);
else
inc_func_success(pclient, CACHE_INODE_CREATE);
return pentry;
}
/**
*
* cache_inode_lookupp_sw: looks up (and caches) the parent directory for a directory. A switches tells is mutex are use.
*
* Looks up (and caches) the parent directory for a directory.
*
* @param pentry [IN] entry whose parent is to be obtained.
* @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.
* @param use_mutex [IN] if TRUE mutex are use, not otherwise.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
* @return CACHE_INODE_LRU_ERROR if allocation error occured when validating the entry
*
*/
cache_entry_t *cache_inode_lookupp_sw(cache_entry_t * pentry,
hash_table_t * ht,
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus, int use_mutex)
{
cache_entry_t *pentry_parent = NULL;
fsal_status_t fsal_status;
fsal_attrib_list_t object_attributes;
cache_inode_fsal_data_t fsdata;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stats */
pclient->stat.nb_call_total += 1;
pclient->stat.func_stats.nb_call[CACHE_INODE_LOOKUP] += 1;
/* The entry should be a directory */
if(use_mutex)
P_r(&pentry->lock);
if(pentry->internal_md.type != DIR_BEGINNING)
{
if(use_mutex)
V_r(&pentry->lock);
*pstatus = CACHE_INODE_BAD_TYPE;
/* stats */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUPP] += 1;
return NULL;
}
/* Renew the entry (to avoid having it being garbagged */
if(cache_inode_renew_entry(pentry, NULL, ht, pclient, pcontext, pstatus) !=
CACHE_INODE_SUCCESS)
{
pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_GETATTR] += 1;
return NULL;
}
/* Does the parent belongs to the cache ? */
if(pentry->parent_list && pentry->parent_list->parent)
{
/* YES, the parent is cached, use the pentry that we have found */
pentry_parent = pentry->parent_list->parent;
}
else
{
/* NO, the parent is not cached, query FSAL to get it and cache the result */
object_attributes.asked_attributes = pclient->attrmask;
fsal_status =
FSAL_lookup(&pentry->object.dir_begin.handle, (fsal_name_t *) & FSAL_DOT_DOT,
pcontext, &fsdata.handle, &object_attributes);
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
if(use_mutex)
V_r(&pentry->lock);
/* Stale File Handle to be detected and managed */
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,"cache_inode_lookupp: Stale FSAL FH detected for pentry %p",
pentry);
if(cache_inode_kill_entry(pentry, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,"cache_inode_remove: 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_LOOKUPP] += 1;
return NULL;
}
/* Call cache_inode_get to populate the cache with the parent entry */
fsdata.cookie = 0;
if((pentry_parent = cache_inode_get(&fsdata,
&object_attributes,
ht, pclient, pcontext, pstatus)) == NULL)
{
if(use_mutex)
V_r(&pentry->lock);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUPP] += 1;
return NULL;
}
}
*pstatus = cache_inode_valid(pentry_parent, CACHE_INODE_OP_GET, pclient);
if(use_mutex)
V_r(&pentry->lock);
/* stat */
if(*pstatus != CACHE_INODE_SUCCESS)
pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_LOOKUPP] += 1;
else
pclient->stat.func_stats.nb_success[CACHE_INODE_LOOKUPP] += 1;
return pentry_parent;
} /* cache_inode_lookupp_sw */
/**
*
* cache_inode_lookup_sw: looks up for a name in a directory indicated by a
* cached entry.
*
* Looks up for a name in a directory indicated by a cached entry. The directory
* should have been cached before.
*
* @param pentry_parent [IN] entry for the parent directory to be managed.
* @param name [IN] name of the entry that we are looking for in the
* cache.
* @param pattr [OUT] attributes for the entry that we have found.
* @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.
* @param use_mutex [IN] if TRUE, mutex management is done, not if equal
* to FALSE.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
* @return CACHE_INODE_LRU_ERROR if allocation error occured when validating the
* entry
*
*/
cache_entry_t *cache_inode_lookup_sw(cache_entry_t * pentry_parent,
fsal_name_t * pname,
cache_inode_policy_t policy,
fsal_attrib_list_t * pattr,
hash_table_t * ht,
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus,
int use_mutex)
{
cache_inode_dir_entry_t dirent_key[1], *dirent;
struct avltree_node *dirent_node;
cache_inode_dir_entry_t *new_dir_entry;
cache_entry_t *pentry = NULL;
fsal_status_t fsal_status;
#ifdef _USE_MFSL
mfsl_object_t object_handle;
#else
fsal_handle_t object_handle;
#endif
fsal_handle_t dir_handle;
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;
cache_inode_fsal_data_t new_entry_fsdata;
fsal_accessflags_t access_mask = 0;
memset(&create_arg, 0, sizeof(create_arg));
memset( (char *)&new_entry_fsdata, 0, sizeof( new_entry_fsdata ) ) ;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stats */
(pclient->stat.nb_call_total)++;
(pclient->stat.func_stats.nb_call[CACHE_INODE_LOOKUP])++;
/* We should not renew entries when !use_mutex (because unless we
* make the flag explicit (shared vs. exclusive), we don't know
* whether a mutating operation is safe--and, the caller should have
* already renewed the entry */
if(use_mutex == TRUE) {
P_w(&pentry_parent->lock);
cache_status = cache_inode_renew_entry(pentry_parent, pattr, ht,
pclient, pcontext, pstatus);
if(cache_status != CACHE_INODE_SUCCESS)
{
V_w(&pentry_parent->lock);
inc_func_err_retryable(pclient, CACHE_INODE_GETATTR);
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_lookup: returning %d(%s) from cache_inode_renew_entry",
*pstatus, cache_inode_err_str(*pstatus));
return NULL;
}
/* RW Lock goes for writer to reader */
rw_lock_downgrade(&pentry_parent->lock);
}
if(pentry_parent->internal_md.type != DIRECTORY)
{
/* Parent is no directory base, return NULL */
*pstatus = CACHE_INODE_NOT_A_DIRECTORY;
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUP])++;
if(use_mutex == TRUE)
V_r(&pentry_parent->lock);
return NULL;
}
/* if name is ".", use the input value */
if(!FSAL_namecmp(pname, (fsal_name_t *) & FSAL_DOT))
{
pentry = pentry_parent;
}
else if(!FSAL_namecmp(pname, (fsal_name_t *) & FSAL_DOT_DOT))
{
/* Directory do only have exactly one parent. This a limitation in all FS,
* which implies that hard link are forbidden on directories (so that
* they exists only in one dir). Because of this, the parent list is
* always limited to one element for a dir. Clients SHOULD never
* 'lookup( .. )' in something that is no dir. */
pentry =
cache_inode_lookupp_no_mutex(pentry_parent, ht, pclient, pcontext,
pstatus);
}
else
{
/* This is a "regular lookup" (not on "." or "..") */
/* Check is user (as specified by the credentials) is authorized to
* lookup the directory or not */
access_mask = FSAL_MODE_MASK_SET(FSAL_X_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_LIST_DIR);
if(cache_inode_access_no_mutex(pentry_parent,
access_mask,
ht,
pclient,
pcontext,
pstatus) != CACHE_INODE_SUCCESS)
{
if(use_mutex == TRUE)
V_r(&pentry_parent->lock);
(pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_GETATTR])++;
return NULL;
}
/* We first try avltree_lookup by name. If that fails, we dispatch to
* the fsal. */
FSAL_namecpy(&dirent_key->name, pname);
dirent_node = avltree_lookup(&dirent_key->node_n,
&pentry_parent->object.dir.dentries);
if (dirent_node) {
dirent = avltree_container_of(dirent_node, cache_inode_dir_entry_t,
node_n);
pentry = dirent->pentry;
}
if(pentry == NULL)
{
LogDebug(COMPONENT_CACHE_INODE, "Cache Miss detected");
dir_handle = pentry_parent->handle;
object_attributes.asked_attributes = pclient->attrmask;
#ifdef _USE_MFSL
#ifdef _USE_MFSL_ASYNC
if(!mfsl_async_is_object_asynchronous(&pentry_parent->mobject))
{
/* If the parent is asynchronous, rely on the content of the cache
* inode parent entry.
*
* /!\ If the fs behind the FSAL is touched in a non-nfs way,
* there will be huge incoherencies.
*/
#endif /* _USE_MFSL_ASYNC */
fsal_status = MFSL_lookup(&pentry_parent->mobject,
pname,
pcontext,
&pclient->mfsl_context,
&object_handle, &object_attributes, NULL);
#ifdef _USE_MFSL_ASYNC
}
else
{
LogMidDebug(COMPONENT_CACHE_INODE,
"cache_inode_lookup chose to bypass FSAL and trusted his cache for name=%s",
pname->name);
fsal_status.major = ERR_FSAL_NOENT;
fsal_status.minor = ENOENT;
}
#endif /* _USE_MFSL_ASYNC */
#else
fsal_status =
FSAL_lookup(&dir_handle, pname, pcontext, &object_handle,
&object_attributes);
#endif /* _USE_MFSL */
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
if(use_mutex == TRUE)
V_r(&pentry_parent->lock);
/* Stale File Handle to be detected and managed */
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_lookup: Stale FSAL File Handle detected for pentry = %p, fsal_status=(%u,%u)",
pentry_parent, fsal_status.major, fsal_status.minor);
if(cache_inode_kill_entry(pentry_parent, NO_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_pentry_parent: Could not kill entry %p, status = %u",
pentry_parent, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUP])++;
return NULL;
}
type = cache_inode_fsal_type_convert(object_attributes.type);
/* If entry is a symlink, this value for be cached */
if(type == SYMBOLIC_LINK)
{
if( CACHE_INODE_KEEP_CONTENT( policy ) )
#ifdef _USE_MFSL
{
fsal_status =
MFSL_readlink(&object_handle, pcontext, &pclient->mfsl_context,
&create_arg.link_content, &object_attributes, NULL);
}
#else
{
fsal_status =
FSAL_readlink(&object_handle, pcontext, &create_arg.link_content,
&object_attributes);
}
else
{
fsal_status.major = ERR_FSAL_NO_ERROR ;
fsal_status.minor = 0 ;
}
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
if(use_mutex == TRUE)
V_r(&pentry_parent->lock);
/* Stale File Handle to be detected and managed */
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_lookup: Stale FSAL File Handle detected for pentry = %p, fsal_status=(%u,%u)",
pentry_parent, fsal_status.major, fsal_status.minor);
if(cache_inode_kill_entry(pentry_parent, NO_LOCK, ht, pclient, &kill_status)
!= CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_pentry_parent: Could not kill entry %p, status = %u",
pentry_parent, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUP])++;
return NULL;
}
}
/* Allocation of a new entry in the cache */
#ifdef _USE_MFSL
new_entry_fsdata.handle = object_handle.handle;
#else
new_entry_fsdata.handle = object_handle;
#endif
new_entry_fsdata.cookie = 0;
if((pentry = cache_inode_new_entry( &new_entry_fsdata,
&object_attributes,
type,
policy,
&create_arg,
NULL,
ht,
pclient,
pcontext,
FALSE, /* This is a population and not a creation */
pstatus ) ) == NULL )
{
if(use_mutex == TRUE)
V_r(&pentry_parent->lock);
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUP])++;
return NULL;
}
/* Entry was found in the FSAL, add this entry to the parent
* directory */
cache_status = cache_inode_add_cached_dirent(pentry_parent,
pname,
pentry,
ht,
&new_dir_entry,
pclient,
pcontext,
pstatus);
if(cache_status != CACHE_INODE_SUCCESS
&& cache_status != CACHE_INODE_ENTRY_EXISTS)
{
if(use_mutex == TRUE)
V_r(&pentry_parent->lock);
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUP])++;
return NULL;
}
} /* cached lookup fail (try fsal) */
int nfs_Create(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
char *str_file_name = NULL;
fsal_name_t file_name;
fsal_accessmode_t mode = 0;
cache_entry_t *file_pentry = NULL;
cache_entry_t *parent_pentry = NULL;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t attr;
fsal_attrib_list_t attr_parent_after;
fsal_attrib_list_t attr_newfile;
fsal_attrib_list_t attributes_create;
fsal_attrib_list_t *ppre_attr;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
cache_inode_status_t cache_status_lookup;
cache_inode_file_type_t parent_filetype;
int rc = NFS_REQ_OK;
#ifdef _USE_QUOTA
fsal_status_t fsal_status ;
#endif
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
str_file_name = parg->arg_create2.where.name;
break;
case NFS_V3:
str_file_name = parg->arg_create3.where.name;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_create2.where.dir),
&(parg->arg_create3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Create handle: %s name: %s",
str, str_file_name);
}
if((preq->rq_vers == NFS_V3) && (nfs3_Is_Fh_Xattr(&(parg->arg_create3.where.dir))))
{
rc = nfs3_Create_Xattr(parg, pexport, pcontext, preq, pres);
goto out;
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_create3.CREATE3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_create3.CREATE3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
}
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_create2.where.dir),
&(parg->arg_create3.where.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_create3.status),
NULL,
&parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
goto out;
}
/* get directory attributes before action (for V3 reply) */
ppre_attr = &parent_attr;
/* Extract the filetype */
parent_filetype = cache_inode_fsal_type_convert(parent_attr.type);
/*
* Sanity checks: new file name must be non-null; parent must be a
* directory.
*/
if(parent_filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_create3.status = NFS3ERR_NOTDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
switch (preq->rq_vers)
{
case NFS_V2:
str_file_name = parg->arg_create2.where.name;
if(parg->arg_create2.attributes.mode != (unsigned int)-1)
{
mode = unix2fsal_mode(parg->arg_create2.attributes.mode);
}
else
{
mode = 0;
}
break;
case NFS_V3:
str_file_name = parg->arg_create3.where.name;
if(parg->arg_create3.how.mode == EXCLUSIVE)
{
/*
* Client has not provided mode information.
* If the create works, the client will issue
* a separate setattr request to fix up the
* file's mode, so pick arbitrary value for now.
*/
mode = 0;
}
else if(parg->arg_create3.how.createhow3_u.obj_attributes.mode.set_it == TRUE)
mode =
unix2fsal_mode(parg->arg_create3.how.createhow3_u.obj_attributes.mode.
set_mode3_u.mode);
else
mode = 0;
break;
}
#ifdef _USE_QUOTA
/* if quota support is active, then we should check is the FSAL allows inode creation or not */
fsal_status = FSAL_check_quota( pexport->fullpath,
FSAL_QUOTA_INODES,
FSAL_OP_CONTEXT_TO_UID( pcontext ) ) ;
if( FSAL_IS_ERROR( fsal_status ) )
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_DQUOT ;
break;
case NFS_V3:
pres->res_create3.status = NFS3ERR_DQUOT;
break;
}
rc = NFS_REQ_OK ;
goto out;
}
#endif /* _USE_QUOTA */
// if(str_file_name == NULL || strlen(str_file_name) == 0)
if(str_file_name == NULL || *str_file_name == '\0' )
{
if(preq->rq_vers == NFS_V2)
pres->res_dirop2.status = NFSERR_IO;
if(preq->rq_vers == NFS_V3)
pres->res_create3.status = NFS3ERR_INVAL;
}
else
{
if((cache_status = cache_inode_error_convert(FSAL_str2name(str_file_name,
FSAL_MAX_NAME_LEN,
&file_name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup file to see if it exists. If so, use it. Otherwise
* create a new one.
*/
file_pentry = cache_inode_lookup(parent_pentry,
&file_name,
&attr,
pcontext,
&cache_status_lookup);
if((cache_status_lookup == CACHE_INODE_NOT_FOUND) ||
((cache_status_lookup == CACHE_INODE_SUCCESS)
&& (parg->arg_create3.how.mode == UNCHECKED)))
{
/* Create the file */
if((parg->arg_create3.how.mode == UNCHECKED)
&& (cache_status_lookup == CACHE_INODE_SUCCESS))
{
cache_status = CACHE_INODE_SUCCESS;
attr_newfile = attr;
}
else
file_pentry = cache_inode_create(parent_pentry,
&file_name,
REGULAR_FILE,
mode,
NULL,
&attr_newfile,
pcontext, &cache_status);
if(file_pentry != NULL)
{
/*
* Look at sattr to see if some attributes are to be set at creation time
*/
attributes_create.asked_attributes = 0ULL;
switch (preq->rq_vers)
{
case NFS_V2:
if(nfs2_Sattr_To_FSALattr(&attributes_create,
&parg->arg_create2.attributes) == 0)
{
pres->res_dirop2.status = NFSERR_IO;
rc = NFS_REQ_OK;
goto out;
break;
}
break;
case NFS_V3:
if(nfs3_Sattr_To_FSALattr(&attributes_create,
&parg->arg_create3.how.createhow3_u.
obj_attributes) == 0)
{
pres->res_create3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
break;
}
/* Mode is managed above (in cache_inode_create), there is no need
* to manage it */
if(attributes_create.asked_attributes & FSAL_ATTR_MODE)
attributes_create.asked_attributes &= ~FSAL_ATTR_MODE;
/* Some clients (like Solaris 10) try to set the size of the file to 0
* at creation time. The FSAL create empty file, so we ignore this */
if(attributes_create.asked_attributes & FSAL_ATTR_SIZE)
attributes_create.asked_attributes &= ~FSAL_ATTR_SIZE;
if(attributes_create.asked_attributes & FSAL_ATTR_SPACEUSED)
attributes_create.asked_attributes &= ~FSAL_ATTR_SPACEUSED;
/* Are there attributes to be set (additional to the mode) ? */
if(attributes_create.asked_attributes != 0ULL &&
attributes_create.asked_attributes != FSAL_ATTR_MODE)
{
/* A call to cache_inode_setattr is required */
if(cache_inode_setattr(file_pentry,
&attributes_create,
pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
/* If we are here, there was an error */
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_create3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_create3.CREATE3res_u.resfail.
dir_wcc), NULL, NULL, NULL);
if(nfs_RetryableError(cache_status)) {
rc = NFS_REQ_DROP;
goto out;
}
rc = NFS_REQ_OK;
goto out;
}
/* Get the resulting attributes from the Cache Inode */
if(cache_inode_getattr(file_pentry,
&attr_newfile,
pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
/* If we are here, there was an error */
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_create3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_create3.CREATE3res_u.resfail.
dir_wcc), NULL, NULL, NULL);
if(nfs_RetryableError(cache_status)) {
rc = NFS_REQ_DROP;
goto out;
}
rc = NFS_REQ_OK;
goto out;
}
}
switch (preq->rq_vers)
{
case NFS_V2:
/* Build file handle */
if(nfs2_FSALToFhandle(
&(pres->res_dirop2.DIROP2res_u.diropok.file),
&file_pentry->handle,
pexport) == 0)
pres->res_dirop2.status = NFSERR_IO;
else
{
if(!nfs2_FSALattr_To_Fattr(
pexport, &attr_newfile,
&(pres->res_dirop2.DIROP2res_u.
diropok.attributes)))
pres->res_dirop2.status = NFSERR_IO;
else
pres->res_dirop2.status = NFS_OK;
}
break;
case NFS_V3:
/* Build file handle */
pres->res_create3.status =
nfs3_AllocateFH(&pres->res_create3.CREATE3res_u
.resok.obj.post_op_fh3_u.handle);
if (pres->res_create3.status != NFS3_OK)
{
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
if(nfs3_FSALToFhandle(
&(pres->res_create3.CREATE3res_u.resok
.obj.post_op_fh3_u.handle),
&file_pentry->handle, pexport) == 0)
{
gsh_free(pres->res_create3.CREATE3res_u.resok.obj.
post_op_fh3_u.handle.data.data_val);
pres->res_create3.status = NFS3ERR_BADHANDLE;
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
pres->res_create3.CREATE3res_u.resok.obj.handle_follows
= TRUE;
/* Get the attributes of the parent after the
operation */
attr_parent_after = parent_pentry->attributes;
/* Build entry attributes */
nfs_SetPostOpAttr(pexport,
&attr_newfile,
&(pres->res_create3.CREATE3res_u.resok.
obj_attributes));
/*
* Build Weak Cache Coherency data
*/
nfs_SetWccData(pexport,
ppre_attr,
&attr_parent_after,
&(pres->res_create3.CREATE3res_u
.resok.dir_wcc));
pres->res_create3.status = NFS3_OK;
break;
} /* switch */
rc = NFS_REQ_OK;
goto out;
}
}
else
{
if(cache_status_lookup == CACHE_INODE_SUCCESS)
{
/* Trying to create a file that already exists */
cache_status = CACHE_INODE_ENTRY_EXISTS;
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_EXIST;
break;
case NFS_V3:
pres->res_create3.status = NFS3ERR_EXIST;
break;
}
}
else
{
/* Server fault */
cache_status = cache_status_lookup;
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_IO;
break;
case NFS_V3:
pres->res_create3.status = NFS3ERR_INVAL;
break;
}
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_create3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_create3.CREATE3res_u.resfail.dir_wcc),
NULL, NULL, NULL);
rc = NFS_REQ_OK;
goto out;
} /* if( cache_status_lookup == CACHE_INODE_NOT_FOUND ) */
}
}
/* Set the exit status */
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_create3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_create3.CREATE3res_u.resfail.dir_wcc),
NULL, NULL, NULL);
/* If we are here, there was an error */
if(nfs_RetryableError(cache_status))
{
rc = NFS_REQ_DROP;
goto out;
}
rc = NFS_REQ_OK;
out:
/* return references */
if (file_pentry)
cache_inode_put(file_pentry);
if (parent_pentry)
cache_inode_put(parent_pentry);
return (rc);
} /* nfs_Create */
/**
*
* cache_inode_readdir_nonamecache: Reads a directory without populating the name cache (no dirents created).
*
* Reads a directory without populating the name cache (no dirents created).
*
* @param pentry [IN] entry for the parent directory to be read.
* @param cookie [IN] cookie for the readdir operation (basically the offset).
* @param nbwanted [IN] Maximum number of directory entries wanted.
* @param peod_met [OUT] A flag to know if end of directory was met during this call.
* @param dirent_array [OUT] the resulting array of found directory entries.
* @param ht [IN] hash table used for the cache, unused in this call.
* @param unlock [OUT] the caller shall release read-lock on pentry when done
* @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
*
*/
static cache_inode_status_t cache_inode_readdir_nonamecache( cache_entry_t * pentry_dir,
cache_inode_policy_t policy,
uint64_t cookie,
unsigned int nbwanted,
unsigned int *pnbfound,
uint64_t *pend_cookie,
cache_inode_endofdir_t *peod_met,
cache_inode_dir_entry_t **dirent_array,
hash_table_t *ht,
int *unlock,
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 iter;
fsal_boolean_t fsal_eod;
fsal_dirent_t fsal_dirent_array[FSAL_READDIR_SIZE + 20];
cache_inode_fsal_data_t entry_fsdata;
/* 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;
}
LogFullDebug(COMPONENT_NFS_READDIR,
"About to readdir in cache_inode_readdir_nonamecache: pentry=%p "
"cookie=%"PRIu64, pentry_dir, cookie ) ;
/* 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 */
// memcpy( &(begin_cookie.data), &cookie, sizeof( uint64_t ) ) ;
FSAL_SET_COOKIE_BY_OFFSET( begin_cookie, cookie ) ;
fsal_eod = FALSE;
#ifdef _USE_MFSL
fsal_status = MFSL_readdir( &fsal_dirhandle,
begin_cookie,
pclient->attrmask,
nbwanted * sizeof(fsal_dirent_t),
fsal_dirent_array,
&end_cookie,
(fsal_count_t *)pnbfound,
&fsal_eod,
&pclient->mfsl_context,
NULL);
#else
fsal_status = FSAL_readdir( &fsal_dirhandle,
begin_cookie,
pclient->attrmask,
nbwanted * sizeof(fsal_dirent_t),
fsal_dirent_array,
&end_cookie,
(fsal_count_t *)pnbfound,
&fsal_eod);
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
return *pstatus;
}
for( iter = 0 ; iter < *pnbfound ; iter ++ )
{
/* cache_inode_readdir does not return . or .. */
if(!FSAL_namecmp(&(fsal_dirent_array[iter].name), (fsal_name_t *) & FSAL_DOT) ||
!FSAL_namecmp(&(fsal_dirent_array[iter].name), (fsal_name_t *) & FSAL_DOT_DOT))
continue;
/* Get the related pentry without populating the name cache (but eventually populating the attrs cache */
entry_fsdata.handle = fsal_dirent_array[iter].handle;
entry_fsdata.cookie = 0; /* XXX needed? */
/* Allocate a dirent to be returned to the client */
/** @todo Make sure this piece of memory once the data are used */
GetFromPool( dirent_array[iter], &pclient->pool_dir_entry, cache_inode_dir_entry_t);
if( dirent_array[iter] == NULL )
{
*pstatus = CACHE_INODE_MALLOC_ERROR;
return *pstatus;
}
/* fills in the dirent_array */
if( ( dirent_array[iter]->pentry= cache_inode_get( &entry_fsdata,
policy,
&fsal_dirent_array[iter].attributes,
ht,
pclient,
pcontext,
pstatus ) ) == NULL )
return *pstatus ;
fsal_status = FSAL_namecpy( &dirent_array[iter]->name, &fsal_dirent_array[iter].name ) ;
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
return *pstatus;
}
(void) FSAL_cookie_to_uint64( &fsal_dirent_array[iter].handle,
pcontext,
&fsal_dirent_array[iter].cookie,
&dirent_array[iter]->fsal_cookie);
dirent_array[iter]->cookie = dirent_array[iter]->fsal_cookie ;
} /* for( iter = 0 ; iter < nbfound ; iter ++ ) */
if( fsal_eod == TRUE )
*peod_met = END_OF_DIR ;
else
*peod_met = TO_BE_CONTINUED ;
/* Do not forget to set returned end cookie */
//memcpy( pend_cookie, &(end_cookie.data), sizeof( uint64_t ) ) ;
FSAL_SET_POFFSET_BY_COOKIE( end_cookie, pend_cookie ) ;
LogFullDebug(COMPONENT_NFS_READDIR,
"End of readdir in cache_inode_readdir_nonamecache: pentry=%p "
"cookie=%"PRIu64, pentry_dir, *pend_cookie ) ;
/* 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;
}
return CACHE_INODE_SUCCESS ;
} /* cache_inode_readdir_nomanecache */
/**
*
* cache_inode_remove_sw: removes a pentry addressed by its parent pentry and
* its FSAL name. Mutex management is switched.
*
* Removes a pentry addressed by its parent pentry and its FSAL name. Mutex
* management is switched.
*
* @param pentry [IN] entry for the parent directory to be managed.
* @param name [IN] name of the entry that we are looking for in the cache.
* @param pattr [OUT] attributes for the entry that we have found.
* @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.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
* @return CACHE_INODE_LRU_ERROR if allocation error occured when validating the entry
*
*/
cache_inode_status_t cache_inode_remove_sw(cache_entry_t * pentry, /**< Parent entry */
fsal_name_t * pnode_name,
fsal_attrib_list_t * pattr,
hash_table_t * ht,
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus, int use_mutex)
{
fsal_status_t fsal_status;
cache_entry_t *to_remove_entry;
fsal_handle_t fsal_handle_parent;
fsal_attrib_list_t remove_attr;
fsal_attrib_list_t after_attr;
cache_inode_status_t status;
cache_content_status_t cache_content_status;
int to_remove_numlinks = 0;
fsal_accessflags_t access_mask = 0;
/* stats */
(pclient->stat.nb_call_total)++;
(pclient->stat.func_stats.nb_call[CACHE_INODE_REMOVE])++;
/* pentry is a directory */
if(use_mutex)
P_w(&pentry->lock);
/* 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);
if((status = cache_inode_access_sw(pentry,
access_mask,
ht,
pclient,
pcontext, &status, FALSE)) != CACHE_INODE_SUCCESS)
{
*pstatus = status;
/* pentry is a directory */
if(use_mutex)
V_w(&pentry->lock);
return *pstatus;
}
/* Looks up for the entry to remove */
if((to_remove_entry = cache_inode_lookup_sw( pentry,
pnode_name,
CACHE_INODE_JOKER_POLICY,
&remove_attr,
ht,
pclient,
pcontext,
&status,
FALSE)) == NULL)
{
*pstatus = status;
/* pentry is a directory */
if(use_mutex)
V_w(&pentry->lock);
return *pstatus;
}
/* lock it */
if(use_mutex)
P_w(&to_remove_entry->lock);
if(pentry->internal_md.type != DIRECTORY)
{
if(use_mutex)
{
V_w(&to_remove_entry->lock);
V_w(&pentry->lock);
}
*pstatus = CACHE_INODE_BAD_TYPE;
return *pstatus;
}
LogDebug(COMPONENT_CACHE_INODE,
"---> Cache_inode_remove : %s", pnode_name->name);
/* Non-empty directories should not be removed. */
if(to_remove_entry->internal_md.type == DIRECTORY &&
to_remove_entry->object.dir.has_been_readdir == CACHE_INODE_YES)
{
if(cache_inode_is_dir_empty(to_remove_entry) != CACHE_INODE_SUCCESS)
{
if(use_mutex)
{
V_w(&to_remove_entry->lock);
V_w(&pentry->lock);
}
*pstatus = CACHE_INODE_DIR_NOT_EMPTY;
return *pstatus;
}
}
/* pentry->internal_md.type == DIRECTORY */
fsal_handle_parent = pentry->object.dir.handle;
if(status == CACHE_INODE_SUCCESS)
{
/* Remove the file from FSAL */
after_attr.asked_attributes = pclient->attrmask;
#ifdef _USE_MFSL
cache_inode_get_attributes(pentry, &after_attr);
#ifdef _USE_PNFS
after_attr.numlinks = remove_attr.numlinks ; /* Hook used to pass nlinks to MFSL_unlink */
if( to_remove_entry->internal_md.type == REGULAR_FILE )
fsal_status = MFSL_unlink(&pentry->mobject,
pnode_name,
&to_remove_entry->mobject,
pcontext, &pclient->mfsl_context, &after_attr,
&to_remove_entry->object.file.pnfs_file );
else
#endif /* _USE_PNFS */
fsal_status = MFSL_unlink(&pentry->mobject,
pnode_name,
&to_remove_entry->mobject,
pcontext, &pclient->mfsl_context, &after_attr,
NULL);
#else
fsal_status = FSAL_unlink(&fsal_handle_parent, pnode_name, pcontext, &after_attr);
#endif
/* Set the 'after' attr */
if(pattr != NULL)
*pattr = after_attr;
if(FSAL_IS_ERROR(fsal_status))
{
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_remove: Stale FSAL FH detected for pentry %p",
pentry);
if(cache_inode_kill_entry(pentry, WT_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_remove: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
*pstatus = cache_inode_error_convert(fsal_status);
if(use_mutex)
{
V_w(&to_remove_entry->lock);
V_w(&pentry->lock);
}
return *pstatus;
}
} /* CACHE_INODE_SUCCESS */
else
{
if(use_mutex)
{
V_w(&to_remove_entry->lock);
V_w(&pentry->lock);
}
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_REMOVE])++;
return status;
}
/* Remove the entry from parent dir_entries avl */
cache_inode_remove_cached_dirent(pentry, pnode_name, ht, pclient, &status);
LogFullDebug(COMPONENT_CACHE_INODE,
"cache_inode_remove_cached_dirent: status=%d", status);
/* Update the cached attributes */
pentry->object.dir.attributes = after_attr;
/* Update the attributes for the removed entry */
if(remove_attr.type != FSAL_TYPE_DIR)
{
if(remove_attr.numlinks > 1)
{
switch (to_remove_entry->internal_md.type)
{
case SYMBOLIC_LINK:
assert(to_remove_entry->object.symlink);
to_remove_entry->object.symlink->attributes.numlinks -= 1;
cache_inode_set_time_current( &to_remove_entry->object.symlink->attributes.ctime ) ;
to_remove_numlinks = to_remove_entry->object.symlink->attributes.numlinks;
break;
case REGULAR_FILE:
to_remove_entry->object.file.attributes.numlinks -= 1;
cache_inode_set_time_current( &to_remove_entry->object.file.attributes.ctime ) ;
to_remove_numlinks = to_remove_entry->object.file.attributes.numlinks;
break;
case CHARACTER_FILE:
case BLOCK_FILE:
case SOCKET_FILE:
case FIFO_FILE:
to_remove_entry->object.special_obj.attributes.numlinks -= 1;
cache_inode_set_time_current( &to_remove_entry->object.special_obj.attributes.ctime ) ;
to_remove_numlinks =
to_remove_entry->object.special_obj.attributes.numlinks;
break;
default:
/* Other objects should not be hard linked */
if(use_mutex)
{
V_w(&to_remove_entry->lock);
V_w(&pentry->lock);
}
*pstatus = CACHE_INODE_BAD_TYPE;
return *pstatus;
break;
}
}
}
else
{
/* No hardlink counter to be decremented for a directory: hardlink are not allowed for them */
}
/* Now, delete "to_remove_entry" from the cache inode and free its associated resources, but only if
* numlinks == 0 */
if(to_remove_numlinks == 0)
{
/* If pentry is a regular file, data cached, the related data cache entry should be removed as well */
if(to_remove_entry->internal_md.type == REGULAR_FILE)
{
if(to_remove_entry->object.file.pentry_content != NULL)
{
/* Something is to be deleted, release the cache data entry */
if(cache_content_release_entry
((cache_content_entry_t *) to_remove_entry->object.file.pentry_content,
(cache_content_client_t *) pclient->pcontent_client,
&cache_content_status) != CACHE_CONTENT_SUCCESS)
{
LogEvent(COMPONENT_CACHE_INODE,
"pentry %p, named %s could not be released from data cache, status=%d",
to_remove_entry, pnode_name->name,
cache_content_status);
}
}
}
if((*pstatus =
cache_inode_clean_internal(to_remove_entry, ht,
pclient)) != CACHE_INODE_SUCCESS)
{
if(use_mutex)
{
V_w(&pentry->lock);
V_w(&to_remove_entry->lock);
}
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_clean_internal ERROR %d", *pstatus);
return *pstatus;
}
/* Finally put the main pentry back to pool */
if(use_mutex)
V_w(&to_remove_entry->lock);
/* Destroy the mutex associated with the pentry */
cache_inode_mutex_destroy(to_remove_entry);
ReleaseToPool(to_remove_entry, &pclient->pool_entry);
} /* to_remove->numlinks == 0 */
/* Validate the entries */
*pstatus = cache_inode_valid(pentry, CACHE_INODE_OP_SET, pclient);
/* Regular exit */
if(use_mutex)
{
if(to_remove_numlinks != 0)
V_w(&to_remove_entry->lock); /* This was not release yet, it should be done here */
V_w(&pentry->lock);
}
if(status == CACHE_INODE_SUCCESS)
(pclient->stat.func_stats.nb_success[CACHE_INODE_REMOVE])++;
else
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_REMOVE])++;
return status;
} /* cache_inode_remove */
int nfs_Mkdir(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
char *str_dir_name = NULL;
fsal_accessmode_t mode = 0;
cache_entry_t *dir_pentry = NULL;
cache_entry_t *parent_pentry = NULL;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t attr;
fsal_attrib_list_t *ppre_attr;
fsal_attrib_list_t attr_parent_after;
cache_inode_file_type_t parent_filetype;
fsal_handle_t *pfsal_handle;
fsal_name_t dir_name;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
cache_inode_status_t cache_status_lookup;
cache_inode_create_arg_t create_arg;
int rc = NFS_REQ_OK;
#ifdef _USE_QUOTA
fsal_status_t fsal_status ;
#endif
memset(&create_arg, 0, sizeof(create_arg));
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
str_dir_name = parg->arg_mkdir2.where.name;
break;
case NFS_V3:
str_dir_name = parg->arg_mkdir3.where.name;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_mkdir2.where.dir),
&(parg->arg_mkdir3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Mkdir handle: %s name: %s",
str, str_dir_name);
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
}
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_mkdir2.where.dir),
&(parg->arg_mkdir3.where.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_mkdir3.status),
NULL,
&parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
goto out;
}
/* get directory attributes before action (for V3 reply) */
ppre_attr = &parent_attr;
/* Extract the filetype */
parent_filetype = cache_inode_fsal_type_convert(parent_attr.type);
/*
* Sanity checks:
*/
if(parent_filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_mkdir3.status = NFS3ERR_NOTDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
#ifdef _USE_QUOTA
/* if quota support is active, then we should check is the FSAL allows inode creation or not */
fsal_status = FSAL_check_quota( pexport->fullpath,
FSAL_QUOTA_INODES,
FSAL_OP_CONTEXT_TO_UID( pcontext ) ) ;
if( FSAL_IS_ERROR( fsal_status ) )
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_DQUOT;
break;
case NFS_V3:
pres->res_mkdir3.status = NFS3ERR_DQUOT;
break;
}
rc = NFS_REQ_OK ;
goto out;
}
#endif /* _USE_QUOTA */
switch (preq->rq_vers)
{
case NFS_V2:
str_dir_name = parg->arg_mkdir2.where.name;
if(parg->arg_mkdir2.attributes.mode != (unsigned int)-1)
{
mode = (fsal_accessmode_t) parg->arg_mkdir2.attributes.mode;
}
else
{
mode = (fsal_accessmode_t) 0;
}
break;
case NFS_V3:
str_dir_name = parg->arg_mkdir3.where.name;
if(parg->arg_mkdir3.attributes.mode.set_it == TRUE)
mode = (fsal_accessmode_t) parg->arg_mkdir3.attributes.mode.set_mode3_u.mode;
else
mode = (fsal_accessmode_t) 0;
break;
}
//if(str_dir_name == NULL || strlen(str_dir_name) == 0)
if(str_dir_name == NULL || *str_dir_name == '\0' )
{
if(preq->rq_vers == NFS_V2)
pres->res_dirop2.status = NFSERR_IO;
if(preq->rq_vers == NFS_V3)
pres->res_mkdir3.status = NFS3ERR_INVAL;
}
else
{
/* Make the directory */
if((cache_status = cache_inode_error_convert(FSAL_str2name(str_dir_name,
0,
&dir_name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup file to see if it exists. If so, use it. Otherwise
* create a new one.
*/
dir_pentry = cache_inode_lookup(parent_pentry,
&dir_name,
&attr,
pcontext,
&cache_status_lookup);
if(cache_status_lookup == CACHE_INODE_NOT_FOUND)
{
/* The create_arg structure contains the information "newly created directory"
* to be passed to cache_inode_new_entry from cache_inode_create */
create_arg.newly_created_dir = TRUE;
/* Create the directory */
if((dir_pentry = cache_inode_create(parent_pentry,
&dir_name,
DIRECTORY,
mode,
&create_arg,
&attr,
pcontext, &cache_status)) != NULL)
{
/*
* Get the FSAL handle for this entry
*/
pfsal_handle = &dir_pentry->handle;
if(preq->rq_vers == NFS_V2)
{
DIROP2resok *d2ok = &pres->res_dirop2.DIROP2res_u.diropok;
/* Build file handle */
if(!nfs2_FSALToFhandle(&d2ok->file, pfsal_handle, pexport))
pres->res_dirop2.status = NFSERR_IO;
else
{
/*
* Build entry
* attributes
*/
if(nfs2_FSALattr_To_Fattr(pexport, &attr,
&d2ok->attributes) == 0)
pres->res_dirop2.status = NFSERR_IO;
else
pres->res_dirop2.status = NFS_OK;
}
}
else
{
MKDIR3resok *d3ok = &pres->res_mkdir3.MKDIR3res_u.resok;
/* Build file handle */
pres->res_mkdir3.status =
nfs3_AllocateFH(&d3ok->obj.post_op_fh3_u.handle);
if(pres->res_mkdir3.status != NFS3_OK)
{
rc = NFS_REQ_OK;
goto out;
}
if(nfs3_FSALToFhandle(&d3ok->obj.post_op_fh3_u.handle,
pfsal_handle, pexport) == 0)
{
gsh_free(d3ok->obj.post_op_fh3_u.handle.data.data_val);
pres->res_mkdir3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
d3ok->obj.handle_follows = TRUE;
/*
* Build entry attributes
*/
nfs_SetPostOpAttr(pexport, &attr, &d3ok->obj_attributes);
/* Get the attributes of the parent after the operation */
if(cache_inode_getattr(parent_pentry,
&attr_parent_after,
pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
pres->res_mkdir3.status = nfs3_Errno(cache_status);
rc = NFS_REQ_OK;
goto out;
}
/*
* Build Weak Cache Coherency data
*/
nfs_SetWccData(pexport, ppre_attr, &attr_parent_after,
&d3ok->dir_wcc);
pres->res_mkdir3.status = NFS3_OK;
}
rc = NFS_REQ_OK;
goto out;
}
} /* If( cache_status_lookup == CACHE_INODE_NOT_FOUND ) */
else
{
switch (preq->rq_vers)
{
case NFS_V2:
if(cache_status_lookup == CACHE_INODE_SUCCESS)
pres->res_dirop2.status = NFSERR_EXIST;
else
pres->res_dirop2.status = NFSERR_IO;
break;
case NFS_V3:
if(cache_status_lookup == CACHE_INODE_SUCCESS)
pres->res_mkdir3.status = NFS3ERR_EXIST;
else
pres->res_mkdir3.status = NFS3ERR_INVAL;
nfs_SetWccData(pexport, ppre_attr, NULL,
&(pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc));
break;
}
rc = NFS_REQ_OK;
goto out;
}
}
}
/* If we are here, there was an error */
rc = nfs_SetFailedStatus(pexport, preq->rq_vers, cache_status,
&pres->res_dirop2.status, &pres->res_mkdir3.status,
NULL, ppre_attr,
&(pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc),
NULL, NULL);
out:
/* return references */
if (dir_pentry)
cache_inode_put(dir_pentry);
if (parent_pentry)
cache_inode_put(parent_pentry);
return (rc);
}
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;
}
/**
*
* cache_inode_link: hardlinks a pentry to another.
*
* Hard links a pentry to another. This is basically a equivalent of FSAL_link in the cache inode layer.
*
* @param pentry_src [IN] entry pointer the entry to be linked. This can't be a directory.
* @param pentry_dir_dest [INOUT] entry pointer for the destination directory in which the link will be created.
* @param plink_name [IN] pointer to the name of the object in the destination directory.
* @param pattr [OUT] attributes for the linked attributes after the operation.
* @param ht [INOUT] hash table used for the cache.
* @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 CACHE_INODE_LRU_ERROR if allocation error occured when validating the entry\n
* @return CACHE_INODE_BAD_TYPE either source or destination have incorrect type\n
* @return CACHE_INODE_ENTRY_EXISTS entry of that name already exists in destination.
*
*/
cache_inode_status_t cache_inode_link(cache_entry_t * pentry_src,
cache_entry_t * pentry_dir_dest,
fsal_name_t * plink_name,
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_status_t fsal_status;
fsal_handle_t handle_src;
fsal_handle_t handle_dest;
fsal_attrib_list_t link_attributes;
#ifdef _USE_MFSL
fsal_attrib_list_t dirdest_attributes;
#endif
cache_inode_status_t status;
cache_entry_t *pentry_lookup = NULL;
fsal_attrib_list_t lookup_attributes;
fsal_size_t save_size = 0;
fsal_size_t save_spaceused = 0;
fsal_time_t save_mtime = {
.seconds = 0,
.nseconds = 0
};
fsal_accessflags_t access_mask = 0;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stats */
pclient->stat.nb_call_total += 1;
pclient->stat.func_stats.nb_call[CACHE_INODE_LINK] += 1;
/* Is the destination a directory ? */
if(pentry_dir_dest->internal_md.type != DIR_BEGINNING &&
pentry_dir_dest->internal_md.type != DIR_CONTINUE)
{
/* Bad type .... */
*pstatus = CACHE_INODE_BAD_TYPE;
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LINK] += 1;
return *pstatus;
}
/* 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_ADD_FILE);
if((status = cache_inode_access(pentry_dir_dest,
access_mask,
ht, pclient, pcontext, &status)) != CACHE_INODE_SUCCESS)
{
*pstatus = status;
/* stats */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LINK] += 1;
/* pentry is a directory */
return *pstatus;
}
/* Check if an entry of the same name doesn't exist in the destination directory */
if((pentry_lookup = cache_inode_lookup(pentry_dir_dest,
plink_name,
&lookup_attributes,
ht, pclient, pcontext, pstatus)) != NULL)
{
/* There exists such an entry... */
*pstatus = CACHE_INODE_ENTRY_EXISTS;
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LINK] += 1;
return *pstatus;
}
/* The pentry to be hardlinked can't be a DIR_BEGINNING or a DIR_CONTINUE */
if(pentry_src->internal_md.type == DIR_BEGINNING ||
pentry_src->internal_md.type == DIR_CONTINUE)
{
/* Bad type .... */
*pstatus = CACHE_INODE_BAD_TYPE;
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LINK] += 1;
return *pstatus;
}
#if 0
if( pentry_src->internal_md.type == REGULAR_FILE )
printf( "=== link === %p | inode=%llu\n", pentry_src, pentry_src->object.file.attributes.fileid ) ;
#endif
/* At this point, we know that the entry does not exist in destination directory, we know that the
* destination is actually a directory and that the source is no directory */
/* Lock the source */
P_w(&pentry_src->lock);
/* Lock the target dir */
P_w(&pentry_dir_dest->lock);
/* Get the handles */
switch (pentry_src->internal_md.type)
{
case REGULAR_FILE:
handle_src = pentry_src->object.file.handle;
break;
case SYMBOLIC_LINK:
handle_src = pentry_src->object.symlink.handle;
break;
case FS_JUNCTION:
case DIR_BEGINNING:
handle_src = pentry_src->object.dir_begin.handle;
break;
case DIR_CONTINUE:
/* lock the related dir_begin (dir begin are garbagge collected AFTER their related dir_cont)
* this means that if a DIR_CONTINUE exists, its pdir pointer is not endless */
P_r(&pentry_src->object.dir_cont.pdir_begin->lock);
handle_src = pentry_src->object.dir_cont.pdir_begin->object.dir_begin.handle;
V_r(&pentry_src->object.dir_cont.pdir_begin->lock);
break;
case CHARACTER_FILE:
case BLOCK_FILE:
case SOCKET_FILE:
case FIFO_FILE:
handle_src = pentry_src->object.special_obj.handle;
break;
case UNASSIGNED:
case RECYCLED:
LogCrit(COMPONENT_CACHE_INODE,
"WARNING: unknown source pentry type: internal_md.type=%d, line %d in file %s",
pentry_src->internal_md.type, __LINE__, __FILE__);
*pstatus = CACHE_INODE_BAD_TYPE;
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LINK] += 1;
return *pstatus;
}
switch (pentry_dir_dest->internal_md.type)
{
case FS_JUNCTION:
case DIR_BEGINNING:
handle_dest = pentry_dir_dest->object.dir_begin.handle;
break;
case DIR_CONTINUE:
/* lock the related dir_begin (dir begin are garbagge collected AFTER their related dir_cont)
* this means that if a DIR_CONTINUE exists, its pdir pointer is not endless */
P_r(&pentry_dir_dest->object.dir_cont.pdir_begin->lock);
handle_dest = pentry_src->object.dir_cont.pdir_begin->object.dir_begin.handle;
V_r(&pentry_dir_dest->object.dir_cont.pdir_begin->lock);
break;
default:
LogCrit(COMPONENT_CACHE_INODE,
"WARNING: unknown source pentry type: internal_md.type=%d, line %d in file %s",
pentry_src->internal_md.type, __LINE__, __FILE__);
*pstatus = CACHE_INODE_BAD_TYPE;
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LINK] += 1;
return *pstatus;
}
/* If object is a data cached regular file, keeps it mtime and size, STEP 1 */
if((pentry_src->internal_md.type == REGULAR_FILE)
&& (pentry_src->object.file.pentry_content != NULL))
{
save_mtime = pentry_src->object.file.attributes.mtime;
save_size = pentry_src->object.file.attributes.filesize;
save_spaceused = pentry_src->object.file.attributes.spaceused;
}
/* Do the link at FSAL level */
link_attributes.asked_attributes = pclient->attrmask;
#ifdef _USE_MFSL
cache_inode_get_attributes(pentry_src, &link_attributes);
cache_inode_get_attributes(pentry_dir_dest, &dirdest_attributes);
fsal_status =
MFSL_link(&pentry_src->mobject, &pentry_dir_dest->mobject, plink_name, pcontext,
&pclient->mfsl_context, &link_attributes, NULL);
#else
fsal_status =
FSAL_link(&handle_src, &handle_dest, plink_name, pcontext, &link_attributes);
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
V_w(&pentry_dir_dest->lock);
V_w(&pentry_src->lock);
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
fsal_status_t getattr_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_link: Stale FSAL File Handle detected for at least one in pentry = %p and pentry = %p",
pentry_src, pentry_dir_dest);
/* Use FSAL_getattrs to find which entry is staled */
getattr_status = FSAL_getattrs(&handle_src, pcontext, &link_attributes);
if(getattr_status.major == ERR_FSAL_ACCESS)
{
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_link: Stale FSAL File Handle detected for pentry = %p",
pentry_src);
if(cache_inode_kill_entry(pentry_src, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_link: Could not kill entry %p, status = %u",
pentry_src, kill_status);
}
getattr_status = FSAL_getattrs(&handle_dest, pcontext, &link_attributes);
if(getattr_status.major == ERR_FSAL_ACCESS)
{
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_link: Stale FSAL File Handle detected for pentry = %p",
pentry_dir_dest);
if(cache_inode_kill_entry(pentry_dir_dest, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_link: Could not kill entry %p, status = %u",
pentry_dir_dest, kill_status);
}
}
*pstatus = CACHE_INODE_FSAL_ESTALE;
return *pstatus;
}
/* If object is a data cached regular file, keeps it mtime and size, STEP 2 */
if((pentry_src->internal_md.type == REGULAR_FILE)
&& (pentry_src->object.file.pentry_content != NULL))
{
link_attributes.mtime = save_mtime;
link_attributes.filesize = save_size;
link_attributes.spaceused = save_spaceused;
}
/* Update cached attributes */
cache_inode_set_attributes(pentry_src, &link_attributes);
/* Add the new entry in the destination directory */
if(cache_inode_add_cached_dirent(pentry_dir_dest,
plink_name,
pentry_src,
NULL,
ht, pclient, pcontext, &status) != CACHE_INODE_SUCCESS)
{
V_w(&pentry_dir_dest->lock);
V_w(&pentry_src->lock);
return *pstatus;
}
/* Regular exit */
/* return the attributes */
*pattr = link_attributes;
/* Validate the entries */
*pstatus = cache_inode_valid(pentry_src, CACHE_INODE_OP_SET, pclient);
/* Release the target dir */
V_w(&pentry_dir_dest->lock);
/* Release the source */
V_w(&pentry_src->lock);
/* stats */
if(*pstatus != CACHE_INODE_SUCCESS)
pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_LINK] += 1;
else
pclient->stat.func_stats.nb_success[CACHE_INODE_LINK] += 1;
return *pstatus;
}
/**
*
* cache_inode_setattrs: set the attributes for an entry located in the cache by its address.
*
* 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 [INOUT] attributes for the entry that we have found. Out: attributes set.
* @param ht [INOUT] 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.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
* @return CACHE_INODE_LRU_ERROR if allocation error occured when validating the entry
*
*/
cache_inode_status_t cache_inode_setattr(cache_entry_t * pentry, fsal_attrib_list_t * pattr, hash_table_t * ht, /* Unused, kept for protototype's homogeneity */
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 *p_object_attributes = NULL;
fsal_attrib_list_t result_attributes;
fsal_attrib_list_t truncate_attributes;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stat */
pclient->stat.nb_call_total += 1;
pclient->stat.func_stats.nb_call[CACHE_INODE_SETATTR] += 1;
/* Lock the entry */
P_w(&pentry->lock);
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 FS_JUNCTION:
case DIRECTORY:
pfsal_handle = &pentry->object.dir.handle;
break;
case CHARACTER_FILE:
case BLOCK_FILE:
case SOCKET_FILE:
case FIFO_FILE:
pfsal_handle = &pentry->object.special_obj.handle;
break;
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 set the attributes */
/* result_attributes.asked_attributes = pattr->asked_attributes ; */
/* mod Th.Leibovici on 2006/02/13
* We ask back all standard attributes, in case they have been modified
* by another program (pftp, rcpd...)
*/
memset(&result_attributes, 0, sizeof(fsal_attrib_list_t));
result_attributes.asked_attributes = pclient->attrmask;
/* end of mod */
#ifdef _USE_MFSL
fsal_status =
MFSL_setattrs(&pentry->mobject, pcontext, &pclient->mfsl_context, pattr,
&result_attributes, NULL);
#else
fsal_status = FSAL_setattrs(pfsal_handle, pcontext, pattr, &result_attributes);
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
V_w(&pentry->lock);
/* stat */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_SETATTR] += 1;
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_setattr: Stale FSAL File Handle detected for pentry = %p",
pentry);
if(cache_inode_kill_entry(pentry, NO_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_setattr: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
return *pstatus;
}
if(pattr->asked_attributes & FSAL_ATTR_SIZE)
{
truncate_attributes.asked_attributes = pclient->attrmask;
fsal_status = FSAL_truncate(pfsal_handle,
pcontext, pattr->filesize, NULL, &truncate_attributes);
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
V_w(&pentry->lock);
/* stat */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_SETATTR] += 1;
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_setattr: Stale FSAL File Handle detected for pentry = %p",
pentry);
if(cache_inode_kill_entry(pentry, NO_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_setattr: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
return *pstatus;
}
}
/* Keep the new attribute in cache */
switch (pentry->internal_md.type)
{
case REGULAR_FILE:
p_object_attributes = &(pentry->object.file.attributes);
break;
case SYMBOLIC_LINK:
assert(pentry->object.symlink);
p_object_attributes = &(pentry->object.symlink->attributes);
break;
case FS_JUNCTION:
case DIRECTORY:
p_object_attributes = &(pentry->object.dir.attributes);
break;
case CHARACTER_FILE:
case BLOCK_FILE:
case SOCKET_FILE:
case FIFO_FILE:
p_object_attributes = &(pentry->object.special_obj.attributes);
break;
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;
}
/* Update the cached attributes */
if((result_attributes.asked_attributes & FSAL_ATTR_SIZE) ||
(result_attributes.asked_attributes & FSAL_ATTR_SPACEUSED))
{
if(pentry->internal_md.type == REGULAR_FILE)
{
if(pentry->object.file.pentry_content == NULL)
{
/* Operation on a non data cached file */
p_object_attributes->filesize = result_attributes.filesize;
p_object_attributes->spaceused = result_attributes.filesize; /* Unclear hook here. BUGAZOMEU */
}
else
{
/* Data cached file */
/* Do not set the p_object_attributes->filesize and p_object_attributes->spaceused in this case
* This will lead to a situation where (for example) untar-ing a file will produced invalid files
* with a size of 0 despite the fact that they are not empty */
LogFullDebug(COMPONENT_CACHE_INODE,
"cache_inode_setattr with FSAL_ATTR_SIZE on data cached entry");
}
}
else if(pattr->asked_attributes & FSAL_ATTR_SIZE)
LogCrit(COMPONENT_CACHE_INODE,
"WARNING !!! cache_inode_setattr tried to set size on a non REGULAR_FILE type=%d",
pentry->internal_md.type);
}
if(result_attributes.asked_attributes &
(FSAL_ATTR_MODE | FSAL_ATTR_OWNER | FSAL_ATTR_GROUP))
{
if(result_attributes.asked_attributes & FSAL_ATTR_MODE)
p_object_attributes->mode = result_attributes.mode;
if(result_attributes.asked_attributes & FSAL_ATTR_OWNER)
p_object_attributes->owner = result_attributes.owner;
if(result_attributes.asked_attributes & FSAL_ATTR_GROUP)
p_object_attributes->group = result_attributes.group;
}
if(result_attributes.asked_attributes &
(FSAL_ATTR_ATIME | FSAL_ATTR_CTIME | FSAL_ATTR_MTIME))
{
if(result_attributes.asked_attributes & FSAL_ATTR_ATIME)
p_object_attributes->atime = result_attributes.atime;
if(result_attributes.asked_attributes & FSAL_ATTR_CTIME)
p_object_attributes->ctime = result_attributes.ctime;
if(result_attributes.asked_attributes & FSAL_ATTR_MTIME)
p_object_attributes->mtime = result_attributes.mtime;
}
#ifdef _USE_NFS4_ACL
if(result_attributes.asked_attributes & FSAL_ATTR_ACL)
{
LogDebug(COMPONENT_CACHE_INODE, "cache_inode_setattr: old acl = %p, new acl = %p",
p_object_attributes->acl, result_attributes.acl);
/* Release previous acl entry. */
if(p_object_attributes->acl)
{
fsal_acl_status_t status;
nfs4_acl_release_entry(p_object_attributes->acl, &status);
if(status != NFS_V4_ACL_SUCCESS)
LogEvent(COMPONENT_CACHE_INODE, "cache_inode_setattr: Failed to release old acl:"
" status = %d", status);
}
/* Update with new acl entry. */
p_object_attributes->acl = result_attributes.acl;
}
#endif /* _USE_NFS4_ACL */
/* Return the attributes as set */
*pattr = *p_object_attributes;
/* validate the entry */
*pstatus = cache_inode_valid(pentry, CACHE_INODE_OP_SET, pclient);
/* Release the entry */
V_w(&pentry->lock);
/* stat */
if(*pstatus != CACHE_INODE_SUCCESS)
pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_SETATTR] += 1;
else
pclient->stat.func_stats.nb_success[CACHE_INODE_SETATTR] += 1;
return *pstatus;
} /* cache_inode_setattr */
/**
*
* 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 */
/**
* @brief Implement actual work of removing file
*
* Actually remove an entry from the directory. Assume that the
* directory contents and attributes are locked for writes. The
* attribute lock is released unless keep_md_lock is TRUE.
*
* @param[in] entry Entry for the parent directory to be managed.
* @param[in] name Name of the entry that we are looking for in the cache.
* @param[in] context FSAL credentials
* @param[in] status Returned status
* @param[in] flags Flags to control lock retention
*
* @return CACHE_INODE_SUCCESS if operation is a success
*
*/
cache_inode_status_t
cache_inode_remove_impl(cache_entry_t *entry,
fsal_name_t *name,
fsal_op_context_t *context,
cache_inode_status_t *status,
uint32_t flags)
{
cache_entry_t *to_remove_entry = NULL;
fsal_status_t fsal_status = {0, 0};
#ifdef _USE_NFS4_ACL
fsal_acl_t *saved_acl = NULL;
fsal_acl_status_t acl_status = 0;
#endif /* _USE_NFS4_ACL */
if(entry->type != DIRECTORY) {
*status = CACHE_INODE_BAD_TYPE;
goto out;
}
if (!(flags & CACHE_INODE_FLAG_CONTENT_HAVE)) {
pthread_rwlock_rdlock(&entry->content_lock);
flags |= CACHE_INODE_FLAG_CONTENT_HAVE;
}
/* 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 */
if ((to_remove_entry
= cache_inode_lookup_impl(entry,
name,
context,
status)) == NULL) {
goto out;
}
/* Lock the attributes (so we can decrement the link count) */
pthread_rwlock_wrlock(&to_remove_entry->attr_lock);
LogDebug(COMPONENT_CACHE_INODE,
"---> Cache_inode_remove : %s", name->name);
#ifdef _USE_NFS4_ACL
saved_acl = entry->attributes.acl;
#endif /* _USE_NFS4_ACL */
fsal_status = FSAL_unlink(&entry->handle,
name,
context,
&entry->attributes);
if (FSAL_IS_ERROR(fsal_status)) {
*status = cache_inode_error_convert(fsal_status);
if (fsal_status.major == ERR_FSAL_STALE) {
cache_inode_kill_entry(entry);
}
goto unlock;
} else {
#ifdef _USE_NFS4_ACL
/* Decrement refcount on saved ACL */
nfs4_acl_release_entry(saved_acl, &acl_status);
if (acl_status != NFS_V4_ACL_SUCCESS) {
LogCrit(COMPONENT_CACHE_INODE,
"Failed to release old acl, status=%d",
acl_status);
}
#endif /* _USE_NFS4_ACL */
}
cache_inode_fixup_md(entry);
if ((flags & CACHE_INODE_FLAG_ATTR_HAVE) &&
!(flags & CACHE_INODE_FLAG_ATTR_HOLD)) {
pthread_rwlock_unlock(&entry->attr_lock);
}
/* Remove the entry from parent dir_entries avl */
cache_inode_remove_cached_dirent(entry, name, status);
LogFullDebug(COMPONENT_CACHE_INODE,
"cache_inode_remove_cached_dirent: status=%d", *status);
/* Update the attributes for the removed entry */
if ((to_remove_entry->type != DIRECTORY) &&
(to_remove_entry->attributes.numlinks > 1)) {
if ((*status = cache_inode_refresh_attrs(to_remove_entry,
context))
!= CACHE_INODE_SUCCESS) {
goto unlock;
}
} else {
/* Otherwise our count is zero, or it was an empty
directory. */
to_remove_entry->attributes.numlinks = 0;
}
/* Now, delete "to_remove_entry" from the cache inode and free
its associated resources, but only if numlinks == 0 */
if (to_remove_entry->attributes.numlinks == 0) {
/* Destroy the entry when everyone's references to it have
been relinquished. Most likely now. */
pthread_rwlock_unlock(&to_remove_entry->attr_lock);
/* Kill off the sentinel reference (and mark the entry so
it doesn't get recycled while a reference exists.) */
cache_inode_lru_kill(to_remove_entry);
} else {
unlock:
pthread_rwlock_unlock(&to_remove_entry->attr_lock);
}
out:
if ((flags & CACHE_INODE_FLAG_CONTENT_HAVE) &&
!(flags & CACHE_INODE_FLAG_CONTENT_HOLD)) {
pthread_rwlock_unlock(&entry->content_lock);
}
/* This is for the reference taken by lookup */
if (to_remove_entry)
{
cache_inode_put(to_remove_entry);
}
return *status;
}
int nfs3_Mknod(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t * pres)
{
cache_entry_t *parent_pentry = NULL;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t *ppre_attr;
fsal_attrib_list_t attr_parent_after;
cache_inode_file_type_t parent_filetype;
cache_inode_file_type_t nodetype;
char *str_file_name = NULL;
fsal_name_t file_name;
cache_inode_status_t cache_status;
cache_inode_status_t cache_status_lookup;
fsal_accessmode_t mode = 0;
cache_entry_t *node_pentry = NULL;
fsal_attrib_list_t attr;
cache_inode_create_arg_t create_arg;
fsal_handle_t *pfsal_handle;
int rc = NFS_REQ_OK;
#ifdef _USE_QUOTA
fsal_status_t fsal_status ;
#endif
memset(&create_arg, 0, sizeof(create_arg));
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
sprint_fhandle3(str, &(parg->arg_mknod3.where.dir));
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs3_Mknod handle: %s name: %s",
str, parg->arg_mknod3.where.name);
}
/* to avoid setting them on each error case */
pres->res_mknod3.MKNOD3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_mknod3.MKNOD3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
/* retrieve parent entry */
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
NULL,
&(parg->arg_mknod3.where.dir),
NULL,
NULL,
&(pres->res_mknod3.status),
NULL,
&parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
return rc;
}
/* get directory attributes before action (for V3 reply) */
ppre_attr = &parent_attr;
/* Extract the filetype */
parent_filetype = cache_inode_fsal_type_convert(parent_attr.type);
/*
* Sanity checks: new node name must be non-null; parent must be a
* directory.
*/
if(parent_filetype != DIRECTORY)
{
pres->res_mknod3.status = NFS3ERR_NOTDIR;
rc = NFS_REQ_OK;
goto out;
}
str_file_name = parg->arg_mknod3.where.name;
switch (parg->arg_mknod3.what.type)
{
case NF3CHR:
case NF3BLK:
if(parg->arg_mknod3.what.mknoddata3_u.device.dev_attributes.mode.set_it)
mode =
(fsal_accessmode_t) parg->arg_mknod3.what.mknoddata3_u.device.dev_attributes.
mode.set_mode3_u.mode;
else
mode = (fsal_accessmode_t) 0;
create_arg.dev_spec.major =
parg->arg_mknod3.what.mknoddata3_u.device.spec.specdata1;
create_arg.dev_spec.minor =
parg->arg_mknod3.what.mknoddata3_u.device.spec.specdata2;
break;
case NF3FIFO:
case NF3SOCK:
if(parg->arg_mknod3.what.mknoddata3_u.pipe_attributes.mode.set_it)
mode =
(fsal_accessmode_t) parg->arg_mknod3.what.mknoddata3_u.pipe_attributes.mode.
set_mode3_u.mode;
else
mode = (fsal_accessmode_t) 0;
create_arg.dev_spec.major = 0;
create_arg.dev_spec.minor = 0;
break;
default:
pres->res_mknod3.status = NFS3ERR_BADTYPE;
rc = NFS_REQ_OK;
goto out;
}
switch (parg->arg_mknod3.what.type)
{
case NF3CHR:
nodetype = CHARACTER_FILE;
break;
case NF3BLK:
nodetype = BLOCK_FILE;
break;
case NF3FIFO:
nodetype = FIFO_FILE;
break;
case NF3SOCK:
nodetype = SOCKET_FILE;
break;
default:
pres->res_mknod3.status = NFS3ERR_BADTYPE;
rc = NFS_REQ_OK;
goto out;
}
//if(str_file_name == NULL || strlen(str_file_name) == 0)
if(str_file_name == NULL || *str_file_name == '\0' )
{
pres->res_mknod3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
#ifdef _USE_QUOTA
/* if quota support is active, then we should check is the FSAL allows inode creation or not */
fsal_status = FSAL_check_quota( pexport->fullpath,
FSAL_QUOTA_INODES,
FSAL_OP_CONTEXT_TO_UID( pcontext ) ) ;
if( FSAL_IS_ERROR( fsal_status ) )
{
pres->res_mknod3.status = NFS3ERR_DQUOT;
return NFS_REQ_OK;
}
#endif /* _USE_QUOTA */
/* convert node name */
if((cache_status = cache_inode_error_convert(FSAL_str2name(str_file_name,
0,
&file_name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup node to see if it exists. If so, use it. Otherwise
* create a new one.
*/
node_pentry = cache_inode_lookup(parent_pentry,
&file_name,
&attr,
pcontext,
&cache_status_lookup);
if(cache_status_lookup == CACHE_INODE_NOT_FOUND)
{
/* Create the node */
if((node_pentry = cache_inode_create(parent_pentry,
&file_name,
nodetype,
mode,
&create_arg,
&attr,
pcontext,
&cache_status)) != NULL)
{
MKNOD3resok *rok = &pres->res_mknod3.MKNOD3res_u.resok;
/*
* Get the FSAL handle for this entry
*/
pfsal_handle = &node_pentry->handle;
/* Build file handle */
pres->res_mknod3.status =
nfs3_AllocateFH(&rok->obj.post_op_fh3_u.handle);
if(pres->res_mknod3.status != NFS3_OK)
return NFS_REQ_OK;
if(nfs3_FSALToFhandle(&rok->obj.post_op_fh3_u.handle,
pfsal_handle, pexport) == 0)
{
gsh_free(rok->obj.post_op_fh3_u.handle.data.data_val);
pres->res_mknod3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
rok->obj.handle_follows = TRUE;
/* Build entry attributes */
nfs_SetPostOpAttr(pexport, &attr, &rok->obj_attributes);
/* Get the attributes of the parent after the operation */
if(cache_inode_getattr(parent_pentry,
&attr_parent_after,
pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
pres->res_mknod3.status = nfs3_Errno(cache_status);
rc = NFS_REQ_OK;
goto out;
}
/* Build Weak Cache Coherency data */
nfs_SetWccData(pexport, ppre_attr, &attr_parent_after,
&rok->dir_wcc);
pres->res_mknod3.status = NFS3_OK;
rc = NFS_REQ_OK;
goto out;
}
/* mknod sucess */
} /* not found */
else
{
/* object already exists or failure during lookup */
if(cache_status_lookup == CACHE_INODE_SUCCESS)
{
/* Trying to create an entry that already exists */
pres->res_mknod3.status = NFS3ERR_EXIST;
}
else
{
/* Server fault */
pres->res_mknod3.status = NFS3ERR_INVAL;
}
nfs_SetWccData(pexport, NULL, NULL,
&(pres->res_mknod3.MKNOD3res_u.resfail.dir_wcc));
rc = NFS_REQ_OK;
goto out;
}
}
/* If we are here, there was an error */
rc = nfs_SetFailedStatus(pexport, preq->rq_vers, cache_status, NULL,
&pres->res_mknod3.status, NULL, ppre_attr,
&(pres->res_mknod3.MKNOD3res_u.resfail.dir_wcc),
NULL, NULL);
out:
/* return references */
if (parent_pentry)
cache_inode_put(parent_pentry);
if (node_pentry)
cache_inode_put(node_pentry);
return (rc);
} /* nfs3_Mknod */
/**
* @brief Set the attributes for a file.
*
* This function sets the attributes of a file, both in the cache and
* in the underlying filesystem.
*
* @param[in] entry Entry whose attributes are to be set
* @param[in,out] attr Attributes to set/result of set
*
* @retval CACHE_INODE_SUCCESS if operation is a success
*/
cache_inode_status_t
cache_inode_setattr(cache_entry_t *entry,
struct attrlist *attr,
bool is_open_write)
{
struct fsal_obj_handle *obj_handle = entry->obj_handle;
fsal_status_t fsal_status = { 0, 0 };
fsal_acl_t *saved_acl = NULL;
fsal_acl_status_t acl_status = 0;
cache_inode_status_t status = CACHE_INODE_SUCCESS;
uint64_t before;
/* True if we have taken the content lock on 'entry' */
bool content_locked = false;
if ((attr->mask & (ATTR_SIZE | ATTR4_SPACE_RESERVED))
&& (entry->type != REGULAR_FILE)) {
LogWarn(COMPONENT_CACHE_INODE,
"Attempt to truncate non-regular file: type=%d",
entry->type);
status = CACHE_INODE_BAD_TYPE;
}
/* Is it allowed to change times ? */
if (!op_ctx->fsal_export->ops->fs_supports(op_ctx->fsal_export,
fso_cansettime)
&&
(FSAL_TEST_MASK
(attr->mask,
(ATTR_ATIME | ATTR_CREATION | ATTR_CTIME | ATTR_MTIME)))) {
status = CACHE_INODE_INVALID_ARGUMENT;
goto out;
}
/* Get wrlock on attr_lock and verify attrs */
status = cache_inode_lock_trust_attrs(entry, true);
if (status != CACHE_INODE_SUCCESS)
return status;
/* Do permission checks */
status = cache_inode_check_setattr_perms(entry, attr, is_open_write);
if (status != CACHE_INODE_SUCCESS)
goto unlock;
if (attr->mask & (ATTR_SIZE | ATTR4_SPACE_RESERVED)) {
PTHREAD_RWLOCK_wrlock(&entry->content_lock);
content_locked = true;
}
saved_acl = obj_handle->attributes.acl;
before = obj_handle->attributes.change;
fsal_status = obj_handle->ops->setattrs(obj_handle, attr);
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_CACHE_INODE,
"FSAL returned STALE from truncate");
cache_inode_kill_entry(entry);
}
goto unlock;
}
fsal_status = obj_handle->ops->getattrs(obj_handle);
*attr = obj_handle->attributes;
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_CACHE_INODE,
"FSAL returned STALE from setattrs");
cache_inode_kill_entry(entry);
}
goto unlock;
}
if (before == obj_handle->attributes.change)
obj_handle->attributes.change++;
/* Decrement refcount on saved ACL */
nfs4_acl_release_entry(saved_acl, &acl_status);
if (acl_status != NFS_V4_ACL_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"Failed to release old acl, status=%d", acl_status);
cache_inode_fixup_md(entry);
/* Copy the complete set of new attributes out. */
*attr = entry->obj_handle->attributes;
status = CACHE_INODE_SUCCESS;
unlock:
if (content_locked)
PTHREAD_RWLOCK_unlock(&entry->content_lock);
PTHREAD_RWLOCK_unlock(&entry->attr_lock);
out:
return status;
}
cache_inode_status_t cache_inode_open(cache_entry_t * pentry,
cache_inode_client_t * pclient,
fsal_openflags_t openflags,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus)
{
fsal_status_t fsal_status;
if((pentry == NULL) || (pclient == NULL) || (pcontext == NULL) || (pstatus == NULL))
return CACHE_INODE_INVALID_ARGUMENT;
if(pentry->internal_md.type != REGULAR_FILE)
{
*pstatus = CACHE_INODE_BAD_TYPE;
return *pstatus;
}
/* Open file need to be closed, unless it is already open as read/write */
if((pentry->object.file.open_fd.openflags != FSAL_O_RDWR) &&
(pentry->object.file.open_fd.openflags != 0) &&
(pentry->object.file.open_fd.fileno != 0) &&
(pentry->object.file.open_fd.openflags != openflags))
{
#ifdef _USE_MFSL
fsal_status = MFSL_close(&(pentry->object.file.open_fd.mfsl_fd), &pclient->mfsl_context, NULL);
#else
fsal_status = FSAL_close(&(pentry->object.file.open_fd.fd));
#endif
if(FSAL_IS_ERROR(fsal_status) && (fsal_status.major != ERR_FSAL_NOT_OPENED))
{
*pstatus = cache_inode_error_convert(fsal_status);
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_open: returning %d(%s) from FSAL_close",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
/* force re-openning */
pentry->object.file.open_fd.last_op = 0;
pentry->object.file.open_fd.fileno = 0;
}
if((pentry->object.file.open_fd.last_op == 0)
|| (pentry->object.file.open_fd.fileno == 0))
{
/* opened file is not preserved yet */
#ifdef _USE_MFSL
fsal_status = MFSL_open(&(pentry->mobject),
pcontext,
&pclient->mfsl_context,
openflags,
&pentry->object.file.open_fd.mfsl_fd,
&(pentry->object.file.attributes),
NULL );
#else
fsal_status = FSAL_open(&(pentry->object.file.handle),
pcontext,
openflags,
&pentry->object.file.open_fd.fd,
&(pentry->object.file.attributes));
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_open: returning %d(%s) from FSAL_open",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
#ifdef _USE_MFSL
pentry->object.file.open_fd.fileno = FSAL_FILENO(&(pentry->object.file.open_fd.mfsl_fd.fsal_file));
#else
pentry->object.file.open_fd.fileno = FSAL_FILENO(&(pentry->object.file.open_fd.fd));
#endif
pentry->object.file.open_fd.openflags = openflags;
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_open: pentry %p: lastop=0, fileno = %d, openflags = %d",
pentry, pentry->object.file.open_fd.fileno, (int) openflags);
}
/* regular exit */
pentry->object.file.open_fd.last_op = time(NULL);
/* if file descriptor is too high, garbage collect FDs */
if(pclient->use_fd_cache
&& (pentry->object.file.open_fd.fileno > pclient->max_fd))
{
if(cache_inode_gc_fd(pclient, pstatus) != CACHE_INODE_SUCCESS)
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"FAILURE performing FD garbage collection");
return *pstatus;
}
}
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
} /* cache_inode_open */
int nfs_Remove(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
cache_entry_t *parent_pentry = NULL;
cache_entry_t *pentry_child = NULL;
fsal_attrib_list_t pre_parent_attr;
fsal_attrib_list_t pentry_child_attr;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t *pparent_attr = NULL;
cache_inode_file_type_t filetype;
cache_inode_file_type_t childtype;
cache_inode_status_t cache_status;
char *file_name = NULL;
fsal_name_t name;
int rc = NFS_REQ_OK;
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
file_name = parg->arg_remove2.name;
break;
case NFS_V3:
file_name = parg->arg_remove3.object.name;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_create2.where.dir),
&(parg->arg_create3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Remove handle: %s name: %s",
str, file_name);
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_remove3.REMOVE3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_remove3.REMOVE3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
pparent_attr = NULL;
}
/* Convert file handle into a pentry */
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_remove2.dir),
&(parg->arg_remove3.object.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_remove3.status),
NULL,
&pre_parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
goto out;
}
if((preq->rq_vers == NFS_V3) && (nfs3_Is_Fh_Xattr(&(parg->arg_remove3.object.dir)))) {
rc = nfs3_Remove_Xattr(parg, pexport, pcontext, preq, pres);
goto out;
}
/* get directory attributes before action (for V3 reply) */
pparent_attr = &pre_parent_attr;
/* Extract the filetype */
filetype = cache_inode_fsal_type_convert(pre_parent_attr.type);
/*
* Sanity checks: new directory name must be non-null; parent must be
* a directory.
*/
if(filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_remove3.status = NFS3ERR_NOTDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
switch (preq->rq_vers)
{
case NFS_V2:
file_name = parg->arg_remove2.name;
break;
case NFS_V3:
file_name = parg->arg_remove3.object.name;
break;
}
//if(file_name == NULL || strlen(file_name) == 0)
if(file_name == NULL || *file_name == '\0' )
{
cache_status = CACHE_INODE_INVALID_ARGUMENT; /* for lack of better... */
}
else
{
if((cache_status = cache_inode_error_convert(FSAL_str2name(file_name,
0,
&name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup to the child entry to check if it is a directory
*
*/
if((pentry_child = cache_inode_lookup(parent_pentry,
&name,
&pentry_child_attr,
pcontext,
&cache_status)) != NULL)
{
/* Extract the filetype */
childtype = cache_inode_fsal_type_convert(pentry_child_attr.type);
/*
* Sanity check: make sure we are about to remove a directory
*/
if(childtype == DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFSERR_ISDIR;
break;
case NFS_V3:
pres->res_remove3.status = NFS3ERR_ISDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
LogFullDebug(COMPONENT_NFSPROTO,
"==== NFS REMOVE ====> Trying to remove file %s",
name.name);
/*
* Remove the entry.
*/
if(cache_inode_remove(parent_pentry,
&name,
&parent_attr,
pcontext, &cache_status) == CACHE_INODE_SUCCESS)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFS_OK;
break;
case NFS_V3:
/* Build Weak Cache Coherency data */
nfs_SetWccData(pexport,
pparent_attr,
&parent_attr,
&(pres->res_remove3.REMOVE3res_u.resok.dir_wcc));
pres->res_remove3.status = NFS3_OK;
break;
}
rc = NFS_REQ_OK;
goto out;
}
}
}
}
/* If we are here, there was an error */
rc = nfs_SetFailedStatus(pexport, preq->rq_vers, cache_status,
&pres->res_stat2,
&pres->res_remove3.status,
NULL,
pparent_attr,
&(pres->res_remove3.REMOVE3res_u.resfail.dir_wcc),
NULL, NULL);
out:
/* return references */
if (pentry_child)
cache_inode_put(pentry_child);
if (parent_pentry)
cache_inode_put(parent_pentry);
return (rc);
} /* nfs_Remove */
cache_inode_status_t cache_inode_open_by_name(cache_entry_t * pentry_dir,
fsal_name_t * pname,
cache_entry_t * pentry_file,
cache_inode_client_t * pclient,
fsal_openflags_t openflags,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus)
{
fsal_status_t fsal_status;
fsal_size_t save_filesize = 0;
fsal_size_t save_spaceused = 0;
fsal_time_t save_mtime = {
.seconds = 0,
.nseconds = 0
};
if((pentry_dir == NULL) || (pname == NULL) || (pentry_file == NULL) ||
(pclient == NULL) || (pcontext == NULL) || (pstatus == NULL))
return CACHE_INODE_INVALID_ARGUMENT;
if((pentry_dir->internal_md.type != DIRECTORY))
{
*pstatus = CACHE_INODE_BAD_TYPE;
return *pstatus;
}
if(pentry_file->internal_md.type != REGULAR_FILE)
{
*pstatus = CACHE_INODE_BAD_TYPE;
return *pstatus;
}
/* Open file need to be closed, unless it is already open as read/write */
if((pentry_file->object.file.open_fd.openflags != FSAL_O_RDWR) &&
(pentry_file->object.file.open_fd.openflags != 0) &&
(pentry_file->object.file.open_fd.fileno >= 0) &&
(pentry_file->object.file.open_fd.openflags != openflags))
{
#ifdef _USE_MFSL
fsal_status =
MFSL_close(&(pentry_file->object.file.open_fd.mfsl_fd), &pclient->mfsl_context, NULL);
#else
fsal_status = FSAL_close(&(pentry_file->object.file.open_fd.fd));
#endif
if(FSAL_IS_ERROR(fsal_status) && (fsal_status.major != ERR_FSAL_NOT_OPENED))
{
*pstatus = cache_inode_error_convert(fsal_status);
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_open_by_name: returning %d(%s) from FSAL_close",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
pentry_file->object.file.open_fd.last_op = 0;
pentry_file->object.file.open_fd.fileno = 0;
}
if(pentry_file->object.file.open_fd.last_op == 0
|| pentry_file->object.file.open_fd.fileno == 0)
{
LogDebug(COMPONENT_FSAL,
"cache_inode_open_by_name: pentry %p: lastop=0", pentry_file);
/* Keep coherency with the cache_content */
if(pentry_file->object.file.pentry_content != NULL)
{
save_filesize = pentry_file->object.file.attributes.filesize;
save_spaceused = pentry_file->object.file.attributes.spaceused;
save_mtime = pentry_file->object.file.attributes.mtime;
}
/* opened file is not preserved yet */
#ifdef _USE_MFSL
fsal_status = MFSL_open_by_name(&(pentry_dir->mobject),
pname,
pcontext,
&pclient->mfsl_context,
openflags,
&pentry_file->object.file.open_fd.mfsl_fd,
&(pentry_file->object.file.attributes),
#ifdef _USE_PNFS
&pentry_file->object.file.pnfs_file ) ;
#else
NULL );
#endif /* _USE_PNFS */
#else
fsal_status = FSAL_open_by_name(&(pentry_dir->object.file.handle),
pname,
pcontext,
openflags,
&pentry_file->object.file.open_fd.fd,
&(pentry_file->object.file.attributes));
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_open_by_name: returning %d(%s) from FSAL_open_by_name",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
#ifdef _USE_PROXY
/* If proxy if used, we should keep the name of the file to do FSAL_rcp if needed */
if((pentry_file->object.file.pname =
(fsal_name_t *) Mem_Alloc_Label(sizeof(fsal_name_t), "fsal_name_t")) == NULL)
{
*pstatus = CACHE_INODE_MALLOC_ERROR;
return *pstatus;
}
pentry_file->object.file.pentry_parent_open = pentry_dir;
pentry_file->object.file.pname->len = pname->len;
memcpy((char *)(pentry_file->object.file.pname->name), (char *)(pname->name),
FSAL_MAX_NAME_LEN);
#endif
/* Keep coherency with the cache_content */
if(pentry_file->object.file.pentry_content != NULL)
{
pentry_file->object.file.attributes.filesize = save_filesize;
pentry_file->object.file.attributes.spaceused = save_spaceused;
pentry_file->object.file.attributes.mtime = save_mtime;
}
#ifdef _USE_MFSL
pentry_file->object.file.open_fd.fileno =
(int)FSAL_FILENO(&(pentry_file->object.file.open_fd.mfsl_fd.fsal_file));
#else
pentry_file->object.file.open_fd.fileno =
(int)FSAL_FILENO(&(pentry_file->object.file.open_fd.fd));
#endif
pentry_file->object.file.open_fd.last_op = time(NULL);
pentry_file->object.file.open_fd.openflags = openflags;
LogDebug(COMPONENT_FSAL,
"cache_inode_open_by_name: pentry %p: fd=%u",
pentry_file, pentry_file->object.file.open_fd.fileno);
}
/* regular exit */
pentry_file->object.file.open_fd.last_op = time(NULL);
/* if file descriptor is too high, garbage collect FDs */
if(pclient->use_fd_cache
&& (pentry_file->object.file.open_fd.fileno > pclient->max_fd))
{
if(cache_inode_gc_fd(pclient, pstatus) != CACHE_INODE_SUCCESS)
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"FAILURE performing FD garbage collection");
return *pstatus;
}
}
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
} /* cache_inode_open_by_name */
cache_inode_status_t cache_inode_readlink(cache_entry_t * pentry, fsal_path_t * plink_content, hash_table_t * ht, /* Unused, kept for protototype's homogeneity */
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus)
{
fsal_status_t fsal_status;
fsal_attrib_list_t attr ;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stats */
(pclient->stat.nb_call_total)++;
(pclient->stat.func_stats.nb_call[CACHE_INODE_READLINK])++;
/* Lock the entry */
P_w(&pentry->lock);
if(cache_inode_renew_entry(pentry, NULL, ht, pclient, pcontext, pstatus) !=
CACHE_INODE_SUCCESS)
{
(pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_READLINK])++;
V_w(&pentry->lock);
return *pstatus;
}
/* RW_Lock obtained as writer turns to reader */
rw_lock_downgrade(&pentry->lock);
switch (pentry->internal_md.type)
{
case REGULAR_FILE:
case DIRECTORY:
case CHARACTER_FILE:
case BLOCK_FILE:
case SOCKET_FILE:
case FIFO_FILE:
case UNASSIGNED:
case FS_JUNCTION:
case RECYCLED:
*pstatus = CACHE_INODE_BAD_TYPE;
V_r(&pentry->lock);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_READLINK] += 1;
return *pstatus;
break;
case SYMBOLIC_LINK:
assert(pentry->object.symlink);
if( CACHE_INODE_KEEP_CONTENT( pentry->policy ) )
{
fsal_status = FSAL_pathcpy(plink_content, &(pentry->object.symlink->content)); /* need copy ctor? */
}
else
{
/* Content is not cached, call FSAL_readlink here */
fsal_status = FSAL_readlink( &pentry->handle, pcontext, plink_content, &attr ) ;
}
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
V_r(&pentry->lock);
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_readlink: Stale FSAL File Handle detected for pentry = %p, fsal_status=(%u,%u)",
pentry, 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_readlink: 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_READLINK] += 1;
return *pstatus;
}
break;
}
/* Release the entry */
*pstatus = cache_inode_valid(pentry, CACHE_INODE_OP_GET, pclient);
V_r(&pentry->lock);
/* stat */
if(*pstatus != CACHE_INODE_SUCCESS)
pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_READLINK] += 1;
else
pclient->stat.func_stats.nb_success[CACHE_INODE_READLINK] += 1;
return *pstatus;
} /* cache_inode_readlink */
/**
*
* cache_inode_close: closes the local fd in the FSAL.
*
* Closes the local fd in the FSAL.
*
* No lock management is done in this layer: the related pentry in the cache inode layer is
* locked and will prevent from concurent accesses.
*
* @param pentry [IN] entry in file content layer whose content is to be accessed.
* @param pclient [IN] ressource allocated by the client for the nfs management.
* @pstatus [OUT] returned status.
*
* @return CACHE_CONTENT_SUCCESS is successful .
*
*/
cache_inode_status_t cache_inode_close(cache_entry_t * pentry,
cache_inode_client_t * pclient,
cache_inode_status_t * pstatus)
{
fsal_status_t fsal_status;
if((pentry == NULL) || (pclient == NULL) || (pstatus == NULL))
return CACHE_CONTENT_INVALID_ARGUMENT;
if(pentry->internal_md.type != REGULAR_FILE)
{
*pstatus = CACHE_INODE_BAD_TYPE;
return *pstatus;
}
/* if nothing is opened, do nothing */
if(pentry->object.file.open_fd.fileno < 0)
{
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
}
/* if locks are held in the file, do not close */
if( cache_inode_file_holds_state( pentry ) )
{
*pstatus = CACHE_INODE_SUCCESS; /** @todo : PhD : May be CACHE_INODE_STATE_CONFLICTS would be better ? */
return *pstatus;
}
if((pclient->use_fd_cache == 0) ||
(time(NULL) - pentry->object.file.open_fd.last_op > pclient->retention) ||
(pentry->object.file.open_fd.fileno > (int)(pclient->max_fd)))
{
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_close: pentry %p, fileno = %d, lastop=%d ago",
pentry, pentry->object.file.open_fd.fileno,
(int)(time(NULL) - pentry->object.file.open_fd.last_op));
#ifdef _USE_MFSL
fsal_status = MFSL_close(&(pentry->object.file.open_fd.mfsl_fd), &pclient->mfsl_context, NULL);
#else
fsal_status = FSAL_close(&(pentry->object.file.open_fd.fd));
#endif
pentry->object.file.open_fd.fileno = 0;
pentry->object.file.open_fd.last_op = 0;
if(FSAL_IS_ERROR(fsal_status) && (fsal_status.major != ERR_FSAL_NOT_OPENED))
{
*pstatus = cache_inode_error_convert(fsal_status);
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_close: returning %d(%s) from FSAL_close",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
}
#ifdef _USE_PROXY
/* If proxy if used, free the name if needed */
if(pentry->object.file.pname != NULL)
{
Mem_Free((char *)(pentry->object.file.pname));
pentry->object.file.pname = NULL;
}
pentry->object.file.pentry_parent_open = NULL;
#endif
*pstatus = CACHE_CONTENT_SUCCESS;
return *pstatus;
} /* cache_content_close */
/**
* @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;
}
int nfs4_op_lookup(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
fsal_name_t name;
char strname[MAXNAMLEN];
#ifndef _NO_XATTRD
char objname[MAXNAMLEN];
#endif
unsigned int xattr_found = FALSE;
cache_entry_t *dir_pentry = NULL;
cache_entry_t *file_pentry = NULL;
fsal_attrib_list_t attrlookup;
cache_inode_status_t cache_status;
fsal_handle_t *pfsal_handle = NULL;
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_lookup";
resp->resop = NFS4_OP_LOOKUP;
res_LOOKUP4.status = NFS4_OK;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_LOOKUP4.status = NFS4ERR_NOFILEHANDLE;
return res_LOOKUP4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_LOOKUP4.status = NFS4ERR_BADHANDLE;
return res_LOOKUP4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_LOOKUP4.status = NFS4ERR_FHEXPIRED;
return res_LOOKUP4.status;
}
/* Check for empty name */
if(op->nfs_argop4_u.oplookup.objname.utf8string_len == 0 ||
op->nfs_argop4_u.oplookup.objname.utf8string_val == NULL)
{
res_LOOKUP4.status = NFS4ERR_INVAL;
return res_LOOKUP4.status;
}
/* Check for name to long */
if(op->nfs_argop4_u.oplookup.objname.utf8string_len > FSAL_MAX_NAME_LEN)
{
res_LOOKUP4.status = NFS4ERR_NAMETOOLONG;
return res_LOOKUP4.status;
}
/* If Filehandle points to a pseudo fs entry, manage it via pseudofs specific functions */
if(nfs4_Is_Fh_Pseudo(&(data->currentFH)))
return nfs4_op_lookup_pseudo(op, data, resp);
#ifndef _NO_XATTRD
/* If Filehandle points to a xattr object, manage it via the xattrs specific functions */
if(nfs4_Is_Fh_Xattr(&(data->currentFH)))
return nfs4_op_lookup_xattr(op, data, resp);
#endif
/* UTF8 strings may not end with \0, but they carry their length */
utf82str(strname, sizeof(strname), &arg_LOOKUP4.objname);
#ifndef _NO_XATTRD
/* Is this a .xattr.d.<object> name ? */
if(nfs_XattrD_Name(strname, objname))
{
strcpy(strname, objname);
xattr_found = TRUE;
}
#endif
if((cache_status = cache_inode_error_convert(FSAL_str2name(strname,
MAXNAMLEN,
&name))) !=
CACHE_INODE_SUCCESS)
{
res_LOOKUP4.status = nfs4_Errno(cache_status);
return res_LOOKUP4.status;
}
/* No 'cd .' is allowed return NFS4ERR_BADNAME in this case */
/* No 'cd .. is allowed, return EINVAL in this case. NFS4_OP_LOOKUPP should be use instead */
if(!FSAL_namecmp(&name, (fsal_name_t *) & FSAL_DOT)
|| !FSAL_namecmp(&name, (fsal_name_t *) & FSAL_DOT_DOT))
{
res_LOOKUP4.status = NFS4ERR_BADNAME;
return res_LOOKUP4.status;
}
/* Do the lookup in the HPSS Namespace */
file_pentry = NULL;
dir_pentry = data->current_entry;
/* Sanity check: dir_pentry should be ACTUALLY a directory */
if(dir_pentry->internal_md.type != DIR_BEGINNING
&& dir_pentry->internal_md.type != DIR_CONTINUE)
{
/* This is not a directory */
if(dir_pentry->internal_md.type == SYMBOLIC_LINK)
res_LOOKUP4.status = NFS4ERR_SYMLINK;
else
res_LOOKUP4.status = NFS4ERR_NOTDIR;
/* Return failed status */
return res_LOOKUP4.status;
}
/* BUGAZOMEU: Faire la gestion des cross junction traverse */
if((file_pentry = cache_inode_lookup(dir_pentry,
&name,
&attrlookup,
data->ht,
data->pclient,
data->pcontext, &cache_status)) != NULL)
{
/* Extract the fsal attributes from the cache inode pentry */
pfsal_handle = cache_inode_get_fsal_handle(file_pentry, &cache_status);
if(cache_status != CACHE_INODE_SUCCESS)
{
res_LOOKUP4.status = NFS4ERR_SERVERFAULT;
return res_LOOKUP4.status;
}
/* Convert it to a file handle */
if(!nfs4_FSALToFhandle(&data->currentFH, pfsal_handle, data))
{
res_LOOKUP4.status = NFS4ERR_SERVERFAULT;
return res_LOOKUP4.status;
}
/* Copy this to the mounted on FH (if no junction is traversed */
memcpy((char *)(data->mounted_on_FH.nfs_fh4_val),
(char *)(data->currentFH.nfs_fh4_val), data->currentFH.nfs_fh4_len);
data->mounted_on_FH.nfs_fh4_len = data->currentFH.nfs_fh4_len;
#if 0
print_buff((char *)cache_inode_get_fsal_handle(file_pentry, &cache_status),
sizeof(fsal_handle_t));
print_buff((char *)cache_inode_get_fsal_handle(dir_pentry, &cache_status),
sizeof(fsal_handle_t));
#endif
if(isFullDebug(COMPONENT_NFS_V4))
{
LogFullDebug(COMPONENT_NFS_V4,
"----> nfs4_op_lookup: name=%s dir_pentry=%p looked up pentry=%p",
strname, dir_pentry, file_pentry);
LogFullDebug(COMPONENT_NFS_V4,
"----> FSAL handle parent puis fils dans nfs4_op_lookup");
print_buff(COMPONENT_NFS_V4,
(char *)cache_inode_get_fsal_handle(file_pentry, &cache_status),
sizeof(fsal_handle_t));
print_buff(COMPONENT_NFS_V4,
(char *)cache_inode_get_fsal_handle(dir_pentry, &cache_status),
sizeof(fsal_handle_t));
}
LogHandleNFS4("NFS4 LOOKUP CURRENT FH: ", &data->currentFH);
/* Keep the pointer within the compound data */
data->current_entry = file_pentry;
data->current_filetype = file_pentry->internal_md.type;
/* Return successfully */
res_LOOKUP4.status = NFS4_OK;
#ifndef _NO_XATTRD
/* If this is a xattr ghost directory name, update the FH */
if(xattr_found == TRUE)
res_LOOKUP4.status = nfs4_fh_to_xattrfh(&(data->currentFH), &(data->currentFH));
#endif
if((data->current_entry->internal_md.type == DIR_BEGINNING) &&
(data->current_entry->object.dir_begin.referral != NULL))
{
if(!nfs4_Set_Fh_Referral(&(data->currentFH)))
{
res_LOOKUP4.status = NFS4ERR_SERVERFAULT;
return res_LOOKUP4.status;
}
}
return NFS4_OK;
}
/* If the part of the code is reached, then something wrong occured in the lookup process, status is not HPSS_E_NOERROR
* and contains the code for the error */
res_LOOKUP4.status = nfs4_Errno(cache_status);
return res_LOOKUP4.status;
} /* nfs4_op_lookup */
int nfs4_op_remove(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
cache_entry_t *parent_entry = NULL;
fsal_attrib_list_t attr_parent;
fsal_name_t name;
cache_inode_status_t cache_status;
#ifdef _USE_PNFS
pnfs_file_t pnfs_file;
#endif
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_remove";
resp->resop = NFS4_OP_REMOVE;
res_REMOVE4.status = NFS4_OK;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_REMOVE4.status = NFS4ERR_NOFILEHANDLE;
return res_REMOVE4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_REMOVE4.status = NFS4ERR_BADHANDLE;
return res_REMOVE4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_REMOVE4.status = NFS4ERR_FHEXPIRED;
return res_REMOVE4.status;
}
/* Pseudo Fs is explictely a Read-Only File system */
if(nfs4_Is_Fh_Pseudo(&(data->currentFH)))
{
res_REMOVE4.status = NFS4ERR_ROFS;
return res_REMOVE4.status;
}
/* If Filehandle points to a xattr object, manage it via the xattrs specific functions */
if(nfs4_Is_Fh_Xattr(&(data->currentFH)))
return nfs4_op_remove_xattr(op, data, resp);
/* Get the parent entry (aka the current one in the compound data) */
parent_entry = data->current_entry;
/* We have to keep track of the 'change' file attribute for reply structure */
memset(&(res_REMOVE4.REMOVE4res_u.resok4.cinfo.before), 0, sizeof(changeid4));
res_REMOVE4.REMOVE4res_u.resok4.cinfo.before =
(changeid4) parent_entry->internal_md.mod_time;
/* The operation delete object named arg_REMOVE4.target in directory pointed bt cuurentFH */
/* Make sur the currentFH is pointed a directory */
if(data->current_filetype != DIR_BEGINNING && data->current_filetype != DIR_CONTINUE)
{
res_REMOVE4.status = NFS4ERR_NOTDIR;
return res_REMOVE4.status;
}
/* Check for name length */
if(arg_REMOVE4.target.utf8string_len > FSAL_MAX_NAME_LEN)
{
res_REMOVE4.status = NFS4ERR_NAMETOOLONG;
return res_REMOVE4.status;
}
/* get the filename from the argument, it should not be empty */
if(arg_REMOVE4.target.utf8string_len == 0)
{
res_REMOVE4.status = NFS4ERR_INVAL;
return res_REMOVE4.status;
}
/* NFS4_OP_REMOVE can delete files as well as directory, it replaces NFS3_RMDIR and NFS3_REMOVE
* because of this, we have to know if object is a directory or not */
if((cache_status =
cache_inode_error_convert(FSAL_buffdesc2name
((fsal_buffdesc_t *) & arg_REMOVE4.target,
&name))) != CACHE_INODE_SUCCESS)
{
res_REMOVE4.status = nfs4_Errno(cache_status);
return res_REMOVE4.status;
}
/* Test RM7: remiving '.' should return NFS4ERR_BADNAME */
if(!FSAL_namecmp(&name, (fsal_name_t *) & FSAL_DOT)
|| !FSAL_namecmp(&name, (fsal_name_t *) & FSAL_DOT_DOT))
{
res_REMOVE4.status = NFS4ERR_BADNAME;
return res_REMOVE4.status;
}
if((cache_status = cache_inode_remove(parent_entry,
&name,
&attr_parent,
data->ht,
data->pclient,
data->pcontext,
&cache_status)) != CACHE_INODE_SUCCESS)
{
res_REMOVE4.status = nfs4_Errno(cache_status);
return res_REMOVE4.status;
}
/* We have to keep track of the 'change' file attribute for reply structure */
memset(&(res_REMOVE4.REMOVE4res_u.resok4.cinfo.before), 0, sizeof(changeid4));
res_REMOVE4.REMOVE4res_u.resok4.cinfo.after =
(changeid4) parent_entry->internal_md.mod_time;
/* Operation was not atomic .... */
res_REMOVE4.REMOVE4res_u.resok4.cinfo.atomic = TRUE;
/* If you reach this point, everything was ok */
res_REMOVE4.status = NFS4_OK;
return NFS4_OK;
} /* nfs4_op_remove */
cache_entry_t *
cache_inode_create(cache_entry_t *parent,
fsal_name_t *name,
cache_inode_file_type_t type,
fsal_accessmode_t mode,
cache_inode_create_arg_t *create_arg,
fsal_attrib_list_t *attr,
fsal_op_context_t *context,
cache_inode_status_t *status)
{
cache_entry_t *entry = NULL;
fsal_status_t fsal_status = {0, 0};
fsal_handle_t object_handle;
fsal_attrib_list_t object_attributes;
cache_inode_fsal_data_t fsal_data;
cache_inode_create_arg_t zero_create_arg;
memset(&zero_create_arg, 0, sizeof(zero_create_arg));
memset(&fsal_data, 0, sizeof(fsal_data));
memset(&object_handle, 0, sizeof(object_handle));
if (create_arg == NULL) {
create_arg = &zero_create_arg;
}
/* Set the return default to CACHE_INODE_SUCCESS */
*status = CACHE_INODE_SUCCESS;
if ((type != REGULAR_FILE) && (type != DIRECTORY) &&
(type != SYMBOLIC_LINK) && (type != SOCKET_FILE) &&
(type != FIFO_FILE) && (type != CHARACTER_FILE) &&
(type != BLOCK_FILE)) {
*status = CACHE_INODE_BAD_TYPE;
entry = NULL;
goto out;
}
/* Check if an entry of the same name exists */
entry = cache_inode_lookup(parent,
name,
attr,
context,
status);
if (entry != NULL) {
*status = CACHE_INODE_ENTRY_EXISTS;
if (entry->type != type) {
/* Incompatible types, returns NULL */
cache_inode_lru_unref(entry, LRU_FLAG_NONE);
entry = NULL;
goto out;
} else {
goto out;
}
}
/* The entry doesn't exist, so we can create it. */
object_attributes.asked_attributes = cache_inode_params.attrmask;
switch (type) {
case REGULAR_FILE:
fsal_status = FSAL_create(&parent->handle,
name, context, mode,
&object_handle, &object_attributes);
break;
case DIRECTORY:
fsal_status = FSAL_mkdir(&parent->handle,
name, context, mode,
&object_handle, &object_attributes);
break;
case SYMBOLIC_LINK:
fsal_status = FSAL_symlink(&parent->handle,
name, &create_arg->link_content,
context, mode, &object_handle,
&object_attributes);
break;
case SOCKET_FILE:
fsal_status = FSAL_mknode(&parent->handle, name, context,
mode, FSAL_TYPE_SOCK, NULL,
&object_handle, &object_attributes);
break;
case FIFO_FILE:
fsal_status = FSAL_mknode(&parent->handle, name, context,
mode, FSAL_TYPE_FIFO, NULL,
&object_handle, &object_attributes);
break;
case BLOCK_FILE:
fsal_status = FSAL_mknode(&parent->handle,
name, context,
mode, FSAL_TYPE_BLK,
&create_arg->dev_spec,
&object_handle, &object_attributes);
break;
case CHARACTER_FILE:
fsal_status = FSAL_mknode(&parent->handle,
name, context,
mode, FSAL_TYPE_CHR,
&create_arg->dev_spec,
&object_handle,
&object_attributes);
break;
default:
/* we should never go there */
*status = CACHE_INODE_INCONSISTENT_ENTRY;
entry = NULL;
goto out;
break;
}
/* Check for the result */
if (FSAL_IS_ERROR(fsal_status)) {
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_CACHE_INODE,
"FSAL returned STALE on create type %d",
type);
cache_inode_kill_entry(parent);
}
*status = cache_inode_error_convert(fsal_status);
entry = NULL;
goto out;
}
fsal_data.fh_desc.start = (caddr_t) &object_handle;
fsal_data.fh_desc.len = 0;
FSAL_ExpandHandle(context->export_context,
FSAL_DIGEST_SIZEOF,
&fsal_data.fh_desc);
entry = cache_inode_new_entry(&fsal_data,
&object_attributes,
type,
create_arg,
status);
if (entry == NULL) {
*status = CACHE_INODE_INSERT_ERROR;
return NULL;
}
PTHREAD_RWLOCK_WRLOCK(&parent->content_lock);
/* Add this entry to the directory (also takes an internal ref) */
cache_inode_add_cached_dirent(parent,
name, entry,
NULL,
status);
PTHREAD_RWLOCK_UNLOCK(&parent->content_lock);
if (*status != CACHE_INODE_SUCCESS) {
cache_inode_lru_unref(entry, LRU_FLAG_NONE);
entry = NULL;
goto out;
}
PTHREAD_RWLOCK_WRLOCK(&parent->attr_lock);
/* Update the parent cached attributes */
cache_inode_set_time_current(&parent->attributes.mtime);
parent->attributes.ctime = parent->attributes.mtime;
/* if the created object is a directory, it contains a link
to its parent : '..'. Thus the numlink attr must be increased. */
if (type == DIRECTORY) {
++(parent->attributes.numlinks);
}
PTHREAD_RWLOCK_UNLOCK(&parent->attr_lock);
/* Copy up the child attributes */
*attr = object_attributes;
*status = CACHE_INODE_SUCCESS;
out:
return entry;
}
