/**
*
* 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_kill_entry( cache_entry_t * pentry,
cache_inode_lock_how_t lock_how,
hash_table_t * ht,
cache_inode_client_t * pclient,
cache_inode_status_t * pstatus )
{
fsal_handle_t *pfsal_handle = NULL;
cache_inode_fsal_data_t fsaldata;
cache_inode_parent_entry_t *parent_iter = NULL;
cache_inode_parent_entry_t *parent_iter_next = NULL;
hash_buffer_t key, old_key;
hash_buffer_t old_value;
int rc;
fsal_status_t fsal_status;
memset( (char *)&fsaldata, 0, sizeof( fsaldata ) ) ;
LogInfo(COMPONENT_CACHE_INODE,
"Using cache_inode_kill_entry for entry %p", pentry);
/* Invalidation is not for junctions or special files */
if( ( pentry->internal_md.type == FS_JUNCTION ) ||
( pentry->internal_md.type == SOCKET_FILE ) ||
( pentry->internal_md.type == FIFO_FILE ) ||
( pentry->internal_md.type == CHARACTER_FILE ) ||
( pentry->internal_md.type == BLOCK_FILE ) )
{
free_lock( pentry, lock_how ) ;
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
}
#if 0
/** @todo: BUGAZOMEU : directory invalidation seems quite tricky, temporarily avoid it */
if( pentry->internal_md.type == DIRECTORY )
{
free_lock( pentry, lock_how ) ;
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
}
/** @todo: BUGAZOMEU : file invalidation seems quite tricky, temporarily avoid it */
/* We need to know how to manage how to deal with "files with states" */
if( pentry->internal_md.type == REGULAR_FILE )
{
free_lock( pentry, lock_how ) ;
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
}
#endif
if(pstatus == NULL)
return CACHE_INODE_INVALID_ARGUMENT;
if(pentry == NULL || pclient == NULL || ht == NULL)
{
free_lock( pentry, lock_how ) ;
*pstatus = CACHE_INODE_INVALID_ARGUMENT;
return *pstatus;
}
/* Get the FSAL handle */
if((pfsal_handle = cache_inode_get_fsal_handle(pentry, pstatus)) == NULL)
{
free_lock( pentry, lock_how ) ;
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_kill_entry: unable to retrieve pentry's specific filesystem info");
return *pstatus;
}
/* Invalidate the related LRU gc entry (no more required) */
if(pentry->gc_lru_entry != NULL)
{
if(LRU_invalidate(pentry->gc_lru, pentry->gc_lru_entry) != LRU_LIST_SUCCESS)
{
free_lock( pentry, lock_how ) ;
*pstatus = CACHE_INODE_LRU_ERROR;
return *pstatus;
}
}
fsaldata.handle = *pfsal_handle;
fsaldata.cookie = DIR_START;
/* Use the handle to build the key */
if(cache_inode_fsaldata_2_key(&key, &fsaldata, pclient))
{
free_lock( pentry, lock_how ) ;
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_kill_entry: could not build hashtable key");
cache_inode_release_fsaldata_key(&key, pclient);
*pstatus = CACHE_INODE_NOT_FOUND;
return *pstatus;
}
/* use the key to delete the entry */
if((rc = HashTable_Del(ht, &key, &old_key, &old_value)) != HASHTABLE_SUCCESS)
{
if( rc != HASHTABLE_ERROR_NO_SUCH_KEY) /* rc=3 => Entry was previously removed */
LogCrit( COMPONENT_CACHE_INODE,
"cache_inode_kill_entry: entry could not be deleted, status = %d",
rc);
cache_inode_release_fsaldata_key(&key, pclient);
*pstatus = CACHE_INODE_NOT_FOUND;
return *pstatus;
}
/* Release the hash key data */
cache_inode_release_fsaldata_key(&old_key, pclient);
/* Clean up the associated ressources in the FSAL */
if(FSAL_IS_ERROR(fsal_status = FSAL_CleanObjectResources(pfsal_handle)))
{
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_kill_entry: Couldn't free FSAL ressources fsal_status.major=%u",
fsal_status.major);
}
/* Sanity check: old_value.pdata is expected to be equal to pentry,
* and is released later in this function */
if((cache_entry_t *) old_value.pdata != pentry)
{
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_kill_entry: unexpected pdata %p from hash table (pentry=%p)",
old_value.pdata, pentry);
}
/* Release the current key */
cache_inode_release_fsaldata_key(&key, pclient);
/* Recover the parent list entries */
parent_iter = pentry->parent_list;
while(parent_iter != NULL)
{
parent_iter_next = parent_iter->next_parent;
ReleaseToPool(parent_iter, &pclient->pool_parent);
parent_iter = parent_iter_next;
}
/* If entry is datacached, remove it from the cache */
if(pentry->internal_md.type == REGULAR_FILE)
{
cache_content_status_t cache_content_status;
if(pentry->object.file.pentry_content != NULL)
if(cache_content_release_entry
((cache_content_entry_t *) pentry->object.file.pentry_content,
(cache_content_client_t *) pclient->pcontent_client,
&cache_content_status) != CACHE_CONTENT_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"Could not removed datacached entry for pentry %p", pentry);
}
/* If entry is a DIRECTORY, invalidate dirents */
if(pentry->internal_md.type == DIRECTORY)
{
cache_inode_invalidate_related_dirents(pentry, pclient);
}
// free_lock( pentry, lock_how ) ; /* Really needed ? The pentry is unaccessible now and will be destroyed */
/* Destroy the mutex associated with the pentry */
cache_inode_mutex_destroy(pentry);
/* Put the pentry back to the pool */
ReleaseToPool(pentry, &pclient->pool_entry);
*pstatus = CACHE_INODE_SUCCESS;
return *pstatus;
} /* cache_inode_kill_entry */
/**
* nfs4_op_readdir: The NFS4_OP_READDIR.
*
* Implements the NFS4_OP_READDIR. If fh is a pseudo FH, then call is routed to routine nfs4_op_readdir_pseudo
*
* @param op [IN] pointer to nfs4_op arguments
* @param data [INOUT] Pointer to the compound request's data
* @param resp [IN] Pointer to nfs4_op results
*
* @return NFS4_OK if ok, any other value show an error.
*
*/
int nfs4_op_readdir(struct nfs_argop4 *op,
compound_data_t * data, struct nfs_resop4 *resp)
{
cache_entry_t *dir_pentry = NULL;
cache_entry_t *pentry = NULL;
cache_inode_endofdir_t eod_met;
fsal_attrib_list_t attrlookup;
cache_inode_status_t cache_status;
cache_inode_status_t cache_status_attr;
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_readdir";
unsigned long dircount;
unsigned long maxcount;
entry4 *entry_nfs_array;
cache_inode_dir_entry_t **dirent_array = NULL;
verifier4 cookie_verifier;
uint64_t cookie = 0;
uint64_t end_cookie = 0;
fsal_handle_t *entry_FSALhandle;
nfs_fh4 entryFH;
char val_fh[NFS4_FHSIZE];
entry_name_array_item_t *entry_name_array = NULL;
unsigned int estimated_num_entries;
unsigned int num_entries;
int dir_pentry_unlock = FALSE;
unsigned int i = 0;
unsigned int outbuffsize = 0 ;
unsigned int entrysize = 0 ;
bitmap4 RdAttrErrorBitmap = { 1, (uint32_t *) "\0\0\0\b" }; /* 0xB = 11 = FATTR4_RDATTR_ERROR */
attrlist4 RdAttrErrorVals = { 0, NULL }; /* Nothing to be seen here */
resp->resop = NFS4_OP_READDIR;
res_READDIR4.status = NFS4_OK;
entryFH.nfs_fh4_len = 0;
entryFH.nfs_fh4_val = val_fh;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_READDIR4.status = NFS4ERR_NOFILEHANDLE;
return res_READDIR4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_READDIR4.status = NFS4ERR_BADHANDLE;
return res_READDIR4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_READDIR4.status = NFS4ERR_FHEXPIRED;
return res_READDIR4.status;
}
/* Pseudo Fs management */
if(nfs4_Is_Fh_Pseudo(&(data->currentFH)))
return nfs4_op_readdir_pseudo(op, data, resp);
/* Xattrs management */
if(nfs4_Is_Fh_Xattr(&(data->currentFH)))
return nfs4_op_readdir_xattr(op, data, resp);
/* You can readdir only within a directory */
dir_pentry = data->current_entry;
if(data->current_filetype != DIRECTORY)
{
res_READDIR4.status = NFS4ERR_NOTDIR;
return res_READDIR4.status;
}
/* get the characteristic value for readdir operation */
dircount = arg_READDIR4.dircount;
maxcount = arg_READDIR4.maxcount*0.9;
cookie = (unsigned int)arg_READDIR4.cookie;
/* dircount is considered meaningless by many nfsv4 client (like the CITI
* one). we use maxcount instead. */
/* the Linux 3.0, 3.1.0 clients vs. TCP Ganesha comes out 10x slower
* with 500 max entries */
#if 0
/* takes 2s to return 2999 entries */
estimated_num_entries = maxcount / sizeof(entry4);
#else
/* takes 20s to return 2999 entries */
estimated_num_entries = 50;
#endif
LogFullDebug(COMPONENT_NFS_V4,
"--- nfs4_op_readdir ---> dircount=%lu maxcount=%lu arg_cookie=%"
PRIu64" cookie=%"PRIu64" estimated_num_entries=%u",
dircount, maxcount, arg_READDIR4.cookie, cookie,
estimated_num_entries);
/* Do not use a cookie of 1 or 2 (reserved values) */
if(cookie == 1 || cookie == 2)
{
res_READDIR4.status = NFS4ERR_BAD_COOKIE;
return res_READDIR4.status;
}
/* Get only attributes that are allowed to be read */
if(!nfs4_Fattr_Check_Access_Bitmap(&arg_READDIR4.attr_request,
FATTR4_ATTR_READ))
{
res_READDIR4.status = NFS4ERR_INVAL;
return res_READDIR4.status;
}
/* If maxcount is too short, return NFS4ERR_TOOSMALL */
if(maxcount < sizeof(entry4) || estimated_num_entries == 0)
{
res_READDIR4.status = NFS4ERR_TOOSMALL;
return res_READDIR4.status;
}
/*
* If cookie verifier is used, then an non-trivial value is
* returned to the client This value is the mtime of
* the pentry. If verifier is unused (as in many NFS
* Servers) then only a set of zeros is returned (trivial
* value)
*/
memset(cookie_verifier, 0, NFS4_VERIFIER_SIZE);
if(data->pexport->UseCookieVerifier == 1)
memcpy(cookie_verifier, &dir_pentry->internal_md.mod_time, sizeof(time_t));
/* Cookie delivered by the server and used by the client SHOULD not ne 0, 1 or 2 (cf RFC3530, page192)
* because theses value are reserved for special use.
* 0 - cookie for first READDIR
* 1 - reserved for . on client handside
* 2 - reserved for .. on client handside
* Entries '.' and '..' are not returned also
* For these reason, there will be an offset of 3 between NFS4 cookie and
* HPSS cookie */
if((cookie != 0) && (data->pexport->UseCookieVerifier == 1))
{
if(memcmp(cookie_verifier, arg_READDIR4.cookieverf, NFS4_VERIFIER_SIZE) != 0)
{
res_READDIR4.status = NFS4ERR_BAD_COOKIE;
return res_READDIR4.status;
}
}
/* The default behaviour is to consider that eof is not reached, the
* returned values by cache_inode_readdir will let us know if eod was
* reached or not */
res_READDIR4.READDIR4res_u.resok4.reply.eof = FALSE;
/* Get prepared for readdir */
if((dirent_array =
(cache_inode_dir_entry_t **) Mem_Alloc(
estimated_num_entries * sizeof(cache_inode_dir_entry_t*))) == NULL)
{
res_READDIR4.status = NFS4ERR_SERVERFAULT;
goto out;
}
/* Perform the readdir operation */
if(cache_inode_readdir(dir_pentry,
data->pexport->cache_inode_policy,
cookie,
estimated_num_entries,
&num_entries,
&end_cookie,
&eod_met,
dirent_array,
data->ht,
&dir_pentry_unlock,
data->pclient,
data->pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
res_READDIR4.status = nfs4_Errno(cache_status);
goto out;
}
/* For an empty directory, we will find only . and .., so reply as if the
* end is reached */
if(num_entries == 0)
{
/* only . and .. */
res_READDIR4.READDIR4res_u.resok4.reply.entries = NULL;
res_READDIR4.READDIR4res_u.resok4.reply.eof = TRUE;
memcpy(res_READDIR4.READDIR4res_u.resok4.cookieverf, cookie_verifier,
NFS4_VERIFIER_SIZE);
}
else
{
/* Start computing the outbuffsize */
outbuffsize = sizeof( bool_t) /* eof */
+ sizeof( nfsstat4 ) /* READDIR4res::status */
+ NFS4_VERIFIER_SIZE /* cookie verifier */ ;
/* Allocation of reply structures */
if((entry_name_array =
(entry_name_array_item_t *) Mem_Alloc(num_entries *
(FSAL_MAX_NAME_LEN + 1)))
== NULL)
{
LogError(COMPONENT_NFS_V4, ERR_SYS, ERR_MALLOC, errno);
res_READDIR4.status = NFS4ERR_SERVERFAULT;
return res_READDIR4.status;
}
memset((char *)entry_name_array, 0,
num_entries * (FSAL_MAX_NAME_LEN + 1));
if((entry_nfs_array = (entry4 *) Mem_Alloc(num_entries * sizeof(entry4)))
== NULL)
{
LogError(COMPONENT_NFS_V4, ERR_SYS, ERR_MALLOC, errno);
res_READDIR4.status = NFS4ERR_SERVERFAULT;
return res_READDIR4.status;
}
memset((char *)entry_nfs_array, 0, num_entries * sizeof(entry4));
for(i = 0; i < num_entries; i++)
{
entry_nfs_array[i].name.utf8string_val = entry_name_array[i];
if(str2utf8(dirent_array[i]->name.name,
&entry_nfs_array[i].name) == -1)
{
res_READDIR4.status = NFS4ERR_SERVERFAULT;
goto out;
}
/* Set the cookie value */
entry_nfs_array[i].cookie = dirent_array[i]->cookie;
/* Get the pentry for the object's attributes and filehandle */
if( ( pentry = cache_inode_lookup_no_mutex( dir_pentry,
&dirent_array[i]->name,
data->pexport->cache_inode_policy,
&attrlookup,
data->ht,
data->pclient,
data->pcontext,
&cache_status ) ) == NULL )
{
Mem_Free((char *)entry_nfs_array);
/* Return the fattr4_rdattr_error , cf RFC3530, page 192 */
entry_nfs_array[i].attrs.attrmask = RdAttrErrorBitmap;
entry_nfs_array[i].attrs.attr_vals = RdAttrErrorVals;
res_READDIR4.status = NFS4ERR_SERVERFAULT;
goto out;
}
/* If file handle is asked in the attributes, provide it */
if(arg_READDIR4.attr_request.bitmap4_val != NULL
&& (arg_READDIR4.attr_request.bitmap4_val[0] & FATTR4_FILEHANDLE))
{
if((entry_FSALhandle =
cache_inode_get_fsal_handle(pentry,
&cache_status_attr)) == NULL)
{
/* Faulty Handle or pentry */
Mem_Free((char *)entry_nfs_array);
res_READDIR4.status = NFS4ERR_SERVERFAULT;
goto out;
}
if(!nfs4_FSALToFhandle(&entryFH, entry_FSALhandle, data))
{
/* Faulty type */
Mem_Free((char *)entry_nfs_array);
res_READDIR4.status = NFS4ERR_SERVERFAULT;
goto out;
}
}
if(nfs4_FSALattr_To_Fattr(data->pexport,
&attrlookup,
&(entry_nfs_array[i].attrs),
data, &entryFH, &(arg_READDIR4.attr_request)) != 0)
{
/* Return the fattr4_rdattr_error , cf RFC3530, page 192 */
entry_nfs_array[i].attrs.attrmask = RdAttrErrorBitmap;
entry_nfs_array[i].attrs.attr_vals = RdAttrErrorVals;
}
/* Update the size of the output buffer */
entrysize = sizeof( nfs_cookie4 ) ; /* nfs_cookie4 */
entrysize += sizeof( u_int ) ; /* pathname4::utf8strings_len */
entrysize += entry_nfs_array[i].name.utf8string_len ;
entrysize += sizeof( u_int ) ; /* bitmap4_len */
entrysize += entry_nfs_array[i].attrs.attrmask.bitmap4_len ;
entrysize += sizeof( u_int ) ; /* attrlist4_len */
entrysize += entry_nfs_array[i].attrs.attr_vals.attrlist4_len ;
entrysize += sizeof( caddr_t ) ;
outbuffsize += entrysize;
LogFullDebug(COMPONENT_NFS_V4,
" === nfs4_op_readdir ===> i=%u name=%s cookie=%"PRIu64" "
"entrysize=%u buffsize=%u",
i, dirent_array[i]->name.name,
entry_nfs_array[i].cookie,
entrysize,
outbuffsize);
/* Chain the entries together */
entry_nfs_array[i].nextentry = NULL;
if(i != 0)
{
if( outbuffsize < maxcount )
entry_nfs_array[i - 1].nextentry = &(entry_nfs_array[i]);
else
{
LogFullDebug(COMPONENT_NFS_V4,
"=== nfs4_op_readdir ===> "
"maxcount reached at %u entries name=%s "
"cookie=%llu "
"buffsize=%u (return early)",
i+1,
dirent_array[i]->name.name,
(unsigned long long)entry_nfs_array[i].cookie,
outbuffsize);
entry_nfs_array[i - 1].nextentry = NULL ;
break ;
}
}
} /* for i */
if((i == num_entries) && (eod_met == END_OF_DIR))
{
LogFullDebug(COMPONENT_NFS_V4,
"End of directory reached: num_entries=%d i=%d",
num_entries,
i);
/* This is the end of the directory */
res_READDIR4.READDIR4res_u.resok4.reply.eof = TRUE;
memcpy(res_READDIR4.READDIR4res_u.resok4.cookieverf,
cookie_verifier, NFS4_VERIFIER_SIZE);
}
/* Put the entry's list in the READDIR reply */
res_READDIR4.READDIR4res_u.resok4.reply.entries = entry_nfs_array;
}
/* Do not forget to set the verifier */
memcpy((char *)res_READDIR4.READDIR4res_u.resok4.cookieverf, cookie_verifier,
NFS4_VERIFIER_SIZE);
res_READDIR4.status = NFS4_OK;
out:
/* release read lock on dir_pentry, if requested */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
if (dirent_array)
{
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, data->pclient ) ;
Mem_Free((char *)dirent_array);
}
return res_READDIR4.status;
} /* nfs4_op_readdir */
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 nfs3_Readdirplus(nfs_arg_t * parg,
exportlist_t * pexport,
fsal_op_context_t * pcontext,
cache_inode_client_t * pclient,
hash_table_t * ht, struct svc_req *preq, nfs_res_t * pres)
{
static char __attribute__ ((__unused__)) funcName[] = "nfs3_Readdirplus";
typedef char entry_name_array_item_t[FSAL_MAX_NAME_LEN];
typedef char fh3_buffer_item_t[NFS3_FHSIZE];
unsigned int delta = 0;
cache_entry_t *dir_pentry = NULL;
cache_entry_t *pentry_dot_dot = NULL;
unsigned long dircount;
unsigned long maxcount;
fsal_attrib_list_t dir_attr;
fsal_attrib_list_t entry_attr;
uint64_t begin_cookie;
uint64_t end_cookie;
uint64_t cache_inode_cookie;
cache_inode_dir_entry_t **dirent_array = NULL;
cookieverf3 cookie_verifier;
int rc;
unsigned int i = 0;
unsigned int num_entries;
unsigned long space_used;
unsigned long estimated_num_entries;
unsigned long asked_num_entries;
cache_inode_file_type_t dir_filetype;
cache_inode_endofdir_t eod_met = UNASSIGNED_EOD;
cache_inode_status_t cache_status;
cache_inode_status_t cache_status_gethandle;
fsal_handle_t *pfsal_handle = NULL;
entry_name_array_item_t *entry_name_array = NULL;
fh3_buffer_item_t *fh3_array = NULL;
entryplus3 reference_entry;
READDIRPLUS3resok reference_reply;
int dir_pentry_unlock = FALSE;
if(isDebug(COMPONENT_NFSPROTO) || isDebug(COMPONENT_NFS_READDIR))
{
char str[LEN_FH_STR];
log_components_t component;
sprint_fhandle3(str, &(parg->arg_readdirplus3.dir));
if(isDebug(COMPONENT_NFSPROTO))
component = COMPONENT_NFSPROTO;
else
component = COMPONENT_NFS_READDIR;
LogDebug(component,
"REQUEST PROCESSING: Calling nfs3_Readdirplus handle: %s", str);
}
/* to avoid setting it on each error case */
pres->res_readdir3.READDIR3res_u.resfail.dir_attributes.attributes_follow = FALSE;
dircount = parg->arg_readdirplus3.dircount;
maxcount = parg->arg_readdirplus3.maxcount;
begin_cookie = (unsigned int)parg->arg_readdirplus3.cookie;
/* FIXME: This calculation over estimates the number of bytes that
* READDIRPLUS3resok will use on the wire by 4 bytes on x86_64. */
space_used = sizeof(reference_reply.dir_attributes.attributes_follow) +
sizeof(reference_reply.dir_attributes.post_op_attr_u.attributes) +
sizeof(reference_reply.cookieverf) +
sizeof(reference_reply.reply.eof);
estimated_num_entries =
(dircount - space_used + sizeof(entry3 *))
/ (sizeof(entry3) - sizeof(char *)*2);
// estimated_num_entries *= 4;
LogFullDebug(COMPONENT_NFS_READDIR,
"nfs3_Readdirplus: dircount=%lu maxcount=%lu begin_cookie=%"
PRIu64" space_used=%lu estimated_num_entries=%lu",
dircount, maxcount, begin_cookie,
space_used, estimated_num_entries);
/* Is this a xattr FH ? */
if(nfs3_Is_Fh_Xattr(&(parg->arg_readdirplus3.dir)))
return nfs3_Readdirplus_Xattr(parg, pexport, pcontext, pclient, ht, preq, pres);
/* Convert file handle into a vnode */
if((dir_pentry = nfs_FhandleToCache(preq->rq_vers,
NULL,
&(parg->arg_readdirplus3.dir),
NULL,
NULL,
&(pres->res_readdirplus3.status),
NULL,
&dir_attr, pcontext, pclient, ht, &rc)) == NULL)
{
/* return NFS_REQ_DROP ; */
return rc;
}
/* Extract the filetype */
dir_filetype = cache_inode_fsal_type_convert(dir_attr.type);
/* Sanity checks -- must be a directory */
if(dir_filetype != DIRECTORY)
{
pres->res_readdirplus3.status = NFS3ERR_NOTDIR;
return NFS_REQ_OK;
}
/* switch */
memset(cookie_verifier, 0, sizeof(cookieverf3));
/*
* If cookie verifier is used, then an non-trivial value is
* returned to the client This value is the mtime of
* the directory. If verifier is unused (as in many NFS
* Servers) then only a set of zeros is returned (trivial
* value)
*/
if(pexport->UseCookieVerifier)
memcpy(cookie_verifier, &(dir_attr.mtime), sizeof(dir_attr.mtime));
/*
* nothing to do if != 0 because the area is already full of
* zero
*/
if(pexport->UseCookieVerifier && (begin_cookie != 0))
{
/*
* Not the first call, so we have to check the cookie
* verifier
*/
if(memcmp(cookie_verifier, parg->arg_readdirplus3.cookieverf,
NFS3_COOKIEVERFSIZE)
!= 0)
{
pres->res_readdirplus3.status = NFS3ERR_BAD_COOKIE;
return NFS_REQ_OK;
}
}
if((dirent_array =
(cache_inode_dir_entry_t **) Mem_Alloc_Label(
estimated_num_entries * sizeof(cache_inode_dir_entry_t*),
"cache_inode_dir_entry_t in nfs3_Readdirplus")) == NULL)
{
pres->res_readdirplus3.status = NFS3ERR_IO;
return NFS_REQ_DROP;
}
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries = NULL;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.eof = FALSE;
/** @todo XXXX fix this--compare nfs4_op_readdir */
/* How many entries will we retry from cache_inode ? */
if(begin_cookie > 1)
{
asked_num_entries = estimated_num_entries;
cache_inode_cookie = begin_cookie;
}
else
{
asked_num_entries = ((estimated_num_entries > 2) ? estimated_num_entries - 2 : 0); /* Keep space for '.' and '..' */
cache_inode_cookie = 0;
}
/* A definition that will be very useful to avoid very long names for variables */
#define RES_READDIRPLUS_REPLY pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply
/* Call readdir */
if(cache_inode_readdir(dir_pentry,
pexport->cache_inode_policy,
cache_inode_cookie,
asked_num_entries,
&num_entries,
&end_cookie,
&eod_met,
dirent_array,
ht,
&dir_pentry_unlock,
pclient,
pcontext,
&cache_status) == CACHE_INODE_SUCCESS)
{
LogFullDebug(COMPONENT_NFS_READDIR,
"Readdirplus3 -> Call to cache_inode_readdir( cookie=%"
PRIu64", asked=%lu ) -> num_entries = %u",
cache_inode_cookie, asked_num_entries, num_entries);
if(eod_met == END_OF_DIR)
{
LogFullDebug(COMPONENT_NFS_READDIR,
"+++++++++++++++++++++++++++++++++++++++++> EOD MET ");
}
/* If nothing was found, return nothing, but if cookie=0, we should return . and .. */
if((num_entries == 0) && (asked_num_entries != 0) && (begin_cookie > 1))
{
pres->res_readdirplus3.status = NFS3_OK;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries = NULL;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.eof = TRUE;
nfs_SetPostOpAttr(pcontext, pexport,
dir_pentry,
NULL,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resok.
dir_attributes));
memcpy(pres->res_readdirplus3.READDIRPLUS3res_u.resok.cookieverf,
cookie_verifier, sizeof(cookieverf3));
}
else
{
/* Allocation of the structure for reply */
entry_name_array =
(entry_name_array_item_t *) Mem_Alloc_Label(estimated_num_entries *
(FSAL_MAX_NAME_LEN + 1),
"entry_name_array in nfs3_Readdirplus");
if(entry_name_array == NULL)
{
/* after successful cache_inode_readdir, dir_pentry may be
* read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
return NFS_REQ_DROP;
}
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries =
(entryplus3 *) Mem_Alloc_Label(estimated_num_entries * sizeof(entryplus3),
"READDIRPLUS3res_u.resok.reply.entries");
if(pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries == NULL)
{
/* after successful cache_inode_readdir, dir_pentry may be
* read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
Mem_Free((char *)entry_name_array);
return NFS_REQ_DROP;
}
/* Allocation of the file handles */
fh3_array =
(fh3_buffer_item_t *) Mem_Alloc_Label(estimated_num_entries * NFS3_FHSIZE,
"Filehandle V3 in nfs3_Readdirplus");
if(fh3_array == NULL)
{
/* after successful cache_inode_readdir, dir_pentry may be
* read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
Mem_Free((char *)entry_name_array);
return NFS_REQ_DROP;
}
delta = 0;
/* manage . and .. */
if(begin_cookie == 0)
{
/* Fill in '.' */
if(estimated_num_entries > 0)
{
if((pfsal_handle = cache_inode_get_fsal_handle(dir_pentry,
&cache_status_gethandle))
== NULL)
{
/* after successful cache_inode_readdir, dir_pentry
* may be read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = nfs3_Errno(cache_status_gethandle);
return NFS_REQ_OK;
}
FSAL_DigestHandle(FSAL_GET_EXP_CTX(pcontext),
FSAL_DIGEST_FILEID3,
pfsal_handle,
(caddr_t) & (RES_READDIRPLUS_REPLY.entries[0].
fileid));
RES_READDIRPLUS_REPLY.entries[0].name = entry_name_array[0];
strcpy(RES_READDIRPLUS_REPLY.entries[0].name, ".");
RES_READDIRPLUS_REPLY.entries[0].cookie = 1;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[0].
name_handle.post_op_fh3_u.handle.data.data_val =
(char *)fh3_array[0];
if(nfs3_FSALToFhandle
(&pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[0].
name_handle.post_op_fh3_u.handle, pfsal_handle, pexport) == 0)
{
/* after successful cache_inode_readdir, dir_pentry may
* be read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = NFS3ERR_BADHANDLE;
return NFS_REQ_OK;
}
RES_READDIRPLUS_REPLY.entries[0].name_attributes.attributes_follow =
FALSE;
RES_READDIRPLUS_REPLY.entries[0].name_handle.handle_follows = FALSE;
entry_attr = dir_pentry->attributes;
/* Set PostPoFh3 structure */
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[0].
name_handle.handle_follows = TRUE;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[0].
name_handle.post_op_fh3_u.handle.data.data_len =
sizeof(file_handle_v3_t);
nfs_SetPostOpAttr(pcontext, pexport,
dir_pentry,
&entry_attr,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resok.
reply.entries[0].name_attributes));
LogFullDebug(COMPONENT_NFS_READDIR,
"Readdirplus3 -> i=0 num_entries=%d space_used=%lu maxcount=%lu Name=. FileId=%016llx Cookie=%llu",
num_entries, space_used, maxcount,
RES_READDIRPLUS_REPLY.entries[0].fileid,
RES_READDIRPLUS_REPLY.entries[0].cookie);
delta += 1;
}
}
/* Fill in '..' */
if(begin_cookie <= 1)
{
if(estimated_num_entries > delta)
{
if((pentry_dot_dot = cache_inode_lookupp_sw(dir_pentry,
ht,
pclient,
pcontext,
&cache_status_gethandle,
!dir_pentry_unlock)) ==
NULL)
{
/* after successful cache_inode_readdir, dir_pentry may
* be read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = nfs3_Errno(cache_status_gethandle);
return NFS_REQ_OK;
}
if((pfsal_handle = cache_inode_get_fsal_handle(pentry_dot_dot,
&cache_status_gethandle))
== NULL)
{
/* after successful cache_inode_readdir, dir_pentry may
* be read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = nfs3_Errno(cache_status_gethandle);
return NFS_REQ_OK;
}
FSAL_DigestHandle(FSAL_GET_EXP_CTX(pcontext),
FSAL_DIGEST_FILEID3,
pfsal_handle,
(caddr_t) & (RES_READDIRPLUS_REPLY.entries[delta].
fileid));
RES_READDIRPLUS_REPLY.entries[delta].name = entry_name_array[delta];
strcpy(RES_READDIRPLUS_REPLY.entries[delta].name, "..");
/* Getting a file handle */
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[delta].
name_handle.post_op_fh3_u.handle.data.data_val =
(char *)fh3_array[delta];
if(nfs3_FSALToFhandle
(&pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[delta].
name_handle.post_op_fh3_u.handle, pfsal_handle, pexport) == 0)
{
/* after successful cache_inode_readdir, dir_pentry may
* be read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = NFS3ERR_BADHANDLE;
return NFS_REQ_OK;
}
RES_READDIRPLUS_REPLY.entries[delta].cookie = 2;
RES_READDIRPLUS_REPLY.entries[delta].name_attributes.attributes_follow =
FALSE;
RES_READDIRPLUS_REPLY.entries[delta].name_handle.handle_follows = FALSE;
entry_attr = pentry_dot_dot->attributes;
/* Set PostPoFh3 structure */
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[delta].
name_handle.handle_follows = TRUE;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[delta].
name_handle.post_op_fh3_u.handle.data.data_len =
sizeof(file_handle_v3_t);
nfs_SetPostOpAttr(pcontext, pexport,
pentry_dot_dot,
&entry_attr,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resok.
reply.entries[delta].name_attributes));
LogFullDebug(COMPONENT_NFS_READDIR,
"Readdirplus3 -> i=%d num_entries=%d space_used=%lu maxcount=%lu Name=.. FileId=%016llx Cookie=%llu",
delta, num_entries, space_used, maxcount,
RES_READDIRPLUS_REPLY.entries[delta].fileid,
RES_READDIRPLUS_REPLY.entries[delta].cookie);
}
RES_READDIRPLUS_REPLY.entries[0].nextentry =
&(RES_READDIRPLUS_REPLY.entries[delta]);
if(num_entries > delta + 1) /* not 0 ??? */
RES_READDIRPLUS_REPLY.entries[delta].nextentry =
&(RES_READDIRPLUS_REPLY.entries[delta + 1]);
else
RES_READDIRPLUS_REPLY.entries[delta].nextentry = NULL;
delta += 1;
}
/* if( begin_cookie == 0 ) */
for(i = delta; i < num_entries + delta; i++)
{
unsigned long needed;
/* maxcount is the size with the FH and attributes overhead,
* so entryplus3 is used instead of entry3. The data structures
* in nfs23.h have funny padding depending on the arch (32 or 64).
* We can't get an accurate estimate by simply using
* sizeof(entryplus3). */
/* FIXME: There is still a 4 byte over estimate here on x86_64. */
/** @todo Remove cookie offset calculation in readdir and readdirplus (obsoleted) */
needed =
sizeof(reference_entry)
+ NFS3_FHSIZE
+ ((strlen(dirent_array[i - delta]->name.name) + 3) & ~3);
/* if delta == 1 or 2, then "." and ".." have already been added
* to the readdirplus reply. */
if (i == delta) {
needed += needed*delta /* size of a dir entry in reply */
- ((strlen(dirent_array[i - delta]->name.name) + 3) & ~3)*delta /* size of filename for current entry */
+ 4*delta; /* size of "." and ".." filenames in reply */
}
if((space_used += needed) > maxcount)
{
/* If delta != 0, then we already added "." or ".." to the reply. */
if(i == delta && delta == 0)
{
/* Not enough room to make even a single reply */
/* after successful cache_inode_readdir, dir_pentry may
* be read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = NFS3ERR_TOOSMALL;
return NFS_REQ_OK;
}
break; /* Make post traitement */
}
/*
* Get information specific to this entry
*/
if((pfsal_handle =
cache_inode_get_fsal_handle(dirent_array[i - delta]->pentry,
&cache_status_gethandle)) == NULL)
{
/* after successful cache_inode_readdir, dir_pentry may be
* read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status =
nfs3_Errno(cache_status_gethandle);
return NFS_REQ_OK;
}
/* Now fill in the replyed entryplus3 list */
FSAL_DigestHandle(FSAL_GET_EXP_CTX(pcontext),
FSAL_DIGEST_FILEID3,
pfsal_handle,
(caddr_t) & (RES_READDIRPLUS_REPLY.entries[i].fileid));
FSAL_name2str(&dirent_array[i - delta]->name, entry_name_array[i],
FSAL_MAX_NAME_LEN);
RES_READDIRPLUS_REPLY.entries[i].name = entry_name_array[i];
LogFullDebug(COMPONENT_NFS_READDIR,
"Readdirplus3 -> i=%u num_entries=%u delta=%u "
"num_entries + delta - 1=%u end_cookie=%"PRIu64,
i, num_entries, delta, num_entries + delta - 1,
end_cookie);
if(i != num_entries + delta - 1)
RES_READDIRPLUS_REPLY.entries[i].cookie =
dirent_array[i - delta]->cookie;
else
RES_READDIRPLUS_REPLY.entries[i].cookie = end_cookie;
RES_READDIRPLUS_REPLY.entries[i].name_attributes.attributes_follow = FALSE;
RES_READDIRPLUS_REPLY.entries[i].name_handle.handle_follows = FALSE;
entry_attr = dirent_array[i - delta]->pentry->attributes;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[i].name_handle.post_op_fh3_u.handle.data.data_val = (char *)fh3_array[i];
/* Compute the NFSv3 file handle */
if(nfs3_FSALToFhandle
(&pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[i].
name_handle.post_op_fh3_u.handle, pfsal_handle, pexport) == 0)
{
/* after successful cache_inode_readdir, dir_pentry may be
* read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = NFS3ERR_BADHANDLE;
return NFS_REQ_OK;
}
/* Set PostPoFh3 structure */
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[i].name_handle.handle_follows = TRUE;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[i].name_handle.post_op_fh3_u.handle.data.data_len = sizeof(file_handle_v3_t);
nfs_SetPostOpAttr(pcontext, pexport,
dirent_array[i - delta]->pentry,
&entry_attr,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[i].name_attributes));
LogFullDebug(COMPONENT_NFS_READDIR,
"Readdirplus3 -> i=%d, num_entries=%d needed=%lu space_used=%lu maxcount=%lu Name=%s FileId=%016llx Cookie=%llu",
i, num_entries, needed, space_used, maxcount,
dirent_array[i - delta]->name.name,
RES_READDIRPLUS_REPLY.entries[i].fileid,
RES_READDIRPLUS_REPLY.entries[i].cookie);
RES_READDIRPLUS_REPLY.entries[i].nextentry = NULL;
if(i != 0)
RES_READDIRPLUS_REPLY.entries[i - 1].nextentry =
&(RES_READDIRPLUS_REPLY.entries[i]);
}
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.eof = FALSE;
}
nfs_SetPostOpAttr(pcontext,
pexport,
dir_pentry,
&dir_attr,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resok.dir_attributes));
memcpy(pres->res_readdirplus3.READDIRPLUS3res_u.resok.cookieverf,
cookie_verifier, sizeof(cookieverf3));
pres->res_readdirplus3.status = NFS3_OK;
if((eod_met == END_OF_DIR) && (i == num_entries + delta))
{
/* End of directory */
LogFullDebug(COMPONENT_NFS_READDIR,
"============================================================> EOD MET !!!!!!");
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.eof = TRUE;
}
else
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.eof = FALSE;
nfs_SetPostOpAttr(pcontext, pexport,
dir_pentry,
&dir_attr,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resok.dir_attributes));
memcpy(pres->res_readdirplus3.READDIRPLUS3res_u.resok.cookieverf, cookie_verifier,
sizeof(cookieverf3));
LogFullDebug(COMPONENT_NFS_READDIR,
"============================================================");
/* after successful cache_inode_readdir, dir_pentry may be
* read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
/* Free the memory */
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
return NFS_REQ_OK;
}
/* If we are here, there was an error */
/* after successful cache_inode_readdir, dir_pentry may be
* read locked */
if (dir_pentry_unlock)
V_r(&dir_pentry->lock);
/* Free the memory */
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, pclient ) ;
Mem_Free((char *)dirent_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
/* Is this a retryable error */
if(nfs_RetryableError(cache_status))
return NFS_REQ_DROP;
/* Set failed status */
nfs_SetFailedStatus(pcontext, pexport,
NFS_V3,
cache_status,
NULL,
&pres->res_readdirplus3.status,
dir_pentry,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resfail.dir_attributes),
NULL, NULL, NULL, NULL, NULL, NULL);
return NFS_REQ_OK;
} /* nfs3_Readdirplus */
int nfs4_op_create(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
cache_entry_t *pentry_parent = NULL;
cache_entry_t *pentry_new = NULL;
fsal_attrib_list_t attr_parent;
fsal_attrib_list_t attr_new;
fsal_attrib_list_t sattr;
fsal_handle_t *pnewfsal_handle = NULL;
nfs_fh4 newfh4;
cache_inode_status_t cache_status;
int convrc = 0;
fsal_accessmode_t mode = 0600;
fsal_name_t name;
cache_inode_create_arg_t create_arg;
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_create";
unsigned int i = 0;
resp->resop = NFS4_OP_CREATE;
res_CREATE4.status = NFS4_OK;
/* If the filehandle is Empty */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_CREATE4.status = NFS4ERR_NOFILEHANDLE;
return res_CREATE4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_CREATE4.status = NFS4ERR_BADHANDLE;
return res_CREATE4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_CREATE4.status = NFS4ERR_FHEXPIRED;
return res_CREATE4.status;
}
/* Pseudo Fs is explictely a Read-Only File system */
if(nfs4_Is_Fh_Pseudo(&(data->currentFH)))
{
res_CREATE4.status = NFS4ERR_ROFS;
return res_CREATE4.status;
}
/* Ask only for supported attributes */
if(!nfs4_Fattr_Supported(&arg_CREATE4.createattrs))
{
res_CREATE4.status = NFS4ERR_ATTRNOTSUPP;
return res_CREATE4.status;
}
/* Do not use READ attr, use WRITE attr */
if(!nfs4_Fattr_Check_Access(&arg_CREATE4.createattrs, FATTR4_ATTR_WRITE))
{
res_CREATE4.status = NFS4ERR_INVAL;
return res_CREATE4.status;
}
/* Check for name to long */
if(arg_CREATE4.objname.utf8string_len > FSAL_MAX_NAME_LEN)
{
res_CREATE4.status = NFS4ERR_NAMETOOLONG;
return res_CREATE4.status;
}
/*
* This operation is used to create a non-regular file,
* this means: - a symbolic link
* - a block device file
* - a character device file
* - a socket file
* - a fifo
* - a directory
*
* You can't use this operation to create a regular file, you have to use NFS4_OP_OPEN for this
*/
/* Convert the UFT8 objname to a regular string */
if(arg_CREATE4.objname.utf8string_len == 0)
{
res_CREATE4.status = NFS4ERR_INVAL;
return res_CREATE4.status;
}
if(utf82str(name.name, &arg_CREATE4.objname) == -1)
{
res_CREATE4.status = NFS4ERR_INVAL;
return res_CREATE4.status;
}
name.len = strlen(name.name);
/* Sanuty check: never create a directory named '.' or '..' */
if(arg_CREATE4.objtype.type == NF4DIR)
{
if(!FSAL_namecmp(&name, (fsal_name_t *) & FSAL_DOT)
|| !FSAL_namecmp(&name, (fsal_name_t *) & FSAL_DOT_DOT))
{
res_CREATE4.status = NFS4ERR_BADNAME;
return res_CREATE4.status;
}
}
/* Filename should contain not slash */
for(i = 0; i < name.len; i++)
{
if(name.name[i] == '/')
{
res_CREATE4.status = NFS4ERR_BADCHAR;
return res_CREATE4.status;
}
}
/* Convert current FH into a cached entry, the current_pentry (assocated with the current FH will be used for this */
pentry_parent = data->current_entry;
/* The currentFH must point to a directory (objects are always created within a directory) */
if(data->current_filetype != DIR_BEGINNING && data->current_filetype != DIR_CONTINUE)
{
res_CREATE4.status = NFS4ERR_NOTDIR;
return res_CREATE4.status;
}
/* get attributes of parent directory, for 'change4' info replyed */
if((cache_status = cache_inode_getattr(pentry_parent,
&attr_parent,
data->ht,
data->pclient,
data->pcontext,
&cache_status)) != CACHE_INODE_SUCCESS)
{
res_CREATE4.status = nfs4_Errno(cache_status);
return res_CREATE4.status;
}
/* Change info for client cache coherency, pentry internal_md is used for that */
memset(&(res_CREATE4.CREATE4res_u.resok4.cinfo.before), 0, sizeof(changeid4));
res_CREATE4.CREATE4res_u.resok4.cinfo.before =
(changeid4) pentry_parent->internal_md.mod_time;
/* Convert the incoming fattr4 to a vattr structure, if such arguments are supplied */
if(arg_CREATE4.createattrs.attrmask.bitmap4_len != 0)
{
/* Arguments were supplied, extract them */
convrc = nfs4_Fattr_To_FSAL_attr(&sattr, &(arg_CREATE4.createattrs));
if(convrc == 0)
{
res_CREATE4.status = NFS4ERR_ATTRNOTSUPP;
return res_CREATE4.status;
}
if(convrc == -1)
{
res_CREATE4.status = NFS4ERR_BADXDR;
return res_CREATE4.status;
}
}
/* Create either a symbolic link or a directory */
switch (arg_CREATE4.objtype.type)
{
case NF4LNK:
/* Convert the name to link from into a regular string */
if(arg_CREATE4.objtype.createtype4_u.linkdata.utf8string_len == 0)
{
res_CREATE4.status = NFS4ERR_INVAL;
return res_CREATE4.status;
}
else
{
if(utf82str
(create_arg.link_content.path,
&arg_CREATE4.objtype.createtype4_u.linkdata) == -1)
{
res_CREATE4.status = NFS4ERR_INVAL;
return res_CREATE4.status;
}
create_arg.link_content.len = strlen(create_arg.link_content.path);
}
/* do the symlink operation */
if((pentry_new = cache_inode_create(pentry_parent,
&name,
SYMBOLIC_LINK,
mode,
&create_arg,
&attr_new,
data->ht,
data->pclient,
data->pcontext, &cache_status)) == NULL)
{
res_CREATE4.status = nfs4_Errno(cache_status);
return res_CREATE4.status;
}
/* If entry exists pentry_new is not null but cache_status was set */
if(cache_status == CACHE_INODE_ENTRY_EXISTS)
{
res_CREATE4.status = NFS4ERR_EXIST;
return res_CREATE4.status;
}
break;
case NF4DIR:
/* Create a new directory */
/* do the symlink operation */
if((pentry_new = cache_inode_create(pentry_parent,
&name,
DIR_BEGINNING,
mode,
&create_arg,
&attr_new,
data->ht,
data->pclient,
data->pcontext, &cache_status)) == NULL)
{
res_CREATE4.status = nfs4_Errno(cache_status);
return res_CREATE4.status;
}
/* If entry exists pentry_new is not null but cache_status was set */
if(cache_status == CACHE_INODE_ENTRY_EXISTS)
{
res_CREATE4.status = NFS4ERR_EXIST;
return res_CREATE4.status;
}
break;
case NF4SOCK:
/* Create a new socket file */
if((pentry_new = cache_inode_create(pentry_parent,
&name,
SOCKET_FILE,
mode,
NULL,
&attr_new,
data->ht,
data->pclient,
data->pcontext, &cache_status)) == NULL)
{
res_CREATE4.status = nfs4_Errno(cache_status);
return res_CREATE4.status;
}
/* If entry exists pentry_new is not null but cache_status was set */
if(cache_status == CACHE_INODE_ENTRY_EXISTS)
{
res_CREATE4.status = NFS4ERR_EXIST;
return res_CREATE4.status;
}
break;
case NF4FIFO:
/* Create a new socket file */
if((pentry_new = cache_inode_create(pentry_parent,
&name,
FIFO_FILE,
mode,
NULL,
&attr_new,
data->ht,
data->pclient,
data->pcontext, &cache_status)) == NULL)
{
res_CREATE4.status = nfs4_Errno(cache_status);
return res_CREATE4.status;
}
/* If entry exists pentry_new is not null but cache_status was set */
if(cache_status == CACHE_INODE_ENTRY_EXISTS)
{
res_CREATE4.status = NFS4ERR_EXIST;
return res_CREATE4.status;
}
break;
case NF4CHR:
create_arg.dev_spec.major = arg_CREATE4.objtype.createtype4_u.devdata.specdata1;
create_arg.dev_spec.minor = arg_CREATE4.objtype.createtype4_u.devdata.specdata2;
/* Create a new socket file */
if((pentry_new = cache_inode_create(pentry_parent,
&name,
CHARACTER_FILE,
mode,
&create_arg,
&attr_new,
data->ht,
data->pclient,
data->pcontext, &cache_status)) == NULL)
{
res_CREATE4.status = nfs4_Errno(cache_status);
return res_CREATE4.status;
}
/* If entry exists pentry_new is not null but cache_status was set */
if(cache_status == CACHE_INODE_ENTRY_EXISTS)
{
res_CREATE4.status = NFS4ERR_EXIST;
return res_CREATE4.status;
}
break;
case NF4BLK:
create_arg.dev_spec.major = arg_CREATE4.objtype.createtype4_u.devdata.specdata1;
create_arg.dev_spec.minor = arg_CREATE4.objtype.createtype4_u.devdata.specdata2;
/* Create a new socket file */
if((pentry_new = cache_inode_create(pentry_parent,
&name,
BLOCK_FILE,
mode,
&create_arg,
&attr_new,
data->ht,
data->pclient,
data->pcontext, &cache_status)) == NULL)
{
res_CREATE4.status = nfs4_Errno(cache_status);
return res_CREATE4.status;
}
/* If entry exists pentry_new is not null but cache_status was set */
if(cache_status == CACHE_INODE_ENTRY_EXISTS)
{
res_CREATE4.status = NFS4ERR_EXIST;
return res_CREATE4.status;
}
break;
default:
/* Should never happen, but return NFS4ERR_BADTYPE in this case */
res_CREATE4.status = NFS4ERR_BADTYPE;
return res_CREATE4.status;
break;
} /* switch( arg_CREATE4.objtype.type ) */
/* Now produce the filehandle to this file */
if((pnewfsal_handle = cache_inode_get_fsal_handle(pentry_new, &cache_status)) == NULL)
{
res_CREATE4.status = nfs4_Errno(cache_status);
return res_CREATE4.status;
}
/* Allocation of a new file handle */
if(nfs4_AllocateFH(&newfh4) != NFS4_OK)
{
res_CREATE4.status = NFS4ERR_SERVERFAULT;
return res_CREATE4.status;
}
/* Building the new file handle */
if(!nfs4_FSALToFhandle(&newfh4, pnewfsal_handle, data))
{
res_CREATE4.status = NFS4ERR_SERVERFAULT;
return res_CREATE4.status;
}
/* This new fh replaces the current FH */
data->currentFH.nfs_fh4_len = newfh4.nfs_fh4_len;
memcpy(data->currentFH.nfs_fh4_val, newfh4.nfs_fh4_val, newfh4.nfs_fh4_len);
/* No do not need newfh any more */
Mem_Free((char *)newfh4.nfs_fh4_val);
/* Set the mode if requested */
/* Use the same fattr mask for reply, if one attribute was not settable, NFS4ERR_ATTRNOTSUPP was replyied */
res_CREATE4.CREATE4res_u.resok4.attrset.bitmap4_len =
arg_CREATE4.createattrs.attrmask.bitmap4_len;
if(arg_CREATE4.createattrs.attrmask.bitmap4_len != 0)
{
if((cache_status = cache_inode_setattr(pentry_new,
&sattr,
data->ht,
data->pclient,
data->pcontext,
&cache_status)) != CACHE_INODE_SUCCESS)
{
res_CREATE4.status = nfs4_Errno(cache_status);
return res_CREATE4.status;
}
/* Allocate a new bitmap */
res_CREATE4.CREATE4res_u.resok4.attrset.bitmap4_val =
(unsigned int *)Mem_Alloc(res_CREATE4.CREATE4res_u.resok4.attrset.bitmap4_len *
sizeof(u_int));
if(res_CREATE4.CREATE4res_u.resok4.attrset.bitmap4_val == NULL)
{
res_CREATE4.status = NFS4ERR_SERVERFAULT;
return res_CREATE4.status;
}
memset(res_CREATE4.CREATE4res_u.resok4.attrset.bitmap4_val, 0,
res_CREATE4.CREATE4res_u.resok4.attrset.bitmap4_len);
memcpy(res_CREATE4.CREATE4res_u.resok4.attrset.bitmap4_val,
arg_CREATE4.createattrs.attrmask.bitmap4_val,
res_CREATE4.CREATE4res_u.resok4.attrset.bitmap4_len * sizeof(u_int));
}
/* Get the change info on parent directory after the operation was successfull */
if((cache_status = cache_inode_getattr(pentry_parent,
&attr_parent,
data->ht,
data->pclient,
data->pcontext,
&cache_status)) != CACHE_INODE_SUCCESS)
{
res_CREATE4.status = nfs4_Errno(cache_status);
return res_CREATE4.status;
}
memset(&(res_CREATE4.CREATE4res_u.resok4.cinfo.after), 0, sizeof(changeid4));
res_CREATE4.CREATE4res_u.resok4.cinfo.after =
(changeid4) pentry_parent->internal_md.mod_time;
/* Operation is supposed to be atomic .... */
res_CREATE4.CREATE4res_u.resok4.cinfo.atomic = TRUE;
LogFullDebug(COMPONENT_NFS_V4, " CREATE CINFO before = %llu after = %llu atomic = %d\n",
res_CREATE4.CREATE4res_u.resok4.cinfo.before,
res_CREATE4.CREATE4res_u.resok4.cinfo.after,
res_CREATE4.CREATE4res_u.resok4.cinfo.atomic);
/* @todo : BUGAZOMEU: fair ele free dans cette fonction */
/* Keep the vnode entry for the file in the compound data */
data->current_entry = pentry_new;
data->current_filetype = pentry_new->internal_md.type;
/* If you reach this point, then no error occured */
res_CREATE4.status = NFS4_OK;
return res_CREATE4.status;
} /* nfs4_op_create */
/**
* cache_inode_clean_internal: remove a pentry from cache and all LRUs,
* and release related resources.
*
* @param pentry [IN] entry to be deleted from cache
* @param hash_table_t [IN] The cache hash table
* @param pclient [INOUT] ressource allocated by the client for the nfs management.
*/
cache_inode_status_t cache_inode_clean_internal(cache_entry_t * to_remove_entry,
hash_table_t * ht,
cache_inode_client_t * pclient)
{
fsal_handle_t *pfsal_handle_remove;
cache_inode_parent_entry_t *parent_iter = NULL;
cache_inode_parent_entry_t *parent_iter_next = NULL;
cache_inode_fsal_data_t fsaldata;
cache_inode_status_t status;
hash_buffer_t key, old_key, old_value;
int rc;
memset( (char *)&fsaldata, 0, sizeof( fsaldata ) ) ;
if((pfsal_handle_remove =
cache_inode_get_fsal_handle(to_remove_entry, &status)) == NULL)
{
return status;
}
/* Invalidate the related LRU gc entry (no more required) */
if(to_remove_entry->gc_lru_entry != NULL)
{
if(LRU_invalidate(to_remove_entry->gc_lru, to_remove_entry->gc_lru_entry)
!= LRU_LIST_SUCCESS)
{
return CACHE_INODE_LRU_ERROR;
}
}
/* delete the entry from the cache */
fsaldata.handle = *pfsal_handle_remove;
/* XXX always DIR_START */
fsaldata.cookie = DIR_START;
if(cache_inode_fsaldata_2_key(&key, &fsaldata, pclient))
{
return CACHE_INODE_INCONSISTENT_ENTRY;
}
/* use the key to delete the entry */
rc = HashTable_Del(ht, &key, &old_key, &old_value);
if(rc)
LogCrit(COMPONENT_CACHE_INODE,
"HashTable_Del error %d in cache_inode_clean_internal", rc);
if((rc != HASHTABLE_SUCCESS) && (rc != HASHTABLE_ERROR_NO_SUCH_KEY))
{
cache_inode_release_fsaldata_key(&key, pclient);
return CACHE_INODE_INCONSISTENT_ENTRY;
}
/* release the key that was stored in hash table */
if(rc != HASHTABLE_ERROR_NO_SUCH_KEY)
{
cache_inode_release_fsaldata_key(&old_key, pclient);
/* Sanity check: old_value.pdata is expected to be equal to pentry,
* and is released later in this function */
if((cache_entry_t *) old_value.pdata != to_remove_entry)
{
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_remove: unexpected pdata %p from hash table (pentry=%p)",
old_value.pdata, to_remove_entry);
}
}
/* release the key used for hash query */
cache_inode_release_fsaldata_key(&key, pclient);
/* Free the parent list entries */
parent_iter = to_remove_entry->parent_list;
while(parent_iter != NULL)
{
parent_iter_next = parent_iter->next_parent;
ReleaseToPool(parent_iter, &pclient->pool_parent);
parent_iter = parent_iter_next;
}
return CACHE_INODE_SUCCESS;
} /* cache_inode_clean_internal */
/**
*
* cache_inode_gc_clean_entry: cleans a entry in the cache_inode.
*
* cleans an entry in the cache_inode.
*
* @param pentry [INOUT] entry to be cleaned.
* @param addparam [IN] additional parameter used for cleaning.
*
* @return LRU_LIST_SET_INVALID if ok, LRU_LIST_DO_NOT_SET_INVALID otherwise
*
*/
static int cache_inode_gc_clean_entry(cache_entry_t * pentry,
cache_inode_param_gc_t * pgcparam)
{
fsal_handle_t *pfsal_handle = NULL;
cache_inode_parent_entry_t *parent_iter = NULL;
cache_inode_parent_entry_t *parent_iter_next = NULL;
cache_inode_fsal_data_t fsaldata;
cache_inode_status_t status;
fsal_status_t fsal_status;
hash_buffer_t key, old_key, old_value;
int rc;
LogFullDebug(COMPONENT_CACHE_INODE_GC,
"(pthread_self=%p): About to remove pentry=%p, type=%d",
(caddr_t)pthread_self(),
pentry, pentry->internal_md.type);
/* sanity check */
if((pentry->gc_lru_entry != NULL) &&
((cache_entry_t *) pentry->gc_lru_entry->buffdata.pdata) != pentry)
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: LRU entry pointed by this pentry doesn't match the GC LRU");
}
/* Get the FSAL handle */
if((pfsal_handle = cache_inode_get_fsal_handle(pentry, &status)) == NULL)
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: unable to retrieve pentry's specific filesystem info");
return LRU_LIST_DO_NOT_SET_INVALID;
}
fsaldata.handle = *pfsal_handle;
if(pentry->internal_md.type != DIR_CONTINUE)
fsaldata.cookie = DIR_START;
else
fsaldata.cookie = pentry->object.dir_cont.dir_cont_pos;
/* Use the handle to build the key */
if(cache_inode_fsaldata_2_key(&key, &fsaldata, pgcparam->pclient))
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: could not build hashtable key");
cache_inode_release_fsaldata_key(&key, pgcparam->pclient);
return LRU_LIST_DO_NOT_SET_INVALID;
}
/* use the key to delete the entry */
rc = HashTable_Del(pgcparam->ht, &key, &old_key, &old_value);
if((rc != HASHTABLE_SUCCESS) && (rc != HASHTABLE_ERROR_NO_SUCH_KEY))
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: entry could not be deleted, status = %d",
rc);
cache_inode_release_fsaldata_key(&key, pgcparam->pclient);
return LRU_LIST_DO_NOT_SET_INVALID;
}
else if(rc == HASHTABLE_ERROR_NO_SUCH_KEY)
{
LogEvent(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: entry already deleted, type=%d, status=%d",
pentry->internal_md.type, rc);
cache_inode_release_fsaldata_key(&key, pgcparam->pclient);
return LRU_LIST_SET_INVALID;
}
/* Clean up the associated ressources in the FSAL */
if(FSAL_IS_ERROR(fsal_status = FSAL_CleanObjectResources(pfsal_handle)))
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: Could'nt free FSAL ressources fsal_status.major=%u",
fsal_status.major);
}
LogFullDebug(COMPONENT_CACHE_INODE_GC,
"++++> pentry %p deleted from HashTable", pentry);
/* Release the hash key data */
cache_inode_release_fsaldata_key(&old_key, pgcparam->pclient);
/* Sanity check: old_value.pdata is expected to be equal to pentry,
* and is released later in this function */
if((cache_entry_t *) old_value.pdata != pentry)
{
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_gc_clean_entry: unexpected pdata %p from hash table (pentry=%p)",
old_value.pdata, pentry);
}
cache_inode_release_fsaldata_key(&key, pgcparam->pclient);
/* Recover the parent list entries */
parent_iter = pentry->parent_list;
while(parent_iter != NULL)
{
parent_iter_next = parent_iter->next_parent;
ReleaseToPool(parent_iter, &pgcparam->pclient->pool_parent);
parent_iter = parent_iter_next;
}
LogFullDebug(COMPONENT_CACHE_INODE_GC,
"++++> parent directory sent back to pool");
/* If entry is a DIR_CONTINUE or a DIR_BEGINNING, release pdir_data */
if(pentry->internal_md.type == DIR_BEGINNING)
{
/* Put the pentry back to the pool */
ReleaseToPool(pentry->object.dir_begin.pdir_data, &pgcparam->pclient->pool_dir_data);
}
if(pentry->internal_md.type == DIR_CONTINUE)
{
/* Put the pentry back to the pool */
ReleaseToPool(pentry->object.dir_cont.pdir_data, &pgcparam->pclient->pool_dir_data);
}
LogFullDebug(COMPONENT_CACHE_INODE_GC,
"++++> pdir_data (if needed) sent back to pool");
#ifdef _USE_NFS4_ACL
/* If entry has NFS4 ACL, release it. */
cache_inode_gc_acl(pentry);
#endif /* _USE_NFS4_ACL */
/* Free and Destroy the mutex associated with the pentry */
V_w(&pentry->lock);
cache_inode_mutex_destroy(pentry);
/* Put the pentry back to the pool */
ReleaseToPool(pentry, &pgcparam->pclient->pool_entry);
/* Regular exit */
pgcparam->nb_to_be_purged = pgcparam->nb_to_be_purged - 1;
LogFullDebug(COMPONENT_CACHE_INODE_GC,
"++++> pentry %p: clean entry is ok", pentry);
return LRU_LIST_SET_INVALID; /* Cleaning ok */
}
/**
*
* cache_content_rdwr: Reads/Writes through the cache layer.
*
* Reads/Writes through the cache layer.
* This routine should be called only from the cache_inode layer.
*
* 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 read_or_write [IN] a flag of type cache_content_io_direction_t to tell if a read or write is to be done.
* @param seek_descriptor [IN] absolute position (in the FSAL file) where the IO will be done.
* @param pio_size_in [IN] requested io size
* @param pio_size_out [OUT] the size of the io that was successfully made.
* @param pbuffstat [OUT] the 'stat' of entry in the data cache after the operation
* @param buffer write:[IN] read:[OUT] the buffer for the data.
* @param pclient [IN] ressource allocated by the client for the nfs management.
* @param pcontext [IN] fsal credentials for the operation.
* @pstatus [OUT] returned status.
*
* @return CACHE_CONTENT_SUCCESS is successful .
*
*/
cache_content_status_t cache_content_rdwr(cache_content_entry_t * pentry,
cache_content_io_direction_t read_or_write,
fsal_seek_t * seek_descriptor,
fsal_size_t * pio_size_in,
fsal_size_t * pio_size_out,
caddr_t buffer,
fsal_boolean_t * p_fsal_eof,
struct stat * pbuffstat,
cache_content_client_t * pclient,
fsal_op_context_t * pcontext,
cache_content_status_t * pstatus)
{
fsal_handle_t *pfsal_handle = NULL;
fsal_status_t fsal_status;
cache_inode_status_t cache_inode_status;
cache_content_status_t cache_content_status;
fsal_path_t local_path;
int statindex;
off_t offset;
size_t iosize_before;
ssize_t iosize_after;
struct stat buffstat;
int rc;
char c;
*pstatus = CACHE_CONTENT_SUCCESS;
LogFullDebug(COMPONENT_CACHE_CONTENT,
"---> DATA : IO Size IN = %llu fdsize=%zu seeksize=%zu",
*pio_size_in, sizeof(fsal_file_t), sizeof(fsal_seek_t));
/* For now, only FSAL_SEEK_SET is supported */
if(seek_descriptor->whence != FSAL_SEEK_SET)
{
LogDebug(COMPONENT_CACHE_CONTENT,
"Implementation trouble: seek_descriptor was not a 'FSAL_SEEK_SET' cursor");
*pstatus = CACHE_INODE_INVALID_ARGUMENT;
return *pstatus;
}
/* Set the statindex variable */
switch (read_or_write)
{
case CACHE_CONTENT_READ:
statindex = CACHE_CONTENT_READ_ENTRY;
break;
case CACHE_CONTENT_WRITE:
statindex = CACHE_CONTENT_WRITE_ENTRY;
break;
default:
*pstatus = CACHE_CONTENT_INVALID_ARGUMENT;
return *pstatus;
break;
}
/* stat */
pclient->stat.func_stats.nb_call[statindex] += 1;
/* Get the fsal handle */
if((pfsal_handle =
cache_inode_get_fsal_handle(pentry->pentry_inode, &cache_inode_status)) == NULL)
{
*pstatus = CACHE_CONTENT_BAD_CACHE_INODE_ENTRY;
LogMajor(COMPONENT_CACHE_CONTENT,
"cache_content_rdwr: cannot get handle");
/* stat */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
return *pstatus;
}
/* Convert the path to FSAL path */
fsal_status =
FSAL_str2path(pentry->local_fs_entry.cache_path_data, MAXPATHLEN, &local_path);
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = CACHE_CONTENT_FSAL_ERROR;
/* stat */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
return *pstatus;
}
/* Parameters conversion */
offset = cache_content_fsal_seek_convert(*seek_descriptor, pstatus);
if(*pstatus != CACHE_CONTENT_SUCCESS)
{
/* stat */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
return *pstatus;
}
iosize_before = cache_content_fsal_size_convert(*pio_size_in, pstatus);
if(*pstatus != CACHE_CONTENT_SUCCESS)
{
/* stat */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
return *pstatus;
}
/* Open the local fd for reading */
if(cache_content_open(pentry, pclient, pstatus) != CACHE_CONTENT_SUCCESS)
{
return *pstatus;
}
/* Perform the IO through the cache */
if(read_or_write == CACHE_CONTENT_READ)
{
/* The file content was completely read before the IO. The read operation is fully done locally */
if((iosize_after =
pread(pentry->local_fs_entry.opened_file.local_fd, buffer, iosize_before,
offset)) == -1)
{
/* stat */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
*pstatus = CACHE_CONTENT_LOCAL_CACHE_ERROR;
return *pstatus;
}
if((cache_content_status =
cache_content_valid(pentry, CACHE_CONTENT_OP_GET,
pclient)) != CACHE_CONTENT_SUCCESS)
{
*pstatus = cache_content_status;
return *pstatus;
}
/* Get the eof */
if(iosize_after == 0)
*p_fsal_eof = TRUE;
else
{
rc = pread(pentry->local_fs_entry.opened_file.local_fd, &c, 1,
offset + iosize_before);
if(rc == 0)
*p_fsal_eof = TRUE;
else
*p_fsal_eof = FALSE;
}
}
else
{
/* The io is done on the cache before being flushed to the FSAL */
if((iosize_after =
pwrite(pentry->local_fs_entry.opened_file.local_fd, buffer, iosize_before,
offset)) == -1)
{
/* stat */
pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;
*pstatus = CACHE_CONTENT_LOCAL_CACHE_ERROR;
return *pstatus;
}
if((cache_content_status =
cache_content_valid(pentry, CACHE_CONTENT_OP_SET,
pclient)) != CACHE_CONTENT_SUCCESS)
{
*pstatus = cache_content_status;
return *pstatus;
}
/* p_fsal_eof has no meaning here, it is unused */
}
/* close the local fd */
if(cache_content_close(pentry, pclient, pstatus) != CACHE_CONTENT_SUCCESS)
return *pstatus;
*pio_size_out = (fsal_size_t) iosize_after;
/* Return the 'stat' as seen in the cache */
if(stat(pentry->local_fs_entry.cache_path_data, &buffstat) == -1)
{
*pstatus = CACHE_CONTENT_LOCAL_CACHE_ERROR;
}
else
{
if(pbuffstat != NULL)
*pbuffstat = buffstat;
}
return *pstatus;
} /* cache_content_rdwr */
int nfs4_op_lookupp(struct nfs_argop4 *op,
compound_data_t * data, struct nfs_resop4 *resp)
{
fsal_name_t name;
cache_entry_t *dir_pentry = NULL;
cache_entry_t *file_pentry = NULL;
fsal_attrib_list_t attrlookup;
cache_inode_status_t cache_status;
int error = 0;
fsal_handle_t *pfsal_handle = NULL;
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_lookupp";
resp->resop = NFS4_OP_LOOKUPP;
resp->nfs_resop4_u.oplookupp.status = NFS4_OK;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_LOOKUPP4.status = NFS4ERR_NOFILEHANDLE;
return res_LOOKUPP4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_LOOKUPP4.status = NFS4ERR_BADHANDLE;
return res_LOOKUPP4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_LOOKUPP4.status = NFS4ERR_FHEXPIRED;
return res_LOOKUPP4.status;
}
/* looking up for parent directory from ROOTFH return NFS4ERR_NOENT (RFC3530, page 166) */
if(data->currentFH.nfs_fh4_len == data->rootFH.nfs_fh4_len
&& memcmp(data->currentFH.nfs_fh4_val, data->rootFH.nfs_fh4_val,
data->currentFH.nfs_fh4_len) == 0)
{
/* Nothing to do, just reply with success */
res_LOOKUPP4.status = NFS4ERR_NOENT;
return res_LOOKUPP4.status;
}
/* If in pseudoFS, proceed with pseudoFS specific functions */
if(nfs4_Is_Fh_Pseudo(&(data->currentFH)))
return nfs4_op_lookupp_pseudo(op, data, resp);
/* If Filehandle points to a xattr object, manage it via the xattrs specific functions */
if(nfs4_Is_Fh_Xattr(&(data->currentFH)))
return nfs4_op_lookupp_xattr(op, data, resp);
/* If data->exportp is null, a junction from pseudo fs was traversed, credp and exportp have to be updated */
if(data->pexport == NULL)
{
if((error = nfs4_SetCompoundExport(data)) != NFS4_OK)
{
res_LOOKUPP4.status = error;
return res_LOOKUPP4.status;
}
}
/* Preparying for cache_inode_lookup ".." */
file_pentry = NULL;
dir_pentry = data->current_entry;
name = FSAL_DOT_DOT;
/* BUGAZOMEU: Faire la gestion des cross junction traverse */
if((file_pentry = cache_inode_lookup(dir_pentry,
&name,
data->pexport->cache_inode_policy,
&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_LOOKUPP4.status = NFS4ERR_SERVERFAULT;
return res_LOOKUPP4.status;
}
/* Convert it to a file handle */
if(!nfs4_FSALToFhandle(&data->currentFH, pfsal_handle, data))
{
res_LOOKUPP4.status = NFS4ERR_SERVERFAULT;
return res_LOOKUPP4.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;
/* Keep the pointer within the compound data */
data->current_entry = file_pentry;
data->current_filetype = file_pentry->internal_md.type;
/* Return successfully */
res_LOOKUPP4.status = NFS4_OK;
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 */
/* If NFS4ERR_SYMLINK should be returned for a symlink instead of ENOTDIR */
if((cache_status == CACHE_INODE_NOT_A_DIRECTORY) &&
(dir_pentry->internal_md.type == SYMBOLIC_LINK))
res_LOOKUPP4.status = NFS4ERR_SYMLINK;
else
res_LOOKUPP4.status = nfs4_Errno(cache_status);
return res_LOOKUPP4.status;
} /* nfs4_op_lookupp */
int nfs41_op_open(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
cache_entry_t *pentry_parent = NULL;
cache_entry_t *pentry_lookup = NULL;
cache_entry_t *pentry_newfile = NULL;
fsal_handle_t *pnewfsal_handle = NULL;
fsal_attrib_list_t attr_parent;
fsal_attrib_list_t attr;
fsal_attrib_list_t attr_newfile;
fsal_attrib_list_t sattr;
fsal_openflags_t openflags = 0;
cache_inode_status_t cache_status;
nfsstat4 rc;
int retval;
fsal_name_t filename;
bool_t AttrProvided = FALSE;
fsal_accessmode_t mode = 0600;
nfs_fh4 newfh4;
nfs_client_id_t nfs_clientid;
nfs_worker_data_t *pworker = NULL;
int convrc = 0;
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_open";
cache_inode_state_data_t candidate_data;
cache_inode_state_type_t candidate_type;
cache_inode_state_t *pfile_state = NULL;
cache_inode_state_t *pstate_found_iterate = NULL;
cache_inode_state_t *pstate_previous_iterate = NULL;
cache_inode_state_t *pstate_found_same_owner = NULL;
cache_inode_open_owner_name_t owner_name;
cache_inode_open_owner_name_t *powner_name = NULL;
cache_inode_open_owner_t *powner = NULL;
bool_t open_owner_known = FALSE;
resp->resop = NFS4_OP_OPEN;
res_OPEN4.status = NFS4_OK;
uint32_t tmp_attr[2];
uint_t tmp_int = 2;
int pnfs_status;
cache_inode_create_arg_t create_arg;
pworker = (nfs_worker_data_t *) data->pclient->pworker;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_OPEN4.status = NFS4ERR_NOFILEHANDLE;
return res_OPEN4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_OPEN4.status = NFS4ERR_BADHANDLE;
return res_OPEN4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_OPEN4.status = NFS4ERR_FHEXPIRED;
return res_OPEN4.status;
}
/* This can't be done on the pseudofs */
if(nfs4_Is_Fh_Pseudo(&(data->currentFH)))
{
res_OPEN4.status = NFS4ERR_ROFS;
return res_OPEN4.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_open_xattr(op, data, resp);
/* If data->current_entry is empty, repopulate it */
if(data->current_entry == NULL)
{
if((data->current_entry = nfs_FhandleToCache(NFS_V4,
NULL,
NULL,
&(data->currentFH),
NULL,
NULL,
&(res_OPEN4.status),
&attr,
data->pcontext,
data->pclient,
data->ht, &retval)) == NULL)
{
res_OPEN4.status = NFS4ERR_SERVERFAULT;
return res_OPEN4.status;
}
}
/* Set parent */
pentry_parent = data->current_entry;
/* First switch is based upon claim type */
switch (arg_OPEN4.claim.claim)
{
case CLAIM_DELEGATE_CUR:
case CLAIM_DELEGATE_PREV:
/* Check for name length */
if(arg_OPEN4.claim.open_claim4_u.file.utf8string_len > FSAL_MAX_NAME_LEN)
{
res_OPEN4.status = NFS4ERR_NAMETOOLONG;
return res_OPEN4.status;
}
/* get the filename from the argument, it should not be empty */
if(arg_OPEN4.claim.open_claim4_u.file.utf8string_len == 0)
{
res_OPEN4.status = NFS4ERR_INVAL;
return res_OPEN4.status;
}
res_OPEN4.status = NFS4ERR_NOTSUPP;
return res_OPEN4.status;
break;
case CLAIM_NULL:
/* Check for name length */
if(arg_OPEN4.claim.open_claim4_u.file.utf8string_len > FSAL_MAX_NAME_LEN)
{
res_OPEN4.status = NFS4ERR_NAMETOOLONG;
return res_OPEN4.status;
}
/* get the filename from the argument, it should not be empty */
if(arg_OPEN4.claim.open_claim4_u.file.utf8string_len == 0)
{
res_OPEN4.status = NFS4ERR_INVAL;
return res_OPEN4.status;
}
/* Check if asked attributes are correct */
if(arg_OPEN4.openhow.openflag4_u.how.mode == GUARDED4 ||
arg_OPEN4.openhow.openflag4_u.how.mode == UNCHECKED4)
{
if(!nfs4_Fattr_Supported
(&arg_OPEN4.openhow.openflag4_u.how.createhow4_u.createattrs))
{
res_OPEN4.status = NFS4ERR_ATTRNOTSUPP;
return res_OPEN4.status;
}
/* Do not use READ attr, use WRITE attr */
if(!nfs4_Fattr_Check_Access
(&arg_OPEN4.openhow.openflag4_u.how.createhow4_u.createattrs,
FATTR4_ATTR_WRITE))
{
res_OPEN4.status = NFS4ERR_INVAL;
return res_OPEN4.status;
}
}
/* Check if filename is correct */
if((cache_status =
cache_inode_error_convert(FSAL_buffdesc2name
((fsal_buffdesc_t *) & arg_OPEN4.claim.open_claim4_u.
file, &filename))) != CACHE_INODE_SUCCESS)
{
res_OPEN4.status = nfs4_Errno(cache_status);
return res_OPEN4.status;
}
/* Check parent */
pentry_parent = data->current_entry;
/* Parent must be a directory */
if((pentry_parent->internal_md.type != DIR_BEGINNING) &&
(pentry_parent->internal_md.type != DIR_CONTINUE))
{
/* Parent object is not a directory... */
if(pentry_parent->internal_md.type == SYMBOLIC_LINK)
res_OPEN4.status = NFS4ERR_SYMLINK;
else
res_OPEN4.status = NFS4ERR_NOTDIR;
return res_OPEN4.status;
}
/* What kind of open is it ? */
LogFullDebug(COMPONENT_NFS_V4,
" OPEN: Claim type = %d Open Type = %d Share Deny = %d Share Access = %d \n",
arg_OPEN4.claim.claim, arg_OPEN4.openhow.opentype, arg_OPEN4.share_deny,
arg_OPEN4.share_access);
/* It this a known client id ? */
LogDebug(COMPONENT_NFS_V4, "OPEN Client id = %llx", arg_OPEN4.owner.clientid);
/* Is this open_owner known ? */
if(!nfs_convert_open_owner(&arg_OPEN4.owner, &owner_name))
{
res_OPEN4.status = NFS4ERR_SERVERFAULT;
return res_OPEN4.status;
}
if(!nfs_open_owner_Get_Pointer(&owner_name, &powner))
{
/* This open owner is not known yet, allocated and set up a new one */
GET_PREALLOC(powner,
data->pclient->pool_open_owner,
data->pclient->nb_pre_state_v4, cache_inode_open_owner_t, next);
GET_PREALLOC(powner_name,
data->pclient->pool_open_owner_name,
data->pclient->nb_pre_state_v4,
cache_inode_open_owner_name_t, next);
if(powner == NULL || powner_name == NULL)
{
res_OPEN4.status = NFS4ERR_SERVERFAULT;
return res_OPEN4.status;
}
memcpy((char *)powner_name, (char *)&owner_name,
sizeof(cache_inode_open_owner_name_t));
/* set up the content of the open_owner */
powner->confirmed = FALSE;
powner->seqid = 1; /* NFSv4.1 specific, initial seqid is 1 */
powner->related_owner = NULL;
powner->next = NULL;
powner->clientid = arg_OPEN4.owner.clientid;
powner->owner_len = arg_OPEN4.owner.owner.owner_len;
memcpy((char *)powner->owner_val, (char *)arg_OPEN4.owner.owner.owner_val,
arg_OPEN4.owner.owner.owner_len);
powner->owner_val[powner->owner_len] = '\0';
pthread_mutex_init(&powner->lock, NULL);
if(!nfs_open_owner_Set(powner_name, powner))
{
res_OPEN4.status = NFS4ERR_SERVERFAULT;
return res_OPEN4.status;
}
}
/* Status of parent directory before the operation */
if((cache_status = cache_inode_getattr(pentry_parent,
&attr_parent,
data->ht,
data->pclient,
data->pcontext,
&cache_status)) != CACHE_INODE_SUCCESS)
{
res_OPEN4.status = nfs4_Errno(cache_status);
return res_OPEN4.status;
}
memset(&(res_OPEN4.OPEN4res_u.resok4.cinfo.before), 0, sizeof(changeid4));
res_OPEN4.OPEN4res_u.resok4.cinfo.before =
(changeid4) pentry_parent->internal_md.mod_time;
/* CLient may have provided fattr4 to set attributes at creation time */
if(arg_OPEN4.openhow.openflag4_u.how.mode == GUARDED4 ||
arg_OPEN4.openhow.openflag4_u.how.mode == UNCHECKED4)
{
if(arg_OPEN4.openhow.openflag4_u.how.createhow4_u.createattrs.attrmask.
bitmap4_len != 0)
{
/* Convert fattr4 so nfs4_sattr */
convrc =
nfs4_Fattr_To_FSAL_attr(&sattr,
&(arg_OPEN4.openhow.openflag4_u.how.
createhow4_u.createattrs));
if(convrc == 0)
{
res_OPEN4.status = NFS4ERR_ATTRNOTSUPP;
return res_OPEN4.status;
}
if(convrc == -1)
{
res_OPEN4.status = NFS4ERR_BADXDR;
return res_OPEN4.status;
}
AttrProvided = TRUE;
}
}
/* Second switch is based upon "openhow" */
switch (arg_OPEN4.openhow.opentype)
{
case OPEN4_CREATE:
/* a new file is to be created */
/* Does a file with this name already exist ? */
pentry_lookup = cache_inode_lookup(pentry_parent,
&filename,
&attr_newfile,
data->ht,
data->pclient,
data->pcontext, &cache_status);
if(cache_status != CACHE_INODE_NOT_FOUND)
{
/* if open is UNCHECKED, return NFS4_OK (RFC3530 page 172) */
if(arg_OPEN4.openhow.openflag4_u.how.mode == UNCHECKED4
&& (cache_status == CACHE_INODE_SUCCESS))
{
/* If the file is opened for write, OPEN4 while deny share write access,
* in this case, check caller has write access to the file */
if(arg_OPEN4.share_deny & OPEN4_SHARE_DENY_WRITE)
{
if(cache_inode_access(pentry_lookup,
FSAL_W_OK,
data->ht,
data->pclient,
data->pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
res_OPEN4.status = NFS4ERR_ACCESS;
return res_OPEN4.status;
}
openflags = FSAL_O_WRONLY;
}
/* Same check on read: check for readability of a file before opening it for read */
if(arg_OPEN4.share_access & OPEN4_SHARE_ACCESS_READ)
{
if(cache_inode_access(pentry_lookup,
FSAL_R_OK,
data->ht,
data->pclient,
data->pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
res_OPEN4.status = NFS4ERR_ACCESS;
return res_OPEN4.status;
}
openflags = FSAL_O_RDONLY;
}
if(AttrProvided == TRUE) /* Set the attribute if provided */
{
if((cache_status = cache_inode_setattr(pentry_lookup,
&sattr,
data->ht,
data->pclient,
data->pcontext,
&cache_status)) !=
CACHE_INODE_SUCCESS)
{
res_OPEN4.status = nfs4_Errno(cache_status);
return res_OPEN4.status;
}
res_OPEN4.OPEN4res_u.resok4.attrset =
arg_OPEN4.openhow.openflag4_u.how.createhow4_u.createattrs.
attrmask;
}
else
res_OPEN4.OPEN4res_u.resok4.attrset.bitmap4_len = 0;
/* Same check on write */
if(arg_OPEN4.share_access & OPEN4_SHARE_ACCESS_WRITE)
{
if(cache_inode_access(pentry_lookup,
FSAL_W_OK,
data->ht,
data->pclient,
data->pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
res_OPEN4.status = NFS4ERR_ACCESS;
return res_OPEN4.status;
}
openflags = FSAL_O_RDWR;
}
/* Set the state for the related file */
/* Prepare state management structure */
candidate_type = CACHE_INODE_STATE_SHARE;
candidate_data.share.share_deny = arg_OPEN4.share_deny;
candidate_data.share.share_access = arg_OPEN4.share_access;
if(cache_inode_add_state(pentry_lookup,
candidate_type,
&candidate_data,
powner,
data->pclient,
data->pcontext,
&pfile_state,
&cache_status) != CACHE_INODE_SUCCESS)
{
/* Seqid has to be incremented even in this case */
P(powner->lock);
powner->seqid += 1;
V(powner->lock);
res_OPEN4.status = NFS4ERR_SHARE_DENIED;
return res_OPEN4.status;
}
/* Open the file */
if(cache_inode_open_by_name(pentry_parent,
&filename,
pentry_lookup,
data->pclient,
openflags,
data->pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
/* Seqid has to be incremented even in this case */
P(powner->lock);
powner->seqid += 1;
V(powner->lock);
res_OPEN4.status = NFS4ERR_SHARE_DENIED;
res_OPEN4.status = NFS4ERR_ACCESS;
return res_OPEN4.status;
}
res_OPEN4.OPEN4res_u.resok4.attrset.bitmap4_len = 2;
if((res_OPEN4.OPEN4res_u.resok4.attrset.bitmap4_val =
(uint32_t *) Mem_Alloc(res_OPEN4.OPEN4res_u.resok4.attrset.
bitmap4_len * sizeof(uint32_t))) == NULL)
{
res_OPEN4.status = NFS4ERR_SERVERFAULT;
return res_OPEN4.status;
}
memset(&(res_OPEN4.OPEN4res_u.resok4.cinfo.after), 0,
sizeof(changeid4));
res_OPEN4.OPEN4res_u.resok4.cinfo.after =
(changeid4) pentry_parent->internal_md.mod_time;
res_OPEN4.OPEN4res_u.resok4.cinfo.atomic = TRUE;
res_OPEN4.OPEN4res_u.resok4.stateid.seqid = pfile_state->seqid;
memcpy(res_OPEN4.OPEN4res_u.resok4.stateid.other,
pfile_state->stateid_other, 12);
/* No delegation */
res_OPEN4.OPEN4res_u.resok4.delegation.delegation_type =
OPEN_DELEGATE_NONE;
res_OPEN4.OPEN4res_u.resok4.rflags = OPEN4_RESULT_LOCKTYPE_POSIX;
/* Now produce the filehandle to this file */
if((pnewfsal_handle =
cache_inode_get_fsal_handle(pentry_lookup, &cache_status)) == NULL)
{
res_OPEN4.status = nfs4_Errno(cache_status);
return res_OPEN4.status;
}
/* Allocation of a new file handle */
if((rc = nfs4_AllocateFH(&newfh4)) != NFS4_OK)
{
res_OPEN4.status = rc;
return res_OPEN4.status;
}
/* Building a new fh */
if(!nfs4_FSALToFhandle(&newfh4, pnewfsal_handle, data))
{
res_OPEN4.status = NFS4ERR_SERVERFAULT;
return res_OPEN4.status;
}
/* This new fh replaces the current FH */
data->currentFH.nfs_fh4_len = newfh4.nfs_fh4_len;
memcpy(data->currentFH.nfs_fh4_val, newfh4.nfs_fh4_val,
newfh4.nfs_fh4_len);
data->current_entry = pentry_lookup;
data->current_filetype = REGULAR_FILE;
res_OPEN4.status = NFS4_OK;
return res_OPEN4.status;
}
/* if open is EXCLUSIVE, but verifier is the same, return NFS4_OK (RFC3530 page 173) */
if(arg_OPEN4.openhow.openflag4_u.how.mode == EXCLUSIVE4)
{
if((pentry_lookup != NULL)
&& (pentry_lookup->internal_md.type == REGULAR_FILE))
{
pstate_found_iterate = NULL;
pstate_previous_iterate = NULL;
do
{
cache_inode_state_iterate(pentry_lookup,
&pstate_found_iterate,
pstate_previous_iterate,
data->pclient,
data->pcontext, &cache_status);
if(cache_status == CACHE_INODE_STATE_ERROR)
break;
if(cache_status == CACHE_INODE_INVALID_ARGUMENT)
{
/* Seqid has to be incremented even in this case */
P(powner->lock);
powner->seqid += 1;
V(powner->lock);
res_OPEN4.status = NFS4ERR_INVAL;
return res_OPEN4.status;
}
/* Check is open_owner is the same */
if(pstate_found_iterate != NULL)
{
if((pstate_found_iterate->state_type ==
CACHE_INODE_STATE_SHARE)
&& !memcmp(arg_OPEN4.owner.owner.owner_val,
pstate_found_iterate->powner->owner_val,
pstate_found_iterate->powner->owner_len)
&& !memcmp(pstate_found_iterate->state_data.share.
oexcl_verifier,
arg_OPEN4.openhow.openflag4_u.how.
createhow4_u.createverf, NFS4_VERIFIER_SIZE))
{
/* A former open EXCLUSIVE with same owner and verifier was found, resend it */
res_OPEN4.OPEN4res_u.resok4.stateid.seqid =
pstate_found_iterate->seqid;
memcpy(res_OPEN4.OPEN4res_u.resok4.stateid.other,
pstate_found_iterate->stateid_other, 12);
memset(&(res_OPEN4.OPEN4res_u.resok4.cinfo.after), 0,
sizeof(changeid4));
res_OPEN4.OPEN4res_u.resok4.cinfo.after =
(changeid4) pentry_parent->internal_md.mod_time;
res_OPEN4.OPEN4res_u.resok4.cinfo.atomic = TRUE;
/* No delegation */
res_OPEN4.OPEN4res_u.resok4.delegation.delegation_type =
OPEN_DELEGATE_NONE;
res_OPEN4.OPEN4res_u.resok4.rflags =
OPEN4_RESULT_LOCKTYPE_POSIX;
/* Now produce the filehandle to this file */
if((pnewfsal_handle =
cache_inode_get_fsal_handle(pentry_lookup,
&cache_status)) == NULL)
{
res_OPEN4.status = nfs4_Errno(cache_status);
return res_OPEN4.status;
}
/* Allocation of a new file handle */
if((rc = nfs4_AllocateFH(&newfh4)) != NFS4_OK)
{
res_OPEN4.status = rc;
return res_OPEN4.status;
}
/* Building a new fh */
if(!nfs4_FSALToFhandle(&newfh4, pnewfsal_handle, data))
{
res_OPEN4.status = NFS4ERR_SERVERFAULT;
return res_OPEN4.status;
}
/* This new fh replaces the current FH */
data->currentFH.nfs_fh4_len = newfh4.nfs_fh4_len;
memcpy(data->currentFH.nfs_fh4_val, newfh4.nfs_fh4_val,
newfh4.nfs_fh4_len);
data->current_entry = pentry_lookup;
data->current_filetype = REGULAR_FILE;
/* regular exit */
res_OPEN4.status = NFS4_OK;
return res_OPEN4.status;
}
}
/* if( pstate_found_iterate != NULL ) */
pstate_previous_iterate = pstate_found_iterate;
}
while(pstate_found_iterate != NULL);
}
}
/* Managing GUARDED4 mode */
if(cache_status != CACHE_INODE_SUCCESS)
res_OPEN4.status = nfs4_Errno(cache_status);
else
res_OPEN4.status = NFS4ERR_EXIST; /* File already exists */
return res_OPEN4.status;
}
/* if( cache_status != CACHE_INODE_NOT_FOUND ), if file already exists basically */
LogFullDebug(COMPONENT_NFS_V4, " OPEN open.how = %d\n", arg_OPEN4.openhow.openflag4_u.how.mode);
create_arg.use_pnfs = FALSE;
#ifdef _USE_PNFS
/* set the file has "managed via pNFS" */
if(data->pexport->options & EXPORT_OPTION_USE_PNFS)
create_arg.use_pnfs = TRUE;
#endif /* _USE_PNFS */
/* Create the file, if we reach this point, it does not exist, we can create it */
if((pentry_newfile = cache_inode_create(pentry_parent,
&filename,
REGULAR_FILE,
mode,
&create_arg,
&attr_newfile,
data->ht,
data->pclient,
data->pcontext, &cache_status)) == NULL)
{
/* If the file already exists, this is not an error if open mode is UNCHECKED */
if(cache_status != CACHE_INODE_ENTRY_EXISTS)
{
res_OPEN4.status = nfs4_Errno(cache_status);
return res_OPEN4.status;
}
else
{
/* If this point is reached, then the file already exists, cache_status == CACHE_INODE_ENTRY_EXISTS and pentry_newfile == NULL
This probably means EXCLUSIVE4 mode is used and verifier matches. pentry_newfile is then set to pentry_lookup */
pentry_newfile = pentry_lookup;
}
}
/* Prepare state management structure */
candidate_type = CACHE_INODE_STATE_SHARE;
candidate_data.share.share_deny = arg_OPEN4.share_deny;
candidate_data.share.share_access = arg_OPEN4.share_access;
candidate_data.share.lockheld = 0;
/* If file is opened under mode EXCLUSIVE4, open verifier should be kept to detect non vicious double open */
if(arg_OPEN4.openhow.openflag4_u.how.mode == EXCLUSIVE4)
{
strncpy(candidate_data.share.oexcl_verifier,
arg_OPEN4.openhow.openflag4_u.how.createhow4_u.createverf,
NFS4_VERIFIER_SIZE);
}
if(cache_inode_add_state(pentry_newfile,
candidate_type,
&candidate_data,
powner,
data->pclient,
data->pcontext,
&pfile_state, &cache_status) != CACHE_INODE_SUCCESS)
{
/* Seqid has to be incremented even in this case */
P(powner->lock);
powner->seqid += 1;
V(powner->lock);
res_OPEN4.status = NFS4ERR_SHARE_DENIED;
return res_OPEN4.status;
}
if(AttrProvided == TRUE) /* Set the attribute if provided */
{
if((cache_status = cache_inode_setattr(pentry_newfile,
&sattr,
data->ht,
data->pclient,
data->pcontext,
&cache_status)) !=
CACHE_INODE_SUCCESS)
{
res_OPEN4.status = nfs4_Errno(cache_status);
return res_OPEN4.status;
}
}
/* Set the openflags variable */
if(arg_OPEN4.share_deny & OPEN4_SHARE_DENY_WRITE)
openflags |= FSAL_O_RDONLY;
if(arg_OPEN4.share_deny & OPEN4_SHARE_DENY_READ)
openflags |= FSAL_O_WRONLY;
if(arg_OPEN4.share_access & OPEN4_SHARE_ACCESS_WRITE)
openflags = FSAL_O_RDWR;
if(arg_OPEN4.share_access != 0)
openflags = FSAL_O_RDWR; /* @todo : BUGAZOMEU : Something better later */
/* Open the file */
if(cache_inode_open_by_name(pentry_parent,
&filename,
pentry_newfile,
data->pclient,
openflags,
data->pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
/* Seqid has to be incremented even in this case */
P(powner->lock);
powner->seqid += 1;
V(powner->lock);
res_OPEN4.status = NFS4ERR_ACCESS;
return res_OPEN4.status;
}
break;
case OPEN4_NOCREATE:
/* It was not a creation, but a regular open */
/* The filehandle to the new file replaces the current filehandle */
if(pentry_newfile == NULL)
{
if((pentry_newfile = cache_inode_lookup(pentry_parent,
&filename,
&attr_newfile,
data->ht,
data->pclient,
data->pcontext,
&cache_status)) == NULL)
{
res_OPEN4.status = nfs4_Errno(cache_status);
return res_OPEN4.status;
}
}
/* OPEN4 is to be done on a file */
if(pentry_newfile->internal_md.type != REGULAR_FILE)
{
if(pentry_newfile->internal_md.type == DIR_BEGINNING
|| pentry_newfile->internal_md.type == DIR_CONTINUE)
{
res_OPEN4.status = NFS4ERR_ISDIR;
return res_OPEN4.status;
}
else if(pentry_newfile->internal_md.type == SYMBOLIC_LINK)
{
res_OPEN4.status = NFS4ERR_SYMLINK;
return res_OPEN4.status;
}
else
{
res_OPEN4.status = NFS4ERR_INVAL;
return res_OPEN4.status;
}
}
/* If the file is opened for write, OPEN4 while deny share write access,
* in this case, check caller has write access to the file */
if(arg_OPEN4.share_deny & OPEN4_SHARE_DENY_WRITE)
{
if(cache_inode_access(pentry_newfile,
FSAL_W_OK,
data->ht,
data->pclient,
data->pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
res_OPEN4.status = NFS4ERR_ACCESS;
return res_OPEN4.status;
}
openflags = FSAL_O_WRONLY;
}
/* Same check on read: check for readability of a file before opening it for read */
if(arg_OPEN4.share_access & OPEN4_SHARE_ACCESS_READ)
{
if(cache_inode_access(pentry_newfile,
FSAL_R_OK,
data->ht,
data->pclient,
data->pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
res_OPEN4.status = NFS4ERR_ACCESS;
return res_OPEN4.status;
}
openflags = FSAL_O_RDONLY;
}
/* Same check on write */
if(arg_OPEN4.share_access & OPEN4_SHARE_ACCESS_WRITE)
{
if(cache_inode_access(pentry_newfile,
FSAL_W_OK,
data->ht,
data->pclient,
data->pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
res_OPEN4.status = NFS4ERR_ACCESS;
return res_OPEN4.status;
}
openflags = FSAL_O_RDWR;
}
/* Try to find if the same open_owner already has acquired a stateid for this file */
pstate_found_iterate = NULL;
pstate_previous_iterate = NULL;
do
{
cache_inode_state_iterate(pentry_newfile,
&pstate_found_iterate,
pstate_previous_iterate,
data->pclient, data->pcontext, &cache_status);
if(cache_status == CACHE_INODE_STATE_ERROR)
break; /* Get out of the loop */
if(cache_status == CACHE_INODE_INVALID_ARGUMENT)
{
res_OPEN4.status = NFS4ERR_INVAL;
return res_OPEN4.status;
}
/* Check is open_owner is the same */
if(pstate_found_iterate != NULL)
{
if((pstate_found_iterate->state_type == CACHE_INODE_STATE_SHARE) &&
(pstate_found_iterate->powner->clientid == arg_OPEN4.owner.clientid)
&&
((pstate_found_iterate->powner->owner_len ==
arg_OPEN4.owner.owner.owner_len)
&&
(!memcmp
(arg_OPEN4.owner.owner.owner_val,
pstate_found_iterate->powner->owner_val,
pstate_found_iterate->powner->owner_len))))
{
/* We'll be re-using the found state */
pstate_found_same_owner = pstate_found_iterate;
}
else
{
/* This is a different owner, check for possible conflicts */
if(memcmp(arg_OPEN4.owner.owner.owner_val,
pstate_found_iterate->powner->owner_val,
pstate_found_iterate->powner->owner_len))
{
switch (pstate_found_iterate->state_type)
{
case CACHE_INODE_STATE_SHARE:
if((pstate_found_iterate->state_data.share.
share_access & OPEN4_SHARE_ACCESS_WRITE)
&& (arg_OPEN4.share_deny & OPEN4_SHARE_DENY_WRITE))
{
res_OPEN4.status = NFS4ERR_SHARE_DENIED;
return res_OPEN4.status;
}
break;
}
}
}
/* In all cases opening in read access a read denied file or write access to a write denied file
* should fail, even if the owner is the same, see discussion in 14.2.16 and 8.9 */
if(pstate_found_iterate->state_type == CACHE_INODE_STATE_SHARE)
{
/* deny read access on read denied file */
if((pstate_found_iterate->state_data.share.
share_deny & OPEN4_SHARE_DENY_READ)
&& (arg_OPEN4.share_access & OPEN4_SHARE_ACCESS_READ))
{
/* Seqid has to be incremented even in this case */
P(powner->lock);
powner->seqid += 1;
V(powner->lock);
powner->seqid += 1;
res_OPEN4.status = NFS4ERR_SHARE_DENIED;
return res_OPEN4.status;
}
/* deny write access on write denied file */
if((pstate_found_iterate->state_data.share.
share_deny & OPEN4_SHARE_DENY_WRITE)
&& (arg_OPEN4.share_access & OPEN4_SHARE_ACCESS_WRITE))
{
/* Seqid has to be incremented even in this case */
P(powner->lock);
powner->seqid += 1;
V(powner->lock);
res_OPEN4.status = NFS4ERR_SHARE_DENIED;
return res_OPEN4.status;
}
}
}
/* if( pstate_found_iterate != NULL ) */
pstate_previous_iterate = pstate_found_iterate;
}
while(pstate_found_iterate != NULL);
if(pstate_found_same_owner != NULL)
{
pfile_state = pstate_found_same_owner;
pfile_state->seqid += 1;
P(powner->lock);
powner->seqid += 1;
V(powner->lock);
}
else
{
/* Set the state for the related file */
/* Prepare state management structure */
candidate_type = CACHE_INODE_STATE_SHARE;
candidate_data.share.share_deny = arg_OPEN4.share_deny;
candidate_data.share.share_access = arg_OPEN4.share_access;
if(cache_inode_add_state(pentry_newfile,
candidate_type,
&candidate_data,
powner,
data->pclient,
data->pcontext,
&pfile_state,
&cache_status) != CACHE_INODE_SUCCESS)
{
/* Seqid has to be incremented even in this case */
P(powner->lock);
powner->seqid += 1;
V(powner->lock);
res_OPEN4.status = NFS4ERR_SHARE_DENIED;
return res_OPEN4.status;
}
}
/* Open the file */
if(cache_inode_open_by_name(pentry_parent,
&filename,
pentry_newfile,
data->pclient,
openflags,
data->pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
/* Seqid has to be incremented even in this case */
P(powner->lock);
powner->seqid += 1;
V(powner->lock);
res_OPEN4.status = NFS4ERR_ACCESS;
return res_OPEN4.status;
}
break;
default:
/* Seqid has to be incremented even in this case */
if(powner != NULL)
{
P(powner->lock);
powner->seqid += 1;
V(powner->lock);
}
res_OPEN4.status = NFS4ERR_INVAL;
return res_OPEN4.status;
break;
} /* switch( arg_OPEN4.openhow.opentype ) */
break;
case CLAIM_PREVIOUS:
break;
default:
/* Seqid has to be incremented even in this case */
if(powner != NULL)
{
P(powner->lock);
powner->seqid += 1;
V(powner->lock);
}
res_OPEN4.status = NFS4ERR_INVAL;
return res_OPEN4.status;
break;
} /* switch( arg_OPEN4.claim.claim ) */
/* Now produce the filehandle to this file */
if((pnewfsal_handle =
cache_inode_get_fsal_handle(pentry_newfile, &cache_status)) == NULL)
{
res_OPEN4.status = nfs4_Errno(cache_status);
return res_OPEN4.status;
}
/* Allocation of a new file handle */
if((rc = nfs4_AllocateFH(&newfh4)) != NFS4_OK)
{
res_OPEN4.status = rc;
return res_OPEN4.status;
}
/* Building a new fh */
if(!nfs4_FSALToFhandle(&newfh4, pnewfsal_handle, data))
{
res_OPEN4.status = NFS4ERR_SERVERFAULT;
return res_OPEN4.status;
}
/* This new fh replaces the current FH */
data->currentFH.nfs_fh4_len = newfh4.nfs_fh4_len;
memcpy(data->currentFH.nfs_fh4_val, newfh4.nfs_fh4_val, newfh4.nfs_fh4_len);
data->current_entry = pentry_newfile;
data->current_filetype = REGULAR_FILE;
/* No do not need newfh any more */
Mem_Free((char *)newfh4.nfs_fh4_val);
/* Status of parent directory after the operation */
if((cache_status = cache_inode_getattr(pentry_parent,
&attr_parent,
data->ht,
data->pclient,
data->pcontext,
&cache_status)) != CACHE_INODE_SUCCESS)
{
res_OPEN4.status = nfs4_Errno(cache_status);
return res_OPEN4.status;
}
res_OPEN4.OPEN4res_u.resok4.attrset.bitmap4_len = 2;
if((res_OPEN4.OPEN4res_u.resok4.attrset.bitmap4_val =
(uint32_t *) Mem_Alloc(res_OPEN4.OPEN4res_u.resok4.attrset.bitmap4_len *
sizeof(uint32_t))) == NULL)
{
res_OPEN4.status = NFS4ERR_SERVERFAULT;
return res_OPEN4.status;
}
res_OPEN4.OPEN4res_u.resok4.attrset.bitmap4_val[0] = 0; /* No Attributes set */
res_OPEN4.OPEN4res_u.resok4.attrset.bitmap4_val[1] = 0; /* No Attributes set */
if(arg_OPEN4.openhow.opentype == OPEN4_CREATE)
{
tmp_int = 2;
tmp_attr[0] = FATTR4_SIZE;
tmp_attr[1] = FATTR4_MODE;
nfs4_list_to_bitmap4(&(res_OPEN4.OPEN4res_u.resok4.attrset), &tmp_int, tmp_attr);
res_OPEN4.OPEN4res_u.resok4.attrset.bitmap4_len = 2;
}
res_OPEN4.OPEN4res_u.resok4.cinfo.after =
(changeid4) pentry_parent->internal_md.mod_time;
res_OPEN4.OPEN4res_u.resok4.cinfo.atomic = TRUE;
res_OPEN4.OPEN4res_u.resok4.stateid.seqid = powner->seqid;
memcpy(res_OPEN4.OPEN4res_u.resok4.stateid.other, pfile_state->stateid_other, 12);
/* No delegation */
res_OPEN4.OPEN4res_u.resok4.delegation.delegation_type = OPEN_DELEGATE_NONE;
res_OPEN4.OPEN4res_u.resok4.rflags = OPEN4_RESULT_LOCKTYPE_POSIX;
/* regular exit */
res_OPEN4.status = NFS4_OK;
return res_OPEN4.status;
} /* nfs41_op_open */
/**
* nfs4_op_readdir: The NFS4_OP_READDIR.
*
* Implements the NFS4_OP_READDIR. If fh is a pseudo FH, then call is routed to routine nfs4_op_readdir_pseudo
*
* @param op [IN] pointer to nfs4_op arguments
* @param data [INOUT] Pointer to the compound request's data
* @param resp [IN] Pointer to nfs4_op results
*
* @return NFS4_OK if ok, any other value show an error.
*
*/
int nfs4_op_readdir(struct nfs_argop4 *op,
compound_data_t * data, struct nfs_resop4 *resp)
{
cache_entry_t *dir_pentry = NULL;
cache_entry_t *pentry = NULL;
cache_inode_endofdir_t eod_met;
fsal_attrib_list_t attrlookup;
cache_inode_status_t cache_status;
cache_inode_status_t cache_status_attr;
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_readdir";
unsigned long dircount;
unsigned long maxcount;
entry4 *entry_nfs_array;
cache_inode_dir_entry_t *dirent_array;
verifier4 cookie_verifier;
unsigned int cookie = 0;
unsigned int end_cookie = 0;
unsigned int *cookie_array;
fsal_handle_t *entry_FSALhandle;
nfs_fh4 entryFH;
char val_fh[NFS4_FHSIZE];
entry_name_array_item_t *entry_name_array;
unsigned long space_used;
unsigned int estimated_num_entries;
unsigned int num_entries;
unsigned int i = 0;
bitmap4 RdAttrErrorBitmap;
attrlist4 RdAttrErrorVals;
resp->resop = NFS4_OP_READDIR;
res_READDIR4.status = NFS4_OK;
entryFH.nfs_fh4_len = 0;
entryFH.nfs_fh4_val = val_fh;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_READDIR4.status = NFS4ERR_NOFILEHANDLE;
return res_READDIR4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_READDIR4.status = NFS4ERR_BADHANDLE;
return res_READDIR4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_READDIR4.status = NFS4ERR_FHEXPIRED;
return res_READDIR4.status;
}
/* Pseudo Fs management */
if(nfs4_Is_Fh_Pseudo(&(data->currentFH)))
return nfs4_op_readdir_pseudo(op, data, resp);
/* Xattrs management */
if(nfs4_Is_Fh_Xattr(&(data->currentFH)))
return nfs4_op_readdir_xattr(op, data, resp);
/* You can readdir only within a directory */
dir_pentry = data->current_entry;
if(data->current_filetype != DIR_BEGINNING && data->current_filetype != DIR_CONTINUE)
{
res_READDIR4.status = NFS4ERR_NOTDIR;
return res_READDIR4.status;
}
/* get the caracteristic value for readdir operation */
dircount = arg_READDIR4.dircount;
maxcount = arg_READDIR4.maxcount;
cookie = (unsigned int)arg_READDIR4.cookie;
space_used = sizeof(entry4);
/* dircount is considered meaningless by many nfsv4 client (like the CITI one). we use maxcount instead */
estimated_num_entries = maxcount / sizeof(entry4); /* Estimated_num_entries is probably far too big */
LogFullDebug(COMPONENT_NFS_V4,
"--- nfs4_op_readdir ---> dircount=%u maxcount=%u arg_cookie=%llu cookie=%d estimated_num_entries=%u\n",
dircount, maxcount, arg_READDIR4.cookie, cookie, estimated_num_entries);
/* Do not use a cookie of 1 or 2 (reserved values) */
if(cookie == 1 || cookie == 2)
{
res_READDIR4.status = NFS4ERR_BAD_COOKIE;
return res_READDIR4.status;
}
if(cookie != 0)
cookie = cookie - 2; /* 0,1 and 2 are reserved, there is a delta of '3' because of this */
/* Get only attributes that are allowed to be read */
if(!nfs4_Fattr_Check_Access_Bitmap(&arg_READDIR4.attr_request, FATTR4_ATTR_READ))
{
res_READDIR4.status = NFS4ERR_INVAL;
return res_READDIR4.status;
}
/* If maxcount is too short, return NFS4ERR_TOOSMALL */
if(maxcount < sizeof(entry4) || estimated_num_entries == 0)
{
res_READDIR4.status = NFS4ERR_TOOSMALL;
return res_READDIR4.status;
}
/*
* If cookie verifier is used, then an non-trivial value is
* returned to the client This value is the mtime of
* the pentry. If verifier is unused (as in many NFS
* Servers) then only a set of zeros is returned (trivial
* value)
*/
memset(cookie_verifier, 0, NFS4_VERIFIER_SIZE);
if(data->pexport->UseCookieVerifier == 1)
memcpy(cookie_verifier, &dir_pentry->internal_md.mod_time, sizeof(time_t));
/* Cookie delivered by the server and used by the client SHOULD not ne 0, 1 or 2 (cf RFC3530, page192)
* because theses value are reserved for special use.
* 0 - cookie for first READDIR
* 1 - reserved for . on client handside
* 2 - reserved for .. on client handside
* Entries '.' and '..' are not returned also
* For these reason, there will be an offset of 3 between NFS4 cookie and HPSS cookie */
if((cookie != 0) && (data->pexport->UseCookieVerifier == 1))
{
if(memcmp(cookie_verifier, arg_READDIR4.cookieverf, NFS4_VERIFIER_SIZE) != 0)
{
res_READDIR4.status = NFS4ERR_BAD_COOKIE;
return res_READDIR4.status;
}
}
/* The default behaviour is to consider that eof is not reached, the returned values by cache_inode_readdir
* will let us know if eod was reached or not */
res_READDIR4.READDIR4res_u.resok4.reply.eof = FALSE;
/* Get prepared for readdir */
if((dirent_array =
(cache_inode_dir_entry_t *) Mem_Alloc(estimated_num_entries *
sizeof(cache_inode_dir_entry_t))) == NULL)
{
res_READDIR4.status = NFS4ERR_SERVERFAULT;
return res_READDIR4.status;
}
if((cookie_array =
(unsigned int *)Mem_Alloc(estimated_num_entries * sizeof(unsigned int))) == NULL)
{
Mem_Free((char *)dirent_array);
res_READDIR4.status = NFS4ERR_SERVERFAULT;
return res_READDIR4.status;
}
/* Perform the readdir operation */
if(cache_inode_readdir(dir_pentry,
cookie,
estimated_num_entries,
&num_entries,
&end_cookie,
&eod_met,
dirent_array,
cookie_array,
data->ht,
data->pclient,
data->pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
res_READDIR4.status = nfs4_Errno(cache_status);
return res_READDIR4.status;
}
/* For an empty directory, we will find only . and .., so reply af if the end if reached */
if(num_entries == 0)
{
/* only . and .. */
res_READDIR4.READDIR4res_u.resok4.reply.entries = NULL;
res_READDIR4.READDIR4res_u.resok4.reply.eof = TRUE;
memcpy(res_READDIR4.READDIR4res_u.resok4.cookieverf, cookie_verifier,
NFS4_VERIFIER_SIZE);
}
else
{
/* Allocation of reply structures */
if((entry_name_array =
(entry_name_array_item_t *) Mem_Alloc(num_entries *
(FSAL_MAX_NAME_LEN + 1))) == NULL)
{
LogError(COMPONENT_NFS_V4, ERR_SYS, ERR_MALLOC, errno);
res_READDIR4.status = NFS4ERR_SERVERFAULT;
return res_READDIR4.status;
}
memset((char *)entry_name_array, 0, num_entries * (FSAL_MAX_NAME_LEN + 1));
if((entry_nfs_array = (entry4 *) Mem_Alloc(num_entries * sizeof(entry4))) == NULL)
{
LogError(COMPONENT_NFS_V4, ERR_SYS, ERR_MALLOC, errno);
res_READDIR4.status = NFS4ERR_SERVERFAULT;
return res_READDIR4.status;
}
for(i = 0; i < num_entries; i++)
{
entry_nfs_array[i].name.utf8string_val = entry_name_array[i];
if(str2utf8(dirent_array[i].name.name, &entry_nfs_array[i].name) == -1)
{
res_READDIR4.status = NFS4ERR_SERVERFAULT;
return res_READDIR4.status;
}
/* Set the cookie value */
if(i != num_entries - 1)
entry_nfs_array[i].cookie = cookie_array[i + 1] + 2; /* 0, 1 and 2 are reserved */
else
entry_nfs_array[i].cookie = end_cookie + 2;
LogFullDebug(COMPONENT_NFS_V4, " === nfs4_op_readdir ===> i=%d name=%s cookie=%llu\n",
i, dirent_array[i].name.name, entry_nfs_array[i].cookie);
/* Get the pentry for the object's attributes and filehandle */
if((pentry = cache_inode_lookup(dir_pentry,
&dirent_array[i].name,
&attrlookup,
data->ht,
data->pclient,
data->pcontext, &cache_status)) == NULL)
{
Mem_Free((char *)entry_nfs_array);
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
/* Return the fattr4_rdattr_error , cf RFC3530, page 192 */
entry_nfs_array[i].attrs.attrmask = RdAttrErrorBitmap;
entry_nfs_array[i].attrs.attr_vals = RdAttrErrorVals;
res_READDIR4.status = NFS4ERR_SERVERFAULT;
return res_READDIR4.status;
}
/* If file handle is asked in the attributes, provide it */
if(arg_READDIR4.attr_request.bitmap4_val != NULL
&& (arg_READDIR4.attr_request.bitmap4_val[0] & FATTR4_FILEHANDLE))
{
if((entry_FSALhandle =
cache_inode_get_fsal_handle(pentry, &cache_status_attr)) == NULL)
{
/* Faulty Handle or pentry */
Mem_Free((char *)entry_nfs_array);
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
res_READDIR4.status = NFS4ERR_SERVERFAULT;
return res_READDIR4.status;
}
if(!nfs4_FSALToFhandle(&entryFH, entry_FSALhandle, data))
{
/* Faulty type */
Mem_Free((char *)entry_nfs_array);
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
res_READDIR4.status = NFS4ERR_SERVERFAULT;
return res_READDIR4.status;
}
}
if(nfs4_FSALattr_To_Fattr(data->pexport,
&attrlookup,
&(entry_nfs_array[i].attrs),
data, &entryFH, &(arg_READDIR4.attr_request)) != 0)
{
/* Return the fattr4_rdattr_error , cf RFC3530, page 192 */
entry_nfs_array[i].attrs.attrmask = RdAttrErrorBitmap;
entry_nfs_array[i].attrs.attr_vals = RdAttrErrorVals;
}
/* Chain the entries together */
entry_nfs_array[i].nextentry = NULL;
if(i != 0)
entry_nfs_array[i - 1].nextentry = &(entry_nfs_array[i]);
/* This test is there to avoid going further than the buffer provided by the client
* the factor "9/10" is there for safety. Its value could be change as beta tests will be done */
if((caddr_t)
((caddr_t) (&entry_nfs_array[i]) - (caddr_t) (&entry_nfs_array[0])) >
(caddr_t) (maxcount * 9 / 10))
break;
} /* for i */
if((eod_met == END_OF_DIR) && (i == num_entries))
{
/* This is the end of the directory */
res_READDIR4.READDIR4res_u.resok4.reply.eof = TRUE;
memcpy(res_READDIR4.READDIR4res_u.resok4.cookieverf, cookie_verifier,
NFS4_VERIFIER_SIZE);
}
/* Put the entry's list in the READDIR reply */
res_READDIR4.READDIR4res_u.resok4.reply.entries = entry_nfs_array;
}
/* Do not forget to set the verifier */
memcpy((char *)res_READDIR4.READDIR4res_u.resok4.cookieverf, cookie_verifier,
NFS4_VERIFIER_SIZE);
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
res_READDIR4.status = NFS4_OK;
return res_READDIR4.status;
} /* nfs4_op_readdir */
int nfs3_Readdirplus(nfs_arg_t * parg,
exportlist_t * pexport,
fsal_op_context_t * pcontext,
cache_inode_client_t * pclient,
hash_table_t * ht, struct svc_req *preq, nfs_res_t * pres)
{
static char __attribute__ ((__unused__)) funcName[] = "nfs3_Readdirplus";
typedef char entry_name_array_item_t[FSAL_MAX_NAME_LEN];
typedef char fh3_buffer_item_t[NFS3_FHSIZE];
unsigned int delta = 0;
cache_entry_t *dir_pentry = NULL;
cache_entry_t *pentry_dot_dot = NULL;
unsigned long dircount;
unsigned long maxcount;
fsal_attrib_list_t dir_attr;
fsal_attrib_list_t entry_attr;
unsigned int begin_cookie;
unsigned int end_cookie;
unsigned int cache_inode_cookie;
cache_inode_dir_entry_t *dirent_array = NULL;
unsigned int *cookie_array = NULL;
cookieverf3 cookie_verifier;
int rc;
unsigned int i = 0;
unsigned int num_entries;
unsigned long space_used;
unsigned long estimated_num_entries;
unsigned long asked_num_entries;
cache_inode_file_type_t dir_filetype;
cache_inode_endofdir_t eod_met = UNASSIGNED_EOD;
cache_inode_status_t cache_status;
cache_inode_status_t cache_status_gethandle;
fsal_handle_t *pfsal_handle = NULL;
entry_name_array_item_t *entry_name_array = NULL;
fh3_buffer_item_t *fh3_array = NULL;
/* to avoid setting it on each error case */
pres->res_readdir3.READDIR3res_u.resfail.dir_attributes.attributes_follow = FALSE;
dircount = parg->arg_readdirplus3.dircount;
maxcount = parg->arg_readdirplus3.maxcount;
begin_cookie = (unsigned int)parg->arg_readdirplus3.cookie;
space_used = sizeof(READDIRPLUS3resok);
estimated_num_entries = dircount / sizeof(entryplus3);
LogFullDebug(COMPONENT_NFS_READDIR,
"---> nfs3_Readdirplus: dircount=%d maxcount=%d begin_cookie=%d space_used=%d estimated_num_entries=%d\n",
dircount, maxcount, begin_cookie, space_used, estimated_num_entries);
/* Is this a xattr FH ? */
if(nfs3_Is_Fh_Xattr(&(parg->arg_readdirplus3.dir)))
return nfs3_Readdirplus_Xattr(parg, pexport, pcontext, pclient, ht, preq, pres);
/* Convert file handle into a vnode */
/* BUGAZOMEU : rajouter acces direct au DIR_CONTINUE */
if((dir_pentry = nfs_FhandleToCache(preq->rq_vers,
NULL,
&(parg->arg_readdirplus3.dir),
NULL,
NULL,
&(pres->res_readdirplus3.status),
NULL,
&dir_attr, pcontext, pclient, ht, &rc)) == NULL)
{
/* return NFS_REQ_DROP ; */
return rc;
}
/* Extract the filetype */
dir_filetype = cache_inode_fsal_type_convert(dir_attr.type);
/* Sanity checks -- must be a directory */
if((dir_filetype != DIR_BEGINNING) && (dir_filetype != DIR_CONTINUE))
{
pres->res_readdirplus3.status = NFS3ERR_NOTDIR;
return NFS_REQ_OK;
}
/* switch */
memset(cookie_verifier, 0, sizeof(cookieverf3));
/*
* If cookie verifier is used, then an non-trivial value is
* returned to the client This value is the mtime of
* the directory. If verifier is unused (as in many NFS
* Servers) then only a set of zeros is returned (trivial
* value)
*/
if(pexport->UseCookieVerifier)
memcpy(cookie_verifier, &(dir_attr.mtime), sizeof(dir_attr.mtime));
/*
* nothing to do if != 0 because the area is already full of
* zero
*/
if(pexport->UseCookieVerifier && (begin_cookie != 0))
{
/*
* Not the first call, so we have to check the cookie
* verifier
*/
if(memcmp(cookie_verifier, parg->arg_readdirplus3.cookieverf, NFS3_COOKIEVERFSIZE)
!= 0)
{
pres->res_readdirplus3.status = NFS3ERR_BAD_COOKIE;
return NFS_REQ_OK;
}
}
#ifdef _DEBUG_MEMLEAKS
/* For debugging memory leaks */
BuddySetDebugLabel("cache_inode_dir_entry_t in nfs3_Readdirplus");
#endif
if((dirent_array =
(cache_inode_dir_entry_t *) Mem_Alloc(estimated_num_entries *
sizeof(cache_inode_dir_entry_t))) == NULL)
{
pres->res_readdirplus3.status = NFS3ERR_IO;
return NFS_REQ_DROP;
}
#ifdef _DEBUG_MEMLEAKS
/* For debugging memory leaks */
BuddySetDebugLabel("cookie array in nfs3_Readdirplus");
#endif
if((cookie_array =
(unsigned int *)Mem_Alloc(estimated_num_entries * sizeof(unsigned int))) == NULL)
{
Mem_Free((char *)dirent_array);
pres->res_readdirplus3.status = NFS3ERR_IO;
return NFS_REQ_DROP;
}
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries = NULL;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.eof = FALSE;
/* How many entries will we retry from cache_inode ? */
if(begin_cookie > 1)
{
asked_num_entries = estimated_num_entries;
cache_inode_cookie = begin_cookie - 2;
}
else
{
asked_num_entries = ((estimated_num_entries > 2) ? estimated_num_entries - 2 : 0); /* Keep space for '.' and '..' */
cache_inode_cookie = 0;
}
/* A definition that will be very useful to avoid very long names for variables */
#define RES_READDIRPLUS_REPLY pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply
/* Call readdir */
if(cache_inode_readdir(dir_pentry,
cache_inode_cookie,
asked_num_entries,
&num_entries,
&end_cookie,
&eod_met,
dirent_array,
cookie_array,
ht, pclient, pcontext, &cache_status) == CACHE_INODE_SUCCESS)
{
LogFullDebug(COMPONENT_NFS_READDIR,
"-- Readdirplus3 -> Call to cache_inode_readdir( cookie=%d, asked=%d ) -> num_entries = %d\n",
cache_inode_cookie, asked_num_entries, num_entries);
if(eod_met == END_OF_DIR)
{
LogFullDebug(COMPONENT_NFS_READDIR, "+++++++++++++++++++++++++++++++++++++++++> EOD MET \n");
}
/* If nothing was found, return nothing, but if cookie=0, we should return . and .. */
if((num_entries == 0) && (asked_num_entries != 0) && (begin_cookie > 1))
{
pres->res_readdirplus3.status = NFS3_OK;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries = NULL;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.eof = TRUE;
nfs_SetPostOpAttr(pcontext, pexport,
dir_pentry,
NULL,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resok.
dir_attributes));
memcpy(pres->res_readdirplus3.READDIRPLUS3res_u.resok.cookieverf,
cookie_verifier, sizeof(cookieverf3));
}
else
{
#ifdef _DEBUG_MEMLEAKS
/* For debugging memory leaks */
BuddySetDebugLabel("entry_name_array in nfs3_Readdirplus");
#endif
/* Allocation of the structure for reply */
entry_name_array =
(entry_name_array_item_t *) Mem_Alloc(estimated_num_entries *
(FSAL_MAX_NAME_LEN + 1));
if(entry_name_array == NULL)
{
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
return NFS_REQ_DROP;
}
#ifdef _DEBUG_MEMLEAKS
/* For debugging memory leaks */
BuddySetDebugLabel("READDIRPLUS3res_u.resok.reply.entries");
#endif
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries =
(entryplus3 *) Mem_Alloc(estimated_num_entries * sizeof(entryplus3));
if(pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries == NULL)
{
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
Mem_Free((char *)entry_name_array);
return NFS_REQ_DROP;
}
/* Allocation of the file handles */
#ifdef _DEBUG_MEMLEAKS
/* For debugging memory leaks */
BuddySetDebugLabel("Filehandle V3 in nfs3_Readdirplus");
#endif
fh3_array =
(fh3_buffer_item_t *) Mem_Alloc(estimated_num_entries * NFS3_FHSIZE);
#ifdef _DEBUG_MEMLEAKS
/* For debugging memory leaks */
BuddySetDebugLabel("N/A");
#endif
if(fh3_array == NULL)
{
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
Mem_Free((char *)entry_name_array);
return NFS_REQ_DROP;
}
delta = 0;
/* manage . and .. */
if(begin_cookie == 0)
{
/* Fill in '.' */
if(estimated_num_entries > 0)
{
if((pfsal_handle = cache_inode_get_fsal_handle(dir_pentry,
&cache_status_gethandle))
== NULL)
{
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = nfs3_Errno(cache_status_gethandle);
return NFS_REQ_OK;
}
FSAL_DigestHandle(FSAL_GET_EXP_CTX(pcontext),
FSAL_DIGEST_FILEID3,
pfsal_handle,
(caddr_t) & (RES_READDIRPLUS_REPLY.entries[0].
fileid));
RES_READDIRPLUS_REPLY.entries[0].name = entry_name_array[0];
strcpy(RES_READDIRPLUS_REPLY.entries[0].name, ".");
RES_READDIRPLUS_REPLY.entries[0].cookie = 1;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[0].
name_handle.post_op_fh3_u.handle.data.data_val =
(char *)fh3_array[0];
if(nfs3_FSALToFhandle
(&pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[0].
name_handle.post_op_fh3_u.handle, pfsal_handle, pexport) == 0)
{
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = NFS3ERR_BADHANDLE;
return NFS_REQ_OK;
}
RES_READDIRPLUS_REPLY.entries[0].name_attributes.attributes_follow =
FALSE;
RES_READDIRPLUS_REPLY.entries[0].name_handle.handle_follows = FALSE;
cache_inode_get_attributes(dir_pentry, &entry_attr);
/* Set PostPoFh3 structure */
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[0].
name_handle.handle_follows = TRUE;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[0].
name_handle.post_op_fh3_u.handle.data.data_len =
sizeof(file_handle_v3_t);
nfs_SetPostOpAttr(pcontext, pexport,
dir_pentry,
&entry_attr,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resok.
reply.entries[0].name_attributes));
delta += 1;
}
}
/* Fill in '..' */
if(begin_cookie <= 1)
{
if(estimated_num_entries > delta)
{
if((pentry_dot_dot = cache_inode_lookupp(dir_pentry,
ht,
pclient,
pcontext,
&cache_status_gethandle)) ==
NULL)
{
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = nfs3_Errno(cache_status_gethandle);
return NFS_REQ_OK;
}
if((pfsal_handle = cache_inode_get_fsal_handle(pentry_dot_dot,
&cache_status_gethandle))
== NULL)
{
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = nfs3_Errno(cache_status_gethandle);
return NFS_REQ_OK;
}
FSAL_DigestHandle(FSAL_GET_EXP_CTX(pcontext),
FSAL_DIGEST_FILEID3,
pfsal_handle,
(caddr_t) & (RES_READDIRPLUS_REPLY.entries[delta].
fileid));
RES_READDIRPLUS_REPLY.entries[delta].name = entry_name_array[delta];
strcpy(RES_READDIRPLUS_REPLY.entries[delta].name, "..");
/* Getting a file handle */
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[delta].
name_handle.post_op_fh3_u.handle.data.data_val =
(char *)fh3_array[delta];
if(nfs3_FSALToFhandle
(&pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[0].
name_handle.post_op_fh3_u.handle, pfsal_handle, pexport) == 0)
{
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = NFS3ERR_BADHANDLE;
return NFS_REQ_OK;
}
RES_READDIRPLUS_REPLY.entries[delta].cookie = 2;
RES_READDIRPLUS_REPLY.entries[delta].name_attributes.attributes_follow =
FALSE;
RES_READDIRPLUS_REPLY.entries[delta].name_handle.handle_follows = FALSE;
cache_inode_get_attributes(pentry_dot_dot, &entry_attr);
/* Set PostPoFh3 structure */
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[delta].
name_handle.handle_follows = TRUE;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[delta].
name_handle.post_op_fh3_u.handle.data.data_len =
sizeof(file_handle_v3_t);
nfs_SetPostOpAttr(pcontext, pexport,
pentry_dot_dot,
&entry_attr,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resok.
reply.entries[delta].name_attributes));
}
RES_READDIRPLUS_REPLY.entries[0].nextentry =
&(RES_READDIRPLUS_REPLY.entries[delta]);
if(num_entries > delta + 1) /* not 0 ??? */
RES_READDIRPLUS_REPLY.entries[delta].nextentry =
&(RES_READDIRPLUS_REPLY.entries[delta + 1]);
else
RES_READDIRPLUS_REPLY.entries[delta].nextentry = NULL;
delta += 1;
}
/* if( begin_cookie == 0 ) */
for(i = delta; i < num_entries + delta; i++)
{
unsigned long needed;
/* dircount is the size without the FH and attributes overhead, so entry3 is used intead of entryplus3 */
needed =
sizeof(entry3) + ((strlen(dirent_array[i - delta].name.name) + 3) & ~3);
/* LogFullDebug(COMPONENT_NFS_READDIR, "==============> i=%d sizeof(entryplus3)=%d needed=%d space_used=%d maxcount=%d num_entries=%d asked_num_entries=%d\n",
i, sizeof( entryplus3 ), needed, space_used, maxcount, num_entries, asked_num_entries ) ; */
if((space_used += needed) > maxcount)
{
if(i == delta)
{
/*
* Not enough room to make even a single reply
*/
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = NFS3ERR_TOOSMALL;
return NFS_REQ_OK;
}
break; /* Make post traitement */
}
/*
* Get information specific to this entry
*/
if((pfsal_handle =
cache_inode_get_fsal_handle(dirent_array[i - delta].pentry,
&cache_status_gethandle)) == NULL)
{
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = nfs3_Errno(cache_status_gethandle);
return NFS_REQ_OK;
}
/* Now fill in the replyed entryplus3 list */
FSAL_DigestHandle(FSAL_GET_EXP_CTX(pcontext),
FSAL_DIGEST_FILEID3,
pfsal_handle,
(caddr_t) & (RES_READDIRPLUS_REPLY.entries[i].fileid));
FSAL_name2str(&dirent_array[i - delta].name, entry_name_array[i],
FSAL_MAX_NAME_LEN);
RES_READDIRPLUS_REPLY.entries[i].name = entry_name_array[i];
if(i != num_entries + delta - 1)
RES_READDIRPLUS_REPLY.entries[i].cookie = cookie_array[i + 1 - delta] + 2;
else
RES_READDIRPLUS_REPLY.entries[i].cookie = end_cookie + 2;
RES_READDIRPLUS_REPLY.entries[i].name_attributes.attributes_follow = FALSE;
RES_READDIRPLUS_REPLY.entries[i].name_handle.handle_follows = FALSE;
cache_inode_get_attributes(dirent_array[i - delta].pentry, &entry_attr);
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[i].name_handle.
post_op_fh3_u.handle.data.data_val = (char *)fh3_array[i];
/* Compute the NFSv3 file handle */
if(nfs3_FSALToFhandle
(&pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[i].
name_handle.post_op_fh3_u.handle, pfsal_handle, pexport) == 0)
{
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
pres->res_readdirplus3.status = NFS3ERR_BADHANDLE;
return NFS_REQ_OK;
}
LogFullDebug(COMPONENT_NFS_READDIR,
"-- Readdirplus3 -> i=%d num_entries=%d needed=%d space_used=%lu maxcount=%lu Name=%s FileId=%llu Cookie=%llu\n",
i, num_entries, needed, space_used, maxcount,
dirent_array[i - delta].name.name,
RES_READDIRPLUS_REPLY.entries[i].fileid,
RES_READDIRPLUS_REPLY.entries[i].cookie);
/* Set PostPoFh3 structure */
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[i].name_handle.
handle_follows = TRUE;
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.entries[i].name_handle.
post_op_fh3_u.handle.data.data_len = sizeof(file_handle_v3_t);
nfs_SetPostOpAttr(pcontext, pexport,
dirent_array[i - delta].pentry,
&entry_attr,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.
entries[i].name_attributes));
RES_READDIRPLUS_REPLY.entries[i].nextentry = NULL;
if(i != 0)
RES_READDIRPLUS_REPLY.entries[i - 1].nextentry =
&(RES_READDIRPLUS_REPLY.entries[i]);
}
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.eof = FALSE;
}
nfs_SetPostOpAttr(pcontext,
pexport,
dir_pentry,
&dir_attr,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resok.dir_attributes));
memcpy(pres->res_readdirplus3.READDIRPLUS3res_u.resok.cookieverf,
cookie_verifier, sizeof(cookieverf3));
pres->res_readdirplus3.status = NFS3_OK;
if((eod_met == END_OF_DIR) && (i == num_entries + delta))
{
/* End of directory */
LogFullDebug(COMPONENT_NFS_READDIR,
"============================================================> EOD MET !!!!!!\n");
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.eof = TRUE;
}
else
pres->res_readdirplus3.READDIRPLUS3res_u.resok.reply.eof = FALSE;
nfs_SetPostOpAttr(pcontext, pexport,
dir_pentry,
&dir_attr,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resok.dir_attributes));
memcpy(pres->res_readdirplus3.READDIRPLUS3res_u.resok.cookieverf, cookie_verifier,
sizeof(cookieverf3));
LogFullDebug(COMPONENT_NFS_READDIR,"============================================================\n");
/* Free the memory */
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
return NFS_REQ_OK;
}
/* If we are here, there was an error */
/* Free the memory */
Mem_Free((char *)dirent_array);
Mem_Free((char *)cookie_array);
Mem_Free((char *)entry_name_array);
Mem_Free((char *)fh3_array);
/* Is this a retryable error */
if(nfs_RetryableError(cache_status))
return NFS_REQ_DROP;
/* Set failed status */
nfs_SetFailedStatus(pcontext, pexport,
NFS_V3,
cache_status,
NULL,
&pres->res_readdirplus3.status,
dir_pentry,
&(pres->res_readdirplus3.READDIRPLUS3res_u.resfail.dir_attributes),
NULL, NULL, NULL, NULL, NULL, NULL);
return NFS_REQ_OK;
} /* nfs3_Readdirplus */
int nfs_Mkdir(nfs_arg_t * parg,
exportlist_t * pexport,
fsal_op_context_t * pcontext,
cache_inode_client_t * pclient,
hash_table_t * ht, struct svc_req *preq, nfs_res_t * pres)
{
static char __attribute__ ((__unused__)) funcName[] = "nfs_Mkdir";
char *str_dir_name = NULL;
fsal_accessmode_t mode = 0;
cache_entry_t *dir_pentry = NULL;
cache_entry_t *parent_pentry = NULL;
int rc = 0;
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;
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, pclient, ht, &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:
*/
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;
}
return NFS_REQ_OK;
}
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,
FSAL_MAX_NAME_LEN,
&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,
pexport->cache_inode_policy,
&attr,
ht,
pclient,
pcontext,
&cache_status_lookup);
if(cache_status_lookup == CACHE_INODE_NOT_FOUND)
{
/* Create the directory */
if((dir_pentry = cache_inode_create(parent_pentry,
&dir_name,
DIRECTORY,
pexport->cache_inode_policy,
mode,
NULL,
&attr,
ht,
pclient,
pcontext, &cache_status)) != NULL)
{
/*
* Get the FSAL handle for this entry
*/
pfsal_handle = cache_inode_get_fsal_handle(dir_pentry, &cache_status);
if(cache_status == CACHE_INODE_SUCCESS)
{
switch (preq->rq_vers)
{
case NFS_V2:
/* Build file handle */
if(!nfs2_FSALToFhandle
(&(pres->res_dirop2.DIROP2res_u.diropok.file), pfsal_handle,
pexport))
pres->res_dirop2.status = NFSERR_IO;
else
{
/*
* Build entry
* attributes
*/
if(nfs2_FSALattr_To_Fattr(pexport, &attr,
&(pres->res_dirop2.DIROP2res_u.
diropok.attributes)) == 0)
pres->res_dirop2.status = NFSERR_IO;
else
pres->res_dirop2.status = NFS_OK;
}
break;
case NFS_V3:
/* Build file handle */
if((pres->res_mkdir3.MKDIR3res_u.resok.obj.post_op_fh3_u.
handle.data.data_val = Mem_Alloc_Label(NFS3_FHSIZE,
"Filehandle V3 in nfs3_mkdir")) == NULL)
{
pres->res_mkdir3.status = NFS3ERR_IO;
return NFS_REQ_OK;
}
if(nfs3_FSALToFhandle
(&pres->res_mkdir3.MKDIR3res_u.resok.obj.post_op_fh3_u.
handle, pfsal_handle, pexport) == 0)
{
Mem_Free((char *)pres->res_mkdir3.MKDIR3res_u.resok.obj.
post_op_fh3_u.handle.data.data_val);
pres->res_mkdir3.status = NFS3ERR_INVAL;
return NFS_REQ_OK;
}
else
{
/* Set Post Op Fh3 structure */
pres->res_mkdir3.MKDIR3res_u.resok.obj.handle_follows =
TRUE;
pres->res_mkdir3.MKDIR3res_u.resok.obj.post_op_fh3_u.handle.
data.data_len = sizeof(file_handle_v3_t);
/*
* Build entry
* attributes
*/
nfs_SetPostOpAttr(pcontext, pexport,
dir_pentry,
&attr,
&(pres->res_mkdir3.MKDIR3res_u.resok.
obj_attributes));
/* Get the attributes of the parent after the operation */
cache_inode_get_attributes(parent_pentry,
&attr_parent_after);
/*
* Build Weak Cache
* Coherency data
*/
nfs_SetWccData(pcontext, pexport,
parent_pentry,
ppre_attr,
&attr_parent_after,
&(pres->res_mkdir3.MKDIR3res_u.resok.
dir_wcc));
pres->res_mkdir3.status = NFS3_OK;
}
break;
}
return NFS_REQ_OK;
}
}
} /* If( cache_status_lookup == CACHE_INODE_NOT_FOUND ) */
else
{
/* object already exists or failure during lookup */
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_mkdir3.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_mkdir3.status = NFS3ERR_INVAL;
break;
}
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_mkdir3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc),
NULL, NULL, NULL);
return NFS_REQ_OK;
}
}
}
/* If we are here, there was an error */
if(nfs_RetryableError(cache_status))
{
return NFS_REQ_DROP;
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_mkdir3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc), NULL, NULL, NULL);
return NFS_REQ_OK;
}
