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);
}
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);
}
/* XXX : ACL */
fsal_status_t fsal_internal_testAccess(fsal_op_context_t * p_context, /* IN */
fsal_accessflags_t access_type, /* IN */
struct stat * p_buffstat, /* IN */
fsal_attrib_list_t * p_object_attributes /* IN */ )
{
fsal_accessflags_t missing_access;
unsigned int is_grp, i;
fsal_uid_t uid;
fsal_gid_t gid;
fsal_accessmode_t mode;
fsal_uid_t userid = ((vfsfsal_op_context_t *)p_context)->credential.user;
fsal_uid_t groupid = ((vfsfsal_op_context_t *)p_context)->credential.group;
/* sanity checks. */
if((!p_object_attributes && !p_buffstat) || !p_context)
ReturnCode(ERR_FSAL_FAULT, 0);
/* If the FSAL_F_OK flag is set, returns ERR INVAL */
if(access_type & FSAL_F_OK)
ReturnCode(ERR_FSAL_INVAL, 0);
/* test root access */
if(userid == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
/* unsatisfied flags */
missing_access = FSAL_MODE_MASK(access_type); /* only modes, no ACLs here */
if(p_object_attributes)
{
uid = p_object_attributes->owner;
gid = p_object_attributes->group;
mode = p_object_attributes->mode;
}
else
{
uid = p_buffstat->st_uid;
gid = p_buffstat->st_gid;
mode = unix2fsal_mode(p_buffstat->st_mode);
}
/* Test if file belongs to user. */
if(userid == uid)
{
LogFullDebug(COMPONENT_FSAL, "File belongs to user %d", uid);
if(mode & FSAL_MODE_RUSR)
missing_access &= ~FSAL_R_OK;
if(mode & FSAL_MODE_WUSR)
missing_access &= ~FSAL_W_OK;
if(mode & FSAL_MODE_XUSR)
missing_access &= ~FSAL_X_OK;
/* handle the creation of a new 500 file correctly */
if((missing_access & FSAL_OWNER_OK) != 0)
missing_access = 0;
if(missing_access == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
else
{
LogFullDebug(COMPONENT_FSAL,
"Mode=%#o, Access=%#o, Rights missing: %#o", mode,
access_type, missing_access);
ReturnCode(ERR_FSAL_ACCESS, 0);
}
}
/* missing_access will be nonzero triggering a failure
* even though FSAL_OWNER_OK is not even a real posix file
* permission */
missing_access &= ~FSAL_OWNER_OK;
/* Test if the file belongs to user's group. */
is_grp = (groupid == gid);
if(is_grp)
LogFullDebug(COMPONENT_FSAL, "File belongs to user's group %d",
groupid);
/* Test if file belongs to alt user's groups */
if(!is_grp)
{
for(i = 0; i < ((vfsfsal_op_context_t *)p_context)->credential.nbgroups; i++)
{
is_grp = (((vfsfsal_op_context_t *)p_context)->credential.alt_groups[i] == gid);
if(is_grp)
LogFullDebug(COMPONENT_FSAL,
"File belongs to user's alt group %d",
((vfsfsal_op_context_t *)p_context)->credential.alt_groups[i]);
// exits loop if found
if(is_grp)
break;
}
}
/* finally apply group rights */
if(is_grp)
{
if(mode & FSAL_MODE_RGRP)
missing_access &= ~FSAL_R_OK;
if(mode & FSAL_MODE_WGRP)
missing_access &= ~FSAL_W_OK;
if(mode & FSAL_MODE_XGRP)
missing_access &= ~FSAL_X_OK;
if(missing_access == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
else
ReturnCode(ERR_FSAL_ACCESS, 0);
}
/* test other perms */
if(mode & FSAL_MODE_ROTH)
missing_access &= ~FSAL_R_OK;
if(mode & FSAL_MODE_WOTH)
missing_access &= ~FSAL_W_OK;
if(mode & FSAL_MODE_XOTH)
missing_access &= ~FSAL_X_OK;
/* XXX ACLs. */
if(missing_access == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
else
ReturnCode(ERR_FSAL_ACCESS, 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);
}
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 */
static fsal_status_t fsal_check_access_no_acl(fsal_op_context_t * p_context, /* IN */
fsal_accessflags_t access_type, /* IN */
struct stat *p_buffstat, /* IN */
fsal_attrib_list_t * p_object_attributes /* IN */ )
{
fsal_accessflags_t missing_access;
unsigned int is_grp, i;
fsal_uid_t uid;
fsal_gid_t gid;
fsal_accessmode_t mode;
/* If the FSAL_F_OK flag is set, returns ERR INVAL */
if(access_type & FSAL_F_OK)
ReturnCode(ERR_FSAL_INVAL, 0);
/* unsatisfied flags */
missing_access = access_type;
if(!missing_access)
{
LogDebug(COMPONENT_FSAL, "fsal_check_access_no_acl: Nothing was requested");
ReturnCode(ERR_FSAL_NO_ERROR, 0);
}
if(p_object_attributes)
{
uid = p_object_attributes->owner;
gid = p_object_attributes->group;
mode = p_object_attributes->mode;
}
else
{
uid = p_buffstat->st_uid;
gid = p_buffstat->st_gid;
mode = unix2fsal_mode(p_buffstat->st_mode);
}
LogDebug(COMPONENT_FSAL,
"fsal_check_access_no_acl: file Mode=%#o, file uid=%d, file gid= %d",
mode,uid, gid);
#ifdef _USE_HPSS
LogDebug(COMPONENT_FSAL,
"fsal_check_access_no_acl: user uid=%d, user gid= %d, access_type=0X%x",
p_context->credential.hpss_usercred.Uid,
p_context->credential.hpss_usercred.Gid,
access_type);
#else
LogDebug(COMPONENT_FSAL,
"fsal_check_access_no_acl: user uid=%d, user gid= %d, access_type=0X%x",
p_context->credential.user,
p_context->credential.group,
access_type);
/* If the uid of the file matches the uid of the user,
* then the uid mode bits take precedence. */
if(p_context->credential.user == uid)
#endif
/* If the uid of the file matches the uid of the user,
* then the uid mode bits take precedence. */
#ifdef _USE_HPSS
if(p_context->credential.hpss_usercred.Uid == uid)
#else
if(p_context->credential.user == uid)
#endif
{
LogDebug(COMPONENT_FSAL,
"fsal_check_access_no_acl: File belongs to user %d", uid);
if(mode & FSAL_MODE_RUSR)
missing_access &= ~FSAL_R_OK;
if(mode & FSAL_MODE_WUSR)
missing_access &= ~FSAL_W_OK;
if(mode & FSAL_MODE_XUSR)
missing_access &= ~FSAL_X_OK;
/* handle the creation of a new 500 file correctly */
if((missing_access & FSAL_OWNER_OK) != 0)
missing_access = 0;
if(missing_access == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
else
{
LogDebug(COMPONENT_FSAL,
"fsal_check_access_no_acl: Mode=%#o, Access=0X%x, Rights missing: 0X%x",
mode, access_type, missing_access);
ReturnCode(ERR_FSAL_ACCESS, 0);
}
}
/* missing_access will be nonzero triggering a failure
* even though FSAL_OWNER_OK is not even a real posix file
* permission */
missing_access &= ~FSAL_OWNER_OK;
/* Test if the file belongs to user's group. */
#ifdef _USE_HPSS
is_grp = (p_context->credential.hpss_usercred.Gid == gid);
if(is_grp)
LogDebug(COMPONENT_FSAL,
"fsal_check_access_no_acl: File belongs to user's group %d",
p_context->credential.hpss_usercred.Gid);
/* Test if file belongs to alt user's groups */
if(!is_grp)
for(i = 0; i < p_context->credential.hpss_usercred.NumGroups; i++)
{
is_grp = (p_context->credential.hpss_usercred.AltGroups[i] == gid);
if(is_grp)
LogDebug(COMPONENT_FSAL,
"fsal_check_access_no_acl: File belongs to user's alt group %d",
p_context->credential.hpss_usercred.AltGroups[i]);
if(is_grp)
break;
}
#else
is_grp = (p_context->credential.group == gid);
if(is_grp)
LogDebug(COMPONENT_FSAL,
"fsal_check_access_no_acl: File belongs to user's group %d",
p_context->credential.group);
/* Test if file belongs to alt user's groups */
if(!is_grp)
for(i = 0; i < p_context->credential.nbgroups; i++)
{
is_grp = (p_context->credential.alt_groups[i] == gid);
if(is_grp)
LogDebug(COMPONENT_FSAL,
"fsal_check_access_no_acl: File belongs to user's alt group %d",
p_context->credential.alt_groups[i]);
if(is_grp)
break;
}
#endif
/* If the gid of the file matches the gid of the user or
* one of the alternatve gids of the user, then the uid mode
* bits take precedence. */
if(is_grp)
{
if(mode & FSAL_MODE_RGRP)
missing_access &= ~FSAL_R_OK;
if(mode & FSAL_MODE_WGRP)
missing_access &= ~FSAL_W_OK;
if(mode & FSAL_MODE_XGRP)
missing_access &= ~FSAL_X_OK;
if(missing_access == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
else
ReturnCode(ERR_FSAL_ACCESS, 0);
}
/* If the user uid is not 0, the uid does not match the file's, and
* the user's gids do not match the file's gid, we apply the "other"
* mode bits to the user. */
if(mode & FSAL_MODE_ROTH)
missing_access &= ~FSAL_R_OK;
if(mode & FSAL_MODE_WOTH)
missing_access &= ~FSAL_W_OK;
if(mode & FSAL_MODE_XOTH)
missing_access &= ~FSAL_X_OK;
if(missing_access == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
else {
LogDebug(COMPONENT_FSAL,
"fsal_check_access_no_acl: Mode=%#o, Access=0X%x, Rights missing: 0X%x",
mode, access_type, missing_access);
ReturnCode(ERR_FSAL_ACCESS, 0);
}
}
/* XXX : ACL */
fsal_status_t fsal_internal_testAccess(xfsfsal_op_context_t * p_context, /* IN */
fsal_accessflags_t access_type, /* IN */
struct stat * p_buffstat, /* IN */
fsal_attrib_list_t * p_object_attributes /* IN */ )
{
fsal_accessflags_t missing_access;
unsigned int is_grp, i;
fsal_uid_t uid;
fsal_gid_t gid;
fsal_accessmode_t mode;
/* sanity checks. */
if((!p_object_attributes && !p_buffstat) || !p_context)
ReturnCode(ERR_FSAL_FAULT, 0);
/* If the FSAL_F_OK flag is set, returns ERR INVAL */
if(access_type & FSAL_F_OK)
ReturnCode(ERR_FSAL_INVAL, 0);
/* test root access */
if(p_context->credential.user == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
/* unsatisfied flags */
missing_access = access_type;
if(p_object_attributes)
{
uid = p_object_attributes->owner;
gid = p_object_attributes->group;
mode = p_object_attributes->mode;
}
else
{
uid = p_buffstat->st_uid;
gid = p_buffstat->st_gid;
mode = unix2fsal_mode(p_buffstat->st_mode);
}
/* Test if file belongs to user. */
if(p_context->credential.user == uid)
{
LogFullDebug(COMPONENT_FSAL, "File belongs to user %d", uid);
if(mode & FSAL_MODE_RUSR)
missing_access &= ~FSAL_R_OK;
if(mode & FSAL_MODE_WUSR)
missing_access &= ~FSAL_W_OK;
if(mode & FSAL_MODE_XUSR)
missing_access &= ~FSAL_X_OK;
if(missing_access == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
else
{
LogFullDebug(COMPONENT_FSAL,
"Mode=%#o, Access=%#o, Rights missing: %#o", mode,
access_type, missing_access);
ReturnCode(ERR_FSAL_ACCESS, 0);
}
}
/* Test if the file belongs to user's group. */
is_grp = (p_context->credential.group == gid);
if(is_grp)
LogFullDebug(COMPONENT_FSAL, "File belongs to user's group %d",
p_context->credential.group);
/* Test if file belongs to alt user's groups */
if(!is_grp)
{
for(i = 0; i < p_context->credential.nbgroups; i++)
{
is_grp = (p_context->credential.alt_groups[i] == gid);
if(is_grp)
LogFullDebug(COMPONENT_FSAL,
"File belongs to user's alt group %d",
p_context->credential.alt_groups[i]);
// exits loop if found
if(is_grp)
break;
}
}
/* finally apply group rights */
if(is_grp)
{
if(mode & FSAL_MODE_RGRP)
missing_access &= ~FSAL_R_OK;
if(mode & FSAL_MODE_WGRP)
missing_access &= ~FSAL_W_OK;
if(mode & FSAL_MODE_XGRP)
missing_access &= ~FSAL_X_OK;
if(missing_access == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
else
ReturnCode(ERR_FSAL_ACCESS, 0);
}
/* test other perms */
if(mode & FSAL_MODE_ROTH)
missing_access &= ~FSAL_R_OK;
if(mode & FSAL_MODE_WOTH)
missing_access &= ~FSAL_W_OK;
if(mode & FSAL_MODE_XOTH)
missing_access &= ~FSAL_X_OK;
/* XXX ACLs. */
if(missing_access == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
else
ReturnCode(ERR_FSAL_ACCESS, 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);
}
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);
}
/*
Check the access from an existing fsal_attrib_list_t or struct stat
*/
fsal_status_t fsal_internal_testAccess(cephfsal_op_context_t* context,
fsal_accessflags_t access_type,
struct stat * st,
fsal_attrib_list_t * object_attributes)
{
fsal_accessflags_t missing_access;
unsigned int is_grp, i;
fsal_uid_t uid;
fsal_gid_t gid;
fsal_accessmode_t mode;
fsal_uid_t userid = context->credential.user;
fsal_uid_t groupid = context->credential.group;
/* sanity checks. */
if((!object_attributes && !st) || !context)
ReturnCode(ERR_FSAL_FAULT, 0);
/* If the FSAL_F_OK flag is set, returns ERR INVAL */
if(access_type & FSAL_F_OK)
ReturnCode(ERR_FSAL_INVAL, 0);
/* test root access */
if(userid == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
/* unsatisfied flags */
missing_access = FSAL_MODE_MASK(access_type); /* only modes, no ACLs here */
if(object_attributes)
{
uid = object_attributes->owner;
gid = object_attributes->group;
mode = object_attributes->mode;
}
else
{
uid = st->st_uid;
gid = st->st_gid;
mode = unix2fsal_mode(st->st_mode);
}
/* Test if file belongs to user. */
if(userid == uid)
{
LogFullDebug(COMPONENT_FSAL, "File belongs to user %d", uid);
if(mode & FSAL_MODE_RUSR)
missing_access &= ~FSAL_R_OK;
if(mode & FSAL_MODE_WUSR)
missing_access &= ~FSAL_W_OK;
if(mode & FSAL_MODE_XUSR)
missing_access &= ~FSAL_X_OK;
if((missing_access & FSAL_OWNER_OK) != 0)
missing_access = 0;
if(missing_access == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
else
{
LogFullDebug(COMPONENT_FSAL,
"Mode=%#o, Access=%#o, Rights missing: %#o", mode,
access_type, missing_access);
ReturnCode(ERR_FSAL_ACCESS, 0);
}
}
/* Test if the file belongs to user's group. */
is_grp = (groupid == gid);
if(is_grp)
LogFullDebug(COMPONENT_FSAL, "File belongs to user's group %d",
groupid);
/* Test if file belongs to alt user's groups */
if(!is_grp)
{
for(i = 0; i < context->credential.nbgroups; i++)
{
is_grp = context->credential.alt_groups[i] == gid;
if(is_grp)
LogFullDebug(COMPONENT_FSAL,
"File belongs to user's alt group %d",
context->credential.alt_groups[i]);
// exits loop if found
if(is_grp)
break;
}
}
/* finally apply group rights */
if(is_grp)
{
if(mode & FSAL_MODE_RGRP)
missing_access &= ~FSAL_R_OK;
if(mode & FSAL_MODE_WGRP)
missing_access &= ~FSAL_W_OK;
if(mode & FSAL_MODE_XGRP)
missing_access &= ~FSAL_X_OK;
if(missing_access == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
else
ReturnCode(ERR_FSAL_ACCESS, 0);
}
/* test other perms */
if(mode & FSAL_MODE_ROTH)
missing_access &= ~FSAL_R_OK;
if(mode & FSAL_MODE_WOTH)
missing_access &= ~FSAL_W_OK;
if(mode & FSAL_MODE_XOTH)
missing_access &= ~FSAL_X_OK;
if(missing_access == 0)
ReturnCode(ERR_FSAL_NO_ERROR, 0);
else
ReturnCode(ERR_FSAL_ACCESS, 0);
}
fsal_status_t
load_FS_common_parameters_from_conf(config_file_t in_config,
struct fsal_fs_params *common_info)
{
int err;
int var_max, var_index;
char *key_name;
char *key_value;
config_item_t block;
block = config_FindItemByName(in_config, CONF_LABEL_FS_COMMON);
/* cannot read item */
if (block == NULL) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: Cannot read item \"%s\" from configuration file",
CONF_LABEL_FS_COMMON);
return fsalstat(ERR_FSAL_NOENT, 0);
} else if (config_ItemType(block) != CONFIG_ITEM_BLOCK) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: Item \"%s\" is expected to be a block",
CONF_LABEL_FS_COMMON);
return fsalstat(ERR_FSAL_INVAL, 0);
}
var_max = config_GetNbItems(block);
for (var_index = 0; var_index < var_max; var_index++) {
config_item_t item;
item = config_GetItemByIndex(block, var_index);
err = config_GetKeyValue(item, &key_name, &key_value);
if (err) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR reading key[%d] from section \"%s\" of configuration file.",
var_index, CONF_LABEL_FS_COMMON);
return fsalstat(ERR_FSAL_SERVERFAULT, err);
}
/* does the variable exists ? */
if (!STRCMP(key_name, "link_support")) {
int val = str_to_bool(key_value);
if (val == -1) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: 0 or 1 expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
/* if set to false, force value to false.
* else keep fs default.
*/
SET_INIT_INFO(common_info, link_support,
FSAL_INIT_MAX_LIMIT, val);
} else if (!STRCMP(key_name, "symlink_support")) {
int val = str_to_bool(key_value);
if (val == -1) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: 0 or 1 expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
/* if set to false, force value to false.
* else keep fs default.
*/
SET_INIT_INFO(common_info, symlink_support,
FSAL_INIT_MAX_LIMIT, val);
} else if (!STRCMP(key_name, "cansettime")) {
int val = str_to_bool(key_value);
if (val == -1) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: 0 or 1 expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
/* if set to false, force value to false.
* else keep fs default.
*/
SET_INIT_INFO(common_info, cansettime,
FSAL_INIT_MAX_LIMIT, val);
} else if (!STRCMP(key_name, "maxread")) {
int size;
size = s_read_int(key_value);
SET_INIT_INFO(common_info, maxread,
FSAL_INIT_FORCE_VALUE, size);
} else if (!STRCMP(key_name, "maxwrite")) {
uint32_t size;
size = s_read_int(key_value);
SET_INIT_INFO(common_info, maxwrite,
FSAL_INIT_FORCE_VALUE, size);
} else if (!STRCMP(key_name, "umask")) {
int mode = s_read_octal(key_value);
if (mode < 0) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: octal expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
SET_INIT_INFO(common_info, umask, FSAL_INIT_FORCE_VALUE,
unix2fsal_mode(mode));
} else if (!STRCMP(key_name, "auth_xdev_export")) {
int val = str_to_bool(key_value);
if (val == -1) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: boolean expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
SET_INIT_INFO(common_info, auth_exportpath_xdev,
FSAL_INIT_FORCE_VALUE, val);
} else if (!STRCMP(key_name, "xattr_access_rights")) {
int mode = s_read_octal(key_value);
if (mode < 0) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: octal expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
SET_INIT_INFO(common_info, xattr_access_rights,
FSAL_INIT_FORCE_VALUE,
unix2fsal_mode(mode));
} else {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unknown or unsettable key: %s (item %s)",
key_name, CONF_LABEL_FS_COMMON);
return fsalstat(ERR_FSAL_INVAL, 0);
}
}
return fsalstat(ERR_FSAL_NO_ERROR, 0);
}