/* retrieve last informations about a handle */
int fsal_posixdb_GetInodeCache(posixfsal_handle_t * p_handle) /* IN/OUT */
{
#ifdef _ENABLE_CACHE_PATH
unsigned int i;
i = hash_cache_path(p_handle->id, p_handle->ts);
/* in the handle in cache ? */
P_r(&cache_array[i].entry_lock);
if(cache_array[i].is_set
&& cache_array[i].handle.id == p_handle->id
&& cache_array[i].handle.ts == p_handle->ts)
{
if(cache_array[i].info_is_set)
{
p_handle->info = cache_array[i].handle.info;
LogDebug(COMPONENT_FSAL, "fsal_posixdb_GetInodeCache(%u, %u)", (unsigned int)(p_handle->id),
(unsigned int)(p_handle->ts));
V_r(&cache_array[i].entry_lock);
return TRUE;
}
}
V_r(&cache_array[i].entry_lock);
#endif
return FALSE;
}
int fsal_posixdb_GetPathCache(posixfsal_handle_t * p_handle, /* IN */
fsal_path_t * p_path /* OUT */ )
{
#ifdef _ENABLE_CACHE_PATH
unsigned int i;
i = hash_cache_path(p_handle->id, p_handle->ts);
/* in the handle in cache ? */
P_r(&cache_array[i].entry_lock);
if(cache_array[i].is_set
&& cache_array[i].handle.id == p_handle->id
&& cache_array[i].handle.ts == p_handle->ts)
{
if(cache_array[i].path_is_set)
{
/* return path it */
memcpy(p_path, &cache_array[i].path, sizeof(fsal_path_t));
V_r(&cache_array[i].entry_lock);
LogDebug(COMPONENT_FSAL, "fsal_posixdb_GetPathCache(%u, %u)=%s",
(unsigned int)p_handle->id, (unsigned int)p_handle->ts,
p_path->path);
return TRUE;
}
}
V_r(&cache_array[i].entry_lock);
#endif
return FALSE;
}
int HashTable_Get(hash_table_t * ht, hash_buffer_t * buffkey, hash_buffer_t * buffval)
{
unsigned int hashval;
struct rbt_node *pn;
struct rbt_head *tete_rbt;
hash_data_t *pdata = NULL;
int rbt_value = 0;
int rc = 0;
/* Sanity check */
if(ht == NULL || buffkey == NULL || buffval == NULL)
return HASHTABLE_ERROR_INVALID_ARGUMENT;
/* Find the RB Tree to be processed */
hashval = (*(ht->parameter.hash_func_key)) (&ht->parameter, buffkey);
tete_rbt = &(ht->array_rbt[hashval]);
/* Seek into the RB Tree */
rbt_value = (*(ht->parameter.hash_func_rbt)) (&ht->parameter, buffkey);
/* Acquire mutex */
P_r(&(ht->array_lock[hashval]));
/* I get the node with this value that is located on the left (first with this value in the rbtree) */
if((rc = Key_Locate(ht, buffkey, hashval, rbt_value, &pn)) != HASHTABLE_SUCCESS)
{
ht->stat_dynamic[hashval].notfound.nb_get += 1;
V_r(&(ht->array_lock[hashval]));
return rc;
}
/* Key was found */
pdata = (hash_data_t *) RBT_OPAQ(pn);
buffval->pdata = pdata->buffval.pdata;
buffval->len = pdata->buffval.len;
ht->stat_dynamic[hashval].ok.nb_get += 1;
/* Release mutex */
V_r(&(ht->array_lock[hashval]));
return HASHTABLE_SUCCESS;
} /* HashTable_Get */
/**
*
* cache_inode_is_dir_empty_WithLock: checks if a directory is empty or not, BUT has lock management.
*
* Checks if a directory is empty or not, BUT has lock management.
*
* @param pentry [IN] entry to be checked (should be of type DIRECTORY)
*
* @return CACHE_INODE_SUCCESS is directory is empty\n
* @return CACHE_INODE_BAD_TYPE is pentry is not of type DIRECTORY\n
* @return CACHE_INODE_DIR_NOT_EMPTY if pentry is not empty
*
*/
cache_inode_status_t cache_inode_is_dir_empty_WithLock(cache_entry_t * pentry)
{
cache_inode_status_t status;
P_r(&pentry->lock);
status = cache_inode_is_dir_empty(pentry);
V_r(&pentry->lock);
return status;
} /* cache_inode_is_dir_empty_WithLock */
static void nfs4_acls_test()
{
int i = 0;
fsal_acl_data_t acldata;
fsal_ace_t *pace = NULL;
fsal_acl_t *pacl = NULL;
fsal_acl_status_t status;
acldata.naces = 3;
acldata.aces = nfs4_ace_alloc(3);
LogDebug(COMPONENT_NFS_V4_ACL, "&acldata.aces = %p", &acldata.aces);
pace = acldata.aces;
for(i = 0; i < 3; i++)
{
pace->type = i;
pace->perm = i;
pace->flag = i;
pace->who.uid = i;
pace++;
}
pacl = nfs4_acl_new_entry(&acldata, &status);
nfs4_acl_entry_inc_ref(pacl);
P_r(&pacl->lock);
LogDebug(COMPONENT_NFS_V4_ACL, "pacl = %p, ref = %u, status = %u", pacl, pacl->ref, status);
V_r(&pacl->lock);
pacl = nfs4_acl_new_entry(&acldata, &status);
nfs4_acl_entry_inc_ref(pacl);
P_r(&pacl->lock);
LogDebug(COMPONENT_NFS_V4_ACL, "re-access: pacl = %p, ref = %u, status = %u", pacl, pacl->ref, status);
V_r(&pacl->lock);
nfs4_acl_release_entry(pacl, &status);
P_r(&pacl->lock);
LogDebug(COMPONENT_NFS_V4_ACL, "release: pacl = %p, ref = %u, status = %u", pacl, pacl->ref, status);
V_r(&pacl->lock);
nfs4_acl_release_entry(pacl, &status);
}
void *thread_reader(void *arg)
{
int duree_sleep = 1;
int nb_iter = NB_ITER;
while(nb_iter > 0)
{
P_r(&lock);
sleep(duree_sleep);
V_r(&lock);
nb_iter -= 1;
}
OkRead = 1; /* Ecriture concurrente ici, mais on s'en fout (pas d'impact) */
return NULL;
} /* thread_writter */
/**
*
* cache_inode_kill_entry: force removing an entry from the cache_inode. This is used in case of a 'stale' entry.
*
* Force removing an entry from the cache_inode. This is used in case of a 'stale' entry.
*
* @param pentry [IN] the input pentry (supposed to be staled).
* @param locked [IN] tells in the entry was previously locked and how it was locked
* @param ht [INOUT] the related hash table for the cache_inode cache.
* @param pclient [INOUT] related cache_inode client.
* @param pstatus [OUT] status for the operation.
*
* @return CACHE_INODE_BAD_TYPE if pentry is not related a REGULAR_FILE or
* DIRECTORY
* @return CACHE_INODE_SUCCESS if operation succeded.
*
*/
static void free_lock( cache_entry_t * pentry,
cache_inode_lock_how_t lock_how )
{
switch( lock_how )
{
case RD_LOCK:
V_r( &pentry->lock ) ;
break ;
case WT_LOCK:
V_w( &pentry->lock ) ;
break ;
case NO_LOCK:
default:
break ;
}
}
/**
*
* cache_inode_getattr: Gets the attributes for a cached entry.
*
* Gets the attributes for a cached entry. The FSAL attributes are kept in a structure when the entry
* is added to the cache.
*
* @param pentry [IN] entry to be managed.
* @param pattr [OUT] pointer to the results
* @param ht [IN] hash table used for the cache, unused in this call.
* @param pclient [INOUT] ressource allocated by the client for the nfs management.
* @param pcontext [IN] FSAL credentials
* @param pstatus [OUT] returned status.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
* @return CACHE_INODE_LRU_ERROR if allocation error occured when validating the entry
*
*/
cache_inode_status_t
cache_inode_getattr(cache_entry_t * pentry,
fsal_attrib_list_t * pattr,
hash_table_t * ht, /* Unused, kept for protototype's homogeneity */
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus)
{
cache_inode_status_t status;
fsal_handle_t *pfsal_handle;
fsal_status_t fsal_status;
/* sanity check */
if(pentry == NULL || pattr == NULL ||
ht == NULL || pclient == NULL || pcontext == NULL)
{
*pstatus = CACHE_INODE_INVALID_ARGUMENT;
return *pstatus;
}
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stats */
pclient->stat.nb_call_total += 1;
inc_func_call(pclient, CACHE_INODE_GETATTR);
/* Lock the entry */
P_w(&pentry->lock);
status = cache_inode_renew_entry(pentry, pattr, ht,
pclient, pcontext, pstatus);
if(status != CACHE_INODE_SUCCESS)
{
V_w(&pentry->lock);
inc_func_err_retryable(pclient, CACHE_INODE_GETATTR);
return *pstatus;
}
/* RW Lock goes for writer to reader */
rw_lock_downgrade(&pentry->lock);
cache_inode_get_attributes(pentry, pattr);
if(FSAL_TEST_MASK(pattr->asked_attributes,
FSAL_ATTR_RDATTR_ERR))
{
switch (pentry->internal_md.type)
{
case REGULAR_FILE:
pfsal_handle = &pentry->object.file.handle;
break;
case SYMBOLIC_LINK:
pfsal_handle = &pentry->object.symlink.handle;
break;
case DIR_BEGINNING:
pfsal_handle = &pentry->object.dir_begin.handle;
break;
case DIR_CONTINUE:
/*
* lock the related dir_begin (dir begin are garbagge
* collected AFTER their related dir_cont)
* this means that if a DIR_CONTINUE exists,
* its pdir pointer is not endless
*/
P_r(&pentry->object.dir_cont.pdir_begin->lock);
pfsal_handle = &pentry->object.dir_cont.pdir_begin->object.dir_begin.handle;
V_r(&pentry->object.dir_cont.pdir_begin->lock);
break;
case SOCKET_FILE:
case FIFO_FILE:
case BLOCK_FILE:
case CHARACTER_FILE:
pfsal_handle = &pentry->object.special_obj.handle;
break;
}
/*
* An error occured when trying to get
* the attributes, they have to be renewed
*/
fsal_status = FSAL_getattrs(pfsal_handle, pcontext, pattr);
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
V_r(&pentry->lock);
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogDebug(COMPONENT_CACHE_INODE_GC,
"cache_inode_getattr: Stale FSAL File "
"Handle detected for pentry = %p",
pentry);
cache_inode_kill_entry(pentry, ht,
pclient, &kill_status);
if(kill_status != CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE_GC,
"cache_inode_getattr: Could not kill "
"entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
/* stat */
inc_func_err_unrecover(pclient, CACHE_INODE_GETATTR);
return *pstatus;
}
/* Set the new attributes */
cache_inode_set_attributes(pentry, pattr);
}
*pstatus = cache_inode_valid(pentry, CACHE_INODE_OP_GET, pclient);
V_r(&pentry->lock);
/* stat */
if(*pstatus != CACHE_INODE_SUCCESS)
inc_func_err_retryable(pclient, CACHE_INODE_GETATTR);
else
inc_func_success(pclient, CACHE_INODE_GETATTR);
return *pstatus;
}
/* Get a possible full path for an entry */
int NamespacePath(ino_t entry, dev_t dev, unsigned int gen, char *path)
{
fsnode_t *p_node;
int rc;
char tmp_path[FSAL_MAX_PATH_LEN];
inode_t curr_inode;
/* initialize paths */
path[0] = '\0';
tmp_path[0] = '\0';
/* lock the namespace read-only */
P_r(&ns_lock);
curr_inode.inum = entry;
curr_inode.dev = dev;
curr_inode.generation = gen;
do
{
/* get entry from hash */
p_node = h_get_node(curr_inode.inum, curr_inode.dev, &rc);
if(!p_node)
{
V_r(&ns_lock);
if(rc == HASHTABLE_ERROR_NO_SUCH_KEY)
{
LogFullDebug(COMPONENT_FSAL, "namespace: %lX.%ld not found", (unsigned long)dev,
(unsigned long)entry);
return ENOENT;
}
else
return EFAULT;
}
else if(p_node->inode.generation != curr_inode.generation)
{
V_r(&ns_lock);
return ESTALE;
}
if(!p_node->parent_list)
{
/* this is the root entry, just add '/' at the begining and return */
LogFullDebug(COMPONENT_FSAL, "namespace: root entry reached");
snprintf(path, FSAL_MAX_PATH_LEN, "/%s", tmp_path);
break;
}
else if(path[0] == '\0')
{
/* nothing in path for the moment, just copy entry name in it */
strncpy(path, p_node->parent_list->name, FSAL_MAX_NAME_LEN);
curr_inode = p_node->parent_list->parent;
}
else
{
/* this is a parent dir, path is now <dirname>/<subpath> */
snprintf(path, FSAL_MAX_PATH_LEN, "%s/%s", p_node->parent_list->name, tmp_path);
LogFullDebug(COMPONENT_FSAL, "lookup peer found: (%lX.%ld,%s)",
p_node->parent_list->parent.dev,
p_node->parent_list->parent.inum, p_node->parent_list->name);
/* loop detection */
if((curr_inode.inum == p_node->parent_list->parent.inum)
&& (curr_inode.dev == p_node->parent_list->parent.dev))
{
LogCrit(COMPONENT_FSAL,
"NAMESPACE MANAGER: loop detected in namespace: %lX.%ld/%s = %lX.%ld",
p_node->parent_list->parent.dev, p_node->parent_list->parent.inum,
p_node->parent_list->name, curr_inode.dev, curr_inode.inum);
V_r(&ns_lock);
return ELOOP;
}
curr_inode = p_node->parent_list->parent;
}
/* backup path to tmp_path for next loop */
strcpy(tmp_path, path);
}
while(1);
LogFullDebug(COMPONENT_FSAL, "inode=%lX.%ld (gen %u), path='%s'", dev, entry, gen, path);
/* reverse lookup succeeded */
V_r(&ns_lock);
return 0;
}
//Simulate the price process:
void
Sim_Price_Disc::simulate(int retries) {
//If we are re-simulating, we need to reset:
if (simulated) {
//X.simulate(retries); //Re-simulate X
X.simulate2();
//Clear Y
Y.clear();
Y.push_back(y_0);
//Reset the SBM Z:
Z.reset();
}
else {
simulated = true;
//Simulate volatility if necessary:
if (X.is_simulated() == false) {
//X.simulate(retries);
X.simulate2();
}
}
//Get the timestep vector from the volatility:
vector<double> timestep = X.get_timestep();
double h_t, drift;
matrix vola(n,n), tmp(n,n);
//For each discretisation step:
for (unsigned int i=1; i<timestep.size(); ++i) {
//Compute stepsize of the Brownian motion (in case this has changed):
h_t = timestep[i] - timestep[i-1];
//Even though we are not interested in eigenvalues anymore, we need the decomposition
// for the matrix square root.
matrix V_x(n,n), D_x(n,n);
eig(V_x, D_x, X.get_X_i(i-1));
//Compute next simulation point using the discretisation formula (see Section 5)
matrix V_r(n,n), D_r(n,n);
eig(V_r, D_r, (eye(n) - R * flens::transpose(R)));
drift = (r - 0.5*trace(X.get_X_i(i-1))) * h_t;
mat4mult(vola, Z.increment(h_t), V_r, matsqrt_diag(D_r), flens::transpose(V_r));
tmp = X.get_W_incr_i(i) * flens::transpose(R) + vola;
mat4mult(vola, V_x, matsqrt_diag(D_x), flens::transpose(V_x), tmp);
//Add simulation point to storage:
Y.push_back(Y[i-1] + drift + trace(vola));
}
}
/**
* 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 */
cache_inode_status_t cache_inode_readlink(cache_entry_t * pentry, fsal_path_t * plink_content, hash_table_t * ht, /* Unused, kept for protototype's homogeneity */
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus)
{
fsal_status_t fsal_status;
fsal_attrib_list_t attr ;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stats */
(pclient->stat.nb_call_total)++;
(pclient->stat.func_stats.nb_call[CACHE_INODE_READLINK])++;
/* Lock the entry */
P_w(&pentry->lock);
if(cache_inode_renew_entry(pentry, NULL, ht, pclient, pcontext, pstatus) !=
CACHE_INODE_SUCCESS)
{
(pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_READLINK])++;
V_w(&pentry->lock);
return *pstatus;
}
/* RW_Lock obtained as writer turns to reader */
rw_lock_downgrade(&pentry->lock);
switch (pentry->internal_md.type)
{
case REGULAR_FILE:
case DIRECTORY:
case CHARACTER_FILE:
case BLOCK_FILE:
case SOCKET_FILE:
case FIFO_FILE:
case UNASSIGNED:
case FS_JUNCTION:
case RECYCLED:
*pstatus = CACHE_INODE_BAD_TYPE;
V_r(&pentry->lock);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_READLINK] += 1;
return *pstatus;
break;
case SYMBOLIC_LINK:
assert(pentry->object.symlink);
if( CACHE_INODE_KEEP_CONTENT( pentry->policy ) )
{
fsal_status = FSAL_pathcpy(plink_content, &(pentry->object.symlink->content)); /* need copy ctor? */
}
else
{
/* Content is not cached, call FSAL_readlink here */
fsal_status = FSAL_readlink( &pentry->handle, pcontext, plink_content, &attr ) ;
}
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
V_r(&pentry->lock);
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_readlink: Stale FSAL File Handle detected for pentry = %p, fsal_status=(%u,%u)",
pentry, fsal_status.major, fsal_status.minor);
if(cache_inode_kill_entry(pentry, NO_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_readlink: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
/* stats */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_READLINK] += 1;
return *pstatus;
}
break;
}
/* Release the entry */
*pstatus = cache_inode_valid(pentry, CACHE_INODE_OP_GET, pclient);
V_r(&pentry->lock);
/* stat */
if(*pstatus != CACHE_INODE_SUCCESS)
pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_READLINK] += 1;
else
pclient->stat.func_stats.nb_success[CACHE_INODE_READLINK] += 1;
return *pstatus;
} /* cache_inode_readlink */
/**
*
* cache_inode_lookupp_sw: looks up (and caches) the parent directory for a directory. A switches tells is mutex are use.
*
* Looks up (and caches) the parent directory for a directory.
*
* @param pentry [IN] entry whose parent is to be obtained.
* @param ht [IN] hash table used for the cache, unused in this call.
* @param pclient [INOUT] ressource allocated by the client for the nfs management.
* @param pcontext [IN] FSAL credentials
* @param pstatus [OUT] returned status.
* @param use_mutex [IN] if TRUE mutex are use, not otherwise.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
* @return CACHE_INODE_LRU_ERROR if allocation error occured when validating the entry
*
*/
cache_entry_t *cache_inode_lookupp_sw(cache_entry_t * pentry,
hash_table_t * ht,
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus, int use_mutex)
{
cache_entry_t *pentry_parent = NULL;
fsal_status_t fsal_status;
fsal_attrib_list_t object_attributes;
cache_inode_fsal_data_t fsdata;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stats */
pclient->stat.nb_call_total += 1;
pclient->stat.func_stats.nb_call[CACHE_INODE_LOOKUP] += 1;
/* The entry should be a directory */
if(use_mutex)
P_r(&pentry->lock);
if(pentry->internal_md.type != DIR_BEGINNING)
{
if(use_mutex)
V_r(&pentry->lock);
*pstatus = CACHE_INODE_BAD_TYPE;
/* stats */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUPP] += 1;
return NULL;
}
/* Renew the entry (to avoid having it being garbagged */
if(cache_inode_renew_entry(pentry, NULL, ht, pclient, pcontext, pstatus) !=
CACHE_INODE_SUCCESS)
{
pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_GETATTR] += 1;
return NULL;
}
/* Does the parent belongs to the cache ? */
if(pentry->parent_list && pentry->parent_list->parent)
{
/* YES, the parent is cached, use the pentry that we have found */
pentry_parent = pentry->parent_list->parent;
}
else
{
/* NO, the parent is not cached, query FSAL to get it and cache the result */
object_attributes.asked_attributes = pclient->attrmask;
fsal_status =
FSAL_lookup(&pentry->object.dir_begin.handle, (fsal_name_t *) & FSAL_DOT_DOT,
pcontext, &fsdata.handle, &object_attributes);
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
if(use_mutex)
V_r(&pentry->lock);
/* Stale File Handle to be detected and managed */
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,"cache_inode_lookupp: Stale FSAL FH detected for pentry %p",
pentry);
if(cache_inode_kill_entry(pentry, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,"cache_inode_remove: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
/* stats */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUPP] += 1;
return NULL;
}
/* Call cache_inode_get to populate the cache with the parent entry */
fsdata.cookie = 0;
if((pentry_parent = cache_inode_get(&fsdata,
&object_attributes,
ht, pclient, pcontext, pstatus)) == NULL)
{
if(use_mutex)
V_r(&pentry->lock);
/* stats */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUPP] += 1;
return NULL;
}
}
*pstatus = cache_inode_valid(pentry_parent, CACHE_INODE_OP_GET, pclient);
if(use_mutex)
V_r(&pentry->lock);
/* stat */
if(*pstatus != CACHE_INODE_SUCCESS)
pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_LOOKUPP] += 1;
else
pclient->stat.func_stats.nb_success[CACHE_INODE_LOOKUPP] += 1;
return pentry_parent;
} /* cache_inode_lookupp_sw */
/**
*
* cache_inode_create: creates an entry through the cache.
*
* Creates an entry through the cache.
*
* @param pentry_parent [IN] pointer to the pentry parent
* @param pname [IN] pointer to the name of the object in the destination directory.
* @param type [IN] type of the object to be created.
* @param mode [IN] mode to be used at file creation
* @param pcreate_arg [IN] additional argument for object creation
* @param pattr [OUT] attributes for the new object.
* @param ht [INOUT] hash table used for the cache.
* @param pclient [INOUT] ressource allocated by the client for the nfs management.
* @param pcontext [IN] FSAL credentials
* @param pstatus [OUT] returned status.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
* @return CACHE_INODE_LRU_ERROR if allocation error occured when validating the entry\n
* @return CACHE_INODE_BAD_TYPE either source or destination have incorrect type\n
* @return CACHE_INODE_ENTRY_EXISTS entry of that name already exists in destination.
*
*/
cache_entry_t *
cache_inode_create(cache_entry_t * pentry_parent,
fsal_name_t * pname,
cache_inode_file_type_t type,
fsal_accessmode_t mode,
cache_inode_create_arg_t * pcreate_arg,
fsal_attrib_list_t * pattr,
hash_table_t * ht,
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus)
{
cache_entry_t *pentry = NULL;
fsal_status_t fsal_status;
#ifdef _USE_MFSL
mfsl_object_t object_handle;
#else
fsal_handle_t object_handle;
#endif
fsal_attrib_list_t parent_attributes;
fsal_attrib_list_t object_attributes;
fsal_handle_t dir_handle;
cache_inode_fsal_data_t fsal_data;
cache_inode_status_t status;
struct cache_inode_dir_begin__ *dir_begin;
int pnfs_status;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stats */
pclient->stat.nb_call_total += 1;
inc_func_call(pclient, CACHE_INODE_CREATE);
/*
* Check if the required type is correct, with this
* function, we manage file, dir and symlink
*/
if(type != REGULAR_FILE && type != DIR_BEGINNING && type != SYMBOLIC_LINK &&
type != SOCKET_FILE && type != FIFO_FILE && type != CHARACTER_FILE &&
type != BLOCK_FILE)
{
*pstatus = CACHE_INODE_BAD_TYPE;
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
return NULL;
}
/*
* Check if caller is allowed to perform the operation
*/
status = cache_inode_access(pentry_parent,
FSAL_W_OK, ht,
pclient, pcontext, &status);
if (status != CACHE_INODE_SUCCESS)
{
*pstatus = status;
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
/* pentry is a directory */
return NULL;
}
/*
* Check if an entry of the same name exists
*/
pentry = cache_inode_lookup(pentry_parent,
pname, &object_attributes,
ht, pclient, pcontext, pstatus);
if (pentry != NULL)
{
*pstatus = CACHE_INODE_ENTRY_EXISTS;
if(pentry->internal_md.type != type)
{
/*
* Incompatible types, returns NULL
*/
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
return NULL;
}
else
{
/* stats */
inc_func_success(pclient, CACHE_INODE_CREATE);
/*
* redondant creation, returned the
* previously created entry
*/
return pentry;
}
}
/*
* At this point, the entry was not found, this means
* that is doesn't exist is FSAL, we can create it
*/
/* Get the lock for the parent */
P_w(&pentry_parent->lock);
if(pentry_parent->internal_md.type == DIR_BEGINNING)
dir_handle = pentry_parent->object.dir_begin.handle;
if(pentry_parent->internal_md.type == DIR_CONTINUE)
{
P_r(&pentry_parent->object.dir_cont.pdir_begin->lock);
dir_handle = pentry_parent->object.dir_cont.pdir_begin->object.dir_begin.handle;
V_r(&pentry_parent->object.dir_cont.pdir_begin->lock);
}
object_attributes.asked_attributes = pclient->attrmask;
switch (type)
{
case REGULAR_FILE:
#ifdef _USE_MFSL
cache_inode_get_attributes(pentry_parent, &parent_attributes);
fsal_status = MFSL_create(&pentry_parent->mobject,
pname, pcontext,
&pclient->mfsl_context,
mode, &object_handle,
&object_attributes, &parent_attributes);
#else
fsal_status = FSAL_create(&dir_handle,
pname, pcontext, mode,
&object_handle, &object_attributes);
#endif
break;
case DIR_BEGINNING:
#ifdef _USE_MFSL
cache_inode_get_attributes(pentry_parent, &parent_attributes);
fsal_status = MFSL_mkdir(&pentry_parent->mobject,
pname, pcontext,
&pclient->mfsl_context,
mode, &object_handle,
&object_attributes, &parent_attributes);
#else
fsal_status = FSAL_mkdir(&dir_handle,
pname, pcontext, mode,
&object_handle, &object_attributes);
#endif
break;
case SYMBOLIC_LINK:
#ifdef _USE_MFSL
cache_inode_get_attributes(pentry_parent, &object_attributes);
fsal_status = MFSL_symlink(&pentry_parent->mobject,
pname, &pcreate_arg->link_content,
pcontext, &pclient->mfsl_context,
mode, &object_handle, &object_attributes);
#else
fsal_status = FSAL_symlink(&dir_handle,
pname, &pcreate_arg->link_content,
pcontext, mode, &object_handle,
&object_attributes);
#endif
break;
case SOCKET_FILE:
#ifdef _USE_MFSL
fsal_status = MFSL_mknode(&pentry_parent->mobject, pname,
pcontext, &pclient->mfsl_context, mode,
FSAL_TYPE_SOCK, NULL, /* no dev_t needed for socket file */
&object_handle, &object_attributes);
#else
fsal_status = FSAL_mknode(&dir_handle, pname, pcontext,
mode, FSAL_TYPE_SOCK, NULL, /* no dev_t needed for socket file */
&object_handle, &object_attributes);
#endif
break;
case FIFO_FILE:
#ifdef _USE_MFSL
fsal_status = MFSL_mknode(&pentry_parent->mobject, pname,
pcontext, &pclient->mfsl_context,
mode, FSAL_TYPE_FIFO, NULL, /* no dev_t needed for FIFO file */
&object_handle, &object_attributes);
#else
fsal_status = FSAL_mknode(&dir_handle, pname, pcontext,
mode, FSAL_TYPE_FIFO, NULL, /* no dev_t needed for FIFO file */
&object_handle, &object_attributes);
#endif
break;
case BLOCK_FILE:
#ifdef _USE_MFSL
fsal_status = MFSL_mknode(&pentry_parent->mobject,
pname, pcontext,
&pclient->mfsl_context,
mode, FSAL_TYPE_BLK,
&pcreate_arg->dev_spec,
&object_handle, &object_attributes);
#else
fsal_status = FSAL_mknode(&dir_handle,
pname, pcontext,
mode, FSAL_TYPE_BLK,
&pcreate_arg->dev_spec,
&object_handle, &object_attributes);
#endif
break;
case CHARACTER_FILE:
#ifdef _USE_MFSL
fsal_status = MFSL_mknode(&pentry_parent->mobject,
pname, pcontext,
&pclient->mfsl_context,
mode, FSAL_TYPE_CHR,
&pcreate_arg->dev_spec,
&object_handle, &object_attributes);
#else
fsal_status = FSAL_mknode(&dir_handle,
pname, pcontext,
mode, FSAL_TYPE_CHR,
&pcreate_arg->dev_spec,
&object_handle, &object_attributes);
#endif
break;
default:
/* we should never go there */
*pstatus = CACHE_INODE_INCONSISTENT_ENTRY;
V_w(&pentry_parent->lock);
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
return NULL;
break;
}
/* Check for the result */
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
V_w(&pentry_parent->lock);
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_create: Stale FSAL File Handle "
"detected for pentry = %p",
pentry_parent);
cache_inode_kill_entry(pentry_parent, ht,
pclient, &kill_status);
if(kill_status != CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE, "cache_inode_create: "
"Could not kill entry %p, status = %u",
pentry_parent, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
return NULL;
}
else
{
#ifdef _USE_MFSL
fsal_data.handle = object_handle.handle;
#else
fsal_data.handle = object_handle;
#endif
fsal_data.cookie = DIR_START;
pentry = cache_inode_new_entry(&fsal_data, &object_attributes,
type, pcreate_arg, NULL,
ht, pclient, pcontext,
TRUE, /* This is a creation and not a population */
pstatus);
if (pentry == NULL)
{
*pstatus = CACHE_INODE_INSERT_ERROR;
V_w(&pentry_parent->lock);
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
return NULL;
}
#ifdef _USE_MFSL
/* Copy the MFSL object to the cache */
memcpy((char *)&(pentry->mobject),
(char *)&object_handle, sizeof(mfsl_object_t));
#endif
/* Add this entry to the directory */
status = cache_inode_add_cached_dirent(pentry_parent,
pname, pentry,
NULL, ht,
pclient, pcontext,
pstatus);
if (status != CACHE_INODE_SUCCESS)
{
V_w(&pentry_parent->lock);
/* stats */
inc_func_err_unrecover(pclient, CACHE_INODE_CREATE);
return NULL;
}
}
#ifdef _USE_PNFS
if((type == REGULAR_FILE) &&
(pcreate_arg != NULL) &&
(pcreate_arg->use_pnfs == TRUE))
{
pnfs_status = pnfs_create_ds_file(&pclient->pnfsclient,
pentry->object.file.attributes.fileid,
&pentry->object.file.pnfs_file.ds_file);
if (pnfs_status != NFS4_OK)
{
V_w(&pentry_parent->lock);
LogDebug(COMPONENT_CACHE_INODE, "OPEN PNFS CREATE DS FILE : Error %u",
pnfs_status);
*pstatus = CACHE_INODE_IO_ERROR;
return NULL;
}
}
#endif
/* Update the parent cached attributes */
if(pentry_parent->internal_md.type == DIR_BEGINNING)
dir_begin = &pentry_parent->object.dir_begin;
else
dir_begin = &pentry_parent->object.dir_cont.pdir_begin->object.dir_begin;
dir_begin->attributes.mtime.seconds = time(NULL);
dir_begin->attributes.mtime.nseconds = 0;
dir_begin->attributes.ctime = dir_begin->attributes.mtime;
/*
* if the created object is a directory, it contains a link
* to its parent : '..'. Thus the numlink attr must be increased.
*/
if(type == DIR_BEGINNING)
{
dir_begin->attributes.numlinks++;
}
/* Get the attributes in return */
*pattr = object_attributes;
/* valid the parent */
*pstatus = cache_inode_valid(pentry_parent,
CACHE_INODE_OP_SET,
pclient);
/* release the lock for the parent */
V_w(&pentry_parent->lock);
/* stat */
if(*pstatus != CACHE_INODE_SUCCESS)
inc_func_err_retryable(pclient, CACHE_INODE_CREATE);
else
inc_func_success(pclient, CACHE_INODE_CREATE);
return pentry;
}
/**
*
* cache_inode_setattrs: set the attributes for an entry located in the cache by its address.
*
* Sets the attributes for an entry located in the cache by its address. Attributes are provided
* with compliance to the underlying FSAL semantics. Attributes that are set are returned in "*pattr".
*
* @param pentry_parent [IN] entry for the parent directory to be managed.
* @param pattr [INOUT] attributes for the entry that we have found. Out: attributes set.
* @param ht [INOUT] hash table used for the cache, unused in this call.
* @param pclient [INOUT] ressource allocated by the client for the nfs management.
* @param pcontext [IN] FSAL credentials
* @param pstatus [OUT] returned status.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
* @return CACHE_INODE_LRU_ERROR if allocation error occured when validating the entry
*
*/
cache_inode_status_t cache_inode_setattr(cache_entry_t * pentry, fsal_attrib_list_t * pattr, hash_table_t * ht, /* Unused, kept for protototype's homogeneity */
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus)
{
fsal_handle_t *pfsal_handle = NULL;
fsal_status_t fsal_status;
fsal_attrib_list_t *p_object_attributes = NULL;
fsal_attrib_list_t result_attributes;
fsal_attrib_list_t truncate_attributes;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stat */
pclient->stat.nb_call_total += 1;
pclient->stat.func_stats.nb_call[CACHE_INODE_SETATTR] += 1;
/* Lock the entry */
P_w(&pentry->lock);
switch (pentry->internal_md.type)
{
case REGULAR_FILE:
pfsal_handle = &pentry->object.file.handle;
break;
case SYMBOLIC_LINK:
pfsal_handle = &pentry->object.symlink.handle;
break;
case FS_JUNCTION:
case DIR_BEGINNING:
pfsal_handle = &pentry->object.dir_begin.handle;
break;
case DIR_CONTINUE:
/* lock the related dir_begin (dir begin are garbagge collected AFTER their related dir_cont)
* this means that if a DIR_CONTINUE exists, its pdir pointer is not endless */
P_r(&pentry->object.dir_cont.pdir_begin->lock);
pfsal_handle = &pentry->object.dir_cont.pdir_begin->object.dir_begin.handle;
V_r(&pentry->object.dir_cont.pdir_begin->lock);
break;
case CHARACTER_FILE:
case BLOCK_FILE:
case SOCKET_FILE:
case FIFO_FILE:
pfsal_handle = &pentry->object.special_obj.handle;
break;
case UNASSIGNED:
case RECYCLED:
LogCrit(COMPONENT_CACHE_INODE,
"WARNING: unknown source pentry type: internal_md.type=%d, line %d in file %s",
pentry->internal_md.type, __LINE__, __FILE__);
*pstatus = CACHE_INODE_BAD_TYPE;
return *pstatus;
}
/* Call FSAL to set the attributes */
/* result_attributes.asked_attributes = pattr->asked_attributes ; */
/* mod Th.Leibovici on 2006/02/13
* We ask back all standard attributes, in case they have been modified
* by another program (pftp, rcpd...)
*/
result_attributes.asked_attributes = pclient->attrmask;
/* end of mod */
#ifdef _USE_MFSL
fsal_status =
MFSL_setattrs(&pentry->mobject, pcontext, &pclient->mfsl_context, pattr,
&result_attributes, NULL);
#else
cache_inode_get_attributes(pentry, &result_attributes);
fsal_status = FSAL_setattrs(pfsal_handle, pcontext, pattr, &result_attributes);
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
V_w(&pentry->lock);
/* stat */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_SETATTR] += 1;
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_setattr: Stale FSAL File Handle detected for pentry = %p",
pentry);
if(cache_inode_kill_entry(pentry, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_setattr: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
return *pstatus;
}
if(pattr->asked_attributes & FSAL_ATTR_SIZE)
{
truncate_attributes.asked_attributes = pclient->attrmask;
fsal_status = FSAL_truncate(pfsal_handle,
pcontext, pattr->filesize, NULL, &truncate_attributes);
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
V_w(&pentry->lock);
/* stat */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_SETATTR] += 1;
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_setattr: Stale FSAL File Handle detected for pentry = %p",
pentry);
if(cache_inode_kill_entry(pentry, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_setattr: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
return *pstatus;
}
}
/* Keep the new attribute in cache */
switch (pentry->internal_md.type)
{
case REGULAR_FILE:
p_object_attributes = &(pentry->object.file.attributes);
break;
case SYMBOLIC_LINK:
p_object_attributes = &(pentry->object.symlink.attributes);
break;
case FS_JUNCTION:
case DIR_BEGINNING:
p_object_attributes = &(pentry->object.dir_begin.attributes);
break;
case DIR_CONTINUE:
/* lock the related dir_begin (dir begin are garbagge collected AFTER their related dir_cont)
* this means that if a DIR_CONTINUE exists, its pdir pointer is not endless */
P_r(&pentry->object.dir_cont.pdir_begin->lock);
p_object_attributes =
&(pentry->object.dir_cont.pdir_begin->object.dir_begin.attributes);
V_r(&pentry->object.dir_cont.pdir_begin->lock);
break;
case CHARACTER_FILE:
case BLOCK_FILE:
case SOCKET_FILE:
case FIFO_FILE:
p_object_attributes = &(pentry->object.special_obj.attributes);
break;
case UNASSIGNED:
case RECYCLED:
LogCrit(COMPONENT_CACHE_INODE,
"WARNING: unknown source pentry type: internal_md.type=%d, line %d in file %s",
pentry->internal_md.type, __LINE__, __FILE__);
*pstatus = CACHE_INODE_BAD_TYPE;
return *pstatus;
}
/* Update the cached attributes */
if((result_attributes.asked_attributes & FSAL_ATTR_SIZE) ||
(result_attributes.asked_attributes & FSAL_ATTR_SPACEUSED))
{
if(pentry->internal_md.type == REGULAR_FILE)
{
if(pentry->object.file.pentry_content == NULL)
{
/* Operation on a non data cached file */
p_object_attributes->filesize = result_attributes.filesize;
p_object_attributes->spaceused = result_attributes.filesize; /* Unclear hook here. BUGAZOMEU */
}
else
{
/* Data cached file */
/* Do not set the p_object_attributes->filesize and p_object_attributes->spaceused in this case
* This will lead to a situation where (for example) untar-ing a file will produced invalid files
* with a size of 0 despite the fact that they are not empty */
LogFullDebug(COMPONENT_CACHE_INODE,
"cache_inode_setattr with FSAL_ATTR_SIZE on data cached entry");
}
}
else if(pattr->asked_attributes & FSAL_ATTR_SIZE)
LogCrit(COMPONENT_CACHE_INODE,
"WARNING !!! cache_inode_setattr tried to set size on a non REGULAR_FILE type=%d",
pentry->internal_md.type);
}
if(result_attributes.asked_attributes &
(FSAL_ATTR_MODE | FSAL_ATTR_OWNER | FSAL_ATTR_GROUP))
{
if(result_attributes.asked_attributes & FSAL_ATTR_MODE)
p_object_attributes->mode = result_attributes.mode;
if(result_attributes.asked_attributes & FSAL_ATTR_OWNER)
p_object_attributes->owner = result_attributes.owner;
if(result_attributes.asked_attributes & FSAL_ATTR_GROUP)
p_object_attributes->group = result_attributes.group;
}
if(result_attributes.asked_attributes &
(FSAL_ATTR_ATIME | FSAL_ATTR_CTIME | FSAL_ATTR_MTIME))
{
if(result_attributes.asked_attributes & FSAL_ATTR_ATIME)
p_object_attributes->atime = result_attributes.atime;
if(result_attributes.asked_attributes & FSAL_ATTR_CTIME)
p_object_attributes->ctime = result_attributes.ctime;
if(result_attributes.asked_attributes & FSAL_ATTR_MTIME)
p_object_attributes->mtime = result_attributes.mtime;
}
#ifdef _USE_NFS4_ACL
if(result_attributes.asked_attributes & FSAL_ATTR_ACL)
{
LogDebug(COMPONENT_CACHE_INODE, "cache_inode_setattr: old acl = %p, new acl = %p",
p_object_attributes->acl, result_attributes.acl);
/* Release previous acl entry. */
if(p_object_attributes->acl)
{
fsal_acl_status_t status;
nfs4_acl_release_entry(p_object_attributes->acl, &status);
if(status != NFS_V4_ACL_SUCCESS)
LogEvent(COMPONENT_CACHE_INODE, "cache_inode_setattr: Failed to release old acl:"
" status = %d", status);
}
/* Update with new acl entry. */
p_object_attributes->acl = result_attributes.acl;
}
#endif /* _USE_NFS4_ACL */
/* Return the attributes as set */
*pattr = *p_object_attributes;
/* validate the entry */
*pstatus = cache_inode_valid(pentry, CACHE_INODE_OP_SET, pclient);
/* Release the entry */
V_w(&pentry->lock);
/* stat */
if(*pstatus != CACHE_INODE_SUCCESS)
pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_SETATTR] += 1;
else
pclient->stat.func_stats.nb_success[CACHE_INODE_SETATTR] += 1;
return *pstatus;
} /* cache_inode_setattr */
int _9p_readdir( _9p_request_data_t * preq9p,
void * pworker_data,
u32 * plenout,
char * preply)
{
char * cursor = preq9p->_9pmsg + _9P_HDR_SIZE + _9P_TYPE_SIZE ;
nfs_worker_data_t * pwkrdata = (nfs_worker_data_t *)pworker_data ;
int rc = 0 ;
u32 err = 0 ;
u16 * msgtag = NULL ;
u32 * fid = NULL ;
u64 * offset = NULL ;
u32 * count = NULL ;
u32 dcount = 0 ;
u32 recsize = 0 ;
u16 name_len = 0 ;
char * name_str = NULL ;
u8 * qid_type = NULL ;
u64 * qid_path = NULL ;
char * dcount_pos = NULL ;
cache_inode_status_t cache_status;
cache_inode_dir_entry_t **dirent_array = NULL;
cache_inode_endofdir_t eod_met;
cache_entry_t * pentry_dot_dot = NULL ;
cache_inode_dir_entry_t dirent_dot ;
cache_inode_dir_entry_t dirent_dot_dot ;
unsigned int cookie = 0;
unsigned int end_cookie = 0;
unsigned int estimated_num_entries = 0 ;
unsigned int num_entries = 0 ;
unsigned int delta = 0 ;
int unlock = FALSE ;
u64 i = 0LL ;
if ( !preq9p || !pworker_data || !plenout || !preply )
return -1 ;
_9p_fid_t * pfid = NULL ;
/* Get data */
_9p_getptr( cursor, msgtag, u16 ) ;
_9p_getptr( cursor, fid, u32 ) ;
_9p_getptr( cursor, offset, u64 ) ;
_9p_getptr( cursor, count, u32 ) ;
LogDebug( COMPONENT_9P, "TREADDIR: tag=%u fid=%u offset=%llu count=%u",
(u32)*msgtag, *fid, (unsigned long long)*offset, *count ) ;
if( *fid >= _9P_FID_PER_CONN )
{
err = ERANGE ;
rc = _9p_rerror( preq9p, msgtag, &err, plenout, preply ) ;
return rc ;
}
pfid = &preq9p->pconn->fids[*fid] ;
/* Use Cache Inode to read the directory's content */
cookie = (unsigned int)*offset ;
/* For each entry, returns:
* qid = 13 bytes
* offset = 8 bytes
* type = 1 byte
* namelen = 2 bytes
* namestr = ~16 bytes (average size)
* -------------------
* total = ~40 bytes (average size) per dentry */
estimated_num_entries = (unsigned int)( *count / 40 ) ;
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 _9p_readdir")) == NULL)
{
err = EIO ;
rc = _9p_rerror( preq9p, msgtag, &err, plenout, preply ) ;
return rc ;
}
/* Is this the first request ? */
if( *offset == 0 )
{
/* compute the parent entry */
if( ( pentry_dot_dot = cache_inode_lookupp( pfid->pentry,
pwkrdata->ht,
&pwkrdata->cache_inode_client,
&pfid->fsal_op_context,
&cache_status) ) == NULL )
{
err = _9p_tools_errno( cache_status ) ; ;
rc = _9p_rerror( preq9p, msgtag, &err, plenout, preply ) ;
return rc ;
}
/* Deal with "." and ".." */
dirent_dot.pentry = pfid->pentry ;
strcpy( dirent_dot.name.name, "." ) ;
dirent_dot.name.len = strlen( dirent_dot.name.name ) ;
dirent_array[0] = &dirent_dot ;
dirent_dot_dot.pentry = pentry_dot_dot ;
strcpy( dirent_dot_dot.name.name, ".." ) ;
dirent_dot_dot.name.len = strlen( dirent_dot_dot.name.name ) ;
dirent_array[1] = &dirent_dot_dot ;
delta = 2 ;
}
else
delta = 0 ;
if( *offset == 2 )
{
/* offset == 2 as an input as one and only reason:
* - a former call with offset=0 was made and the dir was empty
* - '.' and '..' were returned and nothing else
* - the client makes a new call, expecting it to have empty return
*/
num_entries = 0 ; /* Empty return */
unlock = FALSE ;
}
else if(cache_inode_readdir( pfid->pentry,
pfid->pexport->cache_inode_policy,
cookie,
estimated_num_entries - delta,
&num_entries,
(uint64_t *)&end_cookie,
&eod_met,
&dirent_array[delta],
pwkrdata->ht,
&unlock,
&pwkrdata->cache_inode_client,
&pfid->fsal_op_context,
&cache_status) != CACHE_INODE_SUCCESS)
{
if( unlock ) V_r( &pfid->pentry->lock ) ;
err = _9p_tools_errno( cache_status ) ; ;
rc = _9p_rerror( preq9p, msgtag, &err, plenout, preply ) ;
return rc ;
}
/* Unlock the directory if needed */
if( unlock ) V_r( &pfid->pentry->lock ) ;
/* Never go behind _9P_MAXDIRCOUNT */
if( num_entries > _9P_MAXDIRCOUNT ) num_entries = _9P_MAXDIRCOUNT ;
/* Build the reply */
_9p_setinitptr( cursor, preply, _9P_RREADDIR ) ;
_9p_setptr( cursor, msgtag, u16 ) ;
/* Remember dcount position for later use */
_9p_savepos( cursor, dcount_pos, u32 ) ;
/* fills in the dentry in 9P marshalling */
for( i = 0 ; i < num_entries + delta ; i++ )
{
recsize = 0 ;
/* Build qid */
switch( dirent_array[i]->pentry->internal_md.type )
{
case REGULAR_FILE:
qid_path = (u64 *)&dirent_array[i]->pentry->object.file.attributes.fileid ;
qid_type = &qid_type_file ;
break ;
case CHARACTER_FILE:
case BLOCK_FILE:
case SOCKET_FILE:
case FIFO_FILE:
qid_path = (u64 *)&dirent_array[i]->pentry->object.special_obj.attributes.fileid ;
qid_type = &qid_type_file ;
break ;
case SYMBOLIC_LINK:
qid_path = (u64 *)&dirent_array[i]->pentry->object.symlink->attributes.fileid ;
qid_type = &qid_type_symlink;
break ;
case DIRECTORY:
case FS_JUNCTION:
qid_path = (u64 *)&dirent_array[i]->pentry->object.dir.attributes.fileid ;
qid_type = &qid_type_dir ;
break ;
case UNASSIGNED:
case RECYCLED:
default:
LogMajor( COMPONENT_9P, "implementation error, you should not see this message !!!!!!" ) ;
err = EINVAL ;
rc = _9p_rerror( preq9p, msgtag, &err, plenout, preply ) ;
return rc ;
break ;
}
/* Get dirent name information */
name_str = dirent_array[i]->name.name ;
name_len = dirent_array[i]->name.len ;
/* Add 13 bytes in recsize for qid + 8 bytes for offset + 1 for type + 2 for strlen = 24 bytes*/
recsize = 24 + name_len ;
/* Check if there is room left for another dentry */
if( dcount + recsize > *count )
break ; /* exit for loop */
else
dcount += recsize ;
/* qid in 3 parts */
_9p_setptr( cursor, qid_type, u8 ) ;
_9p_setvalue( cursor, 0, u32 ) ; /* qid_version set to 0 to prevent the client from caching */
_9p_setptr( cursor, qid_path, u64 ) ;
/* offset */
_9p_setvalue( cursor, i+cookie+1, u64 ) ;
/* Type (again ?) */
_9p_setptr( cursor, qid_type, u8 ) ;
/* name */
_9p_setstr( cursor, name_len, name_str ) ;
LogDebug( COMPONENT_9P, "RREADDIR dentry: recsize=%u dentry={ off=%llu,qid=(type=%u,version=%u,path=%llu),type=%u,name=%s,pentry=%p",
recsize, (unsigned long long)i+cookie+1, *qid_type, 0, (unsigned long long)*qid_path,
*qid_type, name_str, dirent_array[i]->pentry ) ;
} /* for( i = 0 , ... ) */
if( !CACHE_INODE_KEEP_CONTENT( pfid->pentry->policy ) )
cache_inode_release_dirent( dirent_array, num_entries, &pwkrdata->cache_inode_client ) ;
Mem_Free((char *)dirent_array);
/* Set buffsize in previously saved position */
_9p_setvalue( dcount_pos, dcount, u32 ) ;
_9p_setendptr( cursor, preply ) ;
_9p_checkbound( cursor, preply, plenout ) ;
LogDebug( COMPONENT_9P, "RREADDIR: tag=%u fid=%u dcount=%u",
(u32)*msgtag, *fid , dcount ) ;
return 1 ;
}
/**
*
* cache_inode_lookup_sw: looks up for a name in a directory indicated by a
* cached entry.
*
* Looks up for a name in a directory indicated by a cached entry. The directory
* should have been cached before.
*
* @param pentry_parent [IN] entry for the parent directory to be managed.
* @param name [IN] name of the entry that we are looking for in the
* cache.
* @param pattr [OUT] attributes for the entry that we have found.
* @param ht [IN] hash table used for the cache, unused in this
* call.
* @param pclient [INOUT] ressource allocated by the client for the nfs
* management.
* @param pcontext [IN] FSAL credentials
* @param pstatus [OUT] returned status.
* @param use_mutex [IN] if TRUE, mutex management is done, not if equal
* to FALSE.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
* @return CACHE_INODE_LRU_ERROR if allocation error occured when validating the
* entry
*
*/
cache_entry_t *cache_inode_lookup_sw(cache_entry_t * pentry_parent,
fsal_name_t * pname,
cache_inode_policy_t policy,
fsal_attrib_list_t * pattr,
hash_table_t * ht,
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus,
int use_mutex)
{
cache_inode_dir_entry_t dirent_key[1], *dirent;
struct avltree_node *dirent_node;
cache_inode_dir_entry_t *new_dir_entry;
cache_entry_t *pentry = NULL;
fsal_status_t fsal_status;
#ifdef _USE_MFSL
mfsl_object_t object_handle;
#else
fsal_handle_t object_handle;
#endif
fsal_handle_t dir_handle;
fsal_attrib_list_t object_attributes;
cache_inode_create_arg_t create_arg;
cache_inode_file_type_t type;
cache_inode_status_t cache_status;
cache_inode_fsal_data_t new_entry_fsdata;
fsal_accessflags_t access_mask = 0;
memset(&create_arg, 0, sizeof(create_arg));
memset( (char *)&new_entry_fsdata, 0, sizeof( new_entry_fsdata ) ) ;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stats */
(pclient->stat.nb_call_total)++;
(pclient->stat.func_stats.nb_call[CACHE_INODE_LOOKUP])++;
/* We should not renew entries when !use_mutex (because unless we
* make the flag explicit (shared vs. exclusive), we don't know
* whether a mutating operation is safe--and, the caller should have
* already renewed the entry */
if(use_mutex == TRUE) {
P_w(&pentry_parent->lock);
cache_status = cache_inode_renew_entry(pentry_parent, pattr, ht,
pclient, pcontext, pstatus);
if(cache_status != CACHE_INODE_SUCCESS)
{
V_w(&pentry_parent->lock);
inc_func_err_retryable(pclient, CACHE_INODE_GETATTR);
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_lookup: returning %d(%s) from cache_inode_renew_entry",
*pstatus, cache_inode_err_str(*pstatus));
return NULL;
}
/* RW Lock goes for writer to reader */
rw_lock_downgrade(&pentry_parent->lock);
}
if(pentry_parent->internal_md.type != DIRECTORY)
{
/* Parent is no directory base, return NULL */
*pstatus = CACHE_INODE_NOT_A_DIRECTORY;
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUP])++;
if(use_mutex == TRUE)
V_r(&pentry_parent->lock);
return NULL;
}
/* if name is ".", use the input value */
if(!FSAL_namecmp(pname, (fsal_name_t *) & FSAL_DOT))
{
pentry = pentry_parent;
}
else if(!FSAL_namecmp(pname, (fsal_name_t *) & FSAL_DOT_DOT))
{
/* Directory do only have exactly one parent. This a limitation in all FS,
* which implies that hard link are forbidden on directories (so that
* they exists only in one dir). Because of this, the parent list is
* always limited to one element for a dir. Clients SHOULD never
* 'lookup( .. )' in something that is no dir. */
pentry =
cache_inode_lookupp_no_mutex(pentry_parent, ht, pclient, pcontext,
pstatus);
}
else
{
/* This is a "regular lookup" (not on "." or "..") */
/* Check is user (as specified by the credentials) is authorized to
* lookup the directory or not */
access_mask = FSAL_MODE_MASK_SET(FSAL_X_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_LIST_DIR);
if(cache_inode_access_no_mutex(pentry_parent,
access_mask,
ht,
pclient,
pcontext,
pstatus) != CACHE_INODE_SUCCESS)
{
if(use_mutex == TRUE)
V_r(&pentry_parent->lock);
(pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_GETATTR])++;
return NULL;
}
/* We first try avltree_lookup by name. If that fails, we dispatch to
* the fsal. */
FSAL_namecpy(&dirent_key->name, pname);
dirent_node = avltree_lookup(&dirent_key->node_n,
&pentry_parent->object.dir.dentries);
if (dirent_node) {
dirent = avltree_container_of(dirent_node, cache_inode_dir_entry_t,
node_n);
pentry = dirent->pentry;
}
if(pentry == NULL)
{
LogDebug(COMPONENT_CACHE_INODE, "Cache Miss detected");
dir_handle = pentry_parent->handle;
object_attributes.asked_attributes = pclient->attrmask;
#ifdef _USE_MFSL
#ifdef _USE_MFSL_ASYNC
if(!mfsl_async_is_object_asynchronous(&pentry_parent->mobject))
{
/* If the parent is asynchronous, rely on the content of the cache
* inode parent entry.
*
* /!\ If the fs behind the FSAL is touched in a non-nfs way,
* there will be huge incoherencies.
*/
#endif /* _USE_MFSL_ASYNC */
fsal_status = MFSL_lookup(&pentry_parent->mobject,
pname,
pcontext,
&pclient->mfsl_context,
&object_handle, &object_attributes, NULL);
#ifdef _USE_MFSL_ASYNC
}
else
{
LogMidDebug(COMPONENT_CACHE_INODE,
"cache_inode_lookup chose to bypass FSAL and trusted his cache for name=%s",
pname->name);
fsal_status.major = ERR_FSAL_NOENT;
fsal_status.minor = ENOENT;
}
#endif /* _USE_MFSL_ASYNC */
#else
fsal_status =
FSAL_lookup(&dir_handle, pname, pcontext, &object_handle,
&object_attributes);
#endif /* _USE_MFSL */
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
if(use_mutex == TRUE)
V_r(&pentry_parent->lock);
/* Stale File Handle to be detected and managed */
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_lookup: Stale FSAL File Handle detected for pentry = %p, fsal_status=(%u,%u)",
pentry_parent, fsal_status.major, fsal_status.minor);
if(cache_inode_kill_entry(pentry_parent, NO_LOCK, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_pentry_parent: Could not kill entry %p, status = %u",
pentry_parent, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUP])++;
return NULL;
}
type = cache_inode_fsal_type_convert(object_attributes.type);
/* If entry is a symlink, this value for be cached */
if(type == SYMBOLIC_LINK)
{
if( CACHE_INODE_KEEP_CONTENT( policy ) )
#ifdef _USE_MFSL
{
fsal_status =
MFSL_readlink(&object_handle, pcontext, &pclient->mfsl_context,
&create_arg.link_content, &object_attributes, NULL);
}
#else
{
fsal_status =
FSAL_readlink(&object_handle, pcontext, &create_arg.link_content,
&object_attributes);
}
else
{
fsal_status.major = ERR_FSAL_NO_ERROR ;
fsal_status.minor = 0 ;
}
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
if(use_mutex == TRUE)
V_r(&pentry_parent->lock);
/* Stale File Handle to be detected and managed */
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_lookup: Stale FSAL File Handle detected for pentry = %p, fsal_status=(%u,%u)",
pentry_parent, fsal_status.major, fsal_status.minor);
if(cache_inode_kill_entry(pentry_parent, NO_LOCK, ht, pclient, &kill_status)
!= CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_pentry_parent: Could not kill entry %p, status = %u",
pentry_parent, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUP])++;
return NULL;
}
}
/* Allocation of a new entry in the cache */
#ifdef _USE_MFSL
new_entry_fsdata.handle = object_handle.handle;
#else
new_entry_fsdata.handle = object_handle;
#endif
new_entry_fsdata.cookie = 0;
if((pentry = cache_inode_new_entry( &new_entry_fsdata,
&object_attributes,
type,
policy,
&create_arg,
NULL,
ht,
pclient,
pcontext,
FALSE, /* This is a population and not a creation */
pstatus ) ) == NULL )
{
if(use_mutex == TRUE)
V_r(&pentry_parent->lock);
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUP])++;
return NULL;
}
/* Entry was found in the FSAL, add this entry to the parent
* directory */
cache_status = cache_inode_add_cached_dirent(pentry_parent,
pname,
pentry,
ht,
&new_dir_entry,
pclient,
pcontext,
pstatus);
if(cache_status != CACHE_INODE_SUCCESS
&& cache_status != CACHE_INODE_ENTRY_EXISTS)
{
if(use_mutex == TRUE)
V_r(&pentry_parent->lock);
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LOOKUP])++;
return NULL;
}
} /* cached lookup fail (try fsal) */
/**
*
* cache_inode_getattr: Gets the attributes for a cached entry.
*
* Gets the attributes for a cached entry. The FSAL attributes are kept in a structure when the entry
* is added to the cache.
*
* @param pentry [IN] entry to be managed.
* @param pattr [OUT] pointer to the results
* @param ht [IN] hash table used for the cache, unused in this call.
* @param pclient [INOUT] ressource allocated by the client for the nfs management.
* @param pcontext [IN] FSAL credentials
* @param pstatus [OUT] returned status.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
* @return CACHE_INODE_LRU_ERROR if allocation error occured when validating the entry
*
*/
cache_inode_status_t
cache_inode_getattr(cache_entry_t * pentry,
fsal_attrib_list_t * pattr,
hash_table_t * ht, /* Unused, kept for protototype's homogeneity */
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus)
{
cache_inode_status_t status;
fsal_handle_t *pfsal_handle = NULL;
fsal_status_t fsal_status;
/* sanity check */
if(pentry == NULL || pattr == NULL ||
ht == NULL || pclient == NULL || pcontext == NULL)
{
*pstatus = CACHE_INODE_INVALID_ARGUMENT;
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_getattr: returning CACHE_INODE_INVALID_ARGUMENT because of bad arg");
return *pstatus;
}
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stats */
pclient->stat.nb_call_total += 1;
inc_func_call(pclient, CACHE_INODE_GETATTR);
/* Lock the entry */
P_w(&pentry->lock);
status = cache_inode_renew_entry(pentry, pattr, ht,
pclient, pcontext, pstatus);
if(status != CACHE_INODE_SUCCESS)
{
V_w(&pentry->lock);
inc_func_err_retryable(pclient, CACHE_INODE_GETATTR);
LogFullDebug(COMPONENT_CACHE_INODE,
"cache_inode_getattr: returning %d(%s) from cache_inode_renew_entry",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
/* RW Lock goes for writer to reader */
rw_lock_downgrade(&pentry->lock);
cache_inode_get_attributes(pentry, pattr);
if(FSAL_TEST_MASK(pattr->asked_attributes,
FSAL_ATTR_RDATTR_ERR))
{
switch (pentry->internal_md.type)
{
case REGULAR_FILE:
pfsal_handle = &pentry->object.file.handle;
break;
case SYMBOLIC_LINK:
assert(pentry->object.symlink);
pfsal_handle = &pentry->object.symlink->handle;
break;
case DIRECTORY:
pfsal_handle = &pentry->object.dir.handle;
break;
case SOCKET_FILE:
case FIFO_FILE:
case BLOCK_FILE:
case CHARACTER_FILE:
pfsal_handle = &pentry->object.special_obj.handle;
break;
case FS_JUNCTION:
case UNASSIGNED:
case RECYCLED:
*pstatus = CACHE_INODE_INVALID_ARGUMENT;
LogFullDebug(COMPONENT_CACHE_INODE,
"cache_inode_getattr: returning %d(%s) from cache_inode_renew_entry - unexpected md_type",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
/*
* An error occured when trying to get
* the attributes, they have to be renewed
*/
#ifdef _USE_MFSL
fsal_status = FSAL_getattrs_descriptor(&(cache_inode_fd(pentry)->fsal_file), pfsal_handle, pcontext, pattr);
#else
fsal_status = FSAL_getattrs_descriptor(cache_inode_fd(pentry), pfsal_handle, pcontext, pattr);
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
V_r(&pentry->lock);
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_getattr: Stale FSAL File Handle detected for pentry = %p",
pentry);
/* Locked flag is set to true to show entry has a read lock */
cache_inode_kill_entry( pentry, WT_LOCK, ht,
pclient, &kill_status);
if(kill_status != CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_getattr: Could not kill entry %p, status = %u",
pentry, kill_status);
*pstatus = CACHE_INODE_FSAL_ESTALE;
}
/* stat */
inc_func_err_unrecover(pclient, CACHE_INODE_GETATTR);
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_getattr: returning %d(%s) from FSAL_getattrs_descriptor",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
/* Set the new attributes */
cache_inode_set_attributes(pentry, pattr);
}
*pstatus = cache_inode_valid(pentry, CACHE_INODE_OP_GET, pclient);
V_r(&pentry->lock);
/* stat */
if(*pstatus != CACHE_INODE_SUCCESS)
inc_func_err_retryable(pclient, CACHE_INODE_GETATTR);
else
inc_func_success(pclient, CACHE_INODE_GETATTR);
#ifdef _USE_NFS4_ACL
if(isDebug(COMPONENT_NFS_V4_ACL))
{
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_getattr: pentry = %p, acl = %p",
pentry, pattr->acl);
if(pattr->acl)
{
fsal_ace_t *pace;
for(pace = pattr->acl->aces; pace < pattr->acl->aces + pattr->acl->naces; pace++)
{
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_getattr: ace type = 0x%x, flag = 0x%x, perm = 0x%x, special = %d, %s = 0x%x",
pace->type, pace->flag, pace->perm, IS_FSAL_ACE_SPECIAL_ID(*pace),
GET_FSAL_ACE_WHO_TYPE(*pace), GET_FSAL_ACE_WHO(*pace));
}
}
}
#endif /* _USE_NFS4_ACL */
LogFullDebug(COMPONENT_CACHE_INODE,
"cache_inode_getattr: returning %d(%s) from cache_inode_valid",
*pstatus, cache_inode_err_str(*pstatus));
return *pstatus;
}
/**
*
* cache_inode_readdir: Reads a directory.
*
* Looks up for a name in a directory indicated by a cached entry. The
* directory should have been cached before.
*
* NEW: pending new (C-language) callback based dirent unpacking into caller
* structures, we eliminate copies by returning dir entries by pointer. To
* permit this, we introduce lock donation. If new int pointer argument
* unlock is 1 on return, the calling thread holds pentry read-locked and
* must release this lock after dirent processing.
*
* This is the only function in the cache_inode_readdir.c file that manages MT
* safety on a directory cache entry.
*
* @param pentry [IN] entry for the parent directory to be read.
* @param cookie [IN] cookie for the readdir operation (basically the offset).
* @param nbwanted [IN] Maximum number of directory entries wanted.
* @param peod_met [OUT] A flag to know if end of directory was met during this call.
* @param dirent_array [OUT] the resulting array of found directory entries.
* @param ht [IN] hash table used for the cache, unused in this call.
* @param unlock [OUT] the caller shall release read-lock on pentry when done
* @param pclient [INOUT] ressource allocated by the client for the nfs management.
* @param pcontext [IN] FSAL credentials
* @param pstatus [OUT] returned status.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
* @return CACHE_INODE_BAD_TYPE if entry is not related to a directory\n
* @return CACHE_INODE_LRU_ERROR if allocation error occured when validating the entry
*
*/
cache_inode_status_t cache_inode_readdir(cache_entry_t * dir_pentry,
cache_inode_policy_t policy,
uint64_t cookie,
unsigned int nbwanted,
unsigned int *pnbfound,
uint64_t *pend_cookie,
cache_inode_endofdir_t *peod_met,
cache_inode_dir_entry_t **dirent_array,
hash_table_t *ht,
int *unlock,
cache_inode_client_t *pclient,
fsal_op_context_t *pcontext,
cache_inode_status_t *pstatus)
{
cache_inode_dir_entry_t dirent_key[1], *dirent;
struct avltree_node *dirent_node;
fsal_accessflags_t access_mask = 0;
uint64_t inoff = cookie;
int i = 0;
/* Guide to parameters:
* the first cookie is parameter 'cookie'
* number of entries queried is set by parameter 'nbwanted'
* number of found entries before eod is return is '*pnbfound'
* '*peod_met' is set if end of directory is encountered */
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
dirent = NULL;
/* Set initial value of unlock */
*unlock = FALSE;
/* end cookie initial value is the begin cookie */
LogFullDebug(COMPONENT_NFS_READDIR,
"--> Cache_inode_readdir: setting pend_cookie to cookie=%"
PRIu64,
cookie);
*pend_cookie = cookie;
/* stats */
pclient->stat.nb_call_total++;
(pclient->stat.func_stats.nb_call[CACHE_INODE_READDIR])++;
LogFullDebug(COMPONENT_NFS_READDIR,
"--> Cache_inode_readdir: parameters are cookie=%"PRIu64
"nbwanted=%u",
cookie, nbwanted);
/* Sanity check */
if(nbwanted == 0)
{
/* Asking for nothing is not a crime !!!!!
* build a 'dummy' return in this case */
*pstatus = CACHE_INODE_SUCCESS;
*pnbfound = 0;
*peod_met = TO_BE_CONTINUED;
/* stats */
(pclient->stat.func_stats.nb_success[CACHE_INODE_READDIR])++;
return *pstatus;
}
/* Force dir content invalidation if policy enforced no name cache */
if( !CACHE_INODE_KEEP_CONTENT( dir_pentry->policy ) )
return cache_inode_readdir_nonamecache( dir_pentry,
policy,
cookie,
nbwanted,
pnbfound,
pend_cookie,
peod_met,
dirent_array,
ht,
unlock,
pclient,
pcontext,
pstatus ) ;
P_w(&dir_pentry->lock);
/* Renew the entry (to avoid having it being garbagged */
if(cache_inode_renew_entry(dir_pentry, NULL, ht, pclient, pcontext,
pstatus) != CACHE_INODE_SUCCESS)
{
(pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_GETATTR])++;
V_w(&dir_pentry->lock);
return *pstatus;
}
/* readdir can be done only with a directory */
if(dir_pentry->internal_md.type != DIRECTORY)
{
V_w(&dir_pentry->lock);
*pstatus = CACHE_INODE_BAD_TYPE;
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_READDIR])++;
return *pstatus;
}
/* Check is user (as specified by the credentials) is authorized to read
* the directory or not */
access_mask = FSAL_MODE_MASK_SET(FSAL_R_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_LIST_DIR);
if(cache_inode_access_no_mutex(dir_pentry,
access_mask,
ht, pclient,
pcontext,
pstatus) != CACHE_INODE_SUCCESS)
{
V_w(&dir_pentry->lock);
(pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_READDIR])++;
return *pstatus;
}
/* Is the directory fully cached (this is done if a readdir call is done on the directory) */
if(dir_pentry->object.dir.has_been_readdir != CACHE_INODE_YES)
{
/* populate the cache */
if(cache_inode_readdir_populate(dir_pentry,
policy,
ht,
pclient,
pcontext, pstatus) != CACHE_INODE_SUCCESS)
{
/* stats */
(pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_READDIR])++;
V_w(&dir_pentry->lock);
return *pstatus;
}
}
/* deal with dentry cache invalidates */
revalidate_cookie_cache(dir_pentry, pclient);
/* Downgrade Writer lock to a reader one. */
rw_lock_downgrade(&dir_pentry->lock);
/* deal with initial cookie value:
* 1. cookie is invalid (-should- be checked by caller)
* 2. cookie is 0 (first cookie) -- ok
* 3. cookie is > than highest dirent position (error)
* 4. cookie <= highest dirent position but > highest cached cookie
* (currently equivalent to #2, because we pre-populate the cookie avl)
* 5. cookie is in cached range -- ok */
if (cookie > 0) {
if (cookie < 3) {
*pstatus = CACHE_INODE_BAD_COOKIE;
V_r(&dir_pentry->lock);
return *pstatus;
}
if ((inoff-3) > avltree_size(&dir_pentry->object.dir.dentries)) {
LogCrit(COMPONENT_NFS_V4, "Bad initial cookie %"PRIu64,
inoff);
*pstatus = CACHE_INODE_BAD_COOKIE;
V_r(&dir_pentry->lock);
return *pstatus;
}
/* we assert this can now succeed */
dirent_key->cookie = inoff;
dirent_node = avltree_lookup(&dirent_key->node_c,
&dir_pentry->object.dir.cookies);
if (! dirent_node) {
LogCrit(COMPONENT_NFS_READDIR,
"%s: seek to cookie=%"PRIu64" fail",
__func__,
inoff);
*pstatus = CACHE_INODE_NOT_FOUND;
V_r(&dir_pentry->lock);
return *pstatus;
}
/* switch avls */
dirent = avltree_container_of(dirent_node,
cache_inode_dir_entry_t,
node_c);
dirent_node = &dirent->node_n;
/* client wants the cookie -after- the last we sent, and
* the Linux 3.0 and 3.1.0-rc7 clients misbehave if we
* resend the last one */
dirent_node = avltree_next(dirent_node);
} else {
/* initial readdir */
dirent_node = avltree_first(&dir_pentry->object.dir.dentries);
}
LogFullDebug(COMPONENT_NFS_READDIR,
"About to readdir in cache_inode_readdir: pentry=%p "
"cookie=%"PRIu64,
dir_pentry,
cookie);
/* Now satisfy the request from the cached readdir--stop when either
* the requested sequence or dirent sequence is exhausted */
*pnbfound = 0;
*peod_met = TO_BE_CONTINUED;
for(i = 0; i < nbwanted; ++i)
{
if (!dirent_node)
break;
dirent = avltree_container_of(dirent_node,
cache_inode_dir_entry_t,
node_n);
dirent_array[i] = dirent;
(*pnbfound)++;
dirent_node = avltree_next(dirent_node);
}
if (*pnbfound > 0)
{
if (!dirent)
{
LogCrit(COMPONENT_CACHE_INODE, "cache_inode_readdir: "
"UNEXPECTED CASE: dirent is NULL whereas nbfound>0");
*pstatus = CACHE_INODE_INCONSISTENT_ENTRY;
return CACHE_INODE_INCONSISTENT_ENTRY;
}
*pend_cookie = dirent->cookie;
}
if (! dirent_node)
*peod_met = END_OF_DIR;
*pstatus = cache_inode_valid(dir_pentry, CACHE_INODE_OP_GET, pclient);
/* stats */
if(*pstatus != CACHE_INODE_SUCCESS) {
(pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_READDIR])++;
V_r(&dir_pentry->lock);
}
else {
(pclient->stat.func_stats.nb_success[CACHE_INODE_READDIR])++;
*unlock = TRUE;
}
return *pstatus;
} /* cache_inode_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;
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 */
/**
*
* cache_inode_link: hardlinks a pentry to another.
*
* Hard links a pentry to another. This is basically a equivalent of FSAL_link in the cache inode layer.
*
* @param pentry_src [IN] entry pointer the entry to be linked. This can't be a directory.
* @param pentry_dir_dest [INOUT] entry pointer for the destination directory in which the link will be created.
* @param plink_name [IN] pointer to the name of the object in the destination directory.
* @param pattr [OUT] attributes for the linked attributes after the operation.
* @param ht [INOUT] hash table used for the cache.
* @param pclient [INOUT] ressource allocated by the client for the nfs management.
* @param pcontext [IN] FSAL credentials
* @param pstatus [OUT] returned status.
*
* @return CACHE_INODE_SUCCESS if operation is a success \n
* @return CACHE_INODE_LRU_ERROR if allocation error occured when validating the entry\n
* @return CACHE_INODE_BAD_TYPE either source or destination have incorrect type\n
* @return CACHE_INODE_ENTRY_EXISTS entry of that name already exists in destination.
*
*/
cache_inode_status_t cache_inode_link(cache_entry_t * pentry_src,
cache_entry_t * pentry_dir_dest,
fsal_name_t * plink_name,
fsal_attrib_list_t * pattr,
hash_table_t * ht,
cache_inode_client_t * pclient,
fsal_op_context_t * pcontext,
cache_inode_status_t * pstatus)
{
fsal_status_t fsal_status;
fsal_handle_t handle_src;
fsal_handle_t handle_dest;
fsal_attrib_list_t link_attributes;
#ifdef _USE_MFSL
fsal_attrib_list_t dirdest_attributes;
#endif
cache_inode_status_t status;
cache_entry_t *pentry_lookup = NULL;
fsal_attrib_list_t lookup_attributes;
fsal_size_t save_size = 0;
fsal_size_t save_spaceused = 0;
fsal_time_t save_mtime = {
.seconds = 0,
.nseconds = 0
};
fsal_accessflags_t access_mask = 0;
/* Set the return default to CACHE_INODE_SUCCESS */
*pstatus = CACHE_INODE_SUCCESS;
/* stats */
pclient->stat.nb_call_total += 1;
pclient->stat.func_stats.nb_call[CACHE_INODE_LINK] += 1;
/* Is the destination a directory ? */
if(pentry_dir_dest->internal_md.type != DIR_BEGINNING &&
pentry_dir_dest->internal_md.type != DIR_CONTINUE)
{
/* Bad type .... */
*pstatus = CACHE_INODE_BAD_TYPE;
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LINK] += 1;
return *pstatus;
}
/* Check if caller is allowed to perform the operation */
access_mask = FSAL_MODE_MASK_SET(FSAL_W_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_ADD_FILE);
if((status = cache_inode_access(pentry_dir_dest,
access_mask,
ht, pclient, pcontext, &status)) != CACHE_INODE_SUCCESS)
{
*pstatus = status;
/* stats */
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LINK] += 1;
/* pentry is a directory */
return *pstatus;
}
/* Check if an entry of the same name doesn't exist in the destination directory */
if((pentry_lookup = cache_inode_lookup(pentry_dir_dest,
plink_name,
&lookup_attributes,
ht, pclient, pcontext, pstatus)) != NULL)
{
/* There exists such an entry... */
*pstatus = CACHE_INODE_ENTRY_EXISTS;
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LINK] += 1;
return *pstatus;
}
/* The pentry to be hardlinked can't be a DIR_BEGINNING or a DIR_CONTINUE */
if(pentry_src->internal_md.type == DIR_BEGINNING ||
pentry_src->internal_md.type == DIR_CONTINUE)
{
/* Bad type .... */
*pstatus = CACHE_INODE_BAD_TYPE;
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LINK] += 1;
return *pstatus;
}
#if 0
if( pentry_src->internal_md.type == REGULAR_FILE )
printf( "=== link === %p | inode=%llu\n", pentry_src, pentry_src->object.file.attributes.fileid ) ;
#endif
/* At this point, we know that the entry does not exist in destination directory, we know that the
* destination is actually a directory and that the source is no directory */
/* Lock the source */
P_w(&pentry_src->lock);
/* Lock the target dir */
P_w(&pentry_dir_dest->lock);
/* Get the handles */
switch (pentry_src->internal_md.type)
{
case REGULAR_FILE:
handle_src = pentry_src->object.file.handle;
break;
case SYMBOLIC_LINK:
handle_src = pentry_src->object.symlink.handle;
break;
case FS_JUNCTION:
case DIR_BEGINNING:
handle_src = pentry_src->object.dir_begin.handle;
break;
case DIR_CONTINUE:
/* lock the related dir_begin (dir begin are garbagge collected AFTER their related dir_cont)
* this means that if a DIR_CONTINUE exists, its pdir pointer is not endless */
P_r(&pentry_src->object.dir_cont.pdir_begin->lock);
handle_src = pentry_src->object.dir_cont.pdir_begin->object.dir_begin.handle;
V_r(&pentry_src->object.dir_cont.pdir_begin->lock);
break;
case CHARACTER_FILE:
case BLOCK_FILE:
case SOCKET_FILE:
case FIFO_FILE:
handle_src = pentry_src->object.special_obj.handle;
break;
case UNASSIGNED:
case RECYCLED:
LogCrit(COMPONENT_CACHE_INODE,
"WARNING: unknown source pentry type: internal_md.type=%d, line %d in file %s",
pentry_src->internal_md.type, __LINE__, __FILE__);
*pstatus = CACHE_INODE_BAD_TYPE;
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LINK] += 1;
return *pstatus;
}
switch (pentry_dir_dest->internal_md.type)
{
case FS_JUNCTION:
case DIR_BEGINNING:
handle_dest = pentry_dir_dest->object.dir_begin.handle;
break;
case DIR_CONTINUE:
/* lock the related dir_begin (dir begin are garbagge collected AFTER their related dir_cont)
* this means that if a DIR_CONTINUE exists, its pdir pointer is not endless */
P_r(&pentry_dir_dest->object.dir_cont.pdir_begin->lock);
handle_dest = pentry_src->object.dir_cont.pdir_begin->object.dir_begin.handle;
V_r(&pentry_dir_dest->object.dir_cont.pdir_begin->lock);
break;
default:
LogCrit(COMPONENT_CACHE_INODE,
"WARNING: unknown source pentry type: internal_md.type=%d, line %d in file %s",
pentry_src->internal_md.type, __LINE__, __FILE__);
*pstatus = CACHE_INODE_BAD_TYPE;
pclient->stat.func_stats.nb_err_unrecover[CACHE_INODE_LINK] += 1;
return *pstatus;
}
/* If object is a data cached regular file, keeps it mtime and size, STEP 1 */
if((pentry_src->internal_md.type == REGULAR_FILE)
&& (pentry_src->object.file.pentry_content != NULL))
{
save_mtime = pentry_src->object.file.attributes.mtime;
save_size = pentry_src->object.file.attributes.filesize;
save_spaceused = pentry_src->object.file.attributes.spaceused;
}
/* Do the link at FSAL level */
link_attributes.asked_attributes = pclient->attrmask;
#ifdef _USE_MFSL
cache_inode_get_attributes(pentry_src, &link_attributes);
cache_inode_get_attributes(pentry_dir_dest, &dirdest_attributes);
fsal_status =
MFSL_link(&pentry_src->mobject, &pentry_dir_dest->mobject, plink_name, pcontext,
&pclient->mfsl_context, &link_attributes, NULL);
#else
fsal_status =
FSAL_link(&handle_src, &handle_dest, plink_name, pcontext, &link_attributes);
#endif
if(FSAL_IS_ERROR(fsal_status))
{
*pstatus = cache_inode_error_convert(fsal_status);
V_w(&pentry_dir_dest->lock);
V_w(&pentry_src->lock);
if(fsal_status.major == ERR_FSAL_STALE)
{
cache_inode_status_t kill_status;
fsal_status_t getattr_status;
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_link: Stale FSAL File Handle detected for at least one in pentry = %p and pentry = %p",
pentry_src, pentry_dir_dest);
/* Use FSAL_getattrs to find which entry is staled */
getattr_status = FSAL_getattrs(&handle_src, pcontext, &link_attributes);
if(getattr_status.major == ERR_FSAL_ACCESS)
{
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_link: Stale FSAL File Handle detected for pentry = %p",
pentry_src);
if(cache_inode_kill_entry(pentry_src, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_link: Could not kill entry %p, status = %u",
pentry_src, kill_status);
}
getattr_status = FSAL_getattrs(&handle_dest, pcontext, &link_attributes);
if(getattr_status.major == ERR_FSAL_ACCESS)
{
LogEvent(COMPONENT_CACHE_INODE,
"cache_inode_link: Stale FSAL File Handle detected for pentry = %p",
pentry_dir_dest);
if(cache_inode_kill_entry(pentry_dir_dest, ht, pclient, &kill_status) !=
CACHE_INODE_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"cache_inode_link: Could not kill entry %p, status = %u",
pentry_dir_dest, kill_status);
}
}
*pstatus = CACHE_INODE_FSAL_ESTALE;
return *pstatus;
}
/* If object is a data cached regular file, keeps it mtime and size, STEP 2 */
if((pentry_src->internal_md.type == REGULAR_FILE)
&& (pentry_src->object.file.pentry_content != NULL))
{
link_attributes.mtime = save_mtime;
link_attributes.filesize = save_size;
link_attributes.spaceused = save_spaceused;
}
/* Update cached attributes */
cache_inode_set_attributes(pentry_src, &link_attributes);
/* Add the new entry in the destination directory */
if(cache_inode_add_cached_dirent(pentry_dir_dest,
plink_name,
pentry_src,
NULL,
ht, pclient, pcontext, &status) != CACHE_INODE_SUCCESS)
{
V_w(&pentry_dir_dest->lock);
V_w(&pentry_src->lock);
return *pstatus;
}
/* Regular exit */
/* return the attributes */
*pattr = link_attributes;
/* Validate the entries */
*pstatus = cache_inode_valid(pentry_src, CACHE_INODE_OP_SET, pclient);
/* Release the target dir */
V_w(&pentry_dir_dest->lock);
/* Release the source */
V_w(&pentry_src->lock);
/* stats */
if(*pstatus != CACHE_INODE_SUCCESS)
pclient->stat.func_stats.nb_err_retryable[CACHE_INODE_LINK] += 1;
else
pclient->stat.func_stats.nb_success[CACHE_INODE_LINK] += 1;
return *pstatus;
}
