fs/fuse/fuse_internal.c

/*-
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright (c) 2007-2009 Google Inc. and Amit Singh
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following disclaimer
 *   in the documentation and/or other materials provided with the
 *   distribution.
 * * Neither the name of Google Inc. nor the names of its
 *   contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Copyright (C) 2005 Csaba Henk.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/module.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/uio.h>
#include <sys/malloc.h>
#include <sys/queue.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/sx.h>
#include <sys/proc.h>
#include <sys/mount.h>
#include <sys/vnode.h>
#include <sys/namei.h>
#include <sys/stat.h>
#include <sys/unistd.h>
#include <sys/filedesc.h>
#include <sys/file.h>
#include <sys/fcntl.h>
#include <sys/dirent.h>
#include <sys/bio.h>
#include <sys/buf.h>
#include <sys/sysctl.h>
#include <sys/priv.h>

#include "fuse.h"
#include "fuse_file.h"
#include "fuse_internal.h"
#include "fuse_ipc.h"
#include "fuse_node.h"
#include "fuse_file.h"
#include "fuse_param.h"

#define FUSE_DEBUG_MODULE INTERNAL
#include "fuse_debug.h"

#ifdef ZERO_PAD_INCOMPLETE_BUFS
static int isbzero(void *buf, size_t len);

#endif

/* access */

int
fuse_internal_access(struct vnode *vp,
    mode_t mode,
    struct fuse_access_param *facp,
    struct thread *td,
    struct ucred *cred)
{
        int err = 0;
        uint32_t mask = 0;
        int dataflags;
        int vtype;
        struct mount *mp;
        struct fuse_dispatcher fdi;
        struct fuse_access_in *fai;
        struct fuse_data *data;

        /* NOT YET DONE */
        /*
         * If this vnop gives you trouble, just return 0 here for a lazy
         * kludge.
         */
        /* return 0;*/

        fuse_trace_printf_func();

        mp = vnode_mount(vp);
        vtype = vnode_vtype(vp);

        data = fuse_get_mpdata(mp);
        dataflags = data->dataflags;

        if ((mode & VWRITE) && vfs_isrdonly(mp)) {
                return EACCES;
        }
        /* Unless explicitly permitted, deny everyone except the fs owner. */
            if (vnode_isvroot(vp) && !(facp->facc_flags & FACCESS_NOCHECKSPY)) {
                if (!(dataflags & FSESS_DAEMON_CAN_SPY)) {
                        int denied = fuse_match_cred(data->daemoncred,
                            cred);

                        if (denied) {
                                return EPERM;
                        }
                }
                facp->facc_flags |= FACCESS_NOCHECKSPY;
        }
        if (!(facp->facc_flags & FACCESS_DO_ACCESS)) {
                return 0;
        }
        if (((vtype == VREG) && (mode & VEXEC))) {
#ifdef NEED_MOUNT_ARGUMENT_FOR_THIS
                /* Let   the kernel handle this through open / close heuristics.*/
                    return ENOTSUP;
#else
                    /*  Let the kernel handle this. */
                    return 0;
#endif
        }
        if (!fsess_isimpl(mp, FUSE_ACCESS)) {
                /* Let the kernel handle this. */
                    return 0;
        }
        if (dataflags & FSESS_DEFAULT_PERMISSIONS) {
                /* Let the kernel handle this. */
                    return 0;
        }
        if ((mode & VADMIN) != 0) {
                err = priv_check_cred(cred, PRIV_VFS_ADMIN, 0);
                if (err) {
                        return err;
                }
        }
        if ((mode & (VWRITE | VAPPEND | VADMIN)) != 0) {
                mask |= W_OK;
        }
        if ((mode & VREAD) != 0) {
                mask |= R_OK;
        }
        if ((mode & VEXEC) != 0) {
                mask |= X_OK;
        }
        bzero(&fdi, sizeof(fdi));

        fdisp_init(&fdi, sizeof(*fai));
        fdisp_make_vp(&fdi, FUSE_ACCESS, vp, td, cred);

