xref: /freebsd/sys/fs/fuse/fuse_vnops.c (revision 6a5abb1ee5351d36de3b8589f8bf23fd2dfbb6da)
151369649SPedro F. Giffuni /*-
251369649SPedro F. Giffuni  * SPDX-License-Identifier: BSD-3-Clause
351369649SPedro F. Giffuni  *
45fe58019SAttilio Rao  * Copyright (c) 2007-2009 Google Inc. and Amit Singh
55fe58019SAttilio Rao  * All rights reserved.
65fe58019SAttilio Rao  *
75fe58019SAttilio Rao  * Redistribution and use in source and binary forms, with or without
85fe58019SAttilio Rao  * modification, are permitted provided that the following conditions are
95fe58019SAttilio Rao  * met:
105fe58019SAttilio Rao  *
115fe58019SAttilio Rao  * * Redistributions of source code must retain the above copyright
125fe58019SAttilio Rao  *   notice, this list of conditions and the following disclaimer.
135fe58019SAttilio Rao  * * Redistributions in binary form must reproduce the above
145fe58019SAttilio Rao  *   copyright notice, this list of conditions and the following disclaimer
155fe58019SAttilio Rao  *   in the documentation and/or other materials provided with the
165fe58019SAttilio Rao  *   distribution.
175fe58019SAttilio Rao  * * Neither the name of Google Inc. nor the names of its
185fe58019SAttilio Rao  *   contributors may be used to endorse or promote products derived from
195fe58019SAttilio Rao  *   this software without specific prior written permission.
205fe58019SAttilio Rao  *
215fe58019SAttilio Rao  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
225fe58019SAttilio Rao  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
235fe58019SAttilio Rao  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
245fe58019SAttilio Rao  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
255fe58019SAttilio Rao  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
265fe58019SAttilio Rao  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
275fe58019SAttilio Rao  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
285fe58019SAttilio Rao  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
295fe58019SAttilio Rao  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
305fe58019SAttilio Rao  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
315fe58019SAttilio Rao  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
325fe58019SAttilio Rao  *
335fe58019SAttilio Rao  * Copyright (C) 2005 Csaba Henk.
345fe58019SAttilio Rao  * All rights reserved.
355fe58019SAttilio Rao  *
368aafc8c3SAlan Somers  * Copyright (c) 2019 The FreeBSD Foundation
378aafc8c3SAlan Somers  *
388aafc8c3SAlan Somers  * Portions of this software were developed by BFF Storage Systems, LLC under
398aafc8c3SAlan Somers  * sponsorship from the FreeBSD Foundation.
408aafc8c3SAlan Somers  *
415fe58019SAttilio Rao  * Redistribution and use in source and binary forms, with or without
425fe58019SAttilio Rao  * modification, are permitted provided that the following conditions
435fe58019SAttilio Rao  * are met:
445fe58019SAttilio Rao  * 1. Redistributions of source code must retain the above copyright
455fe58019SAttilio Rao  *    notice, this list of conditions and the following disclaimer.
465fe58019SAttilio Rao  * 2. Redistributions in binary form must reproduce the above copyright
475fe58019SAttilio Rao  *    notice, this list of conditions and the following disclaimer in the
485fe58019SAttilio Rao  *    documentation and/or other materials provided with the distribution.
495fe58019SAttilio Rao  *
505fe58019SAttilio Rao  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
515fe58019SAttilio Rao  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
525fe58019SAttilio Rao  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
535fe58019SAttilio Rao  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
545fe58019SAttilio Rao  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
555fe58019SAttilio Rao  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
565fe58019SAttilio Rao  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
575fe58019SAttilio Rao  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
585fe58019SAttilio Rao  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
595fe58019SAttilio Rao  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
605fe58019SAttilio Rao  * SUCH DAMAGE.
615fe58019SAttilio Rao  */
625fe58019SAttilio Rao 
635fe58019SAttilio Rao #include <sys/cdefs.h>
645fe58019SAttilio Rao __FBSDID("$FreeBSD$");
655fe58019SAttilio Rao 
66cf169498SAlan Somers #include <sys/param.h>
675fe58019SAttilio Rao #include <sys/module.h>
685fe58019SAttilio Rao #include <sys/systm.h>
695fe58019SAttilio Rao #include <sys/errno.h>
705fe58019SAttilio Rao #include <sys/kernel.h>
715fe58019SAttilio Rao #include <sys/conf.h>
725fe58019SAttilio Rao #include <sys/uio.h>
735fe58019SAttilio Rao #include <sys/malloc.h>
745fe58019SAttilio Rao #include <sys/queue.h>
7591898857SMark Johnston #include <sys/limits.h>
765fe58019SAttilio Rao #include <sys/lock.h>
7789f6b863SAttilio Rao #include <sys/rwlock.h>
785fe58019SAttilio Rao #include <sys/sx.h>
795fe58019SAttilio Rao #include <sys/proc.h>
805fe58019SAttilio Rao #include <sys/mount.h>
815fe58019SAttilio Rao #include <sys/vnode.h>
825fe58019SAttilio Rao #include <sys/namei.h>
8304660064SFedor Uporov #include <sys/extattr.h>
845fe58019SAttilio Rao #include <sys/stat.h>
855fe58019SAttilio Rao #include <sys/unistd.h>
865fe58019SAttilio Rao #include <sys/filedesc.h>
875fe58019SAttilio Rao #include <sys/file.h>
885fe58019SAttilio Rao #include <sys/fcntl.h>
895fe58019SAttilio Rao #include <sys/dirent.h>
905fe58019SAttilio Rao #include <sys/bio.h>
915fe58019SAttilio Rao #include <sys/buf.h>
925fe58019SAttilio Rao #include <sys/sysctl.h>
93ca148cdaSGleb Smirnoff #include <sys/vmmeter.h>
945fe58019SAttilio Rao 
955fe58019SAttilio Rao #include <vm/vm.h>
965fe58019SAttilio Rao #include <vm/vm_extern.h>
975fe58019SAttilio Rao #include <vm/pmap.h>
985fe58019SAttilio Rao #include <vm/vm_map.h>
995fe58019SAttilio Rao #include <vm/vm_page.h>
1005fe58019SAttilio Rao #include <vm/vm_param.h>
1015fe58019SAttilio Rao #include <vm/vm_object.h>
1025fe58019SAttilio Rao #include <vm/vm_pager.h>
1035fe58019SAttilio Rao #include <vm/vnode_pager.h>
1045fe58019SAttilio Rao #include <vm/vm_object.h>
1055fe58019SAttilio Rao 
1065fe58019SAttilio Rao #include "fuse.h"
1075fe58019SAttilio Rao #include "fuse_file.h"
1085fe58019SAttilio Rao #include "fuse_internal.h"
1095fe58019SAttilio Rao #include "fuse_ipc.h"
1105fe58019SAttilio Rao #include "fuse_node.h"
1115fe58019SAttilio Rao #include "fuse_io.h"
1125fe58019SAttilio Rao 
1135fe58019SAttilio Rao #include <sys/priv.h>
1145fe58019SAttilio Rao 
115fd2749f2SAlan Somers /* Maximum number of hardlinks to a single FUSE file */
116fd2749f2SAlan Somers #define FUSE_LINK_MAX                      UINT32_MAX
117fd2749f2SAlan Somers 
118419e7ff6SAlan Somers SDT_PROVIDER_DECLARE(fusefs);
119cf169498SAlan Somers /*
120cf169498SAlan Somers  * Fuse trace probe:
121cf169498SAlan Somers  * arg0: verbosity.  Higher numbers give more verbose messages
122cf169498SAlan Somers  * arg1: Textual message
123cf169498SAlan Somers  */
124419e7ff6SAlan Somers SDT_PROBE_DEFINE2(fusefs, , vnops, trace, "int", "char*");
1255fe58019SAttilio Rao 
1265fe58019SAttilio Rao /* vnode ops */
1275fe58019SAttilio Rao static vop_access_t fuse_vnop_access;
128f067b609SAlan Somers static vop_advlock_t fuse_vnop_advlock;
129a1c9f4adSAlan Somers static vop_bmap_t fuse_vnop_bmap;
130f9b0e30bSAlan Somers static vop_close_t fuse_fifo_close;
1315fe58019SAttilio Rao static vop_close_t fuse_vnop_close;
1325fe58019SAttilio Rao static vop_create_t fuse_vnop_create;
13304660064SFedor Uporov static vop_deleteextattr_t fuse_vnop_deleteextattr;
134915012e0SAlan Somers static vop_fdatasync_t fuse_vnop_fdatasync;
1355fe58019SAttilio Rao static vop_fsync_t fuse_vnop_fsync;
1365fe58019SAttilio Rao static vop_getattr_t fuse_vnop_getattr;
13704660064SFedor Uporov static vop_getextattr_t fuse_vnop_getextattr;
1385fe58019SAttilio Rao static vop_inactive_t fuse_vnop_inactive;
1395fe58019SAttilio Rao static vop_link_t fuse_vnop_link;
14004660064SFedor Uporov static vop_listextattr_t fuse_vnop_listextattr;
1415fe58019SAttilio Rao static vop_lookup_t fuse_vnop_lookup;
1425fe58019SAttilio Rao static vop_mkdir_t fuse_vnop_mkdir;
1435fe58019SAttilio Rao static vop_mknod_t fuse_vnop_mknod;
1445fe58019SAttilio Rao static vop_open_t fuse_vnop_open;
145746c92e0SJohn Baldwin static vop_pathconf_t fuse_vnop_pathconf;
1465fe58019SAttilio Rao static vop_read_t fuse_vnop_read;
1475fe58019SAttilio Rao static vop_readdir_t fuse_vnop_readdir;
1485fe58019SAttilio Rao static vop_readlink_t fuse_vnop_readlink;
1495fe58019SAttilio Rao static vop_reclaim_t fuse_vnop_reclaim;
1505fe58019SAttilio Rao static vop_remove_t fuse_vnop_remove;
1515fe58019SAttilio Rao static vop_rename_t fuse_vnop_rename;
1525fe58019SAttilio Rao static vop_rmdir_t fuse_vnop_rmdir;
1535fe58019SAttilio Rao static vop_setattr_t fuse_vnop_setattr;
15404660064SFedor Uporov static vop_setextattr_t fuse_vnop_setextattr;
1555fe58019SAttilio Rao static vop_strategy_t fuse_vnop_strategy;
1565fe58019SAttilio Rao static vop_symlink_t fuse_vnop_symlink;
1575fe58019SAttilio Rao static vop_write_t fuse_vnop_write;
1585fe58019SAttilio Rao static vop_getpages_t fuse_vnop_getpages;
1595fe58019SAttilio Rao static vop_print_t fuse_vnop_print;
160e5b50fe7SAlan Somers static vop_vptofh_t fuse_vnop_vptofh;
1615fe58019SAttilio Rao 
162f9b0e30bSAlan Somers struct vop_vector fuse_fifoops = {
163f9b0e30bSAlan Somers 	.vop_default =		&fifo_specops,
164f9b0e30bSAlan Somers 	.vop_access =		fuse_vnop_access,
165f9b0e30bSAlan Somers 	.vop_close =		fuse_fifo_close,
166f9b0e30bSAlan Somers 	.vop_fsync =		fuse_vnop_fsync,
167f9b0e30bSAlan Somers 	.vop_getattr =		fuse_vnop_getattr,
168f9b0e30bSAlan Somers 	.vop_inactive =		fuse_vnop_inactive,
169f9b0e30bSAlan Somers 	.vop_pathconf =		fuse_vnop_pathconf,
170f9b0e30bSAlan Somers 	.vop_print =		fuse_vnop_print,
171f9b0e30bSAlan Somers 	.vop_read =		VOP_PANIC,
172f9b0e30bSAlan Somers 	.vop_reclaim =		fuse_vnop_reclaim,
173f9b0e30bSAlan Somers 	.vop_setattr =		fuse_vnop_setattr,
174f9b0e30bSAlan Somers 	.vop_write =		VOP_PANIC,
175e5b50fe7SAlan Somers 	.vop_vptofh =		fuse_vnop_vptofh,
176f9b0e30bSAlan Somers };
1776fa079fcSMateusz Guzik VFS_VOP_VECTOR_REGISTER(fuse_fifoops);
178f9b0e30bSAlan Somers 
1795fe58019SAttilio Rao struct vop_vector fuse_vnops = {
1801c8a5f5eSAlan Somers 	.vop_allocate =	VOP_EINVAL,
1815fe58019SAttilio Rao 	.vop_default = &default_vnodeops,
1825fe58019SAttilio Rao 	.vop_access = fuse_vnop_access,
183f067b609SAlan Somers 	.vop_advlock = fuse_vnop_advlock,
184a1c9f4adSAlan Somers 	.vop_bmap = fuse_vnop_bmap,
1855fe58019SAttilio Rao 	.vop_close = fuse_vnop_close,
1865fe58019SAttilio Rao 	.vop_create = fuse_vnop_create,
18704660064SFedor Uporov 	.vop_deleteextattr = fuse_vnop_deleteextattr,
1885fe58019SAttilio Rao 	.vop_fsync = fuse_vnop_fsync,
189915012e0SAlan Somers 	.vop_fdatasync = fuse_vnop_fdatasync,
1905fe58019SAttilio Rao 	.vop_getattr = fuse_vnop_getattr,
19104660064SFedor Uporov 	.vop_getextattr = fuse_vnop_getextattr,
1925fe58019SAttilio Rao 	.vop_inactive = fuse_vnop_inactive,
193e039bafaSAlan Somers 	/*
194e039bafaSAlan Somers 	 * TODO: implement vop_ioctl after upgrading to protocol 7.16.
195e039bafaSAlan Somers 	 * FUSE_IOCTL was added in 7.11, but 32-bit compat is broken until
196e039bafaSAlan Somers 	 * 7.16.
197e039bafaSAlan Somers 	 */
1985fe58019SAttilio Rao 	.vop_link = fuse_vnop_link,
19904660064SFedor Uporov 	.vop_listextattr = fuse_vnop_listextattr,
2005fe58019SAttilio Rao 	.vop_lookup = fuse_vnop_lookup,
2015fe58019SAttilio Rao 	.vop_mkdir = fuse_vnop_mkdir,
2025fe58019SAttilio Rao 	.vop_mknod = fuse_vnop_mknod,
2035fe58019SAttilio Rao 	.vop_open = fuse_vnop_open,
204746c92e0SJohn Baldwin 	.vop_pathconf = fuse_vnop_pathconf,
205e039bafaSAlan Somers 	/*
206e039bafaSAlan Somers 	 * TODO: implement vop_poll after upgrading to protocol 7.21.
207e039bafaSAlan Somers 	 * FUSE_POLL was added in protocol 7.11, but it's kind of broken until
208e039bafaSAlan Somers 	 * 7.21, which adds the ability for the client to choose which poll
209e039bafaSAlan Somers 	 * events it wants, and for a client to deregister a file handle
210e039bafaSAlan Somers 	 */
2115fe58019SAttilio Rao 	.vop_read = fuse_vnop_read,
2125fe58019SAttilio Rao 	.vop_readdir = fuse_vnop_readdir,
2135fe58019SAttilio Rao 	.vop_readlink = fuse_vnop_readlink,
2145fe58019SAttilio Rao 	.vop_reclaim = fuse_vnop_reclaim,
2155fe58019SAttilio Rao 	.vop_remove = fuse_vnop_remove,
2165fe58019SAttilio Rao 	.vop_rename = fuse_vnop_rename,
2175fe58019SAttilio Rao 	.vop_rmdir = fuse_vnop_rmdir,
2185fe58019SAttilio Rao 	.vop_setattr = fuse_vnop_setattr,
21904660064SFedor Uporov 	.vop_setextattr = fuse_vnop_setextattr,
2205fe58019SAttilio Rao 	.vop_strategy = fuse_vnop_strategy,
2215fe58019SAttilio Rao 	.vop_symlink = fuse_vnop_symlink,
2225fe58019SAttilio Rao 	.vop_write = fuse_vnop_write,
2235fe58019SAttilio Rao 	.vop_getpages = fuse_vnop_getpages,
2245fe58019SAttilio Rao 	.vop_print = fuse_vnop_print,
225e5b50fe7SAlan Somers 	.vop_vptofh = fuse_vnop_vptofh,
2265fe58019SAttilio Rao };
2276fa079fcSMateusz Guzik VFS_VOP_VECTOR_REGISTER(fuse_vnops);
2285fe58019SAttilio Rao 
229756a5412SGleb Smirnoff uma_zone_t fuse_pbuf_zone;
2305fe58019SAttilio Rao 
231666f8543SAlan Somers /* Check permission for extattr operations, much like extattr_check_cred */
232666f8543SAlan Somers static int
233666f8543SAlan Somers fuse_extattr_check_cred(struct vnode *vp, int ns, struct ucred *cred,
234666f8543SAlan Somers 	struct thread *td, accmode_t accmode)
235666f8543SAlan Somers {
236666f8543SAlan Somers 	struct mount *mp = vnode_mount(vp);
237666f8543SAlan Somers 	struct fuse_data *data = fuse_get_mpdata(mp);
238666f8543SAlan Somers 
239666f8543SAlan Somers 	/*
240666f8543SAlan Somers 	 * Kernel-invoked always succeeds.
241666f8543SAlan Somers 	 */
242666f8543SAlan Somers 	if (cred == NOCRED)
243666f8543SAlan Somers 		return (0);
244666f8543SAlan Somers 
245666f8543SAlan Somers 	/*
246666f8543SAlan Somers 	 * Do not allow privileged processes in jail to directly manipulate
247666f8543SAlan Somers 	 * system attributes.
248666f8543SAlan Somers 	 */
249666f8543SAlan Somers 	switch (ns) {
250666f8543SAlan Somers 	case EXTATTR_NAMESPACE_SYSTEM:
251666f8543SAlan Somers 		if (data->dataflags & FSESS_DEFAULT_PERMISSIONS) {
252666f8543SAlan Somers 			return (priv_check_cred(cred, PRIV_VFS_EXTATTR_SYSTEM));
253666f8543SAlan Somers 		}
254666f8543SAlan Somers 		/* FALLTHROUGH */
255666f8543SAlan Somers 	case EXTATTR_NAMESPACE_USER:
256666f8543SAlan Somers 		return (fuse_internal_access(vp, accmode, td, cred));
257666f8543SAlan Somers 	default:
258666f8543SAlan Somers 		return (EPERM);
259666f8543SAlan Somers 	}
260666f8543SAlan Somers }
261666f8543SAlan Somers 
262f8d4af10SAlan Somers /* Get a filehandle for a directory */
263f8d4af10SAlan Somers static int
264f8d4af10SAlan Somers fuse_filehandle_get_dir(struct vnode *vp, struct fuse_filehandle **fufhp,
265f8d4af10SAlan Somers 	struct ucred *cred, pid_t pid)
266f8d4af10SAlan Somers {
2679f10f423SAlan Somers 	if (fuse_filehandle_get(vp, FREAD, fufhp, cred, pid) == 0)
268f8d4af10SAlan Somers 		return 0;
2699f10f423SAlan Somers 	return fuse_filehandle_get(vp, FEXEC, fufhp, cred, pid);
2709f10f423SAlan Somers }
2719f10f423SAlan Somers 
2729f10f423SAlan Somers /* Send FUSE_FLUSH for this vnode */
2739f10f423SAlan Somers static int
2749f10f423SAlan Somers fuse_flush(struct vnode *vp, struct ucred *cred, pid_t pid, int fflag)
2759f10f423SAlan Somers {
2769f10f423SAlan Somers 	struct fuse_flush_in *ffi;
2779f10f423SAlan Somers 	struct fuse_filehandle *fufh;
2789f10f423SAlan Somers 	struct fuse_dispatcher fdi;
2799f10f423SAlan Somers 	struct thread *td = curthread;
2809f10f423SAlan Somers 	struct mount *mp = vnode_mount(vp);
2819f10f423SAlan Somers 	int err;
2829f10f423SAlan Somers 
2839f10f423SAlan Somers 	if (!fsess_isimpl(vnode_mount(vp), FUSE_FLUSH))
2849f10f423SAlan Somers 		return 0;
2859f10f423SAlan Somers 
286f067b609SAlan Somers 	err = fuse_filehandle_getrw(vp, fflag, &fufh, cred, pid);
2879f10f423SAlan Somers 	if (err)
2889f10f423SAlan Somers 		return err;
2899f10f423SAlan Somers 
2909f10f423SAlan Somers 	fdisp_init(&fdi, sizeof(*ffi));
2919f10f423SAlan Somers 	fdisp_make_vp(&fdi, FUSE_FLUSH, vp, td, cred);
2929f10f423SAlan Somers 	ffi = fdi.indata;
2939f10f423SAlan Somers 	ffi->fh = fufh->fh_id;
294f067b609SAlan Somers 	/*
295f067b609SAlan Somers 	 * If the file has a POSIX lock then we're supposed to set lock_owner.
296f067b609SAlan Somers 	 * If not, then lock_owner is undefined.  So we may as well always set
297f067b609SAlan Somers 	 * it.
298f067b609SAlan Somers 	 */
299f067b609SAlan Somers 	ffi->lock_owner = td->td_proc->p_pid;
3009f10f423SAlan Somers 
3019f10f423SAlan Somers 	err = fdisp_wait_answ(&fdi);
3029f10f423SAlan Somers 	if (err == ENOSYS) {
3039f10f423SAlan Somers 		fsess_set_notimpl(mp, FUSE_FLUSH);
3049f10f423SAlan Somers 		err = 0;
3059f10f423SAlan Somers 	}
3069f10f423SAlan Somers 	fdisp_destroy(&fdi);
3079f10f423SAlan Somers 	return err;
308f8d4af10SAlan Somers }
309f8d4af10SAlan Somers 
310f9b0e30bSAlan Somers /* Close wrapper for fifos.  */
311f9b0e30bSAlan Somers static int
312f9b0e30bSAlan Somers fuse_fifo_close(struct vop_close_args *ap)
313f9b0e30bSAlan Somers {
314f9b0e30bSAlan Somers 	return (fifo_specops.vop_close(ap));
315f9b0e30bSAlan Somers }
316f9b0e30bSAlan Somers 
3175fe58019SAttilio Rao /*
3185fe58019SAttilio Rao     struct vnop_access_args {
3195fe58019SAttilio Rao 	struct vnode *a_vp;
3205fe58019SAttilio Rao #if VOP_ACCESS_TAKES_ACCMODE_T
3215fe58019SAttilio Rao 	accmode_t a_accmode;
3225fe58019SAttilio Rao #else
3235fe58019SAttilio Rao 	int a_mode;
3245fe58019SAttilio Rao #endif
3255fe58019SAttilio Rao 	struct ucred *a_cred;
3265fe58019SAttilio Rao 	struct thread *a_td;
3275fe58019SAttilio Rao     };
3285fe58019SAttilio Rao */
3295fe58019SAttilio Rao static int
3305fe58019SAttilio Rao fuse_vnop_access(struct vop_access_args *ap)
3315fe58019SAttilio Rao {
3325fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
3335fe58019SAttilio Rao 	int accmode = ap->a_accmode;
3345fe58019SAttilio Rao 	struct ucred *cred = ap->a_cred;
3355fe58019SAttilio Rao 
3365fe58019SAttilio Rao 	struct fuse_data *data = fuse_get_mpdata(vnode_mount(vp));
3375fe58019SAttilio Rao 
3385fe58019SAttilio Rao 	int err;
3395fe58019SAttilio Rao 
3405fe58019SAttilio Rao 	if (fuse_isdeadfs(vp)) {
3415fe58019SAttilio Rao 		if (vnode_isvroot(vp)) {
3425fe58019SAttilio Rao 			return 0;
3435fe58019SAttilio Rao 		}
3445fe58019SAttilio Rao 		return ENXIO;
3455fe58019SAttilio Rao 	}
3465fe58019SAttilio Rao 	if (!(data->dataflags & FSESS_INITED)) {
3475fe58019SAttilio Rao 		if (vnode_isvroot(vp)) {
348cc426dd3SMateusz Guzik 			if (priv_check_cred(cred, PRIV_VFS_ADMIN) ||
3495fe58019SAttilio Rao 			    (fuse_match_cred(data->daemoncred, cred) == 0)) {
3505fe58019SAttilio Rao 				return 0;
3515fe58019SAttilio Rao 			}
3525fe58019SAttilio Rao 		}
3535fe58019SAttilio Rao 		return EBADF;
3545fe58019SAttilio Rao 	}
3555fe58019SAttilio Rao 	if (vnode_islnk(vp)) {
3565fe58019SAttilio Rao 		return 0;
3575fe58019SAttilio Rao 	}
3585fe58019SAttilio Rao 
359666f8543SAlan Somers 	err = fuse_internal_access(vp, accmode, ap->a_td, ap->a_cred);
3605fe58019SAttilio Rao 	return err;
3615fe58019SAttilio Rao }
3625fe58019SAttilio Rao 
3635fe58019SAttilio Rao /*
364f067b609SAlan Somers  * struct vop_advlock_args {
365f067b609SAlan Somers  *	struct vop_generic_args a_gen;
366f067b609SAlan Somers  *	struct vnode *a_vp;
367f067b609SAlan Somers  *	void *a_id;
368f067b609SAlan Somers  *	int a_op;
369f067b609SAlan Somers  *	struct flock *a_fl;
370f067b609SAlan Somers  *	int a_flags;
371f067b609SAlan Somers  * }
372f067b609SAlan Somers  */
373f067b609SAlan Somers static int
374f067b609SAlan Somers fuse_vnop_advlock(struct vop_advlock_args *ap)
375f067b609SAlan Somers {
376f067b609SAlan Somers 	struct vnode *vp = ap->a_vp;
377f067b609SAlan Somers 	struct flock *fl = ap->a_fl;
378f067b609SAlan Somers 	struct thread *td = curthread;
379f067b609SAlan Somers 	struct ucred *cred = td->td_ucred;
380f067b609SAlan Somers 	pid_t pid = td->td_proc->p_pid;
381f067b609SAlan Somers 	struct fuse_filehandle *fufh;
382f067b609SAlan Somers 	struct fuse_dispatcher fdi;
383f067b609SAlan Somers 	struct fuse_lk_in *fli;
384f067b609SAlan Somers 	struct fuse_lk_out *flo;
385f067b609SAlan Somers 	enum fuse_opcode op;
386f067b609SAlan Somers 	int dataflags, err;
3878aa24ed3SAlan Somers 	int flags = ap->a_flags;
388f067b609SAlan Somers 
389f067b609SAlan Somers 	dataflags = fuse_get_mpdata(vnode_mount(vp))->dataflags;
390f067b609SAlan Somers 
391f067b609SAlan Somers 	if (fuse_isdeadfs(vp)) {
392f067b609SAlan Somers 		return ENXIO;
393f067b609SAlan Somers 	}
394f067b609SAlan Somers 
395f067b609SAlan Somers 	if (!(dataflags & FSESS_POSIX_LOCKS))
396f067b609SAlan Somers 		return vop_stdadvlock(ap);
3978aa24ed3SAlan Somers 	/* FUSE doesn't properly support flock until protocol 7.17 */
3988aa24ed3SAlan Somers 	if (flags & F_FLOCK)
3998aa24ed3SAlan Somers 		return vop_stdadvlock(ap);
400f067b609SAlan Somers 
401f067b609SAlan Somers 	err = fuse_filehandle_get_anyflags(vp, &fufh, cred, pid);
402f067b609SAlan Somers 	if (err)
403f067b609SAlan Somers 		return err;
404f067b609SAlan Somers 
405f067b609SAlan Somers 	fdisp_init(&fdi, sizeof(*fli));
406f067b609SAlan Somers 
407f067b609SAlan Somers 	switch(ap->a_op) {
408f067b609SAlan Somers 	case F_GETLK:
409f067b609SAlan Somers 		op = FUSE_GETLK;
410f067b609SAlan Somers 		break;
411f067b609SAlan Somers 	case F_SETLK:
412f067b609SAlan Somers 		op = FUSE_SETLK;
413f067b609SAlan Somers 		break;
414f067b609SAlan Somers 	case F_SETLKW:
415f067b609SAlan Somers 		op = FUSE_SETLKW;
416f067b609SAlan Somers 		break;
417f067b609SAlan Somers 	default:
418f067b609SAlan Somers 		return EINVAL;
419f067b609SAlan Somers 	}
420f067b609SAlan Somers 
421f067b609SAlan Somers 	fdisp_make_vp(&fdi, op, vp, td, cred);
422f067b609SAlan Somers 	fli = fdi.indata;
423f067b609SAlan Somers 	fli->fh = fufh->fh_id;
424f067b609SAlan Somers 	fli->owner = fl->l_pid;
425f067b609SAlan Somers 	fli->lk.start = fl->l_start;
426f067b609SAlan Somers 	if (fl->l_len != 0)
427f067b609SAlan Somers 		fli->lk.end = fl->l_start + fl->l_len - 1;
428f067b609SAlan Somers 	else
429f067b609SAlan Somers 		fli->lk.end = INT64_MAX;
430f067b609SAlan Somers 	fli->lk.type = fl->l_type;
431f067b609SAlan Somers 	fli->lk.pid = fl->l_pid;
432f067b609SAlan Somers 
433f067b609SAlan Somers 	err = fdisp_wait_answ(&fdi);
434f067b609SAlan Somers 	fdisp_destroy(&fdi);
435f067b609SAlan Somers 
436f067b609SAlan Somers 	if (err == 0 && op == FUSE_GETLK) {
437f067b609SAlan Somers 		flo = fdi.answ;
438f067b609SAlan Somers 		fl->l_type = flo->lk.type;
439f067b609SAlan Somers 		fl->l_pid = flo->lk.pid;
440f067b609SAlan Somers 		if (flo->lk.type != F_UNLCK) {
441f067b609SAlan Somers 			fl->l_start = flo->lk.start;
442f067b609SAlan Somers 			if (flo->lk.end == INT64_MAX)
443f067b609SAlan Somers 				fl->l_len = 0;
444f067b609SAlan Somers 			else
445f067b609SAlan Somers 				fl->l_len = flo->lk.end - flo->lk.start + 1;
446f067b609SAlan Somers 			fl->l_start = flo->lk.start;
447f067b609SAlan Somers 		}
448f067b609SAlan Somers 	}
449f067b609SAlan Somers 
450f067b609SAlan Somers 	return err;
451f067b609SAlan Somers }
452f067b609SAlan Somers 
453a1c9f4adSAlan Somers /* {
454a1c9f4adSAlan Somers 	struct vnode *a_vp;
455a1c9f4adSAlan Somers 	daddr_t a_bn;
456a1c9f4adSAlan Somers 	struct bufobj **a_bop;
457a1c9f4adSAlan Somers 	daddr_t *a_bnp;
458a1c9f4adSAlan Somers 	int *a_runp;
459a1c9f4adSAlan Somers 	int *a_runb;
460a1c9f4adSAlan Somers } */
461a1c9f4adSAlan Somers static int
462a1c9f4adSAlan Somers fuse_vnop_bmap(struct vop_bmap_args *ap)
463a1c9f4adSAlan Somers {
464a1c9f4adSAlan Somers 	struct vnode *vp = ap->a_vp;
465a1c9f4adSAlan Somers 	struct bufobj **bo = ap->a_bop;
466a1c9f4adSAlan Somers 	struct thread *td = curthread;
467a1c9f4adSAlan Somers 	struct mount *mp;
468a1c9f4adSAlan Somers 	struct fuse_dispatcher fdi;
469a1c9f4adSAlan Somers 	struct fuse_bmap_in *fbi;
470a1c9f4adSAlan Somers 	struct fuse_bmap_out *fbo;
471a1c9f4adSAlan Somers 	struct fuse_data *data;
472a1c9f4adSAlan Somers 	uint64_t biosize;
473a1c9f4adSAlan Somers 	off_t filesize;
474a1c9f4adSAlan Somers 	daddr_t lbn = ap->a_bn;
475a1c9f4adSAlan Somers 	daddr_t *pbn = ap->a_bnp;
476a1c9f4adSAlan Somers 	int *runp = ap->a_runp;
477a1c9f4adSAlan Somers 	int *runb = ap->a_runb;
478a1c9f4adSAlan Somers 	int error = 0;
479a1c9f4adSAlan Somers 	int maxrun;
480a1c9f4adSAlan Somers 
481a1c9f4adSAlan Somers 	if (fuse_isdeadfs(vp)) {
482a1c9f4adSAlan Somers 		return ENXIO;
483a1c9f4adSAlan Somers 	}
484a1c9f4adSAlan Somers 
485a1c9f4adSAlan Somers 	mp = vnode_mount(vp);
486a1c9f4adSAlan Somers 	data = fuse_get_mpdata(mp);
487a1c9f4adSAlan Somers 	biosize = fuse_iosize(vp);
488a1c9f4adSAlan Somers 	maxrun = MIN(vp->v_mount->mnt_iosize_max / biosize - 1,
489a1c9f4adSAlan Somers 		data->max_readahead_blocks);
490a1c9f4adSAlan Somers 
491a1c9f4adSAlan Somers 	if (bo != NULL)
492a1c9f4adSAlan Somers 		*bo = &vp->v_bufobj;
493a1c9f4adSAlan Somers 
494a1c9f4adSAlan Somers 	/*
495a1c9f4adSAlan Somers 	 * The FUSE_BMAP operation does not include the runp and runb
496a1c9f4adSAlan Somers 	 * variables, so we must guess.  Report nonzero contiguous runs so
497a1c9f4adSAlan Somers 	 * cluster_read will combine adjacent reads.  It's worthwhile to reduce
498a1c9f4adSAlan Somers 	 * upcalls even if we don't know the true physical layout of the file.
499a1c9f4adSAlan Somers 	 *
500a1c9f4adSAlan Somers 	 * FUSE file systems may opt out of read clustering in two ways:
501a1c9f4adSAlan Somers 	 * * mounting with -onoclusterr
502a1c9f4adSAlan Somers 	 * * Setting max_readahead <= maxbcachebuf during FUSE_INIT
503a1c9f4adSAlan Somers 	 */
504a1c9f4adSAlan Somers 	if (runb != NULL)
505a1c9f4adSAlan Somers 		*runb = MIN(lbn, maxrun);
506a1c9f4adSAlan Somers 	if (runp != NULL) {
507a1c9f4adSAlan Somers 		error = fuse_vnode_size(vp, &filesize, td->td_ucred, td);
508a1c9f4adSAlan Somers 		if (error == 0)
50916f87834SAlan Somers 			*runp = MIN(MAX(0, filesize / (off_t)biosize - lbn - 1),
510a1c9f4adSAlan Somers 				    maxrun);
511a1c9f4adSAlan Somers 		else
512a1c9f4adSAlan Somers 			*runp = 0;
513a1c9f4adSAlan Somers 	}
514a1c9f4adSAlan Somers 
515a1c9f4adSAlan Somers 	if (fsess_isimpl(mp, FUSE_BMAP)) {
516a1c9f4adSAlan Somers 		fdisp_init(&fdi, sizeof(*fbi));
517a1c9f4adSAlan Somers 		fdisp_make_vp(&fdi, FUSE_BMAP, vp, td, td->td_ucred);
518a1c9f4adSAlan Somers 		fbi = fdi.indata;
519a1c9f4adSAlan Somers 		fbi->block = lbn;
520a1c9f4adSAlan Somers 		fbi->blocksize = biosize;
521a1c9f4adSAlan Somers 		error = fdisp_wait_answ(&fdi);
522a1c9f4adSAlan Somers 		if (error == ENOSYS) {
523caeea8b4SAlan Somers 			fdisp_destroy(&fdi);
524a1c9f4adSAlan Somers 			fsess_set_notimpl(mp, FUSE_BMAP);
525a1c9f4adSAlan Somers 			error = 0;
526a1c9f4adSAlan Somers 		} else {
527a1c9f4adSAlan Somers 			fbo = fdi.answ;
528a1c9f4adSAlan Somers 			if (error == 0 && pbn != NULL)
529a1c9f4adSAlan Somers 				*pbn = fbo->block;
530caeea8b4SAlan Somers 			fdisp_destroy(&fdi);
531a1c9f4adSAlan Somers 			return error;
532a1c9f4adSAlan Somers 		}
533a1c9f4adSAlan Somers 	}
534a1c9f4adSAlan Somers 
535a1c9f4adSAlan Somers 	/* If the daemon doesn't support BMAP, make up a sensible default */
536a1c9f4adSAlan Somers 	if (pbn != NULL)
537a1c9f4adSAlan Somers 		*pbn = lbn * btodb(biosize);
538a1c9f4adSAlan Somers 	return (error);
539a1c9f4adSAlan Somers }
540a1c9f4adSAlan Somers 
541f067b609SAlan Somers /*
5429f10f423SAlan Somers     struct vop_close_args {
5435fe58019SAttilio Rao 	struct vnode *a_vp;
5445fe58019SAttilio Rao 	int  a_fflag;
5455fe58019SAttilio Rao 	struct ucred *a_cred;
5465fe58019SAttilio Rao 	struct thread *a_td;
5475fe58019SAttilio Rao     };
5485fe58019SAttilio Rao */
5495fe58019SAttilio Rao static int
5505fe58019SAttilio Rao fuse_vnop_close(struct vop_close_args *ap)
5515fe58019SAttilio Rao {
5525fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
5535fe58019SAttilio Rao 	struct ucred *cred = ap->a_cred;
5545fe58019SAttilio Rao 	int fflag = ap->a_fflag;
555f8d4af10SAlan Somers 	struct thread *td = ap->a_td;
556f8d4af10SAlan Somers 	pid_t pid = td->td_proc->p_pid;
5579f10f423SAlan Somers 	int err = 0;
5585fe58019SAttilio Rao 
55935cf0e7eSAlan Somers 	if (fuse_isdeadfs(vp))
5605fe58019SAttilio Rao 		return 0;
56135cf0e7eSAlan Somers 	if (vnode_isdir(vp))
56235cf0e7eSAlan Somers 		return 0;
56335cf0e7eSAlan Somers 	if (fflag & IO_NDELAY)
56435cf0e7eSAlan Somers 		return 0;
5655ec10aa5SAlan Somers 
5669f10f423SAlan Somers 	err = fuse_flush(vp, cred, pid, fflag);
5675ec10aa5SAlan Somers 	/* TODO: close the file handle, if we're sure it's no longer used */
5685fe58019SAttilio Rao 	if ((VTOFUD(vp)->flag & FN_SIZECHANGE) != 0) {
569f8d4af10SAlan Somers 		fuse_vnode_savesize(vp, cred, td->td_proc->p_pid);
5705fe58019SAttilio Rao 	}
5719f10f423SAlan Somers 	return err;
5725fe58019SAttilio Rao }
5735fe58019SAttilio Rao 
57419ef317dSAlan Somers static void
57519ef317dSAlan Somers fdisp_make_mknod_for_fallback(
57619ef317dSAlan Somers 	struct fuse_dispatcher *fdip,
57719ef317dSAlan Somers 	struct componentname *cnp,
57819ef317dSAlan Somers 	struct vnode *dvp,
57919ef317dSAlan Somers 	uint64_t parentnid,
58019ef317dSAlan Somers 	struct thread *td,
58119ef317dSAlan Somers 	struct ucred *cred,
58219ef317dSAlan Somers 	mode_t mode,
58319ef317dSAlan Somers 	enum fuse_opcode *op)
58419ef317dSAlan Somers {
58519ef317dSAlan Somers 	struct fuse_mknod_in *fmni;
58619ef317dSAlan Somers 
58719ef317dSAlan Somers 	fdisp_init(fdip, sizeof(*fmni) + cnp->cn_namelen + 1);
58819ef317dSAlan Somers 	*op = FUSE_MKNOD;
58919ef317dSAlan Somers 	fdisp_make(fdip, *op, vnode_mount(dvp), parentnid, td, cred);
59019ef317dSAlan Somers 	fmni = fdip->indata;
59119ef317dSAlan Somers 	fmni->mode = mode;
59219ef317dSAlan Somers 	fmni->rdev = 0;
59319ef317dSAlan Somers 	memcpy((char *)fdip->indata + sizeof(*fmni), cnp->cn_nameptr,
59419ef317dSAlan Somers 	    cnp->cn_namelen);
59519ef317dSAlan Somers 	((char *)fdip->indata)[sizeof(*fmni) + cnp->cn_namelen] = '\0';
59619ef317dSAlan Somers }
5975fe58019SAttilio Rao /*
5985fe58019SAttilio Rao     struct vnop_create_args {
5995fe58019SAttilio Rao 	struct vnode *a_dvp;
6005fe58019SAttilio Rao 	struct vnode **a_vpp;
6015fe58019SAttilio Rao 	struct componentname *a_cnp;
6025fe58019SAttilio Rao 	struct vattr *a_vap;
6035fe58019SAttilio Rao     };
6045fe58019SAttilio Rao */
6055fe58019SAttilio Rao static int
6065fe58019SAttilio Rao fuse_vnop_create(struct vop_create_args *ap)
6075fe58019SAttilio Rao {
6085fe58019SAttilio Rao 	struct vnode *dvp = ap->a_dvp;
6095fe58019SAttilio Rao 	struct vnode **vpp = ap->a_vpp;
6105fe58019SAttilio Rao 	struct componentname *cnp = ap->a_cnp;
6115fe58019SAttilio Rao 	struct vattr *vap = ap->a_vap;
6125fe58019SAttilio Rao 	struct thread *td = cnp->cn_thread;
6135fe58019SAttilio Rao 	struct ucred *cred = cnp->cn_cred;
6145fe58019SAttilio Rao 
615a4856c96SAlan Somers 	struct fuse_data *data;
616a4856c96SAlan Somers 	struct fuse_create_in *fci;
6175fe58019SAttilio Rao 	struct fuse_entry_out *feo;
61819ef317dSAlan Somers 	struct fuse_open_out *foo;
61919ef317dSAlan Somers 	struct fuse_dispatcher fdi, fdi2;
6205fe58019SAttilio Rao 	struct fuse_dispatcher *fdip = &fdi;
62119ef317dSAlan Somers 	struct fuse_dispatcher *fdip2 = NULL;
6225fe58019SAttilio Rao 
6235fe58019SAttilio Rao 	int err;
6245fe58019SAttilio Rao 
6255fe58019SAttilio Rao 	struct mount *mp = vnode_mount(dvp);
626a4856c96SAlan Somers 	data = fuse_get_mpdata(mp);
6275fe58019SAttilio Rao 	uint64_t parentnid = VTOFUD(dvp)->nid;
6285fe58019SAttilio Rao 	mode_t mode = MAKEIMODE(vap->va_type, vap->va_mode);
62919ef317dSAlan Somers 	enum fuse_opcode op;
6309e444871SAlan Somers 	int flags;
6319e444871SAlan Somers 
632d5ff2688SAlan Somers 	if (fuse_isdeadfs(dvp))
633d5ff2688SAlan Somers 		return ENXIO;
634d5ff2688SAlan Somers 
635d5ff2688SAlan Somers 	/* FUSE expects sockets to be created with FUSE_MKNOD */
636d5ff2688SAlan Somers 	if (vap->va_type == VSOCK)
637d5ff2688SAlan Somers 		return fuse_internal_mknod(dvp, vpp, cnp, vap);
638d5ff2688SAlan Somers 
6399e444871SAlan Somers 	/*
6409e444871SAlan Somers 	 * VOP_CREATE doesn't tell us the open(2) flags, so we guess.  Only a
6419e444871SAlan Somers 	 * writable mode makes sense, and we might as well include readability
6429e444871SAlan Somers 	 * too.
6439e444871SAlan Somers 	 */
6449e444871SAlan Somers 	flags = O_RDWR;
6455fe58019SAttilio Rao 
6465fe58019SAttilio Rao 	bzero(&fdi, sizeof(fdi));
6475fe58019SAttilio Rao 
648d5ff2688SAlan Somers 	if (vap->va_type != VREG)
649372b97d0SRick Macklem 		return (EINVAL);
6505fe58019SAttilio Rao 
651d5ff2688SAlan Somers 	if (!fsess_isimpl(mp, FUSE_CREATE) || vap->va_type == VSOCK) {
65219ef317dSAlan Somers 		/* Fallback to FUSE_MKNOD/FUSE_OPEN */
65319ef317dSAlan Somers 		fdisp_make_mknod_for_fallback(fdip, cnp, dvp, parentnid, td,
65419ef317dSAlan Somers 			cred, mode, &op);
65519ef317dSAlan Somers 	} else {
65619ef317dSAlan Somers 		/* Use FUSE_CREATE */
657a4856c96SAlan Somers 		size_t insize;
658a4856c96SAlan Somers 
65919ef317dSAlan Somers 		op = FUSE_CREATE;
660a4856c96SAlan Somers 		fdisp_init(fdip, sizeof(*fci) + cnp->cn_namelen + 1);
66119ef317dSAlan Somers 		fdisp_make(fdip, op, vnode_mount(dvp), parentnid, td, cred);
662a4856c96SAlan Somers 		fci = fdip->indata;
663a4856c96SAlan Somers 		fci->mode = mode;
664a4856c96SAlan Somers 		fci->flags = O_CREAT | flags;
665a4856c96SAlan Somers 		if (fuse_libabi_geq(data, 7, 12)) {
666a4856c96SAlan Somers 			insize = sizeof(*fci);
667a4856c96SAlan Somers 			fci->umask = td->td_proc->p_fd->fd_cmask;
668a4856c96SAlan Somers 		} else {
669a4856c96SAlan Somers 			insize = sizeof(struct fuse_open_in);
670a4856c96SAlan Somers 		}
671a4856c96SAlan Somers 
672a4856c96SAlan Somers 		memcpy((char *)fdip->indata + insize, cnp->cn_nameptr,
6735fe58019SAttilio Rao 		    cnp->cn_namelen);
674a4856c96SAlan Somers 		((char *)fdip->indata)[insize + cnp->cn_namelen] = '\0';
67519ef317dSAlan Somers 	}
6765fe58019SAttilio Rao 
6775fe58019SAttilio Rao 	err = fdisp_wait_answ(fdip);
6785fe58019SAttilio Rao 
6796de3b00dSAttilio Rao 	if (err) {
68019ef317dSAlan Somers 		if (err == ENOSYS && op == FUSE_CREATE) {
6815fe58019SAttilio Rao 			fsess_set_notimpl(mp, FUSE_CREATE);
682caeea8b4SAlan Somers 			fdisp_destroy(fdip);
68319ef317dSAlan Somers 			fdisp_make_mknod_for_fallback(fdip, cnp, dvp,
68419ef317dSAlan Somers 				parentnid, td, cred, mode, &op);
68519ef317dSAlan Somers 			err = fdisp_wait_answ(fdip);
68619ef317dSAlan Somers 		}
68719ef317dSAlan Somers 		if (err)
6885fe58019SAttilio Rao 			goto out;
6895fe58019SAttilio Rao 	}
690372b97d0SRick Macklem 
6915fe58019SAttilio Rao 	feo = fdip->answ;
6925fe58019SAttilio Rao 
693ede571e4SAlan Somers 	if ((err = fuse_internal_checkentry(feo, vap->va_type))) {
6945fe58019SAttilio Rao 		goto out;
6955fe58019SAttilio Rao 	}
69619ef317dSAlan Somers 
69719ef317dSAlan Somers 	if (op == FUSE_CREATE) {
69819ef317dSAlan Somers 		foo = (struct fuse_open_out*)(feo + 1);
69919ef317dSAlan Somers 	} else {
70019ef317dSAlan Somers 		/* Issue a separate FUSE_OPEN */
701a4856c96SAlan Somers 		struct fuse_open_in *foi;
702a4856c96SAlan Somers 
70319ef317dSAlan Somers 		fdip2 = &fdi2;
70419ef317dSAlan Somers 		fdisp_init(fdip2, sizeof(*foi));
70519ef317dSAlan Somers 		fdisp_make(fdip2, FUSE_OPEN, vnode_mount(dvp), feo->nodeid, td,
70619ef317dSAlan Somers 			cred);
70719ef317dSAlan Somers 		foi = fdip2->indata;
7089e444871SAlan Somers 		foi->flags = flags;
70919ef317dSAlan Somers 		err = fdisp_wait_answ(fdip2);
71019ef317dSAlan Somers 		if (err)
71119ef317dSAlan Somers 			goto out;
71219ef317dSAlan Somers 		foo = fdip2->answ;
71319ef317dSAlan Somers 	}
714ede571e4SAlan Somers 	err = fuse_vnode_get(mp, feo, feo->nodeid, dvp, vpp, cnp, vap->va_type);
7155fe58019SAttilio Rao 	if (err) {
7165fe58019SAttilio Rao 		struct fuse_release_in *fri;
7175fe58019SAttilio Rao 		uint64_t nodeid = feo->nodeid;
71819ef317dSAlan Somers 		uint64_t fh_id = foo->fh;
7195fe58019SAttilio Rao 
7205fe58019SAttilio Rao 		fdisp_init(fdip, sizeof(*fri));
7215fe58019SAttilio Rao 		fdisp_make(fdip, FUSE_RELEASE, mp, nodeid, td, cred);
7225fe58019SAttilio Rao 		fri = fdip->indata;
7235fe58019SAttilio Rao 		fri->fh = fh_id;
7249e444871SAlan Somers 		fri->flags = flags;
7255fe58019SAttilio Rao 		fuse_insert_callback(fdip->tick, fuse_internal_forget_callback);
726268c28edSAlan Somers 		fuse_insert_message(fdip->tick, false);
72719ef317dSAlan Somers 		goto out;
7285fe58019SAttilio Rao 	}
7295fe58019SAttilio Rao 	ASSERT_VOP_ELOCKED(*vpp, "fuse_vnop_create");
7300269ae4cSAlan Somers 	fuse_internal_cache_attrs(*vpp, &feo->attr, feo->attr_valid,
731cad67791SAlan Somers 		feo->attr_valid_nsec, NULL);
7325fe58019SAttilio Rao 
733a7e81cb3SAlan Somers 	fuse_filehandle_init(*vpp, FUFH_RDWR, NULL, td, cred, foo);
73419ef317dSAlan Somers 	fuse_vnode_open(*vpp, foo->open_flags, td);
735002e54b0SAlan Somers 	/*
736002e54b0SAlan Somers 	 * Purge the parent's attribute cache because the daemon should've
737002e54b0SAlan Somers 	 * updated its mtime and ctime
738002e54b0SAlan Somers 	 */
739002e54b0SAlan Somers 	fuse_vnode_clear_attr_cache(dvp);
7405fe58019SAttilio Rao 	cache_purge_negative(dvp);
7415fe58019SAttilio Rao 
7425fe58019SAttilio Rao out:
74319ef317dSAlan Somers 	if (fdip2)
74419ef317dSAlan Somers 		fdisp_destroy(fdip2);
7455fe58019SAttilio Rao 	fdisp_destroy(fdip);
7465fe58019SAttilio Rao 	return err;
7475fe58019SAttilio Rao }
7485fe58019SAttilio Rao 
7495fe58019SAttilio Rao /*
750915012e0SAlan Somers     struct vnop_fdatasync_args {
751915012e0SAlan Somers 	struct vop_generic_args a_gen;
752915012e0SAlan Somers 	struct vnode * a_vp;
753915012e0SAlan Somers 	struct thread * a_td;
754915012e0SAlan Somers     };
7555fe58019SAttilio Rao */
756915012e0SAlan Somers static int
757915012e0SAlan Somers fuse_vnop_fdatasync(struct vop_fdatasync_args *ap)
758915012e0SAlan Somers {
759915012e0SAlan Somers 	struct vnode *vp = ap->a_vp;
760915012e0SAlan Somers 	struct thread *td = ap->a_td;
761915012e0SAlan Somers 	int waitfor = MNT_WAIT;
762915012e0SAlan Somers 
763915012e0SAlan Somers 	int err = 0;
764915012e0SAlan Somers 
765915012e0SAlan Somers 	if (fuse_isdeadfs(vp)) {
766915012e0SAlan Somers 		return 0;
767915012e0SAlan Somers 	}
768915012e0SAlan Somers 	if ((err = vop_stdfdatasync_buf(ap)))
769915012e0SAlan Somers 		return err;
770915012e0SAlan Somers 
771915012e0SAlan Somers 	return fuse_internal_fsync(vp, td, waitfor, true);
772915012e0SAlan Somers }
7735fe58019SAttilio Rao 
7745fe58019SAttilio Rao /*
7755fe58019SAttilio Rao     struct vnop_fsync_args {
776915012e0SAlan Somers 	struct vop_generic_args a_gen;
7775fe58019SAttilio Rao 	struct vnode * a_vp;
7785fe58019SAttilio Rao 	int  a_waitfor;
7795fe58019SAttilio Rao 	struct thread * a_td;
7805fe58019SAttilio Rao     };
7815fe58019SAttilio Rao */
7825fe58019SAttilio Rao static int
7835fe58019SAttilio Rao fuse_vnop_fsync(struct vop_fsync_args *ap)
7845fe58019SAttilio Rao {
7855fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
7865fe58019SAttilio Rao 	struct thread *td = ap->a_td;
78790612f3cSAlan Somers 	int waitfor = ap->a_waitfor;
788915012e0SAlan Somers 	int err = 0;
7895fe58019SAttilio Rao 
7905fe58019SAttilio Rao 	if (fuse_isdeadfs(vp)) {
7915fe58019SAttilio Rao 		return 0;
7925fe58019SAttilio Rao 	}
7935fe58019SAttilio Rao 	if ((err = vop_stdfsync(ap)))
7945fe58019SAttilio Rao 		return err;
7955fe58019SAttilio Rao 
796915012e0SAlan Somers 	return fuse_internal_fsync(vp, td, waitfor, false);
7975fe58019SAttilio Rao }
7985fe58019SAttilio Rao 
7995fe58019SAttilio Rao /*
8005fe58019SAttilio Rao     struct vnop_getattr_args {
8015fe58019SAttilio Rao 	struct vnode *a_vp;
8025fe58019SAttilio Rao 	struct vattr *a_vap;
8035fe58019SAttilio Rao 	struct ucred *a_cred;
8045fe58019SAttilio Rao 	struct thread *a_td;
8055fe58019SAttilio Rao     };
8065fe58019SAttilio Rao */
8075fe58019SAttilio Rao static int
8085fe58019SAttilio Rao fuse_vnop_getattr(struct vop_getattr_args *ap)
8095fe58019SAttilio Rao {
8105fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
8115fe58019SAttilio Rao 	struct vattr *vap = ap->a_vap;
8125fe58019SAttilio Rao 	struct ucred *cred = ap->a_cred;
8135fe58019SAttilio Rao 	struct thread *td = curthread;
8145fe58019SAttilio Rao 
8155fe58019SAttilio Rao 	int err = 0;
8165fe58019SAttilio Rao 	int dataflags;
8175fe58019SAttilio Rao 
8185fe58019SAttilio Rao 	dataflags = fuse_get_mpdata(vnode_mount(vp))->dataflags;
8195fe58019SAttilio Rao 
8205fe58019SAttilio Rao 	/* Note that we are not bailing out on a dead file system just yet. */
8215fe58019SAttilio Rao 
8225fe58019SAttilio Rao 	if (!(dataflags & FSESS_INITED)) {
8235fe58019SAttilio Rao 		if (!vnode_isvroot(vp)) {
8245fe58019SAttilio Rao 			fdata_set_dead(fuse_get_mpdata(vnode_mount(vp)));
8255fe58019SAttilio Rao 			err = ENOTCONN;
8265fe58019SAttilio Rao 			return err;
8275fe58019SAttilio Rao 		} else {
8285fe58019SAttilio Rao 			goto fake;
8295fe58019SAttilio Rao 		}
8305fe58019SAttilio Rao 	}
831cad67791SAlan Somers 	err = fuse_internal_getattr(vp, vap, cred, td);
832cad67791SAlan Somers 	if (err == ENOTCONN && vnode_isvroot(vp)) {
833cf169498SAlan Somers 		/* see comment in fuse_vfsop_statfs() */
8345fe58019SAttilio Rao 		goto fake;
835cad67791SAlan Somers 	} else {
8365fe58019SAttilio Rao 		return err;
837cad67791SAlan Somers 	}
8385fe58019SAttilio Rao 
8395fe58019SAttilio Rao fake:
8405fe58019SAttilio Rao 	bzero(vap, sizeof(*vap));
8415fe58019SAttilio Rao 	vap->va_type = vnode_vtype(vp);
8425fe58019SAttilio Rao 
8435fe58019SAttilio Rao 	return 0;
8445fe58019SAttilio Rao }
8455fe58019SAttilio Rao 
8465fe58019SAttilio Rao /*
8475fe58019SAttilio Rao     struct vnop_inactive_args {
8485fe58019SAttilio Rao 	struct vnode *a_vp;
8495fe58019SAttilio Rao 	struct thread *a_td;
8505fe58019SAttilio Rao     };
8515fe58019SAttilio Rao */
8525fe58019SAttilio Rao static int
8535fe58019SAttilio Rao fuse_vnop_inactive(struct vop_inactive_args *ap)
8545fe58019SAttilio Rao {
8555fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
8565fe58019SAttilio Rao 	struct thread *td = ap->a_td;
8575fe58019SAttilio Rao 
8585fe58019SAttilio Rao 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
8595ec10aa5SAlan Somers 	struct fuse_filehandle *fufh, *fufh_tmp;
8605fe58019SAttilio Rao 
8615ec10aa5SAlan Somers 	int need_flush = 1;
8625fe58019SAttilio Rao 
8635ec10aa5SAlan Somers 	LIST_FOREACH_SAFE(fufh, &fvdat->handles, next, fufh_tmp) {
8645fe58019SAttilio Rao 		if (need_flush && vp->v_type == VREG) {
8655fe58019SAttilio Rao 			if ((VTOFUD(vp)->flag & FN_SIZECHANGE) != 0) {
866f8d4af10SAlan Somers 				fuse_vnode_savesize(vp, NULL, 0);
8675fe58019SAttilio Rao 			}
8685940f822SAlan Somers 			if ((fvdat->flag & FN_REVOKED) != 0)
8695fe58019SAttilio Rao 				fuse_io_invalbuf(vp, td);
8705fe58019SAttilio Rao 			else
8715fe58019SAttilio Rao 				fuse_io_flushbuf(vp, MNT_WAIT, td);
8725fe58019SAttilio Rao 			need_flush = 0;
8735fe58019SAttilio Rao 		}
8745ec10aa5SAlan Somers 		fuse_filehandle_close(vp, fufh, td, NULL);
8755fe58019SAttilio Rao 	}
8765fe58019SAttilio Rao 
877435ecf40SAlan Somers 	if ((fvdat->flag & FN_REVOKED) != 0)
8785fe58019SAttilio Rao 		vrecycle(vp);
879435ecf40SAlan Somers 
8805fe58019SAttilio Rao 	return 0;
8815fe58019SAttilio Rao }
8825fe58019SAttilio Rao 
8835fe58019SAttilio Rao /*
8845fe58019SAttilio Rao     struct vnop_link_args {
8855fe58019SAttilio Rao 	struct vnode *a_tdvp;
8865fe58019SAttilio Rao 	struct vnode *a_vp;
8875fe58019SAttilio Rao 	struct componentname *a_cnp;
8885fe58019SAttilio Rao     };
8895fe58019SAttilio Rao */
8905fe58019SAttilio Rao static int
8915fe58019SAttilio Rao fuse_vnop_link(struct vop_link_args *ap)
8925fe58019SAttilio Rao {
8935fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
8945fe58019SAttilio Rao 	struct vnode *tdvp = ap->a_tdvp;
8955fe58019SAttilio Rao 	struct componentname *cnp = ap->a_cnp;
8965fe58019SAttilio Rao 
8975fe58019SAttilio Rao 	struct vattr *vap = VTOVA(vp);
8985fe58019SAttilio Rao 
8995fe58019SAttilio Rao 	struct fuse_dispatcher fdi;
9005fe58019SAttilio Rao 	struct fuse_entry_out *feo;
9015fe58019SAttilio Rao 	struct fuse_link_in fli;
9025fe58019SAttilio Rao 
9035fe58019SAttilio Rao 	int err;
9045fe58019SAttilio Rao 
9055fe58019SAttilio Rao 	if (fuse_isdeadfs(vp)) {
9065fe58019SAttilio Rao 		return ENXIO;
9075fe58019SAttilio Rao 	}
9085fe58019SAttilio Rao 	if (vnode_mount(tdvp) != vnode_mount(vp)) {
9095fe58019SAttilio Rao 		return EXDEV;
9105fe58019SAttilio Rao 	}
91178a7722fSConrad Meyer 
91278a7722fSConrad Meyer 	/*
91378a7722fSConrad Meyer 	 * This is a seatbelt check to protect naive userspace filesystems from
91478a7722fSConrad Meyer 	 * themselves and the limitations of the FUSE IPC protocol.  If a
91578a7722fSConrad Meyer 	 * filesystem does not allow attribute caching, assume it is capable of
91678a7722fSConrad Meyer 	 * validating that nlink does not overflow.
91778a7722fSConrad Meyer 	 */
91878a7722fSConrad Meyer 	if (vap != NULL && vap->va_nlink >= FUSE_LINK_MAX)
9195fe58019SAttilio Rao 		return EMLINK;
9205fe58019SAttilio Rao 	fli.oldnodeid = VTOI(vp);
9215fe58019SAttilio Rao 
9225fe58019SAttilio Rao 	fdisp_init(&fdi, 0);
9235fe58019SAttilio Rao 	fuse_internal_newentry_makerequest(vnode_mount(tdvp), VTOI(tdvp), cnp,
9245fe58019SAttilio Rao 	    FUSE_LINK, &fli, sizeof(fli), &fdi);
9255fe58019SAttilio Rao 	if ((err = fdisp_wait_answ(&fdi))) {
9265fe58019SAttilio Rao 		goto out;
9275fe58019SAttilio Rao 	}
9285fe58019SAttilio Rao 	feo = fdi.answ;
9295fe58019SAttilio Rao 
9305fe58019SAttilio Rao 	err = fuse_internal_checkentry(feo, vnode_vtype(vp));
931002e54b0SAlan Somers 	if (!err) {
932002e54b0SAlan Somers 		/*
933002e54b0SAlan Somers 		 * Purge the parent's attribute cache because the daemon
934002e54b0SAlan Somers 		 * should've updated its mtime and ctime
935002e54b0SAlan Somers 		 */
936002e54b0SAlan Somers 		fuse_vnode_clear_attr_cache(tdvp);
9370269ae4cSAlan Somers 		fuse_internal_cache_attrs(vp, &feo->attr, feo->attr_valid,
9384ae3a56cSAlan Somers 			feo->attr_valid_nsec, NULL);
939002e54b0SAlan Somers 	}
9405fe58019SAttilio Rao out:
9415fe58019SAttilio Rao 	fdisp_destroy(&fdi);
9425fe58019SAttilio Rao 	return err;
9435fe58019SAttilio Rao }
9445fe58019SAttilio Rao 
945dc14d593SAlan Somers struct fuse_lookup_alloc_arg {
946dc14d593SAlan Somers 	struct fuse_entry_out *feo;
947dc14d593SAlan Somers 	struct componentname *cnp;
948dc14d593SAlan Somers 	uint64_t nid;
949dc14d593SAlan Somers 	enum vtype vtyp;
950dc14d593SAlan Somers };
951dc14d593SAlan Somers 
952dc14d593SAlan Somers /* Callback for vn_get_ino */
953dc14d593SAlan Somers static int
954dc14d593SAlan Somers fuse_lookup_alloc(struct mount *mp, void *arg, int lkflags, struct vnode **vpp)
955dc14d593SAlan Somers {
956dc14d593SAlan Somers 	struct fuse_lookup_alloc_arg *flaa = arg;
957dc14d593SAlan Somers 
958dc14d593SAlan Somers 	return fuse_vnode_get(mp, flaa->feo, flaa->nid, NULL, vpp, flaa->cnp,
959dc14d593SAlan Somers 		flaa->vtyp);
960dc14d593SAlan Somers }
961dc14d593SAlan Somers 
962419e7ff6SAlan Somers SDT_PROBE_DEFINE3(fusefs, , vnops, cache_lookup,
963ccb75e49SAlan Somers 	"int", "struct timespec*", "struct timespec*");
9645fe58019SAttilio Rao /*
9655fe58019SAttilio Rao     struct vnop_lookup_args {
9665fe58019SAttilio Rao 	struct vnodeop_desc *a_desc;
9675fe58019SAttilio Rao 	struct vnode *a_dvp;
9685fe58019SAttilio Rao 	struct vnode **a_vpp;
9695fe58019SAttilio Rao 	struct componentname *a_cnp;
9705fe58019SAttilio Rao     };
9715fe58019SAttilio Rao */
9725fe58019SAttilio Rao int
9735fe58019SAttilio Rao fuse_vnop_lookup(struct vop_lookup_args *ap)
9745fe58019SAttilio Rao {
9755fe58019SAttilio Rao 	struct vnode *dvp = ap->a_dvp;
9765fe58019SAttilio Rao 	struct vnode **vpp = ap->a_vpp;
9775fe58019SAttilio Rao 	struct componentname *cnp = ap->a_cnp;
9785fe58019SAttilio Rao 	struct thread *td = cnp->cn_thread;
9795fe58019SAttilio Rao 	struct ucred *cred = cnp->cn_cred;
9805fe58019SAttilio Rao 
9815fe58019SAttilio Rao 	int nameiop = cnp->cn_nameiop;
9825fe58019SAttilio Rao 	int flags = cnp->cn_flags;
9835fe58019SAttilio Rao 	int wantparent = flags & (LOCKPARENT | WANTPARENT);
9845fe58019SAttilio Rao 	int islastcn = flags & ISLASTCN;
9855fe58019SAttilio Rao 	struct mount *mp = vnode_mount(dvp);
9865fe58019SAttilio Rao 
9875fe58019SAttilio Rao 	int err = 0;
9885fe58019SAttilio Rao 	int lookup_err = 0;
9895fe58019SAttilio Rao 	struct vnode *vp = NULL;
9905fe58019SAttilio Rao 
9915fe58019SAttilio Rao 	struct fuse_dispatcher fdi;
992438b8a6fSAlan Somers 	bool did_lookup = false;
99344f10c6eSAlan Somers 	struct fuse_entry_out *feo = NULL;
994438b8a6fSAlan Somers 	enum vtype vtyp;	/* vnode type of target */
995438b8a6fSAlan Somers 	off_t filesize;		/* filesize of target */
9965fe58019SAttilio Rao 
9975fe58019SAttilio Rao 	uint64_t nid;
9985fe58019SAttilio Rao 
9995fe58019SAttilio Rao 	if (fuse_isdeadfs(dvp)) {
10005fe58019SAttilio Rao 		*vpp = NULL;
10015fe58019SAttilio Rao 		return ENXIO;
10025fe58019SAttilio Rao 	}
100373825da3SAlan Somers 	if (!vnode_isdir(dvp))
10045fe58019SAttilio Rao 		return ENOTDIR;
10055fe58019SAttilio Rao 
100673825da3SAlan Somers 	if (islastcn && vfs_isrdonly(mp) && (nameiop != LOOKUP))
100773825da3SAlan Somers 		return EROFS;
100873825da3SAlan Somers 
1009*6a5abb1eSKyle Evans 	if ((cnp->cn_flags & NOEXECCHECK) != 0)
1010*6a5abb1eSKyle Evans 		cnp->cn_flags &= ~NOEXECCHECK;
1011*6a5abb1eSKyle Evans 	else if ((err = fuse_internal_access(dvp, VEXEC, td, cred)))
10125fe58019SAttilio Rao 		return err;
101373825da3SAlan Somers 
10145fe58019SAttilio Rao 	if (flags & ISDOTDOT) {
1015e5b50fe7SAlan Somers 		KASSERT(VTOFUD(dvp)->flag & FN_PARENT_NID,
1016e5b50fe7SAlan Somers 			("Looking up .. is TODO"));
10175fe58019SAttilio Rao 		nid = VTOFUD(dvp)->parent_nid;
1018438b8a6fSAlan Somers 		if (nid == 0)
10195fe58019SAttilio Rao 			return ENOENT;
1020438b8a6fSAlan Somers 		/* .. is obviously a directory */
1021438b8a6fSAlan Somers 		vtyp = VDIR;
1022438b8a6fSAlan Somers 		filesize = 0;
10235fe58019SAttilio Rao 	} else if (cnp->cn_namelen == 1 && *(cnp->cn_nameptr) == '.') {
10245fe58019SAttilio Rao 		nid = VTOI(dvp);
1025438b8a6fSAlan Somers 		/* . is obviously a directory */
1026438b8a6fSAlan Somers 		vtyp = VDIR;
1027438b8a6fSAlan Somers 		filesize = 0;
1028ccb75e49SAlan Somers 	} else {
10293f2c630cSAlan Somers 		struct timespec now, timeout;
10303f2c630cSAlan Somers 
10313f2c630cSAlan Somers 		err = cache_lookup(dvp, vpp, cnp, &timeout, NULL);
10323f2c630cSAlan Somers 		getnanouptime(&now);
1033419e7ff6SAlan Somers 		SDT_PROBE3(fusefs, , vnops, cache_lookup, err, &timeout, &now);
1034ccb75e49SAlan Somers 		switch (err) {
1035ccb75e49SAlan Somers 		case -1:		/* positive match */
1036ccb75e49SAlan Somers 			if (timespeccmp(&timeout, &now, >)) {
1037560a55d0SAlan Somers 				counter_u64_add(fuse_lookup_cache_hits, 1);
10383f2c630cSAlan Somers 			} else {
10393f2c630cSAlan Somers 				/* Cache timeout */
1040560a55d0SAlan Somers 				counter_u64_add(fuse_lookup_cache_misses, 1);
10410d2bf489SAlan Somers 				bintime_clear(
10420d2bf489SAlan Somers 					&VTOFUD(*vpp)->entry_cache_timeout);
10434683b905SAlan Somers 				cache_purge(*vpp);
1044ccb75e49SAlan Somers 				if (dvp != *vpp)
1045ccb75e49SAlan Somers 					vput(*vpp);
1046ccb75e49SAlan Somers 				else
1047ccb75e49SAlan Somers 					vrele(*vpp);
1048ccb75e49SAlan Somers 				*vpp = NULL;
10493f2c630cSAlan Somers 				break;
10503f2c630cSAlan Somers 			}
10513f2c630cSAlan Somers 			return 0;
10523f2c630cSAlan Somers 
10533f2c630cSAlan Somers 		case 0:		/* no match in cache */
1054560a55d0SAlan Somers 			counter_u64_add(fuse_lookup_cache_misses, 1);
10553f2c630cSAlan Somers 			break;
10563f2c630cSAlan Somers 
10573f2c630cSAlan Somers 		case ENOENT:		/* negative match */
10583f2c630cSAlan Somers 			getnanouptime(&now);
1059ccb75e49SAlan Somers 			if (timespeccmp(&timeout, &now, <=)) {
10603f2c630cSAlan Somers 				/* Cache timeout */
1061ccb75e49SAlan Somers 				cache_purge_negative(dvp);
10623f2c630cSAlan Somers 				break;
10633f2c630cSAlan Somers 			}
10643f2c630cSAlan Somers 			/* fall through */
10653f2c630cSAlan Somers 		default:
10663f2c630cSAlan Somers 			return err;
10673f2c630cSAlan Somers 		}
1068438b8a6fSAlan Somers 
10695fe58019SAttilio Rao 		nid = VTOI(dvp);
10705fe58019SAttilio Rao 		fdisp_init(&fdi, cnp->cn_namelen + 1);
1071438b8a6fSAlan Somers 		fdisp_make(&fdi, FUSE_LOOKUP, mp, nid, td, cred);
10725fe58019SAttilio Rao 
10735fe58019SAttilio Rao 		memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
10745fe58019SAttilio Rao 		((char *)fdi.indata)[cnp->cn_namelen] = '\0';
10755fe58019SAttilio Rao 		lookup_err = fdisp_wait_answ(&fdi);
1076438b8a6fSAlan Somers 		did_lookup = true;
10775fe58019SAttilio Rao 
1078438b8a6fSAlan Somers 		if (!lookup_err) {
1079ccb75e49SAlan Somers 			/* lookup call succeeded */
1080438b8a6fSAlan Somers 			feo = (struct fuse_entry_out *)fdi.answ;
1081e5b50fe7SAlan Somers 			nid = feo->nodeid;
108244f10c6eSAlan Somers 			if (nid == 0) {
108344f10c6eSAlan Somers 				/* zero nodeid means ENOENT and cache it */
108444f10c6eSAlan Somers 				struct timespec timeout;
108544f10c6eSAlan Somers 
10866248288eSAlan Somers 				fdi.answ_stat = ENOENT;
10875fe58019SAttilio Rao 				lookup_err = ENOENT;
108844f10c6eSAlan Somers 				if (cnp->cn_flags & MAKEENTRY) {
108944f10c6eSAlan Somers 					fuse_validity_2_timespec(feo, &timeout);
1090438b8a6fSAlan Somers 					cache_enter_time(dvp, *vpp, cnp,
1091438b8a6fSAlan Somers 						&timeout, NULL);
109244f10c6eSAlan Somers 				}
10935fe58019SAttilio Rao 			} else if (nid == FUSE_ROOT_ID) {
10945fe58019SAttilio Rao 				lookup_err = EINVAL;
10955fe58019SAttilio Rao 			}
1096438b8a6fSAlan Somers 			vtyp = IFTOVT(feo->attr.mode);
1097438b8a6fSAlan Somers 			filesize = feo->attr.size;
10985fe58019SAttilio Rao 		}
1099438b8a6fSAlan Somers 		if (lookup_err && (!fdi.answ_stat || lookup_err != ENOENT)) {
11005fe58019SAttilio Rao 			fdisp_destroy(&fdi);
11015fe58019SAttilio Rao 			return lookup_err;
11025fe58019SAttilio Rao 		}
1103438b8a6fSAlan Somers 	}
11045fe58019SAttilio Rao 	/* lookup_err, if non-zero, must be ENOENT at this point */
11055fe58019SAttilio Rao 
11065fe58019SAttilio Rao 	if (lookup_err) {
1107ff4fbdf5SAlan Somers 		/* Entry not found */
1108ff4fbdf5SAlan Somers 		if ((nameiop == CREATE || nameiop == RENAME) && islastcn) {
1109666f8543SAlan Somers 			err = fuse_internal_access(dvp, VWRITE, td, cred);
11106124fd71SAlan Somers 			if (!err) {
11115fe58019SAttilio Rao 				/*
1112dc14d593SAlan Somers 				 * Set the SAVENAME flag to hold onto the
11136124fd71SAlan Somers 				 * pathname for use later in VOP_CREATE or
11146124fd71SAlan Somers 				 * VOP_RENAME.
11155fe58019SAttilio Rao 				 */
11165fe58019SAttilio Rao 				cnp->cn_flags |= SAVENAME;
11175fe58019SAttilio Rao 
11185fe58019SAttilio Rao 				err = EJUSTRETURN;
11195fe58019SAttilio Rao 			}
11206124fd71SAlan Somers 		} else {
11215fe58019SAttilio Rao 			err = ENOENT;
11226124fd71SAlan Somers 		}
11235fe58019SAttilio Rao 	} else {
1124ff4fbdf5SAlan Somers 		/* Entry was found */
11255fe58019SAttilio Rao 		if (flags & ISDOTDOT) {
1126dc14d593SAlan Somers 			struct fuse_lookup_alloc_arg flaa;
11275fe58019SAttilio Rao 
1128dc14d593SAlan Somers 			flaa.nid = nid;
1129dc14d593SAlan Somers 			flaa.feo = feo;
1130dc14d593SAlan Somers 			flaa.cnp = cnp;
1131dc14d593SAlan Somers 			flaa.vtyp = vtyp;
1132dc14d593SAlan Somers 			err = vn_vget_ino_gen(dvp, fuse_lookup_alloc, &flaa, 0,
1133dc14d593SAlan Somers 				&vp);
11345fe58019SAttilio Rao 			*vpp = vp;
11355fe58019SAttilio Rao 		} else if (nid == VTOI(dvp)) {
11365fe58019SAttilio Rao 			vref(dvp);
11375fe58019SAttilio Rao 			*vpp = dvp;
11385fe58019SAttilio Rao 		} else {
11393c324b94SConrad Meyer 			struct fuse_vnode_data *fvdat;
11403c324b94SConrad Meyer 
114109176f09SConrad Meyer 			err = fuse_vnode_get(vnode_mount(dvp), feo, nid, dvp,
1142438b8a6fSAlan Somers 			    &vp, cnp, vtyp);
11436124fd71SAlan Somers 			if (err)
11445fe58019SAttilio Rao 				goto out;
11456124fd71SAlan Somers 			*vpp = vp;
11466124fd71SAlan Somers 
11473c324b94SConrad Meyer 			/*
11483c324b94SConrad Meyer 			 * In the case where we are looking up a FUSE node
11493c324b94SConrad Meyer 			 * represented by an existing cached vnode, and the
11503c324b94SConrad Meyer 			 * true size reported by FUSE_LOOKUP doesn't match
11512013b723SAlan Somers 			 * the vnode's cached size, then any cached writes
11522013b723SAlan Somers 			 * beyond the file's current size are lost.
11533c324b94SConrad Meyer 			 *
11546124fd71SAlan Somers 			 * We can get here:
11556124fd71SAlan Somers 			 * * following attribute cache expiration, or
11566124fd71SAlan Somers 			 * * due a bug in the daemon, or
11573c324b94SConrad Meyer 			 */
11583c324b94SConrad Meyer 			fvdat = VTOFUD(vp);
11593c324b94SConrad Meyer 			if (vnode_isreg(vp) &&
11602013b723SAlan Somers 			    filesize != fvdat->cached_attrs.va_size &&
11612013b723SAlan Somers 			    fvdat->flag & FN_SIZECHANGE) {
11623c324b94SConrad Meyer 				/*
11633c324b94SConrad Meyer 				 * The FN_SIZECHANGE flag reflects a dirty
11643c324b94SConrad Meyer 				 * append.  If userspace lets us know our cache
11653c324b94SConrad Meyer 				 * is invalid, that write was lost.  (Dirty
11663c324b94SConrad Meyer 				 * writes that do not cause append are also
11673c324b94SConrad Meyer 				 * lost, but we don't detect them here.)
11683c324b94SConrad Meyer 				 *
11693c324b94SConrad Meyer 				 * XXX: Maybe disable WB caching on this mount.
11703c324b94SConrad Meyer 				 */
11712013b723SAlan Somers 				printf("%s: WB cache incoherent on %s!\n",
11722013b723SAlan Somers 				    __func__,
11733c324b94SConrad Meyer 				    vnode_mount(vp)->mnt_stat.f_mntonname);
11743c324b94SConrad Meyer 
11753c324b94SConrad Meyer 				fvdat->flag &= ~FN_SIZECHANGE;
11763c324b94SConrad Meyer 			}
11775fe58019SAttilio Rao 
11786124fd71SAlan Somers 			MPASS(feo != NULL);
11790269ae4cSAlan Somers 			fuse_internal_cache_attrs(*vpp, &feo->attr,
1180438b8a6fSAlan Somers 				feo->attr_valid, feo->attr_valid_nsec, NULL);
11810d2bf489SAlan Somers 			fuse_validity_2_bintime(feo->entry_valid,
11820d2bf489SAlan Somers 				feo->entry_valid_nsec,
11830d2bf489SAlan Somers 				&fvdat->entry_cache_timeout);
11846124fd71SAlan Somers 
11856124fd71SAlan Somers 			if ((nameiop == DELETE || nameiop == RENAME) &&
11866124fd71SAlan Somers 				islastcn)
11876124fd71SAlan Somers 			{
11886124fd71SAlan Somers 				struct vattr dvattr;
11896124fd71SAlan Somers 
11906124fd71SAlan Somers 				err = fuse_internal_access(dvp, VWRITE, td,
11916124fd71SAlan Somers 					cred);
11926124fd71SAlan Somers 				if (err != 0)
11936124fd71SAlan Somers 					goto out;
11946124fd71SAlan Somers 				/*
11956124fd71SAlan Somers 				 * if the parent's sticky bit is set, check
11966124fd71SAlan Somers 				 * whether we're allowed to remove the file.
11976124fd71SAlan Somers 				 * Need to figure out the vnode locking to make
11986124fd71SAlan Somers 				 * this work.
11996124fd71SAlan Somers 				 */
12006124fd71SAlan Somers 				fuse_internal_getattr(dvp, &dvattr, cred, td);
12016124fd71SAlan Somers 				if ((dvattr.va_mode & S_ISTXT) &&
12026124fd71SAlan Somers 					fuse_internal_access(dvp, VADMIN, td,
12036124fd71SAlan Somers 						cred) &&
12046124fd71SAlan Somers 					fuse_internal_access(*vpp, VADMIN, td,
12056124fd71SAlan Somers 						cred)) {
12066124fd71SAlan Somers 					err = EPERM;
12076124fd71SAlan Somers 					goto out;
12086124fd71SAlan Somers 				}
12096124fd71SAlan Somers 			}
12106124fd71SAlan Somers 
12116124fd71SAlan Somers 			if (islastcn && (
12126124fd71SAlan Somers 				(nameiop == DELETE) ||
12136124fd71SAlan Somers 				(nameiop == RENAME && wantparent))) {
12146124fd71SAlan Somers 				cnp->cn_flags |= SAVENAME;
12156124fd71SAlan Somers 			}
12166124fd71SAlan Somers 
12175fe58019SAttilio Rao 		}
12185fe58019SAttilio Rao 	}
12195fe58019SAttilio Rao out:
12206124fd71SAlan Somers 	if (err) {
12216124fd71SAlan Somers 		if (vp != NULL && dvp != vp)
12226124fd71SAlan Somers 			vput(vp);
12236124fd71SAlan Somers 		else if (vp != NULL)
12246124fd71SAlan Somers 			vrele(vp);
12256124fd71SAlan Somers 		*vpp = NULL;
12265fe58019SAttilio Rao 	}
1227438b8a6fSAlan Somers 	if (did_lookup)
12285fe58019SAttilio Rao 		fdisp_destroy(&fdi);
12295fe58019SAttilio Rao 
12305fe58019SAttilio Rao 	return err;
12315fe58019SAttilio Rao }
12325fe58019SAttilio Rao 
12335fe58019SAttilio Rao /*
12345fe58019SAttilio Rao     struct vnop_mkdir_args {
12355fe58019SAttilio Rao 	struct vnode *a_dvp;
12365fe58019SAttilio Rao 	struct vnode **a_vpp;
12375fe58019SAttilio Rao 	struct componentname *a_cnp;
12385fe58019SAttilio Rao 	struct vattr *a_vap;
12395fe58019SAttilio Rao     };
12405fe58019SAttilio Rao */
12415fe58019SAttilio Rao static int
12425fe58019SAttilio Rao fuse_vnop_mkdir(struct vop_mkdir_args *ap)
12435fe58019SAttilio Rao {
12445fe58019SAttilio Rao 	struct vnode *dvp = ap->a_dvp;
12455fe58019SAttilio Rao 	struct vnode **vpp = ap->a_vpp;
12465fe58019SAttilio Rao 	struct componentname *cnp = ap->a_cnp;
12475fe58019SAttilio Rao 	struct vattr *vap = ap->a_vap;
12485fe58019SAttilio Rao 
12495fe58019SAttilio Rao 	struct fuse_mkdir_in fmdi;
12505fe58019SAttilio Rao 
12515fe58019SAttilio Rao 	if (fuse_isdeadfs(dvp)) {
12525fe58019SAttilio Rao 		return ENXIO;
12535fe58019SAttilio Rao 	}
12545fe58019SAttilio Rao 	fmdi.mode = MAKEIMODE(vap->va_type, vap->va_mode);
1255a4856c96SAlan Somers 	fmdi.umask = curthread->td_proc->p_fd->fd_cmask;
12565fe58019SAttilio Rao 
1257d9454fabSAttilio Rao 	return (fuse_internal_newentry(dvp, vpp, cnp, FUSE_MKDIR, &fmdi,
1258d9454fabSAttilio Rao 	    sizeof(fmdi), VDIR));
12595fe58019SAttilio Rao }
12605fe58019SAttilio Rao 
12615fe58019SAttilio Rao /*
12625fe58019SAttilio Rao     struct vnop_mknod_args {
12635fe58019SAttilio Rao 	struct vnode *a_dvp;
12645fe58019SAttilio Rao 	struct vnode **a_vpp;
12655fe58019SAttilio Rao 	struct componentname *a_cnp;
12665fe58019SAttilio Rao 	struct vattr *a_vap;
12675fe58019SAttilio Rao     };
12685fe58019SAttilio Rao */
12695fe58019SAttilio Rao static int
12705fe58019SAttilio Rao fuse_vnop_mknod(struct vop_mknod_args *ap)
12715fe58019SAttilio Rao {
12725fe58019SAttilio Rao 
1273bf4d7084SAlan Somers 	struct vnode *dvp = ap->a_dvp;
1274bf4d7084SAlan Somers 	struct vnode **vpp = ap->a_vpp;
1275bf4d7084SAlan Somers 	struct componentname *cnp = ap->a_cnp;
1276bf4d7084SAlan Somers 	struct vattr *vap = ap->a_vap;
12775fe58019SAttilio Rao 
1278bf4d7084SAlan Somers 	if (fuse_isdeadfs(dvp))
1279bf4d7084SAlan Somers 		return ENXIO;
1280bf4d7084SAlan Somers 
1281d5ff2688SAlan Somers 	return fuse_internal_mknod(dvp, vpp, cnp, vap);
1282bf4d7084SAlan Somers }
12835fe58019SAttilio Rao 
12845fe58019SAttilio Rao /*
1285e76986fdSAlan Somers     struct vop_open_args {
12865fe58019SAttilio Rao 	struct vnode *a_vp;
12875fe58019SAttilio Rao 	int  a_mode;
12885fe58019SAttilio Rao 	struct ucred *a_cred;
12895fe58019SAttilio Rao 	struct thread *a_td;
12905fe58019SAttilio Rao 	int a_fdidx; / struct file *a_fp;
12915fe58019SAttilio Rao     };
12925fe58019SAttilio Rao */
12935fe58019SAttilio Rao static int
12945fe58019SAttilio Rao fuse_vnop_open(struct vop_open_args *ap)
12955fe58019SAttilio Rao {
12965fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
12979e444871SAlan Somers 	int a_mode = ap->a_mode;
12985fe58019SAttilio Rao 	struct thread *td = ap->a_td;
12995fe58019SAttilio Rao 	struct ucred *cred = ap->a_cred;
1300f8d4af10SAlan Somers 	pid_t pid = td->td_proc->p_pid;
13015fe58019SAttilio Rao 	struct fuse_vnode_data *fvdat;
13025fe58019SAttilio Rao 
1303bf4d7084SAlan Somers 	if (fuse_isdeadfs(vp))
13045fe58019SAttilio Rao 		return ENXIO;
1305bf4d7084SAlan Somers 	if (vp->v_type == VCHR || vp->v_type == VBLK || vp->v_type == VFIFO)
1306bf4d7084SAlan Somers 		return (EOPNOTSUPP);
13079e444871SAlan Somers 	if ((a_mode & (FREAD | FWRITE | FEXEC)) == 0)
1308e7df9886SConrad Meyer 		return EINVAL;
1309e7df9886SConrad Meyer 
13105fe58019SAttilio Rao 	fvdat = VTOFUD(vp);
13115fe58019SAttilio Rao 
13129e444871SAlan Somers 	if (fuse_filehandle_validrw(vp, a_mode, cred, pid)) {
13135fccbf31SAlan Somers 		fuse_vnode_open(vp, 0, td);
13145fe58019SAttilio Rao 		return 0;
13155fe58019SAttilio Rao 	}
13165fe58019SAttilio Rao 
13179e444871SAlan Somers 	return fuse_filehandle_open(vp, a_mode, NULL, td, cred);
13185fe58019SAttilio Rao }
13195fe58019SAttilio Rao 
1320746c92e0SJohn Baldwin static int
1321746c92e0SJohn Baldwin fuse_vnop_pathconf(struct vop_pathconf_args *ap)
1322746c92e0SJohn Baldwin {
1323746c92e0SJohn Baldwin 
1324746c92e0SJohn Baldwin 	switch (ap->a_name) {
1325746c92e0SJohn Baldwin 	case _PC_FILESIZEBITS:
1326746c92e0SJohn Baldwin 		*ap->a_retval = 64;
1327746c92e0SJohn Baldwin 		return (0);
1328599afe53SJohn Baldwin 	case _PC_NAME_MAX:
1329599afe53SJohn Baldwin 		*ap->a_retval = NAME_MAX;
1330599afe53SJohn Baldwin 		return (0);
1331599afe53SJohn Baldwin 	case _PC_LINK_MAX:
1332f83f3d79SJohn Baldwin 		*ap->a_retval = MIN(LONG_MAX, FUSE_LINK_MAX);
1333599afe53SJohn Baldwin 		return (0);
1334746c92e0SJohn Baldwin 	case _PC_SYMLINK_MAX:
1335746c92e0SJohn Baldwin 		*ap->a_retval = MAXPATHLEN;
1336746c92e0SJohn Baldwin 		return (0);
1337746c92e0SJohn Baldwin 	case _PC_NO_TRUNC:
1338746c92e0SJohn Baldwin 		*ap->a_retval = 1;
1339746c92e0SJohn Baldwin 		return (0);
1340746c92e0SJohn Baldwin 	default:
1341746c92e0SJohn Baldwin 		return (vop_stdpathconf(ap));
1342746c92e0SJohn Baldwin 	}
1343746c92e0SJohn Baldwin }
1344746c92e0SJohn Baldwin 
13455fe58019SAttilio Rao /*
13465fe58019SAttilio Rao     struct vnop_read_args {
13475fe58019SAttilio Rao 	struct vnode *a_vp;
13485fe58019SAttilio Rao 	struct uio *a_uio;
13495fe58019SAttilio Rao 	int  a_ioflag;
13505fe58019SAttilio Rao 	struct ucred *a_cred;
13515fe58019SAttilio Rao     };
13525fe58019SAttilio Rao */
13535fe58019SAttilio Rao static int
13545fe58019SAttilio Rao fuse_vnop_read(struct vop_read_args *ap)
13555fe58019SAttilio Rao {
13565fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
13575fe58019SAttilio Rao 	struct uio *uio = ap->a_uio;
13585fe58019SAttilio Rao 	int ioflag = ap->a_ioflag;
13595fe58019SAttilio Rao 	struct ucred *cred = ap->a_cred;
1360f8d4af10SAlan Somers 	pid_t pid = curthread->td_proc->p_pid;
13615fe58019SAttilio Rao 
13625fe58019SAttilio Rao 	if (fuse_isdeadfs(vp)) {
13635fe58019SAttilio Rao 		return ENXIO;
13645fe58019SAttilio Rao 	}
1365ead063e0SEdward Tomasz Napierala 
1366ead063e0SEdward Tomasz Napierala 	if (VTOFUD(vp)->flag & FN_DIRECTIO) {
1367ead063e0SEdward Tomasz Napierala 		ioflag |= IO_DIRECT;
1368ead063e0SEdward Tomasz Napierala 	}
1369ead063e0SEdward Tomasz Napierala 
1370b9e20197SAlan Somers 	return fuse_io_dispatch(vp, uio, ioflag, cred, pid);
13715fe58019SAttilio Rao }
13725fe58019SAttilio Rao 
13735fe58019SAttilio Rao /*
13745fe58019SAttilio Rao     struct vnop_readdir_args {
13755fe58019SAttilio Rao 	struct vnode *a_vp;
13765fe58019SAttilio Rao 	struct uio *a_uio;
13775fe58019SAttilio Rao 	struct ucred *a_cred;
13785fe58019SAttilio Rao 	int *a_eofflag;
1379e76986fdSAlan Somers 	int *a_ncookies;
13805fe58019SAttilio Rao 	u_long **a_cookies;
13815fe58019SAttilio Rao     };
13825fe58019SAttilio Rao */
13835fe58019SAttilio Rao static int
13845fe58019SAttilio Rao fuse_vnop_readdir(struct vop_readdir_args *ap)
13855fe58019SAttilio Rao {
13865fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
13875fe58019SAttilio Rao 	struct uio *uio = ap->a_uio;
13885fe58019SAttilio Rao 	struct ucred *cred = ap->a_cred;
13895fe58019SAttilio Rao 	struct fuse_filehandle *fufh = NULL;
13905fe58019SAttilio Rao 	struct fuse_iov cookediov;
13915fe58019SAttilio Rao 	int err = 0;
1392e76986fdSAlan Somers 	u_long *cookies;
1393e76986fdSAlan Somers 	off_t startoff;
1394e76986fdSAlan Somers 	ssize_t tresid;
1395e76986fdSAlan Somers 	int ncookies;
1396e76986fdSAlan Somers 	bool closefufh = false;
1397f8d4af10SAlan Somers 	pid_t pid = curthread->td_proc->p_pid;
13985fe58019SAttilio Rao 
1399e76986fdSAlan Somers 	if (ap->a_eofflag)
1400e76986fdSAlan Somers 		*ap->a_eofflag = 0;
14015fe58019SAttilio Rao 	if (fuse_isdeadfs(vp)) {
14025fe58019SAttilio Rao 		return ENXIO;
14035fe58019SAttilio Rao 	}
14045fe58019SAttilio Rao 	if (				/* XXXIP ((uio_iovcnt(uio) > 1)) || */
14055fe58019SAttilio Rao 	    (uio_resid(uio) < sizeof(struct dirent))) {
14065fe58019SAttilio Rao 		return EINVAL;
14075fe58019SAttilio Rao 	}
14085fe58019SAttilio Rao 
1409e76986fdSAlan Somers 	tresid = uio->uio_resid;
1410e76986fdSAlan Somers 	startoff = uio->uio_offset;
141135cf0e7eSAlan Somers 	err = fuse_filehandle_get_dir(vp, &fufh, cred, pid);
1412e76986fdSAlan Somers 	if (err == EBADF && vnode_mount(vp)->mnt_flag & MNT_EXPORTED) {
1413e76986fdSAlan Somers 		/*
1414e76986fdSAlan Somers 		 * nfsd will do VOP_READDIR without first doing VOP_OPEN.  We
1415e76986fdSAlan Somers 		 * must implicitly open the directory here
1416e76986fdSAlan Somers 		 */
1417e76986fdSAlan Somers 		err = fuse_filehandle_open(vp, FREAD, &fufh, curthread, cred);
1418e76986fdSAlan Somers 		if (err == 0) {
1419e76986fdSAlan Somers 			/*
1420e76986fdSAlan Somers 			 * When a directory is opened, it must be read from
1421e76986fdSAlan Somers 			 * the beginning.  Hopefully, the "startoff" still
1422e76986fdSAlan Somers 			 * exists as an offset cookie for the directory.
1423e76986fdSAlan Somers 			 * If not, it will read the entire directory without
1424e76986fdSAlan Somers 			 * returning any entries and just return eof.
1425e76986fdSAlan Somers 			 */
1426e76986fdSAlan Somers 			uio->uio_offset = 0;
1427e76986fdSAlan Somers 		}
1428e76986fdSAlan Somers 		closefufh = true;
1429e76986fdSAlan Somers 	}
143035cf0e7eSAlan Somers 	if (err)
14315fe58019SAttilio Rao 		return (err);
1432e76986fdSAlan Somers 	if (ap->a_ncookies != NULL) {
1433e76986fdSAlan Somers 		ncookies = uio->uio_resid /
1434e76986fdSAlan Somers 			(offsetof(struct dirent, d_name) + 4) + 1;
1435e76986fdSAlan Somers 		cookies = malloc(ncookies * sizeof(*cookies), M_TEMP, M_WAITOK);
1436e76986fdSAlan Somers 		*ap->a_ncookies = ncookies;
1437e76986fdSAlan Somers 		*ap->a_cookies = cookies;
1438e76986fdSAlan Somers 	} else {
1439e76986fdSAlan Somers 		ncookies = 0;
1440e76986fdSAlan Somers 		cookies = NULL;
1441e76986fdSAlan Somers 	}
14425fe58019SAttilio Rao #define DIRCOOKEDSIZE FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + MAXNAMLEN + 1)
14435fe58019SAttilio Rao 	fiov_init(&cookediov, DIRCOOKEDSIZE);
14445fe58019SAttilio Rao 
1445e76986fdSAlan Somers 	err = fuse_internal_readdir(vp, uio, startoff, fufh, &cookediov,
1446e76986fdSAlan Somers 		&ncookies, cookies);
14475fe58019SAttilio Rao 
14485fe58019SAttilio Rao 	fiov_teardown(&cookediov);
1449e76986fdSAlan Somers 	if (closefufh)
1450e76986fdSAlan Somers 		fuse_filehandle_close(vp, fufh, curthread, cred);
1451e76986fdSAlan Somers 
1452e76986fdSAlan Somers 	if (ap->a_ncookies != NULL) {
1453e76986fdSAlan Somers 		if (err == 0) {
1454e76986fdSAlan Somers 			*ap->a_ncookies -= ncookies;
1455e76986fdSAlan Somers 		} else {
1456e76986fdSAlan Somers 			free(*ap->a_cookies, M_TEMP);
1457e76986fdSAlan Somers 			*ap->a_ncookies = 0;
1458e76986fdSAlan Somers 			*ap->a_cookies = NULL;
1459e76986fdSAlan Somers 		}
1460e76986fdSAlan Somers 	}
1461e76986fdSAlan Somers 	if (err == 0 && tresid == uio->uio_resid)
1462e76986fdSAlan Somers 		*ap->a_eofflag = 1;
14635ec10aa5SAlan Somers 
14645fe58019SAttilio Rao 	return err;
14655fe58019SAttilio Rao }
14665fe58019SAttilio Rao 
14675fe58019SAttilio Rao /*
14685fe58019SAttilio Rao     struct vnop_readlink_args {
14695fe58019SAttilio Rao 	struct vnode *a_vp;
14705fe58019SAttilio Rao 	struct uio *a_uio;
14715fe58019SAttilio Rao 	struct ucred *a_cred;
14725fe58019SAttilio Rao     };
14735fe58019SAttilio Rao */
14745fe58019SAttilio Rao static int
14755fe58019SAttilio Rao fuse_vnop_readlink(struct vop_readlink_args *ap)
14765fe58019SAttilio Rao {
14775fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
14785fe58019SAttilio Rao 	struct uio *uio = ap->a_uio;
14795fe58019SAttilio Rao 	struct ucred *cred = ap->a_cred;
14805fe58019SAttilio Rao 
14815fe58019SAttilio Rao 	struct fuse_dispatcher fdi;
14825fe58019SAttilio Rao 	int err;
14835fe58019SAttilio Rao 
14845fe58019SAttilio Rao 	if (fuse_isdeadfs(vp)) {
14855fe58019SAttilio Rao 		return ENXIO;
14865fe58019SAttilio Rao 	}
14875fe58019SAttilio Rao 	if (!vnode_islnk(vp)) {
14885fe58019SAttilio Rao 		return EINVAL;
14895fe58019SAttilio Rao 	}
14905fe58019SAttilio Rao 	fdisp_init(&fdi, 0);
14915fe58019SAttilio Rao 	err = fdisp_simple_putget_vp(&fdi, FUSE_READLINK, vp, curthread, cred);
14925fe58019SAttilio Rao 	if (err) {
14935fe58019SAttilio Rao 		goto out;
14945fe58019SAttilio Rao 	}
14955fe58019SAttilio Rao 	if (((char *)fdi.answ)[0] == '/' &&
14965fe58019SAttilio Rao 	    fuse_get_mpdata(vnode_mount(vp))->dataflags & FSESS_PUSH_SYMLINKS_IN) {
14975fe58019SAttilio Rao 		char *mpth = vnode_mount(vp)->mnt_stat.f_mntonname;
14985fe58019SAttilio Rao 
14995fe58019SAttilio Rao 		err = uiomove(mpth, strlen(mpth), uio);
15005fe58019SAttilio Rao 	}
15015fe58019SAttilio Rao 	if (!err) {
15025fe58019SAttilio Rao 		err = uiomove(fdi.answ, fdi.iosize, uio);
15035fe58019SAttilio Rao 	}
15045fe58019SAttilio Rao out:
15055fe58019SAttilio Rao 	fdisp_destroy(&fdi);
15065fe58019SAttilio Rao 	return err;
15075fe58019SAttilio Rao }
15085fe58019SAttilio Rao 
15095fe58019SAttilio Rao /*
15105fe58019SAttilio Rao     struct vnop_reclaim_args {
15115fe58019SAttilio Rao 	struct vnode *a_vp;
15125fe58019SAttilio Rao 	struct thread *a_td;
15135fe58019SAttilio Rao     };
15145fe58019SAttilio Rao */
15155fe58019SAttilio Rao static int
15165fe58019SAttilio Rao fuse_vnop_reclaim(struct vop_reclaim_args *ap)
15175fe58019SAttilio Rao {
15185fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
15195fe58019SAttilio Rao 	struct thread *td = ap->a_td;
15205fe58019SAttilio Rao 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
15215ec10aa5SAlan Somers 	struct fuse_filehandle *fufh, *fufh_tmp;
15225fe58019SAttilio Rao 
15235fe58019SAttilio Rao 	if (!fvdat) {
15245fe58019SAttilio Rao 		panic("FUSE: no vnode data during recycling");
15255fe58019SAttilio Rao 	}
15265ec10aa5SAlan Somers 	LIST_FOREACH_SAFE(fufh, &fvdat->handles, next, fufh_tmp) {
15275ec10aa5SAlan Somers 		printf("FUSE: vnode being reclaimed with open fufh "
15289e444871SAlan Somers 			"(type=%#x)", fufh->fufh_type);
15295ec10aa5SAlan Somers 		fuse_filehandle_close(vp, fufh, td, NULL);
15305fe58019SAttilio Rao 	}
15315fe58019SAttilio Rao 
153242767f76SAlan Somers 	if (!fuse_isdeadfs(vp) && fvdat->nlookup > 0) {
15335fe58019SAttilio Rao 		fuse_internal_forget_send(vnode_mount(vp), td, NULL, VTOI(vp),
15345fe58019SAttilio Rao 		    fvdat->nlookup);
15355fe58019SAttilio Rao 	}
15365fe58019SAttilio Rao 	cache_purge(vp);
15375fe58019SAttilio Rao 	vfs_hash_remove(vp);
15385fe58019SAttilio Rao 	fuse_vnode_destroy(vp);
15395fe58019SAttilio Rao 
15405fe58019SAttilio Rao 	return 0;
15415fe58019SAttilio Rao }
15425fe58019SAttilio Rao 
15435fe58019SAttilio Rao /*
15445fe58019SAttilio Rao     struct vnop_remove_args {
15455fe58019SAttilio Rao 	struct vnode *a_dvp;
15465fe58019SAttilio Rao 	struct vnode *a_vp;
15475fe58019SAttilio Rao 	struct componentname *a_cnp;
15485fe58019SAttilio Rao     };
15495fe58019SAttilio Rao */
15505fe58019SAttilio Rao static int
15515fe58019SAttilio Rao fuse_vnop_remove(struct vop_remove_args *ap)
15525fe58019SAttilio Rao {
15535fe58019SAttilio Rao 	struct vnode *dvp = ap->a_dvp;
15545fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
15555fe58019SAttilio Rao 	struct componentname *cnp = ap->a_cnp;
15565fe58019SAttilio Rao 
15575fe58019SAttilio Rao 	int err;
15585fe58019SAttilio Rao 
15595fe58019SAttilio Rao 	if (fuse_isdeadfs(vp)) {
15605fe58019SAttilio Rao 		return ENXIO;
15615fe58019SAttilio Rao 	}
15625fe58019SAttilio Rao 	if (vnode_isdir(vp)) {
15635fe58019SAttilio Rao 		return EPERM;
15645fe58019SAttilio Rao 	}
15655fe58019SAttilio Rao 
15665fe58019SAttilio Rao 	err = fuse_internal_remove(dvp, vp, cnp, FUSE_UNLINK);
15675fe58019SAttilio Rao 
15685fe58019SAttilio Rao 	return err;
15695fe58019SAttilio Rao }
15705fe58019SAttilio Rao 
15715fe58019SAttilio Rao /*
15725fe58019SAttilio Rao     struct vnop_rename_args {
15735fe58019SAttilio Rao 	struct vnode *a_fdvp;
15745fe58019SAttilio Rao 	struct vnode *a_fvp;
15755fe58019SAttilio Rao 	struct componentname *a_fcnp;
15765fe58019SAttilio Rao 	struct vnode *a_tdvp;
15775fe58019SAttilio Rao 	struct vnode *a_tvp;
15785fe58019SAttilio Rao 	struct componentname *a_tcnp;
15795fe58019SAttilio Rao     };
15805fe58019SAttilio Rao */
15815fe58019SAttilio Rao static int
15825fe58019SAttilio Rao fuse_vnop_rename(struct vop_rename_args *ap)
15835fe58019SAttilio Rao {
15845fe58019SAttilio Rao 	struct vnode *fdvp = ap->a_fdvp;
15855fe58019SAttilio Rao 	struct vnode *fvp = ap->a_fvp;
15865fe58019SAttilio Rao 	struct componentname *fcnp = ap->a_fcnp;
15875fe58019SAttilio Rao 	struct vnode *tdvp = ap->a_tdvp;
15885fe58019SAttilio Rao 	struct vnode *tvp = ap->a_tvp;
15895fe58019SAttilio Rao 	struct componentname *tcnp = ap->a_tcnp;
15905fe58019SAttilio Rao 	struct fuse_data *data;
15918e45ec4eSAlan Somers 	bool newparent = fdvp != tdvp;
15928e45ec4eSAlan Somers 	bool isdir = fvp->v_type == VDIR;
15935fe58019SAttilio Rao 	int err = 0;
15945fe58019SAttilio Rao 
15955fe58019SAttilio Rao 	if (fuse_isdeadfs(fdvp)) {
15965fe58019SAttilio Rao 		return ENXIO;
15975fe58019SAttilio Rao 	}
15985fe58019SAttilio Rao 	if (fvp->v_mount != tdvp->v_mount ||
15995fe58019SAttilio Rao 	    (tvp && fvp->v_mount != tvp->v_mount)) {
1600419e7ff6SAlan Somers 		SDT_PROBE2(fusefs, , vnops, trace, 1, "cross-device rename");
16015fe58019SAttilio Rao 		err = EXDEV;
16025fe58019SAttilio Rao 		goto out;
16035fe58019SAttilio Rao 	}
16045fe58019SAttilio Rao 	cache_purge(fvp);
16055fe58019SAttilio Rao 
16065fe58019SAttilio Rao 	/*
16075fe58019SAttilio Rao 	 * FUSE library is expected to check if target directory is not
16085fe58019SAttilio Rao 	 * under the source directory in the file system tree.
16095fe58019SAttilio Rao 	 * Linux performs this check at VFS level.
16105fe58019SAttilio Rao 	 */
16118e45ec4eSAlan Somers 	/*
16128e45ec4eSAlan Somers 	 * If source is a directory, and it will get a new parent, user must
16138e45ec4eSAlan Somers 	 * have write permission to it, so ".." can be modified.
16148e45ec4eSAlan Somers 	 */
16155fe58019SAttilio Rao 	data = fuse_get_mpdata(vnode_mount(tdvp));
16168e45ec4eSAlan Somers 	if (data->dataflags & FSESS_DEFAULT_PERMISSIONS && isdir && newparent) {
16178e45ec4eSAlan Somers 		err = fuse_internal_access(fvp, VWRITE,
16188e45ec4eSAlan Somers 			tcnp->cn_thread, tcnp->cn_cred);
16198e45ec4eSAlan Somers 		if (err)
16208e45ec4eSAlan Somers 			goto out;
16218e45ec4eSAlan Somers 	}
16225fe58019SAttilio Rao 	sx_xlock(&data->rename_lock);
16235fe58019SAttilio Rao 	err = fuse_internal_rename(fdvp, fcnp, tdvp, tcnp);
16245fe58019SAttilio Rao 	if (err == 0) {
1625d9454fabSAttilio Rao 		if (tdvp != fdvp)
16265fe58019SAttilio Rao 			fuse_vnode_setparent(fvp, tdvp);
16275fe58019SAttilio Rao 		if (tvp != NULL)
16285fe58019SAttilio Rao 			fuse_vnode_setparent(tvp, NULL);
16295fe58019SAttilio Rao 	}
16305fe58019SAttilio Rao 	sx_unlock(&data->rename_lock);
16315fe58019SAttilio Rao 
16325fe58019SAttilio Rao 	if (tvp != NULL && tvp != fvp) {
16335fe58019SAttilio Rao 		cache_purge(tvp);
16345fe58019SAttilio Rao 	}
16355fe58019SAttilio Rao 	if (vnode_isdir(fvp)) {
16365fe58019SAttilio Rao 		if ((tvp != NULL) && vnode_isdir(tvp)) {
16375fe58019SAttilio Rao 			cache_purge(tdvp);
16385fe58019SAttilio Rao 		}
16395fe58019SAttilio Rao 		cache_purge(fdvp);
16405fe58019SAttilio Rao 	}
16415fe58019SAttilio Rao out:
16425fe58019SAttilio Rao 	if (tdvp == tvp) {
16435fe58019SAttilio Rao 		vrele(tdvp);
16445fe58019SAttilio Rao 	} else {
16455fe58019SAttilio Rao 		vput(tdvp);
16465fe58019SAttilio Rao 	}
16475fe58019SAttilio Rao 	if (tvp != NULL) {
16485fe58019SAttilio Rao 		vput(tvp);
16495fe58019SAttilio Rao 	}
16505fe58019SAttilio Rao 	vrele(fdvp);
16515fe58019SAttilio Rao 	vrele(fvp);
16525fe58019SAttilio Rao 
16535fe58019SAttilio Rao 	return err;
16545fe58019SAttilio Rao }
16555fe58019SAttilio Rao 
16565fe58019SAttilio Rao /*
16575fe58019SAttilio Rao     struct vnop_rmdir_args {
16585fe58019SAttilio Rao 	    struct vnode *a_dvp;
16595fe58019SAttilio Rao 	    struct vnode *a_vp;
16605fe58019SAttilio Rao 	    struct componentname *a_cnp;
16615fe58019SAttilio Rao     } *ap;
16625fe58019SAttilio Rao */
16635fe58019SAttilio Rao static int
16645fe58019SAttilio Rao fuse_vnop_rmdir(struct vop_rmdir_args *ap)
16655fe58019SAttilio Rao {
16665fe58019SAttilio Rao 	struct vnode *dvp = ap->a_dvp;
16675fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
16685fe58019SAttilio Rao 
16695fe58019SAttilio Rao 	int err;
16705fe58019SAttilio Rao 
16715fe58019SAttilio Rao 	if (fuse_isdeadfs(vp)) {
16725fe58019SAttilio Rao 		return ENXIO;
16735fe58019SAttilio Rao 	}
16745fe58019SAttilio Rao 	if (VTOFUD(vp) == VTOFUD(dvp)) {
16755fe58019SAttilio Rao 		return EINVAL;
16765fe58019SAttilio Rao 	}
16775fe58019SAttilio Rao 	err = fuse_internal_remove(dvp, vp, ap->a_cnp, FUSE_RMDIR);
16785fe58019SAttilio Rao 
16795fe58019SAttilio Rao 	return err;
16805fe58019SAttilio Rao }
16815fe58019SAttilio Rao 
16825fe58019SAttilio Rao /*
16835fe58019SAttilio Rao     struct vnop_setattr_args {
16845fe58019SAttilio Rao 	struct vnode *a_vp;
16855fe58019SAttilio Rao 	struct vattr *a_vap;
16865fe58019SAttilio Rao 	struct ucred *a_cred;
16875fe58019SAttilio Rao 	struct thread *a_td;
16885fe58019SAttilio Rao     };
16895fe58019SAttilio Rao */
16905fe58019SAttilio Rao static int
16915fe58019SAttilio Rao fuse_vnop_setattr(struct vop_setattr_args *ap)
16925fe58019SAttilio Rao {
16935fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
16945fe58019SAttilio Rao 	struct vattr *vap = ap->a_vap;
16955fe58019SAttilio Rao 	struct ucred *cred = ap->a_cred;
16965fe58019SAttilio Rao 	struct thread *td = curthread;
1697474ba6faSAlan Somers 	struct mount *mp;
1698474ba6faSAlan Somers 	struct fuse_data *data;
16994e83d655SAlan Somers 	struct vattr old_va;
1700474ba6faSAlan Somers 	int dataflags;
17014e83d655SAlan Somers 	int err = 0, err2;
1702ff4fbdf5SAlan Somers 	accmode_t accmode = 0;
1703a90e32deSAlan Somers 	bool checkperm;
1704a2bdd737SAlan Somers 	bool drop_suid = false;
17054e83d655SAlan Somers 	gid_t cr_gid;
17065fe58019SAttilio Rao 
1707474ba6faSAlan Somers 	mp = vnode_mount(vp);
1708474ba6faSAlan Somers 	data = fuse_get_mpdata(mp);
1709474ba6faSAlan Somers 	dataflags = data->dataflags;
1710a90e32deSAlan Somers 	checkperm = dataflags & FSESS_DEFAULT_PERMISSIONS;
17114e83d655SAlan Somers 	if (cred->cr_ngroups > 0)
17124e83d655SAlan Somers 		cr_gid = cred->cr_groups[0];
17134e83d655SAlan Somers 	else
17144e83d655SAlan Somers 		cr_gid = 0;
1715474ba6faSAlan Somers 
17165fe58019SAttilio Rao 	if (fuse_isdeadfs(vp)) {
17175fe58019SAttilio Rao 		return ENXIO;
17185fe58019SAttilio Rao 	}
17195fe58019SAttilio Rao 
17205fe58019SAttilio Rao 	if (vap->va_uid != (uid_t)VNOVAL) {
1721a90e32deSAlan Somers 		if (checkperm) {
1722474ba6faSAlan Somers 			/* Only root may change a file's owner */
1723474ba6faSAlan Somers 			err = priv_check_cred(cred, PRIV_VFS_CHOWN);
17244e83d655SAlan Somers 			if (err) {
17254e83d655SAlan Somers 				/* As a special case, allow the null chown */
17264e83d655SAlan Somers 				err2 = fuse_internal_getattr(vp, &old_va, cred,
17274e83d655SAlan Somers 					td);
17284e83d655SAlan Somers 				if (err2)
17294e83d655SAlan Somers 					return (err2);
17304e83d655SAlan Somers 				if (vap->va_uid != old_va.va_uid)
17314e83d655SAlan Somers 					return err;
17324e83d655SAlan Somers 				else
17334e83d655SAlan Somers 					accmode |= VADMIN;
1734a2bdd737SAlan Somers 				drop_suid = true;
17354e83d655SAlan Somers 			} else
17364e83d655SAlan Somers 				accmode |= VADMIN;
17374e83d655SAlan Somers 		} else
1738ff4fbdf5SAlan Somers 			accmode |= VADMIN;
17395fe58019SAttilio Rao 	}
17405fe58019SAttilio Rao 	if (vap->va_gid != (gid_t)VNOVAL) {
1741a2bdd737SAlan Somers 		if (checkperm && priv_check_cred(cred, PRIV_VFS_CHOWN))
1742a2bdd737SAlan Somers 			drop_suid = true;
1743a90e32deSAlan Somers 		if (checkperm && !groupmember(vap->va_gid, cred))
1744474ba6faSAlan Somers 		{
1745474ba6faSAlan Somers 			/*
1746474ba6faSAlan Somers 			 * Non-root users may only chgrp to one of their own
1747474ba6faSAlan Somers 			 * groups
1748474ba6faSAlan Somers 			 */
1749474ba6faSAlan Somers 			err = priv_check_cred(cred, PRIV_VFS_CHOWN);
17504e83d655SAlan Somers 			if (err) {
17514e83d655SAlan Somers 				/* As a special case, allow the null chgrp */
17524e83d655SAlan Somers 				err2 = fuse_internal_getattr(vp, &old_va, cred,
17534e83d655SAlan Somers 					td);
17544e83d655SAlan Somers 				if (err2)
17554e83d655SAlan Somers 					return (err2);
17564e83d655SAlan Somers 				if (vap->va_gid != old_va.va_gid)
1757a90e32deSAlan Somers 					return err;
17584e83d655SAlan Somers 				accmode |= VADMIN;
17594e83d655SAlan Somers 			} else
17604e83d655SAlan Somers 				accmode |= VADMIN;
17614e83d655SAlan Somers 		} else
1762ff4fbdf5SAlan Somers 			accmode |= VADMIN;
17635fe58019SAttilio Rao 	}
17645fe58019SAttilio Rao 	if (vap->va_size != VNOVAL) {
1765a90e32deSAlan Somers 		switch (vp->v_type) {
1766a90e32deSAlan Somers 		case VDIR:
1767a90e32deSAlan Somers 			return (EISDIR);
1768a90e32deSAlan Somers 		case VLNK:
1769a90e32deSAlan Somers 		case VREG:
1770a90e32deSAlan Somers 			if (vfs_isrdonly(mp))
1771a90e32deSAlan Somers 				return (EROFS);
1772a90e32deSAlan Somers 			break;
1773a90e32deSAlan Somers 		default:
1774a90e32deSAlan Somers 			/*
1775a90e32deSAlan Somers 			 * According to POSIX, the result is unspecified
1776a90e32deSAlan Somers 			 * for file types other than regular files,
1777a90e32deSAlan Somers 			 * directories and shared memory objects.  We
1778a90e32deSAlan Somers 			 * don't support shared memory objects in the file
1779a90e32deSAlan Somers 			 * system, and have dubious support for truncating
1780a90e32deSAlan Somers 			 * symlinks.  Just ignore the request in other cases.
1781a90e32deSAlan Somers 			 */
1782a90e32deSAlan Somers 			return (0);
1783a90e32deSAlan Somers 		}
17843fa12789SAlan Somers 		/* Don't set accmode.  Permission to trunc is checked upstack */
17855fe58019SAttilio Rao 	}
1786d943c93eSAlan Somers 	if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
1787d943c93eSAlan Somers 		if (vap->va_vaflags & VA_UTIMES_NULL)
1788d943c93eSAlan Somers 			accmode |= VWRITE;
1789d943c93eSAlan Somers 		else
1790ff4fbdf5SAlan Somers 			accmode |= VADMIN;
1791d943c93eSAlan Somers 	}
1792a2bdd737SAlan Somers 	if (drop_suid) {
1793a2bdd737SAlan Somers 		if (vap->va_mode != (mode_t)VNOVAL)
1794a2bdd737SAlan Somers 			vap->va_mode &= ~(S_ISUID | S_ISGID);
1795a2bdd737SAlan Somers 		else {
1796a2bdd737SAlan Somers 			err = fuse_internal_getattr(vp, &old_va, cred, td);
1797a2bdd737SAlan Somers 			if (err)
1798a2bdd737SAlan Somers 				return (err);
1799a2bdd737SAlan Somers 			vap->va_mode = old_va.va_mode & ~(S_ISUID | S_ISGID);
1800a2bdd737SAlan Somers 		}
1801a2bdd737SAlan Somers 	}
18025fe58019SAttilio Rao 	if (vap->va_mode != (mode_t)VNOVAL) {
1803e5ff3a7eSAlan Somers 		/* Only root may set the sticky bit on non-directories */
1804a90e32deSAlan Somers 		if (checkperm && vp->v_type != VDIR && (vap->va_mode & S_ISTXT)
1805a90e32deSAlan Somers 		    && priv_check_cred(cred, PRIV_VFS_STICKYFILE))
1806a90e32deSAlan Somers 			return EFTYPE;
18078cfb4431SAlan Somers 		if (checkperm && (vap->va_mode & S_ISGID)) {
18088cfb4431SAlan Somers 			err = fuse_internal_getattr(vp, &old_va, cred, td);
18098cfb4431SAlan Somers 			if (err)
18108cfb4431SAlan Somers 				return (err);
18118cfb4431SAlan Somers 			if (!groupmember(old_va.va_gid, cred)) {
18128cfb4431SAlan Somers 				err = priv_check_cred(cred, PRIV_VFS_SETGID);
18138cfb4431SAlan Somers 				if (err)
18148cfb4431SAlan Somers 					return (err);
18158cfb4431SAlan Somers 			}
18168cfb4431SAlan Somers 		}
1817ff4fbdf5SAlan Somers 		accmode |= VADMIN;
18185fe58019SAttilio Rao 	}
18195fe58019SAttilio Rao 
1820a90e32deSAlan Somers 	if (vfs_isrdonly(mp))
1821a90e32deSAlan Somers 		return EROFS;
1822a90e32deSAlan Somers 
1823666f8543SAlan Somers 	err = fuse_internal_access(vp, accmode, td, cred);
1824ff4fbdf5SAlan Somers 	if (err)
18255fe58019SAttilio Rao 		return err;
1826a90e32deSAlan Somers 	else
1827a90e32deSAlan Somers 		return fuse_internal_setattr(vp, vap, td, cred);
18285fe58019SAttilio Rao }
18295fe58019SAttilio Rao 
18305fe58019SAttilio Rao /*
18315fe58019SAttilio Rao     struct vnop_strategy_args {
18325fe58019SAttilio Rao 	struct vnode *a_vp;
18335fe58019SAttilio Rao 	struct buf *a_bp;
18345fe58019SAttilio Rao     };
18355fe58019SAttilio Rao */
18365fe58019SAttilio Rao static int
18375fe58019SAttilio Rao fuse_vnop_strategy(struct vop_strategy_args *ap)
18385fe58019SAttilio Rao {
18395fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
18405fe58019SAttilio Rao 	struct buf *bp = ap->a_bp;
18415fe58019SAttilio Rao 
18425fe58019SAttilio Rao 	if (!vp || fuse_isdeadfs(vp)) {
18435fe58019SAttilio Rao 		bp->b_ioflags |= BIO_ERROR;
18445fe58019SAttilio Rao 		bp->b_error = ENXIO;
18455fe58019SAttilio Rao 		bufdone(bp);
184698852a32SAlan Somers 		return 0;
18475fe58019SAttilio Rao 	}
18485fe58019SAttilio Rao 
18495fe58019SAttilio Rao 	/*
1850f203d173SAlan Somers 	 * VOP_STRATEGY always returns zero and signals error via bp->b_ioflags.
1851f203d173SAlan Somers 	 * fuse_io_strategy sets bp's error fields
18525fe58019SAttilio Rao 	 */
1853f203d173SAlan Somers 	(void)fuse_io_strategy(vp, bp);
1854f203d173SAlan Somers 
18555fe58019SAttilio Rao 	return 0;
18565fe58019SAttilio Rao }
18575fe58019SAttilio Rao 
18585fe58019SAttilio Rao 
18595fe58019SAttilio Rao /*
18605fe58019SAttilio Rao     struct vnop_symlink_args {
18615fe58019SAttilio Rao 	struct vnode *a_dvp;
18625fe58019SAttilio Rao 	struct vnode **a_vpp;
18635fe58019SAttilio Rao 	struct componentname *a_cnp;
18645fe58019SAttilio Rao 	struct vattr *a_vap;
18655fe58019SAttilio Rao 	char *a_target;
18665fe58019SAttilio Rao     };
18675fe58019SAttilio Rao */
18685fe58019SAttilio Rao static int
18695fe58019SAttilio Rao fuse_vnop_symlink(struct vop_symlink_args *ap)
18705fe58019SAttilio Rao {
18715fe58019SAttilio Rao 	struct vnode *dvp = ap->a_dvp;
18725fe58019SAttilio Rao 	struct vnode **vpp = ap->a_vpp;
18735fe58019SAttilio Rao 	struct componentname *cnp = ap->a_cnp;
18741493c2eeSBrooks Davis 	const char *target = ap->a_target;
18755fe58019SAttilio Rao 
18765fe58019SAttilio Rao 	struct fuse_dispatcher fdi;
18775fe58019SAttilio Rao 
18785fe58019SAttilio Rao 	int err;
18795fe58019SAttilio Rao 	size_t len;
18805fe58019SAttilio Rao 
18815fe58019SAttilio Rao 	if (fuse_isdeadfs(dvp)) {
18825fe58019SAttilio Rao 		return ENXIO;
18835fe58019SAttilio Rao 	}
18845fe58019SAttilio Rao 	/*
18855fe58019SAttilio Rao 	 * Unlike the other creator type calls, here we have to create a message
18865fe58019SAttilio Rao 	 * where the name of the new entry comes first, and the data describing
18875fe58019SAttilio Rao 	 * the entry comes second.
18885fe58019SAttilio Rao 	 * Hence we can't rely on our handy fuse_internal_newentry() routine,
18895fe58019SAttilio Rao 	 * but put together the message manually and just call the core part.
18905fe58019SAttilio Rao 	 */
18915fe58019SAttilio Rao 
18925fe58019SAttilio Rao 	len = strlen(target) + 1;
18935fe58019SAttilio Rao 	fdisp_init(&fdi, len + cnp->cn_namelen + 1);
18945fe58019SAttilio Rao 	fdisp_make_vp(&fdi, FUSE_SYMLINK, dvp, curthread, NULL);
18955fe58019SAttilio Rao 
18965fe58019SAttilio Rao 	memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
18975fe58019SAttilio Rao 	((char *)fdi.indata)[cnp->cn_namelen] = '\0';
18985fe58019SAttilio Rao 	memcpy((char *)fdi.indata + cnp->cn_namelen + 1, target, len);
18995fe58019SAttilio Rao 
19005fe58019SAttilio Rao 	err = fuse_internal_newentry_core(dvp, vpp, cnp, VLNK, &fdi);
19015fe58019SAttilio Rao 	fdisp_destroy(&fdi);
19025fe58019SAttilio Rao 	return err;
19035fe58019SAttilio Rao }
19045fe58019SAttilio Rao 
19055fe58019SAttilio Rao /*
19065fe58019SAttilio Rao     struct vnop_write_args {
19075fe58019SAttilio Rao 	struct vnode *a_vp;
19085fe58019SAttilio Rao 	struct uio *a_uio;
19095fe58019SAttilio Rao 	int  a_ioflag;
19105fe58019SAttilio Rao 	struct ucred *a_cred;
19115fe58019SAttilio Rao     };
19125fe58019SAttilio Rao */
19135fe58019SAttilio Rao static int
19145fe58019SAttilio Rao fuse_vnop_write(struct vop_write_args *ap)
19155fe58019SAttilio Rao {
19165fe58019SAttilio Rao 	struct vnode *vp = ap->a_vp;
19175fe58019SAttilio Rao 	struct uio *uio = ap->a_uio;
19185fe58019SAttilio Rao 	int ioflag = ap->a_ioflag;
19195fe58019SAttilio Rao 	struct ucred *cred = ap->a_cred;
1920f8d4af10SAlan Somers 	pid_t pid = curthread->td_proc->p_pid;
19215fe58019SAttilio Rao 
19225fe58019SAttilio Rao 	if (fuse_isdeadfs(vp)) {
19235fe58019SAttilio Rao 		return ENXIO;
19245fe58019SAttilio Rao 	}
19255fe58019SAttilio Rao 
1926ead063e0SEdward Tomasz Napierala 	if (VTOFUD(vp)->flag & FN_DIRECTIO) {
1927ead063e0SEdward Tomasz Napierala 		ioflag |= IO_DIRECT;
1928ead063e0SEdward Tomasz Napierala 	}
1929ead063e0SEdward Tomasz Napierala 
1930b9e20197SAlan Somers 	return fuse_io_dispatch(vp, uio, ioflag, cred, pid);
19315fe58019SAttilio Rao }
19325fe58019SAttilio Rao 
1933b9e20197SAlan Somers static daddr_t
1934b9e20197SAlan Somers fuse_gbp_getblkno(struct vnode *vp, vm_ooffset_t off)
1935b9e20197SAlan Somers {
1936b9e20197SAlan Somers 	const int biosize = fuse_iosize(vp);
1937b9e20197SAlan Somers 
1938b9e20197SAlan Somers 	return (off / biosize);
1939b9e20197SAlan Somers }
1940b9e20197SAlan Somers 
1941b9e20197SAlan Somers static int
1942b9e20197SAlan Somers fuse_gbp_getblksz(struct vnode *vp, daddr_t lbn)
1943b9e20197SAlan Somers {
1944b9e20197SAlan Somers 	off_t filesize;
1945b9e20197SAlan Somers 	int blksz, err;
1946b9e20197SAlan Somers 	const int biosize = fuse_iosize(vp);
1947b9e20197SAlan Somers 
1948b9e20197SAlan Somers 	err = fuse_vnode_size(vp, &filesize, NULL, NULL);
1949b9e20197SAlan Somers 	KASSERT(err == 0, ("vfs_bio_getpages can't handle errors here"));
1950b9e20197SAlan Somers 	if (err)
1951b9e20197SAlan Somers 		return biosize;
1952b9e20197SAlan Somers 
1953b9e20197SAlan Somers 	if ((off_t)lbn * biosize >= filesize) {
1954b9e20197SAlan Somers 		blksz = 0;
1955b9e20197SAlan Somers 	} else if ((off_t)(lbn + 1) * biosize > filesize) {
1956b9e20197SAlan Somers 		blksz = filesize - (off_t)lbn *biosize;
1957b9e20197SAlan Somers 	} else {
1958b9e20197SAlan Somers 		blksz = biosize;
1959b9e20197SAlan Somers 	}
1960b9e20197SAlan Somers 	return (blksz);
1961b9e20197SAlan Somers }
1962b9e20197SAlan Somers 
19635fe58019SAttilio Rao /*
19645fe58019SAttilio Rao     struct vnop_getpages_args {
19655fe58019SAttilio Rao 	struct vnode *a_vp;
19665fe58019SAttilio Rao 	vm_page_t *a_m;
19675fe58019SAttilio Rao 	int a_count;
19685fe58019SAttilio Rao 	int a_reqpage;
19695fe58019SAttilio Rao     };
19705fe58019SAttilio Rao */
19715fe58019SAttilio Rao static int
19725fe58019SAttilio Rao fuse_vnop_getpages(struct vop_getpages_args *ap)
19735fe58019SAttilio Rao {
1974b9e20197SAlan Somers 	struct vnode *vp = ap->a_vp;
19755fe58019SAttilio Rao 
19765fe58019SAttilio Rao 	if (!fsess_opt_mmap(vnode_mount(vp))) {
1977419e7ff6SAlan Somers 		SDT_PROBE2(fusefs, , vnops, trace, 1,
1978cf169498SAlan Somers 			"called on non-cacheable vnode??\n");
19795fe58019SAttilio Rao 		return (VM_PAGER_ERROR);
19805fe58019SAttilio Rao 	}
19815fe58019SAttilio Rao 
1982b9e20197SAlan Somers 	return (vfs_bio_getpages(vp, ap->a_m, ap->a_count, ap->a_rbehind,
1983b9e20197SAlan Somers 	    ap->a_rahead, fuse_gbp_getblkno, fuse_gbp_getblksz));
19845fe58019SAttilio Rao }
19855fe58019SAttilio Rao 
198604660064SFedor Uporov static const char extattr_namespace_separator = '.';
198704660064SFedor Uporov 
198804660064SFedor Uporov /*
198904660064SFedor Uporov     struct vop_getextattr_args {
199004660064SFedor Uporov 	struct vop_generic_args a_gen;
199104660064SFedor Uporov 	struct vnode *a_vp;
199204660064SFedor Uporov 	int a_attrnamespace;
199304660064SFedor Uporov 	const char *a_name;
199404660064SFedor Uporov 	struct uio *a_uio;
199504660064SFedor Uporov 	size_t *a_size;
199604660064SFedor Uporov 	struct ucred *a_cred;
199704660064SFedor Uporov 	struct thread *a_td;
199804660064SFedor Uporov     };
199904660064SFedor Uporov */
200004660064SFedor Uporov static int
200104660064SFedor Uporov fuse_vnop_getextattr(struct vop_getextattr_args *ap)
200204660064SFedor Uporov {
200304660064SFedor Uporov 	struct vnode *vp = ap->a_vp;
200404660064SFedor Uporov 	struct uio *uio = ap->a_uio;
200528f4f623SFedor Uporov 	struct fuse_dispatcher fdi;
200604660064SFedor Uporov 	struct fuse_getxattr_in *get_xattr_in;
200704660064SFedor Uporov 	struct fuse_getxattr_out *get_xattr_out;
200804660064SFedor Uporov 	struct mount *mp = vnode_mount(vp);
200904660064SFedor Uporov 	struct thread *td = ap->a_td;
201004660064SFedor Uporov 	struct ucred *cred = ap->a_cred;
201128f4f623SFedor Uporov 	char *prefix;
201228f4f623SFedor Uporov 	char *attr_str;
201328f4f623SFedor Uporov 	size_t len;
201428f4f623SFedor Uporov 	int err;
201504660064SFedor Uporov 
201604660064SFedor Uporov 	if (fuse_isdeadfs(vp))
201728f4f623SFedor Uporov 		return (ENXIO);
201804660064SFedor Uporov 
20191f4a83f9SAlan Somers 	if (!fsess_isimpl(mp, FUSE_GETXATTR))
20201f4a83f9SAlan Somers 		return EOPNOTSUPP;
20211f4a83f9SAlan Somers 
2022666f8543SAlan Somers 	err = fuse_extattr_check_cred(vp, ap->a_attrnamespace, cred, td, VREAD);
2023ff4fbdf5SAlan Somers 	if (err)
2024ff4fbdf5SAlan Somers 		return err;
2025ff4fbdf5SAlan Somers 
202604660064SFedor Uporov 	/* Default to looking for user attributes. */
202704660064SFedor Uporov 	if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM)
202804660064SFedor Uporov 		prefix = EXTATTR_NAMESPACE_SYSTEM_STRING;
202904660064SFedor Uporov 	else
203004660064SFedor Uporov 		prefix = EXTATTR_NAMESPACE_USER_STRING;
203104660064SFedor Uporov 
203204660064SFedor Uporov 	len = strlen(prefix) + sizeof(extattr_namespace_separator) +
203304660064SFedor Uporov 	    strlen(ap->a_name) + 1;
203404660064SFedor Uporov 
203504660064SFedor Uporov 	fdisp_init(&fdi, len + sizeof(*get_xattr_in));
203604660064SFedor Uporov 	fdisp_make_vp(&fdi, FUSE_GETXATTR, vp, td, cred);
203704660064SFedor Uporov 
203804660064SFedor Uporov 	get_xattr_in = fdi.indata;
203904660064SFedor Uporov 	/*
204004660064SFedor Uporov 	 * Check to see whether we're querying the available size or
204104660064SFedor Uporov 	 * issuing the actual request.  If we pass in 0, we get back struct
204204660064SFedor Uporov 	 * fuse_getxattr_out.  If we pass in a non-zero size, we get back
204304660064SFedor Uporov 	 * that much data, without the struct fuse_getxattr_out header.
204404660064SFedor Uporov 	 */
2045493b4a8cSFedor Uporov 	if (uio == NULL)
204604660064SFedor Uporov 		get_xattr_in->size = 0;
204704660064SFedor Uporov 	else
204804660064SFedor Uporov 		get_xattr_in->size = uio->uio_resid;
204904660064SFedor Uporov 
205004660064SFedor Uporov 	attr_str = (char *)fdi.indata + sizeof(*get_xattr_in);
205104660064SFedor Uporov 	snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator,
205204660064SFedor Uporov 	    ap->a_name);
205304660064SFedor Uporov 
205404660064SFedor Uporov 	err = fdisp_wait_answ(&fdi);
205504660064SFedor Uporov 	if (err != 0) {
20561f4a83f9SAlan Somers 		if (err == ENOSYS) {
205704660064SFedor Uporov 			fsess_set_notimpl(mp, FUSE_GETXATTR);
20581f4a83f9SAlan Somers 			err = EOPNOTSUPP;
20591f4a83f9SAlan Somers 		}
206004660064SFedor Uporov 		goto out;
206104660064SFedor Uporov 	}
206204660064SFedor Uporov 
206304660064SFedor Uporov 	get_xattr_out = fdi.answ;
206404660064SFedor Uporov 
2065493b4a8cSFedor Uporov 	if (ap->a_size != NULL)
206604660064SFedor Uporov 		*ap->a_size = get_xattr_out->size;
2067493b4a8cSFedor Uporov 
2068493b4a8cSFedor Uporov 	if (uio != NULL)
206904660064SFedor Uporov 		err = uiomove(fdi.answ, fdi.iosize, uio);
207004660064SFedor Uporov 
207104660064SFedor Uporov out:
207204660064SFedor Uporov 	fdisp_destroy(&fdi);
207304660064SFedor Uporov 	return (err);
207404660064SFedor Uporov }
207504660064SFedor Uporov 
207604660064SFedor Uporov /*
207704660064SFedor Uporov     struct vop_setextattr_args {
207804660064SFedor Uporov 	struct vop_generic_args a_gen;
207904660064SFedor Uporov 	struct vnode *a_vp;
208004660064SFedor Uporov 	int a_attrnamespace;
208104660064SFedor Uporov 	const char *a_name;
208204660064SFedor Uporov 	struct uio *a_uio;
208304660064SFedor Uporov 	struct ucred *a_cred;
208404660064SFedor Uporov 	struct thread *a_td;
208504660064SFedor Uporov     };
208604660064SFedor Uporov */
208704660064SFedor Uporov static int
208804660064SFedor Uporov fuse_vnop_setextattr(struct vop_setextattr_args *ap)
208904660064SFedor Uporov {
209004660064SFedor Uporov 	struct vnode *vp = ap->a_vp;
209104660064SFedor Uporov 	struct uio *uio = ap->a_uio;
209228f4f623SFedor Uporov 	struct fuse_dispatcher fdi;
209304660064SFedor Uporov 	struct fuse_setxattr_in *set_xattr_in;
209404660064SFedor Uporov 	struct mount *mp = vnode_mount(vp);
209528f4f623SFedor Uporov 	struct thread *td = ap->a_td;
209628f4f623SFedor Uporov 	struct ucred *cred = ap->a_cred;
209704660064SFedor Uporov 	char *prefix;
209804660064SFedor Uporov 	size_t len;
209904660064SFedor Uporov 	char *attr_str;
210028f4f623SFedor Uporov 	int err;
210104660064SFedor Uporov 
210204660064SFedor Uporov 	if (fuse_isdeadfs(vp))
210328f4f623SFedor Uporov 		return (ENXIO);
210404660064SFedor Uporov 
21051f4a83f9SAlan Somers 	if (!fsess_isimpl(mp, FUSE_SETXATTR))
21061f4a83f9SAlan Somers 		return EOPNOTSUPP;
21071f4a83f9SAlan Somers 
2108666f8543SAlan Somers 	if (vfs_isrdonly(mp))
2109666f8543SAlan Somers 		return EROFS;
2110666f8543SAlan Somers 
2111ff4fbdf5SAlan Somers 	/* Deleting xattrs must use VOP_DELETEEXTATTR instead */
21121f4a83f9SAlan Somers 	if (ap->a_uio == NULL) {
21131f4a83f9SAlan Somers 		/*
21141f4a83f9SAlan Somers 		 * If we got here as fallback from VOP_DELETEEXTATTR, then
21151f4a83f9SAlan Somers 		 * return EOPNOTSUPP.
21161f4a83f9SAlan Somers 		 */
21171f4a83f9SAlan Somers 		if (!fsess_isimpl(mp, FUSE_REMOVEXATTR))
21181f4a83f9SAlan Somers 			return (EOPNOTSUPP);
21191f4a83f9SAlan Somers 		else
2120ff4fbdf5SAlan Somers 			return (EINVAL);
21211f4a83f9SAlan Somers 	}
2122ff4fbdf5SAlan Somers 
2123666f8543SAlan Somers 	err = fuse_extattr_check_cred(vp, ap->a_attrnamespace, cred, td,
2124666f8543SAlan Somers 		VWRITE);
2125ff4fbdf5SAlan Somers 	if (err)
2126ff4fbdf5SAlan Somers 		return err;
2127ff4fbdf5SAlan Somers 
212804660064SFedor Uporov 	/* Default to looking for user attributes. */
212904660064SFedor Uporov 	if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM)
213004660064SFedor Uporov 		prefix = EXTATTR_NAMESPACE_SYSTEM_STRING;
213104660064SFedor Uporov 	else
213204660064SFedor Uporov 		prefix = EXTATTR_NAMESPACE_USER_STRING;
213304660064SFedor Uporov 
213404660064SFedor Uporov 	len = strlen(prefix) + sizeof(extattr_namespace_separator) +
213504660064SFedor Uporov 	    strlen(ap->a_name) + 1;
213604660064SFedor Uporov 
213704660064SFedor Uporov 	fdisp_init(&fdi, len + sizeof(*set_xattr_in) + uio->uio_resid);
213804660064SFedor Uporov 	fdisp_make_vp(&fdi, FUSE_SETXATTR, vp, td, cred);
213904660064SFedor Uporov 
214004660064SFedor Uporov 	set_xattr_in = fdi.indata;
214104660064SFedor Uporov 	set_xattr_in->size = uio->uio_resid;
214204660064SFedor Uporov 
214304660064SFedor Uporov 	attr_str = (char *)fdi.indata + sizeof(*set_xattr_in);
214404660064SFedor Uporov 	snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator,
214504660064SFedor Uporov 	    ap->a_name);
214604660064SFedor Uporov 
214704660064SFedor Uporov 	err = uiomove((char *)fdi.indata + sizeof(*set_xattr_in) + len,
214804660064SFedor Uporov 	    uio->uio_resid, uio);
214904660064SFedor Uporov 	if (err != 0) {
215004660064SFedor Uporov 		goto out;
215104660064SFedor Uporov 	}
215204660064SFedor Uporov 
215304660064SFedor Uporov 	err = fdisp_wait_answ(&fdi);
215404660064SFedor Uporov 
21551f4a83f9SAlan Somers 	if (err == ENOSYS) {
215604660064SFedor Uporov 		fsess_set_notimpl(mp, FUSE_SETXATTR);
21571f4a83f9SAlan Somers 		err = EOPNOTSUPP;
215804660064SFedor Uporov 	}
2159f0f7fc1bSAlan Somers 	if (err == ERESTART) {
2160f0f7fc1bSAlan Somers 		/* Can't restart after calling uiomove */
2161f0f7fc1bSAlan Somers 		err = EINTR;
2162f0f7fc1bSAlan Somers 	}
216304660064SFedor Uporov 
216404660064SFedor Uporov out:
216504660064SFedor Uporov 	fdisp_destroy(&fdi);
216604660064SFedor Uporov 	return (err);
216704660064SFedor Uporov }
216804660064SFedor Uporov 
216904660064SFedor Uporov /*
217004660064SFedor Uporov  * The Linux / FUSE extended attribute list is simply a collection of
217104660064SFedor Uporov  * NUL-terminated strings.  The FreeBSD extended attribute list is a single
217204660064SFedor Uporov  * byte length followed by a non-NUL terminated string.  So, this allows
217304660064SFedor Uporov  * conversion of the Linux / FUSE format to the FreeBSD format in place.
217404660064SFedor Uporov  * Linux attribute names are reported with the namespace as a prefix (e.g.
217504660064SFedor Uporov  * "user.attribute_name"), but in FreeBSD they are reported without the
217604660064SFedor Uporov  * namespace prefix (e.g. "attribute_name").  So, we're going from:
217704660064SFedor Uporov  *
217804660064SFedor Uporov  * user.attr_name1\0user.attr_name2\0
217904660064SFedor Uporov  *
218004660064SFedor Uporov  * to:
218104660064SFedor Uporov  *
218204660064SFedor Uporov  * <num>attr_name1<num>attr_name2
218304660064SFedor Uporov  *
218404660064SFedor Uporov  * Where "<num>" is a single byte number of characters in the attribute name.
218504660064SFedor Uporov  *
218604660064SFedor Uporov  * Args:
218704660064SFedor Uporov  * prefix - exattr namespace prefix string
218804660064SFedor Uporov  * list, list_len - input list with namespace prefixes
218904660064SFedor Uporov  * bsd_list, bsd_list_len - output list compatible with bsd vfs
219004660064SFedor Uporov  */
219104660064SFedor Uporov static int
219204660064SFedor Uporov fuse_xattrlist_convert(char *prefix, const char *list, int list_len,
219304660064SFedor Uporov     char *bsd_list, int *bsd_list_len)
219404660064SFedor Uporov {
219504660064SFedor Uporov 	int len, pos, dist_to_next, prefix_len;
219604660064SFedor Uporov 
219704660064SFedor Uporov 	pos = 0;
219804660064SFedor Uporov 	*bsd_list_len = 0;
219904660064SFedor Uporov 	prefix_len = strlen(prefix);
220004660064SFedor Uporov 
220104660064SFedor Uporov 	while (pos < list_len && list[pos] != '\0') {
220204660064SFedor Uporov 		dist_to_next = strlen(&list[pos]) + 1;
220304660064SFedor Uporov 		if (bcmp(&list[pos], prefix, prefix_len) == 0 &&
220404660064SFedor Uporov 		    list[pos + prefix_len] == extattr_namespace_separator) {
220504660064SFedor Uporov 			len = dist_to_next -
220604660064SFedor Uporov 			    (prefix_len + sizeof(extattr_namespace_separator)) - 1;
220704660064SFedor Uporov 			if (len >= EXTATTR_MAXNAMELEN)
220804660064SFedor Uporov 				return (ENAMETOOLONG);
220904660064SFedor Uporov 
221004660064SFedor Uporov 			bsd_list[*bsd_list_len] = len;
221104660064SFedor Uporov 			memcpy(&bsd_list[*bsd_list_len + 1],
221204660064SFedor Uporov 			    &list[pos + prefix_len +
221304660064SFedor Uporov 			    sizeof(extattr_namespace_separator)], len);
221404660064SFedor Uporov 
221504660064SFedor Uporov 			*bsd_list_len += len + 1;
221604660064SFedor Uporov 		}
221704660064SFedor Uporov 
221804660064SFedor Uporov 		pos += dist_to_next;
221904660064SFedor Uporov 	}
222004660064SFedor Uporov 
222104660064SFedor Uporov 	return (0);
222204660064SFedor Uporov }
222304660064SFedor Uporov 
222404660064SFedor Uporov /*
22255e633330SAlan Somers  * List extended attributes
22265e633330SAlan Somers  *
22275e633330SAlan Somers  * The FUSE_LISTXATTR operation is based on Linux's listxattr(2) syscall, which
22285e633330SAlan Somers  * has a number of differences compared to its FreeBSD equivalent,
22295e633330SAlan Somers  * extattr_list_file:
22305e633330SAlan Somers  *
22315e633330SAlan Somers  * - FUSE_LISTXATTR returns all extended attributes across all namespaces,
22325e633330SAlan Somers  *   whereas listxattr(2) only returns attributes for a single namespace
22335e633330SAlan Somers  * - FUSE_LISTXATTR prepends each attribute name with "namespace."
22345e633330SAlan Somers  * - If the provided buffer is not large enough to hold the result,
22355e633330SAlan Somers  *   FUSE_LISTXATTR should return ERANGE, whereas listxattr is expected to
22365e633330SAlan Somers  *   return as many results as will fit.
22375e633330SAlan Somers  */
22385e633330SAlan Somers /*
223904660064SFedor Uporov     struct vop_listextattr_args {
224004660064SFedor Uporov 	struct vop_generic_args a_gen;
224104660064SFedor Uporov 	struct vnode *a_vp;
224204660064SFedor Uporov 	int a_attrnamespace;
224304660064SFedor Uporov 	struct uio *a_uio;
224404660064SFedor Uporov 	size_t *a_size;
224504660064SFedor Uporov 	struct ucred *a_cred;
224604660064SFedor Uporov 	struct thread *a_td;
224704660064SFedor Uporov     };
224804660064SFedor Uporov */
224904660064SFedor Uporov static int
225004660064SFedor Uporov fuse_vnop_listextattr(struct vop_listextattr_args *ap)
225104660064SFedor Uporov {
225204660064SFedor Uporov 	struct vnode *vp = ap->a_vp;
225304660064SFedor Uporov 	struct uio *uio = ap->a_uio;
225428f4f623SFedor Uporov 	struct fuse_dispatcher fdi;
2255493b4a8cSFedor Uporov 	struct fuse_listxattr_in *list_xattr_in;
2256493b4a8cSFedor Uporov 	struct fuse_listxattr_out *list_xattr_out;
225704660064SFedor Uporov 	struct mount *mp = vnode_mount(vp);
225828f4f623SFedor Uporov 	struct thread *td = ap->a_td;
225928f4f623SFedor Uporov 	struct ucred *cred = ap->a_cred;
226004660064SFedor Uporov 	char *prefix;
226104660064SFedor Uporov 	char *bsd_list = NULL;
2262493b4a8cSFedor Uporov 	char *linux_list;
226304660064SFedor Uporov 	int bsd_list_len;
2264493b4a8cSFedor Uporov 	int linux_list_len;
226528f4f623SFedor Uporov 	int err;
226604660064SFedor Uporov 
226704660064SFedor Uporov 	if (fuse_isdeadfs(vp))
226828f4f623SFedor Uporov 		return (ENXIO);
226904660064SFedor Uporov 
22701f4a83f9SAlan Somers 	if (!fsess_isimpl(mp, FUSE_LISTXATTR))
22711f4a83f9SAlan Somers 		return EOPNOTSUPP;
22721f4a83f9SAlan Somers 
2273666f8543SAlan Somers 	err = fuse_extattr_check_cred(vp, ap->a_attrnamespace, cred, td, VREAD);
2274ff4fbdf5SAlan Somers 	if (err)
2275ff4fbdf5SAlan Somers 		return err;
2276ff4fbdf5SAlan Somers 
227704660064SFedor Uporov 	/*
227804660064SFedor Uporov 	 * Add space for a NUL and the period separator if enabled.
227904660064SFedor Uporov 	 * Default to looking for user attributes.
228004660064SFedor Uporov 	 */
228104660064SFedor Uporov 	if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM)
228204660064SFedor Uporov 		prefix = EXTATTR_NAMESPACE_SYSTEM_STRING;
228304660064SFedor Uporov 	else
228404660064SFedor Uporov 		prefix = EXTATTR_NAMESPACE_USER_STRING;
228504660064SFedor Uporov 
22863a79e8e7SAlan Somers 	fdisp_init(&fdi, sizeof(*list_xattr_in));
228704660064SFedor Uporov 	fdisp_make_vp(&fdi, FUSE_LISTXATTR, vp, td, cred);
228804660064SFedor Uporov 
2289493b4a8cSFedor Uporov 	/*
2290493b4a8cSFedor Uporov 	 * Retrieve Linux / FUSE compatible list size.
2291493b4a8cSFedor Uporov 	 */
2292493b4a8cSFedor Uporov 	list_xattr_in = fdi.indata;
2293493b4a8cSFedor Uporov 	list_xattr_in->size = 0;
229404660064SFedor Uporov 
229504660064SFedor Uporov 	err = fdisp_wait_answ(&fdi);
229604660064SFedor Uporov 	if (err != 0) {
22971f4a83f9SAlan Somers 		if (err == ENOSYS) {
229804660064SFedor Uporov 			fsess_set_notimpl(mp, FUSE_LISTXATTR);
22991f4a83f9SAlan Somers 			err = EOPNOTSUPP;
23001f4a83f9SAlan Somers 		}
230104660064SFedor Uporov 		goto out;
230204660064SFedor Uporov 	}
230304660064SFedor Uporov 
2304493b4a8cSFedor Uporov 	list_xattr_out = fdi.answ;
2305493b4a8cSFedor Uporov 	linux_list_len = list_xattr_out->size;
2306493b4a8cSFedor Uporov 	if (linux_list_len == 0) {
2307493b4a8cSFedor Uporov 		if (ap->a_size != NULL)
2308493b4a8cSFedor Uporov 			*ap->a_size = linux_list_len;
230904660064SFedor Uporov 		goto out;
231004660064SFedor Uporov 	}
231104660064SFedor Uporov 
231204660064SFedor Uporov 	/*
2313493b4a8cSFedor Uporov 	 * Retrieve Linux / FUSE compatible list values.
2314493b4a8cSFedor Uporov 	 */
231512292a99SAlan Somers 	fdisp_refresh_vp(&fdi, FUSE_LISTXATTR, vp, td, cred);
2316493b4a8cSFedor Uporov 	list_xattr_in = fdi.indata;
23175e633330SAlan Somers 	list_xattr_in->size = linux_list_len;
2318493b4a8cSFedor Uporov 
2319493b4a8cSFedor Uporov 	err = fdisp_wait_answ(&fdi);
23205e633330SAlan Somers 	if (err == ERANGE) {
23215e633330SAlan Somers 		/*
23225e633330SAlan Somers 		 * Race detected.  The attribute list must've grown since the
23235e633330SAlan Somers 		 * first FUSE_LISTXATTR call.  Start over.  Go all the way back
23245e633330SAlan Somers 		 * to userland so we can process signals, if necessary, before
23255e633330SAlan Somers 		 * restarting.
23265e633330SAlan Somers 		 */
23275e633330SAlan Somers 		err = ERESTART;
23285e633330SAlan Somers 		goto out;
23295e633330SAlan Somers 	} else if (err != 0)
2330493b4a8cSFedor Uporov 		goto out;
2331493b4a8cSFedor Uporov 
2332493b4a8cSFedor Uporov 	linux_list = fdi.answ;
23335e633330SAlan Somers 	/* FUSE doesn't allow the server to return more data than requested */
23345e633330SAlan Somers 	if (fdi.iosize > linux_list_len) {
23355e633330SAlan Somers 		printf("WARNING: FUSE protocol violation.  Server returned "
23365e633330SAlan Somers 			"more extended attribute data than requested; "
23375e633330SAlan Somers 			"should've returned ERANGE instead");
23385e633330SAlan Somers 	} else {
23395e633330SAlan Somers 		/* But returning less data is fine */
2340493b4a8cSFedor Uporov 		linux_list_len = fdi.iosize;
23415e633330SAlan Somers 	}
2342493b4a8cSFedor Uporov 
2343493b4a8cSFedor Uporov 	/*
2344493b4a8cSFedor Uporov 	 * Retrieve the BSD compatible list values.
234504660064SFedor Uporov 	 * The Linux / FUSE attribute list format isn't the same
234604660064SFedor Uporov 	 * as FreeBSD's format. So we need to transform it into
234704660064SFedor Uporov 	 * FreeBSD's format before giving it to the user.
234804660064SFedor Uporov 	 */
2349493b4a8cSFedor Uporov 	bsd_list = malloc(linux_list_len, M_TEMP, M_WAITOK);
2350493b4a8cSFedor Uporov 	err = fuse_xattrlist_convert(prefix, linux_list, linux_list_len,
235104660064SFedor Uporov 	    bsd_list, &bsd_list_len);
235204660064SFedor Uporov 	if (err != 0)
235304660064SFedor Uporov 		goto out;
235404660064SFedor Uporov 
2355493b4a8cSFedor Uporov 	if (ap->a_size != NULL)
2356493b4a8cSFedor Uporov 		*ap->a_size = bsd_list_len;
2357493b4a8cSFedor Uporov 
2358493b4a8cSFedor Uporov 	if (uio != NULL)
235904660064SFedor Uporov 		err = uiomove(bsd_list, bsd_list_len, uio);
236004660064SFedor Uporov 
236104660064SFedor Uporov out:
236204660064SFedor Uporov 	free(bsd_list, M_TEMP);
236304660064SFedor Uporov 	fdisp_destroy(&fdi);
236404660064SFedor Uporov 	return (err);
236504660064SFedor Uporov }
236604660064SFedor Uporov 
236704660064SFedor Uporov /*
236804660064SFedor Uporov     struct vop_deleteextattr_args {
236904660064SFedor Uporov 	struct vop_generic_args a_gen;
237004660064SFedor Uporov 	struct vnode *a_vp;
237104660064SFedor Uporov 	int a_attrnamespace;
237204660064SFedor Uporov 	const char *a_name;
237304660064SFedor Uporov 	struct ucred *a_cred;
237404660064SFedor Uporov 	struct thread *a_td;
237504660064SFedor Uporov     };
237604660064SFedor Uporov */
237704660064SFedor Uporov static int
237804660064SFedor Uporov fuse_vnop_deleteextattr(struct vop_deleteextattr_args *ap)
237904660064SFedor Uporov {
238004660064SFedor Uporov 	struct vnode *vp = ap->a_vp;
238128f4f623SFedor Uporov 	struct fuse_dispatcher fdi;
238204660064SFedor Uporov 	struct mount *mp = vnode_mount(vp);
238328f4f623SFedor Uporov 	struct thread *td = ap->a_td;
238428f4f623SFedor Uporov 	struct ucred *cred = ap->a_cred;
238504660064SFedor Uporov 	char *prefix;
238604660064SFedor Uporov 	size_t len;
238704660064SFedor Uporov 	char *attr_str;
238804660064SFedor Uporov 	int err;
238904660064SFedor Uporov 
239004660064SFedor Uporov 	if (fuse_isdeadfs(vp))
239128f4f623SFedor Uporov 		return (ENXIO);
239204660064SFedor Uporov 
23931f4a83f9SAlan Somers 	if (!fsess_isimpl(mp, FUSE_REMOVEXATTR))
23941f4a83f9SAlan Somers 		return EOPNOTSUPP;
23951f4a83f9SAlan Somers 
2396666f8543SAlan Somers 	if (vfs_isrdonly(mp))
2397666f8543SAlan Somers 		return EROFS;
2398666f8543SAlan Somers 
2399666f8543SAlan Somers 	err = fuse_extattr_check_cred(vp, ap->a_attrnamespace, cred, td,
2400666f8543SAlan Somers 		VWRITE);
2401ff4fbdf5SAlan Somers 	if (err)
2402ff4fbdf5SAlan Somers 		return err;
2403ff4fbdf5SAlan Somers 
240404660064SFedor Uporov 	/* Default to looking for user attributes. */
240504660064SFedor Uporov 	if (ap->a_attrnamespace == EXTATTR_NAMESPACE_SYSTEM)
240604660064SFedor Uporov 		prefix = EXTATTR_NAMESPACE_SYSTEM_STRING;
240704660064SFedor Uporov 	else
240804660064SFedor Uporov 		prefix = EXTATTR_NAMESPACE_USER_STRING;
240904660064SFedor Uporov 
241004660064SFedor Uporov 	len = strlen(prefix) + sizeof(extattr_namespace_separator) +
241104660064SFedor Uporov 	    strlen(ap->a_name) + 1;
241204660064SFedor Uporov 
241304660064SFedor Uporov 	fdisp_init(&fdi, len);
241404660064SFedor Uporov 	fdisp_make_vp(&fdi, FUSE_REMOVEXATTR, vp, td, cred);
241504660064SFedor Uporov 
241604660064SFedor Uporov 	attr_str = fdi.indata;
241704660064SFedor Uporov 	snprintf(attr_str, len, "%s%c%s", prefix, extattr_namespace_separator,
241804660064SFedor Uporov 	    ap->a_name);
241904660064SFedor Uporov 
242004660064SFedor Uporov 	err = fdisp_wait_answ(&fdi);
24211f4a83f9SAlan Somers 	if (err == ENOSYS) {
242204660064SFedor Uporov 		fsess_set_notimpl(mp, FUSE_REMOVEXATTR);
24231f4a83f9SAlan Somers 		err = EOPNOTSUPP;
242404660064SFedor Uporov 	}
242504660064SFedor Uporov 
242604660064SFedor Uporov 	fdisp_destroy(&fdi);
242704660064SFedor Uporov 	return (err);
242804660064SFedor Uporov }
242904660064SFedor Uporov 
24305fe58019SAttilio Rao /*
24315fe58019SAttilio Rao     struct vnop_print_args {
24325fe58019SAttilio Rao 	struct vnode *a_vp;
24335fe58019SAttilio Rao     };
24345fe58019SAttilio Rao */
24355fe58019SAttilio Rao static int
24365fe58019SAttilio Rao fuse_vnop_print(struct vop_print_args *ap)
24375fe58019SAttilio Rao {
24385fe58019SAttilio Rao 	struct fuse_vnode_data *fvdat = VTOFUD(ap->a_vp);
24395fe58019SAttilio Rao 
24405fe58019SAttilio Rao 	printf("nodeid: %ju, parent nodeid: %ju, nlookup: %ju, flag: %#x\n",
24415fe58019SAttilio Rao 	    (uintmax_t)VTOILLU(ap->a_vp), (uintmax_t)fvdat->parent_nid,
24425fe58019SAttilio Rao 	    (uintmax_t)fvdat->nlookup,
24435fe58019SAttilio Rao 	    fvdat->flag);
24445fe58019SAttilio Rao 
24455fe58019SAttilio Rao 	return 0;
24465fe58019SAttilio Rao }
2447e5b50fe7SAlan Somers 
2448e5b50fe7SAlan Somers /*
2449e5b50fe7SAlan Somers  * Get an NFS filehandle for a FUSE file.
2450e5b50fe7SAlan Somers  *
2451e5b50fe7SAlan Somers  * This will only work for FUSE file systems that guarantee the uniqueness of
24520d2bf489SAlan Somers  * nodeid:generation, which most don't.
2453e5b50fe7SAlan Somers  */
2454e5b50fe7SAlan Somers /*
2455e5b50fe7SAlan Somers vop_vptofh {
2456e5b50fe7SAlan Somers 	IN struct vnode *a_vp;
2457e5b50fe7SAlan Somers 	IN struct fid *a_fhp;
2458e5b50fe7SAlan Somers };
2459e5b50fe7SAlan Somers */
2460e5b50fe7SAlan Somers static int
2461e5b50fe7SAlan Somers fuse_vnop_vptofh(struct vop_vptofh_args *ap)
2462e5b50fe7SAlan Somers {
2463e5b50fe7SAlan Somers 	struct vnode *vp = ap->a_vp;
2464e5b50fe7SAlan Somers 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
2465e5b50fe7SAlan Somers 	struct fuse_fid *fhp = (struct fuse_fid *)(ap->a_fhp);
2466e5b50fe7SAlan Somers 	_Static_assert(sizeof(struct fuse_fid) <= sizeof(struct fid),
2467e5b50fe7SAlan Somers 		"FUSE fid type is too big");
2468e5b50fe7SAlan Somers 	struct mount *mp = vnode_mount(vp);
2469e5b50fe7SAlan Somers 	struct fuse_data *data = fuse_get_mpdata(mp);
2470e5b50fe7SAlan Somers 	struct vattr va;
2471e5b50fe7SAlan Somers 	int err;
2472e5b50fe7SAlan Somers 
2473e5b50fe7SAlan Somers 	if (!(data->dataflags & FSESS_EXPORT_SUPPORT))
2474e5b50fe7SAlan Somers 		return EOPNOTSUPP;
2475e5b50fe7SAlan Somers 
2476e5b50fe7SAlan Somers 	err = fuse_internal_getattr(vp, &va, curthread->td_ucred, curthread);
2477e5b50fe7SAlan Somers 	if (err)
2478e5b50fe7SAlan Somers 		return err;
2479e5b50fe7SAlan Somers 
2480e5b50fe7SAlan Somers 	/*ip = VTOI(ap->a_vp);*/
2481e5b50fe7SAlan Somers 	/*ufhp = (struct ufid *)ap->a_fhp;*/
2482e5b50fe7SAlan Somers 	fhp->len = sizeof(struct fuse_fid);
2483e5b50fe7SAlan Somers 	fhp->nid = fvdat->nid;
2484e5b50fe7SAlan Somers 	if (fvdat->generation <= UINT32_MAX)
2485e5b50fe7SAlan Somers 		fhp->gen = fvdat->generation;
2486e5b50fe7SAlan Somers 	else
2487e5b50fe7SAlan Somers 		return EOVERFLOW;
2488e5b50fe7SAlan Somers 	return (0);
2489e5b50fe7SAlan Somers }
2490e5b50fe7SAlan Somers 
2491e5b50fe7SAlan Somers 
2492