uid_t
zfs_fuid_map_id(zfsvfs_t *zfsvfs, uint64_t fuid,
cred_t *cr, zfs_fuid_type_t type)
{
#ifdef HAVE_ZPL
uint32_t index = FUID_INDEX(fuid);
const char *domain;
uid_t id;
if (index == 0)
return (fuid);
domain = zfs_fuid_find_by_idx(zfsvfs, index);
ASSERT(domain != NULL);
if (type == ZFS_OWNER || type == ZFS_ACE_USER) {
(void) kidmap_getuidbysid(crgetzone(cr), domain,
FUID_RID(fuid), &id);
} else {
(void) kidmap_getgidbysid(crgetzone(cr), domain,
FUID_RID(fuid), &id);
}
return (id);
#endif
if(type == ZFS_OWNER || type == ZFS_ACE_USER)
return (crgetuid(cr));
else
return (crgetgid(cr));
}
uid_t
zfs_fuid_map_id(zfs_sb_t *zsb, uint64_t fuid,
cred_t *cr, zfs_fuid_type_t type)
{
#ifdef HAVE_KSID
uint32_t index = FUID_INDEX(fuid);
const char *domain;
uid_t id;
if (index == 0)
return (fuid);
domain = zfs_fuid_find_by_idx(zsb, index);
ASSERT(domain != NULL);
if (type == ZFS_OWNER || type == ZFS_ACE_USER) {
(void) kidmap_getuidbysid(crgetzone(cr), domain,
FUID_RID(fuid), &id);
} else {
(void) kidmap_getgidbysid(crgetzone(cr), domain,
FUID_RID(fuid), &id);
}
return (id);
#else
/*
* The Linux port only supports POSIX IDs, use the passed id.
*/
return (fuid);
#endif /* HAVE_KSID */
}
uid_t
zfs_fuid_map_id(zfsvfs_t *zfsvfs, uint64_t fuid,
cred_t *cr, zfs_fuid_type_t type)
{
uint32_t index = FUID_INDEX(fuid);
char *domain;
uid_t id;
if (index == 0)
return (fuid);
domain = zfs_fuid_find_by_idx(zfsvfs, index);
ASSERT(domain != NULL);
#ifdef TODO
if (type == ZFS_OWNER || type == ZFS_ACE_USER) {
(void) kidmap_getuidbysid(crgetzone(cr), domain,
FUID_RID(fuid), &id);
} else {
(void) kidmap_getgidbysid(crgetzone(cr), domain,
FUID_RID(fuid), &id);
}
#else
panic(__func__);
#endif
return (id);
}
/* ARGSUSED */
static int
xattr_file_write(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr,
caller_context_t *ct)
{
int error = 0;
char *buf;
char *domain;
uint32_t rid;
ssize_t size = uiop->uio_resid;
nvlist_t *nvp;
nvpair_t *pair = NULL;
vnode_t *ppvp;
xvattr_t xvattr;
xoptattr_t *xoap = NULL; /* Pointer to optional attributes */
if (vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR) == 0)
return (EINVAL);
/*
* Validate file offset and size.
*/
if (uiop->uio_loffset < (offset_t)0)
return (EINVAL);
if (size == 0)
return (EINVAL);
xva_init(&xvattr);
if ((xoap = xva_getxoptattr(&xvattr)) == NULL) {
return (EINVAL);
}
/*
* Copy and unpack the nvlist
*/
buf = kmem_alloc(size, KM_SLEEP);
if (uiomove((caddr_t)buf, size, UIO_WRITE, uiop)) {
return (EFAULT);
}
if (nvlist_unpack(buf, size, &nvp, KM_SLEEP) != 0) {
kmem_free(buf, size);
uiop->uio_resid = size;
return (EINVAL);
}
kmem_free(buf, size);
/*
* Fasttrack empty writes (nvlist with no nvpairs)
*/
if (nvlist_next_nvpair(nvp, NULL) == 0)
return (0);
ppvp = gfs_file_parent(gfs_file_parent(vp));
while (pair = nvlist_next_nvpair(nvp, pair)) {
data_type_t type;
f_attr_t attr;
boolean_t value;
uint64_t *time, *times;
uint_t elem, nelems;
nvlist_t *nvp_sid;
uint8_t *scanstamp;
/*
* Validate the name and type of each attribute.
* Log any unknown names and continue. This will
* help if additional attributes are added later.
*/
type = nvpair_type(pair);
if ((attr = name_to_attr(nvpair_name(pair))) == F_ATTR_INVAL) {
cmn_err(CE_WARN, "Unknown attribute %s",
nvpair_name(pair));
continue;
}
/*
* Verify nvlist type matches required type and view is OK
*/
if (type != attr_to_data_type(attr) ||
(attr_to_xattr_view(attr) == XATTR_VIEW_READONLY)) {
nvlist_free(nvp);
return (EINVAL);
}
/*
* For OWNERSID/GROUPSID make sure the target
* file system support ephemeral ID's
*/
if ((attr == F_OWNERSID || attr == F_GROUPSID) &&
(!(vp->v_vfsp->vfs_flag & VFS_XID))) {
nvlist_free(nvp);
return (EINVAL);
}
/*
* Retrieve data from nvpair
*/
switch (type) {
case DATA_TYPE_BOOLEAN_VALUE:
if (nvpair_value_boolean_value(pair, &value)) {
nvlist_free(nvp);
return (EINVAL);
}
break;
case DATA_TYPE_UINT64_ARRAY:
if (nvpair_value_uint64_array(pair, ×, &nelems)) {
nvlist_free(nvp);
return (EINVAL);
}
break;
case DATA_TYPE_NVLIST:
if (nvpair_value_nvlist(pair, &nvp_sid)) {
nvlist_free(nvp);
return (EINVAL);
}
break;
case DATA_TYPE_UINT8_ARRAY:
if (nvpair_value_uint8_array(pair,
&scanstamp, &nelems)) {
nvlist_free(nvp);
return (EINVAL);
}
break;
default:
nvlist_free(nvp);
return (EINVAL);
}
switch (attr) {
/*
* If we have several similar optional attributes to
* process then we should do it all together here so that
* xoap and the requested bitmap can be set in one place.
*/
case F_READONLY:
XVA_SET_REQ(&xvattr, XAT_READONLY);
xoap->xoa_readonly = value;
break;
case F_HIDDEN:
XVA_SET_REQ(&xvattr, XAT_HIDDEN);
xoap->xoa_hidden = value;
break;
case F_SYSTEM:
XVA_SET_REQ(&xvattr, XAT_SYSTEM);
xoap->xoa_system = value;
break;
case F_ARCHIVE:
XVA_SET_REQ(&xvattr, XAT_ARCHIVE);
xoap->xoa_archive = value;
break;
case F_IMMUTABLE:
XVA_SET_REQ(&xvattr, XAT_IMMUTABLE);
xoap->xoa_immutable = value;
break;
case F_NOUNLINK:
XVA_SET_REQ(&xvattr, XAT_NOUNLINK);
xoap->xoa_nounlink = value;
break;
case F_APPENDONLY:
XVA_SET_REQ(&xvattr, XAT_APPENDONLY);
xoap->xoa_appendonly = value;
break;
case F_NODUMP:
XVA_SET_REQ(&xvattr, XAT_NODUMP);
xoap->xoa_nodump = value;
break;
case F_AV_QUARANTINED:
XVA_SET_REQ(&xvattr, XAT_AV_QUARANTINED);
xoap->xoa_av_quarantined = value;
break;
case F_AV_MODIFIED:
XVA_SET_REQ(&xvattr, XAT_AV_MODIFIED);
xoap->xoa_av_modified = value;
break;
case F_CRTIME:
XVA_SET_REQ(&xvattr, XAT_CREATETIME);
time = (uint64_t *)&(xoap->xoa_createtime);
for (elem = 0; elem < nelems; elem++)
*time++ = times[elem];
break;
case F_OWNERSID:
case F_GROUPSID:
if (nvlist_lookup_string(nvp_sid, SID_DOMAIN,
&domain) || nvlist_lookup_uint32(nvp_sid, SID_RID,
&rid)) {
nvlist_free(nvp);
return (EINVAL);
}
/*
* Now map domain+rid to ephemeral id's
*
* If mapping fails, then the uid/gid will
* be set to UID_NOBODY by Winchester.
*/
if (attr == F_OWNERSID) {
(void) kidmap_getuidbysid(crgetzone(cr), domain,
rid, &xvattr.xva_vattr.va_uid);
xvattr.xva_vattr.va_mask |= AT_UID;
} else {
(void) kidmap_getgidbysid(crgetzone(cr), domain,
rid, &xvattr.xva_vattr.va_gid);
xvattr.xva_vattr.va_mask |= AT_GID;
}
break;
case F_AV_SCANSTAMP:
if (ppvp->v_type == VREG) {
XVA_SET_REQ(&xvattr, XAT_AV_SCANSTAMP);
(void) memcpy(xoap->xoa_av_scanstamp,
scanstamp, nelems);
} else {
nvlist_free(nvp);
return (EINVAL);
}
break;
case F_REPARSE:
XVA_SET_REQ(&xvattr, XAT_REPARSE);
xoap->xoa_reparse = value;
break;
case F_OFFLINE:
XVA_SET_REQ(&xvattr, XAT_OFFLINE);
xoap->xoa_offline = value;
break;
case F_SPARSE:
XVA_SET_REQ(&xvattr, XAT_SPARSE);
xoap->xoa_sparse = value;
break;
default:
break;
}
}
ppvp = gfs_file_parent(gfs_file_parent(vp));
error = VOP_SETATTR(ppvp, &xvattr.xva_vattr, 0, cr, ct);
if (error)
uiop->uio_resid = size;
nvlist_free(nvp);
return (error);
}