        fai = fdi.indata;
        fai->mask = F_OK;
        fai->mask |= mask;

        err = fdisp_wait_answ(&fdi);
        fdisp_destroy(&fdi);

        if (err == ENOSYS) {
                fsess_set_notimpl(mp, FUSE_ACCESS);
                err = 0;
        }
        return err;
}

/* fsync */

int
fuse_internal_fsync_callback(struct fuse_ticket *tick, struct uio *uio)
{
        fuse_trace_printf_func();

        if (tick->tk_aw_ohead.error == ENOSYS) {
                fsess_set_notimpl(tick->tk_data->mp, fticket_opcode(tick));
        }
        return 0;
}

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;

}

/* readdir */

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_readdir_processdata(struct uio *uio,
    size_t reqsize,
    void *buf,
    size_t bufsize,
    void *param)
{
        int err = 0;
        int cou = 0;
        int bytesavail;
        size_t freclen;

        struct dirent *de;
        struct fuse_dirent *fudge;
        struct fuse_iov *cookediov = param;

        if (bufsize < FUSE_NAME_OFFSET) {
                return -1;
        }
        for (;;) {

                if (bufsize < FUSE_NAME_OFFSET) {
                        err = -1;
                        break;
                }
                fudge = (struct fuse_dirent *)buf;
                freclen = FUSE_DIRENT_SIZE(fudge);

                cou++;

                if (bufsize < freclen) {
                        err = ((cou == 1) ? -1 : 0);
                        break;
                }
#ifdef ZERO_PAD_INCOMPLETE_BUFS
                if (isbzero(buf, FUSE_NAME_OFFSET)) {
                        err = -1;
                        break;
                }
#endif

                if (!fudge->namelen || fudge->namelen > MAXNAMLEN) {
                        err = EINVAL;
                        break;
                }
                bytesavail = GENERIC_DIRSIZ((struct pseudo_dirent *)
                                            &fudge->namelen);

                if (bytesavail > uio_resid(uio)) {
                        err = -1;
                        break;
                }
                fiov_refresh(cookediov);
                fiov_adjust(cookediov, bytesavail);

                de = (struct dirent *)cookediov->base;
                de->d_fileno = fudge->ino;      /* XXX: truncation */
                de->d_reclen = bytesavail;
                de->d_type = fudge->type;
                de->d_namlen = fudge->namelen;
                memcpy((char *)cookediov->base + sizeof(struct dirent) - 
                       MAXNAMLEN - 1,
                       (char *)buf + FUSE_NAME_OFFSET, fudge->namelen);
                ((char *)cookediov->base)[bytesavail - 1] = '\0';

                err = uiomove(cookediov->base, cookediov->len, uio);
                if (err) {
                        break;
                }
                buf = (char *)buf + freclen;
                bufsize -= freclen;
                uio_setoffset(uio, fudge->off);
        }

        return err;
}

/* remove */

#define INVALIDATE_CACHED_VATTRS_UPON_UNLINK 1
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;
}

/* rename */

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;
}

/* strategy */

/* entity creation */

void
fuse_internal_newentry_makerequest(struct mount *mp,
    uint64_t dnid,
    struct componentname *cnp,
    enum fuse_opcode op,
    void *buf,
    size_t bufsize,
    struct fuse_dispatcher *fdip)
{
        debug_printf("fdip=%p\n", fdip);

        fdip->iosize = bufsize + cnp->cn_namelen + 1;

        fdisp_make(fdip, op, mp, dnid, cnp->cn_thread, cnp->cn_cred);
        memcpy(fdip->indata, buf, bufsize);
        memcpy((char *)fdip->indata + bufsize, cnp->cn_nameptr, cnp->cn_namelen);
        ((char *)fdip->indata)[bufsize + cnp->cn_namelen] = '\0';
}

int
fuse_internal_newentry_core(struct vnode *dvp,
    struct vnode **vpp,
    struct componentname *cnp,
    enum vtype vtyp,
    struct fuse_dispatcher *fdip)
{
        int err = 0;
        struct fuse_entry_out *feo;
        struct mount *mp = vnode_mount(dvp);

