/*
* Compute the same user access value as getattrlist(2)
*/
u_int32_t getuseraccess(znode_t *zp, vfs_context_t ctx)
{
vnode_t *vp;
u_int32_t user_access = 0;
zfs_acl_phys_t acl_phys;
int error;
/* Only take the expensive vnode_authorize path when we have an ACL */
error = sa_lookup(zp->z_sa_hdl, SA_ZPL_ZNODE_ACL(zp->z_zfsvfs),
&acl_phys, sizeof (acl_phys));
if (error || acl_phys.z_acl_count == 0) {
kauth_cred_t cred = vfs_context_ucred(ctx);
uint64_t obj_uid;
uint64_t obj_mode;
/* User id 0 (root) always gets access. */
if (!vfs_context_suser(ctx)) {
return (R_OK | W_OK | X_OK);
}
sa_lookup(zp->z_sa_hdl, SA_ZPL_UID(zp->z_zfsvfs),
&obj_uid, sizeof (obj_uid));
sa_lookup(zp->z_sa_hdl, SA_ZPL_MODE(zp->z_zfsvfs),
&obj_mode, sizeof (obj_mode));
//obj_uid = pzp->zp_uid;
obj_mode = obj_mode & MODEMASK;
if (obj_uid == UNKNOWNUID) {
obj_uid = kauth_cred_getuid(cred);
}
if ((obj_uid == kauth_cred_getuid(cred)) ||
(obj_uid == UNKNOWNUID)) {
return (((u_int32_t)obj_mode & S_IRWXU) >> 6);
}
/* Otherwise, settle for 'others' access. */
return ((u_int32_t)obj_mode & S_IRWXO);
}
/*
* Free reference to null layer
*/
static int
nullfs_unmount(struct mount * mp, int mntflags, __unused vfs_context_t ctx)
{
struct null_mount * mntdata;
struct vnode * vp;
int error, flags;
NULLFSDEBUG("nullfs_unmount: mp = %p\n", (void *)mp);
/* check entitlement or superuser*/
if (!IOTaskHasEntitlement(current_task(), NULLFS_ENTITLEMENT) &&
vfs_context_suser(ctx) != 0) {
return EPERM;
}
if (mntflags & MNT_FORCE) {
flags = FORCECLOSE;
} else {
flags = 0;
}
mntdata = MOUNTTONULLMOUNT(mp);
vp = mntdata->nullm_rootvp;
// release our reference on the root before flushing.
// it will get pulled out of the mount structure by reclaim
vnode_getalways(vp);
error = vflush(mp, vp, flags);
if (error)
{
vnode_put(vp);
return (error);
}
if (vnode_isinuse(vp,1) && flags == 0)
{
vnode_put(vp);
return EBUSY;
}
vnode_rele(vp); // Drop reference taken by nullfs_mount
vnode_put(vp); // Drop ref taken above
//Force close to get rid of the last vnode
(void)vflush(mp, NULL, FORCECLOSE);
/* no more vnodes, so tear down the mountpoint */
lck_mtx_lock(&mntdata->nullm_lock);
vfs_setfsprivate(mp, NULL);
vnode_getalways(mntdata->nullm_lowerrootvp);
vnode_rele(mntdata->nullm_lowerrootvp);
vnode_put(mntdata->nullm_lowerrootvp);
lck_mtx_unlock(&mntdata->nullm_lock);
nullfs_destroy_lck(&mntdata->nullm_lock);
FREE(mntdata, M_TEMP);
uint64_t vflags = vfs_flags(mp);
vfs_setflags(mp, vflags & ~MNT_LOCAL);
return (0);
}
void commonattrpack(attrinfo_t *aip, zfsvfs_t *zfsvfs, znode_t *zp,
const char *name, ino64_t objnum, enum vtype vtype,
boolean_t user64)
{
attrgroup_t commonattr = aip->ai_attrlist->commonattr;
void *attrbufptr = *aip->ai_attrbufpp;
void *varbufptr = *aip->ai_varbufpp;
struct mount *mp = zfsvfs->z_vfs;
cred_t *cr = (cred_t *)vfs_context_ucred(aip->ai_context);
finderinfo_t finderinfo;
/*
* We should probably combine all the sa_lookup into a bulk
* lookup operand.
*/
finderinfo.fi_flags = 0;
if (ATTR_CMN_NAME & commonattr) {
nameattrpack(aip, name, strlen(name));
attrbufptr = *aip->ai_attrbufpp;
varbufptr = *aip->ai_varbufpp;
}
if (ATTR_CMN_DEVID & commonattr) {
*((dev_t *)attrbufptr) = vfs_statfs(mp)->f_fsid.val[0];
attrbufptr = ((dev_t *)attrbufptr) + 1;
}
if (ATTR_CMN_FSID & commonattr) {
*((fsid_t *)attrbufptr) = vfs_statfs(mp)->f_fsid;
attrbufptr = ((fsid_t *)attrbufptr) + 1;
}
if (ATTR_CMN_OBJTYPE & commonattr) {
*((fsobj_type_t *)attrbufptr) = vtype;
attrbufptr = ((fsobj_type_t *)attrbufptr) + 1;
}
if (ATTR_CMN_OBJTAG & commonattr) {
*((fsobj_tag_t *)attrbufptr) = VT_ZFS;
attrbufptr = ((fsobj_tag_t *)attrbufptr) + 1;
}
/*
* Note: ATTR_CMN_OBJID is lossy (only 32 bits).
*/
if ((ATTR_CMN_OBJID | ATTR_CMN_OBJPERMANENTID) & commonattr) {
u_int32_t fileid;
/*
* On Mac OS X we always export the root directory id as 2
*/
fileid = (objnum == zfsvfs->z_root) ? 2 : objnum;
if (ATTR_CMN_OBJID & commonattr) {
((fsobj_id_t *)attrbufptr)->fid_objno = fileid;
((fsobj_id_t *)attrbufptr)->fid_generation = 0;
attrbufptr = ((fsobj_id_t *)attrbufptr) + 1;
}
if (ATTR_CMN_OBJPERMANENTID & commonattr) {
((fsobj_id_t *)attrbufptr)->fid_objno = fileid;
((fsobj_id_t *)attrbufptr)->fid_generation = 0;
attrbufptr = ((fsobj_id_t *)attrbufptr) + 1;
}
}
/*
* Note: ATTR_CMN_PAROBJID is lossy (only 32 bits).
*/
if (ATTR_CMN_PAROBJID & commonattr) {
uint64_t parentid;
VERIFY(sa_lookup(zp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs),
&parentid, sizeof (parentid)) == 0);
/*
* On Mac OS X we always export the root
* directory id as 2 and its parent as 1
*/
if (zp && zp->z_id == zfsvfs->z_root)
parentid = 1;
else if (parentid == zfsvfs->z_root)
parentid = 2;
ASSERT(parentid != 0);
((fsobj_id_t *)attrbufptr)->fid_objno = (uint32_t)parentid;
((fsobj_id_t *)attrbufptr)->fid_generation = 0;
attrbufptr = ((fsobj_id_t *)attrbufptr) + 1;
}
if (ATTR_CMN_SCRIPT & commonattr) {
*((text_encoding_t *)attrbufptr) = kTextEncodingMacUnicode;
attrbufptr = ((text_encoding_t *)attrbufptr) + 1;
}
if (ATTR_CMN_CRTIME & commonattr) {
uint64_t times[2];
VERIFY(sa_lookup(zp->z_sa_hdl, SA_ZPL_CRTIME(zfsvfs),
times, sizeof(times)) == 0);
if (user64) {
ZFS_TIME_DECODE((timespec_user64_t *)attrbufptr,
times);
attrbufptr = ((timespec_user64_t *)attrbufptr) + 1;
} else {
ZFS_TIME_DECODE((timespec_user32_t *)attrbufptr,
times);
attrbufptr = ((timespec_user32_t *)attrbufptr) + 1;
}
}
if (ATTR_CMN_MODTIME & commonattr) {
uint64_t times[2];
VERIFY(sa_lookup(zp->z_sa_hdl, SA_ZPL_MTIME(zfsvfs),
times, sizeof(times)) == 0);
if (user64) {
ZFS_TIME_DECODE((timespec_user64_t *)attrbufptr,
times);
attrbufptr = ((timespec_user64_t *)attrbufptr) + 1;
} else {
ZFS_TIME_DECODE((timespec_user32_t *)attrbufptr,
times);
attrbufptr = ((timespec_user32_t *)attrbufptr) + 1;
}
}
if (ATTR_CMN_CHGTIME & commonattr) {
uint64_t times[2];
VERIFY(sa_lookup(zp->z_sa_hdl, SA_ZPL_CTIME(zfsvfs),
times, sizeof(times)) == 0);
if (user64) {
ZFS_TIME_DECODE((timespec_user64_t *)attrbufptr,
times);
attrbufptr = ((timespec_user64_t *)attrbufptr) + 1;
} else {
ZFS_TIME_DECODE((timespec_user32_t *)attrbufptr,
times);
attrbufptr = ((timespec_user32_t *)attrbufptr) + 1;
}
}
if (ATTR_CMN_ACCTIME & commonattr) {
uint64_t times[2];
VERIFY(sa_lookup(zp->z_sa_hdl, SA_ZPL_ATIME(zfsvfs),
times, sizeof(times)) == 0);
if (user64) {
ZFS_TIME_DECODE((timespec_user64_t *)attrbufptr,
times);
attrbufptr = ((timespec_user64_t *)attrbufptr) + 1;
} else {
ZFS_TIME_DECODE((timespec_user32_t *)attrbufptr,
times);
attrbufptr = ((timespec_user32_t *)attrbufptr) + 1;
}
}
if (ATTR_CMN_BKUPTIME & commonattr) {
/* legacy attribute -- just pass zero */
if (user64) {
((timespec_user64_t *)attrbufptr)->tv_sec = 0;
((timespec_user64_t *)attrbufptr)->tv_nsec = 0;
attrbufptr = ((timespec_user64_t *)attrbufptr) + 1;
} else {
((timespec_user32_t *)attrbufptr)->tv_sec = 0;
((timespec_user32_t *)attrbufptr)->tv_nsec = 0;
attrbufptr = ((timespec_user32_t *)attrbufptr) + 1;
}
}
if (ATTR_CMN_FNDRINFO & commonattr) {
uint64_t val;
VERIFY(sa_lookup(zp->z_sa_hdl, SA_ZPL_FLAGS(zfsvfs),
&val, sizeof(val)) == 0);
getfinderinfo(zp, cr, &finderinfo);
/* Shadow ZFS_HIDDEN to Finder Info's invisible bit */
if (val & ZFS_HIDDEN) {
finderinfo.fi_flags |=
OSSwapHostToBigConstInt16(kIsInvisible);
}
bcopy(&finderinfo, attrbufptr, sizeof (finderinfo));
attrbufptr = (char *)attrbufptr + 32;
}
if (ATTR_CMN_OWNERID & commonattr) {
uint64_t val;
VERIFY(sa_lookup(zp->z_sa_hdl, SA_ZPL_UID(zfsvfs),
&val, sizeof(val)) == 0);
*((uid_t *)attrbufptr) = val;
attrbufptr = ((uid_t *)attrbufptr) + 1;
}
if (ATTR_CMN_GRPID & commonattr) {
uint64_t val;
VERIFY(sa_lookup(zp->z_sa_hdl, SA_ZPL_GID(zfsvfs),
&val, sizeof(val)) == 0);
*((gid_t *)attrbufptr) = val;
attrbufptr = ((gid_t *)attrbufptr) + 1;
}
if (ATTR_CMN_ACCESSMASK & commonattr) {
uint64_t val;
VERIFY(sa_lookup(zp->z_sa_hdl, SA_ZPL_MODE(zfsvfs),
&val, sizeof(val)) == 0);
*((u_int32_t *)attrbufptr) = val;
attrbufptr = ((u_int32_t *)attrbufptr) + 1;
}
if (ATTR_CMN_FLAGS & commonattr) {
u_int32_t flags = zfs_getbsdflags(zp);
/* Shadow Finder Info's invisible bit to UF_HIDDEN */
if ((ATTR_CMN_FNDRINFO & commonattr) &&
(OSSwapBigToHostInt16(finderinfo.fi_flags) & kIsInvisible))
flags |= UF_HIDDEN;
*((u_int32_t *)attrbufptr) = flags;
attrbufptr = ((u_int32_t *)attrbufptr) + 1;
}
if (ATTR_CMN_USERACCESS & commonattr) {
u_int32_t user_access = 0;
uint64_t val;
VERIFY(sa_lookup(zp->z_sa_hdl, SA_ZPL_FLAGS(zfsvfs),
&val, sizeof(val)) == 0);
user_access = getuseraccess(zp, aip->ai_context);
/* Also consider READ-ONLY file system. */
if (vfs_flags(mp) & MNT_RDONLY) {
user_access &= ~W_OK;
}
/* Locked objects are not writable either */
if ((val & ZFS_IMMUTABLE) &&
(vfs_context_suser(aip->ai_context) != 0)) {
user_access &= ~W_OK;
}
*((u_int32_t *)attrbufptr) = user_access;
attrbufptr = ((u_int32_t *)attrbufptr) + 1;
}
if (ATTR_CMN_FILEID & commonattr) {
/*
* On Mac OS X we always export the root directory id as 2
*/
if (objnum == zfsvfs->z_root)
objnum = 2;
*((u_int64_t *)attrbufptr) = objnum;
attrbufptr = ((u_int64_t *)attrbufptr) + 1;
}
if (ATTR_CMN_PARENTID & commonattr) {
uint64_t parentid;
VERIFY(sa_lookup(zp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs),
&parentid, sizeof (parentid)) == 0);
/*
* On Mac OS X we always export the root
* directory id as 2 and its parent as 1
*/
if (zp && zp->z_id == zfsvfs->z_root)
parentid = 1;
else if (parentid == zfsvfs->z_root)
parentid = 2;
ASSERT(parentid != 0);
*((u_int64_t *)attrbufptr) = parentid;
attrbufptr = ((u_int64_t *)attrbufptr) + 1;
}
*aip->ai_attrbufpp = attrbufptr;
*aip->ai_varbufpp = varbufptr;
}
