void posix2fsal_attributes(const struct stat *buffstat,
struct attrlist *fsalattr)
{
FSAL_CLEAR_MASK(fsalattr->mask);
/* Fills the output struct */
fsalattr->type = posix2fsal_type(buffstat->st_mode);
FSAL_SET_MASK(fsalattr->mask, ATTR_TYPE);
fsalattr->filesize = buffstat->st_size;
FSAL_SET_MASK(fsalattr->mask, ATTR_SIZE);
fsalattr->fsid = posix2fsal_fsid(buffstat->st_dev);
FSAL_SET_MASK(fsalattr->mask, ATTR_FSID);
fsalattr->fileid = buffstat->st_ino;
FSAL_SET_MASK(fsalattr->mask, ATTR_FILEID);
fsalattr->mode = unix2fsal_mode(buffstat->st_mode);
FSAL_SET_MASK(fsalattr->mask, ATTR_MODE);
fsalattr->numlinks = buffstat->st_nlink;
FSAL_SET_MASK(fsalattr->mask, ATTR_NUMLINKS);
fsalattr->owner = buffstat->st_uid;
FSAL_SET_MASK(fsalattr->mask, ATTR_OWNER);
fsalattr->group = buffstat->st_gid;
FSAL_SET_MASK(fsalattr->mask, ATTR_GROUP);
/* Use full timer resolution */
#ifdef LINUX
fsalattr->atime = buffstat->st_atim;
fsalattr->ctime = buffstat->st_ctim;
fsalattr->mtime = buffstat->st_mtim;
fsalattr->chgtime =
(gsh_time_cmp(&buffstat->st_mtim, &buffstat->st_ctim) >
0) ? fsalattr->mtime : fsalattr->ctime;
#elif FREEBSD
fsalattr->atime = buffstat->st_atimespec;
fsalattr->ctime = buffstat->st_ctimespec;
fsalattr->mtime = buffstat->st_mtimespec;
fsalattr->chgtime =
(gsh_time_cmp(&buffstat->st_mtimespec, &buffstat->st_ctimespec) >
0) ? fsalattr->mtime : fsalattr->ctime;
#endif
FSAL_SET_MASK(fsalattr->mask, ATTR_ATIME);
FSAL_SET_MASK(fsalattr->mask, ATTR_CTIME);
FSAL_SET_MASK(fsalattr->mask, ATTR_MTIME);
fsalattr->change = timespec_to_nsecs(&fsalattr->chgtime);
FSAL_SET_MASK(fsalattr->mask, ATTR_CHGTIME);
fsalattr->spaceused = buffstat->st_blocks * S_BLKSIZE;
FSAL_SET_MASK(fsalattr->mask, ATTR_SPACEUSED);
fsalattr->rawdev = posix2fsal_devt(buffstat->st_rdev);
FSAL_SET_MASK(fsalattr->mask, ATTR_RAWDEV);
}
fsal_status_t posix2fsal_attributes(const struct stat *buffstat,
struct attrlist *fsalattr)
{
FSAL_CLEAR_MASK(fsalattr->mask);
/* sanity checks */
if(!buffstat || !fsalattr)
return fsalstat(ERR_FSAL_FAULT, 0);
FSAL_CLEAR_MASK(fsalattr->mask);
/* Fills the output struct */
fsalattr->type = posix2fsal_type(buffstat->st_mode);
FSAL_SET_MASK(fsalattr->mask, ATTR_TYPE);
fsalattr->filesize = buffstat->st_size;
FSAL_SET_MASK(fsalattr->mask, ATTR_SIZE);
fsalattr->fsid = posix2fsal_fsid(buffstat->st_dev);
FSAL_SET_MASK(fsalattr->mask, ATTR_FSID);
fsalattr->fileid = buffstat->st_ino;
FSAL_SET_MASK(fsalattr->mask, ATTR_FILEID);
fsalattr->mode = unix2fsal_mode(buffstat->st_mode);
FSAL_SET_MASK(fsalattr->mask, ATTR_MODE);
fsalattr->numlinks = buffstat->st_nlink;
FSAL_SET_MASK(fsalattr->mask, ATTR_NUMLINKS);
fsalattr->owner = buffstat->st_uid;
FSAL_SET_MASK(fsalattr->mask, ATTR_OWNER);
fsalattr->group = buffstat->st_gid;
FSAL_SET_MASK(fsalattr->mask, ATTR_GROUP);
fsalattr->atime = posix2fsal_time(buffstat->st_atime, 0);
FSAL_SET_MASK(fsalattr->mask, ATTR_ATIME);
fsalattr->ctime = posix2fsal_time(buffstat->st_ctime, 0);
FSAL_SET_MASK(fsalattr->mask, ATTR_CTIME);
fsalattr->mtime = posix2fsal_time(buffstat->st_mtime, 0);
FSAL_SET_MASK(fsalattr->mask, ATTR_MTIME);
fsalattr->chgtime
= posix2fsal_time(MAX_2(buffstat->st_mtime,
buffstat->st_ctime), 0);
fsalattr->change = fsalattr->chgtime.tv_sec;
FSAL_SET_MASK(fsalattr->mask, ATTR_CHGTIME);
fsalattr->spaceused = buffstat->st_blocks * S_BLKSIZE;
FSAL_SET_MASK(fsalattr->mask, ATTR_SPACEUSED);
fsalattr->rawdev = posix2fsal_devt(buffstat->st_rdev);
FSAL_SET_MASK(fsalattr->mask, ATTR_RAWDEV);
return fsalstat(ERR_FSAL_NO_ERROR, 0);
}
/**
* @brief convert 'struct stat' to 'fsal_posixdb_fileinfo_t'
*
* @param buffstat
* @param info
*
* @return
*/
fsal_status_t fsal_internal_posix2posixdb_fileinfo(struct stat *buffstat,
fsal_posixdb_fileinfo_t * info)
{
/* sanity check */
if(!info || !buffstat)
ReturnCode(ERR_FSAL_FAULT, 0);
memset(info, 0, sizeof(fsal_posixdb_fileinfo_t));
info->devid = buffstat->st_dev;
info->inode = buffstat->st_ino;
info->nlink = (int)buffstat->st_nlink;
info->ctime = buffstat->st_ctime;
info->ftype = posix2fsal_type(buffstat->st_mode);
ReturnCode(ERR_FSAL_NO_ERROR, 0);
}
void stat2fsal_attributes(const struct stat *buffstat,
struct attrlist *fsalattr)
{
/* Indicate which atrributes we have set without affecting the
* other bits in the mask.
*/
fsalattr->valid_mask |= ATTRS_POSIX;
fsalattr->supported = op_ctx->fsal_export->exp_ops.fs_supported_attrs(
op_ctx->fsal_export);
/* Fills the output struct */
fsalattr->type = posix2fsal_type(buffstat->st_mode);
fsalattr->filesize = buffstat->st_size;
fsalattr->fsid = posix2fsal_fsid(buffstat->st_dev);
fsalattr->fileid = buffstat->st_ino;
fsalattr->mode = unix2fsal_mode(buffstat->st_mode);
fsalattr->numlinks = buffstat->st_nlink;
fsalattr->owner = buffstat->st_uid;
fsalattr->group = buffstat->st_gid;
/** @todo: gfapi currently only fills in the legacy time_t fields
* when it supports the timespec fields calls to this
* function should be replaced with calls to
* posix2fsal_attributes rather than changing this code.
*/
fsalattr->atime = posix2fsal_time(buffstat->st_atime, 0);
fsalattr->ctime = posix2fsal_time(buffstat->st_ctime, 0);
fsalattr->mtime = posix2fsal_time(buffstat->st_mtime, 0);
fsalattr->chgtime = posix2fsal_time(MAX(buffstat->st_mtime,
buffstat->st_ctime), 0);
fsalattr->change = fsalattr->chgtime.tv_sec;
fsalattr->spaceused = buffstat->st_blocks * S_BLKSIZE;
fsalattr->rawdev = posix2fsal_devt(buffstat->st_rdev);
}
fsal_status_t posix2fsal_attributes(struct stat * p_buffstat,
fsal_attrib_list_t * p_fsalattr_out)
{
fsal_attrib_mask_t supp_attr, unsupp_attr;
/* sanity checks */
if(!p_buffstat || !p_fsalattr_out)
ReturnCode(ERR_FSAL_FAULT, 0);
/* check that asked attributes are supported */
supp_attr = global_fs_info.supported_attrs;
unsupp_attr = (p_fsalattr_out->asked_attributes) & (~supp_attr);
if(unsupp_attr)
{
LogFullDebug(COMPONENT_FSAL, "Unsupported attributes: %#llX",
unsupp_attr);
ReturnCode(ERR_FSAL_ATTRNOTSUPP, 0);
}
/* Initialize ACL regardless of whether ACL was asked or not.
* This is needed to make sure ACL attribute is initialized. */
p_fsalattr_out->acl = NULL;
/* Fills the output struct */
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SUPPATTR))
{
p_fsalattr_out->supported_attributes = supp_attr;
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_TYPE))
{
p_fsalattr_out->type = posix2fsal_type(p_buffstat->st_mode);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SIZE))
{
p_fsalattr_out->filesize = p_buffstat->st_size;
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_FSID))
{
p_fsalattr_out->fsid = posix2fsal_fsid(p_buffstat->st_dev);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_ACL))
{
p_fsalattr_out->acl = NULL;
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_FILEID))
{
p_fsalattr_out->fileid = (fsal_u64_t) (p_buffstat->st_ino);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MODE))
{
p_fsalattr_out->mode = unix2fsal_mode(p_buffstat->st_mode);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_NUMLINKS))
{
p_fsalattr_out->numlinks = p_buffstat->st_nlink;
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_OWNER))
{
p_fsalattr_out->owner = p_buffstat->st_uid;
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_GROUP))
{
p_fsalattr_out->group = p_buffstat->st_gid;
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_ATIME))
{
p_fsalattr_out->atime = posix2fsal_time(p_buffstat->st_atime);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_CTIME))
{
p_fsalattr_out->ctime = posix2fsal_time(p_buffstat->st_ctime);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MTIME))
{
p_fsalattr_out->mtime = posix2fsal_time(p_buffstat->st_mtime);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_CHGTIME))
{
p_fsalattr_out->chgtime
= posix2fsal_time(MAX_2(p_buffstat->st_mtime, p_buffstat->st_ctime));
p_fsalattr_out->change = (uint64_t) p_fsalattr_out->chgtime.seconds ;
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SPACEUSED))
{
p_fsalattr_out->spaceused = p_buffstat->st_blocks * S_BLKSIZE;
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_RAWDEV))
{
p_fsalattr_out->rawdev = posix2fsal_devt(p_buffstat->st_rdev); /* XXX: convert ? */
}
/* mounted_on_fileid :
if ( FSAL_TEST_MASK(p_fsalattr_out->asked_attributes,
FSAL_ATTR_MOUNTFILEID )){
p_fsalattr_out->mounted_on_fileid =
hpss2fsal_64( p_hpss_attr_in->FilesetRootId );
}
*/
/* everything has been copied ! */
ReturnCode(ERR_FSAL_NO_ERROR, 0);
}
/* Same function as posixstat64_2_fsal_attributes. When NFS4 ACL support
* is enabled, this will replace posixstat64_2_fsal_attributes. */
fsal_status_t gpfsfsal_xstat_2_fsal_attributes(gpfsfsal_xstat_t *p_buffxstat,
struct attrlist *p_fsalattr_out,
bool use_acl)
{
struct stat *p_buffstat;
/* sanity checks */
if (!p_buffxstat || !p_fsalattr_out)
return fsalstat(ERR_FSAL_FAULT, 0);
p_buffstat = &p_buffxstat->buffstat;
LogDebug(COMPONENT_FSAL, "inode %ld", p_buffstat->st_ino);
/* Fills the output struct */
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_TYPE)) {
p_fsalattr_out->type = posix2fsal_type(p_buffstat->st_mode);
LogFullDebug(COMPONENT_FSAL, "type = 0x%x",
p_fsalattr_out->type);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_SIZE)) {
p_fsalattr_out->filesize = p_buffstat->st_size;
LogFullDebug(COMPONENT_FSAL, "filesize = %llu",
(unsigned long long)p_fsalattr_out->filesize);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_FSID)) {
p_fsalattr_out->fsid = p_buffxstat->fsal_fsid;
LogFullDebug(COMPONENT_FSAL,
"fsid=0x%016"PRIx64".0x%016"PRIx64,
p_fsalattr_out->fsid.major,
p_fsalattr_out->fsid.minor);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_ACL)) {
p_fsalattr_out->acl = NULL;
if (use_acl && p_buffxstat->attr_valid & XATTR_ACL) {
/* ACL is valid, so try to convert fsal acl. */
gpfs_acl_2_fsal_acl(p_fsalattr_out,
(gpfs_acl_t *) p_buffxstat->
buffacl);
}
LogFullDebug(COMPONENT_FSAL, "acl = %p", p_fsalattr_out->acl);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_FILEID)) {
p_fsalattr_out->fileid = (uint64_t) (p_buffstat->st_ino);
LogFullDebug(COMPONENT_FSAL, "fileid = %lu",
p_fsalattr_out->fileid);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MODE)) {
p_fsalattr_out->mode = unix2fsal_mode(p_buffstat->st_mode);
LogFullDebug(COMPONENT_FSAL, "mode = %"PRIu32,
p_fsalattr_out->mode);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_NUMLINKS)) {
p_fsalattr_out->numlinks = p_buffstat->st_nlink;
LogFullDebug(COMPONENT_FSAL, "numlinks = %u",
p_fsalattr_out->numlinks);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_OWNER)) {
p_fsalattr_out->owner = p_buffstat->st_uid;
LogFullDebug(COMPONENT_FSAL, "owner = %lu",
p_fsalattr_out->owner);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_GROUP)) {
p_fsalattr_out->group = p_buffstat->st_gid;
LogFullDebug(COMPONENT_FSAL, "group = %lu",
p_fsalattr_out->group);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_ATIME)) {
p_fsalattr_out->atime =
posix2fsal_time(p_buffstat->st_atime,
p_buffstat->st_atim.tv_nsec);
LogFullDebug(COMPONENT_FSAL, "atime = %lu",
p_fsalattr_out->atime.tv_sec);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_CTIME)) {
p_fsalattr_out->ctime =
posix2fsal_time(p_buffstat->st_ctime,
p_buffstat->st_ctim.tv_nsec);
LogFullDebug(COMPONENT_FSAL, "ctime = %lu",
p_fsalattr_out->ctime.tv_sec);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MTIME)) {
p_fsalattr_out->mtime =
posix2fsal_time(p_buffstat->st_mtime,
p_buffstat->st_mtim.tv_nsec);
LogFullDebug(COMPONENT_FSAL, "mtime = %lu",
p_fsalattr_out->mtime.tv_sec);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_CHGTIME)) {
if (p_buffstat->st_mtime == p_buffstat->st_ctime) {
if (p_buffstat->st_mtim.tv_nsec >
p_buffstat->st_ctim.tv_nsec)
p_fsalattr_out->chgtime =
posix2fsal_time(p_buffstat->st_mtime,
p_buffstat->st_mtim.
tv_nsec);
else
p_fsalattr_out->chgtime =
posix2fsal_time(p_buffstat->st_ctime,
p_buffstat->st_ctim.
tv_nsec);
} else if (p_buffstat->st_mtime > p_buffstat->st_ctime) {
p_fsalattr_out->chgtime =
posix2fsal_time(p_buffstat->st_mtime,
p_buffstat->st_mtim.tv_nsec);
} else {
p_fsalattr_out->chgtime =
posix2fsal_time(p_buffstat->st_ctime,
p_buffstat->st_ctim.tv_nsec);
}
p_fsalattr_out->change =
(uint64_t) p_fsalattr_out->chgtime.tv_sec +
(uint64_t) p_fsalattr_out->chgtime.tv_nsec;
LogFullDebug(COMPONENT_FSAL, "chgtime = %lu",
p_fsalattr_out->chgtime.tv_sec);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_SPACEUSED)) {
p_fsalattr_out->spaceused = p_buffstat->st_blocks * S_BLKSIZE;
LogFullDebug(COMPONENT_FSAL, "spaceused = %llu",
(unsigned long long)p_fsalattr_out->spaceused);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_RAWDEV)) {
p_fsalattr_out->rawdev = posix2fsal_devt(p_buffstat->st_rdev);
LogFullDebug(COMPONENT_FSAL, "rawdev major = %u, minor = %u",
(unsigned int)p_fsalattr_out->rawdev.major,
(unsigned int)p_fsalattr_out->rawdev.minor);
}
/* everything has been copied ! */
return fsalstat(ERR_FSAL_NO_ERROR, 0);
}
/* Same function as posixstat64_2_fsal_attributes. When NFS4 ACL support
* is enabled, this will replace posixstat64_2_fsal_attributes. */
fsal_status_t
ptfsal_xstat_2_fsal_attributes(ptfsal_xstat_t * p_buffxstat,
fsal_attrib_list_t * p_fsalattr_out)
{
fsal_attrib_mask_t supp_attr, unsupp_attr;
struct stat64 *p_buffstat;
/* sanity checks */
if(!p_buffxstat || !p_fsalattr_out)
ReturnCode(ERR_FSAL_FAULT, 0);
/* check that asked attributes are supported */
supp_attr = global_fs_info.supported_attrs;
unsupp_attr = (p_fsalattr_out->asked_attributes) & (~supp_attr);
if(unsupp_attr)
{
LogFullDebug(COMPONENT_FSAL, "Unsupported attributes: %#llX",
unsupp_attr);
ReturnCode(ERR_FSAL_ATTRNOTSUPP, 0);
}
p_buffstat = &p_buffxstat->buffstat;
/* Initialize ACL regardless of whether ACL was asked or not.
* This is needed to make sure ACL attribute is initialized. */
p_fsalattr_out->acl = NULL;
/* Fills the output struct */
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SUPPATTR))
{
p_fsalattr_out->supported_attributes = supp_attr;
LogFullDebug(COMPONENT_FSAL, "supported_attributes = %llu",
p_fsalattr_out->supported_attributes);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_TYPE))
{
p_fsalattr_out->type = posix2fsal_type(p_buffstat->st_mode);
LogFullDebug(COMPONENT_FSAL, "type = 0x%x", p_fsalattr_out->type);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SIZE))
{
p_fsalattr_out->filesize = p_buffstat->st_size;
LogFullDebug(COMPONENT_FSAL, "filesize = %lu",
p_fsalattr_out->filesize);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_FSID))
{
p_fsalattr_out->fsid = posix2fsal_fsid(p_buffstat->st_dev);
LogFullDebug(COMPONENT_FSAL, "fsid major = %llu, minor = %llu",
p_fsalattr_out->fsid.major,
p_fsalattr_out->fsid.minor);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_ACL))
{
#ifndef _USE_NFS4_ACL
p_fsalattr_out->acl = NULL;
#else
if((p_buffxstat->attr_valid & XATTR_ACL) == 0)
{
/* ACL is invalid. */
p_fsalattr_out->acl = NULL;
}
else
{
/* ACL is valid, so try to convert fsal acl. */
if(ptfs_acl_2_fsal_acl(p_fsalattr_out,
(gpfs_acl_t *)p_buffxstat->buffacl) != ERR_FSAL_NO_ERROR)
p_fsalattr_out->acl = NULL;
}
#endif /* _USE_NFS4_ACL */
LogFullDebug(COMPONENT_FSAL, "acl = %p", p_fsalattr_out->acl);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_FILEID))
{
p_fsalattr_out->fileid = (fsal_u64_t) (p_buffstat->st_ino);
LogFullDebug(COMPONENT_FSAL, "fileid = %llu",
p_fsalattr_out->fileid);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MODE))
{
p_fsalattr_out->mode = unix2fsal_mode(p_buffstat->st_mode);
LogFullDebug(COMPONENT_FSAL, "mode = %llu",
(long long unsigned int) p_fsalattr_out->mode);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_NUMLINKS))
{
p_fsalattr_out->numlinks = p_buffstat->st_nlink;
LogFullDebug(COMPONENT_FSAL, "numlinks = %lu",
p_fsalattr_out->numlinks);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_OWNER))
{
p_fsalattr_out->owner = p_buffstat->st_uid;
LogFullDebug(COMPONENT_FSAL, "owner = %u", p_fsalattr_out->owner);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_GROUP))
{
p_fsalattr_out->group = p_buffstat->st_gid;
LogFullDebug(COMPONENT_FSAL, "group = %u", p_fsalattr_out->group);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_ATIME))
{
p_fsalattr_out->atime = posix2fsal_time(p_buffstat->st_atime,
p_buffstat->st_atim.tv_nsec);
LogFullDebug(COMPONENT_FSAL, "atime = %u",
p_fsalattr_out->atime.seconds);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_CTIME))
{
p_fsalattr_out->ctime = posix2fsal_time(p_buffstat->st_ctime,
p_buffstat->st_ctim.tv_nsec);
LogFullDebug(COMPONENT_FSAL, "ctime = %u",
p_fsalattr_out->ctime.seconds);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MTIME))
{
p_fsalattr_out->mtime = posix2fsal_time(p_buffstat->st_mtime,
p_buffstat->st_mtim.tv_nsec);
LogFullDebug(COMPONENT_FSAL, "mtime = %u",
p_fsalattr_out->mtime.seconds);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_CHGTIME))
{
p_fsalattr_out->chgtime
= posix2fsal_time(MAX_2(p_buffstat->st_mtime,
p_buffstat->st_ctime), 0);
p_fsalattr_out->change =
(uint64_t) p_fsalattr_out->chgtime.seconds ;
LogFullDebug(COMPONENT_FSAL, "chgtime = %u",
p_fsalattr_out->chgtime.seconds);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SPACEUSED))
{
p_fsalattr_out->spaceused = p_buffstat->st_blocks * S_BLKSIZE;
LogFullDebug(COMPONENT_FSAL, "spaceused = %lu",
p_fsalattr_out->spaceused);
}
if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_RAWDEV))
{
p_fsalattr_out->rawdev = posix2fsal_devt(p_buffstat->st_rdev);
LogFullDebug(COMPONENT_FSAL,
"rawdev major = %u, minor = %u",
(unsigned int) p_fsalattr_out->rawdev.major,
(unsigned int) p_fsalattr_out->rawdev.minor);
}
/* everything has been copied ! */
ReturnCode(ERR_FSAL_NO_ERROR, 0);
}
/**
* FSAL_lookup :
* Looks up for an object into a directory.
*
* Note : if parent handle and filename are NULL,
* this retrieves root's handle.
*
* \param parent_directory_handle (input)
* Handle of the parent directory to search the object in.
* \param filename (input)
* The name of the object to find.
* \param p_context (input)
* Authentication context for the operation (user,...).
* \param object_handle (output)
* The handle of the object corresponding to filename.
* \param object_attributes (optional input/output)
* Pointer to the attributes of the object we found.
* As input, it defines the attributes that the caller
* wants to retrieve (by positioning flags into this structure)
* and the output is built considering this input
* (it fills the structure according to the flags it contains).
* It can be NULL (increases performances).
*
* \return - ERR_FSAL_NO_ERROR, if no error.
* - Another error code else.
*
*/
fsal_status_t PTFSAL_lookup(const struct req_op_context *p_context,
struct fsal_obj_handle *parent,
const char *p_filename,
struct attrlist *p_object_attr,
ptfsal_handle_t *fh)
{
fsal_status_t status;
int parent_fd;
struct attrlist *parent_dir_attrs;
fsi_stat_struct buffstat;
int rc;
struct pt_fsal_obj_handle *parent_hdl;
FSI_TRACE(FSI_DEBUG, "Begin##################################\n");
if (p_filename != NULL)
FSI_TRACE(FSI_DEBUG, "FSI - fsal_lookup file [%s]\n",
p_filename);
if (parent != NULL)
FSI_TRACE(FSI_DEBUG, "FSI - fsal_lookup parent dir\n");
if (!parent || !p_filename)
return fsalstat(ERR_FSAL_FAULT, 0);
parent_hdl =
container_of(parent, struct pt_fsal_obj_handle, obj_handle);
parent_dir_attrs = &parent_hdl->obj_handle.attributes;
/* get directory metadata */
parent_dir_attrs->mask = p_context->fsal_export->exp_ops.
fs_supported_attrs(p_context->fsal_export);
status =
fsal_internal_handle2fd_at(p_context, parent_hdl, &parent_fd,
O_RDONLY);
if (FSAL_IS_ERROR(status))
return status;
FSI_TRACE(FSI_DEBUG, "FSI - lookup parent directory type = %d\n",
parent_dir_attrs->type);
/* Be careful about junction crossing, symlinks, hardlinks,... */
switch (parent_dir_attrs->type) {
case DIRECTORY:
/* OK */
break;
case REGULAR_FILE:
case SYMBOLIC_LINK:
/* not a directory */
pt_close(parent);
return fsalstat(ERR_FSAL_NOTDIR, 0);
default:
return fsalstat(ERR_FSAL_SERVERFAULT, 0);
}
/* get file handle, it it exists */
/* This might be a race, but it's the best we can currently do */
rc = ptfsal_stat_by_parent_name(p_context, parent_hdl, p_filename,
&buffstat);
if (rc < 0) {
ptfsal_closedir_fd(p_context, p_context->fsal_export,
parent_fd);
return fsalstat(ERR_FSAL_NOENT, errno);
}
memset(fh->data.handle.f_handle, 0, sizeof(fh->data.handle.f_handle));
memcpy(&fh->data.handle.f_handle, &buffstat.st_persistentHandle.handle,
FSI_CCL_PERSISTENT_HANDLE_N_BYTES);
fh->data.handle.handle_size = FSI_CCL_PERSISTENT_HANDLE_N_BYTES;
fh->data.handle.handle_key_size = OPENHANDLE_KEY_LEN;
fh->data.handle.handle_version = OPENHANDLE_VERSION;
fh->data.handle.handle_type = posix2fsal_type(buffstat.st_mode);
/* get object attributes */
if (p_object_attr) {
p_object_attr->mask = p_context->fsal_export->exp_ops.
fs_supported_attrs(p_context->fsal_export);
status = PTFSAL_getattrs(p_context->fsal_export, p_context,
fh, p_object_attr);
if (FSAL_IS_ERROR(status)) {
FSAL_CLEAR_MASK(p_object_attr->mask);
FSAL_SET_MASK(p_object_attr->mask, ATTR_RDATTR_ERR);
}
}
ptfsal_closedir_fd(p_context, p_context->fsal_export, parent_fd);
FSI_TRACE(FSI_DEBUG, "End##################################\n");
/* lookup complete ! */
return fsalstat(ERR_FSAL_NO_ERROR, 0);
}
fsal_status_t posixstat64_2_fsal_attributes(struct stat *p_buffstat,
struct attrlist *p_fsalattr_out)
{
/* sanity checks */
if (!p_buffstat || !p_fsalattr_out)
return fsalstat(ERR_FSAL_FAULT, 0);
/* Initialize ACL regardless of whether ACL was asked or not.
* This is needed to make sure ACL attribute is initialized. */
p_fsalattr_out->acl = NULL;
/* Fills the output struct */
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_TYPE))
p_fsalattr_out->type = posix2fsal_type(p_buffstat->st_mode);
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_SIZE))
p_fsalattr_out->filesize = p_buffstat->st_size;
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_FSID))
p_fsalattr_out->fsid = posix2fsal_fsid(p_buffstat->st_dev);
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_ACL))
p_fsalattr_out->acl = NULL;
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_FILEID))
p_fsalattr_out->fileid = (uint64_t) (p_buffstat->st_ino);
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MODE))
p_fsalattr_out->mode = unix2fsal_mode(p_buffstat->st_mode);
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_NUMLINKS))
p_fsalattr_out->numlinks = p_buffstat->st_nlink;
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_OWNER))
p_fsalattr_out->owner = p_buffstat->st_uid;
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_GROUP))
p_fsalattr_out->group = p_buffstat->st_gid;
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_ATIME)) {
p_fsalattr_out->atime =
posix2fsal_time(p_buffstat->st_atime,
p_buffstat->st_atim.tv_nsec);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_CTIME)) {
p_fsalattr_out->ctime =
posix2fsal_time(p_buffstat->st_ctime,
p_buffstat->st_ctim.tv_nsec);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MTIME)) {
p_fsalattr_out->mtime =
posix2fsal_time(p_buffstat->st_mtime,
p_buffstat->st_mtim.tv_nsec);
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_CHGTIME)) {
p_fsalattr_out->chgtime =
posix2fsal_time(MAX
(p_buffstat->st_mtime,
p_buffstat->st_ctime), 0);
p_fsalattr_out->change =
(uint64_t) p_fsalattr_out->chgtime.tv_sec;
}
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_SPACEUSED))
p_fsalattr_out->spaceused = p_buffstat->st_blocks * S_BLKSIZE;
if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_RAWDEV))
p_fsalattr_out->rawdev = posix2fsal_devt(p_buffstat->st_rdev);
/* everything has been copied ! */
return fsalstat(ERR_FSAL_NO_ERROR, 0);
}
/* alloc_handle
* allocate and fill in a handle
* this uses malloc/free for the time being.
*/
static struct lustre_fsal_obj_handle *alloc_handle(
struct lustre_file_handle *fh,
struct fsal_filesystem *fs,
struct stat *stat,
const char *link_content,
struct lustre_file_handle *dir_fh,
const char *sock_name,
struct fsal_export *exp_hdl)
{
struct lustre_fsal_obj_handle *hdl;
fsal_status_t st;
hdl =
gsh_malloc(sizeof(struct lustre_fsal_obj_handle) +
sizeof(struct lustre_file_handle));
if (hdl == NULL)
return NULL;
memset(hdl, 0,
(sizeof(struct lustre_fsal_obj_handle) +
sizeof(struct lustre_file_handle)));
hdl->handle = (struct lustre_file_handle *)&hdl[1];
memcpy(hdl->handle, fh, sizeof(struct lustre_file_handle));
hdl->obj_handle.type = posix2fsal_type(stat->st_mode);
hdl->dev = posix2fsal_devt(stat->st_dev);
hdl->obj_handle.fs = fs;
if (hdl->obj_handle.type == REGULAR_FILE) {
hdl->u.file.fd = -1; /* no open on this yet */
hdl->u.file.openflags = FSAL_O_CLOSED;
} else if (hdl->obj_handle.type == SYMBOLIC_LINK
&& link_content != NULL) {
size_t len = strlen(link_content) + 1;
hdl->u.symlink.link_content = gsh_malloc(len);
if (hdl->u.symlink.link_content == NULL)
goto spcerr;
memcpy(hdl->u.symlink.link_content, link_content, len);
hdl->u.symlink.link_size = len;
} else if (hdl->obj_handle.type == SOCKET_FILE && dir_fh != NULL
&& sock_name != NULL) {
hdl->u.sock.sock_dir =
gsh_malloc(sizeof(struct lustre_file_handle));
if (hdl->u.sock.sock_dir == NULL)
goto spcerr;
memcpy(hdl->u.sock.sock_dir, dir_fh,
sizeof(struct lustre_file_handle));
hdl->u.sock.sock_name = gsh_malloc(strlen(sock_name) + 1);
if (hdl->u.sock.sock_name == NULL)
goto spcerr;
strcpy(hdl->u.sock.sock_name, sock_name);
}
hdl->obj_handle.attributes.mask =
exp_hdl->ops->fs_supported_attrs(exp_hdl);
st = posix2fsal_attributes(stat, &hdl->obj_handle.attributes);
if (FSAL_IS_ERROR(st))
goto spcerr;
fsal_obj_handle_init(&hdl->obj_handle, exp_hdl,
posix2fsal_type(stat->st_mode));
return hdl;
spcerr:
if (hdl->obj_handle.type == SYMBOLIC_LINK) {
if (hdl->u.symlink.link_content != NULL)
gsh_free(hdl->u.symlink.link_content);
} else if (hdl->obj_handle.type == SOCKET_FILE) {
if (hdl->u.sock.sock_name != NULL)
gsh_free(hdl->u.sock.sock_name);
if (hdl->u.sock.sock_dir != NULL)
gsh_free(hdl->u.sock.sock_dir);
}
gsh_free(hdl); /* elvis has left the building */
return NULL;
}
/**
* FSAL_lookup :
* Looks up for an object into a directory.
*
* Note : if parent handle and filename are NULL,
* this retrieves root's handle.
*
* \param parent_directory_handle (input)
* Handle of the parent directory to search the object in.
* \param filename (input)
* The name of the object to find.
* \param p_context (input)
* Authentication context for the operation (user,...).
* \param object_handle (output)
* The handle of the object corresponding to filename.
* \param object_attributes (optional input/output)
* Pointer to the attributes of the object we found.
* As input, it defines the attributes that the caller
* wants to retrieve (by positioning flags into this structure)
* and the output is built considering this input
* (it fills the structure according to the flags it contains).
*
* \return - ERR_FSAL_NO_ERROR, if no error.
* - Another error code else.
*
*/
fsal_status_t XFSFSAL_lookup(fsal_handle_t * parent_handle, /* IN */
fsal_name_t * p_filename, /* IN */
fsal_op_context_t * context, /* IN */
fsal_handle_t * object_handle, /* OUT */
fsal_attrib_list_t * p_object_attributes /* [ IN/OUT ] */
)
{
xfsfsal_handle_t * p_parent_directory_handle = (xfsfsal_handle_t *)parent_handle;
xfsfsal_op_context_t * p_context = (xfsfsal_op_context_t *)context;
xfsfsal_handle_t * p_object_handle = (xfsfsal_handle_t *)object_handle;
int rc = 0 , errsv = 0 ;
fsal_status_t status;
struct stat buffstat;
int parentfd;
/* sanity checks
* note : object_attributes is optionnal
* parent_directory_handle may be null for getting FS root.
*/
if(!p_object_handle || !p_context)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_lookup);
/* filename AND parent handle are NULL => lookup "/" */
if((p_parent_directory_handle && !p_filename)
|| (!p_parent_directory_handle && p_filename))
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_lookup);
/* get information about root */
if(!p_parent_directory_handle)
{
/* get handle for the mount point */
memcpy(p_object_handle->data.handle_val, p_context->export_context->mnt_handle_val,
p_context->export_context->mnt_handle_len);
p_object_handle->data.handle_len = p_context->export_context->mnt_handle_len;
/* get attributes, if asked */
if(p_object_attributes)
{
status = XFSFSAL_getattrs(p_object_handle, p_context, p_object_attributes);
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(p_object_attributes->asked_attributes);
FSAL_SET_MASK(p_object_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
/* Done */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_lookup);
}
/* retrieve directory attributes */
TakeTokenFSCall();
status =
fsal_internal_handle2fd(context, parent_handle, &parentfd, O_RDONLY);
ReleaseTokenFSCall();
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_lookup);
/* get directory metadata */
TakeTokenFSCall();
rc = fstat(parentfd, &buffstat);
errsv = errno;
ReleaseTokenFSCall();
if(rc)
{
close( parentfd ) ;
if(errsv == ENOENT)
Return(ERR_FSAL_STALE, errsv, INDEX_FSAL_lookup);
else
Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_lookup);
}
/* Be careful about junction crossing, symlinks, hardlinks,... */
switch (posix2fsal_type(buffstat.st_mode))
{
case FSAL_TYPE_DIR:
// OK
break;
case FSAL_TYPE_JUNCTION:
close( parentfd ) ;
// This is a junction
Return(ERR_FSAL_XDEV, 0, INDEX_FSAL_lookup);
case FSAL_TYPE_FILE:
case FSAL_TYPE_LNK:
case FSAL_TYPE_XATTR:
close( parentfd ) ;
// not a directory
Return(ERR_FSAL_NOTDIR, 0, INDEX_FSAL_lookup);
default:
close( parentfd ) ;
Return(ERR_FSAL_SERVERFAULT, 0, INDEX_FSAL_lookup);
}
LogFullDebug(COMPONENT_FSAL, "lookup of inode=%"PRIu64"/%s", buffstat.st_ino,
p_filename->name);
/* check rights to enter into the directory */
status = fsal_check_access(context, FSAL_X_OK, &buffstat, NULL);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_lookup);
status = xfsfsal_stat_by_name(context, parentfd, p_filename->name,
object_handle, p_object_attributes);
close(parentfd);
ReturnStatus(status, INDEX_FSAL_lookup);
}
/**
* @brief convert GPFS xstat to FSAl attributes
*
* @param gpfs_buf Reference to GPFS stat buffer
* @param fsal_attr Reference to attribute list
* @param use_acl Bool whether ACL are used
* @return FSAL status
*
* Same function as posixstat64_2_fsal_attributes. When NFS4 ACL support
* is enabled, this will replace posixstat64_2_fsal_attributes.
*/
fsal_status_t
gpfsfsal_xstat_2_fsal_attributes(gpfsfsal_xstat_t *gpfs_buf,
struct attrlist *fsal_attr, bool use_acl)
{
struct stat *p_buffstat;
/* sanity checks */
if (!gpfs_buf || !fsal_attr)
return fsalstat(ERR_FSAL_FAULT, 0);
p_buffstat = &gpfs_buf->buffstat;
LogDebug(COMPONENT_FSAL, "inode %ld", p_buffstat->st_ino);
/* Fills the output struct */
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_TYPE)) {
fsal_attr->type = posix2fsal_type(p_buffstat->st_mode);
LogFullDebug(COMPONENT_FSAL, "type = 0x%x",
fsal_attr->type);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_SIZE)) {
fsal_attr->filesize = p_buffstat->st_size;
LogFullDebug(COMPONENT_FSAL, "filesize = %llu",
(unsigned long long)fsal_attr->filesize);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_FSID)) {
fsal_attr->fsid = gpfs_buf->fsal_fsid;
LogFullDebug(COMPONENT_FSAL,
"fsid=0x%016"PRIx64".0x%016"PRIx64,
fsal_attr->fsid.major,
fsal_attr->fsid.minor);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_ACL)) {
if (fsal_attr->acl != NULL) {
/* We should never be passed attributes that have an
* ACL attached, but just in case some future code
* path changes that assumption, let's not release the
* old ACL properly.
*/
int acl_status;
acl_status = nfs4_acl_release_entry(fsal_attr->acl);
if (acl_status != NFS_V4_ACL_SUCCESS)
LogCrit(COMPONENT_FSAL,
"Failed to release old acl, status=%d",
acl_status);
fsal_attr->acl = NULL;
}
if (use_acl && gpfs_buf->attr_valid & XATTR_ACL) {
/* ACL is valid, so try to convert fsal acl. */
gpfs_acl_2_fsal_acl(fsal_attr,
(gpfs_acl_t *) gpfs_buf->buffacl);
}
LogFullDebug(COMPONENT_FSAL, "acl = %p", fsal_attr->acl);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_FILEID)) {
fsal_attr->fileid = (uint64_t) (p_buffstat->st_ino);
LogFullDebug(COMPONENT_FSAL, "fileid = %" PRIu64,
fsal_attr->fileid);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_MODE)) {
fsal_attr->mode = unix2fsal_mode(p_buffstat->st_mode);
LogFullDebug(COMPONENT_FSAL, "mode = %"PRIu32,
fsal_attr->mode);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_NUMLINKS)) {
fsal_attr->numlinks = p_buffstat->st_nlink;
LogFullDebug(COMPONENT_FSAL, "numlinks = %u",
fsal_attr->numlinks);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_OWNER)) {
fsal_attr->owner = p_buffstat->st_uid;
LogFullDebug(COMPONENT_FSAL, "owner = %" PRIu64,
fsal_attr->owner);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_GROUP)) {
fsal_attr->group = p_buffstat->st_gid;
LogFullDebug(COMPONENT_FSAL, "group = %" PRIu64,
fsal_attr->group);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_ATIME)) {
fsal_attr->atime =
posix2fsal_time(p_buffstat->st_atime,
p_buffstat->st_atim.tv_nsec);
LogFullDebug(COMPONENT_FSAL, "atime = %lu",
fsal_attr->atime.tv_sec);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_CTIME)) {
fsal_attr->ctime =
posix2fsal_time(p_buffstat->st_ctime,
p_buffstat->st_ctim.tv_nsec);
LogFullDebug(COMPONENT_FSAL, "ctime = %lu",
fsal_attr->ctime.tv_sec);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_MTIME)) {
fsal_attr->mtime =
posix2fsal_time(p_buffstat->st_mtime,
p_buffstat->st_mtim.tv_nsec);
LogFullDebug(COMPONENT_FSAL, "mtime = %lu",
fsal_attr->mtime.tv_sec);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_CHGTIME)) {
if (p_buffstat->st_mtime == p_buffstat->st_ctime) {
if (p_buffstat->st_mtim.tv_nsec >
p_buffstat->st_ctim.tv_nsec)
fsal_attr->chgtime =
posix2fsal_time(p_buffstat->st_mtime,
p_buffstat->st_mtim.
tv_nsec);
else
fsal_attr->chgtime =
posix2fsal_time(p_buffstat->st_ctime,
p_buffstat->st_ctim.
tv_nsec);
} else if (p_buffstat->st_mtime > p_buffstat->st_ctime) {
fsal_attr->chgtime =
posix2fsal_time(p_buffstat->st_mtime,
p_buffstat->st_mtim.tv_nsec);
} else {
fsal_attr->chgtime =
posix2fsal_time(p_buffstat->st_ctime,
p_buffstat->st_ctim.tv_nsec);
}
fsal_attr->change =
(uint64_t) fsal_attr->chgtime.tv_sec +
(uint64_t) fsal_attr->chgtime.tv_nsec;
LogFullDebug(COMPONENT_FSAL, "chgtime = %lu",
fsal_attr->chgtime.tv_sec);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_SPACEUSED)) {
fsal_attr->spaceused = p_buffstat->st_blocks * S_BLKSIZE;
LogFullDebug(COMPONENT_FSAL, "spaceused = %llu",
(unsigned long long)fsal_attr->spaceused);
}
if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_RAWDEV)) {
fsal_attr->rawdev = posix2fsal_devt(p_buffstat->st_rdev);
LogFullDebug(COMPONENT_FSAL, "rawdev major = %u, minor = %u",
(unsigned int)fsal_attr->rawdev.major,
(unsigned int)fsal_attr->rawdev.minor);
}
/* everything has been copied ! */
return fsalstat(ERR_FSAL_NO_ERROR, 0);
}
fsal_status_t posix2fsal_attributes(struct stat * p_buffstat,
struct attrlist * p_fsalattr_out)
{
/* sanity checks */
if(!p_buffstat || !p_fsalattr_out)
return fsalstat(ERR_FSAL_FAULT, 0);
/* Initialize ACL regardless of whether ACL was asked or not.
* This is needed to make sure ACL attribute is initialized. */
p_fsalattr_out->acl = NULL;
/* Fills the output struct */
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_TYPE))
{
p_fsalattr_out->type = posix2fsal_type(p_buffstat->st_mode);
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_SIZE))
{
p_fsalattr_out->filesize = p_buffstat->st_size;
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_FSID))
{
p_fsalattr_out->fsid = posix2fsal_fsid(p_buffstat->st_dev);
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_ACL))
{
p_fsalattr_out->acl = NULL;
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_FILEID))
{
p_fsalattr_out->fileid = (uint64_t) (p_buffstat->st_ino);
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MODE))
{
p_fsalattr_out->mode = unix2fsal_mode(p_buffstat->st_mode);
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_NUMLINKS))
{
p_fsalattr_out->numlinks = p_buffstat->st_nlink;
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_OWNER))
{
p_fsalattr_out->owner = p_buffstat->st_uid;
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_GROUP))
{
p_fsalattr_out->group = p_buffstat->st_gid;
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_ATIME))
{
p_fsalattr_out->atime = p_buffstat->st_atim;
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_CTIME))
{
p_fsalattr_out->ctime = p_buffstat->st_ctim;
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MTIME))
{
p_fsalattr_out->mtime = p_buffstat->st_mtim;
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_CHGTIME))
{
p_fsalattr_out->chgtime =
(gsh_time_cmp(&p_buffstat->st_mtim,
&p_buffstat->st_ctim) > 0) ?
p_buffstat->st_mtim :
p_buffstat->st_ctim;
/* XXX */
p_fsalattr_out->change = p_fsalattr_out->chgtime.tv_sec +
p_fsalattr_out->chgtime.tv_nsec;
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_SPACEUSED))
{
p_fsalattr_out->spaceused = p_buffstat->st_blocks * S_BLKSIZE;
}
if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_RAWDEV))
{
p_fsalattr_out->rawdev = posix2fsal_devt(p_buffstat->st_rdev); /* XXX: convert ? */
}
/* mounted_on_fileid :
if ( FSAL_TEST_MASK(p_fsalattr_out->mask,
ATTR_MOUNTFILEID )){
p_fsalattr_out->mounted_on_fileid =
hpss2fsal_64( p_hpss_attr_in->FilesetRootId );
}
*/
/* everything has been copied ! */
return fsalstat(ERR_FSAL_NO_ERROR, 0);
}
static struct vfs_fsal_obj_handle *alloc_handle(int dirfd,
vfs_file_handle_t *fh,
struct fsal_filesystem *fs,
struct stat *stat,
vfs_file_handle_t *dir_fh,
const char *path,
struct fsal_export *exp_hdl)
{
struct vfs_fsal_export *myself =
container_of(exp_hdl, struct vfs_fsal_export, export);
struct vfs_fsal_obj_handle *hdl;
fsal_status_t st;
hdl = gsh_calloc(1,
(sizeof(struct vfs_fsal_obj_handle) +
sizeof(vfs_file_handle_t)));
if (hdl == NULL)
return NULL;
hdl->handle = (vfs_file_handle_t *) &hdl[1];
memcpy(hdl->handle, fh, sizeof(vfs_file_handle_t));
hdl->obj_handle.type = posix2fsal_type(stat->st_mode);
hdl->dev = posix2fsal_devt(stat->st_dev);
hdl->up_ops = exp_hdl->up_ops;
hdl->obj_handle.fs = fs;
if (hdl->obj_handle.type == REGULAR_FILE) {
hdl->u.file.fd = -1; /* no open on this yet */
hdl->u.file.openflags = FSAL_O_CLOSED;
} else if (hdl->obj_handle.type == SYMBOLIC_LINK) {
ssize_t retlink;
size_t len = stat->st_size + 1;
char *link_content = gsh_malloc(len);
if (link_content == NULL)
goto spcerr;
retlink =
vfs_readlink_by_handle(fh, dirfd, path, link_content, len);
if (retlink < 0 || retlink == len)
goto spcerr;
link_content[retlink] = '\0';
hdl->u.symlink.link_content = link_content;
hdl->u.symlink.link_size = len;
} else if (vfs_unopenable_type(hdl->obj_handle.type)) {
/* AF_UNIX sockets, character special, and block
special files require craziness */
if (dir_fh == NULL) {
int retval;
vfs_alloc_handle(dir_fh);
retval =
vfs_fd_to_handle(dirfd, hdl->obj_handle.fs, fh);
if (retval < 0)
goto spcerr;
}
hdl->u.unopenable.dir = gsh_malloc(sizeof(vfs_file_handle_t));
if (hdl->u.unopenable.dir == NULL)
goto spcerr;
memcpy(hdl->u.unopenable.dir, dir_fh,
sizeof(vfs_file_handle_t));
hdl->u.unopenable.name = gsh_strdup(path);
if (hdl->u.unopenable.name == NULL)
goto spcerr;
}
hdl->obj_handle.attributes.mask =
exp_hdl->exp_ops.fs_supported_attrs(exp_hdl);
st = posix2fsal_attributes(stat, &hdl->obj_handle.attributes);
if (FSAL_IS_ERROR(st))
goto spcerr;
hdl->obj_handle.attributes.fsid = fs->fsid;
fsal_obj_handle_init(&hdl->obj_handle, exp_hdl,
posix2fsal_type(stat->st_mode));
vfs_handle_ops_init(&hdl->obj_handle.obj_ops);
vfs_sub_init_handle_ops(myself, &hdl->obj_handle.obj_ops);
return hdl;
spcerr:
if (hdl->obj_handle.type == SYMBOLIC_LINK) {
if (hdl->u.symlink.link_content != NULL)
gsh_free(hdl->u.symlink.link_content);
} else if (vfs_unopenable_type(hdl->obj_handle.type)) {
if (hdl->u.unopenable.name != NULL)
gsh_free(hdl->u.unopenable.name);
if (hdl->u.unopenable.dir != NULL)
gsh_free(hdl->u.unopenable.dir);
}
gsh_free(hdl); /* elvis has left the building */
return NULL;
}
/**
* FSAL_lookup :
* Looks up for an object into a directory.
*
* Note : if parent handle and filename are NULL,
* this retrieves root's handle.
*
* \param parent_directory_handle (input)
* Handle of the parent directory to search the object in.
* \param filename (input)
* The name of the object to find.
* \param p_context (input)
* Authentication context for the operation (user,...).
* \param object_handle (output)
* The handle of the object corresponding to filename.
* \param object_attributes (optional input/output)
* Pointer to the attributes of the object we found.
* As input, it defines the attributes that the caller
* wants to retrieve (by positioning flags into this structure)
* and the output is built considering this input
* (it fills the structure according to the flags it contains).
* It can be NULL (increases performances).
*
* \return - ERR_FSAL_NO_ERROR, if no error.
* - Another error code else.
*
*/
fsal_status_t LUSTREFSAL_lookup(fsal_handle_t * p_parent_directory_handle, /* IN */
fsal_name_t * p_filename, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_handle_t * p_object_handle, /* OUT */
fsal_attrib_list_t * p_object_attributes /* [ IN/OUT ] */
)
{
int rc, errsv;
fsal_status_t status;
struct stat buffstat;
fsal_path_t pathfsal;
/* sanity checks
* note : object_attributes is optionnal
* parent_directory_handle may be null for getting FS root.
*/
if(!p_object_handle || !p_context)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_lookup);
/* filename AND parent handle are NULL => lookup "/" */
if((p_parent_directory_handle && !p_filename)
|| (!p_parent_directory_handle && p_filename))
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_lookup);
/* get information about root */
if(!p_parent_directory_handle)
{
/* get handle for the mount point */
FSAL_str2path(((lustrefsal_op_context_t *)p_context)->export_context->mount_point,
((lustrefsal_op_context_t *)p_context)->export_context->mnt_len, &pathfsal);
TakeTokenFSCall();
status = fsal_internal_Path2Handle(p_context, &pathfsal, p_object_handle);
ReleaseTokenFSCall();
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_lookup);
/* get attributes, if asked */
if(p_object_attributes)
{
status = LUSTREFSAL_getattrs(p_object_handle, p_context, p_object_attributes);
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(p_object_attributes->asked_attributes);
FSAL_SET_MASK(p_object_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
/* Done */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_lookup);
}
/* retrieve directory attributes */
status = fsal_internal_Handle2FidPath(p_context, p_parent_directory_handle, &pathfsal);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_lookup);
/* get directory metadata */
TakeTokenFSCall();
rc = lstat(pathfsal.path, &buffstat);
errsv = errno;
ReleaseTokenFSCall();
if(rc)
{
if(errsv == ENOENT)
Return(ERR_FSAL_STALE, errsv, INDEX_FSAL_lookup);
else
Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_lookup);
}
/* Be careful about junction crossing, symlinks, hardlinks,... */
switch (posix2fsal_type(buffstat.st_mode))
{
case FSAL_TYPE_DIR:
// OK
break;
case FSAL_TYPE_JUNCTION:
// This is a junction
Return(ERR_FSAL_XDEV, 0, INDEX_FSAL_lookup);
case FSAL_TYPE_FILE:
case FSAL_TYPE_LNK:
case FSAL_TYPE_XATTR:
// not a directory
Return(ERR_FSAL_NOTDIR, 0, INDEX_FSAL_lookup);
default:
Return(ERR_FSAL_SERVERFAULT, 0, INDEX_FSAL_lookup);
}
LogFullDebug(COMPONENT_FSAL, "lookup of %s/%s\n",
pathfsal.path, p_filename->name);
/* check rights to enter into the directory */
status = fsal_internal_testAccess(p_context, FSAL_X_OK, &buffstat, NULL);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_lookup);
status = fsal_internal_appendNameToPath(&pathfsal, p_filename);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_lookup);
/* get file handle, it it exists */
TakeTokenFSCall();
status = fsal_internal_Path2Handle(p_context, &pathfsal, p_object_handle);
ReleaseTokenFSCall();
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_lookup);
/* get object attributes */
if(p_object_attributes)
{
status = LUSTREFSAL_getattrs(p_object_handle, p_context, p_object_attributes);
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(p_object_attributes->asked_attributes);
FSAL_SET_MASK(p_object_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
/* lookup complete ! */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_lookup);
}
