int
afs_mount(struct mount *mp, char *path, caddr_t data, struct nameidata *ndp, CTX_TYPE ctx)
#endif
{
/* ndp contains the mounted-from device. Just ignore it.
* we also don't care about our proc struct. */
size_t size;
int error;
#ifdef AFS_DARWIN80_ENV
struct vfsioattr ioattr;
/* vfs_statfs advertised as RO, but isn't */
/* new api will be needed to initialize this information (nfs needs to
set mntfromname too) */
#endif
STATFS_TYPE *mnt_stat = vfs_statfs(mp);
if (vfs_isupdate(mp))
return EINVAL;
AFS_GLOCK();
AFS_STATCNT(afs_mount);
if (data == 0 && afs_globalVFS) { /* Don't allow remounts. */
AFS_GUNLOCK();
return (EBUSY);
}
afs_globalVFS = mp;
#ifdef AFS_DARWIN80_ENV
vfs_ioattr(mp, &ioattr);
ioattr.io_devblocksize = (16 * 32768);
vfs_setioattr(mp, &ioattr);
/* f_iosize is handled in VFS_GETATTR */
#else
mp->vfs_bsize = 8192;
mp->mnt_stat.f_iosize = 8192;
#endif
vfs_getnewfsid(mp);
#ifndef AFS_DARWIN80_ENV
(void)copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size);
memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
#endif
memset(mnt_stat->f_mntfromname, 0, MNAMELEN);
if (data == 0) {
strcpy(mnt_stat->f_mntfromname, "AFS");
/* null terminated string "AFS" will fit, just leave it be. */
vfs_setfsprivate(mp, NULL);
} else {
struct VenusFid *rootFid = NULL;
struct volume *tvp;
char volName[MNAMELEN];
(void)copyinstr(data, volName, MNAMELEN - 1, &size);
memset(volName + size, 0, MNAMELEN - size);
if (volName[0] == 0) {
strcpy(mnt_stat->f_mntfromname, "AFS");
vfs_setfsprivate(mp, &afs_rootFid);
} else {
struct cell *localcell = afs_GetPrimaryCell(READ_LOCK);
if (localcell == NULL) {
AFS_GUNLOCK();
return ENODEV;
}
/* Set the volume identifier to "AFS:volume.name" */
snprintf(mnt_stat->f_mntfromname, MNAMELEN - 1, "AFS:%s",
volName);
tvp =
afs_GetVolumeByName(volName, localcell->cellNum, 1,
(struct vrequest *)0, READ_LOCK);
if (tvp) {
int volid = (tvp->roVol ? tvp->roVol : tvp->volume);
MALLOC(rootFid, struct VenusFid *, sizeof(*rootFid), M_UFSMNT,
M_WAITOK);
rootFid->Cell = localcell->cellNum;
rootFid->Fid.Volume = volid;
rootFid->Fid.Vnode = 1;
rootFid->Fid.Unique = 1;
} else {
AFS_GUNLOCK();
return ENODEV;
}
vfs_setfsprivate(mp, &rootFid);
}
}
static errno_t
fuse_vfsop_mount(mount_t mp, __unused vnode_t devvp, user_addr_t udata,
vfs_context_t context)
{
int err = 0;
int mntopts = 0;
bool mounted = false;
uint32_t max_read = ~0;
size_t len;
fuse_device_t fdev = NULL;
struct fuse_data *data = NULL;
fuse_mount_args fusefs_args;
struct vfsstatfs *vfsstatfsp = vfs_statfs(mp);
#if M_FUSE4X_ENABLE_BIGLOCK
lck_mtx_t *biglock;
#endif
fuse_trace_printf_vfsop();
if (vfs_isupdate(mp)) {
return ENOTSUP;
}
err = copyin(udata, &fusefs_args, sizeof(fusefs_args));
if (err) {
return EINVAL;
}
/*
* Interesting flags that we can receive from mount or may want to
* otherwise forcibly set include:
*
* MNT_ASYNC
* MNT_AUTOMOUNTED
* MNT_DEFWRITE
* MNT_DONTBROWSE
* MNT_IGNORE_OWNERSHIP
* MNT_JOURNALED
* MNT_NODEV
* MNT_NOEXEC
* MNT_NOSUID
* MNT_NOUSERXATTR
* MNT_RDONLY
* MNT_SYNCHRONOUS
* MNT_UNION
*/
err = ENOTSUP;
#if M_FUSE4X_ENABLE_UNSUPPORTED
vfs_setlocklocal(mp);
#endif /* M_FUSE4X_ENABLE_UNSUPPORTED */
/** Option Processing. **/
if (*fusefs_args.fstypename) {
size_t typenamelen = strlen(fusefs_args.fstypename);
if (typenamelen > FUSE_FSTYPENAME_MAXLEN) {
return EINVAL;
}
snprintf(vfsstatfsp->f_fstypename, MFSTYPENAMELEN, "%s%s",
FUSE_FSTYPENAME_PREFIX, fusefs_args.fstypename);
}
if (!*fusefs_args.fsname)
return EINVAL;
if ((fusefs_args.daemon_timeout > FUSE_MAX_DAEMON_TIMEOUT) ||
(fusefs_args.daemon_timeout < FUSE_MIN_DAEMON_TIMEOUT)) {
return EINVAL;
}
if ((fusefs_args.init_timeout > FUSE_MAX_INIT_TIMEOUT) ||
(fusefs_args.init_timeout < FUSE_MIN_INIT_TIMEOUT)) {
return EINVAL;
}
if (fusefs_args.altflags & FUSE_MOPT_SPARSE) {
mntopts |= FSESS_SPARSE;
}
if (fusefs_args.altflags & FUSE_MOPT_AUTO_CACHE) {
mntopts |= FSESS_AUTO_CACHE;
}
if (fusefs_args.altflags & FUSE_MOPT_AUTO_XATTR) {
if (fusefs_args.altflags & FUSE_MOPT_NATIVE_XATTR) {
return EINVAL;
}
mntopts |= FSESS_AUTO_XATTR;
} else if (fusefs_args.altflags & FUSE_MOPT_NATIVE_XATTR) {
mntopts |= FSESS_NATIVE_XATTR;
}
if (fusefs_args.altflags & FUSE_MOPT_JAIL_SYMLINKS) {
mntopts |= FSESS_JAIL_SYMLINKS;
}
/*
* Note that unlike Linux, which keeps allow_root in user-space and
* passes allow_other in that case to the kernel, we let allow_root
* reach the kernel. The 'if' ordering is important here.
*/
if (fusefs_args.altflags & FUSE_MOPT_ALLOW_ROOT) {
int is_member = 0;
if ((kauth_cred_ismember_gid(kauth_cred_get(), fuse_admin_group, &is_member) != 0) || !is_member) {
log("fuse4x: caller is not a member of fuse4x admin group. "
"Either add user (id=%d) to group (id=%d), "
"or set correct '" SYSCTL_FUSE4X_TUNABLES_ADMIN "' sysctl value.\n",
kauth_cred_getuid(kauth_cred_get()), fuse_admin_group);
return EPERM;
}
mntopts |= FSESS_ALLOW_ROOT;
} else if (fusefs_args.altflags & FUSE_MOPT_ALLOW_OTHER) {
if (!fuse_allow_other && !fuse_vfs_context_issuser(context)) {
int is_member = 0;
if ((kauth_cred_ismember_gid(kauth_cred_get(), fuse_admin_group, &is_member) != 0) || !is_member) {
log("fuse4x: caller is not a member of fuse4x admin group. "
"Either add user (id=%d) to group (id=%d), "
"or set correct '" SYSCTL_FUSE4X_TUNABLES_ADMIN "' sysctl value.\n",
kauth_cred_getuid(kauth_cred_get()), fuse_admin_group);
return EPERM;
}
}
mntopts |= FSESS_ALLOW_OTHER;
}
if (fusefs_args.altflags & FUSE_MOPT_NO_APPLEDOUBLE) {
mntopts |= FSESS_NO_APPLEDOUBLE;
}
if (fusefs_args.altflags & FUSE_MOPT_NO_APPLEXATTR) {
mntopts |= FSESS_NO_APPLEXATTR;
}
if ((fusefs_args.altflags & FUSE_MOPT_FSID) && (fusefs_args.fsid != 0)) {
fsid_t fsid;
mount_t other_mp;
uint32_t target_dev;
target_dev = FUSE_MAKEDEV(FUSE_CUSTOM_FSID_DEVICE_MAJOR,
fusefs_args.fsid);
fsid.val[0] = target_dev;
fsid.val[1] = FUSE_CUSTOM_FSID_VAL1;
other_mp = vfs_getvfs(&fsid);
if (other_mp != NULL) {
return EPERM;
}
vfsstatfsp->f_fsid.val[0] = target_dev;
vfsstatfsp->f_fsid.val[1] = FUSE_CUSTOM_FSID_VAL1;
} else {
vfs_getnewfsid(mp);
}
if (fusefs_args.altflags & FUSE_MOPT_NO_ATTRCACHE) {
mntopts |= FSESS_NO_ATTRCACHE;
}
if (fusefs_args.altflags & FUSE_MOPT_NO_READAHEAD) {
mntopts |= FSESS_NO_READAHEAD;
}
if (fusefs_args.altflags & (FUSE_MOPT_NO_UBC | FUSE_MOPT_DIRECT_IO)) {
mntopts |= FSESS_NO_UBC;
}
if (fusefs_args.altflags & FUSE_MOPT_NO_VNCACHE) {
mntopts |= FSESS_NO_VNCACHE;
}
if (fusefs_args.altflags & FUSE_MOPT_NEGATIVE_VNCACHE) {
if (mntopts & FSESS_NO_VNCACHE) {
return EINVAL;
}
mntopts |= FSESS_NEGATIVE_VNCACHE;
}
if (fusefs_args.altflags & FUSE_MOPT_NO_SYNCWRITES) {
/* Cannot mix 'nosyncwrites' with 'noubc' or 'noreadahead'. */
if (mntopts & (FSESS_NO_READAHEAD | FSESS_NO_UBC)) {
log("fuse4x: cannot mix 'nosyncwrites' with 'noubc' or 'noreadahead'\n");
return EINVAL;
}
mntopts |= FSESS_NO_SYNCWRITES;
vfs_clearflags(mp, MNT_SYNCHRONOUS);
vfs_setflags(mp, MNT_ASYNC);
/* We check for this only if we have nosyncwrites in the first place. */
if (fusefs_args.altflags & FUSE_MOPT_NO_SYNCONCLOSE) {
mntopts |= FSESS_NO_SYNCONCLOSE;
}
} else {
vfs_clearflags(mp, MNT_ASYNC);
vfs_setflags(mp, MNT_SYNCHRONOUS);
}
if (mntopts & FSESS_NO_UBC) {
/* If no buffer cache, disallow exec from file system. */
vfs_setflags(mp, MNT_NOEXEC);
}
vfs_setauthopaque(mp);
vfs_setauthopaqueaccess(mp);
if ((fusefs_args.altflags & FUSE_MOPT_DEFAULT_PERMISSIONS) &&
(fusefs_args.altflags & FUSE_MOPT_DEFER_PERMISSIONS)) {
return EINVAL;
}
if (fusefs_args.altflags & FUSE_MOPT_DEFAULT_PERMISSIONS) {
mntopts |= FSESS_DEFAULT_PERMISSIONS;
vfs_clearauthopaque(mp);
}
if (fusefs_args.altflags & FUSE_MOPT_DEFER_PERMISSIONS) {
mntopts |= FSESS_DEFER_PERMISSIONS;
}
if (fusefs_args.altflags & FUSE_MOPT_EXTENDED_SECURITY) {
mntopts |= FSESS_EXTENDED_SECURITY;
vfs_setextendedsecurity(mp);
}
if (fusefs_args.altflags & FUSE_MOPT_LOCALVOL) {
vfs_setflags(mp, MNT_LOCAL);
}
/* done checking incoming option bits */
err = 0;
vfs_setfsprivate(mp, NULL);
fdev = fuse_device_get(fusefs_args.rdev);
if (!fdev) {
log("fuse4x: invalid device file (number=%d)\n", fusefs_args.rdev);
return EINVAL;
}
fuse_lck_mtx_lock(fdev->mtx);
data = fdev->data;
if (!data) {
fuse_lck_mtx_unlock(fdev->mtx);
return ENXIO;
}
#if M_FUSE4X_ENABLE_BIGLOCK
biglock = data->biglock;
fuse_biglock_lock(biglock);
#endif
if (data->dataflags & FSESS_MOUNTED) {
#if M_FUSE4X_ENABLE_BIGLOCK
fuse_biglock_unlock(biglock);
#endif
fuse_lck_mtx_unlock(fdev->mtx);
return EALREADY;
}
if (!(data->dataflags & FSESS_OPENED)) {
fuse_lck_mtx_unlock(fdev->mtx);
err = ENXIO;
goto out;
}
data->dataflags |= FSESS_MOUNTED;
OSAddAtomic(1, (SInt32 *)&fuse_mount_count);
mounted = true;
if (fdata_dead_get(data)) {
fuse_lck_mtx_unlock(fdev->mtx);
err = ENOTCONN;
goto out;
}
if (!data->daemoncred) {
panic("fuse4x: daemon found but identity unknown");
}
if (fuse_vfs_context_issuser(context) &&
kauth_cred_getuid(vfs_context_ucred(context)) != kauth_cred_getuid(data->daemoncred)) {
fuse_lck_mtx_unlock(fdev->mtx);
err = EPERM;
log("fuse4x: fuse daemon running by user_id=%d does not have privileges to mount on directory %s owned by user_id=%d\n",
kauth_cred_getuid(data->daemoncred), vfsstatfsp->f_mntonname, kauth_cred_getuid(vfs_context_ucred(context)));
goto out;
}
data->mp = mp;
data->fdev = fdev;
data->dataflags |= mntopts;
data->daemon_timeout.tv_sec = fusefs_args.daemon_timeout;
data->daemon_timeout.tv_nsec = 0;
if (data->daemon_timeout.tv_sec) {
data->daemon_timeout_p = &(data->daemon_timeout);
} else {
data->daemon_timeout_p = NULL;
}
data->init_timeout.tv_sec = fusefs_args.init_timeout;
data->init_timeout.tv_nsec = 0;
data->max_read = max_read;
data->fssubtype = fusefs_args.fssubtype;
data->mountaltflags = fusefs_args.altflags;
data->noimplflags = (uint64_t)0;
data->blocksize = fuse_round_size(fusefs_args.blocksize,
FUSE_MIN_BLOCKSIZE, FUSE_MAX_BLOCKSIZE);
data->iosize = fuse_round_size(fusefs_args.iosize,
FUSE_MIN_IOSIZE, FUSE_MAX_IOSIZE);
if (data->iosize < data->blocksize) {
data->iosize = data->blocksize;
}
data->userkernel_bufsize = FUSE_DEFAULT_USERKERNEL_BUFSIZE;
copystr(fusefs_args.fsname, vfsstatfsp->f_mntfromname,
MNAMELEN - 1, &len);
bzero(vfsstatfsp->f_mntfromname + len, MNAMELEN - len);
copystr(fusefs_args.volname, data->volname, MAXPATHLEN - 1, &len);
bzero(data->volname + len, MAXPATHLEN - len);
/* previous location of vfs_setioattr() */
vfs_setfsprivate(mp, data);
fuse_lck_mtx_unlock(fdev->mtx);
/* Send a handshake message to the daemon. */
fuse_send_init(data, context);
struct vfs_attr vfs_attr;
VFSATTR_INIT(&vfs_attr);
// Our vfs_getattr() doesn't look at most *_IS_ACTIVE()'s
err = fuse_vfsop_getattr(mp, &vfs_attr, context);
if (!err) {
vfsstatfsp->f_bsize = vfs_attr.f_bsize;
vfsstatfsp->f_iosize = vfs_attr.f_iosize;
vfsstatfsp->f_blocks = vfs_attr.f_blocks;
vfsstatfsp->f_bfree = vfs_attr.f_bfree;
vfsstatfsp->f_bavail = vfs_attr.f_bavail;
vfsstatfsp->f_bused = vfs_attr.f_bused;
vfsstatfsp->f_files = vfs_attr.f_files;
vfsstatfsp->f_ffree = vfs_attr.f_ffree;
// vfsstatfsp->f_fsid already handled above
vfsstatfsp->f_owner = kauth_cred_getuid(data->daemoncred);
vfsstatfsp->f_flags = vfs_flags(mp);
// vfsstatfsp->f_fstypename already handled above
// vfsstatfsp->f_mntonname handled elsewhere
// vfsstatfsp->f_mnfromname already handled above
vfsstatfsp->f_fssubtype = data->fssubtype;
}
if (fusefs_args.altflags & FUSE_MOPT_BLOCKSIZE) {
vfsstatfsp->f_bsize = data->blocksize;
} else {
//data->blocksize = vfsstatfsp->f_bsize;
}
if (fusefs_args.altflags & FUSE_MOPT_IOSIZE) {
vfsstatfsp->f_iosize = data->iosize;
} else {
//data->iosize = (uint32_t)vfsstatfsp->f_iosize;
vfsstatfsp->f_iosize = data->iosize;
}
out:
if (err) {
vfs_setfsprivate(mp, NULL);
fuse_lck_mtx_lock(fdev->mtx);
data = fdev->data; /* again */
if (mounted) {
OSAddAtomic(-1, (SInt32 *)&fuse_mount_count);
}
if (data) {
data->dataflags &= ~FSESS_MOUNTED;
if (!(data->dataflags & FSESS_OPENED)) {
#if M_FUSE4X_ENABLE_BIGLOCK
assert(biglock == data->biglock);
fuse_biglock_unlock(biglock);
#endif
fuse_device_close_final(fdev);
/* data is gone now */
}
}
fuse_lck_mtx_unlock(fdev->mtx);
} else {
vnode_t fuse_rootvp = NULLVP;
err = fuse_vfsop_root(mp, &fuse_rootvp, context);
if (err) {
goto out; /* go back and follow error path */
}
err = vnode_ref(fuse_rootvp);
(void)vnode_put(fuse_rootvp);
if (err) {
goto out; /* go back and follow error path */
} else {
struct vfsioattr ioattr;
vfs_ioattr(mp, &ioattr);
ioattr.io_devblocksize = data->blocksize;
vfs_setioattr(mp, &ioattr);
}
}
#if M_FUSE4X_ENABLE_BIGLOCK
fuse_lck_mtx_lock(fdev->mtx);
data = fdev->data; /* ...and again */
if(data) {
assert(data->biglock == biglock);
fuse_biglock_unlock(biglock);
}
fuse_lck_mtx_unlock(fdev->mtx);
#endif
return err;
}
static errno_t
fuse_vfsop_mount(mount_t mp, __unused vnode_t devvp, user_addr_t udata,
vfs_context_t context)
{
int err = 0;
int mntopts = 0;
bool mounted = false;
uint32_t drandom = 0;
uint32_t max_read = ~0;
size_t len;
fuse_device_t fdev = NULL;
struct fuse_data *data = NULL;
fuse_mount_args fusefs_args;
struct vfsstatfs *vfsstatfsp = vfs_statfs(mp);
kern_return_t kr;
thread_t init_thread;
#if M_OSXFUSE_ENABLE_BIG_LOCK
fuse_biglock_t *biglock;
#endif
fuse_trace_printf_vfsop();
if (vfs_isupdate(mp)) {
return ENOTSUP;
}
err = copyin(udata, &fusefs_args, sizeof(fusefs_args));
if (err) {
return EINVAL;
}
/*
* Interesting flags that we can receive from mount or may want to
* otherwise forcibly set include:
*
* MNT_ASYNC
* MNT_AUTOMOUNTED
* MNT_DEFWRITE
* MNT_DONTBROWSE
* MNT_IGNORE_OWNERSHIP
* MNT_JOURNALED
* MNT_NODEV
* MNT_NOEXEC
* MNT_NOSUID
* MNT_NOUSERXATTR
* MNT_RDONLY
* MNT_SYNCHRONOUS
* MNT_UNION
*/
#if M_OSXFUSE_ENABLE_UNSUPPORTED
vfs_setlocklocal(mp);
#endif /* M_OSXFUSE_ENABLE_UNSUPPORTED */
/** Option Processing. **/
if (fusefs_args.altflags & FUSE_MOPT_FSTYPENAME) {
size_t typenamelen = strlen(fusefs_args.fstypename);
if ((typenamelen <= 0) || (typenamelen > FUSE_FSTYPENAME_MAXLEN)) {
return EINVAL;
}
snprintf(vfsstatfsp->f_fstypename, MFSTYPENAMELEN, "%s%s",
OSXFUSE_FSTYPENAME_PREFIX, fusefs_args.fstypename);
}
if ((fusefs_args.daemon_timeout > FUSE_MAX_DAEMON_TIMEOUT) ||
(fusefs_args.daemon_timeout < FUSE_MIN_DAEMON_TIMEOUT)) {
return EINVAL;
}
if (fusefs_args.altflags & FUSE_MOPT_SPARSE) {
mntopts |= FSESS_SPARSE;
}
if (fusefs_args.altflags & FUSE_MOPT_SLOW_STATFS) {
mntopts |= FSESS_SLOW_STATFS;
}
if (fusefs_args.altflags & FUSE_MOPT_AUTO_CACHE) {
mntopts |= FSESS_AUTO_CACHE;
}
if (fusefs_args.altflags & FUSE_MOPT_AUTO_XATTR) {
if (fusefs_args.altflags & FUSE_MOPT_NATIVE_XATTR) {
return EINVAL;
}
mntopts |= FSESS_AUTO_XATTR;
} else if (fusefs_args.altflags & FUSE_MOPT_NATIVE_XATTR) {
mntopts |= FSESS_NATIVE_XATTR;
}
if (fusefs_args.altflags & FUSE_MOPT_NO_BROWSE) {
vfs_setflags(mp, MNT_DONTBROWSE);
}
if (fusefs_args.altflags & FUSE_MOPT_JAIL_SYMLINKS) {
mntopts |= FSESS_JAIL_SYMLINKS;
}
/*
* Note that unlike Linux, which keeps allow_root in user-space and
* passes allow_other in that case to the kernel, we let allow_root
* reach the kernel. The 'if' ordering is important here.
*/
if (fusefs_args.altflags & FUSE_MOPT_ALLOW_ROOT) {
int is_member = 0;
if ((kauth_cred_ismember_gid(kauth_cred_get(), fuse_admin_group,
&is_member) == 0) && is_member) {
mntopts |= FSESS_ALLOW_ROOT;
} else {
IOLog("OSXFUSE: caller not a member of OSXFUSE admin group (%d)\n",
fuse_admin_group);
return EPERM;
}
} else if (fusefs_args.altflags & FUSE_MOPT_ALLOW_OTHER) {
if (!fuse_allow_other && !fuse_vfs_context_issuser(context)) {
int is_member = 0;
if ((kauth_cred_ismember_gid(kauth_cred_get(), fuse_admin_group,
&is_member) != 0) || !is_member) {
return EPERM;
}
}
mntopts |= FSESS_ALLOW_OTHER;
}
if (fusefs_args.altflags & FUSE_MOPT_NO_APPLEDOUBLE) {
mntopts |= FSESS_NO_APPLEDOUBLE;
}
if (fusefs_args.altflags & FUSE_MOPT_NO_APPLEXATTR) {
mntopts |= FSESS_NO_APPLEXATTR;
}
if ((fusefs_args.altflags & FUSE_MOPT_FSID) && (fusefs_args.fsid != 0)) {
fsid_t fsid;
mount_t other_mp;
uint32_t target_dev;
target_dev = FUSE_MAKEDEV(FUSE_CUSTOM_FSID_DEVICE_MAJOR,
fusefs_args.fsid);
fsid.val[0] = target_dev;
fsid.val[1] = FUSE_CUSTOM_FSID_VAL1;
other_mp = vfs_getvfs(&fsid);
if (other_mp != NULL) {
return EPERM;
}
vfsstatfsp->f_fsid.val[0] = target_dev;
vfsstatfsp->f_fsid.val[1] = FUSE_CUSTOM_FSID_VAL1;
} else {
vfs_getnewfsid(mp);
}
if (fusefs_args.altflags & FUSE_MOPT_NO_LOCALCACHES) {
mntopts |= FSESS_NO_ATTRCACHE;
mntopts |= FSESS_NO_READAHEAD;
mntopts |= FSESS_NO_UBC;
mntopts |= FSESS_NO_VNCACHE;
}
if (fusefs_args.altflags & FUSE_MOPT_NO_ATTRCACHE) {
mntopts |= FSESS_NO_ATTRCACHE;
}
if (fusefs_args.altflags & FUSE_MOPT_NO_READAHEAD) {
mntopts |= FSESS_NO_READAHEAD;
}
if (fusefs_args.altflags & (FUSE_MOPT_NO_UBC | FUSE_MOPT_DIRECT_IO)) {
mntopts |= FSESS_NO_UBC;
}
if (fusefs_args.altflags & FUSE_MOPT_NO_VNCACHE) {
mntopts |= FSESS_NO_VNCACHE;
}
if (fusefs_args.altflags & FUSE_MOPT_NEGATIVE_VNCACHE) {
if (mntopts & FSESS_NO_VNCACHE) {
return EINVAL;
}
mntopts |= FSESS_NEGATIVE_VNCACHE;
}
if (fusefs_args.altflags & FUSE_MOPT_NO_SYNCWRITES) {
/* Cannot mix 'nosyncwrites' with 'noubc' or 'noreadahead'. */
if (mntopts & (FSESS_NO_READAHEAD | FSESS_NO_UBC)) {
return EINVAL;
}
mntopts |= FSESS_NO_SYNCWRITES;
vfs_clearflags(mp, MNT_SYNCHRONOUS);
vfs_setflags(mp, MNT_ASYNC);
/* We check for this only if we have nosyncwrites in the first place. */
if (fusefs_args.altflags & FUSE_MOPT_NO_SYNCONCLOSE) {
mntopts |= FSESS_NO_SYNCONCLOSE;
}
} else {
vfs_clearflags(mp, MNT_ASYNC);
vfs_setflags(mp, MNT_SYNCHRONOUS);
}
if (mntopts & FSESS_NO_UBC) {
/* If no buffer cache, disallow exec from file system. */
vfs_setflags(mp, MNT_NOEXEC);
}
vfs_setauthopaque(mp);
vfs_setauthopaqueaccess(mp);
if ((fusefs_args.altflags & FUSE_MOPT_DEFAULT_PERMISSIONS) &&
(fusefs_args.altflags & FUSE_MOPT_DEFER_PERMISSIONS)) {
return EINVAL;
}
if (fusefs_args.altflags & FUSE_MOPT_DEFAULT_PERMISSIONS) {
mntopts |= FSESS_DEFAULT_PERMISSIONS;
vfs_clearauthopaque(mp);
}
if (fusefs_args.altflags & FUSE_MOPT_DEFER_PERMISSIONS) {
mntopts |= FSESS_DEFER_PERMISSIONS;
}
if (fusefs_args.altflags & FUSE_MOPT_EXTENDED_SECURITY) {
mntopts |= FSESS_EXTENDED_SECURITY;
vfs_setextendedsecurity(mp);
}
if (fusefs_args.altflags & FUSE_MOPT_LOCALVOL) {
mntopts |= FSESS_LOCALVOL;
vfs_setflags(mp, MNT_LOCAL);
}
/* done checking incoming option bits */
err = 0;
vfs_setfsprivate(mp, NULL);
fdev = fuse_device_get(fusefs_args.rdev);
if (!fdev) {
return EINVAL;
}
fuse_device_lock(fdev);
drandom = fuse_device_get_random(fdev);
if (fusefs_args.random != drandom) {
fuse_device_unlock(fdev);
IOLog("OSXFUSE: failing mount because of mismatched random\n");
return EINVAL;
}
data = fuse_device_get_mpdata(fdev);
if (!data) {
fuse_device_unlock(fdev);
return ENXIO;
}
#if M_OSXFUSE_ENABLE_BIG_LOCK
biglock = data->biglock;
fuse_biglock_lock(biglock);
#endif
if (data->mount_state != FM_NOTMOUNTED) {
#if M_OSXFUSE_ENABLE_BIG_LOCK
fuse_biglock_unlock(biglock);
#endif
fuse_device_unlock(fdev);
return EALREADY;
}
if (!(data->dataflags & FSESS_OPENED)) {
fuse_device_unlock(fdev);
err = ENXIO;
goto out;
}
data->mount_state = FM_MOUNTED;
OSAddAtomic(1, (SInt32 *)&fuse_mount_count);
mounted = true;
if (fdata_dead_get(data)) {
fuse_device_unlock(fdev);
err = ENOTCONN;
goto out;
}
if (!data->daemoncred) {
panic("OSXFUSE: daemon found but identity unknown");
}
if (fuse_vfs_context_issuser(context) &&
kauth_cred_getuid(vfs_context_ucred(context)) != kauth_cred_getuid(data->daemoncred)) {
fuse_device_unlock(fdev);
err = EPERM;
goto out;
}
data->mp = mp;
data->fdev = fdev;
data->dataflags |= mntopts;
data->daemon_timeout.tv_sec = fusefs_args.daemon_timeout;
data->daemon_timeout.tv_nsec = 0;
if (data->daemon_timeout.tv_sec) {
data->daemon_timeout_p = &(data->daemon_timeout);
} else {
data->daemon_timeout_p = (struct timespec *)0;
}
data->max_read = max_read;
data->fssubtype = fusefs_args.fssubtype;
data->mountaltflags = fusefs_args.altflags;
data->noimplflags = (uint64_t)0;
data->blocksize = fuse_round_size(fusefs_args.blocksize,
FUSE_MIN_BLOCKSIZE, FUSE_MAX_BLOCKSIZE);
data->iosize = fuse_round_size(fusefs_args.iosize,
FUSE_MIN_IOSIZE, FUSE_MAX_IOSIZE);
if (data->iosize < data->blocksize) {
data->iosize = data->blocksize;
}
data->userkernel_bufsize = FUSE_DEFAULT_USERKERNEL_BUFSIZE;
copystr(fusefs_args.fsname, vfsstatfsp->f_mntfromname,
MNAMELEN - 1, &len);
bzero(vfsstatfsp->f_mntfromname + len, MNAMELEN - len);
copystr(fusefs_args.volname, data->volname, MAXPATHLEN - 1, &len);
bzero(data->volname + len, MAXPATHLEN - len);
/* previous location of vfs_setioattr() */
vfs_setfsprivate(mp, data);
fuse_device_unlock(fdev);
/* Send a handshake message to the daemon. */
kr = kernel_thread_start(fuse_internal_init, data, &init_thread);
if (kr != KERN_SUCCESS) {
IOLog("OSXFUSE: could not start init thread\n");
err = ENOTCONN;
} else {
thread_deallocate(init_thread);
}
out:
if (err) {
vfs_setfsprivate(mp, NULL);
fuse_device_lock(fdev);
data = fuse_device_get_mpdata(fdev); /* again */
if (mounted) {
OSAddAtomic(-1, (SInt32 *)&fuse_mount_count);
}
if (data) {
data->mount_state = FM_NOTMOUNTED;
if (!(data->dataflags & FSESS_OPENED)) {
#if M_OSXFUSE_ENABLE_BIG_LOCK
assert(biglock == data->biglock);
fuse_biglock_unlock(biglock);
#endif
fuse_device_close_final(fdev);
/* data is gone now */
}
}
fuse_device_unlock(fdev);
} else {
vnode_t fuse_rootvp = NULLVP;
err = fuse_vfsop_root(mp, &fuse_rootvp, context);
if (err) {
goto out; /* go back and follow error path */
}
err = vnode_ref(fuse_rootvp);
#if M_OSXFUSE_ENABLE_BIG_LOCK
/*
* Even though fuse_rootvp will not be reclaimed when calling vnode_put
* because we incremented its usecount by calling vnode_ref release
* biglock just to be safe.
*/
fuse_biglock_unlock(biglock);
#endif /* M_OSXFUSE_ENABLE_BIG_LOCK */
(void)vnode_put(fuse_rootvp);
#if M_OSXFUSE_ENABLE_BIG_LOCK
fuse_biglock_lock(biglock);
#endif
if (err) {
goto out; /* go back and follow error path */
} else {
struct vfsioattr ioattr;
vfs_ioattr(mp, &ioattr);
ioattr.io_maxreadcnt = ioattr.io_maxwritecnt = data->iosize;
ioattr.io_segreadcnt = ioattr.io_segwritecnt = data->iosize / PAGE_SIZE;
ioattr.io_maxsegreadsize = ioattr.io_maxsegwritesize = data->iosize;
ioattr.io_devblocksize = data->blocksize;
vfs_setioattr(mp, &ioattr);
}
}
#if M_OSXFUSE_ENABLE_BIG_LOCK
fuse_device_lock(fdev);
data = fuse_device_get_mpdata(fdev); /* ...and again */
if(data) {
assert(data->biglock == biglock);
fuse_biglock_unlock(biglock);
}
fuse_device_unlock(fdev);
#endif
return err;
}
