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_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;
}
int
fuse_filehandle_put(vnode_t vp, vfs_context_t context, fufh_type_t fufh_type,
fuse_op_waitfor_t waitfor)
{
struct fuse_data *data;
struct fuse_dispatcher fdi;
struct fuse_abi_data fri;
struct fuse_vnode_data *fvdat = VTOFUD(vp);
struct fuse_filehandle *fufh = NULL;
int err = 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("osxfuse: filehandle_put called on a valid fufh (type=%d)",
fufh_type);
/* NOTREACHED */
}
if (fuse_isdeadfs(vp)) {
goto out;
}
data = fuse_get_mpdata(vnode_mount(vp));
if (vnode_isdir(vp)) {
op = FUSE_RELEASEDIR;
}
fdisp_init_abi(&fdi, fuse_release_in, data);
fdisp_make_vp(&fdi, op, vp, context);
fuse_abi_data_init(&fri, DATOI(data), fdi.indata);
fuse_release_in_set_fh(&fri, fufh->fh_id);
fuse_release_in_set_flags(&fri, fufh->open_flags);
if (waitfor == FUSE_OP_FOREGROUNDED) {
err = fdisp_wait_answ(&fdi);
if (err) {
goto out;
}
} else {
fuse_insert_message(fdi.tick);
}
fuse_ticket_release(fdi.tick);
out:
FUSE_OSAddAtomic(-1, (SInt32 *)&fuse_fh_current);
fuse_invalidate_attr(vp);
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_fsync(vnode_t vp,
vfs_context_t context,
struct fuse_filehandle *fufh,
void *param,
fuse_op_waitfor_t waitfor)
{
int err = 0;
int op = FUSE_FSYNC;
struct fuse_fsync_in *ffsi;
struct fuse_dispatcher *fdip = param;
fuse_trace_printf_func();
fdip->iosize = sizeof(*ffsi);
fdip->tick = NULL;
if (vnode_isdir(vp)) {
op = FUSE_FSYNCDIR;
}
fdisp_make_vp(fdip, op, vp, context);
ffsi = fdip->indata;
ffsi->fh = fufh->fh_id;
ffsi->fsync_flags = 1; /* datasync */
if (waitfor == FUSE_OP_FOREGROUNDED) {
if ((err = fdisp_wait_answ(fdip))) {
if (err == ENOSYS) {
if (op == FUSE_FSYNC) {
fuse_clear_implemented(fdip->tick->tk_data,
FSESS_NOIMPLBIT(FSYNC));
} else if (op == FUSE_FSYNCDIR) {
fuse_clear_implemented(fdip->tick->tk_data,
FSESS_NOIMPLBIT(FSYNCDIR));
}
}
goto out;
} else {
fuse_ticket_drop(fdip->tick);
}
} else {
fuse_insert_callback(fdip->tick, fuse_internal_fsync_callback);
fuse_insert_message(fdip->tick);
}
out:
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_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
fdisp_wait_answ(struct fuse_dispatcher *fdip)
{
int err = 0;
fdip->answ_stat = 0;
fuse_insert_callback(fdip->tick, fuse_standard_handler);
fuse_insert_message(fdip->tick);
if ((err = fticket_wait_answer(fdip->tick))) {
debug_printf("IPC: interrupted, err = %d\n", err);
fuse_lck_mtx_lock(fdip->tick->tk_aw_mtx);
if (fticket_answered(fdip->tick)) {
/*
* Just between noticing the interrupt and getting here,
* the standard handler has completed his job.
* So we drop the ticket and exit as usual.
*/
debug_printf("IPC: already answered\n");
fuse_lck_mtx_unlock(fdip->tick->tk_aw_mtx);
goto out;
} else {
/*
* So we were faster than the standard handler.
* Then by setting the answered flag we get *him*
* to drop the ticket.
*/
debug_printf("IPC: setting to answered\n");
fticket_set_answered(fdip->tick);
fuse_lck_mtx_unlock(fdip->tick->tk_aw_mtx);
return err;
}
}
debug_printf("IPC: not interrupted, err = %d\n", err);
if (fdip->tick->tk_aw_errno) {
debug_printf("IPC: explicit EIO-ing, tk_aw_errno = %d\n",
fdip->tick->tk_aw_errno);
err = EIO;
goto out;
}
if ((err = fdip->tick->tk_aw_ohead.error)) {
debug_printf("IPC: setting status to %d\n",
fdip->tick->tk_aw_ohead.error);
/*
* This means a "proper" fuse syscall error.
* We record this value so the caller will
* be able to know it's not a boring messaging
* failure, if she wishes so (and if not, she can
* just simply propagate the return value of this routine).
* [XXX Maybe a bitflag would do the job too,
* if other flags needed, this will be converted thusly.]
*/
fdip->answ_stat = err;
goto out;
}
fdip->answ = fticket_resp(fdip->tick)->base;
fdip->iosize = fticket_resp(fdip->tick)->len;
debug_printf("IPC: all is well\n");
return 0;
out:
debug_printf("IPC: dropping ticket, err = %d\n", err);
return err;
}
/*
struct vnop_create_args {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
};
*/
static int
fuse_vnop_create(struct vop_create_args *ap)
{
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct componentname *cnp = ap->a_cnp;
struct vattr *vap = ap->a_vap;
struct thread *td = cnp->cn_thread;
struct ucred *cred = cnp->cn_cred;
struct fuse_open_in *foi;
struct fuse_entry_out *feo;
struct fuse_dispatcher fdi;
struct fuse_dispatcher *fdip = &fdi;
int err;
struct mount *mp = vnode_mount(dvp);
uint64_t parentnid = VTOFUD(dvp)->nid;
mode_t mode = MAKEIMODE(vap->va_type, vap->va_mode);
uint64_t x_fh_id;
uint32_t x_open_flags;
fuse_trace_printf_vnop();
if (fuse_isdeadfs(dvp)) {
return ENXIO;
}
bzero(&fdi, sizeof(fdi));
/* XXX: Will we ever want devices ? */
if ((vap->va_type != VREG)) {
MPASS(vap->va_type != VFIFO);
goto bringup;
}
debug_printf("parent nid = %ju, mode = %x\n", (uintmax_t)parentnid,
mode);
fdisp_init(fdip, sizeof(*foi) + cnp->cn_namelen + 1);
if (!fsess_isimpl(mp, FUSE_CREATE)) {
debug_printf("eh, daemon doesn't implement create?\n");
return (EINVAL);
}
fdisp_make(fdip, FUSE_CREATE, vnode_mount(dvp), parentnid, td, cred);
foi = fdip->indata;
foi->mode = mode;
foi->flags = O_CREAT | O_RDWR;
memcpy((char *)fdip->indata + sizeof(*foi), cnp->cn_nameptr,
cnp->cn_namelen);
((char *)fdip->indata)[sizeof(*foi) + cnp->cn_namelen] = '\0';
err = fdisp_wait_answ(fdip);
if (err) {
if (err == ENOSYS)
fsess_set_notimpl(mp, FUSE_CREATE);
debug_printf("create: got err=%d from daemon\n", err);
goto out;
}
bringup:
feo = fdip->answ;
if ((err = fuse_internal_checkentry(feo, VREG))) {
goto out;
}
err = fuse_vnode_get(mp, feo->nodeid, dvp, vpp, cnp, VREG);
if (err) {
struct fuse_release_in *fri;
uint64_t nodeid = feo->nodeid;
uint64_t fh_id = ((struct fuse_open_out *)(feo + 1))->fh;
fdisp_init(fdip, sizeof(*fri));
fdisp_make(fdip, FUSE_RELEASE, mp, nodeid, td, cred);
fri = fdip->indata;
fri->fh = fh_id;
fri->flags = OFLAGS(mode);
fuse_insert_callback(fdip->tick, fuse_internal_forget_callback);
fuse_insert_message(fdip->tick);
return err;
}
ASSERT_VOP_ELOCKED(*vpp, "fuse_vnop_create");
fdip->answ = feo + 1;
x_fh_id = ((struct fuse_open_out *)(feo + 1))->fh;
x_open_flags = ((struct fuse_open_out *)(feo + 1))->open_flags;
fuse_filehandle_init(*vpp, FUFH_RDWR, NULL, x_fh_id);
fuse_vnode_open(*vpp, x_open_flags, td);
cache_purge_negative(dvp);
out:
fdisp_destroy(fdip);
return err;
}
