int
fuse_internal_fsync(struct vnode *vp,
struct thread *td,
struct ucred *cred,
struct fuse_filehandle *fufh)
{
int op = FUSE_FSYNC;
struct fuse_fsync_in *ffsi;
struct fuse_dispatcher fdi;
fuse_trace_printf_func();
if (vnode_isdir(vp)) {
op = FUSE_FSYNCDIR;
}
fdisp_init(&fdi, sizeof(*ffsi));
fdisp_make_vp(&fdi, op, vp, td, cred);
ffsi = fdi.indata;
ffsi->fh = fufh->fh_id;
ffsi->fsync_flags = 1; /* datasync */
fuse_insert_callback(fdi.tick, fuse_internal_fsync_callback);
fuse_insert_message(fdi.tick);
fdisp_destroy(&fdi);
return 0;
}
__private_extern__
int
fuse_internal_send_init(struct fuse_data *data, vfs_context_t context)
{
int err = 0;
struct fuse_init_in *fiii;
struct fuse_dispatcher fdi;
fdisp_init(&fdi, sizeof(*fiii));
fdisp_make(&fdi, FUSE_INIT, data->mp, 0, context);
fiii = fdi.indata;
fiii->major = FUSE_KERNEL_VERSION;
fiii->minor = FUSE_KERNEL_MINOR_VERSION;
fiii->max_readahead = data->iosize * 16;
fiii->flags = 0;
/* blocking FUSE_INIT up to user space */
err = fdisp_wait_answ(&fdi);
if (err) {
IOLog("MacFUSE: user-space initialization failed (%d)\n", err);
return err;
}
err = fuse_internal_init_synchronous(fdi.tick);
if (err) {
IOLog("MacFUSE: in-kernel initialization failed (%d)\n", err);
return err;
}
return 0;
}
__private_extern__
int
fuse_internal_newentry(vnode_t dvp,
vnode_t *vpp,
struct componentname *cnp,
enum fuse_opcode op,
void *buf,
size_t bufsize,
enum vtype vtype,
vfs_context_t context)
{
int err;
struct fuse_dispatcher fdi;
mount_t mp = vnode_mount(dvp);
if (fuse_skip_apple_double_mp(mp, cnp->cn_nameptr, cnp->cn_namelen)) {
return EACCES;
}
fdisp_init(&fdi, 0);
fuse_internal_newentry_makerequest(mp, VTOI(dvp), cnp, op, buf,
bufsize, &fdi, context);
err = fuse_internal_newentry_core(dvp, vpp, cnp, vtype, &fdi, context);
fuse_invalidate_attr(dvp);
return err;
}
int
fuse_internal_rename(struct vnode *fdvp,
struct componentname *fcnp,
struct vnode *tdvp,
struct componentname *tcnp)
{
struct fuse_dispatcher fdi;
struct fuse_rename_in *fri;
int err = 0;
fdisp_init(&fdi, sizeof(*fri) + fcnp->cn_namelen + tcnp->cn_namelen + 2);
fdisp_make_vp(&fdi, FUSE_RENAME, fdvp, tcnp->cn_thread, tcnp->cn_cred);
fri = fdi.indata;
fri->newdir = VTOI(tdvp);
memcpy((char *)fdi.indata + sizeof(*fri), fcnp->cn_nameptr,
fcnp->cn_namelen);
((char *)fdi.indata)[sizeof(*fri) + fcnp->cn_namelen] = '\0';
memcpy((char *)fdi.indata + sizeof(*fri) + fcnp->cn_namelen + 1,
tcnp->cn_nameptr, tcnp->cn_namelen);
((char *)fdi.indata)[sizeof(*fri) + fcnp->cn_namelen +
tcnp->cn_namelen + 1] = '\0';
err = fdisp_wait_answ(&fdi);
fdisp_destroy(&fdi);
return err;
}
void
fuse_internal_forget_send(struct mount *mp,
struct thread *td,
struct ucred *cred,
uint64_t nodeid,
uint64_t nlookup)
{
struct fuse_dispatcher fdi;
struct fuse_forget_in *ffi;
debug_printf("mp=%p, nodeid=%ju, nlookup=%ju\n",
mp, (uintmax_t)nodeid, (uintmax_t)nlookup);
/*
* KASSERT(nlookup > 0, ("zero-times forget for vp #%llu",
* (long long unsigned) nodeid));
*/
fdisp_init(&fdi, sizeof(*ffi));
fdisp_make(&fdi, FUSE_FORGET, mp, nodeid, td, cred);
ffi = fdi.indata;
ffi->nlookup = nlookup;
fuse_insert_message(fdi.tick);
fdisp_destroy(&fdi);
}
int
fuse_filehandle_open(struct vnode *vp,
fufh_type_t fufh_type,
struct fuse_filehandle **fufhp,
struct thread *td,
struct ucred *cred)
{
struct fuse_dispatcher fdi;
struct fuse_open_in *foi;
struct fuse_open_out *foo;
int err = 0;
int isdir = 0;
int oflags = 0;
int op = FUSE_OPEN;
fuse_trace_printf("fuse_filehandle_open(vp=%p, fufh_type=%d)\n",
vp, fufh_type);
if (fuse_filehandle_valid(vp, fufh_type)) {
panic("FUSE: filehandle_open 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)) {
isdir = 1;
op = FUSE_OPENDIR;
if (fufh_type != FUFH_RDONLY) {
printf("FUSE:non-rdonly fh requested for a directory?\n");
fufh_type = FUFH_RDONLY;
}
}
fdisp_init(&fdi, sizeof(*foi));
fdisp_make_vp(&fdi, op, vp, td, cred);
foi = fdi.indata;
foi->flags = oflags;
if ((err = fdisp_wait_answ(&fdi))) {
debug_printf("OUCH ... daemon didn't give fh (err = %d)\n", err);
if (err == ENOENT) {
fuse_internal_vnode_disappear(vp);
}
goto out;
}
foo = fdi.answ;
fuse_filehandle_init(vp, fufh_type, fufhp, foo->fh);
fuse_vnode_open(vp, foo->open_flags, td);
out:
fdisp_destroy(&fdi);
return err;
}
int
fuse_filehandle_put(vnode_t vp, vfs_context_t context, fufh_type_t fufh_type)
{
struct fuse_dispatcher fdi;
struct fuse_release_in *fri;
struct fuse_vnode_data *fvdat = VTOFUD(vp);
struct fuse_filehandle *fufh = NULL;
int err = 0;
int isdir = 0;
int op = FUSE_RELEASE;
const bool wait_for_completion = true;
fuse_trace_printf("fuse_filehandle_put(vp=%p, fufh_type=%d)\n",
vp, fufh_type);
fufh = &(fvdat->fufh[fufh_type]);
if (FUFH_IS_VALID(fufh)) {
panic("fuse4x: filehandle_put called on a valid fufh (type=%d)",
fufh_type);
/* NOTREACHED */
}
if (fuse_isdeadfs(vp)) {
goto out;
}
if (vnode_isdir(vp)) {
op = FUSE_RELEASEDIR;
isdir = 1;
}
fdisp_init(&fdi, sizeof(*fri));
fdisp_make_vp(&fdi, op, vp, context);
fri = fdi.indata;
fri->fh = fufh->fh_id;
fri->flags = fufh->open_flags;
if (wait_for_completion) {
if ((err = fdisp_wait_answ(&fdi))) {
goto out;
} else {
fuse_ticket_drop(fdi.tick);
}
} else {
fuse_insert_callback(fdi.tick, NULL);
fuse_insert_message(fdi.tick);
}
out:
OSAddAtomic(-1, (SInt32 *)&fuse_fh_current);
fuse_invalidate_attr(vp);
return err;
}
__private_extern__
int
fuse_internal_remove(vnode_t dvp,
vnode_t vp,
struct componentname *cnp,
enum fuse_opcode op,
vfs_context_t context)
{
struct fuse_dispatcher fdi;
struct vnode_attr *vap = VTOVA(vp);
int need_invalidate = 0;
uint64_t target_nlink = 0;
mount_t mp = vnode_mount(vp);
int err = 0;
fdisp_init(&fdi, cnp->cn_namelen + 1);
fdisp_make_vp(&fdi, op, dvp, context);
memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
((char *)fdi.indata)[cnp->cn_namelen] = '\0';
if ((vap->va_nlink > 1) && vnode_isreg(vp)) {
need_invalidate = 1;
target_nlink = vap->va_nlink;
}
if (!(err = fdisp_wait_answ(&fdi))) {
fuse_ticket_drop(fdi.tick);
}
fuse_invalidate_attr(dvp);
fuse_invalidate_attr(vp);
/*
* XXX: M_MACFUSE_INVALIDATE_CACHED_VATTRS_UPON_UNLINK
*
* Consider the case where vap->va_nlink > 1 for the entity being
* removed. In our world, other in-memory vnodes that share a link
* count each with this one may not know right way that this one just
* got deleted. We should let them know, say, through a vnode_iterate()
* here and a callback that does fuse_invalidate_attr(vp) on each
* relevant vnode.
*/
if (need_invalidate && !err) {
if (!vfs_busy(mp, LK_NOWAIT)) {
vnode_iterate(mp, 0, fuse_internal_remove_callback,
(void *)&target_nlink);
vfs_unbusy(mp);
} else {
IOLog("MacFUSE: skipping link count fixup upon remove\n");
}
}
return err;
}
int
fuse_internal_remove(struct vnode *dvp,
struct vnode *vp,
struct componentname *cnp,
enum fuse_opcode op)
{
struct fuse_dispatcher fdi;
struct vattr *vap = VTOVA(vp);
#if INVALIDATE_CACHED_VATTRS_UPON_UNLINK
int need_invalidate = 0;
uint64_t target_nlink = 0;
#endif
int err = 0;
debug_printf("dvp=%p, cnp=%p, op=%d\n", vp, cnp, op);
fdisp_init(&fdi, cnp->cn_namelen + 1);
fdisp_make_vp(&fdi, op, dvp, cnp->cn_thread, cnp->cn_cred);
memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
((char *)fdi.indata)[cnp->cn_namelen] = '\0';
#if INVALIDATE_CACHED_VATTRS_UPON_UNLINK
if (vap->va_nlink > 1) {
need_invalidate = 1;
target_nlink = vap->va_nlink;
}
#endif
err = fdisp_wait_answ(&fdi);
fdisp_destroy(&fdi);
fuse_invalidate_attr(dvp);
fuse_invalidate_attr(vp);
#ifdef XXXIP
/*
* XXX: INVALIDATE_CACHED_VATTRS_UPON_UNLINK
*
* Consider the case where vap->va_nlink > 1 for the entity being
* removed. In our world, other in-memory vnodes that share a link
* count each with this one may not know right way that this one just
* got deleted. We should let them know, say, through a vnode_iterate()
* here and a callback that does fuse_invalidate_attr(vp) on each
* relevant vnode.
*/
if (need_invalidate && !err) {
vnode_iterate(vnode_mount(vp), 0, fuse_internal_remove_callback,
(void *)&target_nlink);
}
#endif
return err;
}
__private_extern__
int
fuse_internal_readdir(vnode_t vp,
uio_t uio,
vfs_context_t context,
struct fuse_filehandle *fufh,
struct fuse_iov *cookediov,
int *numdirent)
{
int err = 0;
struct fuse_dispatcher fdi;
struct fuse_read_in *fri;
struct fuse_data *data;
if (uio_resid(uio) == 0) {
return 0;
}
fdisp_init(&fdi, 0);
/* Note that we DO NOT have a UIO_SYSSPACE here (so no need for p2p I/O). */
while (uio_resid(uio) > 0) {
fdi.iosize = sizeof(*fri);
fdisp_make_vp(&fdi, FUSE_READDIR, vp, context);
fri = fdi.indata;
fri->fh = fufh->fh_id;
fri->offset = uio_offset(uio);
data = fuse_get_mpdata(vnode_mount(vp));
fri->size = (typeof(fri->size))min((size_t)uio_resid(uio), data->iosize);
if ((err = fdisp_wait_answ(&fdi))) {
goto out;
}
if ((err = fuse_internal_readdir_processdata(vp,
uio,
fri->size,
fdi.answ,
fdi.iosize,
cookediov,
numdirent))) {
break;
}
}
/* done: */
fuse_ticket_drop(fdi.tick);
out:
return ((err == -1) ? 0 : err);
}
int
fuse_vnode_savesize(struct vnode *vp, struct ucred *cred)
{
struct fuse_vnode_data *fvdat = VTOFUD(vp);
struct thread *td = curthread;
struct fuse_filehandle *fufh = NULL;
struct fuse_dispatcher fdi;
struct fuse_setattr_in *fsai;
int err = 0;
DEBUG("inode=%jd size=%jd\n", VTOI(vp), fvdat->filesize);
ASSERT_VOP_ELOCKED(vp, "fuse_io_extend");
if (fuse_isdeadfs(vp)) {
return EBADF;
}
if (vnode_vtype(vp) == VDIR) {
return EISDIR;
}
if (vfs_isrdonly(vnode_mount(vp))) {
return EROFS;
}
if (cred == NULL) {
cred = td->td_ucred;
}
fdisp_init(&fdi, sizeof(*fsai));
fdisp_make_vp(&fdi, FUSE_SETATTR, vp, td, cred);
fsai = fdi.indata;
fsai->valid = 0;
// Truncate to a new value.
fsai->size = fvdat->filesize;
fsai->valid |= FATTR_SIZE;
fuse_filehandle_getrw(vp, FUFH_WRONLY, &fufh);
if (fufh) {
fsai->fh = fufh->fh_id;
fsai->valid |= FATTR_FH;
}
err = fdisp_wait_answ(&fdi);
fdisp_destroy(&fdi);
if (err == 0)
fvdat->flag &= ~FN_SIZECHANGE;
fuse_invalidate_attr(vp);
return err;
}
static int
fuse_read_directbackend(struct vnode *vp, struct uio *uio,
struct ucred *cred, struct fuse_filehandle *fufh)
{
struct fuse_dispatcher fdi;
struct fuse_read_in *fri;
int err = 0;
if (uio->uio_resid == 0)
return (0);
fdisp_init(&fdi, 0);
/*
* XXX In "normal" case we use an intermediate kernel buffer for
* transmitting data from daemon's context to ours. Eventually, we should
* get rid of this. Anyway, if the target uio lives in sysspace (we are
* called from pageops), and the input data doesn't need kernel-side
* processing (we are not called from readdir) we can already invoke
* an optimized, "peer-to-peer" I/O routine.
*/
while (uio->uio_resid > 0) {
fdi.iosize = sizeof(*fri);
fdisp_make_vp(&fdi, FUSE_READ, vp, uio->uio_td, cred);
fri = fdi.indata;
fri->fh = fufh->fh_id;
fri->offset = uio->uio_offset;
fri->size = MIN(uio->uio_resid,
fuse_get_mpdata(vp->v_mount)->max_read);
FS_DEBUG2G("fri->fh %ju, fri->offset %ju, fri->size %ju\n",
(uintmax_t)fri->fh, (uintmax_t)fri->offset,
(uintmax_t)fri->size);
if ((err = fdisp_wait_answ(&fdi)))
goto out;
FS_DEBUG2G("complete: got iosize=%d, requested fri.size=%zd; "
"resid=%zd offset=%ju\n",
fri->size, fdi.iosize, uio->uio_resid,
(uintmax_t)uio->uio_offset);
if ((err = uiomove(fdi.answ, MIN(fri->size, fdi.iosize), uio)))
break;
if (fdi.iosize < fri->size)
break;
}
out:
fdisp_destroy(&fdi);
return (err);
}
static int
fuse_sync_callback(vnode_t vp, void *cargs)
{
int type;
struct fuse_sync_cargs *args;
struct fuse_vnode_data *fvdat;
struct fuse_dispatcher fdi;
struct fuse_filehandle *fufh;
struct fuse_data *data;
mount_t mp;
if (!vnode_hasdirtyblks(vp)) {
return VNODE_RETURNED;
}
mp = vnode_mount(vp);
if (fuse_isdeadfs_mp(mp)) {
return VNODE_RETURNED_DONE;
}
data = fuse_get_mpdata(mp);
if (!fuse_implemented(data, (vnode_isdir(vp)) ?
FSESS_NOIMPLBIT(FSYNCDIR) : FSESS_NOIMPLBIT(FSYNC))) {
return VNODE_RETURNED;
}
args = (struct fuse_sync_cargs *)cargs;
fvdat = VTOFUD(vp);
cluster_push(vp, 0);
fdisp_init(&fdi, 0);
for (type = 0; type < FUFH_MAXTYPE; type++) {
fufh = &(fvdat->fufh[type]);
if (FUFH_IS_VALID(fufh)) {
(void)fuse_internal_fsync(vp, args->context, fufh, &fdi,
FUSE_OP_FOREGROUNDED);
}
}
/*
* In general:
*
* - can use vnode_isinuse() if the need be
* - vnode and UBC are in lock-step
* - note that umount will call ubc_sync_range()
*/
return VNODE_RETURNED;
}
static int
fuse_write_directbackend(struct vnode *vp, struct uio *uio,
struct ucred *cred, struct fuse_filehandle *fufh, int ioflag)
{
struct fuse_vnode_data *fvdat = VTOFUD(vp);
struct fuse_write_in *fwi;
struct fuse_dispatcher fdi;
size_t chunksize;
int diff;
int err = 0;
if (uio->uio_resid == 0)
return (0);
if (ioflag & IO_APPEND)
uio_setoffset(uio, fvdat->filesize);
fdisp_init(&fdi, 0);
while (uio->uio_resid > 0) {
chunksize = MIN(uio->uio_resid,
fuse_get_mpdata(vp->v_mount)->max_write);
fdi.iosize = sizeof(*fwi) + chunksize;
fdisp_make_vp(&fdi, FUSE_WRITE, vp, uio->uio_td, cred);
fwi = fdi.indata;
fwi->fh = fufh->fh_id;
fwi->offset = uio->uio_offset;
fwi->size = chunksize;
if ((err = uiomove((char *)fdi.indata + sizeof(*fwi),
chunksize, uio)))
break;
if ((err = fdisp_wait_answ(&fdi)))
break;
diff = chunksize - ((struct fuse_write_out *)fdi.answ)->size;
if (diff < 0) {
err = EINVAL;
break;
}
uio->uio_resid += diff;
uio->uio_offset -= diff;
if (uio->uio_offset > fvdat->filesize)
fuse_vnode_setsize(vp, cred, uio->uio_offset);
}
fdisp_destroy(&fdi);
return (err);
}
int
fuse_filehandle_close(struct vnode *vp,
fufh_type_t fufh_type,
struct thread *td,
struct ucred *cred)
{
struct fuse_dispatcher fdi;
struct fuse_release_in *fri;
struct fuse_vnode_data *fvdat = VTOFUD(vp);
struct fuse_filehandle *fufh = NULL;
int err = 0;
int isdir = 0;
int op = FUSE_RELEASE;
fuse_trace_printf("fuse_filehandle_put(vp=%p, fufh_type=%d)\n",
vp, fufh_type);
fufh = &(fvdat->fufh[fufh_type]);
if (!FUFH_IS_VALID(fufh)) {
panic("FUSE: filehandle_put called on invalid fufh (type=%d)",
fufh_type);
/* NOTREACHED */
}
if (fuse_isdeadfs(vp)) {
goto out;
}
if (vnode_isdir(vp)) {
op = FUSE_RELEASEDIR;
isdir = 1;
}
fdisp_init(&fdi, sizeof(*fri));
fdisp_make_vp(&fdi, op, vp, td, cred);
fri = fdi.indata;
fri->fh = fufh->fh_id;
fri->flags = fuse_filehandle_xlate_to_oflags(fufh_type);
err = fdisp_wait_answ(&fdi);
fdisp_destroy(&fdi);
out:
atomic_subtract_acq_int(&fuse_fh_count, 1);
fufh->fh_id = (uint64_t)-1;
fufh->fh_type = FUFH_INVALID;
fuse_invalidate_attr(vp);
return err;
}
__private_extern__
void
fuse_internal_interrupt_send(struct fuse_ticket *ftick)
{
struct fuse_dispatcher fdi;
struct fuse_interrupt_in *fii;
fdi.tick = ftick;
fdisp_init(&fdi, sizeof(*fii));
fdisp_make(&fdi, FUSE_INTERRUPT, ftick->tk_data->mp, (uint64_t)0,
(vfs_context_t)0);
fii = fdi.indata;
fii->unique = ftick->tk_unique;
fticket_invalidate(fdi.tick);
fuse_insert_message(fdi.tick);
}
void
fuse_internal_send_init(struct fuse_data *data, struct thread *td)
{
struct fuse_init_in *fiii;
struct fuse_dispatcher fdi;
fdisp_init(&fdi, sizeof(*fiii));
fdisp_make(&fdi, FUSE_INIT, data->mp, 0, td, NULL);
fiii = fdi.indata;
fiii->major = FUSE_KERNEL_VERSION;
fiii->minor = FUSE_KERNEL_MINOR_VERSION;
fiii->max_readahead = FUSE_DEFAULT_IOSIZE * 16;
fiii->flags = 0;
fuse_insert_callback(fdi.tick, fuse_internal_init_callback);
fuse_insert_message(fdi.tick);
fdisp_destroy(&fdi);
}
__private_extern__
void
fuse_internal_newentry_makerequest(mount_t mp,
uint64_t dnid,
struct componentname *cnp,
enum fuse_opcode op,
void *buf,
size_t bufsize,
struct fuse_dispatcher *fdip,
vfs_context_t context)
{
fdisp_init(fdip, bufsize + cnp->cn_namelen + 1);
fdisp_make(fdip, op, mp, dnid, context);
memcpy(fdip->indata, buf, bufsize);
memcpy((char *)fdip->indata + bufsize, cnp->cn_nameptr, cnp->cn_namelen);
((char *)fdip->indata)[bufsize + cnp->cn_namelen] = '\0';
}
/*
struct vnop_link_args {
struct vnode *a_tdvp;
struct vnode *a_vp;
struct componentname *a_cnp;
};
*/
static int
fuse_vnop_link(struct vop_link_args *ap)
{
struct vnode *vp = ap->a_vp;
struct vnode *tdvp = ap->a_tdvp;
struct componentname *cnp = ap->a_cnp;
struct vattr *vap = VTOVA(vp);
struct fuse_dispatcher fdi;
struct fuse_entry_out *feo;
struct fuse_link_in fli;
int err;
fuse_trace_printf_vnop();
if (fuse_isdeadfs(vp)) {
return ENXIO;
}
if (vnode_mount(tdvp) != vnode_mount(vp)) {
return EXDEV;
}
if (vap->va_nlink >= FUSE_LINK_MAX) {
return EMLINK;
}
fli.oldnodeid = VTOI(vp);
fdisp_init(&fdi, 0);
fuse_internal_newentry_makerequest(vnode_mount(tdvp), VTOI(tdvp), cnp,
FUSE_LINK, &fli, sizeof(fli), &fdi);
if ((err = fdisp_wait_answ(&fdi))) {
goto out;
}
feo = fdi.answ;
err = fuse_internal_checkentry(feo, vnode_vtype(vp));
fuse_invalidate_attr(tdvp);
fuse_invalidate_attr(vp);
out:
fdisp_destroy(&fdi);
return err;
}
/*
struct vnop_symlink_args {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
char *a_target;
};
*/
static int
fuse_vnop_symlink(struct vop_symlink_args *ap)
{
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct componentname *cnp = ap->a_cnp;
char *target = ap->a_target;
struct fuse_dispatcher fdi;
int err;
size_t len;
FS_DEBUG2G("inode=%ju name=%*s\n",
(uintmax_t)VTOI(dvp), (int)cnp->cn_namelen, cnp->cn_nameptr);
if (fuse_isdeadfs(dvp)) {
return ENXIO;
}
/*
* Unlike the other creator type calls, here we have to create a message
* where the name of the new entry comes first, and the data describing
* the entry comes second.
* Hence we can't rely on our handy fuse_internal_newentry() routine,
* but put together the message manually and just call the core part.
*/
len = strlen(target) + 1;
fdisp_init(&fdi, len + cnp->cn_namelen + 1);
fdisp_make_vp(&fdi, FUSE_SYMLINK, dvp, curthread, NULL);
memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
((char *)fdi.indata)[cnp->cn_namelen] = '\0';
memcpy((char *)fdi.indata + cnp->cn_namelen + 1, target, len);
err = fuse_internal_newentry_core(dvp, vpp, cnp, VLNK, &fdi);
fdisp_destroy(&fdi);
if (err == 0) {
fuse_invalidate_attr(dvp);
}
return err;
}
int
fuse_internal_readdir(struct vnode *vp,
struct uio *uio,
struct fuse_filehandle *fufh,
struct fuse_iov *cookediov)
{
int err = 0;
struct fuse_dispatcher fdi;
struct fuse_read_in *fri;
if (uio_resid(uio) == 0) {
return 0;
}
fdisp_init(&fdi, 0);
/*
* Note that we DO NOT have a UIO_SYSSPACE here (so no need for p2p
* I/O).
*/
while (uio_resid(uio) > 0) {
fdi.iosize = sizeof(*fri);
fdisp_make_vp(&fdi, FUSE_READDIR, vp, NULL, NULL);
fri = fdi.indata;
fri->fh = fufh->fh_id;
fri->offset = uio_offset(uio);
fri->size = min(uio_resid(uio), FUSE_DEFAULT_IOSIZE);
/* mp->max_read */
if ((err = fdisp_wait_answ(&fdi))) {
break;
}
if ((err = fuse_internal_readdir_processdata(uio, fri->size, fdi.answ,
fdi.iosize, cookediov))) {
break;
}
}
fdisp_destroy(&fdi);
return ((err == -1) ? 0 : err);
}
int
fuse_internal_newentry(struct vnode *dvp,
struct vnode **vpp,
struct componentname *cnp,
enum fuse_opcode op,
void *buf,
size_t bufsize,
enum vtype vtype)
{
int err;
struct fuse_dispatcher fdi;
struct mount *mp = vnode_mount(dvp);
fdisp_init(&fdi, 0);
fuse_internal_newentry_makerequest(mp, VTOI(dvp), cnp, op, buf,
bufsize, &fdi);
err = fuse_internal_newentry_core(dvp, vpp, cnp, vtype, &fdi);
fdisp_destroy(&fdi);
return err;
}
__private_extern__
int
fuse_internal_rename(vnode_t fdvp,
__unused vnode_t fvp,
struct componentname *fcnp,
vnode_t tdvp,
__unused vnode_t tvp,
struct componentname *tcnp,
vfs_context_t context)
{
struct fuse_dispatcher fdi;
struct fuse_rename_in *fri;
int err = 0;
fdisp_init(&fdi, sizeof(*fri) + fcnp->cn_namelen + tcnp->cn_namelen + 2);
fdisp_make_vp(&fdi, FUSE_RENAME, fdvp, context);
fri = fdi.indata;
fri->newdir = VTOI(tdvp);
memcpy((char *)fdi.indata + sizeof(*fri), fcnp->cn_nameptr,
fcnp->cn_namelen);
((char *)fdi.indata)[sizeof(*fri) + fcnp->cn_namelen] = '\0';
memcpy((char *)fdi.indata + sizeof(*fri) + fcnp->cn_namelen + 1,
tcnp->cn_nameptr, tcnp->cn_namelen);
((char *)fdi.indata)[sizeof(*fri) + fcnp->cn_namelen +
tcnp->cn_namelen + 1] = '\0';
if (!(err = fdisp_wait_answ(&fdi))) {
fuse_ticket_drop(fdi.tick);
}
if (err == 0) {
fuse_invalidate_attr(fdvp);
if (tdvp != fdvp) {
fuse_invalidate_attr(tdvp);
}
}
return err;
}
__private_extern__
void
fuse_internal_forget_send(mount_t mp,
vfs_context_t context,
uint64_t nodeid,
uint64_t nlookup,
struct fuse_dispatcher *fdip)
{
struct fuse_forget_in *ffi;
/*
* KASSERT(nlookup > 0, ("zero-times forget for vp #%llu",
* (long long unsigned) nodeid));
*/
fdisp_init(fdip, sizeof(*ffi));
fdisp_make(fdip, FUSE_FORGET, mp, nodeid, context);
ffi = fdip->indata;
ffi->nlookup = nlookup;
fticket_invalidate(fdip->tick);
fuse_insert_message(fdip->tick);
}
int
fuse_internal_remove(struct vnode *dvp,
struct vnode *vp,
struct componentname *cnp,
enum fuse_opcode op)
{
struct fuse_dispatcher fdi;
struct vattr *vap = VTOVA(vp);
#if INVALIDATE_CACHED_VATTRS_UPON_UNLINK
int need_invalidate = 0;
uint64_t target_nlink = 0;
#endif
int err = 0;
debug_printf("dvp=%p, cnp=%p, op=%d\n", vp, cnp, op);
fdisp_init(&fdi, cnp->cn_namelen + 1);
fdisp_make_vp(&fdi, op, dvp, cnp->cn_thread, cnp->cn_cred);
memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
((char *)fdi.indata)[cnp->cn_namelen] = '\0';
#if INVALIDATE_CACHED_VATTRS_UPON_UNLINK
if (vap->va_nlink > 1) {
need_invalidate = 1;
target_nlink = vap->va_nlink;
}
#endif
err = fdisp_wait_answ(&fdi);
fdisp_destroy(&fdi);
return err;
}
/*
struct vnop_readlink_args {
struct vnode *a_vp;
struct uio *a_uio;
struct ucred *a_cred;
};
*/
static int
fuse_vnop_readlink(struct vop_readlink_args *ap)
{
struct vnode *vp = ap->a_vp;
struct uio *uio = ap->a_uio;
struct ucred *cred = ap->a_cred;
struct fuse_dispatcher fdi;
int err;
FS_DEBUG2G("inode=%ju\n", (uintmax_t)VTOI(vp));
if (fuse_isdeadfs(vp)) {
return ENXIO;
}
if (!vnode_islnk(vp)) {
return EINVAL;
}
fdisp_init(&fdi, 0);
err = fdisp_simple_putget_vp(&fdi, FUSE_READLINK, vp, curthread, cred);
if (err) {
goto out;
}
if (((char *)fdi.answ)[0] == '/' &&
fuse_get_mpdata(vnode_mount(vp))->dataflags & FSESS_PUSH_SYMLINKS_IN) {
char *mpth = vnode_mount(vp)->mnt_stat.f_mntonname;
err = uiomove(mpth, strlen(mpth), uio);
}
if (!err) {
err = uiomove(fdi.answ, fdi.iosize, uio);
}
out:
fdisp_destroy(&fdi);
return err;
}
static errno_t
fuse_vfsop_getattr(mount_t mp, struct vfs_attr *attr, vfs_context_t context)
{
int err = 0;
bool deading = false, faking = false;
struct fuse_dispatcher fdi;
struct fuse_statfs_out *fsfo;
struct fuse_statfs_out faked;
struct fuse_data *data;
fuse_trace_printf_vfsop();
data = fuse_get_mpdata(mp);
if (!data) {
panic("fuse4x: no private data for mount point?");
}
if (!(data->dataflags & FSESS_INITED)) {
// coreservices process requests ATTR_VOL_CAPABILITIES on the mountpoint right before
// returning from mount() syscall. We need to fake the output because daemon might
// not be ready to response yet (and deadlock will happen).
faking = true;
goto dostatfs;
}
fdisp_init(&fdi, 0);
fdisp_make(&fdi, FUSE_STATFS, mp, FUSE_ROOT_ID, context);
if ((err = fdisp_wait_answ(&fdi))) {
// If we cannot communicate with the daemon (most likely because
// it's dead), we still want to portray that we are a bonafide
// file system so that we can be gracefully unmounted.
if (err == ENOTCONN) {
deading = faking = true;
goto dostatfs;
}
return err;
}
dostatfs:
if (faking) {
bzero(&faked, sizeof(faked));
fsfo = &faked;
} else {
fsfo = fdi.answ;
}
if (fsfo->st.bsize == 0) {
fsfo->st.bsize = FUSE_DEFAULT_IOSIZE;
}
if (fsfo->st.frsize == 0) {
fsfo->st.frsize = FUSE_DEFAULT_BLOCKSIZE;
}
/* optimal transfer block size; will go into f_iosize in the kernel */
fsfo->st.bsize = fuse_round_size(fsfo->st.bsize,
FUSE_MIN_IOSIZE, FUSE_MAX_IOSIZE);
/* file system fragment size; will go into f_bsize in the kernel */
fsfo->st.frsize = fuse_round_size(fsfo->st.frsize,
FUSE_MIN_BLOCKSIZE, FUSE_MAX_BLOCKSIZE);
/* We must have: f_iosize >= f_bsize (fsfo->st.bsize >= fsfo->st_frsize) */
if (fsfo->st.bsize < fsfo->st.frsize) {
fsfo->st.bsize = fsfo->st.frsize;
}
/*
* TBD: Possibility:
*
* For actual I/O to fuse4x's "virtual" storage device, we use
* data->blocksize and data->iosize. These are really meant to be
* constant across the lifetime of a single mount. If necessary, we
* can experiment by updating the mount point's stat with the frsize
* and bsize values we come across here.
*/
/*
* FUSE user daemon will (might) give us this:
*
* __u64 blocks; // total data blocks in the file system
* __u64 bfree; // free blocks in the file system
* __u64 bavail; // free blocks available to non-superuser
* __u64 files; // total file nodes in the file system
* __u64 ffree; // free file nodes in the file system
* __u32 bsize; // preferred/optimal file system block size
* __u32 namelen; // maximum length of filenames
* __u32 frsize; // fundamental file system block size
*
* On Mac OS X, we will map this data to struct vfs_attr as follows:
*
* Mac OS X FUSE
* -------- ----
* uint64_t f_supported <- // handled here
* uint64_t f_active <- // handled here
* uint64_t f_objcount <- -
* uint64_t f_filecount <- files
* uint64_t f_dircount <- -
* uint32_t f_bsize <- frsize
* size_t f_iosize <- bsize
* uint64_t f_blocks <- blocks
* uint64_t f_bfree <- bfree
* uint64_t f_bavail <- bavail
* uint64_t f_bused <- blocks - bfree
* uint64_t f_files <- files
* uint64_t f_ffree <- ffree
* fsid_t f_fsid <- // handled elsewhere
* uid_t f_owner <- // handled elsewhere
* ... capabilities <- // handled here
* ... attributes <- // handled here
* f_create_time <- -
* f_modify_time <- -
* f_access_time <- -
* f_backup_time <- -
* uint32_t f_fssubtype <- // daemon provides
* char *f_vol_name <- // handled here
* uint16_t f_signature <- // handled here
* uint16_t f_carbon_fsid <- // handled here
*/
VFSATTR_RETURN(attr, f_filecount, fsfo->st.files);
VFSATTR_RETURN(attr, f_bsize, fsfo->st.frsize);
VFSATTR_RETURN(attr, f_iosize, fsfo->st.bsize);
VFSATTR_RETURN(attr, f_blocks, fsfo->st.blocks);
VFSATTR_RETURN(attr, f_bfree, fsfo->st.bfree);
VFSATTR_RETURN(attr, f_bavail, fsfo->st.bavail);
VFSATTR_RETURN(attr, f_bused, (fsfo->st.blocks - fsfo->st.bfree));
VFSATTR_RETURN(attr, f_files, fsfo->st.files);
VFSATTR_RETURN(attr, f_ffree, fsfo->st.ffree);
/* f_fsid and f_owner handled elsewhere. */
/* Handle capabilities and attributes. */
handle_capabilities_and_attributes(mp, attr);
VFSATTR_RETURN(attr, f_create_time, kZeroTime);
VFSATTR_RETURN(attr, f_modify_time, kZeroTime);
VFSATTR_RETURN(attr, f_access_time, kZeroTime);
VFSATTR_RETURN(attr, f_backup_time, kZeroTime);
if (deading) {
VFSATTR_RETURN(attr, f_fssubtype, (uint32_t)FUSE_FSSUBTYPE_INVALID);
} else {
VFSATTR_RETURN(attr, f_fssubtype, data->fssubtype);
}
/* Daemon needs to pass this. */
if (VFSATTR_IS_ACTIVE(attr, f_vol_name)) {
if (data->volname[0] != 0) {
strncpy(attr->f_vol_name, data->volname, MAXPATHLEN);
attr->f_vol_name[MAXPATHLEN - 1] = 0;
VFSATTR_SET_SUPPORTED(attr, f_vol_name);
}
}
VFSATTR_RETURN(attr, f_signature, OSSwapBigToHostInt16(FUSEFS_SIGNATURE));
VFSATTR_RETURN(attr, f_carbon_fsid, 0);
if (!faking)
fuse_ticket_drop(fdi.tick);
return 0;
}
static errno_t
fuse_vfsop_unmount(mount_t mp, int mntflags, vfs_context_t context)
{
int err = 0;
int flags = 0;
fuse_device_t fdev;
struct fuse_data *data;
struct fuse_dispatcher fdi;
vnode_t fuse_rootvp = NULLVP;
fuse_trace_printf_vfsop();
if (mntflags & MNT_FORCE) {
flags |= FORCECLOSE;
}
data = fuse_get_mpdata(mp);
if (!data) {
panic("fuse4x: no mount private data in vfs_unmount");
}
#if M_FUSE4X_ENABLE_BIGLOCK
fuse_biglock_lock(data->biglock);
#endif
fdev = data->fdev;
if (fdata_dead_get(data)) {
/*
* If the file system daemon is dead, it's pointless to try to do
* any unmount-time operations that go out to user space. Therefore,
* we pretend that this is a force unmount. However, this isn't of much
* use. That's because if any non-root vnode is in use, the vflush()
* that the kernel does before calling our VFS_UNMOUNT will fail
* if the original unmount wasn't forcible already. That earlier
* vflush is called with SKIPROOT though, so it wouldn't bail out
* on the root vnode being in use.
*
* If we want, we could set FORCECLOSE here so that a non-forced
* unmount will be "upgraded" to a forced unmount if the root vnode
* is busy (you are cd'd to the mount point, for example). It's not
* quite pure to do that though.
*
* flags |= FORCECLOSE;
* log("fuse4x: forcing unmount on a dead file system\n");
*/
} else if (!(data->dataflags & FSESS_INITED)) {
flags |= FORCECLOSE;
log("fuse4x: forcing unmount on not-yet-alive file system\n");
fdata_set_dead(data);
}
fuse_rootvp = data->rootvp;
fuse_trace_printf("%s: Calling vflush(mp, fuse_rootvp, flags=0x%X);\n", __FUNCTION__, flags);
#if M_FUSE4X_ENABLE_BIGLOCK
fuse_biglock_unlock(data->biglock);
#endif
err = vflush(mp, fuse_rootvp, flags);
#if M_FUSE4X_ENABLE_BIGLOCK
fuse_biglock_lock(data->biglock);
#endif
fuse_trace_printf("%s: Done.\n", __FUNCTION__);
if (err) {
#if M_FUSE4X_ENABLE_BIGLOCK
fuse_biglock_unlock(data->biglock);
#endif
return err;
}
if (vnode_isinuse(fuse_rootvp, 1) && !(flags & FORCECLOSE)) {
#if M_FUSE4X_ENABLE_BIGLOCK
fuse_biglock_unlock(data->biglock);
#endif
return EBUSY;
}
if (fdata_dead_get(data)) {
goto alreadydead;
}
fdisp_init(&fdi, 0 /* no data to send along */);
fdisp_make(&fdi, FUSE_DESTROY, mp, FUSE_ROOT_ID, context);
fuse_trace_printf("%s: Waiting for reply from FUSE_DESTROY.\n", __FUNCTION__);
err = fdisp_wait_answ(&fdi);
fuse_trace_printf("%s: Reply received.\n", __FUNCTION__);
if (!err) {
fuse_ticket_drop(fdi.tick);
}
/*
* Note that dounmount() signals a VQ_UNMOUNT VFS event.
*/
fdata_set_dead(data);
alreadydead:
fuse_trace_printf("%s: Calling vnode_rele(fuse_rootp);\n", __FUNCTION__);
#if M_FUSE4X_ENABLE_BIGLOCK
fuse_biglock_unlock(data->biglock);
#endif
vnode_rele(fuse_rootvp); /* We got this reference in fuse_vfsop_mount(). */
#if M_FUSE4X_ENABLE_BIGLOCK
fuse_biglock_lock(data->biglock);
#endif
fuse_trace_printf("%s: Done.\n", __FUNCTION__);
data->rootvp = NULLVP;
fuse_trace_printf("%s: Calling vflush(mp, NULLVP, FORCECLOSE);\n", __FUNCTION__);
#if M_FUSE4X_ENABLE_BIGLOCK
fuse_biglock_unlock(data->biglock);
#endif
(void)vflush(mp, NULLVP, FORCECLOSE);
#if M_FUSE4X_ENABLE_BIGLOCK
fuse_biglock_lock(data->biglock);
#endif
fuse_trace_printf("%s: Done.\n", __FUNCTION__);
fuse_lck_mtx_lock(fdev->mtx);
vfs_setfsprivate(mp, NULL);
data->dataflags &= ~FSESS_MOUNTED;
OSAddAtomic(-1, (SInt32 *)&fuse_mount_count);
#if M_FUSE4X_ENABLE_BIGLOCK
fuse_biglock_unlock(data->biglock);
#endif
if (!(data->dataflags & FSESS_OPENED)) {
/* fdev->data was left for us to clean up */
fuse_device_close_final(fdev);
/* fdev->data is gone now */
}
fuse_lck_mtx_unlock(fdev->mtx);
return 0;
}
static errno_t
fuse_vfsop_setattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t context)
{
int error = 0;
fuse_trace_printf_vfsop();
kauth_cred_t cred = vfs_context_ucred(context);
if (!fuse_vfs_context_issuser(context) &&
(kauth_cred_getuid(cred) != vfs_statfs(mp)->f_owner)) {
return EACCES;
}
struct fuse_data *data = fuse_get_mpdata(mp);
if (VFSATTR_IS_ACTIVE(fsap, f_vol_name)) {
if (!fuse_implemented(data, FSESS_NOIMPLBIT(SETVOLNAME))) {
error = ENOTSUP;
goto out;
}
if (fsap->f_vol_name[0] == 0) {
error = EINVAL;
goto out;
}
size_t namelen = strlen(fsap->f_vol_name);
if (namelen >= MAXPATHLEN) {
error = ENAMETOOLONG;
goto out;
}
vnode_t root_vp;
error = fuse_vfsop_root(mp, &root_vp, context);
if (error) {
goto out;
}
struct fuse_dispatcher fdi;
fdisp_init(&fdi, namelen + 1);
fdisp_make_vp(&fdi, FUSE_SETVOLNAME, root_vp, context);
memcpy((char *)fdi.indata, fsap->f_vol_name, namelen);
((char *)fdi.indata)[namelen] = '\0';
if (!(error = fdisp_wait_answ(&fdi))) {
fuse_ticket_drop(fdi.tick);
}
(void)vnode_put(root_vp);
if (error) {
if (error == ENOSYS) {
error = ENOTSUP;
fuse_clear_implemented(data, FSESS_NOIMPLBIT(SETVOLNAME));
}
goto out;
}
copystr(fsap->f_vol_name, data->volname, MAXPATHLEN - 1, &namelen);
bzero(data->volname + namelen, MAXPATHLEN - namelen);
VFSATTR_SET_SUPPORTED(fsap, f_vol_name);
}
out:
return error;
}
/*
struct vnop_lookup_args {
struct vnodeop_desc *a_desc;
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
};
*/
int
fuse_vnop_lookup(struct vop_lookup_args *ap)
{
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct componentname *cnp = ap->a_cnp;
struct thread *td = cnp->cn_thread;
struct ucred *cred = cnp->cn_cred;
int nameiop = cnp->cn_nameiop;
int flags = cnp->cn_flags;
int wantparent = flags & (LOCKPARENT | WANTPARENT);
int islastcn = flags & ISLASTCN;
struct mount *mp = vnode_mount(dvp);
int err = 0;
int lookup_err = 0;
struct vnode *vp = NULL;
struct fuse_dispatcher fdi;
enum fuse_opcode op;
uint64_t nid;
struct fuse_access_param facp;
FS_DEBUG2G("parent_inode=%ju - %*s\n",
(uintmax_t)VTOI(dvp), (int)cnp->cn_namelen, cnp->cn_nameptr);
if (fuse_isdeadfs(dvp)) {
*vpp = NULL;
return ENXIO;
}
if (!vnode_isdir(dvp)) {
return ENOTDIR;
}
if (islastcn && vfs_isrdonly(mp) && (nameiop != LOOKUP)) {
return EROFS;
}
/*
* We do access check prior to doing anything else only in the case
* when we are at fs root (we'd like to say, "we are at the first
* component", but that's not exactly the same... nevermind).
* See further comments at further access checks.
*/
bzero(&facp, sizeof(facp));
if (vnode_isvroot(dvp)) { /* early permission check hack */
if ((err = fuse_internal_access(dvp, VEXEC, &facp, td, cred))) {
return err;
}
}
if (flags & ISDOTDOT) {
nid = VTOFUD(dvp)->parent_nid;
if (nid == 0) {
return ENOENT;
}
fdisp_init(&fdi, 0);
op = FUSE_GETATTR;
goto calldaemon;
} else if (cnp->cn_namelen == 1 && *(cnp->cn_nameptr) == '.') {
nid = VTOI(dvp);
fdisp_init(&fdi, 0);
op = FUSE_GETATTR;
goto calldaemon;
} else if (fuse_lookup_cache_enable) {
err = cache_lookup(dvp, vpp, cnp, NULL, NULL);
switch (err) {
case -1: /* positive match */
atomic_add_acq_long(&fuse_lookup_cache_hits, 1);
return 0;
case 0: /* no match in cache */
atomic_add_acq_long(&fuse_lookup_cache_misses, 1);
break;
case ENOENT: /* negative match */
/* fall through */
default:
return err;
}
}
nid = VTOI(dvp);
fdisp_init(&fdi, cnp->cn_namelen + 1);
op = FUSE_LOOKUP;
calldaemon:
fdisp_make(&fdi, op, mp, nid, td, cred);
if (op == FUSE_LOOKUP) {
memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
((char *)fdi.indata)[cnp->cn_namelen] = '\0';
}
lookup_err = fdisp_wait_answ(&fdi);
if ((op == FUSE_LOOKUP) && !lookup_err) { /* lookup call succeeded */
nid = ((struct fuse_entry_out *)fdi.answ)->nodeid;
if (!nid) {
/*
* zero nodeid is the same as "not found",
* but it's also cacheable (which we keep
* keep on doing not as of writing this)
*/
lookup_err = ENOENT;
} else if (nid == FUSE_ROOT_ID) {
lookup_err = EINVAL;
}
}
if (lookup_err &&
(!fdi.answ_stat || lookup_err != ENOENT || op != FUSE_LOOKUP)) {
fdisp_destroy(&fdi);
return lookup_err;
}
/* lookup_err, if non-zero, must be ENOENT at this point */
if (lookup_err) {
if ((nameiop == CREATE || nameiop == RENAME) && islastcn
/* && directory dvp has not been removed */ ) {
if (vfs_isrdonly(mp)) {
err = EROFS;
goto out;
}
#if 0 /* THINK_ABOUT_THIS */
if ((err = fuse_internal_access(dvp, VWRITE, cred, td, &facp))) {
goto out;
}
#endif
/*
* Possibly record the position of a slot in the
* directory large enough for the new component name.
* This can be recorded in the vnode private data for
* dvp. Set the SAVENAME flag to hold onto the
* pathname for use later in VOP_CREATE or VOP_RENAME.
*/
cnp->cn_flags |= SAVENAME;
err = EJUSTRETURN;
goto out;
}
/* Consider inserting name into cache. */
/*
* No we can't use negative caching, as the fs
* changes are out of our control.
* False positives' falseness turns out just as things
* go by, but false negatives' falseness doesn't.
* (and aiding the caching mechanism with extra control
* mechanisms comes quite close to beating the whole purpose
* caching...)
*/
#if 0
if ((cnp->cn_flags & MAKEENTRY) && nameiop != CREATE) {
FS_DEBUG("inserting NULL into cache\n");
cache_enter(dvp, NULL, cnp);
}
#endif
err = ENOENT;
goto out;
} else {
/* !lookup_err */
struct fuse_entry_out *feo = NULL;
struct fuse_attr *fattr = NULL;
if (op == FUSE_GETATTR) {
fattr = &((struct fuse_attr_out *)fdi.answ)->attr;
} else {
feo = (struct fuse_entry_out *)fdi.answ;
fattr = &(feo->attr);
}
/*
* If deleting, and at end of pathname, return parameters
* which can be used to remove file. If the wantparent flag
* isn't set, we return only the directory, otherwise we go on
* and lock the inode, being careful with ".".
*/
if (nameiop == DELETE && islastcn) {
/*
* Check for write access on directory.
*/
facp.xuid = fattr->uid;
facp.facc_flags |= FACCESS_STICKY;
err = fuse_internal_access(dvp, VWRITE, &facp, td, cred);
facp.facc_flags &= ~FACCESS_XQUERIES;
if (err) {
goto out;
}
if (nid == VTOI(dvp)) {
vref(dvp);
*vpp = dvp;
} else {
err = fuse_vnode_get(dvp->v_mount, nid, dvp,
&vp, cnp, IFTOVT(fattr->mode));
if (err)
goto out;
*vpp = vp;
}
/*
* Save the name for use in VOP_RMDIR and VOP_REMOVE
* later.
*/
cnp->cn_flags |= SAVENAME;
goto out;
}
/*
* If rewriting (RENAME), return the inode and the
* information required to rewrite the present directory
* Must get inode of directory entry to verify it's a
* regular file, or empty directory.
*/
if (nameiop == RENAME && wantparent && islastcn) {
#if 0 /* THINK_ABOUT_THIS */
if ((err = fuse_internal_access(dvp, VWRITE, cred, td, &facp))) {
goto out;
}
#endif
/*
* Check for "."
*/
if (nid == VTOI(dvp)) {
err = EISDIR;
goto out;
}
err = fuse_vnode_get(vnode_mount(dvp),
nid,
dvp,
&vp,
cnp,
IFTOVT(fattr->mode));
if (err) {
goto out;
}
*vpp = vp;
/*
* Save the name for use in VOP_RENAME later.
*/
cnp->cn_flags |= SAVENAME;
goto out;
}
if (flags & ISDOTDOT) {
struct mount *mp;
int ltype;
/*
* Expanded copy of vn_vget_ino() so that
* fuse_vnode_get() can be used.
*/
mp = dvp->v_mount;
ltype = VOP_ISLOCKED(dvp);
err = vfs_busy(mp, MBF_NOWAIT);
if (err != 0) {
vfs_ref(mp);
VOP_UNLOCK(dvp, 0);
err = vfs_busy(mp, 0);
vn_lock(dvp, ltype | LK_RETRY);
vfs_rel(mp);
if (err)
goto out;
if ((dvp->v_iflag & VI_DOOMED) != 0) {
err = ENOENT;
vfs_unbusy(mp);
goto out;
}
}
VOP_UNLOCK(dvp, 0);
err = fuse_vnode_get(vnode_mount(dvp),
nid,
NULL,
&vp,
cnp,
IFTOVT(fattr->mode));
vfs_unbusy(mp);
vn_lock(dvp, ltype | LK_RETRY);
if ((dvp->v_iflag & VI_DOOMED) != 0) {
if (err == 0)
vput(vp);
err = ENOENT;
}
if (err)
goto out;
*vpp = vp;
} else if (nid == VTOI(dvp)) {
vref(dvp);
*vpp = dvp;
} else {
err = fuse_vnode_get(vnode_mount(dvp),
nid,
dvp,
&vp,
cnp,
IFTOVT(fattr->mode));
if (err) {
goto out;
}
fuse_vnode_setparent(vp, dvp);
*vpp = vp;
}
if (op == FUSE_GETATTR) {
cache_attrs(*vpp, (struct fuse_attr_out *)fdi.answ);
} else {
cache_attrs(*vpp, (struct fuse_entry_out *)fdi.answ);
}
/* Insert name into cache if appropriate. */
/*
* Nooo, caching is evil. With caching, we can't avoid stale
* information taking over the playground (cached info is not
* just positive/negative, it does have qualitative aspects,
* too). And a (VOP/FUSE)_GETATTR is always thrown anyway, when
* walking down along cached path components, and that's not
* any cheaper than FUSE_LOOKUP. This might change with
* implementing kernel side attr caching, but... In Linux,
* lookup results are not cached, and the daemon is bombarded
* with FUSE_LOOKUPS on and on. This shows that by design, the
* daemon is expected to handle frequent lookup queries
* efficiently, do its caching in userspace, and so on.
*
* So just leave the name cache alone.
*/
/*
* Well, now I know, Linux caches lookups, but with a
* timeout... So it's the same thing as attribute caching:
* we can deal with it when implement timeouts.
*/
#if 0
if (cnp->cn_flags & MAKEENTRY) {
cache_enter(dvp, *vpp, cnp);
}
#endif
}
out:
if (!lookup_err) {
/* No lookup error; need to clean up. */
if (err) { /* Found inode; exit with no vnode. */
if (op == FUSE_LOOKUP) {
fuse_internal_forget_send(vnode_mount(dvp), td, cred,
nid, 1);
}
fdisp_destroy(&fdi);
return err;
} else {
#ifndef NO_EARLY_PERM_CHECK_HACK
if (!islastcn) {
/*
* We have the attributes of the next item
* *now*, and it's a fact, and we do not
* have to do extra work for it (ie, beg the
* daemon), and it neither depends on such
* accidental things like attr caching. So
* the big idea: check credentials *now*,
* not at the beginning of the next call to
* lookup.
*
* The first item of the lookup chain (fs root)
* won't be checked then here, of course, as
* its never "the next". But go and see that
* the root is taken care about at the very
* beginning of this function.
*
* Now, given we want to do the access check
* this way, one might ask: so then why not
* do the access check just after fetching
* the inode and its attributes from the
* daemon? Why bother with producing the
* corresponding vnode at all if something
* is not OK? We know what's the deal as
* soon as we get those attrs... There is
* one bit of info though not given us by
* the daemon: whether his response is
* authorative or not... His response should
* be ignored if something is mounted over
* the dir in question. But that can be
* known only by having the vnode...
*/
int tmpvtype = vnode_vtype(*vpp);
bzero(&facp, sizeof(facp));
/*the early perm check hack */
facp.facc_flags |= FACCESS_VA_VALID;
if ((tmpvtype != VDIR) && (tmpvtype != VLNK)) {
err = ENOTDIR;
}
if (!err && !vnode_mountedhere(*vpp)) {
err = fuse_internal_access(*vpp, VEXEC, &facp, td, cred);
}
if (err) {
if (tmpvtype == VLNK)
FS_DEBUG("weird, permission error with a symlink?\n");
vput(*vpp);
*vpp = NULL;
}
}
#endif
}
}
fdisp_destroy(&fdi);
return err;
}
