fsal_status_t ZFSFSAL_SetXAttrValueById(fsal_handle_t * obj_handle, /* IN */
unsigned int xattr_id, /* IN */
fsal_op_context_t * context, /* IN */
caddr_t buffer_addr, /* IN */
size_t buffer_size /* IN */
)
{
int rc;
char psz_name[FSAL_MAX_NAME_LEN];
fsal_name_t attr_name;
zfsfsal_handle_t * p_objecthandle = (zfsfsal_handle_t *)obj_handle;
zfsfsal_op_context_t *p_context = (zfsfsal_op_context_t *)context;
/* Hook to prevent any modification in the snapshots */
if(p_objecthandle->data.i_snap != 0)
Return(ERR_FSAL_ROFS, 0, INDEX_FSAL_SetXAttrValue);
if(attr_is_read_only(xattr_id))
Return(ERR_FSAL_PERM, 0, INDEX_FSAL_SetXAttrValue);
else if(xattr_id < XATTR_COUNT)
Return(ERR_FSAL_PERM, 0, INDEX_FSAL_SetXAttrValue);
if((rc = xattr_id_to_name(p_context->export_context->p_vfs, p_context, p_objecthandle,
xattr_id, psz_name)))
Return(rc, 0, INDEX_FSAL_SetXAttrValue);
FSAL_str2name(psz_name, FSAL_MAX_NAME_LEN, &attr_name);
return ZFSFSAL_SetXAttrValue(obj_handle, &attr_name, context,
buffer_addr, buffer_size, FALSE);
}
/*
* Convert a buffer descriptor to an fsal name.
*/
fsal_status_t dpmfsal_buffdesc2name(fsal_buffdesc_t * in_buf,
fsal_name_t * out_name)
{
if (!in_buf || !out_name)
ReturnCode(ERR_FSAL_FAULT, 0);
return FSAL_str2name(in_buf->pointer, in_buf->len, out_name);
}
void populatedb(fsal_posixdb_conn * p_conn, char *path)
{
int rc;
fsal_posixdb_fileinfo_t info;
fsal_name_t fsalname;
posixfsal_handle_t handle, handle_parent;
struct stat buffstat;
char *begin, *end, backup;
if(path[0] != '/')
{
fputs("Error : you should provide a complete path", stderr);
return;
}
if(path[strlen(path) - 1] != '/')
strcat(path, "/");
/* add the path (given in arguments) to the database */
rc = lstat("/", &buffstat);
fsal_internal_posix2posixdb_fileinfo(&buffstat, &info);
fsal_internal_posixdb_add_entry(p_conn, NULL, &info, NULL, &handle_parent);
begin = end = path;
while(*end != '\0')
{
while(*begin == '/')
begin++;
if(*begin == '\0')
break;
end = begin + 1;
while(*end != '/' && *end != '\0')
end++;
backup = *end;
*end = '\0';
rc = lstat(path, &buffstat);
fsal_internal_posix2posixdb_fileinfo(&buffstat, &info);
FSAL_str2name(begin, FSAL_MAX_NAME_LEN, &fsalname);
fsal_internal_posixdb_add_entry(p_conn, &fsalname, &info, &handle_parent, &handle);
memcpy(&handle_parent, &handle, sizeof(posixfsal_handle_t));
*end = backup;
begin = end;
}
/* add files */
printf("Adding entries in %s... rc=%d ", path, rc);
fflush(stdout);
add_dir(p_conn, path, &handle_parent);
puts("done");
}
int fsal_internal_proxy_fsal_utf8_2_name(fsal_name_t * pname, utf8string * utf8str)
{
char tmpstr[FSAL_MAX_NAME_LEN];
fsal_status_t fsal_status;
if(pname == NULL || utf8str == NULL)
return FALSE;
if(utf82str(tmpstr, sizeof(tmpstr), utf8str) == -1)
return FALSE;
fsal_status = FSAL_str2name(tmpstr, FSAL_MAX_NAME_LEN, pname);
if(fsal_status.major != ERR_FSAL_NO_ERROR)
return FALSE;
return TRUE;
} /* fsal_internal_proxy_fsal_utf8_2_name */
void add_dir(fsal_posixdb_conn * p_conn, char *path, posixfsal_handle_t * p_dir_handle)
{
DIR *dirp;
struct dirent *dp;
struct dirent dpe;
posixfsal_handle_t new_handle;
struct stat buffstat;
char path_temp[FSAL_MAX_PATH_LEN];
fsal_status_t st;
fsal_posixdb_fileinfo_t info;
fsal_name_t fsalname;
if((dirp = opendir(path)))
{
while(!readdir_r(dirp, &dpe, &dp) && dp)
{
if(!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
continue;
if(!strcmp(dp->d_name, ".snapshot"))
{
fputs("(ignoring .snapshot)", stderr);
continue;
}
strcpy(path_temp, path);
strcat(path_temp, dp->d_name);
lstat(path_temp, &buffstat);
fsal_internal_posix2posixdb_fileinfo(&buffstat, &info);
FSAL_str2name(dp->d_name, FSAL_MAX_NAME_LEN, &fsalname);
st = fsal_internal_posixdb_add_entry(p_conn, &fsalname, &info, p_dir_handle,
&new_handle);
if(FSAL_IS_ERROR(st))
{
fprintf(stderr, "[Error %i/%i]\n", st.major, st.minor);
return;
}
if(S_ISDIR(buffstat.st_mode))
{
strcat(path_temp, "/");
add_dir(p_conn, path_temp, &new_handle);
}
};
closedir(dirp);
}
}
fsal_status_t XFSFSAL_readdir(fsal_dir_t * dir_descriptor, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_cookie_t startposition, /* IN */
fsal_attrib_mask_t get_attr_mask, /* IN */
fsal_mdsize_t buffersize, /* IN */
fsal_dirent_t * p_pdirent, /* OUT */
fsal_cookie_t * end_position, /* OUT */
fsal_count_t * p_nb_entries, /* OUT */
fsal_boolean_t * p_end_of_dir /* OUT */
)
{
xfsfsal_dir_t * p_dir_descriptor = (xfsfsal_dir_t * ) dir_descriptor;
xfsfsal_cookie_t start_position;
xfsfsal_cookie_t * p_end_position = (xfsfsal_cookie_t *) end_position;
fsal_status_t st;
fsal_count_t max_dir_entries;
char buff[BUF_SIZE];
struct linux_dirent *dp = NULL;
int bpos = 0;
int rc = 0;
memset(buff, 0, BUF_SIZE);
/*****************/
/* sanity checks */
/*****************/
if(!p_dir_descriptor || !p_pdirent || !p_end_position || !p_nb_entries || !p_end_of_dir)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
max_dir_entries = (buffersize / sizeof(fsal_dirent_t));
/***************************/
/* seek into the directory */
/***************************/
memcpy( (char *)&start_position.data.cookie, (char *)&startposition.data, sizeof( off_t ) ) ;
rc = errno = 0;
lseek(p_dir_descriptor->fd, start_position.data.cookie, SEEK_SET);
rc = errno;
if(rc)
Return(posix2fsal_error(rc), rc, INDEX_FSAL_readdir);
/************************/
/* browse the directory */
/************************/
*p_nb_entries = 0;
while(*p_nb_entries < max_dir_entries)
{
/***********************/
/* read the next entry */
/***********************/
TakeTokenFSCall();
rc = syscall(SYS_getdents, p_dir_descriptor->fd, buff, BUF_SIZE);
ReleaseTokenFSCall();
if(rc < 0)
{
rc = errno;
Return(posix2fsal_error(rc), rc, INDEX_FSAL_readdir);
}
/* End of directory */
if(rc == 0)
{
*p_end_of_dir = 1;
break;
}
/***********************************/
/* Get information about the entry */
/***********************************/
for(bpos = 0; bpos < rc;)
{
dp = (struct linux_dirent *)(buff + bpos);
bpos += dp->d_reclen;
/* LogFullDebug(COMPONENT_FSAL, "\tino=%8ld|%8lx off=%d|%x reclen=%d|%x name=%s|%d", dp->d_ino, dp->d_ino, (int)dp->d_off, (int)dp->d_off,
dp->d_reclen, dp->d_reclen, dp->d_name, (int)dp->d_name[0] ) ; */
if(!(*p_nb_entries < max_dir_entries))
break;
/* skip . and .. */
if(!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
continue;
/* build the full path of the file into "fsalpath */
if(FSAL_IS_ERROR
(st =
FSAL_str2name(dp->d_name, FSAL_MAX_NAME_LEN,
&(p_pdirent[*p_nb_entries].name))))
ReturnStatus(st, INDEX_FSAL_readdir);
p_pdirent[*p_nb_entries].attributes.asked_attributes = get_attr_mask;
st = xfsfsal_stat_by_name((fsal_op_context_t *)&(p_dir_descriptor->context),
p_dir_descriptor->fd, dp->d_name,
&p_pdirent[*p_nb_entries].handle,
&p_pdirent[*p_nb_entries].attributes);
if(FSAL_IS_ERROR(st))
ReturnStatus(st, INDEX_FSAL_readdir);
((xfsfsal_cookie_t *) (&p_pdirent[*p_nb_entries].cookie))->data.cookie = dp->d_off;
p_pdirent[*p_nb_entries].nextentry = NULL;
if(*p_nb_entries)
p_pdirent[*p_nb_entries - 1].nextentry = &(p_pdirent[*p_nb_entries]);
memcpy((char *)p_end_position, (char *)&p_pdirent[*p_nb_entries].cookie,
sizeof(xfsfsal_cookie_t));
(*p_nb_entries)++;
} /* for */
} /* While */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_readdir);
}
/**
* FSAL_readdir :
* Read the entries of an opened directory.
*
* \param dir_descriptor (input):
* Pointer to the directory descriptor filled by FSAL_opendir.
* \param start_position (input):
* Cookie that indicates the first object to be read during
* this readdir operation.
* This should be :
* - FSAL_READDIR_FROM_BEGINNING for reading the content
* of the directory from the beginning.
* - The end_position parameter returned by the previous
* call to FSAL_readdir.
* \param get_attr_mask (input)
* Specify the set of attributes to be retrieved for directory entries.
* \param buffersize (input)
* The size (in bytes) of the buffer where
* the direntries are to be stored.
* \param pdirent (output)
* Adresse of the buffer where the direntries are to be stored.
* \param end_position (output)
* Cookie that indicates the current position in the directory.
* \param nb_entries (output)
* Pointer to the number of entries read during the call.
* \param end_of_dir (output)
* Pointer to a boolean that indicates if the end of dir
* has been reached during the call.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - Another error code if an error occured.
*/
fsal_status_t LUSTREFSAL_readdir(fsal_dir_t *dir_desc, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_cookie_t start_pos, /* IN */
fsal_attrib_mask_t get_attr_mask, /* IN */
fsal_mdsize_t buffersize, /* IN */
fsal_dirent_t * p_pdirent, /* OUT */
fsal_cookie_t * p_end_position, /* OUT */
fsal_count_t * p_nb_entries, /* OUT */
fsal_boolean_t * p_end_of_dir /* OUT */
)
{
fsal_status_t st;
fsal_count_t max_dir_entries;
struct dirent *dp;
struct dirent dpe;
fsal_path_t fsalpath;
int rc;
lustrefsal_dir_t * p_dir_descriptor = (lustrefsal_dir_t *)dir_desc;
lustrefsal_cookie_t start_position;
/*****************/
/* sanity checks */
/*****************/
if(!p_dir_descriptor || !p_pdirent || !p_end_position || !p_nb_entries || !p_end_of_dir)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
max_dir_entries = (buffersize / sizeof(fsal_dirent_t));
memcpy( (char *)& start_position.data.cookie, (char *)&start_pos.data, sizeof( off_t ) ) ;
/***************************/
/* seek into the directory */
/***************************/
errno = 0;
if(start_position.data.cookie == 0)
{
rewinddir(p_dir_descriptor->p_dir);
rc = errno;
}
else
{
seekdir(p_dir_descriptor->p_dir, start_position.data.cookie);
rc = errno;
}
if(rc)
Return(posix2fsal_error(rc), rc, INDEX_FSAL_readdir);
/************************/
/* browse the directory */
/************************/
*p_nb_entries = 0;
while(*p_nb_entries < max_dir_entries)
{
/***********************/
/* read the next entry */
/***********************/
TakeTokenFSCall();
rc = readdir_r(p_dir_descriptor->p_dir, &dpe, &dp);
ReleaseTokenFSCall();
if(rc)
{
rc = errno;
Return(posix2fsal_error(rc), rc, INDEX_FSAL_readdir);
}
/* End of directory */
if(!dp)
{
*p_end_of_dir = 1;
break;
}
/***********************************/
/* Get information about the entry */
/***********************************/
/* skip . and .. */
if(!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
continue;
/* build the full path of the file into "fsalpath */
if(FSAL_IS_ERROR
(st =
FSAL_str2name(dp->d_name, FSAL_MAX_NAME_LEN, &(p_pdirent[*p_nb_entries].name))))
ReturnStatus(st, INDEX_FSAL_readdir);
memcpy(&fsalpath, &(p_dir_descriptor->path), sizeof(fsal_path_t));
st = fsal_internal_appendNameToPath(&fsalpath, &(p_pdirent[*p_nb_entries].name));
if(FSAL_IS_ERROR(st))
ReturnStatus(st, INDEX_FSAL_readdir);
/* get object handle */
TakeTokenFSCall();
st = fsal_internal_Path2Handle((fsal_op_context_t *) &p_dir_descriptor->context, &fsalpath,
&(p_pdirent[*p_nb_entries].handle));
ReleaseTokenFSCall();
if(FSAL_IS_ERROR(st))
ReturnStatus(st, INDEX_FSAL_readdir);
/************************
* Fills the attributes *
************************/
p_pdirent[*p_nb_entries].attributes.asked_attributes = get_attr_mask;
st = LUSTREFSAL_getattrs(&(p_pdirent[*p_nb_entries].handle),
(fsal_op_context_t *) &p_dir_descriptor->context,
&p_pdirent[*p_nb_entries].attributes);
if(FSAL_IS_ERROR(st))
{
FSAL_CLEAR_MASK(p_pdirent[*p_nb_entries].attributes.asked_attributes);
FSAL_SET_MASK(p_pdirent[*p_nb_entries].attributes.asked_attributes,
FSAL_ATTR_RDATTR_ERR);
}
((lustrefsal_cookie_t *) (&p_pdirent[*p_nb_entries].cookie))->data.cookie = telldir(p_dir_descriptor->p_dir);
p_pdirent[*p_nb_entries].nextentry = NULL;
if(*p_nb_entries)
p_pdirent[*p_nb_entries - 1].nextentry = &(p_pdirent[*p_nb_entries]);
memcpy((char *)p_end_position, (char *)&p_pdirent[*p_nb_entries].cookie,
sizeof(lustrefsal_cookie_t));
(*p_nb_entries)++;
}
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_readdir);
}
int nfs_Create(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
char *str_file_name = NULL;
fsal_name_t file_name;
fsal_accessmode_t mode = 0;
cache_entry_t *file_pentry = NULL;
cache_entry_t *parent_pentry = NULL;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t attr;
fsal_attrib_list_t attr_parent_after;
fsal_attrib_list_t attr_newfile;
fsal_attrib_list_t attributes_create;
fsal_attrib_list_t *ppre_attr;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
cache_inode_status_t cache_status_lookup;
cache_inode_file_type_t parent_filetype;
int rc = NFS_REQ_OK;
#ifdef _USE_QUOTA
fsal_status_t fsal_status ;
#endif
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
str_file_name = parg->arg_create2.where.name;
break;
case NFS_V3:
str_file_name = parg->arg_create3.where.name;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_create2.where.dir),
&(parg->arg_create3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Create handle: %s name: %s",
str, str_file_name);
}
if((preq->rq_vers == NFS_V3) && (nfs3_Is_Fh_Xattr(&(parg->arg_create3.where.dir))))
{
rc = nfs3_Create_Xattr(parg, pexport, pcontext, preq, pres);
goto out;
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_create3.CREATE3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_create3.CREATE3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
}
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_create2.where.dir),
&(parg->arg_create3.where.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_create3.status),
NULL,
&parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
goto out;
}
/* get directory attributes before action (for V3 reply) */
ppre_attr = &parent_attr;
/* Extract the filetype */
parent_filetype = cache_inode_fsal_type_convert(parent_attr.type);
/*
* Sanity checks: new file name must be non-null; parent must be a
* directory.
*/
if(parent_filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_create3.status = NFS3ERR_NOTDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
switch (preq->rq_vers)
{
case NFS_V2:
str_file_name = parg->arg_create2.where.name;
if(parg->arg_create2.attributes.mode != (unsigned int)-1)
{
mode = unix2fsal_mode(parg->arg_create2.attributes.mode);
}
else
{
mode = 0;
}
break;
case NFS_V3:
str_file_name = parg->arg_create3.where.name;
if(parg->arg_create3.how.mode == EXCLUSIVE)
{
/*
* Client has not provided mode information.
* If the create works, the client will issue
* a separate setattr request to fix up the
* file's mode, so pick arbitrary value for now.
*/
mode = 0;
}
else if(parg->arg_create3.how.createhow3_u.obj_attributes.mode.set_it == TRUE)
mode =
unix2fsal_mode(parg->arg_create3.how.createhow3_u.obj_attributes.mode.
set_mode3_u.mode);
else
mode = 0;
break;
}
#ifdef _USE_QUOTA
/* if quota support is active, then we should check is the FSAL allows inode creation or not */
fsal_status = FSAL_check_quota( pexport->fullpath,
FSAL_QUOTA_INODES,
FSAL_OP_CONTEXT_TO_UID( pcontext ) ) ;
if( FSAL_IS_ERROR( fsal_status ) )
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_DQUOT ;
break;
case NFS_V3:
pres->res_create3.status = NFS3ERR_DQUOT;
break;
}
rc = NFS_REQ_OK ;
goto out;
}
#endif /* _USE_QUOTA */
// if(str_file_name == NULL || strlen(str_file_name) == 0)
if(str_file_name == NULL || *str_file_name == '\0' )
{
if(preq->rq_vers == NFS_V2)
pres->res_dirop2.status = NFSERR_IO;
if(preq->rq_vers == NFS_V3)
pres->res_create3.status = NFS3ERR_INVAL;
}
else
{
if((cache_status = cache_inode_error_convert(FSAL_str2name(str_file_name,
FSAL_MAX_NAME_LEN,
&file_name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup file to see if it exists. If so, use it. Otherwise
* create a new one.
*/
file_pentry = cache_inode_lookup(parent_pentry,
&file_name,
&attr,
pcontext,
&cache_status_lookup);
if((cache_status_lookup == CACHE_INODE_NOT_FOUND) ||
((cache_status_lookup == CACHE_INODE_SUCCESS)
&& (parg->arg_create3.how.mode == UNCHECKED)))
{
/* Create the file */
if((parg->arg_create3.how.mode == UNCHECKED)
&& (cache_status_lookup == CACHE_INODE_SUCCESS))
{
cache_status = CACHE_INODE_SUCCESS;
attr_newfile = attr;
}
else
file_pentry = cache_inode_create(parent_pentry,
&file_name,
REGULAR_FILE,
mode,
NULL,
&attr_newfile,
pcontext, &cache_status);
if(file_pentry != NULL)
{
/*
* Look at sattr to see if some attributes are to be set at creation time
*/
attributes_create.asked_attributes = 0ULL;
switch (preq->rq_vers)
{
case NFS_V2:
if(nfs2_Sattr_To_FSALattr(&attributes_create,
&parg->arg_create2.attributes) == 0)
{
pres->res_dirop2.status = NFSERR_IO;
rc = NFS_REQ_OK;
goto out;
break;
}
break;
case NFS_V3:
if(nfs3_Sattr_To_FSALattr(&attributes_create,
&parg->arg_create3.how.createhow3_u.
obj_attributes) == 0)
{
pres->res_create3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
break;
}
/* Mode is managed above (in cache_inode_create), there is no need
* to manage it */
if(attributes_create.asked_attributes & FSAL_ATTR_MODE)
attributes_create.asked_attributes &= ~FSAL_ATTR_MODE;
/* Some clients (like Solaris 10) try to set the size of the file to 0
* at creation time. The FSAL create empty file, so we ignore this */
if(attributes_create.asked_attributes & FSAL_ATTR_SIZE)
attributes_create.asked_attributes &= ~FSAL_ATTR_SIZE;
if(attributes_create.asked_attributes & FSAL_ATTR_SPACEUSED)
attributes_create.asked_attributes &= ~FSAL_ATTR_SPACEUSED;
/* Are there attributes to be set (additional to the mode) ? */
if(attributes_create.asked_attributes != 0ULL &&
attributes_create.asked_attributes != FSAL_ATTR_MODE)
{
/* A call to cache_inode_setattr is required */
if(cache_inode_setattr(file_pentry,
&attributes_create,
pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
/* If we are here, there was an error */
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_create3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_create3.CREATE3res_u.resfail.
dir_wcc), NULL, NULL, NULL);
if(nfs_RetryableError(cache_status)) {
rc = NFS_REQ_DROP;
goto out;
}
rc = NFS_REQ_OK;
goto out;
}
/* Get the resulting attributes from the Cache Inode */
if(cache_inode_getattr(file_pentry,
&attr_newfile,
pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
/* If we are here, there was an error */
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_create3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_create3.CREATE3res_u.resfail.
dir_wcc), NULL, NULL, NULL);
if(nfs_RetryableError(cache_status)) {
rc = NFS_REQ_DROP;
goto out;
}
rc = NFS_REQ_OK;
goto out;
}
}
switch (preq->rq_vers)
{
case NFS_V2:
/* Build file handle */
if(nfs2_FSALToFhandle(
&(pres->res_dirop2.DIROP2res_u.diropok.file),
&file_pentry->handle,
pexport) == 0)
pres->res_dirop2.status = NFSERR_IO;
else
{
if(!nfs2_FSALattr_To_Fattr(
pexport, &attr_newfile,
&(pres->res_dirop2.DIROP2res_u.
diropok.attributes)))
pres->res_dirop2.status = NFSERR_IO;
else
pres->res_dirop2.status = NFS_OK;
}
break;
case NFS_V3:
/* Build file handle */
pres->res_create3.status =
nfs3_AllocateFH(&pres->res_create3.CREATE3res_u
.resok.obj.post_op_fh3_u.handle);
if (pres->res_create3.status != NFS3_OK)
{
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
if(nfs3_FSALToFhandle(
&(pres->res_create3.CREATE3res_u.resok
.obj.post_op_fh3_u.handle),
&file_pentry->handle, pexport) == 0)
{
gsh_free(pres->res_create3.CREATE3res_u.resok.obj.
post_op_fh3_u.handle.data.data_val);
pres->res_create3.status = NFS3ERR_BADHANDLE;
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
pres->res_create3.CREATE3res_u.resok.obj.handle_follows
= TRUE;
/* Get the attributes of the parent after the
operation */
attr_parent_after = parent_pentry->attributes;
/* Build entry attributes */
nfs_SetPostOpAttr(pexport,
&attr_newfile,
&(pres->res_create3.CREATE3res_u.resok.
obj_attributes));
/*
* Build Weak Cache Coherency data
*/
nfs_SetWccData(pexport,
ppre_attr,
&attr_parent_after,
&(pres->res_create3.CREATE3res_u
.resok.dir_wcc));
pres->res_create3.status = NFS3_OK;
break;
} /* switch */
rc = NFS_REQ_OK;
goto out;
}
}
else
{
if(cache_status_lookup == CACHE_INODE_SUCCESS)
{
/* Trying to create a file that already exists */
cache_status = CACHE_INODE_ENTRY_EXISTS;
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_EXIST;
break;
case NFS_V3:
pres->res_create3.status = NFS3ERR_EXIST;
break;
}
}
else
{
/* Server fault */
cache_status = cache_status_lookup;
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_IO;
break;
case NFS_V3:
pres->res_create3.status = NFS3ERR_INVAL;
break;
}
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_create3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_create3.CREATE3res_u.resfail.dir_wcc),
NULL, NULL, NULL);
rc = NFS_REQ_OK;
goto out;
} /* if( cache_status_lookup == CACHE_INODE_NOT_FOUND ) */
}
}
/* Set the exit status */
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_create3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_create3.CREATE3res_u.resfail.dir_wcc),
NULL, NULL, NULL);
/* If we are here, there was an error */
if(nfs_RetryableError(cache_status))
{
rc = NFS_REQ_DROP;
goto out;
}
rc = NFS_REQ_OK;
out:
/* return references */
if (file_pentry)
cache_inode_put(file_pentry);
if (parent_pentry)
cache_inode_put(parent_pentry);
return (rc);
} /* nfs_Create */
/**
* Retrieves the list of extended attributes for an object in the filesystem.
*
* \param p_objecthandle Handle of the object we want to get extended attributes.
* \param cookie index of the next entry to be returned.
* \param p_context pointer to the current security context.
* \param xattrs_tab a table for storing extended attributes list to.
* \param xattrs_tabsize the maximum number of xattr entries that xattrs_tab
* can contain.
* \param p_nb_returned the number of xattr entries actually stored in xattrs_tab.
* \param end_of_list this boolean indicates that the end of xattrs list has been reached.
*/
fsal_status_t dpmfsal_ListXAttrs(fsal_handle_t * p_objecthandle, // IN
unsigned int cookie, // IN
fsal_op_context_t * p_context, // IN
fsal_xattrent_t * xattrs_tab, // IN/OUT
unsigned int xattrs_tabsize, // IN
unsigned int *p_nb_returned, // OUT
int *end_of_list // OUT
)
{
unsigned int index;
unsigned int out_index;
fsal_status_t st;
fsal_attrib_list_t file_attrs;
LogInfo(COMPONENT_FSAL, "dpmfsal_ListXAttrs: start");
/* sanity checks */
if (!p_objecthandle || !p_context || !xattrs_tab || !p_nb_returned || !end_of_list)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_ListXAttrs);
/* object attributes we want to retrieve from parent */
file_attrs.asked_attributes = FSAL_ATTR_MODE | FSAL_ATTR_FILEID
| FSAL_ATTR_OWNER | FSAL_ATTR_GROUP | FSAL_ATTR_ATIME
| FSAL_ATTR_MTIME | FSAL_ATTR_CTIME | FSAL_ATTR_CREATION
| FSAL_ATTR_CHGTIME | FSAL_ATTR_FSID;
/* don't retrieve unsupported attributes */
file_attrs.asked_attributes &= global_fs_info.supported_attrs;
st = FSAL_getattrs(p_objecthandle, p_context, &file_attrs);
if (FSAL_IS_ERROR(st))
Return(st.major, st.minor, INDEX_FSAL_ListXAttrs);
for (index = cookie, out_index = 0; index < XATTR_COUNT && out_index
< xattrs_tabsize; index++) {
if (do_match_type(xattr_list[index].flags,
p_objecthandle->data.ntype)) {
/* fills an xattr entry */
xattrs_tab[out_index].xattr_id = index;
FSAL_str2name(xattr_list[index].xattr_name, FSAL_MAX_NAME_LEN,
&xattrs_tab[out_index].xattr_name);
xattrs_tab[out_index].xattr_cookie = index + 1;
/* set asked attributes (all supported) */
xattrs_tab[out_index].attributes.asked_attributes
= global_fs_info.supported_attrs;
if (file_attributes_to_xattr_attrs(&file_attrs,
&xattrs_tab[out_index].attributes, index)) {
/* set error flag */
xattrs_tab[out_index].attributes.asked_attributes
= FSAL_ATTR_RDATTR_ERR;
}
/* next output slot */
out_index++;
}
}
*p_nb_returned = out_index;
*end_of_list = (index == XATTR_COUNT);
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_ListXAttrs);
}
fsal_status_t HPSSFSAL_readdir(hpssfsal_dir_t * dir_descriptor, /* IN */
fsal_op_context_t * p_context, /* IN */
hpssfsal_cookie_t start_position, /* IN */
fsal_attrib_mask_t get_attr_mask, /* IN */
fsal_mdsize_t buffersize, /* IN */
fsal_dirent_t * pdirent, /* OUT */
hpssfsal_cookie_t * end_position, /* OUT */
fsal_count_t * nb_entries, /* OUT */
fsal_boolean_t * end_of_dir /* OUT */ )
{
int rc, returned, i;
fsal_status_t st;
fsal_attrib_mask_t handle_attr_mask;
fsal_count_t current_nb_entries, missing_entries, max_dir_entries;
/* hpss_ReadRawAttrsHandle arguments. */
u_signed64 curr_start_position;
unsigned32 buff_size_in;
unsigned32 bool_getattr_in;
unsigned32 bool_eod_out;
u_signed64 last_offset_out;
//ns_DirEntry_t outbuff[FSAL_READDIR_SIZE];
ns_DirEntry_t * outbuff = NULL ;
/* sanity checks */
if(!dir_descriptor || !pdirent || !end_position || !nb_entries || !end_of_dir)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
if((outbuff = gsh_calloc(FSAL_READDIR_SIZE, sizeof(ns_DirEntry_t))) == NULL)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
/* handle provides : suppattr, type, fileid */
/** @todo : does handle provide mounted_on_fileid ? */
handle_attr_mask = FSAL_ATTR_SUPPATTR | FSAL_ATTR_TYPE | FSAL_ATTR_FILEID;
/* if the handle cannot provide the requested attributes,
* we have to retrieve file attributes. */
if(get_attr_mask & (~handle_attr_mask))
bool_getattr_in = TRUE;
else
bool_getattr_in = FALSE;
/* init values */
curr_start_position = start_position.data;
bool_eod_out = 0;
current_nb_entries = 0;
max_dir_entries = (buffersize / sizeof(fsal_dirent_t));
/* while we haven't filled the output buffer
* and the end of dir has not been reached :
*/
while((current_nb_entries < max_dir_entries) && (!bool_eod_out))
{
missing_entries = max_dir_entries - current_nb_entries;
/* If the requested count is smaller than the default FSAL_READDIR_SIZE,
* we use a smaller output buffer.
*/
if(missing_entries < FSAL_READDIR_SIZE)
buff_size_in = missing_entries * sizeof(ns_DirEntry_t);
else
buff_size_in = FSAL_READDIR_SIZE * sizeof(ns_DirEntry_t);
/* call to hpss clapi */
TakeTokenFSCall();
rc = HPSSFSAL_ReadRawAttrsHandle(&(dir_descriptor->dir_handle.data.ns_handle),
curr_start_position,
&dir_descriptor->context.credential.hpss_usercred,
buff_size_in,
bool_getattr_in,
ReturnInconsistentDirent,
&bool_eod_out, &last_offset_out, outbuff);
ReleaseTokenFSCall();
if(rc < 0)
{
gsh_free( outbuff ) ;
Return(hpss2fsal_error(rc), -rc, INDEX_FSAL_readdir);
}
else
returned = rc;
/* Fills the fsal dirent list. */
for(i = 0; i < returned; i++)
{
memset( (char *)&(pdirent[current_nb_entries].handle), 0, sizeof( hpssfsal_handle_t ) ) ;
pdirent[current_nb_entries].handle.data.ns_handle = outbuff[i].ObjHandle;
pdirent[current_nb_entries].handle.data.obj_type =
hpss2fsal_type(outbuff[i].ObjHandle.Type);
st = FSAL_str2name((char *)outbuff[i].Name, HPSS_MAX_FILE_NAME,
&pdirent[current_nb_entries].name);
/** @todo : test returned status */
pdirent[current_nb_entries].cookie.data = outbuff[i].ObjOffset;
/* set asked attributes */
pdirent[current_nb_entries].attributes.asked_attributes = get_attr_mask;
if(bool_getattr_in)
{
/* convert HPSS attributes to fsal attributes */
st = hpss2fsal_attributes(&outbuff[i].ObjHandle,
&outbuff[i].Attrs,
&pdirent[current_nb_entries].attributes);
/* on error, we set a special bit in the mask. */
if(FSAL_IS_ERROR(st))
{
FSAL_CLEAR_MASK(pdirent[current_nb_entries].attributes.
asked_attributes);
FSAL_SET_MASK(pdirent[current_nb_entries].attributes.asked_attributes,
FSAL_ATTR_RDATTR_ERR);
}
}
else if(get_attr_mask)
{
/* extract asked attributes from file handle */
st = hpssHandle2fsalAttributes(&outbuff[i].ObjHandle,
&pdirent[current_nb_entries].attributes);
/* on error, we set a special bit in the mask. */
if(FSAL_IS_ERROR(st))
{
FSAL_CLEAR_MASK(pdirent[current_nb_entries].attributes.
asked_attributes);
FSAL_SET_MASK(pdirent[current_nb_entries].attributes.asked_attributes,
FSAL_ATTR_RDATTR_ERR);
}
}
/* set the previous' next */
if(current_nb_entries)
pdirent[current_nb_entries - 1].nextentry = &(pdirent[current_nb_entries]);
/* current's next */
pdirent[current_nb_entries].nextentry = NULL;
/* increment entries count */
current_nb_entries++;
curr_start_position = last_offset_out;
}
}
/* At this point, 2 cases :
* - the requested count is reached
* - the end of dir is reached.
* However, the treatment is the same.
*/
/* setting output vars. */
/* if no item was read, the offset keeps the same. */
end_position->data = (current_nb_entries == 0 ? start_position.data : last_offset_out);
*nb_entries = current_nb_entries;
*end_of_dir = (bool_eod_out ? TRUE : FALSE);
LogDebug(COMPONENT_FSAL, "%s() returned %u entries, end_of_dir=%d", __func__, *nb_entries, *end_of_dir);
gsh_free( outbuff ) ;
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_readdir); /* @todo badly set fsal_log ? */
}
int nfs_Mkdir(nfs_arg_t * parg,
exportlist_t * pexport,
fsal_op_context_t * pcontext,
cache_inode_client_t * pclient,
hash_table_t * ht, struct svc_req *preq, nfs_res_t * pres)
{
static char __attribute__ ((__unused__)) funcName[] = "nfs_Mkdir";
char *str_dir_name = NULL;
fsal_accessmode_t mode = 0;
cache_entry_t *dir_pentry = NULL;
cache_entry_t *parent_pentry = NULL;
int rc = 0;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t attr;
fsal_attrib_list_t *ppre_attr;
fsal_attrib_list_t attr_parent_after;
cache_inode_file_type_t parent_filetype;
fsal_handle_t *pfsal_handle;
fsal_name_t dir_name;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
cache_inode_status_t cache_status_lookup;
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
str_dir_name = parg->arg_mkdir2.where.name;
break;
case NFS_V3:
str_dir_name = parg->arg_mkdir3.where.name;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_mkdir2.where.dir),
&(parg->arg_mkdir3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Mkdir handle: %s name: %s",
str, str_dir_name);
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
}
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_mkdir2.where.dir),
&(parg->arg_mkdir3.where.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_mkdir3.status),
NULL,
&parent_attr,
pcontext, pclient, ht, &rc)) == NULL)
{
/* Stale NFS FH ? */
return rc;
}
/* get directory attributes before action (for V3 reply) */
ppre_attr = &parent_attr;
/* Extract the filetype */
parent_filetype = cache_inode_fsal_type_convert(parent_attr.type);
/*
* Sanity checks:
*/
if(parent_filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_mkdir3.status = NFS3ERR_NOTDIR;
break;
}
return NFS_REQ_OK;
}
switch (preq->rq_vers)
{
case NFS_V2:
str_dir_name = parg->arg_mkdir2.where.name;
if(parg->arg_mkdir2.attributes.mode != (unsigned int)-1)
{
mode = (fsal_accessmode_t) parg->arg_mkdir2.attributes.mode;
}
else
{
mode = (fsal_accessmode_t) 0;
}
break;
case NFS_V3:
str_dir_name = parg->arg_mkdir3.where.name;
if(parg->arg_mkdir3.attributes.mode.set_it == TRUE)
mode = (fsal_accessmode_t) parg->arg_mkdir3.attributes.mode.set_mode3_u.mode;
else
mode = (fsal_accessmode_t) 0;
break;
}
//if(str_dir_name == NULL || strlen(str_dir_name) == 0)
if(str_dir_name == NULL || *str_dir_name == '\0' )
{
if(preq->rq_vers == NFS_V2)
pres->res_dirop2.status = NFSERR_IO;
if(preq->rq_vers == NFS_V3)
pres->res_mkdir3.status = NFS3ERR_INVAL;
}
else
{
/* Make the directory */
if((cache_status = cache_inode_error_convert(FSAL_str2name(str_dir_name,
FSAL_MAX_NAME_LEN,
&dir_name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup file to see if it exists. If so, use it. Otherwise
* create a new one.
*/
dir_pentry = cache_inode_lookup( parent_pentry,
&dir_name,
pexport->cache_inode_policy,
&attr,
ht,
pclient,
pcontext,
&cache_status_lookup);
if(cache_status_lookup == CACHE_INODE_NOT_FOUND)
{
/* Create the directory */
if((dir_pentry = cache_inode_create(parent_pentry,
&dir_name,
DIRECTORY,
pexport->cache_inode_policy,
mode,
NULL,
&attr,
ht,
pclient,
pcontext, &cache_status)) != NULL)
{
/*
* Get the FSAL handle for this entry
*/
pfsal_handle = cache_inode_get_fsal_handle(dir_pentry, &cache_status);
if(cache_status == CACHE_INODE_SUCCESS)
{
switch (preq->rq_vers)
{
case NFS_V2:
/* Build file handle */
if(!nfs2_FSALToFhandle
(&(pres->res_dirop2.DIROP2res_u.diropok.file), pfsal_handle,
pexport))
pres->res_dirop2.status = NFSERR_IO;
else
{
/*
* Build entry
* attributes
*/
if(nfs2_FSALattr_To_Fattr(pexport, &attr,
&(pres->res_dirop2.DIROP2res_u.
diropok.attributes)) == 0)
pres->res_dirop2.status = NFSERR_IO;
else
pres->res_dirop2.status = NFS_OK;
}
break;
case NFS_V3:
/* Build file handle */
if((pres->res_mkdir3.MKDIR3res_u.resok.obj.post_op_fh3_u.
handle.data.data_val = Mem_Alloc_Label(NFS3_FHSIZE,
"Filehandle V3 in nfs3_mkdir")) == NULL)
{
pres->res_mkdir3.status = NFS3ERR_IO;
return NFS_REQ_OK;
}
if(nfs3_FSALToFhandle
(&pres->res_mkdir3.MKDIR3res_u.resok.obj.post_op_fh3_u.
handle, pfsal_handle, pexport) == 0)
{
Mem_Free((char *)pres->res_mkdir3.MKDIR3res_u.resok.obj.
post_op_fh3_u.handle.data.data_val);
pres->res_mkdir3.status = NFS3ERR_INVAL;
return NFS_REQ_OK;
}
else
{
/* Set Post Op Fh3 structure */
pres->res_mkdir3.MKDIR3res_u.resok.obj.handle_follows =
TRUE;
pres->res_mkdir3.MKDIR3res_u.resok.obj.post_op_fh3_u.handle.
data.data_len = sizeof(file_handle_v3_t);
/*
* Build entry
* attributes
*/
nfs_SetPostOpAttr(pcontext, pexport,
dir_pentry,
&attr,
&(pres->res_mkdir3.MKDIR3res_u.resok.
obj_attributes));
/* Get the attributes of the parent after the operation */
cache_inode_get_attributes(parent_pentry,
&attr_parent_after);
/*
* Build Weak Cache
* Coherency data
*/
nfs_SetWccData(pcontext, pexport,
parent_pentry,
ppre_attr,
&attr_parent_after,
&(pres->res_mkdir3.MKDIR3res_u.resok.
dir_wcc));
pres->res_mkdir3.status = NFS3_OK;
}
break;
}
return NFS_REQ_OK;
}
}
} /* If( cache_status_lookup == CACHE_INODE_NOT_FOUND ) */
else
{
/* object already exists or failure during lookup */
if(cache_status_lookup == CACHE_INODE_SUCCESS)
{
/* Trying to create a file that already exists */
cache_status = CACHE_INODE_ENTRY_EXISTS;
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_EXIST;
break;
case NFS_V3:
pres->res_mkdir3.status = NFS3ERR_EXIST;
break;
}
}
else
{
/* Server fault */
cache_status = cache_status_lookup;
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_IO;
break;
case NFS_V3:
pres->res_mkdir3.status = NFS3ERR_INVAL;
break;
}
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_mkdir3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc),
NULL, NULL, NULL);
return NFS_REQ_OK;
}
}
}
/* If we are here, there was an error */
if(nfs_RetryableError(cache_status))
{
return NFS_REQ_DROP;
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_mkdir3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc), NULL, NULL, NULL);
return NFS_REQ_OK;
}
/**
* Retrieves the list of extended attributes for an object in the filesystem.
*
* \param p_objecthandle Handle of the object we want to get extended attributes.
* \param cookie index of the next entry to be returned.
* \param p_context pointer to the current security context.
* \param xattrs_tab a table for storing extended attributes list to.
* \param xattrs_tabsize the maximum number of xattr entries that xattrs_tab
* can contain.
* \param p_nb_returned the number of xattr entries actually stored in xattrs_tab.
* \param end_of_list this boolean indicates that the end of xattrs list has been reached.
*/
fsal_status_t ZFSFSAL_ListXAttrs(fsal_handle_t * obj_handle, /* IN */
unsigned int argcookie, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_xattrent_t * xattrs_tab, /* IN/OUT */
unsigned int xattrs_tabsize, /* IN */
unsigned int *p_nb_returned, /* OUT */
int *end_of_list /* OUT */
)
{
unsigned int index;
unsigned int out_index;
fsal_status_t st;
fsal_attrib_list_t file_attrs;
int rc;
creden_t cred;
zfsfsal_handle_t *p_objecthandle = (zfsfsal_handle_t *)obj_handle;
unsigned int cookie = argcookie ;
/* sanity checks */
if(!p_objecthandle || !p_context || !xattrs_tab || !p_nb_returned || !end_of_list)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_ListXAttrs);
/* Deal with special cookie */
if( argcookie == FSAL_XATTR_RW_COOKIE ) cookie = XATTR_COUNT ;
/* object attributes we want to retrieve from parent */
file_attrs.asked_attributes = FSAL_ATTR_MODE | FSAL_ATTR_FILEID | FSAL_ATTR_OWNER
| FSAL_ATTR_GROUP | FSAL_ATTR_ATIME | FSAL_ATTR_MTIME | FSAL_ATTR_TYPE
| FSAL_ATTR_CTIME | FSAL_ATTR_CREATION | FSAL_ATTR_CHGTIME | FSAL_ATTR_FSID;
/* don't retrieve unsuipported attributes */
file_attrs.asked_attributes &= global_fs_info.supported_attrs;
st = ZFSFSAL_getattrs(obj_handle, p_context, &file_attrs);
if(FSAL_IS_ERROR(st))
Return(st.major, st.minor, INDEX_FSAL_ListXAttrs);
/* Get the right VFS */
ZFSFSAL_VFS_RDLock();
libzfswrap_vfs_t *p_vfs = ZFSFSAL_GetVFS(p_objecthandle);
if(!p_vfs)
{
ZFSFSAL_VFS_Unlock();
Return(ERR_FSAL_NOENT, 0, INDEX_FSAL_ListXAttrs);
}
for(index = cookie, out_index = 0;
index < XATTR_COUNT && out_index < xattrs_tabsize; index++)
{
if(do_match_type(xattr_list[index].flags, p_objecthandle->data.type))
{
/* fills an xattr entry */
xattrs_tab[out_index].xattr_id = index;
FSAL_str2name(xattr_list[index].xattr_name, FSAL_MAX_NAME_LEN,
&xattrs_tab[out_index].xattr_name);
xattrs_tab[out_index].xattr_cookie = index + 1;
/* set asked attributes (all supported) */
xattrs_tab[out_index].attributes.asked_attributes =
global_fs_info.supported_attrs;
if(file_attributes_to_xattr_attrs
(&file_attrs, &xattrs_tab[out_index].attributes, index))
{
/* set error flag */
xattrs_tab[out_index].attributes.asked_attributes = FSAL_ATTR_RDATTR_ERR;
}
/* next output slot */
out_index++;
}
}
/* Save a call if the output array is full */
if(out_index == xattrs_tabsize)
{
*end_of_list = FALSE;
*p_nb_returned = out_index;
ZFSFSAL_VFS_Unlock();
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_ListXAttrs);
}
/* List the extended attributes */
char *psz_buffer;
size_t i_size;
cred.uid = p_context->credential.user;
cred.gid = p_context->credential.group;
TakeTokenFSCall();
rc = libzfswrap_listxattr(p_vfs, &cred,
p_objecthandle->data.zfs_handle, &psz_buffer, &i_size);
ReleaseTokenFSCall();
ZFSFSAL_VFS_Unlock();
if(rc)
Return(posix2fsal_error(rc), 0, INDEX_FSAL_ListXAttrs);
if(i_size > 0)
{
size_t len = 0;
char *ptr;
int xattr_idx;
for(ptr = psz_buffer, xattr_idx = 0;
(ptr < psz_buffer + i_size) && (out_index < xattrs_tabsize);
xattr_idx++, ptr += len + 1)
{
len = strlen(ptr);
index = XATTR_COUNT + xattr_idx;
/* Skip if the index is before the cookie */
if(index < cookie)
continue;
xattrs_tab[out_index].xattr_id = index;
FSAL_str2name(ptr, len + 1, &xattrs_tab[out_index].xattr_name);
xattrs_tab[out_index].xattr_cookie = index + 1;
/* set asked attributes (all supported) */
xattrs_tab[out_index].attributes.asked_attributes =
global_fs_info.supported_attrs;
if(file_attributes_to_xattr_attrs(&file_attrs,
&xattrs_tab[out_index].attributes,
index))
{
/* set error flag */
xattrs_tab[out_index].attributes.asked_attributes = FSAL_ATTR_RDATTR_ERR;
}
/* next output slot */
out_index++;
}
/* Every xattrs are in the output array */
if(ptr >= psz_buffer + i_size)
*end_of_list = TRUE;
else
*end_of_list = FALSE;
}
else
*end_of_list = TRUE;
free(psz_buffer);
*p_nb_returned = out_index;
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_ListXAttrs);
}
int nfs_Remove(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
cache_entry_t *parent_pentry = NULL;
cache_entry_t *pentry_child = NULL;
fsal_attrib_list_t pre_parent_attr;
fsal_attrib_list_t pentry_child_attr;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t *pparent_attr = NULL;
cache_inode_file_type_t filetype;
cache_inode_file_type_t childtype;
cache_inode_status_t cache_status;
char *file_name = NULL;
fsal_name_t name;
int rc = NFS_REQ_OK;
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
file_name = parg->arg_remove2.name;
break;
case NFS_V3:
file_name = parg->arg_remove3.object.name;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_create2.where.dir),
&(parg->arg_create3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Remove handle: %s name: %s",
str, file_name);
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_remove3.REMOVE3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_remove3.REMOVE3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
pparent_attr = NULL;
}
/* Convert file handle into a pentry */
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_remove2.dir),
&(parg->arg_remove3.object.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_remove3.status),
NULL,
&pre_parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
goto out;
}
if((preq->rq_vers == NFS_V3) && (nfs3_Is_Fh_Xattr(&(parg->arg_remove3.object.dir)))) {
rc = nfs3_Remove_Xattr(parg, pexport, pcontext, preq, pres);
goto out;
}
/* get directory attributes before action (for V3 reply) */
pparent_attr = &pre_parent_attr;
/* Extract the filetype */
filetype = cache_inode_fsal_type_convert(pre_parent_attr.type);
/*
* Sanity checks: new directory name must be non-null; parent must be
* a directory.
*/
if(filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_remove3.status = NFS3ERR_NOTDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
switch (preq->rq_vers)
{
case NFS_V2:
file_name = parg->arg_remove2.name;
break;
case NFS_V3:
file_name = parg->arg_remove3.object.name;
break;
}
//if(file_name == NULL || strlen(file_name) == 0)
if(file_name == NULL || *file_name == '\0' )
{
cache_status = CACHE_INODE_INVALID_ARGUMENT; /* for lack of better... */
}
else
{
if((cache_status = cache_inode_error_convert(FSAL_str2name(file_name,
0,
&name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup to the child entry to check if it is a directory
*
*/
if((pentry_child = cache_inode_lookup(parent_pentry,
&name,
&pentry_child_attr,
pcontext,
&cache_status)) != NULL)
{
/* Extract the filetype */
childtype = cache_inode_fsal_type_convert(pentry_child_attr.type);
/*
* Sanity check: make sure we are about to remove a directory
*/
if(childtype == DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFSERR_ISDIR;
break;
case NFS_V3:
pres->res_remove3.status = NFS3ERR_ISDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
LogFullDebug(COMPONENT_NFSPROTO,
"==== NFS REMOVE ====> Trying to remove file %s",
name.name);
/*
* Remove the entry.
*/
if(cache_inode_remove(parent_pentry,
&name,
&parent_attr,
pcontext, &cache_status) == CACHE_INODE_SUCCESS)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFS_OK;
break;
case NFS_V3:
/* Build Weak Cache Coherency data */
nfs_SetWccData(pexport,
pparent_attr,
&parent_attr,
&(pres->res_remove3.REMOVE3res_u.resok.dir_wcc));
pres->res_remove3.status = NFS3_OK;
break;
}
rc = NFS_REQ_OK;
goto out;
}
}
}
}
/* If we are here, there was an error */
rc = nfs_SetFailedStatus(pexport, preq->rq_vers, cache_status,
&pres->res_stat2,
&pres->res_remove3.status,
NULL,
pparent_attr,
&(pres->res_remove3.REMOVE3res_u.resfail.dir_wcc),
NULL, NULL);
out:
/* return references */
if (pentry_child)
cache_inode_put(pentry_child);
if (parent_pentry)
cache_inode_put(parent_pentry);
return (rc);
} /* nfs_Remove */
static void fill_dirent(fsal_dirent_t * to_be_filled,
fsal_attrib_mask_t getattr_mask,
const char *name, const struct stat *stbuf, off_t off)
{
fsal_status_t status;
struct stat tmp_statbuff;
int err = FALSE;
fusefsal_handle_t *fill_handle = (fusefsal_handle_t *) &to_be_filled->handle;
if(stbuf)
{
if(stbuf->st_ino == 0)
{
LogDebug(COMPONENT_FSAL,
"WARNING in fill_dirent: Filesystem doesn't provide inode numbers !!!");
}
fill_handle->data.inode = stbuf->st_ino;
fill_handle->data.device = stbuf->st_dev;
FSAL_str2name(name, strlen(name) + 1, &(to_be_filled->name));
((fusefsal_cookie_t *) &to_be_filled->cookie)->data = off;
/* local copy for non "const" calls */
tmp_statbuff = *stbuf;
/* set attributes */
to_be_filled->attributes.asked_attributes = getattr_mask;
status = posix2fsal_attributes(&tmp_statbuff, &to_be_filled->attributes);
LogFullDebug(COMPONENT_FSAL,
"getattr_mask = %X, recupere = %X, status=%d, inode=%llX.%llu, type=%d, posixmode=%#o, mode=%#o",
(unsigned int)getattr_mask, (unsigned int)to_be_filled->attributes.asked_attributes, status.major,
to_be_filled->attributes.fsid.major, to_be_filled->attributes.fileid,
to_be_filled->attributes.type, tmp_statbuff.st_mode,
to_be_filled->attributes.mode);
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(to_be_filled->attributes.asked_attributes);
/* set getattr error bit in attr mask */
FSAL_SET_MASK(to_be_filled->attributes.asked_attributes, FSAL_ATTR_RDATTR_ERR);
err = TRUE;
}
}
/* if any error occured during conversion,
* or if values seem to be inconsistent,
* proceed a lookup afterward */
if(!stbuf
|| (stbuf->st_ino == 0)
|| err
|| to_be_filled->attributes.type == (fsal_nodetype_t) - 1
|| to_be_filled->attributes.mode == 0 || to_be_filled->attributes.numlinks == 0)
{
FSAL_CLEAR_MASK(to_be_filled->attributes.asked_attributes);
/* we only known entry name, we tag it for a later lookup.
*/
fill_handle->data.inode = INODE_TO_BE_COMPLETED;
FSAL_str2name(name, strlen(name) + 1, &(to_be_filled->name));
((fusefsal_cookie_t *) &to_be_filled->cookie)->data = off;
}
} /* fill_dirent */
int main(int argc, char **argv)
{
char localmachine[256];
char *test;
fsal_parameter_t init_param;
fsal_status_t st;
uid_t uid;
fsal_export_context_t export_ctx;
fsal_op_context_t op_ctx;
fsal_handle_t root_handle, handle;
fsal_name_t name;
fsal_path_t path;
fsal_attrib_list_t attribs;
fsal_attrib_mask_t mask;
char tracebuff[256];
if(argc < 2)
{
usage();
exit(-1);
}
test = argv[1];
/* retrieving params */
#ifndef _NO_BUDDY_SYSTEM
BuddyInit(NULL);
#endif
/* init debug */
SetNamePgm("test_fsal");
SetDefaultLogging("TEST");
SetNameFunction("main");
InitLogging();
/* Obtention du nom de la machine */
if(gethostname(localmachine, sizeof(localmachine)) != 0)
{
LogError(COMPONENT_STDOUT,ERR_SYS, ERR_GETHOSTNAME, errno);
exit(1);
}
else
SetNameHost(localmachine);
AddFamilyError(ERR_FSAL, "FSAL related Errors", tab_errstatus_FSAL);
/* prepare fsal_init */
/* 1 - fs specific info */
#ifdef _USE_HPSS_51
init_param.fs_specific_info.behaviors.PrincipalName = FSAL_INIT_FORCE_VALUE;
strcpy(init_param.fs_specific_info.hpss_config.PrincipalName, "hpss_nfs");
init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE;
strcpy(init_param.fs_specific_info.hpss_config.KeytabPath, "/krb5/hpssserver.keytab");
#elif defined _USE_HPSS_62
init_param.fs_specific_info.behaviors.AuthnMech = FSAL_INIT_FORCE_VALUE;
init_param.fs_specific_info.hpss_config.AuthnMech = hpss_authn_mech_krb5;
init_param.fs_specific_info.behaviors.Principal = FSAL_INIT_FORCE_VALUE;
strcpy(init_param.fs_specific_info.Principal, "hpssfs");
init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE;
strcpy(init_param.fs_specific_info.KeytabPath, "/var/hpss/etc/hpss.keytab");
#endif
/* 2-common info (default) */
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxfilesize);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxlink);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxnamelen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxpathlen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, no_trunc);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, chown_restricted);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_insensitive);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_preserving);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, fh_expire_type);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, link_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, symlink_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, named_attr);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, unique_handles);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, lease_time);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, acl_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, cansettime);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, homogenous);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, supported_attrs);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxread);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxwrite);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, umask);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, auth_exportpath_xdev);
/* 3- fsal info */
init_param.fsal_info.max_fs_calls = 0;
/* Init */
if(FSAL_IS_ERROR(st = FSAL_Init(&init_param)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
/* getting creds */
uid = getuid();
LogTest("uid = %d", uid);
st = FSAL_BuildExportContext(&export_ctx, NULL, NULL);
if(FSAL_IS_ERROR(st))
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
st = FSAL_InitClientContext(&op_ctx);
if(FSAL_IS_ERROR(st))
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
st = FSAL_GetClientContext(&op_ctx, &export_ctx, uid, -1, NULL, 0);
if(FSAL_IS_ERROR(st))
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
/* getting root handle */
if(FSAL_IS_ERROR(st = FSAL_lookup(NULL, NULL, &op_ctx, &root_handle, NULL)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &root_handle);
LogTest("Root handle = %s", tracebuff);
/* getting what are the supported attributes */
attribs.asked_attributes = 0;
FSAL_SET_MASK(attribs.asked_attributes, FSAL_ATTR_SUPPATTR);
LogTest("asked attributes :");
printmask(attribs.asked_attributes);
if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&root_handle, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("supported attributes :");
printmask(attribs.supported_attributes);
mask = attribs.supported_attributes;
/* TEST 1 */
if(test[0] == '1')
{
attribs.asked_attributes = 0;
FSAL_SET_MASK(attribs.asked_attributes, FSAL_ATTR_SUPPATTR);
LogTest("asked attributes :");
printmask(attribs.asked_attributes);
if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&root_handle, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("supported attributes :");
/* getting all spported attributes of root */
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&root_handle, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
printattributes(attribs);
}
else
/* TEST 2 */
if(test[0] == '2')
{
/* getting handle and attributes for subdirectory "OSF1_V5" */
if(FSAL_IS_ERROR(st = FSAL_str2name("cea", 4, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookup(&root_handle, &name, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
/* getting handle and attributes for subdirectory "bin" */
if(FSAL_IS_ERROR(st = FSAL_str2name("prot", 5, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
root_handle = handle;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookup(&root_handle, &name, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
/* getting handle and attributes for symlink "AglaePwrSW" */
if(FSAL_IS_ERROR(st = FSAL_str2name("lama", 5, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
root_handle = handle;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookup(&root_handle, &name, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/lama handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
}
else
/* TEST 3 */
if(test[0] == '3')
{
/* lookup root */
if(FSAL_IS_ERROR(st = FSAL_str2path("/", 30, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/ handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
/* lookup path */
if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/lama", 15, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/lama handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
}
else
/* TEST 4 */
if(test[0] == '4')
{
/* readdir on root */
fsal_dir_t dir;
fsal_cookie_t from, to;
fsal_dirent_t entries[READDIR_SIZE];
fsal_count_t number;
fsal_boolean_t eod = FALSE;
int error = FALSE;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_opendir(&root_handle, &op_ctx, &dir, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("'/' attributes :");
/* displaying attributes */
printattributes(attribs);
from = FSAL_READDIR_FROM_BEGINNING;
while(!error && !eod)
{
unsigned int i;
char cookiebuff[256];
snprintCookie(cookiebuff, 256, &from);
LogTest("\nReaddir cookie = %s", cookiebuff);
if(FSAL_IS_ERROR(st = FSAL_readdir(&dir, from,
mask, READDIR_SIZE * sizeof(fsal_dirent_t),
entries, &to, &number, &eod)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
error = TRUE;
}
for(i = 0; (!error) && (i < number); i++)
{
snprintHandle(tracebuff, 256, &entries[i].handle);
snprintCookie(cookiebuff, 256, &entries[i].cookie);
LogTest("\t%s : %s (cookie %s)", tracebuff,
entries[i].name.name, cookiebuff);
}
/* preparing next call */
from = to;
}
LogTest("Fin de boucle : error=%d ; eod=%d", error, eod);
}
else
/* TEST 5 */
if(test[0] == '5')
{
/* readdir on root */
fsal_dir_t dir;
fsal_cookie_t from, to;
fsal_dirent_t entries[READDIR_SIZE];
fsal_count_t number;
fsal_boolean_t eod = FALSE;
int error = FALSE;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_opendir(&root_handle, &op_ctx, &dir, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("'/' attributes :");
/* displaying attributes */
printattributes(attribs);
from = FSAL_READDIR_FROM_BEGINNING;
while(!error && !eod)
{
fsal_dirent_t *curr;
char cookiebuff[256];
snprintCookie(cookiebuff, 256, &from);
LogTest("\nReaddir cookie = %s", cookiebuff);
if(FSAL_IS_ERROR(st = FSAL_readdir(&dir, from,
mask, READDIR_SIZE * sizeof(fsal_dirent_t),
entries, &to, &number, &eod)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
error = TRUE;
}
if(number > 0)
{
curr = entries;
do
{
snprintHandle(tracebuff, 256, &curr->handle);
snprintCookie(cookiebuff, 256, &curr->cookie);
LogTest("\t%s : %s (cookie %s)", tracebuff,
curr->name.name, cookiebuff);
}
while(curr = curr->nextentry);
}
/* preparing next call */
from = to;
}
LogTest("Fin de boucle : error=%d ; eod=%d", error, eod);
}
else
/* TEST 6 */
if(test[0] == '6')
{
/* readdir on root */
fsal_dir_t dir;
fsal_cookie_t from, to;
fsal_dirent_t entries[READDIR_SIZE];
fsal_count_t number;
fsal_boolean_t eod = FALSE;
int error = FALSE;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_opendir(&root_handle, &op_ctx, &dir, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("'/' attributes :");
/* displaying attributes */
printattributes(attribs);
from = FSAL_READDIR_FROM_BEGINNING;
while(!error && !eod)
{
unsigned int i;
snprintCookie(tracebuff, 256, &from);
LogTest("\nReaddir cookie = %s", tracebuff);
st = FSAL_readdir(&dir, from, mask,
READDIR_SIZE * sizeof(fsal_dirent_t),
entries, &to, &number, &eod);
if(FSAL_IS_ERROR(st))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
error = TRUE;
}
/* for each entry, we compare the result of FSAL_access
* to FSAL_test_access. */
for(i = 0; (!error) && (i < number); i++)
{
fsal_status_t st1, st2;
char cookiebuff[256];
snprintHandle(tracebuff, 256, &entries[i].handle);
snprintCookie(cookiebuff, 256, &entries[i].cookie);
LogTest("\t%s : %s (cookie %s)", tracebuff,
entries[i].name.name, cookiebuff);
if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&entries[i].handle, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
/* 1 - test R access */
st1 = FSAL_access(&entries[i].handle, &op_ctx, FSAL_R_OK, NULL);
st2 = FSAL_test_access(&op_ctx, FSAL_R_OK, &attribs);
LogError(COMPONENT_STDOUT, ERR_FSAL, st1.major, st1.minor);
LogError(COMPONENT_STDOUT, ERR_FSAL, st2.major, st2.minor);
if(st1.major != st2.major)
{
LogTest
("Error : different access permissions given by FSAL_access and FSAL_test_access : %d <>%d",
st1.major, st2.major);
}
/* 2 - test W access */
st1 = FSAL_access(&entries[i].handle, &op_ctx, FSAL_W_OK, NULL);
st2 = FSAL_test_access(&op_ctx, FSAL_W_OK, &attribs);
LogError(COMPONENT_STDOUT, ERR_FSAL, st1.major, st1.minor);
LogError(COMPONENT_STDOUT, ERR_FSAL, st2.major, st2.minor);
if(st1.major != st2.major)
{
LogTest
("Error : different access permissions given by FSAL_access and FSAL_test_access : %d <>%d",
st1.major, st2.major);
}
/* 3 - test X access */
st1 = FSAL_access(&entries[i].handle, &op_ctx, FSAL_X_OK, NULL);
st2 = FSAL_test_access(&op_ctx, FSAL_X_OK, &attribs);
LogError(COMPONENT_STDOUT, ERR_FSAL, st1.major, st1.minor);
LogError(COMPONENT_STDOUT, ERR_FSAL, st2.major, st2.minor);
if(st1.major != st2.major)
{
LogTest
("Error : different access permissions given by FSAL_access and FSAL_test_access : %d <>%d",
st1.major, st2.major);
}
}
/* preparing next call */
from = to;
}
LogTest("Fin de boucle : error=%d ; eod=%d", error, eod);
}
else
/* TEST 7 */
if(test[0] == '7')
{
/* test snprintmem and sscanmem */
char test_string[] =
"Ceci est une chaine d'essai.\nLes chiffres : 0123456789\nLes lettres : ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char buffer[256];
char string[200]; /* 200 suffit car test_string fait <100 */
int size1, size2, size3, i;
/* we put bad values in string, to see if it is correctly set. */
for(i = 0; i < 200; i++)
string[i] = (char)i;
LogTest("Initial data (%d Bytes) = <<%s>>", strlen(test_string), test_string);
/* Write test_string to a buffer. */
/* We don't give the final '\0'. */
snprintmem(buffer, 256, test_string, strlen(test_string));
LogTest("Dest_Buffer (%d Bytes) = <<%s>>", strlen(buffer), buffer);
/* read the value from the buffer */
sscanmem(string, strlen(test_string), buffer);
/* sets the final 0 to print the content of the buffer */
LogTest("Retrieved string : following byte = %d",
(int)string[strlen(test_string)]);
string[strlen(test_string)] = '\0';
LogTest("Retrieved string (%d Bytes) = <<%s>>", strlen(string), string);
/* Automatic tests : */
size1 = strlen(test_string);
size2 = strlen(buffer);
size3 = strlen(string);
LogTest("-------------------------------------");
if(size1 <= 0)
LogTest("***** ERROR: source size=0 !!!");
if(size1 != size3)
LogTest("***** ERROR: source size <> target size");
else
LogTest("OK: source size = target size");
if((size1 * 2) != size2)
LogTest("***** ERROR: hexa size <> 2 * source size");
else
LogTest("OK: hexa size = 2 * source size");
if(strcmp(test_string, string))
LogTest("***** ERROR: source string <> target string");
else
LogTest("OK: source string = target string");
}
else
/* TEST 8 */
if(test[0] == '8')
{
fsal_handle_t dir_hdl, subdir_hdl;
fsal_name_t subdir_name;
/* lookup on /cea/prot/S/lama/s8/leibovic */
if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/S/lama/s8/leibovic", 40, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/S/lama/s8/leibovic: handle = %s", tracebuff);
sleep(1);
/* creates a directory */
LogTest("------- Create a directory -------");
if(FSAL_IS_ERROR(st = FSAL_str2name("tests_GANESHA", 30, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_mkdir(&handle, &name, &op_ctx,
FSAL_MODE_RUSR | FSAL_MODE_WUSR
| FSAL_MODE_XUSR | FSAL_MODE_RGRP
| FSAL_MODE_WGRP, &dir_hdl, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
snprintHandle(tracebuff, 256, &dir_hdl);
LogTest("newly created dir handle = %s", tracebuff);
printattributes(attribs);
}
sleep(1);
/* Try to create it again */
LogTest("------- Try to create it again -------");
if(FSAL_IS_ERROR(st = FSAL_mkdir(&handle, &name, &op_ctx,
FSAL_MODE_RUSR | FSAL_MODE_WUSR
| FSAL_MODE_XUSR | FSAL_MODE_RGRP
| FSAL_MODE_WGRP, &dir_hdl, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("**** Error: FSAL should have returned ERR_FSAL_EXIST");
}
sleep(1);
/* creates a subdirectory */
LogTest("------- Create a subdirectory -------");
if(FSAL_IS_ERROR(st = FSAL_str2name("subdir_GANESHA", 30, &subdir_name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
if(FSAL_IS_ERROR(st = FSAL_mkdir(&dir_hdl, &subdir_name, &op_ctx,
FSAL_MODE_RUSR | FSAL_MODE_WUSR
| FSAL_MODE_XUSR | FSAL_MODE_RGRP
| FSAL_MODE_WGRP, &subdir_hdl, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
snprintHandle(tracebuff, 256, &subdir_hdl);
LogTest("newly created subdir handle = %s", tracebuff);
printattributes(attribs);
}
/* try to removes the parent directory */
LogTest("------- Try to removes the parent directory -------");
if(FSAL_IS_ERROR(st = FSAL_unlink(&handle, &name, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("FSAL should not have unlinked %s because it is not empty", name.name);
}
sleep(1);
/* removes the subdirectory */
LogTest("------- Removes the subdirectory -------");
if(FSAL_IS_ERROR(st = FSAL_unlink(&dir_hdl, &subdir_name, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("New attributes for parent directory:");
printattributes(attribs);
}
/* removes the parent directory */
LogTest("------- Removes the parent directory -------");
if(FSAL_IS_ERROR(st = FSAL_unlink(&handle, &name, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("Unlink %s OK", name.name);
}
}
/* TEST 9 */
else if(test[0] == '9')
{
fsal_handle_t dir_hdl, subdir_hdl;
fsal_name_t subdir_name;
fsal_attrib_list_t attr_set;
fsal_fsid_t set_fsid = { 1LL, 2LL };
#ifdef _LINUX
struct tm jour_heure = { 56, 34, 12, 31, 12, 110, 0, 0, 0, 0, 0 };
#else
struct tm jour_heure = { 56, 34, 12, 31, 12, 110, 0, 0, 0 };
#endif
/* lookup on /cea/prot/S/lama/s8/leibovic */
if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/S/lama/s8/leibovic", 40, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/S/lama/s8/leibovic: handle = %s", tracebuff);
sleep(1);
/* creates a file */
LogTest("------- Create a file -------");
if(FSAL_IS_ERROR(st = FSAL_str2name("tests_GANESHA_setattrs", 30, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_create(&handle, &name, &op_ctx,
FSAL_MODE_RUSR | FSAL_MODE_WUSR
| FSAL_MODE_XUSR | FSAL_MODE_RGRP
| FSAL_MODE_WGRP, &dir_hdl, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
snprintHandle(tracebuff, 256, &dir_hdl);
LogTest("newly created file handle = %s", tracebuff);
printattributes(attribs);
}
sleep(1);
LogTest("------- Try to change its attributes -------");
/* Macro that try to change the value for an attribute */
#define CHANGE_ATTRS( str_nom, nom, flag, new_val ) do {\
memset(&attr_set, 0, sizeof(fsal_attrib_list_t) ); \
LogTest("\nTry to change '%s' :",str_nom); \
FSAL_SET_MASK( attr_set.asked_attributes , flag ); \
attr_set.nom = new_val; \
attribs.asked_attributes = attr_set.asked_attributes; \
/* attribs.asked_attributes = mask; */\
st = FSAL_setattrs( &dir_hdl, &op_ctx, &attr_set, &attribs );\
if ( FSAL_IS_ERROR(st) ) \
LogError(COMPONENT_STDOUT,ERR_FSAL,st.major,st.minor);\
else \
printattributes( attribs ); \
} while(0)
CHANGE_ATTRS("supported_attributes", supported_attributes,
FSAL_ATTR_SUPPATTR, FSAL_ATTRS_MANDATORY);
CHANGE_ATTRS("type", type, FSAL_ATTR_TYPE, FSAL_TYPE_LNK);
sleep(1); /* to see mtime modification by truncate */
CHANGE_ATTRS("filesize", filesize, FSAL_ATTR_SIZE, (fsal_size_t) 12);
sleep(1); /* to see mtime modification by truncate */
CHANGE_ATTRS("fsid", fsid, FSAL_ATTR_FSID, set_fsid);
/* @todo : ACLs */
CHANGE_ATTRS("fileid", fileid, FSAL_ATTR_FILEID, (fsal_u64_t) 1234);
CHANGE_ATTRS("mode", mode, FSAL_ATTR_MODE,
(FSAL_MODE_RUSR | FSAL_MODE_WUSR | FSAL_MODE_RGRP));
CHANGE_ATTRS("numlinks", numlinks, FSAL_ATTR_NUMLINKS, 7);
/* FSAL_ATTR_RAWDEV */
CHANGE_ATTRS("atime", atime.seconds, FSAL_ATTR_ATIME, mktime(&jour_heure));
jour_heure.tm_min++;
CHANGE_ATTRS("creation", creation.seconds, FSAL_ATTR_CREATION, mktime(&jour_heure));
jour_heure.tm_min++;
CHANGE_ATTRS("mtime", mtime.seconds, FSAL_ATTR_MTIME, mktime(&jour_heure));
jour_heure.tm_min++;
CHANGE_ATTRS("ctime", ctime.seconds, FSAL_ATTR_CTIME, mktime(&jour_heure));
CHANGE_ATTRS("spaceused", spaceused, FSAL_ATTR_SPACEUSED, (fsal_size_t) 12345);
CHANGE_ATTRS("mounted_on_fileid", mounted_on_fileid,
FSAL_ATTR_MOUNTFILEID, (fsal_u64_t) 3210);
CHANGE_ATTRS("owner", owner, FSAL_ATTR_OWNER, 3051); /* deniel */
CHANGE_ATTRS("group", group, FSAL_ATTR_GROUP, 5953); /* sr */
sleep(1);
/* removes the parent directory */
LogTest("------- Removes the directory -------");
if(FSAL_IS_ERROR(st = FSAL_unlink(&handle, &name, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("Unlink %s OK", name.name);
}
}
else if(test[0] == 'A')
{
char digest_buff[FSAL_DIGEST_SIZE_HDLV3];
/* lookup on /cea/prot/S/lama/s8/leibovic */
if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/S/lama/s8/leibovic", 40, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/S/lama/s8/leibovic: handle = %s", tracebuff);
/* building digest */
st = FSAL_DigestHandle(&export_ctx, FSAL_DIGEST_NFSV3, &handle, digest_buff);
if(FSAL_IS_ERROR(st))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
/* print digest */
snprintmem(tracebuff, 256, digest_buff, FSAL_DIGEST_SIZE_HDLV3);
LogTest("/cea/prot/S/lama/s8/leibovic: handle_digest = %s", tracebuff);
}
memset(&handle, 0, sizeof(fsal_handle_t));
/* expend digest */
st = FSAL_ExpandHandle(&export_ctx, FSAL_DIGEST_NFSV3, digest_buff, &handle);
if(FSAL_IS_ERROR(st))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
/* print expended handle */
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/S/lama/s8/leibovic: handle expended = %s", tracebuff);
}
}
else if(test[0] == 'B')
{
fsal_dynamicfsinfo_t dyninfo;
if(FSAL_IS_ERROR(st = FSAL_dynamic_fsinfo(&root_handle, &op_ctx, &dyninfo)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
exit(st.major);
}
LogTest("total_bytes = %llu", dyninfo.total_bytes);
LogTest("free_bytes = %llu", dyninfo.free_bytes);
LogTest("avail_bytes = %llu", dyninfo.avail_bytes);
LogTest("total_files = %llu", dyninfo.total_files);
LogTest("free_files = %llu", dyninfo.free_files);
LogTest("avail_files = %llu", dyninfo.avail_files);
LogTest("time_delta = %u.%u", dyninfo.time_delta.seconds,
dyninfo.time_delta.nseconds);
}
else
LogTest("%s : test inconnu", test);
return 0;
}
/**
* Get a valid path associated to an handle.
* The function selects many paths from the DB and return the first valid one. If is_dir is set, then only 1 path will be constructed from the database.
*/
fsal_status_t fsal_internal_getPathFromHandle(posixfsal_op_context_t * p_context, /* IN */
posixfsal_handle_t * p_handle, /* IN */
int is_dir, /* IN */
fsal_path_t * p_fsalpath, /* OUT */
struct stat *p_buffstat /* OUT */ )
{
fsal_status_t status;
fsal_posixdb_status_t statusdb;
int rc, errsv, count, i;
fsal_posixdb_fileinfo_t infofs;
fsal_path_t paths[global_fs_info.maxlink];
if(!p_context || !p_handle || !p_fsalpath)
ReturnCode(ERR_FSAL_FAULT, 0);
/* if there is a path in the posixfsal_handle_t variable, then try to use it instead of querying the database for it */
/* Read the path from the Handle. If it's valid & coherent, then no need to query the database ! */
/* if !p_buffstat, we don't need to check the path */
statusdb = fsal_posixdb_getInfoFromHandle(p_context->p_conn,
p_handle,
paths,
(is_dir ? 1 : global_fs_info.maxlink),
&count);
if(FSAL_POSIXDB_IS_ERROR(statusdb)
&& FSAL_IS_ERROR(status = posixdb2fsal_error(statusdb)))
return status;
/* if !p_buffstat, then we do not stat the path to test if file is valid */
if(p_buffstat)
{
for(i = 0; i < count; i++)
{
TakeTokenFSCall();
rc = lstat(paths[i].path, p_buffstat);
errsv = errno;
ReleaseTokenFSCall();
if(rc)
{
/* error : delete the bad path from the database */
char dirc[FSAL_MAX_PATH_LEN];
char basec[FSAL_MAX_PATH_LEN];
fsal_path_t parentdir;
fsal_name_t filename;
posixfsal_handle_t parenthdl;
char *dname, *bname;
/* split /path/to/filename in /path/to & filename */
strncpy(dirc, paths[i].path, FSAL_MAX_PATH_LEN);
strncpy(basec, paths[i].path, FSAL_MAX_PATH_LEN);
dname = dirname(dirc);
bname = basename(basec);
status = FSAL_str2path(dname, FSAL_MAX_PATH_LEN, &parentdir);
status = FSAL_str2name(bname, FSAL_MAX_NAME_LEN, &filename);
/* get the handle of /path/to */
status = POSIXFSAL_lookupPath(&parentdir, p_context, &parenthdl, NULL);
if(!FSAL_IS_ERROR(status))
{
statusdb =
fsal_posixdb_delete(p_context->p_conn, &parenthdl, &filename, NULL);
/* no need to check if there was an error, because it doesn't change the behavior of the function */
}
}
else
{ /* no error */
FSAL_pathcpy(p_fsalpath, &(paths[0]));
break;
}
}
if(i == count)
ReturnCode(ERR_FSAL_STALE, 0);
/* check consistency */
status = fsal_internal_posix2posixdb_fileinfo(p_buffstat, &infofs);
if(FSAL_IS_ERROR(status))
return status;
if(fsal_posixdb_consistency_check(&(p_handle->data.info), &infofs))
{
/* not consistent !! */
/* delete the stale handle */
statusdb = fsal_posixdb_deleteHandle(p_context->p_conn, p_handle);
if(FSAL_POSIXDB_IS_ERROR(statusdb)
&& FSAL_IS_ERROR(status = posixdb2fsal_error(statusdb)))
return status;
ReturnCode(ERR_FSAL_STALE, 0);
}
}
else
{
/* @TODO : check that there si at liste 1 path */
FSAL_pathcpy(p_fsalpath, &(paths[0]));
}
ReturnCode(ERR_FSAL_NO_ERROR, 0);
}
/**
* FSAL_readdir :
* Read the entries of an opened directory.
*
* \param descriptor (input):
* Pointer to the directory descriptor filled by FSAL_opendir.
* \param start_position (input):
* Cookie that indicates the first object to be read during
* this readdir operation.
* This should be :
* - FSAL_READDIR_FROM_BEGINNING for reading the content
* of the directory from the beginning.
* - The end_position parameter returned by the previous
* call to FSAL_readdir.
* \param get_attr_mask (input)
* Specify the set of attributes to be retrieved for directory entries.
* \param buffersize (input)
* The size (in bytes) of the buffer where
* the direntries are to be stored.
* \param dirents (output)
* Adress of the buffer where the direntries are to be stored.
* \param end_position (output)
* Cookie that indicates the current position in the directory.
* \param count (output)
* Pointer to the number of entries read during the call.
* \param end_of_dir (output)
* Pointer to a boolean that indicates if the end of dir
* has been reached during the call.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - ERR_FSAL_FAULT (a NULL pointer was passed as mandatory argument)
* - Other error codes can be returned :
* ERR_FSAL_IO, ...
*/
fsal_status_t CEPHFSAL_readdir(fsal_dir_t *extdescriptor,
fsal_op_context_t * p_context, /* IN */
fsal_cookie_t extstart,
fsal_attrib_mask_t attrmask,
fsal_mdsize_t buffersize,
fsal_dirent_t *dirents,
fsal_cookie_t *extend,
fsal_count_t *count,
fsal_boolean_t *end_of_dir)
{
int rc = 0;
fsal_status_t status;
struct dirent de;
cephfsal_dir_t* descriptor = (cephfsal_dir_t*) extdescriptor;
struct ceph_mount_info *cmount = descriptor->ctx.export_context->cmount;
loff_t start = ((cephfsal_cookie_t*) extstart.data)->cookie;
loff_t* end = &((cephfsal_cookie_t*) extend->data)->cookie;
unsigned int max_entries = buffersize / sizeof(fsal_dirent_t);
/* sanity checks */
if(!descriptor || !dirents || !end || !count || !end_of_dir)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
*end_of_dir = FALSE;
*count = 0;
TakeTokenFSCall();
(void) ceph_seekdir(cmount, DH(descriptor), start);
while ((*count <= max_entries) && !(*end_of_dir)) {
struct stat st;
memset(&dirents[*count], sizeof(fsal_dirent_t), 0);
memset(&de, sizeof(struct dirent), 0);
memset(&st, sizeof(struct stat), 0);
int stmask = 0;
TakeTokenFSCall();
rc = ceph_readdirplus_r(cmount, DH(descriptor), &de, &st, &stmask);
if (rc < 0) /* Error */
Return(posix2fsal_error(rc), 0, INDEX_FSAL_readdir);
else if (rc == 1) {
/* Got a dirent */
cephfsal_handle_t* entryhandle
= (cephfsal_handle_t*) &(dirents[*count].handle.data);
cephfsal_cookie_t* entrycookie
= (cephfsal_cookie_t*) &(dirents[*count].cookie);
/* skip . and .. */
if(!strcmp(de.d_name, ".") || !strcmp(de.d_name, ".."))
continue;
entryhandle->data.vi.ino.val = st.st_ino;
entryhandle->data.vi.snapid.val = st.st_dev;
status = FSAL_str2name(de.d_name, FSAL_MAX_NAME_LEN,
&(dirents[*count].name));
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_readdir);
entrycookie->data.cookie = ceph_telldir(cmount, DH(descriptor));
dirents[*count].attributes.asked_attributes = attrmask;
status =
posix2fsal_attributes(&st,
&(dirents[*count].attributes));
if(FSAL_IS_ERROR(status)) {
FSAL_CLEAR_MASK(dirents[*count].attributes
.asked_attributes);
FSAL_SET_MASK(dirents[*count].attributes.asked_attributes,
FSAL_ATTR_RDATTR_ERR);
}
if (*count != 0) {
dirents[(*count)-1].nextentry = &(dirents[*count]);
}
(*count)++;
} else if (rc == 0) /* EOF */
*end_of_dir = TRUE;
else{
/* Can't happen */
abort();
}
} /* while */
(*end) = ceph_telldir(cmount, DH(descriptor));
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_readdir);
}
fsal_status_t VFSFSAL_readdir(fsal_dir_t * dir_descriptor, /* IN */
fsal_cookie_t startposition, /* IN */
fsal_attrib_mask_t get_attr_mask, /* IN */
fsal_mdsize_t buffersize, /* IN */
fsal_dirent_t * p_pdirent, /* OUT */
fsal_cookie_t * end_position, /* OUT */
fsal_count_t * p_nb_entries, /* OUT */
fsal_boolean_t * p_end_of_dir /* OUT */
)
{
vfsfsal_dir_t * p_dir_descriptor = (vfsfsal_dir_t * ) dir_descriptor;
vfsfsal_cookie_t start_position;
vfsfsal_cookie_t * p_end_position = (vfsfsal_cookie_t *) end_position;
fsal_status_t st;
fsal_count_t max_dir_entries;
fsal_name_t entry_name;
char buff[BUF_SIZE];
struct linux_dirent *dp = NULL;
int bpos = 0;
struct stat buffstat;
int rc = 0;
memset(buff, 0, BUF_SIZE);
memset(&entry_name, 0, sizeof(fsal_name_t));
/*****************/
/* sanity checks */
/*****************/
if(!p_dir_descriptor || !p_pdirent || !p_end_position || !p_nb_entries || !p_end_of_dir)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
max_dir_entries = (buffersize / sizeof(fsal_dirent_t));
/***************************/
/* seek into the directory */
/***************************/
start_position.data.cookie = *((off_t*) &startposition.data);
rc = errno = 0;
lseek(p_dir_descriptor->fd, start_position.data.cookie, SEEK_SET);
rc = errno;
if(rc)
Return(posix2fsal_error(rc), rc, INDEX_FSAL_readdir);
/************************/
/* browse the directory */
/************************/
*p_nb_entries = 0;
while(*p_nb_entries < max_dir_entries)
{
/***********************/
/* read the next entry */
/***********************/
TakeTokenFSCall();
rc = syscall(SYS_getdents, p_dir_descriptor->fd, buff, BUF_SIZE);
ReleaseTokenFSCall();
if(rc < 0)
{
rc = errno;
Return(posix2fsal_error(rc), rc, INDEX_FSAL_readdir);
}
/* End of directory */
if(rc == 0)
{
*p_end_of_dir = 1;
break;
}
/***********************************/
/* Get information about the entry */
/***********************************/
for(bpos = 0; bpos < rc;)
{
dp = (struct linux_dirent *)(buff + bpos);
bpos += dp->d_reclen;
if(!(*p_nb_entries < max_dir_entries))
break;
/* skip . and .. */
if(!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
continue;
/* build the full path of the file into "fsalpath */
if(FSAL_IS_ERROR
(st =
FSAL_str2name(dp->d_name, FSAL_MAX_NAME_LEN,
&(p_pdirent[*p_nb_entries].name))))
ReturnStatus(st, INDEX_FSAL_readdir);
// TODO: there is a race here, because between handle fetch
// and open at things might change. we need to figure out if there
// is another way to open without the pcontext
strncpy(entry_name.name, dp->d_name, sizeof(entry_name.name));
entry_name.len = strlen(entry_name.name);
/* get object handle */
TakeTokenFSCall();
if(fstatat(p_dir_descriptor->fd, dp->d_name, &buffstat, AT_SYMLINK_NOFOLLOW) < 0 )
{
ReleaseTokenFSCall();
Return(posix2fsal_error(errno), errno, INDEX_FSAL_readdir);
}
st = fsal_internal_get_handle_at( p_dir_descriptor->fd, dp->d_name,
&p_pdirent[*p_nb_entries].handle) ;
if(FSAL_IS_ERROR(st))
{
ReleaseTokenFSCall();
ReturnStatus(st, INDEX_FSAL_readdir);
}
p_pdirent[*p_nb_entries].attributes.asked_attributes = get_attr_mask;
st = posix2fsal_attributes(&buffstat, &p_pdirent[*p_nb_entries].attributes);
if(FSAL_IS_ERROR(st))
{
ReleaseTokenFSCall();
FSAL_CLEAR_MASK(p_pdirent[*p_nb_entries].attributes.asked_attributes);
FSAL_SET_MASK(p_pdirent[*p_nb_entries].attributes.asked_attributes,
FSAL_ATTR_RDATTR_ERR);
ReturnStatus(st, INDEX_FSAL_getattrs);
}
ReleaseTokenFSCall();
//p_pdirent[*p_nb_entries].cookie.cookie = dp->d_off;
((vfsfsal_cookie_t *) (&p_pdirent[*p_nb_entries].cookie))->data.cookie = dp->d_off;
p_pdirent[*p_nb_entries].nextentry = NULL;
if(*p_nb_entries)
p_pdirent[*p_nb_entries - 1].nextentry = &(p_pdirent[*p_nb_entries]);
//(*p_end_position) = p_pdirent[*p_nb_entries].cookie;
memcpy((char *)p_end_position, (char *)&p_pdirent[*p_nb_entries].cookie,
sizeof(vfsfsal_cookie_t));
(*p_nb_entries)++;
} /* for */
} /* While */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_readdir);
}
/**
* Retrieves the list of extended attributes for an object in the filesystem.
*
* \param p_objecthandle Handle of the object we want to get extended attributes.
* \param cookie index of the next entry to be returned.
* \param p_context pointer to the current security context.
* \param xattrs_tab a table for storing extended attributes list to.
* \param xattrs_tabsize the maximum number of xattr entries that xattrs_tab
* can contain.
* \param p_nb_returned the number of xattr entries actually stored in xattrs_tab.
* \param end_of_list this boolean indicates that the end of xattrs list has been reached.
*/
fsal_status_t POSIXFSAL_ListXAttrs(fsal_handle_t * objecthandle, /* IN */
unsigned int argcookie, /* IN */
fsal_op_context_t * context, /* IN */
fsal_xattrent_t * xattrs_tab, /* IN/OUT */
unsigned int xattrs_tabsize, /* IN */
unsigned int *p_nb_returned, /* OUT */
int *end_of_list /* OUT */
)
{
posixfsal_handle_t * p_objecthandle = (posixfsal_handle_t *) objecthandle;
posixfsal_op_context_t * p_context = (posixfsal_op_context_t *) context;
unsigned int index;
unsigned int out_index;
fsal_status_t st;
fsal_attrib_list_t file_attrs;
unsigned int cookie = argcookie ;
/* sanity checks */
if(!p_objecthandle || !p_context || !xattrs_tab || !p_nb_returned || !end_of_list)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_ListXAttrs);
/* Deal with special cookie */
if( argcookie == FSAL_XATTR_RW_COOKIE ) cookie = XATTR_COUNT ;
/* object attributes we want to retrieve from parent */
file_attrs.asked_attributes = FSAL_ATTR_MODE | FSAL_ATTR_FILEID | FSAL_ATTR_OWNER
| FSAL_ATTR_GROUP | FSAL_ATTR_ATIME | FSAL_ATTR_MTIME
| FSAL_ATTR_CTIME | FSAL_ATTR_CREATION | FSAL_ATTR_CHGTIME | FSAL_ATTR_FSID;
/* don't retrieve unsuipported attributes */
file_attrs.asked_attributes &= global_fs_info.supported_attrs;
st = POSIXFSAL_getattrs(objecthandle, context, &file_attrs);
if(FSAL_IS_ERROR(st))
Return(st.major, st.minor, INDEX_FSAL_ListXAttrs);
for(index = cookie, out_index = 0;
index < XATTR_COUNT && out_index < xattrs_tabsize; index++)
{
if(do_match_type(xattr_list[index].flags, p_objecthandle->data.info.ftype))
{
/* fills an xattr entry */
xattrs_tab[out_index].xattr_id = index;
FSAL_str2name(xattr_list[index].xattr_name, FSAL_MAX_NAME_LEN,
&xattrs_tab[out_index].xattr_name);
xattrs_tab[out_index].xattr_cookie = index + 1;
/* set asked attributes (all supported) */
xattrs_tab[out_index].attributes.asked_attributes =
global_fs_info.supported_attrs;
if(file_attributes_to_xattr_attrs
(&file_attrs, &xattrs_tab[out_index].attributes, index))
{
/* set error flag */
xattrs_tab[out_index].attributes.asked_attributes = FSAL_ATTR_RDATTR_ERR;
}
/* next output slot */
out_index++;
}
}
*p_nb_returned = out_index;
*end_of_list = (index == XATTR_COUNT);
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_ListXAttrs);
}
/**
* Retrieves the list of extended attributes for an object in the filesystem.
*
* \param p_objecthandle Handle of the object we want to get extended attributes.
* \param cookie index of the next entry to be returned.
* \param p_context pointer to the current security context.
* \param xattrs_tab a table for storing extended attributes list to.
* \param xattrs_tabsize the maximum number of xattr entries that xattrs_tab
* can contain.
* \param p_nb_returned the number of xattr entries actually stored in xattrs_tab.
* \param end_of_list this boolean indicates that the end of xattrs list has been reached.
*/
fsal_status_t GPFSFSAL_ListXAttrs(fsal_handle_t * p_objecthandle, /* IN */
unsigned int cookie, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_xattrent_t * xattrs_tab, /* IN/OUT */
unsigned int xattrs_tabsize, /* IN */
unsigned int *p_nb_returned, /* OUT */
int *end_of_list /* OUT */
)
{
#if 0
int rc;
unsigned int index;
unsigned int out_index;
char object_path[FSAL_MAX_PATH_LEN];
fsal_status_t st;
fsal_attrib_list_t file_attrs;
#endif
/* sanity checks */
if(!p_objecthandle || !p_context || !xattrs_tab || !p_nb_returned || !end_of_list)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_ListXAttrs);
/* @todo: to be implemented */
Return(ERR_FSAL_NOTSUPP, 0, INDEX_FSAL_ListXAttrs);
#if 0
/* object attributes we want to retrieve from parent */
file_attrs.asked_attributes = FSAL_ATTR_MODE | FSAL_ATTR_FILEID | FSAL_ATTR_OWNER
| FSAL_ATTR_GROUP | FSAL_ATTR_ATIME | FSAL_ATTR_MTIME
| FSAL_ATTR_CTIME | FSAL_ATTR_CREATION | FSAL_ATTR_CHGTIME | FSAL_ATTR_FSID;
/* don't retrieve unsuipported attributes */
file_attrs.asked_attributes &= global_fs_info.supported_attrs;
st = GPFSFSAL_getattrs(p_objecthandle, p_context, &file_attrs);
if(FSAL_IS_ERROR(st))
Return(st.major, st.minor, INDEX_FSAL_ListXAttrs);
for(index = cookie, out_index = 0;
index < XATTR_COUNT && out_index < xattrs_tabsize; index++)
{
if(do_match_type(xattr_list[index].flags, p_objecthandle->handle.handle_type))
{
/* fills an xattr entry */
xattrs_tab[out_index].xattr_id = index;
FSAL_str2name(xattr_list[index].xattr_name, 0,
&xattrs_tab[out_index].xattr_name);
xattrs_tab[out_index].xattr_cookie = index + 1;
/* set asked attributes (all supported) */
xattrs_tab[out_index].attributes.asked_attributes =
global_fs_info.supported_attrs;
if(file_attributes_to_xattr_attrs
(&file_attrs, &xattrs_tab[out_index].attributes, index))
{
/* set error flag */
xattrs_tab[out_index].attributes.asked_attributes = FSAL_ATTR_RDATTR_ERR;
}
/* next output slot */
out_index++;
}
}
*p_nb_returned = out_index;
*end_of_list = (index == XATTR_COUNT);
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_ListXAttrs);
#endif
}
main(int argc, char *argv[])
{
char localmachine[256];
cache_inode_client_t client;
LRU_parameter_t lru_param;
LRU_status_t lru_status;
cache_inode_fsal_data_t fsdata;
fsal_status_t status;
fsal_parameter_t init_param;
fsal_name_t name;
fsal_path_t path;
fsal_attrib_mask_t mask;
fsal_path_t pathroot;
fsal_attrib_list_t attribs;
fsal_handle_t root_handle;
cache_inode_endofdir_t eod_met;
cache_inode_dir_entry_t dirent_array[100];
cache_inode_dir_entry_t dirent_array_loop[5];
unsigned int nbfound;
unsigned int begin_cookie = 0;
hash_buffer_t key, value;
uid_t uid;
fsal_cred_t cred;
cache_inode_status_t cache_status;
cache_inode_parameter_t cache_param;
cache_inode_client_parameter_t cache_client_param;
hash_table_t *ht = NULL;
fsal_attrib_list_t attrlookup;
cache_entry_t *cache_entry_root = NULL;
cache_entry_t *cache_entry_lookup = NULL;
cache_entry_t *cache_entry_lookup2 = NULL;
cache_entry_t *cache_entry_lookup3 = NULL;
cache_entry_t *cache_entry_lookup4 = NULL;
cache_entry_t *cache_entry_lookup5 = NULL;
cache_entry_t *cache_entry_lookup6 = NULL;
cache_entry_t *cache_entry_dircont = NULL;
cache_inode_gc_policy_t gcpol;
char *configfile = argv[1];
int i = 0;
int rc = 0;
/* Init the Buddy System allocation */
if((rc = BuddyInit(NULL)) != BUDDY_SUCCESS)
{
LogTest("Error while initializing Buddy system allocator");
exit(1);
}
/* init debug */
SetNamePgm("test_cache_inode");
SetDefaultLogging("TEST");
SetNameFunction("main");
InitLogging();
#if defined( _USE_GHOSTFS )
if(argc != 2)
{
LogTest("Please set the configuration file as parameter");
exit(1);
}
#endif
/* Obtention du nom de la machine */
if(gethostname(localmachine, sizeof(localmachine)) != 0)
{
LogError(COMPONENT_STDOUT, ERR_SYS, ERR_GETHOSTNAME, errno);
exit(1);
}
else
SetNameHost(localmachine);
AddFamilyError(ERR_FSAL, "FSAL related Errors", tab_errstatus_FSAL);
AddFamilyError(ERR_CACHE_INODE, "FSAL related Errors", tab_errstatus_cache_inode);
LogTest( "Starting the test");
LogTest( "-----------------");
#if defined( _USE_GHOSTFS )
if(FSAL_IS_ERROR(status = FSAL_str2path(configfile,
strlen(configfile) + 1,
&(init_param.fs_specific_info.
definition_file))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
}
#elif defined( _USE_HPSS )
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, Flags);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DebugValue);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, TransferType);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, NumRetries);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, BusyDelay);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, BusyRetries);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, TotalDelay);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, GKTotalDelay);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, LimitedRetries);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, MaxConnections);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, ReuseDataConnections);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, UsePortRange);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, RetryStageInp);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DMAPWriteUpdates);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, ServerName);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DescName);
init_param.fs_specific_info.behaviors.PrincipalName = FSAL_INIT_FORCE_VALUE;
strncpy(init_param.fs_specific_info.hpss_config.PrincipalName,
HPSS_SSM, HPSS_MAX_PRINCIPAL_NAME);
init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE;
strncpy(init_param.fs_specific_info.hpss_config.KeytabPath,
HPSS_KEYTAB, HPSS_MAX_PATH_NAME);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DebugPath);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, HostName);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, RegistrySiteName);
#endif
/* 2-common info (default) */
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxfilesize);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxlink);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxnamelen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxpathlen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, no_trunc);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, chown_restricted);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_insensitive);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_preserving);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, fh_expire_type);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, link_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, symlink_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, named_attr);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, unique_handles);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, lease_time);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, acl_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, cansettime);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, homogenous);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxread);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxwrite);
/* Init */
if(FSAL_IS_ERROR(status = FSAL_Init(&init_param)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
}
/* getting creds */
uid = getuid();
if(FSAL_IS_ERROR(status = FSAL_GetUserCred(uid, NULL, &cred)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
}
/* Init of the cache inode module */
cache_param.hparam.index_size = 31;
cache_param.hparam.alphabet_length = 10; /* Buffer seen as a decimal polynom */
cache_param.hparam.nb_node_prealloc = 100;
cache_param.hparam.hash_func_key = cache_inode_fsal_hash_func;
cache_param.hparam.hash_func_rbt = cache_inode_fsal_rbt_func;
cache_param.hparam.hash_func_both = NULL ; /* BUGAZOMEU */
cache_param.hparam.compare_key = cache_inode_compare_key_fsal;
cache_param.hparam.key_to_str = display_key;
cache_param.hparam.val_to_str = display_value;
if((ht = cache_inode_init(cache_param, &cache_status)) == NULL)
{
LogTest( "Error %d while init hash ", cache_status);
}
else
LogTest( "Hash Table address = %p", ht);
/* We need a cache_client to acces the cache */
cache_client_param.attrmask =
FSAL_ATTRS_MANDATORY | FSAL_ATTR_MTIME | FSAL_ATTR_CTIME | FSAL_ATTR_ATIME;
cache_client_param.nb_prealloc_entry = 1000;
cache_client_param.nb_pre_dir_data = 200;
cache_client_param.nb_pre_parent = 1200;
cache_client_param.nb_pre_state_v4 = 100;
cache_client_param.lru_param.nb_entry_prealloc = 1000;
cache_client_param.lru_param.entry_to_str = lru_entry_to_str;
cache_client_param.lru_param.clean_entry = lru_clean_entry;
cache_client_param.grace_period_attr = 0;
cache_client_param.grace_period_link = 0;
cache_client_param.grace_period_dirent = 0;
cache_client_param.expire_type_attr = CACHE_INODE_EXPIRE_NEVER;
cache_client_param.expire_type_link = CACHE_INODE_EXPIRE_NEVER;
cache_client_param.expire_type_dirent = CACHE_INODE_EXPIRE_NEVER;
/* Init the cache_inode client */
if(cache_inode_client_init(&client, cache_client_param, 0) != 0)
exit(1);
/* Getting the root of the FS */
if((FSAL_IS_ERROR(status = FSAL_str2path("/", 2, &pathroot))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
exit(1);
}
attribs.asked_attributes = cache_client_param.attrmask;
if((FSAL_IS_ERROR(status = FSAL_lookupPath(pathroot, &cred, &root_handle, &attribs))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
exit(1);
}
fsdata.cookie = 0;
fsdata.handle = root_handle;
/* Cache the root of the FS */
if((cache_entry_root =
cache_inode_make_root(&fsdata, 1, ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't init fs's root");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("cea", 10, &name))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup = cache_inode_lookup(cache_entry_root,
name,
&attrlookup,
ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
/* Lookup a second time (entry should now be cached) */
if((cache_entry_lookup2 = cache_inode_lookup(cache_entry_root,
name,
&attrlookup,
ht,
&client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
if(cache_entry_lookup2 != cache_entry_lookup)
{
LogTest("Error: lookup results should be the same");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("log", 10, &name))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup3 = cache_inode_lookup(cache_entry_root,
name,
&attrlookup,
ht,
&client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
if((cache_entry_lookup4 = cache_inode_lookup(cache_entry_root,
name,
&attrlookup,
ht,
&client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
if(cache_entry_lookup3 != cache_entry_lookup4)
{
LogTest("Error: lookup results should be the same");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("cea", 10, &name))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup = cache_inode_lookup(cache_entry_root,
name,
&attrlookup,
ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("log", 10, &name))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup = cache_inode_lookup(cache_entry_root,
name,
&attrlookup,
ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
LogTest( "---------------------------------");
/* The end of all the tests */
LogTest( "All tests exited successfully");
exit(0);
} /* main */
int nfs_Symlink(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
char *str_symlink_name = NULL;
fsal_name_t symlink_name;
char *str_target_path = NULL;
cache_inode_create_arg_t create_arg;
fsal_accessmode_t mode = 0777;
cache_entry_t *symlink_pentry = NULL;
cache_entry_t *parent_pentry;
cache_inode_file_type_t parent_filetype;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t attr_symlink;
fsal_attrib_list_t attributes_symlink;
fsal_attrib_list_t attr_parent_after;
fsal_attrib_list_t *ppre_attr;
cache_inode_status_t cache_status;
cache_inode_status_t cache_status_parent;
fsal_handle_t *pfsal_handle;
int rc = NFS_REQ_OK;
#ifdef _USE_QUOTA
fsal_status_t fsal_status ;
#endif
memset(&create_arg, 0, sizeof(create_arg));
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
str_symlink_name = parg->arg_symlink2.from.name;
str_target_path = parg->arg_symlink2.to;
break;
case NFS_V3:
str_symlink_name = parg->arg_symlink3.where.name;
str_target_path = parg->arg_symlink3.symlink.symlink_data;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_symlink2.from.dir),
&(parg->arg_symlink3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Symlink handle: %s name: %s target: %s",
str, str_symlink_name, str_target_path);
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_symlink3.SYMLINK3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_symlink3.SYMLINK3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
}
/* Convert directory file handle into a vnode */
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_symlink2.from.dir),
&(parg->arg_symlink3.where.dir),
NULL,
&(pres->res_stat2),
&(pres->res_symlink3.status),
NULL,
&parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
goto out;;
}
/* get directory attributes before action (for V3 reply) */
ppre_attr = &parent_attr;
/* Extract the filetype */
parent_filetype = cache_inode_fsal_type_convert(parent_attr.type);
/*
* Sanity checks: new directory name must be non-null; parent must be
* a directory.
*/
if(parent_filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_symlink3.status = NFS3ERR_NOTDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
#ifdef _USE_QUOTA
/* if quota support is active, then we should check is the FSAL allows inode creation or not */
fsal_status = FSAL_check_quota( pexport->fullpath,
FSAL_QUOTA_INODES,
FSAL_OP_CONTEXT_TO_UID( pcontext ) ) ;
if( FSAL_IS_ERROR( fsal_status ) )
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFSERR_DQUOT ;
break;
case NFS_V3:
pres->res_symlink3.status = NFS3ERR_DQUOT;
break;
}
rc = NFS_REQ_OK;
goto out;
}
#endif /* _USE_QUOTA */
switch (preq->rq_vers)
{
case NFS_V2:
str_symlink_name = parg->arg_symlink2.from.name;
str_target_path = parg->arg_symlink2.to;
break;
case NFS_V3:
str_symlink_name = parg->arg_symlink3.where.name;
str_target_path = parg->arg_symlink3.symlink.symlink_data;
break;
}
if(str_symlink_name == NULL ||
*str_symlink_name == '\0'||
str_target_path == NULL ||
*str_target_path == '\0' ||
FSAL_IS_ERROR(FSAL_str2name(str_symlink_name, 0, &symlink_name)) ||
FSAL_IS_ERROR(FSAL_str2path(str_target_path, 0, &create_arg.link_content)))
{
cache_status = CACHE_INODE_INVALID_ARGUMENT;
}
else
{
/* Make the symlink */
if((symlink_pentry = cache_inode_create(parent_pentry,
&symlink_name,
SYMBOLIC_LINK,
mode,
&create_arg,
&attr_symlink,
pcontext, &cache_status)) != NULL)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFS_OK;
break;
case NFS_V3:
/* Build file handle */
pfsal_handle = &symlink_pentry->handle;
/* Some clients (like the Spec NFS benchmark) set attributes with the NFSPROC3_SYMLINK request */
if(nfs3_Sattr_To_FSALattr(&attributes_symlink,
&parg->arg_symlink3.symlink.symlink_attributes) == 0)
{
pres->res_create3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
/* Mode is managed above (in cache_inode_create), there is no need
* to manage it */
if(attributes_symlink.asked_attributes & FSAL_ATTR_MODE)
attributes_symlink.asked_attributes &= ~FSAL_ATTR_MODE;
/* Some clients (like Solaris 10) try to set the size of the file to 0
* at creation time. The FSAL create empty file, so we ignore this */
if(attributes_symlink.asked_attributes & FSAL_ATTR_SIZE)
attributes_symlink.asked_attributes &= ~FSAL_ATTR_SIZE;
if(attributes_symlink.asked_attributes & FSAL_ATTR_SPACEUSED)
attributes_symlink.asked_attributes &= ~FSAL_ATTR_SPACEUSED;
/* If owner or owner_group are set, and the credential was
* squashed, then we must squash the set owner and owner_group.
*/
squash_setattr(&pworker->export_perms,
&pworker->user_credentials,
&attributes_symlink);
/* Are there attributes to be set (additional to the mode) ? */
if(attributes_symlink.asked_attributes != 0ULL &&
attributes_symlink.asked_attributes != FSAL_ATTR_MODE)
{
/* A call to cache_inode_setattr is required */
if(cache_inode_setattr(symlink_pentry,
&attributes_symlink,
pcontext,
FALSE,
&cache_status) != CACHE_INODE_SUCCESS)
{
goto out_error;
}
}
if ((pres->res_symlink3.status =
(nfs3_AllocateFH(&pres->res_symlink3.SYMLINK3res_u
.resok.obj.post_op_fh3_u.handle)))
!= NFS3_OK) {
pres->res_symlink3.status = NFS3ERR_IO;
rc = NFS_REQ_OK;
goto out;
}
if(nfs3_FSALToFhandle
(&pres->res_symlink3.SYMLINK3res_u.resok.obj.post_op_fh3_u.handle,
pfsal_handle, pexport) == 0)
{
gsh_free(pres->res_symlink3.SYMLINK3res_u.resok.obj.
post_op_fh3_u.handle.data.data_val);
pres->res_symlink3.status = NFS3ERR_BADHANDLE;
rc = NFS_REQ_OK;
goto out;
}
/* The the parent pentry attributes for building Wcc Data */
if(cache_inode_getattr(parent_pentry,
&attr_parent_after,
pcontext,
&cache_status_parent)
!= CACHE_INODE_SUCCESS)
{
gsh_free(pres->res_symlink3.SYMLINK3res_u.resok.obj.
post_op_fh3_u.handle.data.data_val);
pres->res_symlink3.status = NFS3ERR_BADHANDLE;
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
pres->res_symlink3.SYMLINK3res_u.resok.obj.handle_follows = TRUE;
/* Build entry attributes */
nfs_SetPostOpAttr(pexport,
&attr_symlink,
&(pres->res_symlink3.SYMLINK3res_u
.resok.obj_attributes));
/* Build Weak Cache Coherency data */
nfs_SetWccData(pexport,
ppre_attr,
&attr_parent_after,
&(pres->res_symlink3.SYMLINK3res_u.resok.dir_wcc));
pres->res_symlink3.status = NFS3_OK;
break;
} /* switch */
rc = NFS_REQ_OK;
goto out;
}
}
out_error:
rc = nfs_SetFailedStatus(pexport, preq->rq_vers, cache_status,
&pres->res_stat2, &pres->res_symlink3.status,
NULL, ppre_attr,
&(pres->res_symlink3.SYMLINK3res_u.resfail.dir_wcc),
NULL, NULL);
out:
/* return references */
if (parent_pentry)
cache_inode_put(parent_pentry);
if (symlink_pentry)
cache_inode_put(symlink_pentry);
return (rc);
} /* nfs_Symlink */
fsal_status_t VFSFSAL_readdir(vfsfsal_dir_t * p_dir_descriptor, /* IN */
vfsfsal_cookie_t start_position, /* IN */
fsal_attrib_mask_t get_attr_mask, /* IN */
fsal_mdsize_t buffersize, /* IN */
fsal_dirent_t * p_pdirent, /* OUT */
vfsfsal_cookie_t * p_end_position, /* OUT */
fsal_count_t * p_nb_entries, /* OUT */
fsal_boolean_t * p_end_of_dir /* OUT */
)
{
fsal_status_t st;
fsal_count_t max_dir_entries;
char buff[BUF_SIZE];
struct linux_dirent *dp = NULL;
int bpos = 0;
int tmpfd = 0;
char d_type;
struct stat buffstat;
int errsv = 0, rc = 0;
memset(buff, 0, BUF_SIZE);
/*****************/
/* sanity checks */
/*****************/
if(!p_dir_descriptor || !p_pdirent || !p_end_position || !p_nb_entries || !p_end_of_dir)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
max_dir_entries = (buffersize / sizeof(fsal_dirent_t));
/***************************/
/* seek into the directory */
/***************************/
errno = 0;
if(start_position.data.cookie == 0)
{
//rewinddir(p_dir_descriptor->p_dir);
rc = errno;
}
else
{
//seekdir(p_dir_descriptor->p_dir, start_position.cookie);
rc = errno;
}
if(rc)
Return(posix2fsal_error(rc), rc, INDEX_FSAL_readdir);
/************************/
/* browse the directory */
/************************/
*p_nb_entries = 0;
while(*p_nb_entries < max_dir_entries)
{
/***********************/
/* read the next entry */
/***********************/
TakeTokenFSCall();
rc = syscall(SYS_getdents, p_dir_descriptor->fd, buff, BUF_SIZE);
ReleaseTokenFSCall();
if(rc < 0)
{
rc = errno;
Return(posix2fsal_error(rc), rc, INDEX_FSAL_readdir);
}
/* End of directory */
if(rc == 0)
{
*p_end_of_dir = 1;
break;
}
/***********************************/
/* Get information about the entry */
/***********************************/
for(bpos = 0; bpos < rc;)
{
dp = (struct linux_dirent *)(buff + bpos);
d_type = *(buff + bpos + dp->d_reclen - 1);
/** @todo not used for the moment. Waiting for information on symlink management */
bpos += dp->d_reclen;
/* LogFullDebug(COMPONENT_FSAL, "\tino=%8ld|%8lx off=%d|%x reclen=%d|%x name=%s|%d", dp->d_ino, dp->d_ino, (int)dp->d_off, (int)dp->d_off,
dp->d_reclen, dp->d_reclen, dp->d_name, (int)dp->d_name[0] ) ; */
if(!(*p_nb_entries < max_dir_entries))
break;
/* skip . and .. */
if(!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
continue;
/* build the full path of the file into "fsalpath */
if(FSAL_IS_ERROR
(st =
FSAL_str2name(dp->d_name, FSAL_MAX_NAME_LEN,
&(p_pdirent[*p_nb_entries].name))))
ReturnStatus(st, INDEX_FSAL_readdir);
d_type = DT_UNKNOWN;
if((tmpfd =
openat(p_dir_descriptor->fd, dp->d_name, O_RDONLY | O_NOFOLLOW, 0600)) < 0)
{
if(errno != ELOOP) /* ( p_dir_descriptor->fd, dp->d_name) is not a symlink */
Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_readdir);
else
d_type = DT_LNK;
}
/* get object handle */
TakeTokenFSCall();
if(d_type != DT_LNK)
{
vfsfsal_handle_t *tmp_handle =
(vfsfsal_handle_t *) (&(p_pdirent[*p_nb_entries].handle));
st = fsal_internal_fd2handle(&p_dir_descriptor->context, tmpfd, tmp_handle);
close(tmpfd);
}
else
{
vfsfsal_handle_t *tmp_handle =
(vfsfsal_handle_t *) (&(p_pdirent[*p_nb_entries].handle));
if(fstatat(p_dir_descriptor->fd, dp->d_name, &buffstat, AT_SYMLINK_NOFOLLOW)
< 0)
{
ReleaseTokenFSCall();
Return(posix2fsal_error(errno), errno, INDEX_FSAL_readdir);
}
st = fsal_internal_get_handle_at( p_dir_descriptor->fd, dp->d_name, tmp_handle ) ;
if(FSAL_IS_ERROR(st))
{
ReleaseTokenFSCall();
ReturnStatus(st, INDEX_FSAL_readdir);
}
p_pdirent[*p_nb_entries].attributes.asked_attributes = get_attr_mask;
st = posix2fsal_attributes(&buffstat, &p_pdirent[*p_nb_entries].attributes);
if(FSAL_IS_ERROR(st))
{
ReleaseTokenFSCall();
FSAL_CLEAR_MASK(p_pdirent[*p_nb_entries].attributes.asked_attributes);
FSAL_SET_MASK(p_pdirent[*p_nb_entries].attributes.asked_attributes,
FSAL_ATTR_RDATTR_ERR);
ReturnStatus(st, INDEX_FSAL_getattrs);
}
}
ReleaseTokenFSCall();
if(FSAL_IS_ERROR(st))
ReturnStatus(st, INDEX_FSAL_readdir);
/************************
* Fills the attributes *
************************/
if(d_type != DT_LNK)
{
p_pdirent[*p_nb_entries].attributes.asked_attributes = get_attr_mask;
st = VFSFSAL_getattrs((vfsfsal_handle_t
*) (&(p_pdirent[*p_nb_entries].handle)),
(vfsfsal_op_context_t *) & p_dir_descriptor->context,
&p_pdirent[*p_nb_entries].attributes);
if(FSAL_IS_ERROR(st))
{
FSAL_CLEAR_MASK(p_pdirent[*p_nb_entries].attributes.asked_attributes);
FSAL_SET_MASK(p_pdirent[*p_nb_entries].attributes.asked_attributes,
FSAL_ATTR_RDATTR_ERR);
}
}
//p_pdirent[*p_nb_entries].cookie.cookie = dp->d_off;
((vfsfsal_cookie_t *) (&p_pdirent[*p_nb_entries].cookie))->data.cookie = dp->d_off;
p_pdirent[*p_nb_entries].nextentry = NULL;
if(*p_nb_entries)
p_pdirent[*p_nb_entries - 1].nextentry = &(p_pdirent[*p_nb_entries]);
//(*p_end_position) = p_pdirent[*p_nb_entries].cookie;
memcpy((char *)p_end_position, (char *)&p_pdirent[*p_nb_entries].cookie,
sizeof(vfsfsal_cookie_t));
(*p_nb_entries)++;
} /* for */
} /* While */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_readdir);
}
/*
* Read the entries of an opened directory.
*
* \param dir_descriptor (input):
* Pointer to the directory descriptor filled by FSAL_opendir.
* \param start_position (input):
* Cookie that indicates the first object to be read during
* this readdir operation.
* This should be :
* - FSAL_READDIR_FROM_BEGINNING for reading the content
* of the directory from the beginning.
* - The end_position parameter returned by the previous
* call to FSAL_readdir.
* \param get_attr_mask (input)
* Specify the set of attributes to be retrieved for directory entries.
* \param buffersize (input)
* The size (in bytes) of the buffer where
* the direntries are to be stored.
* \param pdirent (output)
* Adresse of the buffer where the direntries are to be stored.
* \param end_position (output)
* Cookie that indicates the current position in the directory.
* \param nb_entries (output)
* Pointer to the number of entries read during the call.
* \param end_of_dir (output)
* Pointer to a boolean that indicates if the end of dir
* has been reached during the call.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - ERR_FSAL_FAULT (a NULL pointer was passed as mandatory argument)
* - Other error codes can be returned :
* ERR_FSAL_IO, ...
*/
fsal_status_t dpmfsal_readdir(dpmfsal_dir_t * dir_descriptor, // IN
dpmfsal_cookie_t start_position, // IN
fsal_attrib_mask_t get_attr_mask, // IN
fsal_mdsize_t buffersize, // IN
fsal_dirent_t * pdirent, // OUT
dpmfsal_cookie_t * end_position, // OUT
fsal_count_t * nb_entries, // OUT
fsal_boolean_t * end_of_dir // OUT
)
{
int rc;
struct dpns_direnstat * denstat;
fsal_status_t st;
unsigned long max_entries;
// Sanity checks
if (!dir_descriptor || !pdirent || !end_position || !nb_entries || !end_of_dir)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
// How many entries should we read?
max_entries = (buffersize / sizeof(fsal_dirent_t));
LogInfo(COMPONENT_FSAL, "dpmfsal_readdir: start :: %s :: up to %d entries",
dir_descriptor->path.path, start_position, max_entries);
// We might want to rewind
serrno = 0;
if (start_position.data.cookie == 0) {
LogDebug(COMPONENT_FSAL, "dpmfsal_readdir: cookie == 0 :: rewind");
dpns_rewinddir(dir_descriptor->p_dir);
} else { // Or simply move forward in the directory
LogDebug(COMPONENT_FSAL, "dpmfsal_opendir: cookie == %d :: seek");
// dpns_seekdir(dir_descriptor->p_dir, start_position.cookie); (does not exist)
}
if (serrno)
Return(dpns2fsal_error(serrno), serrno, INDEX_FSAL_readdir);
// Read the directory entries
TakeTokenFSCall();
*nb_entries = 0;
while (*nb_entries < max_entries) {
fsal_handle_t entry_handle;
fsal_path_t entry_path;
// Fetch the entry
denstat = dpns_readdirx(dir_descriptor->p_dir);
// Are we done?
if (denstat == NULL) {
LogDebug(COMPONENT_FSAL, "dpmfsal_readdir: (end of dir) after %d entries", *nb_entries);
*end_of_dir = 1;
break;
}
// Get the fsal_path_t struct corresponding to the entry name
st = FSAL_str2name(denstat->d_name, FSAL_MAX_NAME_LEN, &(pdirent[*nb_entries].name));
if (FSAL_IS_ERROR(st))
ReturnStatus(st, INDEX_FSAL_readdir);
strcpy(entry_path.path, dir_descriptor->path.path);
fsal_internal_appendNameToPath(&entry_path, &(pdirent[*nb_entries].name));
// Set the direntry object handle
dpnsDirEntry2fsal_handle(denstat, &entry_path, dir_descriptor,
&(pdirent[*nb_entries].handle));
// Fill in the entry attributes
pdirent[*nb_entries].attributes.asked_attributes = get_attr_mask;
st = dpns2fsal_attributes(denstat, &pdirent[*nb_entries].attributes);
if (FSAL_IS_ERROR(st)) {
FSAL_CLEAR_MASK(pdirent[*nb_entries].attributes.asked_attributes);
FSAL_SET_MASK(pdirent[*nb_entries].attributes.asked_attributes,
FSAL_ATTR_RDATTR_ERR);
}
pdirent[*nb_entries].cookie.data.cookie = start_position.data.cookie + *nb_entries;
pdirent[*nb_entries].nextentry = NULL;
if (*nb_entries)
pdirent[*nb_entries - 1].nextentry = &(pdirent[*nb_entries]);
(*end_position) = pdirent[*nb_entries].cookie;
LogDebug(COMPONENT_FSAL, "dpmfsal_readdir: entry %d :: %d",
*nb_entries, pdirent[*nb_entries].handle.data.id);
(*nb_entries)++;
}
ReleaseTokenFSCall();
LogDebug(COMPONENT_FSAL, "dpmfsal_readdir: read %d entries :: end position is %d",
*nb_entries, end_position->data.cookie);
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_readdir);
}
int nfs_Mkdir(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
char *str_dir_name = NULL;
fsal_accessmode_t mode = 0;
cache_entry_t *dir_pentry = NULL;
cache_entry_t *parent_pentry = NULL;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t attr;
fsal_attrib_list_t *ppre_attr;
fsal_attrib_list_t attr_parent_after;
cache_inode_file_type_t parent_filetype;
fsal_handle_t *pfsal_handle;
fsal_name_t dir_name;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
cache_inode_status_t cache_status_lookup;
cache_inode_create_arg_t create_arg;
int rc = NFS_REQ_OK;
#ifdef _USE_QUOTA
fsal_status_t fsal_status ;
#endif
memset(&create_arg, 0, sizeof(create_arg));
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
str_dir_name = parg->arg_mkdir2.where.name;
break;
case NFS_V3:
str_dir_name = parg->arg_mkdir3.where.name;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_mkdir2.where.dir),
&(parg->arg_mkdir3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Mkdir handle: %s name: %s",
str, str_dir_name);
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
}
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_mkdir2.where.dir),
&(parg->arg_mkdir3.where.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_mkdir3.status),
NULL,
&parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
goto out;
}
/* get directory attributes before action (for V3 reply) */
ppre_attr = &parent_attr;
/* Extract the filetype */
parent_filetype = cache_inode_fsal_type_convert(parent_attr.type);
/*
* Sanity checks:
*/
if(parent_filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_mkdir3.status = NFS3ERR_NOTDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
#ifdef _USE_QUOTA
/* if quota support is active, then we should check is the FSAL allows inode creation or not */
fsal_status = FSAL_check_quota( pexport->fullpath,
FSAL_QUOTA_INODES,
FSAL_OP_CONTEXT_TO_UID( pcontext ) ) ;
if( FSAL_IS_ERROR( fsal_status ) )
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_DQUOT;
break;
case NFS_V3:
pres->res_mkdir3.status = NFS3ERR_DQUOT;
break;
}
rc = NFS_REQ_OK ;
goto out;
}
#endif /* _USE_QUOTA */
switch (preq->rq_vers)
{
case NFS_V2:
str_dir_name = parg->arg_mkdir2.where.name;
if(parg->arg_mkdir2.attributes.mode != (unsigned int)-1)
{
mode = (fsal_accessmode_t) parg->arg_mkdir2.attributes.mode;
}
else
{
mode = (fsal_accessmode_t) 0;
}
break;
case NFS_V3:
str_dir_name = parg->arg_mkdir3.where.name;
if(parg->arg_mkdir3.attributes.mode.set_it == TRUE)
mode = (fsal_accessmode_t) parg->arg_mkdir3.attributes.mode.set_mode3_u.mode;
else
mode = (fsal_accessmode_t) 0;
break;
}
//if(str_dir_name == NULL || strlen(str_dir_name) == 0)
if(str_dir_name == NULL || *str_dir_name == '\0' )
{
if(preq->rq_vers == NFS_V2)
pres->res_dirop2.status = NFSERR_IO;
if(preq->rq_vers == NFS_V3)
pres->res_mkdir3.status = NFS3ERR_INVAL;
}
else
{
/* Make the directory */
if((cache_status = cache_inode_error_convert(FSAL_str2name(str_dir_name,
0,
&dir_name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup file to see if it exists. If so, use it. Otherwise
* create a new one.
*/
dir_pentry = cache_inode_lookup(parent_pentry,
&dir_name,
&attr,
pcontext,
&cache_status_lookup);
if(cache_status_lookup == CACHE_INODE_NOT_FOUND)
{
/* The create_arg structure contains the information "newly created directory"
* to be passed to cache_inode_new_entry from cache_inode_create */
create_arg.newly_created_dir = TRUE;
/* Create the directory */
if((dir_pentry = cache_inode_create(parent_pentry,
&dir_name,
DIRECTORY,
mode,
&create_arg,
&attr,
pcontext, &cache_status)) != NULL)
{
/*
* Get the FSAL handle for this entry
*/
pfsal_handle = &dir_pentry->handle;
if(preq->rq_vers == NFS_V2)
{
DIROP2resok *d2ok = &pres->res_dirop2.DIROP2res_u.diropok;
/* Build file handle */
if(!nfs2_FSALToFhandle(&d2ok->file, pfsal_handle, pexport))
pres->res_dirop2.status = NFSERR_IO;
else
{
/*
* Build entry
* attributes
*/
if(nfs2_FSALattr_To_Fattr(pexport, &attr,
&d2ok->attributes) == 0)
pres->res_dirop2.status = NFSERR_IO;
else
pres->res_dirop2.status = NFS_OK;
}
}
else
{
MKDIR3resok *d3ok = &pres->res_mkdir3.MKDIR3res_u.resok;
/* Build file handle */
pres->res_mkdir3.status =
nfs3_AllocateFH(&d3ok->obj.post_op_fh3_u.handle);
if(pres->res_mkdir3.status != NFS3_OK)
{
rc = NFS_REQ_OK;
goto out;
}
if(nfs3_FSALToFhandle(&d3ok->obj.post_op_fh3_u.handle,
pfsal_handle, pexport) == 0)
{
gsh_free(d3ok->obj.post_op_fh3_u.handle.data.data_val);
pres->res_mkdir3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
d3ok->obj.handle_follows = TRUE;
/*
* Build entry attributes
*/
nfs_SetPostOpAttr(pexport, &attr, &d3ok->obj_attributes);
/* Get the attributes of the parent after the operation */
if(cache_inode_getattr(parent_pentry,
&attr_parent_after,
pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
pres->res_mkdir3.status = nfs3_Errno(cache_status);
rc = NFS_REQ_OK;
goto out;
}
/*
* Build Weak Cache Coherency data
*/
nfs_SetWccData(pexport, ppre_attr, &attr_parent_after,
&d3ok->dir_wcc);
pres->res_mkdir3.status = NFS3_OK;
}
rc = NFS_REQ_OK;
goto out;
}
} /* If( cache_status_lookup == CACHE_INODE_NOT_FOUND ) */
else
{
switch (preq->rq_vers)
{
case NFS_V2:
if(cache_status_lookup == CACHE_INODE_SUCCESS)
pres->res_dirop2.status = NFSERR_EXIST;
else
pres->res_dirop2.status = NFSERR_IO;
break;
case NFS_V3:
if(cache_status_lookup == CACHE_INODE_SUCCESS)
pres->res_mkdir3.status = NFS3ERR_EXIST;
else
pres->res_mkdir3.status = NFS3ERR_INVAL;
nfs_SetWccData(pexport, ppre_attr, NULL,
&(pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc));
break;
}
rc = NFS_REQ_OK;
goto out;
}
}
}
/* If we are here, there was an error */
rc = nfs_SetFailedStatus(pexport, preq->rq_vers, cache_status,
&pres->res_dirop2.status, &pres->res_mkdir3.status,
NULL, ppre_attr,
&(pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc),
NULL, NULL);
out:
/* return references */
if (dir_pentry)
cache_inode_put(dir_pentry);
if (parent_pentry)
cache_inode_put(parent_pentry);
return (rc);
}
int nfs3_Mknod(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t * pres)
{
cache_entry_t *parent_pentry = NULL;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t *ppre_attr;
fsal_attrib_list_t attr_parent_after;
cache_inode_file_type_t parent_filetype;
cache_inode_file_type_t nodetype;
char *str_file_name = NULL;
fsal_name_t file_name;
cache_inode_status_t cache_status;
cache_inode_status_t cache_status_lookup;
fsal_accessmode_t mode = 0;
cache_entry_t *node_pentry = NULL;
fsal_attrib_list_t attr;
cache_inode_create_arg_t create_arg;
fsal_handle_t *pfsal_handle;
int rc = NFS_REQ_OK;
#ifdef _USE_QUOTA
fsal_status_t fsal_status ;
#endif
memset(&create_arg, 0, sizeof(create_arg));
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
sprint_fhandle3(str, &(parg->arg_mknod3.where.dir));
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs3_Mknod handle: %s name: %s",
str, parg->arg_mknod3.where.name);
}
/* to avoid setting them on each error case */
pres->res_mknod3.MKNOD3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_mknod3.MKNOD3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
/* retrieve parent entry */
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
NULL,
&(parg->arg_mknod3.where.dir),
NULL,
NULL,
&(pres->res_mknod3.status),
NULL,
&parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
return rc;
}
/* get directory attributes before action (for V3 reply) */
ppre_attr = &parent_attr;
/* Extract the filetype */
parent_filetype = cache_inode_fsal_type_convert(parent_attr.type);
/*
* Sanity checks: new node name must be non-null; parent must be a
* directory.
*/
if(parent_filetype != DIRECTORY)
{
pres->res_mknod3.status = NFS3ERR_NOTDIR;
rc = NFS_REQ_OK;
goto out;
}
str_file_name = parg->arg_mknod3.where.name;
switch (parg->arg_mknod3.what.type)
{
case NF3CHR:
case NF3BLK:
if(parg->arg_mknod3.what.mknoddata3_u.device.dev_attributes.mode.set_it)
mode =
(fsal_accessmode_t) parg->arg_mknod3.what.mknoddata3_u.device.dev_attributes.
mode.set_mode3_u.mode;
else
mode = (fsal_accessmode_t) 0;
create_arg.dev_spec.major =
parg->arg_mknod3.what.mknoddata3_u.device.spec.specdata1;
create_arg.dev_spec.minor =
parg->arg_mknod3.what.mknoddata3_u.device.spec.specdata2;
break;
case NF3FIFO:
case NF3SOCK:
if(parg->arg_mknod3.what.mknoddata3_u.pipe_attributes.mode.set_it)
mode =
(fsal_accessmode_t) parg->arg_mknod3.what.mknoddata3_u.pipe_attributes.mode.
set_mode3_u.mode;
else
mode = (fsal_accessmode_t) 0;
create_arg.dev_spec.major = 0;
create_arg.dev_spec.minor = 0;
break;
default:
pres->res_mknod3.status = NFS3ERR_BADTYPE;
rc = NFS_REQ_OK;
goto out;
}
switch (parg->arg_mknod3.what.type)
{
case NF3CHR:
nodetype = CHARACTER_FILE;
break;
case NF3BLK:
nodetype = BLOCK_FILE;
break;
case NF3FIFO:
nodetype = FIFO_FILE;
break;
case NF3SOCK:
nodetype = SOCKET_FILE;
break;
default:
pres->res_mknod3.status = NFS3ERR_BADTYPE;
rc = NFS_REQ_OK;
goto out;
}
//if(str_file_name == NULL || strlen(str_file_name) == 0)
if(str_file_name == NULL || *str_file_name == '\0' )
{
pres->res_mknod3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
#ifdef _USE_QUOTA
/* if quota support is active, then we should check is the FSAL allows inode creation or not */
fsal_status = FSAL_check_quota( pexport->fullpath,
FSAL_QUOTA_INODES,
FSAL_OP_CONTEXT_TO_UID( pcontext ) ) ;
if( FSAL_IS_ERROR( fsal_status ) )
{
pres->res_mknod3.status = NFS3ERR_DQUOT;
return NFS_REQ_OK;
}
#endif /* _USE_QUOTA */
/* convert node name */
if((cache_status = cache_inode_error_convert(FSAL_str2name(str_file_name,
0,
&file_name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup node to see if it exists. If so, use it. Otherwise
* create a new one.
*/
node_pentry = cache_inode_lookup(parent_pentry,
&file_name,
&attr,
pcontext,
&cache_status_lookup);
if(cache_status_lookup == CACHE_INODE_NOT_FOUND)
{
/* Create the node */
if((node_pentry = cache_inode_create(parent_pentry,
&file_name,
nodetype,
mode,
&create_arg,
&attr,
pcontext,
&cache_status)) != NULL)
{
MKNOD3resok *rok = &pres->res_mknod3.MKNOD3res_u.resok;
/*
* Get the FSAL handle for this entry
*/
pfsal_handle = &node_pentry->handle;
/* Build file handle */
pres->res_mknod3.status =
nfs3_AllocateFH(&rok->obj.post_op_fh3_u.handle);
if(pres->res_mknod3.status != NFS3_OK)
return NFS_REQ_OK;
if(nfs3_FSALToFhandle(&rok->obj.post_op_fh3_u.handle,
pfsal_handle, pexport) == 0)
{
gsh_free(rok->obj.post_op_fh3_u.handle.data.data_val);
pres->res_mknod3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
rok->obj.handle_follows = TRUE;
/* Build entry attributes */
nfs_SetPostOpAttr(pexport, &attr, &rok->obj_attributes);
/* Get the attributes of the parent after the operation */
if(cache_inode_getattr(parent_pentry,
&attr_parent_after,
pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
pres->res_mknod3.status = nfs3_Errno(cache_status);
rc = NFS_REQ_OK;
goto out;
}
/* Build Weak Cache Coherency data */
nfs_SetWccData(pexport, ppre_attr, &attr_parent_after,
&rok->dir_wcc);
pres->res_mknod3.status = NFS3_OK;
rc = NFS_REQ_OK;
goto out;
}
/* mknod sucess */
} /* not found */
else
{
/* object already exists or failure during lookup */
if(cache_status_lookup == CACHE_INODE_SUCCESS)
{
/* Trying to create an entry that already exists */
pres->res_mknod3.status = NFS3ERR_EXIST;
}
else
{
/* Server fault */
pres->res_mknod3.status = NFS3ERR_INVAL;
}
nfs_SetWccData(pexport, NULL, NULL,
&(pres->res_mknod3.MKNOD3res_u.resfail.dir_wcc));
rc = NFS_REQ_OK;
goto out;
}
}
/* If we are here, there was an error */
rc = nfs_SetFailedStatus(pexport, preq->rq_vers, cache_status, NULL,
&pres->res_mknod3.status, NULL, ppre_attr,
&(pres->res_mknod3.MKNOD3res_u.resfail.dir_wcc),
NULL, NULL);
out:
/* return references */
if (parent_pentry)
cache_inode_put(parent_pentry);
if (node_pentry)
cache_inode_put(node_pentry);
return (rc);
} /* nfs3_Mknod */
/**
* FSAL_readdir :
* Read the entries of an opened directory.
*
* \param dir_descriptor (input):
* Pointer to the directory descriptor filled by FSAL_opendir.
* \param start_position (input):
* Cookie that indicates the first object to be read during
* this readdir operation.
* This should be :
* - FSAL_READDIR_FROM_BEGINNING for reading the content
* of the directory from the beginning.
* - The end_position parameter returned by the previous
* call to FSAL_readdir.
* \param get_attr_mask (input)
* Specify the set of attributes to be retrieved for directory entries.
* \param buffersize (input)
* The size (in bytes) of the buffer where
* the direntries are to be stored.
* \param pdirent (output)
* Adresse of the buffer where the direntries are to be stored.
* \param end_position (output)
* Cookie that indicates the current position in the directory.
* \param nb_entries (output)
* Pointer to the number of entries read during the call.
* \param end_of_dir (output)
* Pointer to a boolean that indicates if the end of dir
* has been reached during the call.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - Another error code if an error occured.
*/
fsal_status_t POSIXFSAL_readdir(fsal_dir_t * dir_descriptor, /* IN */
fsal_cookie_t start_pos, /* IN */
fsal_attrib_mask_t get_attr_mask, /* IN */
fsal_mdsize_t buffersize, /* IN */
fsal_dirent_t * p_pdirent, /* OUT */
fsal_cookie_t * end_position, /* OUT */
fsal_count_t * p_nb_entries, /* OUT */
fsal_boolean_t * p_end_of_dir /* OUT */
)
{
posixfsal_dir_t * p_dir_descriptor = (posixfsal_dir_t *) dir_descriptor;
posixfsal_cookie_t start_position, telldir_pos;
posixfsal_cookie_t * p_end_position = (posixfsal_cookie_t *) end_position;
fsal_status_t st;
fsal_posixdb_status_t stdb;
fsal_count_t max_dir_entries;
struct dirent *dp;
struct dirent dpe;
struct stat buffstat;
fsal_path_t fsalpath;
fsal_posixdb_fileinfo_t infofs;
int rc;
/*****************/
/* sanity checks */
/*****************/
if(!p_dir_descriptor || !p_pdirent || !p_end_position || !p_nb_entries || !p_end_of_dir)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
max_dir_entries = (buffersize / sizeof(fsal_dirent_t));
/***************************/
/* seek into the directory */
/***************************/
memcpy ( (char *)&start_position.data.cookie, (char *)&start_pos.data, sizeof( off_t ) ) ;
errno = 0;
if(start_position.data.cookie == 0)
{
rewinddir(p_dir_descriptor->p_dir);
rc = errno;
}
else
{
seekdir(p_dir_descriptor->p_dir, start_position.data.cookie);
rc = errno;
}
if(rc)
{
st.major = posix2fsal_error(rc);
st.minor = rc;
goto readdir_error;
}
/************************/
/* browse the directory */
/************************/
*p_nb_entries = 0;
while(*p_nb_entries < max_dir_entries)
{
/***********************/
/* read the next entry */
/***********************/
TakeTokenFSCall();
rc = readdir_r(p_dir_descriptor->p_dir, &dpe, &dp);
ReleaseTokenFSCall();
if(rc)
{
st.major = posix2fsal_error(errno);
st.minor = errno;
goto readdir_error;
} /* End of directory */
if(!dp)
{
*p_end_of_dir = 1;
break;
}
/***********************************/
/* Get information about the entry */
/***********************************/
/* build the full path of the file into "fsalpath */
if(FSAL_IS_ERROR
(st =
FSAL_str2name(dp->d_name, FSAL_MAX_NAME_LEN, &(p_pdirent[*p_nb_entries].name))))
goto readdir_error;
memcpy(&fsalpath, &(p_dir_descriptor->path), sizeof(fsal_path_t));
st = fsal_internal_appendFSALNameToFSALPath(&fsalpath,
&(p_pdirent[*p_nb_entries].name));
if(FSAL_IS_ERROR(st))
goto readdir_error;
/* get object info */
TakeTokenFSCall();
rc = lstat(fsalpath.path, &buffstat);
ReleaseTokenFSCall();
if(rc)
{
st.major = posix2fsal_error(errno);
st.minor = errno;
goto readdir_error;
}
if(FSAL_IS_ERROR(st = fsal_internal_posix2posixdb_fileinfo(&buffstat, &infofs)))
goto readdir_error;
/********************/
/* fills the handle */
/********************/
/* check for "." and ".." */
if(!strcmp(dp->d_name, "."))
{
memcpy(&(p_pdirent[*p_nb_entries].handle), &(p_dir_descriptor->handle),
sizeof(posixfsal_handle_t));
}
else if(!strcmp(dp->d_name, ".."))
{
stdb = fsal_posixdb_getParentDirHandle(p_dir_descriptor->context.p_conn,
&(p_dir_descriptor->handle),
(posixfsal_handle_t *) &(p_pdirent[*p_nb_entries].handle));
if(FSAL_POSIXDB_IS_ERROR(stdb) && FSAL_IS_ERROR(st = posixdb2fsal_error(stdb)))
goto readdir_error;
}
else
{
#ifdef _USE_POSIXDB_READDIR_BLOCK
if(p_dir_descriptor->dbentries_count > -1)
{ /* look for the entry in dbentries */
st = fsal_internal_getInfoFromChildrenList(&(p_dir_descriptor->context),
&(p_dir_descriptor->handle),
&(p_pdirent[*p_nb_entries].name),
&infofs,
p_dir_descriptor->p_dbentries,
p_dir_descriptor->
dbentries_count,
&(p_pdirent[*p_nb_entries].
handle));
}
else
#endif
{ /* get handle for the entry */
st = fsal_internal_getInfoFromName(&(p_dir_descriptor->context),
&(p_dir_descriptor->handle),
&(p_pdirent[*p_nb_entries].name),
&infofs,
(posixfsal_handle_t *) &(p_pdirent[*p_nb_entries].handle));
}
if(FSAL_IS_ERROR(st))
goto readdir_error;
} /* end of name check for "." and ".." */
/************************
* Fills the attributes *
************************/
p_pdirent[*p_nb_entries].attributes.asked_attributes = get_attr_mask;
st = posix2fsal_attributes(&buffstat, &(p_pdirent[*p_nb_entries].attributes));
if(FSAL_IS_ERROR(st))
goto readdir_error;
/*
*
**/
telldir_pos.data.cookie = telldir(p_dir_descriptor->p_dir);
memcpy(&p_pdirent[*p_nb_entries].cookie, &telldir_pos, sizeof(fsal_cookie_t));
p_pdirent[*p_nb_entries].nextentry = NULL;
if(*p_nb_entries)
p_pdirent[*p_nb_entries - 1].nextentry = &(p_pdirent[*p_nb_entries]);
memcpy(p_end_position, &p_pdirent[*p_nb_entries].cookie, sizeof(fsal_cookie_t));
(*p_nb_entries)++;
};
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_readdir);
/* return error, and free what must be freed */
readdir_error:
Return(st.major, st.minor, INDEX_FSAL_readdir);
}
int nfs4_op_lookup(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
fsal_name_t name;
char strname[MAXNAMLEN];
#ifndef _NO_XATTRD
char objname[MAXNAMLEN];
#endif
unsigned int xattr_found = FALSE;
cache_entry_t *dir_pentry = NULL;
cache_entry_t *file_pentry = NULL;
fsal_attrib_list_t attrlookup;
cache_inode_status_t cache_status;
fsal_handle_t *pfsal_handle = NULL;
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_lookup";
resp->resop = NFS4_OP_LOOKUP;
res_LOOKUP4.status = NFS4_OK;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_LOOKUP4.status = NFS4ERR_NOFILEHANDLE;
return res_LOOKUP4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_LOOKUP4.status = NFS4ERR_BADHANDLE;
return res_LOOKUP4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_LOOKUP4.status = NFS4ERR_FHEXPIRED;
return res_LOOKUP4.status;
}
/* Check for empty name */
if(op->nfs_argop4_u.oplookup.objname.utf8string_len == 0 ||
op->nfs_argop4_u.oplookup.objname.utf8string_val == NULL)
{
res_LOOKUP4.status = NFS4ERR_INVAL;
return res_LOOKUP4.status;
}
/* Check for name to long */
if(op->nfs_argop4_u.oplookup.objname.utf8string_len > FSAL_MAX_NAME_LEN)
{
res_LOOKUP4.status = NFS4ERR_NAMETOOLONG;
return res_LOOKUP4.status;
}
/* If Filehandle points to a pseudo fs entry, manage it via pseudofs specific functions */
if(nfs4_Is_Fh_Pseudo(&(data->currentFH)))
return nfs4_op_lookup_pseudo(op, data, resp);
#ifndef _NO_XATTRD
/* If Filehandle points to a xattr object, manage it via the xattrs specific functions */
if(nfs4_Is_Fh_Xattr(&(data->currentFH)))
return nfs4_op_lookup_xattr(op, data, resp);
#endif
/* UTF8 strings may not end with \0, but they carry their length */
utf82str(strname, sizeof(strname), &arg_LOOKUP4.objname);
#ifndef _NO_XATTRD
/* Is this a .xattr.d.<object> name ? */
if(nfs_XattrD_Name(strname, objname))
{
strcpy(strname, objname);
xattr_found = TRUE;
}
#endif
if((cache_status = cache_inode_error_convert(FSAL_str2name(strname,
MAXNAMLEN,
&name))) !=
CACHE_INODE_SUCCESS)
{
res_LOOKUP4.status = nfs4_Errno(cache_status);
return res_LOOKUP4.status;
}
/* No 'cd .' is allowed return NFS4ERR_BADNAME in this case */
/* No 'cd .. is allowed, return EINVAL in this case. NFS4_OP_LOOKUPP should be use instead */
if(!FSAL_namecmp(&name, (fsal_name_t *) & FSAL_DOT)
|| !FSAL_namecmp(&name, (fsal_name_t *) & FSAL_DOT_DOT))
{
res_LOOKUP4.status = NFS4ERR_BADNAME;
return res_LOOKUP4.status;
}
/* Do the lookup in the HPSS Namespace */
file_pentry = NULL;
dir_pentry = data->current_entry;
/* Sanity check: dir_pentry should be ACTUALLY a directory */
if(dir_pentry->internal_md.type != DIR_BEGINNING
&& dir_pentry->internal_md.type != DIR_CONTINUE)
{
/* This is not a directory */
if(dir_pentry->internal_md.type == SYMBOLIC_LINK)
res_LOOKUP4.status = NFS4ERR_SYMLINK;
else
res_LOOKUP4.status = NFS4ERR_NOTDIR;
/* Return failed status */
return res_LOOKUP4.status;
}
/* BUGAZOMEU: Faire la gestion des cross junction traverse */
if((file_pentry = cache_inode_lookup(dir_pentry,
&name,
&attrlookup,
data->ht,
data->pclient,
data->pcontext, &cache_status)) != NULL)
{
/* Extract the fsal attributes from the cache inode pentry */
pfsal_handle = cache_inode_get_fsal_handle(file_pentry, &cache_status);
if(cache_status != CACHE_INODE_SUCCESS)
{
res_LOOKUP4.status = NFS4ERR_SERVERFAULT;
return res_LOOKUP4.status;
}
/* Convert it to a file handle */
if(!nfs4_FSALToFhandle(&data->currentFH, pfsal_handle, data))
{
res_LOOKUP4.status = NFS4ERR_SERVERFAULT;
return res_LOOKUP4.status;
}
/* Copy this to the mounted on FH (if no junction is traversed */
memcpy((char *)(data->mounted_on_FH.nfs_fh4_val),
(char *)(data->currentFH.nfs_fh4_val), data->currentFH.nfs_fh4_len);
data->mounted_on_FH.nfs_fh4_len = data->currentFH.nfs_fh4_len;
#if 0
print_buff((char *)cache_inode_get_fsal_handle(file_pentry, &cache_status),
sizeof(fsal_handle_t));
print_buff((char *)cache_inode_get_fsal_handle(dir_pentry, &cache_status),
sizeof(fsal_handle_t));
#endif
if(isFullDebug(COMPONENT_NFS_V4))
{
LogFullDebug(COMPONENT_NFS_V4,
"----> nfs4_op_lookup: name=%s dir_pentry=%p looked up pentry=%p",
strname, dir_pentry, file_pentry);
LogFullDebug(COMPONENT_NFS_V4,
"----> FSAL handle parent puis fils dans nfs4_op_lookup");
print_buff(COMPONENT_NFS_V4,
(char *)cache_inode_get_fsal_handle(file_pentry, &cache_status),
sizeof(fsal_handle_t));
print_buff(COMPONENT_NFS_V4,
(char *)cache_inode_get_fsal_handle(dir_pentry, &cache_status),
sizeof(fsal_handle_t));
}
LogHandleNFS4("NFS4 LOOKUP CURRENT FH: ", &data->currentFH);
/* Keep the pointer within the compound data */
data->current_entry = file_pentry;
data->current_filetype = file_pentry->internal_md.type;
/* Return successfully */
res_LOOKUP4.status = NFS4_OK;
#ifndef _NO_XATTRD
/* If this is a xattr ghost directory name, update the FH */
if(xattr_found == TRUE)
res_LOOKUP4.status = nfs4_fh_to_xattrfh(&(data->currentFH), &(data->currentFH));
#endif
if((data->current_entry->internal_md.type == DIR_BEGINNING) &&
(data->current_entry->object.dir_begin.referral != NULL))
{
if(!nfs4_Set_Fh_Referral(&(data->currentFH)))
{
res_LOOKUP4.status = NFS4ERR_SERVERFAULT;
return res_LOOKUP4.status;
}
}
return NFS4_OK;
}
/* If the part of the code is reached, then something wrong occured in the lookup process, status is not HPSS_E_NOERROR
* and contains the code for the error */
res_LOOKUP4.status = nfs4_Errno(cache_status);
return res_LOOKUP4.status;
} /* nfs4_op_lookup */
main(int argc, char *argv[])
{
char localmachine[256];
cache_inode_client_t client;
LRU_parameter_t lru_param;
LRU_status_t lru_status;
cache_inode_fsal_data_t fsdata;
fsal_status_t status;
fsal_parameter_t init_param;
fsal_name_t name;
fsal_path_t path;
fsal_attrib_mask_t mask;
fsal_path_t pathroot;
fsal_attrib_list_t attribs;
fsal_handle_t root_handle;
cache_inode_endofdir_t eod_met;
cache_inode_dir_entry_t dirent_array[100];
cache_inode_dir_entry_t dirent_array_loop[5];
unsigned int nbfound;
unsigned int begin_cookie = 0;
hash_buffer_t key, value;
uid_t uid;
fsal_cred_t cred;
cache_inode_status_t cache_status;
cache_inode_parameter_t cache_param;
cache_inode_client_parameter_t cache_client_param;
hash_table_t *ht = NULL;
fsal_attrib_list_t attrlookup;
cache_entry_t *cache_entry_root = NULL;
cache_entry_t *cache_entry_lookup = NULL;
cache_entry_t *cache_entry_lookup2 = NULL;
cache_entry_t *cache_entry_lookup3 = NULL;
cache_entry_t *cache_entry_lookup4 = NULL;
cache_entry_t *cache_entry_dircont = NULL;
cache_inode_gc_policy_t gcpol;
char *configfile = argv[1];
int i = 0;
int rc = 0;
/* Init the Buddy System allocation */
if((rc = BuddyInit(NULL)) != BUDDY_SUCCESS)
{
LogTest("Error initializing memory allocator");
exit(1);
}
/* init debug */
SetDefaultLogging("TEST");
SetNamePgm("test_cache_inode");
SetNameFunction("main");
InitLogging();
#if defined( _USE_GHOSTFS )
if(argc != 2)
{
LogTest("Please set the configuration file as parameter");
exit(1);
}
#endif
/* Obtention du nom de la machine */
if(gethostname(localmachine, sizeof(localmachine)) != 0)
{
LogError(COMPONENT_STDOUT,ERR_SYS, ERR_GETHOSTNAME, errno);
exit(1);
}
else
SetNameHost(localmachine);
AddFamilyError(ERR_FSAL, "FSAL related Errors", tab_errstatus_FSAL);
AddFamilyError(ERR_CACHE_INODE, "FSAL related Errors", tab_errstatus_cache_inode);
/* creating log */
LogTest( "Starting the test");
LogTest( "-----------------");
#if defined( _USE_GHOSTFS )
if(FSAL_IS_ERROR(status = FSAL_str2path(configfile,
strlen(configfile) + 1,
&(init_param.fs_specific_info.
definition_file))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
}
#elif defined( _USE_HPSS )
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, Flags);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DebugValue);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, TransferType);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, NumRetries);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, BusyDelay);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, BusyRetries);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, TotalDelay);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, GKTotalDelay);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, LimitedRetries);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, MaxConnections);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, ReuseDataConnections);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, UsePortRange);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, RetryStageInp);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DMAPWriteUpdates);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, ServerName);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DescName);
init_param.fs_specific_info.behaviors.PrincipalName = FSAL_INIT_FORCE_VALUE;
strncpy(init_param.fs_specific_info.hpss_config.PrincipalName,
HPSS_SSM, HPSS_MAX_PRINCIPAL_NAME);
init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE;
strncpy(init_param.fs_specific_info.hpss_config.KeytabPath,
HPSS_KEYTAB, HPSS_MAX_PATH_NAME);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DebugPath);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, HostName);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, RegistrySiteName);
#endif
/* 2-common info (default) */
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxfilesize);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxlink);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxnamelen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxpathlen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, no_trunc);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, chown_restricted);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_insensitive);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_preserving);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, fh_expire_type);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, link_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, symlink_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, named_attr);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, unique_handles);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, lease_time);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, acl_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, cansettime);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, homogenous);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxread);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxwrite);
/* Init */
if(FSAL_IS_ERROR(status = FSAL_Init(&init_param)))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
}
/* getting creds */
uid = getuid();
if(FSAL_IS_ERROR(status = FSAL_GetUserCred(uid, NULL, &cred)))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
}
/* Init of the cache inode module */
cache_param.hparam.index_size = 31;
cache_param.hparam.alphabet_length = 10; /* Buffer seen as a decimal polynom */
cache_param.hparam.nb_node_prealloc = 100;
cache_param.hparam.hash_func_key = cache_inode_fsal_hash_func;
cache_param.hparam.hash_func_rbt = cache_inode_fsal_rbt_func;
cache_param.hparam.hash_func_both = NULL ; /* BUGAZOMEU */
cache_param.hparam.compare_key = cache_inode_compare_key_fsal;
cache_param.hparam.key_to_str = display_key;
cache_param.hparam.val_to_str = display_value;
if((ht = cache_inode_init(cache_param, &cache_status)) == NULL)
{
LogTest( "Error %d while init hash ", cache_status);
}
else
LogTest( "Hash Table address = %p", ht);
/* We need a cache_client to acces the cache */
cache_client_param.attrmask =
FSAL_ATTRS_MANDATORY | FSAL_ATTR_MTIME | FSAL_ATTR_CTIME | FSAL_ATTR_ATIME;
cache_client_param.nb_prealloc_entry = 1000;
cache_client_param.nb_pre_dir_data = 200;
cache_client_param.nb_pre_parent = 1200;
cache_client_param.nb_pre_state_v4 = 100;
cache_client_param.lru_param.nb_entry_prealloc = 1000;
cache_client_param.lru_param.entry_to_str = lru_entry_to_str;
cache_client_param.lru_param.clean_entry = lru_clean_entry;
cache_client_param.grace_period_attr = 0;
cache_client_param.grace_period_link = 0;
cache_client_param.grace_period_dirent = 0;
cache_client_param.expire_type_attr = CACHE_INODE_EXPIRE_NEVER;
cache_client_param.expire_type_link = CACHE_INODE_EXPIRE_NEVER;
cache_client_param.expire_type_dirent = CACHE_INODE_EXPIRE_NEVER;
/* Init the cache_inode client */
if(cache_inode_client_init(&client, cache_client_param, 0, NULL) != 0)
exit(1);
/* Init the gc */
gcpol.file_expiration_delay = 3;
gcpol.directory_expiration_delay = 4;
gcpol.hwmark_nb_entries = 6;
gcpol.lwmark_nb_entries = 3;
gcpol.run_interval = 4;
cache_inode_set_gc_policy(gcpol);
/* Getting the root of the FS */
if((FSAL_IS_ERROR(status = FSAL_str2path("/", 2, &pathroot))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
if((FSAL_IS_ERROR(status = FSAL_lookupPath(&pathroot, &cred, &root_handle, &attribs))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
fsdata.cookie = 0;
fsdata.handle = root_handle;
/* Cache the root of the FS */
if((cache_entry_root =
cache_inode_make_root(&fsdata, 1, ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't init fs's root");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("cea", 10, &name))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup = cache_inode_lookup(cache_entry_root,
&name,
&attrlookup,
ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
/* Lookup a second time (entry should now be cached) */
if((cache_entry_lookup2 = cache_inode_lookup(cache_entry_root,
&name,
&attrlookup,
ht,
&client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
if(cache_entry_lookup2 != cache_entry_lookup)
{
LogTest("Error: lookup results should be the same");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("log", 10, &name))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup3 = cache_inode_lookup(cache_entry_root,
&name,
&attrlookup,
ht,
&client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
if((cache_entry_lookup4 = cache_inode_lookup(cache_entry_root,
&name,
&attrlookup,
ht,
&client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
if(cache_entry_lookup3 != cache_entry_lookup4)
{
LogTest("Error: lookup results should be the same");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("SunOS_5", 10, &name))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
cache_inode_print_dir(cache_entry_root);
/* Test readdir */
if(cache_inode_readdir(cache_entry_root,
0,
100,
&nbfound,
&eod_met,
dirent_array,
ht, &client, &cred, &cache_status) != CACHE_INODE_SUCCESS)
{
LogTest( "Error: cache_inode_readdir failed");
exit(1);
}
LogTest( "Readdir nbfound=%d, eod_met=%d", nbfound, eod_met);
for(i = 0; i < nbfound; i++)
LogTest( "dirent_array[%d] ==> %s | %p", i,
dirent_array[i].name.name, dirent_array[i].pentry);
cache_inode_print_dir(cache_entry_root);
/* looping on readir */
LogTest( "Loop directory in several pass");
eod_met = TO_BE_CONTINUED;
begin_cookie = 0;
do
{
if(cache_inode_readdir(cache_entry_root,
begin_cookie,
2,
&nbfound,
&eod_met,
dirent_array_loop,
ht, &client, &cred, &cache_status) != CACHE_INODE_SUCCESS)
{
LogTest("Error: cache_inode_readdir failed: %d", cache_status);
exit(1);
}
for(i = 0; i < nbfound; i++)
LogTest( " ==> %s | %p", dirent_array_loop[i].name.name,
dirent_array_loop[i].pentry);
begin_cookie += nbfound;
}
while(eod_met == TO_BE_CONTINUED);
LogTest( "---------------------------------");
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("cea", 10, &name))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup = cache_inode_lookup(cache_entry_root,
&name,
&attrlookup,
ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("log", 10, &name))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup = cache_inode_lookup(cache_entry_root,
&name,
&attrlookup,
ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
/* Print the Hash Table */
HashTable_Log(COMPONENT_STDOUT, ht);
#ifdef _ADDITIONAL_TEST
/* Trying to lookup from a DIR_CONTINUE */
fsdata.handle = cache_entry_root->object.dir_begin.handle;
fsdata.cookie = 3 * CHILDREN_ARRAY_SIZE;
LogTest("Input key: (Handle=%p, Cookie=%d)", fsdata.handle, fsdata.cookie);
/* Turn the input to a hash key */
if(cache_inode_fsaldata_2_key(&key, &fsdata, NULL))
{
LogTest( "Impossible to allocate a key to that value");
exit(1);
}
if(HashTable_Get(ht, &key, &value) != HASHTABLE_SUCCESS)
{
LogTest( "Key could not be found");
exit(1);
}
/* pentry for the dir cont */
cache_entry_dircont = (cache_entry_t *) value.pdata;
/* Test readdir */
if(cache_inode_readdir(cache_entry_dircont,
fsdata.cookie,
100,
&nbfound,
&eod_met,
dirent_array,
ht, &client, &cred, &cache_status) != CACHE_INODE_SUCCESS)
{
LogTest( "Error: cache_inode_readdir failed");
exit(1);
}
#endif
LogTest( "Readdir nbfound=%d, eod_met=%d", nbfound, eod_met);
for(i = 0; i < nbfound; i++)
LogTest( "dirent_array[%d] ==> %s | %p ", i,
dirent_array[i].name.name, dirent_array[i].pentry);
/* Call the GC */
LogTest( "Sleeping %d second before gc (for gc invalidation)",
gcpol.file_expiration_delay + 2);
sleep(gcpol.file_expiration_delay + 2);
if(cache_inode_gc(ht, &client, &cache_status) != CACHE_INODE_SUCCESS)
{
LogTest( "Error: cache_inode_gc failed");
exit(1);
}
LogTest( "GC performed successfully");
/* Print the Hash Table */
HashTable_Log(COMPONENT_STDOUT, ht);
/* Another readdir, after gc is made */
eod_met = TO_BE_CONTINUED;
begin_cookie = 0;
LogTest( "ANOTHER READDIR AFTER GC");
do
{
if(cache_inode_readdir(cache_entry_root,
begin_cookie,
2,
&nbfound,
&eod_met,
dirent_array_loop,
ht, &client, &cred, &cache_status) != CACHE_INODE_SUCCESS)
{
LogTest("Error: cache_inode_readdir failed: %d", cache_status);
exit(1);
}
for(i = 0; i < nbfound; i++)
LogTest( " ==> %s | %p", dirent_array_loop[i].name.name,
dirent_array_loop[i].pentry);
begin_cookie += nbfound;
}
while(eod_met == TO_BE_CONTINUED);
LogTest( "---------------------------------");
/* Print the Hash Table */
HashTable_Log(COMPONENT_STDOUT, ht);
LogTest( "---------------------------------");
/* The end of all the tests */
LogTest( "All tests exited successfully");
exit(0);
} /* main */
int nfs_Rename(nfs_arg_t * parg /* IN */ ,
exportlist_t * pexport /* IN */ ,
fsal_op_context_t * pcontext /* IN */ ,
cache_inode_client_t * pclient /* IN */ ,
hash_table_t * ht /* INOUT */ ,
struct svc_req *preq /* IN */ ,
nfs_res_t * pres /* OUT */ )
{
static char __attribute__ ((__unused__)) funcName[] = "nfs_Rename";
char *str_entry_name = NULL;
fsal_name_t entry_name;
char *str_new_entry_name = NULL;
fsal_name_t new_entry_name;
cache_entry_t *pentry = NULL;
cache_entry_t *new_pentry = NULL;
cache_entry_t *parent_pentry = NULL;
cache_entry_t *new_parent_pentry = NULL;
cache_entry_t *should_not_exists = NULL;
cache_entry_t *should_exists = NULL;
cache_inode_status_t cache_status;
int rc;
fsal_attrib_list_t *ppre_attr;
fsal_attrib_list_t pre_attr;
fsal_attrib_list_t *pnew_pre_attr;
fsal_attrib_list_t new_attr;
fsal_attrib_list_t new_parent_attr;
fsal_attrib_list_t attr;
fsal_attrib_list_t tst_attr;
cache_inode_file_type_t parent_filetype;
cache_inode_file_type_t new_parent_filetype;
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_rename3.RENAME3res_u.resfail.fromdir_wcc.before.attributes_follow = FALSE;
pres->res_rename3.RENAME3res_u.resfail.fromdir_wcc.after.attributes_follow = FALSE;
pres->res_rename3.RENAME3res_u.resfail.todir_wcc.before.attributes_follow = FALSE;
pres->res_rename3.RENAME3res_u.resfail.todir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
pnew_pre_attr = NULL;
}
/* Convert fromdir file handle into a cache_entry */
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_rename2.from.dir),
&(parg->arg_rename3.from.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_create3.status),
NULL,
&pre_attr, pcontext, pclient, ht, &rc)) == NULL)
{
/* Stale NFS FH ? */
return rc;
}
/* Convert todir file handle into a cache_entry */
if((new_parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_rename2.to.dir),
&(parg->arg_rename3.to.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_create3.status),
NULL,
&new_parent_attr,
pcontext, pclient, ht, &rc)) == NULL)
{
/* Stale NFS FH ? */
return rc;
}
/* get the attr pointers */
ppre_attr = &pre_attr;
pnew_pre_attr = &new_parent_attr;
/* Get the filetypes */
parent_filetype = cache_inode_fsal_type_convert(pre_attr.type);
new_parent_filetype = cache_inode_fsal_type_convert(new_parent_attr.type);
/*
* Sanity checks: we must manage directories
*/
if((parent_filetype != DIR_BEGINNING && parent_filetype != DIR_CONTINUE) ||
(new_parent_filetype != DIR_BEGINNING && new_parent_filetype != DIR_CONTINUE))
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_rename3.status = NFS3ERR_NOTDIR;
break;
}
return NFS_REQ_OK;
}
switch (preq->rq_vers)
{
case NFS_V2:
str_entry_name = parg->arg_rename2.from.name;
str_new_entry_name = parg->arg_rename2.to.name;
break;
case NFS_V3:
str_entry_name = parg->arg_rename3.from.name;
str_new_entry_name = parg->arg_rename3.to.name;
break;
}
pentry = new_pentry = NULL;
if(str_entry_name == NULL ||
strlen(str_entry_name) == 0 ||
str_new_entry_name == NULL ||
strlen(str_new_entry_name) == 0 ||
FSAL_IS_ERROR(FSAL_str2name(str_entry_name, FSAL_MAX_NAME_LEN, &entry_name)) ||
FSAL_IS_ERROR(FSAL_str2name(str_new_entry_name, FSAL_MAX_NAME_LEN, &new_entry_name)))
{
cache_status = CACHE_INODE_INVALID_ARGUMENT;
}
else
{
/*
* Lookup file to see if new entry exists
*
*/
should_not_exists = cache_inode_lookup(new_parent_pentry,
&new_entry_name,
&tst_attr,
ht, pclient, pcontext, &cache_status);
if(cache_status == CACHE_INODE_NOT_FOUND)
{
/* We need to lookup over the old entry also */
should_exists = cache_inode_lookup(parent_pentry,
&entry_name,
&tst_attr,
ht, pclient, pcontext, &cache_status);
/* Rename entry */
if(cache_status == CACHE_INODE_SUCCESS)
cache_inode_rename(parent_pentry,
&entry_name,
new_parent_pentry,
&new_entry_name,
&attr, &new_attr, ht, pclient, pcontext, &cache_status);
if(cache_status == CACHE_INODE_SUCCESS)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFS_OK;
break;
case NFS_V3:
/*
* Build Weak Cache Coherency
* data
*/
nfs_SetWccData(pcontext, pexport,
parent_pentry,
ppre_attr,
&attr,
&(pres->res_rename3.RENAME3res_u.resok.fromdir_wcc));
nfs_SetWccData(pcontext, pexport,
new_parent_pentry,
pnew_pre_attr,
&new_attr,
&(pres->res_rename3.RENAME3res_u.resok.todir_wcc));
pres->res_rename3.status = NFS3_OK;
break;
}
return NFS_REQ_OK;
}
}
else
{
/* If name are the same (basically renaming a/file1 to a/file1, this is a non-erroneous situation to be managed */
if(new_parent_pentry == parent_pentry)
{
if(!FSAL_namecmp(&new_entry_name, &entry_name))
{
/* trying to rename a file to himself, this is allowed */
cache_status = CACHE_INODE_SUCCESS;
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFS_OK;
break;
case NFS_V3:
/*
* Build Weak Cache Coherency
* data
*/
nfs_SetWccData(pcontext, pexport,
parent_pentry,
ppre_attr,
&attr,
&(pres->res_rename3.RENAME3res_u.resok.fromdir_wcc));
nfs_SetWccData(pcontext, pexport,
parent_pentry,
ppre_attr,
&attr,
&(pres->res_rename3.RENAME3res_u.resok.todir_wcc));
pres->res_rename3.status = NFS3_OK;
break;
}
return NFS_REQ_OK;
}
}
/* New entry already exists. In this case (see RFC), entry should be compatible: Both are non-directories or
* both are directories and 'todir' is empty. If compatible, old 'todir' entry is scratched, if not returns EEXISTS */
if(should_not_exists != NULL)
{
/* We need to lookup over the old entry also */
if((should_exists = cache_inode_lookup(parent_pentry,
&entry_name,
&tst_attr,
ht,
pclient,
pcontext, &cache_status)) != NULL)
{
if(cache_inode_type_are_rename_compatible
(should_exists, should_not_exists))
{
/* Remove the old entry before renaming it */
if(cache_inode_remove(new_parent_pentry,
&new_entry_name,
&tst_attr,
ht,
pclient,
pcontext,
&cache_status) == CACHE_INODE_SUCCESS)
{
if(cache_inode_rename(parent_pentry,
&entry_name,
new_parent_pentry,
&new_entry_name,
&attr,
&new_attr,
ht,
pclient,
pcontext,
&cache_status) == CACHE_INODE_SUCCESS)
{
/* trying to rename a file to himself, this is allowed */
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFS_OK;
break;
case NFS_V3:
/*
* Build Weak Cache Coherency
* data
*/
nfs_SetWccData(pcontext, pexport,
parent_pentry,
ppre_attr,
&attr,
&(pres->res_rename3.RENAME3res_u.resok.
fromdir_wcc));
nfs_SetWccData(pcontext, pexport,
parent_pentry,
ppre_attr,
&attr,
&(pres->res_rename3.RENAME3res_u.resok.
todir_wcc));
pres->res_rename3.status = NFS3_OK;
break;
}
return NFS_REQ_OK;
}
}
}
} /* if( cache_inode_type_are_rename_compatible( should_exists, should_not_exists ) ) */
}
/* if( ( should_exists = cache_inode_lookup( parent_pentry, .... */
/* If this point is reached, then destination object already exists with that name in the directory
and types are not compatible, we should return that the file exists */
cache_status = CACHE_INODE_ENTRY_EXISTS;
} /* if( should_not_exists != NULL ) */
}
/* If we are here, there was an error */
if(nfs_RetryableError(cache_status))
{
return NFS_REQ_DROP;
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_stat2,
&pres->res_rename3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_rename3.RENAME3res_u.resfail.fromdir_wcc),
new_parent_pentry,
pnew_pre_attr, &(pres->res_rename3.RENAME3res_u.resfail.todir_wcc));
return NFS_REQ_OK;
} /* nfs_Rename */
