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);
}
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_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);
}
/**
* @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);
}