__private_extern__
void
fuse_preflight_log(vnode_t vp, fufh_type_t fufh_type, int err, char *message)
{
const char *vname = NULL;
#if M_MACFUSE_ENABLE_UNSUPPORTED
vname = vnode_getname(vp);
#else
(void)vname;
(void)vp;
#endif /* M_MACFUSE_ENABLE_UNSUPPORTED */
if (vname) {
IOLog("MacFUSE: file handle preflight "
"(caller=%s, type=%d, err=%d, name=%s)\n",
message, fufh_type, err, vname);
} else {
IOLog("MacFUSE: file handle preflight "
"(caller=%s, type=%d, err=%d)\n", message, fufh_type, err);
}
#if M_MACFUSE_ENABLE_UNSUPPORTED
if (vname) {
vnode_putname(vname);
}
#endif /* M_MACFUSE_ENABLE_UNSUPPORTED */
}
static int
fuse_internal_print_vnodes_callback(vnode_t vp, __unused void *cargs)
{
const char *vname = NULL;
struct fuse_vnode_data *fvdat = VTOFUD(vp);
#if M_MACFUSE_ENABLE_UNSUPPORTED
vname = vnode_getname(vp);
#endif /* M_MACFUSE_ENABLE_UNSUPPORTED */
if (vname) {
IOLog("MacFUSE: vp=%p ino=%lld parent=%lld inuse=%d %s\n",
vp, fvdat->nodeid, fvdat->parent_nodeid,
vnode_isinuse(vp, 0), vname);
} else {
if (fvdat->nodeid == FUSE_ROOT_ID) {
IOLog("MacFUSE: vp=%p ino=%lld parent=%lld inuse=%d /\n",
vp, fvdat->nodeid, fvdat->parent_nodeid,
vnode_isinuse(vp, 0));
} else {
IOLog("MacFUSE: vp=%p ino=%lld parent=%lld inuse=%d\n",
vp, fvdat->nodeid, fvdat->parent_nodeid,
vnode_isinuse(vp, 0));
}
}
#if M_MACFUSE_ENABLE_UNSUPPORTED
if (vname) {
vnode_putname(vname);
}
#endif /* M_MACFUSE_ENABLE_UNSUPPORTED */
return VNODE_RETURNED;
}
/*
* Because of the vagaries of how a filehandle can be used, we try not to
* be too smart in here (we try to be smart elsewhere). It is required that
* you come in here only if you really do not have the said filehandle--else
* we panic.
*/
int
fuse_filehandle_get(vnode_t vp,
vfs_context_t context,
fufh_type_t fufh_type,
int mode)
{
struct fuse_dispatcher fdi;
struct fuse_abi_data foi;
struct fuse_abi_data foo;
struct fuse_filehandle *fufh;
struct fuse_vnode_data *fvdat = VTOFUD(vp);
struct fuse_data *data = fuse_get_mpdata(vnode_mount(vp));
int err = 0;
int oflags = 0;
int op = FUSE_OPEN;
fuse_trace_printf("fuse_filehandle_get(vp=%p, fufh_type=%d, mode=%x)\n",
vp, fufh_type, mode);
fufh = &(fvdat->fufh[fufh_type]);
if (FUFH_IS_VALID(fufh)) {
panic("osxfuse: filehandle_get called despite valid fufh (type=%d)",
fufh_type);
/* NOTREACHED */
}
/*
* Note that this means we are effectively FILTERING OUT open() flags.
*/
(void)mode;
oflags = fuse_filehandle_xlate_to_oflags(fufh_type);
if (vnode_isdir(vp)) {
op = FUSE_OPENDIR;
if (fufh_type != FUFH_RDONLY) {
IOLog("osxfuse: non-rdonly fufh requested for directory\n");
fufh_type = FUFH_RDONLY;
}
}
if (vnode_islnk(vp) && (mode & O_SYMLINK)) {
oflags |= O_SYMLINK;
}
if ((mode & O_TRUNC) && (data->dataflags & FSESS_ATOMIC_O_TRUNC)) {
oflags |= O_TRUNC;
}
fdisp_init_abi(&fdi, fuse_open_in, data);
fdisp_make_vp(&fdi, op, vp, context);
fuse_abi_data_init(&foi, DATOI(data), fdi.indata);
fuse_open_in_set_flags(&foi, oflags);
FUSE_OSAddAtomic(1, (SInt32 *)&fuse_fh_upcall_count);
err = fdisp_wait_answ(&fdi);
if (err) {
#if M_OSXFUSE_ENABLE_UNSUPPORTED
const char *vname = vnode_getname(vp);
#endif /* M_OSXFUSE_ENABLE_UNSUPPORTED */
if (err == ENOENT) {
/*
* See comment in fuse_vnop_reclaim().
*/
cache_purge(vp);
}
#if M_OSXFUSE_ENABLE_UNSUPPORTED
IOLog("osxfuse: filehandle_get: failed for %s "
"(type=%d, err=%d, caller=%p)\n",
(vname) ? vname : "?", fufh_type, err,
__builtin_return_address(0));
if (vname) {
vnode_putname(vname);
}
#endif /* M_OSXFUSE_ENABLE_UNSUPPORTED */
if (err == ENOENT) {
#if M_OSXFUSE_ENABLE_BIG_LOCK
fuse_biglock_unlock(data->biglock);
#endif
fuse_internal_vnode_disappear(vp, context, REVOKE_SOFT);
#if M_OSXFUSE_ENABLE_BIG_LOCK
fuse_biglock_lock(data->biglock);
#endif
}
return err;
}
FUSE_OSAddAtomic(1, (SInt32 *)&fuse_fh_current);
fuse_abi_data_init(&foo, DATOI(data), fdi.answ);
fufh->fh_id = fuse_open_out_get_fh(&foo);
fufh->open_count = 1;
fufh->open_flags = oflags;
fufh->fuse_open_flags = fuse_open_out_get_open_flags(&foo);
fufh->aux_count = 0;
fuse_ticket_release(fdi.tick);
return 0;
}
/*
* Look up a vnode/nfsnode by file handle.
* Callers must check for mount points!!
* In all cases, a pointer to a
* nfsnode structure is returned.
*/
int
nfs_nget(
mount_t mp,
nfsnode_t dnp,
struct componentname *cnp,
u_char *fhp,
int fhsize,
struct nfs_vattr *nvap,
u_int64_t *xidp,
uint32_t auth,
int flags,
nfsnode_t *npp)
{
nfsnode_t np;
struct nfsnodehashhead *nhpp;
vnode_t vp;
int error, nfsvers;
mount_t mp2;
struct vnode_fsparam vfsp;
uint32_t vid;
FSDBG_TOP(263, mp, dnp, flags, npp);
/* Check for unmount in progress */
if (!mp || vfs_isforce(mp)) {
*npp = NULL;
error = ENXIO;
FSDBG_BOT(263, mp, dnp, 0xd1e, error);
return (error);
}
nfsvers = VFSTONFS(mp)->nm_vers;
nhpp = NFSNOHASH(nfs_hash(fhp, fhsize));
loop:
lck_mtx_lock(nfs_node_hash_mutex);
for (np = nhpp->lh_first; np != 0; np = np->n_hash.le_next) {
mp2 = (np->n_hflag & NHINIT) ? np->n_mount : NFSTOMP(np);
if (mp != mp2 || np->n_fhsize != fhsize ||
bcmp(fhp, np->n_fhp, fhsize))
continue;
if (nvap && (nvap->nva_flags & NFS_FFLAG_TRIGGER_REFERRAL) &&
cnp && (cnp->cn_namelen > (fhsize - (int)sizeof(dnp)))) {
/* The name was too long to fit in the file handle. Check it against the node's name. */
int namecmp = 0;
const char *vname = vnode_getname(NFSTOV(np));
if (vname) {
if (cnp->cn_namelen != (int)strlen(vname))
namecmp = 1;
else
namecmp = strncmp(vname, cnp->cn_nameptr, cnp->cn_namelen);
vnode_putname(vname);
}
if (namecmp) /* full name didn't match */
continue;
}
FSDBG(263, dnp, np, np->n_flag, 0xcace0000);
/* if the node is locked, sleep on it */
if ((np->n_hflag & NHLOCKED) && !(flags & NG_NOCREATE)) {
np->n_hflag |= NHLOCKWANT;
FSDBG(263, dnp, np, np->n_flag, 0xcace2222);
msleep(np, nfs_node_hash_mutex, PDROP | PINOD, "nfs_nget", NULL);
FSDBG(263, dnp, np, np->n_flag, 0xcace3333);
goto loop;
}
vp = NFSTOV(np);
vid = vnode_vid(vp);
lck_mtx_unlock(nfs_node_hash_mutex);
if ((error = vnode_getwithvid(vp, vid))) {
/*
* If vnode is being reclaimed or has already
* changed identity, no need to wait.
*/
FSDBG_BOT(263, dnp, *npp, 0xcace0d1e, error);
return (error);
}
if ((error = nfs_node_lock(np))) {
/* this only fails if the node is now unhashed */
/* so let's see if we can find/create it again */
FSDBG(263, dnp, *npp, 0xcaced1e2, error);
vnode_put(vp);
if (flags & NG_NOCREATE) {
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0xcaced1e0, ENOENT);
return (ENOENT);
}
goto loop;
}
/* update attributes */
if (nvap)
error = nfs_loadattrcache(np, nvap, xidp, 0);
if (error) {
nfs_node_unlock(np);
vnode_put(vp);
} else {
if (dnp && cnp && (flags & NG_MAKEENTRY))
cache_enter(NFSTOV(dnp), vp, cnp);
/*
* Update the vnode if the name/and or the parent has
* changed. We need to do this so that if getattrlist is
* called asking for ATTR_CMN_NAME, that the "most"
* correct name is being returned. In addition for
* monitored vnodes we need to kick the vnode out of the
* name cache. We do this so that if there are hard
* links in the same directory the link will not be
* found and a lookup will get us here to return the
* name of the current link. In addition by removing the
* name from the name cache the old name will not be
* found after a rename done on another client or the
* server. The principle reason to do this is because
* Finder is asking for notifications on a directory.
* The directory changes, Finder gets notified, reads
* the directory (which we have purged) and for each
* entry returned calls getattrlist with the name
* returned from readdir. gettattrlist has to call
* namei/lookup to resolve the name, because its not in
* the cache we end up here. We need to update the name
* so Finder will get the name it called us with.
*
* We had an imperfect solution with respect to case
* sensitivity. There is a test that is run in
* FileBuster that does renames from some name to
* another name differing only in case. It then reads
* the directory looking for the new name, after it
* finds that new name, it ask gettattrlist to verify
* that the name is the new name. Usually that works,
* but renames generate fsevents and fseventsd will do a
* lookup on the name via lstat. Since that test renames
* old name to new name back and forth there is a race
* that an fsevent will be behind and will access the
* file by the old name, on a case insensitive file
* system that will work. Problem is if we do a case
* sensitive compare, we're going to change the name,
* which the test's getattrlist verification step is
* going to fail. So we will check the case sensitivity
* of the file system and do the appropriate compare. In
* a rare instance for non homogeneous file systems
* w.r.t. pathconf we will use case sensitive compares.
* That could break if the file system is actually case
* insensitive.
*
* Note that V2 does not know the case, so we just
* assume case sensitivity.
*
* This is clearly not perfect due to races, but this is
* as good as its going to get. You can defeat the
* handling of hard links simply by doing:
*
* while :; do ls -l > /dev/null; done
*
* in a terminal window. Even a single ls -l can cause a
* race.
*
* <rant>What we really need is for the caller, that
* knows the name being used is valid since it got it
* from a readdir to use that name and not ask for the
* ATTR_CMN_NAME</rant>
*/
if (dnp && cnp && (vp != NFSTOV(dnp))) {
int update_flags = (vnode_ismonitored((NFSTOV(dnp)))) ? VNODE_UPDATE_CACHE : 0;
int (*cmp)(const char *s1, const char *s2, size_t n);
cmp = nfs_case_insensitive(mp) ? strncasecmp : strncmp;
if (vp->v_name && cnp->cn_namelen && (*cmp)(cnp->cn_nameptr, vp->v_name, cnp->cn_namelen))
update_flags |= VNODE_UPDATE_NAME;
if ((vp->v_name == NULL && cnp->cn_namelen != 0) || (vp->v_name != NULL && cnp->cn_namelen == 0))
update_flags |= VNODE_UPDATE_NAME;
if (vnode_parent(vp) != NFSTOV(dnp))
update_flags |= VNODE_UPDATE_PARENT;
if (update_flags) {
NFS_NODE_DBG("vnode_update_identity old name %s new name %.*s update flags = %x\n",
vp->v_name, cnp->cn_namelen, cnp->cn_nameptr ? cnp->cn_nameptr : "", update_flags);
vnode_update_identity(vp, NFSTOV(dnp), cnp->cn_nameptr, cnp->cn_namelen, 0, update_flags);
}
}
*npp = np;
}
FSDBG_BOT(263, dnp, *npp, 0xcace0000, error);
return(error);
}
FSDBG(263, mp, dnp, npp, 0xaaaaaaaa);
if (flags & NG_NOCREATE) {
lck_mtx_unlock(nfs_node_hash_mutex);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000001, ENOENT);
return (ENOENT);
}
/*
* allocate and initialize nfsnode and stick it in the hash
* before calling getnewvnode(). Anyone finding it in the
* hash before initialization is complete will wait for it.
*/
MALLOC_ZONE(np, nfsnode_t, sizeof *np, M_NFSNODE, M_WAITOK);
if (!np) {
lck_mtx_unlock(nfs_node_hash_mutex);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000001, ENOMEM);
return (ENOMEM);
}
bzero(np, sizeof *np);
np->n_hflag |= (NHINIT | NHLOCKED);
np->n_mount = mp;
np->n_auth = auth;
TAILQ_INIT(&np->n_opens);
TAILQ_INIT(&np->n_lock_owners);
TAILQ_INIT(&np->n_locks);
np->n_dlink.tqe_next = NFSNOLIST;
np->n_dreturn.tqe_next = NFSNOLIST;
np->n_monlink.le_next = NFSNOLIST;
/* ugh... need to keep track of ".zfs" directories to workaround server bugs */
if ((nvap->nva_type == VDIR) && cnp && (cnp->cn_namelen == 4) &&
(cnp->cn_nameptr[0] == '.') && (cnp->cn_nameptr[1] == 'z') &&
(cnp->cn_nameptr[2] == 'f') && (cnp->cn_nameptr[3] == 's'))
np->n_flag |= NISDOTZFS;
if (dnp && (dnp->n_flag & NISDOTZFS))
np->n_flag |= NISDOTZFSCHILD;
if (dnp && cnp && ((cnp->cn_namelen != 2) ||
(cnp->cn_nameptr[0] != '.') || (cnp->cn_nameptr[1] != '.'))) {
vnode_t dvp = NFSTOV(dnp);
if (!vnode_get(dvp)) {
if (!vnode_ref(dvp))
np->n_parent = dvp;
vnode_put(dvp);
}
}
/* setup node's file handle */
if (fhsize > NFS_SMALLFH) {
MALLOC_ZONE(np->n_fhp, u_char *,
fhsize, M_NFSBIGFH, M_WAITOK);
if (!np->n_fhp) {
lck_mtx_unlock(nfs_node_hash_mutex);
FREE_ZONE(np, sizeof *np, M_NFSNODE);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000002, ENOMEM);
return (ENOMEM);
}
} else {
__private_extern__
int
fuse_internal_access(vnode_t vp,
int action,
vfs_context_t context,
struct fuse_access_param *facp)
{
int err = 0;
int default_error = 0;
uint32_t mask = 0;
int dataflags;
mount_t mp;
struct fuse_dispatcher fdi;
struct fuse_access_in *fai;
struct fuse_data *data;
fuse_trace_printf_func();
mp = vnode_mount(vp);
data = fuse_get_mpdata(mp);
dataflags = data->dataflags;
/* Allow for now; let checks be handled inline later. */
if (fuse_isdeferpermissions_mp(mp)) {
return 0;
}
if (facp->facc_flags & FACCESS_FROM_VNOP) {
default_error = ENOTSUP;
}
/*
* (action & KAUTH_VNODE_GENERIC_WRITE_BITS) on a read-only file system
* would have been handled by higher layers.
*/
if (!fuse_implemented(data, FSESS_NOIMPLBIT(ACCESS))) {
return default_error;
}
/* Unless explicitly permitted, deny everyone except the fs owner. */
if (!vnode_isvroot(vp) && !(facp->facc_flags & FACCESS_NOCHECKSPY)) {
if (!(dataflags & FSESS_ALLOW_OTHER)) {
int denied = fuse_match_cred(data->daemoncred,
vfs_context_ucred(context));
if (denied) {
return EPERM;
}
}
facp->facc_flags |= FACCESS_NOCHECKSPY;
}
if (!(facp->facc_flags & FACCESS_DO_ACCESS)) {
return default_error;
}
if (vnode_isdir(vp)) {
if (action & (KAUTH_VNODE_LIST_DIRECTORY |
KAUTH_VNODE_READ_EXTATTRIBUTES)) {
mask |= R_OK;
}
if (action & (KAUTH_VNODE_ADD_FILE |
KAUTH_VNODE_ADD_SUBDIRECTORY |
KAUTH_VNODE_DELETE_CHILD)) {
mask |= W_OK;
}
if (action & KAUTH_VNODE_SEARCH) {
mask |= X_OK;
}
} else {
if (action & (KAUTH_VNODE_READ_DATA | KAUTH_VNODE_READ_EXTATTRIBUTES)) {
mask |= R_OK;
}
if (action & (KAUTH_VNODE_WRITE_DATA | KAUTH_VNODE_APPEND_DATA)) {
mask |= W_OK;
}
if (action & KAUTH_VNODE_EXECUTE) {
mask |= X_OK;
}
}
if (action & (KAUTH_VNODE_WRITE_ATTRIBUTES |
KAUTH_VNODE_WRITE_EXTATTRIBUTES |
KAUTH_VNODE_WRITE_SECURITY)) {
mask |= W_OK;
}
bzero(&fdi, sizeof(fdi));
fdisp_init(&fdi, sizeof(*fai));
fdisp_make_vp(&fdi, FUSE_ACCESS, vp, context);
fai = fdi.indata;
fai->mask = F_OK;
fai->mask |= mask;
if (!(err = fdisp_wait_answ(&fdi))) {
fuse_ticket_drop(fdi.tick);
}
if (err == ENOSYS) {
/*
* Make sure we don't come in here again.
*/
vfs_clearauthopaque(mp);
fuse_clear_implemented(data, FSESS_NOIMPLBIT(ACCESS));
err = default_error;
}
if (err == ENOENT) {
const char *vname = NULL;
#if M_MACFUSE_ENABLE_UNSUPPORTED
vname = vnode_getname(vp);
#endif /* M_MACFUSE_ENABLE_UNSUPPORTED */
IOLog("MacFUSE: disappearing vnode %p (name=%s type=%d action=%x)\n",
vp, (vname) ? vname : "?", vnode_vtype(vp), action);
#if M_MACFUSE_ENABLE_UNSUPPORTED
if (vname) {
vnode_putname(vname);
}
#endif /* M_MACFUSE_ENABLE_UNSUPPORTED */
/*
* On 10.4, I think I can get Finder to lock because of /.Trashes/<uid>
* unless I use REVOKE_NONE here.
*/
#if M_MACFUSE_ENABLE_INTERIM_FSNODE_LOCK && !M_MACFUSE_ENABLE_HUGE_LOCK
fuse_biglock_unlock(data->biglock);
#endif
fuse_internal_vnode_disappear(vp, context, REVOKE_SOFT);
#if M_MACFUSE_ENABLE_INTERIM_FSNODE_LOCK && !M_MACFUSE_ENABLE_HUGE_LOCK
fuse_biglock_lock(data->biglock);
#endif
}
return err;
}
/*
* Because of the vagaries of how a filehandle can be used, we try not to
* be too smart in here (we try to be smart elsewhere). It is required that
* you come in here only if you really do not have the said filehandle--else
* we panic.
*
* This function should be called with fufh_mtx mutex locked.
*/
int
fuse_filehandle_get(vnode_t vp,
vfs_context_t context,
fufh_type_t fufh_type,
int mode)
{
struct fuse_dispatcher fdi;
struct fuse_open_in *foi;
struct fuse_open_out *foo;
struct fuse_filehandle *fufh;
struct fuse_vnode_data *fvdat = VTOFUD(vp);
int err = 0;
int oflags = 0;
int op = FUSE_OPEN;
fuse_trace_printf("fuse_filehandle_get(vp=%p, fufh_type=%d, mode=%x)\n",
vp, fufh_type, mode);
fufh = &(fvdat->fufh[fufh_type]);
if (FUFH_IS_VALID(fufh)) {
panic("fuse4x: filehandle_get called despite valid fufh (type=%d)",
fufh_type);
/* NOTREACHED */
}
/*
* Note that this means we are effectively FILTERING OUT open() flags.
*/
oflags = fuse_filehandle_xlate_to_oflags(fufh_type);
if (vnode_isdir(vp)) {
op = FUSE_OPENDIR;
if (fufh_type != FUFH_RDONLY) {
log("fuse4x: non-rdonly fufh requested for directory\n");
fufh_type = FUFH_RDONLY;
}
}
fuse_dispatcher_init(&fdi, sizeof(*foi));
fuse_dispatcher_make_vp(&fdi, op, vp, context);
if (vnode_islnk(vp) && (mode & O_SYMLINK)) {
oflags |= O_SYMLINK;
}
foi = fdi.indata;
foi->flags = oflags;
OSIncrementAtomic((SInt32 *)&fuse_fh_upcall_count);
if ((err = fuse_dispatcher_wait_answer(&fdi))) {
const char *vname = vnode_getname(vp);
if (err == ENOENT) {
/*
* See comment in fuse_vnop_reclaim().
*/
cache_purge(vp);
}
log("fuse4x: filehandle_get: failed for %s "
"(type=%d, err=%d, caller=%p)\n",
(vname) ? vname : "?", fufh_type, err,
__builtin_return_address(0));
if (vname) {
vnode_putname(vname);
}
if (err == ENOENT) {
fuse_vncache_purge(vp);
}
return err;
}
OSIncrementAtomic((SInt32 *)&fuse_fh_current);
foo = fdi.answer;
fufh->fh_id = foo->fh;
fufh->open_count = 1;
fufh->open_flags = oflags;
fufh->fuse_open_flags = foo->open_flags;
fuse_ticket_drop(fdi.ticket);
return 0;
}
