fsal_status_t tank_setextattr_value_by_id(struct fsal_obj_handle *obj_hdl,
unsigned int xattr_id,
caddr_t buffer_addr,
size_t buffer_size)
{
char name[MAXNAMLEN];
struct zfs_fsal_obj_handle *obj_handle = NULL;
int retval = -1;
creden_t cred;
obj_handle =
container_of(obj_hdl, struct zfs_fsal_obj_handle, obj_handle);
if (attr_is_read_only(xattr_id))
return fsalstat(ERR_FSAL_PERM, 0);
else if (xattr_id < XATTR_COUNT)
return fsalstat(ERR_FSAL_PERM, 0);
cred.uid = op_ctx->creds->caller_uid;
cred.gid = op_ctx->creds->caller_gid;
retval =
xattr_id_to_name(ZFSFSAL_GetVFS(obj_handle->handle), &cred,
obj_handle->handle->zfs_handle, xattr_id, name);
if (retval)
return fsalstat(retval, 0);
return tank_setextattr_value(obj_hdl, name, buffer_addr,
buffer_size, false);
}
fsal_status_t ZFSFSAL_SetXAttrValueById(fsal_handle_t * obj_handle, /* IN */
unsigned int xattr_id, /* IN */
fsal_op_context_t * context, /* IN */
caddr_t buffer_addr, /* IN */
size_t buffer_size /* IN */
)
{
int rc;
char psz_name[FSAL_MAX_NAME_LEN];
fsal_name_t attr_name;
zfsfsal_handle_t * p_objecthandle = (zfsfsal_handle_t *)obj_handle;
zfsfsal_op_context_t *p_context = (zfsfsal_op_context_t *)context;
/* Hook to prevent any modification in the snapshots */
if(p_objecthandle->data.i_snap != 0)
Return(ERR_FSAL_ROFS, 0, INDEX_FSAL_SetXAttrValue);
if(attr_is_read_only(xattr_id))
Return(ERR_FSAL_PERM, 0, INDEX_FSAL_SetXAttrValue);
else if(xattr_id < XATTR_COUNT)
Return(ERR_FSAL_PERM, 0, INDEX_FSAL_SetXAttrValue);
if((rc = xattr_id_to_name(p_context->export_context->p_vfs, p_context, p_objecthandle,
xattr_id, psz_name)))
Return(rc, 0, INDEX_FSAL_SetXAttrValue);
FSAL_str2name(psz_name, FSAL_MAX_NAME_LEN, &attr_name);
return ZFSFSAL_SetXAttrValue(obj_handle, &attr_name, context,
buffer_addr, buffer_size, FALSE);
}
fsal_status_t vfs_setextattr_value_by_id(struct fsal_obj_handle *obj_hdl,
const struct req_op_context *opctx,
unsigned int xattr_id,
caddr_t buffer_addr,
size_t buffer_size)
{
char name[MAXNAMLEN];
struct vfs_fsal_obj_handle *obj_handle = NULL;
int fd = -1;
fsal_errors_t fe;
int rc = 0;
obj_handle =
container_of(obj_hdl, struct vfs_fsal_obj_handle, obj_handle);
if (attr_is_read_only(xattr_id))
return fsalstat(ERR_FSAL_PERM, 0);
else if (xattr_id < XATTR_COUNT)
return fsalstat(ERR_FSAL_PERM, 0);
/* build fid path in lustre */
fd = (obj_hdl->type == DIRECTORY) ? vfs_fsal_open(obj_handle,
O_DIRECTORY,
&fe) :
vfs_fsal_open(obj_handle, O_RDWR, &fe);
if (fd < 0)
return fsalstat(fe, -fd);
rc = xattr_id_to_name(fd, xattr_id, name);
close(fd);
if (rc)
return fsalstat(rc, errno);
return vfs_setextattr_value(obj_hdl, opctx, name, buffer_addr,
buffer_size, FALSE);
}
static int file_attributes_to_xattr_attrs(struct attrlist *file_attrs,
struct attrlist *xattr_attrs,
unsigned int attr_index)
{
/* supported attributes are:
* - owner (same as the objet)
* - group (same as the objet)
* - type FSAL_TYPE_XATTR
* - fileid (attr index ? or (fileid^((index+1)<<24)) )
* - mode (config & file)
* - atime, mtime, ctime = these of the object ?
* - size=1block, used=1block
* - rdev=0
* - nlink=1
*/
attrmask_t supported =
(ATTR_MODE | ATTR_FILEID | ATTR_TYPE |
ATTR_OWNER | ATTR_GROUP |
ATTR_ATIME | ATTR_MTIME | ATTR_CTIME |
ATTR_CREATION | ATTR_CHGTIME
| ATTR_SIZE | ATTR_SPACEUSED |
ATTR_NUMLINKS | ATTR_RAWDEV |
ATTR_FSID);
attrmask_t unsupp;
if (xattr_attrs->mask == 0) {
xattr_attrs->mask = supported;
LogCrit(COMPONENT_FSAL,
"Error: xattr_attrs->mask was 0");
}
unsupp = xattr_attrs->mask & (~supported);
if (unsupp) {
LogDebug(COMPONENT_FSAL,
"Asking for unsupported attributes: %#llX removing it from asked attributes",
(long long unsigned int)unsupp);
xattr_attrs->mask &= (~unsupp);
}
if (xattr_attrs->mask & ATTR_MODE) {
xattr_attrs->mode = file_attrs->mode;
if (attr_is_read_only(attr_index))
xattr_attrs->mode &= ~(0222);
}
if (xattr_attrs->mask & ATTR_FILEID) {
unsigned int i;
unsigned long hash = attr_index + 1;
char *str = (char *)&file_attrs->fileid;
for (i = 0; i < sizeof(xattr_attrs->fileid); i++, str++)
hash = (hash << 5) - hash + (unsigned long)(*str);
xattr_attrs->fileid = hash;
}
if (xattr_attrs->mask & ATTR_TYPE)
xattr_attrs->type = EXTENDED_ATTR;
if (xattr_attrs->mask & ATTR_OWNER)
xattr_attrs->owner = file_attrs->owner;
if (xattr_attrs->mask & ATTR_GROUP)
xattr_attrs->group = file_attrs->group;
if (xattr_attrs->mask & ATTR_ATIME)
xattr_attrs->atime = file_attrs->atime;
if (xattr_attrs->mask & ATTR_MTIME)
xattr_attrs->mtime = file_attrs->mtime;
if (xattr_attrs->mask & ATTR_CTIME)
xattr_attrs->ctime = file_attrs->ctime;
if (xattr_attrs->mask & ATTR_CREATION)
xattr_attrs->creation = file_attrs->creation;
if (xattr_attrs->mask & ATTR_CHGTIME) {
xattr_attrs->chgtime = file_attrs->chgtime;
xattr_attrs->change = xattr_attrs->chgtime.tv_sec;
}
if (xattr_attrs->mask & ATTR_SIZE)
xattr_attrs->filesize = DEV_BSIZE;
if (xattr_attrs->mask & ATTR_SPACEUSED)
xattr_attrs->spaceused = DEV_BSIZE;
if (xattr_attrs->mask & ATTR_NUMLINKS)
xattr_attrs->numlinks = 1;
if (xattr_attrs->mask & ATTR_RAWDEV) {
xattr_attrs->rawdev.major = 0;
xattr_attrs->rawdev.minor = 0;
}
if (xattr_attrs->mask & ATTR_FSID)
xattr_attrs->fsid = file_attrs->fsid;
/* if mode==0, then owner is set to root and mode is set to 0600 */
if ((xattr_attrs->mask & ATTR_OWNER)
&& (xattr_attrs->mask & ATTR_MODE) && (xattr_attrs->mode == 0)) {
xattr_attrs->owner = 0;
xattr_attrs->mode = 0600;
if (attr_is_read_only(attr_index))
xattr_attrs->mode &= ~(0200);
}
return 0;
}
fsal_status_t hpss_setextattr_value_by_id(struct fsal_obj_handle *fsal_obj_hdl,
unsigned int xattr_id,
caddr_t buffer_addr,
size_t buffer_size)
{
struct hpss_fsal_obj_handle *obj_hdl;
int rc, index, listlen;
sec_cred_t ucreds;
hpss_userattr_list_t attr_list;
if (!fsal_obj_hdl || !buffer_addr)
return fsalstat(ERR_FSAL_FAULT, 0);
if (attr_is_read_only(xattr_id))
return fsalstat(ERR_FSAL_PERM, 0);
if (((char *)buffer_addr)[0] == '\0')
return fsalstat(ERR_FSAL_NO_ERROR, 0);
obj_hdl = container_of(fsal_obj_hdl,
struct hpss_fsal_obj_handle,
obj_handle);
HPSSFSAL_ucreds_from_opctx(op_ctx, &ucreds);
if (xattr_id < XATTR_COUNT)
rc = xattr_list[xattr_id].set_func(fsal_obj_hdl,
buffer_addr,
buffer_size,
0,
&ucreds);
else {
memset(&attr_list, 0, sizeof(hpss_userattr_list_t));
LogFullDebug(COMPONENT_FSAL, "Setting value for UDA #%u",
xattr_id - XATTR_COUNT);
/* get list of UDAs for this entry, and return the good value */
rc = hpss_UserAttrListAttrHandle(&(obj_hdl->handle->ns_handle),
NULL,
&ucreds,
&attr_list,
XML_ATTR);
if (rc != 0)
return fsalstat(hpss2fsal_error(rc), rc);
else
if (xattr_id - XATTR_COUNT >= attr_list.len)
return fsalstat(ERR_FSAL_STALE, 0);
listlen = attr_list.len;
attr_list.Pair[0].Key =
attr_list.Pair[xattr_id - XATTR_COUNT].Key;
attr_list.Pair[0].Value = buffer_addr;
attr_list.len = 1;
rc = hpss_UserAttrSetAttrHandle(&(obj_hdl->handle->ns_handle),
NULL,
&ucreds,
&attr_list,
UDA_API_VALUE);
/* Allocated by hpss - use free */
for (index = 0; index < listlen; index++) {
free(attr_list.Pair[index].Key);
free(attr_list.Pair[index].Value);
}
free(attr_list.Pair);
if (rc)
rc = hpss2fsal_error(rc);
}
return fsalstat(rc, 0);
}
static int file_attributes_to_xattr_attrs(fsal_attrib_list_t * file_attrs,
fsal_attrib_list_t * p_xattr_attrs,
unsigned int attr_index)
{
/* supported attributes are:
* - owner (same as the objet)
* - group (same as the objet)
* - type FSAL_TYPE_XATTR
* - fileid (attr index ? or (fileid^((index+1)<<24)) )
* - mode (config & file)
* - atime, mtime, ctime = these of the object ?
* - size=1block, used=1block
* - rdev=0
* - nlink=1
*/
fsal_attrib_mask_t supported = FSAL_ATTR_SUPPATTR | FSAL_ATTR_MODE | FSAL_ATTR_FILEID
| FSAL_ATTR_TYPE | FSAL_ATTR_OWNER | FSAL_ATTR_GROUP
| FSAL_ATTR_ATIME | FSAL_ATTR_MTIME | FSAL_ATTR_CTIME
| FSAL_ATTR_CREATION | FSAL_ATTR_CHGTIME | FSAL_ATTR_SIZE
| FSAL_ATTR_SPACEUSED | FSAL_ATTR_NUMLINKS | FSAL_ATTR_RAWDEV | FSAL_ATTR_FSID;
fsal_attrib_mask_t unsupp;
/* only those supported by filesystem */
supported &= global_fs_info.supported_attrs;
if(p_xattr_attrs->asked_attributes == 0)
{
p_xattr_attrs->asked_attributes = supported;
LogCrit(COMPONENT_FSAL,
"Error: p_xattr_attrs->asked_attributes was 0 in %s() line %d, file %s",
__FUNCTION__, __LINE__, __FILE__);
}
unsupp = p_xattr_attrs->asked_attributes & (~supported);
if(unsupp)
{
LogDebug(COMPONENT_FSAL,
"Asking for unsupported attributes in %s(): %#llX removing it from asked attributes",
__FUNCTION__, unsupp);
p_xattr_attrs->asked_attributes &= (~unsupp);
}
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_SUPPATTR)
p_xattr_attrs->supported_attributes = supported;
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_MODE)
{
p_xattr_attrs->mode = file_attrs->mode & global_fs_info.xattr_access_rights;
if(attr_is_read_only(attr_index))
p_xattr_attrs->mode &= ~(0222);
}
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_FILEID)
{
unsigned int i;
unsigned long hash = attr_index + 1;
char *str = (char *)&file_attrs->fileid;
for(i = 0; i < sizeof(p_xattr_attrs->fileid); i++, str++)
{
hash = (hash << 5) - hash + (unsigned long)(*str);
}
p_xattr_attrs->fileid = hash;
}
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_TYPE)
p_xattr_attrs->type = FSAL_TYPE_XATTR;
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_OWNER)
p_xattr_attrs->owner = file_attrs->owner;
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_GROUP)
p_xattr_attrs->group = file_attrs->group;
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_ATIME)
p_xattr_attrs->atime = file_attrs->atime;
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_MTIME)
p_xattr_attrs->mtime = file_attrs->mtime;
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_CTIME)
p_xattr_attrs->ctime = file_attrs->ctime;
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_CREATION)
p_xattr_attrs->creation = file_attrs->creation;
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_CHGTIME)
{
p_xattr_attrs->chgtime = file_attrs->chgtime;
p_xattr_attrs->change = (uint64_t) p_xattr_attrs->chgtime.seconds;
}
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_SIZE)
p_xattr_attrs->filesize = DEV_BSIZE;
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_SPACEUSED)
p_xattr_attrs->spaceused = DEV_BSIZE;
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_NUMLINKS)
p_xattr_attrs->numlinks = 1;
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_RAWDEV)
{
p_xattr_attrs->rawdev.major = 0;
p_xattr_attrs->rawdev.minor = 0;
}
if(p_xattr_attrs->asked_attributes & FSAL_ATTR_FSID)
{
p_xattr_attrs->fsid = file_attrs->fsid;
}
/* if mode==0, then owner is set to root and mode is set to 0600 */
if((p_xattr_attrs->asked_attributes & FSAL_ATTR_OWNER)
&& (p_xattr_attrs->asked_attributes & FSAL_ATTR_MODE) && (p_xattr_attrs->mode == 0))
{
p_xattr_attrs->owner = 0;
p_xattr_attrs->mode = 0600;
if(attr_is_read_only(attr_index))
p_xattr_attrs->mode &= ~(0200);
}
return 0;
}
