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); }