        if ((err = fdisp_wait_answ(fdip))) {
                return err;
        }
        feo = fdip->answ;

        if ((err = fuse_internal_checkentry(feo, vtyp))) {
                return err;
        }
        err = fuse_vnode_get(mp, feo->nodeid, dvp, vpp, cnp, vtyp);
        if (err) {
                fuse_internal_forget_send(mp, cnp->cn_thread, cnp->cn_cred,
                    feo->nodeid, 1);
                return err;
        }
        cache_attrs(*vpp, feo);

        return 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;
}

/* entity destruction */

int
fuse_internal_forget_callback(struct fuse_ticket *ftick, struct uio *uio)
{
        fuse_internal_forget_send(ftick->tk_data->mp, curthread, NULL,
            ((struct fuse_in_header *)ftick->tk_ms_fiov.base)->nodeid, 1);

        return 0;
}

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);
}

void
fuse_internal_vnode_disappear(struct vnode *vp)
{
        struct fuse_vnode_data *fvdat = VTOFUD(vp);

        ASSERT_VOP_ELOCKED(vp, "fuse_internal_vnode_disappear");
        fvdat->flag |= FN_REVOKED;
        cache_purge(vp);
}

/* fuse start/stop */

int
fuse_internal_init_callback(struct fuse_ticket *tick, struct uio *uio)
{
        int err = 0;
        struct fuse_data *data = tick->tk_data;
        struct fuse_init_out *fiio;

        if ((err = tick->tk_aw_ohead.error)) {
                goto out;
        }
        if ((err = fticket_pull(tick, uio))) {
                goto out;
        }
        fiio = fticket_resp(tick)->base;

        /* XXX: Do we want to check anything further besides this? */
        if (fiio->major < 7) {
                debug_printf("userpace version too low\n");
                err = EPROTONOSUPPORT;
                goto out;
        }
        data->fuse_libabi_major = fiio->major;
        data->fuse_libabi_minor = fiio->minor;

        if (fuse_libabi_geq(data, 7, 5)) {
                if (fticket_resp(tick)->len == sizeof(struct fuse_init_out)) {
                        data->max_write = fiio->max_write;
                } else {
                        err = EINVAL;
                }
        } else {
                /* Old fix values */
                data->max_write = 4096;
        }

out:
        if (err) {
                fdata_set_dead(data);
        }
        FUSE_LOCK();
        data->dataflags |= FSESS_INITED;
        wakeup(&data->ticketer);
        FUSE_UNLOCK();

        return 0;
}

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);
}

#ifdef ZERO_PAD_INCOMPLETE_BUFS
static int
isbzero(void *buf, size_t len)
{
        int i;

        for (i = 0; i < len; i++) {
                if (((char *)buf)[i])
                        return (0);
        }

        return (1);
}

#endif
1	/*-
2	* SPDX-License-Identifier: BSD-3-Clause
3	*
4	* Copyright (c) 2007-2009 Google Inc. and Amit Singh
5	* All rights reserved.
6	*
7	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions are
9	* met:
10	*
11	* * Redistributions of source code must retain the above copyright
12	* notice, this list of conditions and the following disclaimer.
13	* * Redistributions in binary form must reproduce the above
14	* copyright notice, this list of conditions and the following disclaimer
15	* in the documentation and/or other materials provided with the
16	* distribution.
17	* * Neither the name of Google Inc. nor the names of its
18	* contributors may be used to endorse or promote products derived from
19	* this software without specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32	*
33	* Copyright (C) 2005 Csaba Henk.
34	* All rights reserved.
35	*
36	* Redistribution and use in source and binary forms, with or without
37	* modification, are permitted provided that the following conditions
38	* are met:
39	* 1. Redistributions of source code must retain the above copyright
40	* notice, this list of conditions and the following disclaimer.
41	* 2. Redistributions in binary form must reproduce the above copyright
42	* notice, this list of conditions and the following disclaimer in the
43	* documentation and/or other materials provided with the distribution.
44	*
45	* THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
46	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48	* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
49	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
51	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
52	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
53	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
54	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
55	* SUCH DAMAGE.
56	*/
57
58	#include <sys/cdefs.h>
59	__FBSDID("$FreeBSD$");
60
61	#include <sys/types.h>
62	#include <sys/module.h>
63	#include <sys/systm.h>
64	#include <sys/errno.h>
65	#include <sys/param.h>
66	#include <sys/kernel.h>
67	#include <sys/conf.h>
68	#include <sys/uio.h>
69	#include <sys/malloc.h>
70	#include <sys/queue.h>
71	#include <sys/lock.h>
72	#include <sys/mutex.h>
73	#include <sys/sx.h>
74	#include <sys/proc.h>
75	#include <sys/mount.h>
76	#include <sys/vnode.h>
77	#include <sys/namei.h>
78	#include <sys/stat.h>
79	#include <sys/unistd.h>
80	#include <sys/filedesc.h>
81	#include <sys/file.h>
82	#include <sys/fcntl.h>
83	#include <sys/dirent.h>
84	#include <sys/bio.h>
85	#include <sys/buf.h>
86	#include <sys/sysctl.h>
87	#include <sys/priv.h>
88
89	#include "fuse.h"
90	#include "fuse_file.h"
91	#include "fuse_internal.h"
92	#include "fuse_ipc.h"
93	#include "fuse_node.h"
94	#include "fuse_file.h"
95	#include "fuse_param.h"
96
97	#define FUSE_DEBUG_MODULE INTERNAL
98	#include "fuse_debug.h"
99
100	#ifdef ZERO_PAD_INCOMPLETE_BUFS
101	static int isbzero(void *buf, size_t len);
102
103	#endif
104
105	/* access */
106
107	int
108	fuse_internal_access(struct vnode *vp,
109	mode_t mode,
110	struct fuse_access_param *facp,
111	struct thread *td,
112	struct ucred *cred)
113	{
114	int err = 0;
115	uint32_t mask = 0;
116	int dataflags;
117	int vtype;
118	struct mount *mp;
119	struct fuse_dispatcher fdi;
120	struct fuse_access_in *fai;
121	struct fuse_data *data;
122
123	/* NOT YET DONE */
124	/*
125	* If this vnop gives you trouble, just return 0 here for a lazy
126	* kludge.
127	*/
128	/* return 0;*/
129
130	fuse_trace_printf_func();
131
132	mp = vnode_mount(vp);
133	vtype = vnode_vtype(vp);
134
135	data = fuse_get_mpdata(mp);
136	dataflags = data->dataflags;
137
138	if ((mode & VWRITE) && vfs_isrdonly(mp)) {
139	return EACCES;
140	}
141	/* Unless explicitly permitted, deny everyone except the fs owner. */
142	if (vnode_isvroot(vp) && !(facp->facc_flags & FACCESS_NOCHECKSPY)) {
143	if (!(dataflags & FSESS_DAEMON_CAN_SPY)) {
144	int denied = fuse_match_cred(data->daemoncred,
145	cred);
146
147	if (denied) {
148	return EPERM;
149	}
150	}
151	facp->facc_flags \|= FACCESS_NOCHECKSPY;
152	}
153	if (!(facp->facc_flags & FACCESS_DO_ACCESS)) {
154	return 0;
155	}
156	if (((vtype == VREG) && (mode & VEXEC))) {
157	#ifdef NEED_MOUNT_ARGUMENT_FOR_THIS
158	/* Let the kernel handle this through open / close heuristics.*/
159	return ENOTSUP;
160	#else
161	/* Let the kernel handle this. */
162	return 0;
163	#endif
164	}
165	if (!fsess_isimpl(mp, FUSE_ACCESS)) {
166	/* Let the kernel handle this. */
167	return 0;
168	}
169	if (dataflags & FSESS_DEFAULT_PERMISSIONS) {
170	/* Let the kernel handle this. */
171	return 0;
172	}
173	if ((mode & VADMIN) != 0) {
174	err = priv_check_cred(cred, PRIV_VFS_ADMIN, 0);
175	if (err) {
176	return err;
177	}
178	}
179	if ((mode & (VWRITE \| VAPPEND \| VADMIN)) != 0) {
180	mask \|= W_OK;
181	}
182	if ((mode & VREAD) != 0) {
183	mask \|= R_OK;
184	}
185	if ((mode & VEXEC) != 0) {
186	mask \|= X_OK;
187	}
188	bzero(&fdi, sizeof(fdi));
189
190	fdisp_init(&fdi, sizeof(*fai));
191	fdisp_make_vp(&fdi, FUSE_ACCESS, vp, td, cred);
192
193	fai = fdi.indata;
194	fai->mask = F_OK;
195	fai->mask \|= mask;
196
197	err = fdisp_wait_answ(&fdi);
198	fdisp_destroy(&fdi);
199
200	if (err == ENOSYS) {
201	fsess_set_notimpl(mp, FUSE_ACCESS);
202	err = 0;
203	}
204	return err;
205	}
206
207	/* fsync */
208
209	int
210	fuse_internal_fsync_callback(struct fuse_ticket tick, struct uio uio)
211	{
212	fuse_trace_printf_func();
213
214	if (tick->tk_aw_ohead.error == ENOSYS) {
215	fsess_set_notimpl(tick->tk_data->mp, fticket_opcode(tick));
216	}
217	return 0;
218	}
219
220	int
221	fuse_internal_fsync(struct vnode *vp,
222	struct thread *td,
223	struct ucred *cred,
224	struct fuse_filehandle *fufh)
225	{
226	int op = FUSE_FSYNC;
227	struct fuse_fsync_in *ffsi;
228	struct fuse_dispatcher fdi;
229
230	fuse_trace_printf_func();
231
232	if (vnode_isdir(vp)) {
233	op = FUSE_FSYNCDIR;
234	}
235	fdisp_init(&fdi, sizeof(*ffsi));
236	fdisp_make_vp(&fdi, op, vp, td, cred);
237	ffsi = fdi.indata;
238	ffsi->fh = fufh->fh_id;
239
240	ffsi->fsync_flags = 1; /* datasync */
241
242	fuse_insert_callback(fdi.tick, fuse_internal_fsync_callback);
243	fuse_insert_message(fdi.tick);
244
245	fdisp_destroy(&fdi);
246
247	return 0;
248
249	}
250
251	/* readdir */
252
253	int
254	fuse_internal_readdir(struct vnode *vp,
255	struct uio *uio,
256	struct fuse_filehandle *fufh,
257	struct fuse_iov *cookediov)
258	{
259	int err = 0;
260	struct fuse_dispatcher fdi;
261	struct fuse_read_in *fri;
262
263	if (uio_resid(uio) == 0) {
264	return 0;
265	}
266	fdisp_init(&fdi, 0);
267
268	/*
269	* Note that we DO NOT have a UIO_SYSSPACE here (so no need for p2p
270	* I/O).
271	*/
272
273	while (uio_resid(uio) > 0) {
274
275	fdi.iosize = sizeof(*fri);
276	fdisp_make_vp(&fdi, FUSE_READDIR, vp, NULL, NULL);
277
278	fri = fdi.indata;
279	fri->fh = fufh->fh_id;
280	fri->offset = uio_offset(uio);
281	fri->size = min(uio_resid(uio), FUSE_DEFAULT_IOSIZE);
282	/* mp->max_read */
283
284	if ((err = fdisp_wait_answ(&fdi))) {
285	break;
286	}
287	if ((err = fuse_internal_readdir_processdata(uio, fri->size, fdi.answ,
288	fdi.iosize, cookediov))) {
289	break;
290	}
291	}
292
293	fdisp_destroy(&fdi);
294	return ((err == -1) ? 0 : err);
295	}
296
297	int
298	fuse_internal_readdir_processdata(struct uio *uio,
299	size_t reqsize,
300	void *buf,
301	size_t bufsize,
302	void *param)
303	{
304	int err = 0;
305	int cou = 0;
306	int bytesavail;
307	size_t freclen;
308
309	struct dirent *de;
310	struct fuse_dirent *fudge;
311	struct fuse_iov *cookediov = param;
312
313	if (bufsize < FUSE_NAME_OFFSET) {
314	return -1;
315	}
316	for (;;) {
317
318	if (bufsize < FUSE_NAME_OFFSET) {
319	err = -1;
320	break;
321	}
322	fudge = (struct fuse_dirent *)buf;
323	freclen = FUSE_DIRENT_SIZE(fudge);
324
325	cou++;
326
327	if (bufsize < freclen) {
328	err = ((cou == 1) ? -1 : 0);
329	break;
330	}
331	#ifdef ZERO_PAD_INCOMPLETE_BUFS
332	if (isbzero(buf, FUSE_NAME_OFFSET)) {
333	err = -1;
334	break;
335	}
336	#endif
337
338	if (!fudge->namelen \|\| fudge->namelen > MAXNAMLEN) {
339	err = EINVAL;
340	break;
341	}
342	bytesavail = GENERIC_DIRSIZ((struct pseudo_dirent *)
343	&fudge->namelen);
344
345	if (bytesavail > uio_resid(uio)) {
346	err = -1;
347	break;
348	}
349	fiov_refresh(cookediov);
350	fiov_adjust(cookediov, bytesavail);
351
352	de = (struct dirent *)cookediov->base;
353	de->d_fileno = fudge->ino; /* XXX: truncation */
354	de->d_reclen = bytesavail;
355	de->d_type = fudge->type;
356	de->d_namlen = fudge->namelen;
357	memcpy((char *)cookediov->base + sizeof(struct dirent) -
358	MAXNAMLEN - 1,
359	(char *)buf + FUSE_NAME_OFFSET, fudge->namelen);
360	((char *)cookediov->base)[bytesavail - 1] = '\0';
361
362	err = uiomove(cookediov->base, cookediov->len, uio);
363	if (err) {
364	break;
365	}
366	buf = (char *)buf + freclen;
367	bufsize -= freclen;
368	uio_setoffset(uio, fudge->off);
369	}
370
371	return err;
372	}
373
374	/* remove */
375
376	#define INVALIDATE_CACHED_VATTRS_UPON_UNLINK 1
377	int
378	fuse_internal_remove(struct vnode *dvp,
379	struct vnode *vp,
380	struct componentname *cnp,
381	enum fuse_opcode op)
382	{
383	struct fuse_dispatcher fdi;
384
385	struct vattr *vap = VTOVA(vp);
386
387	#if INVALIDATE_CACHED_VATTRS_UPON_UNLINK
388	int need_invalidate = 0;
389	uint64_t target_nlink = 0;
390
391	#endif
392	int err = 0;
393
394	debug_printf("dvp=%p, cnp=%p, op=%d\n", vp, cnp, op);
395
396	fdisp_init(&fdi, cnp->cn_namelen + 1);
397	fdisp_make_vp(&fdi, op, dvp, cnp->cn_thread, cnp->cn_cred);
398
399	memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
400	((char *)fdi.indata)[cnp->cn_namelen] = '\0';
401
402	#if INVALIDATE_CACHED_VATTRS_UPON_UNLINK
403	if (vap->va_nlink > 1) {
404	need_invalidate = 1;
405	target_nlink = vap->va_nlink;
406	}
407	#endif
408
409	err = fdisp_wait_answ(&fdi);
410	fdisp_destroy(&fdi);
411	return err;
412	}
413
414	/* rename */
415
416	int
417	fuse_internal_rename(struct vnode *fdvp,
418	struct componentname *fcnp,
419	struct vnode *tdvp,
420	struct componentname *tcnp)
421	{
422	struct fuse_dispatcher fdi;
423	struct fuse_rename_in *fri;
424	int err = 0;
425
426	fdisp_init(&fdi, sizeof(*fri) + fcnp->cn_namelen + tcnp->cn_namelen + 2);
427	fdisp_make_vp(&fdi, FUSE_RENAME, fdvp, tcnp->cn_thread, tcnp->cn_cred);
428
429	fri = fdi.indata;
430	fri->newdir = VTOI(tdvp);
431	memcpy((char )fdi.indata + sizeof(fri), fcnp->cn_nameptr,
432	fcnp->cn_namelen);
433	((char )fdi.indata)[sizeof(fri) + fcnp->cn_namelen] = '\0';
434	memcpy((char )fdi.indata + sizeof(fri) + fcnp->cn_namelen + 1,
435	tcnp->cn_nameptr, tcnp->cn_namelen);
436	((char )fdi.indata)[sizeof(fri) + fcnp->cn_namelen +
437	tcnp->cn_namelen + 1] = '\0';
438
439	err = fdisp_wait_answ(&fdi);
440	fdisp_destroy(&fdi);
441	return err;
442	}
443
444	/* strategy */
445
446	/* entity creation */
447
448	void
449	fuse_internal_newentry_makerequest(struct mount *mp,
450	uint64_t dnid,
451	struct componentname *cnp,
452	enum fuse_opcode op,
453	void *buf,
454	size_t bufsize,
455	struct fuse_dispatcher *fdip)
456	{
457	debug_printf("fdip=%p\n", fdip);
458
459	fdip->iosize = bufsize + cnp->cn_namelen + 1;
460
461	fdisp_make(fdip, op, mp, dnid, cnp->cn_thread, cnp->cn_cred);
462	memcpy(fdip->indata, buf, bufsize);
463	memcpy((char *)fdip->indata + bufsize, cnp->cn_nameptr, cnp->cn_namelen);
464	((char *)fdip->indata)[bufsize + cnp->cn_namelen] = '\0';
465	}
466
467	int
468	fuse_internal_newentry_core(struct vnode *dvp,
469	struct vnode **vpp,
470	struct componentname *cnp,
471	enum vtype vtyp,
472	struct fuse_dispatcher *fdip)
473	{
474	int err = 0;
475	struct fuse_entry_out *feo;
476	struct mount *mp = vnode_mount(dvp);
477
478	if ((err = fdisp_wait_answ(fdip))) {
479	return err;
480	}
481	feo = fdip->answ;
482
483	if ((err = fuse_internal_checkentry(feo, vtyp))) {
484	return err;
485	}
486	err = fuse_vnode_get(mp, feo->nodeid, dvp, vpp, cnp, vtyp);
487	if (err) {
488	fuse_internal_forget_send(mp, cnp->cn_thread, cnp->cn_cred,
489	feo->nodeid, 1);
490	return err;
491	}
492	cache_attrs(*vpp, feo);
493
494	return err;
495	}
496
497	int
498	fuse_internal_newentry(struct vnode *dvp,
499	struct vnode **vpp,
500	struct componentname *cnp,
501	enum fuse_opcode op,
502	void *buf,
503	size_t bufsize,
504	enum vtype vtype)
505	{
506	int err;
507	struct fuse_dispatcher fdi;
508	struct mount *mp = vnode_mount(dvp);
509
510	fdisp_init(&fdi, 0);
511	fuse_internal_newentry_makerequest(mp, VTOI(dvp), cnp, op, buf,
512	bufsize, &fdi);
513	err = fuse_internal_newentry_core(dvp, vpp, cnp, vtype, &fdi);
514	fdisp_destroy(&fdi);
515
516	return err;
517	}
518
519	/* entity destruction */
520
521	int
522	fuse_internal_forget_callback(struct fuse_ticket ftick, struct uio uio)
523	{
524	fuse_internal_forget_send(ftick->tk_data->mp, curthread, NULL,
525	((struct fuse_in_header *)ftick->tk_ms_fiov.base)->nodeid, 1);
526
527	return 0;
528	}
529
530	void
531	fuse_internal_forget_send(struct mount *mp,
532	struct thread *td,
533	struct ucred *cred,
534	uint64_t nodeid,
535	uint64_t nlookup)
536	{
537
538	struct fuse_dispatcher fdi;
539	struct fuse_forget_in *ffi;
540
541	debug_printf("mp=%p, nodeid=%ju, nlookup=%ju\n",
542	mp, (uintmax_t)nodeid, (uintmax_t)nlookup);
543
544	/*
545	* KASSERT(nlookup > 0, ("zero-times forget for vp #%llu",
546	* (long long unsigned) nodeid));
547	*/
548
549	fdisp_init(&fdi, sizeof(*ffi));
550	fdisp_make(&fdi, FUSE_FORGET, mp, nodeid, td, cred);
551
552	ffi = fdi.indata;
553	ffi->nlookup = nlookup;
554
555	fuse_insert_message(fdi.tick);
556	fdisp_destroy(&fdi);
557	}
558
559	void
560	fuse_internal_vnode_disappear(struct vnode *vp)
561	{
562	struct fuse_vnode_data *fvdat = VTOFUD(vp);
563
564	ASSERT_VOP_ELOCKED(vp, "fuse_internal_vnode_disappear");
565	fvdat->flag \|= FN_REVOKED;
566	cache_purge(vp);
567	}
568
569	/* fuse start/stop */
570
571	int
572	fuse_internal_init_callback(struct fuse_ticket tick, struct uio uio)
573	{
574	int err = 0;
575	struct fuse_data *data = tick->tk_data;
576	struct fuse_init_out *fiio;
577
578	if ((err = tick->tk_aw_ohead.error)) {
579	goto out;
580	}
581	if ((err = fticket_pull(tick, uio))) {
582	goto out;
583	}
584	fiio = fticket_resp(tick)->base;
585
586	/* XXX: Do we want to check anything further besides this? */
587	if (fiio->major < 7) {
588	debug_printf("userpace version too low\n");
589	err = EPROTONOSUPPORT;
590	goto out;
591	}
592	data->fuse_libabi_major = fiio->major;
593	data->fuse_libabi_minor = fiio->minor;
594
595	if (fuse_libabi_geq(data, 7, 5)) {
596	if (fticket_resp(tick)->len == sizeof(struct fuse_init_out)) {
597	data->max_write = fiio->max_write;
598	} else {
599	err = EINVAL;
600	}
601	} else {
602	/* Old fix values */
603	data->max_write = 4096;
604	}
605
606	out:
607	if (err) {
608	fdata_set_dead(data);
609	}
610	FUSE_LOCK();
611	data->dataflags \|= FSESS_INITED;
612	wakeup(&data->ticketer);
613	FUSE_UNLOCK();
614
615	return 0;
616	}
617
618	void
619	fuse_internal_send_init(struct fuse_data data, struct thread td)
620	{
621	struct fuse_init_in *fiii;
622	struct fuse_dispatcher fdi;
623
624	fdisp_init(&fdi, sizeof(*fiii));
625	fdisp_make(&fdi, FUSE_INIT, data->mp, 0, td, NULL);
626	fiii = fdi.indata;
627	fiii->major = FUSE_KERNEL_VERSION;
628	fiii->minor = FUSE_KERNEL_MINOR_VERSION;
629	fiii->max_readahead = FUSE_DEFAULT_IOSIZE * 16;
630	fiii->flags = 0;
631
632	fuse_insert_callback(fdi.tick, fuse_internal_init_callback);
633	fuse_insert_message(fdi.tick);
634	fdisp_destroy(&fdi);
635	}
636
637	#ifdef ZERO_PAD_INCOMPLETE_BUFS
638	static int
639	isbzero(void *buf, size_t len)
640	{
641	int i;
642
643	for (i = 0; i < len; i++) {
644	if (((char *)buf)[i])
645	return (0);
646	}
647
648	return (1);
649	}
650
651	#endif
Name	Value
svn:eol-style	native
svn:keywords	FreeBSD=%H
svn:mime-type	text/plain